Dev - C++ - MULTIPLICACION DE MATRICES

//Suma de dos matrices, debe coincidir i=fila; j=columna

#include <stdio.h>

int main()

{int m,n,f,c,i,j,k;

float A[100][100],B[100][100],C[100][100];

printf("\n---------------------------------------------------\n");

printf("\nINGRESE LA FILA Y COLUMNA DE LA PRIMERA MATRIZ\n");

scanf("%d",&m);

scanf("%d",&n);

printf("\n---------------------------------------------------\n");

printf("\nINGRESE LA FILA Y COLUMNA DE LA SEGUNDA MATRIZ\n");

scanf("%d",&f);

scanf("%d",&c);

printf("\n");

if (n==f)

{printf("\n---------------------------------------------------\n");

printf("INGRESE EL VALOR DE LA PRIMERA MATRIZ\n\n");

//INGRESE LAS MATRICES

for (i=1;i<=m;i++)

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

{ printf("A(%d,%d)= ",i,j);

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

}

printf("\n");

printf("\n---------------------------------------------------\n");

printf("\nINGRESE EL VALOR DE LA SEGUNDA MATRIZ\n\n");

  for (i=1;i<=f;i++)

   for (j=1;j<=c;j++)

    { printf("B(%d,%d)= ",i,j);

      scanf ("%f",&B[i][j]);

    }

//OPERACION DE MULTIPLICACION

 for (i=1;i<=m;i++)

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

       { C[i][j]=0;

         for (k=1;k<=n;k++)

          {C[i][j]=C[i][j]+A[i][k]*B[k][j];

          }

       }

    }

 printf("\n---------------------------------------------------\n");

 printf("\nLA MULTIPLICACION DE LAS MATRICES ES:\n\n");

//IMPRESION

  for (i=1;i<=m;i++)

   for (j=1;j<=c;j++)

    { printf("C(%d,%d)=\t%4.2f\n",i,j,C[i][j]);

    }

}

else

{printf("\n_________________________________________\n");

printf("Estas matrices no se pueden multiplicar \n");

printf("debido a que el numero de columnas de la\n");

printf("matriz A es diferente al numero de filas\n");

printf("de la matriz B, !Vuelva a intentarlo!   \n");

}

getchar(); getchar();

}

//ESPERO LES SIRVA !Y SI ALGUIEN TIENE LA DETERMINATE DE UNA MATRIZ EN BIBLIOTECA //#include<stdio.h>!; seria tan amable de pasarmelo .......................LBAC

#include<iostream> /*esta biblioteca es igul a stdio.h*/

main()

{

int i,j,k,l,m,n ;

float a[100][100];

float det;

printf("\t\tIntroducir el ORDEN DE LA MATRIZ : N = ");

scanf("%d",&n);

printf("\n");

m=n-1;

/* Vamos a introducir la matriz por teclado*/

printf("\t\tIntroducir los elementos por FILAS \n");

printf("\t\t---------------------------------- \n");

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

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

{ printf("A(%d,%d) =",i,j);

scanf("%f",&a[i][j]); } }

/* SI QUEREMOS LEER LOS ELEMENTOS DE LA MATRIZ LISTADOS */

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

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

printf("\t\t\tA(%d,%d) =%8.4f\n",i,j,a[i][j] ); }

/*****Calculo del DETERMINANTE*****/

det=a[1][1];

for(k=1;k<=m;k++)

{ l=k+1;

for(i=l;i<=n;i++)

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

a[i][j] = ( a[k][k]*a[i][j]-a[k][j]*a[i][k] )/a[k][k]; }

det=det*a[k+1][k+1];

}

printf("\n\n");

printf("\t\t\tDETERMINANTE = %f\n", det);

printf("\t\t\t-------------------------\n");

system("pause");

return 0;

}

// aqui les dejo un pequeño programa de la regla de kramer con matrices

# include <stdio.h>

# include <stdlib.h>

# include <conio.h>

# include <string.h>

