Page MenuHomec4science
Files F61269934

main_cormat.cpp
No OneTemporary
Actions

File Metadata

Created
Sun, May 5, 14:51

main_cormat.cpp
View Options

#include <iostream>
#include <utility>
#include <vector>
#include <string>
#include <boost/date_time/posix_time/ptime.hpp>
#include <boost/date_time/microsec_time_clock.hpp>
#include <Matrix2D.hpp>
#include <Matrix3D.hpp>
#include <Matrix4D.hpp>
#include <Random.hpp>
class TestTimer
{
public:
TestTimer(const std::string & name) : name(name),
start(boost::date_time::microsec_clock<boost::posix_time::ptime>::local_time())
{
}
~TestTimer()
{
using namespace std;
using namespace boost;
posix_time::ptime now(date_time::microsec_clock<posix_time::ptime>::local_time());
posix_time::time_duration d = now - start;
cout << name << " completed in " << d.total_milliseconds() / 1000.0 <<
" seconds" << endl;
}
private:
std::string name;
boost::posix_time::ptime start;
};
void f_vector2d(size_t nrow, size_t ncol)
{ std::vector<std::vector<int>> m ;
{ TestTimer timer("f_vector2d init") ;
m = std::vector<std::vector<int>>(nrow,
std::vector<int>(ncol, 0.)) ;
for(size_t i=0; i<nrow; i++)
{ for(size_t j=0; j<ncol; j++)
{ m[i][j] = 0. ; }
}
}
{ TestTimer timer("f_vector2d writting") ;
for(size_t i=0; i<nrow; i++)
{ for(size_t j=0; j<ncol; j++)
{ m[i][j] = i*j ; }
}
}
{ TestTimer timer("f_vector2d reading") ;
for(size_t i=0; i<nrow; i++)
{ for(size_t j=0; j<ncol; j++)
{ if(m[i][j]) {;} }
}
}
}
void f_matrix2d(size_t nrow, size_t ncol)
{ Matrix2D<int> m ;
{ TestTimer timer("f_matrix2d init") ;
m = Matrix2D<int>(nrow, ncol, 0.) ;
}
{ TestTimer timer("f_matrix2d writting") ;
for(size_t i=0; i<nrow; i++)
{ for(size_t j=0; j<ncol; j++)
{ m(i,j) = i*j ; }
}
}
{ TestTimer timer("f_matrix2d reading") ;
for(size_t i=0; i<nrow; i++)
{ for(size_t j=0; j<ncol; j++)
{ if(m(i,j)) {;} }
}
}
}
void f_vector3d(size_t dim1, size_t dim2, size_t dim3)
{ std::vector<std::vector<std::vector<int>>> m ;
{ TestTimer timer("f_vector3d init") ;
m = std::vector<std::vector<std::vector<int>>>(dim1,
std::vector<std::vector<int>>(dim2,
std::vector<int>(dim3,0.))) ;
for(size_t i=0; i<dim1; i++)
{ for(size_t j=0; j<dim2; j++)
{ for(size_t k=0; k<dim3; k++)
{ m[i][j][k] = 0. ; }
}
}
}
{ TestTimer timer("f_vector3d writting") ;
for(size_t i=0; i<dim1; i++)
{ for(size_t j=0; j<dim2; j++)
{ for(size_t k=0; k<dim3; k++)
{ m[i][j][k] = i*j*k ; }
}
}
}
{ TestTimer timer("f_vector3d reading") ;
for(size_t i=0; i<dim1; i++)
{ for(size_t j=0; j<dim2; j++)
{ for(size_t k=0; k<dim3; k++)
{ if(m[i][j][k]) {;} }
}
}
}
}
void f_matrix3d(size_t dim1, size_t dim2, size_t dim3)
{ Matrix3D<int> m ;
{ TestTimer timer("f_matrix3d init") ;
m = Matrix3D<int>(dim1, dim2, dim3) ;
for(size_t i=0; i<dim1; i++)
{ for(size_t j=0; j<dim2; j++)
{ for(size_t k=0; k<dim3; k++)
{ m(i,j,k) = 0. ; }
}
}
}
{ TestTimer timer("f_matrix3d writting") ;
for(size_t i=0; i<dim1; i++)
{ for(size_t j=0; j<dim2; j++)
{ for(size_t k=0; k<dim3; k++)
{ m(i,j,k) = i*j*k ; }
}
}
}
{ TestTimer timer("f_matrix3d reading") ;
for(size_t i=0; i<dim1; i++)
{ for(size_t j=0; j<dim2; j++)
{ for(size_t k=0; k<dim3; k++)
{ if(m(i,j,k)) {;} }
}
}
}
}
void f_vector4d(size_t dim1, size_t dim2, size_t dim3, size_t dim4)
{ std::vector<std::vector<std::vector<std::vector<int>>>> m ;
{ TestTimer timer("f_vector4d init") ;
m = std::vector<std::vector<std::vector<std::vector<int>>>>(dim1,
std::vector<std::vector<std::vector<int>>>(dim2,
std::vector<std::vector<int>>(dim3,
std::vector<int>(dim4, 0)))) ;
for(size_t i=0; i<dim1; i++)
{ for(size_t j=0; j<dim2; j++)
{ for(size_t k=0; k<dim3; k++)
{ for(size_t l=0; l<dim4; l++)
{ m[i][j][k][l] = 0. ; }
}
}
}
}
{ TestTimer timer("f_vector4d writting") ;
for(size_t i=0; i<dim1; i++)
{ for(size_t j=0; j<dim2; j++)
{ for(size_t k=0; k<dim3; k++)
{ for(size_t l=0; l<dim4; l++)
{ m[i][j][k][l] = i*j*k*l ; }
}
}
}
}
{ TestTimer timer("f_vector4d reading") ;
for(size_t i=0; i<dim1; i++)
{ for(size_t j=0; j<dim2; j++)
{ for(size_t k=0; k<dim3; k++)
{ for(size_t l=0; l<dim4; l++)
{ if(m[i][j][k][l]) {;} }
}
}
}
}
}
void f_matrix4d(size_t dim1, size_t dim2, size_t dim3, size_t dim4)
{ Matrix4D<int> m ;
{ TestTimer timer("f_matrix4d init") ;
m = Matrix4D<int>(dim1, dim2, dim3,dim4, 0) ;
for(size_t i=0; i<dim1; i++)
{ for(size_t j=0; j<dim2; j++)
{ for(size_t k=0; k<dim3; k++)
{ for(size_t l=0; l<dim4; l++)
{ m(i,j,k,l) = 0. ; }
}
}
}
}
{ TestTimer timer("f_matrix4d writting") ;
for(size_t i=0; i<dim1; i++)
{ for(size_t j=0; j<dim2; j++)
{ for(size_t k=0; k<dim3; k++)
{ for(size_t l=0; l<dim4; l++)
{ m(i,j,k,l) = i*j*k*l ; }
}
}
}
}
{ TestTimer timer("f_matrix4d reading") ;
for(size_t i=0; i<dim1; i++)
{ for(size_t j=0; j<dim2; j++)
{ for(size_t k=0; k<dim3; k++)
{ for(size_t l=0; l<dim4; l++)
{ if(m(i,j,k,l)) {;} }
}
}
}
}
}
int main()
{ /*
TestTimer timer("main") ;
size_t nrow = 10000 ;
size_t ncol = 10000 ;
f_vector2d(nrow, ncol) ;
f_matrix2d(nrow, ncol) ;
size_t dim1 = 100 ;
size_t dim2 = 100 ;
size_t dim3 = 10 ;
size_t dim4 = 10 ;
f_vector3d(dim1, dim2, dim3) ;
f_matrix3d(dim1, dim2, dim3) ;
f_vector4d(dim1, dim2, dim3, dim4) ;
f_matrix4d(dim1, dim2, dim3, dim4) ;
*/
std::cout << "main START" << std::endl ;
Matrix2D<double> m2 ;
m2 = Matrix2D<double>(10, 10) ;
Matrix3D<double> m3 ;
m3 = Matrix3D<double>(10, 10, 10) ;
Matrix4D<double> m4 ;
m4 = Matrix4D<double>(10, 10, 10, 10) ;
std::cout << "main END" << std::endl ;
return 0;
}

Event Timeline

c4science · Help