[ < ] [ > ]   [ << ] [ Up ] [ >> ]         [Top] [Contents] [Índice] [ ? ]

23. Numérico


[ < ] [ > ]   [ << ] [ Up ] [ >> ]         [Top] [Contents] [Índice] [ ? ]

23.1 Introdução a Numérico


[ < ] [ > ]   [ << ] [ Up ] [ >> ]         [Top] [Contents] [Índice] [ ? ]

23.2 Pacotes de Fourier

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

O pacote fourie compreende funções para computação simbólica de séries de Fourier. load ("fourie") chama esse pacote. Existem funções no pacote fourie para calcular coeficientes da integral de Fourier e algumas funções para manipulação de expressões. Veja Funções e Variáveis Definidas para Séries.


[ < ] [ > ]   [ << ] [ Up ] [ >> ]         [Top] [Contents] [Índice] [ ? ]

23.3 Funções e Variáveis Definidas para Numérico

Funçã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 funçã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 função inversa de recttopolar.

Funçã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 funçã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 função inversa de polartorect.

Função: ift (real_array, imaginary_array)

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

ift realiza a transformação rápida complexa de Fourier sobre arrays em ponto flutuante unidimensionais. A transformaçã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.

Função: fft (real_array, imaginary_array)
Função: ift (real_array, imaginary_array)
Função: recttopolar (real_array, imaginary_array)
Função: polartorect (magnitude_array, phase_array)

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

fft e ift realiza transformação rápida complexa de Fourier e a transformaçã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 função 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 x sendo os dados originais, com

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

Tome y sendo os dados transformados. A transformação normal e sua transformaçã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 funçã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 cosseno. Após chamar fft, os coeficientes seno e cosseno, 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 demonstração do pacote fft.

Variável de opção: fortindent

Valor padrão: 0

fortindent controla a margem esquerda de indentação de expressões mostradas pelo comando 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.

Função: fortran (expr)

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

expr pode ser uma equação. Nesse caso, 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 expr é um nome de uma matriz, então fortran mostra uma declaração de atribuição para cada elemento da matriz.

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

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

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

fortran avalia seus argumentos; colocando um apóstrofo em um argumento evita avaliaçã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 opção: fortspaces

Valor padrão: false

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

Função: horner (expr, x)
Função: horner (expr)

Retorna uma representaçã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
Função: find_root (f(x), x, a, b)
Função: find_root (f, a, b)

Encontra a raíz da função f com a variável x percorrendo o intervalo [a, 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 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 aproximaçõ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 equaçã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 função é fechada o suficiente para ser linear, isso inicia usando interpolaçã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 opção: find_root_abs

Valor padrã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 opção: find_root_error

Valor padrão: true

find_root_error governa o comportamento de find_root. Quando 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 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 opção: find_root_rel

Valor padrã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.

Função: newton (expr, x, x_0, eps)

Retorna uma solução aproximada de expr = 0 através do método de Newton, considerando expr como sendo uma função de uma variável, x. A busca pela solução começa 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 apareçam em expr, contanto que o teste de terminaçã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 funçã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

[ < ] [ > ]   [ << ] [ Up ] [ >> ]         [Top] [Contents] [Índice] [ ? ]

23.4 Funções e Variáveis Definidas para Séries de Fourier

Funçã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).

Função: remfun (f, expr)
Funçã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.

Função: funp (f, expr)
Função: funp (f, expr, x)

funp (f, expr) retorna true se expr contém a função f.

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

Função: absint (f, x, halfplane)
Função: absint (f, x)
Função: absint (f, x, a, b)

absint (f, x, halfplane) retorna a integral indefinida de f com relaçã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 relação a x de a até b. f pode incluir valores absolutos.

Função: fourier (f, x, p)

Retorna uma lista de coeficientes de Fourier de f(x) definidos sobre o intervalo [-p, p].

Funçã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 opção: sinnpiflag

Valor padrão: true

Veja foursimp.

Variável de opção: cosnpiflag

Valor padrão: true

Veja foursimp.

Funçã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.

Função: fourcos (f, x, p)

Retorna os coeficientes do cosseno de Fourier para f(x) definida sobre [0, %pi].

Função: foursin (f, x, p)

Retorna os coeficientes do seno de Fourier para f(x) definida sobre [0, p].

Função: totalfourier (f, x, p)

Retorna fourexpand (foursimp (fourier (f, x, p)), x, p, 'inf).

Função: fourint (f, x)

Constrói e retorna uma lista de coeficientes de integral de Fourier de f(x) definida sobre [minf, inf].

Função: fourintcos (f, x)

Retorna os coeficientes da integral do cosseno de Fourier para f(x) on [0, inf].

Função: fourintsin (f, x)

Retorna os coeficientes da integral do seno de Fourier para f(x) on [0, inf].


[ << ] [ >> ]           [Top] [Contents] [Índice] [ ? ]

This document was generated by Robert Dodier on Dezembro, 22 2007 using texi2html 1.76.