Funciones para la resolución numérica de ecuaciones (Manual de Maxima 5.46.0)

Siguiente: Introducción a la resolución numérica de ecuaciones diferenciales, Anterior: Funciones y variables para la transformada rápida de Fourier, Subir: Métodos numéricos [Índice general][Índice]

### 22.3 Funciones para la resolución numérica de ecuaciones

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, [abserr, relerr]) ¶
Función: find_root (f, a, b, [abserr, relerr]) ¶
Función: bf_find_root (expr, x, a, b, [abserr, relerr]) ¶
Función: bf_find_root (f, a, b, [abserr, relerr]) ¶
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 por bipartición. Si la expresión es lo suficientemente suave, entonces `find_root` aplicará el método de interpolación lineal.

  `bf_find_root` es una versión de `find_root` para números reales de precisión arbitraria (bigfloat). La función se evalúa utilizando la aritmética de estos números, devolviendo un resultado numérico de este tipo. En cualquier otro aspecto, `bf_find_root` es idéntica a `find_root`, siendo la explicación que sigue igualmente válida para `bf_find_root`.

  La precisión de `find_root` está controlada por `abserr` y `relerr`, que son claves opcionales para `find_root`. Estas claves toman la forma `key=val`. Las claves disponibles son:

  `abserr`

    Error absoluto deseado de la función en la raíz. El valor por defecto es `find_root_abs`.

  `relerr`

    Error relativo deseado de la raíz. El valor por defecto es `find_root_rel`.

  `find_root` se detiene cuando la función alcanza un valor menor o igual que `abserr`, o si las sucesivas aproximaciones x_0, x_1 difieren en no más que `relerr * 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 la función toma valores numéricos en ambos extremos y estos números son del mismo signo, entonces 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
      (%i9) fpprec:32;
      (%o9)                           32
      (%i10) bf_find_root (exp(x) = y, x, 0, 100), y = 10;
      (%o10)                  2.3025850929940456840179914546844b0
      (%i11) log(10b0);
      (%o11)                  2.3025850929940456840179914546844b0

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

Siguiente: Introducción a la resolución numérica de ecuaciones diferenciales, Anterior: Funciones y variables para la transformada rápida de Fourier, Subir: Métodos numéricos [Índice general][Índice]