Page MenuHomec4science
Files F62595319

main_cormat.cpp
No OneTemporary
Actions

File Metadata

Created
Tue, May 14, 05:44

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()
{
/*
Matrix2D<int> m ;
// move assignment operator
m = Matrix2D<int>(2, 3, 9) ;
int b = 1 ;
for(size_t i=0; i<m.get_dim()[0]; i++)
{ for(size_t j=0; j<m.get_dim()[1]; j++)
{ m(i,j) = b ; b++ ; }
}
std::cout << m << std::endl ;
// copy constructor
Matrix2D<int> m2(m) ;
std::cout << m2 << std::endl ;
// move constructor
Matrix2D<int> m3(std::move(m)) ;
std::cout << m3 << std::endl ;
std::cout << (m2 == m3) << std::endl ;
*/
/*
Matrix3D<int> m ;
// move assignment operator
m = Matrix3D<int>(2, 3, 4, 9) ;
int b = 1 ;
for(size_t i=0; i<m.get_dim()[0]; i++)
{ for(size_t j=0; j<m.get_dim()[1]; j++)
{ for(size_t k=0; k<m.get_dim()[2]; k++)
{ m(i,j,k) = b ; b++ ; }
}
}
std::cout << m << std::endl ;
// copy constructor
Matrix3D<int> m2(m) ;
std::cout << m2 << std::endl ;
// move constructor
Matrix3D<int> m3(std::move(m)) ;
std::cout << m3 << std::endl ;
std::cout << (m2 == m3) << std::endl ;
*/
/*
Matrix4D<int> m ;
// move assignment operator
m = Matrix4D<int>(2, 3, 4, 2, 9) ;
int b = 1 ;
for(size_t i=0; i<m.get_dim()[0]; i++)
{ for(size_t j=0; j<m.get_dim()[1]; j++)
{ for(size_t k=0; k<m.get_dim()[2]; k++)
{ for(size_t l=0; l<m.get_dim()[3]; l++)
{ m(i,j,k,l) = b ; b++ ; }
}
}
}
std::cout << m << std::endl ;
// copy constructor
Matrix4D<int> m2(m) ;
std::cout << m2 << std::endl ;
// move constructor
Matrix4D<int> m3(std::move(m)) ;
std::cout << m3 << std::endl ;
std::cout << (m2 == m3) << std::endl ;
*/
return 0;
}

Event Timeline

c4science · Help