main(){

    int f, c;

	int det, incog1, incog2, incog3, x, y, z;

    int matriz[3][4];

	//llenado de la matriz

		for(f=0;f<3;f++){

			for(c=0;c<4;c++){

			printf("dame los valores de la matriz ");

			scanf("%d",&matriz[c][f]);

		}

	}

	//impresion de los datos de la matriz

	printf("\n\n");

		for(f=0;f<3;f++){

			printf(" \n\n");

		   	for(c=0;c<4;c++){

			    printf("  %d",matriz[c][f]);

			}

		}

		printf("\n\n");

	//operaciones para obtener valores y determinate

	det = (((matriz[0][0])*(((matriz[1][1])*(matriz[2][2]))-((matriz[1][2])*(matriz[2][1])))) +

	 (((-1)*(matriz[0][1]))*(((matriz[1][0])*(matriz[2][2]))-((matriz[1][2])*(matriz[2][0])))) +

	 ((matriz[0][2])*(((matriz[1][0])*(matriz[2][1]))-((matriz[1][1])*(matriz[2][0])))));

	incog1 = (((matriz[03][0])*(((matriz[1][1])*(matriz[2][2]))-((matriz[1][2])*(matriz[2][1])))) +

	 (((-1)*(matriz[3][1]))*(((matriz[1][0])*(matriz[2][2]))-((matriz[1][2])*(matriz[2][0])))) +

	 ((matriz[3][2])*(((matriz[1][0])*(matriz[2][1]))-((matriz[1][1])*(matriz[2][0])))));

   incog2 = (((matriz[0][0])*(((matriz[3][1])*(matriz[2][2]))-((matriz[3][2])*(matriz[2][1])))) +

	 (((-1)*(matriz[0][1]))*(((matriz[3][0])*(matriz[2][2]))-((matriz[3][2])*(matriz[2][0])))) +

	 ((matriz[0][2])*(((matriz[3][0])*(matriz[2][1]))-((matriz[3][1])*(matriz[2][0])))));

	incog3 = (((matriz[0][0])*(((matriz[1][1])*(matriz[3][2]))-((matriz[1][2])*(matriz[3][1])))) +

	 ((-1)*(matriz[0][1])*(((matriz[1][0])*(matriz[3][2]))-((matriz[1][2])*(matriz[3][0])))) +

	 ((matriz[0][2])*(((matriz[1][0])*(matriz[3][1]))-((matriz[1][1])*(matriz[3][0])))));

	x = incog1/det;

	y = incog2/det;

	z = incog3/det;

	//impresion de los datos de la matriz

	printf("el valor de la determinante es: %d\n\n", det);

	printf("el valor de la primera incognita es %d\n", x);

	printf("el valor de la segunda incognita es %d\n", y);

	printf("el valor de la tercera incognita es %d\n", z);

	getch();

}

//////Código fuente reslizado por Jesus Armando Camacho Felix

#include <time.h>

#include <string>

using namespace std;

#define PI     3.1415926535897932

#define exp    2.7182818284590452353602874713527

class matriz

{

public:

double **real;//////////////////////////////puntero donde se almacenan los parte real

double **imaj;//////////////////////////////puntero donde se almacenan la parte imaginria

bool im;///////////////////////////////////identifica si la matriz es real o compleja. im=true es compleja im=false es real////////////

bool mostrable;

string nombre;/////////////////////////////nombre de la matriz

string mensaje_error;//////////////////////Nombre e identificador de errores

int m,n;////////////////////////////////////dimension de la matriz, m===>numero de renglones n===>numero de columnas

unsigned short int error;///////////////////indica si tiene error de captura o de operación

short int id;///////////////////////////////numero identificador de la matriz

bool capturar_matriz(const char *cadena);///(;)-->indica renglón y (espacio)--> columna. Captura una matriz [numero1 numero2 etc...;numero1 numero2 etc...]

void ceros_imag();//////////////////////////rellena de ceros toda la parte imaginaria de la matriz

matriz *siguiente;

};

////////////////////////////////////////////////////////////////////////////////

matriz gauss_jhordan(matriz A,int r);/////////////////////////////////Realiza el metodo de gaussj-Jordan para la solucion de un sistema de ecuaciones simultaneas

matriz ceros(int I,int J,bool im); /////////////////////////////////////Proporciona una matriz de ceros de I renglones y J columnas

matriz rellenar(int I,int J,int valor);///////////////////////////////////////Proporciona una matriz de unos de I renglones y J columnas

matriz sumar(matriz A,matriz B);////////////////////////////////Realiza la suma de A+B

matriz convolucion(matriz A,matriz B);//////////////////////////Obtiene la convolucion discreta de A con B

matriz multiplicar(matriz A,matriz B);//////////////////////////Multiplica la matriz A por la matriz B o escalares AXB

matriz identidad(short int tam,bool im);////////////////////////////////Proporciona la matriz identidad en "tam" dimensiones

matriz aumentar(matriz A,matriz B,short int c_r);///////////////Aumenta a la matriz A,con matriz B, c_r=1-->en columnas,c_r=0-->en renglones

matriz inverza(matriz A);///////////////////////////////////////Obtiene la inverza de una matriz cuadrada

matriz lyapounov(matriz A,matriz B,matriz C);///////////////////Resuelve la ecuacion de lypounov AX+XB=C

matriz tran(matriz A);//////////////////////////////////////////Obtiene la transpuesta de una matriz

