[ < ] | [ > ] |  | [ << ] | [ Up ] | [ >> ] |  |  |  |  | [Top] | [Contents] | [Index] | [ ? ]

# 28. Sumas productos y series

[ < ] | [ > ] |  | [ << ] | [ Up ] | [ >> ] |  |  |  |  | [Top] | [Contents] | [Index] | [ ? ]

## 28.1 Funciones y variables para sumas y productos

Función: bashindices (expr)

  Transforma la expresión expr dándole a cada sumatorio y producto un único índice. Esto le da a `changevar` mayor precisión cuando opera con sumas y productos. La forma del único índice es `jnumber`. La cantidad number se determina en función de `gensumnum`, valor que puede cambiar el usuario. Por ejemplo, haciendo `gensumnum:0$`.

Función: lsum (expr, x, L)

  Representa la suma de expr para cada elemento x en L.

  Se retornará la forma nominal `'lsum` si el argumento L no es una lista.

  Ejemplos:

      (%i1) lsum (x^i, i, [1, 2, 7]);
                                  7    2
      (%o1)                      x  + x  + x
      (%i2) lsum (i^2, i, rootsof (x^3 - 1, x));
                           ====
                           \      2
      (%o2)                 >    i
                           /
                           ====
                                         3
                           i in rootsof(x  - 1, x)

Función: intosum (expr)

  Mueve los factores multiplicativos que están fuera de un sumatorio hacia dentro de éste. Si el índice del sumatorio aparece en la expresión exterior, entonces `intosum` busca un índice razonable, lo mismo que hace con `sumcontract`. Se trata de la operación contraria a extraer factores comunes de los sumatorios.

  En algunos caos puede ser necesario hacer `scanmap (multthru, expr)` antes que `intosum`.

  Ejemplo:

      (%i1) sum(2*x^2*n^k, k , 0, inf);
                                     inf
                                     ====
                                   2 \      k
      (%o1)                     2 x   >    n
                                     /
                                     ====
                                     k = 0
      (%i2) intosum(%);
                                inf
                                ====
                                \        k  2
      (%o2)                      >    2 n  x
                                /
                                ====
                                k = 0

Función: product (expr, i, i_0, i_1)

  Representa el producto de los valores de `expr` según el índice i varía de i_0 hasta i_1. La forma nominal `'product` se presenta en forma de letra pi mayúscula.

  La función `product` evalúa expr y los límites inferior y superior, i_0 y i_1, pero no evalúa el índice i.

  Si la diferencia entre los límites superior e inferior es un número entero, la expresión expr se evalúa para cada valor del índice i, siendo el resultado un producto en forma explícita.

  En caso contrario, el rango del índice no está definido, aplicándose entonces algunas reglas que permitan simplificar el producto. Cuando la variable global `simpproduct` valga `true`, se aplicarán reglas adicionales. En ciertos casos, la simplificación dará lugar a un resultado que ya no tenga el formato del producto; en caso contrario se devolverá una forma nominal `'product`.

  Véanse también `nouns` y `evflag`.

  Ejemplos:

      (%i1) product (x + i*(i+1)/2, i, 1, 4);
      (%o1)           (x + 1) (x + 3) (x + 6) (x + 10)
      (%i2) product (i^2, i, 1, 7);
      (%o2)                       25401600
      (%i3) product (a[i], i, 1, 7);
      (%o3)                 a  a  a  a  a  a  a
                             1  2  3  4  5  6  7
      (%i4) product (a(i), i, 1, 7);
      (%o4)          a(1) a(2) a(3) a(4) a(5) a(6) a(7)
      (%i5) product (a(i), i, 1, n);
                                   n
                                 /===\
                                  ! !
      (%o5)                       ! !  a(i)
                                  ! !
                                 i = 1
      (%i6) product (k, k, 1, n);
                                     n
                                   /===\
                                    ! !
      (%o6)                         ! !  k
                                    ! !
                                   k = 1
      (%i7) product (k, k, 1, n), simpproduct;
      (%o7)                          n!
      (%i8) product (integrate (x^k, x, 0, 1), k, 1, n);
                                   n
                                 /===\
                                  ! !    1
      (%o8)                       ! !  -----
                                  ! !  k + 1
                                 k = 1
      (%i9) product (if k <= 5 then a^k else b^k, k, 1, 10);
                                    15  40
      (%o9)                        a   b

