metodos numericos

UAM A Métodos numéricos Profr. Rafael Escarela Pérez

RAÍCES DE ECUACIONES

Métodos cerrados

Para los siguientes métodos (cerrados y abiertos) que son utilizados para el cálculo de las raíces de ecuaciones; se utilizó la misma función, para poder establecer una comparación y comprobación entre los resultados arrojados por los mismos.

Función: f(x) = -0.4x2+2.2x+4.7

Método gráfico:

Eurídice Hernández Herrera 210333148


Método de bisección:

#include "stdafx.h"#include "math.h"

double a,b,tolerancia;unsigned int nitermax,contador;double f(double),raiz,error;void leer_datos(),comprueba(),bisecta(),imprimir();

int main(){

leer_datos();comprueba();bisecta();imprimir();

scanf("%u",&nitermax);return 0; }

double f(double x){

return (-.4) * pow(x, 2) + 2.2* x + 4.7; }

void leer_datos(){

printf("\nESTE PROGRAMA ENCUENTRA LA RAIZ DE UNA ECUACION POR EL ALGORITMO DE BISECCION\n");printf("\t\ta=");scanf("%lf",&a);printf("\t\tb=");scanf("%lf",&b);printf("\t\tTolerancia=");scanf("%lf",&tolerancia); }

void comprueba(){

double producto;producto=f(a)*f(b);if(producto==0){

error=0;if(f(a)==0)

raiz=a;else

raiz=b;imprimir(); }

if(producto>0){

printf("\nNO SE SATISFACE LA CONDICION f(a)*f(b)<0");main(); } }

void bisecta(){

double xmedia,producto;error=1.0;



contador=0;while(error>tolerancia && contador<nitermax){

++contador;xmedia=(a+b)/2;producto=f(a)*f(xmedia);if(producto==0){

raiz=xmedia;error=0;imprimir(); }

if(producto<0)b=xmedia;

elsea=xmedia;

error=fabs(b-a);printf("\nIteraccion=%u Xmedia=%12.18lg Error=%12.18lg",contador,xmedia,error); }

raiz=xmedia; }

