Introducedilhaão a Numérico
===========================

Pacotes de Fourier
==================

O pacote fft compreende funcedilhaões para computacedilhaão numérica (não simbólica) das transformacedilhaões rápidas de Fourier. load ("fft") chama esse pacote. Veja fft.

O pacote fourie compreende funcedilhaões para computacedilhaão simbólica de séries de Fourier. load ("fourie") chama esse pacote. Existem funcedilhaões no pacote fourie para calcular coeficientes da integral de Fourier e algumas funcedilhaões para manipulacedilhaão de expressões. Veja Definicedilhaões para Séries.

Definicedilhaões para Numérico
==============================

 -- Funcedilhaão: polartorect (MAGNITUDE_ARRAY, PHASE_ARRAY)

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

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

          a: r cos (t)
          b: r sin (t)

     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.

     polartorect é a funcedilhaão inversa de recttopolar.

 -- Funcedilhaão: recttopolar (REAL_ARRAY, IMAGINARY_ARRAY)

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

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

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

     O ângulo calculado encontra-se no intervalo de -%pi a %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.

     recttopolar é a funcedilhaão inversa de polartorect.

 -- Funcedilhaão: ift (REAL_ARRAY, IMAGINARY_ARRAY)

     Transformacedilhaão rápida inversa discreta de Fourier . load ("fft") chama essa funcedilhaão dentro do Maxima.

     ift realiza a transformacedilhaão rápida complexa de Fourier sobre arrays em ponto flutuante unidimensionais. A transformacedilhaão inversa é definida como

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

     Veja fft para maiores detalhes.

 -- Funcedilhaão: fft (REAL_ARRAY, IMAGINARY_ARRAY)
 -- Funcedilhaão: ift (REAL_ARRAY, IMAGINARY_ARRAY)
 -- Funcedilhaão: recttopolar (REAL_ARRAY, IMAGINARY_ARRAY)
 -- Funcedilhaão: polartorect (MAGNITUDE_ARRAY, PHASE_ARRAY)

     Transformacedilhaão rápidada de Fourier e funcedilhaões relacionadas. load ("fft") chama essas funcedilhaões dentro do Maxima.

     fft e ift realiza transformacedilhaão rápida complexa de Fourier e a transformacedilhaão inversa, respectivamente, sobre arrays em ponto flutuante unidimensionais. O tamanho de IMAGINARY_ARRAY deve ser igual ao tamanho de REAL_ARRAY.

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

     A transformacedilhaão discreta de Fourier e sua transformacedilhaão inversa são definidas como segue. Tome x sendo os dados originais, com

          x[i]: real_array[i] + %i imaginary_array[i]

     Tome y sendo os dados transformados. A transformacedilhaão normal e sua transformacedilhaão inversa são

          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)

     Arrays adequadas podem ser alocadas pela funcedilhaão array. Por exemplo:

          array (my_array, float, n-1)$

     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.

     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 fft, os coeficientes seno e co-seno, digamos a e b, podem ser calculados como

          a[0]: real_array[0]
          b[0]: 0

     e

          a[j]: real_array[j] + real_array[n-j]
          b[j]: imaginary_array[j] - imaginary_array[n-j]

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

          a[n/2]: real_array[n/2]
          b[n/2]: 0

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

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

     demo ("fft") exibe uma demonstracedilhaão do pacote fft.

 -- Variável de opcedilhaão: fortindent
     Valor por omissão: 0

     fortindent controla a margem esquerda de indentacedilhaão de expressões mostradas pelo comando fortran.  0 fornece indentacedilhaão normal (i.e., 6 espacedilhaos), e valores positivos farão com que expressões sejam mostrados mais além para a direita.

 -- Funcedilhaão: fortran (EXPR)
     Mostra EXPR como uma declaracedilhaão Fortran. A linha de saída é indentada com espacedilhaos. Se a linha for muito longa, fortran imprime linhas de continuacedilhaão. fortran mostra o operador de exponenciacedilhaão ^ como **, e mostra um número complexo a + b %i na forma (a,b).

     EXPR pode ser uma equacedilhaão. Nesse caso, fortran mostra uma declaracedilhaão de atribuicedilhaão, atribuindo o primeiro membro (esquerda) da equacedilhaão ao segundo membro (direita). Em particular, se o primeiro membro EXPR é um nome de uma matriz, então fortran mostra uma declaracedilhaão de atribuicedilhaão para cada elemento da matriz.

     Se EXPR não for alguma coisa reconhecida por fortran, a expressão é mostrada no formato grind sem reclamacedilhaão. fortran não conhece listas, arrays ou funcedilhaões.

     fortindent controla o margem esquerda das linhas mostradas. 0 é a margem normal (i.e., indentada 6 espacedilhaos). Incrementando fortindent faz com que expressões sejam mostradas adiante para a direita.

     quando fortspaces for true, fortran preenche cada linha mostrada com espacedilhaos em branco até completar 80 columas.

     fortran avalia seus argumentos; colocando um apóstrofo em um argumento evita avaliacedilhaão. fortran sempre retorna done.

     Exemplos:

          (%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

 -- Variável de opcedilhaão: fortspaces
     Valor por omissão: false

     Quando fortspaces for true, fortran preenche cada linha mostrada com espacedilhaos em branco até completar 80 columas.

 -- Funcedilhaão: horner (EXPR, X)
 -- Funcedilhaão: horner (EXPR)
     Retorna uma representacedilhaão rearranjada de EXPR como na regra de Horner, usando X como variável principal se isso for especificado. x pode ser omitido e nesse caso a variável principal da forma de expressão racional canónica de EXPR é usada.

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

          (%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

 -- Funcedilhaão: find_root (F(X), X, A, B)
 -- Funcedilhaão: find_root (F, A, B)
     Encontra a raíz da funcedilhaão F com a variável X percorrendo o intervalo [A, B]. A funcedilhaão deve ter um sinal diferente em cada ponto final.  Se essa condicedilhaão não for alcancedilhaada, a action of the function is governed by find_root_error.  If find_root_error is true then an error occurs, otherwise the value of find_root_error is returned (thus for plotting 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) find_root é garantido vir para cima com a raíz (ou um deles se existir mais que uma raíz).  A precisão de find_root é governada por intpolabs e intpolrel os quais devem ser números em ponto flutuante não negativos.  find_root encerrará quando o primeiro argumento avaliar para alguma coisa menor que ou igual a intpolabs ou se sucessivas aproximacedilhaões da raíz diferirem por não mais que intpolrel * <um dos aproximandos>. O valor padrão de intpolabs e intpolrel são 0.0 de forma que 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 equacedilhaão.  A ordem dos dois últimos argumentos é irrelevante.  Dessa forma

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

     é equivalente a

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

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

     Examples:

          (%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

 -- Variável de opcedilhaão: find_root_abs
     Valor por omissão: 0.0

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

 -- Variável de opcedilhaão: find_root_error
     Valor por omissão: true

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

 -- Variável de opcedilhaão: find_root_rel
     Valor por omissão: 0.0

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

 -- Funcedilhaão: newton (EXPR, X, X_0, EPS)
     Retorna uma solucedilhaão aproximada de EXPR = 0 através do método de Newton, considerando EXPR como sendo uma funcedilhaão de uma variável, X. A busca pela solucedilhaão comecedilhaa com X = X_0 e prossegue até abs(EXPR) < EPS (com EXPR avaliada para o valor corrente de X).

     newton permite que variáveis indefinidas aparecedilhaam em EXPR, contanto que o teste de terminacedilhaão abs(EXPR) < EPS avalie para true ou false. Dessa forma não é necessário que EXPR avalie para um número.

     load(newton1) chama essa funcedilhaão.

     Veja também realroots, allroots, find_root, e mnewton.

     Exemplos:

          (%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

Definicedilhaões para Séries de Fourier
=======================================

 -- Funcedilhaão: equalp (X, Y)
     Retorna true se equal (X, Y) de outra forma false (não fornece uma mensagem de erro como equal (x, y) poderia fazer nesse caso).

 -- Funcedilhaão: remfun (F, EXPR)
 -- Funcedilhaão: remfun (F, EXPR, X)
     remfun (F, EXPR) substitue todas as ocorrências de F (ARG) por ARG em EXPR.

     remfun (F, EXPR, X) substitue todas as ocorrências de F (ARG) por ARG em EXPR somente se ARG contiver a variável X.

 -- Funcedilhaão: funp (F, EXPR)
 -- Funcedilhaão: funp (F, EXPR, X)
     funp (F, EXPR) retorna true se EXPR contém a funcedilhaão F.

     funp (F, EXPR, X) retorna true se EXPR contém a funcedilhaão F e a variável X em algum lugar no argumento de uma das instâncias de F.

 -- Funcedilhaão: absint (F, X, HALFPLANE)
 -- Funcedilhaão: absint (F, X)
 -- Funcedilhaão: absint (F, X, A, B)
     absint (F, X, HALFPLANE) retorna a integral indefinida de F com relacedilhaão a X no dado semi-plano (pos, neg, ou both). F pode conter expressões da forma abs (x), abs (sin (x)), abs (a) * exp (-abs (b) * abs (x)).

     absint (F, X) é equivalente a absint (F, X, pos).

     absint (F, X, A, B) retorna a integral definida de F com relacedilhaão a X de A até B. F pode incluir valores absolutos.

 -- Funcedilhaão: fourier (F, X, P)
     Retorna uma lista de coeficientes de Fourier de F(X) definidos sobre o intervalo [-p, p].

 -- Funcedilhaão: foursimp (L)
     Simplifica sin (n %pi) para 0 se sinnpiflag for true e cos (n %pi) para (-1)^n se cosnpiflag for true.

 -- Variável de opcedilhaão: sinnpiflag
     Valor por omissão: true

     Veja foursimp.

 -- Variável de opcedilhaão: cosnpiflag
     Valor por omissão: true

     Veja foursimp.

 -- Funcedilhaão: fourexpand (L, X, P, LIMIT)
     Constrói e retorna a série de Fourier partindo da lista de coeficientes de Fourier L até (up through) LIMIT termos (LIMIT pode ser inf). X e P possuem o mesmo significado que em fourier.

 -- Funcedilhaão: fourcos (F, X, P)
     Retorna os coeficientes do co-seno de Fourier para F(X) definida sobre [0, %pi].

 -- Funcedilhaão: foursin (F, X, P)
     Retorna os coeficientes do seno de Fourier para F(X) definida sobre [0, P].

 -- Funcedilhaão: totalfourier (F, X, P)
     Retorna fourexpand (foursimp (fourier (F, X, P)), X, P, 'inf).

 -- Funcedilhaão: fourint (F, X)
     Constrói e retorna uma lista de coeficientes de integral de Fourier de F(X) definida sobre [minf, inf].

 -- Funcedilhaão: fourintcos (F, X)
     Retorna os coeficientes da integral do co-seno de Fourier para F(X) on [0, inf].

 -- Funcedilhaão: fourintsin (F, X)
     Retorna os coeficientes da integral do seno de Fourier para F(X) on [0, inf].