CVM Class Library  8.1
This C++ class library encapsulates concepts of vector and different matrices including square, band, symmetric and hermitian ones in Euclidean space of real and complex numbers.
 All Classes Files Functions Variables Typedefs Friends Macros Pages
Public Member Functions | Protected Types | Protected Attributes | Friends | List of all members
basic_fmatrix< T > Class Template Reference

Matrix of functions class More...

#include <cfun.h>

Inheritance diagram for basic_fmatrix< T >:
Inheritance graph
[legend]
Collaboration diagram for basic_fmatrix< T >:
Collaboration graph
[legend]

Public Member Functions

 basic_fmatrix ()
 Default constructor.
 basic_fmatrix (size_t m, size_t n)
 Constructor.
 basic_fmatrix (size_t m, size_t n, const string_array &saInput)
 Constructor.
 basic_fmatrix (size_t m, size_t n, const string_array &saVars, const string_array &saBodies, const string_array &saParameters, const string_array &saMeanings)
 Constructor.
 basic_fmatrix (const basic_fmatrix &fm)
 Copy Constructor.
 basic_fmatrix (basic_fmatrix &&fm)
 Move Constructor.
size_t msize () const
 Number of rows.
size_t nsize () const
 Number of columns.
basic_fmatrix & operator= (const basic_fmatrix &fm) throw (cvmexception)
 Assignment operator.
basic_fmatrix & operator= (basic_fmatrix &&fm) throw (cvmexception)
 Assignment operator.
BaseFunction & at (size_t nRow, size_t nCol)
 Reference to element (l-value)
const BaseFunction & at (size_t nRow, size_t nCol) const
 Value of element (not l-value)
bool operator== (const basic_fmatrix &fm) const
 Matrices of functions comparison.
bool operator!= (const basic_fmatrix &fm) const
 Matrices of functions comparison.
basic_fmatrix & operator<< (const basic_fmatrix &fm)
 Replacement operator.
basic_fmatrix drv (size_t nVarNum) const
 Partial derivative.
basic_fmatrix & simp ()
 Simplifier.
basic_fmatrix operator+ (const basic_fmatrix &fm) const throw (cvmexception)
 Addition operator.
basic_fmatrix operator- (const basic_fmatrix &fm) const throw (cvmexception)
 Subtraction operator.
basic_fmatrix & operator+= (const basic_fmatrix &fm) throw (cvmexception)
 Increment operator.
basic_fmatrix & operator-= (const basic_fmatrix &fm) throw (cvmexception)
 Decrement operator.
basic_fmatrix operator* (const BaseFunction &f) const
 Multiplication operator.
basic_fmatrix operator/ (const BaseFunction &f) const
 Division operator.
basic_fmatrix operator* (const T &d) const
 Multiplication operator.
basic_fmatrix operator/ (const T &d) const
 Division operator.
basic_fmatrix & operator*= (const BaseFunction &f)
 Multiply and assign operator.
basic_fmatrix & operator/= (const BaseFunction &f)
 Divide and assign operator.
basic_fmatrix & operator*= (const T &d)
 Multiply and assign operator.
basic_fmatrix & operator/= (const T &d)
 Divide and assign operator.
basic_fvector< T > get_row (size_t nRow) const throw (cvmexception)
 Row as not l-value.
basic_fvector< T > get_col (size_t nCol) const throw (cvmexception)
 Column as not l-value.
basic_fmatrix & set_row (size_t nRow, const basic_fvector< T > &fv) throw (cvmexception)
 Row assignment.
basic_fmatrix & set_col (size_t nCol, const basic_fvector< T > &fv) throw (cvmexception)
 Column assignment.
basic_fvector< T > operator* (const basic_fvector< T > &fv) const throw (cvmexception)
 Matrix by vector product
basic_fmatrix operator* (const basic_fmatrix &fm) const throw (cvmexception)
 Matrix by matrix product
basic_fmatrix & mult (const basic_fmatrix &fmA, const basic_fmatrix &fmB) throw (cvmexception)
 Matrix by matrix product
- Public Member Functions inherited from FArray< T >
 FArray ()
 Default constructor.
 FArray (size_t nSize)
 Constructor.
 FArray (const FArray &a)
 Copy constructor.
 FArray (FArray &&a)
 Move constructor.
 FArray (const string_array &saInput)
 Constructor.
 FArray (const string_array &saVars, const string_array &saBodies, const string_array &saParameters, const string_array &saMeanings)
 Constructor.
virtual ~FArray ()
 Destructor.
std::vector< BaseFunction > & impl ()
 Internal storage.
const std::vector< BaseFunction > & impl () const
 Internal storage.
size_t size () const
 Internal storage.
const BaseFunction & operator[] (size_t n) const
 Constant reference to element (not l-value, zero-based)
BaseFunction & operator[] (size_t n)
 Reference to element (l-value, zero-based)
void value (T *pv) const
 Numerical value.
void value (T d, T *pv) const
 Numerical value.
void value (T d1, T d2, T *pv) const
 Numerical value.
void value (T d1, T d2, T d3, T *pv) const
 Numerical value.
void value (const T *pd, T *pv) const
 Numerical value.

Protected Types

typedef FArray< T > BaseFArray
 Base class.
typedef BaseFArray::BaseFunction BaseFunction
 Matrix element, i.e. rfunction or cfunction
- Protected Types inherited from FArray< T >
typedef basic_function< T > BaseFunction
 Vector element, i.e. rfunction or cfunction.

Protected Attributes

size_t mM
 Number of rows
size_t mN
 Number of columns
- Protected Attributes inherited from FArray< T >
std::vector< BaseFunction > mv
 Internal storage.

Friends

class basic_fvector< T >
std::ostream & operator<< (std::ostream &os, const basic_fmatrix< T > &fm)
 Output operator.

Detailed Description

template<typename T>
class basic_fmatrix< T >

Matrix of functions class

T type stands for treal or tcomplex. Please use inherited rfmatrix and cfmatrix classes. Fortran style storage is used here, i.e. elements are stored by columns (the same way as in basic_rmatrix etc.).

See Also
rfmatrix
cfmatrix
basic_fvector

Definition at line 9972 of file cfun.h.

Member Typedef Documentation

template<typename T>
typedef FArray<T> basic_fmatrix< T >::BaseFArray
protected

Base class.

Definition at line 9977 of file cfun.h.

template<typename T>
typedef BaseFArray::BaseFunction basic_fmatrix< T >::BaseFunction
protected

Matrix element, i.e. rfunction or cfunction

