coco
873 lines
28 KiB
C++
873 lines
28 KiB
C++
// Copyright (C) 2006 Davis E. King (davis@dlib.net)
|
|
// License: Boost Software License See LICENSE.txt for the full license.
|
|
#undef DLIB_MATRIx_ABSTRACT_
|
|
#ifdef DLIB_MATRIx_ABSTRACT_
|
|
|
|
#include "matrix_exp_abstract.h"
|
|
#include "../serialize.h"
|
|
#include "../algs.h"
|
|
#include "matrix_data_layout_abstract.h"
|
|
|
|
namespace dlib
|
|
{
|
|
|
|
// ----------------------------------------------------------------------------------------
|
|
|
|
/*
|
|
Note that these operator prototypes are not correct C++ (the real versions, which
|
|
you can see in the implementation are really complex and so probably would
|
|
distract/confuse people if shown here). Think of this as just a list of the
|
|
operators available to you and what they do.
|
|
*/
|
|
|
|
const matrix_exp operator* (
|
|
const matrix_exp& m1,
|
|
const matrix_exp& m2
|
|
);
|
|
/*!
|
|
requires
|
|
- m1.nc() == m2.nr()
|
|
- m1.size() > 0 && m2.size() > 0
|
|
(you can't multiply any sort of empty matrices together)
|
|
- m1 and m2 both contain elements of the same type
|
|
ensures
|
|
- returns the result of doing the matrix multiplication m1*m2. The resulting
|
|
matrix will have m1.nr() rows and m2.nc() columns.
|
|
!*/
|
|
|
|
const matrix_exp operator+ (
|
|
const matrix_exp& m1,
|
|
const matrix_exp& m2
|
|
);
|
|
/*!
|
|
requires
|
|
- m1.nr() == m2.nr()
|
|
- m1.nc() == m2.nc()
|
|
- m1 and m2 both contain elements of the same type
|
|
ensures
|
|
- returns a matrix R such that for all valid r and c:
|
|
R(r,c) == m1(r,c) + m2(r,c)
|
|
(i.e. returns the result of doing a pairwise addition of the matrices m1 and m2.)
|
|
The resulting matrix will have the same dimensions as the originals.
|
|
!*/
|
|
|
|
const matrix_exp operator- (
|
|
const matrix_exp& m1,
|
|
const matrix_exp& m2
|
|
);
|
|
/*!
|
|
requires
|
|
- m1.nr() == m2.nr()
|
|
- m1.nc() == m2.nc()
|
|
- m1 and m2 both contain elements of the same type
|
|
ensures
|
|
- returns a matrix R such that for all valid r and c:
|
|
R(r,c) == m1(r,c) - m2(r,c)
|
|
(i.e. returns the result of doing a pairwise subtraction of the matrices m1 and m2.)
|
|
The resulting matrix will have the same dimensions as the originals.
|
|
!*/
|
|
|
|
template <typename T>
|
|
const matrix_exp operator* (
|
|
const matrix_exp& m,
|
|
const T& value
|
|
);
|
|
/*!
|
|
ensures
|
|
- returns the result of multiplying all the elements of matrix m by the given
|
|
scalar value. The resulting matrix will have the same dimensions as m.
|
|
!*/
|
|
|
|
template <typename T>
|
|
const matrix_exp operator* (
|
|
const T& value,
|
|
const matrix_exp& m
|
|
);
|
|
/*!
|
|
ensures
|
|
- returns the result of multiplying all the elements of matrix m by the given
|
|
scalar value. The resulting matrix will have the same dimensions as m.
|
|
!*/
|
|
|
|
const matrix_exp operator- (
|
|
const matrix_exp& m
|
|
);
|
|
/*!
|
|
ensures
|
|
- returns -1*m
|
|
!*/
|
|
|
|
template <typename T>
|
|
const matrix_exp operator/ (
|
|
const matrix_exp& m,
|
|
const T& value
|
|
);
|
|
/*!
|
|
ensures
|
|
- returns the result of dividing all the elements of matrix m by the given
|
|
scalar value. The resulting matrix will have the same dimensions as m.
|
|
!*/
|
|
|
|
template <typename T>
|
|
const matrix_exp operator/ (
|
|
const T& value,
|
|
const matrix_exp& m
|
|
);
|
|
/*!
|
|
ensures
|
|
- returns the result of dividing the given scalar value by all the elements
|
|
of matrix m. The resulting matrix will have the same dimensions as m.
|
|
!*/
|
|
|
|
template <typename T>
|
|
const matrix_exp operator+ (
|
|
const matrix_exp& m,
|
|
const T& value
|
|
);
|
|
/*!
|
|
ensures
|
|
- returns the result of adding value to all the elements of matrix m.
|
|
The resulting matrix will have the same dimensions as m.
|
|
!*/
|
|
|
|
template <typename T>
|
|
const matrix_exp operator+ (
|
|
const T& value,
|
|
const matrix_exp& m
|
|
);
|
|
/*!
|
|
ensures
|
|
- returns the result of adding value to all the elements of matrix m.
|
|
The resulting matrix will have the same dimensions as m.
|
|
!*/
|
|
|
|
template <typename T>
|
|
const matrix_exp operator- (
|
|
const matrix_exp& m,
|
|
const T& value
|
|
);
|
|
/*!
|
|
ensures
|
|
- returns the result of subtracting value from all the elements of matrix m.
|
|
The resulting matrix will have the same dimensions as m.
|
|
!*/
|
|
|
|
template <typename T>
|
|
const matrix_exp operator- (
|
|
const T& value,
|
|
const matrix_exp& m
|
|
);
|
|
/*!
|
|
ensures
|
|
- Returns a matrix M such that:
|
|
- M has the same dimensions as m
|
|
- M contains the same type of element as m
|
|
- for all valid r and c:
|
|
- M(r,c) == value - m(r,c)
|
|
!*/
|
|
|
|
bool operator== (
|
|
const matrix_exp& m1,
|
|
const matrix_exp& m2
|
|
);
|
|
/*!
|
|
ensures
|
|
- if (m1.nr() == m2.nr() && m1.nc() == m2.nc() &&
|
|
for all valid r and c: m1(r,c) == m2(r,c) ) then
|
|
- returns true
|
|
- else
|
|
- returns false
|
|
!*/
|
|
|
|
bool operator!= (
|
|
const matrix_exp& m1,
|
|
const matrix_exp& m2
|
|
);
|
|
/*!
|
|
ensures
|
|
- returns !(m1 == m2)
|
|
!*/
|
|
|
|
// ----------------------------------------------------------------------------------------
|
|
|
|
template <
|
|
typename T,
|
|
long num_rows = 0,
|
|
long num_cols = 0,
|
|
typename mem_manager = default_memory_manager,
|
|
typename layout = row_major_layout
|
|
>
|
|
class matrix : public matrix_exp<matrix<T,num_rows,num_cols,mem_manager,layout> >
|
|
{
|
|
/*!
|
|
REQUIREMENTS ON num_rows and num_cols
|
|
both must be bigger than or equal to 0
|
|
|
|
REQUIREMENTS ON mem_manager
|
|
must be an implementation of memory_manager/memory_manager_kernel_abstract.h or
|
|
must be an implementation of memory_manager_global/memory_manager_global_kernel_abstract.h or
|
|
must be an implementation of memory_manager_stateless/memory_manager_stateless_kernel_abstract.h
|
|
mem_manager::type can be set to anything.
|
|
|
|
REQUIREMENTS ON layout
|
|
Must be either row_major_layout or column_major_layout
|
|
|
|
INITIAL VALUE
|
|
- if (num_rows > 0) then
|
|
- nr() == num_rows
|
|
- else
|
|
- nr() == 0
|
|
|
|
- if (num_cols > 0) then
|
|
- nc() == num_cols
|
|
- else
|
|
- nc() == 0
|
|
|
|
WHAT THIS OBJECT REPRESENTS
|
|
This object represents a matrix of nr() rows and nc() columns. This object
|
|
is also a matrix_exp. Thus it can be used in all of the above
|
|
global operators.
|
|
|
|
The number of rows and columns of this object are determined by the template
|
|
arguments num_rows and num_cols. If num_rows or num_cols are 0 then
|
|
the matrix starts out empty (i.e. nr() == 0 and nc() == 0) and you may change
|
|
its size via the set_size() member function.
|
|
|
|
Setting num_rows or num_cols to something other than 0 causes that dimension
|
|
to have a fixed size. Setting a fixed size at compile time is useful because
|
|
any errors related to operating on matrices with incompatible dimensions will
|
|
be detected at compile time. It also allows the compiler to perform loop
|
|
unrolling which can result in substantially faster code.
|
|
|
|
Also note that the elements of this matrix are laid out in memory by the layout
|
|
object supplied as a template argument to this class. The row_major_layout
|
|
sets elements down contiguously in memory and in row major order. Additionally,
|
|
all memory allocations are performed using the memory manager object supplied as
|
|
a template argument to this class.
|
|
!*/
|
|
|
|
public:
|
|
typedef T type;
|
|
typedef mem_manager mem_manager_type;
|
|
typedef layout layout_type;
|
|
const static long NR = num_rows;
|
|
const static long NC = num_cols;
|
|
const static long cost = 1;
|
|
typedef T* iterator;
|
|
typedef const T* const_iterator;
|
|
|
|
matrix (
|
|
);
|
|
/*!
|
|
ensures
|
|
- #*this is properly initialized
|
|
- #aliases(*this) == true
|
|
- #ref().aliases(*this) == true
|
|
!*/
|
|
|
|
explicit matrix (
|
|
long length
|
|
);
|
|
/*!
|
|
requires
|
|
- NR == 1 || NC == 1 (i.e. this must be a column or row vector)
|
|
- length >= 0
|
|
- if (NR == 1 && NC > 0) then
|
|
- length == NC
|
|
- if (NC == 1 && NR > 0) then
|
|
- length == NR
|
|
ensures
|
|
- #*this is properly initialized
|
|
- #aliases(*this) == true
|
|
- #ref().aliases(*this) == true
|
|
- if (NR == 1) then
|
|
- #nr() == 1
|
|
- #nc() == length
|
|
- else
|
|
- #nr() == length
|
|
- #nc() == 1
|
|
!*/
|
|
|
|
matrix (
|
|
long rows,
|
|
long cols
|
|
);
|
|
/*!
|
|
requires
|
|
- rows == NR || NR == 0
|
|
- cols == NC || NC == 0
|
|
- rows >= 0 && cols >= 0
|
|
ensures
|
|
- #*this is properly initialized
|
|
- #aliases(*this) == true
|
|
- #ref().aliases(*this) == true
|
|
- #nr() == rows
|
|
- #nc() == cols
|
|
!*/
|
|
|
|
template <typename EXP>
|
|
matrix (
|
|
const matrix_exp<EXP>& m
|
|
);
|
|
/*!
|
|
requires
|
|
- matrix_exp<EXP>::type == T
|
|
(i.e. m contains the same type as *this does)
|
|
- if (NR != 0) then NR == m.nr()
|
|
- if (NC != 0) then NC == m.nc()
|
|
ensures
|
|
- #*this == m
|
|
- #aliases(*this) == true
|
|
- #ref().aliases(*this) == true
|
|
!*/
|
|
|
|
template <typename U, size_t len>
|
|
explicit matrix (
|
|
U (&array)[len]
|
|
);
|
|
/*!
|
|
requires
|
|
- NR != 0 && NC != 0 (i.e. you can only use this constructor on statically sized matrices)
|
|
- len == nr()*nc() (i.e. the array you give here must be the right size)
|
|
ensures
|
|
- for all valid r and c:
|
|
#(*this)(r,c) == array[r*nc() + c]
|
|
(i.e. initializes this matrix with the contents of the given array)
|
|
- #aliases(*this) == true
|
|
- #ref().aliases(*this) == true
|
|
!*/
|
|
|
|
matrix(
|
|
const std::initializer_list<T>& l
|
|
);
|
|
/*!
|
|
requires
|
|
- This matrix is capable of having a size() == l.size(). Therefore, if
|
|
NR*NC != 0 then l.size() must equal NR*NC. Alternatively, if NR or NC is
|
|
!= 0 then l.size() must be a multiple of the non-zero NR or NC.
|
|
ensures
|
|
- #size() == l.size()
|
|
- The contents of l are enumerated and read into the matrix in row major order.
|
|
- if (NR != 0) then
|
|
- #nr() == NR
|
|
- #nc() == l.size()/NR
|
|
- if (NC != 0) then
|
|
- #nr() == l.size()/NC
|
|
- #nc() == NC
|
|
- if (NR*NC==0) then
|
|
- #nr() == l.size()
|
|
- #nc() == 1
|
|
- #aliases(*this) == true
|
|
- #ref().aliases(*this) == true
|
|
!*/
|
|
|
|
T& operator() (
|
|
long r,
|
|
long c
|
|
);
|
|
/*!
|
|
requires
|
|
- 0 <= r < nr()
|
|
- 0 <= c < nc()
|
|
ensures
|
|
- returns a reference to the value at the given row and column in
|
|
this matrix.
|
|
!*/
|
|
|
|
const T& operator() (
|
|
long r,
|
|
long c
|
|
) const;
|
|
/*!
|
|
requires
|
|
- 0 <= r < nr()
|
|
- 0 <= c < nc()
|
|
ensures
|
|
- returns a const reference to the value at the given row and column in
|
|
this matrix.
|
|
!*/
|
|
|
|
T& operator() (
|
|
long i
|
|
);
|
|
/*!
|
|
requires
|
|
- nc() == 1 || nr() == 1 (i.e. this must be a column or row vector)
|
|
- 0 <= i < size()
|
|
ensures
|
|
- if (nc() == 1) then
|
|
- returns a reference to (*this)(i,0)
|
|
- else
|
|
- returns a reference to (*this)(0,i)
|
|
!*/
|
|
|
|
const T& operator() (
|
|
long i
|
|
) const;
|
|
/*!
|
|
requires
|
|
- nc() == 1 || nr() == 1 (i.e. this must be a column or row vector)
|
|
- 0 <= i < size()
|
|
ensures
|
|
- if (nc() == 1) then
|
|
- returns a reference to (*this)(i,0)
|
|
- else
|
|
- returns a reference to (*this)(0,i)
|
|
!*/
|
|
|
|
operator const type (
|
|
) const;
|
|
/*!
|
|
requires
|
|
- nr() == 1
|
|
- nc() == 1
|
|
ensures
|
|
- returns (*this)(0,0)
|
|
!*/
|
|
|
|
long nr(
|
|
) const;
|
|
/*!
|
|
ensures
|
|
- returns the number of rows in this matrix
|
|
!*/
|
|
|
|
long nc(
|
|
) const;
|
|
/*!
|
|
ensures
|
|
- returns the number of columns in this matrix
|
|
!*/
|
|
|
|
long size (
|
|
) const;
|
|
/*!
|
|
ensures
|
|
- returns nr()*nc()
|
|
!*/
|
|
|
|
void set_size (
|
|
long rows,
|
|
long cols
|
|
);
|
|
/*!
|
|
requires
|
|
- rows == NR || NR == 0
|
|
- cols == NC || NC == 0
|
|
- rows >= 0 && cols >= 0
|
|
ensures
|
|
- #nr() == rows
|
|
- #nc() == cols
|
|
!*/
|
|
|
|
void set_size (
|
|
long length
|
|
);
|
|
/*!
|
|
requires
|
|
- NR == 1 || NC == 1 (i.e. this must be a column or row vector)
|
|
- length >= 0
|
|
- if (NR == 1 && NC > 0) then
|
|
- length == NC
|
|
- if (NC == 1 && NR > 0) then
|
|
- length == NR
|
|
ensures
|
|
- if (NR == 1) then
|
|
- #nr() == 1
|
|
- #nc() == length
|
|
- else
|
|
- #nr() == length
|
|
- #nc() == 1
|
|
!*/
|
|
|
|
std::unique_ptr<T[]> steal_memory(
|
|
);
|
|
/*!
|
|
requires
|
|
- NR*NC==0
|
|
(i.e. this array isn't statically sized)
|
|
ensures
|
|
- Returns a pointer containing the memory block underlying this matrix.
|
|
After calling steal_memory() this matrix doesn't own the memory anymore
|
|
and is automatically set to the empty matrix.
|
|
- The returned pointer points to an array of size() T objects and in
|
|
particular is the pointer &(*this)(0,0).
|
|
- #size() == 0
|
|
!*/
|
|
|
|
template <typename U, size_t len>
|
|
matrix& operator= (
|
|
U (&array)[len]
|
|
);
|
|
/*!
|
|
requires
|
|
- len == nr()*nc() (i.e. the array you give here must be the right size)
|
|
ensures
|
|
- for all valid r and c:
|
|
#(*this)(r,c) == array[r*nc() + c]
|
|
(i.e. loads this matrix with the contents of the given array)
|
|
- returns *this
|
|
!*/
|
|
|
|
matrix& operator=(
|
|
const std::initializer_list<T>& l
|
|
);
|
|
/*!
|
|
requires
|
|
- This matrix is capable of having a size() == l.size(). Therefore, if
|
|
NR*NC != 0 then l.size() must equal NR*NC. Alternatively, if NR or NC is
|
|
!= 0 then l.size() must be a multiple of the non-zero NR or NC.
|
|
ensures
|
|
- Assigns the contents of l to *this by performing: matrix(l).swap(*this)
|
|
- returns *this
|
|
!*/
|
|
|
|
template <typename EXP>
|
|
matrix& operator= (
|
|
const matrix_exp<EXP>& m
|
|
);
|
|
/*!
|
|
requires
|
|
- matrix_exp<EXP>::type == T
|
|
(i.e. m contains the same type as *this does)
|
|
- if (NR != 0) then NR == m.nr()
|
|
- if (NC != 0) then NC == m.nc()
|
|
ensures
|
|
- copies the given matrix expression m to *this
|
|
- returns *this
|
|
!*/
|
|
|
|
template <typename EXP>
|
|
matrix& operator += (
|
|
const matrix_exp<EXP>& m
|
|
);
|
|
/*!
|
|
requires
|
|
- matrix_exp<EXP>::type == T
|
|
- One of the following is true:
|
|
- nr() == m.nr() && nc() == m.nc()
|
|
- size() == 0
|
|
(i.e. this matrix must have matching dimensions or it must be empty)
|
|
ensures
|
|
- if (nr() == m.nr() && nc() == m.nc()) then
|
|
- #(*this) == *this + m
|
|
- else
|
|
- #(*this) == m
|
|
(i.e. if the dimensions don't match then this function performs a
|
|
normal assignment)
|
|
- returns *this
|
|
!*/
|
|
|
|
template <typename EXP>
|
|
matrix& operator -= (
|
|
const matrix_exp<EXP>& m
|
|
);
|
|
/*!
|
|
requires
|
|
- matrix_exp<EXP>::type == T
|
|
- One of the following is true:
|
|
- nr() == m.nr() && nc() == m.nc()
|
|
- size() == 0
|
|
(i.e. this matrix must have matching dimensions or it must be empty)
|
|
ensures
|
|
- if (nr() == m.nr() && nc() == m.nc()) then
|
|
- #(*this) == *this - m
|
|
- else
|
|
- #(*this) == -m
|
|
- returns *this
|
|
!*/
|
|
|
|
template <typename EXP>
|
|
matrix& operator *= (
|
|
const matrix_exp<EXP>& m
|
|
);
|
|
/*!
|
|
requires
|
|
- matrix_exp<EXP>::type == T
|
|
(i.e. m must contain the same type of element as *this)
|
|
- nc() == m.nr()
|
|
- size() > 0 && m.size() > 0
|
|
(you can't multiply any sort of empty matrices together)
|
|
ensures
|
|
- #(*this) == *this * m
|
|
- returns *this
|
|
!*/
|
|
|
|
matrix& operator *= (
|
|
const T& a
|
|
);
|
|
/*!
|
|
ensures
|
|
- #(*this) == *this * a
|
|
- returns *this
|
|
!*/
|
|
|
|
matrix& operator /= (
|
|
const T& a
|
|
);
|
|
/*!
|
|
ensures
|
|
- #(*this) == *this / a
|
|
- returns *this
|
|
!*/
|
|
|
|
matrix& operator += (
|
|
const T& a
|
|
);
|
|
/*!
|
|
ensures
|
|
- #(*this) == *this + a
|
|
- returns *this
|
|
!*/
|
|
|
|
matrix& operator -= (
|
|
const T& a
|
|
);
|
|
/*!
|
|
ensures
|
|
- #(*this) == *this - a
|
|
- returns *this
|
|
!*/
|
|
|
|
const literal_assign_helper operator = (
|
|
const T& val
|
|
);
|
|
/*!
|
|
This function is somewhat different than all the others defined in this file.
|
|
The purpose of this function is to enable you to easily initialize a matrix object.
|
|
For example:
|
|
matrix<double> m(2,3);
|
|
m = 1,2,3,
|
|
4,5,6;
|
|
|
|
The above code creates a matrix m with 2 rows and 3 columns and sets it so that
|
|
it contains the matrix | 1 2 3 |
|
|
| 4 5 6 |
|
|
|
|
You can also use this function to assign to all elements of a matrix. So
|
|
saying m = 3; would assign all elements of m equal to 3.
|
|
|
|
Note that to use this method of assignment it is required that you supply
|
|
exactly m.size() or 1 values so that the matrix is fully initialized. Supplying
|
|
fewer or more than that is an error that will cause a dlib::fatal_error to be
|
|
thrown.
|
|
|
|
Note also that using an expression of the form m = scalar; when m.size() == 0
|
|
is legal but has no effect on m.
|
|
!*/
|
|
|
|
void swap (
|
|
matrix& item
|
|
);
|
|
/*!
|
|
ensures
|
|
- swaps *this and item
|
|
!*/
|
|
|
|
iterator begin(
|
|
);
|
|
/*!
|
|
ensures
|
|
- returns a random access iterator pointing to the first element in this
|
|
matrix.
|
|
- The iterator will iterate over the elements of the matrix in row major
|
|
order if layout is row_major_layout or in column major order if layout is
|
|
column_major_layout.
|
|
!*/
|
|
|
|
iterator end(
|
|
);
|
|
/*!
|
|
ensures
|
|
- returns a random access iterator pointing to one past the end of the last
|
|
element in this matrix.
|
|
!*/
|
|
|
|
const_iterator begin(
|
|
) const;
|
|
/*!
|
|
ensures
|
|
- returns a random access iterator pointing to the first element in this
|
|
matrix.
|
|
- The iterator will iterate over the elements of the matrix in row major
|
|
order if layout is row_major_layout or in column major order if layout is
|
|
column_major_layout.
|
|
!*/
|
|
|
|
const_iterator end(
|
|
) const;
|
|
/*!
|
|
ensures
|
|
- returns a random access iterator pointing to one past the end of the last
|
|
element in this matrix.
|
|
!*/
|
|
};
|
|
|
|
// ----------------------------------------------------------------------------------------
|
|
|
|
/*!A matrix_colmajor
|
|
This is just a typedef of the matrix object that uses column major layout.
|
|
!*/
|
|
typedef matrix<double,0,0,default_memory_manager,column_major_layout> matrix_colmajor;
|
|
|
|
/*!A fmatrix_colmajor
|
|
This is just a typedef of the matrix object that uses column major layout.
|
|
!*/
|
|
typedef matrix<float,0,0,default_memory_manager,column_major_layout> fmatrix_colmajor;
|
|
|
|
// ----------------------------------------------------------------------------------------
|
|
template <
|
|
typename T,
|
|
long NR,
|
|
long NC,
|
|
typename mm,
|
|
typename l
|
|
>
|
|
void swap(
|
|
matrix<T,NR,NC,mm,l>& a,
|
|
matrix<T,NR,NC,mm,l>& b
|
|
) { a.swap(b); }
|
|
/*!
|
|
Provides a global swap function
|
|
!*/
|
|
|
|
template <
|
|
typename T,
|
|
long NR,
|
|
long NC,
|
|
typename mm,
|
|
typename l
|
|
>
|
|
void serialize (
|
|
const matrix<T,NR,NC,mm,l>& item,
|
|
std::ostream& out
|
|
);
|
|
/*!
|
|
Provides serialization support. Note that the serialization formats used by the
|
|
dlib::matrix and dlib::array2d objects are compatible. That means you can load the
|
|
serialized data from one into another and it will work properly.
|
|
!*/
|
|
|
|
template <
|
|
typename T,
|
|
long NR,
|
|
long NC,
|
|
typename mm,
|
|
typename l
|
|
>
|
|
void deserialize (
|
|
matrix<T,NR,NC,mm,l>& item,
|
|
std::istream& in
|
|
);
|
|
/*!
|
|
Provides deserialization support
|
|
!*/
|
|
|
|
template <
|
|
typename EXP
|
|
>
|
|
std::ostream& operator<< (
|
|
std::ostream& out,
|
|
const matrix_exp<EXP>& m
|
|
);
|
|
/*!
|
|
ensures
|
|
- writes m to the given out stream in a form suitable for human consumption.
|
|
- returns out
|
|
!*/
|
|
|
|
template <
|
|
typename T,
|
|
long NR,
|
|
long NC,
|
|
typename MM,
|
|
typename L
|
|
>
|
|
std::istream& operator>> (
|
|
std::istream& in,
|
|
matrix<T,NR,NC,MM,L>& m
|
|
);
|
|
/*!
|
|
ensures
|
|
- Tries to read a matrix from the given input stream and store it into #m.
|
|
- The format expected is the text format output by the above operator<<().
|
|
That is, the format should be a grid of text such as:
|
|
2 3 4
|
|
5 2 6
|
|
- The separation between numbers can be any number of whitespace characters or
|
|
commas.
|
|
- The matrix data is assumed to end upon the first blank line or end-of-file,
|
|
whichever comes first. This means you can create an input stream with
|
|
multiple matrices in it by separating them with empty lines.
|
|
- returns in.
|
|
- If there was a formatting error or something which prevents the input data
|
|
from being parsed into a matrix then #in.fail() == true.
|
|
!*/
|
|
|
|
/*!A csv
|
|
This object is used to define an io manipulator for matrix expressions. In
|
|
particular, you can write statements like:
|
|
cout << csv << yourmatrix;
|
|
and have it print the matrix with commas separating each element.
|
|
!*/
|
|
some_undefined_iomnaip_type csv;
|
|
|
|
// ----------------------------------------------------------------------------------------
|
|
|
|
template <typename EXP>
|
|
class const_temp_matrix : public matrix_exp<const_temp_matrix<EXP> >, noncopyable
|
|
{
|
|
/*!
|
|
REQUIREMENTS ON EXP
|
|
- must be an object that inherits publicly from matrix_exp.
|
|
|
|
WHAT THIS OBJECT REPRESENTS
|
|
This object represents a copy of a matrix expression. The twist
|
|
is that it only actually makes a copy of its input matrix expression
|
|
if that matrix expression is costly to evaluate. If it has
|
|
low cost then this object just stores a reference.
|
|
|
|
This class is useful in cases where you write a function that
|
|
takes a matrix_exp object as input and you want to do some
|
|
intensive computation that looks at each element of that matrix_exp
|
|
many times. If the input matrix_exp has a high cost then you want
|
|
to store it into a temporary matrix. But if it has low cost then
|
|
it is faster if you just use a reference to it. The const_temp_matrix
|
|
makes doing this easy.
|
|
!*/
|
|
public:
|
|
|
|
const_temp_matrix (
|
|
const matrix_exp<EXP>& item
|
|
);
|
|
/*!
|
|
ensures
|
|
- #*this == item
|
|
- if (EXP::cost <= 1) then
|
|
- this const_temp_matrix stores a reference to the item matrix
|
|
- else
|
|
- this const_temp_matrix creates a temporary matrix and copies
|
|
item into it
|
|
!*/
|
|
|
|
const_temp_matrix (
|
|
const EXP& item
|
|
);
|
|
/*!
|
|
ensures
|
|
- #*this == item
|
|
- if (EXP::cost <= 1) then
|
|
- this const_temp_matrix stores a reference to the item matrix
|
|
- else
|
|
- this const_temp_matrix creates a temporary matrix and copies
|
|
item into it
|
|
!*/
|
|
};
|
|
|
|
// ----------------------------------------------------------------------------------------
|
|
|
|
}
|
|
|
|
#endif // DLIB_MATRIx_ABSTRACT_
|
|
|