@c Language: Brazilian Portuguese, Encoding: iso-8859-1
@c /Logarithms.texi/1.17/Sat Jun  2 00:12:55 2007/-ko/
@menu
* Fun@value{cedilha}@~{o}es e Vari@'{a}veis Definidas para Logar@'{i}tmos::
@end menu

@node Fun@value{cedilha}@~{o}es e Vari@'{a}veis Definidas para Logar@'{i}tmos,  , Logar@'{i}tmos, Logar@'{i}tmos
@section Fun@value{cedilha}@~{o}es e Vari@'{a}veis Definidas para Logar@'{i}tmos

@defvr {Vari@'{a}vel de op@value{cedilha}@~{a}o} %e_to_numlog
Valor padr@~{a}o: @code{false}

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

@end defvr

@deffn {Fun@value{cedilha}@~{a}o} li [@var{s}] (@var{z})
Representa a fun@value{cedilha}@~{a}o polilogar@'{i}tmo de ordem @var{s} e argumento @var{z},
definida por meio de s@'{e}ries infinitas

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

@code{li [1]} @'{e} @code{- log (1 - z)}.
@code{li [2]} e @code{li [3]} s@~{a}o as fun@value{cedilha}@~{o}es dilogar@'{i}tmo e trilogar@'{i}tmo, respectivamente.

Quando a ordem for 1, o polilogar@'{i}tmo simplifica para @code{- log (1 - z)},
o qual por sua vez simplifica para um valor num@'{e}rico
se @var{z} for um n@'{u}mero em ponto flutuante real ou complexo ou o sinalizador de avalia@value{cedilha}@~{a}o @code{numer} estiver presente.

Quando a ordem for 2 ou 3,
o polilogar@'{i}tmo simplifica para um valor num@'{e}rico
se @var{z} for um n@'{u}mero real em ponto flutuante
ou o sinalizador de avalia@value{cedilha}@~{a}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@value{cedilha}@~{a}o} log (@var{x})
Representa o logar@'{i}tmo natural (base @math{e}) de @var{x}.

Maxima n@~{a}o possui uma fun@value{cedilha}@~{a}o interna para logar@'{i}tmo de base 10 ou de outras bases.
@code{log10(x) := log(x) / log(10)} @'{e} uma defini@value{cedilha}@~{a}o @'{u}til.

Simplifica@value{cedilha}@~{a}o e avalia@value{cedilha}@~{a}o de logar@'{i}tmos s@~{a}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@'{a} tamb@'{e}m simplificar para @code{log(a)+log(b)}.
Se @code{logexpand} for escolhida para @code{super}, ent@~{a}o @code{log(a/b)} ir@'{a} tamb@'{e}m simplificar para @code{log(a)-log(b)} para n@'{u}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@value{cedilha}@~{o}es ir@~{a}o ser desabilitadas.

@code{logsimp} - se @code{false} ent@~{a}o nenhuma simplifica@value{cedilha}@~{a}o de @code{%e} para um expoente
contendo @code{log}'s @'{e} conclu@'{i}da.

@code{lognumer} - se @code{true} ent@~{a}o argumentos negativos em ponto flutuante para
@code{log} ir@'{a} sempre ser convertido para seu valor absoluto antes que @code{log} seja
tomado.  Se @code{numer} for tamb@'{e}m @code{true}, ent@~{a}o argumentos negativos inteiros para @code{log}
ir@~{a}o tamb@'{e}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@'{u}mero racional, e
@code{x} alguma express@~{a}o, @code{%e^(r*log(x))} ser@'{a} simplificado em
@code{x^r} .  Note-se que o comando @code{radcan} tamb@'{e}m
faz essa transforma@value{cedilha}@~{a}o, e transforma@value{cedilha}@~{o}es mais complicadas desse tipo tamb@'{e}m.
O comando @code{logcontract} "contrai" express@~{o}es contendo @code{log}.

@end deffn