Variable opcional: simpsum

  Valor por defecto: `false`

  Si `simpsum` vale `true`, se simplifica el resultado de un sumatorio `sum`. Esta simplificación podrá producir en ocasiones una expresión compacta. Si `simpsum` vale `false` o si se utiliza la forma apostrofada `'sum`, el valor es una forma nominal que representa la notación sigma habitual en matemáticas.

Función: sum (expr, i, i_0, i_1)

  Representa la suma de los valores de `expr` según el índice i varía de i_0 hasta i_1. La forma nominal `'sum` se presenta en forma de letra sigma mayúscula.

  La función `sum` evalúa su sumando expr y los límites inferior y superior, i_0 y i_1, pero no evalúa el índice i.

  Si la diferencia entre los límites superior e inferior es un número entero, el sumando expr se evalúa para cada valor del índice i, siendo el resultado una suma en forma explícita.

  En caso contrario, el rango del índice no está definido, aplicándose entonces algunas reglas que permitan simplificar la suma. Cuando la variable global `simpsum` valga `true`, se aplicarán reglas adicionales. En ciertos casos, la simplificación dará lugar a un resultado que ya no tenga el formato del sumatorio; en caso contrario se devolverá una forma nominal `'product`.

  Cuando `cauchysum` vale `true`, el producto de sumatorios se expresa como un producto de Cauchy, en cuyo caso el índice del sumatorio interior es función del índice del exterior, en lugar de variar independientemente.

  La variable global `genindex` guarda el prefijo alfabético a utilizar cuando sea necesario generar automáticamente el siguiente índice de sumatorio.

  La variable global `gensumnum` guarda el sufijo numérico a utilizar cuando sea necesario generar automáticamente el siguiente índice de sumatorio. Si `gensumnum` vale `false`, un índice generado automáticamente constará sólo de `genindex`, sin sufijo numérico.

  Véanse también `sumcontract`, `intosum`, `bashindices`, `niceindices`, `nouns` y `evflag`.

  Ejemplos:

      (%i1) sum (i^2, i, 1, 7);
      (%o1)                          140
      (%i2) sum (a[i], i, 1, 7);
      (%o2)           a  + a  + a  + a  + a  + a  + a
                       7    6    5    4    3    2    1
      (%i3) sum (a(i), i, 1, 7);
      (%o3)    a(7) + a(6) + a(5) + a(4) + a(3) + a(2) + a(1)
      (%i4) sum (a(i), i, 1, n);
                                  n
                                 ====
                                 \
      (%o4)                       >    a(i)
                                 /
                                 ====
                                 i = 1
      (%i5) sum (2^i + i^2, i, 0, n);
                                n
                               ====
                               \       i    2
      (%o5)                     >    (2  + i )
                               /
                               ====
                               i = 0
      (%i6) sum (2^i + i^2, i, 0, n), simpsum;
                                    3      2
                         n + 1   2 n  + 3 n  + n
      (%o6)             2      + --------------- - 1
                                        6
      (%i7) sum (1/3^i, i, 1, inf);
                                  inf
                                  ====
                                  \     1
      (%o7)                        >    --
                                  /      i
                                  ====  3
                                  i = 1
      (%i8) sum (1/3^i, i, 1, inf), simpsum;
                                      1
      (%o8)                           -
                                      2
      (%i9) sum (i^2, i, 1, 4) * sum (1/i^2, i, 1, inf);
                                    inf
                                    ====
                                    \     1
      (%o9)                      30  >    --
                                    /      2
                                    ====  i
                                    i = 1
      (%i10) sum (i^2, i, 1, 4) * sum (1/i^2, i, 1, inf), simpsum;
                                        2
      (%o10)                       5 %pi
      (%i11) sum (integrate (x^k, x, 0, 1), k, 1, n);
                                  n
                                 ====
                                 \       1
      (%o11)                      >    -----
                                 /     k + 1
                                 ====
                                 k = 1
      (%i12) sum (if k <= 5 then a^k else b^k, k, 1, 10));
                10    9    8    7    6    5    4    3    2
      (%o12)   b   + b  + b  + b  + b  + a  + a  + a  + a  + a

