itpp::Mat< Num_T > Class Template Reference
Base Module » Array, Vector and Matrix Classes

Matrix Class (Templated) More...

`#include <itpp/base/mat.h>`

## Public Types

typedef Num_T | value_type
| The type of the matrix values.

## Public Member Functions

| Mat (const Factory &f=DEFAULT_FACTORY)
| Default constructor. An element factory `f` can be specified.
| Mat (int rows, int cols, const Factory &f=DEFAULT_FACTORY)
| Create a matrix of size (rows, cols). An element factory `f` can be specified.
| Mat (const Mat< Num_T > &m)
| Copy constructor.
| Mat (const Mat< Num_T > &m, const Factory &f)
| Constructor, similar to the copy constructor, but also takes an element factory `f` as argument.
| Mat (const Vec< Num_T > &v, const Factory &f=DEFAULT_FACTORY)
| Construct a matrix from a column vector `v`. An element factory `f` can be specified.
| Mat (const std::string &str, const Factory &f=DEFAULT_FACTORY)
| Set matrix equal to values in string `str`. An element factory `f` can be specified.
| Mat (const char *str, const Factory &f=DEFAULT_FACTORY)
| Set matrix equal to values in string `str`. An element factory `f` can be specified.
| Mat (const Num_T *c_array, int rows, int cols, bool row_major=true, const Factory &f=DEFAULT_FACTORY)
| Constructor taking a C-array as input. An element factory `f` can be specified. More...
| ~Mat ()
| Destructor.
int | cols () const
| The number of columns.
int | rows () const
| The number of rows.
int | size () const
| The number of elements.
void | set_size (int rows, int cols, bool copy=false)
| Set size of matrix. If copy = true then keep the data before resizing.
void | zeros ()
| Set matrix equal to the all zero matrix.
void | clear ()
| Set matrix equal to the all zero matrix.
void | ones ()
| Set matrix equal to the all one matrix.
void | set (const std::string &str)
| Set matrix equal to values in the string `str`.
void | set (const char *str)
| Set matrix equal to values in the string `str`.
const Num_T & | operator() (int r, int c) const
| Get element (r,c) from matrix.
Num_T & | operator() (int r, int c)
| Get element (r,c) from matrix.
const Num_T & | operator() (int i) const
| Get element `i` using linear addressing (by rows)
Num_T & | operator() (int i)
| Get element `i` using linear addressing (by rows)
const Num_T & | get (int r, int c) const
| Get element (r,c) from matrix.
const Num_T & | get (int i) const
| Get element `i` using linear addressing (by rows)
void | set (int r, int c, Num_T t)
| Set element (r,c) of matrix.
Mat< Num_T > | operator() (int r1, int r2, int c1, int c2) const
| Sub-matrix from row `r1` to row `r2` and columns `c1` to `c2`. More...
Mat< Num_T > | get (int r1, int r2, int c1, int c2) const
| Sub-matrix from row `r1` to row `r2` and columns `c1` to `c2`. More...
Vec< Num_T > | get_row (int r) const
| Get row `r`.
Mat< Num_T > | get_rows (int r1, int r2) const
| Get rows `r1` through `r2`.
Mat< Num_T > | get_rows (const Vec< int > &indexlist) const
| Get the rows specified by `indexlist`.
Vec< Num_T > | get_col (int c) const
| Get column `c`.
Mat< Num_T > | get_cols (int c1, int c2) const
| Get columns `c1` through `c2`.
Mat< Num_T > | get_cols (const Vec< int > &indexlist) const
| Get the columns specified by `indexlist`.
void | set_row (int r, const Vec< Num_T > &v)
| Set row `r` to vector `v`.
void | set_col (int c, const Vec< Num_T > &v)
| Set column `c` to vector `v`.
void | set_rows (int r, const Mat< Num_T > &m)
| Set rows to matrix `m`, staring from row `r`.
void | set_cols (int c, const Mat< Num_T > &m)
| Set columns to matrix `m`, starting from column `c`.
void | copy_row (int to, int from)
| Copy row `from` onto row `to`.
void | copy_col (int to, int from)
| Copy column `from` onto column `to`.
void | swap_rows (int r1, int r2)
| Swap the rows `r1` and `r2`.
void | swap_cols (int c1, int c2)
| Swap the columns `c1` and `c2`.
void | set_submatrix (int r1, int r2, int c1, int c2, const Mat< Num_T > &m)
| This function is deprecated. Please use set_submatrix(int r, int c, const Mat<> &m) instead.
void | set_submatrix (int r, int c, const Mat< Num_T > &m)
| Set submatrix defined by upper-left element (r,c) and the size of matrix m to m.
void | set_submatrix (int r1, int r2, int c1, int c2, Num_T t)
| Set all elements of submatrix defined by rows r1,r2 and columns c1,c2 to value t.
void | del_row (int r)
| Delete row number `r`.
void | del_rows (int r1, int r2)
| Delete rows from `r1` to `r2`.
void | del_col (int c)
| Delete column number `c`.
void | del_cols (int c1, int c2)
| Delete columns from `c1` to `c2`.
void | ins_row (int r, const Vec< Num_T > &v)
| Insert vector `v` at row number `r`. The matrix can be empty.
void | ins_col (int c, const Vec< Num_T > &v)
| Insert vector `v` at column number `c`. The matrix can be empty.
void | append_row (const Vec< Num_T > &v)
| Append vector `v` to the bottom of the matrix. The matrix can be empty.
void | append_col (const Vec< Num_T > &v)
| Append vector `v` to the right side of the matrix. The matrix can be empty.
Mat< Num_T > | transpose () const
| Matrix transpose.
Mat< Num_T > | T () const
| Matrix transpose.
Mat< Num_T > | hermitian_transpose () const
| Hermitian matrix transpose (conjugate transpose)
Mat< Num_T > | H () const
| Hermitian matrix transpose (conjugate transpose)
Mat< Num_T > & | operator= (Num_T t)
| Set all elements of the matrix equal to `t`.
Mat< Num_T > & | operator= (const Mat< Num_T > &m)
| Set matrix equal to `m`.
Mat< Num_T > & | operator= (const Vec< Num_T > &v)
| Set matrix equal to the vector `v`, assuming column vector.
Mat< Num_T > & | operator= (const std::string &str)
| Set matrix equal to values in the string `str`.
Mat< Num_T > & | operator= (const char *str)
| Set matrix equal to values in the string `str`.
Mat< Num_T > & | operator+= (const Mat< Num_T > &m)
| Addition of matrices.
Mat< Num_T > & | operator+= (Num_T t)
| Addition of scalar to matrix.
Mat< Num_T > & | operator-= (const Mat< Num_T > &m)
| Subtraction of matrix.
Mat< Num_T > & | operator-= (Num_T t)
| Subtraction of scalar from matrix.
Mat< Num_T > & | operator*= (const Mat< Num_T > &m)
| Matrix multiplication.
Mat< Num_T > & | operator*= (Num_T t)
| Multiplication by a scalar.
Mat< Num_T > & | operator/= (Num_T t)
| Division by a scalar.
Mat< Num_T > & | operator/= (const Mat< Num_T > &m)
| Element-wise division with the current matrix.
bool | operator== (const Mat< Num_T > &m) const
| Compare two matrices. False if wrong sizes or different values.
bool | operator!= (const Mat< Num_T > &m) const
| Compare two matrices. True if different.
Num_T & | _elem (int r, int c)
| Get element (r,c) from matrix without boundary check (not recommended to use)
const Num_T & | _elem (int r, int c) const
| Get element (r,c) from matrix without boundary check (not recommended to use)
Num_T & | _elem (int i)
| Get element `i` using linear addressing (by rows) without boundary check (not recommended to use)
const Num_T & | _elem (int i) const
| Get element `i` using linear addressing (by rows) without boundary check (not recommended to use)
Num_T * | _data ()
| Access of the internal data structure (not recommended to use)
const Num_T * | _data () const
| Access to the internal data structure (not recommended to use)
int | _datasize () const
| Access to the internal data structure (not recommended to use)

