Cosinus Pedanta

29

Mój szef właśnie powiedział mi, żebym napisał funkcję cosinus. Będąc dobrym maniakiem matematyki, mój umysł natychmiast wyczarował odpowiedni serial Taylora.

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

Jednak mój szef jest bardzo wybredny. Chciałby móc dokładnie określić, ile terminów z serii Taylor należy obliczyć. Czy możesz mi pomóc napisać tę funkcję?

Twoje zadanie

Biorąc pod uwagę zmiennoprzecinkową wartość xod 0do 2 pii dodatnią liczbę całkowitą nmniejszą niż 100, oblicz sumę pierwszych nskładników szeregu Taylora podanych powyżej dla cos(x).

To jest , więc wygrywa najkrótszy kod. Dane wejściowe i wyjściowe można pobierać na dowolny ze standardowych sposobów. Standardowe luki są zabronione.

Uwagi

  • Dane wejściowe można przyjmować w dowolnej rozsądnej formie, o ile istnieje wyraźny rozdział między xi n.
  • Dane wejściowe i wyjściowe powinny być wartościami zmiennoprzecinkowymi, co najmniej tak dokładnymi jak obliczanie formuły przy użyciu liczb zmiennoprzecinkowych IEEE o pojedynczej precyzji z pewnymi standardowymi regułami zaokrąglania.
  • Jeśli ma to sens dla używanego języka, obliczenia mogą być wykonywane przy użyciu dokładnych wielkości wymiernych, ale dane wejściowe i wyjściowe powinny być nadal w postaci dziesiętnej.

Przykłady

 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
źródło
1
Zakładam, że nto też jest większe niż 0?
GamrCorps
8
Powiedziałbym, że technicznie nie jest to, co oznacza pedant, ale byłoby to zbyt meta.
PyRulez
8
Jeśli Twój szef chce, abyś napisał dobrą lub przynajmniej czytelną funkcję, jesteś w złym miejscu.
Roman Gräf
2
Naprawdę wybredna szef chciałby, aby obliczyć cosinus za pomocą czegoś bardziej wydajne (i dokładne), niż szereg Taylora ...
PM 2Ring
6
@ PM2Ring To nie byłoby wybredne, byłoby rozsądne. Seria Taylor jest naprawdę najokrutniejszą opcją.
user1997744 18.04.17

Odpowiedzi:

64

Operacyjny język skryptowy Flashpoint , 165 157 bajtów

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}

Zadzwoń z:

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]

Wydajność:

wprowadź opis zdjęcia tutaj

Dane wejściowe i wyjściowe powinny być wartościami zmiennoprzecinkowymi, co najmniej tak dokładnymi jak obliczanie formuły przy użyciu liczb zmiennoprzecinkowych IEEE o pojedynczej precyzji z pewnymi standardowymi regułami zaokrąglania.

Jestem całkiem pewien, że liczby są liczbami zmiennoprzecinkowymi IEEE o pojedynczej precyzji, nawet jeśli na wydruku dłuższe miejsca dziesiętne nie są tak dokładne. To druk zaokrągla liczby w ten sposób, w rzeczywistości liczby są dokładniejsze.

Na przykład a=1.00001;b=1.000011;hint format["%1\n%2\n%3", a, b, a==b]wyświetli to:

1.00001
1.00001
false

Tak więc wyraźnie rzeczywista dokładność liczb jest większa niż precyzja drukowana.

Steadybox
źródło
16
@orlp Dlaczego nie?
Steadybox
3
@orlp Myślę, że bardziej odpowiednie pytanie brzmi: dlaczego język skryptowy Operation Flashpoint nie jest odmianą ArnoldC ?
ceilingcat
2
Hmmm… czy wprowadzasz dane, strzelając określoną liczbę rund [n] w dany kierunek kompasu [x]? 😍 Operacja Flashpoint!
Mormegil 18.04.17
14
@Mormegil Cóż, ogólnie nie, ale można to zrobić za pomocą tego kodu: 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}}}]- Strzelanie w określonym kierunku zwiększa licznik, a następnie strzelanie w innym kierunku wywołuje funkcję cosinus z wcześniejszym kierunkiem i liczbą strzałów w tym kierunku.
Steadybox
13

