Introducción a los métodos numéricos
====================================

Series de Fourier
=================

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 Funciones y variables para las series de Fourier.

Funciones y variables para los métodos numéricos
================================================

 -- Función: polartorect (MAGNITUDE_ARRAY, PHASE_ARRAY)

     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.

 -- Función: recttopolar (REAL_ARRAY, IMAGINARY_ARRAY)

     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.

 -- Función: ift (REAL_ARRAY, IMAGINARY_ARRAY)

     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.

 -- Función: fft (REAL_ARRAY, IMAGINARY_ARRAY)
 -- Función: ift (REAL_ARRAY, IMAGINARY_ARRAY)
 -- Función: recttopolar (REAL_ARRAY, IMAGINARY_ARRAY)
 -- Función: polartorect (MAGNITUDE_ARRAY, PHASE_ARRAY)

     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.

 -- Variable opcional: fortindent
     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.

 -- Función: fortran (EXPR)
     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

 -- Variable opcional: fortspaces
     Valor por defecto: false

     Si fortspaces vale true, fortran rellena las líneas con espacios de 80 columnas.

 -- Función: horner (EXPR, X)
 -- Función: horner (EXPR)
     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

 -- Función: find_root (EXPR, X, A, B)
 -- Función: find_root (F, A, B)
 -- Variable opcional: find_root_error
 -- Variable opcional: find_root_abs
 -- Variable opcional: find_root_rel

     Calcula una raíz de la expresión EXPR o de la función F en el intervalo cerrado [A, B]. La expresión EXPR puede ser una ecuación, en cuyo caso find_root busca una raíz de lhs(EXPR) - rhs(EXPR).

     Dado que Maxima puede evaluar EXPR o F en [A, B], entonces, si EXPR o F es continua, find_root encuentrará la raíz buscada; o raíces en caso de existir varias.

     La función find_root aplica al principio la búsqueda binaria. Si la expresión es lo suficientemente suave, entonces find_root aplicará el método de interpolación lineal.

     La precisión del resultado se controla con find_root_abs y find_root_rel. La búsqueda se detiene cuando la función alcanza valores menores o iguales a find_root_abs, o cuando dos soluciones sucesivas X_0 y X_1 se diferencian en una cantidad menor o igual a find_root_rel * max(abs(x_0), abs(x_1)). Los valores por defecto de find_root_abs y find_root_rel son ambos cero.

     find_root espera que la función en cuestión tenga signos diferentes en los extremos del intervalo. Si esto no se verifica, el comportamiento de find_root se controla con find_root_error. Cuando find_root_error vale true, find_root devuelve un mensaje de error; en caso contrario, find_root devuelve el valor de find_root_error. El valor por defecto de find_root_error es true.

     Si en algún momento del proceso de búsqueda F alcanza un valor no numérico, find_root devuelve una expresión parcialmente evaluada.

     Se ignora el orden de A y B; la región de búsqueda es [min(A, B), max(A, B)].

     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
          (%i6) find_root (exp(x) = y, x, 0, 100);
                                      x
          (%o6)           find_root(%e  = y, x, 0.0, 100.0)
          (%i7) find_root (exp(x) = y, x, 0, 100), y = 10;
          (%o7)                   2.302585092994046
          (%i8) log (10.0);
          (%o8)                   2.302585092994046

 -- Función: newton (EXPR, X, X_0, EPS)
     Devuelve una solución aproximada de EXPR = 0 obtenida por el método de Newton, considerando EXPR como una función de una variable, X. La búsqueda comienza con X = X_0 y continúa hasta que se verifique abs(EXPR) < EPS, donde EXPR se evalúa con el valor actual de X.

     La función newton permite que en EXPR haya variables no definidas, siempre y cuando la condición de terminación abs(EXPR) < EPS pueda reducirse a un valor lógico true o false; de este modo, no es necesario que EXPR tome un valor numérico.

     Ejecútese load(newton1) para cargar esta función.

     Véanse también realroots, allroots, find_root y mnewton.

     Ejemplos:

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

Funciones y variables para las series de Fourier
================================================

 -- Función: equalp (X, Y)
     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.

 -- Función: remfun (F, EXPR)
 -- Función: remfun (F, EXPR, X)
     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.

 -- Función: funp (F, EXPR)
 -- Función: funp (F, EXPR, 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.

 -- Función: absint (F, X, HALFPLANE)
 -- Función: absint (F, X)
 -- Función: absint (F, X, A, B)
     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.

 -- Función: fourier (F, X, P)
     Devuelve una lista con los coeficientes de Fourier de F(X) definida en el intervalo [-p, p].

 -- Función: foursimp (L)
     Simplifica sin (n %pi) a 0 si sinnpiflag vale true y cos (n %pi) a (-1)^n si cosnpiflag vale true.

 -- Variable opcional: sinnpiflag
     Valor por defecto: true

     Véase foursimp.

 -- Variable opcional: cosnpiflag
     Valor por defecto: true

     Véase foursimp.

 -- Función: fourexpand (L, X, P, LIMIT)
     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.

 -- Función: fourcos (F, X, P)
     Devuelve los coeficientes de los cosenos de Fourier de F(X) definida en [0, P].

 -- Función: foursin (F, X, P)
     Devuelve los coeficientes de los senos de Fourier de F(X) definida en [0, P].

 -- Función: totalfourier (F, X, P)
     Devuelve fourexpand (foursimp (fourier (F, X, P)), X, P, 'inf).

 -- Función: fourint (F, X)
     Calcula y devuelve la lista de los coeficientes integrales de Fourier de F(X) definida en [minf, inf].

 -- Función: fourintcos (F, X)
     Devuelve los coeficientes integrales de los cosenos  F(X) en [0, inf].

 -- Función: fourintsin (F, X)
     Devuelve los coeficientes integrales de los senos  F(X) en [0, inf].