matriz abs(matriz A);///////////////////////////////////////////Obtiene el valor absoluto

matriz ifft(matriz X);//////////////////////////////////////////obtiene la transformada inverza rapda de fourier

matriz M_func(matriz A,int x,bool deg);////////////////////////////////////////

matriz subM(matriz A,int i,int j);//////////////////////////////obtiene submatriz i j

matriz detC(matriz A);//////////////////////////////////////////Obtiene el determinante de una matriz

matriz aleatoria(int m,int n,int rango,bool im);//////////////////////////////////Entrega una matriz rellena con numeros aleatorios///////////////////////////////////Reacomoda los renglones en los cuales hay un cero en la posicion de la diagonal

matriz subMat(matriz A,matriz B);///////////////////////////////////////////////////////////////entrega una sección de matriz

double strTof(const char *c);////////////////////////////////////Convierte de texto a un valor flotante

double cos(float angulo,bool deg);///////////////////////////////Obtiene el coseno de un angulo en radianes o grados deg=1-->grados deg=0-->radianes

double sen(float angulo,bool deg);///////////////////////////////Obtiene el seno de un angulo en radianes o grados deg=1-->grados deg=0-->radianes

double tan(float angulo,bool deg);///////////////////////////////Obtiene tangente de un angulo en radianes o grados deg=1-->grados deg=0-->radianes

double raiz(float x);////////////////////////////////////////////Obtiene la raiz cuadrada de x

double e(float x);//////////////////////////////////////////////Obtiene el esponexial con base 2.718281828

double ln(float x);/////////////////////////////////////////////Obtiene el Ln de x

double pow(float base,float potencia);//////////////////////////Eleva un numero a la n potencia

double log(float base,float x);/////////////////////////////////Obtiene el logaritmo de una base a la x potencia

double abs(double a);

////////////////////////////////////////////////////////////////////////////////

int strToint(const char *string);

/////////////////////////////////////////////////////////////////////////////////

void reservarF(double **&C,int i,int j,int init);

////////////////////////////////////////////////////////////////////////////////

void dft(matriz X,matriz &C);

void fft4(matriz X,matriz &C);

////////////////////////////////////////////////////////////////////////////////

void ifft4(matriz X,matriz &C);

void VerfDiagonal(matriz &A);

////////////////////////////////////////////////////////////////////////////////

void VerfDiagonal(matriz &A)

{

 double *aux;

 aux=new double[A.n];

  for(int p=0;p<A.m;p++)

    {

     if( A.real[p][p]==0&&p<A.m-1)

       {

       	if(A.im&&A.imaj[p][p]==0)

       	  {

       	   for(int x=0;x<A.n;x++)aux[x]=A.real[p][x];

       	   A.real[p]=A.real[p+1];

       	   A.real[p+1]=aux;

       	   for(int x=0;x<A.n;x++)aux[x]=A.imaj[p][x];

       	   A.imaj[p]=A.imaj[p+1];

       	   A.imaj[p+1]=aux;

		  }

       	else

       	  {

       	   for(int x=0;x<A.n;x++)aux[x]=A.real[p][x];

       	   A.real[p]=A.real[p+1];

       	   A.real[p+1]=aux;

		  }

       }

    }

}

////////////////////////////////////////////////////////////////////////////////

matriz gauss_jhordan(matriz A,int r)