void imprimir(){

printf("\nRaiz=%12.18lg",raiz);printf("\nError=%12.18lg",error);printf("\n# de Iteracciones=%u\n",contador);//exit(1); }



Método de la falsa posición:


double a,b,raiz,precision,error,funcion(double x);unsigned int niteraciones,contador;void leer_datos(),reglafalsa(),resultados();

int main(){

leer_datos();reglafalsa();resultados();return 0; }

/*En caso de otra ecuacion sustituir la linea de return(?).....*/

double funcion(double x){

return (-.4) * pow(x,2) + 2.2 * x + 4.7; }

void leer_datos(){

printf("\nESTE PROGRAMA ENCUENTRA LA RAIZ DE LA ECUACION\n\n\tPOR EL METODO DE LA REGLA FALSA\n\n");printf("\nProporciona a=");scanf("%lf",&a);printf("\nProporciona b=");scanf("%lf",&b);printf("\nProporciona Precision=");scanf("%lf",&precision);printf("\nProporciona # maximo de iteraciones=");scanf("%u",&niteraciones); }

void reglafalsa(){

double fa,fb,fx,x;contador=0;error=1.0;fa=funcion(a);fb=funcion(b);if(fa*fb>0){

printf("\nNo se puede aplicar regla falsa ya que f(a)*f(b)>0\n");main(); }

if(fa*fb==0){

if(fa==0){

raiz=a;error=0; }

else{

raiz=b;error=0; } }



/*Aplicamos algoritmo de regula falsi.......*/else

while(error>precision&&niteraciones>contador){

contador++;x=(b*fabs(funcion(a))+a*fabs(funcion(b)))/(fabs(funcion(a))+fabs(funcion(b)));fx=funcion(x);error=fabs(fx);if(fa*fx==0){

raiz=x;error=0; }

if(fa*fx<0){

b=x;fb=fx; }

else{

a=x;fa=fx; }

printf("\nI=%3u a=%12.18lf b=%2.18lf error=%2.18lf",contador,a,b,error); }raiz=x; }

void resultados(){

printf("\n\n\nRaiz=%2.18lf",raiz);printf("\nError=%2.18lf",error);printf("\n# de interaciones=%u\n",contador);scanf("%u",&niteraciones);}



Métodos abiertos

Iteración simple de punto fijo:

// PUNTOFIJO.cpp : Defines the entry point for the console application.///*programa que calcula la raíz de una ecuación con el método del punto fijo*/

#include "stdafx.h"#include<stdio.h>#include<math.h>

double funcion(double);double xn, precision;unsigned int nitermax;void leer_datos(), punto_fijo();

void main(){

leer_datos();punto_fijo();scanf("%u",&nitermax); }

void leer_datos(){ printf("\n\tEste programa aplica el metodo del punto fijo:"); printf("\n\n\tProporciona Xn:"); scanf("%lf",&xn); printf("\n\t\tProporciona tolerancia:"); scanf("%lf",&precision); printf("\n\t\tproporciona # maximo de iteraciones:"); scanf("%u",&nitermax); }

void punto_fijo(){ double xnm1,error=1; unsigned int cuenta=0; while(error>precision && nitermax>cuenta) { ++cuenta; xnm1=funcion(xn); error=fabs(xnm1-xn); printf("\n\nI=%u X=%12.17lf",cuenta,xnm1); xn=xnm1; }

printf("\n\nRAIZ=%12.17lf ERROR=%12.17lf",xnm1,error); printf("\n\n# ITERACIONES=%u\n\n\n",cuenta); }

double funcion(double x){ return (-.4) * pow(x,2) + 2.2*x + 4.7; }



Newton – Raphson:

// NR.cpp : Defines the entry point for the console application.////ESTE PROGRAMA APLICA EL METODO DE NEWTON PARA ENCONTRAR LA RAIZ DE UNA ECUACION. Xn+1 = Xn - f(Xn)/f´(Xn)...

#include "stdafx.h"#include<stdio.h>#include<math.h>void lectura_datos(),newton(),imprimir_resultado();double funcion(double),derivada_funcion(double),xn,tolerancia,error;unsigned int niteraciones,cuenta;

void main(){lectura_datos();newton();scanf("%u",&niteraciones); }

void lectura_datos(){printf("\n\tESTE PROGRAMA ENCUENTRA RAICES POR EL METODO DE NEWTON RAPHSON\n");printf("\tProporciona Xn=");scanf("%lf",&xn);printf("\tProporciona Tolerancia=");scanf("%lf",&tolerancia);printf("\tProporciona # max de iteracciones=");scanf("%u",&niteraciones); }

void newton(){double xnm1;error=1.0;cuenta=0;while(error>tolerancia && cuenta<niteraciones){++cuenta;xnm1=xn-funcion(xn)/derivada_funcion(xn);error=fabs(xnm1-xn);printf("\nI=%u Xn=%12.15lf Xnm1=%12.15lf deltaX=%12.15lf",cuenta,xn,xnm1,error);xn=xnm1; }

imprimir_resultado(); }

double funcion(double x){return (-.4) * pow(x,2) + 2.2 * x + 4.7;; }

double derivada_funcion(double x){return (-0.8)*x +2.2; }

void imprimir_resultado(){printf("\n\n\t#De Iteraciones = %u",cuenta);printf("\n\tRaiz=%12.18lf",xn); }



Método de la secante:


double funcion(double);double a,b,tolerancia,raiz,error;unsigned int nitermax,cuenta;void leer_datos(),secante(),comprueba(),imprimir();

void main(){

leer_datos();secante();imprimir();scanf("%u",&nitermax); }

void leer_datos(){

printf("\n\tEste programa aplica el metodo de la secante para encontrar una raiz");printf("\n\tProporciona intervalo: \n");printf("\t\ta=");scanf("%lf",&a);printf("\n\t\tb=");scanf("%lf",&b);printf("\n\t\tProporcione tolerancia:");scanf("%lf",&tolerancia);printf("\n\t\tProporcione # maximo de iteraciones=");scanf("%u",&nitermax); }

void secante(){

double x;error=1;cuenta=0;while(error>tolerancia && nitermax>cuenta){

++cuenta;x=(a*funcion(b)-b*funcion(a))/(funcion(b)-funcion(a));error=fabs(funcion(x));printf("\nI=%u X=%12.17lf",cuenta,x);if(x<a)

a=x;else

b=x; }raiz=x; }


return (-.4) * pow(x,2) + 2.2 * x + 4.7;

void imprimir(){

printf("\n\nRaiz=%12.18lf Error=%1.18lf",raiz,error);printf("\n\t#De iteraciones=%u\n",cuenta);



//exit(1);}



SOLUCIONES DE SISTEMAS DE ECUACIONES

Dentro de la solución de sistemas de ecuaciones se trabajará con el mismo sistema para todos los métodos involucrados para poder establecer comparación entre los mismos.

Sistema de ecuaciones: 3x - 0.1y - 0.2z = 7.85 (1) color azul0.1x + 7y -0.3z = -19.3 (2) color verde0.3x - 0.2y +10 = 71.4 (3) color rosa

Gráfica:

Eliminación de Gauss:


double niteraciones,x[100]={0},a[100][100]={0},c[100]={0};double tam;void gauss(),leer();

int main(void){

leer();gauss();scanf("%lf",&niteraciones);return 0; }

void leer(){

int i,j,k;



printf("\n\n\t\tMETODO ITERATIVO DE GAUSS\n\n\n\n");printf("\n\tPROPORCIONA EL NUMERO DE ITERACIONES=");scanf("%lf",&niteraciones);printf("\nPROPORCIONA EL TAMANO=");scanf("%lf",&tam);printf("\nPROPORCIONA LOS VALORES DE LOS COEFICIENTES DE LA ECUACION\n");for(j=0;j<tam;j++){

for(i=0;i<tam;i++){

printf("\n\tA[%d,%d]=",j+1,i+1);scanf("%lf",&a[j][i]);} }

printf("\n\tPROPORCIONA LOS VALORES A QUE SE IGUALA LA ECUACION\n");for(k=0;k<tam;++k){

printf("\n\tC[%d]=",k+1);scanf("%lf",&c[k]); }

return; }

void gauss(){

int i,j,k,r;double contador=0,aa=0,bb,cc,dd,ee=0,ff;do{

contador+=1;printf("\n\tITERACION=%3.0lf\n",contador);for(j=0;j<tam;j++){

aa=0;for(k=0;k<tam;k++){

if(j!=k){

aa+=a[j][k]*x[k]; } }

x[j]=(1.0/a[j][j])*(c[j]-aa);printf("\tR[%d]= %lf\n",j+1,x[j]); } }

while(contador<niteraciones);

printf("\n\n\n\n\n");printf("\n\t\tRESULTADOS\n\n");for(i=0;i<tam;i++){

printf("\n\n\tX[%d]= %lf\n\n",i+1,x[i]); }

return; }



Gauss – Jordan:


double niteraciones,x[100]={0},a[100][100]={0},c[100]={0};double tam;void gauss(),leer();

int main(void){

leer();gauss();scanf("%lf",&niteraciones);return 0; }

void leer(){

int i,j,k;printf("\n\n\t\tMETODO ITERATIVO DE GAUSS\n\n\n\n");printf("\n\tPROPORCIONA EL NUMERO DE ITERACIONES=");scanf("%lf",&niteraciones);printf("\nPROPORCIONA EL TAMANO=");scanf("%lf",&tam);printf("\nPROPORCIONA LOS VALORES DE LOS COEFICIENTES DE LA ECUACION\n");for(j=0;j<tam;j++){

for(i=0;i<tam;i++){

printf("\n\tA[%d,%d]=",j+1,i+1);scanf("%lf",&a[j][i]); } }

printf("\n\tPROPORCIONA LOS VALORES A QUE SE IGUALA LA ECUACION\n");for(k=0;k<tam;++k){

printf("\n\tC[%d]=",k+1);scanf("%lf",&c[k]); }

return; }

void gauss(){

int i,j,k,r;double contador=0,aa=0,bb,cc,dd,ee=0,ff;do{

contador+=1;printf("\n\tITERACION=%3.0lf\n",contador);for(j=0;j<tam;j++){

aa=0;for(k=0;k<tam;k++){

if(j!=k){

aa+=a[j][k]*x[k]; } }Eurídice Hernández Herrera 210333148


x[j]=(1.0/a[j][j])*(c[j]-aa);printf("\tR[%d]= %lf\n",j+1,x[j]); } }

while(contador<niteraciones);

printf("\n\n\n\n\n");printf("\n\t\tRESULTADOS\n\n");for(i=0;i<tam;i++){

printf("\n\n\tX[%d]= %lf\n\n",i+1,x[i]); }

return; }



Descomposición LU:

#include "stdafx.h"#include<stdio.h>#define max 20double s,b[max],a[max][max],c[max],x[max];int n,i,j,k;

int _tmain(void){printf("Introduce el orden de la matriz:");scanf("%d",&n);while (n>max)

{ printf("\nEl orden de la matriz debe ser menor a %d",max); printf("\nIntroduce de nuevo el orden de la matriz="); scanf("%d",&n); }

for(i=1;i<=n;i++)for(j=1;j<=n;j++)

{ printf("\nIntroduce el dato a[%d,%d]=",i,j); scanf("%lf",&a[i][j]); }

while(a[1][1]==0){

printf("\nLa factorizacion no es posible \n\ta[1,1] debe ser diferente de 0"); printf("\nIntroduzca a[1,1]="); scanf("%lf",&a[1][1]); }

for(j=1;j<=n;j++) { printf("\nIntroduce el dato c[%d]=",j); scanf("%lf",&b[j]); c[j]=x[j]=0; }

for(j=1;j<=n;j++){

for(i=j;i<=n;i++) { s=0; if(j==1)

a[j][i]-=s; else { for(k=1;k<=j-1;k++) s+=a[j][k]*a[k][i]; a[j][i]-=s; } }

if(j!=n) { for(i=j+1;i<=n;i++) { s=0; if(j==1)



a[i][j]=(a[i][j]-s)/a[j][j]; else { for (k=1;k<=j-1;k++) s+=a[k][j]*a[i][k]; a[i][j]=(a[i][j]-s)/a[j][j]; } } } }

if(a[n][n]==0)printf("\nLa factorizacion no es posible");

else{

for(i=1;i<=n;i++) for(j=1;j<=n;j++) if(i>j) printf("\nL[%d,%d]=%lf",i,j,a[i][j]); else if(i==j) printf("\nL[%d,%d]=1",i,j); else printf("\nL[%d,%d]=0",i,j); printf("\n"); for(i=1;i<=n;i++) for(j=1;j<=n;j++) if(i>j) printf("\nU[%d,%d]=0",i,j); else printf("\nU[%d,%d]=%lf",i,j,a[i][j]); }

for(i=1;i<=n;i++){

s=0; for(j=1;j<=n;j++) s+=a[i][j]*c[j]; c[i]=(b[i]-s); }

printf("\n");for(i=n;i>=1;i--)

{ s=0; for(j=1;j<=n;j++) { s+=a[i][j]*x[j]; } x[i]=(c[i]-s)/a[i][i]; }

for(i=1;i<=n;i++)printf("\nx[%d]=%lf",i,x[i]);

scanf("\nx[%d]=%lf",i,x[i]); }



Matriz inversa:

// Ma_In.cpp : Defines the entry point for the console application.////CALCULO DE LA MATRIZ INVERSA

#include "stdafx.h"#include<stdio.h>#define indice 50double a[indice][indice];double rango;void leer_datos(),inversa();

void main(){printf("\n\n PROPORCIONA RANGO DE LA MATRIZ=");scanf("%lf",&rango);leer_datos();inversa();scanf("%lf",&rango); }

void leer_datos(){register int i,j,k;//LECTURA DE LA MATRIZ...for(i=0;i<rango;++i){for(j=0;j<rango;++j){printf("A[%d,%d]=",i+1,j+1);scanf("%lf",&a[i][j]); } } }

void inversa(){register int i,j,k;/*CALCULO MATRIZ INVERSA*/for(k=0;k<rango;++k){for(j=0;j<rango;++j){if(j!=k)a[k][j]=a[k][j]/a[k][k]; }

a[k][k]=1/a[k][k];for(i=0;i<rango;++i){if(i!=k){for(j=0;j<rango;++j){if(j!=k)a[i][j]=a[i][j]-a[k][j]*a[i][k]; } } }

for(i=0;i<rango;++i){if(i!=k) a[i][k]=-a[i][k]*a[k][k]; } }

printf("\n CALCULO DE LA INVERSA\n");Eurídice Hernández Herrera 210333148


for(i=0;i<rango;++i){for(j=0;j<rango;++j){printf("\nA^-1[%d,%d]=",i+1,j+1);printf("%12.8lf",a[i][j]); } } }



Gauss – Seidel:

// GaussSeidel.cpp: define el punto de entrada de la aplicación de consola.//


#define REN 50#define COL 50float converge,X[REN],xant[REN],sum,epsi,A[REN][COL];int q,n,k,r,c,maxiter;

int main(){

int i,j;printf("\n Dame el orden de la matriz de coeficientes: ");scanf("%d",&n);printf("\n Dame la matriz aumentada\n");for (i=1;i<=n;++i)

for(j=1;j<=n+1;++j){

printf("A[%d,%d]",i,j);scanf("%f",&A[i][j]); }

printf("\nDame la tolerancia e = ");scanf("%f",&epsi);printf("\nEscribe el numero de iteraciones 0<N<5 N= ");scanf("%d",&maxiter);converge=1;for (j=1;j<=n;++j)

X[j]=xant[j]=0;k=1;while(k<maxiter && converge > epsi){

for(r=1;r<=n;++r){

sum=A[r][n+1];for(c=1;c<=n;++c){

if (c!=r)sum = sum - A[r][c]*X[c]; }

X[r]=sum/A[r][r]; }

converge=0;for(j=1;j<=n;++j)

converge=converge + fabs(X[j]-xant[j]);for(j=1;j<=n;++j)

xant[j]=X[j];

k++; }

if (converge<epsi)

{Eurídice Hernández Herrera 210333148


printf("\n El resultado es: \n");for(j=1;j<=n;++j)

printf("\n x%d= %f\n",j,X[j]); }

else printf("\n\n NO CONVERGE \n\n");

scanf("%d",&n); }



AJUSTE DE CURVAS

En esta parte de ajuste de curvas se trabajará con los siguientes puntos:

X Y1 0.52 2.53 24 45 3.56 67 5.5

Al realizarse la graficación de los puntos y linealización de los mismos, se obtiene:

Regresión por mínimos cuadrados (lineal):

// MinimosCuadrados.cpp: define el punto de entrada de la aplicación de consola.//


double x[100],y[100];double T[40][100],TT[100][40];double TY[40],yc[100],multTTT[40][40],A[100],error[100],yp,errorp[100];int grado,ndatos;void lectura(),matrizT(),transpT(),inversaT(),multipli_TTT(),inversa_TTT(),multipli_TY(),coeficientes(),calculo_Y(),varianza_calculo();

int main(void){

lectura();matrizT();transpT();



multipli_TTT();inversa_TTT();multipli_TY();coeficientes();calculo_Y();varianza_calculo();scanf("%d",&grado); }

void lectura(){

register int i;int j;//LECTURA DEL GRADO DEL POLINOMIO A AJUSTAR Y DEL NUMERO TOTAL DE DATOS...printf("\n\n\n\n\t\t\aProporciona grado de Polinomio a Ajustar:");scanf("%d",&grado);printf("\n\n\t\t\a# total de datos = ");scanf("%d",&ndatos);//Lectura de Datos Experimentales...for(i=0;i<ndatos;++i){

j=i+1;printf("\t\t\b\a X[%d] = ",j);scanf("%lf",&x[i]);printf("\t\t\aY[%d] = ",j);scanf("%lf",&y[i]); } }

void matrizT(){

register int i,j;int k;k=grado;for(i=0;i<=grado;++i){

for(j=0;j<ndatos;++j){

T[i][j]=pow(x[j],k);printf("\nT= %lf",T[i][j]);

}--k; } }

void transpT(){

register int i,j;for(i=0;i<=grado;++i)

for(j=0;j<ndatos;++j)TT[j][i]=T[i][j];}

void multipli_TTT(){

register int i,j,k;double suma=0.;for(i=0;i<=grado;++i){

for(j=0;j<=grado;++j)



{for(k=0;k<ndatos;++k){

suma+=T[i][k]*TT[k][j];}multTTT[i][j]=suma;suma=0.; } } }

void inversa_TTT(){

register int i,j,k;for(k=0;k<=grado;++k){

for(j=0;j<=grado;++j){

if(j!=k) multTTT[k][j]=multTTT[k][j]/multTTT[k][k]; }

multTTT[k][k]=1/multTTT[k][k];for(i=0;i<=grado;++i){

if(i != k){


if(j != k) multTTT[i][j]=multTTT[i][j]-multTTT[k][j]*multTTT[i][k];} } }

for(i=0;i<=grado;++i){

if(i != k) multTTT[i][k]=-multTTT[i][k]*multTTT[k][k]; } }

for(i=0;i<=grado;++i){


printf("\n I[%u,%u] = ",i,j);printf("%lf",multTTT[i][j]); } } }

