Paradas en el camino...: Metodo de punto fijo

La teoria de punto fijo constituyo una parte importante en la topología del siglo XIX. Una aplicación sencilla e interesante, que este estudio nos concede, es la posibilidad de encontrar las raíces para algunas funciones.

Si reescribimos la ecuación $f(x)=0$ como $x=g(x)$ podemos emplear un método iterativo para hallar los puntos fijos. Esto consiste en escoger un punto inicial $x_{0}$ e iterar el sistema $x_{i+1}=g(x_{i})$ hasta alcanzar algún criterio de convergencia.

A continuación te comparto un código en C que haya un punto fijo para las siguientes funciones:

a) $x = \cos\left(x\right)$
b) $x = 0.5\left(x^{3}+1\right)$
c) $x = x^{3}+1$
d) $x = -\sqrt{1-x}$

Se aceptan votos. Espero te sea de utilidad.

#include <stdio.h>

#include <stdlib.h>

#include <math.h>

#define CONVERGE 1

#define DIVERGE 0

#define MODOR "r"

#define MODOW "w"

// Funcion para cargar o crear un archivo

FILE *openFile(const char *nomFile, const char *modo)

{ FILE *inFile=(FILE *)malloc(sizeof(FILE));

// Apertura de Archivo de ENTRADA y validacion de errores

inFile = fopen(nomFile,modo);

printf( "\n Archivo: %s ->",nomFile);

if(inFile) printf( " ABIERTO" );

else{printf( " NO ABIERTO" ); return(NULL);}

return(inFile);

}// fin de cargar o crear un archivo

// Estructura donde se almacena el

// punto fijo hallado y si convergio o divergio

struct puntoFijo1D

{ double punto; // almacena el punto hallado de X

int condiv; // 1: converge, 0: diverge

};

// Retorna el minimo double

double overDownDouble()

{ double val=1.0, ant,i=2.0;

{ ant=val;

val=val/i;

}while((ant)==(val*i));

return(ant);

}// fin de funcion

// Retorna el maximo Double

double overUpDouble()

{ double val=1.0, ant,i=2.0;

do{

{ ant=val;

val=val*i;

}while((ant)==(val/i));

val=ant;

i=i-1/pow(10,6);

}while(i>1.0);

return(val);

}// fin de funcion

// Funciones a evaluar-------------------------------------------------------

// Funcion inciso a)

double getFA(double x)

{return(cos(x));}

// Funcion inciso b)

double getFB(double x)

{return(0.5*(x*x*x+1));}

// Funcion inciso c)

double getFC(double x)

{return(x*x*x+1);}

// Funcion inciso d)

double getFD(double x)

{

if((1.0-x)<0)return(fabs((1.0-x)));

return(-sqrt(1.0-x));

}

// Retorna el punto fijo, si es que convergio o no

// para una funcion de la forma x=F(x)

struct puntoFijo1D *getPuntoFijo1D(double x0, double F(double x), FILE *file)

{ struct puntoFijo1D *point=(struct puntoFijo1D *)malloc(sizeof(struct puntoFijo1D));

double epsilon=0.0, maxDouble=0.0, x1=x0, iter=-1.0;

epsilon=overDownDouble();

maxDouble=overUpDouble();

// Buscar punto de convergencia

{ x0=x1;

x1=F(x0);

iter++;

fprintf(file,"\n Iteracion%7.0lf : %e",iter,x0);

if(fabs(x1)>maxDouble)// divergio

{

point->punto=x0;

point->condiv=DIVERGE;// divergio

return(point);

}// fin de if

}while(fabs(x1-x0)>epsilon);// fin del while

// sale del while significa que converge

point->punto=x1;

point->condiv=CONVERGE;// divergio

return(point);

}// fin de la funcion

// Main Principal

int main()

{

double val=0,sigVal=0.0;

FILE *outFile;

struct puntoFijo1D *punto;

printf("\n Probar diferentes procesos iterativos y su convergencia con diferentes puntos\n");

printf("\n x = cos( x )");

outFile=openFile("A1.txt", MODOW); val=-3.0;

punto=getPuntoFijo1D(val, getFA,outFile);