{

matriz ux,P;

VerfDiagonal(A);

P.error=false;

ux.m=A.m;

ux.n=A.n;

ux=ceros(ux.m,ux.n,A.im);

for(int i=0;i<A.m;i++)

 for(int j=0;j<A.n;j++)

  {

  ux.real[i][j]=A.real[i][j];

  if(A.im)ux.imaj[i][j]=A.imaj[i][j];

  }

P.m=A.m;

P.n=A.n-r;

short int bandera=0;

float c,piv,PIV[2]={0.0,0.0},AUX[2]={0.0,0.0};

int in=0,in2=1;

P=ceros(P.m,P.n,A.im);

for(int k=0;k<2;k++)

 {

 for(int p=0;p<ux.m;p++)

 {

  if(!A.im)piv=ux.real[in+p*in2][in+p*in2];

  else

   {

   PIV[0]=ux.real[in+p*in2][in+p*in2];

   PIV[1]=ux.imaj[in+p*in2][in+p*in2];

   }

  for(int x=0;x<ux.n;x++)

   {

    if(!A.im)ux.real[in+p*in2][x]/=piv;

    else

     {

     AUX[0]=(ux.real[in+p*in2][x]*PIV[0]+ux.imaj[in+p*in2][x]*PIV[1])/(PIV[0]*PIV[0]+PIV[1]*PIV[1]);

     AUX[1]=(PIV[0]*ux.imaj[in+p*in2][x]-ux.real[in+p*in2][x]*PIV[1])/(PIV[0]*PIV[0]+PIV[1]*PIV[1]);

     ux.real[in+p*in2][x]=AUX[0];

     ux.imaj[in+p*in2][x]=AUX[1];

     }

   }

  for(int j=p+1;j<ux.m;j++)

   {

   if(!A.im)c=ux.real[in+j*in2][in+p*in2];

   else

    {

     PIV[0]=ux.real[in+j*in2][in+p*in2];

     PIV[1]=ux.imaj[in+j*in2][in+p*in2];

    }

   for(int i=0;i<ux.n;i++)

    if(!A.im)ux.real[in+j*in2][i]-=ux.real[in+p*in2][i]*c;

    else

     {

      AUX[0]=ux.real[in+p*in2][i]*PIV[0]-ux.imaj[in+p*in2][i]*PIV[1];

      AUX[1]=ux.real[in+p*in2][i]*PIV[1]+ux.imaj[in+p*in2][i]*PIV[0];

      ux.real[in+j*in2][i]-=AUX[0];

      ux.imaj[in+j*in2][i]-=AUX[1];

     }

   }

  }

  in=ux.m-1;

  in2=-1;

 }

for(int Y=0;Y<ux.m;Y++)

 for(int X=r;X<ux.n;X++)

     {

     P.real[Y][X-r]=ux.real[Y][X];

     if(A.im)

     P.imaj[Y][X-r]=ux.imaj[Y][X];

	 }

VerfDiagonal(P);

return P;

}

////////////////////////////////////////////////////////////////////////////////

matriz  ceros(int I,int J,bool im)

{

 matriz A;

 A.m=I;

 A.n=J;

 A.im=im;

 A.error=0;

 A.mostrable=true;

 reservarF(A.real,A.m,A.n,0);

 if(im)

 {

  reservarF(A.imaj,A.m,A.n,0);

  A.im=true;

 }

 return A;

}

/////////////////////////////////////////////////////////////////////////////////

matriz rellenar(int I,int J,int valor)

{

matriz A;

A.error=0;

A.m=I;

A.n=J;

A.mostrable=true;

reservarF(A.real,A.m,A.n,valor);

return A;

}

////////////////////////////////////////////////////////////////////////////////

matriz sumar(matriz A,matriz B)

{

 matriz C;

 if(A.m==B.m&&A.n==B.n)

   {

   C=ceros(A.m,A.n,A.im||B.im);

   if(A.im&&!B.im)B.ceros_imag();

   else if(B.im&&!A.im)A.ceros_imag();

   for(int i=0;i<C.m;i++)

    for(int j=0;j<C.n;j++)

     {

     C.real[i][j]=A.real[i][j]+B.real[i][j];

	 if(C.im)

     C.imaj[i][j]=A.imaj[i][j]+B.imaj[i][j];

	 }

   }

 else

  {

 	C.error=1;

 	C.mensaje_error="Todos los argumentos deben tener la misma dimension.\r\n";

  }

 return C;

}

////////////////////////////////////////////////////////////////////////////////

matriz convolucion(matriz A,matriz B)

{

 matriz conv;

 if(A.n==B.n)

 {

 conv=ceros(1,2*A.n-1,A.im||B.im);

 if(A.im||B.im)

   {

   if(!B.im)B.ceros_imag();

   else if(!A.im)A.ceros_imag();

   }

 for(int n=0;n<conv.n;n++)

  for(int k=0;k<A.n;k++)

     {

      if(n-k>=0&&n-k<A.n)

        {

         if(conv.im)

          {

          	conv.real[0][n]+=A.real[0][k]*B.real[0][n-k]-A.imaj[0][k]*B.imaj[0][n-k];

          	conv.imaj[0][n]+=A.real[0][k]*B.imaj[0][n-k]+A.imaj[0][k]*B.real[0][n-k];

          }

		 else conv.real[0][n]+=A.real[0][k]*B.real[0][n-k];

        }

     }

 }

else conv.mensaje_error="El numero de columnas de los dos argumentos deben de ser igual.\r\n";

return conv;

}

/////////////////////////////////////////////////////////////////////////////////

matriz multiplicar(matriz A,matriz B)

