@c Language: Brazilian Portuguese, Encoding: iso-8859-1
@c /Numerical.texi/1.25/Sat Jun  2 00:12:59 2007/-ko/
@menu
* Introdu@value{cedilha}@~{a}o a Num@'{e}rico::
* Pacotes de Fourier::
* Fun@value{cedilha}@~{o}es e Vari@'{a}veis Definidas para Num@'{e}rico::
* Fun@value{cedilha}@~{o}es e Vari@'{a}veis Definidas para S@'{e}ries de Fourier::
@end menu

@node Introdu@value{cedilha}@~{a}o a Num@'{e}rico, Pacotes de Fourier, Num@'{e}rico, Num@'{e}rico
@section Introdu@value{cedilha}@~{a}o a Num@'{e}rico

@node Pacotes de Fourier, Fun@value{cedilha}@~{o}es e Vari@'{a}veis Definidas para Num@'{e}rico, Introdu@value{cedilha}@~{a}o a Num@'{e}rico, Num@'{e}rico
@section Pacotes de Fourier
O pacote @code{fft} compreende fun@value{cedilha}@~{o}es para computa@value{cedilha}@~{a}o num@'{e}rica (n@~{a}o simb@'{o}lica)
das transforma@value{cedilha}@~{o}es r@'{a}pidas de Fourier.
@code{load ("fft")} chama esse pacote.
Veja @code{fft}.

O pacote @code{fourie} compreende fun@value{cedilha}@~{o}es para computa@value{cedilha}@~{a}o simb@'{o}lica
de s@'{e}ries de Fourier.
@code{load ("fourie")} chama esse pacote.
Existem fun@value{cedilha}@~{o}es no pacote @code{fourie} para calcular coeficientes da
integral de Fourier e algumas fun@value{cedilha}@~{o}es para manipula@value{cedilha}@~{a}o de express@~{o}es.
Veja @code{Fun@value{cedilha}@~{o}es e Vari@'{a}veis Definidas para S@'{e}ries}.

@c end concepts Numerical

@node Fun@value{cedilha}@~{o}es e Vari@'{a}veis Definidas para Num@'{e}rico, Fun@value{cedilha}@~{o}es e Vari@'{a}veis Definidas para S@'{e}ries de Fourier, Pacotes de Fourier, Num@'{e}rico
@section Fun@value{cedilha}@~{o}es e Vari@'{a}veis Definidas para Num@'{e}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@value{cedilha}@~{a}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@value{cedilha}@~{a}o dentro do Maxima. Veja tamb@'{e}m @code{fft}.

O m@'{o}dulo e a fase, @code{r} e @code{t}, S@~{a}o tomados de @var{magnitude_array} e
@var{phase_array}, respectivamente. Os valores originais de arrays de entrada s@~{a}o
substitu@'{i}dos pelas partes real e emagin@'{a}ria, @code{a} e @code{b}, no retorno. As sa@'{i}das s@~{a}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@~{a}o deve ser uma pot@^{e}ncia de 2.

@code{polartorect} @'{e} a fun@value{cedilha}@~{a}o inversa de @code{recttopolar}.

@end deffn

@deffn {Fun@value{cedilha}@~{a}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@value{cedilha}@~{a}o dentro do Maxima. Veja tamb@'{e}m @code{fft}.

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

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

O @^{a}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@~{a}o deve ser uma pot@^{e}ncia de 2.

@code{recttopolar} @'{e} a fun@value{cedilha}@~{a}o inversa de @code{polartorect}.

@end deffn

@deffn {Fun@value{cedilha}@~{a}o} ift (@var{real_array}, @var{imaginary_array})

Transforma@value{cedilha}@~{a}o r@'{a}pida inversa discreta de Fourier . @code{load ("fft")} chama essa fun@value{cedilha}@~{a}o
dentro do Maxima.

@code{ift} realiza a transforma@value{cedilha}@~{a}o r@'{a}pida complexa de Fourier sobre
arrays em ponto flutuante unidimensionais. A transforma@value{cedilha}@~{a}o inversa @'{e} 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@value{cedilha}@~{a}o} fft (@var{real_array}, @var{imaginary_array})
@deffnx {Fun@value{cedilha}@~{a}o} ift (@var{real_array}, @var{imaginary_array})
@deffnx {Fun@value{cedilha}@~{a}o} recttopolar (@var{real_array}, @var{imaginary_array})
@deffnx {Fun@value{cedilha}@~{a}o} polartorect (@var{magnitude_array}, @var{phase_array})

Transforma@value{cedilha}@~{a}o r@'{a}pidada de Fourier e fun@value{cedilha}@~{o}es relacionadas. @code{load ("fft")}
chama essas fun@value{cedilha}@~{o}es dentro do Maxima.

@code{fft} e @code{ift} realiza transforma@value{cedilha}@~{a}o r@'{a}pida complexa de Fourier e
a transforma@value{cedilha}@~{a}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 @'{e}, sobre o retorno de @code{fft} ou de @code{ift},
O conte@'{u}do original dos arrays de entrada @'{e} substitu@'{i}do pela sa@'{i}da.
A fun@value{cedilha}@~{a}o @code{fillarray} pode fazer uma c@'{o}pia de um array, isso pode
ser necess@'{a}rio.

A transforma@value{cedilha}@~{a}o discreta de Fourier e sua transforma@value{cedilha}@~{a}o inversa s@~{a}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@value{cedilha}@~{a}o normal e sua transforma@value{cedilha}@~{a}o inversa s@~{a}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@value{cedilha}@~{a}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@'{u}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@'{a}rios s@~{a}o iguais a zero) para obter
coeficientes seno e cosseno.  Ap@'{o}s chamar @code{fft}, os coeficientes
seno e cosseno, 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@value{cedilha}@~{a}o do pacote @code{fft}.

