¡Descarga Métodos Numéricos: Bisección y Falsa Posición - Prof. Parra y más Monografías, Ensayos en PDF de Matemáticas solo en Docsity!
1 RAICES DE ECUACIONES
DEFINICIÓN:
La raíz de una ecuación es aquel valor de la variable independiente que hace que el resultado de la ecuación sea cero o por lo menos se acerque a cero con una cierto grado de aproximación deseado (error máximo permitido).
OBJETIVOS:
Al terminar esta unidad de estudio, el estudiante estará en capacidad de:
Aprender el concepto de raíz de una ecuación Comprender las distintas técnicas usadas para hallar raíces de ecuaciones Evaluar la confiabilidad de cada método Estar en capacidad de elegir el mejor método para aplicarlo en la solución de problemas de ingeniería, relacionados con la búsqueda de raíces de una ecuación.
1.1 MÉTODOS BASADOS EN INTERVALOS
Su característica fundamental es que se elige un intervalo [a, b] dentro del cual se encuentre la raíz buscada. No hay una regla a seguir para la selección de este intervalo, sin embargo, se debe cumplir que en los extremos del intervalo la función
cambie de signo lo cual que equivale a que: f(a)*f(b) < 0. Una primera aproximación
a la solución se logra al elaborar un modelo gráfico de la ecuación y a partir de él, por simple inspección, seleccionar el intervalo más adecuado.
Figura 1. Raíces en diferentes intervalos.
Si al evaluar la función, en los extremo del intervalo elegido, presenta igual signo puede no existir raíces o existir un número impar de ellas. Si la función cambia de signo esto nos indica que al menos hay una raíz en dicho intervalo. Los casos que requieren análisis especial se presentan cuando la función tiene puntos tangentes al eje x o cuando tiene discontinuidades.
a (^) b
f(x)
x a^ b
f(x)
x No hay raíces o existe un número par de ellas
a (^) b
f(x)
x
Existe un número impar de raíces
a (^) b
f(x)
x
Tangente al eje x
a (^) b
f(x)
x
1.1.1 Criterio de convergencia. Se considera que se ha encontrado una
respuesta satisfactoria cuando el valor hallado para la variable faltante ( x) cumple con
alguno de los siguientes criterios:
f(x) < Tol ; ó ≤ Tol
r
r r- 1 X
|X -X |
Siendo Xr, y Xr-1 los valores de las dos últimas iteraciones y Tol es el nivel máximo de
error aceptado que se puede definir ya sea con base en el número de cifras
significativas (NCS) Tol = 5x10-(NCS+1)^ o en el número de cifras decimales (ND) que se
desea obtener, Tol = 5x10-(ND+1). Otro criterio para terminar el proceso es que se
exceda el número máximo de iteraciones propuesto, en cuyo caso lo más probable es que la solución no esté convergiendo hacia un valor determinado (cada vez se aleja más del valor estimado), por lo tanto se debe probar con otra estrategia de solución o revisar muy bien lo cálculos matemáticos realizados para ver si no se están cometiendo errores en el proceso.
1.1.2 Método gráfico. Lo esencial en este método es poder construir un
modelo gráfico de la ecuación y luego por inspección estimar una aproximación a la raíz.
El mayor inconveniente de éste método es su poca precisión y exactitud. Sin embargo, hoy día se cuenta con excelentes herramientas de software para realizar rápidamente gráficas con un alto grado de realismo. El primer problema a resolver es ¿que intervalo usar para construir la gráfica? No hay regla que nos diga como hacerlo, por eso lo mejor es probar con varios intervalos hasta encontrar el más adecuado, no obstante es importante considerar las características particulares del problema que vamos a resolver, ya que eso nos dará una idea del rango de posibles soluciones, por ejemplo si queremos hallar una magnitud física como velocidad, distancia, masa, etc., sabemos que no tiene sentido probar con valores negativos, por lo tanto podemos graficar rangos a partir de cero.
Como ejemplo consideremos las funciones: f(x) = seno(3x) + Cos(x) y f(x) = ex^ – x -2.
El conjunto de posibles valores que puede tomar x están en el intervalo (-∞, ∞), pero
sabemos además que la primera función tiene período 2π, lo cual nos ayuda a limitar e intervalo a graficar.
Usando MatLab podemos graficar la primera función el intervalo [0, π] y la segunda en el intervalo [-4, 4], para obtener un modelo gráfico como el de la figura 2.
Por leyes de la física se sabe que para este tipo de movimiento la velocidad está dada
por: (^ ) (^1 )
t m
c e c
gm v t
− = − donde m es la masa del objeto que cae, c es el
coeficiente de rozamiento, t es el tiempo y g es la fuerza de gravedad (9.81 m/s²
aprox.).
Solución: Si reemplazamos los valores conocidos, el único valor que queda por
averiguar es c, no es sencillo despejarlo de la ecuación, por lo tanto recurrimos a los
métodos numéricos para hallar una aproximación satisfactoria. Reemplazando los valores conocidos obtenemos:
( 1 )
- 81 * 60 40
10 60
c e c
− = −
Esta expresión es una ecuación matemática en función de c que podemos expresar
como:
( 1 ) 40
- 81 * 60 ( )
10 = −^60 −
− c e c
f c.
Podríamos resolver por ensayo y error dando valores a c e ir haciendo las respectivas
operaciones hasta que se logre obtener un valor cercano a cero en la ecuación y esa sería la solución buscada, método que probablemente nos tome mucho tiempo y cálculos matemáticos. Si elaboramos la gráfica con MatLab, obtenemos una respuesta
aproximada de 13.02 con un error cercano al 5%. (Ver figura 3).
Figura 3. Raíz aproximada de f(c) usando el método gráfico.
El archivo .m de MatLab que permite obtener esta gráfica es: clc clear all c=0.1:.01:15;
f=9.81.60./c .(1 - exp(-c.10/60))-40; plot(c,f) grid title ('f=9.81.60./c .(1 - exp(-c.10/60))-40')
No siempre la gráfica realizada con el MatLab, es la representación real de la función, esto depende le incremento que usemos para representar los valores de la variable independiente, de la resolución de la pantalla que usemos para visualizar la gráfica, del intervalo a considerar, etc. En MatLab, podemos delimitar la región que va a ser usada para trazar la gráfica y esto nos permite visualizar mejor la imagen. Veamos el siguiente ejemplo:
y = cos(x)*cosh(x)+1 en el intervalo [0,20].
El siguiente guión escrito en MatLab, permite obtener la anterior figura:
x=0:0.01:20; y = cos(x).cosh(x)+1; plot(x,y) grid subplot(1,2,1) plot(x,y) grid subplot(1,2,2) plot(x,y) AXIS([0,20,-20,20]) GRID subplot(1,2,1) TITLE('Y = cos(x)cosh(x)+1') subplot(1,2,2) TITLE('Y = cos(x)*cosh(x)+1, usando el comando AXIS([0,20,-20,20])')
La gráfica de la izquierda difiere de la de la derecha, esto se debe a que el comando AXIS permite ajustar los valores mínimo y máximo de las coordenadas x e y para
dibujar la figura. El comando es: axis([xmin, xmax, ymin, ymax]). Si un valor se
sale de esos límites, se cortan, lo cual de una imagen mas cercana a la realidad. Si se
desea una figura de forma cuadrada se pude usar el comando axis(‘square’).
El comando AXIS también puede usarse para omitir los ejes de coordenadas y la
escala, tecleando el comando axis(`off’). Para activar nuevamente los ejes se utiliza el
comando axis(‘on’).
2. r = r + 1.
3. Elija un intervalo [a, b] donde la función cambie de signo ( f(a)*f(b)) < 0).
4. La aproximación a la raíz se determina como: xr = a + (b - a)/2.
- Verifique en que mitad del intervalo queda la nueva aproximación, evaluando:
a. Si f(a)*f(xr) < 0 la raíz esta en este primer subintervalo. Haga b = xr. Vaya
al paso 3.
b. Si f(a)*f(xr) > 0 la raíz está en el segundo subintervalo derecho. Haga a =
xr. (Se cambia la cota inferior). Vaya al paso 3.
- Verificar si se cumple el criterio de convergencia:
Si f(x) < Tol ó ≤ Tol r
r r- 1 X
| X -X |
. Se ha halló la raíz y su valor es xr ; el
proceso se detiene.
Si r > maxIter: se excedió el número de iteraciones, por lo tanto la solución no
está convergiendo. Se debe parar el proceso.
- Xr-1 = Xr. Guardamos la anterior aproximación a la raíz.
- Volver al paso 3.
El siguiente programa codificado en MatLab, permite calcular raíces de ecuaciones por el método de bisección y corresponde al diagrama de flujo de la figura 5. En la parte final del programa se cambia la ecuación que se desea procesar. El programa se
ejecuta directamente desde la línea de comandos de MatLab tecleando biseccion o
abriendo el archivo y ejecutando el comando run, en el menú debug, o presionando la
tecla F5 o haciendo clic en el icono Run en la barra de herramientas.
% Programa para calcular raices de ecuaciones basado en el metodo de biseccion %autor: Ing. Edgar Romero Rodríguez %Docente Fundación Universitaria de San Gil, UISANGIL %San Gil, Santander – Colombia. Enero de 2004
function biseccion clc; clear; a=input('Valor de la cota inferior: '); b=input('Valor de la cota superior: '); TOL=input('Tolerancia de error : '); max_iter=input('Numero de iteracciones: '); iter = 0; fprintf('\nMETODO DE BISECCION...\nRESULTADOS\n') fprintf('Iter a Xr b f(a) f(xr) Error\n'); while 1 %Inicio un cliclo infinito del cual salgo al hallar la raíz o exceder max_iter xr=(b+a)/2; %Aproximo el valor de la posible raíz como el punto medio del intervalo. fa = funcion(a); %Evaluamos la función en la cota inferior fb = funcion(b); %evaluamos la función en la cota superior fxr= funcion(xr); %Evaluamos la función en la posible raíz error = abs((b - a)/a);
% Impresion de resultados en cada iteración fprintf('%4.0f,%10.6f,%10.6f,%10.6f,%10.6f,%10.6f,%12.6f\n',iter,a,xr,b,fa,fxr,error) if error <= TOL %Si supero el error aceptado detengo el proceso fprintf('Proceso concluido exitosamente con el nivel de error <= %10.6f\n\n',TOL) break; end if abs(fxr)<=TOL %Se hallo la aproximación a la raíz y salgo del ciclo infinito fprintf('\nProceso concluido exitosamente con el nivel de error <= %12.6e\n\n',TOL) break; end if fa*fxr < 0 b=xr; %La raiz esta en el primer intervalo else a=xr; %La raiz esta en el segundo intervalo end if (iter > max_iter) %Verifico si se excede el numero de iteracciones fprintf('\nNumero de iteracciones excedido...\n\n') break; end iter=iter+1; %Incremento el numero de iteracciones end fprintf('Raiz aproximada: %12.6f',xr); fprintf(' Iteraciones : %5.0f\n',iter); % Modelo gráfico x=CotaInf:0.01:CotaSup; f=funcion(x); plot(x,f) gris
function y=funcion(x) %A continuación debo colocar la función a evaluar y=cos(x); % fin del programa
Ejemplo 2: Si evaluamos f(x) = cos(x) en el intervalo [1, 2], con cuatro cifras
significativas obtenemos:
Valor de la cota inferior : 1 Valor de la cota superior: 2 Tolerancia de error : 5e- Numero de iteraciones : 25
METODO DE BISECCION... RESULTADOS Iter a Xr b f(a) f(xr) Error 0, 1.000000, 1.500000, 2.000000, 0.540302, 0.070737, 0. 1, 1.500000, 1.750000, 2.000000, 0.070737, -0.178246, 0. 2, 1.500000, 1.625000, 1.750000, 0.070737, -0.054177, 0.
Figura 5. Diagrama de flujo para el algoritmo del método de Bisección.
En este método en cada iteración el intervalo se divide en dos, por lo tanto en n iteraciones se ha dividido el intervalo en 2 n^ partes. Si deseamos obtener un
determinado error, este hecho podemos usarlo para hallar de antemano cuantas
Inicio
a, b, Tol, MaxIter MaxIter
Xr = (a + b) / 2 Iter = Iter + 1
fa = f(a) fb = f(b) fxr = f(Xr)
a = Xr fxr * fa < 0 (^) b = Xr
Error = |(b - a)/b|
Raíz: Xr
F V
Iter = 0 Xa = 0
F
V
Fin
“No converge”
F
V
Error < Tol OR |fxr| < Tol
Iter >M>MaxIter
a Xr b
f(b)
f(a)
Xr- a
b- a
iteraciones realizar. (^) an n
b a E 2
= donde Ea n es el error aproximado en la iteración n.
Aplicando logaritmos podemos despejar n y obtenemos: Log ( 2 )
E
b a Log n
n a^
− = que será
el número de iteraciones necesarias para obtener la respuesta aproximada con el nivel de error deseado.
1.1.4 Falsa posición (Regula falsi)
La aproximación a la raíz se toma como la intersección de la línea que une los puntos (a,f(a)) y (b,f(b)) con el eje X. Por semejanza de triángulos se puede expresar:
b a
f b
Xr a
f a
de donde podemos derivar la
fórmula:
f a f b
f b a b
Xr b
= −^1.
El algoritmo para hallar raíces es entonces en esencia el mismo planteado para el método de bisección, pero reemplazando la fórmula para calcular la aproximación a la
raíz Xr (Numeral 4). El programa codificado en matlab es el siguiente:
%Programa para calcular raíces de ecuaciones, basado en el algoritmo de Falsa %Posición %Autor: Ing. Edgar Romero Rodríguez %Docente fundación Universiraria UNISANGIL %San Gil,Santander - Colombia. Enero de 2004
function FalsaPosicion clc; clear all; a=input('Valor de la cota inferior: '); b=input('Valor de la cota superior: '); TOL=input('Tolerancia de error : '); max_iter=input('Numero de iteracciones: '); %Modelo gráfico x=a:0.01:b; f=funcion(x); plot(x,x,x,f); grid; title ('Grafica de la función en el intervalo dado');
(^1) Ver demostración completa en el libro de métodos numéricos de Chapra y P. Canale, página 142.
Figura 6. Modelo gráfico.
Evaluamos la función en los extremos del intervalo:
f(1) = -7 y f(2) = 16 (la función cambia de signo en el intervalo)
Calculamos la posible raíz:
Xr = 2 – 16*(1 – 2)/(-7 – 16) = 1,
Evaluamos:
f(Xr)=1,30434782609³ + 21,30434782609² + 101,30434782609 - 20 = -1,
En este punto no tenemos aun datos para evaluar el error relativo pero podemos
evaluar |f(Xr)| < Tol y vemos que no cumple la condición, por lo tanto pasamos a la
siguiente iteración.
Figura 7. Modelo gráfico de la ecuación de Leonardo de Piza.
Segunda iteración:
Verificamos en que subintervalo queda la nueva aproximación de la raíz. Para ello
evaluamos el producto f(Xl)*f(Xu) y vemos que es mayor que cero, por lo cual
variamos la cota inferior pasándola a Xr, el nuevo intervalo a procesar es [1,30434782609, 2].
Evaluamos f(1,30434782609) = -1,33475795, f(2) = 16
Calculamos la posible raíz:
Xr = 2 – 16*(-1,33475795 – 2)/( -1,33475795 - 16) = 1,
Evaluamos la función en la nueva raíz: f(1,35791230466) = -0,
Calculamos el error como la diferencia entre las dos últimas iteraciones:
Error = Abs(-1,33475795184 - -0,22913572959) = 0,
El valor es mayor que el error máximo aceptado, Tol, por lo tanto realizamos una
nueva iteración.
Los cálculos de las siguientes se realizaron con ayuda de la hoja electrónica y sus resultados se muestran a continuación:
Iter a b f(a) f(b) Xr f(xr) Error 1 1 2 -7 16 1,30434782609 -1, 2 1,30434783 2 -1,33475795 16 1,35791230466 -0,22913572959 0, 3 1,3579123 2 -0,22913573 16 1,36697780482 -0,03859187678 0, 4 1,3669778 2 -0,03859188 16 1,36850097560 -0,00647872815 0, 5 1,36850098 2 -0,00647873 16 1,36875657901 -0,00108704283 0, 6 1,36875658 2 -0,00108704 16 1,36879946288 -0,00018237436 0, 7 1,36879946 2 -0,00018237 16 1,36880665748 -0,00003059668 0, 8 1,36880666 2 -3,0597E-05 16 1,36880786450 -0,00000513315 0, 9 1,36880786 2 -5,1331E-06 16 1,36880806700 -0,00000086118 0, 10 1,36880807 2 -8,6118E-07 16 1,36880810097 -0,00000014448 0, 11 1,3688081 2 -1,4448E-07 16 1,36880810667 -0,00000002424 0, 12 1,36880811 2 -2,4239E-08 16 1,36880810763 -0,00000000407 0, 13 1,36880811 2 -4,0665E-09 16 1,36880810779 -0,00000000068 0, 14 1,36880811 2 -6,8223E-10 16 1,36880810782^ -0,00000000011 0,
En la iteración 14 vemos como se alcanza la tolerancia de error deseada y por lo tanto
se finaliza el proceso encontrándose una raíz aproximada. Xr = 1,36880810782.
Usando Matlab y el algoritmo de FalsaPosicion mostrado antes obtenemos los
siguientes resultados:
Valor de la cota inferior: 1 Valor de la cota superior: 2 Tolerancia de error : 5e- Numero de iteracciones: 50
METODO DE FALSA POSICION...
Iter a Xr b f(a) f(xr) f(b) Error 0, 1.000000, 1.304348, 2.000000, -7.000000, -1.334758, 16.000000, 1.3348e+ 1, 1.304348, 1.357912, 2.000000, -1.334758, -0.229136, 16.000000, 2.2914e- 2, 1.357912, 1.366978, 2.000000, -0.229136, -0.038592, 16.000000, 3.8592e- 3, 1.366978, 1.368501, 2.000000, -0.038592, -0.006479, 16.000000, 6.4787e- 4, 1.368501, 1.368757, 2.000000, -0.006479, -0.001087, 16.000000, 1.0870e- 5, 1.368757, 1.368799, 2.000000, -0.001087, -0.000182, 16.000000, 1.8237e- 6, 1.368799, 1.368807, 2.000000, -0.000182, -0.000031, 16.000000, 3.0597e- 7, 1.368807, 1.368808, 2.000000, -0.000031, -0.000005, 16.000000, 5.1331e- 8, 1.368808, 1.368808, 2.000000, -0.000005, -0.000001, 16.000000, 8.6118e- 9, 1.368808, 1.368808, 2.000000, -0.000001, -0.000000, 16.000000, 1.4448e- 10, 1.368808, 1.368808, 2.000000, -0.000000, -0.000000, 16.000000, 2.4239e- 11, 1.368808, 1.368808, 2.000000, -0.000000, -0.000000, 16.000000, 4.0665e- 12, 1.368808, 1.368808, 2.000000, -0.000000, -0.000000, 16.000000, 6.8223e-
a. Guardar el valor de la aproximación anterior (Xa = Xr). b. Calcular una nueva aproximación: Xr = g(Xa) c. Incrementar el número de iteraciones (Iter = Iter + 1) d. Si Xr ≠ 0 entonces calcular: Error = |Xr – Xa| / Xr.
e. Si Error < Tol entonces Imprimir Xr como aproximación de la raíz y parar.
f. Si Iter > MaxIter entonces Imprimir mensaje de error de que el proceso fallo y parar. g. Volver al paso 7.
DIAGRAMA DE FLUJO PARA EL METODO DE PUNTO FIJO
Ejemplo:
Resolver la ecuación: f(x) = X² - 3X + eX– 2.
Se despejamos x de la ecuación podemos obtener:
x = g(x), donde g(x) = ( X² + eX– 2)/3.
Usando MatLab podemos ver la solución al elaborar la gráfica de X y de g(x) respectivamente así:
Inicio
Iter = 0, Xr = Xo
Iter = Iter + 1 Xa = Xr Xr = g(Xa)
Xr ≠ 0 Xl = Xr Error = |Xr – Xa| / Xr
Error < TOL
V
V Iter > IMax
F
Fin
Xr
Iteraciones excedidas
Xo, Tol, MaxIter
V
F
Definimos:
Error máximo aceptado: Tol = 5*10-11.
Número máximo de iteraciones a realizar: MaxIter = 25
Aproximación inicial: Xo = 0.
Primera iteración:
Xr = g(Xo) = ( 0² + exp(0) -2)/3 = -0,
Evaluamos el error como el error relativo entre las dos aproximaciones:
Er = Abs((-0.3333333333 - 0)/-0.333333) = 1,
El valor es mayor que el error máximo aceptado, por lo tanto continuamos el proceso.
Segunda iteración:
Calculamos la nueva aproximación como el valor de g(x) en la aproximación anterior:
Xr = g(-0,33333333) = -0,
Evaluamos el error como el error relativo entre las dos aproximaciones:
Er = Abs((-0,39078586 -0.3333333333)/ -0,39078586) = 0,17235757832.
Es mayor que el error máximo aceptado, por lo tanto continuamos el proceso.
Algoritmo:
- Definir el error máximo a aceptar (Tol).
- Definir una aproximación inicial cualquiera (Xo)
- Definir el máximo número de iteraciones a realizar (MaxIter)
- Establecer a cero el contador de iteraciones (Iter)
- Tomar Xo como primera aproximación (Xr = Xo)
- Repetir estos pasos:
h. Guardar el valor de la aproximación anterior (Xa = Xr). i. Calcular una nueva aproximación: Xr = Xa – f(Xa) / f’(Xa) j. Incrementar el número de iteraciones (Iter = Iter + 1) k. Si Xr ≠ 0 entonces calcular: Error = |Xr – Xa| / Xr. l. Si Error < Tol entonces Imprimir Xr como aproximación de la raíz y parar. m. Si Iter > MaxIter entonces Imprimir mensaje de error de que el proceso fallo y parar. n. Volver al paso 6.
1.2.3 Método de la secante
Surge como una variación del método de Newton. Usando el concepto de diferencia dividida para evaluar la derivada de la función con base en los dos valores anteriores de modo que la nueva aproximación puede calcularse como:
1 2 1 − −
− − −
i i
i i i i
f X f X
X X
X X para i=2,3,…
En este caso para iniciar el proceso se requiere de dos aproximaciones iniciales pero no necesariamente deben ser un intervalo que incluya la raíz, incluso la segunda aproximación se pude calcular como Xi-1+∆x siendo ∆x un valor pequeño como 0.01.
Ejemplo: Halla la primera raíz positiva de la ecuación de Leonardo de Piza:
f(x) = X³ + 2X² + 10X – 20.
Aproximación inicial: X 0 =1 y X 1 = 1.01. Tol = 5E-11.
Primera iteración:
Evalúo la función en la aproximación inicial: f(1) = -7 y f(1.01) = -6.82949. Calculo la aproximación a la raíz: X 2 =-7 – (1.01 - 1)/(-7 -6.82949) = 1.
Evalúo el error: Ea=|1.41055478 – 1.01|/1.41055478 = 0.283969.
Como el valor del error es mayor que Tol, se continúa el proceso.
Segunda iteración:
Evalúo la función en la nueva aproximación: f(1.4105549)=0. Calculo la aproximación a la raíz: X 3 =1.41055478 – (1.41055478 - 1.01)/( -6.82949 - 0.89140848) = 1,
Evaluación del error: Ea=|1,35867554 - 1.41055478|/1,35867554 = 0.03818.
Como el valor del error es mayor que Tol, se continúa el proceso.
Tercera iteración:
Evalúo la función en la nueva aproximación: f(1,35867554)=-0. Calculo la aproximación a la raíz: X 4 =1.41055478 – (1.41055478 - 1.01)/( -6.82949 - 0.89140848) = 1,
Evaluación del error: Ea=|1,368686 - 1,35867554|/1,368686= 0.007314.
Como el valor del error es mayor que Tol, se continúa el proceso.
De esa misma manera se continúa el proceso hasta lograr el error tolerado. Los resultados se muestran en la siguiente tabla.
Iter Xi-2 Xi-1 Xi F(Xi-1) f(Xi-2) F(Xi) Error 1 1 1,01 1,41055478 -6,829499 -7 0,89140848 0, 2 1,01 1,41055478 1,35867554 0,89140848 -6,829499 0,30566022 0, 3 1,41055478 1,35867554 1,36868616 -0,21313213 0,89140848 -0,10267875 0, 4 1,35867554 1,36868616 1,36880847 -0,00257259 -0,21313213 -0,00121553 0, 5 1,36868616 1,36880847 1,36880811 7,5552E-06 -0,00257259 3,5812E-06 0, 6 1,36880847 1,36880811 1,36880811 -2,667E-10 7,5552E-06 -1,2642E-10 0,
En la sexta iteración se alcanza el nivel de error deseado por lo tanto se detiene el proceso y se toma como valor de la raíz aproximada de 1.3688011.
1.1. RAICES MÚLTIPLES
1.2. SISTEMAS DE ECUACIONES NO LINEALES