{

matriz C;

C.error=0;

if((A.n==1&&A.m==1)||(B.n==1&&B.m==1)||(A.n==B.m))

  {

  if(A.n==1&&A.m==1)C=ceros(B.m,B.n,A.im||B.im);

  else if(B.n==1&&B.m==1)C=ceros(A.m,A.n,A.im||B.im);

  else if(A.n==B.m)C=ceros(A.m,B.n,A.im||B.im);

  if(A.im||B.im)

   {

   	if(!A.im)A.ceros_imag();

   	else if(!B.im)B.ceros_imag();

   }

  for(int i=0;i<C.m;i++)

   for(int j=0;j<C.n;j++)

      {

       if(A.n==1&&A.m==1)

       {

       	 if(!C.im)C.real[i][j]=A.real[0][0]*B.real[i][j];

         else

          {

            C.real[i][j]=A.real[0][0]*B.real[i][j]-A.imaj[0][0]*B.imaj[i][j];

			C.imaj[i][j]=A.real[0][0]*B.imaj[i][j]+B.real[i][j]*A.imaj[0][0];

          }

	   }

      else if(B.n==1&&B.m==1)

       {

         if(!C.im)C.real[i][j]=B.real[0][0]*A.real[i][j];

         else

	     {

	       C.real[i][j]=A.real[i][j]*B.real[0][0]-A.imaj[i][j]*B.imaj[0][0];

		   C.imaj[i][j]=A.real[i][j]*B.imaj[0][0]+B.real[0][0]*A.imaj[i][j];

	     }

       }

      else if(A.n==B.m)

       for(int y=0;y<A.n;y++)

        {

         if(!C.im)C.real[i][j]+=A.real[i][y]*B.real[y][j];

         else

         {

       	   C.real[i][j]+=A.real[i][y]*B.real[y][j]-A.imaj[i][y]*B.imaj[y][j];

       	   C.imaj[i][j]+=A.real[i][y]*B.imaj[y][j]+B.real[y][j]*A.imaj[i][y];

         }

        }

      }

   }

  else

  {

   C.error=1;

   C.mensaje_error="Error de argumentos el numeros de columnas del primer argumento\r\nes diferente al numero de rengoles del segundo argumento.\r\n";

  }

 return C;

}

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

matriz identidad(short int tam,bool im)

{

  matriz C;

  C=ceros(tam,tam,im);

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

   for(int j=0;j<tam;j++)

    if(i==j)C.real[i][j]=1.0;

return C;

}

////////////////////////////////////////////////////////////////////////////////

matriz aumentar(matriz A,matriz B,short int c_r)

{

matriz C;

C.error=1;

if(A.error==0&&B.error==0&&B.n!=0&&B.m!=0)

{

 if((bool)c_r)C=ceros(A.m,A.n+B.n,A.im||B.im);//////////////////////////////////aumento por columnas

 else C=ceros(A.m+B.m,A.n,A.im||B.im);//////////////////////////////////////////aumento por renglones

 if(A.im&&!B.im)B.ceros_imag();

 else if(B.im&&!A.im)A.ceros_imag();

 if((bool)c_r&&A.m==B.m)

  for(int i=0;i<C.m;i++)

   for(int j=0;j<C.n;j++)

    if(j<A.n)

    {

     C.real[i][j]=A.real[i][j];

     if(C.im)C.imaj[i][j]=A.imaj[i][j];

    }

   else

    {

     C.real[i][j]=B.real[i][j-A.n];

     if(C.im)C.imaj[i][j]=B.imaj[i][j-A.n];

    }

else if(A.n==B.n&&!(bool)c_r)

 for(int j=0;j<C.n;j++)

  for(int i=0;i<C.m;i++)

   if(i<A.m)

    {

     C.real[i][j]=A.real[i][j];

     if(C.im)C.imaj[i][j]=A.imaj[i][j];

    }

   else

    {

     C.real[i][j]=B.real[i-A.m][j];

     if(C.im)C.imaj[i][j]=B.imaj[i-A.m][j];

    }

 else C.error=1;

 }

 else if(B.n==0||B.m==0)C=A;

return C;

}

/////////////////////////////////////////////////////////////////////////////////

matriz inverza(matriz A)

{

matriz c,a;

a=aumentar(A,identidad(A.m,A.im),1);

c=gauss_jhordan(a,A.m);

return c;

}

/////////////////////////////////////////////////////////////////////////////////

matriz lyapounov(matriz A,matriz B,matriz C)