## Protected Member Functions

void | alloc (int rows, int cols)
| Allocate memory for the matrix.
void | free ()
| Free the memory space of the matrix.

## Protected Attributes

Num_T * | data
| Protected data pointer.
const Factory & | factory
| Element factory (set to DEFAULT_FACTORY to use Num_T default constructors only)
int | datasize
int | no_rows
int | no_cols

## Friends

Mat< Num_T > | concat_horizontal (const Mat< Num_T > &m1, const Mat< Num_T > &m2)
| Concatenate the matrices `m1` and `m2` horizontally.
Mat< Num_T > | concat_vertical (const Mat< Num_T > &m1, const Mat< Num_T > &m2)
| Concatenate the matrices `m1` and `m2` vertically.
Mat< Num_T > | operator+ (const Mat< Num_T > &m1, const Mat< Num_T > &m2)
| Addition of two matrices.
Mat< Num_T > | operator+ (const Mat< Num_T > &m, Num_T t)
| Addition of matrix and scalar.
Mat< Num_T > | operator+ (Num_T t, const Mat< Num_T > &m)
| Addition of scalar and matrix.
Mat< Num_T > | operator- (const Mat< Num_T > &m1, const Mat< Num_T > &m2)
| Subtraction of `m2` from `m1`.
Mat< Num_T > | operator- (const Mat< Num_T > &m, Num_T t)
| Subtraction of scalar from matrix.
Mat< Num_T > | operator- (Num_T t, const Mat< Num_T > &m)
| Subtract matrix from scalar.
Mat< Num_T > | operator- (const Mat< Num_T > &m)
| Subtraction of matrix.
Mat< Num_T > | elem_mult (const Mat< Num_T > &m1, const Mat< Num_T > &m2)
| Element wise multiplication of two matrices.
void | elem_mult_out (const Mat< Num_T > &m1, const Mat< Num_T > &m2, Mat< Num_T > &out)
| Element wise multiplication of two matrices, storing the result in matrix `out`.
void | elem_mult_out (const Mat< Num_T > &m1, const Mat< Num_T > &m2, const Mat< Num_T > &m3, Mat< Num_T > &out)
| Element wise multiplication of three matrices, storing the result in matrix `out`.
void | elem_mult_out (const Mat< Num_T > &m1, const Mat< Num_T > &m2, const Mat< Num_T > &m3, const Mat< Num_T > &m4, Mat< Num_T > &out)
| Element wise multiplication of four matrices, storing the result in matrix `out`.
void | elem_mult_inplace (const Mat< Num_T > &m1, Mat< Num_T > &m2)
| In-place element wise multiplication of two matrices. Fast version of B = elem_mult(A, B).
Num_T | elem_mult_sum (const Mat< Num_T > &m1, const Mat< Num_T > &m2)
| Element wise multiplication of two matrices, followed by summation of the resultant elements. Fast version of sumsum(elem_mult(A, B)).
Mat< Num_T > | operator/ (const Mat< Num_T > &m, Num_T t)
| Element-wise division by a scalar.
Mat< Num_T > | operator/ (Num_T t, const Mat< Num_T > &m)
| Element-wise division (`t` is the dividend, elements of `m` are divisors)
Mat< Num_T > | elem_div (const Mat< Num_T > &m1, const Mat< Num_T > &m2)
| Element wise division of two matrices.
void | elem_div_out (const Mat< Num_T > &m1, const Mat< Num_T > &m2, Mat< Num_T > &out)
| Element wise division of two matrices, storing the result in matrix `out`.
Num_T | elem_div_sum (const Mat< Num_T > &m1, const Mat< Num_T > &m2)
| Element wise division of two matrices, followed by summation of the resultant elements. Fast version of sumsum(elem_div(A, B)).

