Mein Chef hat mir gerade gesagt, ich soll eine Kosinusfunktion schreiben. Da ich ein guter Mathematikfreak bin, beschwor ich sofort die passende Taylor-Serie.

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

Mein Chef ist jedoch sehr wählerisch. Er möchte genau angeben können, wie viele Terme der Taylor-Reihe berechnet werden sollen. Können Sie mir helfen, diese Funktion zu schreiben?

Deine Aufgabe

Berechnen Sie bei einem Gleitkommawert xvon 0bis 2 piund einer positiven ganzen Zahl nkleiner als 100die Summe der ersten nTerme der oben angegebenen Taylor-Reihe für cos(x).

Das ist Code-Golf , also gewinnt der kürzeste Code. Die Ein- und Ausgabe kann auf eine der üblichen Arten erfolgen. Standardlücken sind verboten.

Anmerkungen

• Die Eingabe kann in jeder angemessenen Form erfolgen, sofern eine klare Trennung zwischen xund besteht n.
• Eingabe und Ausgabe sollten Gleitkommawerte sein, mindestens so genau wie die Berechnung der Formel unter Verwendung von IEEE-Gleitkommazahlen mit einfacher Genauigkeit und einigen Standardrundungsregeln.
• Wenn es für die verwendete Sprache sinnvoll ist, können Berechnungen mit genauen rationalen Größen durchgeführt werden, aber die Eingabe und Ausgabe müssen immer noch in Dezimalform erfolgen.

Beispiele

 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...

Operation Flashpoint- Skriptsprache, 165 bis 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}

Rufen Sie an mit:

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]

Ausgabe:

Eingabe und Ausgabe sollten Gleitkommawerte sein, mindestens so genau wie die Berechnung der Formel unter Verwendung von IEEE-Gleitkommazahlen mit einfacher Genauigkeit und einigen Standardrundungsregeln.

Ich bin mir ziemlich sicher, dass die Zahlen IEEE-Gleitkommazahlen mit einfacher Genauigkeit sind, obwohl die längeren Dezimalstellen in der gedruckten Ausgabe nicht so genau sind. Es ist der Druck, der die Zahlen so rundet, tatsächlich sind die Zahlen präziser.

Zum Beispiel wird a=1.00001;b=1.000011;hint format["%1\n%2\n%3", a, b, a==b]Folgendes ausgegeben:

1.00001
1.00001
false

Die tatsächliche Genauigkeit der Zahlen ist also eindeutig höher als die gedruckte Genauigkeit.

05AB1E , 14 11 Bytes

FIn(NmN·!/O

Probieren Sie es online!

Erläuterung

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 Bytes

U_iqE:2ep/YpsQ

Probieren Sie es online! Oder überprüfen Sie alle Testfälle .

Erklärung mit Beispiel

Alle Zahlen haben doppelte Genauigkeit (dies ist die Standardeinstellung).

Betrachten Sie Eingänge 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 Bytes

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

Alte, "spaßigere" Version: (39 Bytes)

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

10 Bytes dank @Pavel und 8 dank @Greg Martin!

Jelly , 12 11 Bytes

ḶḤµ⁹*÷!_2/S

Probieren Sie es online!

Wie?

ḶḤµ⁹*÷!_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

Jelly, 22 Bytes

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

Dies ist ein vollständiges Programm, das n als erstes Argument und x als zweites Argument verwendet.

Erläuterung:

              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 Bytes

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

Wenn Sie Python 2 verwenden, müssen Sie x als Gleitkommazahl übergeben, nicht als Ganzzahl. Meines Wissens ist es jedoch unerheblich, ob Sie Python 3 verwenden.

TI-Basic, 41 bis 40 Byte

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

C 96 Bytes

Rekursives Leben

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;}

Detailliert

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
}

Progressiv Rekursiv, 133 Bytes Live

#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;}

Detailliert

#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

Nimmt Curry-Eingänge (x) (n).

C 71 Bytes

unter Verwendung des Horner-Schemas

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

Ungolfed-Version:

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 Bytes

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

6 Bytes gespart dank der Antwort von pizzapants184 mit dem (-x ^ 2) ^ y-Trick

65 Bytes:

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

so ziemlich die naive Umsetzung davon, aber ein kleines bisschen golfen; Gibt eine anonyme Funktion zurück, die die Taylor-Reihe mit dem angegebenen n berechnet

• Die Verwendung eines Reduce benötigt ein weiteres Byte, da inites auf 0 gesetzt werden muss
• verwendet gamma(n+1)stattfactorial(n)
• 1:n-1 ist äquivalent zu 0:(n-1)

ok , 38 bytes

Dies funktioniert auch in k , benötigt aber 39 Bytes, da stattdessen 'geschrieben /:werden muss (zumindest in kmac 2016.06.28).

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

Erläuterung:

