@c Language: Brazilian Portuguese, Encoding: iso-8859-1
@c /Logarithms.texi/1.17/Sat Jun  2 00:12:55 2007/-ko/
@menu
* Funções e Variáveis Definidas para Logarítmos::
@end menu

@node Funções e Variáveis Definidas para Logarítmos,  , Logarítmos, Logarítmos
@section Funções e Variáveis Definidas para Logarítmos

@defvr {Variável de opção} %e_to_numlog
Valor padrão: @code{false}

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

@end defvr

@deffn {Função} li [@var{s}] (@var{z})
Representa a função polilogarítmo de ordem @var{s} e argumento @var{z},
definida por meio de séries infinitas

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

@code{li [1]} é @code{- log (1 - z)}.
@code{li [2]} e @code{li [3]} são as funções dilogarítmo e trilogarítmo, respectivamente.

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

Quando a ordem for 2 ou 3,
o polilogarítmo simplifica para um valor numérico
se @var{z} for um número real em ponto flutuante
ou o sinalizador de avaliação @code{numer} estiver presente.

Exemplos:

@c ===beg===
@c assume (x > 0);
@c integrate ((log (1 - t)) / t, t, 0, x);
@c li [2] (7);
@c li [2] (7), numer;
@c li [3] (7);
@c li [2] (7), numer;
@c L : makelist (i / 4.0, i, 0, 8);
@c map (lambda ([x], li [2] (x)), L);
@c map (lambda ([x], li [3] (x)), L);
@c ===end===
@example
(%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]
@end example

@end deffn

@deffn {Função} log (@var{x})
Representa o logarítmo natural (base @math{e}) de @var{x}.

Maxima não possui uma função interna para logarítmo de base 10 ou de outras bases.
@code{log10(x) := log(x) / log(10)} é uma definição útil.

Simplificação e avaliação de logarítmos são governadas por muitos sinalizadores globais:

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

@code{logsimp} - se @code{false} então nenhuma simplificação de @code{%e} para um expoente
contendo @code{log}'s é concluída.

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

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

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

@end deffn

@defvr {Variável de opção} logabs
Valor padrão: @code{false}

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

@end defvr

@c NEEDS EXAMPLES
@defvr {Variável de opção} logarc
@defvrx {Função} logarc (@var{expr})

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

A função @code{logarc(@var{expr})} realiza aquela substituíção para
uma expressão @var{expr}
sem modificar o valor da variável global @code{logarc}.

@end defvr

@defvr {Variável de opção} logconcoeffp
Valor padrão: @code{false}

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

@end defvr

@deffn {Função} logcontract (@var{expr})
Recursivamente examina a expressão @var{expr}, transformando
subexpressões da forma @code{a1*log(b1) + a2*log(b2) + c} em
@code{log(ratsimp(b1^a1 * b2^a2)) + c}

@c ===beg===
@c 2*(a*log(x) + 2*a*log(y))$
@c logcontract(%);
@c ===end===
@example
(%i1) 2*(a*log(x) + 2*a*log(y))$
(%i2) logcontract(%);
                                 2  4
(%o2)                     a log(x  y )

@end example

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

@end deffn

@defvr {Variável de opção} logexpand
Valor padrão: @code{true}

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

@end defvr

@defvr {Variável de opção} lognegint
Valor padrão: @code{false}

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

@end defvr

@defvr {Variável de opção} lognumer
Valor padrão: @code{false}

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

@end defvr

@defvr {Variável de opção} logsimp
Valor padrão: @code{true}

Se @code{false} então nenhuma simplificação de @code{%e} para um
expoente contendo @code{log}'s é concluída.

@end defvr

@deffn {Função} plog (@var{x})
Representa o principal ramo logarítmos naturais avaliados para
complexos com @code{-%pi} < @code{carg(@var{x})} <= @code{+%pi} .

@end deffn


