Dev - C++ - MULTIPLICACION DE MATRICES

   
Vista:

MULTIPLICACION DE MATRICES

Publicado por Luis lbadauto@gmail.com (6 intervenciones) el 25/02/2013 21:10:20
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
//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
Valora esta pregunta
Me gusta: Está pregunta es útil y esta claraNo me gusta: Está pregunta no esta clara o no es útil
2
Responder

MULTIPLICACION DE MATRICES

Publicado por JAJAVIER D (1 intervención) el 27/05/2013 20:29:51
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
#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;
}
Valora esta respuesta
Me gusta: Está respuesta es útil y esta claraNo me gusta: Está respuesta no esta clara o no es útil
0
Comentar

regla de kramer

Publicado por juan andres yeyo_lajauria2@hotmail.com (1 intervención) el 20/11/2014 00:44:53
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
// 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();
}
Valora esta respuesta
Me gusta: Está respuesta es útil y esta claraNo me gusta: Está respuesta no esta clara o no es útil
0
Comentar

MULTIPLICACION DE MATRICES

Publicado por Allan flores (1 intervención) el 11/04/2014 06:18:51
Que excelente programa GRACIAS me sirvió demasiado :D
Valora esta respuesta
Me gusta: Está respuesta es útil y esta claraNo me gusta: Está respuesta no esta clara o no es útil
0
Comentar

MULTIPLICACION DE MATRICES

Publicado por Xoxola (1 intervención) el 15/03/2016 21:25:56
Thank you!
Valora esta respuesta
Me gusta: Está respuesta es útil y esta claraNo me gusta: Está respuesta no esta clara o no es útil
0
Comentar
Imágen de perfil de Jesus Armando

MULTIPLICACION DE MATRICES

Publicado por Jesus Armando armando_1218@hotmail.com (5 intervenciones) el 24/08/2016 00:07:35
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
//////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;
}
Valora esta respuesta
Me gusta: Está respuesta es útil y esta claraNo me gusta: Está respuesta no esta clara o no es útil
0
Comentar
Imágen de perfil de Jesus Armando

MULTIPLICACION DE MATRICES

Publicado por Jesus Armando (5 intervenciones) el 24/08/2016 00:25:04
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
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;
}
Valora esta respuesta
Me gusta: Está respuesta es útil y esta claraNo me gusta: Está respuesta no esta clara o no es útil
0
Comentar

MULTIPLICACION DE MATRICES

Publicado por Jose Luis (1 intervención) el 22/09/2016 07:29:04
¿como introduces los valores de la matriz desde el teclado? no le entiendo al momento que te dice que introduzcas fila y columna de la primera matriz!
Valora esta respuesta
Me gusta: Está respuesta es útil y esta claraNo me gusta: Está respuesta no esta clara o no es útil
0
Comentar
Imágen de perfil de Jesus Armando

MULTIPLICACION DE MATRICES

Publicado por Jesus Armando (5 intervenciones) el 22/09/2016 22:59:32
te paso el siguiente código en el cual tu capturas una matriz, ya sea real o con números complejos y te la muestra

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
#include<stdio.h>
#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(string A);///////////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();
	A=leer_matriz(cadena);
	mostrar_matriz(A);
	main();
}
//////////////////////////////////////////////////////////////////////////////////////////
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
      	    	   	    {
      	    	   	    if(!complejo[0].find('i')&&!complejo[0].find('j'))
      	    	   	     {
      	    	   	      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(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(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());
      	    	 columnas[j].clear();
      	    	// printf("\n%s",columnas[j].c_str());
      	    	 }
      	    }
      	if(ret.n!=col)
      	ret.error=1;
      }
   if(ret.m!=ren)
   ret.error=1;
   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)
{
if(A.error==0)
  {
  	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]);/////////si es positivo el imaginario
  	      else printf("%f%fi  ",A.real[i][j],A.imaj[i][j]);/////////si es negativo el imaginario
  	    }
  	  else	printf("%f  ",A.real[i][j]);
  	  }
  	  printf("\n");
    }
  }
else puts("\nMatriz erronea");
}
///////////////////////////////////////////////////////////////////////////////
double StrTof(string a)
{
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;
const char *c;
c=a.c_str();
lon=a.length();
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;
}
http://www.lawebdelprogramador.com/codigo/Visual-C-NET/3663-capturar-una-matriz-y-mostrarla-con-libreria-matcam.h.html
Valora esta respuesta
Me gusta: Está respuesta es útil y esta claraNo me gusta: Está respuesta no esta clara o no es útil
1
Comentar

MULTIPLICACION DE MATRICES

Publicado por adriana (1 intervención) el 15/10/2016 21:34:43
para q sirve \t%4.2f\n" ??....se que el \t es como espacio y el \n como salto de linea y el %4.2 ?? muchas gracias me sirvio mucho,espero su respuesta
Valora esta respuesta
Me gusta: Está respuesta es útil y esta claraNo me gusta: Está respuesta no esta clara o no es útil
1
Comentar
Imágen de perfil de Jesus Armando

MULTIPLICACION DE MATRICES

Publicado por Jesus Armando (5 intervenciones) el 17/10/2016 06:33:26
%4.2f significa que imprimirá dos decimales y cuatro caracteres como justificado del texto
Valora esta respuesta
Me gusta: Está respuesta es útil y esta claraNo me gusta: Está respuesta no esta clara o no es útil
1
Comentar