@end deffn

@defvr {Vari@'{a}vel de op@value{cedilha}@~{a}o} fortindent
Valor padr@~{a}o: 0

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

@end defvr

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

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

Se @var{expr} n@~{a}o for alguma coisa reconhecida por @code{fortran},
a express@~{a}o @'{e} mostrada no formato @code{grind} sem reclama@value{cedilha}@~{a}o.
@code{fortran} n@~{a}o conhece listas, arrays ou fun@value{cedilha}@~{o}es.

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

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

@code{fortran} avalia seus argumentos;
colocando um ap@'{o}strofo em um argumento evita avalia@value{cedilha}@~{a}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@'{a}vel de op@value{cedilha}@~{a}o} fortspaces
Valor padr@~{a}o: @code{false}

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

@end defvr

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

@code{horner} algumas vezes melhora a estabilidade se @code{expr} for
ser numericamente avaliada.  Isso tamb@'{e}m @'{e} @'{u}til se Maxima @'{e} usado para
gerar programas para rodar em Fortran. Veja tamb@'{e}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@value{cedilha}@~{a}o} find_root (@var{f}(@var{x}), @var{x}, @var{a}, @var{b})
@deffnx {Fun@value{cedilha}@~{a}o} find_root (@var{f}, @var{a}, @var{b})
Encontra a ra@'{i}z da fun@value{cedilha}@~{a}o @var{f} com a vari@'{a}vel @var{x} percorrendo o intervalo @code{[@var{a}, @var{b}]}.
A fun@value{cedilha}@~{a}o deve ter um
sinal diferente em cada ponto final.  Se essa condi@value{cedilha}@~{a}o n@~{a}o for alcan@value{cedilha}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 @'{e} cont@'{i}nuo) @code{find_root} @'{e}
garantido vir para cima com a ra@'{i}z (ou um deles se existir mais
que uma ra@'{i}z).  A precis@~{a}o de @code{find_root} @'{e} governada por
@code{intpolabs} e @code{intpolrel} os quais devem ser n@'{u}meros em ponto flutuante
n@~{a}o negativos.  @code{find_root} encerrar@'{a} quando o primeiro argumento avaliar para
alguma coisa menor que ou igual a @code{intpolabs} ou se sucessivas
aproxima@value{cedilha}@~{o}es da ra@'{i}z diferirem por n@~{a}o mais que @code{intpolrel * <um dos aproximandos>}.
O valor padr@~{a}o de @code{intpolabs} e @code{intpolrel} s@~{a}o
0.0 de forma que @code{find_root} pega como boa uma resposta como for poss@'{i}vel com a
precis@~{a}o aritm@'{e}tica simples que tivermos.  O primeiro argumento pode ser uma
equa@value{cedilha}@~{a}o.  A ordem dos dois @'{u}ltimos argumentos @'{e} irrelevante.  Dessa forma

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

@'{e} equivalente a

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

O m@'{e}todo usado @'{e} uma busca bin@'{a}ria no intervalo especificado pelos @'{u}ltimos
dois argumentos.  Quando o resultado da busca for encontrado a fun@value{cedilha}@~{a}o @'{e} fechada o suficiente para ser
linear, isso inicia usando interpola@value{cedilha}@~{a}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@'{a}vel de op@value{cedilha}@~{a}o} find_root_abs
Valor padr@~{a}o: 0.0

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

@end defvr

