Page Menu
Home
c4science
Search
Configure Global Search
Log In
Files
F75790061
main_cormat.cpp
No One
Temporary
Actions
Download File
Edit File
Delete File
View Transforms
Subscribe
Mute Notifications
Award Token
Subscribers
None
File Metadata
Details
File Info
Storage
Attached
Created
Sun, Aug 4, 07:15
Size
8 KB
Mime Type
text/x-c
Expires
Tue, Aug 6, 07:15 (2 d)
Engine
blob
Format
Raw Data
Handle
19608953
Attached To
R8820 scATAC-seq
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
Log In to Comment