@c /Series.texi/1.16/Sun Jan  7 05:49:50 2007/-ko/
@menu
* Introdução a Séries::      
* Definições para Séries::      
@end menu

@node Introdução a Séries, Definições para Séries, Séries, Séries
@section Introdução a Séries
Maxima contém funções @code{taylor} e @code{powerseries} (séries de potência) para encontrar as
séries de funções diferenciáveis.   Maxima também tem ferramentas  tais como @code{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 secção apresenta as variáveis globais que controlam a
expansão.
@c end concepts Series
@node Definições para Séries,  , Introdução a Séries, Séries
@section Definições para Séries

@defvr {Variável de opção} cauchysum
Valor por omissão: @code{false}

@c REPHRASE
Quando multiplicando adições jutas com @code{inf} como seus limites superiores,
se @code{sumexpand} for @code{true} e @code{cauchysum} for @code{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:

@example
(%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
@end example

@end defvr

@deffn {Função} deftaylor (@var{f_1}(@var{x_1}), @var{expr_1}, ..., @var{f_n}(@var{x_n}), @var{expr_n})
Para cada função @var{f_i} de uma variável @var{x_i}, 
@code{deftaylor} define @var{expr_i} como a séries de Taylor sobre zero.
@var{expr_i} é tipicamente um polinómio em @var{x_i} ou um somatório;
expressões mais gerais são aceitas por @code{deftaylor} sem reclamações.

@code{powerseries (@var{f_i}(@var{x_i}), @var{x_i}, 0)}
retorna as séries definidas por @code{deftaylor}.

@code{deftaylor} retorna uma lista das funções
@var{f_1}, ..., @var{f_n}.
@code{deftaylor} avalia seus argumentos.

Exemplo:

@example
(%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
@end example

@end deffn

@defvr {Variável de opção} maxtayorder
Valor por omissão: @code{true}

@c REPHRASE
Quando @code{maxtayorder} for @code{true}, durante a manipulação
algébrica de séries (truncadas) de Taylor, @code{taylor} tenta reter
tantos termos quantos forem conhecidos serem correctos.

@end defvr

@deffn {Função} niceindices (@var{expr})
Renomeia os índices de adições e produtos em @var{expr}.
@code{niceindices} tenta renomear cada índice para o valor de @code{niceindicespref[1]},
a menos que o nome apareça nas parcelas do somatório ou produtório,
nesses casos @code{niceindices} tenta
os elementos seguintes de @code{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
@code{niceindicespref[1]}, e.g., @code{i0}, @code{i1}, @code{i2}, ....

@code{niceindices} retorna uma expressão.
@code{niceindices} avalia seu argumento.

Exemplo:

@example
(%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
@end example

@end deffn

@defvr {Variável de opção} niceindicespref
Valor por omissão: @code{[i, j, k, l, m, n]}

@code{niceindicespref} é a lista da qual @code{niceindices}
obtém os nomes dos índices de adições e produtos products.

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

Exemplo:

@example
(%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
@end example

@end defvr

@deffn {Função} nusum (@var{expr}, @var{x}, @var{i_0}, @var{i_1})
Realiza o somatório hipergeométrico indefinido de @var{expr} com
relação a @var{x} usando um procedimento de decisão devido a R.W. Gosper.
@var{expr} e o resultado deve ser expressável como produtos de expoentes inteiros,
factoriais, binomios, e funções recionais.

@c UMM, DO WE REALLY NEED TO DEFINE "DEFINITE" AND "INDEFINITE" SUMMATION HERE ??
@c (CAN'T WE MAKE THE POINT WITHOUT DRAGGING IN SOME NONSTANDARD TERMINOLOGY ??)
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, @code{nusum} não pode fazer isso.

@code{nusum} e @code{unsum} conhecem um porco sobre adições e subtrações de produtos finitos.
Veja também @code{unsum}.

Exemplos:

@example
(%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
@end example

@end deffn

@c THIS ITEM NEEDS SERIOUS WORK
@deffn {Função} pade (@var{taylor_series}, @var{numer_deg_bound}, @var{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.

@var{taylor_series} é uma séries de Taylor de uma variável.
@var{numer_deg_bound} e @var{denom_deg_bound}
são inteiros positivos especificando o grau associado sobre
o numerador e o denominador.

@var{taylor_series} podem também ser séries de Laurent, e o grau
associado pode ser @code{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 @code{@var{numer_deg_bound} + @var{denom_deg_bound}}.
O comprimento de séries de potência é definido como
@code{"nível de trncação" + 1 - min(0, "ordem das séries")}.

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

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 objectivo de ter disponível coeficientes desconhecidos para resolver.

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

@end deffn

@defvr {Variável de opção} powerdisp
Valor por omissão: @code{false}

Quando @code{powerdisp} for @code{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.

@c NEED AN EXAMPLE HERE
@end defvr

@deffn {Função} powerseries (@var{expr}, @var{x}, @var{a})
Retorna a forma geral expansão de séries de potência para @var{expr}
na variável @var{x} sobre o ponto @var{a} (o qual pode ser @code{inf} para infinito).

Se @code{powerseries} incapaz de expandir @var{expr},
@code{taylor} pode dar os primeiros muitos termos de séries.

Quando @code{verbose} for @code{true},
@code{powerseries} mostra mensagens de progresso. 

@example
(%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
@end example

@end deffn

@defvr {Variável de opção} psexpand
Valor por omissão: @code{false}

Quando @code{psexpand} for @code{true},
uma expressão função racional extendida é mostrada completamente expandida.
O comutador @code{ratexpand} tem o mesmo efeito.

@c WE NEED TO BE EXPLICIT HERE
Quando @code{psexpand} for @code{false},
uma expressão de várias variáveis é mostrada apenas como no pacote de função racional.

@c TERMS OF WHAT ??
Quando @code{psexpand} for  @code{multi},
então termos com o mesmo grau total nas variáveis são agrupados juntos.

@end defvr

@deffn {Função} revert (@var{expr}, @var{x})
@deffnx {Função} revert2 (@var{expr}, @var{x}, @var{n})
Essas funções retornam a reversão de @var{expr}, uma série de Taylor sobre zero na variável @var{x}.
@code{revert} retorna um polinómio de grau igual ao maior expoente em @var{expr}.
@code{revert2} retorna um polinómio de grau @var{n},
o qual pode ser maior que, igual a, ou menor que o grau de @var{expr}.

@code{load ("revert")} chama essas funções.

Exemplos:

@example
(%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
@end example

@end deffn

@deffn {Função} taylor (@var{expr}, @var{x}, @var{a}, @var{n})
@deffnx {Função} taylor (@var{expr}, [@var{x_1}, @var{x_2}, ...], @var{a}, @var{n})
@deffnx {Função} taylor (@var{expr}, [@var{x}, @var{a}, @var{n}, 'asymp])
@deffnx {Função} taylor (@var{expr}, [@var{x_1}, @var{x_2}, ...], [@var{a_1}, @var{a_2}, ...], [@var{n_1}, @var{n_2}, ...])
@deffnx {Função} taylor (@var{expr}, [@var{x_1}, @var{a_1}, @var{n_1}], [@var{x_2}, @var{a_2}, @var{n_2}], ...)
@code{taylor (@var{expr}, @var{x}, @var{a}, @var{n})} expande a expressão @var{expr}
em uma série truncada de Taylor ou de Laurent na variável @var{x}
em torno do ponto @var{a},
contendo termos até @code{(@var{x} - @var{a})^@var{n}}.

Se @var{expr} é da forma @code{@var{f}(@var{x})/@var{g}(@var{x})}
e @code{@var{g}(@var{x})} não possui de grau acima do grau @var{n}
então @code{taylor} tenta expandir @code{@var{g}(@var{x})} acima do gau @code{2 @var{n}}.
Se existe ainda termos não zero, @code{taylor} dobra o
grau de expansão de @code{@var{g}(@var{x})}
contanto que o grau da expansão o grau da expansão seja menor que ou igual a @code{@var{n} 2^taylordepth}.

@code{taylor (@var{expr}, [@var{x_1}, @var{x_2}, ...], @var{a}, @var{n})}
retorna uma série de potência truncada 
de grau @var{n} em todas as variáveis @var{x_1}, @var{x_2}, ...
sobre o ponto @code{(@var{a}, @var{a}, ...)}.

@code{taylor (@var{expr}, [@var{x_1}, @var{a_1}, @var{n_1}], [@var{x_2}, @var{a_2}, @var{n_2}], ...)}
retorna uma série de potência truncada nas variáveis @var{x_1}, @var{x_2}, ...
sobre o ponto @code{(@var{a_1}, @var{a_2}, ...)},
truncada em @var{n_1}, @var{n_2}, ....

@code{taylor (@var{expr}, [@var{x_1}, @var{x_2}, ...], [@var{a_1}, @var{a_2}, ...], [@var{n_1}, @var{n_2}, ...])}
retorna uma série de potência truncada nas variáveis @var{x_1}, @var{x_2}, ...
sobre o ponto @code{(@var{a_1}, @var{a_2}, ...)},
truncada em @var{n_1}, @var{n_2}, ....

@code{taylor (@var{expr}, [@var{x}, @var{a}, @var{n}, 'asymp])}
retorna uma expansão de @var{expr} em expoentes negativos de @code{@var{x} - @var{a}}.
O termo de maior ordem é @code{(@var{x} - @var{a})^@var{-n}}.

Quando @code{maxtayorder} for @code{true}, então durante maniplulação
algébrica da séries de Taylor (truncada), @code{taylor} tenta reter
tantos termos quantos forem conhecidos serem correctos.

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

Veja também o comutador @code{taylor_logexpand} para controlar a expansão.

Exemplos:
@c EXAMPLES ADAPTED FROM example (taylor)
@c taylor (sqrt (sin(x) + a*x + 1), x, 0, 3);
@c %^2;
@c taylor (sqrt (x + 1), x, 0, 5);
@c %^2;
@c product ((1 + x^i)^2.5, i, 1, inf)/(1 + x^2);
@c ev (taylor(%, x,  0, 3), keepfloat);
@c taylor (1/log (x + 1), x, 0, 3);
@c taylor (cos(x) - sec(x), x, 0, 5);
@c taylor ((cos(x) - sec(x))^3, x, 0, 5);
@c taylor (1/(cos(x) - sec(x))^3, x, 0, 5);
@c taylor (sqrt (1 - k^2*sin(x)^2), x, 0, 6);
@c taylor ((x + 1)^n, x, 0, 4);
@c taylor (sin (y + x), x, 0, 3, y, 0, 3);
@c taylor (sin (y + x), [x, y], 0, 3);
@c taylor (1/sin (y + x), x, 0, 3, y, 0, 3);
@c taylor (1/sin (y + x), [x, y], 0, 3);

@example
(%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
@end example

@end deffn

@defvr {Variável de opção} taylordepth
Valor por omissão: 3

@c UM, THE CONTEXT FOR THIS REMARK NEEDS TO BE ESTABLISHED
Se existem ainda termos não zero, @code{taylor} dobra o
grau da expansão de @code{@var{g}(@var{x})}
contanto que o grau da expansão seja menor que ou igual a @code{@var{n} 2^taylordepth}.

@end defvr

@deffn {Função} taylorinfo (@var{expr})
Retorna information about the séries de Taylor @var{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.

@code{taylorinfo} retorna @code{false} se @var{expr} não for uma séries de Taylor.

Exemplo:

@example
(%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]]
@end example

@end deffn

@deffn {Função} taylorp (@var{expr})
Retorna @code{true} se @var{expr} for uma séries de Taylor,
e @code{false} de outra forma.

@end deffn

@c WHAT IS THIS ABOUT EXACTLY ??
@defvr {Variável de opção} taylor_logexpand
Valor por omissão: @code{true}

@code{taylor_logexpand} controla expansão de logaritmos em
séries de @code{taylor}.

Quando @code{taylor_logexpand} for @code{true}, todos  logaritmos 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
matematicamente correcto uma vez que isso ignora informações de ramo.

Quando @code{taylor_logexpand} for escolhida para @code{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.

@c NEED EXAMPLES HERE
@end defvr

@defvr {Variável de opção} taylor_order_coefficients
Valor por omissão: @code{true}

@code{taylor_order_coefficients} controla a ordenação dos
coeficientes em uma série de Taylor.

Quando @code{taylor_order_coefficients} for @code{true},
coeficientes da séries de Taylor são ordenados canonicamente.
@c IS MAXIMA'S NOTION OF "CANONICALLY" DESCRIBED ELSEWHERE ??
@c AND WHAT HAPPENS WHEN IT IS FALSE ??

@c NEED EXAMPLES HERE
@end defvr

@deffn {Função} taylor_simplifier (@var{expr})
Simplifica coeficientes da séries  de potência @var{expr}.
@code{taylor} chama essa função.

@end deffn

@defvr {Variável de opção} taylor_truncate_polynomials
Valor por omissão: @code{true}

@c WHAT IS THE "INPUT TRUNCATION LEVEL" ?? THE ARGUMENT n OF taylor ??
Quando @code{taylor_truncate_polynomials} for @code{true},
polinómios são truncados baseados sobre a entrada de níveis de truncação.

De outra forma,
entrada de polinómios para @code{taylor} são consideradas terem precisão infinita.
@c WHAT IS "INFINITE PRECISION" IN THIS CONTEXT ??

@end defvr

@deffn {Função} taytorat (@var{expr})
Converte @var{expr} da forma @code{taylor} para a forma de expressão racional canónica (CRE).
O efeito é o mesmo que @code{rat (ratdisrep (@var{expr}))}, mas mais rápido.

@end deffn

@deffn {Função} trunc (@var{expr})
Coloca notas na representação interna da expressão geral @var{expr}
de modo que isso é mostrado como se suas adições forem séries de Taylor truncadas.
@var{expr} is not otherwise modified.

Exemplo:

@example
(%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
@end example

@end deffn

@deffn {Função} unsum (@var{f}, @var{n})
Retorna a primeira diferençã de trás para frente @code{@var{f}(@var{n}) - @var{f}(@var{n} - 1)}.
Dessa forma @code{unsum} logicamente é a inversa de @code{sum}.

Veja também @code{nusum}.

Exemplos:
@c GENERATED FROM THE FOLLOWING INPUTS
@c g(p) := p*4^n/binomial(2*n,n);
@c g(n^4);
@c nusum (%, n, 0, n);
@c unsum (%, n);

@example
(%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)
@end example

@end deffn

@defvr {Variável de opção} verbose
Valor por omissão: @code{false}

Quando @code{verbose} for @code{true},
@code{powerseries} mostra mensagens de progresso.

@end defvr

