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


26

Los polinomios de Chebyshev son una familia de polinomios ortogonales que aparecen en todo tipo de lugares en matemáticas, y tienen muchas propiedades bastante interesantes. Una caracterización de ellos es que son los polinomios únicos que satisfacen .Tn(cos(x)) = cos(n*x)

Reto

Dado un número entero no negativo n, debe generar el nenésimo polinomio de Chebyshev. .Tn(x)

Definición

El nsexto polinomio de Chebyshev se da siguiendo la recursión de tres términos:

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

Detalles

Si su idioma tiene un tipo de polinomio nativo, puede usarlo como salida, de lo contrario, debería generar una lista de coeficientes en orden ascendente o descendente, o como una cadena que representa un polinomio.

Ejemplos

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

En el formato de lista de grados descendente obtendríamos y en el formato de grados ascendentes obtendríamosT3(x) = [4,0,-3,0]T3(x) = [0,-3,0,4]


Si envío una lista, ¿puedo enviar 0 1(es decir 0*x+1) para T_0?
Luis Mendo

Mientras el orden de los monomios sea consistente, ¡está bien!
flawr

@flawr está 2*x*(2*x**2 - 1) - xbien como salida para 3 para lang de soporte de polinom, ¿o necesitamos la representación como coeffs desc?
Uriel


2
¿Son aceptables las imprecisiones de coma flotante? es decirT_5(n) = [0, 5, 3.55271e-15, -20, 0, 16]
millas

Respuestas:


15

Mathematica, 15 bytes

#~ChebyshevT~x&

Por supuesto, Mathematica tiene un incorporado.

Si se permite un formulario de entrada alternativo (10 bytes):

ChebyshevT

toma un entero ny una variable.


3
No podría haberlo adivinado, eh. : P
HyperNeutrino

14

Octava , 39 bytes

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

Pruébalo en línea!

Explicación

cos((.5:n)/n*pi)construye un vector con las raíces del polinomio , dado por

ingrese la descripción de la imagen aquí

polyda el polinomio monico con esas raices. Multiplicar por 2^n/2escalas los coeficientes según sea necesario. roundse asegura de que los resultados sean enteros a pesar de la precisión numérica.


1
Inteligente como siempre :)
flawr


10

Haskell , 62 bytes

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

Pruébalo en línea!

flawr guardó un byte.


¡Esto es muy elegante! (Me sigo olvidando zipWithde las operaciones de vectores.)
error

1
Creo que se puede incluso ahorrar un byte más mediante el uso de guardias: t n|n<2=1:[0|n>0]|x<-(*2)<$>t(n-1)++[0]=zipWith(-)x$0:t(n-2), de esa manera se puede quitar el par medio de paréntesis en la última línea :)
flawr

Creo que tiene que cambiar 0:a 0:0:- OP simplemente rechazó este tipo de omisión de los ceros.
Ørjan Johansen




5

MATL , 17 bytes

lFTi:"0yhEbFFh-]x

Los coeficientes se producen en orden creciente de grado.

Pruébalo en línea! O verificar todos los casos de prueba .

Explicación

Para la entrada n , el código aplica la relación recursiva n veces. Los dos polinomios más recientes siempre se mantienen en la pila. Cuando se calcula un nuevo polinomio, se elimina el más antiguo.

Al final, se muestra el penúltimo polinomio (se elimina el último polinomio), ya que hemos hecho demasiadas iteraciones.

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

4

Jalea , 18 bytes

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

Pruébalo en línea!

Devuelve una lista de coeficientes en orden ascendente.

Hay otra solución para 17 bytes con imprecisiones de punto flotante.

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

Pruébalo en línea!

Explicación

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


2

Ruby + polinomio , 59 58 + 13 = 72 71 bytes

Usa la -rpolynomialbandera.

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

2

J , 33 bytes

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

Pruébalo en línea!

Asume que las imprecisiones de coma flotante son aceptables y crea el emoji (0>.<:)

Para 41 bytes , hay otra solución que evita los flotantes.

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

Pruébalo en línea!



2

Axioma, 40 bytes

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

resultados

(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

es posible definir una ley de sustitución para la fórmula en el uso de Axiom sobre la función f () para la expansión de cos (n * x) donde n es un número entero

(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

1

C # (.NET Core) , 126 bytes

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

El recuento de bytes también incluye:

using System.Linq;

Pruébalo en línea!

La función devuelve polinomio como una matriz de coeficientes en orden ascendente (de x^0a x^n)

Explicación:

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

1

JavaScript (ES6), 65 bytes

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

Ineficiente para grandes n. Interesante pero lamentablemente también ineficiente:

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

Muy eficiente para 68 bytes:

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

Devuelve una matriz de coeficientes en orden ascendente.

Al usar nuestro sitio, usted reconoce que ha leído y comprende nuestra Política de Cookies y Política de Privacidad.
Licensed under cc by-sa 3.0 with attribution required.