miércoles, 5 de diciembre de 2012

MÉTODO DEL TRAPECIO

En este método tomamos en cuenta la formula  de la velocidad de una paracaidista apara entenderlo un poco mas claro y lograr ver su aplicación:

Código:


#include <iostream.h>
#include <conio.h>
#include <ctype.h>
#include <math.h>
#include <stdlib.h>
#include <string.h>
#include <stdio.h>

//--------------------------------------TRAPECIO SIMPLE-------------------------------------
  class TRAPECIO_SIMPLE{

  private:


  double a,b,fa,fb,I,fc,fa1,fb1;
        float d,o,u,r,k,s,Ea,ET;



  public:

  void menu();
  void datos();
  void imprime();
  void evalua();
  void VV();
  void METODO();
  void ERRORES();
  void nmain();
};

void TRAPECIO_SIMPLE::datos()
{


clrscr();
cout<<endl<<"\t ------METODO DEL TRAPECIO (SIMPLE) ----"<<endl;
cout<<endl<<"\t ------FORMULA DE LA VELOCIDAD DE UN PARACAIDISTA----"<<endl;
cout<<endl<<"\t ------(gm/c)*(t+(m/c)*(e^(ct/m))----"<<endl;
cout<<endl<<" Ingrese el valor de a: ";
cin>>a;
cout<<endl<<" Ingrese el valor de b: ";
cin>>b;

}
void TRAPECIO_SIMPLE::VV()
{

      d=((9.81*68.1)/12.5);
      r=68.1/12.5;
      u=((-12.5/68.1)*(a));
      o=((-12.5/68.1)*(b));
fa=(a+(r*exp(u)));
fb=(b+(r*exp(o)));
      fc=(d*(fb-fa));
      }
void TRAPECIO_SIMPLE::METODO()
{
 k=(-12.5/68.1);
      fa1=(1-(exp(k*a)));
fb1=(1-(exp(k*b)));

I=d*(b-a)*((fa1+fb1)/2);

}

void TRAPECIO_SIMPLE::ERRORES()
{

ET=fc-I;
//Ea=fabs((d*-k)*(exp(k*b)-exp(k*a)));

}


void TRAPECIO_SIMPLE::imprime()
{
cout<<endl<<endl<<" VALOR VERDADERO DE LA INTEGRAL= "<<fc;
cout<<endl<<endl<<" Integral de f(x)= "<<I;
         cout<<endl<<endl<<" ET= "<<ET;
         //cout<<endl<<endl<<" Ea= "<<Ea;
getch();
    }



void TRAPECIO_SIMPLE::nmain()
{
datos();
VV();
METODO();
ERRORES();
imprime();

}

int main()
{
clrscr();
TRAPECIO_SIMPLE obj;
obj.nmain();
getch();
}




En este enlace pueden apreciar algunos ejemplos prácticos y lo que seria un poco de teoría de dicho método

MÍNIMOS CUADRADOS

En este método  es para encontrar digamos   un ajuste donde una familia de puntos coincida y se encuentren el la misma posición o alineados  en el siguiente figura  se puede apreciar mejor el concepto


Con esta gráfica se aprecia mejor el concepto que acabamos de mencionar notemos que la curva rojo es el ajuste que se buscara .

El código queda:


#include <iostream.h>
#include <conio.h>
#include <ctype.h>
#include <math.h>
#include <stdlib.h>
#include <string.h>
#define N 10
#include <stdio.h>

//--------------------------------------Minimos cuadrados-------------------------------------

//FUNCIONES DE MINIMOS CUADRADOS
  class registro
{
 
  private:
          int i,n;
  float xi[100],yi[100],xiyi[100],x2i[100];
  float sumxi,sumyi,sumxiyi,sumx2i,sumxi2,sumsr,sumst;
  float xprom,yprom,a1,a0,y,sr[100],st[100],sy,syx,r2;  
 
  public:
  void menu();
  void datos();
  void sumatorias();
  void promedio();
  void resultado();
  void coeficientes();
  void nmain();
};