Definition at line 9978 of file cfun.h.

Constructor & Destructor Documentation

template<typename T>
basic_fmatrix< T >::basic_fmatrix ( )
inline

Default constructor.

Creates empty matrix of functions. No memory gets allocated.

Definition at line 10004 of file cfun.h.

template<typename T>
basic_fmatrix< T >::basic_fmatrix ( size_t  m,
size_t  n 
)
inline

Constructor.

Creates m-by-n matrix of zero functions.

Example:
using namespace cvm;
rfmatrix rfm(2,3);
std::cout << rfm;
cfmatrix cfm(2,3);
std::cout << cfm;
prints
0 0 0
0 0 0
(0,0) (0,0) (0,0)
(0,0) (0,0) (0,0)
Parameters
[in]mNumber of rows.
[in]nNumber of columns.

Definition at line 10033 of file cfun.h.

template<typename T>
basic_fmatrix< T >::basic_fmatrix ( size_t  m,
size_t  n,
const string_array &  saInput 
)
inline

Constructor.

Creates m-by-n matrix of functions. Each function element is ininialized using appropriate string as parameterless input in Wolfram's Mathemaca syntax {var1[,var2,...]} expr. For expression syntax look at basic_function description. Matrix elements are initialized column by column. Constructor throws cvmexception in case of inappropriate sizes passed.

Example:
using namespace cvm;
string_array funcs;
funcs.push_back("{x} x");
funcs.push_back("{x} x^2");
funcs.push_back("{x} x^3");
funcs.push_back("{x} x^4");
rfmatrix rfm(2,2,funcs);
cfmatrix cfm(2,2,funcs);
std::cout << rfm << std::endl;
std::cout << cfm << std::endl;
prints
{x} x {x} x^3
{x} x^2 {x} x^4
{x} x {x} x^(3,0)
{x} x^(2,0) {x} x^(4,0)
Parameters
[in]mNumber of rows.
[in]nNumber of columns.
[in]saInputArray of strings with functions' expressions.

Definition at line 10075 of file cfun.h.

template<typename T>
basic_fmatrix< T >::basic_fmatrix ( size_t  m,
size_t  n,
const string_array &  saVars,
const string_array &  saBodies,
const string_array &  saParameters,
const string_array &  saMeanings 
)
inline

Constructor.

Creates m-by-n matrix of parameterized functions. Each function element is ininialized using appropriate string as parameterless input in Wolfram's Mathemaca syntax {var1[,var2,...]} expr. For expression syntax look at basic_function description. Matrix elements are initialized column by column. Constructor throws cvmexception in case of inappropriate sizes passed.

Example:
using namespace cvm;
try{
string_array vars, bodies, params, meanings;
vars.push_back("x");
vars.push_back("y");
params.push_back("p");
meanings.push_back("sqrt(x) + sqrt(y)");
bodies.push_back("p*x");
bodies.push_back("p+1");
bodies.push_back("p*y");
bodies.push_back("p-1");
rfmatrix rm(2, 2, vars, bodies, params, meanings);
std::cout << rm;
cfmatrix cm(2, 2, vars, bodies, params, meanings);
std::cout << cm;
}
catch (std::exception& e) {
std::cout << "Exception " << e.what () << std::endl;
}
prints
{x,y} (sqrt(x)+sqrt(y))*x {x,y} (sqrt(x)+sqrt(y))*y
{x,y} sqrt(x)+sqrt(y)+1 {x,y} sqrt(x)+sqrt(y)-1
{x,y} (sqrt(x)+sqrt(y))*x {x,y} (sqrt(x)+sqrt(y))*y
{x,y} sqrt(x)+sqrt(y)+(1,0) {x,y} sqrt(x)+sqrt(y)-(1,0)
Parameters
[in]mNumber of rows.
[in]nNumber of columns.
[in]saVarsString array with variables (may be empty).
[in]saBodiesString array with functions' expressions. For expression syntax look at basic_function description.
[in]saParametersString array with parameters (may be empty).
[in]saMeaningsString array with parameters' meanings (may be empty, must have the same size as saParameters).

Definition at line 10129 of file cfun.h.

template<typename T>
basic_fmatrix< T >::basic_fmatrix ( const basic_fmatrix< T > &  fm)
inline

Copy Constructor.

Creates copy of matrix of functions referred by fm.

Parameters
[in]fmMatrix of functions (rfmatrix or cfmatrix) to copy from.

Definition at line 10142 of file cfun.h.

template<typename T>
basic_fmatrix< T >::basic_fmatrix ( basic_fmatrix< T > &&  fm)
inline

Move Constructor.

Definition at line 10150 of file cfun.h.

Member Function Documentation

template<typename T>
size_t basic_fmatrix< T >::msize ( ) const
inline

Number of rows.

Returns number of rows of calling matrix.

Example:
using namespace cvm;
rfmatrix rfm(3,4);
std::cout << rfm.msize() << std::endl;
cfmatrix cfm(3,4);
std::cout << cfm.msize() << std::endl;
prints
3
3
Returns
Number of columns of calling matrix of functions.

Definition at line 10174 of file cfun.h.

Here is the caller graph for this function:

template<typename T>
size_t basic_fmatrix< T >::nsize ( ) const
inline

Number of columns.

Returns number of columns of calling matrix.

Example:
using namespace cvm;
rfmatrix rfm(3,4);
std::cout << rfm.nsize() << std::endl;
cfmatrix cfm(3,4);
std::cout << cfm.nsize() << std::endl;
prints
4
4
Returns
Number of rows of calling matrix of functions.

Definition at line 10197 of file cfun.h.

Here is the caller graph for this function:

template<typename T>
basic_fmatrix& basic_fmatrix< T >::operator= ( const basic_fmatrix< T > &  fm) throw (cvmexception)
inline

Assignment operator.

Assigns basic_fmatrix object to calling one or throws cvmexception if objects have different sizes.

Example:
using namespace cvm;
string_array funcs;
funcs.push_back("{x} x");
funcs.push_back("{x} x^2");
funcs.push_back("{x} x^3");
funcs.push_back("{x} x^4");
rfmatrix rfm(2,2,funcs), rfm2(2,2);
cfmatrix cfm(2,2,funcs), cfm2(2,2);
rfm2 = rfm;
cfm2 = cfm;
std::cout << rfm2 << std::endl;
std::cout << cfm2 << std::endl;
prints
{x} x {x} x^3
{x} x^2 {x} x^4
{x} x {x} x^(3,0)
{x} x^(2,0) {x} x^(4,0)
Parameters
[in]fmConst reference to matrix of functions to assign.
Returns
Reference to changed calling matrix.