{

 matriz u,Q,a;

 if(A.m==A.n&&B.m==B.n&&C.m==A.m&&C.n==B.n)

   {

    u=ceros(A.m*B.m,A.m*B.m+1,A.im||B.im||C.im);

    Q=ceros(A.m,B.n,A.im||B.im||C.im);

    for(int y=0;y<B.m;y++)

     for(int i=0;i<A.m;i++)

      for(int j=0;j<A.n;j++)

       {

       u.real[i+A.m*y][j+A.n*y]=A.real[i][j];

       if(A.im)u.imaj[i+A.m*y][j+A.n*y]=A.imaj[i][j];

	   }

     for(int i=0;i<B.m;i++)

      for(int x=0;x<A.m;x++)

       for(int j=0;j<B.n;j++)

        {

         u.real[x+i*A.m][j*A.n+x]+=B.real[j][i];

         if(B.im)u.imaj[x+i*A.m][j*A.n+x]+=B.imaj[j][i];

        }

     for(int j=0;j<C.n;j++)

      for(int i=0;i<C.m;i++)

        {

          u.real[i+j*C.m][u.n-1]=C.real[i][j];

          if(C.im)u.imaj[i+j*C.m][u.n-1]=C.imaj[i][j];

        }

     a=gauss_jhordan(u,u.m);

     for(int i=0;i<Q.m;i++)

      for(int j=0;j<Q.n;j++)

       {

       	 Q.real[i][j]=a.real[i+j*Q.m][0];

       	 if(Q.im)Q.imaj[i][j]=a.imaj[i+j*Q.m][0];

       }

   }else Q.error=1;

return Q;

}

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

matriz tran(matriz A)

{

 matriz C;

 if(A.error==0)

 {

 C=ceros(A.n,A.m,A.im);

  for(int i=0;i<C.m;i++)

   for(int j=0;j<C.n;j++)

    {

     C.real[i][j]=A.real[j][i];

     if(A.im)

     C.imaj[i][j]=A.imaj[j][i];

    }

  }

 return C;

}

////////////////////////////////////////////////////////////////////////////////

matriz detC(matriz A)

{

 matriz sub,aux;

 float s=1.0;

 double r=0.0,i=0.0;

 int n=A.n;

 for(int x=0;x<n;x++)

  {

  	if(x%2==0)s=1.0;

  	else s=-1.0;

  	sub=subM(A,1,x+1);

  	if(sub.n==1&&sub.m==1)

	 {

		if(!A.im)r+=s*A.real[0][x]*sub.real[0][0];

		else

		{

		 r+=s*(A.real[0][x]*sub.real[0][0]-A.imaj[0][x]*sub.imaj[0][0]);

		 i+=s*(A.real[0][x]*sub.imaj[0][0]+A.imaj[0][x]*sub.real[0][0]);

		}

  	 }

    else if(sub.n>1&&sub.m>1)

	 {

	   if(!A.im)r+=s*A.real[0][x]*detC(sub).real[0][0];

	   else

	    {

	     aux=detC(sub);

	     r+=s*(A.real[0][x]*aux.real[0][0]-A.imaj[0][x]*aux.imaj[0][0]);

		 i+=s*(A.real[0][x]*aux.imaj[0][0]+A.imaj[0][x]*aux.real[0][0]);

	    }

	 }

  }

  sub=ceros(1,1,A.im);

  sub.real[0][0]=r;

  if(A.im)sub.imaj[0][0]=i;

  return sub;

}

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

matriz aleatoria(int m,int n,int rango,bool im)

{

 matriz C;

 int div;

 C.error=0;

 C.im=im;

 C.m=m;

 C.n=n;

 C.mostrable=true;

 reservarF(C.real,m,n,0);

 if(im)reservarF(C.imaj,m,n,0);

 srand(time(0));

 for(int i=0;i<m;i++)

  for(int j=0;j<n;j++)

    {

    	div=rand()%15;

    	if(div==0)div=1;

    	C.real[i][j]=(rand()%rango)/div;

    	if(im)C.imaj[i][j]=(rand()%rango)/div;

    }

 return C;

}

/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

void reservarF(double **&C,int i,int j,int init)

{

C=new double*[i];

for(int x=0;x<i;x++)

 {

  C[x]=new double[j];

  memset((void*)C[x],init, sizeof (double)*i);

 }

}

////////////////////////////////////////////////////////////////////////////////

double strTof(const char *c)

{

float ent=0.0,dec=0,aux=0;

short int bandera=0,sig=1,f=0;

float d=10.0,num=0.0,den=1.0;

for(int x=0;c[x]!=' '&&c[x]!=';'&&c[x]!=']'&&c[x]!=','&&c[x]!=0;x++)

  {

   if(bandera&&c[x]>='0'&&c[x]<='9')

   dec=dec+(c[x]-48)/d,d*=10;

   else if(c[x]>='0'&&c[x]<='9'&&!bandera)

   ent=ent*10+c[x]-48;

   if(c[x]=='.')

   bandera=1;

   if(c[x]=='-')

   sig=-1;

   if(c[x]=='/')

   bandera=0,num=(ent+dec),f=1,ent=0,dec=0,d=10.0;

  }

if(!f)num=(ent+dec)*sig;

if(f)den=(ent+dec)*sig;

aux=num/den;

return aux;

}