void registro::datos()
{

cout<<endl<<" Ingrese el numero de datos: ";
cin>>n;      
clrscr();
for(i=0;i<n;i++)
{
clrscr();
cout<<endl<<" Dato "<<(i+1)<<" "<<"de"<<" "<<n<<endl;
cout<<endl<<" Ingrese el valor de Xi: ";
cin>>xi[i];
cout<<endl<<" Ingrese el valor de Yi: ";
cin>>yi[i];

}    
}




void registro::sumatorias()
{
 
clrscr();  
sumxi=0;
cout<<endl<<"\nSUMAS: ";  

cout<<endl<<endl<<" Xi:"<<endl;
for(i=0;i<n;i++)
{
cout<<endl<<xi[i];
}

for(i=0;i<n;i++)
{
sumxi=sumxi+xi[i];
}
cout<<endl<<"\nSUMA Xi = "<<sumxi;  

sumyi=0;
cout<<endl<<endl<<" Yi:"<<endl;

for(i=0;i<n;i++)
{
cout<<endl<<yi[i];
}

for(i=0;i<n;i++)
{
sumyi=sumyi+yi[i];
}
cout<<endl<<"SUMA Yi = "<<sumyi;

cout<<endl<<endl<<" Xi*Yi:"<<endl;

for(i=0;i<n;i++)
{
xiyi[i]=xi[i]*yi[i];
cout<<endl<<xiyi[i];
}

sumxiyi=0;
for(i=0;i<n;i++)
{
sumxiyi=sumxiyi+xi[i]*yi[i];
}
cout<<endl<<"SUMA Xi*Yi = "<<sumxiyi;

sumx2i=0;
cout<<endl<<endl<<" Xi^2:"<<endl;

for(i=0;i<n;i++)
{
x2i[i]=pow(xi[i],2);
cout<<endl<<x2i[i];
}
for(i=0;i<n;i++)
{
sumx2i=sumx2i+pow(xi[i],2);
}
cout<<endl<<" Xi^2 = "<<sumx2i;

sumxi2=pow(sumxi,2);
//cout<<endl<<" (sum Xi)^2 = "<<sumxi2;

}


void registro::promedio()
{
cout<<endl<<"\n PROMEDIO: ";
xprom=sumxi/n;
yprom=sumyi/n;
cout<<endl<<" Xprom. = "<<xprom;
cout<<endl<<" Yprom. = "<<yprom;    
}
void registro::coeficientes()
{
cout<<endl<<"\nCOEFICIENTES: ";
a1=(n*sumxiyi-sumxi*sumyi)/(n*sumx2i-sumxi2);
cout<<endl<<" a1 = "<<a1;

a0=yprom-a1*xprom;
cout<<endl<<" a0 = "<<a0;
cout<<endl<<"\nLA ECUACION ES: ";
//y=a0+a1*xprom;
cout<<endl<<"Y="<<a0<<"+"<<a1<<"*X"<<"+e";

   
}

void registro::resultado()
{
cout<<endl<<"\nSr: ";  
cout<<endl<<endl<<" Sr (Yi-a0-a1Xi)^2"<<endl;
for(i=0;i<n;i++)
{
sr[i]=pow(yi[i]-a0-a1*xi[i],2);
cout<<endl<<sr[i];
}

sumsr=0;
for(i=0;i<n;i++)
{
sumsr=sumsr+sr[i];
}
cout<<endl<<" Suma de Sr : "<<sumsr;

cout<<endl<<endl<<" St (Yi-Yprom)^2"<<endl;
for(i=0;i<n;i++)
{
st[i]=pow(yi[i]-yprom,2);
cout<<endl<<st[i];
}

sumst=0;
for(i=0;i<n;i++)
{
sumst=sumst+st[i];
}
cout<<endl<<" Suma St : "<<sumst;

cout<<endl;
sy=sqrt(sumst/(n-1));
cout<<endl<<" Sy = "<<sy;
cout<<endl;
cout<<endl<<"\nDESVIACION ESTANDAR: ";
syx=sqrt(sumsr/(n-2));
cout<<endl<<" Sy/x = "<<syx;
cout<<endl;
cout<<endl<<"\nCOEFICIENTE DE CORRELACION: ";
r2=(sumst-sumsr)/sumst;
cout<<endl<<" r^2 = "<<r2;

getch();
}
void registro::nmain()
{
cout<<"\n\t\t--------------METODO DE MINIMOS CUADRADOS-----------------\n";
datos();
sumatorias();
promedio();
coeficientes();
resultado();
}

