#include <windows.h>
#include <iostream>
#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];
resp.real[0][4*k]+=R*W1[0];
resp.imaj[0][4*k]+=R*W1[1];
}
threadId[0]=0;
}
/////////////////////////////////////////////////////////////////////////////////////////////////
DWORD WINAPI hilo2(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/2];
I=auxiliar.real[0][n+3*N/4]-auxiliar.real[0][n+N/4];
resp.real[0][4*k+1]+=R*W2[0]-I*W2[1];
resp.imaj[0][4*k+1]+=R*W2[1]+W2[0]*I;
}
threadId[1]=0;
}
/////////////////////////////////////////////////////////////////////////////////////////////////
DWORD WINAPI hilo3(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/2];
I=auxiliar.real[0][n+N/4]-auxiliar.real[0][n+3*N/4];
resp.real[0][4*k+3]+=R*W4[0]-I*W4[1];
resp.imaj[0][4*k+3]+=R*W4[1]+W4[0]*I;
}
threadId[2]=0;
}
/////////////////////////////////////////////////////////////////////////////////////////////////
DWORD WINAPI hilo4(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];
// I=auxiliar.real[0][n+N/4]-auxiliar.real[0][n+3*N/4];
R=auxiliar.real[0][n]-auxiliar.real[0][n+N/4]+auxiliar.real[0][n+N/2]-auxiliar.real[0][n+3*N/4];
resp.real[0][4*k+2]+=R*W3[0];
resp.imaj[0][4*k+2]+=R*W3[1];
}
threadId[3]=0;
}
///////////////////////////////////////////////////
void fft4(matriz X,matriz &C)
{ HANDLE tareas[4];
int residuo=X.n%4;
if(residuo>0)residuo=4-residuo;
auxiliar=aumentar(X,ceros(1,residuo,false),1);//X;
resp=ceros(1,X.n+residuo,true);
for(int x=0;x<4;x++)threadId[x]=x+1;
int val[4];
tareas[0]=CreateThread( NULL, 0,hilo1, &val[0], 0, &threadId[0]);
tareas[1]=CreateThread( NULL, 0,hilo2, &val[1], 0, &threadId[1]);
tareas[2]=CreateThread( NULL, 0,hilo3, &val[2], 0, &threadId[2]);
tareas[3]=CreateThread( NULL, 0,hilo4, &val[3], 0, &threadId[3]);
while(!(threadId[0]==0&&threadId[1]==0&&threadId[2]==0&&threadId[3]==0));
C=resp;
}
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void ifft4(matriz X,matriz &C)
{ int N=X.n*X.m;
float W1[2]={0.0,0.0},W2[2]={0.0,0.0},W3[2]={0.0,0.0},W4[2]={0.0,0.0},Wk[2]={0.0,0.0}; float R=0.0,I=0.0;
C=ceros(1,N,false);
for(int n=0;n<N/4;n++)
{ for(int k=0;k<N/4;k++)
{ Wk[0]=cos(2*PI*k/N,false);
Wk[1]=sen(2*PI*k/N,false);
W1[0]=cos(8*PI*n*k/N,false);
W1[1]=sen(8*PI*n*k/N,false);
W2[0]=W1[0]*Wk[0]-W1[1]*Wk[1];
W2[1]=W1[0]*Wk[1]+W1[1]*Wk[0];
W3[0]=W2[0]*Wk[0]-W2[1]*Wk[1];
W3[1]=W2[0]*Wk[1]+W2[1]*Wk[0];
W4[0]=W3[0]*Wk[0]-W3[1]*Wk[1];
W4[1]=W3[0]*Wk[1]+W3[1]*Wk[0];
R=X.real[0][k]+X.real[0][k+N/4]+X.real[0][k+N/2]+X.real[0][k+3*N/4];
I=X.imaj[0][k]+X.imaj[0][k+N/4]+X.imaj[0][k+N/2]+X.imaj[0][k+3*N/4];
C.real[0][4*n]+=R*W1[0]-I*W1[1];
R=X.real[0][k]-X.real[0][k+N/2]-X.imaj[0][k+N/4]+X.imaj[0][k+3*N/4];
I=X.imaj[0][k]-X.imaj[0][k+N/2]+X.real[0][k+N/4]-X.real[0][k+3*N/4];
C.real[0][4*n+1]+=R*W2[0]-W2[1]*I;
R=X.real[0][k]-X.real[0][k+N/2]+X.imaj[0][k+N/4]-X.imaj[0][k+3*N/4];
I=X.imaj[0][k]-X.imaj[0][k+N/2]-X.real[0][k+N/4]+X.real[0][k+3*N/4];
C.real[0][4*n+3]+=R*W4[0]-W4[1]*I;
R=X.real[0][k]-X.real[0][k+N/4]+X.real[0][k+N/2]-X.real[0][k+3*N/4];
I=X.imaj[0][k]-X.imaj[0][k+N/4]+X.imaj[0][k+N/2]-X.imaj[0][k+3*N/4];
C.real[0][4*n+2]+=R*W3[0]-W3[1]*I;
}
C.real[0][4*n]/=N;
C.real[0][4*n+1]/=N;
C.real[0][4*n+2]/=N;
C.real[0][4*n+3]/=N;
}
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////
matriz M_func(matriz A,int x,bool deg)
{matriz R;
R=ceros(A.m,A.n,A.im);
for(int i=0;i<R.m;i++)
for(int j=0;j<R.n;j++)
switch(x)
{ case 0:R.real[i][j]=sen(A.real[i][j],deg);break;////sen
case 1:R.real[i][j]=cos(A.real[i][j],deg);break;////cos
case 2:R.real[i][j]=tan(A.real[i][j],deg);break;///tan
case 3:R.real[i][j]=raiz(A.real[i][j]);break;///raiz
case 4:R.real[i][j]=ln(A.real[i][j]);break;////logaritmo natural
case 5:R.real[i][j]=e(A.real[i][j]);
if(R.im)
{ float m=R.real[i][j];
R.real[i][j]=m*cos(A.imaj[i][j],false);
R.imaj[i][j]=m*sen(A.imaj[i][j],false);
}
break;/////exponencial
}
return R;
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
matriz subMat(matriz A,matriz B)
{matriz C;
int m1,n1,m2,n2;
if(A.m==2&&A.n==2&&!A.im)
{ m1=A.real[0][0]-1;n1=A.real[0][1]-1;
m2=A.real[1][0];n2=A.real[1][1];
if(m1<B.m&&m2<=B.m&n1<B.n&&n2<=B.n)
{ C=ceros(m2-m1,n2-n1,B.im);
for(int x=m1;x<m2;x++)
for(int y=n1;y<n2;y++)
{ C.real[x-m1][y-n1]=B.real[x][y];
if(B.im)
C.imaj[x-m1][y-n1]=B.imaj[x][y];
}
}
}
return C;
}
Comentarios sobre la versión: versión 1.1 (6)
Desarrolla los siguientes ejercicios utilizando matrices en Codeblocks:
• Leer una Matriz y Mostrar su contenido (El tamaño debe ser m x m )
• Mostrar los números pares y su cantidad que se encuentran dentro de dicha matriz
• Mostrar los números impares y su cantidad que se encuentran dentro de dicha matriz
• Mostrar las diagonales de dicha matriz
• Invertir la primera posición con la ultima
• Solicitar al usuario dos posiciones e invertir el contenido de las mismas
• Multiplicar cada posición de la Matriz por un número suministrado por el usuario y mostrar la Matriz resultante en pantalla
TE AGRADESCO ME COLABORES VOY A ESTAR PENDIENTE DE TUS PUBLICACIONES QUE DIOS TE BENDIGA AMIGO
mi correo : [email protected]
#include<conio.h>
#include"matcam.h"
/////////////////////////////objeto matriz//////////////////////////////////
/*
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 leer_matriz(string cadena);/////////////////////////leemos un string conteniendo
/////////////////////el formato de declaracion de una matriz/////////////////////////////////////////
/*
datos:
,==>indica que es un separador en columnas
;==>indica deparador de renglones
formato:
nombreMatriz=num11,num12,nu1n;num21 num22 num2n
ejemplo:
tenemos la matriz A
1 2 3
7 8 5
9 8 6
formato de captura seria
A=1,2,3;7,8,5;9,8,6
*/
///////////////////////////////////////////////////////////////////////////
string capturar_caracteres();/////////////////////////////////captura los caracteres del teclado devolviendo un string de caracteres
int split(string *&elementos,string cad,char c);///////////////////divide un string apartir de un caracter 'c'
void mostrar_matriz(matriz A);///////////////////muestra la matriz///
double StrTof(const char *c);///////////convierte de caracter a flotante o double
//////////////////////////////////////////////////////////////////////////
int main()
{
string *el,cadena,col;
matriz A;
int i,j;
printf("Declare una matriz:\n");
cadena=capturar_caracteres();
cadena=capturar_caracteres();
A=leer_matriz(cadena);
mostrar_matriz(A);
}
//////////////////////////////////////////////////////////////////////////////////////////
matriz leer_matriz(string cadena)
{
string formato,*elementos,*columnas,*complejo,*complejoP,nom;
//char c;////////////////////variable char donde guardaremos el caracter para ser comparado
matriz ret;//////matriz que contiene los valores capturados que retorna la funcion,
bool bandera=false;////////bandera que indica que hay un signo "=" igual e indicar segundo miembro
int l,n,comas=0,ren,col;/////////////////////////variavle donde se guarda la longitud de cadena
ret.m=1;///////////////inicializo la variable de m renglones
ret.im=false;///////////inicializo con false indicando que la matriz es completamente real
l=cadena.length();//////////////obtenemos la longitud de la cadena
for(int x=0;x<l;x++)
{
if(cadena[x]==';')ret.m++;/////////////////contamos los punto y comas que indica que son renglones
else if(cadena[x]==',')comas++;////////////contamos las comas en el formato
if(cadena[x]=='=')bandera=true;//////si encuentra el caracter "=" bandera será verdadero
if(!bandera)nom.operator+=(cadena[x]);//mintras no encuentre el caracter "=" almacena cada caracter del nombre
else formato.operator+=(cadena[x]);//////de lo contrario almacena el caracter en la cadena del formato de llenado de matriz
if(bandera&&(cadena[x]=='j'||cadena[x]=='i'))ret.im=true;////////si encuentra el caracter 'i' o 'j' indica que la matriz tiene parte imaginaria
}
ret.n=comas/ret.m+1;//////////////obtenemos el numero de columnas en relacion del numero de comas sobre el numero de renglones para obtener numero de columnas
ret=ceros(ret.m,ret.n,ret.im);/////////reservamos memoria para alojar su valores reales e imaginarios(en caso que tenga componente imaginaria)
ret.nombre=nom;
////////////////////////////////////////////////////////////////////////////////////////////////////////
ren=split(elementos,formato.c_str(),';');///////////////dividimos todos los renglones///////////////////////////////
for(int i=0;i<ret.m&&ret.m==ren;i++)
{
col= split(columnas,elementos[i].c_str(),',');////////separamos los elementos de cada renglón
for(int j=0;j<ret.n&&ret.n==col;j++)
{
if(ret.im)////si es imaginaria
{
l=split(complejoP,columnas[j].c_str(),'+');
if(l==1)
{
n=split(complejo,columnas[j].c_str(),'-');
if(n==2)///////si es negativa la parte imaginaria
{
ret.real[i][j]=StrTof(complejo[0].c_str());//////////se convierte un string de la parte real a flotante
ret.imaj[i][j]=-StrTof(complejo[1].c_str());//////////se convierte un string de la parte imaginaria a flotante
}
else if(n==1)/////////////si nomas tiene puro reales
{
ret.real[i][j]=StrTof(complejo[0].c_str());//////////se convierte un string de la parte real a flotante
ret.imaj[i][j]=0.0;//////////se convierte un string de la parte imaginaria a flotante
}
else if(n==1&&(complejo[0].find('i')||complejo[0].find('j')))
{
ret.real[i][j]=0.0;//////////se convierte un string de la parte imaginaria a flotante
ret.imaj[i][j]=StrTof(complejo[0].c_str());//////////se convierte un string de la parte real a flotante
}
}
else if(l==2)//si es positiva la parte imaginaria
{
ret.real[i][j]=StrTof(complejoP[0].c_str());//////////se convierte un string de la parte real a flotante
ret.imaj[i][j]=StrTof(complejoP[1].c_str());//////////se convierte un string de la parte imaginaria a flotante
}
}
else
{
if(!columnas[j].empty())ret.real[i][j]=StrTof(columnas[j].c_str());
// printf("\n%s",columnas[j].c_str());
}
}
}
return ret;
}
////////////////////////////////////////////////////////////////////////////////
string capturar_caracteres()
{
char c;////////variable donde se alojara el caracterdel teclado
string caracteres;////////////////////variable string dode se almacenara la cadena ingresada
do
{
c=getche();///////capturamos caracter entrante del teclado
if(c!=13)//////////siempre que "c" sea diferente de el retorno de carro CRLF
caracteres.operator+=(c);/////se almacena el caracter a la cadena
}while(c!=13);
return caracteres;
}
///////////////////////////////////////////////////////////////////////////////////////////////////////
int split(string *&elementos,string cad,char c)
{
const char *cadena;
cadena=cad.c_str();
int l,e=0,cont=1;
l=cad.length();////////obtenemos el numero de caracteres de la caderna
for(int x=0;x<l;x++)if(cadena[x]==c&&x!=0)cont++;///////////cuenta el numero de caracteres separadores
elementos=new string[cont];///////////////////////////reserva espacio de memoria de acuerdo al numero de separciones
for(int x=0;x<l;x++)
{
if(cadena[x]!=c||(cadena[x]==c&&x==0))///si se presenta el caracter de divicion en la primer posicion, este sera ignorado
elementos[e].operator+=(cadena[x]);
else e++;
}
return cont;
}
//////////////////////////////////////////////////////////////////
void mostrar_matriz(matriz A)
{
printf("\n%s=:\n",A.nombre.c_str());
for(int i=0;i<A.m;i++)
{
for(int j=0;j<A.n;j++)
{
if(A.im)
{
if(A.imaj[i][j]>=0)printf("%f+%fi ",A.real[i][j],A.imaj[i][j]);
else printf("%f%fi ",A.real[i][j],A.imaj[i][j]);
}
else printf("%f ",A.real[i][j]);
}
printf("\n");
}
}
///////////////////////////////////////////////////////////////////////////////
double StrTof(const char *c)
{
float ent=0.0,dec=0,aux=0;
short int bandera=0,sig=1,f=0,lon;
float d=10.0,num=0.0,den=1.0;
lon=sizeof(c);
for(int x=0;x<lon;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;
}
te va a aparecer el mensaje
Declare una matriz:
tu vas a teclear por ejemplo el siguiente string
"A=2,3,4;3,2,5;9,7,6" (sin las comillas y un enter para retorno de carro )///////////entrada del programa
///////////////////////////////////////////////////////////////////salida:
A=:
2.000000 3.000000 4.000000
3.000000 2.000000 5.000000
9.000000 7.000000 6.000000
////////////////////////////////////////////////////para declarar una matriz compleja//////////////////////////////////////////////////////////
ejemplo:
"A=2+8i,2-7i;2+3i,4-6i"
//////////////////////////////////////////////////////////salida
A=:
2.000000+8.000000i 2.000000-7.000000i
2.000000+3.000000i 4.000000-6.000000i