Il mio capo mi ha appena detto di scrivere una funzione coseno. Essendo un bravo appassionato di matematica, la mia mente ha immediatamente evocato la serie Taylor appropriata.

cos(x) = 1 / 0! - x^2 / 2! + x^4 / 4! - x^6 / 6! + ... + (-1)^k x^(2k) / (2k)! + ...

Tuttavia, il mio capo è molto esigente. Vorrebbe essere in grado di specificare esattamente quanti termini della serie Taylor calcolare. Potete aiutarmi a scrivere questa funzione?

Il tuo compito

Dato un valore in virgola mobile xda 0a 2 pie un numero intero positivo ninferiore a 100, calcolare la somma dei primi ntermini della serie di Taylor fornita sopra cos(x).

Questo è code-golf , quindi vince il codice più corto. Input e output possono essere acquisiti in uno dei modi standard. Sono vietate le scappatoie standard.

Gli appunti

• L'input può essere preso in qualsiasi forma ragionevole, purché vi sia una chiara separazione tra xe n.
• L'input e l'output dovrebbero essere valori in virgola mobile, almeno accurati come il calcolo della formula utilizzando numeri in virgola mobile IEEE a precisione singola con alcune regole di arrotondamento standard.
• Se ha senso per il linguaggio utilizzato, i calcoli possono essere eseguiti usando quantità razionali esatte, ma l'input e l'output devono comunque essere in forma decimale.

Esempi

 x  |  n | Output
----+----+--------------
0.0 |  1 | 1.0
0.5 |  1 | 1.0
0.5 |  2 | 0.875
0.5 |  4 | 0.87758246...
0.5 |  9 | 0.87758256...
2.0 |  2 | -1.0
2.0 |  5 | -0.4158730...

Linguaggio di scripting dell'operazione Flashpoint , 165 157 byte

F={x=_this select 0;n=_this select 1;i=0;r=0;while{i<n*2}do{r=r+x^i/(i call{c=_this;j=c-1;while{j>0}do{c=c*j;j=j-1};if(c<1)then{c=1};c})*(-1)^(i/2);i=i+2};r}

Chiama con:

hint format["%1\n%2\n%3\n%4\n%5\n%6\n%7",
    [0.0, 1] call f,
    [0.5, 1] call f,
    [0.5, 2] call f,
    [0.5, 4] call f,
    [0.5, 9] call f,
    [2.0, 2] call f,
    [2.0, 5] call f]

Produzione:

L'input e l'output dovrebbero essere valori in virgola mobile, almeno accurati come il calcolo della formula utilizzando numeri in virgola mobile IEEE a precisione singola con alcune regole di arrotondamento standard.

Sono abbastanza sicuro che i numeri siano numeri in virgola mobile IEEE a precisione singola, anche se nell'output stampato i decimali più lunghi non sono così precisi. È la stampa che arrotonda i numeri in questo modo, in realtà i numeri sono più precisi.

Ad esempio, a=1.00001;b=1.000011;hint format["%1\n%2\n%3", a, b, a==b]produrrà questo:

1.00001
1.00001
false

Quindi chiaramente la precisione effettiva dei numeri è maggiore della precisione stampata.

05AB1E , 14 11 byte