Definition at line 10234 of file cfun.h.

template<typename T>
basic_fmatrix& basic_fmatrix< T >::operator= ( basic_fmatrix< T > &&  fm) throw (cvmexception)
inline

Assignment operator.

Definition at line 10244 of file cfun.h.

template<typename T>
BaseFunction& basic_fmatrix< T >::at ( size_t  nRow,
size_t  nCol 
)
inline

Reference to element (l-value)

Operator provides access to a particular element of calling matrix of functions by its row and column index. Indexes passed are 0-based. This is different from core classes indexing like basic_rmatrix indexing. That's because function arrays are based on std::vector implementation having 0-based indexing. Operator returns l-value in order to make possible write access to an element. Operator throws cvmexception if nRow or nCol is outside of boundaries.

Example:
using namespace cvm;
rfmatrix rfm(3,2);
cfmatrix cfm(3,2);
rfm.at(0,1) = rfunction("{x} x+1");
cfm.at(0,1) = cfunction("{x} x+1");
std::cout << rfm << std::endl;
rmatrix rm(3,2);
rfm.value(1., rm);
std::cout << rm << std::endl;
std::cout << cfm << std::endl;
cmatrix cm(3,2);
cfm.value(tcomplex(1., 1.), cm);
std::cout << cm << std::endl;
prints
0 {x} x+1
0 0
0 0
0 2
0 0
0 0
(0,0) {x} x+(1,0)
(0,0) (0,0)
(0,0) (0,0)
(0,0) (2,1)
(0,0) (0,0)
(0,0) (0,0)
See Also
http://cvmlib.com/faq.htm
Parameters
[in]nRowRow index (0-based).
[in]nColColumn index (0-based).
Returns
Reference to basic_function element (l-value).

Definition at line 10301 of file cfun.h.

template<typename T>
const BaseFunction& basic_fmatrix< T >::at ( size_t  nRow,
size_t  nCol 
) const
inline

Value of element (not l-value)

Operator returns value of a particular element of calling matrix of functions by its row and column index. Indexes passed are 0-based. This is different from core classes indexing like basic_rmatrix indexing. That's because function arrays are based on std::vector implementation having 0-based indexing. Operator throws cvmexception if nRow or nCol is outside of boundaries.

Example:
using namespace cvm;
string_array funcs;
funcs.push_back("{x} x");
funcs.push_back("{x} x^2");
funcs.push_back("{x} x^3");
funcs.push_back("{x} x^4");
const rfmatrix rfm(2,2,funcs);
const cfmatrix cfm(2,2,funcs);
std::cout << rfm.at(1,0) << std::endl;
std::cout << cfm.at(1,0) << std::endl;
prints
{x} x^2
{x} x^(2,0)
See Also
http://cvmlib.com/faq.htm
Parameters
[in]nRowRow index (0-based).
[in]nColColumn index (0-based).
Returns
Constant reference to basic_function element (i.e. not l-value).

Definition at line 10336 of file cfun.h.

template<typename T>
bool basic_fmatrix< T >::operator== ( const basic_fmatrix< T > &  fm) const
inline

Matrices of functions comparison.

Returns true if matrices of functions are equal and false otherwise.

Example:
using namespace cvm;
string_array funcs;
funcs.push_back("{x} x");
funcs.push_back("{x} x^2");
funcs.push_back("{x} x^3");
funcs.push_back("{x} x^4");
rfmatrix rfm(2,2,funcs);
cfmatrix cfm(2,2,funcs);
rfmatrix rfm2(2,2);
cfmatrix cfm2(2,2);
std::cout << (rfm2 == rfm) << std::endl;
std::cout << (cfm2 == cfm) << std::endl;
rfm2 = rfm;
cfm2 = cfm;
std::cout << (rfm2 == rfm) << std::endl;
std::cout << (cfm2 == cfm) << std::endl;
prints
0
0
1
1
Parameters
[in]fmConst reference to matrix of functions to compare with.
Returns
boolean value.

Definition at line 10373 of file cfun.h.

Here is the caller graph for this function:

template<typename T>
bool basic_fmatrix< T >::operator!= ( const basic_fmatrix< T > &  fm) const
inline

Matrices of functions comparison.

Returns true if matrices of functions are not equal and false otherwise.

Example:
using namespace cvm;
string_array funcs;
funcs.push_back("{x} x");
funcs.push_back("{x} x^2");
funcs.push_back("{x} x^3");
funcs.push_back("{x} x^4");
rfmatrix rfm(2,2,funcs);
cfmatrix cfm(2,2,funcs);
rfmatrix rfm2(2,2);
cfmatrix cfm2(2,2);
std::cout << (rfm2 != rfm) << std::endl;
std::cout << (cfm2 != cfm) << std::endl;
rfm2 = rfm;
cfm2 = cfm;
std::cout << (rfm2 != rfm) << std::endl;
std::cout << (cfm2 != cfm) << std::endl;
prints
1
1
0
0
Parameters
[in]fmConst reference to matrix of functions to compare with.
Returns
boolean value.

Definition at line 10410 of file cfun.h.

template<typename T>
basic_fmatrix& basic_fmatrix< T >::operator<< ( const basic_fmatrix< T > &  fm)
inline

Replacement operator.

Assigns basic_fmatrix object to calling one without checking anything.

Example:
using namespace cvm;
string_array funcs;
funcs.push_back("{x} x");
funcs.push_back("{x} x^2");
funcs.push_back("{x} x^3");
funcs.push_back("{x} x^4");
rfmatrix rfm(2,2,funcs);
cfmatrix cfm(2,2,funcs);
rfmatrix rfm2(2,2);
cfmatrix cfm2(2,2);
rfm2 << rfm;
cfm2 << cfm;
std::cout << rfm2 << cfm2;
prints
{x} x {x} x^3
{x} x^2 {x} x^4
{x} x {x} x^(3,0)
{x} x^(2,0) {x} x^(4,0)
Parameters
[in]fmConst reference to matrix of functions to replace by.
Returns
Reference to changed calling matrix.

Definition at line 10445 of file cfun.h.

template<typename T>
basic_fmatrix basic_fmatrix< T >::drv ( size_t  nVarNum) const
inline

Partial derivative.

Creates basic_fmatrix object as a partial derivative of calling matrix. Variables set remains the same even if the derivative doesn't depend on some of them. Partial derivative is computed by nVarNum's variable (0-based, 0 by default).

