Bos saya baru saja mengatakan kepada saya untuk menulis fungsi kosinus. Menjadi ahli matematika yang baik, pikiran saya segera menyihir Seri Taylor yang sesuai.

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

Namun, bos saya sangat pemilih. Dia ingin dapat menentukan dengan tepat berapa banyak istilah dari Seri Taylor untuk dihitung. Bisakah Anda membantu saya menulis fungsi ini?

Tugas Anda

Diberi nilai floating point xdari 0ke 2 pidan bilangan bulat positif nkurang dari 100, hitung jumlah nsyarat pertama dari seri Taylor yang diberikan di atas cos(x).

Ini kode-golf , jadi kode terpendek menang. Input dan output dapat diambil dengan salah satu cara standar. Celah standar dilarang.

Catatan

• Masukan dapat diambil dalam bentuk apa pun yang wajar, selama ada pemisahan yang jelas antara xdan n.
• Input dan output harus nilai floating-point, setidaknya seakurat menghitung rumus menggunakan nomor floating point IEEE presisi tunggal dengan beberapa aturan pembulatan standar.
• Jika masuk akal untuk bahasa yang digunakan, perhitungan dapat dilakukan dengan menggunakan jumlah rasional yang tepat, tetapi input dan output masih harus dalam bentuk desimal.

Contohnya

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

Operasi bahasa scripting 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}

Telepon dengan:

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]

Keluaran:

Input dan output harus nilai floating-point, setidaknya seakurat menghitung rumus menggunakan nomor floating point IEEE presisi tunggal dengan beberapa aturan pembulatan standar.

Saya cukup yakin bahwa angka-angka adalah angka floating point IEEE presisi tunggal, meskipun dalam hasil cetak desimal yang lebih panjang tidak begitu akurat. Ini adalah pencetakan yang membulatkan angka-angka seperti itu, sebenarnya angkanya lebih tepat.

Misalnya, a=1.00001;b=1.000011;hint format["%1\n%2\n%3", a, b, a==b]akan menampilkan ini:

1.00001
1.00001
false

Jadi jelas ketepatan angka yang sebenarnya lebih besar dari ketepatan yang dicetak.

05AB1E , 14 11 byte

FIn(NmN·!/O

Cobalah online!

Penjelasan

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

Cobalah online! Atau verifikasi semua kasus uji .

Penjelasan dengan contoh

Semua angka memiliki presisi ganda (ini adalah standar).

Pertimbangkan input 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}]&

Versi lama, lebih "menyenangkan": (39 byte)

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

Disimpan 10 byte berkat @Pavel dan 8 terima kasih ke @Greg Martin!

Jelly , 12 11 byte

ḶḤµ⁹*÷!_2/S

Cobalah online!

Bagaimana?

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

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

Ini adalah program lengkap yang menganggap n sebagai argumen pertama dan x sebagai argumen kedua.

Penjelasan:

              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)

Jika menggunakan Python 2, pastikan untuk melewatkan x sebagai float, bukan bilangan bulat, tapi saya pemahaman saya adalah bahwa tidak masalah jika Anda menggunakan 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

Rekursif Langsung

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

Terperinci

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
}

Progresif Rekursif, 133 byte 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;}

Terperinci

#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

Mengambil input kari (x) (n).

C, 71 byte

menggunakan skema Horner

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

Versi tidak disatukan:

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

disimpan 6 byte berkat jawaban pizzapants184 dengan trik (-x ^ 2) ^ y

65 byte:

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

cukup banyak implementasi naif ini tetapi sedikit golf; mengembalikan fungsi anonim yang menghitung seri Taylor ke n yang ditentukan

• menggunakan Reduce membutuhkan satu byte lagi karena initharus diatur ke 0
• menggunakan gamma(n+1)bukanfactorial(n)
• 1:n-1 setara dengan 0:(n-1)

OK , 38 byte

Ini juga berfungsi dalam k , tetapi membutuhkan 39 byte karena kita 'harus menulis sebagai /:gantinya (setidaknya, dalam kmac 2016.06.28 memang demikian).

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

Penjelasan:

Mari kita mulai dengan bit tengah. (*/y#x)adalah eksponensial, sama dengan x^y. */1+!yakan menjadi y!, atau yfaktorial. %adalah pembagian. Karena itu fungsi di tengah adalah middle(x,y) = (x^y)/(y!).

Sekarang bit di sebelah kanan, di mana fungsi di atas diterapkan. 2*!yadalah {0, 2, 4, ..., 2*(y-1)}. x,'menambahkan xke setiap item dalam daftar itu, mengubahnya menjadi {(x, 0), (x, 2), (x, 4), ..., (x, 2*(y-1))}. The .'kemudian berlaku middleuntuk setiap pasangan nomor ( map, pada dasarnya).

Akhirnya, (y#1 -1)*gandakan hasilnya dengan 1 atau -1 (bergantian), dan +/ambil jumlahnya.

Haskell, 71 Bytes

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

Ini adalah jawaban yang cukup membosankan yang tidak terlalu sulit untuk diuraikan. Tapi itu fromIntegralbenar - benar menggigit. ( /Operator memerlukan operan dari tipe numerik yang sama di Haskell, dan paksaan antara tipe numerik tidak diperbolehkan tanpa fungsi bertele-tele.)

Jelly , 12 byte

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

Cobalah online!

Bagaimana itu bekerja

²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

Terima ndulu, lalu x. Contoh dijalankan.

Haskell , 61 byte

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

Ini tampaknya cukup berbeda dari solusi Haskell lainnya untuk menjamin jawaban yang terpisah. Pelaksanaan harus cukup jelas-panggilan dengan x#nmana xadalah jumlah kosinus dari yang akan dihitung dan nmerupakan urutan jumlah parsial yang akan diambil.

Pyt , 37 34 33 byte

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

J, 26 24 Bytes

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

-2 byte terima kasih kepada @cole

Saya awalnya berencana menggunakan gerund siklik untuk bergantian antara menambah dan mengurangi, tetapi tidak bisa membuatnya bekerja.

Penjelasan:

                    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}

Cobalah online!

Ini benar-benar menghitung kompleks eksponensial e ^iθ untuk dua kali jumlah istilah yang diminta dan kemudian mengambil bagian nyata.

MATLAB dengan Symbolic Math Toolbox, 57 byte

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

Ini mendefinisikan fungsi anonim dengan yang mengambil doubleinput x, ndan output hasilnya sebagai double.

Contoh (diuji pada 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

Untuk menggunakannya:

Tekan F12, ketik fungsi dan kemudian lakukan

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

Versi Tidak Serigala:

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

Terima kasih Kevin telah menghemat beberapa 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}

Cobalah online!

Stax , 12 byte

ü┘·.ⁿYeò≥Vîû

Jalankan dan debug itu

Dibongkar, tidak diserang, dan dikomentari, sepertinya ini.

            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

Jalankan yang ini

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

Cobalah online!

PHP, 76 byte

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

mengambil Xdan Ndari argumen baris perintah; jalankan bersama -r.

lingkaran $idari 0ke N*2-1, terus fac($i)di $f; jika $igenap, tambahkan istilah ke jumlah $s. jumlah cetak.

Saya berharap saya memiliki bilangan kompleks (dengan M_Isebagai unit imajiner);
Saya hanya akan mengalikan $fdengan M_I*++$idan menyimpan 7 byte.

Mungkin Mathematica dapat melakukannya. Tapi Mathematica tidak harus.

Saya bisa menyimpan dua byte dengan cos(M_PI*$i/2)alih - alih $i&1?:dan (-1)**$k++;
tapi rasanya agak aneh menggunakan cosine builtin untuk membangun fungsi cosinus.

Aksioma, 36 byte

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

Bangun infinite (dalam arti terbatas tetapi orang dapat meminta untuk membangun daftar elemen 2 * n jika PC memiliki cukup memori) daftar jumlah parsial untuk seri Taylor untuk cos (x) menghitung dalam 'a', dalam "eval ( taylor (cos (x)), a) "; mendapat elemen 2 * n dari daftar itu di ". (2 * n)". Kasus uji:

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

Cobalah online!

Menggunakan built-in , yang saya anggap OK.

Sayangnya, saya tidak benar-benar tahu bagaimana bekerja dengan baik dengan fungsi yang mengambil argumen melalui currying seperti ini, jadi saya harus melakukan ini secara eksplisit. Saya yakin ada cara untuk melakukannya secara diam-diam atau lebih pendek.

Bersih , 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..]]

Cobalah online!