Funcedilhaões e Variáveis Definidas para Logarítmos
===================================================

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

     Quando true, sendo r algum número racional, e x alguma expressão, %e^(r*log(x)) será simplificado em x^r . Note-se que o comando radcan também faz essa transformacedilhaão, e transformacedilhaões mais complicadas desse tipo também. O comando logcontract "contrai" expressões contendo log.

 -- Funcedilhaão: li [S] (Z)
     Representa a funcedilhaão polilogarítmo de ordem S e argumento Z, definida por meio de séries infinitas

                                           inf
                                           ====   k
                                           \     z
                                  Li (z) =  >    --
                                    s      /      s
                                           ====  k
                                           k = 1

     li [1] é - log (1 - z). li [2] e li [3] são as funcedilhaões dilogarítmo e trilogarítmo, respectivamente.

     Quando a ordem for 1, o polilogarítmo simplifica para - log (1 - z), o qual por sua vez simplifica para um valor numérico se Z for um número em ponto flutuante real ou complexo ou o sinalizador de avaliacedilhaão numer estiver presente.

     Quando a ordem for 2 ou 3, o polilogarítmo simplifica para um valor numérico se Z for um número real em ponto flutuante ou o sinalizador de avaliacedilhaão numer estiver presente.

     Exemplos:

          (%i1) assume (x > 0);
          (%o1)                        [x > 0]
          (%i2) integrate ((log (1 - t)) / t, t, 0, x);
          (%o2)                       - li (x)
                                          2
          (%i3) li [2] (7);
          (%o3)                        li (7)
                                         2
          (%i4) li [2] (7), numer;
          (%o4)        1.24827317833392 - 6.113257021832577 %i
          (%i5) li [3] (7);
          (%o5)                        li (7)
                                         3
          (%i6) li [2] (7), numer;
          (%o6)        1.24827317833392 - 6.113257021832577 %i
          (%i7) L : makelist (i / 4.0, i, 0, 8);
          (%o7)   [0.0, 0.25, 0.5, 0.75, 1.0, 1.25, 1.5, 1.75, 2.0]
          (%i8) map (lambda ([x], li [2] (x)), L);
          (%o8) [0, .2676526384986274, .5822405249432515,
          .9784693966661848, 1.64493407, 2.190177004178597
           - .7010261407036192 %i, 2.374395264042415
           - 1.273806203464065 %i, 2.448686757245154
           - 1.758084846201883 %i, 2.467401098097648
           - 2.177586087815347 %i]
          (%i9) map (lambda ([x], li [3] (x)), L);
          (%o9) [0, .2584613953442624, 0.537213192678042,
          .8444258046482203, 1.2020569, 1.642866878950322
           - .07821473130035025 %i, 2.060877505514697
           - .2582419849982037 %i, 2.433418896388322
           - .4919260182322965 %i, 2.762071904015935
           - .7546938285978846 %i]

 -- Funcedilhaão: log (X)
     Representa o logarítmo natural (base e) de X.

     Maxima não possui uma funcedilhaão interna para logarítmo de base 10 ou de outras bases. log10(x) := log(x) / log(10) é uma definicedilhaão útil.

     Simplificacedilhaão e avaliacedilhaão de logarítmos são governadas por muitos sinalizadores globais:

     logexpand - faz com que log(a^b) torne-se b*log(a). Se logexpand for escolhida para all, log(a*b) irá também simplificar para log(a)+log(b). Se logexpand for escolhida para super, então log(a/b) irá também simplificar para log(a)-log(b) para números racionais a/b, a#1.  (log(1/b), para b inteiro, sempre simplifica).  Se logexpand for escolhida para false, todas essas simplificacedilhaões irão ser desabilitadas.

     logsimp - se false então nenhuma simplificacedilhaão de %e para um expoente contendo log's é concluída.

     lognumer - se true então argumentos negativos em ponto flutuante para log irá sempre ser convertido para seu valor absoluto antes que log seja tomado.  Se numer for também true, então argumentos negativos inteiros para log irão também ser convertidos para seu valor absoluto.

     lognegint - se true implementa a regra log(-n) -> log(n)+%i*%pi para n um inteiro positivo.

     %e_to_numlog - quando true, r sendo algum número racional, e x alguma expressão, %e^(r*log(x)) será simplificado em x^r .  Note-se que o comando radcan também faz essa transformacedilhaão, e transformacedilhaões mais complicadas desse tipo também. O comando logcontract "contrai" expressões contendo log.

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

     Quando fazendo integracedilhaão indefinida onde logs são gerados, e.g. integrate(1/x,x), a resposta é dada em termos de log(abs(...)) se logabs for true, mas em termos de log(...) se logabs for false.  Para integracedilhaão definida, a escolha logabs:true é usada, porque aqui "avaliacedilhaão" de integral indefinida nos extremos é muitas vezes necessária.

 -- Variável de opcedilhaão: logarc
 -- Funcedilhaão: logarc (EXPR)

     Quando a variável global logarc for true, funcedilhaões circulares inversas e funcedilhaões hiperbólicas serão convertidas em funcedilhaões logarítimicas equivalentes. O valor padrão de logarc é false.

     A funcedilhaão logarc(EXPR) realiza aquela substituícedilhaão para uma expressão EXPR sem modificar o valor da variável global logarc.

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

     Controla quais coeficientes são contraídos quando usando logcontract.  Pode ser escolhida para o nome de uma funcedilhaão predicado de um argumento.  E.g. se você gosta de gerar raízes quadradas, você pode fazer logconcoeffp:'logconfun$ logconfun(m):=featurep(m,integer) ou ratnump(m)$ .  Então logcontract(1/2*log(x)); irá fornecer log(sqrt(x)).

 -- Funcedilhaão: logcontract (EXPR)
     Recursivamente examina a expressão EXPR, transformando subexpressões da forma a1*log(b1) + a2*log(b2) + c em log(ratsimp(b1^a1 * b2^a2)) + c

          (%i1) 2*(a*log(x) + 2*a*log(y))$
          (%i2) logcontract(%);
                                           2  4
          (%o2)                     a log(x  y )

     Se você faz declare(n,integer); então logcontract(2*a*n*log(x)); fornece a*log(x^(2*n)).  Os coeficientes que "contraem" dessa maneira são aqueles tais que 2 e n que satisfazem featurep(coeff,integer).  O usuário pode controlar quais coeficientes são contraídos escolhendo a opcedilhaão logconcoeffp para o nome de uma funcedilhaão predicado de um argumento.  E.g. se você gosta de gerara raízes quadradas, você pode fazer logconcoeffp:'logconfun$ logconfun(m):=featurep(m,integer) ou ratnump(m)$ .  Então logcontract(1/2*log(x)); irá fornecer log(sqrt(x)).

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

     Faz com que log(a^b) torne-se b*log(a).  Se for escolhida para all, log(a*b) irá também simplificar para log(a)+log(b).  Se for escolhida para super, então log(a/b) irá também simplificar para log(a)-log(b) para números racionais a/b, a#1.  (log(1/b), para b inteiro, sempre simplifica).  Se for escolhida para false, todas essas simplificacedilhaões irão ser desabilitadas.

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

     Se true implementa a regra log(-n) -> log(n)+%i*%pi para n um inteiro positivo.

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

     Se true então argumentos negativos em ponto flutuante para log irão sempre ser convertidos para seus valores absolutos antes que o log seja tomado.  Se numer for também true, então argumentos inteiros negativos para log irão também ser convertidos para seus valores absolutos.

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

     Se false então nenhuma simplificacedilhaão de %e para um expoente contendo log's é concluída.

 -- Funcedilhaão: plog (X)
     Representa o principal ramo logarítmos naturais avaliados para complexos com -%pi < carg(X) <= +%pi .