Example:
using namespace cvm;
string_array funcs;
funcs.push_back("{x,y} x + log(x) + x^y");
funcs.push_back("{x,y} sin(x)*cos(y) + sin(y)*cos(x) + x*y");
funcs.push_back("{x,y} log10(x*y)");
funcs.push_back("{x,y} x/(x+y)");
rfmatrix rfm(2,2,funcs);
cfmatrix cfm(2,2,funcs);
std::cout << rfm.drv(0) << std::endl << rfm.drv(1) << std::endl;
std::cout << cfm.drv(0) << std::endl << cfm.drv(1) << std::endl;
prints
{x,y} 1+1/x+y*x^(y-1) {x,y} 0.434294/x
{x,y} cos(x)*cos(y)-sin(x)*sin(y)+y {x,y} y/(x+y)^2
{x,y} x^y*log(x) {x,y} 0.434294/y
{x,y} cos(y)*cos(x)-sin(y)*sin(x)+x {x,y} -x/(x+y)^2
{x,y} (1,0)+(1,0)/x+y*x^(y-(1,-0)) {x,y} (0.434294,0)/x
{x,y} cos(x)*cos(y)-sin(x)*sin(y)+y {x,y} y/(x+y)^(2,0)
{x,y} x^y*log(x) {x,y} (0.434294,0)/y
{x,y} cos(y)*cos(x)-sin(y)*sin(x)+x {x,y} -x/(x+y)^(2,0)
Parameters
[in]nVarNumVariable's index (0-based, 0 by default).
Returns
Matrix of functions object.

Definition at line 10490 of file cfun.h.

template<typename T>
basic_fmatrix& basic_fmatrix< T >::simp ( )
inline

Simplifier.

Simplifies basic_fmatrix for fatsest numerical computation possible and returns reference to the object changed.

Example:
using namespace cvm;
string_array funcs;
funcs.push_back("{x,y} x*2 + 3*x");
funcs.push_back("{x,y} x + y + x + y + x");
funcs.push_back("{x,y} 1 + 2 + 3 + 4");
funcs.push_back("{x,y} 2*(x + x + x)");
rfmatrix rfm(2,2,funcs);
cfmatrix cfm(2,2,funcs);
std::cout << rfm.simp() << std::endl << cfm.simp();
prints
{x,y} x*5 {x,y} 10
{x,y} 2*(y+x)+x {x,y} 6*x
{x,y} x*(5,0) {x,y} (10,0)
{x,y} (2,0)*(y+x)+x {x,y} (6,0)*x
Returns
Reference to changed calling matrix.

Definition at line 10524 of file cfun.h.

template<typename T>
basic_fmatrix basic_fmatrix< T >::operator+ ( const basic_fmatrix< T > &  fm) const throw (cvmexception)
inline

Addition operator.

Creates basic_fmatrix object as sum of calling matrix and matrix referred by fm. Operator throws cvmexception if sizes of matrices or lists of variables don't match.

Example:
using namespace cvm;
try{
string_array funcs1, funcs2;
funcs1.push_back("{x,y} x");
funcs1.push_back("{x,y} x + y");
funcs2.push_back("{x,y} y");
funcs2.push_back("{x,y} x * y");
rfmatrix rfm1(2,1,funcs1);
cfmatrix cfm1(2,1,funcs1);
rfmatrix rfm2(2,1,funcs2);
cfmatrix cfm2(2,1,funcs2);
std::cout << (rfm1 + rfm2) << std::endl;
std::cout << (cfm1 + cfm2) << std::endl;
}
catch (std::exception& e) {
std::cout << "Exception " << e.what () << std::endl;
}
prints
{x,y} x+y
{x,y} x+y+x*y
{x,y} x+y
{x,y} x+y+x*y
Parameters
[in]fmConst reference to matrix to add.
Returns
Matrix of functions object.

Definition at line 10567 of file cfun.h.

template<typename T>
basic_fmatrix basic_fmatrix< T >::operator- ( const basic_fmatrix< T > &  fm) const throw (cvmexception)
inline

Subtraction operator.

Creates basic_fmatrix object as difference of calling matrix and matrix referred by fm. Operator throws cvmexception if sizes of matrices or lists of variables don't match.

Example:
using namespace cvm;
try{
string_array funcs1, funcs2;
funcs1.push_back("{x,y} x");
funcs1.push_back("{x,y} x + y");
funcs2.push_back("{x,y} y");
funcs2.push_back("{x,y} x * y");
rfmatrix rfm1(2,1,funcs1);
cfmatrix cfm1(2,1,funcs1);
rfmatrix rfm2(2,1,funcs2);
cfmatrix cfm2(2,1,funcs2);
std::cout << (rfm1 - rfm2) << std::endl;
std::cout << (cfm1 - cfm2) << std::endl;
}
catch (std::exception& e) {
std::cout << "Exception " << e.what () << std::endl;
}
prints
{x,y} x-y
{x,y} x+y-x*y
{x,y} x-y
{x,y} x+y-x*y
Parameters
[in]fmConst reference to matrix to subtract.
Returns
Matrix of functions object.

Definition at line 10612 of file cfun.h.

template<typename T>
basic_fmatrix& basic_fmatrix< T >::operator+= ( const basic_fmatrix< T > &  fm) throw (cvmexception)
inline

Increment operator.

Adds to calling basic_fmatrix matrix of functions referred by fm and returns reference to the object changed. Operator throws cvmexception if sizes of matrices or lists of variables don't match.

Example:
using namespace cvm;
try{
string_array funcs1, funcs2;
funcs1.push_back("{x,y} x");
funcs1.push_back("{x,y} x + y");
funcs2.push_back("{x,y} y");
funcs2.push_back("{x,y} x * y");
rfmatrix rfm1(2,1,funcs1);
cfmatrix cfm1(2,1,funcs1);
rfmatrix rfm2(2,1,funcs2);
cfmatrix cfm2(2,1,funcs2);
rfm2 += rfm1;
cfm2 += cfm1;
std::cout << rfm2 << std::endl;
std::cout << cfm2 << std::endl;
}
catch (std::exception& e) {
std::cout << "Exception " << e.what () << std::endl;
}
prints
{x,y} y+x
{x,y} x*y+x+y
{x,y} y+x
{x,y} x*y+x+y
Parameters
[in]fmConst reference to matrix to add.
Returns
Reference to changed calling matrix.

Definition at line 10661 of file cfun.h.