void multipli_TY(){

register int i,j;double suma=0.;for(i=0;i<=grado;++i){


suma+=T[i][j]*y[j]; }TY[i]=suma;printf("\nTY[%u]=%g",i,TY[i]);suma=0.; } }

void coeficientes(){

register int i,j;



double suma=0.;for(i=0;i<=grado;++i){


suma+=multTTT[i][j]*TY[j];}A[i]=suma;printf("\nA=%lf",A[i]);suma=0.; } }

void calculo_Y(){

register int i,j;double suma=0.;double sumay=0.;for(i=0;i<ndatos;++i){


suma+=A[j]*pow(x[i],grado-j);printf("\n\t\a A[%u] = %lf",j,A[j]);

}yc[i]=suma;sumay+=y[i];suma=0.;printf("\nY=%lf",yc[i]); }

yp=sumay/ndatos;printf("\n\t\t\a\aSUMAY=%lf YP=%lf",sumay,yp); }

void varianza_calculo(){

register int i,j;double varianza,difer,diferp,r;double suma=0.,sumap=0.;for(i=0;i<ndatos;++i){

printf("\nY=%lf YC=%lf",y[i],yc[i]);difer=yc[i]-y[i];diferp=y[i]-yp;printf("\nDIFER=%lf",difer);suma+=pow(difer,2);sumap+=pow(diferp,2); }

r=sqrt((sumap-suma)/sumap);printf("\nSUMA=%lf SUMAP=%lf",suma,sumap);varianza=suma/(ndatos-(grado+1));printf("\nvarianza=%lf r=%lf",varianza,r);for(j=0;j<=grado;++j){

printf("\n\nvarianza=%f T[j,j]=%g",varianza,multTTT[j][j]);error[j]=sqrt((varianza*multTTT[j][j])/ndatos);printf("\n\n\t\aError[%u]=%lf\n",j,error[j]);printf("\nA[%u] = %lf",j,A[j]);



if(A[j]!=0)errorp[j]=fabs(error[j]/A[j]*100);

printf("\n\n\t\t\aERRORP[%u]=%lf\n",j,errorp[j]); }

printf("\n\tECUACION DEL POLINOMIO AJUSTADO...");printf("\n\t\tY = ");for(j=0;j<=grado;++j)

printf("%lf X ^ %d +",A[j],grado-j);printf("\n\n"); }



