[ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
23.1 Introducción a los métodos numéricos | ||
23.2 Series de Fourier | ||
23.3 Definiciones para los métodos numéricos | ||
23.4 Definiciones para las series de Fourier |
[ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
[ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
El paquete fft
contiene funciones para el cálculo numérico (no simbólico) de la transformada rápida de Fourier. La instrucción load ("fft")
carga el paquete. Véase fft
.
El paquete fourie
contiene funciones para el cálculo simbólico de series de Fourier. La instrucción
load ("fourie")
carga el paquete. Hay funciones en el paquete fourie
para calcular los coeficientes de Fourier y para la transformación de expresiones. Véase Definiciones para las series de Fourier
.
[ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
Transforma valores complejos de la forma r %e^(%i t)
a la forma a + b %i
. La instrucción
load ("fft")
carga esta función en Maxima. Véase también fft
.
El módulo y la fase, r
y t
, se toman de magnitude_array y phase_array, respectivamente. Los valores originales de los arreglos de entrada se reemplazan por las partes real e imaginaria, a
y b
. Los resultados se calculan como
a: r cos (t) b: r sin (t) |
Los arreglos de entrada deben ser de igual tamaño y de dimensión 1. El tamaño del arreglo no necesita ser potencia de 2.
La función polartorect
es la inversa de recttopolar
.
Transforma valores complejos de la forma a + b %i
a la forma r %e^(%i t)
. La instrucción
load ("fft")
carga esta función en Maxima. Véase también fft
.
Las partes real e imaginaria, a
y b
, se toman de real_array y imaginary_array, respectivamente. Los valores originales de los arreglos de entrada se reemplazan por el módulo y el argumento, r
y t
. Los resultados se calculan como
r: sqrt (a^2 + b^2) t: atan2 (b, a) |
El ángulo calculado está en el rango entre -%pi
y %pi
.
Los arreglos de entrada deben ser de igual tamaño y de dimensión 1. El tamaño del arreglo no necesita ser potencia de 2.
La función recttopolar
es la inversa de polartorect
.
Tranformada discreta inversa de Fourier. La instrucción load ("fft")
carga esta función en Maxima.
La función ift
calcula la transformada rápida inversa compleja de Fourier de arreglos unidimensionales de números decimales en coma flotante. La transformada inversa se define como
x[j]: sum (y[j] exp (+2 %i %pi j k / n), k, 0, n-1) |
Véase fft
para más detalles.
Transformada rápida de Fourier y funciones asociadas. La instrucción load ("fft")
carga estas funciones en Maxima.
Las funciones fft
y ift
calculan la transformada rápida compleja de Fourier y su inversa de arreglos unidimensionales de números decimales en coma flotante. El tamaño de imaginary_array debe ser igual al de real_array.
Los resultados devueltos por las funciones fft
y ift
sustituyen al contenido original de los arreglos de entrada. La función fillarray
puede hacer una copia de un array en caso de ser necesario.
La transformada discreta de Fourier y la transformada inversa se definen como sigue. Sea x
el arreglo con los datos originales, con
x[i]: real_array[i] + %i imaginary_array[i] |
Sea y
el arreglo con los datos transformados. Las transformadas directa e inversa son
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) |
Arreglos apropiados se pueden preparar con la función array
. Por ejemplo:
array (my_array, float, n-1)$ |
declara un arreglo unidimensional con n
elementos, indexado de 0 a n-1, ambos inclusive. El número de elementos, n
, debe ser par.
La función fft
se puede aplicar a datos reales (con partes imaginarias nulas) para obtener coeficientes seno y coseno. Después de llamar a la función fft
, los coeficientes del seno y coseno, llamémosles a
y b
, se pueden calcular como
a[0]: real_array[0] b[0]: 0 |
y
a[j]: real_array[j] + real_array[n-j] b[j]: imaginary_array[j] - imaginary_array[n-j] |
para j tomando valores de 1 a n/2-1, y
a[n/2]: real_array[n/2] b[n/2]: 0 |
La función recttopolar
transforma valores complejos de la forma a + b %i
a la forma r %e^(%i t)
. Véase recttopolar
.
La función polartorect
transforma valores complejos de la forma r %e^(%i t)
a la forma a + b %i
. Véase polartorect
.
La instrucción demo ("fft")
presenta una demostarción del paquete fft
.
Valor por defecto: 0
La variable fortindent
controla el margen izquierdo de las expresiones que escribe la instrucción fortran
. El valor 0 escribe con un margen normal de 6 espacios; valores positivos harán que las expresiones se escriban más a la derecha.
Escribe expr en código Fortran. La salida se escribe con márgenes, y si ésta es demasiado larga fortran
sigue escribiendo en líneas sucesivas. La función fortran
escribe el operador de exponenciación ^
como **
, e imprime un número complejo a + b %i
como (a,b)
.
El argumento expr puede ser una ecuación. En tal caso, fortran
escribe una sentencia de asignación, dándole el valor del miembro derecho de la expresión al miembro izquierdo. En particular, si el miembro derecho de expr es el nombre de una matriz, entonces fortran
escribe una sentencia de asignación para cada elemento de la matriz.
Si expr no es reconozida por fortran
, la expresión se escribe en formato grind
sin avisos. La función fortran
no reconoce listas, arreglos ni funciones.
La variable fortindent
controla el margen izquierdo de las expresiones que escribe la instrucción fortran
. El valor 0 escribe con un margen normal de 6 espacios; valores positivos harán que las expresiones se escriban más a la derecha.
Si fortspaces
vale true
, fortran
rellena las líneas con espacios de 80 columnas.
La función fortran
evalúa sus argumentos; un argumento precedido de apóstrofo previene de la evaluación.
La función fortran
siempre devuelve done
.
Ejemplos:
(%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 defecto: false
Si fortspaces
vale true
, fortran
rellena las líneas con espacios de 80 columnas.
Cambia el formato de expr según la regla de Horner utilizando x como variable principal, si ésta se especifica. El argumento x
se puede omitir, en cuyo caso se considerará como variable principal la de expr en su formato racional canónico (CRE).
La función horner
puede mejorar las estabilidad si expr
va a ser numéricamente evaluada. También es útil si Maxima se utiliza para generar programas que serán ejecutados en Fortran. Véase también 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 |
Calcula el cero de la función f cuando x varía en el rango [a, b]
.
La función debe tener signos diferentes en los extremos del intervalo. Si esta condición no se cumple, la acción de esta función la gobierna la variable find_root_error
. Si find_root_error
vale true
entonces se emite un mensaje de error, en otro caso se devuelve el valor de find_root_error
. En caso contrario, dado que Maxima pouede evaluar el primer argumento en el rango especificado, el cual es continuo, está garantizado que find_root
encontrará el cero buscado (o uno de ellos en caso de haber varios). La precisión de find_root
está gobernada por find_root_abs
y find_root_rel
, que deben ser números no negativos en coma flotante. La función find_root
se detendrá cuando el primer argumento tome un valor menor o igual que find_root_abs
, o cuando sucesivas aproximaciones de la raíz se diferencien en menos de find_root_rel * <one of the approximants>
. El valor por defecto de find_root_abs
y find_root_rel
es 0.0 en ambos casos, de forma que find_root
obtiene la mejor aproximación posible para la aritmética de simple precisión de que se dispone. El primer argumento puede ser una ecuación. La ordenación de los dos últimos argumentos es irrelevante. Así,
find_root (sin(x) = x/2, x, %pi, 0.1); |
equivale a
find_root (sin(x) = x/2, x, 0.1, %pi); |
El método que se aplica es una búsqueda binaria en el rango especificado por los dos últimos argumentos. Cuando el algoritmo considera que la función está lo suficientemente cerca de ser lineal, comienza a utilizar interpolación lineal.
Ejemplos:
(%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 defecto: 0.0
La variable find_root_abs
es la precisión de la instrucción find_root
, cuyo comportamiento lo controlan find_root_abs
y find_root_rel
, variables que deben guardar dos números no negativos decimales en coma flotante. La función find_root
parará cuando su primer argumento tome un valor menor o igual que find_root_abs
o si sucesivas aproximaciones a la raíz difieren entre sí en no más de find_root_rel * <one of the approximants>
.
El valor por defecto de find_root_abs
y find_root_rel
es 0.0 en ambos casos, de forma que find_root
obtiene la mejor aproximación posible para la aritmética de simple precisión de que se dispone.
Valor por defecto: true
La variable find_root_error
controla el comportamiento de find_root
.
Cuando se llama a la función find_root
, ésta determina si la función a ser resuelta satisface la condición de que sus valores en los extremos de los intervalos tengan signos diferentes. Si son de signo opuesto, se procede a la interpolación. Si son del mismo signo, y find_root_error
vale true
, entonces se señala un error. Si son del mismo signo y find_root_error
no vale true
, retornará el valor de find_root_error
.
Valor por defecto: 0.0
La variable find_root_rel
es la precisión de la instrucción find_root
, cuyo comportamiento lo controlan find_root_abs
y find_root_rel
, variables que deben guardar dos números no negativos decimales en coma flotante. La función find_root
parará cuando su primer argumento tome un valor menor o igual que find_root_abs
o si sucesivas aproximaciones a la raíz difieren entre sí en no más de find_root_rel * <one of the approximants>
.
El valor por defecto de find_root_abs
y find_root_rel
es 0.0 en ambos casos, de forma que find_root
obtiene la mejor aproximación posible para la aritmética de simple precisión de que se dispone.
[ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
Devuelve true
si equal (x, y)
, en otro caso devuelve false
. No devuelve el mensaje de error que se obtiene de equal (x, y)
en un caso como éste.
La llamada remfun (f, expr)
reemplaza todas las subexpresiones f (arg)
por arg en expr.
La llamada remfun (f, expr, x)
reemplaza todas las subexpresiones f (arg)
por arg en expr sólo si arg contiene a la variable x.
La llamada funp (f, expr)
devuelve true
si expr contiene la función f.
La llamada funp (f, expr, x)
devuelve true
si expr contiene la función f y la variable x está presente en el argumento de alguna de las presencias de f.
La llamada absint (f, x, halfplane)
devuelve la integral indefinida de f con respecto a
x en el semiplano dado (pos
, neg
o both
). La función f puede contener expresiones de la forma abs (x)
, abs (sin (x))
, abs (a) * exp (-abs (b) * abs (x))
.
La llamada absint (f, x)
equivale a absint (f, x, pos)
.
La llamada absint (f, x, a, b)
devuelve la integral definida de f con respecto a x de a a b.
Devuelve una lista con los coeficientes de Fourier de f(x)
definida en el intervalo [-%pi, %pi]
.
Simplifica sin (n %pi)
a 0 si sinnpiflag
vale true
y
cos (n %pi)
a (-1)^n
si cosnpiflag
vale true
.
Valor por defecto: true
Véase foursimp
.
Valor por defecto: true
Véase foursimp
.
Calcula y devuelve la serie de Fourier a partir de la lista de los coeficientes de Fourier l hasta el término limit (limit puede ser inf
). Los argumentos x y p tienen el mismo significado que en
fourier
.
Devuelve los coeficientes de los cosenos de Fourier de f(x)
definida en [0, %pi]
.
Devuelve los coeficientes de los senos de Fourier de f(x)
definida en [0, %pi]
.
Devuelve fourexpand (foursimp (fourier (f, x, p)), x, p, 'inf)
.
Calcula y devuelve la lista de los coeficientes integrales de Fourier de f(x)
definida en [minf, inf]
.
Devuelve los coeficientes integrales de los cosenos f(x)
en [0, inf]
.
Devuelve los coeficientes integrales de los senos f(x)
en [0, inf]
.
[ << ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
This document was generated by root on octubre, 18 2006 using texi2html 1.76.