template<typename T>
basic_fmatrix& basic_fmatrix< T >::operator-= ( const basic_fmatrix< T > &  fm) throw (cvmexception)
inline

Decrement operator.

Subtracts from calling basic_fmatrix matrix of functions referred by fm and returns reference to the object changed. Operator throws cvmexception if sizes of matrices or lists of variables don't match.

Example:
using namespace cvm;
try{
string_array funcs1, funcs2;
funcs1.push_back("{x,y} x");
funcs1.push_back("{x,y} x + y");
funcs2.push_back("{x,y} y");
funcs2.push_back("{x,y} x * y");
rfmatrix rfm1(2,1,funcs1);
cfmatrix cfm1(2,1,funcs1);
rfmatrix rfm2(2,1,funcs2);
cfmatrix cfm2(2,1,funcs2);
rfm2 -= rfm1;
cfm2 -= cfm1;
std::cout << rfm2 << std::endl;
std::cout << cfm2 << std::endl;
}
catch (std::exception& e) {
std::cout << "Exception " << e.what () << std::endl;
}
prints
{x,y} y-x
{x,y} x*y-x+y
{x,y} y-x
{x,y} x*y-x+y
Parameters
[in]fmConst reference to matrix to subtract.
Returns
Reference to changed calling matrix.

Definition at line 10709 of file cfun.h.

template<typename T>
basic_fmatrix basic_fmatrix< T >::operator* ( const BaseFunction &  f) const
inline

Multiplication operator.

Creates basic_fmatrix object as product of calling matrix and function referred by f. Operator throws cvmexception if lists of variables don't match.

Example:
using namespace cvm;
try{
string_array funcs;
funcs.push_back("{x} x + x^2");
funcs.push_back("{x} 2 * x");
funcs.push_back("{x} x / 2");
funcs.push_back("{x} x - x^2");
rfmatrix rfm(2,2,funcs);
cfmatrix cfm(2,2,funcs);
rfunction rf("{x} x/2");
cfunction cf("{x} x/2");
std::cout << rfm * rf << std::endl << (rfm * rf).simp() << std::endl;
std::cout << cfm * cf << std::endl << (cfm * cf).simp() << std::endl;
}
catch (std::exception& e) {
std::cout << "Exception " << e.what () << std::endl;
}
prints
{x} (x+x^2)*x/2 {x} x/2*x/2
{x} 2*x*x/2 {x} (x-x^2)*x/2
{x} (x+x^2)*x/2 {x} (x/2)^2
{x} x^2 {x} (x-x^2)*x/2
{x} (x+x^(2,0))*x/(2,0) {x} x/(2,0)*x/(2,0)
{x} (2,0)*x*x/(2,0) {x} (x-x^(2,0))*x/(2,0)
{x} (x+x^(2,0))*x/(2,0) {x} (x/(2,0))^(2,0)
{x} x^(2,0) {x} (x-x^(2,0))*x/(2,0)
Parameters
[in]fConst reference to function to multiply by.
Returns
Matrix of functions object.

Definition at line 10759 of file cfun.h.

template<typename T>
basic_fmatrix basic_fmatrix< T >::operator/ ( const BaseFunction &  f) const
inline

Division operator.

Creates basic_fmatrix object as division of calling matrix by function referred by f. Operator throws cvmexception if lists of variables don't match.

Example:
using namespace cvm;
try{
string_array funcs;
funcs.push_back("{x} x + x^2");
funcs.push_back("{x} 2 * x");
funcs.push_back("{x} x / 2");
funcs.push_back("{x} x - x^2");
rfmatrix rfm(2,2,funcs);
cfmatrix cfm(2,2,funcs);
rfunction rf("{x} x/2");
cfunction cf("{x} x/2");
std::cout << rfm / rf << std::endl << (rfm / rf).simp() << std::endl;
std::cout << cfm / cf << std::endl << (cfm / cf).simp() << std::endl;
}
catch (std::exception& e) {
std::cout << "Exception " << e.what () << std::endl;
}
prints
{x} (x+x^2)/(x/2) {x} (x/2)/(x/2)
{x} 2*x/(x/2) {x} (x-x^2)/(x/2)
{x} (x+x^2)*2/x {x} 1
{x} 4 {x} (x-x^2)*2/x
{x} (x+x^(2,0))/(x/(2,0)) {x} (x/(2,0))/(x/(2,0))
{x} (2,0)*x/(x/(2,0)) {x} (x-x^(2,0))/(x/(2,0))
{x} (x+x^(2,0))*(2,0)/x {x} (1,0)
{x} (4,0) {x} (x-x^(2,0))*(2,0)/x
Parameters
[in]fConst reference to function to divide by.
Returns
Matrix of functions object.

Definition at line 10809 of file cfun.h.

template<typename T>
basic_fmatrix basic_fmatrix< T >::operator* ( const T &  d) const
inline

Multiplication operator.

Creates basic_fmatrix object as product of calling matrix and real or complex number referred by d.

Example:
using namespace cvm;
try{
string_array funcs;
funcs.push_back("{x} x^2");
funcs.push_back("{x} 2 * x");
funcs.push_back("{x} x / 2");
funcs.push_back("{x} x + 2");
rfmatrix rfm(2,2,funcs);
cfmatrix cfm(2,2,funcs);
std::cout << rfm * 2. << std::endl << (rfm * 2.).simp() << std::endl;
std::cout << cfm * 2. << std::endl << (cfm * 2.).simp() << std::endl;
}
catch (std::exception& e) {
std::cout << "Exception " << e.what () << std::endl;
}
prints
{x} x^2*2 {x} x/2*2
{x} 2*x*2 {x} (x+2)*2
{x} x^2*2 {x} x
{x} 4*x {x} (x+2)*2
{x} x^(2,0)*(2,0) {x} x/(2,0)*(2,0)
{x} (2,0)*x*(2,0) {x} (x+(2,0))*(2,0)
{x} x^(2,0)*(2,0) {x} x
{x} (4,0)*x {x} (x+(2,0))*(2,0)
Parameters
[in]dNumber to multiply by.
Returns
Matrix of functions object.

Definition at line 10856 of file cfun.h.

template<typename T>
basic_fmatrix basic_fmatrix< T >::operator/ ( const T &  d) const
inline

Division operator.

Creates basic_fmatrix object as division of calling matrix by real or complex number referred by d.