## Related Functions

(Note that these are not member functions.)
typedef Mat< double > | mat
| Default Matrix Type.
typedef Mat< std::complex< double > > | cmat
| Default Complex Matrix Type.
typedef Mat< int > | imat
| Integer matrix.
typedef Mat< short int > | smat
| short int matrix
template<class T >
bmat | to_bmat (const Mat< T > &m)
| Converts a Mat<T> to bmat.
template<class T >
smat | to_smat (const Mat< T > &m)
| Converts a Mat<T> to smat.
template<class T >
imat | to_imat (const Mat< T > &m)
| Converts a Mat<T> to imat.
template<class T >
mat | to_mat (const Mat< T > &m)
| Converts a Mat<T> to mat.
template<class T >
cmat | to_cmat (const Mat< T > &m)
| Converts a Mat<T> to cmat.
template<class T >
cmat | to_cmat (const Mat< T > &real, const Mat< T > &imag)
| Converts real and imaginary Mat<T> to cmat.
ITPP_EXPORT void | sub_v_vT_m (mat &m, const vec &v)
| Calculates m=m-v*v'*m.
ITPP_EXPORT void | sub_m_v_vT (mat &m, const vec &v)
| Calculates m=m-m*v*v'.
template<class Num_T >
std::ostream & | operator<< (std::ostream &os, const Mat< Num_T > &m)
| Output stream for matrices.
template<class Num_T >
std::istream & | operator>> (std::istream &is, Mat< Num_T > &m)
| Input stream for matrices. More...
template<class T >
Mat< T > | repmat (const Mat< T > &data, int m, int n)
| Creates a matrix with `m` by `n` copies of the matrix `data`. More...
template<class T >
Mat< T > | repmat (const Vec< T > &v, int m, int n, bool transpose=false)
| Returns a matrix with `m` by `n` copies of the vector `data`. More...
mat | operator+ (const float &s, const mat &m)
| Addition operator for float and mat.
mat | operator+ (const short &s, const mat &m)
| Addition operator for short and mat.
mat | operator+ (const int &s, const mat &m)
| Addition operator for int and mat.
mat | operator+ (const mat &m, const float &s)
| Addition operator for mat and float.
mat | operator+ (const mat &m, const short &s)
| Addition operator for mat and short.
mat | operator+ (const mat &m, const int &s)
| Addition operator for mat and int.
mat | operator- (const float &s, const mat &m)
| Subtraction operator for float and mat.
mat | operator- (const short &s, const mat &m)
| Subtraction operator for short and mat.
mat | operator- (const int &s, const mat &m)
| Subtraction operator for int and mat.
mat | operator- (const mat &m, const float &s)
| Subtraction operator for mat and float.
mat | operator- (const mat &m, const short &s)
| Subtraction operator for mat and short.
mat | operator- (const mat &m, const int &s)
| Subtraction operator for mat and int.
mat | operator* (const float &s, const mat &m)
| Multiplication operator for float and mat.
mat | operator* (const short &s, const mat &m)
| Multiplication operator for short and mat.
mat | operator* (const int &s, const mat &m)
| Multiplication operator for int and mat.
mat | operator* (const mat &m, const float &s)
| Multiplication operator for mat and float.
mat | operator* (const mat &m, const short &s)
| Multiplication operator for mat and short.
mat | operator* (const mat &m, const int &s)
| Multiplication operator for mat and int.
mat | operator/ (const mat &m, const float &s)
| Division operator for mat and float.
mat | operator/ (const mat &m, const short &s)
| Division operator for mat and short.
mat | operator/ (const mat &m, const int &s)
| Division operator for mat and int.
ITPP_EXPORT cmat | operator+ (const double &s, const cmat &m)
| Addition operator for double and cmat.
ITPP_EXPORT cmat | operator- (const double &s, const cmat &m)
| Subtraction operator for double and cmat.
ITPP_EXPORT cmat | operator* (const double &s, const cmat &m)
| Multiplication operator for double and cmat.
ITPP_EXPORT cmat | operator* (const std::complex< double > &s, const mat &m)
| Multiplication operator for complex<double> and mat.
cmat | operator* (const mat &m, const std::complex< double > &s)
| Multiplication operator for mat and complex<double>
ITPP_EXPORT cmat | operator/ (const cmat &m, const double &s)
| Division operator for cmat and double.
ITPP_EXPORT mat | operator+ (const bmat &a, const mat &b)
| Addition operator for bmat and mat.
ITPP_EXPORT mat | operator+ (const smat &a, const mat &b)
| Addition operator for smat and mat.
ITPP_EXPORT mat | operator+ (const imat &a, const mat &b)
| Addition operator for imat and mat.
mat | operator+ (const mat &a, const bmat &b)
| Addition operator for mat and bmat.
mat | operator+ (const mat &a, const smat &b)
| Addition operator for mat and smat.
mat | operator+ (const mat &a, const imat &b)
| Addition operator for mat and imat.
mat | operator- (const bmat &a, const mat &b)
| Subtraction operator for bmat and mat.
mat | operator- (const smat &a, const mat &b)
| Subtraction operator for smat and mat.
mat | operator- (const imat &a, const mat &b)
| Subtraction operator for imat and mat.
mat | operator- (const mat &a, const bmat &b)
| Subtraction operator for mat and bmat.
mat | operator- (const mat &a, const smat &b)
| Subtraction operator for mat and smat.
mat | operator- (const mat &a, const imat &b)
| Subtraction operator for mat and imat.
ITPP_EXPORT cmat | operator+ (const bmat &a, const cmat &b)
| Addition operator for bmat and cmat.
ITPP_EXPORT cmat | operator+ (const smat &a, const cmat &b)
| Addition operator for smat and cmat.
ITPP_EXPORT cmat | operator+ (const imat &a, const cmat &b)
| Addition operator for imat and cmat.
ITPP_EXPORT cmat | operator+ (const mat &a, const cmat &b)
| Addition operator for mat and cmat.
cmat | operator+ (const cmat &a, const bmat &b)
| Addition operator for cmat and bmat.
cmat | operator+ (const cmat &a, const smat &b)
| Addition operator for cmat and smat.
cmat | operator+ (const cmat &a, const imat &b)
| Addition operator for cmat and imat.
cmat | operator+ (const cmat &a, const mat &b)
| Addition operator for cmat and mat.
cmat | operator- (const bmat &a, const cmat &b)
| Subtraction operator for bmat and cmat.
cmat | operator- (const smat &a, const cmat &b)
| Subtraction operator for smat and cmat.
cmat | operator- (const imat &a, const cmat &b)
| Subtraction operator for imat and cmat.
cmat | operator- (const mat &a, const cmat &b)
| Subtraction operator for mat and cmat.
cmat | operator- (const cmat &a, const bmat &b)
| Subtraction operator for cmat and bmat.
cmat | operator- (const cmat &a, const smat &b)
| Subtraction operator for cmat and smat.
cmat | operator- (const cmat &a, const imat &b)
| Subtraction operator for cmat and imat.
cmat | operator- (const cmat &a, const mat &b)
| Subtraction operator for cmat and mat.
cmat | operator* (const mat &a, const cmat &b)
| Multiplication operator for mat and cmat.
cmat | operator* (const bmat &a, const cmat &b)
| Multiplication operator for bmat and cmat.
cmat | operator* (const smat &a, const cmat &b)
| Multiplication operator for smat and cmat.
cmat | operator* (const imat &a, const cmat &b)
| Multiplication operator for imat and cmat.
cmat | operator* (const cmat &a, const mat &b)
| Multiplication operator for cmat and mat.
cmat | operator* (const cmat &a, const bmat &b)
| Multiplication operator for cmat and bmat.
cmat | operator* (const cmat &a, const smat &b)
| Multiplication operator for cmat and smat.
cmat | operator* (const cmat &a, const imat &b)
| Multiplication operator for cmat and imat.
template<class T >
Mat< T > | mat_1x1 (T m00)
| Matrix of size 1 by 1.
template<class T >
Mat< T > | mat_1x2 (T m00, T m01)
| Matrix of size 1 by 2.
template<class T >
Mat< T > | mat_2x1 (T m00, T m10)
| Matrix of size 2 by 1.
template<class T >
Mat< T > | mat_2x2 (T m00, T m01, T m10, T m11)
| Matrix of size 2 by 2.
template<class T >
Mat< T > | mat_1x3 (T m00, T m01, T m02)
| Matrix of size 1 by 3.
template<class T >
Mat< T > | mat_3x1 (T m00, T m10, T m20)
| Matrix of size 3 by 1.
template<class T >
Mat< T > | mat_2x3 (T m00, T m01, T m02, T m10, T m11, T m12)
| Matrix of size 2 by 3.
template<class T >
Mat< T > | mat_3x2 (T m00, T m01, T m10, T m11, T m20, T m21)
| Matrix of size 3 by 2.
template<class T >
Mat< T > | mat_3x3 (T m00, T m01, T m02, T m10, T m11, T m12, T m20, T m21, T m22)
| Matrix of size 3 by 3.

