ayudenme
felipe
31 de Agosto del 2003
hola necesito los metodos de punto fijo, newton-rapshon,metodo de la secante, de biseccion y el de regula falsi porfavor son para el jueves ok gracias
hechenme la mano ok bye [email protected]
hechenme la mano ok bye [email protected]
Victor Hugo Zepeda
31 de Agosto del 2003
/*ESPERO TE SIRVA, ESTE METODO ES EL DE NEWTON RAPHSON LA CONTRASEÑA ES: victor
*/
/*Programa que encuentra las raices de una ecuacion ya sea con coeficientes */
/*reales o complejos de cualquier gradao utilizando elmetodo de */
/* Newton-Raphson y la division sintetica*/
/* El programa necesita una contrase¤a para trabajar*/
#include<stdio.h>
#include<conio.h>
#include<stdlib.h>
#define max 20
struct complejo
{
double real;
double imag;
};
/*Funcion que calcula el producto de dos numeros complejos*/
struct complejo producto(struct complejo pot,struct complejo x)
{
struct complejo resultado;
resultado.real=pot.real*x.real-pot.imag*x.imag;
resultado.imag=pot.real*x.imag+pot.imag*x.real;
return resultado;
}
/*funcion que calcula el producto de un numero complejo por una constante*/
struct complejo multiplica(int grado,struct complejo variable)
{
struct complejo resultado;
resultado.real=grado*variable.real;
resultado.imag=grado*variable.imag;
return resultado;
}
/*funcion que eleva un numero complejo a una potencia dada*/
struct complejo potencia(struct complejo x, int grado)
{
struct complejo resultado;
int i;
resultado.real=1;
resultado.imag=0;
if(grado<0)
{
exit(1);
}
if(grado==0)
{
return resultado;
}
else
{
for(i=0;i<grado;i++)
{
resultado=producto(resultado,x);
}
}
return resultado;
}
/*Funcion que calcula la derivada*/
struct complejo derivada(struct complejo coef[max],struct complejo x, int grado)
{
int i,n;
struct complejo resultado;
struct complejo y;
resultado.real=0;
resultado.imag=0;
n=grado;
for(i=0;i<grado;i++)
{
y=producto(multiplica(n,coef[i]),potencia(x,n-1));
resultado.real+=y.real ;
resultado.imag+=y.imag;
n=n-1;
}
return resultado;
}
/*Funcion que evalua a la funcion dada*/
struct complejo eval_fun(struct complejo coef[max],struct complejo x,int grado)
{
struct complejo resultado;
struct complejo y;
int i,n;
resultado.real=0;
resultado.imag=0;
n=grado;
for(i=0;i<=grado;i++)
{
y=producto(coef[i],potencia(x,n));
resultado.real+=y.real;
resultado.imag+=y.imag;
n=n-1;
}
return resultado;
}
/*Funcion que calcula la resta del algoritmo*/
struct complejo resta(struct complejo xn, struct complejo d)
{
struct complejo resultado;
resultado.real=xn.real-d.real;
resultado.imag=xn.imag-d.imag;
return resultado;
}
/*Funcion que encuentra una raiz*/
struct complejo raiz(struct complejo xn,struct complejo h)
{
struct complejo resultado;
resultado=resta(xn,h);
return resultado;
}
/*Funcion que lee los coeficientes*/
void lee_coef(struct complejo coef[max],int grado)
{
int i;
for(i=0;i<=grado;i++)
{
printf("coef[%d]= ",i);
scanf("%lf,%lf",&coef[i].real,&coef[i].imag);
}
}
struct complejo division(struct complejo x,struct complejo y)
{
struct complejo r;
r.real=((x.real*y.real+x.imag*y.imag)/(y.real*y.real+y.imag*y.imag));
r.imag=((x.imag*y.real-x.real*y.imag)/(y.real*y.real+y.imag*y.imag));
return r;
}
/* ||||Funciones que ocupa la division sintetica |||*/
/* Funcion que calcula la suma de dos numeros complejos */
struct complejo sumacom(struct complejo c, struct complejo retorno)
{
struct complejo resultado;
resultado.real=c.real+retorno.real;
resultado.imag=c.imag+retorno.imag;
return resultado;
}
/* funcion que reemplaza los coeficientes de la funcion */
void reemplaza_coef_com(struct complejo coef[max],struct complejo resultado[max],int grado)
{
int i;
for(i=0;i<=grado;i++)
coef[i]=resultado[i];
}
/* Funcion que imprime los nuevos coeficientes */
void imprimecomp(struct complejo resultado[max],int grado)
{
int j;
for(j=0;j<=grado;j++)
printf("%.4lf,%.4lfi ",resultado[j].real,resultado[j].imag);
}
/* ||| Funciones que se utilizan para identificar la contrase¤a |||*/
/*Funcion que cuenta la longitud de un palabra*/
int longitud_palabra(char palabra[max])
{
int i;
int lon=0;
for(i=0;i<=max;i++)
{
if(palabra[i]==' ')
{
break;
}
else
{
lon=lon+1;
}
}
return lon;
}
/*Funcion que compara la palabra base con la entregada por el usuario*/
int compara(char pwd[max],char id[max],int l)
{
int i;
int s=0;
for(i=0;i<l;i++)
{
if(pwd[i]==id[i])
s=s+1;
}
return s;
}
/* Parte principal*/
main()
{
int ite;
int grado,k;
struct complejo coef[max];
struct complejo xn;
struct complejo r;
struct complejo d;
struct complejo n,h;
struct complejo prueba;
struct complejo retorno;
struct complejo resultado[max];
/* Variables para utilizar una contrase¤a */
char pwd[max];
char id[]= "victor";
int c,usuario,base;
clrscr();
printf(" ²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²n");
printf(" ² Combinacion del metodo de Newton-Raphson y la Division sintetica ²n");
printf(" ² Para encontrar las raices de una ecuacion con coeficientes complejos.²n");
printf(" ²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²nn");
printf("Contrase¤a: ");
scanf("%s",&pwd);
base=longitud_palabra(id);
usuario=longitud_palabra(pwd);
if(base!=usuario)
{
printf("aContrase¤a INCORRECTAn");
printf("Ni siquiera sabes introducir una maldita contrase¤a????a");
exit(1);
}
c=compara(pwd,id,usuario);
if(c==base)
{
gotoxy(1,6);
printf("%c Grado del polinomio: ",1);
scanf("%d",&grado);
printf("n%c Coeficientes: reales o complejos:n",1);
lee_coef(coef,grado);
printf("%c Primer aproximacion: real o compleja ",1);
scanf("%lf,%lf",&xn.real,&xn.imag);
printf("n********************************************n");
while(grado>=1)
{
do
{
for(ite=0;ite<3000;ite++)
{
n=eval_fun(coef,xn,grado);
d=derivada(coef,xn,grado);
h=division(n,d);
r=raiz(xn,h);
xn=r;
if(n.real!=0 && n.imag!=0 && ite==2999)
{
printf("No encontre raiz en %d iteraciones.n",ite+1);
exit(0);
}
}
}
while(n.real!=0 && n.imag!=0);
printf("nUna raiz es: %lf, %lfinn",r.real,r.imag);
prueba=eval_fun(coef,r,grado);
printf("La prueba es: %lf,%lfin",prueba.real,prueba.imag);
resultado[0]=coef[0];
retorno=coef[0];
for(k=1;k<=grado;k++)
{
resultado[k]=sumacom(coef[k],producto(retorno,r));
/*resultado[k]=producto(sumacom(coef[k],retorno),r);*/
retorno=resultado[k];
}
grado=grado-1;
printf("********************************************n");
printf("Los nuevos coeficientes son:n");
reemplaza_coef_com(coef,resultado,grado);
imprimecomp(coef,grado);
}
/* printf("No de iteracion %dn",ite);*/
}
else
{
printf("aContrase¤a INCORRECTAn");
printf("God bye...$#%&?a");
}
getch();
return 0;
}
*/
/*Programa que encuentra las raices de una ecuacion ya sea con coeficientes */
/*reales o complejos de cualquier gradao utilizando elmetodo de */
/* Newton-Raphson y la division sintetica*/
/* El programa necesita una contrase¤a para trabajar*/
#include<stdio.h>
#include<conio.h>
#include<stdlib.h>
#define max 20
struct complejo
{
double real;
double imag;
};
/*Funcion que calcula el producto de dos numeros complejos*/
struct complejo producto(struct complejo pot,struct complejo x)
{
struct complejo resultado;
resultado.real=pot.real*x.real-pot.imag*x.imag;
resultado.imag=pot.real*x.imag+pot.imag*x.real;
return resultado;
}
/*funcion que calcula el producto de un numero complejo por una constante*/
struct complejo multiplica(int grado,struct complejo variable)
{
struct complejo resultado;
resultado.real=grado*variable.real;
resultado.imag=grado*variable.imag;
return resultado;
}
/*funcion que eleva un numero complejo a una potencia dada*/
struct complejo potencia(struct complejo x, int grado)
{
struct complejo resultado;
int i;
resultado.real=1;
resultado.imag=0;
if(grado<0)
{
exit(1);
}
if(grado==0)
{
return resultado;
}
else
{
for(i=0;i<grado;i++)
{
resultado=producto(resultado,x);
}
}
return resultado;
}
/*Funcion que calcula la derivada*/
struct complejo derivada(struct complejo coef[max],struct complejo x, int grado)
{
int i,n;
struct complejo resultado;
struct complejo y;
resultado.real=0;
resultado.imag=0;
n=grado;
for(i=0;i<grado;i++)
{
y=producto(multiplica(n,coef[i]),potencia(x,n-1));
resultado.real+=y.real ;
resultado.imag+=y.imag;
n=n-1;
}
return resultado;
}
/*Funcion que evalua a la funcion dada*/
struct complejo eval_fun(struct complejo coef[max],struct complejo x,int grado)
{
struct complejo resultado;
struct complejo y;
int i,n;
resultado.real=0;
resultado.imag=0;
n=grado;
for(i=0;i<=grado;i++)
{
y=producto(coef[i],potencia(x,n));
resultado.real+=y.real;
resultado.imag+=y.imag;
n=n-1;
}
return resultado;
}
/*Funcion que calcula la resta del algoritmo*/
struct complejo resta(struct complejo xn, struct complejo d)
{
struct complejo resultado;
resultado.real=xn.real-d.real;
resultado.imag=xn.imag-d.imag;
return resultado;
}
/*Funcion que encuentra una raiz*/
struct complejo raiz(struct complejo xn,struct complejo h)
{
struct complejo resultado;
resultado=resta(xn,h);
return resultado;
}
/*Funcion que lee los coeficientes*/
void lee_coef(struct complejo coef[max],int grado)
{
int i;
for(i=0;i<=grado;i++)
{
printf("coef[%d]= ",i);
scanf("%lf,%lf",&coef[i].real,&coef[i].imag);
}
}
struct complejo division(struct complejo x,struct complejo y)
{
struct complejo r;
r.real=((x.real*y.real+x.imag*y.imag)/(y.real*y.real+y.imag*y.imag));
r.imag=((x.imag*y.real-x.real*y.imag)/(y.real*y.real+y.imag*y.imag));
return r;
}
/* ||||Funciones que ocupa la division sintetica |||*/
/* Funcion que calcula la suma de dos numeros complejos */
struct complejo sumacom(struct complejo c, struct complejo retorno)
{
struct complejo resultado;
resultado.real=c.real+retorno.real;
resultado.imag=c.imag+retorno.imag;
return resultado;
}
/* funcion que reemplaza los coeficientes de la funcion */
void reemplaza_coef_com(struct complejo coef[max],struct complejo resultado[max],int grado)
{
int i;
for(i=0;i<=grado;i++)
coef[i]=resultado[i];
}
/* Funcion que imprime los nuevos coeficientes */
void imprimecomp(struct complejo resultado[max],int grado)
{
int j;
for(j=0;j<=grado;j++)
printf("%.4lf,%.4lfi ",resultado[j].real,resultado[j].imag);
}
/* ||| Funciones que se utilizan para identificar la contrase¤a |||*/
/*Funcion que cuenta la longitud de un palabra*/
int longitud_palabra(char palabra[max])
{
int i;
int lon=0;
for(i=0;i<=max;i++)
{
if(palabra[i]==' ')
{
break;
}
else
{
lon=lon+1;
}
}
return lon;
}
/*Funcion que compara la palabra base con la entregada por el usuario*/
int compara(char pwd[max],char id[max],int l)
{
int i;
int s=0;
for(i=0;i<l;i++)
{
if(pwd[i]==id[i])
s=s+1;
}
return s;
}
/* Parte principal*/
main()
{
int ite;
int grado,k;
struct complejo coef[max];
struct complejo xn;
struct complejo r;
struct complejo d;
struct complejo n,h;
struct complejo prueba;
struct complejo retorno;
struct complejo resultado[max];
/* Variables para utilizar una contrase¤a */
char pwd[max];
char id[]= "victor";
int c,usuario,base;
clrscr();
printf(" ²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²n");
printf(" ² Combinacion del metodo de Newton-Raphson y la Division sintetica ²n");
printf(" ² Para encontrar las raices de una ecuacion con coeficientes complejos.²n");
printf(" ²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²nn");
printf("Contrase¤a: ");
scanf("%s",&pwd);
base=longitud_palabra(id);
usuario=longitud_palabra(pwd);
if(base!=usuario)
{
printf("aContrase¤a INCORRECTAn");
printf("Ni siquiera sabes introducir una maldita contrase¤a????a");
exit(1);
}
c=compara(pwd,id,usuario);
if(c==base)
{
gotoxy(1,6);
printf("%c Grado del polinomio: ",1);
scanf("%d",&grado);
printf("n%c Coeficientes: reales o complejos:n",1);
lee_coef(coef,grado);
printf("%c Primer aproximacion: real o compleja ",1);
scanf("%lf,%lf",&xn.real,&xn.imag);
printf("n********************************************n");
while(grado>=1)
{
do
{
for(ite=0;ite<3000;ite++)
{
n=eval_fun(coef,xn,grado);
d=derivada(coef,xn,grado);
h=division(n,d);
r=raiz(xn,h);
xn=r;
if(n.real!=0 && n.imag!=0 && ite==2999)
{
printf("No encontre raiz en %d iteraciones.n",ite+1);
exit(0);
}
}
}
while(n.real!=0 && n.imag!=0);
printf("nUna raiz es: %lf, %lfinn",r.real,r.imag);
prueba=eval_fun(coef,r,grado);
printf("La prueba es: %lf,%lfin",prueba.real,prueba.imag);
resultado[0]=coef[0];
retorno=coef[0];
for(k=1;k<=grado;k++)
{
resultado[k]=sumacom(coef[k],producto(retorno,r));
/*resultado[k]=producto(sumacom(coef[k],retorno),r);*/
retorno=resultado[k];
}
grado=grado-1;
printf("********************************************n");
printf("Los nuevos coeficientes son:n");
reemplaza_coef_com(coef,resultado,grado);
imprimecomp(coef,grado);
}
/* printf("No de iteracion %dn",ite);*/
}
else
{
printf("aContrase¤a INCORRECTAn");
printf("God bye...$#%&?a");
}
getch();
return 0;
}