Example:
using namespace cvm;
try{
string_array funcs;
funcs.push_back("{x} x^2");
funcs.push_back("{x} 2 * x");
funcs.push_back("{x} x / 2");
funcs.push_back("{x} x + 2");
rfmatrix rfm(2,2,funcs);
cfmatrix cfm(2,2,funcs);
std::cout << rfm / 2. << std::endl << (rfm / 2.).simp() << std::endl;
std::cout << cfm / 2. << std::endl << (cfm / 2.).simp() << std::endl;
}
catch (std::exception& e) {
std::cout << "Exception " << e.what () << std::endl;
}
prints
{x} x^2/2 {x} (x/2)/2
{x} 2*x/2 {x} (x+2)/2
{x} x^2/2 {x} x/4
{x} x {x} (x+2)/2
{x} x^(2,0)/(2,0) {x} (x/(2,0))/(2,0)
{x} (2,0)*x/(2,0) {x} (x+(2,0))/(2,0)
{x} x^(2,0)/(2,0) {x} x/(4,0)
{x} x {x} (x+(2,0))/(2,0)
Parameters
[in]dNumber to multiply by.
Returns
Matrix of functions object.

Definition at line 10903 of file cfun.h.

template<typename T>
basic_fmatrix& basic_fmatrix< T >::operator*= ( const BaseFunction &  f)
inline

Multiply and assign operator.

Multiplies calling matrix of functions by function referred by f and returns reference to the object changed. Operator throws cvmexception if lists of variables don't match.

Example:
using namespace cvm;
try{
string_array funcs;
funcs.push_back("{x} x + x^2");
funcs.push_back("{x} 2 * x");
funcs.push_back("{x} x / 2");
funcs.push_back("{x} x - x^2");
rfmatrix rfm(2,2,funcs);
cfmatrix cfm(2,2,funcs);
rfunction rf("{x} x/2");
cfunction cf("{x} x/2");
rfm *= rf;
cfm *= cf;
std::cout << rfm.simp() << std::endl;
std::cout << cfm.simp() << std::endl;
}
catch (std::exception& e) {
std::cout << "Exception " << e.what () << std::endl;
}
prints
{x} (x+x^2)*x/2 {x} (x/2)^2
{x} x^2 {x} (x-x^2)*x/2
{x} (x+x^(2,0))*x/(2,0) {x} (x/(2,0))^(2,0)
{x} x^(2,0) {x} (x-x^(2,0))*x/(2,0)
Parameters
[in]fConst reference to function to multiply by.
Returns
Reference to changed calling matrix.

Definition at line 10950 of file cfun.h.

template<typename T>
basic_fmatrix& basic_fmatrix< T >::operator/= ( const BaseFunction &  f)
inline

Divide and assign operator.

Divides calling matrix of functions by function referred by f and returns reference to the object changed. Operator throws cvmexception if lists of variables don't match.

Example:
using namespace cvm;
try{
string_array funcs;
funcs.push_back("{x} x + x^2");
funcs.push_back("{x} 2 * x");
funcs.push_back("{x} x / 2");
funcs.push_back("{x} x - x^2");
rfmatrix rfm(2,2,funcs);
cfmatrix cfm(2,2,funcs);
rfunction rf("{x} x/2");
cfunction cf("{x} x/2");
rfm /= rf;
cfm /= cf;
std::cout << rfm.simp() << std::endl;
std::cout << cfm.simp() << std::endl;
}
catch (std::exception& e) {
std::cout << "Exception " << e.what () << std::endl;
}
prints
{x} (x+x^2)*2/x {x} 1
{x} 4 {x} (x-x^2)*2/x
{x} (x+x^(2,0))*(2,0)/x {x} (1,0)
{x} (4,0) {x} (x-x^(2,0))*(2,0)/x
Parameters
[in]fConst reference to function to divide by.
Returns
Reference to changed calling matrix.

Definition at line 10995 of file cfun.h.

template<typename T>
basic_fmatrix& basic_fmatrix< T >::operator*= ( const T &  d)
inline

Multiply and assign operator.

Multiplies calling matrix of functions by real or complex number referred by d and returns reference to the object changed.

Example:
using namespace cvm;
try{
string_array funcs;
funcs.push_back("{x} x + x^2");
funcs.push_back("{x} 2 * x");
funcs.push_back("{x} x / 2");
funcs.push_back("{x} x - x^2");
rfmatrix rfm(2,2,funcs);
cfmatrix cfm(2,2,funcs);
rfm *= 2.;
cfm *= 2.;
std::cout << rfm.simp() << std::endl;
std::cout << cfm.simp() << std::endl;
}
catch (std::exception& e) {
std::cout << "Exception " << e.what () << std::endl;
}
prints
{x} (x+x^2)*2 {x} x
{x} 4*x {x} (x-x^2)*2
{x} (x+x^(2,0))*(2,0) {x} x
{x} (4,0)*x {x} (x-x^(2,0))*(2,0)
Parameters
[in]dNumber to multiply by.
Returns
Reference to changed calling matrix.

Definition at line 11038 of file cfun.h.

template<typename T>
basic_fmatrix& basic_fmatrix< T >::operator/= ( const T &  d)
inline

Divide and assign operator.

Divides calling matrix of functions by real or complex number referred by d and returns reference to the object changed.

Example:
using namespace cvm;
try{
string_array funcs;
funcs.push_back("{x} x + x^2");
funcs.push_back("{x} 2 * x");
funcs.push_back("{x} x / 2");
funcs.push_back("{x} x - x^2");
rfmatrix rfm(2,2,funcs);
cfmatrix cfm(2,2,funcs);
rfm /= 2.;
cfm /= 2.;
std::cout << rfm.simp() << std::endl;
std::cout << cfm.simp() << std::endl;
}
catch (std::exception& e) {
std::cout << "Exception " << e.what () << std::endl;
}
prints
{x} (x+x^2)/2 {x} x/4
{x} x {x} (x-x^2)/2
{x} (x+x^(2,0))/(2,0) {x} x/(4,0)
{x} x {x} (x-x^(2,0))/(2,0)
Parameters
[in]dNumber to divide by.
Returns
Reference to changed calling matrix.

Definition at line 11081 of file cfun.h.

template<typename T>
basic_fvector<T> basic_fmatrix< T >::get_row ( size_t  nRow) const throw (cvmexception)
inline

Row as not l-value.

Operator creates basic_fvector object as a copy of nRow-th row (0-based) of calling matrix. Note: index passed is 0-based. This is different from core classes indexing like basic_rmatrix indexing. Operator throws cvmexception if nRow is outside of boundaries.