## Detailed Description

### template<class Num_T>
class itpp::Mat< Num_T >

Matrix Class (Templated)

Author
  Tony Ottosson, Tobias Ringstrom, Adam Piatyszek and Conrad Sanderson

Matrices can be of arbitrarily types, but conversions and functions are prepared for `bin`, `short`, `int`, `double`, and `complex<double>` vectors and these are predefined as: `bmat`, `smat`, `imat`, `mat`, and `cmat`. `double` and `complex<double>` are usually `double` and `complex<double>` respectively. However, this can be changed when compiling the it++ (see installation notes for more details). (Note: for binary matrices, an alternative to the bmat class is `GF2mat` and `GF2mat_dense`, which offer a more memory efficient representation and additional functions for linear algebra.)

Examples:

Matrix Constructors: When constructing a matrix without dimensions (memory) use

mat temp;

For construction of a matrix of a given size use

mat temp(rows, cols);

It is also possible to assign the constructed matrix the value and dimension of another matrix by

vec temp(inmatrix);

If you have explicit values you would like to assign to the matrix it is possible to do this using strings as:

mat a("0 0.7;5 9.3"); // that is a = [0, 0.7; 5, 9.3]
mat a="0 0.7;5 9.3"; // the constructor are called implicitly

It is also possible to change dimension by

