Código de Visual C++ .NET - libreria de operacion de matrices

Imágen de perfil

libreria de operacion de matricesgráfica de visualizaciones


Visual C++ .NET

estrellaestrellaestrellaestrellaestrella(6)
Publicado el 24 de Agosto del 2016 por Jesus Armando
2.710 visualizaciones desde el 24 de Agosto del 2016. Una media de 35 por semana
Esta librería te facilita realizar operaciones matemáticas de matrices complejas y reales; Viene funciones de operaciones matemáticas de números complejos y reales, funciones trigonométricas, y funciones básicas de matemáticas. Los vectores son considerados como matrices de un solo renglón de N columnas y un escalar como matriz de 1X1,

Requerimientos

solo requiere minimo sistema operativo windows xp

versión 1.1
estrellaestrellaestrellaestrellaestrella(6)

Actualizado el 27 de Agosto del 2016 (Publicado el 24 de Agosto del 2016)gráfica de visualizaciones de la versión: versión 1.1
2.711 visualizaciones desde el 24 de Agosto del 2016. Una media de 35 por semana
estrellaestrellaestrellaestrellaestrella
estrellaestrellaestrellaestrella
estrellaestrellaestrella
estrellaestrella
estrella

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
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
#include <windows.h>
#include <iostream> 
#include <time.h>
#include <string> 
using namespace std;
#define PI     3.1415926535897932
#define exp    2.7182818284590452353602874713527
class matriz
{
public:
double **real;//////////////////////////////puntero donde se almacenan los parte real
double **imaj;//////////////////////////////puntero donde se almacenan la parte imaginria
bool im;///////////////////////////////////identifica si la matriz es real o compleja. im=true es compleja im=false es real////////////
bool mostrable;
string nombre;/////////////////////////////nombre de la matriz
string mensaje_error;//////////////////////Nombre e identificador de errores
int m,n;////////////////////////////////////dimension de la matriz, m===>numero de renglones n===>numero de columnas
unsigned short int error;///////////////////indica si tiene error de captura o de operación
short int id;///////////////////////////////numero identificador de la matriz
bool capturar_matriz(const char *cadena);///(;)-->indica renglón y (espacio)--> columna. Captura una matriz [numero1 numero2 etc...;numero1 numero2 etc...]
void ceros_imag();//////////////////////////rellena de ceros toda la parte imaginaria de la matriz
matriz *siguiente;
};
////////////////////////////////////////////////////////////////////////////////
matriz gauss_jhordan(matriz A,int r);/////////////////////////////////Realiza el metodo de gaussj-Jordan para la solucion de un sistema de ecuaciones simultaneas
matriz ceros(int I,int J,bool im); /////////////////////////////////////Proporciona una matriz de ceros de I renglones y J columnas
matriz rellenar(int I,int J,int valor);///////////////////////////////////////Proporciona una matriz de unos de I renglones y J columnas
matriz sumar(matriz A,matriz B);////////////////////////////////Realiza la suma de A+B
matriz convolucion(matriz A,matriz B);//////////////////////////Obtiene la convolucion discreta de A con B
matriz multiplicar(matriz A,matriz B);//////////////////////////Multiplica la matriz A por la matriz B o escalares AXB
matriz identidad(short int tam,bool im);////////////////////////////////Proporciona la matriz identidad en "tam" dimensiones
matriz aumentar(matriz A,matriz B,short int c_r);///////////////Aumenta a la matriz A,con matriz B, c_r=1-->en columnas,c_r=0-->en renglones
matriz inverza(matriz A);///////////////////////////////////////Obtiene la inverza de una matriz cuadrada
matriz lyapounov(matriz A,matriz B,matriz C);///////////////////Resuelve la ecuacion de lypounov AX+XB=C
matriz tran(matriz A);//////////////////////////////////////////Obtiene la transpuesta de una matriz
matriz abs(matriz A);///////////////////////////////////////////Obtiene el valor absoluto
matriz ifft(matriz X);//////////////////////////////////////////obtiene la transformada inverza rapda de fourier
matriz M_func(matriz A,int x,bool deg);////////////////////////////////////////
matriz subM(matriz A,int i,int j);//////////////////////////////obtiene submatriz i j
matriz detC(matriz A);//////////////////////////////////////////Obtiene el determinante de una matriz
matriz aleatoria(int m,int n,int rango,bool im);//////////////////////////////////Entrega una matriz rellena con numeros aleatorios///////////////////////////////////Reacomoda los renglones en los cuales hay un cero en la posicion de la diagonal
matriz subMat(matriz A,matriz B);///////////////////////////////////////////////////////////////entrega una sección de matriz
double strTof(const char *c);////////////////////////////////////Convierte de texto a un valor flotante
double cos(float angulo,bool deg);///////////////////////////////Obtiene el coseno de un angulo en radianes o grados deg=1-->grados deg=0-->radianes
double sen(float angulo,bool deg);///////////////////////////////Obtiene el seno de un angulo en radianes o grados deg=1-->grados deg=0-->radianes
double tan(float angulo,bool deg);///////////////////////////////Obtiene tangente de un angulo en radianes o grados deg=1-->grados deg=0-->radianes
double raiz(float x);////////////////////////////////////////////Obtiene la raiz cuadrada de x
double e(float x);//////////////////////////////////////////////Obtiene el esponexial con base 2.718281828
double ln(float x);/////////////////////////////////////////////Obtiene el Ln de x
double pow(float base,float potencia);//////////////////////////Eleva un numero a la n potencia
double log(float base,float x);/////////////////////////////////Obtiene el logaritmo de una base a la x potencia
double abs(double a);
////////////////////////////////////////////////////////////////////////////////
int strToint(const char *string);
/////////////////////////////////////////////////////////////////////////////////
void reservarF(double **&C,int i,int j,int init);
////////////////////////////////////////////////////////////////////////////////
void dft(matriz X,matriz &C);
void fft4(matriz X,matriz &C);
////////////////////////////////////////////////////////////////////////////////
void ifft4(matriz X,matriz &C);
void VerfDiagonal(matriz &A);
////////////////////////////////////////////////////////////////////////////////
void VerfDiagonal(matriz &A)
{
 double *aux;
 aux=new double[A.n];
  for(int p=0;p<A.m;p++)
    {
     if( A.real[p][p]==0&&p<A.m-1)
       {
       	if(A.im&&A.imaj[p][p]==0)
       	  {
       	   for(int x=0;x<A.n;x++)aux[x]=A.real[p][x];
       	   A.real[p]=A.real[p+1];
       	   A.real[p+1]=aux;
       	   for(int x=0;x<A.n;x++)aux[x]=A.imaj[p][x];
       	   A.imaj[p]=A.imaj[p+1];
       	   A.imaj[p+1]=aux;
		  }
       	else
       	  {
       	   for(int x=0;x<A.n;x++)aux[x]=A.real[p][x];
       	   A.real[p]=A.real[p+1];
       	   A.real[p+1]=aux;
		  }
       }
    }
}
////////////////////////////////////////////////////////////////////////////////
matriz gauss_jhordan(matriz A,int r)
{
matriz ux,P;
VerfDiagonal(A);
P.error=false;
ux.m=A.m;
ux.n=A.n;
ux=ceros(ux.m,ux.n,A.im);
for(int i=0;i<A.m;i++)
 for(int j=0;j<A.n;j++)
  {
  ux.real[i][j]=A.real[i][j];
  if(A.im)ux.imaj[i][j]=A.imaj[i][j];
  }
P.m=A.m;
P.n=A.n-r;
short int bandera=0;
float c,piv,PIV[2]={0.0,0.0},AUX[2]={0.0,0.0};
int in=0,in2=1;
P=ceros(P.m,P.n,A.im);
for(int k=0;k<2;k++)
 {
 for(int p=0;p<ux.m;p++)
 {
  if(!A.im)piv=ux.real[in+p*in2][in+p*in2];
  else
   {
   PIV[0]=ux.real[in+p*in2][in+p*in2];
   PIV[1]=ux.imaj[in+p*in2][in+p*in2];
   }
  for(int x=0;x<ux.n;x++)
   {
    if(!A.im)ux.real[in+p*in2][x]/=piv;
    else
     {
     AUX[0]=(ux.real[in+p*in2][x]*PIV[0]+ux.imaj[in+p*in2][x]*PIV[1])/(PIV[0]*PIV[0]+PIV[1]*PIV[1]);
     AUX[1]=(PIV[0]*ux.imaj[in+p*in2][x]-ux.real[in+p*in2][x]*PIV[1])/(PIV[0]*PIV[0]+PIV[1]*PIV[1]);
     ux.real[in+p*in2][x]=AUX[0];
     ux.imaj[in+p*in2][x]=AUX[1];
     }
   }
  for(int j=p+1;j<ux.m;j++)
   {
   if(!A.im)c=ux.real[in+j*in2][in+p*in2];
   else
    {
     PIV[0]=ux.real[in+j*in2][in+p*in2];
     PIV[1]=ux.imaj[in+j*in2][in+p*in2];
    }
   for(int i=0;i<ux.n;i++)
    if(!A.im)ux.real[in+j*in2][i]-=ux.real[in+p*in2][i]*c;
    else
     {
      AUX[0]=ux.real[in+p*in2][i]*PIV[0]-ux.imaj[in+p*in2][i]*PIV[1];
      AUX[1]=ux.real[in+p*in2][i]*PIV[1]+ux.imaj[in+p*in2][i]*PIV[0];
      ux.real[in+j*in2][i]-=AUX[0];
      ux.imaj[in+j*in2][i]-=AUX[1];
     }
   }
  }
  in=ux.m-1;
  in2=-1;
 }
for(int Y=0;Y<ux.m;Y++)
 for(int X=r;X<ux.n;X++)
     {
     P.real[Y][X-r]=ux.real[Y][X];
     if(A.im)
     P.imaj[Y][X-r]=ux.imaj[Y][X];
	 }
VerfDiagonal(P);
return P;
}
////////////////////////////////////////////////////////////////////////////////
matriz  ceros(int I,int J,bool im)
{
 matriz A;
 A.m=I;
 A.n=J;
 A.im=im;
 A.error=0;
 A.mostrable=true;
 reservarF(A.real,A.m,A.n,0);
 if(im)
 {
  reservarF(A.imaj,A.m,A.n,0);
  A.im=true;
 }
 return A;
}
/////////////////////////////////////////////////////////////////////////////////
matriz rellenar(int I,int J,int valor)
{
matriz A;
A.error=0;
A.m=I;
A.n=J;
A.mostrable=true;
reservarF(A.real,A.m,A.n,valor);
return A;
}
////////////////////////////////////////////////////////////////////////////////
matriz sumar(matriz A,matriz B)
{
 matriz C;
 if(A.m==B.m&&A.n==B.n)
   {
   C=ceros(A.m,A.n,A.im||B.im);
   if(A.im&&!B.im)B.ceros_imag();
   else if(B.im&&!A.im)A.ceros_imag();
   for(int i=0;i<C.m;i++)
    for(int j=0;j<C.n;j++)
     {
     C.real[i][j]=A.real[i][j]+B.real[i][j];
	 if(C.im)
     C.imaj[i][j]=A.imaj[i][j]+B.imaj[i][j];
	 }
   }
 else
  {
 	C.error=1;
 	C.mensaje_error="Todos los argumentos deben tener la misma dimension.\r\n";
  }
 return C;
}
////////////////////////////////////////////////////////////////////////////////
matriz convolucion(matriz A,matriz B)
{
 matriz conv;
 if(A.n==B.n)
 {
 conv=ceros(1,2*A.n-1,A.im||B.im);
 if(A.im||B.im)
   {
   if(!B.im)B.ceros_imag();
   else if(!A.im)A.ceros_imag();
   }
 for(int n=0;n<conv.n;n++)
  for(int k=0;k<A.n;k++)
     {
      if(n-k>=0&&n-k<A.n)
        {
         if(conv.im)
          {
          	conv.real[0][n]+=A.real[0][k]*B.real[0][n-k]-A.imaj[0][k]*B.imaj[0][n-k];
          	conv.imaj[0][n]+=A.real[0][k]*B.imaj[0][n-k]+A.imaj[0][k]*B.real[0][n-k];
          }
		 else conv.real[0][n]+=A.real[0][k]*B.real[0][n-k];
        }
     }
 }
else conv.mensaje_error="El numero de columnas de los dos argumentos deben de ser igual.\r\n";
return conv;
}
/////////////////////////////////////////////////////////////////////////////////
matriz multiplicar(matriz A,matriz B)
{
matriz C;
C.error=0;
if((A.n==1&&A.m==1)||(B.n==1&&B.m==1)||(A.n==B.m))
  {
  if(A.n==1&&A.m==1)C=ceros(B.m,B.n,A.im||B.im);
  else if(B.n==1&&B.m==1)C=ceros(A.m,A.n,A.im||B.im);
  else if(A.n==B.m)C=ceros(A.m,B.n,A.im||B.im);
  if(A.im||B.im)
   {
   	if(!A.im)A.ceros_imag();
   	else if(!B.im)B.ceros_imag();
   }
  for(int i=0;i<C.m;i++)
   for(int j=0;j<C.n;j++)
      {
       if(A.n==1&&A.m==1)
       {
       	 if(!C.im)C.real[i][j]=A.real[0][0]*B.real[i][j];
         else
          {
            C.real[i][j]=A.real[0][0]*B.real[i][j]-A.imaj[0][0]*B.imaj[i][j];
			C.imaj[i][j]=A.real[0][0]*B.imaj[i][j]+B.real[i][j]*A.imaj[0][0];
          }
	   }
      else if(B.n==1&&B.m==1)
       {
         if(!C.im)C.real[i][j]=B.real[0][0]*A.real[i][j];
         else
	     {
	       C.real[i][j]=A.real[i][j]*B.real[0][0]-A.imaj[i][j]*B.imaj[0][0];
		   C.imaj[i][j]=A.real[i][j]*B.imaj[0][0]+B.real[0][0]*A.imaj[i][j];
	     }
       }
      else if(A.n==B.m)
       for(int y=0;y<A.n;y++)
        {
         if(!C.im)C.real[i][j]+=A.real[i][y]*B.real[y][j];
         else
         {
       	   C.real[i][j]+=A.real[i][y]*B.real[y][j]-A.imaj[i][y]*B.imaj[y][j];
       	   C.imaj[i][j]+=A.real[i][y]*B.imaj[y][j]+B.real[y][j]*A.imaj[i][y];
         }
        }
      }
   }
  else
  {
   C.error=1;
   C.mensaje_error="Error de argumentos el numeros de columnas del primer argumento\r\nes diferente al numero de rengoles del segundo argumento.\r\n";
  }
 return C;
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
matriz identidad(short int tam,bool im)
{
  matriz C;
  C=ceros(tam,tam,im);
  for(int i=0;i<tam;i++)
   for(int j=0;j<tam;j++)
    if(i==j)C.real[i][j]=1.0;
return C;
}
////////////////////////////////////////////////////////////////////////////////
matriz aumentar(matriz A,matriz B,short int c_r)
{
matriz C;
C.error=1;
if(A.error==0&&B.error==0&&B.n!=0&&B.m!=0)
{
 if((bool)c_r)C=ceros(A.m,A.n+B.n,A.im||B.im);//////////////////////////////////aumento por columnas
 else C=ceros(A.m+B.m,A.n,A.im||B.im);//////////////////////////////////////////aumento por renglones
 if(A.im&&!B.im)B.ceros_imag();
 else if(B.im&&!A.im)A.ceros_imag();
 if((bool)c_r&&A.m==B.m)
  for(int i=0;i<C.m;i++)
   for(int j=0;j<C.n;j++)
    if(j<A.n)
    {
     C.real[i][j]=A.real[i][j];
     if(C.im)C.imaj[i][j]=A.imaj[i][j];
    }
   else
    {
     C.real[i][j]=B.real[i][j-A.n];
     if(C.im)C.imaj[i][j]=B.imaj[i][j-A.n];
    }
else if(A.n==B.n&&!(bool)c_r)
 for(int j=0;j<C.n;j++)
  for(int i=0;i<C.m;i++)
   if(i<A.m)
    {
     C.real[i][j]=A.real[i][j];
     if(C.im)C.imaj[i][j]=A.imaj[i][j];
    }
   else
    {
     C.real[i][j]=B.real[i-A.m][j];
     if(C.im)C.imaj[i][j]=B.imaj[i-A.m][j];
    }
 else C.error=1;
 }
 else if(B.n==0||B.m==0)C=A;
return C;
}
/////////////////////////////////////////////////////////////////////////////////
matriz inverza(matriz A)
{
matriz c,a;
a=aumentar(A,identidad(A.m,A.im),1);
c=gauss_jhordan(a,A.m);
return c;
}
/////////////////////////////////////////////////////////////////////////////////
matriz lyapounov(matriz A,matriz B,matriz C)
{
 matriz u,Q,a;
 if(A.m==A.n&&B.m==B.n&&C.m==A.m&&C.n==B.n)
   {
    u=ceros(A.m*B.m,A.m*B.m+1,A.im||B.im||C.im);
    Q=ceros(A.m,B.n,A.im||B.im||C.im);
    for(int y=0;y<B.m;y++)
     for(int i=0;i<A.m;i++)
      for(int j=0;j<A.n;j++)
       {
       u.real[i+A.m*y][j+A.n*y]=A.real[i][j];
       if(A.im)u.imaj[i+A.m*y][j+A.n*y]=A.imaj[i][j];
	   }
     for(int i=0;i<B.m;i++)
      for(int x=0;x<A.m;x++)
       for(int j=0;j<B.n;j++)
        {
         u.real[x+i*A.m][j*A.n+x]+=B.real[j][i];
         if(B.im)u.imaj[x+i*A.m][j*A.n+x]+=B.imaj[j][i];
        }
     for(int j=0;j<C.n;j++)
      for(int i=0;i<C.m;i++)
        {
          u.real[i+j*C.m][u.n-1]=C.real[i][j];
          if(C.im)u.imaj[i+j*C.m][u.n-1]=C.imaj[i][j];
        }
     a=gauss_jhordan(u,u.m);
     for(int i=0;i<Q.m;i++)
      for(int j=0;j<Q.n;j++)
       {
       	 Q.real[i][j]=a.real[i+j*Q.m][0];
       	 if(Q.im)Q.imaj[i][j]=a.imaj[i+j*Q.m][0];
       }
   }else Q.error=1;
return Q;
}
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
matriz tran(matriz A)
{
 matriz C;
 if(A.error==0)
 {
 C=ceros(A.n,A.m,A.im);
  for(int i=0;i<C.m;i++)
   for(int j=0;j<C.n;j++)
    {
     C.real[i][j]=A.real[j][i];
     if(A.im)
     C.imaj[i][j]=A.imaj[j][i];
    }
  }
 return C;
}
////////////////////////////////////////////////////////////////////////////////
matriz detC(matriz A)
{
 matriz sub,aux;
 float s=1.0;
 double r=0.0,i=0.0;
 int n=A.n;
 for(int x=0;x<n;x++)
  {
  	if(x%2==0)s=1.0;
  	else s=-1.0;
  	sub=subM(A,1,x+1);
  	if(sub.n==1&&sub.m==1)
	 {
		if(!A.im)r+=s*A.real[0][x]*sub.real[0][0];
		else
		{
		 r+=s*(A.real[0][x]*sub.real[0][0]-A.imaj[0][x]*sub.imaj[0][0]);
		 i+=s*(A.real[0][x]*sub.imaj[0][0]+A.imaj[0][x]*sub.real[0][0]);
		}
  	 }
    else if(sub.n>1&&sub.m>1)
	 {
	   if(!A.im)r+=s*A.real[0][x]*detC(sub).real[0][0];
	   else
	    {
	     aux=detC(sub);
	     r+=s*(A.real[0][x]*aux.real[0][0]-A.imaj[0][x]*aux.imaj[0][0]);
		 i+=s*(A.real[0][x]*aux.imaj[0][0]+A.imaj[0][x]*aux.real[0][0]);
	    }
	 }
  }
  sub=ceros(1,1,A.im);
  sub.real[0][0]=r;
  if(A.im)sub.imaj[0][0]=i;
  return sub;
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
matriz aleatoria(int m,int n,int rango,bool im)
{
 matriz C;
 int div;
 C.error=0;
 C.im=im;
 C.m=m;
 C.n=n;
 C.mostrable=true;
 reservarF(C.real,m,n,0);
 if(im)reservarF(C.imaj,m,n,0);
 srand(time(0));
 for(int i=0;i<m;i++)
  for(int j=0;j<n;j++)
    {
    	div=rand()%15;
    	if(div==0)div=1;
    	C.real[i][j]=(rand()%rango)/div;
    	if(im)C.imaj[i][j]=(rand()%rango)/div;
    }
 return C;
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void reservarF(double **&C,int i,int j,int init)
{
C=new double*[i];
for(int x=0;x<i;x++)
 {
  C[x]=new double[j];
  memset((void*)C[x],init, sizeof (double)*i);
 }
}
////////////////////////////////////////////////////////////////////////////////
double strTof(const char *c)
{
float ent=0.0,dec=0,aux=0;
short int bandera=0,sig=1,f=0;
float d=10.0,num=0.0,den=1.0;
for(int x=0;c[x]!=' '&&c[x]!=';'&&c[x]!=']'&&c[x]!=','&&c[x]!=0;x++)
  {
   if(bandera&&c[x]>='0'&&c[x]<='9')
   dec=dec+(c[x]-48)/d,d*=10;
   else if(c[x]>='0'&&c[x]<='9'&&!bandera)
   ent=ent*10+c[x]-48;
   if(c[x]=='.')
   bandera=1;
   if(c[x]=='-')
   sig=-1;
   if(c[x]=='/')
   bandera=0,num=(ent+dec),f=1,ent=0,dec=0,d=10.0;
  }
if(!f)num=(ent+dec)*sig;
if(f)den=(ent+dec)*sig;
aux=num/den;
return aux;
}
/////////////////////////////////////////////////////////////////////////////////
int strToint(const char *string)
{
int ent=0;
for(int x=0;string[x]!=0;x++)
 if(string[x]>='0'&&string[x]<='9')
   ent=ent*10+string[x]-48;
return ent;
}
////////////////////////////////////////////////////////////////////////////////
double cos(float angulo,bool deg)
{
bool neg=false;
if(angulo<0){angulo=-angulo;neg=true;}
float C[6]={-0.5,0.041667,-0.001389,0.000025,-0.0000002755,0.00000000208767};
float num=1.0,m=1.0,t,t2=1.0;
if(deg)angulo=PI*angulo/180.0;
int rad=(int)(2.0*angulo/PI),cuadrante;
cuadrante=rad%4;
angulo-=((float)rad*PI/2.0);
if(cuadrante==1||cuadrante==3)
angulo-=PI/2.0;
t=angulo*angulo;
for(int x=0;x<6;x++)
 {
 t2*=t;
 num+=C[x]*t2;
 }
if(cuadrante==1||cuadrante==2)
 num=-num;
if(neg)num=-num;
return num;
}
////////////////////////////////////////////////////////////////////////////////
double sen(float angulo,bool deg)
{
float r;
bool neg=false;
if(angulo<0.0){angulo=-angulo;neg=true;}
if(deg)
angulo=PI*angulo/180.0;
r=cos(abs(angulo-PI/2.0),false);
if(neg)r=-r;
return r;
}
////////////////////////////////////////////////////////////////////////////////
double tan(float angulo,bool deg)
{
float O,A;
if(angulo<0.0)angulo=-angulo;
if(deg)
angulo=PI*angulo/180.0;
O=sen(angulo,false);
A=cos(angulo,false);
return O/A;
}
////////////////////////////////////////////////////////////////////////////////
double e(float x)
{
long double aux,sum=1.0,p=1.0,f=1.0,mult=1.0;
bool b=false;
int m;
aux=x;
if(x<0.0)
aux=-aux;
if(aux>0)b=true;
m=(int)aux;
aux=aux-m;
for(int i=0;i<m;i++)mult*=exp;
 for(int i=1;i<=30&&b;i++)
  {
  p*=aux;
  f*=i;
  sum+=(p/f);
  }
if(x>=0.0)
return sum*mult;
else
return (1.0/sum)*mult;
}
////////////////////////////////////////////////////////////////////////////////////
double ln(float x)
{
 long double num=0.0,a=1.0,mult=1.0;
 bool ban=false;
 if(x>6)
  {
   int r=3;
   if(x>5000000)r=4;
  for(int i=0;i<r;i++)
  {
   x=raiz(x);
   mult*=2.0;
  }
 }
 if(x>1)
 x=1.0/x,ban=true;
 for(int n=1;n<=30;n++)
  {
  	a*=x-1;
  	if((n+1)%2)
  	num-=a/n;
  	else
  	num+=a/n;
  }
  if(ban)
  num=-num;
return num*mult;
}
////////////////////////////////////////////////////////////////////////////////////////
double pow(float base,float potencia)
{
 long double f=1,num=1.0,bas=1.0,a,N=1.0;
 bool neg=false;
 if(potencia<0)neg=true;
 int mult=(int)abs(potencia);
 for(int x=0;x<mult;x++)N*=base;
 potencia=abs(potencia)-mult;
 a=potencia*ln(base);
 for(int n=1;n<=50&&potencia>0.0;n++)
  {
  	f*=n;
  	bas*=a;
  	num+=bas/f;
  }
  if(neg)return 1/(N*num);
  else   return N*num;
 }
/////////////////////////////////////////////////////////////////////////////////////////
double log(float base,float x)
{
 float A,X;
 A=ln(base);
 X=ln(x);
 return (double)X/A;
}
///////////////////////////////////////////////////////////////////////////////////////////
matriz abs(matriz A)
{
  matriz C,T;
  C.error=0;
  reservarF(C.real,1,1,0);
  if(A.m==1&&A.n>1||A.m>1&&A.n==1)
   {
      T=tran(A);
      if(A.m==1&&A.n>1)
      C=multiplicar(A,T);
	  else if(A.m>1&&A.n==1)
	  C=multiplicar(T,A);
	  C.real[0][0]=raiz(C.real[0][0]);
   }
  else if(A.n==A.m)
   {
   C=detC(A);
   if(A.n==A.m&&A.im&&A.m==1)
    C.real[0][0]=raiz(pow(A.real[0][0],2)+pow(A.imaj[0][0],2)),C.im=0;
   }
  else C.error=1;
  if(C.real[0][0]<0)C.real[0][0]=-C.real[0][0];
  return C;
}
///////////////////////////////////////////////////////////////////////////////////////////
double abs(double a)
{
	double r;
	if(a<0)r=-a;
	else r=a;
return r;
}
///////////////////////////////////////////////////////////////////////////////////////////
bool matriz::capturar_matriz(const char *cadena)
{
  int i=1,c=0,j;
  char *string,*aux;
  string=new char[2];
  for(int x=0;cadena[x]!=0;x++)
  if(cadena[x]==';')i++;
  else if(cadena[x]==' ')c++;	
  j=c/i+1;
  m=i;
  n=j;
  reservarF(real,i,j,0);
  i=0,c=0,j=0;
  for(int x=0;cadena[x]!=0;x++)
  {
    if(cadena[x]!=';'&&cadena[x]!=' ')
	{
    	aux=string;
        string[c]=cadena[x];
        string[c+1]=0;
        string=aux;
        c++;
        aux=new char[c+2];
    }
    if(cadena[x]==';'||cadena[x]==' ')
    {
    real[i][j]=strTof(string);
    if(cadena[x]==';')i++,j=0,c=0;
    else if(cadena[x]==' ')j++,c=0;
    }
  }
   real[i][j]=strTof(string);
}
////////////////////////////////////////////////////////////////////////////////////////////////
double raiz(float x)
{
 double r=x,t=0;
 while (t!=r)
  {
   t=r;
   r=(x/r+r)/2;
  }
 return (float)r;
}
//////////////////////////////////////////////////////////////////////////////////////////////////
void matriz::ceros_imag()
{
 if(!im)
 {
 reservarF(imaj,m,n,0);
 im=1;
 }
}
///////////////////////////////////////////////////////////////////////////////////////////////
matriz subM(matriz A,int i,int j)
{
 matriz C;
 int X=0;
 int Y=0;
 if(i>0) C.m=A.m-1;else C.m=0;
 if(j>0)C.n=A.n-1;else  C.n=0;
 C=ceros(C.m,C.n,A.im);
 if(i>0&&j>0)
 for(int x=0;x<A.m;x++)
  {
  for(int y=0;y<A.n&&x!=i-1;y++)
    {
     if(y!=j-1)
      {
       C.real[X][Y]=A.real[x][y];
       if(C.im)C.imaj[X][Y]=A.imaj[x][y];
	   Y++;
      }
	}
  Y=0;
  if(x!=i-1)X++;
  }
 else C.error=1;
 return C;
}
///////////////////////////////////////////////////////////////////////////////////////////////
void dft(matriz X,matriz &C)
{
 int N=X.n;
 C=ceros(1,N,true);
 float Wnk[2]={0.0,0.0};
 for(int k=0;k<N;k++)
  for(int n=0;n<N;n++)
   {
   	Wnk[0]=cos(2*PI*n*k/N,false);
   	Wnk[1]=-sen(2*PI*n*k/N,false);
   	C.real[0][k]+=X.real[0][n]*Wnk[0];
   	C.imaj[0][k]+=X.real[0][n]*Wnk[1];
   }
}
///////////////////////
matriz auxiliar,resp;
DWORD   threadId[4];
/////////////////////////////////////////////////////////////////////////////////////////////////
DWORD WINAPI hilo1(LPVOID args)
{
  double W1[2]={0.0,0.0},W2[2]={0.0,0.0},W3[2]={0.0,0.0},W4[2]={0.0,0.0},Wn[2]={0.0,0.0};
  double R=0.0,I=0.0;
  int N=auxiliar.n;
  for(int k=0;k<N/4;k++)
  	for(int n=0;n<N/4;n++)
  	{
  	Wn[0]=cos(2*PI*n/N,false);
  	  Wn[1]=-sen(2*PI*n/N,false);
  	  W1[0]=cos(8*PI*n*k/N,false);//////////////////////////////////////////////////////////Real
  	  W1[1]=-sen(8*PI*n*k/N,false);/////////////////////////////////////////////////////////Imaginario
  	  W2[0]=W1[0]*Wn[0]-W1[1]*Wn[1];
  	  W2[1]=W1[0]*Wn[1]+W1[1]*Wn[0];
  	  W3[0]=W2[0]*Wn[0]-W2[1]*Wn[1];
  	  W3[1]=W2[0]*Wn[1]+W2[1]*Wn[0];
  	  W4[0]=W3[0]*Wn[0]-W3[1]*Wn[1];
  	  W4[1]=W3[0]*Wn[1]+W3[1]*Wn[0];
	  R=auxiliar.real[0][n]+auxiliar.real[0][n+N/4]+auxiliar.real[0][n+N/2]+auxiliar.real[0][n+3*N/4];
  	  resp.real[0][4*k]+=R*W1[0];
  	  resp.imaj[0][4*k]+=R*W1[1];
  	}
  	threadId[0]=0;
}
/////////////////////////////////////////////////////////////////////////////////////////////////
DWORD WINAPI hilo2(LPVOID args)
{
  double W1[2]={0.0,0.0},W2[2]={0.0,0.0},W3[2]={0.0,0.0},W4[2]={0.0,0.0},Wn[2]={0.0,0.0};
  double R=0.0,I=0.0;
  int N=auxiliar.n;
  for(int k=0;k<N/4;k++)
  	for(int n=0;n<N/4;n++)
  	{
  	  Wn[0]=cos(2*PI*n/N,false);
  	  Wn[1]=-sen(2*PI*n/N,false);
  	  W1[0]=cos(8*PI*n*k/N,false);//////////////////////////////////////////////////////////Real
  	  W1[1]=-sen(8*PI*n*k/N,false);/////////////////////////////////////////////////////////Imaginario
  	  W2[0]=W1[0]*Wn[0]-W1[1]*Wn[1];
  	  W2[1]=W1[0]*Wn[1]+W1[1]*Wn[0];
  	  W3[0]=W2[0]*Wn[0]-W2[1]*Wn[1];
  	  W3[1]=W2[0]*Wn[1]+W2[1]*Wn[0];
  	  W4[0]=W3[0]*Wn[0]-W3[1]*Wn[1];
  	  W4[1]=W3[0]*Wn[1]+W3[1]*Wn[0];
	  R=auxiliar.real[0][n]-auxiliar.real[0][n+N/2];
  	  I=auxiliar.real[0][n+3*N/4]-auxiliar.real[0][n+N/4];
  	  resp.real[0][4*k+1]+=R*W2[0]-I*W2[1];
  	  resp.imaj[0][4*k+1]+=R*W2[1]+W2[0]*I;
  	}
  	threadId[1]=0;
}
/////////////////////////////////////////////////////////////////////////////////////////////////
DWORD WINAPI hilo3(LPVOID args)
{
 double W1[2]={0.0,0.0},W2[2]={0.0,0.0},W3[2]={0.0,0.0},W4[2]={0.0,0.0},Wn[2]={0.0,0.0};
 double R=0.0,I=0.0;
 int N=auxiliar.n;
  for(int k=0;k<N/4;k++)
  	for(int n=0;n<N/4;n++)
  	{
  	 Wn[0]=cos(2*PI*n/N,false);
  	  Wn[1]=-sen(2*PI*n/N,false);
  	  W1[0]=cos(8*PI*n*k/N,false);//////////////////////////////////////////////////////////Real
  	  W1[1]=-sen(8*PI*n*k/N,false);/////////////////////////////////////////////////////////Imaginario
  	  W2[0]=W1[0]*Wn[0]-W1[1]*Wn[1];
  	  W2[1]=W1[0]*Wn[1]+W1[1]*Wn[0];
  	  W3[0]=W2[0]*Wn[0]-W2[1]*Wn[1];
  	  W3[1]=W2[0]*Wn[1]+W2[1]*Wn[0];
  	  W4[0]=W3[0]*Wn[0]-W3[1]*Wn[1];
  	  W4[1]=W3[0]*Wn[1]+W3[1]*Wn[0];
  	  R=auxiliar.real[0][n]-auxiliar.real[0][n+N/2];
	  I=auxiliar.real[0][n+N/4]-auxiliar.real[0][n+3*N/4];
  	  resp.real[0][4*k+3]+=R*W4[0]-I*W4[1];
  	  resp.imaj[0][4*k+3]+=R*W4[1]+W4[0]*I;
  	}
  threadId[2]=0;
}
/////////////////////////////////////////////////////////////////////////////////////////////////
DWORD WINAPI hilo4(LPVOID args)
{
 double W1[2]={0.0,0.0},W2[2]={0.0,0.0},W3[2]={0.0,0.0},W4[2]={0.0,0.0},Wn[2]={0.0,0.0};
 double R=0.0,I=0.0;
 int N=auxiliar.n;
  for(int k=0;k<N/4;k++)
  	for(int n=0;n<N/4;n++)
  	{
  	  Wn[0]=cos(2*PI*n/N,false);
  	  Wn[1]=-sen(2*PI*n/N,false);
  	  W1[0]=cos(8*PI*n*k/N,false);//////////////////////////////////////////////////////////Real
  	  W1[1]=-sen(8*PI*n*k/N,false);/////////////////////////////////////////////////////////Imaginario
  	  W2[0]=W1[0]*Wn[0]-W1[1]*Wn[1];
  	  W2[1]=W1[0]*Wn[1]+W1[1]*Wn[0];
  	  W3[0]=W2[0]*Wn[0]-W2[1]*Wn[1];
  	  W3[1]=W2[0]*Wn[1]+W2[1]*Wn[0];
  	  W4[0]=W3[0]*Wn[0]-W3[1]*Wn[1];
  	  W4[1]=W3[0]*Wn[1]+W3[1]*Wn[0];
  	 // I=auxiliar.real[0][n+N/4]-auxiliar.real[0][n+3*N/4];
	  R=auxiliar.real[0][n]-auxiliar.real[0][n+N/4]+auxiliar.real[0][n+N/2]-auxiliar.real[0][n+3*N/4];
  	  resp.real[0][4*k+2]+=R*W3[0];
  	  resp.imaj[0][4*k+2]+=R*W3[1];
  	}
  	threadId[3]=0;
}
///////////////////////////////////////////////////
void fft4(matriz X,matriz &C)
{
 HANDLE  tareas[4];
 int residuo=X.n%4;
 if(residuo>0)residuo=4-residuo;
 auxiliar=aumentar(X,ceros(1,residuo,false),1);//X; 
 resp=ceros(1,X.n+residuo,true);
 for(int x=0;x<4;x++)threadId[x]=x+1;
 int val[4];
 tareas[0]=CreateThread( NULL, 0,hilo1, &val[0], 0, &threadId[0]);
 tareas[1]=CreateThread( NULL, 0,hilo2, &val[1], 0, &threadId[1]);
 tareas[2]=CreateThread( NULL, 0,hilo3, &val[2], 0, &threadId[2]);
 tareas[3]=CreateThread( NULL, 0,hilo4, &val[3], 0, &threadId[3]);
 while(!(threadId[0]==0&&threadId[1]==0&&threadId[2]==0&&threadId[3]==0));
 C=resp;
}
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void ifft4(matriz X,matriz &C)
{
 int N=X.n*X.m;
 float W1[2]={0.0,0.0},W2[2]={0.0,0.0},W3[2]={0.0,0.0},W4[2]={0.0,0.0},Wk[2]={0.0,0.0};
 float R=0.0,I=0.0;
 C=ceros(1,N,false);
 for(int n=0;n<N/4;n++)
  {
  for(int k=0;k<N/4;k++)
   {
    Wk[0]=cos(2*PI*k/N,false);
  	Wk[1]=sen(2*PI*k/N,false);
  	W1[0]=cos(8*PI*n*k/N,false);
  	W1[1]=sen(8*PI*n*k/N,false);
  	W2[0]=W1[0]*Wk[0]-W1[1]*Wk[1];
    W2[1]=W1[0]*Wk[1]+W1[1]*Wk[0];
  	W3[0]=W2[0]*Wk[0]-W2[1]*Wk[1];
  	W3[1]=W2[0]*Wk[1]+W2[1]*Wk[0];
  	W4[0]=W3[0]*Wk[0]-W3[1]*Wk[1];
  	W4[1]=W3[0]*Wk[1]+W3[1]*Wk[0];
  	R=X.real[0][k]+X.real[0][k+N/4]+X.real[0][k+N/2]+X.real[0][k+3*N/4];
  	I=X.imaj[0][k]+X.imaj[0][k+N/4]+X.imaj[0][k+N/2]+X.imaj[0][k+3*N/4];
  	C.real[0][4*n]+=R*W1[0]-I*W1[1];
  	R=X.real[0][k]-X.real[0][k+N/2]-X.imaj[0][k+N/4]+X.imaj[0][k+3*N/4];
  	I=X.imaj[0][k]-X.imaj[0][k+N/2]+X.real[0][k+N/4]-X.real[0][k+3*N/4];
  	C.real[0][4*n+1]+=R*W2[0]-W2[1]*I;
  	R=X.real[0][k]-X.real[0][k+N/2]+X.imaj[0][k+N/4]-X.imaj[0][k+3*N/4];
  	I=X.imaj[0][k]-X.imaj[0][k+N/2]-X.real[0][k+N/4]+X.real[0][k+3*N/4];
  	C.real[0][4*n+3]+=R*W4[0]-W4[1]*I;
  	R=X.real[0][k]-X.real[0][k+N/4]+X.real[0][k+N/2]-X.real[0][k+3*N/4];
  	I=X.imaj[0][k]-X.imaj[0][k+N/4]+X.imaj[0][k+N/2]-X.imaj[0][k+3*N/4];
  	C.real[0][4*n+2]+=R*W3[0]-W3[1]*I;
   }
   C.real[0][4*n]/=N;
   C.real[0][4*n+1]/=N;
   C.real[0][4*n+2]/=N;
   C.real[0][4*n+3]/=N;
 }
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////
matriz M_func(matriz A,int x,bool deg)
{
matriz R;
R=ceros(A.m,A.n,A.im);
for(int i=0;i<R.m;i++)
 for(int j=0;j<R.n;j++)
  switch(x)
   {
   	case 0:R.real[i][j]=sen(A.real[i][j],deg);break;////sen
   	case 1:R.real[i][j]=cos(A.real[i][j],deg);break;////cos
   	case 2:R.real[i][j]=tan(A.real[i][j],deg);break;///tan
   	case 3:R.real[i][j]=raiz(A.real[i][j]);break;///raiz
   	case 4:R.real[i][j]=ln(A.real[i][j]);break;////logaritmo natural
   	case 5:R.real[i][j]=e(A.real[i][j]);
	       if(R.im)
	           {
	           	float m=R.real[i][j];
	           	R.real[i][j]=m*cos(A.imaj[i][j],false);
	           	R.imaj[i][j]=m*sen(A.imaj[i][j],false);
	           }
		   break;/////exponencial
   }
return R;
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
matriz subMat(matriz A,matriz B)
{
matriz C;
int m1,n1,m2,n2;
if(A.m==2&&A.n==2&&!A.im)
 {
  m1=A.real[0][0]-1;n1=A.real[0][1]-1;
  m2=A.real[1][0];n2=A.real[1][1];
  if(m1<B.m&&m2<=B.m&n1<B.n&&n2<=B.n)
   {
    C=ceros(m2-m1,n2-n1,B.im);
    for(int x=m1;x<m2;x++)
     for(int y=n1;y<n2;y++)
       {
       	C.real[x-m1][y-n1]=B.real[x][y];
       	if(B.im)
       	C.imaj[x-m1][y-n1]=B.imaj[x][y];
       }
   }
 }
 return C;
}



Comentarios sobre la versión: versión 1.1 (6)

Imágen de perfil
Jesus Armando
03 de Septiembre del 2016
estrellaestrellaestrellaestrellaestrella
cualquier duda pregunten por este medio
Responder
nahum isaac gamero acosta
07 de Septiembre del 2016
estrellaestrellaestrellaestrellaestrella
Jesus armando soy estudiante de ingenieria de sistemas en colombia y soy seguidor de tu trabajo me parece espectacular tu labor, quisiera me colaboraras con un taller de programacion ii te agradezco el favor dice asi:
Desarrolla los siguientes ejercicios utilizando matrices en Codeblocks:
• Leer una Matriz y Mostrar su contenido (El tamaño debe ser m x m )
• Mostrar los números pares y su cantidad que se encuentran dentro de dicha matriz
• Mostrar los números impares y su cantidad que se encuentran dentro de dicha matriz
• Mostrar las diagonales de dicha matriz

• Invertir la primera posición con la ultima
• Solicitar al usuario dos posiciones e invertir el contenido de las mismas
• Multiplicar cada posición de la Matriz por un número suministrado por el usuario y mostrar la Matriz resultante en pantalla
TE AGRADESCO ME COLABORES VOY A ESTAR PENDIENTE DE TUS PUBLICACIONES QUE DIOS TE BENDIGA AMIGO
mi correo : nahumgameroacosta@gmail.com
Responder
Imágen de perfil
Jesus Armando
07 de Septiembre del 2016
estrellaestrellaestrellaestrellaestrella
muchas gracias compañero, con gusto te colaboro, en cuanto tenga lista la información te contesto y te envió inf. a tu coreo, saludos...
Responder
Imágen de perfil
Jesus Armando
10 de Septiembre del 2016
estrellaestrellaestrellaestrellaestrella
#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(const char *c);///////////convierte de caracter a flotante o double
//////////////////////////////////////////////////////////////////////////
int main()
{
string *el,cadena,col;
matriz A;
int i,j;
printf("Declare una matriz:\n");
cadena=capturar_caracteres();
cadena=capturar_caracteres();
A=leer_matriz(cadena);
mostrar_matriz(A);
}
//////////////////////////////////////////////////////////////////////////////////////////
matriz leer_matriz(string cadena)
{
string formato,*elementos,*columnas,*complejo,*complejoP,nom;
//char c;////////////////////variable char donde guardaremos el caracter para ser comparado
matriz ret;//////matriz que contiene los valores capturados que retorna la funcion,
bool bandera=false;////////bandera que indica que hay un signo "=" igual e indicar segundo miembro
int l,n,comas=0,ren,col;/////////////////////////variavle donde se guarda la longitud de cadena
ret.m=1;///////////////inicializo la variable de m renglones
ret.im=false;///////////inicializo con false indicando que la matriz es completamente real
l=cadena.length();//////////////obtenemos la longitud de la cadena
for(int x=0;x<l;x++)
{
if(cadena[x]==';')ret.m++;/////////////////contamos los punto y comas que indica que son renglones
else if(cadena[x]==',')comas++;////////////contamos las comas en el formato
if(cadena[x]=='=')bandera=true;//////si encuentra el caracter "=" bandera será verdadero
if(!bandera)nom.operator+=(cadena[x]);//mintras no encuentre el caracter "=" almacena cada caracter del nombre
else formato.operator+=(cadena[x]);//////de lo contrario almacena el caracter en la cadena del formato de llenado de matriz
if(bandera&&(cadena[x]=='j'||cadena[x]=='i'))ret.im=true;////////si encuentra el caracter 'i' o 'j' indica que la matriz tiene parte imaginaria
}
ret.n=comas/ret.m+1;//////////////obtenemos el numero de columnas en relacion del numero de comas sobre el numero de renglones para obtener numero de columnas
ret=ceros(ret.m,ret.n,ret.im);/////////reservamos memoria para alojar su valores reales e imaginarios(en caso que tenga componente imaginaria)
ret.nombre=nom;
////////////////////////////////////////////////////////////////////////////////////////////////////////
ren=split(elementos,formato.c_str(),';');///////////////dividimos todos los renglones///////////////////////////////
for(int i=0;i<ret.m&&ret.m==ren;i++)
{
col= split(columnas,elementos[i].c_str(),',');////////separamos los elementos de cada renglón
for(int j=0;j<ret.n&&ret.n==col;j++)
{
if(ret.im)////si es imaginaria
{
l=split(complejoP,columnas[j].c_str(),'+');
if(l==1)
{
n=split(complejo,columnas[j].c_str(),'-');
if(n==2)///////si es negativa la parte imaginaria
{
ret.real[i][j]=StrTof(complejo[0].c_str());//////////se convierte un string de la parte real a flotante
ret.imaj[i][j]=-StrTof(complejo[1].c_str());//////////se convierte un string de la parte imaginaria a flotante
}
else if(n==1)/////////////si nomas tiene puro reales
{
ret.real[i][j]=StrTof(complejo[0].c_str());//////////se convierte un string de la parte real a flotante
ret.imaj[i][j]=0.0;//////////se convierte un string de la parte imaginaria a flotante
}
else if(n==1&&(complejo[0].find('i')||complejo[0].find('j')))
{
ret.real[i][j]=0.0;//////////se convierte un string de la parte imaginaria a flotante
ret.imaj[i][j]=StrTof(complejo[0].c_str());//////////se convierte un string de la parte real a flotante
}
}
else if(l==2)//si es positiva la parte imaginaria
{
ret.real[i][j]=StrTof(complejoP[0].c_str());//////////se convierte un string de la parte real a flotante
ret.imaj[i][j]=StrTof(complejoP[1].c_str());//////////se convierte un string de la parte imaginaria a flotante
}
}

else
{
if(!columnas[j].empty())ret.real[i][j]=StrTof(columnas[j].c_str());
// printf("\n%s",columnas[j].c_str());
}
}
}
return ret;
}
////////////////////////////////////////////////////////////////////////////////
string capturar_caracteres()
{
char c;////////variable donde se alojara el caracterdel teclado
string caracteres;////////////////////variable string dode se almacenara la cadena ingresada
do
{
c=getche();///////capturamos caracter entrante del teclado
if(c!=13)//////////siempre que "c" sea diferente de el retorno de carro CRLF
caracteres.operator+=(c);/////se almacena el caracter a la cadena
}while(c!=13);
return caracteres;
}
///////////////////////////////////////////////////////////////////////////////////////////////////////
int split(string *&elementos,string cad,char c)
{
const char *cadena;
cadena=cad.c_str();
int l,e=0,cont=1;
l=cad.length();////////obtenemos el numero de caracteres de la caderna
for(int x=0;x<l;x++)if(cadena[x]==c&&x!=0)cont++;///////////cuenta el numero de caracteres separadores
elementos=new string[cont];///////////////////////////reserva espacio de memoria de acuerdo al numero de separciones
for(int x=0;x<l;x++)
{
if(cadena[x]!=c||(cadena[x]==c&&x==0))///si se presenta el caracter de divicion en la primer posicion, este sera ignorado
elementos[e].operator+=(cadena[x]);
else e++;
}
return cont;
}
//////////////////////////////////////////////////////////////////
void mostrar_matriz(matriz A)
{
printf("\n%s=:\n",A.nombre.c_str());
for(int i=0;i<A.m;i++)
{
for(int j=0;j<A.n;j++)
{
if(A.im)
{
if(A.imaj[i][j]>=0)printf("%f+%fi ",A.real[i][j],A.imaj[i][j]);
else printf("%f%fi ",A.real[i][j],A.imaj[i][j]);
}
else printf("%f ",A.real[i][j]);
}
printf("\n");
}
}
///////////////////////////////////////////////////////////////////////////////
double StrTof(const char *c)
{
float ent=0.0,dec=0,aux=0;
short int bandera=0,sig=1,f=0,lon;
float d=10.0,num=0.0,den=1.0;
lon=sizeof(c);
for(int x=0;x<lon;x++)
{
if(bandera&&c[x]>='0'&&c[x]<='9')
dec=dec+(c[x]-48)/d,d*=10;
else if(c[x]>='0'&&c[x]<='9'&&!bandera)
ent=ent*10+c[x]-48;
if(c[x]=='.')
bandera=1;
if(c[x]=='-')
sig=-1;
if(c[x]=='/')
bandera=0,num=(ent+dec),f=1,ent=0,dec=0,d=10.0;
}
if(!f)num=(ent+dec)*sig;
if(f)den=(ent+dec)*sig;
aux=num/den;
return aux;
}
Responder
Imágen de perfil
Jesus Armando
10 de Septiembre del 2016
estrellaestrellaestrellaestrellaestrella
Este programa captura una matriz y la muestra
te va a aparecer el mensaje
Declare una matriz:
tu vas a teclear por ejemplo el siguiente string
"A=2,3,4;3,2,5;9,7,6" (sin las comillas y un enter para retorno de carro )///////////entrada del programa
///////////////////////////////////////////////////////////////////salida:
A=:
2.000000 3.000000 4.000000
3.000000 2.000000 5.000000
9.000000 7.000000 6.000000
////////////////////////////////////////////////////para declarar una matriz compleja//////////////////////////////////////////////////////////
ejemplo:
"A=2+8i,2-7i;2+3i,4-6i"
//////////////////////////////////////////////////////////salida
A=:
2.000000+8.000000i 2.000000-7.000000i
2.000000+3.000000i 4.000000-6.000000i
Responder
eder fernandez
08 de Noviembre del 2016
estrellaestrellaestrellaestrellaestrella
buenas tardes tengo un problema y me gustaria ver si me puede asesorar necesito hacer una calculadora de matrices (suma,resta,multiplicación,determinantes,transpuesta e inversa) y la verdad ya tengo todo menos la inversa y por mas que eh intentado no logro que me quede el programa asi que me gustaria saber si puedes ayudarme
Responder

Comentar la versión: versión 1.1

Nombre
Correo (no se visualiza en la web)
Valoración
Comentarios

http://lwp-l.com/s3643