Example:
try{
string_array funcs;
funcs.push_back("{x} 1");
funcs.push_back("{x} 2");
funcs.push_back("{x} 3");
funcs.push_back("{x} 4");
rfmatrix rfm(2,2,funcs);
cfmatrix cfm(2,2,funcs);
std::cout << rfm.get_row(0) << std::endl;
std::cout << rfm.get_row(1) << std::endl;
std::cout << cfm.get_row(0) << std::endl;
std::cout << cfm.get_row(1) << std::endl;
}
catch (std::exception& e) {
std::cout << "Exception " << e.what () << std::endl;
}
prints
{x} 1 {x} 3
{x} 2 {x} 4
{x} (1,0) {x} (3,0)
{x} (2,0) {x} (4,0)
Parameters
[in]nRowIndex of row (0-based).
See Also
set_row(size_t,const basic_fvector<T>&)
Returns
basic_fvector Row value.

Definition at line 11130 of file cfun.h.

template<typename T>
basic_fvector<T> basic_fmatrix< T >::get_col ( size_t  nCol) const throw (cvmexception)
inline

Column as not l-value.

Operator creates basic_fvector object as a copy of nCol-th column (0-based) of calling matrix. Note: index passed is 0-based. This is different from core classes indexing like basic_rmatrix indexing. Operator throws cvmexception if nCol is outside of boundaries.

Example:
try{
string_array funcs;
funcs.push_back("{x} 1");
funcs.push_back("{x} 2");
funcs.push_back("{x} 3");
funcs.push_back("{x} 4");
rfmatrix rfm(2,2,funcs);
cfmatrix cfm(2,2,funcs);
std::cout << rfm.get_col(0) << std::endl;
std::cout << rfm.get_col(1) << std::endl;
std::cout << cfm.get_col(0) << std::endl;
std::cout << cfm.get_col(1) << std::endl;
}
catch (std::exception& e) {
std::cout << "Exception " << e.what () << std::endl;
}
prints
{x} 1 {x} 2
{x} 3 {x} 4
{x} (1,0) {x} (2,0)
{x} (3,0) {x} (4,0)
Parameters
[in]nColIndex of column (0-based).
See Also
set_col(size_t,const basic_fvector<T>&)
Returns
basic_fvector Column value.

Definition at line 11181 of file cfun.h.

template<typename T>
basic_fmatrix& basic_fmatrix< T >::set_row ( size_t  nRow,
const basic_fvector< T > &  fv 
) throw (cvmexception)
inline

Row assignment.

Function assigns basic_fvector object referred by fv to nRow-th row (0-based) of calling matrix and returns reference to the object changed. Note: index passed is 0-based. This is different from core classes indexing like basic_rmatrix indexing. Operator throws cvmexception if nRow is outside of boundaries.

Example:
try{
string_array funcs;
funcs.push_back("{x} 1");
funcs.push_back("{x} 2");
funcs.push_back("{x} 3");
funcs.push_back("{x} 4");
rfmatrix rfm(2,2,funcs);
cfmatrix cfm(2,2,funcs);
rfvector r1 = rfm.get_row(1);
rfm.set_row(1, r1 * 2).simp();
std::cout << rfm << std::endl;
cfvector c1 = cfm.get_row(1);
cfm.set_row(1, c1 * 2).simp();
std::cout << cfm << std::endl;
}
catch (std::exception& e) {
std::cout << "Exception " << e.what () << std::endl;
}
prints
{x} 1 {x} 3
{x} 4 {x} 8
{x} (1,0) {x} (3,0)
{x} (4,0) {x} (8,0)
Parameters
[in]nRowIndex of row (0-based).
[in]fvVector of functions to assign.
See Also
get_row(size_t)
Returns
Reference to changed calling matrix.

Definition at line 11236 of file cfun.h.

template<typename T>
basic_fmatrix& basic_fmatrix< T >::set_col ( size_t  nCol,
const basic_fvector< T > &  fv 
) throw (cvmexception)
inline

Column assignment.

Function assigns basic_fvector object referred by fv to nCol-th column (0-based) of calling matrix and returns reference to the object changed. Note: index passed is 0-based. This is different from core classes indexing like basic_rmatrix indexing. Operator throws cvmexception if nCol is outside of boundaries.

Example:
try{
string_array funcs;
funcs.push_back("{x} 1");
funcs.push_back("{x} 2");
funcs.push_back("{x} 3");
funcs.push_back("{x} 4");
rfmatrix rfm(2,2,funcs);
cfmatrix cfm(2,2,funcs);
rfvector r1 = rfm.get_col(1);
rfm.set_col(1, r1 * 2).simp();
std::cout << rfm << std::endl;
cfvector c1 = cfm.get_col(1);
cfm.set_col(1, c1 * 2).simp();
std::cout << cfm << std::endl;
}
catch (std::exception& e) {
std::cout << "Exception " << e.what () << std::endl;
}
prints
{x} 1 {x} 6
{x} 2 {x} 8
{x} (1,0) {x} (6,0)
{x} (2,0) {x} (8,0)
Parameters
[in]nColIndex of column (0-based).
[in]fvVector of functions to assign.
See Also
get_col(size_t)
Returns
Reference to changed calling matrix.

Definition at line 11291 of file cfun.h.

template<typename T>
basic_fvector<T> basic_fmatrix< T >::operator* ( const basic_fvector< T > &  fv) const throw (cvmexception)
inline

Matrix by vector product

Creates basic_fvector object as product of calling matrix of functions and vector of functions referred by fv. Operator throws cvmexception if sizes of objects or lists of variables don't match.

Example:
using namespace cvm;
try{
string_array funcs1, funcs2;
funcs1.push_back("{x,y} x");
funcs1.push_back("{x,y} x + y");
funcs2.push_back("{x,y} x");
funcs2.push_back("{x,y} 1");
funcs2.push_back("{x,y} 2");
funcs2.push_back("{x,y} y");
rfvector rfv1(funcs1);
cfvector cfv1(funcs1);
rfmatrix rfm(2,2,funcs2);
cfmatrix cfm(2,2,funcs2);
rfvector rfv2 = rfm * rfv1;
cfvector cfv2 = cfm * cfv1;
std::cout << rfm << std::endl;
std::cout << rfv2 << std::endl;
std::cout << cfm << std::endl;
std::cout << cfv2 << std::endl;
}
catch (std::exception& e) {
std::cout << "Exception " << e.what () << std::endl;
}
prints
{x,y} x {x,y} 2
{x,y} 1 {x,y} y
{x,y} x^2+2*(x+y) {x,y} x+y*(x+y)
{x,y} x {x,y} (2,0)
{x,y} (1,0) {x,y} y
{x,y} x^(2,0)+(2,0)*(x+y) {x,y} x+y*(x+y)
Parameters
[in]fvVector of functions to multiply by.
Returns
Vector of functions object.