temp.set_size(new_rows, new_cols, false);

where `false` is used to indicate that the old values in `temp` is not copied. If you like to preserve the values use `true`.

There are a number of methods to access parts of a matrix. Examples are

a(5,3); // Element number (5,3)
a(5,9,3,5); // Sub-matrix from rows 5, 6, 7, 8, 9 the columns 3, 4, and 5
a.get_row(10); // Row 10
a.get_col(10); // Column 10

It is also possible to modify parts of a vector as e.g. in

a.set_row(5, invector); // Set row 5 to \c invector
a.set_col(3, invector); // Set column 3 to \c invector
a.copy_col(1, 5); // Copy column 5 to column 1
a.swap_cols(1, 5); // Swap the contents of columns 1 and 5

It is of course also possible to perform the common linear algebra methods such as addition, subtraction, and matrix multiplication. Observe though, that vectors are assumed to be column-vectors in operations with matrices.

Most elementary functions such as sin(), cosh(), log(), abs(), ..., are available as operations on the individual elements of the matrices. Please see the individual functions for more details.

By default, the Mat elements are created using the default constructor for the element type. This can be changed by specifying a suitable Factory in the Mat constructor call; see Detailed Description for Factory.

Definition at line 41 of file factory.h.

## Constructor & Destructor Documentation

