Metodo de Newton Raphson

Algebra Lineal Numerica MM423

Prof. Ivan Henrquez
25 de mayo de 2015
//Metodo de Newton-Raphson; Sergio Alejandro Gomez Macias, 20121000227
#include<iostream>
#include<iomanip>
#include<math.h>
using namespace std;
typedef double functions(double x0[]);
typedef unsigned int uint;
/**************************************************************/
void Newton(functions *F[],functions *Jacob[], double x0[],
const uint n, const double error,const uint max);
void Eval_Jacob(functions *Jacob[], const uint n, double x0[], double evaluated[]);
void Eval_Function(functions *F[],const uint n, double x0[],double FXn[]);
void MatrixVector(double Matriz[],const double Vector[], const uint m,
const uint n, double Vector_Resultante[]);
void gauss_elimination(double A[], double resultado[], double b[],const uint n);
double err( const double x0[],const double x[],const uint n);
void backward_substitution(double A[],const double b[], double resultado[], const uint n);
/**********************************FUNCIONES****************************/
/***************************F(X)=(F1,F2,...,Fn)***********************************/
double F1(double x[]);
double F2(double x[]);
/*************************JACOBIANO*************************************/
double F1x(double x[]);
double F1y(double x[]);
double F2x(double x[]);
double F2y(double x[]);
/**************************************************************/
int main(){
1

uint n;
cout<<"Introduzca el tama
Ao del sistema"<<endl;
cin>>n;
functions (*F[n]);
F[0]=F1;
F[1]=F2;
functions (*Jacobiano[n]);
Jacobiano[0]=F1x; Jacobiano[1]=F1y; Jacobiano[2]=F2x;
Jacobiano[3]=F2y;
/*******************************VECTOR INICIAL*******************************/
double *x0=new double [n];
x0[0]=0.5; x0[1]=0.5;
/**************************************************************/
double *x=new double [n];

Newton(F,Jacobiano,x0,n,1.0e-20,40);
delete []x0;
return 0;
}
/*****************************DEFINICION DE FUNCIONES*********************************/
double F1(double x[])
{
return x[0]*x[0]+x[1]*x[1]-1;
}
double F2(double x[])
{
return x[1]-x[0];
}
/*****************************ELEMENTOS DEL JACOBIANO*********************************/
double F1x(double x[])
{
return 1;
}
double F1y(double x[])
{
return 1;
}
double F2x(double x[])
{
return -1;
}
2

double F2y(double x[])

{
return 1;
}
/****************************METODO DE NEWTON**********************************/
void Newton(functions *F[],functions *Jacob[],double x0[],
const uint n,const double error,const uint max )
{
cout<<setw(15)<<"x"<<setw(20)<<"y"<<setw(20)<<"error"<<endl;
double *Resultado=new double [n];
double *Jacob_Evaluated=new double [n*n];
double *FXn=new double [n];
double *xTemp=new double [n];
double *Xn=new double [n];
for(uint i=0;i<n;i++) xTemp[i]=0;
for(uint i=0;i<n;i++) Resultado[i]=0;
for(uint i=0;i<n*n;i++) Jacob_Evaluated[i]=0;
for(uint i=0;i<n;i++) FXn[i]=0;
for(uint i=0;i<max;i++)
{
Eval_Function(F,n,x0,FXn);
Eval_Jacob(Jacob,n,x0, Jacob_Evaluated);
MatrixVector(Jacob_Evaluated, x0,n,n, xTemp);
for(uint k=0;k<n;k++) Xn[k]=x0[k];
for(uint j=0;j<n;j++) x0[j]=xTemp[j]-FXn[j];
cout<<setprecision(16)<<scientific;
gauss_elimination(Jacob_Evaluated, Resultado,x0,n);
for(uint k=0;k<n;k++) x0[k]=Resultado[k];

for(uint k=0;k<n;k++) cout<<x0[k]<<"

cout<<err(Resultado,Xn,2)<<endl;

";

if(err(Resultado,Xn,2)<error) break;

}
delete []Resultado; delete []Jacob_Evaluated;
delete []FXn; delete []xTemp;
}
/******************************FUNCION PARA EVALUAR LOS PUNTOS EN EL JACOBIANO**************
void Eval_Jacob(functions *Jacob[], const uint n, double x0[], double evaluated[])
{
for(uint i=0;i<n*n;i++) evaluated[i]=Jacob[i](x0);
3

}
/*************FUNCION PARA EVALUAR LOS PUNTOS EN LAS FUNCIONES DEL SISTEMA***********/
void Eval_Function(functions *F[],const uint n, double x0[],double FXn[])
{
for(uint i=0;i<n;i++) FXn[i]=F[i](x0);
}
/***************MULTIPLICAR MATRIZ POR VECTOR*************************/

void MatrixVector(double Matriz[],const double Vector[], const uint m,const uint n, double V
{
for(uint i=0;i<m;i++)
{Vector_Resultante[i]=0;
for(uint j=0;j<n;j++)
{
Vector_Resultante[i]+=Matriz[n*i+j]*Vector[j];
}
}
}
/**************************CALCULAR EL ERROR************************************/
double err(const double x0[],const double x[],const uint n)
{
double aux=0;
for(uint i=0;i<n;i++) aux+=(x0[i]-x[i])*(x0[i]-x[i]);
return sqrt(aux);
}
/**************************ELIMINACION GAUSS************************************/
void gauss_elimination(double A[], double resultado[], double b[], const uint n)
{
double factor;
double *factores=new double [n];
for(uint i=0;i<n-1;i++)
{
factor=1/A[(n+1)*i];
A[(n+1)*i]=1;
for(uint j=i+1;j<n;j++) A[n*i+j]=factor*A[n*i+j];
b[i]=factor*b[i];
for(uint j=i+1;j<n;j++)
{
for(uint k=i+1;k<n;k++) A[n*j+k]=-A[n*j+i]*A[n*i+k] +A[n*j+k];
4

b[j]=-A[n*j+i]*b[i]+b[j];
A[n*j+i]=0;
}
}
/**************************SUSTITUCION HACIA ATRAS************************************/
backward_substitution(A,b,resultado,n);
}
void backward_substitution(double A[], const double b[], double resultado[], uint n)
{
for(int i=n-1;i>=0;i--)
{
resultado[i]=b[i];
for(uint j=i+1;j<n;j++) resultado[i]=resultado[i]-resultado[j]*A[n*i+j];
resultado[i]=resultado[i]/A[(n+1)*i];
}