int main()
{
clrscr();
registro obj;
obj.nmain();
getch();
}

Imágenes del programa:








MÉTODO DE SIMPSON DE 1/3

Este método sirve para calcular las integrales   por ejemplo de tipo exponencial elevada al cuadrado como la que se trabajo en clase. Recordemos que el calcular una integral  nos significa otra cosa mas que el área que se encuentra debajo de la curva.

Algo muy importante que debemos tener en cuenta es que para este método recuerden que "n" debe ser PAR.. se preguntaran ¿Por Qué?... esto por que para generar una parábola  es necesario contar con 2 puntos.

Se podría calcular  si "n" fuera impar pero se utilizaría otro método el del trapecio y para obtener dicha área se realizaría  la suma del método de simpson 1/3 y el método del trapecio.

Un ejemplo del código:


#include<iostream.h>
#include<conio.h>
#include<stdio.h>
#include<math.h>
main()
{
clrscr();
long double coef[20],a,b,h, x[20],y[20], I, div, promedio;
long double deriv[20];
int exp[20],n;// grado, n;
#ifndef BOOLEAN_H
#define BOOLEAN_H
      //typedef int bool;
      //const int true  = 1;
      //const int false = 0;
#endif
 // int numero, cont = 0;
     int cont=0;
   double grado;
   bool continuar;
   do
   {
      continuar = false;
      cin.clear();
      if(cont > 0) cin.ignore(1024, '\n');
cout<<"........Programa que hace  un tercio de simson........."<<endl<<endl;
cout<<"Dame el grado del polinomio a integrar:"<<endl;
cin>>grado;
cont++;
      if(cin.fail() && cin.rdstate())
      {
      cout << "NO ES UN NUMERO" << endl;
      continuar = true;
      }
}while (continuar);
cout<<endl<<endl;
//*******************************************1
for(int i=0;i<=grado; i++)
{

     cout<<"Dame el coeficiente de x^"<<i<<endl;
     cin>>coef[i];
     deriv[i]=coef[i];
     exp[i]=i;
//deriv[i]=coef[i];
//exp[i]=i;

}
//*******************************************1
cout<<"La funcion quedara de la siguiente forma:"<<endl<<endl;
cout<<"\tf(x)= ";

//*******************************************2
for(int c=0; c<=grado;c++)
{
if(exp[c]!=0)
{
cout<<"+";
}
if(exp[c]!=0)
{
cout<<"("<<coef[c]<<"x^"<<exp[c]<<")";
}
if(exp[c]==0)
{
cout<<"("<<coef[c]<<")";
}
}
//*******************************************2
cout<<endl;
    int  cont2 = 0;
   // double a;
    bool continuar2;
    do
    {
    continuar2= false;
    cin.clear();

    if(cont2 > 0) cin.ignore(1024, '\n');

cout<<"Dame el punto 'a' donde se va a evaluar la funcion"<<endl;
cin>>a;
    cont2++;

    if(cin.fail() && cin.rdstate())
    {
    cout << "NO ES UN NUMERO" << endl;
    continuar2 = true;
    }
}while (continuar2);
//++++++++++
    int  cont3 = 0;
  //  double C;
    bool continuar3;
    do
    {
    continuar3= false;
    cin.clear();

    if(cont3 > 0) cin.ignore(1024, '\n');

cout<<"Dame el punto 'b' donde se va a evaluar la funcion"<<endl;
cin>>b;
    cont3++;

    if(cin.fail() && cin.rdstate())
    {
    cout << "NO ES UN NUMERO" << endl;
    continuar3 = true;
    }
}while (continuar3);
cout<<endl<<"En cuantos segmentos se va a dividir"<<endl;
scanf("%d",&n);
while (pow(-1,n)<0)  //Esto es por si es impar
{
printf("\n -------Lo SABIAMOs  siempre hay alguien q no sabe q es par-------- ");
scanf("%d",&n);
//while 1
}

h=((b-a)/(n));
//*******************************************3

x[0]=a;

cout<<"Valores:"<<endl<<"\t"<<"x0="<<x[0]<<endl<<endl;
for(int d=1; d<=n; d++)
{

x[d]=x[d-1]+h;

cout<<"\tx"<<d<<"="<<x[d]<<endl<<endl;

}
//*******************************************3


//*******************************************4


for(int e=0; e<=n; e++)
{
long double fx=0;

for(int f=0; f<=grado; f++)
 {

if(f!=0)
   {
fx=(coef[f]*(pow(x[e],f)))+fx;
   }
if(f==0)
   {
fx=coef[f]+fx;
   }


 }
y[e]=fx;
cout<<endl<<"El valor de:"<<endl<<endl<<"\t f(x"<<e<<")="<<y[e]<<endl<<endl;

}
//*******************************************4

long double impar,par;
//******************************************5
long double auximpar=0;
long double auxpar=0;

for(int g=1; g<=(n-1); g+=2)
{

auximpar=y[g]+auximpar;
//cout<<endl<<auximpar<<endl;

}
impar=auximpar*4;
//cout<<endl<<impar<<endl;

//******************************************5

//******************************************6

for(int j=2; j<=(n-2); j+=2)
{

auxpar=y[j]+auxpar;
//cout<<endl<<auxpar<<endl;

}
par=auxpar*2;
//cout<<endl<<par<<endl;
//******************************************6

div=((y[0]+par+impar+y[n])/(3*n));

I=((b-a)*div)    ;

cout<<"El resultado de la integral es: "<<I<<endl;





//derivar*******************************************************************

//int ;

//auxgrado=grado;
//****************************************7
for(int l=grado; l>(grado-4);l--)
{


for(int k=1; k<=l; k++)
{

deriv[k-1]=(deriv[k]*k);



}


}
//*****************************************7




cout<<endl<<endl<<"La cuarta derivada es:"<<endl;
//****************************************8
cout<<"fIV(x)=";
for(int m=0; m<=(grado-4);m++)
{


if(exp[m]!=0)
{
cout<<"+";
}
if(exp[m]!=0)
{
cout<<"("<<deriv[m]<<"x^"<<exp[m]<<")";
}
if(exp[m]==0)
{
cout<<"("<<deriv[m]<<")";
}

}
//***************************************8

promedio=((b-a)/2);


//*******************************************9



long double fxaux=0;

for(int o=0; o<=(grado-4); o++)
 {

if(o!=0)
   {
fxaux=(deriv[o]*(pow(promedio,o)))+fxaux;
   }
if(o==0)
   {
fxaux=deriv[o]+fxaux;
   }


 }
//y[e]=fx;

long double numerador, dominador, conciente, erroraprox;
numerador=(pow((b-a),5));
dominador=((pow(n,4))*180);
conciente=((numerador)/(dominador))*(-1);
erroraprox=(conciente)*(fxaux);

cout<<"El valor del error aproximado es: "<<endl;
cout<<erroraprox;

//*******************************************


getch();
return 0;
}
 Imagen:






