Introducción a las series
=========================

Maxima dispone de las funciones taylor y powerseries para calcular las series de las funciones diferenciables. También tiene herramientas como nusum capaces de encontrar la expresión compacta de algunas series. Operaciones como la suma y la multiplicación operan de la forma habitual en el contexto de las series. Esta sección presenta las variables globales que controlan la expansión.

Funciones y variables para las series
=====================================

 -- Variable opcional: cauchysum
     Valor por defecto: false

     Cuando se multiplican sumatorios infinitos, si sumexpand vale true y cauchysum vale true, entonces se utilizará el producto  de Cauchy en lugar del usual. En el producto de Cauchy  el índice de la suma interna es función del índice de la exterior en lugar de variar de forma independiente. Un ejemplo aclara esta idea:

          (%i1) sumexpand: false$
          (%i2) cauchysum: false$
          (%i3) s: sum (f(i), i, 0, inf) * sum (g(j), j, 0, inf);
                                inf         inf
                                ====        ====
                                \           \
          (%o3)                ( >    f(i))  >    g(j)
                                /           /
                                ====        ====
                                i = 0       j = 0
          (%i4) sumexpand: true$
          (%i5) cauchysum: true$
          (%i6) ''s;
                           inf     i1
                           ====   ====
                           \      \
          (%o6)             >      >     g(i1 - i2) f(i2)
                           /      /
                           ====   ====
                           i1 = 0 i2 = 0

 -- Función: deftaylor (F_1(X_1), EXPR_1, ..., F_N(X_N), EXPR_N)
     Para cada función F_I de variable X_I,  deftaylor define EXPR_I como una serie de Taylor alrededor de cero. La expresión EXPR_I será un polinomio en  X_I o una suma; deftaylor admite también expresiones más generales.

     La llamada powerseries (F_I(X_I), X_I, 0) devuelve la serie definida por  deftaylor.

     La función deftaylor evalúa sus argumentos y devuelve la lista de las funciones F_1, ..., F_N.

     Ejemplo:

          (%i1) deftaylor (f(x), x^2 + sum(x^i/(2^i*i!^2), i, 4, inf));
          (%o1)                          [f]
          (%i2) powerseries (f(x), x, 0);
                                inf
                                ====      i1
                                \        x         2
          (%o2)                  >     -------- + x
                                /       i1    2
                                ====   2   i1!
                                i1 = 4
          (%i3) taylor (exp (sqrt (f(x))), x, 0, 4);
                                2         3          4
                               x    3073 x    12817 x
          (%o3)/T/     1 + x + -- + ------- + -------- + . . .
                               2     18432     307200

 -- Variable opcional: maxtayorder
     Valor por defecto: true

     Si maxtayorder vale true, entonces durante la manipulación algebraica de series truncadas de Taylor, la función taylor trata de retener tantos términos correctos como sea posible.

 -- Función: niceindices (EXPR)
     Cambia las etiquetas de los índices de sumas y productos de EXPR. La función niceindices trata de cambiar cada índice al valor de niceindicespref[1], a menos que esa etiqueta aparezca ya en el sumando o factor, en cuyo caso  niceindices realiza intentos con los siguientes elementos de  niceindicespref, hasta que encuentre una variable que que no esté en uso. Si todas las variables de la lista han sido ya revisadas, se formarán nuevos ínices añadiendo números enteros al valor de niceindicespref[1], como i0, i1, i2, ....

     La función niceindices evalúa sus argumentos y devuelve una expresión.

     Ejemplo:

          (%i1) niceindicespref;
          (%o1)                  [i, j, k, l, m, n]
          (%i2) product (sum (f (foo + i*j*bar), foo, 1, inf), bar, 1, inf);
                           inf    inf
                          /===\   ====
                           ! !    \
          (%o2)            ! !     >      f(bar i j + foo)
                           ! !    /
                          bar = 1 ====
                                  foo = 1
          (%i3) niceindices (%);
                               inf  inf
                              /===\ ====
                               ! !  \
          (%o3)                ! !   >    f(i j l + k)
                               ! !  /
                              l = 1 ====
                                    k = 1

 -- Variable opcional: niceindicespref
     Valor por defecto: [i, j, k, l, m, n]

     La variable niceindicespref es la lista de la que la función niceindices va tomando nombres de etiquetas para índices de sumatorios y productos.

     En niceindicespref se guardan normalmente nombres de variables.

     Ejemplo:

          (%i1) niceindicespref: [p, q, r, s, t, u]$
          (%i2) product (sum (f (foo + i*j*bar), foo, 1, inf), bar, 1, inf);
                           inf    inf
                          /===\   ====
                           ! !    \
          (%o2)            ! !     >      f(bar i j + foo)
                           ! !    /
                          bar = 1 ====
                                  foo = 1
          (%i3) niceindices (%);
                               inf  inf
                              /===\ ====
                               ! !  \
          (%o3)                ! !   >    f(i j q + p)
                               ! !  /
                              q = 1 ====
                                    p = 1

 -- Función: nusum (EXPR, X, I_0, I_1)
     Calcula la suma hipergeométrica indefinida de  EXPR con respecto a la variable  X utilizando una procedimiento de decisión debido a R.W. Gosper. La expresión EXPR y el resultado deben poder ser escritos como productos de potencias enteras, factoriales, coeficientes binomiales y funciones racionales.

     Los términos suma "definida" e "indefinida" se usan de forma análoga a integración "definida" e "indefinida". La suma indefinida significa dar un resultado simbólico.

     Las funciones nusum y unsum disponen de cierta información sobre sumas y diferencias de productos finitos. Véase también unsum.

     Ejemplos:

          (%i1) nusum (n*n!, n, 0, n);

          Dependent equations eliminated:  (1)
          (%o1)                     (n + 1)! - 1
          (%i2) nusum (n^4*4^n/binomial(2*n,n), n, 0, n);
                               4        3       2              n
                2 (n + 1) (63 n  + 112 n  + 18 n  - 22 n + 3) 4      2
          (%o2) ------------------------------------------------ - ------
                              693 binomial(2 n, n)                 3 11 7
          (%i3) unsum (%, n);
                                        4  n
                                       n  4
          (%o3)                   ----------------
                                  binomial(2 n, n)
          (%i4) unsum (prod (i^2, i, 1, n), n);
                              n - 1
                              /===\
                               ! !   2
          (%o4)              ( ! !  i ) (n - 1) (n + 1)
                               ! !
                              i = 1
          (%i5) nusum (%, n, 1, n);

          Dependent equations eliminated:  (2 3)
                                      n
                                    /===\
                                     ! !   2
          (%o5)                      ! !  i  - 1
                                     ! !
                                    i = 1

 -- Función: pade (TAYLOR_SERIES, NUMER_DEG_BOUND, DENOM_DEG_BOUND)
     Devuelve la lista de todas las funciones racionales que tienen el desarrollo de Taylor dado, en las que la suma de los grados del numerador y denominador es menor o igual que el nivel de truncamiento de la serie de potencias.

     La expresión TAYLOR_SERIES es una serie de Taylor univariante. Los argumentos NUMER_DEG_BOUND y DENOM_DEG_BOUND son enteros positivos que indican las cotas para numerador y denominador.

     La expresión TAYLOR_SERIES también puede ser una serie de Laurent, y las cotas de los grados pueden ser inf. El grado total se define como NUMER_DEG_BOUND + DENOM_DEG_BOUND. La longitud de una serie de potencias se define como "truncation level" + 1 - min(0, "order of series").

          (%i1) taylor (1 + x + x^2 + x^3, x, 0, 3);
                                        2    3
          (%o1)/T/             1 + x + x  + x  + . . .
          (%i2) pade (%, 1, 1);
                                           1
          (%o2)                       [- -----]
                                         x - 1
          (%i3) t: taylor(-(83787*x^10 - 45552*x^9 - 187296*x^8
                             + 387072*x^7 + 86016*x^6 - 1507328*x^5
                             + 1966080*x^4 + 4194304*x^3 - 25165824*x^2
                             + 67108864*x - 134217728)
                 /134217728, x, 0, 10);
                              2    3       4       5       6        7
                       x   3 x    x    15 x    23 x    21 x    189 x
          (%o3)/T/ 1 - - + ---- - -- - ----- + ----- - ----- - ------
                       2    16    32   1024    2048    32768   65536

                                            8         9          10
                                      5853 x    2847 x    83787 x
                                    + ------- + ------- - --------- + . . .
                                      4194304   8388608   134217728
          (%i4) pade (t, 4, 4);
          (%o4)                          []

     No hay ninguna función racional de grado 4 en numerador y denominador con este desarrollo en serie de potencias. Es necesario dar un número de grados al numerador y denominador cuya suma sea al menos el grado del desarrollo de la serie, a fin de disponer de un número suficiente de coeficientes desconocidos para calcular.

          (%i5) pade (t, 5, 5);
                               5                4                 3
          (%o5) [- (520256329 x  - 96719020632 x  - 489651410240 x

                            2
           - 1619100813312 x  - 2176885157888 x - 2386516803584)

                         5                 4                  3
          /(47041365435 x  + 381702613848 x  + 1360678489152 x

                            2
           + 2856700692480 x  + 3370143559680 x + 2386516803584)]

 -- Variable opcional: powerdisp
     Valor por defecto: false

     Si powerdisp vale true, se muestran las sumas con sus términos ordenados de menor a mayor potencia. Así, un polinomio se presenta como una serie de potencias truncada con el término constante al principio y el de mayor potencia al final.

     Por defecto, los términos de una suma se muestran en el orden de las potencias decrecientes.

 -- Función: powerseries (EXPR, X, A)
     Devuelve la forma general del desarrollo en serie de potencias de EXPR para la variable X alrededor del punto A (que puede ser inf, de infinito).

     Si powerseries no es capaz de desarrollar EXPR, la función taylor puede calcular los primeros términos de la serie.

     Si verbose vale true, powerseries va mostrando mensajes mientras progresa el cálculo.

          (%i1) verbose: true$
          (%i2) powerseries (log(sin(x)/x), x, 0);
          can't expand
                                           log(sin(x))
          so we'll try again after applying the rule:
                                                  d
                                                / -- (sin(x))
                                                [ dx
                                  log(sin(x)) = i ----------- dx
                                                ]   sin(x)
                                                /
          in the first simplification we have returned:
                                       /
                                       [
                                       i cot(x) dx - log(x)
                                       ]
                                       /
                              inf
                              ====        i1  2 i1             2 i1
                              \      (- 1)   2     bern(2 i1) x
                               >     ------------------------------
                              /                i1 (2 i1)!
                              ====
                              i1 = 1
          (%o2)                -------------------------------------
                                                2

 -- Variable opcional: psexpand
     Valor por defecto: false

     Si psexpand vale true, toda expresi'on racional se muestra completamente expandida. La variable ratexpand tiene el mismo efecto.

     Si psexpand vale false, las expresines multivariantes se presentan tal como lo hace el paquete de funciones racionales.

     Si psexpand vale  multi, los términos de igual grado son agrupados.

 -- Función: revert (EXPR, X)
 -- Función: revert2 (EXPR, X, N)

     Estas funciones devuelven el recíproco de EXPR en forma de desarrollo de Taylor alrededor de cero respecto de la variable X. La función revert devuelve un polinomio de grado igual a la mayor potencia en EXPR. La función revert2 devuelve un polinomio de grado N, el cual puede ser mayor, igual o menor que el grado de  EXPR.

     Para utilizar estas funciones es necesario cargarlas en memoria mediante load ("revert").

     Ejemplos:

          (%i1) load ("revert")$
          (%i2) t: taylor (exp(x) - 1, x, 0, 6);
                             2    3    4    5     6
                            x    x    x    x     x
          (%o2)/T/      x + -- + -- + -- + --- + --- + . . .
                            2    6    24   120   720
          (%i3) revert (t, x);
                         6       5       4       3       2
                     10 x  - 12 x  + 15 x  - 20 x  + 30 x  - 60 x
          (%o3)/R/ - --------------------------------------------
                                          60
          (%i4) ratexpand (%);
                               6    5    4    3    2
                              x    x    x    x    x
          (%o4)             - -- + -- - -- + -- - -- + x
                              6    5    4    3    2
          (%i5) taylor (log(x+1), x, 0, 6);
                              2    3    4    5    6
                             x    x    x    x    x
          (%o5)/T/       x - -- + -- - -- + -- - -- + . . .
                             2    3    4    5    6
          (%i6) ratsimp (revert (t, x) - taylor (log(x+1), x, 0, 6));
          (%o6)                           0
          (%i7) revert2 (t, x, 4);
                                    4    3    2
                                   x    x    x
          (%o7)                  - -- + -- - -- + x
                                   4    3    2

 -- Función: taylor (EXPR, X, A, N)
 -- Función: taylor (EXPR, [X_1, X_2, ...], A, N)
 -- Función: taylor (EXPR, [X, A, N, 'asymp])
 -- Función: taylor (EXPR, [X_1, X_2, ...], [A_1, A_2, ...], [N_1, N_2, ...])
 -- Función: taylor (EXPR, [X_1, A_1, N_1], [X_2, A_2, N_2], ...)

     La llamada taylor (EXPR, X, A, N) expande la expresión EXPR en un desarrollo  de Taylor o de  Laurent respecto de la variable X alrededor del punto A, con términos hasta (X - A)^N.

     Si EXPR es de la forma F(X)/G(X) y G(X) no tiene términos hasta de grado N, entonces taylor intenta expandir G(X) hasta el grado  2 N. Si aún así no hay términos no nulos, taylor dobla el grado de la expansión de G(X) hasta que el grado de la expansión sea menor o igual que N 2^taylordepth.

     La llamada taylor (EXPR, [X_1, X_2, ...], A, N) devuelve la serie en potencias truncada de grado  N en todas las variables X_1, X_2, ... alrededor del punto (A, A, ...).

     La llamada taylor (EXPR, [X_1, A_1, N_1], [X_2, A_2, N_2], ...) devuelve la serie en potencias truncada en las variables X_1, X_2, ... alrededor del punto (A_1, A_2, ...); el truncamiento se realiza, respectivamente, en los grados N_1, N_2, ....

     La llamada taylor (EXPR, [X_1, X_2, ...], [A_1, A_2, ...], [N_1, N_2, ...]) devuelve la serie en potencias truncada en las variables X_1, X_2, ... alrededor del punto (A_1, A_2, ...), el truncamiento se realiza, respectivamente, en los grados N_1, N_2, ....

     La llamada taylor (EXPR, [X, A, N, 'asymp]) devuelve el desarrollo de  EXPR en potencias negativas de X - A. El término de mayor orden es (X - A)^-N.

     Si maxtayorder vale true, entonces durante la manipulación algebraica de las series (truncadas) de Taylor, la función taylor intenta mantener tantos términos correctos como sea posible.

     Si psexpand vale true, una expresión racional desarrollada se muestra completamente expandida. La variable  ratexpand tiene el mismo efecto. Si psexpand vale false, una expresión multivariante se mostrará tal como lo hace el paquete de funciones racionales. Si  psexpand vale  multi, los términos del mismo grado son agrupados.

     Véase también la variable taylor_logexpand para el control del desarrollo.

     Ejemplos:

          (%i1) taylor (sqrt (sin(x) + a*x + 1), x, 0, 3);
                                     2             2
                       (a + 1) x   (a  + 2 a + 1) x
          (%o1)/T/ 1 + --------- - -----------------
                           2               8

                                             3      2             3
                                         (3 a  + 9 a  + 9 a - 1) x
                                       + -------------------------- + . . .
                                                     48
          (%i2) %^2;
                                              3
                                             x
          (%o2)/T/           1 + (a + 1) x - -- + . . .
                                             6
          (%i3) taylor (sqrt (x + 1), x, 0, 5);
                                 2    3      4      5
                            x   x    x    5 x    7 x
          (%o3)/T/      1 + - - -- + -- - ---- + ---- + . . .
                            2   8    16   128    256
          (%i4) %^2;
          (%o4)/T/                  1 + x + . . .
          (%i5) product ((1 + x^i)^2.5, i, 1, inf)/(1 + x^2);
                                   inf
                                  /===\
                                   ! !    i     2.5
                                   ! !  (x  + 1)
                                   ! !
                                  i = 1
          (%o5)                   -----------------
                                        2
                                       x  + 1
          (%i6) ev (taylor(%, x,  0, 3), keepfloat);
                                         2           3
          (%o6)/T/    1 + 2.5 x + 3.375 x  + 6.5625 x  + . . .
          (%i7) taylor (1/log (x + 1), x, 0, 3);
                                         2       3
                           1   1   x    x    19 x
          (%o7)/T/         - + - - -- + -- - ----- + . . .
                           x   2   12   24    720
          (%i8) taylor (cos(x) - sec(x), x, 0, 5);
                                          4
                                     2   x
          (%o8)/T/                - x  - -- + . . .
                                         6
          (%i9) taylor ((cos(x) - sec(x))^3, x, 0, 5);
          (%o9)/T/                    0 + . . .
          (%i10) taylor (1/(cos(x) - sec(x))^3, x, 0, 5);
                                                         2          4
                      1     1       11      347    6767 x    15377 x
          (%o10)/T/ - -- + ---- + ------ - ----- - ------- - --------
                       6      4        2   15120   604800    7983360
                      x    2 x    120 x

                                                                    + . . .
          (%i11) taylor (sqrt (1 - k^2*sin(x)^2), x, 0, 6);
                         2  2       4      2   4
                        k  x    (3 k  - 4 k ) x
          (%o11)/T/ 1 - ----- - ----------------
                          2            24

                                              6       4       2   6
                                         (45 k  - 60 k  + 16 k ) x
                                       - -------------------------- + . . .
                                                    720
          (%i12) taylor ((x + 1)^n, x, 0, 4);
                                2       2     3      2         3
                              (n  - n) x    (n  - 3 n  + 2 n) x
          (%o12)/T/ 1 + n x + ----------- + --------------------
                                   2                 6

                                         4      3       2         4
                                       (n  - 6 n  + 11 n  - 6 n) x
                                     + ---------------------------- + . . .
                                                    24
          (%i13) taylor (sin (y + x), x, 0, 3, y, 0, 3);
                         3                 2
                        y                 y
          (%o13)/T/ y - -- + . . . + (1 - -- + . . .) x
                        6                 2

                              3                       2
                         y   y            2      1   y            3
                    + (- - + -- + . . .) x  + (- - + -- + . . .) x  + . . .
                         2   12                  6   12
          (%i14) taylor (sin (y + x), [x, y], 0, 3);
                               3        2      2      3
                              x  + 3 y x  + 3 y  x + y
          (%o14)/T/   y + x - ------------------------- + . . .
                                          6
          (%i15) taylor (1/sin (y + x), x, 0, 3, y, 0, 3);
                    1   y              1    1               1            2
          (%o15)/T/ - + - + . . . + (- -- + - + . . .) x + (-- + . . .) x
                    y   6               2   6                3
                                       y                    y

                                                     1            3
                                                + (- -- + . . .) x  + . . .
                                                      4
                                                     y
          (%i16) taylor (1/sin (y + x), [x, y], 0, 3);
                                       3         2       2        3
                      1     x + y   7 x  + 21 y x  + 21 y  x + 7 y
          (%o16)/T/ ----- + ----- + ------------------------------- + . . .
                    x + y     6                   360

 -- Variable opcional: taylordepth
     Valor por defecto: 3

     Si todavía no hay términos no nulos, la función taylor dobla el grado del desarrollo de G(X) tantas veces como sea necesario para que el grado del desarrollo sea menor o igual que N 2^taylordepth.

 -- Función: taylorinfo (EXPR)
     Devuelve información sobre el desarrollo de Taylor EXPR. El valor devuelto por esta función es una lista de listas. Cada lista contiene el nombre de una variable, el punto de expansión y el grado del desarrollo.

     La función taylorinfo devuelve false si EXPR no es un desarrollo de Taylor.

     Ejemplo:

          (%i1) taylor ((1 - y^2)/(1 - x), x, 0, 3, [y, a, inf]);
                            2                       2
          (%o1)/T/ - (y - a)  - 2 a (y - a) + (1 - a )

                   2                        2
           + (1 - a  - 2 a (y - a) - (y - a) ) x

                   2                        2   2
           + (1 - a  - 2 a (y - a) - (y - a) ) x

                   2                        2   3
           + (1 - a  - 2 a (y - a) - (y - a) ) x  + . . .
          (%i2) taylorinfo(%);
          (%o2)               [[y, a, inf], [x, 0, 3]]

 -- Función: taylorp (EXPR)
     Devuelve true si EXPR es un desarrollo de Taylor y false en caso contrario.

 -- Variable opcional: taylor_logexpand
     Valor por defecto: true

     La variable taylor_logexpand controla los desarrollos de logaritmos en la función taylor.

     Si taylor_logexpand vale true, todos los logaritmos se expanden completamente de manera que algunos problemas que se plantean debido a ciertas identidades logarítmicas no interfieran con el proceso del cálculo del desarrollo de Taylor. Sin embargo, este proceder no es del todo correcto.

 -- Variable opcional: taylor_order_coefficients
     Valor por defecto: true

     La variable taylor_order_coefficients controla la ordenación de los coeficientes en un desarrollo de Taylor.

     Si taylor_order_coefficients vale true, los coeficientes del desarrollo de Taylor se ordenan de la forma canónica.

 -- Función: taylor_simplifier (EXPR)
     Simplifica los coeficientes de la serie de potencias EXPR. Esta función es llamada desde la función taylor.

 -- Variable opcional: taylor_truncate_polynomials
     Valor por defecto: true

     Si taylor_truncate_polynomials vale true, los polinomios quedan truncados en base a los niveles de truncamiento de entrada.

     En otro caso, aquellos polinomios que se utilicen como entrada a la función  taylor se consideran que tienen precisión infinita.

 -- Función: taytorat (EXPR)
     Convierte EXPR del formato de taylor al formato CRE (Canonical Rational Expression). El efecto es el mismo que haciendo  rat (ratdisrep (EXPR)), pero más rápido.

 -- Función: trunc (EXPR)
     Devuelve la representación interna de la expresión EXPR de tal forma como si sus sumas fuesen una serie truncada de Taylor. La expresión EXPR no sufre ninguna otra modificación.

     Ejemplo:

          (%i1) expr: x^2 + x + 1;
                                      2
          (%o1)                      x  + x + 1
          (%i2) trunc (expr);
                                          2
          (%o2)                  1 + x + x  + . . .
          (%i3) is (expr = trunc (expr));
          (%o3)                         true

 -- Función: unsum (F, N)
     Devuelve la diferencia F(N) - F(N - 1). En cierto sentido unsum es la inversa de sum.

     Véase también nusum.

     Ejemplos:

          (%i1) g(p) := p*4^n/binomial(2*n,n);
                                               n
                                            p 4
          (%o1)               g(p) := ----------------
                                      binomial(2 n, n)
          (%i2) g(n^4);
                                        4  n
                                       n  4
          (%o2)                   ----------------
                                  binomial(2 n, n)
          (%i3) nusum (%, n, 0, n);
                               4        3       2              n
                2 (n + 1) (63 n  + 112 n  + 18 n  - 22 n + 3) 4      2
          (%o3) ------------------------------------------------ - ------
                              693 binomial(2 n, n)                 3 11 7
          (%i4) unsum (%, n);
                                        4  n
                                       n  4
          (%o4)                   ----------------
                                  binomial(2 n, n)

 -- Variable opcional: verbose
     Valor por defecto: false

     Si verbose vale true, la función powerseries va imprimiendo mensajes durante su ejecución.