Многочлены Чебышёва (Polinomi di Chebyshev)

26

I polinomi di Chebyshev sono una famiglia di polinomi ortogonali che compaiono in tutti i tipi di luoghi in matematica e hanno molte proprietà piuttosto interessanti. Una loro caratterizzazione è che sono i polinomi unici che soddisfano .Tn(cos(x)) = cos(n*x)

Sfida

Dato un numero intero non negativo n, dovresti generare il n-th Polinomio di Chebyshev. .Tn(x)

Definizione

Il nPolinomio di Chebyshev è dato dalla seguente ricorsione a tre termini:

T0(x) = 1
T1(x) = x
Tn+1(x) = 2*x*Tn(x) - Tn-1(x)

Dettagli

Se la tua lingua ha un tipo polinomiale nativo, puoi usarlo come output, altrimenti dovresti produrre un elenco di coefficienti in ordine crescente o decrescente o come stringa che rappresenta un polinomio.

Esempi

T0(x) = 1
T1(x) = x 
T2(x) = 2x^2 - 1
T3(x) = 4x^3 - 3 x
T4(x) = 8x^4 - 8x^2 + 1
T5(x) = 16x^5 - 20x^3 + 5x
T10(x) = 512x^10 - 1280x^8 + 1120x^6 - 400x^4 + 50x^2 - 1

Nel formato dell'elenco dei gradi decrescente otterremmo e nel formato dei gradi ascendenti otterremmoT3(x) = [4,0,-3,0]T3(x) = [0,-3,0,4]

code-golf  math  sequence  polynomials  recursion 
— flawr
fonte
Se output un elenco, posso output 0 1(cioè 0*x+1) per T_0?
— Luis Mendo,
Finché l'ordine dei monomi è coerente, va bene!
— Flawr,
@flawr è 2*x*(2*x**2 - 1) - xok come output per 3 per lang supportivo polinomio, o abbiamo bisogno della rappresentazione come descrittori?
— Uriel,
11
— Mego
2
Le inesattezze in virgola mobile sono accettabili? vale a direT_5(n) = [0, 5, 3.55271e-15, -20, 0, 16]
— miglia

Risposte:

15

Mathematica, 15 byte

#~ChebyshevT~x&

Certo, Mathematica ha un builtin.

Se è consentito un modulo di input alternativo (10 byte):

ChebyshevT

accetta un numero intero ne una variabile.

— JungHwan Min
fonte
3
Non avrei potuto indovinare, eh. : P
— HyperNeutrino,
14

Ottava , 39 byte

@(n)round(2^n/2*poly(cos((.5:n)/n*pi)))

Provalo online!

Spiegazione

cos((.5:n)/n*pi)costruisce un vettore con le radici del polinomio , dato da

inserisci qui la descrizione dell'immagine

polydà il polinomio monico con quelle radici. Moltiplicando per 2^n/2scala i coefficienti come richiesto. roundsi assicura che i risultati siano interi nonostante la precisione numerica.

— Luis Mendo
fonte
1
Intelligente come sempre :)
— flawr
10

Haskell , 62 byte

t n|n<2=1:[0|n>0]|x<-(*2)<$>t(n-1)++[0]=zipWith(-)x$0:0:t(n-2)

Provalo online!

flawr ha salvato un byte.

— Lynn
fonte
Questo è molto elegante! (Continuo a dimenticare le zipWithoperazioni vettoriali.)
— Flawr
1
Penso che puoi anche salvare un altro byte usando guards: in t n|n<2=1:[0|n>0]|x<-(*2)<$>t(n-1)++[0]=zipWith(-)x$0:t(n-2)questo modo puoi rimuovere la coppia di parentesi centrale nell'ultima riga :)
— flawr
Penso che devi passare 0:a 0:0:- OP ha appena impedito questo tipo di saltare gli zero.
— Ørjan Johansen,
7

CJam (21 byte)

