-> Tiene su menú interactivo, es mas de lo que muestra la imagen.
-> Mantiene una precisión comprobada de 9 decimas.
-> Presenta 3 métodos para resolver las ecuaciones planteadas.
-> Trabaja las ecuaciones en funciones independientes.
-> Las condiciones iniciales deben ser declaradas antes de correr el programa.
-> Las ecuaciones deben ser declaradas antes de correr el programa.
-> Mejorable añadiendo funciones para las ecuaciones para cada caso de integración, si así se desea.
-> Dado que el programa puede ciclarse se puede colocar datos con diferentes funciones y valores iniciales, aunque por ahora esta limitado a una función para todos los casos. Logrando así resolver 3 ejercicios sin terminar de correr el programa.
Acá les dejo el código:
///INTEGRALES DOBLES
#include <iostream>
#include <math.h>
#include <stdio.h>
#include <stdlib.h>
#include <iomanip>
#include <string.h>
using namespace std;
///---------------------------------------------------------------------------------------
struct Vect
{
double v[100];
};
///---------------------------------------------------------------------------------------
double pi=3.14159265 , e=2.71828183;
///---------------------------------------------------------------------------------------
void paso_inicial(double &h1,double &n1,double &c,double &d)
{
double aux1,aux2,aux3;
printf("\n ******DEVELOPED BY ALEXIS HUGO SEGALES RAMOSETH******\n");
cout<<"\n MODELO DE LA INTEGRAL: I[I F(xy) dx] dy";
cout<<"\n Defina los limites de la integral EXTERNA: ";
cout<<"\n desde c= "; cin>>aux1; cout<<" hasta d= "; cin>>aux2;
cout<<"\n Con cuantos intervalos desea trabajar: ";
cout<<"\n -> "; cin>>aux3;
c=aux1; d=aux2; n1=aux3;
h1=(double) (d-c)/n1;
}
///---------------------------------------------------------------------------------------
void fun_all(double &x,double &y,double &f)
{
f=(double) (x+y)/(cos(x)+cos(y));
}
///---------------------------------------------------------------------------------------
void con_iniciales(double &a,double &b,double y)
{
a=0;
b=1-y;
}
///---------------------------------------------------------------------------------------
void metTrapecio()
{
Vect y,x,fx,S,aa,bb,h3;
double suma2=0,suma,c,d,n1,h1,I,p2=0,p3=0;
paso_inicial(h1,n1,c,d);
system("cls");
for(int i=0 ; i<=n1 ; i++)
{
suma=0;
printf("\n %d. Integral Interna: ",i+1);
y.v[i]=(double) c + (i*h1);
con_iniciales(aa.v[i],bb.v[i],y.v[i]);
h3.v[i]=(double) (bb.v[i]-aa.v[i])/n1;
printf("\n Desde a= %.10lf Hasta b= %.10lf Con paso de h= %.10lf \n",aa.v[i],bb.v[i],h3.v[i]);
for(int j=0 ; j<=n1 ; j++)
{
x.v[j]=(double) aa.v[i]+(j*h3.v[i]);
fun_all(x.v[j],y.v[i],fx.v[j]);
printf("\n x[%d]= %.10lf | Fx[%d]= %.10lf ",j,x.v[j],j,fx.v[j]);
if(j==0 || j==n1) p2+=fx.v[j];
}
for(int k=1 ; k<n1 ; k++)
{
suma=(double) suma+fx.v[k];
}
//printf("\n El valor de las sumas intermedias es: %.10lf ",suma);
S.v[i]=(double) (h3.v[i]/3)*(p2+(2*suma));
//printf("\n El valor de la %d. Integral es: %.10lf",i+1,S.v[i]);
if(i==0 || i==n1) p3+=S.v[i];
printf("\n");
}
for(int l=0 ; l<=n1 ; l++)
{
printf("\n Resultado %d. Integral -> %.10lf",l+1,S.v[l]);
}
for(int k=1 ; k<n1 ; k++)
{
suma2=(double) suma2+S.v[k];
}
I=(float) (h1/3)*(p3+(2*suma2));
printf("\n\n EL VALOR DE LA INTEGRAL DOBLE ES: %.10lf\n_",I);
}
///---------------------------------------------------------------------------------------
void metSimpson()
{
Vect y,x,fx,S,aa,bb,h3;
double c,d,n1,h1,I,p1=0,p2=0,spa=0,sim=0,sp,si;
paso_inicial(h1,n1,c,d);
system("cls");
for(int i=0 ; i<=n1 ; i++)
{
sp=0, si=0;
printf("\n %d. Integral Interna: ",i+1);
y.v[i]=(double) c + (i*h1);
con_iniciales(aa.v[i],bb.v[i],y.v[i]);
h3.v[i]=(double) (bb.v[i]-aa.v[i])/n1;
printf("\n Desde a= %.10lf Hasta b= %.10lf Con paso de h= %.10lf \n",aa.v[i],bb.v[i],h3.v[i]);
for(int j=0 ; j<=n1 ; j++)
{
x.v[j]=(double) aa.v[i]+(j*h3.v[i]);
fun_all(x.v[j],y.v[i],fx.v[j]);
printf("\n x[%d]= %.10lf | Fx[%d]= %.10lf ",j,x.v[j],j,fx.v[j]);
if(j==0 || j==n1) p2+=fx.v[j];
}
for(int k=1 ; k<n1 ; k++)
{
if(k%2==0) sp=(double) sp+fx.v[k];
else si=(double) si+fx.v[k];
}
//printf("\n El valor de las sumas pares es : %.10lf ",sp);
//printf("\n El valor de las sumas impares es: %.10lf ",si);
S.v[i]=(float) (h3.v[i]/3)*(p2+(4*si)+(2*sp));
//printf("\n El valor de la %d. Integral es: %.10lf",i+1,S.v[i]);
if(i==0 || i==n1) p1+=S.v[i];
printf("\n");
}
printf("\n Los Valores de las Integrales Internas son: ");
for(int l=0 ; l<=n1 ; l++)
{
printf("\n %d. %.10lf ",l+1,S.v[l]);
}
for(int k=1 ; k<n1 ; k++)
{
if(k%2==0) spa=(double) spa+S.v[k];
else sim=(double) sim+S.v[k];
}
I=(float) (h1/3)*(p1+(4*sim)+(2*spa));
printf("\n\n EL VALOR DE LA INTEGRAL DOBLE ES: %.10lf",I);
}
///---------------------------------------------------------------------------------------
void Lamb_Absc(int valor,Vect &abscisas,Vect &lambdas)
{
if(valor==2)
{
abscisas.v[0]=(double) -1/sqrt(3);
abscisas.v[1]=(double) 1/sqrt(3);
lambdas.v[0]=1;
lambdas.v[1]=1;
}
if(valor==3)
{
abscisas.v[0]=(double) -sqrt(0.6);
abscisas.v[1]= 0;
abscisas.v[2]=(double) sqrt(0.6);
lambdas.v[0]=(double) 5/9;
lambdas.v[1]=(double) 8/9;
lambdas.v[2]=(double) 5/9;
}
if(valor==4)
{
abscisas.v[0]=(double) -0.861136311594053;
abscisas.v[1]=(double) -0.339981043584856;
abscisas.v[2]=(double) 0.339981043584856;
abscisas.v[3]=(double) 0.861136311594053;
lambdas.v[0]=(double) 0.347854845137454;
lambdas.v[1]=(double) 0.652145154864546;
lambdas.v[2]=(double) 0.652145154864546;
lambdas.v[3]=(double) 0.347854845137454;
}
if(valor==5)
{
abscisas.v[0]=(double) -0.906179845938664;
abscisas.v[1]=(double) -0.538469310105683;
abscisas.v[2]= 0;
abscisas.v[3]=(double) 0.538469310105683;
abscisas.v[4]=(double) 0.906179845938664;
lambdas.v[0]=(double) 0.236926885056189;
lambdas.v[1]=(double) 0.478628670499366;
lambdas.v[2]=(double) (128/225);
lambdas.v[3]=(double) 0.478628670499366;
lambdas.v[4]=(double) 0.236926885056189;
}
if(valor==6)
{
abscisas.v[0]=(double) -0.932469514203152;
abscisas.v[1]=(double) -0.661209386466265;
abscisas.v[2]=(double) -0.238619186083197;
abscisas.v[3]=(double) 0.238619186083197;
abscisas.v[4]=(double) 0.661209386466265;
abscisas.v[5]=(double) 0.932469514203152;
lambdas.v[0]=(double) 0.171324492379171;
lambdas.v[1]=(double) 0.360761573048139;
lambdas.v[2]=(double) 0.467913934572691;
lambdas.v[3]=(double) 0.467913934572691;
lambdas.v[4]=(double) 0.360761573048139;
lambdas.v[5]=(double) 0.171324492379171;
}
}
///---------------------------------------------------------------------------------------
void metGaussLegendre()
{
Vect y,x,fx,S,abscisas,lambdas,lamfun,Suma,aa,bb,AAA,BBB;
double c,d,n1,h1,I,AA,BB,s;
paso_inicial(h1,n1,c,d);
AA=(double) (d-c)/2;
BB=(double) (d+c)/2;
system("cls");
if(n1==2) Lamb_Absc(n1,abscisas,lambdas);
if(n1==3) Lamb_Absc(n1,abscisas,lambdas);
if(n1==4) Lamb_Absc(n1,abscisas,lambdas);
if(n1==5) Lamb_Absc(n1,abscisas,lambdas);
if(n1==6) Lamb_Absc(n1,abscisas,lambdas);
for(int i=0 ; i<n1 ; i++)
{
printf("\n %d. INTEGRAL INTERNA: ",i+1);
y.v[i]=(double) (AA*abscisas.v[i])+BB;
printf(" | Con y[%d]= %.10lf ",i+1,y.v[i]);
con_iniciales(aa.v[i],bb.v[i],y.v[i]);
printf(" | a= %.10lf | b= %.10lf\n",aa.v[i],bb.v[i]);
printf("\n i t[i] x[i] fx[i] lambda[i] lambda[i]*fx[i]");
printf("\n ------------------------------------------------------------------------------------");
s=0;
for(int j=0 ; j<n1 ; j++)
{
AAA.v[j]=(bb.v[i]-aa.v[i])/2;
BBB.v[j]=(bb.v[i]+aa.v[i])/2;
x.v[j]=(double) (AAA.v[j]*abscisas.v[j])+BBB.v[j];
fun_all(x.v[j],y.v[i],fx.v[j]);
lamfun.v[j]=(double) (lambdas.v[j]*fx.v[j]);
printf("\n |%d.| %.10lf | %.10lf | %.10lf | %.10lf | %.10lf |",j+1,abscisas.v[j],x.v[j],fx.v[j],lambdas.v[j],lamfun.v[j]);
s=s+lamfun.v[j];
}
for(int k=1 ; k<n1 ; k++)
{
S.v[k]=(double) s*BBB.v[k];
printf("\n Resultado de la Integral %.10lf \n",S.v[k]);
Suma.v[i]=S.v[k];
}
printf("\n");
}
double suma=0;
for(int k=0 ; k<n1 ; k++)
{
suma=(double) suma+Suma.v[k];
}
I=(double) AA*suma;
printf("\n\n EL VALOR DE LA INTEGRAL DOBLE ES: %.10lf \n",I);
}
///---------------------------------------------------------------------------------------
void menumetodos()
{
int opcion;
printf("\n\n Escoja el metodo de integracion:\n");
cout<<"\n 1. La Regla Compuesta del Trapecio";
cout<<"\n 2. La Regla Compuesta de Simpson";
cout<<"\n 3. Cuadratura de Gauss Legendre";
cout<<"\n\n -> ";cin>>opcion;
if(opcion==1)
{
system("cls");
metTrapecio();
}
if(opcion==2)
{
system("cls");
metSimpson();
}
if(opcion==3)
{
system("cls");
metGaussLegendre();
}
}
///---------------------------------------------------------------------------------------
void limppant()
{
printf("\n Desea iniciar de nuevo \n 1)SI \n 2)NO ");
int mess; cin>>mess;
if(mess==1)
{
system("cls");
system("rst");
menumetodos();
limppant();
}
if(mess==2)
{
system("close");
}
}
///---------------------------------------------------------------------------------------
int main()
{
menumetodos();
limppant();
return 0;
}
留言