@c /Numerical.texi/1.24/Mon Feb 19 14:23:08 2007/-ko/
@menu
* Introdução a Numérico::
* Pacotes de Fourier::
* Definições para Numérico::
* Definições para Séries de Fourier::
@end menu

@node Introdução a Numérico, Pacotes de Fourier, Numérico, Numérico
@section Introdução a Numérico

@node Pacotes de Fourier, Definições para Numérico, Introdução a Numérico, Numérico
@section Pacotes de Fourier
O pacote @code{fft} compreende funções para computação numérica (não simbólica)
das transformações rápidas de Fourier.
@code{load ("fft")} chama esse pacote.
Veja @code{fft}.

O pacote @code{fourie} compreende funções para computação simbólica
de séries de Fourier.
@code{load ("fourie")} chama esse pacote.
Existem funções no pacote @code{fourie} para calcular coeficientes da
integral de Fourier e algumas funções para manipulação de expressões.
Veja @code{Definições para Séries}.

@c end concepts Numerical

@node Definições para Numérico, Definições para Séries de Fourier, Pacotes de Fourier, Numérico
@section Definições para Numérico
@c NOTE: Let's keep POLARTORECT, RECTTOPOLAR, and IFT before FFT
@c in this file. Otherwise DESCRIBE returns the FFT text (because
@c POLARTORECT, etc are list in the heading of FFT with @defunx).

@deffn {Função} polartorect (@var{magnitude_array}, @var{phase_array})

Traduz valores complexos da forma @code{r %e^(%i t)} para a forma @code{a + b %i}.
@code{load ("fft")} chama essa função dentro do Maxima. Veja também @code{fft}.

O módulo e a fase, @code{r} e @code{t}, São tomados de @var{magnitude_array} e
@var{phase_array}, respectivamente. Os valores originais de arrays de entrada são
substituídos pelas partes real e emaginária, @code{a} e @code{b}, no retorno. As saídas são
calculadas como

@example
a: r cos (t)
b: r sin (t)
@end example

Os arrays de entrada devem ter o mesmo tamanho  e ser unidimensionais.
O tamanho do array não deve ser uma potência de 2.

@code{polartorect} é a função inversa de @code{recttopolar}.

@end deffn

@deffn {Função} recttopolar (@var{real_array}, @var{imaginary_array})

Traduz valores complexos da forma @code{a + b %i} para a forma @code{r %e^(%i t)}.
@code{load ("fft")} chama essa função dentro do Maxima. Veja também @code{fft}.

As partes real e imaginária, @code{a} e @code{b}, são tomadas de @var{real_array} e
@var{imaginary_array}, respectivamente. Os valores originais dos arrays de entrada
são substituídos pelo módulo e pelo ângulo, @code{r} e @code{t}, no retorno. As saídas são
calculadas como

@example
r: sqrt (a^2 + b^2)
t: atan2 (b, a)
@end example

O ângulo calculado encontra-se no intervalo de @code{-%pi} a @code{%pi}. 

Os arrays de entrada devem ter o mesmo tamanho e ser unidimensionais.
O tamanho do array não deve ser uma potência de 2.

@code{recttopolar} é a função inversa de @code{polartorect}.

@end deffn

@deffn {Função} ift (@var{real_array}, @var{imaginary_array})

Transformação rápida inversa discreta de Fourier . @code{load ("fft")} chama essa função
dentro do Maxima.

@code{ift} realiza a transformação rápida complexa de Fourier sobre
arrays em ponto flutuante unidimensionais. A transformação inversa é definida como

@example
x[j]: sum (y[j] exp (+2 %i %pi j k / n), k, 0, n-1)
@end example

Veja @code{fft} para maiores detalhes.

@end deffn

@deffn {Função} fft (@var{real_array}, @var{imaginary_array})
@deffnx {Função} ift (@var{real_array}, @var{imaginary_array})
@deffnx {Função} recttopolar (@var{real_array}, @var{imaginary_array})
@deffnx {Função} polartorect (@var{magnitude_array}, @var{phase_array})