Función: sumcontract (expr)

  Combina todos los sumatorios de una suma cuyos límites inferiores y superiores difieren por constantes. El resultado es una expresión que contiene un sumatorio por cada conjunto de tales sumatorios, más todos los demás términos adicionales que tuvieron que extraerse para formar la suma. La función `sumcontract` combina todos los sumatorios compatibles y utiliza uno de los índices de uno de los sumatorios si puede, si no formará un índice que sea razonable.

  Puede ser necesario hacer `intosum (expr)` antes que `sumcontract`.

  Ejemplo:

      (%i1) 'sum(1/l,l,1,n)+'sum(k,k,1,n+2);
                               n        n + 2
                              ====      ====
                              \     1   \
      (%o1)                    >    - +  >    k
                              /     l   /
                              ====      ====
                              l = 1     k = 1
      (%i2) sumcontract(%);
                                  n
                                 ====
                                 \          1
      (%o2)                2 n +  >    (l + -) + 3
                                 /          l
                                 ====
                                 l = 1

Variable opcional: sumexpand

  Valor por defecto: `false`

  Si `sumexpand` vale `true`, productos de sumatorios y de sumatorios con exponentes se reducen a sumatorios anidados.

  Véase también `cauchysum`.

  Ejemplos:

      (%i1) sumexpand: true$
      (%i2) sum (f (i), i, 0, m) * sum (g (j), j, 0, n);
                           m      n
                          ====   ====
                          \      \
      (%o2)                >      >     f(i1) g(i2)
                          /      /
                          ====   ====
                          i1 = 0 i2 = 0
      (%i3) sum (f (i), i, 0, m)^2;
                           m      m
                          ====   ====
                          \      \
      (%o3)                >      >     f(i3) f(i4)
                          /      /
                          ====   ====
                          i3 = 0 i4 = 0

[ < ] | [ > ] |  | [ << ] | [ Up ] | [ >> ] |  |  |  |  | [Top] | [Contents] | [Index] | [ ? ]

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

[ < ] | [ > ] |  | [ << ] | [ Up ] | [ >> ] |  |  |  |  | [Top] | [Contents] | [Index] | [ ? ]

## 28.3 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)]

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

                 inf
                 ====
                 \               n
                  >    b  (x - a)
                 /      n
                 ====
                 n = 0

  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.

[ < ] | [ > ] |  | [ << ] | [ Up ] | [ >> ] |  |  |  |  | [Top] | [Contents] | [Index] | [ ? ]

## 28.4 Introducción a las series de Fourier

El paquete `fourie` contiene funciones para el cálculo simbólico de series de Fourier. Hay funciones en el paquete `fourie` para calcular los coeficientes y para manipular las expresiones.

[ < ] | [ > ] |  | [ << ] | [ Up ] | [ >> ] |  |  |  |  | [Top] | [Contents] | [Index] | [ ? ]

## 28.5 Funciones y variables para series de Fourier

Función: equalp (x, y)

  Devuelve `true` si `equal (x, y)`, en otro caso devuelve `false`. No devuelve el mensaje de error que se obtiene de `equal (x, y)` en un caso como éste.

Función: remfun (f, expr)
Función: remfun (f, expr, x)

  La llamada `remfun (f, expr)` reemplaza todas las subexpresiones `f (arg)` por arg en expr.

  La llamada `remfun (f, expr, x)` reemplaza todas las subexpresiones `f (arg)` por arg en expr sólo si arg contiene a la variable x.

Función: funp (f, expr)
Función: funp (f, expr, x)

  La llamada `funp (f, expr)` devuelve `true` si expr contiene la función f.

  La llamada `funp (f, expr, x)` devuelve `true` si expr contiene la función f y la variable x está presente en el argumento de alguna de las presencias de f.

Función: absint (f, x, halfplane)
Función: absint (f, x)
Función: absint (f, x, a, b)

  La llamada `absint (f, x, halfplane)` devuelve la integral indefinida de f con respecto a x en el semiplano dado (`pos`, `neg` o `both`). La función f puede contener expresiones de la forma `abs (x)`, `abs (sin (x))`, `abs (a) * exp (-abs (b) * abs (x))`.

  La llamada `absint (f, x)` equivale a `absint (f, x, pos)`.

  La llamada `absint (f, x, a, b)` devuelve la integral definida de f con respecto a x de a a b.

Función: fourier (f, x, p)

  Devuelve una lista con los coeficientes de Fourier de `f(x)` definida en el intervalo `[-p, p]`.