En este enlace podemos encontrar una explicacion detallada de como se resolveria paso a paso y la expliacion del método bien especificada












METODO GAUSS - SEIDEL

En este método se  trabajo de igual forma  con matrices de 3x3 , realmente en este método no entendí mucho pero aquí hay un programa para ver mejor su comportamiento:


/* Metodo de Solucion Simultanea de Ecuaciones Lineales.  */
/* Metodo de Gauss-Seidel de una matriz. */


#include <stdio.h>
#include <iostream.h>
#include <conio.h>
#include <math.h>
#define max_ecu 10
#define max_inc 10
// Declaracion de variables genericas.
void   encabezado( void );
void      a_ceros( void );
void     cap_coef( void );
void gauss_seidel( void );
float    mat_coef[10][10];
float resul[10], C[10], x[10];
float margen_err;
int n_ecu, n_inc ;
int i, j, k, w ;
int lin, col1, col2, col3, col4, n_itera ;
char c;

// Programa Principal.

void main(void)
{
 inicio:
 a_ceros();
 encabezado();
cap_coef();
gauss_seidel();
cout<<"\n\t\t Desea Calcular otra Matriz? (s/n): \t "; c = getch();
if( c == 's' || c == 'S' )
goto inicio;
else
goto final;
 final:
cout<<"\n\n\t Teclee <ENTER> para continuar. "; getch();
}

// Funcion para hacer ceros a las variables.

void a_ceros( void )
{
 int i = j = 0;

for( i = 0; i < max_ecu; i++ )
{
for( j = 0; j <= max_inc; j++ )
{
mat_coef[i][j] = 0.0 ;
}
}
}

// Encabezado del Programa.

void encabezado( void )
 {
 n_itera = 0;
 margen_err = 0.0;
gotoxy(10, 6); cout<<" Metodo de GAUSS_SEIDEL de una Matriz.\n " ;
for( i = 1; i <= 78; i++ )      //Para trazar una linea sombreada.
{
printf("%c", 177 );
}
gotoxy(10, 8); cout<<" Teclee el numero de Ecuaciones. " ;
gotoxy(45, 8); cin>>n_ecu ;
gotoxy(10, 9); cout<<" Teclee el valor de epsilon." ;
gotoxy(45, 9); cin>>margen_err ;
gotoxy(10,10); cout<<" Teclee el numero maximo de iteraciones." ;
gotoxy(50,10); cin>>n_itera ;

gotoxy(10,11); cout<<" Captura de coeficientes del Sistema de Ecuaciones." ;

// Primero de trazan los Parentesis.

 // primer parentesis.
lin = 12 ;
col2 = 20 + (8*n_ecu ); // Inicia en 20 + Separacion del parentesis.

for( i = 1; i <= (n_ecu); i++ )
{
if( i == 1 )
 {
gotoxy(  20,lin); printf("%c", 218 );   //Se imprime un angulo sup. izq.
gotoxy(col2,lin); printf("%c", 191 );   //Se imprime un angulo sup. der.
 }
lin = lin + 1 ;
gotoxy(  20,lin); printf("%c", 179 );   //Se imprime una linea vertical.
gotoxy(col2,lin); printf("%c", 179 );   //Se imprime una linea vertical.
 }
lin = lin + 1 ;
gotoxy(  20,lin); printf("%c", 192 );   //Se imprime un ang inf izq.
gotoxy(col2,lin); printf("%c", 217 );   //Se imprime un ang inf der.

// Segundo parentesis.
lin = 12 ;
col3 = col2 + 2;     // Separacion del 2o parentesis.
col4 = col3 + 4;     // Abertura del parentesis.
for( i = 1; i <= n_ecu; i++ )
{
if( i == 1 )        // Trazo de las esquinas superiorres.
 {
gotoxy(col3,lin); printf("%c", 218 );  //Se imprime un angulo sup. izq.
gotoxy(col4,lin); printf("%c", 191 );  //Se imprime un angulo sup. der.
 }
lin = lin + 1 ;
gotoxy(col3,lin); printf("%c", 179 );  //Se imprime una linea vertical.
gotoxy(col4,lin); printf("%c", 179 );  //Se imprime una linea vertical.
}
lin = lin + 1 ;
gotoxy(col3,lin); printf("%c", 192 );  //Se imprime un ang inf izq.
gotoxy(col4,lin); printf("%c", 217 );  //Se imprime un ang inf der.

// Para imprimir las incognitas x's

 lin = 13;       //1er elemento.
col1 = 24;
col2 = col1 + 3;    // Separacion entre matrices.
col3 = col2 + 7;    // Espacio entre elementos.

for( i = 1; i <= n_ecu; i++ )
{
for( j = 1; j <= n_ecu; j++ )
{
gotoxy(col1,lin); printf("  X%d", i );
lin = lin + 1;    // Cambio de linea.
}
lin = 13;         // se regresa al principio.
 col1 = col1 + 7;   //Espacio entre las x's.
 }
}
/* Captura de Coeficientes. */

void cap_coef( void )
{
i = j = 0;
lin = 13 ;
col1 = 22 ;
for( i = 1; i <= n_ecu; i++ )
{
for( j = 1; j <= (n_ecu + 1); j++ )  //Incluye termino independiente.
{
if( j > n_ecu )
col1 = col1 + 4 ;
gotoxy(col1,lin);

if( i == 1 && j == 1 )           // Primer elemento.
scanf("%f", &mat_coef[1][1] );
else
scanf("%f", &mat_coef[i][j] );   // Elementos restantes.
col1 = col1 + 7 ;                // Separacion entre elementos.
}
lin = lin + 1 ;     // Cambio de linea.
col1 = 22 ;
}
}

