Facultad de Ingenieria Civil y Arquitectura

Escuela Profesional de Ingenieria Civil

SOLUCION DE ECUACIONES
Y PROGRAMACIN

19 DE MAYO DE 2017
1
 INFORME N 001 2017 UNA / EPIC / EPP

A:
Lic.

Docente de curso de Mtodos Numricos

De:
- Edgar Portugal Pari

Estudiante del curso en mencin.

Asunto:
Presentacin del trabajo de SOLUCIN DE ECUACIONES Y PROGRAMACIN

Fecha:
19 de Mayo de 2017

El preente trabajo tiene como objetivo principal la resolucin de ecuaciones lineales

con los mtodos: Biseccin, Punto Fijo, Nexton Raphson, Falsa Posicion y Secante, todo
esto usando los programas Visual Basic en Excel, Dev C++ y Python.

Se presentan los algoritmos que darn a conocer la raz de la funcin mostrada en la

primera parte.

Atte: Edgar Portugal Pari

Cdigo: 151366
INTRODUCCIN
Uno de los problemas ms corrientes en matemticas consiste en resolver una ecuacin,
es decir, encontrar un valor x* E R que satisfaga

f(x) = 0

Donde f es una funcin de variable y valor real, o sea,

f:lR---+lR.

Este x* se llama solucin de la ecuacin. A veces tambin se dice que x* es una raz.

En algunos casos no se tiene una expresin sencilla de f, sino que f (x) corresponde al
resultado de un proceso; por ejemplo:

2
0.2 = 0

Lo mnimo que se le exige a f es que sea continua. Si no es continua en todo lR, por lo
menos debe ser continua en un intervalo [a, b] donde se busca la raz. Algunos mtodos
requieren que f sea derivable. Para la aplicacin de algunos teoremas de
convergencia, no para el mtodo en s, se requieren derivadas de orden superior.

Los mtodos generales de solucin de ecuaciones sirven nicamente para hallar races
reales. Algunos mtodos especficos para polinomios permiten obtener races
complejas.

Los mtodos presuponen que la ecuacin f(x) = O tiene solucin. Es necesario, antes de
aplicar mecnicamente los mtodos, estudiar la funcin, averiguar si tiene races,
ubicarlas aproximadamente. En algunos casos muy difciles no es posible hacer un
anlisis previo de la funcin, entonces hay que utilizar de manera mecnica uno o varios
mtodos, pero sabiendo que podran ser ineficientes o, simplemente, no funcionar.

La mayora de los mtodos parten de Xo, aproximacin inicial de x*, a partir del cual se
obtiene X1 A partir de X1 se obtiene X2 despus X3, y as sucesivamente se construye la
sucesin [Xk] con el objetivo, no siempre cumplido, de que

lim =

El proceso anterior es tericamente infinito, y obtendra la solucin despus de

haber hecho un nmero infinito de clculos. En la prctica el proceso se detiene
cuando se obtenga una aproximacin suficientemente buena de x*. Esto
querra decir que el proceso se detendra cuando
| |

Para un E dado. El anterior criterio supone el conocimiento de x*, que es justamente lo

buscado. Entonces se utiliza el criterio, ste si aplicable,

|( )|

En la mayora de los casos, cuanto ms cerca est Xo de x*, ms rpidamente se

obtendr una buena aproximacin de x*.
Otros mtodos parten de un intervalo inicial [ao, bo], en el cual se sabe que existe una
raz x*. A partir de l, se construye otro intervalo

[a1, b1] contenido en el anterior, en el que tambin est x* y que es de menor tamao.
De manera anloga se construye [a2, b2].

METODO DE NEWTON RAPHSON

Tal vez, de las frmulas para localizar races, la frmula de Newton-Raphson (figura

6.5) sea la ms ampliamente utilizada. Si el valor inicial para la raz es xi, entonces se
puede trazar una tangente desde el punto [xi, f(xi)] de la curva. Por lo comn, el punto
donde esta tangente cruza al eje x representa una aproximacin mejorada de la raz.

El mtodo de Newton-Raphson se deduce a partir de esta interpretacin geomtrica

De la grfica la primera derivada en x es equivalente a la pendiente:

El algoritmo capaz de dar solucin a la ecuacin:

( 0.5)2 0.1 = 0
ALGORITMO
#include <iostream>
#include <iomanip> // setprecision
#include <cmath>
#include <windows.h>

#define PRECISION 10
#define MAX_ITERACIONES 10
#define INTERVALOS 6

using namespace std;

void tabula(double a, double b, int intervalos); // Muestra un # tabulado de intervalos

double f(double x); // Retorna el valor de la funcin evaluada en x
double f_derivada(double x); // Retorna la derivada de la funcin evaluada en x
void newton_raphson(double x0, double tolerancia, int max_interaciones);
// Funcin que calcula la raiz aproximada de una funcin

int main()
{
double a;
double b;
double tolerancia; // Tolerancia
double x0; // Primera aproximacin

cout << setprecision(PRECISION); // Se establece la precisin

cout << "\nCalculo de las raices de una funcion aplicando el metodo de Newton
- Raphson\n";
cout << "\nIngrese el intervalo inicial [a,b]:" << endl;

// Se ingresa el intervalo
cout << "\na = ";
cin >> a;

cout << "b = ";

cin >> b;

// Se tabulan los valores de f para INTERVALOS intervalos

tabula(a, b, INTERVALOS);

// Se pide elegir una aproximacin inicial

cout << "\nEscoja el punto inicial adecuado: x0 = ";
cin >> x0;

// Se pide ingresar la tolerancia

cout << "Tolerancia = ";
cin >> tolerancia;

// Newton Raphson
newton_raphson(x0, tolerancia, MAX_ITERACIONES);

cin.get();
cin.get();
return 0;
}
void tabula(double a, double b, int intervalos)
{
int puntos = intervalos + 1;

double ancho = (b - a) / intervalos;

cout << "\n\tx\t\tf(x) " << endl;

for (int i = 0; i < puntos; i++) {
cout << "\t" << a << "\t\t" << f(a) << endl;
a = a + ancho;
}
}
double f(double x)
{
return pow(x-0.5,2)-0.1;
//return pow(x-0.5,2)-0.1 ;
}
double f_derivada(double x)
{
return 2*x-1;
//return 2*x-1;
}
void newton_raphson(double x0, double tolerancia, int max_iteraciones)
{
double x1; // Siguiente aproximacin
double error;// Diferencia entre dos aproximaciones sucesivas: x1 - x0
int iteracion; // # de iteraciones
bool converge = true;

// Se imprimen los valores de la primera aproximacin

cout << "\nAproximacion inicial:\n";
cout << "x0 = " << x0 << "\n"
<< "f(x0) = " << f(x0) << "\n"
<< "f'(x0) = " << f_derivada(x0) << endl;

iteracion = 1;
do {
if (iteracion > max_iteraciones) {
converge = false; // Se sobrepas la mxima cantidad de iteraciones
permitidas
break;

} else {
x1 = x0 - f(x0) / f_derivada(x0); // Clculo de la siguiente
aproximacin
error = fabs(x1 - x0); // El error es la diferencia entre dos
aproximaciones sucesivas

// Se imprimen los valores de la siguiente aproximacin x1, f(x1),

f_derivada(x1), error
cout << "\a";
Sleep(500);
cout << "\n\nIteracion #" << iteracion << endl;
cout << "\nx" << iteracion << " = " << x1 << "\n"
 << "f(x" << iteracion << ") = " << f(x1) << "\n"
<< "f'(x" << iteracion << ") = " << f_derivada(x1) << "\n"
<< "error = " << error << endl;
// La diferencia entre dos aproximaciones sucesivas es tambin conocida como error.
// La condicin de terminacin consiste en que que el error debe ser <= que la tolerancia
dada
// Si se cumple la condicin de terminacin, se ha encontrado la raiz aproximada
buscada.
if (error <= tolerancia) { // Condicin de terminacin
converge = true;
break;

// Si no se cumple el criterio de terminacin, se pasa a la siguiente iteracin

} else {
x0 = x1;
iteracion++;
}
}

} while (1);

// Respuesta final
cout << "\a";
Sleep(500);
if (converge) {
cout << "\n\nPara una tolerancia de " << tolerancia << " la RAIZ APROXIMADA
de f es = " << x1 << endl;

} else {
cout << "\n\nSe sobrepas la mxima cantidad de iteraciones
permitidas" << endl;
}
}
SOLUCIN

Abrimos el programa Y CALCULAMOS LA PRIMERA RAZ EN EL INTERVALO [0,1]

DONDE
X1= 0.1836538462
X2 = 0.8163461538
METODO DE LA FALSA POCISIN.

Es una modificacin del mtodo de la biseccin. Tambin empieza con un intervalo

[ao, bo] donde f es continua y tal que f(ao) y f(bo) tienen signo diferente.

En el mtodo de biseccin, en cada iteracin, nicamente se tiene en cuenta el signo