Transformação rápidada de Fourier e funções relacionadas. @code{load ("fft")}
chama essas funções dentro do Maxima.

@code{fft} e @code{ift} realiza transformação rápida complexa de Fourier e
a transformação inversa, respectivamente, sobre arrays em ponto flutuante
unidimensionais. O tamanho de @var{imaginary_array} deve ser igual ao tamanho de @var{real_array}.

@code{fft} e @code{ift} operam in-loco. Isto é, sobre o retorno de @code{fft} ou de @code{ift},
O conteúdo original dos arrays de entrada é substituído pela saída.
A função @code{fillarray} pode fazer uma cópia de um array, isso pode
ser necessário.

A transformação discreta de Fourier e sua transformação inversa são definidas
como segue. Tome @code{x} sendo os dados originais, com

@example
x[i]: real_array[i] + %i imaginary_array[i]
@end example
  
Tome @code{y} sendo os dados transformados. A transformação normal e sua transformação inversa são

@example
y[k]: (1/n) sum (x[j] exp (-2 %i %pi j k / n), j, 0, n-1)

x[j]:       sum (y[j] exp (+2 %i %pi j k / n), k, 0, n-1)
@end example

Arrays adequadas podem ser alocadas pela função @code{array}. Por exemplo:

@example
array (my_array, float, n-1)$
@end example

declara um array unidimensional com n elementos, indexado de 0 a
n-1 inclusive. O número de elementos n deve ser igual a 2^m para algum m.

@code{fft} pode ser aplicada a dados reais (todos os arrays imaginários são iguais a zero) para obter
coeficientes seno e co-seno.  Após chamar @code{fft}, os coeficientes
seno e co-seno, digamos @code{a} e @code{b}, podem ser calculados como

@example
a[0]: real_array[0]
b[0]: 0
@end example

e

@example
a[j]: real_array[j] + real_array[n-j]
b[j]: imaginary_array[j] - imaginary_array[n-j]
@end example

para j variando de 1 a n/2-1, e

@example
a[n/2]: real_array[n/2]
b[n/2]: 0
@end example

@code{recttopolar} traduz valores complexos da forma @code{a + b %i} para
a forma @code{r %e^(%i t)}. Veja @code{recttopolar}.

@code{polartorect} traduz valores complexos da forma @code{r %e^(%i t)}
para a forma @code{a + b %i}. Veja @code{polartorect}.

@code{demo ("fft")} exibe uma demonstração do pacote @code{fft}.

@end deffn

@defvr {Variável de opção} fortindent
Valor por omissão: 0

@code{fortindent} controla a margem esquerda de indentação de
expressões mostradas pelo comando @code{fortran}.  0 fornece indentação
normal (i.e., 6 espaços), e valores positivos farão com que
expressões sejam mostrados mais além para a direita.

@end defvr

@deffn {Função} fortran (@var{expr})
Mostra @var{expr} como uma declaração Fortran.
A linha de saída é indentada com espaços.
Se a linha for muito longa, @code{fortran} imprime linhas de continuação.
@code{fortran} mostra o operador de exponenciação @code{^} como @code{**},
e mostra um número complexo @code{a + b %i} na forma @code{(a,b)}.

@var{expr} pode ser uma equação. Nesse caso, @code{fortran} mostra uma declaração de
atribuição, atribuindo o primeiro membro (esquerda) da equação ao segundo membro (direita).
Em particular, se o primeiro membro @var{expr} é um nome de uma matriz,
então @code{fortran} mostra uma declaração de atribuição para cada elemento da matriz.

Se @var{expr} não for alguma coisa reconhecida por @code{fortran},
a expressão é mostrada no formato @code{grind} sem reclamação.
@code{fortran} não conhece listas, arrays ou funções.

@code{fortindent} controla o margem esquerda das linhas mostradas.
0 é a margem normal (i.e., indentada 6 espaços). Incrementando @code{fortindent}
faz com que expressões sejam mostradas adiante para a direita.