/////////////////////////////////////////////////////////////////////////////////

int strToint(const char *string)

{

int ent=0;

for(int x=0;string[x]!=0;x++)

 if(string[x]>='0'&&string[x]<='9')

   ent=ent*10+string[x]-48;

return ent;

}

////////////////////////////////////////////////////////////////////////////////

double cos(float angulo,bool deg)

{

bool neg=false;

if(angulo<0){angulo=-angulo;neg=true;}

float C[6]={-0.5,0.041667,-0.001389,0.000025,-0.0000002755,0.00000000208767};

float num=1.0,m=1.0,t,t2=1.0;

if(deg)angulo=PI*angulo/180.0;

int rad=(int)(2.0*angulo/PI),cuadrante;

cuadrante=rad%4;

angulo-=((float)rad*PI/2.0);

if(cuadrante==1||cuadrante==3)

angulo-=PI/2.0;

t=angulo*angulo;

for(int x=0;x<6;x++)

 {

 t2*=t;

 num+=C[x]*t2;

 }

if(cuadrante==1||cuadrante==2)

 num=-num;

if(neg)num=-num;

return num;

}

////////////////////////////////////////////////////////////////////////////////

double sen(float angulo,bool deg)

{

float r;

bool neg=false;

if(angulo<0.0){angulo=-angulo;neg=true;}

if(deg)

angulo=PI*angulo/180.0;

r=cos(abs(angulo-PI/2.0),false);

if(neg)r=-r;

return r;

}

////////////////////////////////////////////////////////////////////////////////

double tan(float angulo,bool deg)

{

float O,A;

if(angulo<0.0)angulo=-angulo;

if(deg)

angulo=PI*angulo/180.0;

O=sen(angulo,false);

A=cos(angulo,false);

return O/A;

}

////////////////////////////////////////////////////////////////////////////////

double e(float x)

{

long double aux,sum=1.0,p=1.0,f=1.0,mult=1.0;

bool b=false;

int m;

aux=x;

if(x<0.0)

aux=-aux;

if(aux>0)b=true;

m=(int)aux;

aux=aux-m;

for(int i=0;i<m;i++)mult*=exp;

 for(int i=1;i<=30&&b;i++)

  {

  p*=aux;

  f*=i;

  sum+=(p/f);

  }

if(x>=0.0)

return sum*mult;

else

return (1.0/sum)*mult;

}

////////////////////////////////////////////////////////////////////////////////////

double ln(float x)

{

 long double num=0.0,a=1.0,mult=1.0;

 bool ban=false;

 if(x>6)

  {

   int r=3;

   if(x>5000000)r=4;

  for(int i=0;i<r;i++)

  {

   x=raiz(x);

   mult*=2.0;

  }

 }

 if(x>1)

 x=1.0/x,ban=true;

 for(int n=1;n<=30;n++)

  {

  	a*=x-1;

  	if((n+1)%2)

  	num-=a/n;

  	else

  	num+=a/n;

  }

  if(ban)

  num=-num;

return num*mult;

}

////////////////////////////////////////////////////////////////////////////////////////

double pow(float base,float potencia)

{

 long double f=1,num=1.0,bas=1.0,a,N=1.0;

 bool neg=false;

 if(potencia<0)neg=true;

 int mult=(int)abs(potencia);

 for(int x=0;x<mult;x++)N*=base;

 potencia=abs(potencia)-mult;

 a=potencia*ln(base);

 for(int n=1;n<=50&&potencia>0.0;n++)

  {

  	f*=n;

  	bas*=a;

  	num+=bas/f;

  }

  if(neg)return 1/(N*num);

  else   return N*num;

 }

/////////////////////////////////////////////////////////////////////////////////////////

double log(float base,float x)

{

 float A,X;

 A=ln(base);

 X=ln(x);

 return (double)X/A;

}

///////////////////////////////////////////////////////////////////////////////////////////

matriz abs(matriz A)

{

  matriz C,T;

  C.error=0;

  reservarF(C.real,1,1,0);

  if(A.m==1&&A.n>1||A.m>1&&A.n==1)

   {

      T=tran(A);

      if(A.m==1&&A.n>1)

      C=multiplicar(A,T);

	  else if(A.m>1&&A.n==1)

	  C=multiplicar(T,A);

	  C.real[0][0]=raiz(C.real[0][0]);

   }

  else if(A.n==A.m)

   {

   C=detC(A);

   if(A.n==A.m&&A.im&&A.m==1)

    C.real[0][0]=raiz(pow(A.real[0][0],2)+pow(A.imaj[0][0],2)),C.im=0;

   }

  else C.error=1;

  if(C.real[0][0]<0)C.real[0][0]=-C.real[0][0];

  return C;

}

