Ông chủ của tôi chỉ bảo tôi viết một hàm cosin. Là một người đam mê toán học giỏi, tâm trí tôi ngay lập tức tạo ra Taylor Series thích hợp.

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

Tuy nhiên, ông chủ của tôi rất kén chọn. Anh ấy muốn có thể chỉ định chính xác có bao nhiêu điều khoản của Sê-ri Taylor để tính toán. Bạn có thể giúp tôi viết chức năng này?

Nhiệm vụ của bạn

Cho một giá trị dấu phẩy động xtừ 0đến 2 pivà một số nguyên dương nnhỏ hơn 100, tính tổng các số hạng đầu tiên ncủa chuỗi Taylor được đưa ra ở trên cho cos(x).

Đây là mã golf , vì vậy mã ngắn nhất sẽ thắng. Đầu vào và đầu ra có thể được thực hiện theo bất kỳ cách tiêu chuẩn nào. Sơ hở tiêu chuẩn bị cấm.

Ghi chú

• Đầu vào có thể được thực hiện dưới bất kỳ hình thức hợp lý nào, miễn là có sự tách biệt rõ ràng giữa xvà n.
• Đầu vào và đầu ra phải là các giá trị dấu phẩy động, ít nhất là chính xác như tính toán công thức bằng cách sử dụng các số dấu phẩy động chính xác đơn của IEEE với một số quy tắc làm tròn tiêu chuẩn.
• Nếu nó có ý nghĩa đối với ngôn ngữ đang được sử dụng, việc tính toán có thể được thực hiện bằng cách sử dụng các đại lượng hợp lý chính xác, nhưng đầu vào và đầu ra vẫn phải ở dạng thập phân.

Ví dụ

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

Hoạt động ngôn ngữ kịch bản 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}

Gọi với:

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]

Đầu ra:

Đầu vào và đầu ra phải là các giá trị dấu phẩy động, ít nhất là chính xác như tính toán công thức bằng cách sử dụng các số dấu phẩy động chính xác đơn của IEEE với một số quy tắc làm tròn tiêu chuẩn.

Tôi khá chắc chắn rằng các số này là các số dấu phẩy động có độ chính xác đơn của IEEE, mặc dù trong đầu ra được in, các số thập phân dài hơn không chính xác. Đó là in ấn làm tròn các số như thế, thực sự các số chính xác hơn.

Chẳng hạn, a=1.00001;b=1.000011;hint format["%1\n%2\n%3", a, b, a==b]sẽ xuất ra điều này:

1.00001
1.00001
false

Vì vậy, rõ ràng độ chính xác thực tế của các con số lớn hơn độ chính xác được in.

05AB1E , 14 11 byte

FIn(NmN·!/O

Hãy thử trực tuyến!

Giải trình

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

Hãy thử trực tuyến! Hoặc xác minh tất cả các trường hợp thử nghiệm .

Giải thích với ví dụ

Tất cả các số có độ chính xác gấp đôi (đây là mặc định).

Xem xét đầu vào 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

Toán học, 49 41 39 31 byte

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

Phiên bản cũ hơn, "vui nhộn" hơn: (39 byte)

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

Đã lưu 10 byte nhờ @Pavel và 8 nhờ @Greg Martin!

Thạch , 12 11 byte

ḶḤµ⁹*÷!_2/S

Hãy thử trực tuyến!

Làm sao?

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

Thạch, 22 byte

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

Đây là một chương trình đầy đủ, lấy n là đối số thứ nhất và x là đối số thứ hai.

Giải trình:

              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)

Nếu sử dụng Python 2, hãy chắc chắn vượt qua x dưới dạng float, không phải là số nguyên, nhưng tôi hiểu rằng điều đó không quan trọng nếu bạn đang sử dụng 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

Đệ quy sống

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

Chi tiết

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
}

Đệ quy lũy tiến, 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;}

Chi tiết

#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

Đưa đầu vào bị cong (x) (n).

C, 71 byte

sử dụng sơ đồ Horner

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

Phiên bản bị đánh cắp:

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

đã lưu 6 byte nhờ câu trả lời của pizzapants184 với thủ thuật (-x ^ 2) ^ y

65 byte:

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

khá nhiều việc thực hiện ngây thơ của điều này nhưng một chút golf; trả về một hàm ẩn danh tính toán chuỗi Taylor cho n được chỉ định

• sử dụng Giảm sẽ mất thêm một byte khi initphải đặt thành 0
• sử dụng gamma(n+1)thay vìfactorial(n)
• 1:n-1 tương đương với 0:(n-1)

oK , 38 byte

Điều này cũng hoạt động trong k , nhưng mất 39 byte vì người 'ta phải viết /:thay thế (ít nhất là trong kmac 2016,06.28).

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

Giải trình:

Hãy bắt đầu với bit giữa. (*/y#x)là lũy thừa, nó tương đương với x^y. */1+!ysẽ là y!, hoặc ygiai thừa. %là sự phân chia. Do đó chức năng ở giữa là middle(x,y) = (x^y)/(y!).

Bây giờ bit bên phải, mà hàm trên được áp dụng. 2*!ylà {0, 2, 4, ..., 2*(y-1)}. x,'chuẩn bị xcho mọi mục trong danh sách đó, biến nó thành {(x, 0), (x, 2), (x, 4), ..., (x, 2*(y-1))}. Sau .'đó áp dụng middlecho mọi cặp số ( map, về cơ bản).

Cuối cùng, (y#1 -1)* nhân kết quả với 1 hoặc -1 (xen kẽ) và +/lấy tổng.

Haskell, 71 byte

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

Đây là một câu trả lời khá nhàm chán mà không quá khó để giải mã. Các fromIntegralvết cắn thực sự, mặc dù. ( /Toán tử yêu cầu các toán hạng cùng loại trong Haskell và không được phép ép buộc giữa các loại số nếu không có hàm wordy.)

Thạch , 12 byte

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

Hãy thử trực tuyến!

Làm thế nào nó hoạt động

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

Bình thường, 16 byte

sm_Fc^vzyd.!yddU

Chấp nhận ntrước, sau đó x. Ví dụ chạy.

Haskell , 61 byte

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

Điều này dường như đủ khác với giải pháp Haskell khác để đảm bảo một câu trả lời riêng. Việc thực hiện cuộc gọi khá tự giải thích vớix#n nơi xlà số cosin trong số đó là được tính toán và nlà thứ tự của tổng cục bộ được thực hiện.

Pyt , 37 34 33 byte

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

J, 26 24 byte

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

-2 byte nhờ @cole

Ban đầu tôi dự định sử dụng một gerund tuần hoàn để xen kẽ giữa cộng và trừ, nhưng không thể làm cho nó hoạt động được.

Giải trình:

                    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}

Hãy thử trực tuyến!

Điều này thực sự tính toán phức tạp hàm mũ e ^iθ cho gấp đôi số từ ngữ được yêu cầu và sau đó mất phần thực.

MATLAB với Hộp công cụ Toán học tượng trưng, ​​57 byte

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

Điều này xác định một hàm ẩn danh với các doubleđầu vàox , nvà đầu ra kết quả như mộtdouble .

Ví dụ (được thử nghiệm trên 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

Để dùng nó:

Nhấn F12, nhập chức năng và sau đó làm

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

Phiên bản 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;
 }

Cảm ơn Kevin đã lưu một số 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}

Hãy thử trực tuyến!

Stax , 12 byte

ü┘·.ⁿYeò≥Vîû

Chạy và gỡ lỗi nó

Giải nén, không được chỉnh sửa, và nhận xét, nó trông như thế này.

            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

Chạy cái này

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

Hãy thử trực tuyến!

PHP, 76 byte

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

mất Xvà Ntừ các đối số dòng lệnh; chạy với -r.

vòng lặp $itừ 0đến N*2-1, giữ fac($i)trong $f; nếu $ilà chẵn, thêm số hạng vào tổng $s. in tổng.

Tôi ước tôi có số phức (với M_Iđơn vị là tưởng tượng);
Tôi chỉ đơn giản là nhân $fvới M_I*++$ivà lưu 7 byte.

Có lẽ Mathicala có thể làm điều đó. Nhưng Mathicala khôngnt phải.

Tôi có thể lưu hai byte cos(M_PI*$i/2)thay vì $i&1?:và (-1)**$k++;
nhưng nó sẽ cảm thấy hơi kỳ lạ khi sử dụng một cosin dựng sẵn để xây dựng một chức năng cosine.

Tiên đề, 36 byte

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

Xây dựng vô hạn (theo nghĩa hữu hạn nhưng người ta có thể yêu cầu xây dựng danh sách các phần tử 2 * n nếu PC có đủ bộ nhớ) danh sách tổng một phần cho chuỗi Taylor cho cos (x) tính theo 'a', trong "eval ( taylor (cos (x)), a) "; lấy phần tử 2 * n của danh sách đó trong ". (2 * n)". Các trường hợp thử nghiệm:

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

Hãy thử trực tuyến!

Sử dụng tích hợp , mà tôi giả sử là OK.

Thật không may, tôi thực sự không biết làm thế nào để làm việc tốt với các hàm lấy các đối số thông qua curry như thế này, vì vậy tôi phải làm điều này một cách rõ ràng. Tôi chắc chắn rằng có một cách để làm điều đó ngầm hoặc ngắn hơn.

Sạch , 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..]]

Hãy thử trực tuyến!