Iniciar sesiónCrear cuenta

# Dev - C++ - MULTIPLICACION DE MATRICES

Vista:

## MULTIPLICACION DE MATRICES

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
2

## 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
0

## 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
0

## 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
0

## MULTIPLICACION DE MATRICES

Publicado por Xoxola (1 intervención) el 15/03/2016 21:25:56
Thank you!
Valora esta respuesta
0

## 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
0

## 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
0

## 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
0

## 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;`
`}`
Valora esta respuesta
1