UNIVERSIDAD NACIONAL DE

UCAYALI
FACULTAD DE INGENIERIA DE SISTEMAS

ESCUELA PROFESIONAL DE INGENIERIA DE

SISTEMAS

ASIGNATURA

Mtodos Numricos

DOCENTE

Ing. Walter Romn Claros

CICLO

VII

INTEGRANTES

:Narro, Erika Contreras

Ponce Morales, Edeher
Ruiz Zumaeta, Piero
Valera Fernndez, Frank
Valera La Torre, Nicols
PUCALLPA- PER
2007

Mtodo de la Regula
Falsi
Vamos a revisar las tareas bsicas para resolver ecuaciones
por mtodos numricos. Mientras la mayor parte de las
ecuaciones tienen los dos miembros distintos de cero, a
veces movemos todos los trminos al miembro izquierdo de
la ecuacin, quedndonos de la forma:

f(x)=0
Las soluciones que entonces se buscan son las
denominadas races de la funcin. La bsqueda de las
races se realiza mediante iteraciones, tanto para
problemas mono como multidimensionales.

Generalmente se comienza por algn punto de prueba, de ser

posible cercano a la raz buscada.
Funciones con races mltiples o con races muy cercanas entre
s representan un verdadero problema, fundamentalmente si el
nmero de races es impar, ya que el cambio de signo indicara
en primera instancia que probablemente hay una sola raz,
cuando en realidad hay varias en un entorno muy reducido.
Debido a ello es fundamental contar con un graficador, aunque
sea rudimentario para poder determinar visualmente como
vara la funcin en el entorno elegido.

MTODO PARA ENCONTRAR

RACES DE UNA ECUACIN f(x)=0
Acotamiento:
De ahora en adelante diremos que una raz se encuentra
acotada (Bracketed) en el intervalo (a, b) si f(a) y f(b)
tienen signos opuestos. Si la funcin es continua al
menos una raz debe encontrarse en dicho intervalo
(debido al teorema del valor intermedio). Ahora, si la
funcin es discontinua en lugar de una raz podemos
tener un salto de discontinuidad que cruza cero.

MTODO DE LA REGULA FALSI

Tambin conocido como: Regula Falsi, Regla Falsa, False
Position, etc. Nos permite encontrar la raz de la ecuacin
f(x)=0, donde f(x) es una funcin continua definida en el
intervalo [a, b], con f(a) y f(b) de signos diferentes.
Ejemplo:
Encontrar las races de
f(x)=x3-2x2-5=0.
Para ello necesitamos dos
aproximaciones:
Tomamos:
a=2 y b=3, ya que:
f(2)=-5 y f(3)=4
La tolerancia Tol=0.000001 y con
N=10 iteraciones, obtenemos
una raz en x=2.690647

Algoritmo:
Est basado en una idea para
aproximarse en forma ms eficiente a la
raz. Supongamos f continua en [a, b]
tal que f (a) * f (b) <= 0, y adems que
existe una nica raz x en dicho
intervalo.

Datos: a, b, EPSILON () y f(x)

Paso 1)

pastc = 2b a

Paso 2)

c = b - f(b) * (b -a)
f(b) - f(a)

Paso 3)

SI ( f(a) * f(c) <= 0) ENTONCES

b=c
SINO
a=c

Paso 4)
ENTONCES

SI (Valor Absoluto(c-pastc) <= EPSILON)

y fin
SINO

Paso 5)

raiz = c
seguir

pastc = c
y volver a
Paso 2)

Implementacin en
Java:
public class RegulaFalse{
public static double EPSILON = 0.00005;
public final static int MAX_ITER = 500;
private double a,b,c,pastc;
private int cont;
public void asignarDatos(double a,double b)
this.a = a;
this.b = b;
this.cont = 0;
}

public int numIteraciones( ) {

return cont;
}
public double raiz(Evaluar e) {
pastc = 2*b - a;
while(true)
{
double aux = e.f(b) - e.f(a);
if (aux != 0.0 )
c = b - ( e.f(b) * (b - a) ) / aux;
else
break;
if ( e.f(a) * e.f(c) <= 0 )
b = c;
else
a = c;
if (Math.abs(c - pastc) <= EPSILON)
break;
pastc = c;
cont++;
if (cont > MAX_ITER )
break;
}
return c;
}

Programa de Prueba:
Consiste en encontrar la raz de la funcin Exponencial de
f(x)= x-x5, usando Regula False, con su respectivas
interfaces e implementaciones.

Interfaz:
interface Evaluar
{
double f(double x);
}

Funcin a evaluar e implementacin de la interfaz:

public class funcExp implements Evaluar{
public double f (double x)

return Math.exp(x) - Math.pow(x,5);

}
}//fin clase funcExp

Cdigo fuente del programa de prueba:

public class pruebaExp{
public static void main(String arg[ ])

RegulaFalse r = new RegulaFalse( );

funcExp exp = new funcExp( );
r.asignarDatos(1.0 , 2.0);
System.out.println("\nPrograma de prueba para Regula
False");
System.out.println("------------------------------------");
System.out.println("\nf(1.0) : " + exp.f(1.0));
System.out.println("f(2.0) : " + exp.f(2.0));
System.out.println("\nraiz : " + r.raiz(exp));
System.out.println("\nnumero de
iteraciones: "+r.numIteraciones());
System.out.println( );
}//fin main
}//fin class

Resolviendo el mtodo
manualmente
EJEMPLO:
Usar el mtodo de la regla falsa para aproximar la raz de
f(x)=e x-lnx, comenzando en el intervalo [1,2] y hasta que |a|<1.
SOLUCIN:
Sabemos que f(x) es
continua en el intervalo
dado y que toma signos
opuestos en los extremos
de dicho intervalo. Por lo
tanto podemos aplicar el
mtodo de la regla falsa.

Calculamos la primera aproximacin:

Puesto que solamente tenemos una sola

aproximacin continuamos con el proceso.
As pues: