Métodos o Análisis Numérico.

Método numérico: Integral definida. Regla de Simpson 1/3. Newton – Cotes:
C++

//==============================================================
//Método numérico para calcular la integral definida de f(x) dx
//por medio de la regla Simpson 1/3.
//==============================================================

#include <iostream>
#include <cmath>
#include<windows.h>
#include <stdlib.h>
using namespace std; //Para hacer uso de las funciones estándar del C.

double f(double x); //Esta subrutina definirá a la función.

int main(void)
{
 // Se despliega por pantalla la identificación del método:
 cout<<"Se ha omitido intencionalmente la acentuación gramatical."<<endl<<endl;
 cout<<"Metodo numerico para resolver integrales definidas"<<endl;
 cout<<"por la regla trapezoidal."<<endl;
 cout<<"=================================================="<<endl;
 cout<<"Se resuelve Integral de: exp(x)dx en el intervalo:"<<endl;
 

 //Se definen el contador de iteraciones y el número de iteraciones
 // n siempre deberá ser número par.
 int i,n=122;
 
 //Se definen los límites del intervalo:
 double a=0,b=1;

 cout<<"a = "<< a <<", b ="<< b <<", considerando "<< n << " iteraciones."<<endl;
 cout<<"=================================================="<<endl;

 cout<<"Resultado:"<<endl<<endl;

 // Se definen variables requeridas para el cálculo:
 double x,xant,factor,suma=0,h;
 
 h=(b-a)/double(n);

 xant=a;

 for (i=1;i<=n+1;i++)
 { 
  if(i%2==0)
   factor=double(4);
  else
   factor=double(2);

  if(i==1 || i==n+1)
   factor=double(1);

  x = h/double(3) * factor * f(xant);
  suma = suma + x;
  xant+=h;
 }

 //Se produce la salida del resultado por pantalla:
 cout << "Aproximadamente: " << suma << endl<<endl;

 cout<<"Introduzca 0 y Enter para terminar.";
 cin>>i;
 return 0;
}

//------------------------------------------------------
//Se define la función a integrar:
double f(double x)
{
 double fxr=exp(x);
 return(fxr);
}

Método numérico: Integral definida. Regla Trapezoidal. Newton – Cotes:
C++ 

//==============================================================
//Método numérico para calcular la integra definida de f(x) dx
//por medio de la regla trapezoidal.
//==============================================================

#include <iostream>
#include <cmath>
#include<windows.h>
#include <stdlib.h>
using namespace std; //Para hacer uso de las funciones estándar del C.

double f(double x); //Esta subrutina definirá a la función.

int main(void)
{
 // Se despliega por pantalla la identificación del método:
 cout<<"Se ha omitido intencionalmente la acentuación gramatical."<<endl<<endl;
 cout<<"Metodo numerico para resolver integrales definidas"<<endl;
 cout<<"por la regla trapezoidal."<<endl;
 cout<<"=================================================="<<endl;
 cout<<"Se resuelve Integral de: exp(x)dx en el intervalo:"<<endl;
 

 //Se definen el contador de iteraciones y el número de iteraciones:
 double i,n=100;
 int j=0;
 //Se definen los límites del intervalo:
 double a=1.8,b=3.4;

 cout<<"a = "<< a <<", b ="<< b <<", considerando "<< n << " iteraciones."<<endl;
 cout<<"=================================================="<<endl;

 cout<<"Resultado:"<<endl<<endl;

 // Se definen variables requeridas para el cálculo:
 double x,suma=0,h;
 
 h=(b-a)/double(n);

 for (i=1;i<=n;i++)
 {
  x = h/double(2) * ( f(a+(i-double(1))*h) + f(a + double(i)*h));
  suma = suma + x;
 }

 //Se produce la salida del resultado por pantalla:
 cout << "Aproximadamente: " << suma << endl<<endl;

 cout<<"Introduzca 0 y Enter para terminar.";
 cin>>i;
 return 0;
}

//------------------------------------------------------
//Se define la función a integrar:
double f(double x)
{
 double fxr=exp(x);
 return(fxr);
}

Método numérico: Ecuaciones no lineales. Bisecciones consecutivas. Intervalo medio.
C++

//==============================================================
//Método numérico para calcular raíces de ecuaciones no lineales.
//Bisecciones consecutivas. Intervalo medio.
//==============================================================

#include <iostream>
#include <cmath>
#include<windows.h>
#include <stdlib.h>

using namespace std; //Para hacer uso de las funciones estándar del C.

double f(double x); //Esta subrutina definirá a la función.

int main(void)
{
   // Se despliega por pantalla la identificación del método:
   cout<<"Se han omitido intencionalmente los acentos gramaticales."<<endl<<endl;
   cout<<"Metodo numerico para resolver ecuaciones no lineales."<<endl;
   cout<<"Bisecciones consecutivas. Intervalo medio."<<endl;
   cout<<"=================================================="<<endl;
   cout<<"Se resuelve f(x)= x3 + x2 - 3x - 3 =0"<<endl;

   //Se definen los valores iniciales:
   double x1=1,x2=2,tol=.005;

   cout<<"Raices x1 = "<< x1 <<", x2 ="<< x2 <<", Tolerancia = "<< tol <<endl;
   cout<<"=================================================="<<endl;

   cout<<"Resultado:"<<endl<<endl;
   //Se definen variables requeridas para el proceso de cálculo:
   double xm, fx1, fxm;
   if(f(x1)*f(x2)>=0)
   {
      cout<<"Los valores de x1="<<x1<<", x2="<<x2<<" no generan";
      cout<<"valores de signo contrario entre f(x1) y f(x2)."; 
   }
   else
   {
      while(abs(x1-x2)>tol)
      {
         xm=(x1+x2)/double(2); //Se obtiene el valor medio.
         if(f(xm)*f(x1)<0) //Comprobar si son de signo contrario.
            x2=xm;        //Se intercambian valores.
         else
            x1=xm;
      }
      //Se produce la salida del resultado por pantalla:
      printf("Raiz aproximada:%10.4f\n\n",xm);
   }
   cout<<"Introduzca 0 y Enter para terminar.";
   cin>>x1;
   return 0;
}

//------------------------------------------------------
//Se define la función a resolver:
double f(double x)
{
   double fxr=pow(x,3)+pow(x,2)-3*x-3;
   return(fxr);
}

Método numérico: Raíces de Ecuaciones no Lineales. Bisecciones consecutivas. Interpolación Lineal Inversa (secante).
C++

//=================================================================
//Método numérico para calcular raíces de ecuaciones no lineales.
//Bisecciones consecutivas. Interpolacíón Lineal Inversa (secante).
//=================================================================

#include <iostream>
#include <cmath>
#include<windows.h>
#include <stdlib.h>
using namespace std; //Para hacer uso de las funciones estándar del C.
double f(double x); //Esta subrutina definirá a la función.

int main(void)
{
   // Se despliega por pantalla la identificación del método:
   cout<<"Se han omitido intencionalmente los acentos gramaticales."<<endl<<endl;
   cout<<"Metodo numerico para resolver ecuaciones no lineales."<<endl;
   cout<<"Bisecciones consecutivas. Interpolacion Lineal (Secante)."<<endl;
   cout<<"=================================================="<<endl;
   cout<<"Se resuelve f(x)= x3 + x2 - 3x - 3 =0"<<endl;
   //Se definen los valores iniciales:
   double x1=1,x2=2, x3, tol=.001, tol2=.001;

   cout<<"Raices x1 = "<< x1 <<", x2 ="<< x2 <<endl;
   cout<<"Tolerancia 1 = "<< tol<<" Tolerancia 2 = "<<tol2<<endl; 
   cout<<"=================================================="<<endl;

   cout<<"Resultado:"<<endl<<endl;
   //Se definen variables requeridas para el proceso de cálculo:
   double divisor,j=0;
   if(f(x1)*f(x2)>=0)
   {
      cout<<"Los valores de x1="<<x1<<", x2="<<x2<<" no generan";
      cout<<"valores de signo contrario entre f(x1) y f(x2)."; 
   }
   else
   {
      divisor=f(x2)-f(x1);
      if(divisor!=0){
         x3=x2-(x2-x1)*f(x2)/divisor;
         while(abs(x3-x1)>tol||abs(f(x3)>tol2))
         {
            divisor=f(x2)-f(x1);
            if(divisor==0)
            {
               x3=0;x1=0;//Para abandonar las repeticiones.
            }
            else
            {
               j++;
               x3=x2-(x2-x1)*f(x2)/divisor;
               x1=x2;
               x2=x3;        //Se intercambian valores.*/
            }
         }
      }
      if(divisor!=0){
         //Se produce la salida del resultado por pantalla:
         printf("Raiz aproximada:%10.5f\n\n",x3);
         printf("Iteraciones:%f\n",j);
      }
      else
         cout<<"Se produjo división por cero."<<endl;
   }
   cout<<"Introduzca 0 y Enter para terminar.";
   cin>>x1;
   return 0;
}

//------------------------------------------------------
//Se define la función a resolver:
double f(double x)
{
   double fxr=pow(x,3)+pow(x,2)-3*x-3;
   return(fxr);
}

Método numérico: Raíces de Ecuaciones no lineales. Bisecciones consecutivas. Newton Raphson (tangente).
C++

//=================================================================
//Método numérico para calcular raíces de ecuaciones no lineales.
//Bisecciones consecutivas. Newton Raphson (tangente).
//=================================================================

#include <iostream>
#include <cmath>
#include<windows.h>
#include <stdlib.h>
using namespace std; //Para hacer uso de las funciones estándar del C.

double f(double x); //Esta subrutina definirá a la función.
double fp(double x);//Esta subrutina definirá su primera derivada 

int main(void)
{
   // Se despliega por pantalla la identificación del método:
   cout<<"Se han omitido intencionalmente los acentos gramaticales."<<endl<<endl;
   cout<<"Metodo numerico para resolver ecuaciones no lineales."<<endl;
   cout<<"Aproximaciones sucesivas. Newton Raphson (Tangente)."<<endl;
   cout<<"=================================================="<<endl;
   cout<<"Se resuelve f(x)= x3 + x2 - 3x - 3"<<endl;
   //Se definen los valores iniciales:
   double x1=1,tol=.001, tol2=.001;

   cout<<"Raiz x1 = "<< x1 <<endl;
   cout<<"Tolerancia 1 = "<< tol<<" Tolerancia 2 = "<<tol2<<endl; 
   cout<<"=================================================="<<endl;

   cout<<"Resultado:"<<endl<<endl;
   //Se definen variables requeridas para el proceso de cálculo:
   double j=0,x2=0,x3=0;
   while(abs(x3-x1)>=tol||abs(f(x2)>=tol2))
   {
      j++;
      x2=x1-f(x1)/fp(x1);
      x3=x1;
      x1=x2;
   }
      
   //Se produce la salida del resultado por pantalla:
   printf("Raiz aproximada:%10.5f\n",x1);
   printf("Iteraciones:%f\n\n",j);
      
   cout<<"Introduzca 0 y Enter para terminar.";
   cin>>x1;
   return 0;
}

//------------------------------------------------------
//Se define la función a integrar:
double f(double x)
{
   double fxr=pow(x,3)+ pow(x,2) - 3* x - 3;
   return(fxr);
}
//Primera derivada a la función a integrar:
double fp(double x)
{
   double fxr=3 *pow(x,2) + 2*x - 3;
   return(fxr);
}

Método numérico: Raíces de Ecuaciones Lineales. Eliminación Gaussiana (Método de Gauss).
C++

//=================================================================
//Método numérico para calcular raíces de ecuaciones lineales.
//Eliminacion Gaussiana.
//=================================================================

#include <iostream>
#include <cmath>
#include<windows.h>
#include <stdlib.h>
using namespace std; //Para hacer uso de las funciones estándar del C.

int main(void)
{
   // Se despliega por pantalla la identificación del método:
   cout<<"Se han omitido intencionalmente los acentos gramaticales."<<endl<<endl;
   cout<<"Metodo numerico para resolver ecuaciones lineales."<<endl;
   cout<<"Eliminacion Gaussiana."<<endl<<endl;
   cout<<"===============   Se resuelve:    ========================"<<endl;
   cout<<"        2x + 3y - 7z = -1"<<endl;
   cout<<"        3x + 4y - 6z =  5"<<endl;
   cout<<"        5x - 2y + 4z = -7"<<endl;
   //Se definen una variable temporal y una de sumatoria:
   double temp,sum;
   //Se definen los contadores requeridos para las iteraciones:
   int i,j,k,l,m,n;
   //Se indica el número de renglones que tiene la matriz:
   n=3;  //También puede indicarse desde teclado: 
   //Se define el arreglo que contendrá los resultados.
   double result[3];
   int divPorCero=0; //Bandera utilizada para detectar división por cero.
   //Se define la matriz a resolver. También podría leerse desde teclado.
   double x[3][4]={{2,3,-7,-1},
               {3,4,-6,5},
               {5,-2,4,-7}};
   //___________________________________________
   //Inicia el proceso de solución al sistema:
   n=n-1;
   m=n+1;
   for (l = 0; l <= n - 1; l++)
   {
      j = l;
      for (k = l + 1; k <= n; k++)
      {
         if (!(abs(x[j][l]) >= abs(x[k][l]))) j = k;
      }
      if (!(j == l))
      {
         for (i = 0; i <= m; i++)
         {
            temp= x[l][i];
            x[l][i] = x[j][i];
            x[j][i] = temp;
         }
      }
      for (j = l + 1; j <= n; j++)
      {
         temp= (x[j][l] / x[l][l]);
         for (i = 0; i <= m; i++) 
            x[j][i] -= temp* x[l][i];
      }
   }
   result[n] = x[n][m] / x[n][n];
   for (i = 0; i <= n - 1; i++)
   {
      j = n - i - 1;
      sum = 0;
      for (l = 0; l <= i; l++)
      {
         k = j + l + 1;
         sum += x[j][k] * result[k];
      }
      result[j] = ((x[j][m] - sum) / x[j][j]);
   }

   //_________________________________________________
   //Se produce la salida del resultado por pantalla:
   cout<<"\nResultados: ";
   printf("(");
   for(i=0;i<m;i++)
   {
         printf("%+6.2f",result[i]);
         if(i!=m-1) printf(",");             
   }
   printf(")\n");

   cout<<"\nIntroduzca 0 y Enter para terminar.";
   cin>>i;

   return 0;
}

Método numérico: Raíces de Ecuaciones Lineales. Método Numérico de Jacobi.
C++

//======================================================================
//Método numérico de JACOBI para calcular raíces de ecuaciones lineales.
//======================================================================

#include <iostream>
#include <cmath>
#include<windows.h>
#include <stdlib.h>
using namespace std; //Para hacer uso de las funciones estándar del C.

int main()
{ 
   system("cls");
   float ar[10][10], b[10], x[10], temp, xmax, tol=float(0.0005), suma=0;
   int i,j,n,aceptada=1,nItera=10,convergen=0;  //convergen es utiliza como bandera.
   // Se despliega por pantalla la identificación del método:
   cout<<"Se han omitido intencionalmente los acentos gramaticales."<<endl<<endl;
   cout<<"Metodo numerico para resolver ecuaciones lineales."<<endl;
   cout<<"Método de Jacobi."<<endl<<endl;
   cout<<"========================================================="<<endl;
   printf("No. de ecuaciones a resolver:");
   scanf("%d",&n);
   printf("\nNo. de iteraciones propuestas:");
   scanf("%d",&nItera);

   printf("\nIntroducir los valores de la matriz:");
     
   for(i=0;i<n;i++)
   {
      for(j=0;j<n+1;j++)
      {
         printf("\nEscriba el elemento (%d,%d):",i,j);
         scanf("%f",&ar[i][j]);
      }
   }

   for(i=0;i<n;i++)
   {
      for(j=0;j<n;j++)
         if(i!=j) suma+=abs(ar[i][j]);
      if(abs(ar[i][i])<suma) aceptada=0;
      suma=0;
   }

   if(aceptada!=1)
   {
      printf("\n\nEl sistema de ecuaciones introducido no puede resolverse ");
      printf("\npor el metodo de Jacobi al carecer de diagonal dominante\n");
   }
   
   if(aceptada==1)
   {
      //Asignar los valores de igualdad al vector b
      for(i=0;i<n;i++) b[i]=ar[i][n];

      for(i=0;i<n;i++) x[i]=0; //Inicializar los valores de xi en cero.

      //Se realizan las iteraciones en busca de la solución:
      for(int iter=1;iter<=nItera;iter++)
      {
         xmax=0;  temp=0;
         for(i=0;i<n;i++)
         {
            suma=0;
            xmax+=x[i];//Valores actuales de x[i]
            for(j=0;j<n;j++)
            {
               if(j!=i) suma+=(ar[i][j]/ar[i][i])*x[j];
            }
            x[i]=b[i]/ar[i][i]-suma;
            temp+=x[i];
         }
         //Resultados de la iteración
         printf("\nIteracion No.:%d",iter);
         for(i=0;i<n;i++)
            printf("\nx[%d] = %9.6f",i,x[i]);
         if(abs(xmax-temp)<=tol) 
            printf("\nConvergencia exitosa tol.: %6.4f\n",tol);
         else
            printf("\n");
      }
   }
   cout<<endl;
   system("pause");
   return 0;
}

Método numérico: Raíces de Ecuaciones Lineales. Método de Gauss - Seidel.
C++

//=================================================================
//Método numérico para calcular raíces de ecuaciones lineales.
//Gauss - Seidel.
//=================================================================

#include <iostream>
#include <cmath>
#include<windows.h>
#include <stdlib.h>
using namespace std; //Para hacer uso de las funciones estándar del C.

int main()
{ 
   system("cls");
   float ar[10][10], b[10], s=float(0.0), x[10], temp, tol=float(0.0005), xmax;
   int i,j,n,aceptada=1,nItera=10,convergen=0;  //convergen es utiliza como bandera.
   // Se despliega por pantalla la identificación del método:
   cout<<"Se han omitido intencionalmente los acentos gramaticales."<<endl<<endl;
   cout<<"Metodo numerico para resolver ecuaciones lineales."<<endl;
   cout<<"Gauss - Seidel."<<endl<<endl;
   cout<<"========================================================="<<endl;
   printf("No. de ecuaciones a resolver:");
   scanf("%d",&n);
   printf("\nNo. de iteraciones propuestas:");
   scanf("%d",&nItera);

   printf("\nIntroducir los valores de la matriz:");
     
   for(i=0;i<n;i++)
   {
      for(j=0;j<n+1;j++)
      {
         printf("\nEscriba el elemento (%d,%d):",i,j);
         scanf("%f",&ar[i][j]);
      }
   }

   for(i=0;i<n;i++)
   {
      for(j=0;j<n;j++)
      {
         if(i!=j) s+=abs(ar[i][j]);
      }
      if(abs(ar[i][i])<s) aceptada=0;
      s=0;
   }

   if(aceptada!=1)
   {
      printf("\n\nEl sistema de ecuaciones introducido no puede resolverse ");
      printf("\npor el metodo de Gauss Seidel al carecer de diagonal dominante\n");
   }
   
   if(aceptada==1)
   {
      //Asignar los valores de igualdad al vector b
      for(i=0;i<n;i++) b[i]=ar[i][n];

      for(i=0;i<n;i++) x[i]=0; //Inicializar los valores de xi en cero.

      //Hacer que los elementos de la diagonal sean la unidad:
      for(i=0;i<=n-1;i++)
      {
         temp=ar[i][i];
         b[i]=b[i]/temp;
         for(j=0;j<=n-1;j++)
            ar[i][j]=ar[i][j]/temp;
      }
      
      //Se realizan las iteraciones en busca de la solución:
      for(int iter=1;iter<=nItera;iter++)
      {
         xmax=0;
         for(i=0;i<n;i++)
         {
            temp=x[i];
            x[i]=b[i];
            for(j=0;j<n;j++)
            {
               if(j!=i) x[i]=x[i]-ar[i][j]*x[j];
            }
            if(abs(x[i]-temp>xmax)) xmax=abs(x[i]-temp);
         }

         if(xmax<=tol) convergen=1;
         //Resultados de la iteración
         printf("\nIteracion No.:%d",iter);
         for(i=0;i<n;i++)
            printf("\nx[%d] = %f",i,x[i]);
         if(convergen==1) 
            printf("\nConvergencia exitosa con tolerancia de %6.4f",tol);
      }
   }
   cout<<endl;
   system("pause");
   return 0;
}

Método numérico: Solución de Polinomios Interpolantes. Aproximación Polinomial Simple.
C++

//===================================================
//Método numérico de Interpolación Polinomial Simple.
//Polinomial Simple.
//===================================================

#include <iostream>
#include <cmath>
#include<windows.h>
#include <stdlib.h>
using namespace std; //Para hacer uso de las funciones estándar del C.
void eliGauss(float ar[][10],float result[],int n);
void gotoxy ( int x , int y );

int main()
{ 
   system("cls");

   // Se despliega por pantalla la identificación del método:
   cout<<"Se han omitido intencionalmente los acentos gramaticales."<<endl<<endl;
   cout<<"Metodo numerico para resolver interpolaciones."<<endl;
   cout<<"Polinomial Simple."<<endl<<endl;
   cout<<"========================================================="<<endl;
   float x[10],y[10],b[10][10],a[10];
   int i,j,n,ren,col,valida=0;
   do{
      if(valida!=0)
      {
         gotoxy(1,8);
         printf("Se permite especificar un grado maximo de 8.");
      }
      gotoxy(1,7);printf("Grado del polinomio:          ");
      gotoxy(22,7);scanf("%d",&n);
      valida=1;
   }while(n>8);

   gotoxy(1,8);
   printf("Introduzca los valores para cada punto :        ");
   ren=8;col=1;
   for(i=0;i<=n;i++)
   {
      gotoxy(col,++ren);printf("x(%2d)",i+1);
      gotoxy(col+6,ren);scanf("%f",&x[i]);

      gotoxy(col+16,ren);printf("f(x(%2d))",i+1);
      gotoxy(col+24,ren);scanf("%f",&y[i]);
   }
   // Se obtiene el sistema de ecuaciones lineales:
   for(i=0;i<=n;i++)
   {
      b[i][0]=1;
      for(j=1;j<=n;j++)
      {
         b[i][j]=b[i][j-1]*x[i];
      }
      b[i][n+1]=y[i];
   }
   
   //El conjunto de ecuaciones lineales resultantes es:
   printf("\nEcuaciones lineales resultantes:\n");
   for(i=0;i<=n;i++){
      for(j=0;j<=n+1;j++)
         printf("%6.2f ",b[i][j]);
      printf("\n");
   }
   //Hallar las soluciones para las ecuaciones lineales
   //mediante el método de eliminación de Gauss:
   eliGauss(b,a,n);

   //Generar la salida de los coeficientes del polinomio:
   printf("\nPolinomio de %do. grado generado:\n",n);
   for(i=0;i<=n;i++)
   {
      printf("%+5.2f x%d ",a[i],i);
   }
   printf("\n--------------------------------------------------");
   cout<<endl;

   // Pedir un valor a calcular de f(x)
   float xi,yi=0;
   printf("\nAnote un valor para x que requiera interpolar:");
   scanf("%f",&xi);
   for(i=0;i<=n;i++)
   {
      yi+=a[i]*pow(xi,i);//Evaluando el polinomio.
   }
   printf("\nResultado: f(%6.3f)= %+6.4f",xi,yi);
   printf("\n--------------------------------------------------");

   cout<<endl;
   system("pause");
   return 0;
}

// Esta función se utiliza para colocar el cursor en una posición específica

// sobre la pantalla de la consola de Windows.
void gotoxy ( int x , int y ) 
{ 
   HANDLE handle = GetStdHandle(STD_OUTPUT_HANDLE); 
   COORD coordenadas = { x , y }; 
   SetConsoleCursorPosition(handle, coordenadas); 
}

//Esta función calcula las raíces del sistema de ecuaciones mediante 

//el método de Gauss. 
void eliGauss(float ar[][10],float result[],int n)
{
   int i,j,k,l,m;
   float temp=0, sum=0;

   //n=n-1;
   m=n+1;
   for (l = 0; l <= n - 1; l++)
   {
      j = l;
      for (k = l + 1; k <= n; k++)
      {
         if (!(abs(ar[j][l]) >= abs(ar[k][l]))) j = k;
      }
      if (!(j == l))
      {
         for (i = 0; i <= m; i++)
         {
            temp= ar[l][i];
            ar[l][i] = ar[j][i];
            ar[j][i] = temp;
         }
      }
      for (j = l + 1; j <= n; j++)
      {
         temp= (ar[j][l] / ar[l][l]);
         for (i = 0; i <= m; i++) 
            ar[j][i] -= temp* ar[l][i];
      }
   }
   result[n] = ar[n][m] / ar[n][n];
   for (i = 0; i <= n - 1; i++)
   {
      j = n - i - 1;
      sum = 0;
      for (l = 0; l <= i; l++)
      {
         k = j + l + 1;
         sum += ar[j][k] * result[k];
      }
      result[j] = ((ar[j][m] - sum) / ar[j][j]);
   }
}

Método numérico: Solución de Polinomios Interpolantes. Aproximación Polinomial de Lagrange.
C++

//===================================================
//Método numérico de Interpolación Polinomial.
//Interpolación de Lagrange.
//===================================================

#include <iostream>
#include <cmath>
#include<windows.h>
#include <stdlib.h>
using namespace std; //Para hacer uso de las funciones estándar del C.
float Lagrange(float x[], float y[], int N, float xint);
void gotoxy ( int x , int y );

int main()
{ 
   system("cls");

   // Se despliega por pantalla la identificación del método:
   cout<<"Se han omitido intencionalmente los acentos gramaticales."<<endl<<endl;
   cout<<"Metodo numerico para resolver interpolaciones."<<endl;
   cout<<"Interpolación de Lagrange."<<endl<<endl;
   cout<<"========================================================="<<endl;
   float x[10],y[10];
   int i,n,valida=0,ren,col;
   do{
      if(valida!=0)
      {
         gotoxy(1,8);
         printf("Se permite especificar un grado maximo de 10.");
      }
      gotoxy(1,7);printf("Numero de puntos:          ");
      gotoxy(22,7);scanf("%d",&n);
      valida=1;
   }while(n>8);

   gotoxy(1,8);
   printf("Introduzca los valores para cada punto :        ");
   ren=8;col=1;
   for(i=0;i<n;i++)
   {
      gotoxy(col,++ren);printf("x(%2d)",i+1);
      gotoxy(col+6,ren);scanf("%f",&x[i]);

      gotoxy(col+16,ren);printf("f(x(%2d))",i+1);
      gotoxy(col+25,ren);scanf("%f",&y[i]);
   }

   // Pedir un valor a calcular de f(x)
   float xi,yi=0;
   printf("\nAnote un valor para x que requiera interpolar:");
   scanf("%f",&xi);
   //Calcular la interpolación:
   yi=Lagrange(x,y,n,xi);

   printf("\nResultado: f(%6.3f)= %+6.4f",xi,yi);
   printf("\n--------------------------------------------------");

   cout<<endl;
   system("pause");
   return 0;
}




void gotoxy ( int x , int y ) 
{ 
   HANDLE handle = GetStdHandle(STD_OUTPUT_HANDLE); 
   COORD coordenadas = { x , y }; 
   SetConsoleCursorPosition(handle, coordenadas); 
}

float Lagrange(float x[], float y[], int N, float xint)
{
   float yout=0,term;
   for(int i=0;i<N;i++)
   {
      term=y[i];
      for(int j=0;j<N;j++)
      {
         if(i!=j) term=term*(xint-x[j])/(x[i]-x[j]);
      }
      yout+=term;
   }
   return(yout);
}

Método numérico: Solución de Polinomios Interpolantes. Aproximación por Mínimos Cuadrados.
C++

//===================================================
//Método numérico de Interpolación .
//Mínimos cuadrados.
//===================================================

#include <iostream>
#include <cmath>
#include<windows.h>
#include <stdlib.h>
using namespace std; //Para hacer uso de las funciones estándar del C.
float MinimosCuadrados(float x[], float y[], int N, float xint);
void gotoxy ( int x , int y );

int main()
{ 
   system("cls");

   // Se despliega por pantalla la identificación del método:
   cout<<"Se han omitido intencionalmente los acentos gramaticales."<<endl<<endl;
   cout<<"Metodo numerico para resolver interpolaciones."<<endl;
   cout<<"Mínimos cuadrados."<<endl<<endl;
   cout<<"========================================================="<<endl;
   float x[10],y[10];
   int i,n,valida=0,ren,col;
   do{
      if(valida!=0)
      {
         gotoxy(1,8);
         printf("Se permite especificar un grado maximo de 10.");
      }
      gotoxy(1,7);printf("Numero de puntos:          ");
      gotoxy(22,7);scanf("%d",&n);
      valida=1;
   }while(n>8);

   gotoxy(1,8);
   printf("Introduzca los valores para cada punto :        ");
   ren=8;col=1;
   for(i=0;i<n;i++)
   {
      gotoxy(col,++ren);printf("x(%2d)",i+1);
      gotoxy(col+6,ren);scanf_s("%f",&x[i]);

      gotoxy(col+16,ren);printf("f(x(%2d))",i+1);
      gotoxy(col+25,ren);scanf_s("%f",&y[i]);
   }

   // Pedir un valor a calcular de f(x)
   float xi,yi=0;
   printf("\nAnote un valor para x que requiera interpolar:");
   scanf_s("%f",&xi);
   //Calcular la interpolación:
   yi=MinimosCuadrados(x,y,n,xi);

   printf("\nResultado: f(%6.3f)= %+6.4f",xi,yi);
   printf("\n--------------------------------------------------");

   cout<<endl;
   system("pause");
   return 0;
}

void gotoxy ( int x , int y ) 
{ 
   HANDLE handle = GetStdHandle(STD_OUTPUT_HANDLE); 
   COORD coordenadas = { x , y }; 
   SetConsoleCursorPosition(handle, coordenadas); 
}

float MinimosCuadrados(float x[], float y[], int N, float xint)
{
   float yint=0,sxi=0,syi=0,sx2=0,sy2=0,sxy=0,xm,ym,a1,a0;
   int i;
   for(i=0;i<N;i++)
   {
      sxi+=x[i]; syi+=y[i];
      sx2+=pow(x[i],2);  sy2+=pow(y[i],2);
      sxy+=x[i]*y[i];
   }
   xm=sxi/N;
   ym=syi/N;
   a1=(N*sxy-sxi*syi)/(N*sx2-pow(sxi,2));
   a0=ym-a1*xm;
   yint=a0+a1*xint;
   return(yint);
}