// Algoritmo de Gauss-Seidel.

void gauss_seidel( void )
 {
float  x_ante[10];
float x_nueva[10];
float suma_err = 0.0 ;
float  err = 0.0;
float    r = 0.0;
 int    z = 0.0;
 int cont = 0  ;
w = n_ecu + 1;
for( k = 1; k <= n_ecu; k++ )
{
C[k] = mat_coef[k][w];
x[k] = 0.0;
 x_ante[k] = 0.0;
x_nueva[k] = 0.0;
}
do
{
cont = cont + 1;
printf("\n\t\t\t Iteracion Numero: %d ", cont);
for( i = 1; i <= n_ecu; i++ )
{
for( j = 1; j <= n_ecu; j++ )
{
if( i != j )
 {
 r = r +  mat_coef[i][j]*x[j];
 }
}
 x[i] = (C[i] - r)/mat_coef[i][i];
 printf("\n\t\t\t x[%d] = %10.5f", i, x[i] );
 x_nueva[i] = x[i];
 r = 0.0;
 }
 suma_err = 0.0;
 for( z = 1; z <= n_ecu; z++ )
 {
 if(x_nueva[z] != 0 )
 err = ( x_nueva[z] - x_ante[z])/x_nueva[z];
 err = fabs(err)*100;
 x_ante[z] = x_nueva[z];
suma_err = suma_err + err;
 }
 printf("\n\t\t\t Margen de error =%10.5f %", suma_err ); getch();
 }
 while ( (margen_err > suma_err) != (cont< n_itera)) ;
 }









Si no les queda muy claro dejo  link para que chequen bien el tema y esta muy bien explicado y con un ejemplo resuelto

MÉTODO DE GAUSS - JORDAN

En este método se trata de eliminar poco apoco para que podamos encontrar los valores de las variables. Es importante mencionar que debemos colocar la   matriz aumentada. Esta se obtiene  realizando la diagonal dominante la cual se debe de acomodar las filas de manera que los valores de mayor valor diagonalmente.

El siguiente programa realiza este método y explica  lo que va haciendo:


#include<iostream.h>
#include <conio.h>
#include <ctype.h>
#include <math.h>
#include <stdlib.h>
#include <string.h>
#define N 10
#include <stdio.h>
class jordan
   {
      private:
              float m[N][N+1], m1[N][N+1], X[N];

     public:
  
            void obtenerm(int n), imprimirm(int matriz,int n);
            void mfila(float factor,int fila, int n);
            void sumarfilas(float factor,int fila1, int fila2, int n);
            float sumarX(int n,int fila);
            void obtenerinc(int n);
            void gauss(int n);
            float evaluar(int n);
            void mmain();
 
   };




 void jordan::obtenerm( int n)
{
   int i,j;

cout<<"\nINGRESA LOS COEFICIENTES DE LA MATRIZ AUMENTADA: "<<endl;
   for(i=0;i<n;i++)
   {
    for(j=0;j<n;j++)
      {
      printf("\na[%d,%d]= ",i+1,j+1);
      cin>>m[i][j];
      }
      printf("\nb%d= ",i+1);
      cin>>m[i][j];
   }
}

void jordan::imprimirm(int matriz, int n)
{
   int i,j;
   for(i=0;i<n;i++)
   {
    for(j=0;j<n;j++)
      {
         if(matriz==0)
      printf("%5.2f  ",m[i][j]);
         else
         printf("%5.2f  ",m1[i][j]);
      }
      if(matriz==0)
      printf("|  %5.2f \n",m[i][j]);
      else
printf("|  %5.2f \n",m1[i][j]);
   }
   getch();
}

void jordan::mfila(float factor,int fila, int n)
{
   int i;
for(i=0;i<=n;i++)
    m1[fila][i]=m1[fila][i]*factor;
   printf("\nSe multiplico la fila %d por el factor %4.1f, para obtener un 1 en la diagonal principal\n",fila+1,factor);
   imprimirm(1,n);
}

