Introducedilhaão a Séries
=========================

Maxima contém funcedilhaões taylor e powerseries (séries de potência) para encontrar as
séries de funcedilhaões diferenciáveis.   Maxima também tem ferramentas  tais como nusum
capazes de encontrar a forma fechada de algumas séries.   Operacedilhaões tais como adicedilhaão e multiplicacedilhaão travalham da forma usual sobre séries.  Essa secedilhaão apresenta as variáveis globais que controlam a
expansão.

Funcedilhaões e Variáveis Definidas para Séries
===============================================

 -- Variável de opcedilhaão: cauchysum
     Valor padrão: false

     Quando multiplicando adicedilhaões jutas com inf como seus limites superiores, se sumexpand for true e cauchysum for true então o produto de Cauchy será usado em lugar do produto usual. No produto de Cauchy o índice do somatório interno é uma funcedilhaão do índice do externo em lugar de variar independentemente.

     Exemplo:

          (%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

 -- Funcedilhaão: deftaylor (F_1(X_1), EXPR_1, ..., F_N(X_N), EXPR_N)
     Para cada funcedilhaão F_I de uma variável X_I, deftaylor define EXPR_I como a séries de Taylor sobre zero. EXPR_I é tipicamente um polinômio em X_I ou um somatório; expressões mais gerais são aceitas por deftaylor sem reclamacedilhaões.

     powerseries (F_I(X_I), X_I, 0) retorna as séries definidas por deftaylor.

     deftaylor retorna uma lista das funcedilhaões F_1, ..., F_N. deftaylor avalia seus argumentos.

     Exemplo:

          (%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

 -- Variável de opcedilhaão: maxtayorder
     Valor padrão: true

     Quando maxtayorder for true, durante a manipulacedilhaão algébrica de séries (truncadas) de Taylor, taylor tenta reter tantos termos quantos forem conhecidos serem corretos.

 -- Funcedilhaão: niceindices (EXPR)
     Renomeia os índices de adicedilhaões e produtos em EXPR. niceindices tenta renomear cada índice para o valor de niceindicespref[1], a menos que o nome aparecedilhaa nas parcelas do somatório ou produtório, nesses casos niceindices tenta os elementos seguintes de niceindicespref por sua vez, até que uma varável não usada unused variable seja encontrada. Se a lista inteira for exaurida, índices adicionais são constrídos através da anexaao de inteiros ao valor de niceindicespref[1], e.g., i0, i1, i2, ....

     niceindices retorna uma expressão. niceindices avalia seu argumento.

     Exemplo:

          (%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

 -- Variável de opcedilhaão: niceindicespref
     Valor padrão: [i, j, k, l, m, n]

     niceindicespref é a lista da qual niceindices pega os nomes dos índices de adicedilhaões e produtos products.

     Os elementos de niceindicespref são tipicamente nomes de variáveis, embora que não seja imposto por niceindices.

     Exemplo:

          (%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

 -- Funcedilhaão: nusum (EXPR, X, I_0, I_1)
     Realiza o somatório hipergeométrico indefinido de EXPR com relacedilhaão a X usando um procedimento de decisão devido a R.W. Gosper. EXPR e o resultado deve ser expressável como produtos de expoentes inteiros, fatoriais, binomios, e funcedilhaões recionais.

     Os termos "definido" and "e somatório indefinido" são usados analogamente a "definida" and "integracedilhaão indefinida". Adicionar indefinidamente significa dar um resultado simólico para a adicedilhaão sobre intervalos de comprimentos de variáveis, não apenas e.g. 0 a infinito.  Dessa forma, uma vez que não existe fórmula para a adicedilhaão parcial geral de séries binomiais, nusum não pode fazer isso.

     nusum e unsum conhecem um porco sobre adicedilhaões e subtracedilhaões de produtos finitos. Veja também unsum.

     Exemplos:

          (%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

 -- Funcedilhaão: pade (TAYLOR_SERIES, NUMER_DEG_BOUND, DENOM_DEG_BOUND)
     Retorna uma lista de todas as funcedilhaões racionais que possuem a dada expansão da séries de Taylor onde a adicedilhaão dos graus do numerador e do denominador é menor que ou igual ao nível de truncacedilhaão das séries de potência, i.e. são "melhores" aproximacedilhaões, e que adicionalmente satisfazem o grau especificado associado.

     TAYLOR_SERIES é uma séries de Taylor de uma variável. NUMER_DEG_BOUND e DENOM_DEG_BOUND são inteiros positivos especificando o grau associado sobre o numerador e o denominador.

     TAYLOR_SERIES podem também ser séries de Laurent, e o grau associado pode ser inf que acarreta todas funcedilhaões racionais cujo grau total for menor que ou igual ao comprimento das séries de potências a serem retornadas.  O grau total é definido como NUMER_DEG_BOUND + DENOM_DEG_BOUND. O comprimento de séries de potência é definido como "nível de trncacedilhaão" + 1 - min(0, "ordem das séries").

          (%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)                          []

     Não existe funcedilhaão racional de grau 4 numerador/denominador, com essa expansão de série de potência.  Você obrigatoriamente em geral tem grau do numerador e grau do denominador adicionando para cima ao menor grau das séries de potência, com o objetivo de ter disponível coeficientes desconhecidos para resolver.

          (%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)]

 -- Variável de opcedilhaão: powerdisp
     Valor padrão: false

     Quando powerdisp for true, uma adicedilhaão é mostrada com seus termos em ordem do crescimento do expoente. Dessa forma um polinômio é mostrado como séries de potências truncadas, com o termo constante primeiro e o maior expoente por último.

     Por padão, termos de uma adicedilhaão são mostrados em ordem do expoente decrescente.

 -- Funcedilhaão: powerseries (EXPR, X, A)
     Retorna a forma geral expansão de séries de potência para EXPR na variável X sobre o ponto A (o qual pode ser inf para infinito).

     Se powerseries incapaz de expandir EXPR, taylor pode dar os primeiros muitos termos de séries.

     Quando verbose for true, powerseries mostra mensagens de progresso.

          (%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

 -- Variável de opcedilhaão: psexpand
     Valor padrão: false

     Quando psexpand for true, uma expressão funcedilhaão racional extendida é mostrada completamente expandida. O comutador ratexpand tem o mesmo efeito.

     Quando psexpand for false, uma expressão de várias variáveis é mostrada apenas como no pacote de funcedilhaão racional.

     Quando psexpand for  multi, então termos com o mesmo grau total nas variáveis são agrupados juntos.

 -- Funcedilhaão: revert (EXPR, X)
 -- Funcedilhaão: revert2 (EXPR, X, N)
     Essas funcedilhaões retornam a reversão de EXPR, uma série de Taylor sobre zero na variável X. revert retorna um polinômio de grau igual ao maior expoente em EXPR. revert2 retorna um polinômio de grau N, o qual pode ser maior que, igual a, ou menor que o grau de EXPR.

     load ("revert") chama essas funcedilhaões.

     Exemplos:

          (%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

 -- Funcedilhaão: taylor (EXPR, X, A, N)
 -- Funcedilhaão: taylor (EXPR, [X_1, X_2, ...], A, N)
 -- Funcedilhaão: taylor (EXPR, [X, A, N, 'asymp])
 -- Funcedilhaão: taylor (EXPR, [X_1, X_2, ...], [A_1, A_2, ...], [N_1, N_2, ...])
 -- Funcedilhaão: taylor (EXPR, [X_1, A_1, N_1], [X_2, A_2, N_2], ...)
     taylor (EXPR, X, A, N) expande a expressão EXPR em uma série truncada de Taylor ou de Laurent na variável X em torno do ponto A, contendo termos até (X - A)^N.

     Se EXPR é da forma F(X)/G(X) e G(X) não possui de grau acima do grau N então taylor tenta expandir G(X) acima do gau 2 N. Se existe ainda termos não zero, taylor dobra o grau de expansão de G(X) contanto que o grau da expansão o grau da expansão seja menor que ou igual a N 2^taylordepth.

     taylor (EXPR, [X_1, X_2, ...], A, N) retorna uma série de potência truncada de grau N em todas as variáveis X_1, X_2, ... sobre o ponto (A, A, ...).

     taylor (EXPR, [X_1, A_1, N_1], [X_2, A_2, N_2], ...) retorna uma série de potência truncada nas variáveis X_1, X_2, ... sobre o ponto (A_1, A_2, ...), truncada em N_1, N_2, ....

     taylor (EXPR, [X_1, X_2, ...], [A_1, A_2, ...], [N_1, N_2, ...]) retorna uma série de potência truncada nas variáveis X_1, X_2, ... sobre o ponto (A_1, A_2, ...), truncada em N_1, N_2, ....

     taylor (EXPR, [X, A, N, 'asymp]) retorna uma expansão de EXPR em expoentes negativos de X - A. O termo de maior ordem é (X - A)^-N.

     Quando maxtayorder for true, então durante maniplulacedilhaão algébrica da séries de Taylor (truncada), taylor tenta reter tantos termos quantos forem conhecidos serem corretos.

     Quando psexpand for true, uma expressão de funcedilhaão racional extendida é mostrada completamente expandida. O comutador ratexpand tem o mesmo efeito. Quando psexpand for false, uma expressão de várias variáveis é mostrada apenas como no pacote de funcedilhaão racional. Quando psexpand for  multi, então os termos com o mesmo grau total nas variáveis são agrupados juntos.

     Veja também o comutador taylor_logexpand para controlar a expansão.

     Exemplos:

          (%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

 -- Variável de opcedilhaão: taylordepth
     Valor padrão: 3

     Se existem ainda termos não zero, taylor dobra o grau da expansão de G(X) contanto que o grau da expansão seja menor que ou igual a N 2^taylordepth.

 -- Funcedilhaão: taylorinfo (EXPR)
     Retorna information about the séries de Taylor EXPR. O valor de retorno é uma lista de listas. Cada lista compreende o nome de uma variável, o ponto de expansão, e o grau da expansão.

     taylorinfo retorna false se EXPR não for uma séries de Taylor.

     Exemplo:

          (%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]]

 -- Funcedilhaão: taylorp (EXPR)
     Retorna true se EXPR for uma séries de Taylor, e false de outra forma.

 -- Variável de opcedilhaão: taylor_logexpand
     Valor padrão: true

     taylor_logexpand controla expansão de logarítmos em séries de taylor.

     Quando taylor_logexpand for true, todos  logarítmos são expandidos completamente dessa forma problemas de reconhecimento de zero envolvendo envolvendo identidades logarítmicas não atrapalham o processo de expansão.  Todavia, esse esquema não é sempre maematicamente correto uma vez que isso ignora informacedilhaões de ramo.

     Quando taylor_logexpand for escolhida para false, então a expansão logarítmica que ocorre é somente aquela que for necessária para obter uma séries de potência formal.

 -- Variável de opcedilhaão: taylor_order_coefficients
     Valor padrão: true

     taylor_order_coefficients controla a ordenacedilhaão dos coeficientes em uma série de Taylor.

     Quando taylor_order_coefficients for true, coeficientes da séries de Taylor são ordenados canonicamente.

 -- Funcedilhaão: taylor_simplifier (EXPR)
     Simplifica coeficientes da séries  de potência EXPR. taylor chama essa funcedilhaão.

 -- Variável de opcedilhaão: taylor_truncate_polynomials
     Valor padrão: true

     Quando taylor_truncate_polynomials for true, polinômios são truncados baseados sobre a entrada de níveis de truncacedilhaão.

     De outra forma, entrada de polinômios para taylor são consideradas terem precisão infinita.

 -- Funcedilhaão: taytorat (EXPR)
     Converte EXPR da forma taylor para a forma de expressão racional canônica (CRE). O efeito é o mesmo que rat (ratdisrep (EXPR)), mas mais rápido.

 -- Funcedilhaão: trunc (EXPR)
     Coloca notas na representacedilhaão interna da expressão geral EXPR de modo que isso é mostrado como se suas adicedilhaões forem séries de Taylor truncadas. EXPR is not otherwise modified.

     Exemplo:

          (%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

 -- Funcedilhaão: unsum (F, N)
     Retorna a primeira diferencedilhaã de trás para frente F(N) - F(N - 1). Dessa forma unsum logicamente é a inversa de sum.

     Veja também nusum.

     Exemplos:

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

 -- Variável de opcedilhaão: verbose
     Valor padrão: false

     Quando verbose for true, powerseries mostra mensagens de progresso.