PROGRAMARIO: BISECCIÓN, REGLA FALSA, NEWTON-RAPHSON, FACTORES CUADRÁTICOS

UNIVERSIDAD NACIONAL AUTÓNOMA DE MÉXICO

FACULTAD DE INGENIERÍA

PROGRAMARIO: BISECCIÓN, REGLA FALSA, NEWTON-RAPHSON, FACTORES CUADRÁTICOS

ANÁLISIS NUMÉRICO

Método de bisección

Obtenga la raíz positiva de la función , empleando el método de bisección. Con una tolerancia menor o igual a 0.001.

Intervalo (1,2)

a=1

b=2

→ converge

Primera iteración

Evaluando f(x₀)

Como f(x₀)<0 entonces se cambia por b

Nuevo intervalo [1,0.2525]

Evaluando f(x₁)

Como f(x₁)>0 cambia a

Nuevo intervalo

[1.2254,0.373]

Evaluando f(x₂)

=1.007

Como f(x₁)>0 cambia a

Nuevo intervalo

[1.007,0.373]

Iterando n veces

[1.41, 0]

Error absoluto 0.0001

ALGORITMO DE LA BISECCION

Cálculo de una solución aproximada de la ecuación f(x)= 0, siendo f continua en [a, b] y f(a)f(b)<0.

ENTRADA: a, b, f; N (número máximo de iteraciones)

SALIDA:Solución aproximada s

1.Tomar i =1

2. Mientras que i <= N hacer

2.1.s=(ab)/2

2.2. Si f(s) =0 entonces s= solución exacta.

2.3. Si f(a)f(s)<0 entonces b=s Si f(a)f(s)> 0 entonces a=s

2.4. i = i+1

3. Salida s: "solución aproximada"

4.FIN

Codigo

public double metodo_biseccion(funcion func,double interv_me,double interv_ma,double tolerancia,Error tipo_tolerancia){

double f_x;

n_tol=1000;

x_i = 0;

x_i1 = 0;

//verifica que haya solo una raiz en el intervalo para continuar con el metodo

if(func.f(interv_ma)*func.f(interv_me) > 0){

System.out.println("puede haber mas de una raiz, declare otro intervalo");

return -1;

}

//en caso de ser un intervalo decreciente (f(a) > 0 y f(b) < 0 ) se cambia el orden del intervalo ([b,a])

if(func.f(interv_ma) < 0 && func.f(interv_me) > 0){

f_x = interv_ma;

interv_ma = interv_me;

interv_me = f_x;

}

System.out.println("\n----Metodo de biseccion----\n=====================================");

//inicia la formula recirrente

for(int i=1; n_tol > tolerancia;i++){ //ciclo el cual temina cuando la tolerancia < a la proporcionada

x_i = x_i1;//actualizo el valor aproximado

x_i1 = (interv_ma + interv_me)/2;//calculo el nuevo valor real

f_x = func.f(x_i1);//obtengo f(x_i+1)

if (f_x < 0){ //si f(x_i+1) es menor a cero

interv_me = x_i1;//el valor de a(extremo inferior del intervalo) cambia al de x_i+1; [a,x_i+1]

}else{;//si f(x_i+1) es mayor a cero

interv_ma = x_i1;//el valor de b(extremo superior del intervalo) cambia al de x_i+1: [a,x_i+1]

}

if(i > 1){ //si estamos en una iteracion diferente de la primera

n_tol = tipo_tolerancia.calcula_error(x_i1,x_i);//calculamos el error (absoluto o relativo)

}

System.out.println("\n****Iteracion " + i + "****\nx_i: " + x_i + "\nx_i+1: " + x_i1 + "\nTolerancia: " + n_tol + "\nIntervalo: [" + interv_me + "," + interv_ma + "]");

}

System.out.println("\n=====================================\n===>La raiz es: " + x_i1);

return x_i1;

}

Método de la regla falsa

Cálculos

Obtenga la raíz positiva de la función , empleando el método de Regla Falsa. Con una tolerancia menor o igual a 0.001.

Intervalo (1,2)

a=1

b=2

→ converge

Primera iteración : i=0

→

Segunda iteración i=1

.44903

→

Eabs= |- |=0.16205>Tol

Tercera iteración i=2

a=

b=

→

Eabs= |- |=0.04225>Tol

Cuarta iteración i=3

a=

b=

Eabs= |- |=0.00278

→

Quinta iteración i=4

a=

b=

Eabs= |- |=0.00025< Tol ; → raiz

ALGORITMO

1. Ingresar función→ f(x)

2. Ingresar tolerancia→ Tol

3. Ingresar intervalo inicial (a,b)

4. Evaluar a y b en la función f(x)

5. Multiplicar f(a)*f(b)

5.1 Si f(a)*f(b)<0 continuar al paso 6

5.2 Si f(a)*f(b)>0 regresar al paso 3

6. Calcular la aproximación

7. Evaluar en f(x)

7.1 Si f( )=0 entonces es raiz

7.2 Si f( )>0 entonces

7.3 Si f( )<0 entonces

8. Calcular error absoluto Eabs=|-|

9. Comparar el error absoluto con la tolerancia

9.1 Si Eabs<Tol entonces es raíz

9.2 Si Eabs>Tol entonces regresar al paso 6

Código

public double metodo_falsa_posicion(funcion func, double a, double b, double tolerancia,Error tipo_tolerancia){

double f_a,f_xi;

n_tol = 1000;

x_i = 0;

x_i1 = 0;

//verifica que haya solo una raiz en el intervalo para continuar con el metodo

if(func.f(a)*func.f(b) > 0){

System.out.println("Puede haber mas de dos raices, buesque otro intervalo");

return -1;

}

System.out.println("\n----Metodo de falsa posicion----\n=====================================");

for(int i = 1; n_tol > tolerancia; i++){//ciclo el cual temina cuando la tolerancia < a la proporcionada

x_i = x_i1; //actualiza el valor aproximado (x_i)

f_a = func.f(a);//calcula f(a)

x_i1 = b - ((func.f(b) * (a-b))/(f_a - func.f(b)));//obtienen un nuevo calor real (x_i+1)

f_xi = func.f(x_i1);//obtienen f(x_i+1)

if(f_xi * f_a < 0){ //en caso de que f(x_i+1)f(a) < 0

b = x_i1;//b toma el valor de x_i+1 (el nuevo valor real)

}else{

a = x_i1;//a toma el valor de x_i+1(el nuevo valor real)

}

if(i > 1){ //si estamos en un a iteracion mayor a la 1

n_tol = tipo_tolerancia.calcula_error(x_i1,x_i); //calculamos la tolerancia (relativa o absoluta)

}

System.out.println("\n****Iteracion " + i + "****\nx_i: " + x_i + "\nx_i+1: " + x_i1 + "\nTolerancia: " + n_tol + "\nIntervalo: [" + a + "," + b + "]");

}

System.out.println("\n=====================================\n===>La raiz es: " + x_i1);

return 1;

}

...