///////////////////////////////////////////////////////////////////////////////////////////

double abs(double a)

{

	double r;

	if(a<0)r=-a;

	else r=a;

return r;

}

///////////////////////////////////////////////////////////////////////////////////////////

bool matriz::capturar_matriz(const char *cadena)

{

  int i=1,c=0,j;

  char *string,*aux;

  string=new char[2];

  for(int x=0;cadena[x]!=0;x++)

  if(cadena[x]==';')i++;

  else if(cadena[x]==' ')c++;

  j=c/i+1;

  m=i;

  n=j;

  reservarF(real,i,j,0);

  i=0,c=0,j=0;

  for(int x=0;cadena[x]!=0;x++)

  {

    if(cadena[x]!=';'&&cadena[x]!=' ')

	{

    	aux=string;

        string[c]=cadena[x];

        string[c+1]=0;

        string=aux;

        c++;

        aux=new char[c+2];

    }

    if(cadena[x]==';'||cadena[x]==' ')

    {

    real[i][j]=strTof(string);

    if(cadena[x]==';')i++,j=0,c=0;

    else if(cadena[x]==' ')j++,c=0;

    }

  }

   real[i][j]=strTof(string);

}

////////////////////////////////////////////////////////////////////////////////////////////////

double raiz(float x)

{

 double r=x,t=0;

 while (t!=r)

  {

   t=r;

   r=(x/r+r)/2;

  }

 return (float)r;

}

//////////////////////////////////////////////////////////////////////////////////////////////////

void matriz::ceros_imag()

{

 if(!im)

 {

 reservarF(imaj,m,n,0);

 im=1;

 }

}

///////////////////////////////////////////////////////////////////////////////////////////////

matriz subM(matriz A,int i,int j)

{

 matriz C;

 int X=0;

 int Y=0;

 if(i>0) C.m=A.m-1;else C.m=0;

 if(j>0)C.n=A.n-1;else  C.n=0;

 C=ceros(C.m,C.n,A.im);

 if(i>0&&j>0)

 for(int x=0;x<A.m;x++)

  {

  for(int y=0;y<A.n&&x!=i-1;y++)

    {

     if(y!=j-1)

      {

       C.real[X][Y]=A.real[x][y];

       if(C.im)C.imaj[X][Y]=A.imaj[x][y];

	   Y++;

      }

	}

  Y=0;

  if(x!=i-1)X++;

  }

 else C.error=1;

 return C;

}

///////////////////////////////////////////////////////////////////////////////////////////////

void dft(matriz X,matriz &C)

{

 int N=X.n;

 C=ceros(1,N,true);

 float Wnk[2]={0.0,0.0};

 for(int k=0;k<N;k++)

  for(int n=0;n<N;n++)

   {

   	Wnk[0]=cos(2*PI*n*k/N,false);

   	Wnk[1]=-sen(2*PI*n*k/N,false);

   	C.real[0][k]+=X.real[0][n]*Wnk[0];

   	C.imaj[0][k]+=X.real[0][n]*Wnk[1];

   }

}

///////////////////////

matriz auxiliar,resp;

DWORD   threadId[4];

/////////////////////////////////////////////////////////////////////////////////////////////////

DWORD WINAPI hilo1(LPVOID args)

{

  double W1[2]={0.0,0.0},W2[2]={0.0,0.0},W3[2]={0.0,0.0},W4[2]={0.0,0.0},Wn[2]={0.0,0.0};

  double R=0.0,I=0.0;

  int N=auxiliar.n;

  for(int k=0;k<N/4;k++)

  	for(int n=0;n<N/4;n++)

  	{

  	Wn[0]=cos(2*PI*n/N,false);

  	  Wn[1]=-sen(2*PI*n/N,false);

  	  W1[0]=cos(8*PI*n*k/N,false);//////////////////////////////////////////////////////////Real

  	  W1[1]=-sen(8*PI*n*k/N,false);/////////////////////////////////////////////////////////Imaginario

  	  W2[0]=W1[0]*Wn[0]-W1[1]*Wn[1];

  	  W2[1]=W1[0]*Wn[1]+W1[1]*Wn[0];

  	  W3[0]=W2[0]*Wn[0]-W2[1]*Wn[1];

  	  W3[1]=W2[0]*Wn[1]+W2[1]*Wn[0];

  	  W4[0]=W3[0]*Wn[0]-W3[1]*Wn[1];

  	  W4[1]=W3[0]*Wn[1]+W3[1]*Wn[0];

	  R=auxiliar.real[0][n]+auxiliar.real[0][n+N/4]+auxiliar.real[0][n+N/2]+auxiliar.real[0][n+3*N/4];