doc/info/pt/Logarithms.texi

   1 @c Language: Portuguese
   2 @c /Logarithms.texi/1.16/Sat Jul  8 08:14:48 2006/-ko/
   3 @menu
   4 * Definições para Logaritmos::
   5 @end menu
   6
   7 @node Definições para Logaritmos,  , Logaritmos, Logaritmos
   8 @section Definições para Logaritmos
   9
  10 @defvr {Variável de opção} %e_to_numlog
  11 Valor por omissão: @code{false}
  12
  13 Quando @code{true}, sendo @code{r} algum número racional, e @code{x}
  14 alguma expressão, @code{%e^(r*log(x))} será simplificado em
  15 @code{x^r} .  Note-se que o comando @code{radcan} também faz essa
  16 transformação, assim como algumas transformações mais
  17 complicadas.  O comando @code{logcontract} @emph{contrai} expressões
  18 contendo @code{log}.
  19
  20 @end defvr
  21
  22 @deffn {Função} li [@var{s}] (@var{z})
  23 Representa a função polilogaritmo de ordem @var{s}
  24 e argumento @var{z}, definida por meio da série infinita
  25
  26 @example
  27                                  inf
  28                                  ====   k
  29                                  \     z
  30                         Li (z) =  >    --
  31                           s      /      s
  32                                  ====  k
  33                                  k = 1
  34 @end example
  35
  36 @code{li [1]} é @code{- log (1 - z)}.  @code{li [2]} e @code{li [3]}
  37 são as funções dilogaritmo e
  38 trilogaritmo, respectivamente.
  39
  40 Quando a ordem for 1, o polilogaritmo simplifica para
  41 @code{- log (1 - z)}, o qual por sua vez simplifica para um valor
  42 numérico se @var{z} for um número em ponto flutuante real ou
  43 complexo ou o sinalizador de avaliação @code{numer} estiver
  44 presente.
  45
  46 Quando a ordem for 2 ou 3, o polilogaritmo simplifica
  47 para um valor numérico se @var{z} for um número real em ponto
  48 flutuante ou o sinalizador de avaliação @code{numer} estiver
  49 presente.
  50
  51 Exemplos:
  52
  53 @c ===beg===
  54 @c assume (x > 0);
  55 @c integrate ((log (1 - t)) / t, t, 0, x);
  56 @c li [2] (7);
  57 @c li [2] (7), numer;
  58 @c li [3] (7);
  59 @c li [2] (7), numer;
  60 @c L : makelist (i / 4.0, i, 0, 8);
  61 @c map (lambda ([x], li [2] (x)), L);
  62 @c map (lambda ([x], li [3] (x)), L);
  63 @c ===end===
  64 @example
  65 (%i1) assume (x > 0);
  66 (%o1)                        [x > 0]
  67 (%i2) integrate ((log (1 - t)) / t, t, 0, x);
  68 (%o2)                       - li (x)
  69                                 2
  70 (%i3) li [2] (7);
  71 (%o3)                        li (7)
  72                                2
  73 (%i4) li [2] (7), numer;
  74 (%o4)        1.24827317833392 - 6.113257021832577 %i
  75 (%i5) li [3] (7);
  76 (%o5)                        li (7)
  77                                3
  78 (%i6) li [2] (7), numer;
  79 (%o6)        1.24827317833392 - 6.113257021832577 %i
  80 (%i7) L : makelist (i / 4.0, i, 0, 8);
  81 (%o7)   [0.0, 0.25, 0.5, 0.75, 1.0, 1.25, 1.5, 1.75, 2.0]
  82 (%i8) map (lambda ([x], li [2] (x)), L);
  83 (%o8) [0, .2676526384986274, .5822405249432515,
  84 .9784693966661848, 1.64493407, 2.190177004178597
  85  - .7010261407036192 %i, 2.374395264042415
  86  - 1.273806203464065 %i, 2.448686757245154
  87  - 1.758084846201883 %i, 2.467401098097648
  88  - 2.177586087815347 %i]
  89 (%i9) map (lambda ([x], li [3] (x)), L);
  90 (%o9) [0, .2584613953442624, 0.537213192678042,
  91 .8444258046482203, 1.2020569, 1.642866878950322
  92  - .07821473130035025 %i, 2.060877505514697
  93  - .2582419849982037 %i, 2.433418896388322
  94  - .4919260182322965 %i, 2.762071904015935
  95  - .7546938285978846 %i]
  96 @end example
  97
  98 @end deffn
  99
 100 @deffn {Função} log (@var{x})
 101 Representa o logaritmo natural (base @math{e}) de
 102 @var{x}.
 103
 104 Maxima não possui uma função interna para
 105 logaritmo de base 10 ou de outras bases. @code{log10(x)
 106 := log(x) / log(10)} é uma definição útil.
 107
 108 A simplificação e avaliação de logaritmos
 109 são governadas por vários sinalizadores globais:
 110
 111 @code{logexpand} - faz com que @code{log(a^b)} se transfome em
 112 @code{b*log(a)}. Se @code{logexpand} tiver o valor @code{all},
 113 @code{log(a*b)} irá também simplificar para @code{log(a)+log(b)}.
 114 Se @code{logexpand} for igual a @code{super}, então
 115 @code{log(a/b)} irá também simplificar para @code{log(a)-log(b)}
 116 para números racionais @code{a/b}, @code{a#1} (@code{log(1/b)},
 117 para @code{b} inteiro, sempre simplifica).  Se @code{logexpand} for
 118 igaul a @code{false}, todas essas simplificações irão
 119 ser desabilitadas.
 120
 121 @code{logsimp} - se tiver valor @code{false}, não será feita nenhuma
 122 simplificação de @code{%e} para um expoente contendo
 123 @code{log}'s.
 124
 125 @code{lognumer} - se tiver valor @code{true}, os argumentos negativos
 126 em ponto flutuante para @code{log} irá sempre ser convertidos para
 127 seu valor absoluto antes que @code{log} seja calculado. Se
 128 @code{numer} for também @code{true}, então argumentos negativos
 129 inteiros para @code{log} irão também ser convertidos para os seus
 130 valores absolutos.
 131
 132 @code{lognegint} - se tiver valor @code{true}, implementa a regra
 133 @code{log(-n)} -> @code{log(n)+%i*%pi} para @code{n} um inteiro
 134 positivo.
 135
 136 @code{%e_to_numlog} - quando for igual a @code{true},
 137 @code{%e^(r*log(x))}, sendo @code{r} algum número racional, e
 138 @code{x} alguma expressão, será simplificado para
 139 @code{x^r}. Note-se que o comando @code{radcan} também faz essa
 140 transformação, e outras transformações mais complicadas
 141 desse género.
 142
 143 O comando @code{logcontract} "contrai" expressões
 144 contendo @code{log}.
 145
 146 @end deffn
 147
 148 @defvr {Variável de opção} logabs
 149 Valor por omissão: @code{false}
 150
 151 No cálculo de primitivas em que sejam gerados
 152 logaritmos, por exemplo, @code{integrate(1/x,x)}, a
 153 resposta será dada em termos de @code{log(abs(...))} se
 154 @code{logabs} for @code{true}, mas em termos de @code{log(...)} se
 155 @code{logabs} for @code{false}. Para integrais definidos, usa-se
 156 @code{logabs:true}, porque nesse caso muitas vezes é necessário
 157 calcular a primitiva nos extremos.
 158
 159 @end defvr
 160
 161 @c NEEDS EXAMPLES
 162 @defvr {Variável de opção} logarc
 163 @defvrx {Função} logarc (@var{expr})
 164
 165 Quando a variável global @code{logarc} for igual a @code{true}, as
 166 funções trigononométricas inversas, circulares e
 167 hiperbólicas, serão substituídas por suas
 168 funções logarítmicas equivalentes. O valor
 169 padrão de @code{logarc} é @code{false}.
 170
 171 A função @code{logarc(@var{expr})} realiza essa
 172 substituição para uma expressão @var{expr} sem modificar o
 173 valor da variável global @code{logarc}.
 174
 175 @end defvr
 176
 177 @defvr {Variável de opção} logconcoeffp
 178 Valor por omissão: @code{false}
 179
 180 Controla quais coeficientes são contraídos quando se
 181 usa @code{logcontract}. Poderá ser igual ao nome de uma função
 182 de um argumento. Por exemplo, se quiser gerar raízes
 183 quadradas, pode fazer @code{logconcoeffp:'logconfun$
 184 logconfun(m):=featurep(m,integer) or ratnump(m)$}. E assim,
 185 @code{logcontract(1/2*log(x));} produzirá @code{log(sqrt(x))}.
 186
 187 @end defvr
 188
 189 @deffn {Função} logcontract (@var{expr})
 190 Examina recursivamente a expressão @var{expr}, transformando
 191 subexpressões da forma @code{a1*log(b1) + a2*log(b2) + c} em
 192 @code{log(ratsimp(b1^a1 * b2^a2)) + c}
 193
 194 @c ===beg===
 195 @c 2*(a*log(x) + 2*a*log(y))$
 196 @c logcontract(%);
 197 @c ===end===
 198 @example
 199 (%i1) 2*(a*log(x) + 2*a*log(y))$
 200 (%i2) logcontract(%);
 201                                  2  4
 202 (%o2)                     a log(x  y )
 203
 204 @end example
 205
 206 Se fizer @code{declare(n,integer);} então
 207 @code{logcontract(2*a*n*log(x));} produzirá
 208 @code{a*log(x^(2*n))}. Os coeficientes que @emph{contraem} dessa
 209 maneira são os que, tal como 2 e @code{n} neste exemplo, satisfazem
 210 @code{featurep(coeficiente,integer)}. O utilizador pode controlar
 211 quais coeficientes são contraídos, dando à variável
 212 @code{logconcoeffp} o nome de uma função de um argumento. Por
 213 exemplo, se quiser gerar raízes quadradas, pode fazer
 214 @code{logconcoeffp:'logconfun$ logconfun(m):=featurep(m,integer) or
 215 ratnump(m)$}. E assim, @code{logcontract(1/2*log(x));} produzirá
 216 @code{log(sqrt(x))}.
 217
 218
 219 @end deffn
 220
 221 @defvr {Variável de opção} logexpand
 222 Valor por omissão: @code{true}
 223
 224 Faz com que @code{log(a^b)} se transfome em @code{b*log(a)}. Se
 225 @code{logexpand} tiver o valor @code{all}, @code{log(a*b)} irá
 226 também simplificar para @code{log(a)+log(b)}.  Se @code{logexpand}
 227 for igual a @code{super}, então @code{log(a/b)} irá também
 228 simplificar para @code{log(a)-log(b)} para números racionais
 229 @code{a/b}, @code{a#1} (@code{log(1/b)}, para @code{b} inteiro, sempre
 230 simplifica).  Se @code{logexpand} for igaul a @code{false}, todas
 231 essas simplificações irão ser desabilitadas.
 232
 233 @end defvr
 234
 235 @defvr {Variável de opção} lognegint
 236 Valor por omissão: @code{false}
 237
 238 Se for igual a @code{true}, implementa a regra @code{log(-n)} ->
 239 @code{log(n)+%i*%pi} para @code{n} um inteiro positivo.
 240
 241 @end defvr
 242
 243 @defvr {Variável de opção} lognumer
 244 Valor por omissão: @code{false}
 245
 246 Se tiver valor @code{true}, os argumentos negativos em ponto flutuante
 247 para @code{log} irá sempre ser convertidos para seu valor absoluto
 248 antes que @code{log} seja calculado. Se @code{numer} for também
 249 @code{true}, então argumentos negativos inteiros para @code{log}
 250 irão também ser convertidos para os seus valores absolutos.
 251
 252 @end defvr
 253
 254 @defvr {Variável de opção} logsimp
 255 Valor por omissão: @code{true}
 256
 257 Se tiver valor @code{false}, não será feita nenhuma
 258 simplificação de @code{%e} para um expoente contendo
 259 @code{log}'s.
 260
 261 @end defvr
 262
 263 @deffn {Função} plog (@var{x})
 264 Representa o ramo principal dos logaritmos naturais no
 265 plano complexo, com @code{-%pi} < @code{carg(@var{x})} <= @code{+%pi}.
 266
 267 @end deffn
 268
 269