FIn(NmN·!/O

Provalo online!

Spiegazione

F                # for N in [0 ... n] do
 In              # push (x^2)
   (             # negate
    Nm           # raise to the Nth power
      N·!        # push (2*N)!
         /       # divide
          O      # sum

MATL , 14 byte

U_iqE:2ep/YpsQ

Provalo online! Oppure verifica tutti i casi di test .

Spiegazione con esempio

Tutti i numeri hanno una doppia precisione (questa è l'impostazione predefinita).

Considerate ingressi x = 2.0, n = 5.

U_     % Implicitly input x. Square and negate
       % STACK: -4
iqE    % Input n. Subtract 1, multiply by 2
       % STACK: -4, 8
:      % Range
       % STACK: -4, [1 2 3 4 5 6 7 8]
2e     % Reshape into a 2-row matrix
       % STACK: -4, [1 3 5 7;
       %             2 4 6 8]
p      % Product of each column
       % STACK: -4, [2 12 30 56]
/      % Divide, element-wise
       % STACK: [-2 -0.333333333333333 -0.133333333333333 -0.0714285714285714]
Yp     % Cumulative product of array
       % STACK: [-2 0.666666666666667 -0.0888888888888889 0.00634920634920635]
s      % Sum of array
       % STACK: -1.41587301587302
Q      % Add 1. Implicitly display
       % STACK: -0.41587301587302

Mathematica, 49 41 39 31 byte

Sum[(-#^2)^k/(2k)!,{k,0,#2-1}]&

Vecchia versione più "divertente": (39 byte)

Normal@Series[Cos@k,{k,0,2#2-2}]/.k->#&

Risparmio di 10 byte grazie a @Pavel e 8 grazie a @Greg Martin!

Gelatina , 12 11 byte

ḶḤµ⁹*÷!_2/S

Provalo online!

Come?

ḶḤµ⁹*÷!_2/S - Main link: n, x           e.g. 5, 2.0
Ḷ           - lowered range(n)              [0,1,2,3,4]
 Ḥ          - double (vectorises)           [0,2,4,6,8]
  µ         - monadic chain separation (call that i)
   ⁹        - link's right argument         2.0
    *       - exponentiate(i) (vectorises)  [1.0,4.0,16.0,64.0,256.0]
      !     - factorial(i) (vectorises)     [1,  2,  24,  720, 40320]
     ÷      - divide (vectorises)           [1.0,2.0,0.6666666666666666,0.08888888888888889,0.006349206349206349]
        2/  - pairwise reduce by:
       _    -     subtraction               [-1.0,0.5777777777777777,0.006349206349206349]
         S  - sum                           -0.41587301587301617

Gelatina, 22 byte

-*ð×ø⁹*⁸²ð÷ø⁸Ḥ!
⁸R’Ç€S

Questo è un programma completo che accetta n come primo argomento e x come secondo.

Spiegazione:

              Creates a function to compute each term in the series. 
Its argument we will call k, eg k=3 computes 3rd term. Take x=2 for example.
-*           Computes (-1)^k. Eg -1
ð×ø        Multiplies by the quantity of
⁹             x.  
*             to the power of
⁸             k
²             ...squared. Eg -1 × (2³)² 
ð÷ø        divides by the quantity of
⁸              k
Ḥ             doubled
!               ...factorial. Eg -1 × (2³)²/(6!).


                Main link, first argument n and second argument n. Eg n=4, x=2.
⁸R            Creates range(n). Eg [1,2,3,4]
’                Decrements each element. Eg [0,1,2,3]
Ç€            Maps the above function over each element. Eg [1,-2,0.666,-0.0889]
S               Sum all all of the elements.  Eg -0.422.

Python, 54 byte

f=lambda x,n,t=1,p=1:n and t+f(x,n-1,-t*x*x/p/-~p,p+2)

Se usi Python 2, assicurati di passare x come float, non come numero intero, ma la mia comprensione è che non importa se stai usando Python 3.

TI-Basic, 41 40 byte

Prompt X,N
sum(seq((-(X+1E-49)2)^Q/((2Q)!),Q,0,N-1

C, 96 byte

Ricorsivo dal vivo

f(n){return n?n*f(n-1):1;}float c(n,x)float x;{return n?c(n-1,x)+pow(-1,n)*pow(x,2*n)/f(2*n):1;}

dettagliata

f(n) // factorial(n)
{
    return n ?   // n != 0 ?
        n*f(n-1) // n! = n * (n-1)!
    : 1;         // 0! = 1
}

float c(n,x)float x; // cos(x) with n+1 terms
{
    return n ?        // n != 0 ?
        c(n-1, x)     // cos(x) (n-1)th term
        + pow(-1, n)  // + (-1)^n
        * pow(x, 2*n) // * x^(2n)
        / f(2 * n)    // / (2n)!
    : 1;              // cos(x) at n=0
}

Progressivo ricorsivo, 133 byte in diretta

#define F float
#define c(x,n) 1+g(1,n,x,1,1,1)
F g(F i,F n,F x,F s,F p,F f){s=-s;p*=x*x;f*=i;return i<n?g(i+1,n,x,s,p,f)+s/2*p/f:0;}

dettagliata

#define F float // shorthand float

#define c(x,n) 1+g(1,n,x,1,1,1) // macro function

F g(F i,F n,F x,F s,F p,F f)
{
    s = -s;   // (-1)^n = (-1) * (-1)^(n-1)
    p *= x*x; // x^(2n) =  x^2 * x^(2(n-1))
    f *= i;   //    2n! =    2 * (1*2*..*n)

    return i < n ?       // i = 0 .. n-1
        g(i+1,n,x,s,p,f) // next term
        + s / 2 * p / f  // s*p/2f = s/2*p/f
        : 0;             // don't compute nth term
}

JavaScript (ES6), 46 byte

f=
x=>g=(n,t=1,p=0)=>n&&t+g(--n,-t*x*x/++p/++p,p)

<div oninput=o.textContent=f(x.value)(n.value)><input id=x><input type=number min=1 value=1 id=n><pre id=o>1

Accetta input al curry (x) (n).

C, 71 byte

usando lo schema Horner

float f(n,x)float x;{float y;for(n+=n;n;)y=1-(y*x*x/n--)/n--;return y;}

Versione non golfata:

float f(n,x) float x;
{
  float y = 0.0;
  for(n = 2*n; n>0; n -= 2)
  {
    y = 1-y*x*x/n/(n-1);
  }
  return y;
}

R, 70 64 byte

function(x,n)sum(sapply(1:n-1,function(y)(-x^2)^y/gamma(2*y+1)))

salvato 6 byte grazie alla risposta di pizzapants184 con il trucco (-x ^ 2) ^ y

65 byte:

function(x,n)Reduce(function(a,b)a+(-x^2)^b/gamma(2*b+1),1:n-1,0)

praticamente l'implementazione ingenua di questo, ma un po 'golfato; restituisce una funzione anonima che calcola la serie di Taylor al n specificato

• l'utilizzo di un Riduci richiede un altro byte poiché initdeve essere impostato su 0
• usi gamma(n+1) invece difactorial(n)
• 1:n-1 è equivalente a 0:(n-1)

ok , 38 byte

Questo funziona anche in k , ma richiede 39 byte perché uno 'deve essere scritto come /:invece (almeno, in kmac 2016.06.28 lo fa).

{+/(y#1 -1)*{(*/y#x)%*/1+!y}.'x,'2*!y}

Spiegazione:

Cominciamo con il bit centrale. (*/y#x)è esponenziazione, è equivalente a x^y. */1+!ysarebbe y!, o yfattoriale. %è divisione. Pertanto la funzione nel mezzo èmiddle(x,y) = (x^y)/(y!) .

Ora il bit a destra, a cui viene applicata la funzione sopra. 2*!yè{0, 2, 4, ..., 2*(y-1)} . x,'antepone xad ogni elemento in quell'elenco, trasformandolo in {(x, 0), (x, 2), (x, 4), ..., (x, 2*(y-1))}. L' .'poi applica middlead ogni coppia di numeri (map essenzialmente).

Finalmente, (y#1 -1)* moltiplica il risultato per 1 o -1 (alternando) e +/prende la somma.

Haskell, 71 byte

f x n=sum$map(\i->(-1)^i*x^(2*i)/fromIntegral(product[1..2*i]))[0..n-1]

Questa è una risposta piuttosto noiosa che non è troppo difficile da decifrare. I fromIntegralmorsi davvero, però. (L' /operatore richiede operandi dello stesso tipo numerico in Haskell e la coercizione tra tipi numerici non è consentita senza una funzione wordy.)

Gelatina , 12 byte

²N*Ḷ}©÷®Ḥ!¤S

Provalo online!

Come funziona

²N*Ḷ}©÷®Ḥ!¤S  Main link. Left argument: x. Right argument: n

²             Square; yield x².
 N            Negate; yield -x².
     ©         Call the link to the left and copy the result to the register.
   Ḷ}          Call unlength on the right argument, yielding [0, 1, ..., n-1].
  *           Yield [1, -x², ..., (-x²)**(n-1)].
          ¤   Combine the three links to the left into a niladic chain.
       ®        Yield the value in the register, [0, 1, ..., n-1].
        Ḥ       Unhalve; yield [0, 2, ..., 2n-2].
         !      Factorial; yield [0!, 2!, ..., (2n-2)!].
      ÷         Division; yield [1/0!, -x²/2!, ..., (-x²)**(n-1)/(2n-2)!].
           S  Take the sum.

Pyth, 16 byte

sm_Fc^vzyd.!yddU

Accetta nprima, quindi x. Esempio di esecuzione.

Haskell , 61 byte

x#n=sum[(-1*x^2)^i/fromIntegral(product[1..2*i])|i<-[0..n-1]]

Sembrava abbastanza diverso dall'altra soluzione Haskell da giustificare una risposta separata. L'implementazione dovrebbe essere piuttosto autoesplicativa: chiamare con x#ndov'è xil numero di cui calcolare il coseno ed nè l'ordine della somma parziale da prendere.

Pyt , 37 34 33 byte

←←ĐĐ↔3Ș1~⇹ř⁻^04Ș⇹ř⁻^²*0↔ř⁻2*!+/+Ʃ

J, 26 24 byte

+/@:(!@]%~^*_1^2%~])2*i.

-2 byte grazie a @cole

Inizialmente avevo pianificato di usare un gerundio ciclico per alternare tra l'aggiunta e la sottrazione, ma non riuscivo a farlo funzionare.

Spiegazione:

                    2*i.     | Integers from 0 to 2(n-1)
    (              )         | Dyadic train:
            _1^-:@]          | -1 to the power of the left argument
          ^*                 | Times left arg to the power of right arg
     !@]%~                   | Divided by the factorial of the right arg
+/@:                         | Sum

Perl 6 , 53 byte

{(sum (1,*i*$^x...*)[^2*$^n] »/»(1,|[\*] 1..*)).re}

Provalo online!

Questo in realtà calcola il complesso esponenziale e ^iθ per il doppio del numero di termini richiesti e quindi prende la parte reale.

MATLAB con Symbolic Math Toolbox, 57 byte

@(x,n)eval(subs(taylor(sym('cos(x)'),'Order',2*n),'x',x))

Ciò definisce una funzione anonima con che prende doubleingressi x, ned emette il risultato comedouble .

Esempio (testato su R2015b):

>> @(x,n)eval(subs(taylor(sym('cos(x)'),'Order',2*n),'x',x))
ans = 
    @(x,n)eval(subs(taylor(sym('cos(x)'),'Order',2*n),'x',x))
>> f = ans; format long; f(0,1), f(0.5,1), f(0.5,2), f(0.5,4), f(0.5,9), f(2,2), f(2,5)
ans =
     1
ans =
     1
ans =
   0.875000000000000
ans =
   0.877582465277778
ans =
   0.877582561890373
ans =
    -1
ans =
  -0.415873015873016

JavaScript ES7 60 byte

x=>a=n=>--n?(-1)**n*x**(2*n)/(f=m=>m?m*f(m-1):1)(2*n)+a(n):1


x=>a=n=>                                                         // Curry-d function, it basically returns another function
        --n?                                              :1  // subtract one from n. If n - 1 is 0, return 1
            (-1)**n*                                             // This generates the sign of the number
                    x**(2*n)/                                    // This creates the part before the division, basicaly x^2n
                             (f=m=>m?m*f(m-1):1)(2*n)            // This creates a recursive factorial function and calls it with 2n
                                                     +a(n)    // Recursively call the function. This adds the elements of the taylor series together

Per usarlo:

Premere F12, digitare la funzione e quindi fare

c(x)(n)

C 144 130 byte

F(m){int u=1;while(m)u*=m--;return u;}float f(float x,n){float s;for(int i=1;i<n;i++)s+=pow(-1,i)*pow(x,2*i)/(F(2*i));return 1+s;}

Versione Ungolfed:

//Function to calculate factorial
int F(int m)
{
  int u=1;

  while(m>1)
   u*=m--; 

  return u;
}

//actual function called in main function   
float f(float x, int n)
{

  float s=0.0;

  for(int i=1;i<=n-1;i++)
     s+=pow(-1,i)*pow(x,2*i)/(F(2*i)); 

  return 1+s;
 }

Grazie Kevin per aver salvato alcuni byte!

Tcl , 126 byte

proc c {x n k\ 0 r\ 0} {proc F n {expr $n?($n)*\[F $n-1]:1}
time {set r [expr $r+-1**$k*$x**(2*$k)/[F 2*$k]]
incr k} $n
set r}

Provalo online!

Stax , 12 byte

ü┘·.ⁿYeò≥Vîû

Esegui ed esegui il debug

Disimballato, ungolfed e commentato, sembra così.

            Input is `x n`
Z           Push a zero underneath the top.  The stack is now `x 0 n` 
D           Run the rest of the program n times.
  xJNi|*    (-x*x)^i where i is the iteration index
  iH|F/     divide that by factorial(2i)
  +         add to the running total so far
            final result is implicitly printed

Esegui questo

JavaScript, 59 byte

x=>k=n=>--n?k(n)+(-1)**n*x**(n*=2)/f(n):1
f=p=>p?p*f(p-1):1

Provalo online!

PHP, 76 byte

for($f=1;$i<$argv[2]*2;$f*=++$i)$i&1?:$s+=(-1)**$k++*$argv[1]**$i/$f;echo$s;

prende Xe Ndagli argomenti della riga di comando; Corri con-r .

cappio $ida 0a N*2-1, tenere fac($i)in $f; se $iè pari, aggiungi il termine alla somma $s. somma di stampa.

Vorrei avere numeri complessi (con M_Icome unità immaginaria);
Mi limiterei semplicemente $faM_I*++$i e Salva 7 byte.

Forse Mathematica può farlo. Ma Mathematica non deve.

Ho potuto salvare due byte con cos(M_PI*$i/2)invece di $i&1?:e (-1)**$k++;
ma sarebbe strano usare un coseno incorporato per costruire una funzione coseno.

Assioma, 36 byte

g(a,n)==eval(taylor(cos(x)),a).(2*n)

Costruisci l'infinito (nel senso finito ma si può chiedere di costruire l'elenco di 2 * n elementi se il PC ha memoria sufficiente) elenco di somme parziali per la serie di Taylor per cos (x) calcolare in 'a', in "eval ( taylor (cos (x)), a) "; ottiene l'elemento 2 * n dell'elenco in ". (2 * n)". Casi test:

(47) -> g(0,1)
   (47)  1
                                                 Type: Expression Integer
(48) -> g(0.5,1)
   (48)  1.0
                                                   Type: Expression Float
(49) -> g(0.5,2)
   (49)  0.875
                                                   Type: Expression Float
(50) -> g(0.5,4)
   (50)  0.8775824652 7777777778
                                                   Type: Expression Float
(51) -> g(0.5,9)
   (51)  0.8775825618 9037271611
                                                   Type: Expression Float
(52) -> g(2.0,5)
   (52)  - 0.4158730158 7301587302
                                                   Type: Expression Float
(53) -> g(2.0,800)
   (53)  - 0.4161468365 471423870

J , 17 byte

4 :'2&o.T.(+:y)x'

Provalo online!

Utilizza un built-in , che presumo sia OK.

Sfortunatamente, non so davvero come lavorare bene con le funzioni che accettano argomenti tramite il curry in questo modo, quindi ho dovuto farlo esplicitamente. Sono sicuro che esiste un modo per farlo tacitamente o in modo più breve.

Pulito , 77 byte

import StdEnv
?x n=sum[(-1.0)^(p/2.0)*x^p/prod[1.0..p]\\p<-take n[0.0,2.0..]]

Provalo online!