@c Language: Portuguese
@c /Logarithms.texi/1.16/Sat Jul  8 08:14:48 2006/-ko/
@menu
* Definições para Logaritmos::
@end menu

@node Definições para Logaritmos,  , Logaritmos, Logaritmos
@section Definições para Logaritmos

@defvr {Variável de opção} %e_to_numlog
Valor por omissã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, assim como algumas transformações mais
complicadas.  O comando @code{logcontract} @emph{contrai} expressões
contendo @code{log}.

@end defvr

@deffn {Função} li [@var{s}] (@var{z})
Representa a função polilogaritmo de ordem @var{s}
e argumento @var{z}, definida por meio da série infinita

@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 dilogaritmo e
trilogaritmo, respectivamente.

Quando a ordem for 1, o polilogaritmo 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 polilogaritmo 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 logaritmo natural (base @math{e}) de
@var{x}.

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

A simplificação e avaliação de logaritmos
são governadas por vários sinalizadores globais:

@code{logexpand} - faz com que @code{log(a^b)} se transfome em
@code{b*log(a)}. Se @code{logexpand} tiver o valor @code{all},
@code{log(a*b)} irá também simplificar para @code{log(a)+log(b)}.
Se @code{logexpand} for igual a @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
igaul a @code{false}, todas essas simplificações irão
ser desabilitadas.

@code{logsimp} - se tiver valor @code{false}, não será feita nenhuma
simplificação de @code{%e} para um expoente contendo
@code{log}'s.

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

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

@code{%e_to_numlog} - quando for igual a @code{true},
@code{%e^(r*log(x))}, sendo @code{r} algum número racional, e
@code{x} alguma expressão, será simplificado para
@code{x^r}. Note-se que o comando @code{radcan} também faz essa
transformação, e outras transformações mais complicadas
desse género.

O comando @code{logcontract} "contrai" expressões
contendo @code{log}.

@end deffn

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

No cálculo de primitivas em que sejam gerados
logaritmos, por exemplo, @code{integrate(1/x,x)}, a
resposta será 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 integrais definidos, usa-se
@code{logabs:true}, porque nesse caso muitas vezes é necessário
calcular a primitiva nos extremos.

@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 igual a @code{true}, as
funções trigononométricas inversas, circulares e
hiperbólicas, serão substituídas por suas
funções logarítmicas equivalentes. O valor
padrão de @code{logarc} é @code{false}.

A função @code{logarc(@var{expr})} realiza essa
substituiçã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 por omissão: @code{false}

Controla quais coeficientes são contraídos quando se
usa @code{logcontract}. Poderá ser igual ao nome de uma função
de um argumento. Por exemplo, se quiser gerar raízes
quadradas, pode fazer @code{logconcoeffp:'logconfun$
logconfun(m):=featurep(m,integer) or ratnump(m)$}. E assim,
@code{logcontract(1/2*log(x));} produzirá @code{log(sqrt(x))}.

@end defvr

@deffn {Função} logcontract (@var{expr})
Examina recursivamente 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 fizer @code{declare(n,integer);} então
@code{logcontract(2*a*n*log(x));} produzirá
@code{a*log(x^(2*n))}. Os coeficientes que @emph{contraem} dessa
maneira são os que, tal como 2 e @code{n} neste exemplo, satisfazem
@code{featurep(coeficiente,integer)}. O utilizador pode controlar
quais coeficientes são contraídos, dando à variável
@code{logconcoeffp} o nome de uma função de um argumento. Por
exemplo, se quiser gerar raízes quadradas, pode fazer
@code{logconcoeffp:'logconfun$ logconfun(m):=featurep(m,integer) or
ratnump(m)$}. E assim, @code{logcontract(1/2*log(x));} produzirá
@code{log(sqrt(x))}.


@end deffn

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

Faz com que @code{log(a^b)} se transfome em @code{b*log(a)}. Se
@code{logexpand} tiver o valor @code{all}, @code{log(a*b)} irá
também simplificar para @code{log(a)+log(b)}.  Se @code{logexpand}
for igual a @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 igaul a @code{false}, todas
essas simplificações irão ser desabilitadas.

@end defvr

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

Se for igual a @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 por omissão: @code{false}

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

@end defvr

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

Se tiver valor @code{false}, não será feita nenhuma
simplificação de @code{%e} para um expoente contendo
@code{log}'s.

@end defvr

@deffn {Função} plog (@var{x})
Representa o ramo principal dos logaritmos naturais no
plano complexo, com @code{-%pi} < @code{carg(@var{x})} <= @code{+%pi}.

@end deffn