@defvr {Vari@'{a}vel de op@value{cedilha}@~{a}o} find_root_error
Valor padr@~{a}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@value{cedilha}@~{a}o
a ser resolvida satisfaz ou n@~{a}o a condi@value{cedilha}@~{a}o que os valores da
fun@value{cedilha}@~{a}o nos pontos finais do intervalo de interpola@value{cedilha}@~{a}o s@~{a}o opostos
em sinal.  Se eles forem de sinais opostos, a interpola@value{cedilha}@~{a}o prossegue.
Se eles forem de mesmo sinal, e @code{find_root_error} for @code{true}, ent@~{a}o um erro @'{e}
sinalizado.  Se eles forem de mesmo sinal e @code{find_root_error} n@~{a}o for @code{true}, o
valor de @code{find_root_error} @'{e} retornado.  Dessa forma para montagem de gr@'{a}fico, @code{find_root_error}
pode ser escolhida para 0.0.

@end defvr

@defvr {Vari@'{a}vel de op@value{cedilha}@~{a}o} find_root_rel
Valor padr@~{a}o: 0.0

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

@end defvr

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

@code{newton} permite que vari@'{a}veis indefinidas apare@value{cedilha}am em @var{expr},
contanto que o teste de termina@value{cedilha}@~{a}o @code{abs(@var{expr}) < @var{eps}} avalie
para @code{true} ou @code{false}.
Dessa forma n@~{a}o @'{e} necess@'{a}rio que @var{expr} avalie para um n@'{u}mero.

@code{load(newton1)} chama essa fun@value{cedilha}@~{a}o.

Veja tamb@'{e}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 Fun@value{cedilha}@~{o}es e Vari@'{a}veis Definidas para S@'{e}ries de Fourier, , Fun@value{cedilha}@~{o}es e Vari@'{a}veis Definidas para Num@'{e}rico, Num@'{e}rico
@section Fun@value{cedilha}@~{o}es e Vari@'{a}veis Definidas para S@'{e}ries de Fourier

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

@c NEEDS EXAMPLES
@end deffn

@deffn {Fun@value{cedilha}@~{a}o} remfun (@var{f}, @var{expr})
@deffnx {Fun@value{cedilha}@~{a}o} remfun (@var{f}, @var{expr}, @var{x})
@code{remfun (@var{f}, @var{expr})}
substitue todas as ocorr@^{e}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@^{e}ncias de @code{@var{f} (@var{arg})} por @var{arg} em @var{expr}
somente se @var{arg} contiver a vari@'{a}vel @var{x}.

@c NEEDS EXAMPLES
@end deffn

@deffn {Fun@value{cedilha}@~{a}o} funp (@var{f}, @var{expr})
@deffnx {Fun@value{cedilha}@~{a}o} funp (@var{f}, @var{expr}, @var{x})
@code{funp (@var{f}, @var{expr})}
retorna @code{true} se @var{expr} cont@'{e}m a fun@value{cedilha}@~{a}o @var{f}.

@code{funp (@var{f}, @var{expr}, @var{x})}
retorna @code{true} se @var{expr} cont@'{e}m a fun@value{cedilha}@~{a}o @var{f} e a vari@'{a}vel
@var{x} em algum lugar no argumento de uma das inst@^{a}ncias de @var{f}.

@c NEEDS EXAMPLES
@end deffn

@deffn {Fun@value{cedilha}@~{a}o} absint (@var{f}, @var{x}, @var{halfplane})
@deffnx {Fun@value{cedilha}@~{a}o} absint (@var{f}, @var{x})
@deffnx {Fun@value{cedilha}@~{a}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@value{cedilha}@~{a}o a
@var{x} no dado semi-plano (@code{pos}, @code{neg}, ou @code{both}).
@var{f} pode conter express@~{o}es da forma
@code{abs (x)}, @code{abs (sin (x))}, @code{abs (a) * exp (-abs (b) * abs (x))}.

@code{absint (@var{f}, @var{x})} @'{e} 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@value{cedilha}@~{a}o a @var{x} de @var{a} at@'{e} @var{b}.
@c SAME LIST AS ABOVE ??
@var{f} pode incluir valores absolutos.

@c NEEDS EXAMPLES
@end deffn

@c NEEDS EXPANSION
@deffn {Fun@value{cedilha}@~{a}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@value{cedilha}@~{a}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@'{a}vel de op@value{cedilha}@~{a}o} sinnpiflag
Valor padr@~{a}o: @code{true}

Veja @code{foursimp}.

@end defvr

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

Veja @code{foursimp}.

@end defvr

@c NEEDS EXPANSION. EXPLAIN x AND p HERE (DO NOT REFER SOMEWHERE ELSE)
@deffn {Fun@value{cedilha}@~{a}o} fourexpand (@var{l}, @var{x}, @var{p}, @var{limit})
Constr@'{o}i e retorna a s@'{e}rie de Fourier partindo da lista de
coeficientes de Fourier @var{l} at@'{e} (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@value{cedilha}@~{a}o} fourcos (@var{f}, @var{x}, @var{p})
Retorna os coeficientes do cosseno de Fourier para @code{@var{f}(@var{x})} definida sobre @code{[0, %pi]}.

@c NEEDS EXAMPLES
@end deffn

@c NEEDS EXPANSION
@deffn {Fun@value{cedilha}@~{a}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@value{cedilha}@~{a}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@value{cedilha}@~{a}o} fourint (@var{f}, @var{x})
Constr@'{o}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@value{cedilha}@~{a}o} fourintcos (@var{f}, @var{x})
Retorna os coeficientes da integral do cosseno de Fourier para @code{@var{f}(@var{x})} on @code{[0, inf]}.

@c NEEDS EXAMPLES
@end deffn

@c NEEDS EXPANSION
@deffn {Fun@value{cedilha}@~{a}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