## Mat()

template<class Num_T>

itpp::Mat< Num_T >::Mat | ( | const Num_T * | c_array,
|  | int | rows,
|  | int | cols,
|  | bool | row_major = `true`,
|  | const Factory & | f = `DEFAULT_FACTORY`
| ) |  |

Constructor taking a C-array as input. An element factory `f` can be specified.

By default the matrix is stored as a row-major matrix (i.e. listing elements in sequence beginning with the first column).

Definition at line 626 of file mat.h.

## Member Function Documentation

## operator()()

template<class Num_T >

Mat< Num_T > itpp::Mat< Num_T >::operator() | ( | int | r1,
|  | int | r2,
|  | int | c1,
|  | int | c2
| ) |  | const

inline

Sub-matrix from row `r1` to row `r2` and columns `c1` to `c2`.

Value -1 indicates the last row and column, respectively.

Definition at line 826 of file mat.h.

## get()

template<class Num_T >

Mat< Num_T > itpp::Mat< Num_T >::get | ( | int | r1,
|  | int | r2,
|  | int | c1,
|  | int | c2
| ) |  | const

inline

Sub-matrix from row `r1` to row `r2` and columns `c1` to `c2`.

Value -1 indicates the last row and column, respectively.

Definition at line 846 of file mat.h.

