//! More...
Classes | |
class | Cube< eT > |
Dense cube class. More... | |
class | Cube_aux |
Functions | |
Cube::~Cube () | |
Cube::Cube () | |
Cube::Cube (const u32 in_rows, const u32 in_cols, const u32 in_slices) | |
construct the cube to have user specified dimensions | |
void | Cube::init (const u32 in_rows, const u32 in_cols, const u32 in_slices) |
internal cube construction; if the requested size is small enough, memory from the stack is used. //! otherwise memory is allocated via 'new' | |
void | Cube::delete_mat () |
void | Cube::create_mat () |
arma_inline const Cube & | Cube::operator= (const eT val) |
Set the cube to be equal to the specified scalar. //! NOTE: the size of the cube will be 1x1x1. | |
arma_inline const Cube & | Cube::operator+= (const eT val) |
In-place addition of a scalar to all elements of the cube. | |
arma_inline const Cube & | Cube::operator-= (const eT val) |
In-place subtraction of a scalar from all elements of the cube. | |
arma_inline const Cube & | Cube::operator*= (const eT val) |
In-place multiplication of all elements of the cube with a scalar. | |
arma_inline const Cube & | Cube::operator/= (const eT val) |
In-place division of all elements of the cube with a scalar. | |
Cube::Cube (const Cube &m) | |
construct a cube from a given cube | |
const Cube & | Cube::operator= (const Cube &m) |
construct a cube from a given cube | |
void | Cube::init (const Cube &x) |
construct a cube from a given cube | |
Cube::Cube (eT *aux_mem, const u32 aux_n_rows, const u32 aux_n_cols, const u32 aux_n_slices, const bool copy_aux_mem=true) | |
construct a cube from a given auxiliary array of eTs. //! if copy_aux_mem is true, new memory is allocated and the array is copied. //! if copy_aux_mem is false, the auxiliary array is used directly (without allocating memory and copying). //! note that in the latter case //! the default is to copy the array. | |
Cube::Cube (const eT *aux_mem, const u32 aux_n_rows, const u32 aux_n_cols, const u32 aux_n_slices) | |
construct a cube from a given auxiliary read-only array of eTs. //! the array is copied. | |
const Cube & | Cube::operator+= (const Cube &m) |
in-place cube addition | |
const Cube & | Cube::operator-= (const Cube &m) |
in-place cube subtraction | |
const Cube & | Cube::operator%= (const Cube &m) |
in-place element-wise cube multiplication | |
const Cube & | Cube::operator/= (const Cube &m) |
in-place element-wise cube division | |
template<typename T1 , typename T2 > | |
Cube::Cube (const BaseCube< typename Cube< eT >::pod_type, T1 > &A, const BaseCube< typename Cube< eT >::pod_type, T2 > &B) | |
for constructing a complex cube out of two non-complex cubes | |
Cube::Cube (const subview_cube< eT > &X) | |
construct a cube from a subview_cube instance (e.g. construct a cube from a delayed subcube operation) | |
const Cube & | Cube::operator= (const subview_cube< eT > &X) |
construct a cube from a subview_cube instance (e.g. construct a cube from a delayed subcube operation) | |
const Cube & | Cube::operator+= (const subview_cube< eT > &X) |
in-place cube addition (using a subcube on the right-hand-side) | |
const Cube & | Cube::operator-= (const subview_cube< eT > &X) |
in-place cube subtraction (using a subcube on the right-hand-side) | |
const Cube & | Cube::operator%= (const subview_cube< eT > &X) |
in-place element-wise cube mutiplication (using a subcube on the right-hand-side) | |
const Cube & | Cube::operator/= (const subview_cube< eT > &X) |
in-place element-wise cube division (using a subcube on the right-hand-side) | |
arma_inline Mat< eT > & | Cube::slice (const u32 in_slice) |
provide the reference to the matrix representing a single slice | |
arma_inline const Mat< eT > & | Cube::slice (const u32 in_slice) const |
provide the reference to the matrix representing a single slice | |
arma_inline subview_cube< eT > | Cube::slices (const u32 in_slice1, const u32 in_slice2) |
creation of subview_cube (subcube comprised of specified slices) | |
arma_inline const subview_cube < eT > | Cube::slices (const u32 in_slice1, const u32 in_slice2) const |
creation of subview_cube (subcube comprised of specified slices) | |
arma_inline subview_cube< eT > | Cube::subcube (const u32 in_row1, const u32 in_col1, const u32 in_slice1, const u32 in_row2, const u32 in_col2, const u32 in_slice2) |
creation of subview_cube (generic subcube) | |
arma_inline const subview_cube < eT > | Cube::subcube (const u32 in_row1, const u32 in_col1, const u32 in_slice1, const u32 in_row2, const u32 in_col2, const u32 in_slice2) const |
creation of subview_cube (generic subcube) | |
template<typename T1 , typename op_type > | |
Cube::Cube (const OpCube< T1, op_type > &X) | |
create a cube from OpCube, i.e. run the previously delayed unary operations | |
template<typename T1 , typename op_type > | |
const Cube & | Cube::operator= (const OpCube< T1, op_type > &X) |
create a cube from OpCube, i.e. run the previously delayed unary operations | |
template<typename T1 , typename op_type > | |
const Cube & | Cube::operator+= (const OpCube< T1, op_type > &X) |
in-place cube addition, with the right-hand-side operand having delayed operations | |
template<typename T1 , typename op_type > | |
const Cube & | Cube::operator-= (const OpCube< T1, op_type > &X) |
in-place cube subtraction, with the right-hand-side operand having delayed operations | |
template<typename T1 , typename op_type > | |
const Cube & | Cube::operator%= (const OpCube< T1, op_type > &X) |
in-place cube element-wise multiplication, with the right-hand-side operand having delayed operations | |
template<typename T1 , typename op_type > | |
const Cube & | Cube::operator/= (const OpCube< T1, op_type > &X) |
in-place cube element-wise division, with the right-hand-side operand having delayed operations | |
template<typename T1 , typename eop_type > | |
Cube::Cube (const eOpCube< T1, eop_type > &X) | |
create a cube from eOpCube, i.e. run the previously delayed unary operations | |
template<typename T1 , typename eop_type > | |
const Cube & | Cube::operator= (const eOpCube< T1, eop_type > &X) |
create a cube from eOpCube, i.e. run the previously delayed unary operations | |
template<typename T1 , typename eop_type > | |
const Cube & | Cube::operator+= (const eOpCube< T1, eop_type > &X) |
in-place cube addition, with the right-hand-side operand having delayed operations | |
template<typename T1 , typename eop_type > | |
const Cube & | Cube::operator-= (const eOpCube< T1, eop_type > &X) |
in-place cube subtraction, with the right-hand-side operand having delayed operations | |
template<typename T1 , typename eop_type > | |
const Cube & | Cube::operator%= (const eOpCube< T1, eop_type > &X) |
in-place cube element-wise multiplication, with the right-hand-side operand having delayed operations | |
template<typename T1 , typename eop_type > | |
const Cube & | Cube::operator/= (const eOpCube< T1, eop_type > &X) |
in-place cube element-wise division, with the right-hand-side operand having delayed operations | |
template<typename T1 , typename T2 , typename glue_type > | |
Cube::Cube (const GlueCube< T1, T2, glue_type > &X) | |
create a cube from Glue, i.e. run the previously delayed binary operations | |
template<typename T1 , typename T2 , typename glue_type > | |
const Cube & | Cube::operator= (const GlueCube< T1, T2, glue_type > &X) |
create a cube from Glue, i.e. run the previously delayed binary operations | |
template<typename T1 , typename T2 , typename glue_type > | |
const Cube & | Cube::operator+= (const GlueCube< T1, T2, glue_type > &X) |
in-place cube addition, with the right-hand-side operands having delayed operations | |
template<typename T1 , typename T2 , typename glue_type > | |
const Cube & | Cube::operator-= (const GlueCube< T1, T2, glue_type > &X) |
in-place cube subtraction, with the right-hand-side operands having delayed operations | |
template<typename T1 , typename T2 , typename glue_type > | |
const Cube & | Cube::operator%= (const GlueCube< T1, T2, glue_type > &X) |
in-place cube element-wise multiplication, with the right-hand-side operands having delayed operations | |
template<typename T1 , typename T2 , typename glue_type > | |
const Cube & | Cube::operator/= (const GlueCube< T1, T2, glue_type > &X) |
in-place cube element-wise division, with the right-hand-side operands having delayed operations | |
template<typename T1 , typename T2 , typename eglue_type > | |
Cube::Cube (const eGlueCube< T1, T2, eglue_type > &X) | |
create a cube from eGlue, i.e. run the previously delayed binary operations | |
template<typename T1 , typename T2 , typename eglue_type > | |
const Cube & | Cube::operator= (const eGlueCube< T1, T2, eglue_type > &X) |
create a cube from Glue, i.e. run the previously delayed binary operations | |
template<typename T1 , typename T2 , typename eglue_type > | |
const Cube & | Cube::operator+= (const eGlueCube< T1, T2, eglue_type > &X) |
in-place cube addition, with the right-hand-side operands having delayed operations | |
template<typename T1 , typename T2 , typename eglue_type > | |
const Cube & | Cube::operator-= (const eGlueCube< T1, T2, eglue_type > &X) |
in-place cube subtraction, with the right-hand-side operands having delayed operations | |
template<typename T1 , typename T2 , typename eglue_type > | |
const Cube & | Cube::operator%= (const eGlueCube< T1, T2, eglue_type > &X) |
in-place cube element-wise multiplication, with the right-hand-side operands having delayed operations | |
template<typename T1 , typename T2 , typename eglue_type > | |
const Cube & | Cube::operator/= (const eGlueCube< T1, T2, eglue_type > &X) |
in-place cube element-wise division, with the right-hand-side operands having delayed operations | |
arma_inline eT & | Cube::operator() (const u32 i) |
linear element accessor (treats the cube as a vector); bounds checking not done when ARMA_NO_DEBUG is defined | |
arma_inline eT | Cube::operator() (const u32 i) const |
linear element accessor (treats the cube as a vector); bounds checking not done when ARMA_NO_DEBUG is defined | |
arma_inline eT & | Cube::operator[] (const u32 i) |
linear element accessor (treats the cube as a vector); no bounds check. | |
arma_inline eT | Cube::operator[] (const u32 i) const |
linear element accessor (treats the cube as a vector); no bounds check | |
arma_inline eT & | Cube::operator() (const u32 in_row, const u32 in_col, const u32 in_slice) |
element accessor; bounds checking not done when ARMA_NO_DEBUG is defined | |
arma_inline eT | Cube::operator() (const u32 in_row, const u32 in_col, const u32 in_slice) const |
element accessor; bounds checking not done when ARMA_NO_DEBUG is defined | |
arma_inline eT & | Cube::at (const u32 in_row, const u32 in_col, const u32 in_slice) |
element accessor; no bounds check | |
arma_inline eT | Cube::at (const u32 in_row, const u32 in_col, const u32 in_slice) const |
element accessor; no bounds check | |
arma_inline const Cube & | Cube::operator++ () |
prefix ++ | |
arma_inline void | Cube::operator++ (int) |
postfix ++ (must not return the object by reference) | |
arma_inline const Cube & | Cube::operator-- () |
prefix -- | |
arma_inline void | Cube::operator-- (int) |
postfix -- (must not return the object by reference) | |
arma_inline bool | Cube::is_finite () const |
returns true if all of the elements are finite | |
arma_inline eT * | Cube::memptr () |
returns a pointer to array of eTs used by the cube | |
arma_inline const eT * | Cube::memptr () const |
returns a pointer to array of eTs used by the cube | |
arma_inline eT * | Cube::slice_memptr (const u32 slice) |
returns a pointer to array of eTs used by the specified slice in the cube | |
arma_inline const eT * | Cube::slice_memptr (const u32 slice) const |
returns a pointer to array of eTs used by the specified slice in the cube | |
arma_inline eT * | Cube::slice_colptr (const u32 in_slice, const u32 in_col) |
returns a pointer to array of eTs used by the specified slice in the cube | |
arma_inline const eT * | Cube::slice_colptr (const u32 in_slice, const u32 in_col) const |
returns a pointer to array of eTs used by the specified slice in the cube | |
void | Cube::print (const std::string extra_text="") const |
print contents of the cube (to the cout stream), //! optionally preceding with a user specified line of text. //! the precision and cell width are modified. //! on return, the stream's flags are restored to their original values. | |
void | Cube::print (std::ostream &user_stream, const std::string extra_text="") const |
print contents of the cube to a user specified stream, //! optionally preceding with a user specified line of text. //! the precision and cell width are modified. //! on return, the stream's flags are restored to their original values. | |
void | Cube::raw_print (const std::string extra_text="") const |
print contents of the cube (to the cout stream), //! optionally preceding with a user specified line of text. //! the stream's flags are used as is and are not modified //! (i.e. the precision and cell width are not modified). | |
void | Cube::raw_print (std::ostream &user_stream, const std::string extra_text="") const |
print contents of the cube to a user specified stream, //! optionally preceding with a user specified line of text. //! the stream's flags are used as is and are not modified. //! (i.e. the precision and cell width are not modified). | |
void | Cube::set_size (const u32 in_rows, const u32 in_cols, const u32 in_slices) |
change the cube to have user specified dimensions (data is not preserved) | |
template<typename eT2 > | |
void | Cube::copy_size (const Cube< eT2 > &m) |
change the cube (without preserving data) to have the same dimensions as the given cube | |
void | Cube::fill (const eT val) |
fill the cube with the specified value | |
void | Cube::zeros () |
void | Cube::zeros (const u32 in_rows, const u32 in_cols, const u32 in_slices) |
void | Cube::ones () |
void | Cube::ones (const u32 in_rows, const u32 in_cols, const u32 in_slices) |
void | Cube::reset () |
bool | Cube::save (const std::string name, const file_type type=arma_binary, const bool print_status=true) const |
save the cube to a file | |
bool | Cube::save (std::ostream &os, const file_type type=arma_binary, const bool print_status=true) const |
save the cube to a stream | |
bool | Cube::load (const std::string name, const file_type type=auto_detect, const bool print_status=true) |
load a cube from a file | |
bool | Cube::load (std::istream &is, const file_type type=auto_detect, const bool print_status=true) |
load a cube from a stream | |
bool | Cube::quiet_save (const std::string name, const file_type type=arma_binary) const |
save the cube to a file, without printing any error messages | |
bool | Cube::quiet_save (std::ostream &os, const file_type type=arma_binary) const |
save the cube to a stream, without printing any error messages | |
bool | Cube::quiet_load (const std::string name, const file_type type=auto_detect) |
load a cube from a file, without printing any error messages | |
bool | Cube::quiet_load (std::istream &is, const file_type type=auto_detect) |
load a cube from a stream, without printing any error messages | |
iterator | Cube::begin () |
const_iterator | Cube::begin () const |
iterator | Cube::end () |
const_iterator | Cube::end () const |
slice_iterator | Cube::begin_slice (const u32 slice_num) |
const_slice_iterator | Cube::begin_slice (const u32 slice_num) const |
slice_iterator | Cube::end_slice (const u32 slice_num) |
const_slice_iterator | Cube::end_slice (const u32 slice_num) const |
template<typename eT > | |
static arma_inline void | Cube_aux::prefix_pp (Cube< eT > &x) |
prefix ++ | |
template<typename T > | |
static arma_inline void | Cube_aux::prefix_pp (Cube< std::complex< T > > &x) |
prefix ++ for complex numbers (work around for limitations of the std::complex class) | |
template<typename eT > | |
static arma_inline void | Cube_aux::postfix_pp (Cube< eT > &x) |
postfix ++ | |
template<typename T > | |
static arma_inline void | Cube_aux::postfix_pp (Cube< std::complex< T > > &x) |
postfix ++ for complex numbers (work around for limitations of the std::complex class) | |
template<typename eT > | |
static arma_inline void | Cube_aux::prefix_mm (Cube< eT > &x) |
prefix -- | |
template<typename T > | |
static arma_inline void | Cube_aux::prefix_mm (Cube< std::complex< T > > &x) |
prefix -- for complex numbers (work around for limitations of the std::complex class) | |
template<typename eT > | |
static arma_inline void | Cube_aux::postfix_mm (Cube< eT > &x) |
postfix -- | |
template<typename T > | |
static arma_inline void | Cube_aux::postfix_mm (Cube< std::complex< T > > &x) |
postfix ++ for complex numbers (work around for limitations of the std::complex class) |
//!
Definition at line 23 of file Cube_meat.hpp.
References arma_config::debug, Cube< eT >::delete_mat(), Cube< eT >::mat_ptrs, Cube< eT >::mem, Cube< eT >::mem_local, Cube< eT >::n_cols, Cube< eT >::n_elem, Cube< eT >::n_elem_slice, Cube< eT >::n_rows, Cube< eT >::n_slices, access::rw(), and Cube< eT >::use_aux_mem.
{ arma_extra_debug_sigprint_this(this); delete_mat(); if(use_aux_mem == false) { if(n_elem > sizeof(mem_local)/sizeof(eT) ) { delete [] mem; } } if(arma_config::debug == true) { // try to expose buggy user code that accesses deleted objects access::rw(n_rows) = 0; access::rw(n_cols) = 0; access::rw(n_elem_slice) = 0; access::rw(n_slices) = 0; access::rw(n_elem) = 0; access::rw(mat_ptrs) = 0; access::rw(mem) = 0; } isnt_supported_elem_type<eT>::check(); }
Definition at line 56 of file Cube_meat.hpp.
: n_rows(0) , n_cols(0) , n_elem_slice(0) , n_slices(0) , n_elem(0) , use_aux_mem(false) , mat_ptrs(mat_ptrs) , mem(mem) { arma_extra_debug_sigprint_this(this); }
Cube< eT >::Cube | ( | const u32 | in_rows, | |
const u32 | in_cols, | |||
const u32 | in_slices | |||
) | [inline, inherited] |
construct the cube to have user specified dimensions
Definition at line 74 of file Cube_meat.hpp.
References Cube< eT >::init().
void Cube< eT >::init | ( | const u32 | in_rows, | |
const u32 | in_cols, | |||
const u32 | in_slices | |||
) | [inline, protected, inherited] |
internal cube construction; if the requested size is small enough, memory from the stack is used. //! otherwise memory is allocated via 'new'
Definition at line 96 of file Cube_meat.hpp.
References arma_check(), Cube< eT >::create_mat(), Cube< eT >::delete_mat(), Cube< eT >::mem, Cube< eT >::mem_local, Cube< eT >::n_cols, Cube< eT >::n_elem, Cube< eT >::n_elem_slice, Cube< eT >::n_rows, Cube< eT >::n_slices, access::rw(), and Cube< eT >::use_aux_mem.
Referenced by Cube< eT >::copy_size(), Cube< eT >::Cube(), Cube< eT >::init(), Cube< eT >::operator=(), Cube< eT >::reset(), and Cube< eT >::set_size().
{ arma_extra_debug_sigprint( arma_boost::format("in_n_rows = %d, in_n_cols = %d, in_n_slices = %d") % in_n_rows % in_n_cols % in_n_slices ); const u32 new_n_elem = in_n_rows * in_n_cols * in_n_slices; if(n_elem == new_n_elem) { if( (n_rows != in_n_rows) || (n_cols != in_n_cols) || (n_slices != in_n_slices) ) { delete_mat(); access::rw(n_rows) = in_n_rows; access::rw(n_cols) = in_n_cols; access::rw(n_elem_slice) = in_n_rows*in_n_cols; access::rw(n_slices) = in_n_slices; create_mat(); } } else { arma_debug_check ( (use_aux_mem == true), "Cube::init(): can't change the amount of memory as auxiliary memory is in use" ); delete_mat(); if(n_elem > sizeof(mem_local)/sizeof(eT) ) { delete [] mem; } if(new_n_elem <= sizeof(mem_local)/sizeof(eT) ) { access::rw(mem) = mem_local; } else { access::rw(mem) = new(std::nothrow) eT[new_n_elem]; arma_check( (mem == 0), "Cube::init(): out of memory" ); } access::rw(n_elem) = new_n_elem; if(new_n_elem == 0) { access::rw(n_rows) = 0; access::rw(n_cols) = 0; access::rw(n_elem_slice) = 0; access::rw(n_slices) = 0; } else { access::rw(n_rows) = in_n_rows; access::rw(n_cols) = in_n_cols; access::rw(n_elem_slice) = in_n_rows*in_n_cols; access::rw(n_slices) = in_n_slices; } create_mat(); } }
void Cube< eT >::delete_mat | ( | ) | [inline, protected, inherited] |
Definition at line 166 of file Cube_meat.hpp.
References Cube< eT >::mat_ptrs, Cube< eT >::mat_ptrs_local, Cube< eT >::n_slices, access::rw(), and Cube< eT >::slice().
Referenced by Cube< eT >::init(), and Cube< eT >::~Cube().
{ arma_extra_debug_sigprint(); for(u32 slice = 0; slice < n_slices; ++slice) { delete access::rw(mat_ptrs[slice]); } if(n_slices > sizeof(mat_ptrs_local)/sizeof(Mat<eT>*) ) { delete [] mat_ptrs; } }
void Cube< eT >::create_mat | ( | ) | [inline, protected, inherited] |
Definition at line 186 of file Cube_meat.hpp.
References arma_check(), Cube< eT >::mat_ptrs, Cube< eT >::mat_ptrs_local, Cube< eT >::n_cols, Cube< eT >::n_rows, Cube< eT >::n_slices, access::rw(), Cube< eT >::slice(), and Cube< eT >::slice_memptr().
Referenced by Cube< eT >::Cube(), and Cube< eT >::init().
{ arma_extra_debug_sigprint(); if( n_slices <= sizeof(mat_ptrs_local)/sizeof(Mat<eT>*) ) { access::rw(mat_ptrs) = const_cast< const Mat<eT>** >(mat_ptrs_local); } else { access::rw(mat_ptrs) = new(std::nothrow) const Mat<eT>*[n_slices]; arma_check( (mat_ptrs == 0), "Cube::create_mat(): out of memory" ); } for(u32 slice = 0; slice < n_slices; ++slice) { mat_ptrs[slice] = new Mat<eT>('j', slice_memptr(slice), n_rows, n_cols); } }
arma_inline const Cube< eT > & Cube< eT >::operator= | ( | const eT | val | ) | [inherited] |
Set the cube to be equal to the specified scalar. //! NOTE: the size of the cube will be 1x1x1.
Definition at line 213 of file Cube_meat.hpp.
References Cube< eT >::init(), Cube< eT >::mem, and access::rw().
Referenced by Cube< eT >::Cube().
{ arma_extra_debug_sigprint(); init(1,1,1); access::rw(mem[0]) = val; return *this; }
arma_inline const Cube< eT > & Cube< eT >::operator+= | ( | const eT | val | ) | [inherited] |
In-place addition of a scalar to all elements of the cube.
Definition at line 228 of file Cube_meat.hpp.
References Cube< eT >::memptr(), and Cube< eT >::n_elem.
arma_inline const Cube< eT > & Cube< eT >::operator-= | ( | const eT | val | ) | [inherited] |
In-place subtraction of a scalar from all elements of the cube.
Definition at line 257 of file Cube_meat.hpp.
References Cube< eT >::memptr(), and Cube< eT >::n_elem.
arma_inline const Cube< eT > & Cube< eT >::operator*= | ( | const eT | val | ) | [inherited] |
In-place multiplication of all elements of the cube with a scalar.
Definition at line 286 of file Cube_meat.hpp.
References Cube< eT >::memptr(), and Cube< eT >::n_elem.
arma_inline const Cube< eT > & Cube< eT >::operator/= | ( | const eT | val | ) | [inherited] |
In-place division of all elements of the cube with a scalar.
Definition at line 315 of file Cube_meat.hpp.
References Cube< eT >::memptr(), and Cube< eT >::n_elem.
construct a cube from a given cube
Definition at line 343 of file Cube_meat.hpp.
References Cube< eT >::init().
: n_rows(0) , n_cols(0) , n_elem_slice(0) , n_slices(0) , n_elem(0) , use_aux_mem(false) , mat_ptrs(mat_ptrs) , mem(mem) { arma_extra_debug_sigprint(arma_boost::format("this = %x in_cube = %x") % this % &in_cube); init(in_cube); }
const Cube< eT > & Cube< eT >::operator= | ( | const Cube< eT > & | m | ) | [inline, inherited] |
construct a cube from a given cube
Definition at line 364 of file Cube_meat.hpp.
References Cube< eT >::init().
{ arma_extra_debug_sigprint(); init(x); return *this; }
void Cube< eT >::init | ( | const Cube< eT > & | x | ) | [inline, protected, inherited] |
construct a cube from a given cube
Definition at line 378 of file Cube_meat.hpp.
References syslib::copy_elem(), Cube< eT >::init(), Cube< eT >::mem, Cube< eT >::memptr(), Cube< eT >::n_cols, Cube< eT >::n_elem, Cube< eT >::n_rows, and Cube< eT >::n_slices.
Cube< eT >::Cube | ( | eT * | aux_mem, | |
const u32 | aux_n_rows, | |||
const u32 | aux_n_cols, | |||
const u32 | aux_n_slices, | |||
const bool | copy_aux_mem = true | |||
) | [inline, inherited] |
construct a cube from a given auxiliary array of eTs. //! if copy_aux_mem is true, new memory is allocated and the array is copied. //! if copy_aux_mem is false, the auxiliary array is used directly (without allocating memory and copying). //! note that in the latter case //! the default is to copy the array.
Definition at line 399 of file Cube_meat.hpp.
References syslib::copy_elem(), Cube< eT >::create_mat(), Cube< eT >::init(), Cube< eT >::memptr(), and Cube< eT >::n_elem.
: n_rows (copy_aux_mem ? 0 : aux_n_rows ) , n_cols (copy_aux_mem ? 0 : aux_n_cols ) , n_elem_slice(copy_aux_mem ? 0 : aux_n_rows*aux_n_cols ) , n_slices (copy_aux_mem ? 0 : aux_n_slices ) , n_elem (copy_aux_mem ? 0 : aux_n_rows*aux_n_cols*aux_n_slices) , use_aux_mem (copy_aux_mem ? false : true ) , mat_ptrs (mat_ptrs ) , mem (copy_aux_mem ? mem : aux_mem ) { arma_extra_debug_sigprint_this(this); if(copy_aux_mem == true) { init(aux_n_rows, aux_n_cols, aux_n_slices); syslib::copy_elem( memptr(), aux_mem, n_elem ); } else { create_mat(); } }
Cube< eT >::Cube | ( | const eT * | aux_mem, | |
const u32 | aux_n_rows, | |||
const u32 | aux_n_cols, | |||
const u32 | aux_n_slices | |||
) | [inline, inherited] |
construct a cube from a given auxiliary read-only array of eTs. //! the array is copied.
Definition at line 428 of file Cube_meat.hpp.
References syslib::copy_elem(), Cube< eT >::init(), Cube< eT >::memptr(), and Cube< eT >::n_elem.
: n_rows(0) , n_cols(0) , n_elem_slice(0) , n_slices(0) , n_elem(0) , use_aux_mem(false) , mat_ptrs(mat_ptrs) , mem(mem) { arma_extra_debug_sigprint_this(this); init(aux_n_rows, aux_n_cols, aux_n_slices); syslib::copy_elem( memptr(), aux_mem, n_elem ); }
const Cube< eT > & Cube< eT >::operator+= | ( | const Cube< eT > & | m | ) | [inline, inherited] |
in-place cube addition
Definition at line 450 of file Cube_meat.hpp.
References Cube< eT >::memptr(), and Cube< eT >::n_elem.
{ arma_extra_debug_sigprint(); arma_debug_assert_same_size(*this, m, "cube addition"); const u32 local_n_elem = m.n_elem; eT* out_mem = (*this).memptr(); const eT* m_mem = m.memptr(); u32 i,j; for(i=0, j=1; j<local_n_elem; i+=2, j+=2) { out_mem[i] += m_mem[i]; out_mem[j] += m_mem[j]; } if(i < local_n_elem) { out_mem[i] += m_mem[i]; } return *this; }
const Cube< eT > & Cube< eT >::operator-= | ( | const Cube< eT > & | m | ) | [inline, inherited] |
in-place cube subtraction
Definition at line 483 of file Cube_meat.hpp.
References Cube< eT >::memptr(), and Cube< eT >::n_elem.
{ arma_extra_debug_sigprint(); arma_debug_assert_same_size(*this, m, "cube subtraction"); const u32 local_n_elem = m.n_elem; eT* out_mem = (*this).memptr(); const eT* m_mem = m.memptr(); u32 i,j; for(i=0, j=1; j<local_n_elem; i+=2, j+=2) { out_mem[i] -= m_mem[i]; out_mem[j] -= m_mem[j]; } if(i < local_n_elem) { out_mem[i] -= m_mem[i]; } return *this; }
const Cube< eT > & Cube< eT >::operator%= | ( | const Cube< eT > & | m | ) | [inline, inherited] |
in-place element-wise cube multiplication
Definition at line 516 of file Cube_meat.hpp.
References Cube< eT >::memptr(), and Cube< eT >::n_elem.
{ arma_extra_debug_sigprint(); arma_debug_assert_same_size(*this, m, "element-wise cube multiplication"); const u32 local_n_elem = m.n_elem; eT* out_mem = (*this).memptr(); const eT* m_mem = m.memptr(); u32 i,j; for(i=0, j=1; j<local_n_elem; i+=2, j+=2) { out_mem[i] *= m_mem[i]; out_mem[j] *= m_mem[j]; } if(i < local_n_elem) { out_mem[i] *= m_mem[i]; } return *this; }
const Cube< eT > & Cube< eT >::operator/= | ( | const Cube< eT > & | m | ) | [inline, inherited] |
in-place element-wise cube division
Definition at line 549 of file Cube_meat.hpp.
References Cube< eT >::memptr(), and Cube< eT >::n_elem.
{ arma_extra_debug_sigprint(); arma_debug_assert_same_size(*this, m, "element-wise cube division"); const u32 local_n_elem = m.n_elem; eT* out_mem = (*this).memptr(); const eT* m_mem = m.memptr(); u32 i,j; for(i=0, j=1; j<local_n_elem; i+=2, j+=2) { out_mem[i] /= m_mem[i]; out_mem[j] /= m_mem[j]; } if(i < local_n_elem) { out_mem[i] /= m_mem[i]; } return *this; }
Cube< eT >::Cube | ( | const BaseCube< typename Cube< eT >::pod_type, T1 > & | A, | |
const BaseCube< typename Cube< eT >::pod_type, T2 > & | B | |||
) | [inline, inherited] |
for constructing a complex cube out of two non-complex cubes
< compile-time abort if eT isn't std::complex
< compile-time abort if T is std::complex
< compile-time abort if types are not compatible
Definition at line 583 of file Cube_meat.hpp.
References arma_assert_same_size(), Cube< eT >::mem, and access::rw().
: n_rows(0) , n_cols(0) , n_elem_slice(0) , n_slices(0) , n_elem(0) , use_aux_mem(false) , mat_ptrs(mat_ptrs) , mem(mem) { arma_extra_debug_sigprint_this(this); arma_type_check< is_complex<eT>::value == false >::apply(); //!< compile-time abort if eT isn't std::complex typedef typename T1::elem_type T; arma_type_check< is_complex<T>::value == true >::apply(); //!< compile-time abort if T is std::complex isnt_same_type<std::complex<T>, eT>::check(); //!< compile-time abort if types are not compatible const unwrap_cube<T1> tmp_A(A.get_ref()); const unwrap_cube<T2> tmp_B(B.get_ref()); const Cube<T>& X = tmp_A.M; const Cube<T>& Y = tmp_B.M; arma_assert_same_size(X, Y, "Cube()"); init(X.n_rows, X.n_cols, X.n_slices); const T* X_mem = X.mem; const T* Y_mem = Y.mem; for(u32 i=0; i<n_elem; ++i) { access::rw(mem[i]) = std::complex<T>(X_mem[i], Y_mem[i]); } }
Cube< eT >::Cube | ( | const subview_cube< eT > & | X | ) | [inline, inherited] |
construct a cube from a subview_cube instance (e.g. construct a cube from a delayed subcube operation)
Definition at line 629 of file Cube_meat.hpp.
References Cube< eT >::operator=().
const Cube< eT > & Cube< eT >::operator= | ( | const subview_cube< eT > & | X | ) | [inline, inherited] |
construct a cube from a subview_cube instance (e.g. construct a cube from a delayed subcube operation)
Definition at line 650 of file Cube_meat.hpp.
{ arma_extra_debug_sigprint(); subview_cube<eT>::extract(*this, X); return *this; }
const Cube< eT > & Cube< eT >::operator+= | ( | const subview_cube< eT > & | X | ) | [inline, inherited] |
in-place cube addition (using a subcube on the right-hand-side)
Definition at line 664 of file Cube_meat.hpp.
{ arma_extra_debug_sigprint(); subview_cube<eT>::plus_inplace(*this, X); return *this; }
const Cube< eT > & Cube< eT >::operator-= | ( | const subview_cube< eT > & | X | ) | [inline, inherited] |
in-place cube subtraction (using a subcube on the right-hand-side)
Definition at line 678 of file Cube_meat.hpp.
{ arma_extra_debug_sigprint(); subview_cube<eT>::minus_inplace(*this, X); return *this; }
const Cube< eT > & Cube< eT >::operator%= | ( | const subview_cube< eT > & | X | ) | [inline, inherited] |
in-place element-wise cube mutiplication (using a subcube on the right-hand-side)
Definition at line 692 of file Cube_meat.hpp.
{ arma_extra_debug_sigprint(); subview_cube<eT>::schur_inplace(*this, X); return *this; }
const Cube< eT > & Cube< eT >::operator/= | ( | const subview_cube< eT > & | X | ) | [inline, inherited] |
in-place element-wise cube division (using a subcube on the right-hand-side)
Definition at line 706 of file Cube_meat.hpp.
{ arma_extra_debug_sigprint(); subview_cube<eT>::div_inplace(*this, X); return *this; }
provide the reference to the matrix representing a single slice
Definition at line 720 of file Cube_meat.hpp.
References Cube< eT >::mat_ptrs, and Cube< eT >::n_slices.
Referenced by Cube< eT >::create_mat(), Cube< eT >::delete_mat(), diskio::load_raw_ascii(), and arma_ostream::print().
arma_inline const Mat< eT > & Cube< eT >::slice | ( | const u32 | in_slice | ) | const [inherited] |
provide the reference to the matrix representing a single slice
Definition at line 739 of file Cube_meat.hpp.
References Cube< eT >::mat_ptrs, and Cube< eT >::n_slices.
arma_inline subview_cube< eT > Cube< eT >::slices | ( | const u32 | in_slice1, | |
const u32 | in_slice2 | |||
) | [inherited] |
creation of subview_cube (subcube comprised of specified slices)
Definition at line 758 of file Cube_meat.hpp.
References Cube< eT >::n_cols, Cube< eT >::n_rows, and Cube< eT >::n_slices.
arma_inline const subview_cube< eT > Cube< eT >::slices | ( | const u32 | in_slice1, | |
const u32 | in_slice2 | |||
) | const [inherited] |
creation of subview_cube (subcube comprised of specified slices)
Definition at line 777 of file Cube_meat.hpp.
References Cube< eT >::n_cols, Cube< eT >::n_rows, and Cube< eT >::n_slices.
arma_inline subview_cube< eT > Cube< eT >::subcube | ( | const u32 | in_row1, | |
const u32 | in_col1, | |||
const u32 | in_slice1, | |||
const u32 | in_row2, | |||
const u32 | in_col2, | |||
const u32 | in_slice2 | |||
) | [inherited] |
creation of subview_cube (generic subcube)
Definition at line 796 of file Cube_meat.hpp.
References Cube< eT >::n_cols, Cube< eT >::n_rows, and Cube< eT >::n_slices.
{ arma_extra_debug_sigprint(); arma_debug_check ( (in_row1 > in_row2) || (in_col1 > in_col2) || (in_slice1 > in_slice2) || (in_row2 >= n_rows) || (in_col2 >= n_cols) || (in_slice2 >= n_slices), "Cube::subcube(): indices out of bounds or incorrectly used" ); return subview_cube<eT>(*this, in_row1, in_col1, in_slice1, in_row2, in_col2, in_slice2); }
arma_inline const subview_cube< eT > Cube< eT >::subcube | ( | const u32 | in_row1, | |
const u32 | in_col1, | |||
const u32 | in_slice1, | |||
const u32 | in_row2, | |||
const u32 | in_col2, | |||
const u32 | in_slice2 | |||
) | const [inherited] |
creation of subview_cube (generic subcube)
Definition at line 816 of file Cube_meat.hpp.
References Cube< eT >::n_cols, Cube< eT >::n_rows, and Cube< eT >::n_slices.
{ arma_extra_debug_sigprint(); arma_debug_check ( (in_row1 > in_row2) || (in_col1 > in_col2) || (in_slice1 > in_slice2) || (in_row2 >= n_rows) || (in_col2 >= n_cols) || (in_slice2 >= n_slices), "Cube::subcube(): indices out of bounds or incorrectly used" ); return subview_cube<eT>(*this, in_row1, in_col1, in_slice1, in_row2, in_col2, in_slice2); }
Cube< eT >::Cube | ( | const OpCube< T1, op_type > & | X | ) | [inline, inherited] |
create a cube from OpCube, i.e. run the previously delayed unary operations
Definition at line 836 of file Cube_meat.hpp.
: n_rows(0) , n_cols(0) , n_elem_slice(0) , n_slices(0) , n_elem(0) , use_aux_mem(false) , mat_ptrs(mat_ptrs) , mem(mem) { arma_extra_debug_sigprint_this(this); isnt_same_type<eT, typename T1::elem_type>::check(); op_type::apply(*this, X); }
const Cube< eT > & Cube< eT >::operator= | ( | const OpCube< T1, op_type > & | X | ) | [inline, inherited] |
create a cube from OpCube, i.e. run the previously delayed unary operations
Definition at line 860 of file Cube_meat.hpp.
{ arma_extra_debug_sigprint(); isnt_same_type<eT, typename T1::elem_type>::check(); op_type::apply(*this, X); return *this; }
const Cube< eT > & Cube< eT >::operator+= | ( | const OpCube< T1, op_type > & | X | ) | [inline, inherited] |
in-place cube addition, with the right-hand-side operand having delayed operations
Definition at line 878 of file Cube_meat.hpp.
{ arma_extra_debug_sigprint(); isnt_same_type<eT, typename T1::elem_type>::check(); const Cube<eT> m(X); return (*this).operator+=(m); }
const Cube< eT > & Cube< eT >::operator-= | ( | const OpCube< T1, op_type > & | X | ) | [inline, inherited] |
in-place cube subtraction, with the right-hand-side operand having delayed operations
Definition at line 896 of file Cube_meat.hpp.
{ arma_extra_debug_sigprint(); isnt_same_type<eT, typename T1::elem_type>::check(); const Cube<eT> m(X); return (*this).operator-=(m); }
const Cube< eT > & Cube< eT >::operator%= | ( | const OpCube< T1, op_type > & | X | ) | [inline, inherited] |
in-place cube element-wise multiplication, with the right-hand-side operand having delayed operations
Definition at line 914 of file Cube_meat.hpp.
{ arma_extra_debug_sigprint(); isnt_same_type<eT, typename T1::elem_type>::check(); const Cube<eT> m(X); return (*this).operator%=(m); }
const Cube< eT > & Cube< eT >::operator/= | ( | const OpCube< T1, op_type > & | X | ) | [inline, inherited] |
in-place cube element-wise division, with the right-hand-side operand having delayed operations
Definition at line 932 of file Cube_meat.hpp.
{ arma_extra_debug_sigprint(); isnt_same_type<eT, typename T1::elem_type>::check(); const Cube<eT> m(X); return (*this).operator/=(m); }
Cube< eT >::Cube | ( | const eOpCube< T1, eop_type > & | X | ) | [inline, inherited] |
create a cube from eOpCube, i.e. run the previously delayed unary operations
Definition at line 949 of file Cube_meat.hpp.
: n_rows(0) , n_cols(0) , n_elem_slice(0) , n_slices(0) , n_elem(0) , use_aux_mem(false) , mat_ptrs(mat_ptrs) , mem(mem) { arma_extra_debug_sigprint_this(this); isnt_same_type<eT, typename T1::elem_type>::check(); eop_type::apply(*this, X); }
const Cube< eT > & Cube< eT >::operator= | ( | const eOpCube< T1, eop_type > & | X | ) | [inline, inherited] |
create a cube from eOpCube, i.e. run the previously delayed unary operations
Definition at line 973 of file Cube_meat.hpp.
{ arma_extra_debug_sigprint(); isnt_same_type<eT, typename T1::elem_type>::check(); eop_type::apply(*this, X); return *this; }
const Cube< eT > & Cube< eT >::operator+= | ( | const eOpCube< T1, eop_type > & | X | ) | [inline, inherited] |
in-place cube addition, with the right-hand-side operand having delayed operations
Definition at line 991 of file Cube_meat.hpp.
{ arma_extra_debug_sigprint(); isnt_same_type<eT, typename T1::elem_type>::check(); eop_type::apply_inplace_plus(*this, X); return *this; }
const Cube< eT > & Cube< eT >::operator-= | ( | const eOpCube< T1, eop_type > & | X | ) | [inline, inherited] |
in-place cube subtraction, with the right-hand-side operand having delayed operations
Definition at line 1009 of file Cube_meat.hpp.
{ arma_extra_debug_sigprint(); isnt_same_type<eT, typename T1::elem_type>::check(); eop_type::apply_inplace_minus(*this, X); return *this; }
const Cube< eT > & Cube< eT >::operator%= | ( | const eOpCube< T1, eop_type > & | X | ) | [inline, inherited] |
in-place cube element-wise multiplication, with the right-hand-side operand having delayed operations
Definition at line 1027 of file Cube_meat.hpp.
{ arma_extra_debug_sigprint(); isnt_same_type<eT, typename T1::elem_type>::check(); eop_type::apply_inplace_schur(*this, X); return *this; }
const Cube< eT > & Cube< eT >::operator/= | ( | const eOpCube< T1, eop_type > & | X | ) | [inline, inherited] |
in-place cube element-wise division, with the right-hand-side operand having delayed operations
Definition at line 1045 of file Cube_meat.hpp.
{ arma_extra_debug_sigprint(); isnt_same_type<eT, typename T1::elem_type>::check(); eop_type::apply_inplace_div(*this, X); return *this; }
Cube< eT >::Cube | ( | const GlueCube< T1, T2, glue_type > & | X | ) | [inline, inherited] |
create a cube from Glue, i.e. run the previously delayed binary operations
Definition at line 1062 of file Cube_meat.hpp.
References Cube< eT >::operator=().
const Cube< eT > & Cube< eT >::operator= | ( | const GlueCube< T1, T2, glue_type > & | X | ) | [inline, inherited] |
create a cube from Glue, i.e. run the previously delayed binary operations
Definition at line 1083 of file Cube_meat.hpp.
{ arma_extra_debug_sigprint(); isnt_same_type<eT, typename T1::elem_type>::check(); isnt_same_type<eT, typename T2::elem_type>::check(); glue_type::apply(*this, X); return *this; }
const Cube< eT > & Cube< eT >::operator+= | ( | const GlueCube< T1, T2, glue_type > & | X | ) | [inline, inherited] |
in-place cube addition, with the right-hand-side operands having delayed operations
Definition at line 1101 of file Cube_meat.hpp.
{ arma_extra_debug_sigprint(); isnt_same_type<eT, typename T1::elem_type>::check(); isnt_same_type<eT, typename T2::elem_type>::check(); const Cube<eT> m(X); return (*this).operator+=(m); }
const Cube< eT > & Cube< eT >::operator-= | ( | const GlueCube< T1, T2, glue_type > & | X | ) | [inline, inherited] |
in-place cube subtraction, with the right-hand-side operands having delayed operations
Definition at line 1120 of file Cube_meat.hpp.
{ arma_extra_debug_sigprint(); isnt_same_type<eT, typename T1::elem_type>::check(); isnt_same_type<eT, typename T2::elem_type>::check(); const Cube<eT> m(X); return (*this).operator-=(m); }
const Cube< eT > & Cube< eT >::operator%= | ( | const GlueCube< T1, T2, glue_type > & | X | ) | [inline, inherited] |
in-place cube element-wise multiplication, with the right-hand-side operands having delayed operations
Definition at line 1139 of file Cube_meat.hpp.
{ arma_extra_debug_sigprint(); isnt_same_type<eT, typename T1::elem_type>::check(); isnt_same_type<eT, typename T2::elem_type>::check(); const Cube<eT> m(X); return (*this).operator%=(m); }
const Cube< eT > & Cube< eT >::operator/= | ( | const GlueCube< T1, T2, glue_type > & | X | ) | [inline, inherited] |
in-place cube element-wise division, with the right-hand-side operands having delayed operations
Definition at line 1158 of file Cube_meat.hpp.
{ arma_extra_debug_sigprint(); isnt_same_type<eT, typename T1::elem_type>::check(); isnt_same_type<eT, typename T2::elem_type>::check(); const Cube<eT> m(X); return (*this).operator/=(m); }
Cube< eT >::Cube | ( | const eGlueCube< T1, T2, eglue_type > & | X | ) | [inline, inherited] |
create a cube from eGlue, i.e. run the previously delayed binary operations
Definition at line 1176 of file Cube_meat.hpp.
References Cube< eT >::operator=().
const Cube< eT > & Cube< eT >::operator= | ( | const eGlueCube< T1, T2, eglue_type > & | X | ) | [inline, inherited] |
create a cube from Glue, i.e. run the previously delayed binary operations
Definition at line 1197 of file Cube_meat.hpp.
{ arma_extra_debug_sigprint(); isnt_same_type<eT, typename T1::elem_type>::check(); isnt_same_type<eT, typename T2::elem_type>::check(); eglue_type::apply(*this, X); return *this; }
const Cube< eT > & Cube< eT >::operator+= | ( | const eGlueCube< T1, T2, eglue_type > & | X | ) | [inline, inherited] |
in-place cube addition, with the right-hand-side operands having delayed operations
Definition at line 1215 of file Cube_meat.hpp.
{ arma_extra_debug_sigprint(); isnt_same_type<eT, typename T1::elem_type>::check(); isnt_same_type<eT, typename T2::elem_type>::check(); eglue_type::apply_inplace_plus(*this, X); return *this; }
const Cube< eT > & Cube< eT >::operator-= | ( | const eGlueCube< T1, T2, eglue_type > & | X | ) | [inline, inherited] |
in-place cube subtraction, with the right-hand-side operands having delayed operations
Definition at line 1234 of file Cube_meat.hpp.
{ arma_extra_debug_sigprint(); isnt_same_type<eT, typename T1::elem_type>::check(); isnt_same_type<eT, typename T2::elem_type>::check(); eglue_type::apply_inplace_minus(*this, X); return *this; }
const Cube< eT > & Cube< eT >::operator%= | ( | const eGlueCube< T1, T2, eglue_type > & | X | ) | [inline, inherited] |
in-place cube element-wise multiplication, with the right-hand-side operands having delayed operations
Definition at line 1253 of file Cube_meat.hpp.
{ arma_extra_debug_sigprint(); isnt_same_type<eT, typename T1::elem_type>::check(); isnt_same_type<eT, typename T2::elem_type>::check(); eglue_type::apply_inplace_schur(*this, X); return *this; }
const Cube< eT > & Cube< eT >::operator/= | ( | const eGlueCube< T1, T2, eglue_type > & | X | ) | [inline, inherited] |
in-place cube element-wise division, with the right-hand-side operands having delayed operations
Definition at line 1272 of file Cube_meat.hpp.
{ arma_extra_debug_sigprint(); isnt_same_type<eT, typename T1::elem_type>::check(); isnt_same_type<eT, typename T2::elem_type>::check(); eglue_type::apply_inplace_div(*this, X); return *this; }
linear element accessor (treats the cube as a vector); bounds checking not done when ARMA_NO_DEBUG is defined
Definition at line 1290 of file Cube_meat.hpp.
References Cube< eT >::mem, Cube< eT >::n_elem, and access::rw().
{ arma_debug_check( (i >= n_elem), "Cube::operator(): index out of bounds"); return access::rw(mem[i]); }
linear element accessor (treats the cube as a vector); bounds checking not done when ARMA_NO_DEBUG is defined
Definition at line 1302 of file Cube_meat.hpp.
References Cube< eT >::mem, and Cube< eT >::n_elem.
linear element accessor (treats the cube as a vector); no bounds check.
Definition at line 1313 of file Cube_meat.hpp.
References Cube< eT >::mem, and access::rw().
{ return access::rw(mem[i]); }
linear element accessor (treats the cube as a vector); no bounds check
Definition at line 1324 of file Cube_meat.hpp.
References Cube< eT >::mem.
{ return mem[i]; }
arma_inline eT & Cube< eT >::operator() | ( | const u32 | in_row, | |
const u32 | in_col, | |||
const u32 | in_slice | |||
) | [inherited] |
element accessor; bounds checking not done when ARMA_NO_DEBUG is defined
Definition at line 1335 of file Cube_meat.hpp.
References Cube< eT >::mem, Cube< eT >::n_cols, Cube< eT >::n_elem_slice, Cube< eT >::n_rows, Cube< eT >::n_slices, and access::rw().
{ arma_debug_check ( (in_row >= n_rows) || (in_col >= n_cols) || (in_slice >= n_slices) , "Cube::operator(): index out of bounds" ); return access::rw(mem[in_slice*n_elem_slice + in_col*n_rows + in_row]); }
arma_inline eT Cube< eT >::operator() | ( | const u32 | in_row, | |
const u32 | in_col, | |||
const u32 | in_slice | |||
) | const [inherited] |
element accessor; bounds checking not done when ARMA_NO_DEBUG is defined
Definition at line 1355 of file Cube_meat.hpp.
References Cube< eT >::mem, Cube< eT >::n_cols, Cube< eT >::n_elem_slice, Cube< eT >::n_rows, and Cube< eT >::n_slices.
arma_inline eT & Cube< eT >::at | ( | const u32 | in_row, | |
const u32 | in_col, | |||
const u32 | in_slice | |||
) | [inherited] |
element accessor; no bounds check
Definition at line 1375 of file Cube_meat.hpp.
References Cube< eT >::mem, Cube< eT >::n_elem_slice, Cube< eT >::n_rows, and access::rw().
Referenced by op_reshape::apply(), diskio::load_arma_ascii(), diskio::load_ppm_binary(), diskio::save_arma_ascii(), diskio::save_ppm_binary(), and diskio::save_raw_ascii().
{ return access::rw( mem[in_slice*n_elem_slice + in_col*n_rows + in_row] ); }
arma_inline eT Cube< eT >::at | ( | const u32 | in_row, | |
const u32 | in_col, | |||
const u32 | in_slice | |||
) | const [inherited] |
element accessor; no bounds check
Definition at line 1386 of file Cube_meat.hpp.
References Cube< eT >::mem, Cube< eT >::n_elem_slice, and Cube< eT >::n_rows.
{ return mem[in_slice*n_elem_slice + in_col*n_rows + in_row]; }
prefix ++
Definition at line 1397 of file Cube_meat.hpp.
References Cube_aux::prefix_pp().
{ Cube_aux::prefix_pp(*this); return *this; }
arma_inline void Cube< eT >::operator++ | ( | int | ) | [inherited] |
postfix ++ (must not return the object by reference)
Definition at line 1409 of file Cube_meat.hpp.
References Cube_aux::postfix_pp().
{ Cube_aux::postfix_pp(*this); }
prefix --
Definition at line 1420 of file Cube_meat.hpp.
References Cube_aux::prefix_mm().
{ Cube_aux::prefix_mm(*this); return *this; }
arma_inline void Cube< eT >::operator-- | ( | int | ) | [inherited] |
postfix -- (must not return the object by reference)
Definition at line 1432 of file Cube_meat.hpp.
References Cube_aux::postfix_mm().
{ Cube_aux::postfix_mm(*this); }
arma_inline bool Cube< eT >::is_finite | ( | ) | const [inherited] |
returns true if all of the elements are finite
Definition at line 1443 of file Cube_meat.hpp.
References arma_isfinite(), Cube< eT >::mem, and Cube< eT >::n_elem.
{ for(u32 i=0; i<n_elem; ++i) { if(arma_isfinite(mem[i]) == false) { return false; } } return true; }
arma_inline eT * Cube< eT >::memptr | ( | ) | [inherited] |
returns a pointer to array of eTs used by the cube
Definition at line 1462 of file Cube_meat.hpp.
References Cube< eT >::mem.
Referenced by abs(), op_reshape::apply(), eglue_cube_core< eglue_type >::apply(), eop_cube_core< eop_cube_type >::apply_inplace_div(), eglue_cube_core< eglue_type >::apply_inplace_div(), eop_cube_core< eop_cube_type >::apply_inplace_minus(), eglue_cube_core< eglue_type >::apply_inplace_minus(), eop_cube_core< eop_cube_type >::apply_inplace_plus(), eglue_cube_core< eglue_type >::apply_inplace_plus(), eop_cube_core< eop_cube_type >::apply_inplace_schur(), eglue_cube_core< eglue_type >::apply_inplace_schur(), eop_cube_core< eop_cube_type >::apply_proxy(), eop_cube_core< eop_cube_type >::apply_unwrap(), Cube< eT >::begin(), Cube< eT >::Cube(), Cube< eT >::end(), Cube< eT >::fill(), conv_to< Cube< out_eT > >::from(), Cube< eT >::init(), diskio::load_arma_binary(), operator!=(), operator%(), Cube< eT >::operator%=(), Cube< eT >::operator*=(), operator+(), Cube< eT >::operator+=(), operator-(), Cube< eT >::operator-=(), operator/(), Cube< eT >::operator/=(), operator<(), operator<=(), operator==(), operator>(), operator>=(), Cube_aux::postfix_mm(), Cube_aux::postfix_pp(), Cube_aux::prefix_mm(), Cube_aux::prefix_pp(), and arma_ostream::print().
{ return const_cast<eT*>(mem); }
arma_inline const eT * Cube< eT >::memptr | ( | ) | const [inherited] |
returns a pointer to array of eTs used by the cube
Definition at line 1473 of file Cube_meat.hpp.
References Cube< eT >::mem.
{ return mem; }
returns a pointer to array of eTs used by the specified slice in the cube
Definition at line 1484 of file Cube_meat.hpp.
References Cube< eT >::mem, and Cube< eT >::n_elem_slice.
Referenced by Cube< eT >::begin_slice(), Cube< eT >::create_mat(), and Cube< eT >::end_slice().
{ return const_cast<eT*>( &mem[ slice*n_elem_slice ] ); }
arma_inline const eT * Cube< eT >::slice_memptr | ( | const u32 | slice | ) | const [inherited] |
returns a pointer to array of eTs used by the specified slice in the cube
Definition at line 1495 of file Cube_meat.hpp.
References Cube< eT >::mem, and Cube< eT >::n_elem_slice.
{ return &mem[ slice*n_elem_slice ]; }
arma_inline eT * Cube< eT >::slice_colptr | ( | const u32 | in_slice, | |
const u32 | in_col | |||
) | [inherited] |
returns a pointer to array of eTs used by the specified slice in the cube
Definition at line 1506 of file Cube_meat.hpp.
References Cube< eT >::mem, Cube< eT >::n_elem_slice, and Cube< eT >::n_rows.
Referenced by subview_cube< eT >::div_inplace(), subview_cube< eT >::extract(), subview_cube< eT >::minus_inplace(), subview_cube< eT >::plus_inplace(), and subview_cube< eT >::schur_inplace().
{ return const_cast<eT*>( &mem[ slice*n_elem_slice + col*n_rows] ); }
arma_inline const eT * Cube< eT >::slice_colptr | ( | const u32 | in_slice, | |
const u32 | in_col | |||
) | const [inherited] |
returns a pointer to array of eTs used by the specified slice in the cube
Definition at line 1517 of file Cube_meat.hpp.
References Cube< eT >::mem, Cube< eT >::n_elem_slice, and Cube< eT >::n_rows.
{ return &mem[ slice*n_elem_slice + col*n_rows ]; }
void Cube< eT >::print | ( | const std::string | extra_text = "" |
) | const [inline, inherited] |
print contents of the cube (to the cout stream), //! optionally preceding with a user specified line of text. //! the precision and cell width are modified. //! on return, the stream's flags are restored to their original values.
Definition at line 1531 of file Cube_meat.hpp.
Referenced by Cube< eT >::print(), and Cube< eT >::raw_print().
{ arma_extra_debug_sigprint(); if(extra_text.length() != 0) { cout << extra_text << '\n'; } arma_ostream::print(cout, *this, true); }
void Cube< eT >::print | ( | std::ostream & | user_stream, | |
const std::string | extra_text = "" | |||
) | const [inline, inherited] |
print contents of the cube to a user specified stream, //! optionally preceding with a user specified line of text. //! the precision and cell width are modified. //! on return, the stream's flags are restored to their original values.
Definition at line 1551 of file Cube_meat.hpp.
References Cube< eT >::print().
{ arma_extra_debug_sigprint(); if(extra_text.length() != 0) { user_stream << extra_text << '\n'; } arma_ostream::print(user_stream, *this, true); }
void Cube< eT >::raw_print | ( | const std::string | extra_text = "" |
) | const [inline, inherited] |
print contents of the cube (to the cout stream), //! optionally preceding with a user specified line of text. //! the stream's flags are used as is and are not modified //! (i.e. the precision and cell width are not modified).
Definition at line 1572 of file Cube_meat.hpp.
References Cube< eT >::print().
{ arma_extra_debug_sigprint(); if(extra_text.length() != 0) { cout << extra_text << '\n'; } arma_ostream::print(cout, *this, false); }
void Cube< eT >::raw_print | ( | std::ostream & | user_stream, | |
const std::string | extra_text = "" | |||
) | const [inline, inherited] |
print contents of the cube to a user specified stream, //! optionally preceding with a user specified line of text. //! the stream's flags are used as is and are not modified. //! (i.e. the precision and cell width are not modified).
Definition at line 1593 of file Cube_meat.hpp.
References Cube< eT >::print().
{ arma_extra_debug_sigprint(); if(extra_text.length() != 0) { user_stream << extra_text << '\n'; } arma_ostream::print(user_stream, *this, false); }
void Cube< eT >::set_size | ( | const u32 | in_rows, | |
const u32 | in_cols, | |||
const u32 | in_slices | |||
) | [inline, inherited] |
change the cube to have user specified dimensions (data is not preserved)
Definition at line 1611 of file Cube_meat.hpp.
References Cube< eT >::init().
Referenced by op_reshape::apply(), eglue_cube_core< eglue_type >::apply(), eop_cube_core< eop_cube_type >::apply_proxy(), eop_cube_core< eop_cube_type >::apply_unwrap(), subview_cube< eT >::extract(), diskio::load_arma_ascii(), diskio::load_arma_binary(), diskio::load_ppm_binary(), diskio::load_raw_ascii(), Cube< eT >::ones(), and Cube< eT >::zeros().
{ arma_extra_debug_sigprint(); init(in_n_rows, in_n_cols, in_n_slices); }
void Cube< eT >::copy_size | ( | const Cube< eT2 > & | m | ) | [inline, inherited] |
change the cube (without preserving data) to have the same dimensions as the given cube
Definition at line 1625 of file Cube_meat.hpp.
References Cube< eT >::init(), Cube< eT >::n_cols, Cube< eT >::n_rows, and Cube< eT >::n_slices.
void Cube< eT >::fill | ( | const eT | val | ) | [inline, inherited] |
fill the cube with the specified value
Definition at line 1638 of file Cube_meat.hpp.
References Cube< eT >::memptr(), and Cube< eT >::n_elem.
Referenced by Cube< eT >::ones(), and Cube< eT >::zeros().
void Cube< eT >::zeros | ( | ) | [inline, inherited] |
Definition at line 1664 of file Cube_meat.hpp.
References Cube< eT >::fill().
{ arma_extra_debug_sigprint(); fill(eT(0)); }
void Cube< eT >::zeros | ( | const u32 | in_rows, | |
const u32 | in_cols, | |||
const u32 | in_slices | |||
) | [inline, inherited] |
Definition at line 1676 of file Cube_meat.hpp.
References Cube< eT >::fill(), and Cube< eT >::set_size().
{ arma_extra_debug_sigprint( arma_boost::format("in_rows = %d, in_cols = %d, in_slices = %d") % in_rows % in_cols % in_slices ); set_size(in_rows, in_cols, in_slices); fill(eT(0)); }
void Cube< eT >::ones | ( | ) | [inline, inherited] |
Definition at line 1689 of file Cube_meat.hpp.
References Cube< eT >::fill().
{ arma_extra_debug_sigprint(); fill(eT(1)); }
void Cube< eT >::ones | ( | const u32 | in_rows, | |
const u32 | in_cols, | |||
const u32 | in_slices | |||
) | [inline, inherited] |
Definition at line 1701 of file Cube_meat.hpp.
References Cube< eT >::fill(), and Cube< eT >::set_size().
{ arma_extra_debug_sigprint( arma_boost::format("in_rows = %d, in_cols = %d, in_slices = %d") % in_rows % in_cols % in_slices ); set_size(in_rows, in_cols, in_slices); fill(eT(1)); }
void Cube< eT >::reset | ( | ) | [inline, inherited] |
Definition at line 1714 of file Cube_meat.hpp.
References Cube< eT >::init().
{ arma_extra_debug_sigprint(); init(0,0,0); }
bool Cube< eT >::save | ( | const std::string | name, | |
const file_type | type = arma_binary , |
|||
const bool | print_status = true | |||
) | const [inline, inherited] |
save the cube to a file
Definition at line 1727 of file Cube_meat.hpp.
References arma_ascii, arma_binary, arma_warn(), ppm_binary, raw_ascii, diskio::save_arma_ascii(), diskio::save_arma_binary(), diskio::save_ppm_binary(), and diskio::save_raw_ascii().
{ arma_extra_debug_sigprint(); bool save_okay; switch(type) { case raw_ascii: save_okay = diskio::save_raw_ascii(*this, name); break; case arma_ascii: save_okay = diskio::save_arma_ascii(*this, name); break; case arma_binary: save_okay = diskio::save_arma_binary(*this, name); break; case ppm_binary: save_okay = diskio::save_ppm_binary(*this, name); break; default: arma_warn(print_status, "Cube::save(): unsupported file type"); save_okay = false; } arma_warn( (print_status && (save_okay == false)), "Cube::save(): couldn't write to ", name); return save_okay; }
bool Cube< eT >::save | ( | std::ostream & | os, | |
const file_type | type = arma_binary , |
|||
const bool | print_status = true | |||
) | const [inline, inherited] |
save the cube to a stream
Definition at line 1767 of file Cube_meat.hpp.
References arma_ascii, arma_binary, arma_warn(), ppm_binary, raw_ascii, diskio::save_arma_ascii(), diskio::save_arma_binary(), diskio::save_ppm_binary(), and diskio::save_raw_ascii().
{ arma_extra_debug_sigprint(); bool save_okay; switch(type) { case raw_ascii: save_okay = diskio::save_raw_ascii(*this, os); break; case arma_ascii: save_okay = diskio::save_arma_ascii(*this, os); break; case arma_binary: save_okay = diskio::save_arma_binary(*this, os); break; case ppm_binary: save_okay = diskio::save_ppm_binary(*this, os); break; default: arma_warn(print_status, "Cube::save(): unsupported file type"); save_okay = false; } arma_warn( (print_status && (save_okay == false)), "Cube::save(): couldn't write to given stream"); return save_okay; }
bool Cube< eT >::load | ( | const std::string | name, | |
const file_type | type = auto_detect , |
|||
const bool | print_status = true | |||
) | [inline, inherited] |
load a cube from a file
Definition at line 1807 of file Cube_meat.hpp.
References arma_ascii, arma_binary, arma_print(), arma_warn(), auto_detect, diskio::load_arma_ascii(), diskio::load_arma_binary(), diskio::load_auto_detect(), diskio::load_ppm_binary(), diskio::load_raw_ascii(), ppm_binary, and raw_ascii.
{ arma_extra_debug_sigprint(); bool load_okay; std::string err_msg; switch(type) { case auto_detect: load_okay = diskio::load_auto_detect(*this, name, err_msg); break; case raw_ascii: load_okay = diskio::load_raw_ascii(*this, name, err_msg); break; case arma_ascii: load_okay = diskio::load_arma_ascii(*this, name, err_msg); break; case arma_binary: load_okay = diskio::load_arma_binary(*this, name, err_msg); break; case ppm_binary: load_okay = diskio::load_ppm_binary(*this, name, err_msg); break; default: arma_warn(print_status, "Cube::load(): unsupported file type"); load_okay = false; } if( (print_status == true) && (load_okay == false) ) { if(err_msg.length() > 0) { arma_print("Cube::load(): ", err_msg, name); } else { arma_print("Cube::load(): couldn't read ", name); } } if(load_okay == false) { (*this).reset(); } return load_okay; }
bool Cube< eT >::load | ( | std::istream & | is, | |
const file_type | type = auto_detect , |
|||
const bool | print_status = true | |||
) | [inline, inherited] |
load a cube from a stream
Definition at line 1867 of file Cube_meat.hpp.
References arma_ascii, arma_binary, arma_print(), arma_warn(), auto_detect, diskio::load_arma_ascii(), diskio::load_arma_binary(), diskio::load_auto_detect(), diskio::load_ppm_binary(), diskio::load_raw_ascii(), ppm_binary, and raw_ascii.
{ arma_extra_debug_sigprint(); bool load_okay; std::string err_msg; switch(type) { case auto_detect: load_okay = diskio::load_auto_detect(*this, is, err_msg); break; case raw_ascii: load_okay = diskio::load_raw_ascii(*this, is, err_msg); break; case arma_ascii: load_okay = diskio::load_arma_ascii(*this, is, err_msg); break; case arma_binary: load_okay = diskio::load_arma_binary(*this, is, err_msg); break; case ppm_binary: load_okay = diskio::load_ppm_binary(*this, is, err_msg); break; default: arma_warn(print_status, "Cube::load(): unsupported file type"); load_okay = false; } if( (print_status == true) && (load_okay == false) ) { if(err_msg.length() > 0) { arma_print("Cube::load(): ", err_msg, "the given stream"); } else { arma_print("Cube::load(): couldn't load from the given stream"); } } if(load_okay == false) { (*this).reset(); } return load_okay; }
bool Cube< eT >::quiet_save | ( | const std::string | name, | |
const file_type | type = arma_binary | |||
) | const [inline, inherited] |
save the cube to a file, without printing any error messages
Definition at line 1928 of file Cube_meat.hpp.
{ arma_extra_debug_sigprint(); return (*this).save(name, type, false); }
bool Cube< eT >::quiet_save | ( | std::ostream & | os, | |
const file_type | type = arma_binary | |||
) | const [inline, inherited] |
save the cube to a stream, without printing any error messages
Definition at line 1941 of file Cube_meat.hpp.
{ arma_extra_debug_sigprint(); return (*this).save(os, type, false); }
bool Cube< eT >::quiet_load | ( | const std::string | name, | |
const file_type | type = auto_detect | |||
) | [inline, inherited] |
load a cube from a file, without printing any error messages
Definition at line 1954 of file Cube_meat.hpp.
{ arma_extra_debug_sigprint(); return (*this).load(name, type, false); }
bool Cube< eT >::quiet_load | ( | std::istream & | is, | |
const file_type | type = auto_detect | |||
) | [inline, inherited] |
load a cube from a stream, without printing any error messages
Definition at line 1967 of file Cube_meat.hpp.
{ arma_extra_debug_sigprint(); return (*this).load(is, type, false); }
Definition at line 1979 of file Cube_meat.hpp.
References Cube< eT >::memptr().
{ arma_extra_debug_sigprint(); return memptr(); }
Definition at line 1991 of file Cube_meat.hpp.
References Cube< eT >::memptr().
{ arma_extra_debug_sigprint(); return memptr(); }
Definition at line 2003 of file Cube_meat.hpp.
References Cube< eT >::memptr(), and Cube< eT >::n_elem.
Definition at line 2015 of file Cube_meat.hpp.
References Cube< eT >::memptr(), and Cube< eT >::n_elem.
Cube< eT >::slice_iterator Cube< eT >::begin_slice | ( | const u32 | slice_num | ) | [inline, inherited] |
Definition at line 2027 of file Cube_meat.hpp.
References Cube< eT >::n_slices, and Cube< eT >::slice_memptr().
{ arma_extra_debug_sigprint(); arma_debug_check( (slice_num >= n_slices), "begin_slice(): index out of bounds"); return slice_memptr(slice_num); }
Cube< eT >::const_slice_iterator Cube< eT >::begin_slice | ( | const u32 | slice_num | ) | const [inline, inherited] |
Definition at line 2041 of file Cube_meat.hpp.
References Cube< eT >::n_slices, and Cube< eT >::slice_memptr().
{ arma_extra_debug_sigprint(); arma_debug_check( (slice_num >= n_slices), "begin_slice(): index out of bounds"); return slice_memptr(slice_num); }
Cube< eT >::slice_iterator Cube< eT >::end_slice | ( | const u32 | slice_num | ) | [inline, inherited] |
Definition at line 2055 of file Cube_meat.hpp.
References Cube< eT >::n_elem_slice, Cube< eT >::n_slices, and Cube< eT >::slice_memptr().
{ arma_extra_debug_sigprint(); arma_debug_check( (slice_num >= n_slices), "end_slice(): index out of bounds"); return slice_memptr(slice_num) + n_elem_slice; }
Cube< eT >::const_slice_iterator Cube< eT >::end_slice | ( | const u32 | slice_num | ) | const [inline, inherited] |
Definition at line 2069 of file Cube_meat.hpp.
References Cube< eT >::n_elem_slice, Cube< eT >::n_slices, and Cube< eT >::slice_memptr().
{ arma_extra_debug_sigprint(); arma_debug_check( (slice_num >= n_slices), "end_slice(): index out of bounds"); return slice_memptr(slice_num) + n_elem_slice; }
arma_inline void Cube_aux::prefix_pp | ( | Cube< eT > & | x | ) | [static, inherited] |
prefix ++
Definition at line 2084 of file Cube_meat.hpp.
References Cube< eT >::memptr(), and Cube< eT >::n_elem.
Referenced by Cube< eT >::operator++().
arma_inline void Cube_aux::prefix_pp | ( | Cube< std::complex< T > > & | x | ) | [static, inherited] |
prefix ++ for complex numbers (work around for limitations of the std::complex class)
Definition at line 2109 of file Cube_meat.hpp.
{ x += T(1); }
arma_inline void Cube_aux::postfix_pp | ( | Cube< eT > & | x | ) | [static, inherited] |
postfix ++
Definition at line 2120 of file Cube_meat.hpp.
References Cube< eT >::memptr(), and Cube< eT >::n_elem.
Referenced by Cube< eT >::operator++().
arma_inline void Cube_aux::postfix_pp | ( | Cube< std::complex< T > > & | x | ) | [static, inherited] |
postfix ++ for complex numbers (work around for limitations of the std::complex class)
Definition at line 2145 of file Cube_meat.hpp.
{ x += T(1); }
arma_inline void Cube_aux::prefix_mm | ( | Cube< eT > & | x | ) | [static, inherited] |
prefix --
Definition at line 2156 of file Cube_meat.hpp.
References Cube< eT >::memptr(), and Cube< eT >::n_elem.
Referenced by Cube< eT >::operator--().
arma_inline void Cube_aux::prefix_mm | ( | Cube< std::complex< T > > & | x | ) | [static, inherited] |
prefix -- for complex numbers (work around for limitations of the std::complex class)
Definition at line 2181 of file Cube_meat.hpp.
{ x -= T(1); }
arma_inline void Cube_aux::postfix_mm | ( | Cube< eT > & | x | ) | [static, inherited] |
postfix --
Definition at line 2192 of file Cube_meat.hpp.
References Cube< eT >::memptr(), and Cube< eT >::n_elem.
Referenced by Cube< eT >::operator--().
arma_inline void Cube_aux::postfix_mm | ( | Cube< std::complex< T > > & | x | ) | [static, inherited] |
postfix ++ for complex numbers (work around for limitations of the std::complex class)
Definition at line 2217 of file Cube_meat.hpp.
{ x -= T(1); }