[ < ] [ > ]   [ << ] [ Up ] [ >> ]         [Top] [Contents] [Índice] [ ? ]

30. Séries


[ < ] [ > ]   [ << ] [ Up ] [ >> ]         [Top] [Contents] [Índice] [ ? ]

30.1 Introdução a Séries

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


[ < ] [ > ]   [ << ] [ Up ] [ >> ]         [Top] [Contents] [Índice] [ ? ]

30.2 Funções e Variáveis Definidas para Séries

Variável de opção: cauchysum

Valor padrão: false

Quando multiplicando adiçõ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 funçã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
Função: deftaylor (f_1(x_1), expr_1, ..., f_n(x_n), expr_n)

Para cada funçã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 reclamações.

powerseries (f_i(x_i), x_i, 0) retorna as séries definidas por deftaylor.

deftaylor retorna uma lista das funçõ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 opção: maxtayorder

Valor padrão: true

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

Função: niceindices (expr)

Renomeia os índices de adições e produtos em expr. niceindices tenta renomear cada índice para o valor de niceindicespref[1], a menos que o nome apareça 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 opção: niceindicespref

Valor padrão: [i, j, k, l, m, n]

niceindicespref é a lista da qual niceindices pega os nomes dos índices de adiçõ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
Função: nusum (expr, x, i_0, i_1)

Realiza o somatório hipergeométrico indefinido de expr com relaçã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 funções recionais.

Os termos "definido" and "e somatório indefinido" são usados analogamente a "definida" and "integração indefinida". Adicionar indefinidamente significa dar um resultado simólico para a adiçã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 adição parcial geral de séries binomiais, nusum não pode fazer isso.

nusum e unsum conhecem um porco sobre adições e subtraçõ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
Função: pade (taylor_series, numer_deg_bound, denom_deg_bound)

Retorna uma lista de todas as funções racionais que possuem a dada expansão da séries de Taylor onde a adição dos graus do numerador e do denominador é menor que ou igual ao nível de truncação das séries de potência, i.e. são "melhores" aproximaçõ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 funçõ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 trncaçã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 funçã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 opção: powerdisp

Valor padrão: false

Quando powerdisp for true, uma adiçã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 adição são mostrados em ordem do expoente decrescente.

Funçã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 opção: psexpand

Valor padrão: false

Quando psexpand for true, uma expressão funçã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 função racional.

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

Função: revert (expr, x)
Função: revert2 (expr, x, n)

Essas funçõ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 funçõ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
Função: taylor (expr, x, a, n)
Função: taylor (expr, [x_1, x_2, ...], a, n)
Função: taylor (expr, [x, a, n, 'asymp])
Função: taylor (expr, [x_1, x_2, ...], [a_1, a_2, ...], [n_1, n_2, ...])
Funçã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 maniplulaçã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 funçã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 funçã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 opçã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.

Funçã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]]
Função: taylorp (expr)

Retorna true se expr for uma séries de Taylor, e false de outra forma.

Variável de opçã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 informaçõ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 opção: taylor_order_coefficients

Valor padrão: true

taylor_order_coefficients controla a ordenaçã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.

Função: taylor_simplifier (expr)

Simplifica coeficientes da séries de potência expr. taylor chama essa função.

Variável de opçã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 truncação.

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

Funçã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.

Função: trunc (expr)

Coloca notas na representação interna da expressão geral expr de modo que isso é mostrado como se suas adiçõ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
Função: unsum (f, n)

Retorna a primeira diferençã 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 opção: verbose

Valor padrão: false

Quando verbose for true, powerseries mostra mensagens de progresso.


[ << ] [ >> ]           [Top] [Contents] [Índice] [ ? ]

This document was generated by Jaime Villate on Outubro, 14 2014 using texi2html 1.76.