Interpolación

Interpolación de polinomios de Lagrange:

// InterpolacionLagrange.cpp: define el punto de entrada de la aplicación de consola.//

#include "stdafx.h"

#define indice 50void lectura(),calculo();float x[indice],y[indice],l[indice];int ndatos;

int main(){

lectura();calculo();scanf("%u",&ndatos);return 0; }

void lectura(){

int i;printf("\n\t\t Interpolacion Lagrange");printf("\n\n\t Proporciona # total de datos=");scanf("%u",&ndatos);for(i=1;i<ndatos;i++){

printf("\nX[%u]=",i);scanf("%g",&x[i]);printf("\nY[%u]=",i);scanf("%g",&y[i]); } }

void calculo(){

float xint,acumula,multiplica,yint;int i,j;printf("\n\n\t Proporciona X para interpolar=");scanf("%g",&xint);

for(i=1;i<=ndatos;++i){

multiplica=1;for(j=1;j<=ndatos;++j){

if(i!=j)multiplica*=(xint-x[j])/(x[i]-x[j]); }

l[i]=multiplica; }acumula=0;

for(i=1;i<=ndatos;++i) acumula+=l[i]*y[i];yint=acumula;printf("\n\n\t El valor de Y interpolado es = %g",yint); }



DIFERENCIACIÓN NUMÉRICA E INTEGRACIÓN Regla trapezoidal:

// ReglaTrapezoidal.cpp: define el punto de entrada de la aplicación de consola.//


void lectura_datos(),trapecio(),imprimir();double funcion (double),xminima,xmaxima,integral;unsigned int nparticiones;

int main(){

lectura_datos();trapecio();imprimir();scanf("%u",&nparticiones); return 0; }


return .2 + 25 * x + (-200) * pow(x,2) + 675 * pow(x,3) - 900 * pow(x,4) + 400 * pow(x,5); }

void lectura_datos(){

printf("\nESTE PROGRAMA CALCULA LA INTEGRAL DE funcion (x)...\n");printf("Xminimima=");scanf("%lf",&xminima);printf("Xmaxima=");scanf("%lf",&xmaxima);printf("#De Particiones=");scanf("%u",&nparticiones); }

void trapecio(){

double h,acumulador;register int j;h=(xmaxima-xminima)/nparticiones;acumulador=0;for(j=1;j<nparticiones;++j)

acumulador+=funcion(xminima+j*h);integral=h*(funcion(xminima)/2.0+acumulador+funcion(xmaxima)/2.0); }

void imprimir(){

printf("\nla intengral de la funcion es:%12.18lf\n",integral); }



Simpson 1/3:

// ReglaSimpson.cpp: define el punto de entrada de la aplicación de consola.//


