Dev - C++ - Manejo de objetos

   
Vista:

Manejo de objetos

Publicado por Sodor (4 intervenciones) el 09/06/2010 00:12:35
Buen día, tengo el siguiente problema: Desarrolle un algoritmo en C++ que usa el filtro Kalman para realizar algunos cálculos, ese código lo desarrolle en base a uno que previamente hice en MATLAB, el problema esta en que cuando corro el ejecutable tarda como 15 segundos en procesar 1334 datos, cuando MATLAB tarda a lo mucho 1 segundo, esto me confunde por que tengo entendido que debería de haber corrido mas rápido el ejecutable que el MATLAB mismo.

Un maestro me indica que los culpables de ese lento funcionamiento son los objetos, como yo cree una clase para manejo de vectores de matrices (suma, resta, multiplicación, etc), me dice que puede que eso provoque la lentitud y que mejor haga el programa en C usando solo arrays y estructuras en vez de usar clases y objetos.

Sinceramente de momento tendré que pasar el código a C sin usar clases y objetos para probar, pero aun así quiero saber si es verdad que los objetos son el causante, o si hay alguna forma de remediar el problema.
Valora esta pregunta
Me gusta: Está pregunta es útil y esta claraNo me gusta: Está pregunta no esta clara o no es útil
0
Responder

RE:Manejo de objetos

Publicado por Capitan Kirk (44 intervenciones) el 11/06/2010 14:42:36
Por lo poco que sé de C++, creo que tu maestro tiene razón. Si en la clase que has implementado tienes, por ejemplo, asignaciones que supongan copias de matrices (o sea, de todos sus datos), o asignaciones de memoria dinámica dentro de funciones que sean llamadas con frecuencia, sí que puede suponer una sobrecarga significativa del sistema. Aunque no he visto tu código, pienso que el remedio sería reescribir el código evitando lo que he citado más arriba, y creo que el resultado se parecería bastante a código C.

Saludos,
Valora esta respuesta
Me gusta: Está respuesta es útil y esta claraNo me gusta: Está respuesta no esta clara o no es útil
0
Comentar

RE:Manejo de objetos

Publicado por Sodor (4 intervenciones) el 11/06/2010 22:10:49
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;
}
----------------------------------------------------------------------------------
Valora esta respuesta
Me gusta: Está respuesta es útil y esta claraNo me gusta: Está respuesta no esta clara o no es útil
0
Comentar