@defvr {Vari@'{a}vel de op@value{cedilha}@~{a}o} logabs
Valor padr@~{a}o: @code{false}

Quando fazendo integra@value{cedilha}@~{a}o indefinida onde
logs s@~{a}o gerados, e.g. @code{integrate(1/x,x)}, a resposta @'{e} 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@value{cedilha}@~{a}o definida, a escolha @code{logabs:true} @'{e}
usada, porque aqui "avalia@value{cedilha}@~{a}o" de integral indefinida nos
extremos @'{e} muitas vezes necess@'{a}ria.

@end defvr

@c NEEDS EXAMPLES
@defvr {Vari@'{a}vel de op@value{cedilha}@~{a}o} logarc
@defvrx {Fun@value{cedilha}@~{a}o} logarc (@var{expr})

Quando a vari@'{a}vel global @code{logarc} for @code{true},
fun@value{cedilha}@~{o}es circulares inversas e fun@value{cedilha}@~{o}es hiperb@'{o}licas ser@~{a}o convertidas
em fun@value{cedilha}@~{o}es logar@'{i}timicas equivalentes.
O valor padr@~{a}o de @code{logarc} @'{e} @code{false}.

A fun@value{cedilha}@~{a}o @code{logarc(@var{expr})} realiza aquela substitu@'{i}@value{cedilha}@~{a}o para
uma express@~{a}o @var{expr}
sem modificar o valor da vari@'{a}vel global @code{logarc}.

@end defvr

@defvr {Vari@'{a}vel de op@value{cedilha}@~{a}o} logconcoeffp
Valor padr@~{a}o: @code{false}

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

@end defvr

@deffn {Fun@value{cedilha}@~{a}o} logcontract (@var{expr})
Recursivamente examina a express@~{a}o @var{expr}, transformando
subexpress@~{o}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@^{e} faz @code{declare(n,integer);} ent@~{a}o @code{logcontract(2*a*n*log(x));} fornece
@code{a*log(x^(2*n))}.  Os coeficientes que "contraem" dessa maneira s@~{a}o
aqueles tais que 2 e @code{n} que satisfazem
@code{featurep(coeff,integer)}.  O usu@'{a}rio pode controlar quais coeficientes s@~{a}o
contra@'{i}dos escolhendo a op@value{cedilha}@~{a}o @code{logconcoeffp} para o nome de uma
fun@value{cedilha}@~{a}o predicado de um argumento.  E.g. se voc@^{e} gosta de gerara
ra@'{i}zes quadradas, voc@^{e} pode fazer @code{logconcoeffp:'logconfun$
logconfun(m):=featurep(m,integer) ou ratnump(m)$} .  Ent@~{a}o
@code{logcontract(1/2*log(x));} ir@'{a} fornecer @code{log(sqrt(x))}.

@end deffn

@defvr {Vari@'{a}vel de op@value{cedilha}@~{a}o} logexpand
Valor padr@~{a}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@'{a} tamb@'{e}m simplificar para @code{log(a)+log(b)}.  Se
for escolhida para @code{super}, ent@~{a}o @code{log(a/b)} ir@'{a} tamb@'{e}m simplificar para @code{log(a)-log(b)} para
n@'{u}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@value{cedilha}@~{o}es ir@~{a}o
ser desabilitadas.

@end defvr

@defvr {Vari@'{a}vel de op@value{cedilha}@~{a}o} lognegint
Valor padr@~{a}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@'{a}vel de op@value{cedilha}@~{a}o} lognumer
Valor padr@~{a}o: @code{false}

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

@end defvr

@defvr {Vari@'{a}vel de op@value{cedilha}@~{a}o} logsimp
Valor padr@~{a}o: @code{true}

Se @code{false} ent@~{a}o nenhuma simplifica@value{cedilha}@~{a}o de @code{%e} para um
expoente contendo @code{log}'s @'{e} conclu@'{i}da.

@end defvr

@deffn {Fun@value{cedilha}@~{a}o} plog (@var{x})
Representa o principal ramo logar@'{i}tmos naturais avaliados para
complexos com @code{-%pi} < @code{carg(@var{x})} <= @code{+%pi} .

@end deffn

