Próximo: Arrays, Anterior: Equações Diferenciais [Conteúdo][Índice]
Próximo: Pacotes de Fourier, Anterior: Numérico, Acima: Numérico [Conteúdo][Índice]
Próximo: Definições para Numérico, Anterior: Introdução a Numérico, Acima: Numérico [Conteúdo][Índice]
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 Definições para Séries.
Próximo: Definições para Séries de Fourier, Anterior: Pacotes de Fourier, Acima: Numérico [Conteúdo][Índice]
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.
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.
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.
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 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 demonstração do pacote fft.
Valor por omissã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.
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
Valor por omissão: false
Quando fortspaces for true, fortran preenche
cada linha mostrada com espaços em branco até completar 80 columas.
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
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
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.
Valor por omissã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.
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.
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
Anterior: Definições para Numérico, Acima: Numérico [Conteúdo][Índice]
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).
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.
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.
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.
Retorna uma lista de coeficientes de Fourier de f(x) definidos
sobre o intervalo [-p, p].
Simplifica sin (n %pi) para 0 se sinnpiflag for true e
cos (n %pi) para (-1)^n se cosnpiflag for true.
Valor por omissão: true
Veja foursimp.
Valor por omissão: true
Veja foursimp.
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.
Retorna os coeficientes do co-seno de Fourier para f(x) definida sobre [0, %pi].
Retorna os coeficientes do seno de Fourier para f(x) definida sobre [0, p].
Retorna fourexpand (foursimp (fourier (f, x, p)), x, p, 'inf).
Constrói e retorna uma lista de coeficientes de integral de Fourier de f(x)
definida sobre [minf, inf].
Retorna os coeficientes da integral do co-seno de Fourier para f(x) on [0, inf].
Retorna os coeficientes da integral do seno de Fourier para f(x) on [0, inf].
Próximo: Arrays, Anterior: Equações Diferenciais [Conteúdo][Índice]