05AB1E , 14 11 bajtów

FIn(NmN·!/O

Wypróbuj online!

Wyjaśnienie

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
źródło
@JamesHolderness: Tak, od tego czasu język przeszedł gruntowny remont. Wygląda na to ², że dziwny robak dotknął go , ale zamiast tego można go zastąpić I.
Emigna
10

MATL , 14 bajtów

U_iqE:2ep/YpsQ

Wypróbuj online! Lub sprawdź wszystkie przypadki testowe .

Objaśnienie z przykładem

Wszystkie liczby mają podwójną precyzję (jest to ustawienie domyślne).

Rozważmy wejść 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
źródło
10

Mathematica, 49 41 39 31 bajtów

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

Stara, bardziej „zabawna” wersja: (39 bajtów)

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

Zaoszczędź 10 bajtów dzięki @Pavel i 8 dzięki @Greg Martin!

GamrCorps
źródło
9
Chociaż Seriesmożliwości Mathematiki są naprawdę niesamowite i zabawne, okazuje się, że ręczne wdrażanie Sum[(-#^2)^k/(2k)!,{k,0,#2-1}]&jest tutaj krótsze.
Greg Martin
9

Galaretka , 12 11 bajtów

ḶḤµ⁹*÷!_2/S

Wypróbuj online!

W jaki sposób?

ḶḤµ⁹*÷!_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
źródło
8

Galaretka, 22 bajty

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

Jest to pełny program, który przyjmuje n jako pierwszy argument, a x jako drugi.

Wyjaśnienie:

              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
źródło
7
Witamy w PPCG!
Martin Ender
6

Python, 54 bajty

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

Jeśli używasz Python 2, pamiętaj, aby przekazać x jako liczbę zmiennoprzecinkową, a nie liczbę całkowitą, ale rozumiem, że nie ma znaczenia, czy używasz Python 3.

Neil
źródło
5

TI-Basic, 41 40 bajtów

Prompt X,N
sum(seq((-(X+1E-49)2)^Q/((2Q)!),Q,0,N-1
1E-49 jest dodawany do kąta, ponieważ TI-Basic generuje błąd dla 0 ^ 0, jest wystarczająco duży, aby nie powodować błędu, i nie jest wystarczająco duży, aby zmienić odpowiedź.

pizzapanty184
źródło
4

C, 96 bajtów

Recursive Live

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

Szczegółowy

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
}

Progresywny rekurencyjny, 133 bajty na żywo

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

Szczegółowy

#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
źródło
Wersja 96b c(0.5, 80)=> NaN, za przepełnienief(80)=0
l4m2
@ L4m2 funkcje rekurencyjne są tutaj w celu gry w golfa, ale są niepraktyczne, ponieważ mogą łatwo przepełnić, ponieważ liczba połączeń przekracza limit stosów wywołań, a nawet przy wyższych limitach jest to strata zasobów, dla powyższego rozwiązania mniejsze liczby.
Khaled.K
1
Problem bezpośrednio mówi, n<100więc przynajmniej nie zajdziesz tak daleko w zasięgu. Nie przepełnienie stosu
l4m2
Jeśli problem mówi n<100i używasz O(2^n)rozwiązania, myślę, że jest w porządku, o ile w końcu retuanuje wynik
l4m2
1
FYI, wynik NaN nie ma nic wspólnego z rekurencją - jest to przepełnienie obliczeń czynnikowych, które używają liczb całkowitych, kiedy powinny używać liczb zmiennoprzecinkowych (198! Nigdy nie zmieści się w int).
James Holderness
4

JavaScript (ES6), 46 bajtów

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

Pobiera curry wejściowe (x) (n).

Neil
źródło
Dlaczego nie zrobić z tego fragmentu?
Arjun
4

C, 71 bajtów

używając schematu Hornera

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

Wersja bez golfa:

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
źródło
Na jakiej platformie to działa?
anatolyg
4

R 70 70 bajtów

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

zapisano 6 bajtów dzięki odpowiedzi pizzapants184 na lewę (-x ^ 2) ^ y

65 bajtów:

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

właściwie naiwna realizacja tego, ale trochę golfa; zwraca anonimową funkcję, która oblicza szereg Taylora do podanego n

  • użycie Reduce zajmuje jeszcze jeden bajt, ponieważ initmusi być ustawiony na 0
  • używa gamma(n+1)zamiastfactorial(n)
  • 1:n-1 jest równa 0:(n-1)
Giuseppe
źródło
3

ok , 38 bajtów

Działa to również w k , ale zajmuje 39 bajtów, ponieważ jeden 'musi być napisany w ten sposób /:(przynajmniej w kmac 2016.06.28 to robi).

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

Wyjaśnienie:

Zacznijmy od środkowego kawałka. (*/y#x)jest potęgowaniem, jest równoważne z x^y. */1+!ybyłoby y!lub ysilnia. %to podział. Dlatego funkcja pośrodku to middle(x,y) = (x^y)/(y!).

Teraz bit po prawej stronie, do którego stosuje się powyższą funkcję. 2*!yjest {0, 2, 4, ..., 2*(y-1)}. x,'dołącza xdo każdego elementu na liście, zamieniając go w {(x, 0), (x, 2), (x, 4), ..., (x, 2*(y-1))}. To .'odnosi się middledo każdej pary liczb ( mapzasadniczo).

Na koniec (y#1 -1)*mnoży wynik przez 1 lub -1 (naprzemiennie) i +/pobiera sumę.

zgrep
źródło
3

Haskell, 71 bajtów

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

To dość nudna odpowiedź, która nie jest zbyt trudna do rozszyfrowania. Ale fromIntegralnaprawdę gryzie. ( /Operator wymaga operandów tego samego typu liczbowego w języku Haskell, a wymuszanie między typami liczbowymi jest niedozwolone bez trudnej funkcji.)

Enderperson1010
źródło
1
Zrozumienie listy może uratować ci kilka kęsów:f x n=sum[(-1)^i*x^(2*i)/fromIntegral(product[1..2*i])|i<-[0..n-1]]
Julian Wolf,
1
Witamy w szczególności w PPCG i Haskell!
Laikoni
3

Galaretka , 12 bajtów

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

Wypróbuj online!

Jak to działa

²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
źródło
3

Haskell , 61 bajtów

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

Wydawało się, że różni się to od innych rozwiązań Haskell, aby uzasadnić osobną odpowiedź. Wdrożenie powinno być dość oczywiste - zadzwoń, x#ngdzie xjest liczbą, której cosinus ma być obliczony, i njest to kolejność częściowej sumy, którą należy pobrać.

Julian Wolf
źródło
Możesz zaoszczędzić sporo bajtów, usuwając fromIntegrali używając **zamiast ^, takich jak ten
B. Mehta
x#n=sum[(-x*x)**i/product[1..2*i]|i<-[0..n-1]]oszczędza jeszcze 3 bajty.
Lynn
3

Pyt , 37 34 33 bajtów

←←ĐĐ↔3Ș1~⇹ř⁻^04Ș⇹ř⁻^²*0↔ř⁻2*!+/+Ʃ
mudkip201
źródło
3

J, 26 24 bajtów

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

-2 bajty dzięki @cole

Początkowo planowałem użyć cyklicznego gerunda do przełączania między dodawaniem a odejmowaniem, ale nie mogłem go uruchomić.

Wyjaśnienie:

                    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
źródło
1
24 bajty: +/@:(!@]%~^*_1^2%~])2*i.Zbadam cyklicznego gerunda: prawdopodobnie nie udał się, ponieważ J ocenia od /prawej do lewej, więc musisz go użyć |.(a może to zrobiłeś i nadal miałeś trudności).
cole
3

Perl 6 , 53 bajtów

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

Wypróbuj online!

To faktycznie oblicza złożoną wartość wykładniczą e dla dwukrotności żądanych terminów, a następnie bierze rzeczywistą część.

Sean
źródło
2

MATLAB z Symbolic Math Toolbox, 57 bajtów

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

Ta funkcja definiuje anonimową z tym bierze doublewejściowe x, ni wysyła wynik postaci double.

Przykład (testowany na 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
źródło
2

JavaScript ES7 60 bajtów

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

Aby go użyć:

Naciśnij klawisz F12, wpisz funkcję, a następnie zrób

c(x)(n)
Bálint
źródło
2

C 144 130 bajtów

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

Wersja bez golfa:

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

Dzięki Kevin za uratowanie niektórych bajtów!

Abel Tom
źródło
Możesz zaoszczędzić kilka bajtów, masując definicje funkcji:F(m){...}f(x,n)float x;{...}
Kevin,
Ponieważ u * 1 == u, możesz wykonać pętlę w pierwszej funkcji albo while(m)u*=m--albo u=m;while(--m)u*=m(tej samej długości)
Kevin
i<=n-1jest taki sam jaki<n
Kevin,
@Kevin Dzięki, masz absolutną rację, od jakiegoś czasu nie grałeś w golfa. :)
Abel Tom
2
101 bajtów
ceilingcat
2

Stax , 12 bajtów

ü┘·.ⁿYeò≥Vîû

Uruchom i debuguj

Rozpakowane, niepolowane i skomentowane, wygląda to tak.

            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

Uruchom ten

rekurencyjny
źródło
1

JavaScript, 59 bajtów

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

Wypróbuj online!

Fəˈnɛtɪk
źródło
To jest 65 bajtów
Bálint
@ Bálint popełnił błąd podczas kopiowania zmian. (n) miał być po prostu n
fəˈnɛtɪk
1

PHP, 76 bajtów

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

pobiera Xi Nz argumentów wiersza poleceń; biegać z -r.

Pętla $ize 0się N*2-1, zawieszone fac($i)w $f; jeśli $ijest parzysty, dodaj termin do sumy $s. wydrukuj sumę.


Chciałbym mieć liczby zespolone (z M_Ijednostką urojoną);
Chciałbym po prostu pomnożyć $fz M_I*++$izaoszczędzisz 7 bajtów.

Może Mathematica może to zrobić. Ale Mathematica nie musi.

I mógłby uratować dwa bajty z cos(M_PI*$i/2)zamiast $i&1?:a (-1)**$k++;
ale używanie wbudowanego cosinusa do zbudowania funkcji cosinusa byłoby trochę dziwne.

Tytus
źródło
1

Aksjomat, 36 bajtów

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

Zbuduj nieskończoną (w sensie skończoną, ale można poprosić o zbudowanie listy 2 * n elementów, jeśli komputer ma wystarczającą ilość pamięci) listę częściowych sum dla szeregu Taylora dla cos (x) oblicz w „a”, w „eval ( Taylor (cos (x)), a) "; pobiera element 2 * n z tej listy w „. (2 * n)”. Przypadki testowe:

(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
źródło
1

J , 17 bajtów

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

Wypróbuj online!

Używa wbudowanego , co, jak zakładam, jest OK.

Niestety, tak naprawdę nie wiem, jak dobrze pracować z funkcjami, które pobierają argumenty za pomocą curry w ten sposób, więc musiałem to zrobić jawnie. Jestem pewien, że istnieje sposób, aby zrobić to milcząco lub krócej.

kapusta
źródło