de f(ak) Y de f(bk), pero no sus valores: no se est utilizando toda la informacin
disponible. Adems es de esperar que si f(ak) est ms cerca de O que f(bk), entonces
puede ser interesante considerar, no el punto medio, sino un punto ms cercano a ak.
De manera anloga, si f(bk) est ms cerca de O que f(ak), entonces puede ser
interesante considerar, no el punto medio, sino un punto ms cercano a bk.

En el mtodo de Falsa Pocisin se considera el punto donde la recta que pasa por (ak,
f(ak)), (bk, f(bk)) corta el eje x. Como f(ak) Y f(bk) tienen signo diferente, entonces el
punto de corte Ck queda entre ak Y bk.
ALGORITMO
#include <iostream>
#include <iomanip> // setprecision
#include <cmath> // fabs

#define PRECISION 6
#define INTERVALOS 10

using namespace std;

void tabula(double a, double b);

double f(double x);

int main()
{
cout << setprecision(PRECISION);
cout << "\nCalculo de las raices de una funcion aplicando el metodo de la
falsa posicion\n";
cout << "\nIngrese el intervalo inicial [a,b]:" << endl;

double a, b, tolerancia;

cout << "\na = ";

cin >> a;

cout << "b = ";

cin >> b;

tabula(a, b);

cout << "\nEscoja el intervalo adecuado" << endl;

cout << "\na = ";
cin >> a;

cout << "b = ";

cin >> b;

double xr; // La solucin aproximada

double xa = 0; // Solucin anterior

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

cout << "\nNo se puede aplicar el metodo de la falsa posicion\n";
cout << "porque f(" << a << ") y f(" << b << ") tienen el mismo signo" <<
endl;

} else {
cout << "Tolerancia = ";
cin >> tolerancia;

cout << "\na\tb\tx\tf(a)\t\tf(b)\t\tf(x)\n" << endl;

do {
xr = b - f(b) * ((b - a) / (f(b) - f(a)));

cout << a << "\t" << b << "\t" << xr << "\t" << f(a) << "\t" << f(b) <<
"\t" << f(xr) << endl;
 // if (fabs(f(xr)) <= tolerancia) {
if (fabs(xr - xa) / fabs(xr) <= tolerancia) {
cout << "\n\nPara una tolerancia de " << tolerancia << "
la raiz de f es: " << xr << endl;
break;

} else {
xa = xr; // Se guarda el valor de la aproximacin anterior
if (f(xr) * f(a) > 0) {
a = xr;

} else if (f(xr) * f(b) > 0) {

b = xr;
}
}

} while (1);
}

cin.get();
cin.get();
return 0;
}

void tabula(double a, double b)

{
int puntos = INTERVALOS + 1;

double ancho = (b - a) / INTERVALOS;

cout << "\n\tx\tf(x) " << endl;

for (int i = 0; i < puntos; i++) {
cout << "\t" << a << "\t" << f(a) << endl;
a = a + ancho;
}
}

double f(double x)
{
// return ((x-0.5)^2)-0.1;
return pow(x-0.5,2)-0.1;
}
SOLUCIN:

OBSERVAMOS QUE LAS SOLUCIONES A LA ECUACIN SON:

X1 = 0.184
X2 = 0.815217
METODO DE BISECCIN
El mtodo de biseccin, conocido tambin como de corte binario, de particin de
intervalos o de Bolzano, es un tipo de bsqueda incremental en el que el intervalo se
divide siempre a la mitad. Si la funcin cambia de signo sobre un intervalo, se evala el
valor de la funcin en el punto medio. La posicin de la raz se determina situndola en
el punto medio del subintervalo, dentro del cual ocurre un cambio de signo. El proceso
se repite hasta obtener una mejor aproximacin. En la figura 5.5 se presenta un algoritmo
sencillo para los clculos de la biseccin. En la figura 5.6 se muestra una representacin
grfica del mtodo. Los siguientes ejemplos se harn a travs de clculos reales
involucrados en el mtodo.

Procedimiento:

ALGORITMO (VISUAL BASIC)

Sub BiseccionFc1()
k = 10 'NUMERO DE ITERCIONES
a = -1 'VALOR DEL LIMITE INFERIOR
b = 1 'VALOR DEL PUNTO O LIMITE INFERIOR
m = (a + b) / 2 'MITAD DE LOS PUNTOS

FuncionA = a ^ 2 - a + 0.15
FuncionB = b ^ 2 - b + 0.15
FuncionM = m ^ 2 - m + 0.15