Beginnen wir mit dem mittleren Teil. (*/y#x)ist Potenzierung, es ist äquivalent zu x^y. */1+!ywäre y!, oder yFakultät. %ist Teilung. Daher ist die Funktion in der Mitte middle(x,y) = (x^y)/(y!).

Nun das Bit rechts, auf das die obige Funktion angewendet wird. 2*!yist {0, 2, 4, ..., 2*(y-1)}. x,'Stellt xjedem Element in dieser Liste ein vorangestelltes Element voran und verwandelt es in {(x, 0), (x, 2), (x, 4), ..., (x, 2*(y-1))}. Das .'gilt dann für middlejedes Zahlenpaar ( mapim Wesentlichen).

Zum Schluss (y#1 -1)*multipliziert man das Ergebnis mit 1 oder -1 (alternierend) und +/erhält die Summe.

Haskell, 71 Bytes

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

Dies ist eine ziemlich langweilige Antwort, die nicht zu schwer zu entziffern ist. Das fromIntegralbeißt aber wirklich. (Der /Operator benötigt in Haskell Operanden desselben numerischen Typs, und das Erzwingen zwischen numerischen Typen ist ohne eine wordy-Funktion nicht zulässig.)

Gelee , 12 Bytes

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

Probieren Sie es online!

Wie es funktioniert

²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 Bytes

sm_Fc^vzyd.!yddU

Akzeptiert ndann zuerst x. Beispiellauf.

Haskell , 61 Bytes

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

Dies schien sich von der anderen Haskell-Lösung zu unterscheiden und eine separate Antwort zu rechtfertigen. Die Umsetzung sollte ziemlich selbsterklärend-Anruf sein , mit x#ndenen xdie Zahl der Kosinus von denen berechnet werden und nist die Ordnung der Teilsumme genommen werden.

Pyt , 37 34 33 Bytes

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

J, 26 24 Bytes

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

-2 Bytes dank @cole

Ursprünglich wollte ich ein zyklisches Gerundium verwenden, um zwischen Addieren und Subtrahieren zu wechseln, aber ich konnte es nicht zum Laufen bringen.

Erläuterung:

                    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 Bytes

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

Probieren Sie es online!

Dies berechnet tatsächlich das komplexe Exponential e ^iθ für die doppelte Anzahl der angeforderten Terme und nimmt dann den Realteil ein.

MATLAB mit Symbolic Math Toolbox, 57 Byte

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

Dies definiert eine anonyme Funktion mit übernimmt , dass doubleEingaben x, nund gibt das Ergebnis als ein double.

Beispiel (getestet an 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 Bytes

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

Um es zu benutzen:

Drücken Sie die Taste F12, geben Sie die Funktion ein und klicken Sie dann auf OK

c(x)(n)

C 144 130 Bytes

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;}

Ungolfed Version:

//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;
 }

Danke Kevin, dass du ein paar Bytes gespart hast!

Tcl , 126 Bytes

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}

Probieren Sie es online!

Stax , 12 Bytes

ü┘·.ⁿYeò≥Vîû

Führen Sie es aus und debuggen Sie es

Ausgepackt, ungolfed und kommentiert sieht es so aus.

            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

Führen Sie dieses aus

JavaScript, 59 Bytes

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

Probieren Sie es online!

PHP, 76 Bytes

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

nimmt Xund Nvon Kommandozeilenargumenten; renn mit -r.

Schleife $ivon 0bis N*2-1, halte fac($i)in $f; Wenn gerade $iist, addiere den Term zur Summe $s. Summe drucken.

Ich wünschte, ich hätte komplexe Zahlen (mit M_Ials imaginäre Einheit);
Ich würde einfach mehrfach $fmit M_I*++$iund speichern 7 Bytes.

Vielleicht kann Mathematica das auch. Aber Mathematica muss nicht.

Ich könnte zwei Bytes mit cos(M_PI*$i/2)anstelle von $i&1?:und speichern (-1)**$k++;
Es würde sich jedoch etwas seltsam anfühlen, einen Cosinus zu verwenden, um eine Cosinusfunktion zu erstellen.

Axiom, 36 Bytes

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

Bilde die unendliche (in der Bedeutung endlich, aber man kann fragen, ob die Liste der 2 * n Elemente erstellt werden soll, wenn der PC genügend Speicher hat) Liste der Teilsummen für die Taylor-Reihe für cos (x) berechne in 'a', in "eval ( Taylor (cos (x)), a) "; Ruft das 2 * n-Element dieser Liste in ". (2 * n)" ab. Testfälle:

(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 Bytes

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

Probieren Sie es online!

Verwendet ein eingebautes , was ich für OK halte.

Leider weiß ich nicht so recht, wie ich mit Funktionen umgehen soll, die Argumente über ein solches Currying annehmen. Deshalb musste ich dies explizit tun. Ich bin sicher, dass es eine Möglichkeit gibt, es stillschweigend oder kürzer zu machen.

Sauber , 77 Bytes

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

Probieren Sie es online!