Universidad Nacional Autónoma de México

Facultad de Estudios Superiores Aragón

Ingeniería en Computación

Métodos Numéricos

Trabajo:
Método de Von Mises

Equipo:
Leal Sanchez Bryan Uriel
Maldonado Cantellan Irene Angelica
Manzano Montes Luis Raul Carlos
Jael Gonzalez Perez
Salazar Guzmán Alexys Daniel
Macedo Frasco Pablo Alberto

Profesor:
Blanco Bautista Roberto

Grupo:
1308

Fecha: 10 de Noviembre del 2022

 Método de Von Mises

El método de Newton-Raphson puede ser problemático si se está en puntos

alejados de las raíces y cercanos a puntos donde el valor de f’(xi) sea próximo a
cero. Para ello von Mises sugirió utilizar Newton-Raphson (fórmula 3.9)
sustituyendo el denominador f’(xi) por f’(x0), es decir obtener geométricamente las
siguientes aproximaciones por medio de paralelas a la primera tangente. La
ecuación de recurrencia es:

Expresión gráfica:
 Diagrama de Flujo

Inicio

i=1

i≤NN
i≤

SI x=x 0−f ¿ ¿ NO

|x- x 0|< E i=i+1

x 0=x

Fin
 Código Fuente
InicioVon

package fes.aragon.inicio;

import fes.aragon.vista.InterfazPrincipal;
import java.awt.Color;
import javax.swing.UIManager;

public class InicioVon {

public static void main(String[] args) {
try {
for (javax.swing.UIManager.LookAndFeelInfo info :
javax.swing.UIManager.getInstalledLookAndFeels()) {
if ("Nimbus".equals(info.getName())) {
javax.swing.UIManager.setLookAndFeel(info.getClass
Name());
UIManager.put("nimbusBlueGrey", new Color(30, 40,
44));
UIManager.put("control", new Color(30, 40, 44));
break;
}
}
} catch (ClassNotFoundException |
InstantiationException | IllegalAccessException |
javax.swing.UnsupportedLookAndFeelException ex) {
java.util.logging.Logger.getLogger(InterfazPrincipal.clas
s.getName()).log(java.util.logging.Level.SEVERE, null,
ex);
}
java.awt.EventQueue.invokeLater(new Runnable() {
@Override
public void run() {
new InterfazPrincipal().setVisible(true);
}
});
}
}
Derivada
package fes.aragon.modelo;

import org.lsmp.djep.djep.DJep;
import org.nfunk.jep.Node;
import org.nfunk.jep.ParseException;

public class Derivada {

private String funcion;

private DJep djep;
private Node nodoFuncion;
private Node nodoDerivada;

public Derivada(String funcion) {

this.funcion = funcion;
}

public String getFuncionDerivada() {

return funcion;
}

public void derivar() {

try {
this.djep = new DJep();
this.djep.addStandardFunctions();
this.djep.addStandardConstants();
this.djep.addComplex();
this.djep.setAllowAssignment(true);
this.djep.setAllowUndeclared(true);
this.djep.setImplicitMul(true);
this.djep.addStandardDiffRules();
this.nodoFuncion = this.djep.parse(funcion);

Node dif = this.djep.differentiate(nodoFuncion,

"x");
this.nodoDerivada = this.djep.simplify(dif);
this.funcion =
this.djep.toString(this.nodoDerivada);
 } catch (ParseException e) {
e.printStackTrace();
}
}

Función
package fes.aragon.modelo;

import org.nfunk.jep.JEP;

public class Funcion {

private String funcion = "";

private double resultado = 0.0;
private String error = "";

JEP jep;

public Funcion(String funcion) {

this.funcion = funcion;
jep = new JEP();
}

public String getError() {

return this.error;
}

public double evaluar(double valorX) {

this.jep.addStandardFunctions();
this.jep.addVariable("x", valorX);
this.jep.parseExpression(this.funcion);
this.resultado = this.jep.getValue();
this.error = (this.jep.hasError()) ? "Existe un error."
: "No hay error.";
return resultado;
}
}
VonMises
package fes.aragon.modelo;

import fes.aragon.vista.InterfazPrincipal;

public class VonMises {

private final String funcionPrincipal;

private final Funcion evaluarFuncion;
private final Funcion evaluarDerivada;
private final Derivada derivada;

public VonMises(String funcionP) {

//obtenemos la funcion Principal y su derivada
this.funcionPrincipal = funcionP;
this.derivada = new Derivada(funcionP);
this.derivada.derivar();
evaluarFuncion = new
Funcion(this.funcionPrincipal);
evaluarDerivada = new
Funcion(this.derivada.getFuncionDerivada());
}

public double obtenerRaiz(double puntoInicial,

double errorEsperado) {
double evaluacionFuncion, raiz = 0,
puntoCambiante, error = Double.MAX_VALUE;
final double evaluacionDerivada =
evaluarDerivada.evaluar(puntoInicial);
int iteracion = 0;
while (error > errorEsperado) {
iteracion++;
evaluacionFuncion =
evaluarFuncion.evaluar(puntoInicial);
puntoCambiante = puntoInicial -
(evaluacionFuncion / evaluacionDerivada);
error = Math.abs((puntoCambiante -
puntoInicial) / puntoCambiante);
raiz = puntoCambiante;
InterfazPrincipal.getDatosI().llenarTabla(iteracio
n, puntoInicial, puntoCambiante, evaluacionFuncion,
evaluacionDerivada, error);
puntoInicial = puntoCambiante;
}
return raiz;
}

Conclusiones

Como pudimos observar este método es de gran eficacia debido a

que es más sencillo que el de Newton-Raphson. Su simplicidad
hace que se utilice más, la ventaja de este método es que evita la
evaluación de la derivada en cada etapa iterativa.

Los criterios de convergencia de este método son la supuesta

constancia de los signos de las derivadas f’(x) y f’’(x) las
aproximaciones sucesivas presentan un proceso convergente.

La contrapartida de esta mayor economía de método es obviamente

la perdida de velocidad de convergencia.