unsigned int nparticiones;double limite_inferior,limite_superior,area;double funcion(double);void lectura(),simpson(),imprime();int main(){

lectura();simpson();imprime();scanf("%u",&nparticiones);return 0; }

void lectura(){

printf("\tESTE PROGRAMA CALCULA LA INTEGRAL POR LA REGLA DE SIMPSON DE 1/3");printf("\n\t\tEL NUMERO DE PARTICIONES ES UN NUMERO PAR");printf("\n\t# DE PARTICIONES=");scanf("%u",&nparticiones);if(nparticiones %2 != 0){

printf("\n\tEL NUMERO DE PARTICIONES ES UN NUMERO PAR");printf("\n\n\t\tPRESIONA UNA TECLA PARA CONTINUAR");main(); }

else{

printf("\n\tLIMITE INFERIOR=");scanf("%lf",&limite_inferior);printf("\n\tLIMITE SUPERIOR=");scanf("%lf",&limite_superior); } }

void simpson(){

double suma1=0,suma2=0,h,x;register int i;x=limite_inferior;h=(limite_superior-limite_inferior)/nparticiones;for(i=1;i<=nparticiones-1;i+=2)

suma1+=funcion(limite_inferior+i*h);for(i=2;i<=nparticiones-2;i+=2)

suma2+=funcion(limite_inferior+i*h);

area=h/3.0*(funcion(limite_inferior)+4*suma1+2*suma2+funcion(limite_superior)); }