quando @code{fortspaces} for @code{true}, @code{fortran} preenche
cada linha mostrada com espaços em branco até completar 80 columas.

@code{fortran} avalia seus argumentos;
colocando um apóstrofo em um argumento evita avaliação.
@code{fortran} sempre retorna @code{done}.

Exemplos:

@example
(%i1) expr: (a + b)^12$
(%i2) fortran (expr);
      (b+a)**12                                                                 
(%o2)                         done
(%i3) fortran ('x=expr);
      x = (b+a)**12                                                             
(%o3)                         done
(%i4) fortran ('x=expand (expr));
      x = b**12+12*a*b**11+66*a**2*b**10+220*a**3*b**9+495*a**4*b**8+792        
     1   *a**5*b**7+924*a**6*b**6+792*a**7*b**5+495*a**8*b**4+220*a**9*b        
     2   **3+66*a**10*b**2+12*a**11*b+a**12                                     
(%o4)                         done
(%i5) fortran ('x=7+5*%i);
      x = (7,5)                                                                 
(%o5)                         done
(%i6) fortran ('x=[1,2,3,4]);
      x = [1,2,3,4]                                                             
(%o6)                         done
(%i7) f(x) := x^2$
(%i8) fortran (f);
      f                                                                         
(%o8)                         done
@end example

@end deffn

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

Quando @code{fortspaces} for @code{true}, @code{fortran} preenche
cada linha mostrada com espaços em branco até completar 80 columas.

@end defvr

@deffn {Função} horner (@var{expr}, @var{x})
@deffnx {Função} horner (@var{expr})
Retorna uma representação rearranjada de @var{expr} como
na regra de Horner, usando @var{x} como variável principal se isso for especificado.
@code{x} pode ser omitido e nesse caso a variável principal da forma de expressão racional
canónica de @var{expr} é usada.

@code{horner} algumas vezes melhora a estabilidade se @code{expr} for
ser numericamente avaliada.  Isso também é útil se Maxima é usado para
gerar programas para rodar em Fortran. Veja também @code{stringout}.

@example
(%i1) expr: 1e-155*x^2 - 5.5*x + 5.2e155;
                           2
(%o1)            1.0E-155 x  - 5.5 x + 5.2E+155
(%i2) expr2: horner (%, x), keepfloat: true;
(%o2)            (1.0E-155 x - 5.5) x + 5.2E+155
(%i3) ev (expr, x=1e155);
Maxima encountered a Lisp error:

 floating point overflow

Automatically continuing.
To reenable the Lisp debugger set *debugger-hook* to nil.
(%i4) ev (expr2, x=1e155);
(%o4)                       7.0E+154
@end example

@end deffn

@c NEEDS WORK
@deffn {Função} find_root (@var{f}(@var{x}), @var{x}, @var{a}, @var{b})
@deffnx {Função} find_root (@var{f}, @var{a}, @var{b})
Encontra a raíz da função @var{f} com a variável @var{x} percorrendo o intervalo @code{[@var{a}, @var{b}]}.
A função deve ter um
sinal diferente em cada ponto final.  Se essa condição não for alcançada, a
action of the function is governed by @code{find_root_error}.  If
@code{find_root_error} is @code{true} then an error occurs, otherwise the value of
@code{find_root_error} is returned (thus for plotting @code{find_root_error} might be set to
0.0).  De outra forma (dado que Maxima pode avaliar o primeiro argumento
no intervalo especificado, e que o intervalo é contínuo) @code{find_root} é
garantido vir para cima com a raíz (ou um deles se existir mais
que uma raíz).  A precisão de @code{find_root} é governada por
@code{intpolabs} e @code{intpolrel} os quais devem ser números em ponto flutuante
não negativos.  @code{find_root} encerrará quando o primeiro argumento avaliar para
alguma coisa menor que ou igual a @code{intpolabs} ou se sucessivas
aproximações da raíz diferirem por não mais que @code{intpolrel * <um dos aproximandos>}.
O valor padrão de @code{intpolabs} e @code{intpolrel} são
0.0 de forma que @code{find_root} pega como boa uma resposta como for possível com a
precisão aritmética simples que tivermos.  O primeiro argumento pode ser uma
equação.  A ordem dos dois últimos argumentos é irrelevante.  Dessa forma

@example
find_root (sin(x) = x/2, x, %pi, 0.1);
@end example

é equivalente a

@example
find_root (sin(x) = x/2, x, 0.1, %pi);
@end example

O método usado é uma busca binária no intervalo especificado pelos últimos
dois argumentos.  Quando o resultado da busca for encontrado a função é fechada o suficiente para ser
linear, isso inicia usando interpolação linear.

Examples:
@c ===beg===
@c f(x):=(mode_declare(x,float),sin(x)-x/2.0);
@c find_root(sin(x)-x/2,x,0.1,%pi)       time= 60 msec
@c find_root(f(x),x,0.1,%pi);            time= 68 msec
@c translate(f);
@c find_root(f(x),x,0.1,%pi);            time= 26 msec
@c find_root(f,0.1,%pi);                 time=  5 msec
@c
@c STUFF BELOW GENERATED FROM THE FOLLOWING
@c f(x) := sin(x) - x/2;
@c find_root (sin(x) - x/2, x, 0.1, %pi);
@c find_root (sin(x) = x/2, x, 0.1, %pi);
@c find_root (f(x), x, 0.1, %pi);
@c find_root (f, 0.1, %pi);
@example
(%i1) f(x) := sin(x) - x/2;
                                        x
(%o1)                  f(x) := sin(x) - -
                                        2
(%i2) find_root (sin(x) - x/2, x, 0.1, %pi);
(%o2)                   1.895494267033981
(%i3) find_root (sin(x) = x/2, x, 0.1, %pi);
(%o3)                   1.895494267033981
(%i4) find_root (f(x), x, 0.1, %pi);
(%o4)                   1.895494267033981
(%i5) find_root (f, 0.1, %pi);
(%o5)                   1.895494267033981
@end example

@end deffn

@defvr {Variável de opção} find_root_abs
Valor por omissão: 0.0

@code{find_root_abs} é a precisão do comando @code{find_root}. A precisão é
governada por @code{find_root_abs} e @code{find_root_rel} que devem ser
números não negativos em ponto flutuante.  @code{find_root} terminará quando o
primeiro argumento avaliar para alguma coisa menor que ou igual a @code{find_root_abs} ou se
sucessivos aproximandos para a raíz diferirem por não mais que @code{find_root_rel * <um dos aproximandos>}.
Os valores padrão de @code{find_root_abs} e
@code{find_root_rel} são 0.0 de forma que @code{find_root} tome como boa uma resposta que for possível
com a precisão aritmética simples que tivermos.

@end defvr

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

@code{find_root_error} governa o comportamento de @code{find_root}.
Quando @code{find_root} for chamada, ela determina se a função
a ser resolvida satisfaz ou não a condição que os valores da
função nos pontos finais do intervalo de interpolação são opostos
em sinal.  Se eles forem de sinais opostos, a interpolação prossegue.
Se eles forem de mesmo sinal, e @code{find_root_error} for @code{true}, então um erro é
sinalizado.  Se eles forem de mesmo sinal e @code{find_root_error} não for @code{true}, o
valor de @code{find_root_error} é retornado.  Dessa forma para montagem de gráfico, @code{find_root_error}
pode ser escolhida para 0.0.

@end defvr

@defvr {Variável de opção} find_root_rel
Valor por omissão: 0.0

@code{find_root_rel} é a precisão do comando @code{find_root} e é
governada por @code{find_root_abs} e @code{find_root_rel} que devem ser
números não negativos em ponto flutuante.  @code{find_root} terminará quando o
primeiro argumento avaliar para alguma coisa menor que ou igual a @code{find_root_abs} ou se
sucessivos aproximandos para a raíz diferirem de não mais que @code{find_root_rel * <um dos aproximandos>}.
Os valores padrão de @code{find_root_labs} e
@code{find_root_rel} é 0.0 de forma que @code{find_root} toma como boa uma resposta que for possível
com a precisão aritmética simples que tivermos.

@end defvr

@deffn {Função} newton (@var{expr}, @var{x}, @var{x_0}, @var{eps})
Retorna uma solução aproximada de @code{@var{expr} = 0} através do método de Newton,
considerando @var{expr} como sendo uma função de uma variável, @var{x}.
A busca pela solução começa com @code{@var{x} = @var{x_0}}
e prossegue até @code{abs(@var{expr}) < @var{eps}}
(com @var{expr} avaliada para o valor corrente de @var{x}).

@code{newton} permite que variáveis indefinidas apareçam em @var{expr},
contanto que o teste de terminação @code{abs(@var{expr}) < @var{eps}} avalie
para @code{true} ou @code{false}.
Dessa forma não é necessário que @var{expr} avalie para um número.

@code{load(newton1)} chama essa função.

Veja também @code{realroots}, @code{allroots}, @code{find_root}, e @code{mnewton}.

Exemplos:

@c ===beg===
@c load (newton1);
@c newton (cos (u), u, 1, 1/100);
@c ev (cos (u), u = %);
@c assume (a > 0);
@c newton (x^2 - a^2, x, a/2, a^2/100);
@c ev (x^2 - a^2, x = %);
@c ===end===
@example
(%i1) load (newton1);
(%o1) /usr/share/maxima/5.10.0cvs/share/numeric/newton1.mac
(%i2) newton (cos (u), u, 1, 1/100);
(%o2)                   1.570675277161251
(%i3) ev (cos (u), u = %);
(%o3)                 1.2104963335033528E-4
(%i4) assume (a > 0);
(%o4)                        [a > 0]
(%i5) newton (x^2 - a^2, x, a/2, a^2/100);
(%o5)                  1.00030487804878 a
(%i6) ev (x^2 - a^2, x = %);
                                           2
(%o6)                6.098490481853958E-4 a
@end example

@end deffn

@node Definições para Séries de Fourier, , Definições para Numérico, Numérico
@section Definições para Séries de Fourier

@c REPHRASE
@deffn {Função} equalp (@var{x}, @var{y})
Retorna @code{true} se @code{equal (@var{x}, @var{y})} de outra forma @code{false} (não fornece uma
mensagem de erro como @code{equal (x, y)} poderia fazer nesse caso).

@c NEEDS EXAMPLES
@end deffn

@deffn {Função} remfun (@var{f}, @var{expr})
@deffnx {Função} remfun (@var{f}, @var{expr}, @var{x})
@code{remfun (@var{f}, @var{expr})}
substitue todas as ocorrências de @code{@var{f} (@var{arg})} por @var{arg} em @var{expr}.

@code{remfun (@var{f}, @var{expr}, @var{x})}
substitue todas as ocorrências de @code{@var{f} (@var{arg})} por @var{arg} em @var{expr}
somente se @var{arg} contiver a variável @var{x}.

@c NEEDS EXAMPLES
@end deffn

@deffn {Função} funp (@var{f}, @var{expr})
@deffnx {Função} funp (@var{f}, @var{expr}, @var{x})
@code{funp (@var{f}, @var{expr})}
retorna @code{true} se @var{expr} contém a função @var{f}.

@code{funp (@var{f}, @var{expr}, @var{x})}
retorna @code{true} se @var{expr} contém a função @var{f} e a variável
@var{x} em algum lugar no argumento de uma das instâncias de @var{f}.

@c NEEDS EXAMPLES
@end deffn

@deffn {Função} absint (@var{f}, @var{x}, @var{halfplane})
@deffnx {Função} absint (@var{f}, @var{x})
@deffnx {Função} absint (@var{f}, @var{x}, @var{a}, @var{b})
@code{absint (@var{f}, @var{x}, @var{halfplane})}
retorna a integral indefinida de @var{f} com relação a
@var{x} no dado semi-plano (@code{pos}, @code{neg}, ou @code{both}).
@var{f} pode conter expressões da forma
@code{abs (x)}, @code{abs (sin (x))}, @code{abs (a) * exp (-abs (b) * abs (x))}.

@code{absint (@var{f}, @var{x})} é equivalente a @code{absint (@var{f}, @var{x}, pos)}.

@code{absint (@var{f}, @var{x}, @var{a}, @var{b})}
retorna a integral definida de @var{f} com relação a @var{x} de @var{a} até @var{b}.
@c SAME LIST AS ABOVE ??
@var{f} pode incluir valores absolutos.

@c NEEDS EXAMPLES
@end deffn

@c NEEDS EXPANSION
@deffn {Função} fourier (@var{f}, @var{x}, @var{p})
Retorna uma lista de coeficientes de Fourier de @code{@var{f}(@var{x})} definidos
sobre o intervalo @code{[-p, p]}.

@c NEEDS EXAMPLES
@end deffn

@c NEES EXPANSION. WHAT IS THE ARGUMENT l ??
@deffn {Função} foursimp (@var{l})
Simplifica @code{sin (n %pi)} para 0 se @code{sinnpiflag} for @code{true} e
@code{cos (n %pi)} para @code{(-1)^n} se @code{cosnpiflag} for @code{true}.

@c NEEDS EXAMPLES
@end deffn

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

Veja @code{foursimp}.

@end defvr

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

Veja @code{foursimp}.

@end defvr

@c NEEDS EXPANSION. EXPLAIN x AND p HERE (DO NOT REFER SOMEWHERE ELSE)
@deffn {Função} fourexpand (@var{l}, @var{x}, @var{p}, @var{limit})
Constrói e retorna a série de Fourier partindo da lista de
coeficientes de Fourier @var{l} até (up through) @var{limit} termos (@var{limit}
pode ser @code{inf}). @var{x} e @var{p} possuem o mesmo significado que em
@code{fourier}.

@c NEEDS EXAMPLES
@end deffn

@c NEEDS EXPANSION. WHAT IS THE ARGUMENT p ??
@deffn {Função} fourcos (@var{f}, @var{x}, @var{p})
Retorna os coeficientes do co-seno de Fourier para @code{@var{f}(@var{x})} definida sobre @code{[0, %pi]}.

@c NEEDS EXAMPLES
@end deffn

@c NEEDS EXPANSION
@deffn {Função} foursin (@var{f}, @var{x}, @var{p})
Retorna os coeficientes do seno de Fourier para @code{@var{f}(@var{x})} definida sobre @code{[0, @var{p}]}.

@c NEEDS EXAMPLES
@end deffn

@c NEEDS EXPANSION
@deffn {Função} totalfourier (@var{f}, @var{x}, @var{p})
Retorna @code{fourexpand (foursimp (fourier (@var{f}, @var{x}, @var{p})), @var{x}, @var{p}, 'inf)}.

@c NEEDS EXAMPLES
@end deffn

@c NEEDS EXPANSION
@deffn {Função} fourint (@var{f}, @var{x})
Constrói e retorna uma lista de coeficientes de integral de Fourier de @code{@var{f}(@var{x})}
definida sobre @code{[minf, inf]}.

@c NEEDS EXAMPLES
@end deffn

@c NEEDS EXPANSION
@deffn {Função} fourintcos (@var{f}, @var{x})
Retorna os coeficientes da integral do co-seno de Fourier para @code{@var{f}(@var{x})} on @code{[0, inf]}.

@c NEEDS EXAMPLES
@end deffn

@c NEEDS EXPANSION
@deffn {Função} fourintsin (@var{f}, @var{x})
Retorna os coeficientes da integral do seno de Fourier para @code{@var{f}(@var{x})} on @code{[0, inf]}.

@c NEEDS EXAMPLES
@end deffn