## Friends And Related Function Documentation

## operator>>()

template<class Num_T >

std::istream & operator>> | ( | std::istream & | is,
|  | Mat< Num_T > & | m
| ) |  |

related

Input stream for matrices.

The input can be on the form "1 2 3; 4 5 6" or "[[1 2 3][4 5 6]]", i.e. with brackets or semicolons as row delimiters. The first form is compatible with the set method, while the second form is compatible with the ostream operator. The elements on a row can be separated by blank space or commas. Rows that are shorter than the longest row are padded with zero elements. "[]" means an empty matrix.

Definition at line 1765 of file mat.h.

## Member Data Documentation

## datasize

template<class Num_T>

int itpp::Mat< Num_T >::datasize

protected

Protected integer variables

Definition at line 454 of file mat.h.

Referenced by itpp::Mat< bin >::_datasize(), itpp::Mat< bin >::alloc(), itpp::Mat< bin >::free(), and itpp::Mat< bin >::size().

## no_rows

template<class Num_T>

int itpp::Mat< Num_T >::no_rows

protected

Protected integer variables

Definition at line 454 of file mat.h.

Referenced by itpp::Mat< bin >::_elem(), itpp::Mat< bin >::alloc(), itpp::Mat< bin >::free(), and itpp::Mat< bin >::rows().

## no_cols

template<class Num_T>

int itpp::Mat< Num_T >::no_cols

protected

Protected integer variables

Definition at line 454 of file mat.h.

Referenced by itpp::Mat< bin >::alloc(), itpp::Mat< bin >::cols(), and itpp::Mat< bin >::free().

The documentation for this class was generated from the following files:

- itpp/base/factory.h
- itpp/base/mat.h
- itpp/base/converters.h
- itpp/base/fastmath.h
- itpp/base/matfunc.h
- itpp/base/operators.h
- itpp/base/specmat.h
- itpp/fixed/cfix.cpp
- itpp/fixed/cfix.h
- itpp/fixed/fix.cpp
- itpp/fixed/fix.h

Generated on Sat Sep 30 2017 07:04:09 for IT++ by Doxygen 1.8.13