void jordan::sumarfilas(float factor,int fila1, int fila2, int n)
{
   int i;
for(i=0;i<=n;i++)
    m1[fila2][i]=m1[fila1][i]*factor+m1[fila2][i];
   printf("\nSe multiplico la  fila %d por el factor %5.2f",fila1+1,factor);
   printf("\nSe sumo la fila multiplicada (%d) a la fila %d\n",fila1+1,fila2+1);
   imprimirm(1,n);
}

float jordan::sumarX(int n,int fila)
{
   float suma=0;
   int i;
for(i=0;i<n;i++)
    suma=suma+(X[i]*m1[fila][i]);
   return suma;
}

void jordan::obtenerinc(int n)
{
   int i;
   for(i=0;i<n;i++)
    X[i]=0;
   X[n-1]=m1[n-1][n];
for(i=n-2;i>=0;i--)
   {
    X[i]=m1[i][n]-sumarX(n,i);
   }
}

void jordan::gauss(int n)
{
int i,j,k;
   float a=0,suma=0;



   for(i=0;i<n;i++)
   for(j=0;j<=n;j++)
   m1[i][j]=m[i][j];
   for(i=0;i<n;i++)
   {
      if(m1[i][i]==0)
      {
         exit(0);
      }
    a=1/m1[i][i];
mfila(a,i,n);
      j=i;
      for(k=i+1;k<n;k++)
      {
      a=-m1[k][j];
         sumarfilas(a,i,k,n);
      }
      if(i>0)
      for(k=i-1;k>=0;k--)
      {
      a=-m1[k][j];
         sumarfilas(a,i,k,n);
      }

   }

   printf("\nLa matriz despues de aplicar el metodo es: \n");
   imprimirm(1,n);
   obtenerinc(n);
   printf("\n\nLos valores de las incognitas son: ");
   for(i=0;i<n;i++)
    printf("\nx%d = %5.2f",i+1,X[i]);
   int z;
   printf("\n\n\nEn que ecuacion desea comprobar (1,2,3): \n\n");
   printf("Opcion:      "); cin>>z;

   if(z==1)
   {
   printf("\n\nEvaluando valores en la primera ecuacion: \n\n");;
   for(i=0;i<n;i++)
   {
      if(m[0][i]>=0)
      printf("+%5.2f(%5.2f)",m[0][i],X[i]);
      else if(m[0][i]<0)
      printf("%5.2f(%5.2f)",m[0][i],X[i]);
suma=suma+(m[0][i]*X[i]);
   }
   printf("=%5.2f",suma);
    }
   else if(z==2)
   {
   printf("\nEvaluando valores en la segunda ecuacion: \n\n");;
   for(i=0;i<n;i++)
   {
      if(m[1][i]>=0)
      printf("+%5.2f(%5.2f)",m[1][i],X[i]);
      else if(m[1][i]<0)
      printf("%5.2f(%5.2f)",m[1][i],X[i]);
suma=suma+(m[1][i]*X[i]);
   }
   printf("=%5.2f",suma);
    }
    else if(z==3)
   {
   printf("\nEvaluando valores en la tercera ecuacion: \n\n");;
   for(i=0;i<n;i++)
   {
      if(m[2][i]>=0)
      printf("+%5.2f(%5.2f)",m[2][i],X[i]);
      else if(m[2][i]<0)
      printf("%5.2f(%5.2f)",m[2][i],X[i]);
suma=suma+(m[2][i]*X[i]);
   }
   printf("=%5.2f",suma);
}
}

void jordan::mmain()
{

cout<<"                              METODO DE GAUS JORDAN"<<endl;

   int n;
 cout<<"\nINGRESA EL TAMAÑO QUE TENDRA LA MATRIZ (nxn): ";
   cin>>n;

   obtenerm(n);
   cout<<"\nLa matriz aumentada es: "<<endl;
   imprimirm(0,n);

   //cout<<"\nSe usara el metodo de Gauss - Jordan para obtener las incognitas."<<endl;
   gauss(n);

}

int main()
{

clrscr();
jordan obj;
obj.mmain();
getch();
}

Imagenes:











RAÍCES DE UNA ECUACIÓN

Para poder empezar a ver bien los métodos debemos saber como regla básica  creo yo. el calculo de raíces de una ecuación. Tendremos en cuenta que habrá que habra 3 tipo de soluciones como se ha visto en los cursos de calculo desde la secundaria.