void imprime(){

printf("\n\tINTEGRAL=%20.20lf\n",area); }




return .2 + 25 * x + (-200) * pow(x,2) + 675 * pow(x,3) - 900 * pow(x,4) + 400 * pow(x,5); }



Simpson 3/8:

// SIMPSON 38.cpp : Defines the entry point for the console application.//

#include "stdafx.h"#include <stdio.h> #include <math.h>

double a,b;unsigned int n;double f(double);void LeeDatos(),Simpson3_8();

int main(){LeeDatos();Simpson3_8();scanf("%u",&n); }

void LeeDatos(){double f;printf("\n Metodo de Integracion por 3/8 de Simpson"); printf("\n ========================================\n"); printf("\n Numero de intervalos (IMPAR) ="); scanf("%u",&n); printf("\n Valor de a ="); scanf("%lf",&a); printf("\n Valor de b ="); scanf("%lf",&b);f=(b-a)/n;printf("f= %lf",f); }

/*Metodo de Simpson 3/8 dada una funcion*/void Simpson3_8(){ double Area; register int i; double S0,S1,h,x; S0=S1=0.0; h=(b-a)/n; printf("h= %lf",h); x=a; for(i=1;i<n;i++) { x+=h; if(i==(i/3)*3)

S0+=2*f(x); else

S1+=3*f(x); }

Area=3*(b-a)/(8*n)*(f(a)+S0+S1+f(b)); printf("\n El area es -> %5.6lf",Area); }

/*Funcion a integrar*/Eurídice Hernández Herrera 210333148


double f(double x){ return .2 + 25 * x + (-200) * pow(x,2) + 675 * pow(x,3) - 900 * pow(x,4) + 400 * pow(x,5);; }



EDO

Método de Euler:

// EULER.cpp: Defines the entry point for the console application.////ESTE PROGRAMA RESUELVE LA ECUACION Y'=f(x,y) POR EULER

#include "stdafx.h"#include<stdio.h>#include<math.h>

double funcion(double,double),x0,yinicial,h;unsigned int n;void lectura_datos(),euler();