1a2,qi{0X$+2f*@.-}*;`

Questo è un programma completo: l'equivalente di un blocco anonimo ha la stessa lunghezza:

{1a2,@{0X$+2f*@.-}*;}

Demo online

— Peter Taylor
fonte
6

Python + SymPy , 66 byte

from sympy.abc import*
T=lambda n:n<2and x**n or 2*x*T(n-1)-T(n-2)

Provalo online!

Con rappresentazione dei coefficienti decrescenti

from sympy import*
x=symbols('x')
T=lambda n:n<2and x**n or expand(2*x*T(n-1)-T(n-2))

Provalo online!

— Uriel
fonte
[1,x][n]->x**n
— alephalpha,
5

MATL , 17 byte

lFTi:"0yhEbFFh-]x

I coefficienti vengono emessi in ordine crescente di grado.

Provalo online! Oppure verifica tutti i casi di test .

Spiegazione

Per l'ingresso n , il codice applica la relazione ricorsiva n volte. I due polinomi più recenti sono sempre tenuti in pila. Quando viene calcolato un nuovo polinomio, il più vecchio viene rimosso.

Alla fine, viene visualizzato il penultimo polinomio (l'ultimo polinomio viene eliminato), poiché abbiamo eseguito troppe iterazioni.

l        % Push 1
FT       % Push [0 1]. These are the first two polynomials
i:"      % Input n. Do the following n times
  0      %   Push 0
  y      %   Duplicate most recent polynomial
  h      %   Concatenate: prepends 0 to that polynomial
  E      %   Multiply coefficients by 2
  b      %   Bubble up. This moves second-most recent polynomial to top
  FF     %   Push [0 0]
  h      %   Concatenate: appends [0 0] to that polynomial
  -      %   Subtract coefficients
]        % End
x        % Delete. Implicitly display
— Luis Mendo
fonte
4

Gelatina , 18 byte

Cr1µ’ßḤ0;_’’$ß$µỊ?

Provalo online!

Restituisce un elenco di coefficienti in ordine crescente.

Esiste un'altra soluzione per 17 byte con imprecisioni in virgola mobile.

RḤ’÷Ḥ-*ḞÆṛæ«’µ1Ṡ?

Provalo online!

Spiegazione

Cr1µ’ßḤ0;_’’$ß$µỊ?  Input: integer n
                Ị   Insignificant - abs(n) <= 1
                    If true, n = 0 or n = 1
   µ                  Monadic chain
C                       Complement, 1-x
 r1                     Range to 1
                    Else
               µ      Monadic chain
    ’                   Decrement
     ß                  Call itself recursively
      Ḥ                 Double
       0;               Prepend 0
         _              Subtract with
            $             Monadic chain
          ’’                Decrement twice
              $           Monadic chain
             ß              Call itself recursively
— miglia
fonte
— Leaky Nun
2

Rubino + polinomio , 59 58 + 13 = 72 71 byte

Usa la -rpolynomialbandiera.

f=->n{x=Polynomial.new 0,1;n<2?[1,x][n]:2*x*f[n-1]-f[n-2]}
— Value Ink
fonte
2

J , 33 byte

(0>.<:)2&*1:p.@;9:o._1^+:%~1+2*i.

Provalo online!

Suppone che le imprecisioni in virgola mobile siano accettabili e crea l'emoji (0>.<:)

Per 41 byte , esiste un'altra soluzione che evita i float.

(0&,1:)`(-&2((-,&0 0)~2*0&,)&$:<:)@.(>&1)

Provalo online!

— miglia
fonte
2

Assioma, 40 byte

f(n,x)==(n<2=>x^n;2*x*f(n-1,x)-f(n-2,x))

risultati

(9) -> for i in [0,1,2,3,4,5,10] repeat output ["f(y)",i,"=", f(i,y)]
   ["f(y)",0,"=",1]
   ["f(y)",1,"=",y]
                   2
   ["f(y)",2,"=",2y  - 1]
                   3
   ["f(y)",3,"=",4y  - 3y]
                   4     2
   ["f(y)",4,"=",8y  - 8y  + 1]
                    5      3
   ["f(y)",5,"=",16y  - 20y  + 5y]
                      10        8        6       4      2
   ["f(y)",10,"=",512y   - 1280y  + 1120y  - 400y  + 50y  - 1]
                                                               Type: Void

è possibile definire una legge di sostituzione per la formula nell'uso di Axiom sopra la funzione f () per l'espansione di cos (n * x) dove n è un numero intero

(9) -> o:=rule cos(n*%y)==f(n,cos(%y))
   (9)  cos(%y n) == 'f(n,cos(%y))
                    Type: RewriteRule(Integer,Integer,Expression Integer)
                                                              Time: 0 sec
(10) -> b:=o cos(20*x)
   (10)
                 20                18                16                14
     524288cos(x)   - 2621440cos(x)   + 5570560cos(x)   - 6553600cos(x)
   +
                  12                10               8              6
     4659200cos(x)   - 2050048cos(x)   + 549120cos(x)  - 84480cos(x)
   +
               4            2
     6600cos(x)  - 200cos(x)  + 1
                                                 Type: Expression Integer
                       Time: 0.48 (EV) + 0.02 (OT) + 0.10 (GC) = 0.60 sec
— RosLuP
fonte
1

C # (.NET Core) , 126 byte

f=n=>n==0?new[]{1}:n==1?new[]{0,1}:new[]{0}.Concat(f(n-1)).Select((a,i)=>2*a-(i<n-1?f(n-2)[i]:0)).ToArray();

Il conteggio dei byte include anche:

using System.Linq;

Provalo online!

La funzione restituisce il polinomio come una matrice di coefficienti in ordine crescente (da x^0a x^n)

Spiegazione:

f = n =>                          // Create a function taking one parameter (int)
    n == 0 ? new[] { 1 } :        // If it's 0, return collection [1]
    n == 1 ? new[] { 0, 1 } :     // If it's 1, return collection [0,1] (so x + 0)
    new[] { 0 }                   // Else create new collection, starting with 0
        .Concat(f(n - 1))         // Concatenate with f(n-1), effectively multiplying polynomial by x
        .Select((a, i) => 2 * a - (i < n - 1 ? f(n - 2)[i] : 0))
                                  // Multiply everything by 2 and if possible, subtract f(n-2)
        .ToArray();               // Change collection to array so we have a nice short [] operator
                                  // Actually omitting this and using .ElementAt(i) is the same length, but this is my personal preference
— Grzegorz Puławski
fonte
1

JavaScript (ES6), 65 byte

f=n=>n?n>1?[0,...f(n-1)].map((e,i)=>e+e-(f(n-2)[i]||0)):[0,1]:[1]

Inefficiente per grandi n. Interessante ma purtroppo anche inefficiente:

n=>[...Array(n+1)].map(g=(m=n,i)=>i<0|i>m?0:m<2?i^m^1:g(m-1,i-1)*2-g(m-2,i))

Molto efficiente per 68 byte:

f=(n,a=[1],b=[0,1])=>n?f(n-1,b,[0,...b].map((e,i)=>e+e-(a[i]||0))):a

Restituisce una matrice di coefficienti in ordine crescente.

— Neil
fonte
Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.