j=3
Cells(j, 1) = "k"
Cells(j, 2) = "a"
Cells(j, 3) = "b"
Cells(j, 4) = "m"
Cells(j, 5) = "F(a)"
Cells(j, 6) = "F(b)"
Cells(j, 7) = "F(m)"
Cells(j, 8) = "L = |b-a|"
Cells(j, 9) = "L < Tolerancia"
j=j+1
Tolerancia = 0.0000000000001
If ((FuncionA * FuncionB) < 0) Then
While (Abs(b - a) > Tolerancia)
m = (a + b) / 2
FuncionA = Sin(8 * a) + 0.531
FuncionB = Sin(8 * b) + 0.531
FuncionM = Sin(8 * m) + 0.531

Cells(j, 1) = k
Cells(j, 2) = a
Cells(j, 3) = b
Cells(j, 4) = m
Cells(j, 5) = FuncionA
Cells(j, 6) = FuncionB
Cells(j, 7) = FuncionM
Cells(j, 8) = Abs(b - a)
Cells(j, 9) = "L aun sigue siendo mayor que tolerancia"

If (FuncionA * FuncionM < 0) Then

b=m
Else
a=m
End If

k=k+1
j=j+1

Wend
Cells(j, 1) = k
Cells(j, 2) = a
Cells(j, 3) = b
Cells(j, 4) = m
Cells(j, 5) = FuncionA
Cells(j, 6) = FuncionB
Cells(j, 7) = FuncionM
Cells(j, 8) = Abs(b - a)
Cells(j, 9) = "L ya es menor que Tolerancia"
MsgBox ("SE HA CONCLUIDO SATISFACTORIAMENTE EL METODO DE BISECCION PARA
F(X)")

Else
MsgBox ("NO EXISTE UNA POSIBLE RAIZ EN LOS PUNTOS INGRESADOS")
End If
End Sub
SOLUCIN:
Intervalo [0; 0.5]
Intervalo [0.5; 1]
METODO DE LA SECANTE
Un problema potencial en la implementacin del mtodo de Newton-Raphson es la
evaluacin de la derivada. Aunque esto no es un inconveniente para los polinomios ni
para muchas otras funciones, existen algunas funciones cuyas derivadas en ocasiones
resultan muy difciles de calcular. En dichos casos, la derivada se puede aproximar
mediante una diferencia finita dividida hacia atrs, como en:

La ecuacin es la frmula para el mtodo de la secante. Observe que el mtodo

requiere de dos valores iniciales de x. Sin embargo, debido a que no se necesita que f(x)
cambie de signo entre los valores dados, este mtodo no se clasifica como un mtodo
cerrado.

ALGORITMO:
Public Function fRaizSecante(ByVal Xa As Double, ByVal Xb As Double, Optional ByVal
tolerancia As Double = 0.000001) As Double
Dim f_a As Double, f_b As Double, f_c As Double
Dim Xc As Double
Dim errorAproximacion As Double
Dim Seguimiento As String
Static intIteracion As Integer
f_a = fFuncionCalculo(Xa)
f_b = fFuncionCalculo(Xb)
If ((f_a * f_b) < 0) Then 'Se produce un cambio de signo
errorAproximacion = VBA.Abs(Xa - Xb)
Do While tolerancia <= errorAproximacion
If f_a <> f_b Then
Xc = Xb - ((Xb - Xa) * f_b / (f_b - f_a)) 'Se toma el valor secante entre los extremos
 Else
Xc = (Xa + Xb) / 2 'El punto medio, para evitar el paso por tramos concavos o
convexos
End If
f_c = fFuncionCalculo(Xc) 'Se obtiene el valor de la funcin en dicho punto
errorAproximacion = VBA.Abs(Xa - Xb)
Seguimiento = CStr(intIteracion) + "" & VBA.Chr(9) & "x= " & VBA.CStr(Xc) & Chr(9)
& " f(x)= " & VBA.CStr(f_c) & VBA.Chr(9) & " error= " & VBA.CStr(errorAproximacion) &
VBA.Chr(13) & VBA.Chr(10)
intIteracion = intIteracion + 1
If ((f_c * f_a) < 0) Then 'Si el cambio de signo se produce entre Xa y Xc, cambiamos
los lmites
Xb = Xc
ElseIf ((f_c * f_b) < 0) Then 'Si el cambio de signo se produce entre Xc y Xb,
cambiamos los lmites
Xa = Xc
End If
Loop
Else
MsgBox "Verificar que entre " & Xa & " y " & Xb & " existe una raz. Acote mejor los
extremos de la raiz y vuelva a empezar"
Exit Function
End If
fRaizSecante = Xc
End Function