Función: foursimp (l)

  Simplifica `sin (n %pi)` a 0 si `sinnpiflag` vale `true` y `cos (n %pi)` a `(-1)^n` si `cosnpiflag` vale `true`.

Variable opcional: sinnpiflag

  Valor por defecto: `true`

  Véase `foursimp`.

Variable opcional: cosnpiflag

  Valor por defecto: `true`

  Véase `foursimp`.

Función: fourexpand (l, x, p, limit)

  Calcula y devuelve la serie de Fourier a partir de la lista de los coeficientes de Fourier l hasta el término limit (limit puede ser `inf`). Los argumentos x y p tienen el mismo significado que en `fourier`.

Función: fourcos (f, x, p)

  Devuelve los coeficientes de los cosenos de Fourier de `f(x)` definida en `[0, p]`.

Función: foursin (f, x, p)

  Devuelve los coeficientes de los senos de Fourier de `f(x)` definida en `[0, p]`.

Función: totalfourier (f, x, p)

  Devuelve `fourexpand (foursimp (fourier (f, x, p)), x, p, 'inf)`.

Función: fourint (f, x)

  Calcula y devuelve la lista de los coeficientes integrales de Fourier de `f(x)` definida en `[minf, inf]`.

Función: fourintcos (f, x)

  Devuelve los coeficientes integrales de los cosenos `f(x)` en `[0, inf]`.

Función: fourintsin (f, x)

  Devuelve los coeficientes integrales de los senos `f(x)` en `[0, inf]`.

[ < ] | [ > ] |  | [ << ] | [ Up ] | [ >> ] |  |  |  |  | [Top] | [Contents] | [Index] | [ ? ]

## 28.6 Funciones y variables para series de Poisson

Función: intopois (a)

  Convierte a en un codificado Poisson.

Función: outofpois (a)

  Convierte a desde codificado de Poisson a una representación general. Si a no está en forma de Poisson, `outofpois` hace la conversión, siendo entonces el valor retornado `outofpois (intopois (a))`. Esta función es un simplificador canónico para sumas de potencias de senos y cosenos.

Función: poisdiff (a, b)

  Deriva a con respecto a b. El argumento b debe aparecer sólo en los argumentos trigonométricos o sólo en los coeficientes.

Función: poisexpt (a, b)

  Idéntico a `intopois (a^b)`. El argumento b debe ser un entero positivo.

Función: poisint (a, b)

  Integra en un sentido restringido similar a `poisdiff`.

Variable optativa: poislim

  Valor por defecto: 5

  La variable `poislim` determina el dominio de los coeficientes en los argumentos de las funciones trigonométricas. El valor por defecto 5 corresponde al intervalo [-2^(5-1)+1,2^(5-1)], o [-15,16], pero puede reasignarse para [-2^(n-1)+1, 2^(n-1)].

Función: poismap (series, sinfn, cosfn)

  Aplica las funciones sinfn a los términos sinusoidales y las funciones cosfn a los cosenoidales de la serie de Poisson dada. Tanto sinfn como cosfn son funciones de dos argumentos, los cuales son un coeficiente y una parte trigonométrica de un término de la serie.

Función: poisplus (a, b)

  Idéntico a `intopois (a + b)`.

Función: poissimp (a)

  Convierte a en una serie de Poisson para a en su representación general.

Símbolo especial: poisson

  El símbolo `/P/` sigue a la etiqueta de las líneas que contienen expresiones que son series de Poisson.

Función: poissubst (a, b, c)

  Sustituye b por a en c, donde c es una serie de Poisson.

  (1) Si b es una de las variables u, v, w, x, y o z, entonces a debe ser una expresión lineal en esas variables (por ejemplo, `6*u + 4*v`).

  (2) Si b no es ninguna de esas variables, entonces a no puede contener tampoco a ninguna de ellas, ni senos, ni cosenos.

Función: poistimes (a, b)

  Idéntico a `intopois (a*b)`.

Función: printpois (a)

  Presenta una serie de Poisson en un formato legible. Conjuntamente con `outofpois`, si es necesario convertirá a primero en una codificación de Poisson.

[ << ] | [ >> ] |  |  |  |  |  | [Top] | [Contents] | [Index] | [ ? ]

This document was generated by Viktor T. Toth on septiembre, 27 2018 using texi2html 1.76.