Page Menu
Home
c4science
Search
Configure Global Search
Log In
Files
F78663804
DenseVector.h
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
Thu, Aug 22, 06:46
Size
5 KB
Mime Type
text/x-c++
Expires
Sat, Aug 24, 06:46 (2 d)
Engine
blob
Format
Raw Data
Handle
20082907
Attached To
rLAMMPS lammps
DenseVector.h
View Options
#ifndef DENSEVECTOR_H
#define DENSEVECTOR_H
#include "Vector.h"
namespace
ATC_matrix
{
template
<
typename
T
>
/**
* @class DenseVector
* @brief Class for storing data in a "dense" vector form
*/
class
DenseVector
:
public
Vector
<
T
>
{
public:
explicit
DenseVector
(
INDEX
n
=
0
,
bool
z
=
1
)
{
_create
(
n
,
z
);
}
DenseVector
(
const
DenseVector
<
T
>
&
c
)
:
Vector
<
T
>
(),
_data
(
NULL
)
{
_copy
(
c
);
}
DenseVector
(
const
Vector
<
T
>
&
c
)
:
Vector
<
T
>
(),
_data
(
NULL
)
{
_copy
(
c
);
}
DenseVector
(
const
T
*
ptr
,
INDEX
nrows
)
:
Vector
<
T
>
(),
_data
(
NULL
)
{
copy
(
ptr
,
nrows
);
}
virtual
~
DenseVector
()
{
_delete
();
}
//* resizes the Vector, ignores nCols, optionally copys what fits
void
resize
(
INDEX
rows
,
INDEX
cols
=
1
,
bool
copy
=
false
);
//* resizes the Vector, ignores nCols, optionally zeros it out
void
reset
(
INDEX
rows
,
INDEX
cols
=
1
,
bool
zero
=
true
);
//* resizes the Vector and copies data, ignores nCols
void
copy
(
const
T
*
ptr
,
INDEX
rows
,
INDEX
cols
=
1
);
// overloaded inline virtual functions
T
operator
[](
INDEX
i
)
const
{
VICK
(
i
)
return
_data
[
i
];
}
T
&
operator
[](
INDEX
i
)
{
VICK
(
i
)
return
_data
[
i
];
}
T
operator
()(
INDEX
i
,
INDEX
j
=
0
)
const
{
VICK
(
i
)
return
_data
[
i
];
}
T
&
operator
()(
INDEX
i
,
INDEX
j
=
0
)
{
VICK
(
i
)
return
_data
[
i
];
}
void
set_all_elements_to
(
const
T
&
v
)
{
int
sz
=
this
->
size
();
for
(
INDEX
i
=
0
;
i
<
sz
;
i
++
)
_data
[
i
]
=
v
;
}
INDEX
nRows
()
const
{
return
_size
;
}
T
*
ptr
()
const
{
return
_data
;
}
DenseVector
<
T
>&
operator
=
(
const
T
&
v
);
DenseVector
<
T
>&
operator
=
(
const
Vector
<
T
>
&
c
);
DenseVector
<
T
>&
operator
=
(
const
DenseVector
<
T
>
&
c
);
void
write_restart
(
FILE
*
f
)
const
;
private:
void
_delete
();
void
_create
(
INDEX
n
,
bool
zero
=
0
);
void
_copy
(
const
Vector
<
T
>
&
c
);
T
*
_data
;
INDEX
_size
;
};
///////////////////////////////////////////////////////////////////////////////
// Template definitions ///////////////////////////////////////////////////////
//-----------------------------------------------------------------------------
// resizes the matrix and optionally copies over what still fits, ignores cols
//-----------------------------------------------------------------------------
template
<
typename
T
>
void
DenseVector
<
T
>::
resize
(
INDEX
rows
,
INDEX
cols
,
bool
copy
)
{
if
(
_size
==
rows
)
return
;
// if is correct size, done
if
(
!
copy
)
{
_delete
();
_create
(
rows
);
return
;
}
DenseVector
<
T
>
temp
(
*
this
);
_delete
();
_create
(
rows
);
int
sz
=
this
->
size
();
for
(
INDEX
i
=
0
;
i
<
sz
;
i
++
)
_data
[
i
]
=
i
<
temp
.
size
()
?
temp
[
i
]
:
T
(
0.0
);
return
;
}
///////////////////////////////////////////////////////////////////////////////
//* resizes the matrix and optionally zeros it out
template
<
typename
T
>
void
DenseVector
<
T
>::
reset
(
INDEX
rows
,
INDEX
cols
,
bool
zero
)
{
if
(
_size
!=
rows
)
{
_delete
();
_create
(
rows
);
}
if
(
zero
)
this
->
zero
();
}
///////////////////////////////////////////////////////////////////////////////
//* resizes the matrix and optionally zeros it out
template
<
typename
T
>
void
DenseVector
<
T
>::
copy
(
const
T
*
ptr
,
INDEX
rows
,
INDEX
cols
)
{
resize
(
rows
,
1
,
false
);
memcpy
(
_data
,
ptr
,
this
->
size
()
*
sizeof
(
T
));
}
///////////////////////////////////////////////////////////////////////////////
//* writes the matrix data to a file
template
<
typename
T
>
void
DenseVector
<
T
>::
write_restart
(
FILE
*
f
)
const
{
fwrite
(
&
_size
,
sizeof
(
INDEX
),
1
,
f
);
if
(
_size
)
fwrite
(
_data
,
sizeof
(
T
),
_size
,
f
);
}
///////////////////////////////////////////////////////////////////////////////
//* clears allocated memory
template
<
typename
T
>
inline
void
DenseVector
<
T
>::
_delete
()
{
if
(
_data
)
delete
[]
_data
;
_size
=
0
;
}
///////////////////////////////////////////////////////////////////////////////
//* allocates memory for an rows by cols DenseMatrix
template
<
typename
T
>
inline
void
DenseVector
<
T
>::
_create
(
INDEX
n
,
bool
zero
)
{
_size
=
n
;
_data
=
_size
?
new
T
[
_size
]
:
NULL
;
if
(
zero
)
this
->
zero
();
}
///////////////////////////////////////////////////////////////////////////////
//* creates a deep memory copy from a general matrix
template
<
typename
T
>
inline
void
DenseVector
<
T
>::
_copy
(
const
Vector
<
T
>
&
c
)
{
if
(
!
_data
||
_size
!=
c
.
size
())
{
_delete
();
_create
(
c
.
size
(),
false
);
}
else
_size
=
c
.
size
();
memcpy
(
_data
,
c
.
ptr
(),
_size
*
sizeof
(
T
));
}
///////////////////////////////////////////////////////////////////////////////
//* assigns v to all values in the vector
template
<
typename
T
>
DenseVector
<
T
>&
DenseVector
<
T
>::
operator
=
(
const
T
&
v
)
{
int
sz
=
this
->
size
();
for
(
INDEX
i
=
0
;
i
<
sz
;
i
++
)
(
*
this
)[
i
]
=
v
;
return
*
this
;
}
///////////////////////////////////////////////////////////////////////////////
//* copys c with a deep copy
template
<
typename
T
>
DenseVector
<
T
>&
DenseVector
<
T
>::
operator
=
(
const
Vector
<
T
>
&
c
)
{
_copy
(
c
);
return
*
this
;
}
///////////////////////////////////////////////////////////////////////////////
//* copys c with a deep copy
template
<
typename
T
>
DenseVector
<
T
>&
DenseVector
<
T
>::
operator
=
(
const
DenseVector
<
T
>
&
c
)
{
_copy
(
c
);
return
*
this
;
}
}
// end namespace
#endif
Event Timeline
Log In to Comment