En este programa se calculan las raíces de una ecuación de segundo grado y se  muestra como queda ya una vez corrido programa :

 #include <iostream.h>
#include <math.h>
#include <conio.h>
#include <process.h>

class Formula
{
  private :
            double a;
            double b;
            double c;
            double d;
  public  :
            Formula( );
            void Leer( );
            double CalD( );
            void Reales( );
            void Imag( );
            ~Formula( );
};

int main ( )
{  clrscr();
   
    char opc;
    
    do
    {
    system( "cls" );

    Formula F;
      cout << " \tEste Programa calcula las raices de una ecuacion de segundo grado \
              por medio de la formula general que es....Ax2+Bx+C" << endl << endl;
              
    F.Leer( );
     if( F.CalD( )>=0 )
F.Reales( );

      else
F.Imag( );

    cout << " DESEA CONTINUAR S/N ";
   cout << endl;
   opc=getch( );
   system( "pause" );
    clrscr();

    }while( opc=='S' || opc=='s'  );

    return 0;
}

Formula :: Formula ( )
{
  a = 0.0;
  b = 0.0;
  c = 0.0;
  d = 0.0;
}

Formula :: ~Formula( )
{
  cout << " Termina el programa ";
  cout << endl;
  system( " pause " );
}

void Formula :: Leer( )
{
  cout << " Dame el valor de a : ";
  cin >> a;

  cout << " Dame el valor de b : ";
  cin >> b;

  cout << " Dame el valor de c : ";
  cin >> c;

  cout << endl << endl<<endl;
}

double Formula :: CalD( )
{
  d =  pow( b,2 ) - ( 4*( a*c ) ) ;

  return d;

}

void Formula :: Reales( )
{
  double X1;
  double X2;
  double X;

 if( a == 0 )
   {
    cout << " Raiz Unica : " << endl;

    X =  - c / b;

    cout << " X = " << X << endl << endl;
   }

else
  {
    cout << " Soluciones reales y distintas : " << endl;

     X1 = -b + sqrt( d );
     X1 = X1 / ( 2*a ) ;
     cout << " \tX1 = " << X1 << endl;

     X2 = -b - sqrt( d );
     X2 = X2 / ( 2*a );
     cout << " \tX2 = " << X2 << endl << endl;
  }

}

void Formula :: Imag( )
{

  cout << " Soluciones Imaginarias : " << endl;

  cout << " \tX1 = " << -b / ( 2*a ) <<  " i " << +  ( -1 )*sqrt( -d ) / ( 2*a ) << " i " << endl;
  cout << " \tX2 = " << -b / ( 2*a ) << " - i " << ( -1 )* sqrt( -d ) / ( 2*a ) << endl << endl;

}

El programa queda así:



EPSILON DE LA MAQUINA


Como una de las cosas que primeramente hicimos fue comprobar el 'epsilon de la computador, entendamos por epsilon de la maquina la exactitud relativa de la computadora para realizar operaciones aritméticas.

Se realizo un pequeño programa para indicar esto que se acaba de mencionar y así fue como me resulto: 

#include<math.h>
#include<iostream.h>
#include<iomanip.h>
#include<conio.h>
long double epsilon= 1;
long double suma= 1;
class vaca
{
 private:

    void calculosEpsilon(void);
    //void DEpsilon(void);
};


 void vaca::calculosEpsilon(void)
 {
   while(epsilon+1.0>1.0){
   epsilon= epsilon/2.0;
   }
   for(int i=1; i<=10000; i++){
    suma=suma+ 0.000010000000;
   }
   epsilon=10000 + 0.000010000000+1;
 }
 void main(void)
 {
  cout.setf(ios::scientific);
  cout<<setprecision(16)<<"\nEl epsilon de la maquina=  "<<epsilon<<"\n\n";

  cout<<setprecision(16)<<"El producto es= "<<epsilon<<"\n";
  cout<<setprecision(16)<<"La suma es= "<<suma<<"\n";
  cout<<setprecision(16)<<"El error acumulado es=  "<<suma - epsilon<<"\n\n";
  getch();
 }

Una vez que se corre el programa queda de la siguiente forma: