Der Cosinus des Pedanten

28

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 , 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...
Silvio Mayolo
quelle
1
Ich gehe mal davon aus, dass ndas auch größer ist als 0?
GamrCorps
8
Ich würde sagen, sie sind technisch nicht das, was Pedant bedeutet, aber das wäre zu meta.
PyRulez
8
Wenn Ihr Chef möchte, dass Sie eine gute oder zumindest lesbare Funktion schreiben, sind Sie am falschen Ort.
Roman Gräf
2
Ein wirklich wählerischer Chef möchte den Kosinus mit etwas berechnen, das ein wenig effizienter (und genauer) ist als die Taylor-Serie ...
PM 2Ring
6
@ PM2Ring Das wäre nicht wählerisch, das wäre vernünftig. Taylor-Serie ist wirklich die gröbste Option.
user1997744

Antworten:

64

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:

Bildbeschreibung hier eingeben

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.

Steadybox
quelle
10
Aber wieso?
Orlp
16
@orlp Warum nicht?
Steadybox
3
@orlp Ich denke, die passendere Frage ist: Warum ist die Operation Flashpoint-Skriptsprache keine Variante von ArnoldC ?
Ceilingcat
2
Hmmm… geben Sie die Eingabe ein, indem Sie eine bestimmte Anzahl von Runden [n] in die angegebene Kompassrichtung [x] schießen? 😍 Operation Flammpunkt!
Mormegil
14
@Mormegil Nun, im Allgemeinen nein, aber das kann mit diesem Code geschehen: dir=-1;num=1;player addEventHandler ["fired", {_dir=getdir (nearestObject [_this select 0, _this select 4]);if (dir < 0) then {dir = _dir} else {if (abs(dir - _dir) < 5) then {num = num + 1} else {hint format["%1", [dir*(pi/180), num] call F];dir=-1;num=1}}}]- Wenn Sie in eine Richtung aufnehmen, wird der Zähler inkrementiert, und wenn Sie dann in eine andere Richtung aufnehmen, wird die Kosinusfunktion mit der früheren Richtung und der Anzahl der Aufnahmen in dieser Richtung aufgerufen.
Steadybox
13

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
Emigna
quelle
@ JamesHolderness: Ja, die Sprache hat seitdem eine ziemlich große Überarbeitung durchlaufen. Ein seltsamer Fehler scheint befallen zu sein ², aber er kann stattdessen durch ersetzt werden I.
Emigna
10

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
Luis Mendo
quelle
10

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!

GamrCorps
quelle
9
Obwohl Mathematicas SeriesFähigkeiten in der Tat großartig sind und Spaß machen, stellt sich heraus, dass die Implementierung von Hand Sum[(-#^2)^k/(2k)!,{k,0,#2-1}]&hier kürzer ist.
Greg Martin
9

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
Jonathan Allan
quelle
8

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.
fireflame241
quelle
7
Willkommen bei PPCG!
Martin Ender
6

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.

Neil
quelle
5

TI-Basic, 41 bis 40 Byte

Prompt X,N
sum(seq((-(X+1E-49)2)^Q/((2Q)!),Q,0,N-1
1E-49 Wird dem Winkel hinzugefügt, weil TI-Basic einen Fehler für 0 ^ 0 ausgibt. Er ist gerade groß genug, um den Fehler nicht zu verursachen, und nicht groß genug, um die Antwort zu ändern.

Pizzapants184
quelle
4

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
}
Khaled.K
quelle
96b version c(0.5, 80)=> NaN, für Überlauff(80)=0
l4m2
@ l4m2 rekursive Funktionen sind hier zum Golfen gedacht, aber sie sind unpraktisch, da sie leicht überlaufen können, wenn die Anzahl der Aufrufe das Call-Stack-Limit überschreitet, und selbst bei höheren Limits ist dies eine Verschwendung von Ressourcen kleinere Zahlen.
Khaled.K
1
Problem direkt sagen, n<100damit du zumindest nicht so weit in den Bereich gehst. Nicht Stapelüberlauf
l4m2
Wenn das Problem sagen n<100und Sie verwenden O(2^n)Lösung ich denke , es ist okay, solange es schließlich das Ergebnis retuan
l4m2
1
Zu Ihrer Information, das NaN-Ergebnis hat nichts mit Rekursion zu tun - es ist ein Überlauf der Fakultätsberechnung, die Ganzzahlen verwendet, wenn sie Floats verwenden sollten (198! Wird niemals in ein Int passen).
James Holderness
4

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

Neil
quelle
Warum nicht ein Snippet daraus machen?
Arjun
4

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;
}
Hagen von Eitzen
quelle
Auf welcher Plattform funktioniert das?
Anatolyg
4

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)
Giuseppe
quelle
3

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.

zgrep
quelle
3

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

Enderperson1010
quelle
1
Ein Listenverständnis kann Ihnen ein paar Bissen ersparen:f x n=sum[(-1)^i*x^(2*i)/fromIntegral(product[1..2*i])|i<-[0..n-1]]
Julian Wolf
1
Willkommen bei PPCG und Haskell Golf im Besonderen!
Laikoni
3

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.
Dennis
quelle
3

Pyth, 16 Bytes

sm_Fc^vzyd.!yddU

Akzeptiert ndann zuerst x. Beispiellauf.

Steven H.
quelle
3

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.

Julian Wolf
quelle
Sie können einige Bytes einsparen, indem Sie das entfernen fromIntegralund **anstelle von verwenden ^, wie dies
B. Mehta
x#n=sum[(-x*x)**i/product[1..2*i]|i<-[0..n-1]]Spart 3 weitere Bytes.
Lynn
3

Pyt , 37 34 33 Bytes

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

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
Bolce Bussiere
quelle
1
24 Bytes: +/@:(!@]%~^*_1^2%~])2*i.Ich werde ein zyklisches Gerundium untersuchen: Es ist wahrscheinlich fehlgeschlagen, da J von /rechts nach links ausgewertet wird , damit Sie es verwenden müssen |.(oder vielleicht haben Sie dies erklärt und hatten immer noch Schwierigkeiten).
Cole
3

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 für die doppelte Anzahl der angeforderten Terme und nimmt dann den Realteil ein.

Sean
quelle
2

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
Luis Mendo
quelle
2

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)
Bálint
quelle
2

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!

Abel Tom
quelle
Sie können einige Bytes einsparen, indem Sie die Funktionsdefinitionen massieren:F(m){...}f(x,n)float x;{...}
Kevin
Da u * 1 == u, können Sie die Schleife in der ersten Funktion entweder while(m)u*=m--oder u=m;while(--m)u*=m(gleiche Länge) machen
Kevin
i<=n-1ist das gleiche wiei<n
Kevin
@ Kevin Danke, Sie haben absolut Recht, haben eine Weile nicht mehr Golf gespielt. :)
Abel Tom
2
101 Bytes
Ceilingcat
2

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

rekursiv
quelle
1

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!

fəˈnəˈtɪk
quelle
Dies ist 65 Bytes
Bálint
@ Bálint hatte einen Fehler beim Kopieren der Änderungen gemacht. (n) sollte eigentlich nur n
fəˈn12tɛk 16.04.17
1

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.

Titus
quelle
1

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
RosLuP
quelle
1

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.

cole
quelle