Gracias por responder, de hecho mi amigo, así es, la clase maneja vectores de 3 dimensiones y realiza muchas multiplicaciones y redimencionamientos, ademas por allí estaba leyendo que las clases pasan los valores de los datos por referencia en vez de puntero y que por eso es mas lento, sinceramente no se bien a que se refiere, al fin y al cabo reescribí el código haciendo uso de funciones en vez de clases y si muy parecido a C, el resultado: el ejecutable procesa todos los datos en una centésima de segundo.
No se si algo se me este escapando o no, pero por experiencia propia creo que las ventajas de C++ no sirven para hacer matemática compleja sino mas bien para programas mejor organizados y mas entendibles, como manejos de bases de datos o manejo de strings cosas así, corrijanme si me equivoco y si lo hacen al menos expliquen por que C++ corrió tan lento y aquí les va el código que define la clase matrix en matrix.h y el código de los métodos para acceso a las variables privadas en matrix.cpp, Yo no soy un experto en programación, yo he aprendido según he necesitado así que si ven errores en cuanto a la forma en cuanto escribo mi código (que no siga algún standart de programación) pues es por que no lo conocía y les agradecería correcciones:
---------------------Archivo matrix.h---------------------------------------------
/****************************************
Esta clase es para manejo de un vector de
matrices. útil para calculos de matrices
cambiantes con el tiempo.
Omar Andrés Trevizo Rascón Mayo/2010
T=Vector de tiempo
R=Renglon de la matriz
C=Columna de la matriz
****************************************/
#include <vector>
#ifndef _matrix_
#define _matrix_
namespace mtrx
{
class matrix{
private:
/*Declaracion del vector de matrices*/
std::vector< std::vector<std::vector<float> > > Mvector;
public:
//matrix();
void dim(int T, int R, int C);
void asig(float x, int T, int R, int C);
void mul(int T, int Ta, int Tb, int a_NumCol, matrix a, matrix b);
void suma(int T, int Ta, int Tb, matrix a, matrix b);
void resta(int T, int Ta, int Tb, matrix a, matrix b);
void trans(int T, matrix a);
void div_sca(int T, int Ta, matrix a, float x);
matrix trans(int T);
float toma(int T, int R, int C);
};
};
#endif
----------------------------------------------------------------------------------
----------------------------matrix.cpp-------------------------------------------
/**************************************
Esta clase es para manejo de arrays de
matrices de dos dimensiones. útil para
calculos de matrices cambiantes con
el tiempo.
Omar Andrés Trevizo Rascón Mayo/2010
**************************************/
#include <vector>
#include "matrix.h"
/*Redimencionamiento de matrices*/
void mtrx::matrix::dim(int T, int R, int C)
{
Mvector.resize(T);
for (int i=0;i<(int)Mvector.size();++i)
{
Mvector[i].resize(R);
for (int j=0;j<(int)Mvector[i].size();++j)
{
Mvector[i][j].resize(C);
}
}
};
/*Multiplicación entre dos matrices pertenecientes a un vector*/
void mtrx::matrix::mul(int T,int Ta,int Tb,int a_NumCol, matrix a, matrix b)
{
int C=0,R=0;
int Rt=(int)Mvector[T].size(), Ct=(int)Mvector[T][R].size(),;
for(R=0;R<Rt;R++) //renglon
{
for(C=0;C<Ct;C++) //columna
{
Mvector[T][R][C]=0;
for(int Cont=0;Cont<a_NumCol;Cont++)
{
Mvector[T][R][C]+=a.toma(Ta,R,Cont)*b.toma(Tb,Cont,C);
}
}
}
};
/*Suma entre dos matrices pertenecientes a un vector*/
void mtrx::matrix::suma(int T, int Ta, int Tb, matrix a, matrix b)
{
int C=0,R=0;
int Rt=(int)Mvector[T].size(), Ct=(int)Mvector[T][R].size(),;
for(R=0;R<Rt;R++) //renglon
{
for(C=0;C<Ct;C++) //columna
{
Mvector[T][R][C]=a.toma(Ta,R,C)+b.toma(Tb,R,C);
}
}
};
/*Resta entre dos matrices pertenecientes a un vector*/
void mtrx::matrix::resta(int T, int Ta, int Tb, matrix a, matrix b)
{
int C=0,R=0;
int Rt=(int)Mvector[T].size(), Ct=(int)Mvector[T][R].size(),;
for(R=0;R<Rt;R++) //renglon
{
for(C=0;C<Ct;C++) //columna
{
Mvector[T][R][C]=a.toma(Ta,R,C)-b.toma(Tb,R,C);
}
}
};
/*Asignación de valores a los elementos de una matriz perteneciente a un vector*/
void mtrx::matrix::asig(float x,int T, int R, int C)
{
Mvector[T][R][C]=x;
};
/*Division entre una matriz perteneciente a un vector y un escalar*/
void mtrx::matrix::div_sca(int T, int Ta, matrix a, float x)
{
int R=0;
int Rt=(int)Mvector[T].size(), Ct=(int)Mvector[T][R].size(),;
for (int j=0;j<Rt;++j)
{
for (int k=0;k<Ct;++k)
Mvector[T][j][k]=a.toma(Ta,j,k)/x;
}
}
/*Toma y regresa el valor de un elemento que se encuentre en una matriz perteneciente a un vector*/
float mtrx::matrix::toma(int T, int R, int C)
{
return Mvector[T][R][C];
};
/*Transpuesta de una matriz perteneciente a un vector*/
mtrx::matrix mtrx::matrix::trans(int T)
{
mtrx::matrix tmp;
int C=(int)Mvector[T].size(); //intercambio renglon-conlumna por columna-renglon
int R=(int)Mvector[T][C-1].size();
tmp.dim(T+1,R,C); //T+1 por que el redimencionamiento no comienza de cero.
for (int ren=0;ren<R;++ren)
{
for (int col=0;col<C;++col)
tmp.asig((float)Mvector[T][col][ren],T,ren,col);
}
return tmp;
}
----------------------------------------------------------------------------------