Definition at line 11348 of file cfun.h.

template<typename T>
basic_fmatrix basic_fmatrix< T >::operator* ( const basic_fmatrix< T > &  fm) const throw (cvmexception)
inline

Matrix by matrix product

Creates basic_fmatrix object as product of calling matrix of functions and matrix of functions referred by fm. Operator throws cvmexception if sizes of objects or lists of variables don't match.

Example:
using namespace cvm;
try{
string_array funcs1, funcs2;
funcs1.push_back("{x} x");
funcs1.push_back("{x} x^2");
funcs1.push_back("{x} x^3");
funcs1.push_back("{x} x^4");
funcs2.push_back("{x} 1");
funcs2.push_back("{x} 2");
funcs2.push_back("{x} 3");
funcs2.push_back("{x} 4");
rfmatrix rfm1(2,2,funcs1);
cfmatrix cfm1(2,2,funcs1);
rfmatrix rfm2(2,2,funcs2);
cfmatrix cfm2(2,2,funcs2);
std::cout << rfm1 << std::endl;
std::cout << rfm2 << std::endl;
std::cout << rfm1 * rfm2 << std::endl;
std::cout << cfm1 << std::endl;
std::cout << cfm2 << std::endl;
std::cout << cfm1 * cfm2 << std::endl;
}
catch (std::exception& e) {
std::cout << "Exception " << e.what () << std::endl;
}
prints
{x} x {x} x^3
{x} x^2 {x} x^4
{x} 1 {x} 3
{x} 2 {x} 4
{x} x+x^3*2 {x} x*3+x^3*4
{x} x^2+x^4*2 {x} x^2*3+x^4*4
{x} x {x} x^(3,0)
{x} x^(2,0) {x} x^(4,0)
{x} (1,0) {x} (3,0)
{x} (2,0) {x} (4,0)
{x} x+x^(3,0)*(2,0) {x} x*(3,0)+x^(3,0)*(4,0)
{x} x^(2,0)+x^(4,0)*(2,0) {x} x^(2,0)*(3,0)+x^(4,0)*(4,0)
Parameters
[in]fmMatrix of functions to multiply by.
Returns
Matrix of functions object.

Definition at line 11415 of file cfun.h.

template<typename T>
basic_fmatrix& basic_fmatrix< T >::mult ( const basic_fmatrix< T > &  fmA,
const basic_fmatrix< T > &  fmB 
) throw (cvmexception)
inline

Matrix by matrix product

Sets calling basic_fmatrix object to be product of matrices referred by fmA and fmB and returns reference to the object changed. Function throws cvmexception if sizes of objects or lists of variables don't match.

Example:
using namespace cvm;
try{
string_array funcs1, funcs2;
funcs1.push_back("{x} x");
funcs1.push_back("{x} x^2");
funcs1.push_back("{x} x^3");
funcs1.push_back("{x} x^4");
funcs2.push_back("{x} 1");
funcs2.push_back("{x} 2");
funcs2.push_back("{x} 3");
funcs2.push_back("{x} 4");
rfmatrix rfm1(2,2,funcs1);
cfmatrix cfm1(2,2,funcs1);
rfmatrix rfm2(2,2,funcs2);
cfmatrix cfm2(2,2,funcs2);
rfmatrix rfm(2,2);
cfmatrix cfm(2,2);
rfm.mult(rfm1, rfm2);
cfm.mult(cfm1, cfm2);
std::cout << rfm1 << std::endl;
std::cout << rfm2 << std::endl;
std::cout << rfm << std::endl;
std::cout << cfm1 << std::endl;
std::cout << cfm2 << std::endl;
std::cout << cfm << std::endl;
}
catch (std::exception& e) {
std::cout << "Exception " << e.what () << std::endl;
}
prints
{x} x {x} x^3
{x} x^2 {x} x^4
{x} 1 {x} 3
{x} 2 {x} 4
{x} x+x^3*2 {x} x*3+x^3*4
{x} x^2+x^4*2 {x} x^2*3+x^4*4
{x} x {x} x^(3,0)
{x} x^(2,0) {x} x^(4,0)
{x} (1,0) {x} (3,0)
{x} (2,0) {x} (4,0)
{x} x+x^(3,0)*(2,0) {x} x*(3,0)+x^(3,0)*(4,0)
{x} x^(2,0)+x^(4,0)*(2,0) {x} x^(2,0)*(3,0)+x^(4,0)*(4,0)
Parameters
[in]fmAMatrix of functions to multiply.
[in]fmBMatrix of functions to multiply by.
Returns
Reference to changed calling matrix.

Definition at line 11485 of file cfun.h.

Friends And Related Function Documentation

template<typename T>
friend class basic_fvector< T >
friend

Definition at line 9974 of file cfun.h.

template<typename T>
std::ostream& operator<< ( std::ostream &  os,
const basic_fmatrix< T > &  fm 
)
friend

Output operator.

Prints matrix of functions referred by fm to output stream referred by os using Wolfram's Mathemaca syntax {var1[,var2,...]} expr for each element.

Example:
string_array funcs;
funcs.push_back("{x,y} x");
funcs.push_back("{x,y} x^2");
funcs.push_back("{x,y} y");
funcs.push_back("{x,y} y^2");
rfmatrix rfm(2,2,funcs);
cfmatrix cfm(2,2,funcs);
std::cout << rfm << std::endl;
std::cout << cfm << std::endl;
prints
{x,y} x {x,y} y
{x,y} x^2 {x,y} y^2
{x,y} x {x,y} y
{x,y} x^(2,0) {x,y} y^(2,0)
Parameters
[in]osReference to output stream.
[in]fmConst reference to matrix of functions to print.
Returns
Reference to output stream.

Definition at line 11524 of file cfun.h.

Member Data Documentation

template<typename T>
size_t basic_fmatrix< T >::mM
protected

Number of rows

Definition at line 9980 of file cfun.h.

template<typename T>
size_t basic_fmatrix< T >::mN
protected

Number of columns

Definition at line 9981 of file cfun.h.

The documentation for this class was generated from the following file:
Generated on Tue Jul 22 2014 18:52:14 for CVM Class Library by   doxygen 1.8.1.2