int main(){lectura_datos();euler();scanf("%lf",&x0);return 0; }

double funcion(double x,double y){return(x*y); }

void lectura_datos(){printf("\nEste programa resuelve la ecuacion y'=f(x,y) por euler\n");printf("\tProporciona condiciones iniciales...\n");printf("\tX0=");scanf("%lf",&x0);printf("\tY(%lf)=",x0);scanf("%lf",&yinicial);printf("\th=");scanf("%lf",&h);printf("\tn="); scanf("%u",&n); }

void euler(){double xim1,yim1,yi;register int j;printf("\ty(%lf)=%lf",x0,yinicial);xim1=x0;yim1=yinicial; for(j=1;j<=n;++j){yi=yim1+h*funcion(xim1,yim1);xim1=x0+j*h;printf("\nY(%lf)=%lf\n",xim1,yi);yim1=yi; } }



RK segundo orden:

// RungeKuttaSegOrden.cpp: define el punto de entrada de la aplicación de consola.//


double xinic,yinic,h;double f(double, double);long unsigned int nitera;

int main(){

void leer_datos(), runge_kutta_2();leer_datos();runge_kutta_2();scanf("%u",&nitera);return 0; }

void leer_datos(){

printf("\t\nESTE PROGRAMA RESUELVE LA ECUACION Y'=F(X,Y)\n\t\t POR RUNGE KUTTA DE SEGUNDO ORDEN\n");printf("\n\t\tPROPORCIONA Xinicial=");scanf("%lf", &xinic);printf("\n\t\tPROPORCIONA Yinicial=");scanf("%lf",&yinic);printf("\n\t\tPROPORCIONA h=");scanf("%lf",&h);printf("\n\t\tPROPORCIONA # DE ITERACIONES=");scanf("%u",&nitera); }

void runge_kutta_2(){

double x,y,k1,k2,phi;long unsigned int i=0;x=xinic;y=yinic;printf("\n\tY(%lf)=%12.12lf",x,y);for(i=1;i<=nitera;++i){

k1=f(x,y);k2=f(x+h,y+h*k1);phi=1.0/2.0*(k1+k2); printf("\n\t\tk1=%12.12lf k2=%12.12lf",k1,k2);printf("\n\t\tPHI=%12.12lf",phi);y+=h*phi;x+=h;printf("\n\tY(%lf)=%12.12lf",x,y); } }

double f(double x, double y){

return (-2)* pow(x,3) + 12 * pow(x,2) - 20 * x + 8.5; }



RK cuarto orden:

// RK4.cpp : Defines the entry point for the console application.//

#include "stdafx.h"#include<stdio.h>#include<math.h>double xinic,yinic,h;double f(double,double);long unsigned int nitera;

int main(){void leer_datos(),runge_kutta_4();leer_datos();runge_kutta_4();scanf("%lf",&xinic);return 0; }

void leer_datos(){printf("\t\tESTE PROGRAMA RESUELVE LA ECUACION Y'=F(X,Y)\n\t\t\tPOR RUNGE KUTTA DE CUARTO ORDEN\n");printf("\n\tPROPORCIONA Xinicial=");scanf("%lf",&xinic);printf("\n\t\tPROPORCIONA Yinicial=");scanf("%lf",&yinic);printf("\n\t\tPROPORCIONA h=");scanf("%lf",&h);printf("\n\t\tPROPORCIONA # DE ITERACIONES=");scanf("%lu",&nitera); }

void runge_kutta_4(){double x,y,k1,k2,k3,k4,phi;long unsigned int i=0;x=xinic;y=yinic;printf("\n\tY(%lf)=%12.12lf",x,y);for(i=1;i<=nitera;++i){k1=f(x,y);k2=f(x+h/2.0,y+h/2.0*k1);k3=f(x+h/2.0,y+h/2.0*k2);k4=f(x+h,y+h*k3);phi=1.0/6.0*(k1+2*k2+2*k3+k4);printf("\n\t\tk1=%12.12lf k2=%12.12lf",k1,k2);printf("\n\t\tk3=%12.12lf k4=%12.12lf",k3,k4);printf("\n\t\tPHI=%12.12lf",phi);y+=h*phi;x+=h;printf("\n\tY(%lf)=%12.12lf",x,y); } }

double f(double x,double y){return(x*y+1); }


metodos numericos

Documents