fmatvec Namespace Reference

Namespace fmatvec. More...

Classes
class	AdoptCurrentMessageStreamsUntilScopeExit
struct	AssertUseException
struct	AssertUseException< IndependentVariable >
struct	AssertUseException< SymbolicExpression >
class	Atom
class	DebugMeasureAccumulatedTime
class	DebugMeasureAccumulatedTimeOnExit
struct	Der
struct	Der< Dep, double >
struct	Der< double, Vector< IndepVecShape, double > >
struct	Der< Matrix< Rotation, Fixed< 3 >, Fixed< 3 >, double >, double >
struct	Der< Matrix< Rotation, Fixed< 3 >, Fixed< 3 >, double >, Vector< IndepVecShape, double > >
struct	Der< Vector< DepVecShape, double >, Vector< IndepVecShape, double > >
class	Diagonal
	Shape class for diagonal matrices. More...
struct	DirDer
struct	DirDer< Matrix< Rotation, Fixed< 3 >, Fixed< 3 >, double >, Indep >
class	DisableEscaping
class	EnableEscaping
class	ErrorType
class	Eval
class	Eye
class	Fixed
class	Function
class	Function< Ret(Arg)>
	A function object with 1 argument. More...
class	Function< Ret(Arg1, Arg2)>
	A function object with 2 arguments. More...
class	FunctionWrap1MatRetToScalar
class	FunctionWrap1VecRetToScalar
class	FunctionWrap2MatRetToScalar
class	FunctionWrap2VecRetToScalar
class	General
	Shape class for general matrices. More...
class	GeneralBand
	Shape class for general band matrices. More...
class	IndependentVariable
class	Indices
class	Init
class	LRUCache
class	Matrix
	This is the basic matrix class for arbitrary matrices. More...
class	Matrix< Diagonal, Ref, Ref, AT >
	This is a matrix class for diagonal matrices. More...
class	Matrix< General, Fixed< M >, Fixed< N >, AT >
	This is a matrix class for general matrices. More...
class	Matrix< General, Fixed< M >, Var, AT >
	This is a matrix class for general matrices. More...
class	Matrix< General, Ref, Ref, AT >
	This is a matrix class for general matrices. More...
class	Matrix< General, Var, Fixed< N >, AT >
	This is a matrix class for general matrices. More...
class	Matrix< General, Var, Var, AT >
	This is a matrix class for general matrices. More...
class	Matrix< GeneralBand, Ref, Ref, AT >
	This is a matrix class for general band matrices. More...
class	Matrix< Rotation, Fixed< M >, Fixed< M >, AT >
class	Matrix< Sparse, Ref, Ref, AT >
	This is a matrix class for sparse quadratic matrices. More...
class	Matrix< Symmetric, Fixed< M >, Fixed< M >, AT >
	This is a matrix class for symmetric matrices. More...
class	Matrix< Symmetric, Ref, Ref, AT >
	This is a matrix class for symmetric matrices. More...
class	Matrix< Symmetric, Var, Var, AT >
	This is a matrix class for symmetric matrices. More...
class	Matrix< SymmetricSparse, Ref, Ref, AT >
	This is a matrix class for sparse quadratic matrices. More...
class	Noinit
struct	OperatorResult
class	osyncstream
class	PrePostfixedStream
class	Range
	This is an index class for creating submatrices. More...
class	Range< Fixed< I1 >, Fixed< I2 > >
	This is an index class for creating submatrices. More...
class	Range< Var, Var >
	This is an index class for creating submatrices. More...
class	Ref
struct	ReplaceAT
struct	ReplaceAT< double, NewAT >
struct	ReplaceAT< ErrorType, NewAT >
struct	ReplaceAT< Matrix< MatType, RowShape, ColShape, OldAT >, NewAT >
struct	ReplaceAT< RowVector< Shape, OldAT >, NewAT >
struct	ReplaceAT< SquareMatrix< Shape, OldAT >, NewAT >
struct	ReplaceAT< SymbolicExpression, NewAT >
struct	ReplaceAT< Vector< Shape, OldAT >, NewAT >
class	Rotation
	Shape class for rotation matrices. More...
class	RowVector
class	RowVector< Fixed< N >, AT >
	This is a rowvector class of general shape in dense storage format. More...
class	RowVector< Ref, AT >
	This is a rowvector class of general shape in dense storage format. More...
class	RowVector< Var, AT >
	This is a vector class of general shape in dense storage format. More...
class	Sparse
	Shape class for sparse matrices. More...
class	Spooles
class	Square
	Dummy shape class for square matrices. More...
class	SquareMatrix
class	SquareMatrix< Fixed< M >, AT >
	This is a matrix class of general quadratic matrices. More...
class	SquareMatrix< Ref, AT >
	This is a matrix class of general quadratic matrices. More...
class	SquareMatrix< Var, AT >
	This is a matrix class of general quadratic matrices. More...
struct	StaticSize
struct	StaticSize< double >
	Defines the static size (dimension) of a double. More...
struct	StaticSize< int >
	Defines the static size (dimension) of a double. More...
struct	StaticSize< Matrix< Storage, Fixed< N >, ColShape, AT > >
	Defines the static size (dimension) of a partial fixed matrix. More...
struct	StaticSize< Matrix< Storage, Fixed< N >, Fixed< M >, AT > >
	Defines the static size (dimension) of a fixed matrix. More...
struct	StaticSize< Matrix< Storage, RowShape, ColShape, AT > >
	Defines the static size (dimension) of a variable matrix. More...
struct	StaticSize< Matrix< Storage, RowShape, Fixed< M >, AT > >
	Defines the static size (dimension) of a partial fixed matrix. More...
struct	StaticSize< RowVector< Fixed< N >, AT > >
	Defines the static size (dimension) of a fixed rowvector. More...
struct	StaticSize< RowVector< Shape, AT > >
	Defines the static size (dimension) of a row vector. More...
struct	StaticSize< SquareMatrix< Fixed< N >, AT > >
	Defines the static size (dimension) of a fixed square matrix. More...
struct	StaticSize< SquareMatrix< Shape, AT > >
	Defines the static size (dimension) of a variable square matrix. More...
struct	StaticSize< Vector< Fixed< N >, AT > >
	Defines the static size (dimension) of a fixed vector. More...
struct	StaticSize< Vector< Shape, AT > >
	Defines the static size (dimension) of a vector. More...
class	SymbolicExpression
class	SymbolicFunction
class	Symmetric
	Shape class for symmetric matrices. More...
class	SymmetricSparse
	Shape class for sparse matrices. More...
struct	Transpose
class	Var
class	Vector
class	Vector< Fixed< M >, AT >
	This is a vector class of general shape in dense storage format. More...
class	Vector< Ref, AT >
	This is a vector class of general shape in dense storage format. More...
class	Vector< Var, AT >
	This is a vector class of general shape in dense storage format. More...

Typedefs
using	Mat = Matrix< General, Ref, Ref, double >
	General matrix. More...
using	Vec = Vector< Ref, double >
	Vector. More...
using	RowVec = RowVector< Ref, double >
	Row vector. More...
using	SqrMat = SquareMatrix< Ref, double >
	Square matrix. More...
using	DiagMat = Matrix< Diagonal, Ref, Ref, double >
	Diagonal matrix. More...
using	SymMat = Matrix< Symmetric, Ref, Ref, double >
	Symmetric matrix. More...
using	BandMat = Matrix< GeneralBand, Ref, Ref, double >
	Band matrix. More...
using	SparseMat = Matrix< Sparse, Ref, Ref, double >
using	SymSparseMat = Matrix< SymmetricSparse, Ref, Ref, double >
using	VecInt = Vector< Ref, int >
using	VecVI = Vector< Var, int >
using	Vec1 = Vector< Fixed< 1 >, double >
using	Vec2 = Vector< Fixed< 2 >, double >
using	Vec2I = Vector< Fixed< 2 >, int >
using	Vec3 = Vector< Fixed< 3 >, double >
using	Vec4 = Vector< Fixed< 4 >, double >
using	Vec11 = Vector< Fixed< 11 >, double >
using	Vec16 = Vector< Fixed< 16 >, double >
using	RowVec1 = RowVector< Fixed< 1 >, double >
using	RowVec2 = RowVector< Fixed< 2 >, double >
using	RowVec3 = RowVector< Fixed< 3 >, double >
using	RowVec4 = RowVector< Fixed< 4 >, double >
using	RowVec11 = RowVector< Fixed< 11 >, double >
using	RowVec16 = RowVector< Fixed< 16 >, double >
using	Mat3x3 = Matrix< General, Fixed< 3 >, Fixed< 3 >, double >
using	Mat3x2 = Matrix< General, Fixed< 3 >, Fixed< 2 >, double >
using	Mat3x11 = Matrix< General, Fixed< 3 >, Fixed< 11 >, double >
using	Mat3x16 = Matrix< General, Fixed< 3 >, Fixed< 16 >, double >
using	Mat4x16 = Matrix< General, Fixed< 4 >, Fixed< 16 >, double >
using	Mat16x3 = Matrix< General, Fixed< 16 >, Fixed< 3 >, double >
using	Mat16x4 = Matrix< General, Fixed< 16 >, Fixed< 4 >, double >
using	SqrMat1 = SquareMatrix< Fixed< 1 >, double >
using	SqrMat2 = SquareMatrix< Fixed< 2 >, double >
using	SqrMat3 = SquareMatrix< Fixed< 3 >, double >
using	SqrMat11 = SquareMatrix< Fixed< 11 >, double >
using	SqrMat16 = SquareMatrix< Fixed< 16 >, double >
using	SymMat3 = Matrix< Symmetric, Fixed< 3 >, Fixed< 3 >, double >
using	SymMat4 = Matrix< Symmetric, Fixed< 4 >, Fixed< 4 >, double >
using	SymMatV = Matrix< Symmetric, Var, Var, double >
using	MatV = Matrix< General, Var, Var, double >
using	MatVI = Matrix< General, Var, Var, int >
using	SqrMatV = SquareMatrix< Var, double >
using	VecV = Vector< Var, double >
using	RowVecV = RowVector< Var, double >
using	RowVecVI = RowVector< Var, int >
using	RotMat3 = Matrix< Rotation, Fixed< 3 >, Fixed< 3 >, double >
using	Mat2xV = Matrix< General, Fixed< 2 >, Var, double >
using	MatVx2I = Matrix< General, Var, Fixed< 2 >, int >
using	Mat3xV = Matrix< General, Fixed< 3 >, Var, double >
using	Mat3xVI = Matrix< General, Fixed< 3 >, Var, int >
using	MatVx2 = Matrix< General, Var, Fixed< 2 >, double >
using	MatVx3 = Matrix< General, Var, Fixed< 3 >, double >
using	MatVx3I = Matrix< General, Var, Fixed< 3 >, int >
using	RangeV = Range< Var, Var >
template<int N>
using	StringLiteral = char[N]

Functions
template<class T >
void	erase (T &cache)
SymbolicExpression	pow (const SymbolicExpression &a, const SymbolicExpression &b)
SymbolicExpression	log (const SymbolicExpression &a)
SymbolicExpression	sqrt (const SymbolicExpression &a)
SymbolicExpression	sin (const SymbolicExpression &a)
SymbolicExpression	cos (const SymbolicExpression &a)
SymbolicExpression	tan (const SymbolicExpression &a)
SymbolicExpression	sinh (const SymbolicExpression &a)
SymbolicExpression	cosh (const SymbolicExpression &a)
SymbolicExpression	tanh (const SymbolicExpression &a)
SymbolicExpression	asin (const SymbolicExpression &a)
SymbolicExpression	acos (const SymbolicExpression &a)
SymbolicExpression	atan (const SymbolicExpression &a)
SymbolicExpression	atan2 (const SymbolicExpression &y, const SymbolicExpression &x)
SymbolicExpression	asinh (const SymbolicExpression &a)
SymbolicExpression	acosh (const SymbolicExpression &a)
SymbolicExpression	atanh (const SymbolicExpression &a)
SymbolicExpression	exp (const SymbolicExpression &a)
SymbolicExpression	sign (const SymbolicExpression &a)
SymbolicExpression	heaviside (const SymbolicExpression &a)
SymbolicExpression	abs (const SymbolicExpression &a)
SymbolicExpression	min (const SymbolicExpression &a, const SymbolicExpression &b)
SymbolicExpression	max (const SymbolicExpression &a, const SymbolicExpression &b)
SymbolicExpression	condition (const SymbolicExpression &c, const SymbolicExpression &gt, const SymbolicExpression &lt)
ostream &	operator<< (ostream &s, const SymbolicExpression &se)
	Write a SymbolicExpression to a stream using serialization.
istream &	operator>> (istream &s, SymbolicExpression &se)
istream &	operator>> (istream &s, IndependentVariable &v)
SymbolicExpression	operator+ (double a, const SymbolicExpression &b)
SymbolicExpression	operator- (double a, const SymbolicExpression &b)
SymbolicExpression	operator* (double a, const SymbolicExpression &b)
SymbolicExpression	operator/ (double a, const SymbolicExpression &b)
SymbolicExpression	operator+ (int a, const SymbolicExpression &b)
SymbolicExpression	operator+ (long a, const SymbolicExpression &b)
SymbolicExpression	operator- (int a, const SymbolicExpression &b)
SymbolicExpression	operator- (long a, const SymbolicExpression &b)
SymbolicExpression	operator* (int a, const SymbolicExpression &b)
SymbolicExpression	operator* (long a, const SymbolicExpression &b)
SymbolicExpression	operator/ (int a, const SymbolicExpression &b)
SymbolicExpression	operator/ (long a, const SymbolicExpression &b)
SymbolicExpression	parDer (const SymbolicExpression &dep, const IndependentVariable &indep)
template<>
boost::spirit::qi::rule< boost::spirit::istream_iterator, IndependentVariable()> &	getBoostSpiritQiRule< IndependentVariable > ()
template<>
boost::spirit::qi::rule< boost::spirit::istream_iterator, SymbolicExpression()> &	getBoostSpiritQiRule< SymbolicExpression > ()
template<>
boost::spirit::karma::rule< std::ostream_iterator< char >, SymbolicExpression()> &	getBoostSpiritKarmaRule< SymbolicExpression > ()
template<>
boost::spirit::karma::rule< std::ostream_iterator< char >, IndependentVariable()> &	getBoostSpiritKarmaRule< IndependentVariable > ()
FMATVEC_EXPORT std::ostream &	operator<< (std::ostream &s, const SymbolicExpression &se)
	Write a SymbolicExpression to a stream using serialization.
FMATVEC_EXPORT std::istream &	operator>> (std::istream &s, SymbolicExpression &se)
	Create/initialize a SymbolicExpression from a stream using deserialization.
FMATVEC_EXPORT std::istream &	operator>> (std::istream &s, IndependentVariable &v)
	Create/initialize a IndependentVariable from a stream using deserialization.
bool	operator< (const fmatvec::SymbolicExpression &a, const fmatvec::SymbolicExpression &b) noexcept
template<>
boost::spirit::qi::rule< boost::spirit::istream_iterator, IndependentVariable()> &	getBoostSpiritQiRule< IndependentVariable > ()
template<>
boost::spirit::qi::rule< boost::spirit::istream_iterator, SymbolicExpression()> &	getBoostSpiritQiRule< SymbolicExpression > ()
template<>
boost::spirit::karma::rule< std::ostream_iterator< char >, IndependentVariable()> &	getBoostSpiritKarmaRule< IndependentVariable > ()
template<>
boost::spirit::karma::rule< std::ostream_iterator< char >, SymbolicExpression()> &	getBoostSpiritKarmaRule< SymbolicExpression > ()
osyncstream &	operator<< (osyncstream &os, char ch)
osyncstream &	operator<< (osyncstream &os, signed char ch)
osyncstream &	operator<< (osyncstream &os, unsigned char ch)
osyncstream &	operator<< (osyncstream &os, const char *s)
osyncstream &	operator<< (osyncstream &os, const signed char *s)
osyncstream &	operator<< (osyncstream &os, const unsigned char *s)
osyncstream &	operator<< (osyncstream &os, const std::string &s)
template<class Value >
void	checkDerivative (const void *idPtr, const std::string &idName, const std::function< void(double)> &func, const Value &anaDiff, const Value &value, double indep, double eps=1e-6, double delta=1e-8)
template<class T >
std::complex< T >	operator+ (const std::complex< T > &x, int y)
template<class T >
std::complex< T >	operator- (const std::complex< T > &x, int y)
template<class T >
std::complex< T >	operator* (const std::complex< T > &x, int y)
template<class T >
std::complex< T >	operator/ (const std::complex< T > &x, int y)
template<class T >
std::complex< T >	operator+ (int x, const std::complex< T > &y)
template<class T >
std::complex< T >	operator- (int x, const std::complex< T > &y)
template<class T >
std::complex< T >	operator* (int x, const std::complex< T > &y)
template<class T >
std::complex< T >	operator/ (int x, const std::complex< T > &y)
template<class Row1 , class Row2 , class Row3 , class AT1 , class AT2 , class AT3 >
void	add (const Vector< Row1, AT1 > &a1, const Vector< Row2, AT2 > &a2, Vector< Row3, AT3 > &a3)
template<class Row1 , class Row2 , class AT >
void	add (Vector< Row1, AT > &a1, const Vector< Row2, AT > &a2)
template<class Row1 , class Row2 , class Row3 , class AT1 , class AT2 >
void	sub (const Vector< Row1, AT1 > &a1, const Vector< Row2, AT2 > &a2, Vector< Row3, typename fmatvec::OperatorResult< AT1, AT2 >::Type > &a3)
template<class Row1 , class Row2 , class AT1 , class AT2 >
void	sub (Vector< Row1, AT1 > &a1, const Vector< Row2, AT2 > &a2)
template<class AT1 , class AT2 , class Row1 , class Row2 >
Vector< Var, typename OperatorResult< AT1, AT2 >::Type >	operator+ (const Vector< Row1, AT1 > &a, const Vector< Row2, AT2 > &b)
template<class AT1 , class AT2 , class Row >
Vector< Row, typename OperatorResult< AT1, AT2 >::Type >	operator+ (const Vector< Row, AT1 > &a, const Vector< Row, AT2 > &b)
template<class AT1 , class AT2 , int M, class Row >
Vector< Fixed< M >, typename OperatorResult< AT1, AT2 >::Type >	operator+ (const Vector< Fixed< M >, AT1 > &a, const Vector< Row, AT2 > &b)
template<class AT1 , class AT2 , int M>
Vector< Fixed< M >, typename OperatorResult< AT1, AT2 >::Type >	operator+ (const Vector< Fixed< M >, AT1 > &a, const Vector< Fixed< M >, AT2 > &b)
template<class Row1 , class Row2 >
Vector< Row2, double >	operator+ (Vector< Row1, double > &&a, Vector< Row2, double > &&b)
template<class Row1 , class Row2 >
Vector< Row1, double >	operator+ (Vector< Row1, double > &&a, const Vector< Row2, double > &b)
template<class Row1 , class Row2 >
Vector< Row2, double >	operator+ (const Vector< Row1, double > &a, Vector< Row2, double > &&b)
template<class AT , class Row1 , class Row2 >
Vector< Row1, AT >	operator+= (Vector< Row1, AT > &a, const Vector< Row2, AT > &b)
template<class AT1 , class AT2 , class Row1 , class Row2 >
Vector< Var, typename fmatvec::OperatorResult< AT1, AT2 >::Type >	operator- (const Vector< Row1, AT1 > &a, const Vector< Row2, AT2 > &b)
template<class AT1 , class AT2 , class Row >
Vector< Row, typename fmatvec::OperatorResult< AT1, AT2 >::Type >	operator- (const Vector< Row, AT1 > &a, const Vector< Row, AT2 > &b)
template<class AT1 , class AT2 , int M, class Row2 >
Vector< Fixed< M >, typename fmatvec::OperatorResult< AT1, AT2 >::Type >	operator- (const Vector< Fixed< M >, AT1 > &a, const Vector< Row2, AT2 > &b)
template<class AT1 , class AT2 , int M>
Vector< Fixed< M >, typename fmatvec::OperatorResult< AT1, AT2 >::Type >	operator- (const Vector< Fixed< M >, AT1 > &a, const Vector< Fixed< M >, AT2 > &b)
template<class Row1 , class Row2 , class AT >
Vector< Row2, AT >	operator- (Vector< Row1, AT > &&a, Vector< Row2, AT > &&b)
template<class Row1 , class Row2 , class AT >
Vector< Row1, AT >	operator- (Vector< Row1, AT > &&a, const Vector< Row2, AT > &b)
template<class Row1 , class Row2 , class AT >
Vector< Row2, AT >	operator- (const Vector< Row1, AT > &a, Vector< Row2, AT > &&b)
template<class AT , class Row1 , class Row2 >
Vector< Row1, AT >	operator-= (Vector< Row1, AT > &a, const Vector< Row2, AT > &b)
template<class Col1 , class Col2 , class Col3 , class AT >
void	add (const RowVector< Col1, AT > &a1, const RowVector< Col2, AT > &a2, RowVector< Col3, AT > &a3)
template<class Col1 , class Col2 , class AT >
void	add (RowVector< Col1, AT > &a1, const RowVector< Col2, AT > &a2)
template<class Col1 , class Col2 , class Col3 , class AT1 , class AT2 >
void	sub (const RowVector< Col1, AT1 > &a1, const RowVector< Col2, AT2 > &a2, RowVector< Col3, typename fmatvec::OperatorResult< AT1, AT2 >::Type > &a3)
template<class Col1 , class Col2 , class AT1 , class AT2 >
void	sub (RowVector< Col1, AT1 > &a1, const RowVector< Col2, AT2 > &a2)
template<class AT1 , class AT2 , class Col1 , class Col2 >
RowVector< Var, typename OperatorResult< AT1, AT2 >::Type >	operator+ (const RowVector< Col1, AT1 > &a, const RowVector< Col2, AT2 > &b)
template<class AT1 , class AT2 , class Col >
RowVector< Col, typename OperatorResult< AT1, AT2 >::Type >	operator+ (const RowVector< Col, AT1 > &a, const RowVector< Col, AT2 > &b)
template<class AT1 , class AT2 , int N, class Col2 >
RowVector< Fixed< N >, typename OperatorResult< AT1, AT2 >::Type >	operator+ (const RowVector< Fixed< N >, AT1 > &a, const RowVector< Col2, AT2 > &b)
template<class AT1 , class AT2 , int N>
RowVector< Fixed< N >, typename OperatorResult< AT1, AT2 >::Type >	operator+ (const RowVector< Fixed< N >, AT1 > &a, const RowVector< Fixed< N >, AT2 > &b)
template<class Row1 , class Row2 >
RowVector< Row2, double >	operator+ (RowVector< Row1, double > &&a, RowVector< Row2, double > &&b)
template<class Row1 , class Row2 >
RowVector< Row1, double >	operator+ (RowVector< Row1, double > &&a, const RowVector< Row2, double > &b)
template<class Row1 , class Row2 >
RowVector< Row2, double >	operator+ (const RowVector< Row1, double > &a, RowVector< Row2, double > &&b)
template<class AT , class Col1 , class Col2 >
RowVector< Col1, AT >	operator+= (RowVector< Col1, AT > &a, const RowVector< Col2, AT > &b)
template<class AT1 , class AT2 , class Col1 , class Col2 >
RowVector< Var, typename fmatvec::OperatorResult< AT1, AT2 >::Type >	operator- (const RowVector< Col1, AT1 > &a, const RowVector< Col2, AT2 > &b)
template<class AT1 , class AT2 , class Col >
RowVector< Col, typename fmatvec::OperatorResult< AT1, AT2 >::Type >	operator- (const RowVector< Col, AT1 > &a, const RowVector< Col, AT2 > &b)
template<class AT1 , class AT2 , int N, class Col2 >
RowVector< Fixed< N >, typename fmatvec::OperatorResult< AT1, AT2 >::Type >	operator- (const RowVector< Fixed< N >, AT1 > &a, const RowVector< Col2, AT2 > &b)
template<class AT1 , class AT2 , int N>
RowVector< Fixed< N >, typename fmatvec::OperatorResult< AT1, AT2 >::Type >	operator- (const RowVector< Fixed< N >, AT1 > &a, const RowVector< Fixed< N >, AT2 > &b)
template<class Row1 , class Row2 , class AT >
RowVector< Row2, AT >	operator- (RowVector< Row1, AT > &&a, RowVector< Row2, AT > &&b)
template<class Row1 , class Row2 , class AT >
RowVector< Row1, AT >	operator- (RowVector< Row1, AT > &&a, const RowVector< Row2, AT > &b)
template<class Row1 , class Row2 , class AT >
RowVector< Row2, AT >	operator- (const RowVector< Row1, AT > &a, RowVector< Row2, AT > &&b)
template<class AT , class Col1 , class Col2 >
RowVector< Col1, AT >	operator-= (RowVector< Col1, AT > &a, const RowVector< Col2, AT > &b)
template<class Type1 , class Row1 , class Col1 , class Type2 , class Row2 , class Col2 , class Type3 , class Row3 , class Col3 , class AT1 , class AT2 , class AT3 >
void	add (const Matrix< Type1, Row1, Col1, AT1 > &A1, const Matrix< Type2, Row2, Col2, AT2 > &A2, Matrix< Type3, Row3, Col3, AT3 > &A3)
template<class Row1 , class Row2 , class Row3 , class AT >
void	add (const Matrix< Symmetric, Row1, Row1, AT > &A1, const Matrix< Symmetric, Row2, Row2, AT > &A2, Matrix< Symmetric, Row3, Row3, AT > &A3)
template<class Row1 , class Row2 , class Row3 , class AT >
void	add (const Matrix< Diagonal, Row1, Row1, AT > &A1, const Matrix< Diagonal, Row2, Row2, AT > &A2, Matrix< Diagonal, Row3, Row3, AT > &A3)
template<class Type1 , class Row1 , class Col1 , class Type2 , class Row2 , class Col2 , class AT >
void	add (Matrix< Type1, Row1, Col1, AT > &A1, const Matrix< Type2, Row2, Col2, AT > &A2)
template<class Row1 , class Row2 , class AT >
void	add (Matrix< Symmetric, Row1, Row1, AT > &A1, const Matrix< Symmetric, Row2, Row2, AT > &A2)
template<class Type1 , class Row1 , class Col1 , class Type2 , class Row2 , class Col2 , class Type3 , class Row3 , class Col3 , class AT1 , class AT2 >
void	sub (const Matrix< Type1, Row1, Col1, AT1 > &A1, const Matrix< Type2, Row2, Col2, AT2 > &A2, Matrix< Type3, Row3, Col3, typename fmatvec::OperatorResult< AT1, AT2 >::Type > &A3)
template<class Row1 , class Row2 , class Row3 , class AT1 , class AT2 >
void	sub (const Matrix< Symmetric, Row1, Row1, AT1 > &A1, const Matrix< Symmetric, Row2, Row2, AT2 > &A2, Matrix< Symmetric, Row3, Row3, typename fmatvec::OperatorResult< AT1, AT2 >::Type > &A3)
template<class Row1 , class Row2 , class Row3 , class AT1 , class AT2 >
void	sub (const Matrix< Diagonal, Row1, Row1, AT1 > &A1, const Matrix< Diagonal, Row2, Row2, AT2 > &A2, Matrix< Diagonal, Row3, Row3, typename fmatvec::OperatorResult< AT1, AT2 >::Type > &A3)
template<class Type1 , class Row1 , class Col1 , class Type2 , class Row2 , class Col2 , class AT1 , class AT2 >
void	sub (Matrix< Type1, Row1, Col1, AT1 > &A1, const Matrix< Type2, Row2, Col2, AT2 > &A2)
template<class Row1 , class Row2 , class AT1 , class AT2 >
void	sub (Matrix< Symmetric, Row1, Row1, AT1 > &A1, const Matrix< Symmetric, Row2, Row2, AT2 > &A2)
template<class AT1 , class AT2 , class Type1 , class Type2 , class Row1 , class Col1 , class Row2 , class Col2 >
Matrix< General, Var, Var, typename OperatorResult< AT1, AT2 >::Type >	operator+ (const Matrix< Type1, Row1, Col1, AT1 > &A, const Matrix< Type2, Row2, Col2, AT2 > &B)
template<class AT1 , class AT2 , class Type1 , class Type2 , class Row , class Col >
Matrix< General, Row, Col, typename OperatorResult< AT1, AT2 >::Type >	operator+ (const Matrix< Type1, Row, Col, AT1 > &A, const Matrix< Type2, Row, Col, AT2 > &B)
template<class AT1 , class AT2 , int M, class Type1 , class Type2 , class Row , class Col >
Matrix< General, Fixed< M >, Var, typename OperatorResult< AT1, AT2 >::Type >	operator+ (const Matrix< Type1, Fixed< M >, Var, AT1 > &A, const Matrix< Type2, Row, Col, AT2 > &B)
template<class AT1 , class AT2 , int M, class Type1 , class Type2 >
Matrix< General, Fixed< M >, Var, typename OperatorResult< AT1, AT2 >::Type >	operator+ (const Matrix< Type1, Fixed< M >, Var, AT1 > &A, const Matrix< Type2, Fixed< M >, Var, AT2 > &B)
template<class AT1 , class AT2 , int N, class Type1 , class Type2 , class Row , class Col >
Matrix< General, Var, Fixed< N >, typename OperatorResult< AT1, AT2 >::Type >	operator+ (const Matrix< Type1, Var, Fixed< N >, AT1 > &A, const Matrix< Type2, Row, Col, AT2 > &B)
template<class AT1 , class AT2 , int N, class Type1 , class Type2 >
Matrix< General, Var, Fixed< N >, typename OperatorResult< AT1, AT2 >::Type >	operator+ (const Matrix< Type1, Var, Fixed< N >, AT1 > &A, const Matrix< Type2, Var, Fixed< N >, AT2 > &B)
template<class AT1 , class AT2 , int M, int N, class Type1 , class Type2 , class Row , class Col >
Matrix< General, Fixed< M >, Fixed< N >, typename OperatorResult< AT1, AT2 >::Type >	operator+ (const Matrix< Type1, Fixed< M >, Fixed< N >, AT1 > &A, const Matrix< Type2, Row, Col, AT2 > &B)
template<class AT1 , class AT2 , int M, int N, class Type1 , class Type2 >
Matrix< General, Fixed< M >, Fixed< N >, typename OperatorResult< AT1, AT2 >::Type >	operator+ (const Matrix< Type1, Fixed< M >, Fixed< N >, AT1 > &A, const Matrix< Type2, Fixed< M >, Var, AT2 > &B)
template<class AT1 , class AT2 , int M, int N, class Type1 , class Type2 >
Matrix< General, Fixed< M >, Fixed< N >, typename OperatorResult< AT1, AT2 >::Type >	operator+ (const Matrix< Type1, Fixed< M >, Fixed< N >, AT1 > &A, const Matrix< Type2, Var, Fixed< N >, AT2 > &B)
template<class AT1 , class AT2 , int M, int N, class Type1 , class Type2 >
Matrix< General, Fixed< M >, Fixed< N >, typename OperatorResult< AT1, AT2 >::Type >	operator+ (const Matrix< Type1, Fixed< M >, Fixed< N >, AT1 > &A, const Matrix< Type2, Fixed< M >, Fixed< N >, AT2 > &B)
template<class AT1 , class AT2 , int M, int N, class Type1 , class Type2 , class Row , class Col >
Matrix< General, Fixed< M >, Fixed< N >, typename OperatorResult< AT1, AT2 >::Type >	operator+ (const Matrix< Type2, Row, Col, AT1 > &A, const Matrix< Type1, Fixed< M >, Fixed< N >, AT2 > &B)
template<class AT1 , class AT2 , int M, int N, class Type1 , class Type2 >
Matrix< General, Fixed< M >, Fixed< N >, typename OperatorResult< AT1, AT2 >::Type >	operator+ (const Matrix< Type2, Fixed< M >, Var, AT1 > &A, const Matrix< Type1, Fixed< M >, Fixed< N >, AT2 > &B)
template<class AT1 , class AT2 , int M, int N, class Type1 , class Type2 >
Matrix< General, Fixed< M >, Fixed< N >, typename OperatorResult< AT1, AT2 >::Type >	operator+ (const Matrix< Type2, Var, Fixed< N >, AT1 > &A, const Matrix< Type1, Fixed< M >, Fixed< N >, AT2 > &B)
template<class AT1 , class AT2 , class Type , class Row1 , class Col1 , class Row2 , class Col2 >
Matrix< Type, Var, Var, typename OperatorResult< AT1, AT2 >::Type >	operator+ (const Matrix< Type, Row1, Col1, AT1 > &A, const Matrix< Type, Row2, Col2, AT2 > &B)
template<class AT1 , class AT2 , class Type , class Row , class Col >
Matrix< Type, Row, Col, typename OperatorResult< AT1, AT2 >::Type >	operator+ (const Matrix< Type, Row, Col, AT1 > &A, const Matrix< Type, Row, Col, AT2 > &B)
template<class AT1 , class AT2 , int M, class Type , class Row , class Col >
Matrix< Type, Fixed< M >, Var, typename OperatorResult< AT1, AT2 >::Type >	operator+ (const Matrix< Type, Fixed< M >, Var, AT1 > &A, const Matrix< Type, Row, Col, AT2 > &B)
template<class AT1 , class AT2 , int M, class Type >
Matrix< Type, Fixed< M >, Var, typename OperatorResult< AT1, AT2 >::Type >	operator+ (const Matrix< Type, Fixed< M >, Var, AT1 > &A, const Matrix< Type, Fixed< M >, Var, AT2 > &B)
template<class AT1 , class AT2 , int N, class Type , class Row , class Col >
Matrix< Type, Var, Fixed< N >, typename OperatorResult< AT1, AT2 >::Type >	operator+ (const Matrix< Type, Var, Fixed< N >, AT1 > &A, const Matrix< Type, Row, Col, AT2 > &B)
template<class AT1 , class AT2 , int N, class Type >
Matrix< Type, Var, Fixed< N >, typename OperatorResult< AT1, AT2 >::Type >	operator+ (const Matrix< Type, Var, Fixed< N >, AT1 > &A, const Matrix< Type, Var, Fixed< N >, AT2 > &B)
template<class AT1 , class AT2 , int M, int N, class Type , class Row , class Col >
Matrix< Type, Fixed< M >, Fixed< N >, typename OperatorResult< AT1, AT2 >::Type >	operator+ (const Matrix< Type, Fixed< M >, Fixed< N >, AT1 > &A, const Matrix< Type, Row, Col, AT2 > &B)
template<class AT1 , class AT2 , int M, int N, class Type >
Matrix< Type, Fixed< M >, Fixed< N >, typename OperatorResult< AT1, AT2 >::Type >	operator+ (const Matrix< Type, Fixed< M >, Fixed< N >, AT1 > &A, const Matrix< Type, Fixed< M >, Var, AT2 > &B)
template<class AT1 , class AT2 , int M, int N, class Type >
Matrix< Type, Fixed< M >, Fixed< N >, typename OperatorResult< AT1, AT2 >::Type >	operator+ (const Matrix< Type, Fixed< M >, Fixed< N >, AT1 > &A, const Matrix< Type, Var, Fixed< N >, AT2 > &B)
template<class AT1 , class AT2 , int M, int N, class Type >
Matrix< Type, Fixed< M >, Fixed< N >, typename OperatorResult< AT1, AT2 >::Type >	operator+ (const Matrix< Type, Fixed< M >, Fixed< N >, AT1 > &A, const Matrix< Type, Fixed< M >, Fixed< N >, AT2 > &B)
template<class AT1 , class AT2 , int M, int N, class Type , class Row , class Col >
Matrix< Type, Fixed< M >, Fixed< N >, typename OperatorResult< AT1, AT2 >::Type >	operator+ (const Matrix< Type, Row, Col, AT1 > &A, const Matrix< Type, Fixed< M >, Fixed< N >, AT2 > &B)
template<class AT1 , class AT2 , int M, int N, class Type >
Matrix< Type, Fixed< M >, Fixed< N >, typename OperatorResult< AT1, AT2 >::Type >	operator+ (const Matrix< Type, Fixed< M >, Var, AT1 > &A, const Matrix< Type, Fixed< M >, Fixed< N >, AT2 > &B)
template<class AT1 , class AT2 , int M, int N, class Type >
Matrix< Type, Fixed< M >, Fixed< N >, typename OperatorResult< AT1, AT2 >::Type >	operator+ (const Matrix< Type, Var, Fixed< N >, AT1 > &A, const Matrix< Type, Fixed< M >, Fixed< N >, AT2 > &B)
template<class Type1 , class Type2 , class Row1 , class Row2 , class Col1 , class Col2 >
Matrix< Type2, Row2, Col2, double >	operator+ (Matrix< Type1, Row1, Col1, double > &&a, Matrix< Type2, Row2, Col2, double > &&b)
template<class Type1 , class Type2 , class Row1 , class Row2 , class Col1 , class Col2 >
Matrix< Type1, Row1, Col1, double >	operator+ (Matrix< Type1, Row1, Col1, double > &&a, const Matrix< Type2, Row2, Col2, double > &b)
template<class Type1 , class Type2 , class Row1 , class Row2 , class Col1 , class Col2 >
Matrix< Type2, Row2, Col2, double >	operator+ (const Matrix< Type1, Row1, Col1, double > &a, Matrix< Type2, Row2, Col2, double > &&b)
template<class AT , class Type1 , class Row1 , class Col1 , class Type2 , class Row2 , class Col2 >
Matrix< Type1, Row1, Col1, AT > &	operator+= (Matrix< Type1, Row1, Col1, AT > &A, const Matrix< Type2, Row2, Col2, AT > &B)
template<class AT1 , class AT2 , class Type1 , class Type2 , class Row1 , class Col1 , class Row2 , class Col2 >
Matrix< General, Var, Var, typename fmatvec::OperatorResult< AT1, AT2 >::Type >	operator- (const Matrix< Type1, Row1, Col1, AT1 > &A, const Matrix< Type2, Row2, Col2, AT2 > &B)
template<class AT1 , class AT2 , class Type1 , class Type2 , class Row , class Col >
Matrix< General, Row, Col, typename fmatvec::OperatorResult< AT1, AT2 >::Type >	operator- (const Matrix< Type1, Row, Col, AT1 > &A, const Matrix< Type2, Row, Col, AT2 > &B)
template<class AT1 , class AT2 , int M, class Type1 , class Type2 , class Row , class Col >
Matrix< General, Fixed< M >, Var, typename fmatvec::OperatorResult< AT1, AT2 >::Type >	operator- (const Matrix< Type1, Fixed< M >, Var, AT1 > &A, const Matrix< Type2, Row, Col, AT2 > &B)
template<class AT1 , class AT2 , int M, class Type1 , class Type2 >
Matrix< General, Fixed< M >, Var, typename fmatvec::OperatorResult< AT1, AT2 >::Type >	operator- (const Matrix< Type1, Fixed< M >, Var, AT1 > &A, const Matrix< Type2, Fixed< M >, Var, AT2 > &B)
template<class AT1 , class AT2 , int N, class Type1 , class Type2 , class Row , class Col >
Matrix< General, Var, Fixed< N >, typename fmatvec::OperatorResult< AT1, AT2 >::Type >	operator- (const Matrix< Type1, Var, Fixed< N >, AT1 > &A, const Matrix< Type2, Row, Col, AT2 > &B)
template<class AT1 , class AT2 , int N, class Type1 , class Type2 >
Matrix< General, Var, Fixed< N >, typename fmatvec::OperatorResult< AT1, AT2 >::Type >	operator- (const Matrix< Type1, Var, Fixed< N >, AT1 > &A, const Matrix< Type2, Var, Fixed< N >, AT2 > &B)
template<class AT1 , class AT2 , int M, int N, class Type1 , class Type2 , class Row , class Col >
Matrix< General, Fixed< M >, Fixed< N >, typename fmatvec::OperatorResult< AT1, AT2 >::Type >	operator- (const Matrix< Type1, Fixed< M >, Fixed< N >, AT1 > &A, const Matrix< Type2, Row, Col, AT2 > &B)
template<class AT1 , class AT2 , int M, int N, class Type1 , class Type2 >
Matrix< General, Fixed< M >, Fixed< N >, typename fmatvec::OperatorResult< AT1, AT2 >::Type >	operator- (const Matrix< Type1, Fixed< M >, Fixed< N >, AT1 > &A, const Matrix< Type2, Fixed< M >, Var, AT2 > &B)
template<class AT1 , class AT2 , int M, int N, class Type1 , class Type2 >
Matrix< General, Fixed< M >, Fixed< N >, typename fmatvec::OperatorResult< AT1, AT2 >::Type >	operator- (const Matrix< Type1, Fixed< M >, Fixed< N >, AT1 > &A, const Matrix< Type2, Var, Fixed< N >, AT2 > &B)
template<class AT1 , class AT2 , int M, int N, class Type1 , class Type2 >
Matrix< General, Fixed< M >, Fixed< N >, typename fmatvec::OperatorResult< AT1, AT2 >::Type >	operator- (const Matrix< Type1, Fixed< M >, Fixed< N >, AT1 > &A, const Matrix< Type2, Fixed< M >, Fixed< N >, AT2 > &B)
template<class AT1 , class AT2 , int M, int N, class Type1 , class Type2 , class Row , class Col >
Matrix< General, Fixed< M >, Fixed< N >, typename fmatvec::OperatorResult< AT1, AT2 >::Type >	operator- (const Matrix< Type2, Row, Col, AT1 > &A, const Matrix< Type1, Fixed< M >, Fixed< N >, AT2 > &B)
template<class AT1 , class AT2 , int M, int N, class Type1 , class Type2 >
Matrix< General, Fixed< M >, Fixed< N >, typename fmatvec::OperatorResult< AT1, AT2 >::Type >	operator- (const Matrix< Type2, Fixed< M >, Var, AT1 > &A, const Matrix< Type1, Fixed< M >, Fixed< N >, AT2 > &B)
template<class AT1 , class AT2 , int M, int N, class Type1 , class Type2 >
Matrix< General, Fixed< M >, Fixed< N >, typename fmatvec::OperatorResult< AT1, AT2 >::Type >	operator- (const Matrix< Type2, Var, Fixed< N >, AT1 > &A, const Matrix< Type1, Fixed< M >, Fixed< N >, AT2 > &B)
template<class AT1 , class AT2 , class Type , class Row1 , class Col1 , class Row2 , class Col2 >
Matrix< Type, Var, Var, typename fmatvec::OperatorResult< AT1, AT2 >::Type >	operator- (const Matrix< Type, Row1, Col1, AT1 > &A, const Matrix< Type, Row2, Col2, AT2 > &B)
template<class AT1 , class AT2 , class Type , class Row , class Col >
Matrix< Type, Row, Col, typename fmatvec::OperatorResult< AT1, AT2 >::Type >	operator- (const Matrix< Type, Row, Col, AT1 > &A, const Matrix< Type, Row, Col, AT2 > &B)
template<class AT1 , class AT2 , int M, class Type , class Row , class Col >
Matrix< Type, Fixed< M >, Var, typename fmatvec::OperatorResult< AT1, AT2 >::Type >	operator- (const Matrix< Type, Fixed< M >, Var, AT1 > &A, const Matrix< Type, Row, Col, AT2 > &B)
template<class AT1 , class AT2 , int M, class Type >
Matrix< Type, Fixed< M >, Var, typename fmatvec::OperatorResult< AT1, AT2 >::Type >	operator- (const Matrix< Type, Fixed< M >, Var, AT1 > &A, const Matrix< Type, Fixed< M >, Var, AT2 > &B)
template<class AT1 , class AT2 , int N, class Type , class Row , class Col >
Matrix< Type, Var, Fixed< N >, typename fmatvec::OperatorResult< AT1, AT2 >::Type >	operator- (const Matrix< Type, Var, Fixed< N >, AT1 > &A, const Matrix< Type, Row, Col, AT2 > &B)
template<class AT1 , class AT2 , int N, class Type >
Matrix< Type, Var, Fixed< N >, typename fmatvec::OperatorResult< AT1, AT2 >::Type >	operator- (const Matrix< Type, Var, Fixed< N >, AT1 > &A, const Matrix< Type, Var, Fixed< N >, AT2 > &B)
template<class AT1 , class AT2 , int M, int N, class Type , class Row , class Col >
Matrix< Type, Fixed< M >, Fixed< N >, typename fmatvec::OperatorResult< AT1, AT2 >::Type >	operator- (const Matrix< Type, Fixed< M >, Fixed< N >, AT1 > &A, const Matrix< Type, Row, Col, AT2 > &B)
template<class AT1 , class AT2 , int M, int N, class Type >
Matrix< Type, Fixed< M >, Fixed< N >, typename fmatvec::OperatorResult< AT1, AT2 >::Type >	operator- (const Matrix< Type, Fixed< M >, Fixed< N >, AT1 > &A, const Matrix< Type, Fixed< M >, Var, AT2 > &B)
template<class AT1 , class AT2 , int M, int N, class Type >
Matrix< Type, Fixed< M >, Fixed< N >, typename fmatvec::OperatorResult< AT1, AT2 >::Type >	operator- (const Matrix< Type, Fixed< M >, Fixed< N >, AT1 > &A, const Matrix< Type, Var, Fixed< N >, AT2 > &B)
template<class AT1 , class AT2 , int M, int N, class Type >
Matrix< Type, Fixed< M >, Fixed< N >, typename fmatvec::OperatorResult< AT1, AT2 >::Type >	operator- (const Matrix< Type, Fixed< M >, Fixed< N >, AT1 > &A, const Matrix< Type, Fixed< M >, Fixed< N >, AT2 > &B)
template<class AT1 , class AT2 , int M, int N, class Type , class Row , class Col >
Matrix< Type, Fixed< M >, Fixed< N >, typename fmatvec::OperatorResult< AT1, AT2 >::Type >	operator- (const Matrix< Type, Row, Col, AT1 > &A, const Matrix< Type, Fixed< M >, Fixed< N >, AT2 > &B)
template<class AT1 , class AT2 , int M, int N, class Type >
Matrix< Type, Fixed< M >, Fixed< N >, typename fmatvec::OperatorResult< AT1, AT2 >::Type >	operator- (const Matrix< Type, Fixed< M >, Var, AT1 > &A, const Matrix< Type, Fixed< M >, Fixed< N >, AT2 > &B)
template<class AT1 , class AT2 , int M, int N, class Type >
Matrix< Type, Fixed< M >, Fixed< N >, typename fmatvec::OperatorResult< AT1, AT2 >::Type >	operator- (const Matrix< Type, Var, Fixed< N >, AT1 > &A, const Matrix< Type, Fixed< M >, Fixed< N >, AT2 > &B)
template<class Type1 , class Type2 , class Row1 , class Row2 , class Col1 , class Col2 , class AT >
Matrix< Type2, Row2, Col2, AT >	operator- (Matrix< Type1, Row1, Col1, AT > &&a, Matrix< Type2, Row2, Col2, AT > &&b)
template<class Type1 , class Type2 , class Row1 , class Row2 , class Col1 , class Col2 , class AT >
Matrix< Type1, Row1, Col1, AT >	operator- (Matrix< Type1, Row1, Col1, AT > &&a, const Matrix< Type2, Row2, Col2, AT > &b)
template<class Type1 , class Type2 , class Row1 , class Row2 , class Col1 , class Col2 , class AT >
Matrix< Type2, Row2, Col2, AT >	operator- (const Matrix< Type1, Row1, Col1, AT > &a, Matrix< Type2, Row2, Col2, AT > &&b)
template<class AT , class Type1 , class Row1 , class Col1 , class Type2 , class Row2 , class Col2 >
Matrix< Type1, Row1, Col1, AT > &	operator-= (Matrix< Type1, Row1, Col1, AT > &A, const Matrix< Type2, Row2, Col2, AT > &B)
template<class AT1 , class AT2 , class Row1 , class Row2 >
SquareMatrix< Var, typename OperatorResult< AT1, AT2 >::Type >	operator+ (const SquareMatrix< Row1, AT1 > &A1, const SquareMatrix< Row2, AT2 > &A2)
template<class AT1 , class AT2 , class Row >
SquareMatrix< Row, typename OperatorResult< AT1, AT2 >::Type >	operator+ (const SquareMatrix< Row, AT1 > &A1, const SquareMatrix< Row, AT2 > &A2)
template<class Row1 , class Row2 >
SquareMatrix< Row1, double >	operator+ (SquareMatrix< Row1, double > &&A1, SquareMatrix< Row2, double > &&A2)
template<class Row1 , class Row2 >
SquareMatrix< Row1, double >	operator+ (SquareMatrix< Row1, double > &&A1, const SquareMatrix< Row2, double > &A2)
template<class Row1 , class Row2 >
SquareMatrix< Row2, double >	operator+ (const SquareMatrix< Row1, double > &A1, SquareMatrix< Row2, double > &&A2)
template<class AT1 , class AT2 , class Row1 , class Row2 >
SquareMatrix< Var, typename fmatvec::OperatorResult< AT1, AT2 >::Type >	operator- (const SquareMatrix< Row1, AT1 > &A1, const SquareMatrix< Row2, AT2 > &A2)
template<class AT1 , class AT2 , class Row >
SquareMatrix< Row, typename fmatvec::OperatorResult< AT1, AT2 >::Type >	operator- (const SquareMatrix< Row, AT1 > &A1, const SquareMatrix< Row, AT2 > &A2)
template<class Row1 , class Row2 , class AT >
SquareMatrix< Row1, AT >	operator- (SquareMatrix< Row1, AT > &&A1, SquareMatrix< Row2, AT > &&A2)
template<class Row1 , class Row2 , class AT >
SquareMatrix< Row1, AT >	operator- (SquareMatrix< Row1, AT > &&A1, const SquareMatrix< Row2, AT > &A2)
template<class Row1 , class Row2 , class AT >
SquareMatrix< Row2, AT >	operator- (const SquareMatrix< Row1, AT > &A1, SquareMatrix< Row2, AT > &&A2)
template<class Type1 , class Row1 , class Col1 , class Row2 , class Row3 , class AT1 , class AT2 >
void	mult (const Matrix< Type1, Row1, Col1, AT1 > &A, const Vector< Row2, AT2 > &x, Vector< Row3, typename fmatvec::OperatorResult< AT1, AT2 >::Type > &y)
template<class Row1 , class Row2 , class Row3 , class AT1 , class AT2 >
void	mult (const Matrix< Symmetric, Row1, Row1, AT1 > &A, const Vector< Row2, AT2 > &x, Vector< Row3, typename fmatvec::OperatorResult< AT1, AT2 >::Type > &y)
template<class Row2 , class Row3 , class AT1 , class AT2 >
void	mult (const Matrix< Sparse, Ref, Ref, AT1 > &A, const Vector< Row2, AT2 > &x, Vector< Row3, typename fmatvec::OperatorResult< AT1, AT2 >::Type > &y)
template<class Row2 , class Row3 , class AT1 , class AT2 >
void	mult (const Matrix< SymmetricSparse, Ref, Ref, AT1 > &A, const Vector< Row2, AT2 > &x, Vector< Row3, typename fmatvec::OperatorResult< AT1, AT2 >::Type > &y)
template<class AT1 , class AT2 , class Type1 , class Row1 , class Col1 , class Row2 >
Vector< Var, typename OperatorResult< AT1, AT2 >::Type >	operator* (const Matrix< Type1, Row1, Col1, AT1 > &A, const Vector< Row2, AT2 > &x)
template<class AT1 , class AT2 , class Type1 , class Row , class Col >
Vector< Row, typename OperatorResult< AT1, AT2 >::Type >	operator* (const Matrix< Type1, Row, Col, AT1 > &A, const Vector< Row, AT2 > &x)
template<class AT1 , class AT2 , int M, class Type1 , class Col1 , class Row2 >
Vector< Fixed< M >, typename OperatorResult< AT1, AT2 >::Type >	operator* (const Matrix< Type1, Fixed< M >, Col1, AT1 > &A, const Vector< Row2, AT2 > &x)
template<class AT1 , class AT2 , int M, class Type1 >
Vector< Fixed< M >, typename OperatorResult< AT1, AT2 >::Type >	operator* (const Matrix< Type1, Fixed< M >, Fixed< M >, AT1 > &A, const Vector< Fixed< M >, AT2 > &x)
template<class AT1 , class AT2 , int M, int N, class Type , class Row2 >
Vector< Fixed< M >, typename OperatorResult< AT1, AT2 >::Type >	operator* (const Matrix< Type, Fixed< M >, Fixed< N >, AT1 > &A, const Vector< Row2, AT2 > &x)
template<class AT1 , class AT2 , int M, int N, class Type >
Vector< Fixed< M >, typename OperatorResult< AT1, AT2 >::Type >	operator* (const Matrix< Type, Fixed< M >, Fixed< N >, AT1 > &A, const Vector< Fixed< N >, AT2 > &x)
template<class Col1 , class Type2 , class Row2 , class Col2 , class Type3 , class Col3 , class AT1 , class AT2 >
void	mult (const RowVector< Col1, AT1 > &x, const Matrix< Type2, Row2, Col2, AT2 > &A, RowVector< Col3, typename fmatvec::OperatorResult< AT1, AT2 >::Type > &y)
template<class Col1 , class Row2 , class Col3 , class AT1 , class AT2 >
void	mult (const RowVector< Col1, AT1 > &x, const Matrix< Symmetric, Row2, Row2, AT2 > &A, RowVector< Col3, typename fmatvec::OperatorResult< AT1, AT2 >::Type > &y)
template<class AT1 , class AT2 , class Type2 , class Col2 , class Row1 , class Col1 >
RowVector< Var, typename OperatorResult< AT1, AT2 >::Type >	operator* (const RowVector< Col2, AT1 > &x, const Matrix< Type2, Row1, Col1, AT2 > &A)
template<class AT1 , class AT2 , class Type2 , class Row , class Col >
RowVector< Col, typename OperatorResult< AT1, AT2 >::Type >	operator* (const RowVector< Col, AT1 > &x, const Matrix< Type2, Row, Col, AT2 > &A)
template<class AT1 , class AT2 , int N, class Type2 , class Col1 , class Row2 >
RowVector< Fixed< N >, typename OperatorResult< AT1, AT2 >::Type >	operator* (const RowVector< Col1, AT1 > &x, const Matrix< Type2, Row2, Fixed< N >, AT2 > &A)
template<class AT1 , class AT2 , int N, class Type2 >
RowVector< Fixed< N >, typename OperatorResult< AT1, AT2 >::Type >	operator* (const RowVector< Fixed< N >, AT1 > &x, const Matrix< Type2, Fixed< N >, Fixed< N >, AT2 > &A)
template<class Type1 , class Row1 , class Col1 , class Type2 , class Row2 , class Col2 , class Type3 , class Row3 , class Col3 , class AT1 , class AT2 >
void	mult (const Matrix< Type1, Row1, Col1, AT1 > &A1, const Matrix< Type2, Row2, Col2, AT2 > &A2, Matrix< Type3, Row3, Col3, typename fmatvec::OperatorResult< AT1, AT2 >::Type > &A3)
template<class Row1 , class Type2 , class Row2 , class Col2 , class Type3 , class Row3 , class Col3 , class AT1 , class AT2 >
void	mult (const Matrix< Symmetric, Row1, Row1, AT1 > &A1, const Matrix< Type2, Row2, Col2, AT2 > &A2, Matrix< Type3, Row3, Col3, typename fmatvec::OperatorResult< AT1, AT2 >::Type > &A3)
template<class Row1 , class Row2 , class Row3 , class AT1 , class AT2 >
void	mult (const Matrix< Diagonal, Row1, Row1, AT1 > &A1, const Matrix< Diagonal, Row2, Row2, AT2 > &A2, Matrix< Diagonal, Row3, Row3, typename fmatvec::OperatorResult< AT1, AT2 >::Type > &A3)
template<class Type2 , class Row2 , class Col2 , class Type3 , class Row3 , class Col3 , class AT1 , class AT2 >
void	mult (const Matrix< Sparse, Ref, Ref, AT1 > &A1, const Matrix< Type2, Row2, Col2, AT2 > &A2, Matrix< Type3, Row3, Col3, typename fmatvec::OperatorResult< AT1, AT2 >::Type > &A3)
template<class Type2 , class Row2 , class Col2 , class Type3 , class Row3 , class Col3 , class AT1 , class AT2 >
void	mult (const Matrix< SymmetricSparse, Ref, Ref, AT1 > &A1, const Matrix< Type2, Row2, Col2, AT2 > &A2, Matrix< Type3, Row3, Col3, typename fmatvec::OperatorResult< AT1, AT2 >::Type > &A3)
template<class AT1 , class AT2 , class Type1 , class Type2 , class Row1 , class Col1 , class Row2 , class Col2 >
Matrix< General, Var, Var, typename OperatorResult< AT1, AT2 >::Type >	operator* (const Matrix< Type1, Row1, Col1, AT1 > &A1, const Matrix< Type2, Row2, Col2, AT2 > &A2)
template<class AT1 , class AT2 , class Type1 , class Type2 , class Row , class Col >
Matrix< General, Row, Col, typename OperatorResult< AT1, AT2 >::Type >	operator* (const Matrix< Type1, Row, Col, AT1 > &A1, const Matrix< Type2, Row, Col, AT2 > &A2)
template<class AT1 , class AT2 , int M, class Type1 , class Type2 , class Col1 , class Row2 , class Col2 >
Matrix< General, Fixed< M >, Var, typename OperatorResult< AT1, AT2 >::Type >	operator* (const Matrix< Type1, Fixed< M >, Col1, AT1 > &A1, const Matrix< Type2, Row2, Col2, AT2 > &A2)
template<class AT1 , class AT2 , int N, class Type1 , class Row1 , class Col1 , class Type2 , class Row2 >
Matrix< General, Var, Fixed< N >, typename OperatorResult< AT1, AT2 >::Type >	operator* (const Matrix< Type1, Row1, Col1, AT1 > &A1, const Matrix< Type2, Row2, Fixed< N >, AT2 > &A2)
template<class AT1 , class AT2 , int M, int N, class Type1 , class Type2 , class Col1 , class Row2 >
Matrix< General, Fixed< M >, Fixed< N >, typename OperatorResult< AT1, AT2 >::Type >	operator* (const Matrix< Type1, Fixed< M >, Col1, AT1 > &A1, const Matrix< Type2, Row2, Fixed< N >, AT2 > &A2)
template<class AT1 , class AT2 , int M, class Type1 , class Type2 >
Matrix< General, Fixed< M >, Fixed< M >, typename OperatorResult< AT1, AT2 >::Type >	operator* (const Matrix< Type1, Fixed< M >, Fixed< M >, AT1 > &A1, const Matrix< Type2, Fixed< M >, Fixed< M >, AT2 > &A2)
template<class AT1 , class AT2 , class Type , class Row1 , class Col1 , class Row2 , class Col2 >
Matrix< Type, Var, Var, typename OperatorResult< AT1, AT2 >::Type >	operator* (const Matrix< Type, Row1, Col1, AT1 > &A1, const Matrix< Type, Row2, Col2, AT2 > &A2)
template<class AT1 , class AT2 , class Type , class Row , class Col >
Matrix< Type, Row, Col, typename OperatorResult< AT1, AT2 >::Type >	operator* (const Matrix< Type, Row, Col, AT1 > &A1, const Matrix< Type, Row, Col, AT2 > &A2)
template<class AT1 , class AT2 , int M, class Type , class Col1 , class Row2 , class Col2 >
Matrix< Type, Fixed< M >, Var, typename OperatorResult< AT1, AT2 >::Type >	operator* (const Matrix< Type, Fixed< M >, Col1, AT1 > &A1, const Matrix< Type, Row2, Col2, AT2 > &A2)
template<class AT1 , class AT2 , int N, class Type , class Row1 , class Col1 , class Row2 >
Matrix< Type, Var, Fixed< N >, typename OperatorResult< AT1, AT2 >::Type >	operator* (const Matrix< Type, Row1, Col1, AT1 > &A1, const Matrix< Type, Row2, Fixed< N >, AT2 > &A2)
template<class AT1 , class AT2 , int M, int N, class Type , class Col1 , class Row2 >
Matrix< Type, Fixed< M >, Fixed< N >, typename OperatorResult< AT1, AT2 >::Type >	operator* (const Matrix< Type, Fixed< M >, Col1, AT1 > &A1, const Matrix< Type, Row2, Fixed< N >, AT2 > &A2)
template<class AT1 , class AT2 , int M, class Type >
Matrix< Type, Fixed< M >, Fixed< M >, typename OperatorResult< AT1, AT2 >::Type >	operator* (const Matrix< Type, Fixed< M >, Fixed< M >, AT1 > &A1, const Matrix< Type, Fixed< M >, Fixed< M >, AT2 > &A2)
template<class AT1 , class AT2 , class Row1 , class Row2 >
SquareMatrix< Var, typename OperatorResult< AT1, AT2 >::Type >	operator* (const SquareMatrix< Row1, AT1 > &A1, const SquareMatrix< Row2, AT2 > &A2)
template<class AT1 , class AT2 , class Row >
SquareMatrix< Row, typename OperatorResult< AT1, AT2 >::Type >	operator* (const SquareMatrix< Row, AT1 > &A1, const SquareMatrix< Row, AT2 > &A2)
template<class AT1 , class AT2 , class Row1 , class Row2 >
Matrix< General, Var, Var, typename OperatorResult< AT1, AT2 >::Type >	operator* (const Matrix< Symmetric, Row1, Row1, AT1 > &A1, const Matrix< Symmetric, Row2, Row2, AT2 > &A2)
template<class AT1 , class AT2 , class Row >
Matrix< General, Row, Row, typename OperatorResult< AT1, AT2 >::Type >	operator* (const Matrix< Symmetric, Row, Row, AT1 > &A1, const Matrix< Symmetric, Row, Row, AT2 > &A2)
template<class Row , class AT1 , class AT2 >
Vector< Row, typename OperatorResult< AT1, AT2 >::Type >	operator* (const Vector< Row, AT1 > &x, const AT2 &alpha)
	Vector-scalar multiplication. More...
template<class Row >
Vector< Row, double >	operator* (Vector< Row, double > &&x, const double &alpha)
template<class Row , class AT1 , class AT2 >
Vector< Row, typename OperatorResult< AT1, AT2 >::Type >	operator* (const AT1 &alpha, const Vector< Row, AT2 > &x)
	Scalar-vector multiplication. More...
template<class Row >
Vector< Row, double >	operator* (const double &alpha, Vector< Row, double > &&x)
template<class Row , class AT1 , class AT2 >
Vector< Row, AT1 >	operator*= (Vector< Row, AT1 > &x, const AT2 &alpha)
template<class Row , class AT1 , class AT2 >
Vector< Row, typename OperatorResult< AT1, AT2 >::Type >	operator/ (const Vector< Row, AT1 > &x, const AT2 &alpha)
template<class Row >
Vector< Row, double >	operator/ (Vector< Row, double > &&x, const double &alpha)
template<class Row , class AT1 , class AT2 >
Vector< Row, AT1 >	operator/= (Vector< Row, AT1 > &x, const AT2 &alpha)
template<class Col , class AT1 , class AT2 >
RowVector< Col, typename OperatorResult< AT1, AT2 >::Type >	operator* (const RowVector< Col, AT1 > &x, const AT2 &alpha)
	Rowvector-scalar multiplication. More...
template<class Col >
RowVector< Col, double >	operator* (RowVector< Col, double > &&x, const double &alpha)
template<class Col , class AT1 , class AT2 >
RowVector< Col, typename OperatorResult< AT1, AT2 >::Type >	operator* (const AT1 &alpha, const RowVector< Col, AT2 > &x)
	Scalar-rowvector multiplication. More...
template<class Col >
RowVector< Col, double >	operator* (const double &alpha, RowVector< Col, double > &&x)
template<class Col , class AT1 , class AT2 >
RowVector< Col, AT1 >	operator*= (RowVector< Col, AT1 > &x, const AT2 &alpha)
template<class Col , class AT1 , class AT2 >
RowVector< Col, typename OperatorResult< AT1, AT2 >::Type >	operator/ (const RowVector< Col, AT1 > &x, const AT2 &a)
template<class Col >
RowVector< Col, double >	operator/ (RowVector< Col, double > &&x, const double &a)
template<class Col , class AT1 , class AT2 >
RowVector< Col, AT1 >	operator/= (RowVector< Col, AT1 > &x, const AT2 &a)
template<class Col , class Row , class AT1 , class AT2 >
OperatorResult< AT1, AT2 >::Type	operator* (const RowVector< Col, AT1 > &x, const Vector< Row, AT2 > &y)
	Scalar product. More...
template<class Row , class AT >
AT	scalarProduct (const Vector< Row, AT > &x, const Vector< Row, AT > &y)
	Scalar product. More...
template<class Row1 , class Row2 , class AT1 , class AT2 >
Vector< Fixed< 3 >, typename OperatorResult< AT1, AT2 >::Type >	crossProduct (const Vector< Row1, AT1 > &x, const Vector< Row2, AT2 > &y)
	Cross product. More...
template<class Row , class AT >
double	tripleProduct (const Vector< Row, AT > &a, const Vector< Row, AT > &x, const Vector< Row, AT > &y)
	Triple product. More...
template<class Type , class Row , class Col , class AT1 , class AT2 >
Matrix< Type, Row, Col, typename OperatorResult< AT1, AT2 >::Type >	operator* (const Matrix< Type, Row, Col, AT1 > &A, const AT2 &alpha)
	Matrix-scalar multiplication. More...
template<class Type , class Row , class Col >
Matrix< Type, Row, Col, double >	operator* (Matrix< Type, Row, Col, double > &&A, const double &alpha)
template<class Type , class Row , class Col , class AT1 , class AT2 >
Matrix< Type, Row, Col, typename OperatorResult< AT1, AT2 >::Type >	operator* (const AT1 &alpha, const Matrix< Type, Row, Col, AT2 > &A)
template<class Type , class Row , class Col >
Matrix< Type, Row, Col, double >	operator* (const double &alpha, Matrix< Type, Row, Col, double > &&A)
template<class Row , class AT1 , class AT2 >
Matrix< Symmetric, Row, Row, typename OperatorResult< AT1, AT2 >::Type >	operator* (const AT1 &alpha, const Matrix< Symmetric, Row, Row, AT2 > &A)
template<class Row >
Matrix< Symmetric, Row, Row, double >	operator* (const double &alpha, Matrix< Symmetric, Row, Row, double > &&A)
template<class Row , class AT1 , class AT2 >
Matrix< Symmetric, Row, Row, typename OperatorResult< AT1, AT2 >::Type >	operator* (const Matrix< Symmetric, Row, Row, AT1 > &A, const AT2 &alpha)
template<class Row >
Matrix< Symmetric, Row, Row, double >	operator* (Matrix< Symmetric, Row, Row, double > &&A, const double &alpha)
template<class AT1 , class AT2 >
Matrix< Diagonal, Ref, Ref, typename OperatorResult< AT1, AT2 >::Type >	operator* (const AT1 &alpha, const Matrix< Diagonal, Ref, Ref, AT2 > &A)
Matrix< Diagonal, Ref, Ref, double >	operator* (const double &alpha, Matrix< Diagonal, Ref, Ref, double > &&A)
template<class AT1 , class AT2 >
Matrix< Diagonal, Ref, Ref, typename OperatorResult< AT1, AT2 >::Type >	operator* (const Matrix< Diagonal, Ref, Ref, AT1 > &A, const AT2 &alpha)
Matrix< Diagonal, Ref, Ref, double >	operator* (Matrix< Diagonal, Ref, Ref, double > &&A, const double &alpha)
template<class Type , class Row , class Col , class AT1 , class AT2 >
Matrix< Type, Row, Col, typename OperatorResult< AT1, AT2 >::Type >	operator/ (const Matrix< Type, Row, Col, AT1 > &A, const AT2 &alpha)
template<class Type , class Row , class Col >
Matrix< Type, Row, Col, double >	operator/ (Matrix< Type, Row, Col, double > &&A, const double &alpha)
template<class Row , class AT1 , class AT2 >
Matrix< Symmetric, Row, Row, typename OperatorResult< AT1, AT2 >::Type >	operator/ (const Matrix< Symmetric, Row, Row, AT1 > &A, const AT2 &alpha)
template<class Row >
Matrix< Symmetric, Row, Row, double >	operator/ (Matrix< Symmetric, Row, Row, double > &&A, const double &alpha)
template<class Row , class AT1 , class AT2 >
Matrix< Diagonal, Row, Row, typename OperatorResult< AT1, AT2 >::Type >	operator/ (const Matrix< Diagonal, Row, Row, AT1 > &A, const AT2 &alpha)
template<class Row >
Matrix< Diagonal, Row, Row, double >	operator/ (Matrix< Diagonal, Row, Row, double > &&A, const double &alpha)
template<class Row , class AT1 , class AT2 >
SquareMatrix< Row, typename OperatorResult< AT1, AT2 >::Type >	operator* (const SquareMatrix< Row, AT1 > &A, const AT2 &alpha)
template<class Row >
SquareMatrix< Row, double >	operator* (SquareMatrix< Row, double > &&A, const double &alpha)
template<class Row , class AT1 , class AT2 >
SquareMatrix< Row, typename OperatorResult< AT1, AT2 >::Type >	operator* (const AT1 &alpha, const SquareMatrix< Row, AT2 > &A)
template<class Row >
SquareMatrix< Row, double >	operator* (const double &alpha, SquareMatrix< Row, double > &&A)
template<class Row , class AT1 , class AT2 >
SquareMatrix< Row, typename OperatorResult< AT1, AT2 >::Type >	operator/ (const SquareMatrix< Row, AT1 > &A, const AT2 &alpha)
template<class Row >
SquareMatrix< Row, double >	operator/ (SquareMatrix< Row, double > &&A, const double &alpha)
template<class Type , class Row , class Col , class AT1 , class AT2 >
Matrix< Type, Row, Col, typename OperatorResult< AT1, AT2 >::Type >	operator*= (Matrix< Type, Row, Col, AT1 > &A, const AT2 &alpha)
template<class Row , class AT1 , class AT2 >
Matrix< Symmetric, Row, Row, AT1 >	operator*= (Matrix< Symmetric, Row, Row, AT1 > &A, const AT2 &alpha)
template<class Row , class AT1 , class AT2 >
Matrix< Diagonal, Row, Row, AT1 >	operator*= (Matrix< Diagonal, Row, Row, AT1 > &A, const AT2 &alpha)
template<class Type , class Row , class Col , class AT1 , class AT2 >
Matrix< Type, Row, Col, AT1 >	operator/= (Matrix< Type, Row, Col, AT1 > &A, const AT2 &alpha)
template<class Row , class AT1 , class AT2 >
Matrix< Symmetric, Row, Row, AT1 >	operator/= (Matrix< Symmetric, Row, Row, AT1 > &A, const AT2 &alpha)
template<class Row , class AT1 , class AT2 >
Matrix< Diagonal, Row, Row, AT1 >	operator/= (Matrix< Diagonal, Row, Row, AT1 > &A, const AT2 &alpha)
template<class Row , class AT >
Vector< Row, typename OperatorResult< AT, AT >::Type >	operator- (const Vector< Row, AT > &x)
	Negation. More...
template<class Row , class AT >
Vector< Row, AT >	operator- (Vector< Row, AT > &&x)
template<class Col , class AT >
RowVector< Col, typename OperatorResult< AT, AT >::Type >	operator- (const RowVector< Col, AT > &a)
	Negation. More...
template<class Col , class AT >
RowVector< Col, AT >	operator- (RowVector< Col, AT > &&a)
template<class Row , class AT >
SquareMatrix< Row, typename OperatorResult< AT, AT >::Type >	operator- (const SquareMatrix< Row, AT > &A)
	Negation. More...
template<class Row , class AT >
SquareMatrix< Row, AT >	operator- (SquareMatrix< Row, AT > &&A)
template<class Type , class Row , class Col , class AT >
Matrix< Type, Row, Col, typename OperatorResult< AT, AT >::Type >	operator- (const Matrix< Type, Row, Col, AT > &A)
	Negation. More...
template<class Type , class Row , class Col , class AT >
Matrix< Type, Row, Col, AT >	operator- (Matrix< Type, Row, Col, AT > &&A)
template<class Row , class AT >
RowVector< Row, AT >	trans (const Vector< Row, AT > &x)
	Transpose of a vector. More...
RowVector< Var, double >	trans (Vector< Var, double > &&x)
template<class Col , class AT >
Vector< Col, AT >	trans (const RowVector< Col, AT > &x)
	Transpose of a rowvector. More...
Vector< Var, double >	trans (RowVector< Var, double > &&x)
template<class Type , class Row , class Col , class AT >
Matrix< Type, Col, Row, AT >	trans (const Matrix< Type, Row, Col, AT > &A)
	Transpose of a matrix. More...
template<class Row , class AT >
SquareMatrix< Row, AT >	trans (const SquareMatrix< Row, AT > &A)
	Transpose of a matrix. More...
template<class Row , class AT >
AT	nrmInf (const Vector< Row, AT > &x)
template<class Row , class AT >
AT	nrmInf (const RowVector< Row, AT > &x)
template<class Row , class AT >
OperatorResult< AT, AT >::Type	nrm2 (const Vector< Row, AT > &x)
template<class Col , class AT >
OperatorResult< AT, AT >::Type	nrm2 (const RowVector< Col, AT > &x)
template<class Row , class AT >
SquareMatrix< Row, AT >	tilde (const Vector< Row, AT > &x)
	Tilde operator. More...
template<class Row , class AT >
Vector< Row, AT >	tilde (const SquareMatrix< Row, AT > &T, double tol=tildeEPS)
	Inverse tilde operator. More...
template<class AT , class Type1 , class Row1 , class Col1 , class Type2 , class Row2 , class Col2 >
bool	operator== (const Matrix< Type1, Row1, Col1, AT > &A, const Matrix< Type2, Row2, Col2, AT > &B)
	Matrix-matrix comparison. More...
template<class AT , class Type1 , class Row1 , class Col1 , class Type2 , class Row2 , class Col2 >
bool	operator!= (const Matrix< Type1, Row1, Col1, AT > &A, const Matrix< Type2, Row2, Col2, AT > &B)
	Matrix-matrix comparison. More...
template<class Row , class AT >
AT	max (const Vector< Row, AT > &x)
	Maximum value. More...
template<class Row , class AT >
int	maxIndex (const Vector< Row, AT > &x)
	Index of maximum value. More...
template<class Row , class AT >
AT	min (const Vector< Row, AT > &x)
	Minimum value. More...
template<class Row , class AT >
int	minIndex (const Vector< Row, AT > &x)
	Index of minimum value. More...
template<class AT >
Matrix< General, Ref, Ref, AT >	bubbleSort (const Matrix< General, Ref, Ref, AT > &A_, int PivotCol)
	Bubble Sort Algorithm (stable sorting Algorithm ) More...
template<class AT >
void	quicksortmedian_intern (Matrix< General, Ref, Ref, AT > &A, int PivotCol, RowVector< Ref, AT > &tmp, int l, int r)
template<class AT >
Matrix< General, Ref, Ref, AT >	quickSortMedian (const Matrix< General, Ref, Ref, AT > &A_, int PivotCol)
	Modified QuickSort Algorithm (unstable sorting Algorithm ) More...
template<class Row , class Col , class AT >
Matrix< Symmetric, Col, Col, AT >	JTJ (const Matrix< General, Row, Col, AT > &A)
template<class Row1 , class Row2 , class Col , class AT >
Matrix< Symmetric, Col, Col, AT >	JTMJ (const Matrix< Symmetric, Row2, Row2, AT > &B, const Matrix< General, Row1, Col, AT > &A)
template<class Row , class Col , class AT >
Matrix< Symmetric, Col, Col, AT >	JTMJ (const Matrix< SymmetricSparse, Ref, Ref, AT > &B, const Matrix< General, Row, Col, AT > &A)
template<class Row , class Col1 , class Col2 , class AT >
Matrix< Symmetric, Row, Row, AT >	JMJT (const Matrix< General, Row, Col1, AT > &A, const Matrix< Symmetric, Col2, Col2, AT > &B)
Vector< Ref, std::complex< double > >	slvLU (const SquareMatrix< Ref, std::complex< double > > &A, const Vector< Ref, std::complex< double > > &b)
	System of linear equations. More...
Matrix< General, Ref, Ref, double >	slvLU (const SquareMatrix< Ref, double > &A, const Matrix< General, Ref, Ref, double > &X)
	Systems of linear equations. More...
Matrix< General, Var, Var, double >	slvLU (const SquareMatrix< Var, double > &A, const Matrix< General, Var, Var, double > &X, int &info)
Matrix< General, Ref, Ref, double >	slvLUFac (const SquareMatrix< Ref, double > &A, const Matrix< General, Ref, Ref, double > &X, const Vector< Ref, int > &ipiv)
	Systems of linear equations. More...
Matrix< General, Var, Var, double >	slvLUFac (const SquareMatrix< Var, double > &A, const Matrix< General, Var, Var, double > &X, const Vector< Var, int > &ipiv)
Matrix< General, Ref, Ref, double >	slvQR (const SquareMatrix< Ref, double > &A, const Matrix< General, Ref, Ref, double > &X)
	Systems of linear equations. More...
int	Doolittle_LU_with_Pivoting_Solve (const double *A, double B[], const int pivot[], double x[], int n)
	solve linear system with LU decomposed matrix More...
Vector< Ref, double >	slvLU (const SquareMatrix< Ref, double > &A, const Vector< Ref, double > &x)
	System of linear equations. More...
Vector< Ref, double >	slvLU (const SquareMatrix< Ref, double > &A, const Vector< Ref, double > &x, int &info)
	System of linear equations. More...
Vector< Var, double >	slvLU (const SquareMatrix< Var, double > &A, const Vector< Var, double > &x, int &info)
Vector< Ref, double >	slvLUFac (const SquareMatrix< Ref, double > &A, const Vector< Ref, double > &x, const Vector< Ref, int > &ipiv)
	System of linear equations. More...
Vector< Var, double >	slvLUFac (const SquareMatrix< Var, double > &A, const Vector< Var, double > &x, const Vector< Var, int > &ipiv)
Vector< Ref, double >	slvQR (const SquareMatrix< Ref, double > &A, const Vector< Ref, double > &x)
	System of linear equations. More...
Vector< Ref, double >	slvQRLQ (const Matrix< General, Ref, Ref, double > &A, const Vector< Ref, double > &b)
	System of overdetermined or underdetermined linear equations. More...
Matrix< General, Ref, Ref, double >	slvQRLQ (const Matrix< General, Ref, Ref, double > &A, const Matrix< General, Ref, Ref, double > &B)
	System of overdetermined or underdetermined linear equations. More...
SquareMatrix< Ref, double >	inv (const SquareMatrix< Ref, double > &A)
	Inverse. More...
Matrix< Symmetric, Ref, Ref, double >	inv (const Matrix< Symmetric, Ref, Ref, double > &A)
	Inverse. More...
Matrix< Diagonal, Ref, Ref, double >	inv (const Matrix< Diagonal, Ref, Ref, double > &A)
	Inverse. More...
Matrix< General, Ref, Ref, double >	facLU (const Matrix< General, Ref, Ref, double > &A, Vector< Ref, int > &ipiv)
	LU decomposition. More...
SquareMatrix< Ref, double >	facLU (const SquareMatrix< Ref, double > &A, Vector< Ref, int > &ipiv)
	LU decomposition. More...
SquareMatrix< Var, double >	facLU (const SquareMatrix< Var, double > &A, Vector< Var, int > &ipiv)
int	facLU (double *A, int pivot[], int n)
	LU decomposition. More...
Matrix< Symmetric, Ref, Ref, double >	facLL (const Matrix< Symmetric, Ref, Ref, double > &A)
	LL decomposition. More...
double	nrm1 (const Vector< Ref, double > &x)
	1-norm More...
double	nrmInf (const Vector< Ref, double > &x)
	Infinity-norm. More...
double	nrm2 (const Vector< Ref, double > &x)
	2-norm More...
Vector< Ref, double >	slvLL (const Matrix< Symmetric, Ref, Ref, double > &A, const Vector< Ref, double > &x)
	System of linear equations. More...
Matrix< General, Ref, Ref, double >	slvLL (const Matrix< Symmetric, Ref, Ref, double > &A, const Matrix< General, Ref, Ref, double > &X)
	Systems of linear equations. More...
Vector< Ref, double >	slvLLFac (const Matrix< Symmetric, Ref, Ref, double > &A, const Vector< Ref, double > &x)
Matrix< General, Ref, Ref, double >	slvLLFac (const Matrix< Symmetric, Ref, Ref, double > &A, const Matrix< General, Ref, Ref, double > &X)
Vector< Ref, std::complex< double > >	eigval (const SquareMatrix< Ref, double > &A)
	Eigenvalues. More...
int	eigvec (const SquareMatrix< Ref, double > &A, SquareMatrix< Ref, std::complex< double > > &V, Vector< Ref, std::complex< double > > &w)
	Eigenvectors and Eigenvalues. More...
int	eigvec (const Matrix< Symmetric, Ref, Ref, double > &A, const Matrix< Symmetric, Ref, Ref, double > &B, SquareMatrix< Ref, double > &eigenvectors, Vector< Ref, double > &eigenvalues)
	Eigenvectors and Eigenvalues. More...
int	svd (Matrix< General, Ref, Ref, double > &A, Matrix< General, Ref, Ref, double > &S, SquareMatrix< Ref, double > &U, SquareMatrix< Ref, double > &VT, int Rueckgabe)
Vector< Ref, double >	eigval (const Matrix< Symmetric, Ref, Ref, double > &A)
	Eigenvalues. More...
Vector< Ref, double >	eigvalSel (const Matrix< Symmetric, Ref, Ref, double > &A, int il, int iu, double abstol=0)
	Eigenvalues. More...
double	rho (const SquareMatrix< Ref, double > &A)
	Spectral radius. More...
double	rho (const Matrix< Symmetric, Ref, Ref, double > &A)
	Spectral radius. More...
double	nrmInf (const Matrix< General, Ref, Ref, double > &A)
	Infinity-norm. More...
double	nrmInf (const Matrix< Symmetric, Ref, Ref, double > &A)
	Infinity-norm. More...
double	nrm1 (const Matrix< General, Ref, Ref, double > &A)
	1-norm More...
double	nrmFro (const Matrix< General, Ref, Ref, double > &A)
	Frobenius-norm. More...
double	nrm2 (const Matrix< General, Ref, Ref, double > &A)
	2-norm More...
Matrix< General, Ref, Ref, double >	slvLS (const Matrix< General, Ref, Ref, double > &A, const Matrix< General, Ref, Ref, double > &B, double rcond)
Vector< Ref, double >	slvLS (const Matrix< General, Ref, Ref, double > &A, const Vector< Ref, double > &b, double rcond)
template<int size>
Vector< Fixed< size >, double >	slvLU (const SquareMatrix< Fixed< size >, double > &A, const Vector< Fixed< size >, double > &b, int &info)
	Row interchanges. More...
template<int size>
SquareMatrix< Fixed< size >, double >	facLU (const SquareMatrix< Fixed< size >, double > &A, Vector< Fixed< size >, int > &ipiv)
template<int size>
Vector< Fixed< size >, double >	slvLUFac (const SquareMatrix< Fixed< size >, double > &ALU, const Vector< Fixed< size >, double > &b, const Vector< Fixed< size >, int > &ipiv, int &info)
template<int size, int nrrhs>
Matrix< General, Fixed< size >, Fixed< nrrhs >, double >	slvLUFac (const SquareMatrix< Fixed< size >, double > &ALU, const Matrix< General, Fixed< size >, Fixed< nrrhs >, double > &B, const Vector< Fixed< size >, int > &ipiv, int &info)
template<int size>
Matrix< General, Fixed< size >, Var, double >	slvLUFac (const SquareMatrix< Fixed< size >, double > &ALU, const Matrix< General, Fixed< size >, Var, double > &B, const Vector< Fixed< size >, int > &ipiv, int &info)
template<class T >
void	assign (T &dst, const T &src)
template<class Row , class AT >
void	assign (Vector< Row, AT > &dst, const Vector< Row, AT > &src)
template<class Row , class AT >
void	assign (RowVector< Row, AT > &dst, const RowVector< Row, AT > &src)
template<class Type , class Row , class Col , class AT >
void	assign (Matrix< Type, Row, Col, AT > &dst, const Matrix< Type, Row, Col, AT > &src)
template<class Type , class Row , class Col , class AT >
void	dump (const char *str, const Matrix< Type, Row, Col, AT > &A)
	Matrix dump. More...
bool	operator== (const Range< Var, Var > &I, const Range< Var, Var > &J)
	Equality operator for indices. More...
template<class AT >
Matrix< Rotation, Fixed< 3 >, Fixed< 3 >, AT >	al2T (const AT &al)
template<class AT >
Matrix< Rotation, Fixed< 3 >, Fixed< 3 >, AT >	be2T (const AT &be)
template<class AT >
Matrix< Rotation, Fixed< 3 >, Fixed< 3 >, AT >	ga2T (const AT &ga)
template<class AT >
Matrix< Rotation, Fixed< 3 >, Fixed< 3 >, AT >	albega2T (const Vector< Fixed< 3 >, AT > &albega)
template<class AT >
Matrix< Rotation, Fixed< 3 >, Fixed< 3 >, AT >	begaal2T (const Vector< Fixed< 3 >, AT > &begaal)
template<class AT >
Vector< Fixed< 3 >, AT >	T2albega (const Matrix< Rotation, Fixed< 3 >, Fixed< 3 >, AT > &T)
template<class AT >
Vector< Fixed< 3 >, AT >	T2begaal (const Matrix< Rotation, Fixed< 3 >, Fixed< 3 >, AT > &T)
Vector< Ref, double >	slvLU (const Matrix< SymmetricSparse, Ref, Ref, double > &A, const Vector< Ref, double > &x)
	Systems of linear equations. More...
Matrix< General, Ref, Ref, double >	slvLU (const Matrix< SymmetricSparse, Ref, Ref, double > &A, const Matrix< General, Ref, Ref, double > &X)
	System of linear equations. More...
int	eigvec (const Matrix< SymmetricSparse, Ref, Ref, double > &A, const Matrix< SymmetricSparse, Ref, Ref, double > &M, int nev, double sigma, Matrix< General, Ref, Ref, double > &eigenvectors, Vector< Ref, double > &eigenvalues, double tol_=0)
	Eigenvectors and Eigenvalues. More...
template<>
boost::spirit::qi::rule< boost::spirit::istream_iterator, double()> &	getBoostSpiritQiRule< double > ()
template<>
boost::spirit::qi::rule< boost::spirit::istream_iterator, int()> &	getBoostSpiritQiRule< int > ()
template<>
boost::spirit::qi::rule< boost::spirit::istream_iterator, long()> &	getBoostSpiritQiRule< long > ()
template<>
boost::spirit::qi::rule< boost::spirit::istream_iterator, std::complex< double >()> &	getBoostSpiritQiRule< std::complex< double > > ()
template<>
boost::spirit::karma::rule< std::ostream_iterator< char >, double()> &	getBoostSpiritKarmaRule< double > ()
template<>
boost::spirit::karma::rule< std::ostream_iterator< char >, int()> &	getBoostSpiritKarmaRule< int > ()
template<>
boost::spirit::karma::rule< std::ostream_iterator< char >, long()> &	getBoostSpiritKarmaRule< long > ()
template<>
boost::spirit::karma::rule< std::ostream_iterator< char >, std::complex< double >()> &	getBoostSpiritKarmaRule< std::complex< double > > ()
template<class AT >
boost::spirit::qi::rule< boost::spirit::istream_iterator, AT()> &	getBoostSpiritQiRule ()
template<class AT >
boost::spirit::karma::rule< std::ostream_iterator< char >, AT()> &	getBoostSpiritKarmaRule ()
template<>
FMATVEC_EXPORT boost::spirit::qi::rule< boost::spirit::istream_iterator, double()> &	getBoostSpiritQiRule< double > ()
template<>
FMATVEC_EXPORT boost::spirit::qi::rule< boost::spirit::istream_iterator, int()> &	getBoostSpiritQiRule< int > ()
template<>
FMATVEC_EXPORT boost::spirit::qi::rule< boost::spirit::istream_iterator, long()> &	getBoostSpiritQiRule< long > ()
template<>
FMATVEC_EXPORT boost::spirit::qi::rule< boost::spirit::istream_iterator, std::complex< double >()> &	getBoostSpiritQiRule< std::complex< double > > ()
template<>
FMATVEC_EXPORT boost::spirit::karma::rule< std::ostream_iterator< char >, double()> &	getBoostSpiritKarmaRule< double > ()
template<>
FMATVEC_EXPORT boost::spirit::karma::rule< std::ostream_iterator< char >, int()> &	getBoostSpiritKarmaRule< int > ()
template<>
FMATVEC_EXPORT boost::spirit::karma::rule< std::ostream_iterator< char >, long()> &	getBoostSpiritKarmaRule< long > ()
template<>
FMATVEC_EXPORT boost::spirit::karma::rule< std::ostream_iterator< char >, std::complex< double >()> &	getBoostSpiritKarmaRule< std::complex< double > > ()
template<class Type , class Row , class Col , class AT >
std::istream &	operator>> (std::istream &s, Matrix< Type, Row, Col, AT > &A)
	Matrix input. More...
template<class Type , class Row , class Col , class AT >
std::ostream &	operator<< (std::ostream &s, const Matrix< Type, Row, Col, AT > &A)
	Matrix output. More...
template FMATVEC_EXPORT std::istream &	operator>> (std::istream &s, Matrix< General, Ref, Ref, std::complex< double > > &A)
	!! we explicitly instantiate a lot of mat/vec stream operators to avoid compiling in each included file boost::spirit !!!
template FMATVEC_EXPORT std::ostream &	operator<< (std::ostream &s, const Matrix< General, Ref, Ref, std::complex< double > > &A)
template FMATVEC_EXPORT std::istream &	operator>> (std::istream &s, Matrix< General, Ref, Ref, int > &A)
template FMATVEC_EXPORT std::ostream &	operator<< (std::ostream &s, const Matrix< General, Ref, Ref, int > &A)
template FMATVEC_EXPORT std::istream &	operator>> (std::istream &s, Matrix< General, Var, Var, int > &A)
template FMATVEC_EXPORT std::ostream &	operator<< (std::ostream &s, const Matrix< General, Var, Var, int > &A)
template FMATVEC_EXPORT std::istream &	operator>> (std::istream &s, Matrix< General, Var, Fixed< 1 >, int > &A)
template FMATVEC_EXPORT std::ostream &	operator<< (std::ostream &s, const Matrix< General, Var, Fixed< 1 >, int > &A)
template FMATVEC_EXPORT std::istream &	operator>> (std::istream &s, Matrix< Rotation, Fixed< 3 >, Fixed< 3 >, double > &A)
template FMATVEC_EXPORT std::ostream &	operator<< (std::ostream &s, const Matrix< Rotation, Fixed< 3 >, Fixed< 3 >, double > &A)
template FMATVEC_EXPORT std::istream &	operator>> (std::istream &s, Matrix< Symmetric, Ref, Ref, double > &A)
template FMATVEC_EXPORT std::ostream &	operator<< (std::ostream &s, const Matrix< Symmetric, Ref, Ref, double > &A)
template FMATVEC_EXPORT std::ostream &	operator<< (std::ostream &s, const Matrix< Symmetric, Var, Var, double > &A)
template FMATVEC_EXPORT std::istream &	operator>> (std::istream &s, Matrix< Symmetric, Fixed< 2 >, Fixed< 2 >, double > &A)
template FMATVEC_EXPORT std::ostream &	operator<< (std::ostream &s, const Matrix< Symmetric, Fixed< 2 >, Fixed< 2 >, double > &A)
template FMATVEC_EXPORT std::istream &	operator>> (std::istream &s, Matrix< Symmetric, Fixed< 3 >, Fixed< 3 >, double > &A)
template FMATVEC_EXPORT std::ostream &	operator<< (std::ostream &s, const Matrix< Symmetric, Fixed< 3 >, Fixed< 3 >, double > &A)
template FMATVEC_EXPORT std::istream &	operator>> (std::istream &s, Matrix< General, Ref, Ref, double > &A)
template FMATVEC_EXPORT std::ostream &	operator<< (std::ostream &s, const Matrix< General, Ref, Ref, double > &A)
template FMATVEC_EXPORT std::istream &	operator>> (std::istream &s, Matrix< General, Var, Var, double > &A)
template FMATVEC_EXPORT std::ostream &	operator<< (std::ostream &s, const Matrix< General, Var, Var, double > &A)
template FMATVEC_EXPORT std::istream &	operator>> (std::istream &s, Matrix< General, Var, Fixed< 1 >, double > &A)
template FMATVEC_EXPORT std::ostream &	operator<< (std::ostream &s, const Matrix< General, Var, Fixed< 1 >, double > &A)
template FMATVEC_EXPORT std::istream &	operator>> (std::istream &s, Matrix< General, Var, Fixed< 2 >, double > &A)
template FMATVEC_EXPORT std::ostream &	operator<< (std::ostream &s, const Matrix< General, Var, Fixed< 2 >, double > &A)
template FMATVEC_EXPORT std::istream &	operator>> (std::istream &s, Matrix< General, Var, Fixed< 3 >, double > &A)
template FMATVEC_EXPORT std::ostream &	operator<< (std::ostream &s, const Matrix< General, Var, Fixed< 3 >, double > &A)
template FMATVEC_EXPORT std::istream &	operator>> (std::istream &s, Matrix< General, Fixed< 1 >, Var, double > &A)
template FMATVEC_EXPORT std::ostream &	operator<< (std::ostream &s, const Matrix< General, Fixed< 1 >, Var, double > &A)
template FMATVEC_EXPORT std::istream &	operator>> (std::istream &s, Matrix< General, Fixed< 2 >, Var, double > &A)
template FMATVEC_EXPORT std::ostream &	operator<< (std::ostream &s, const Matrix< General, Fixed< 2 >, Var, double > &A)
template FMATVEC_EXPORT std::istream &	operator>> (std::istream &s, Matrix< General, Fixed< 3 >, Var, double > &A)
template FMATVEC_EXPORT std::ostream &	operator<< (std::ostream &s, const Matrix< General, Fixed< 3 >, Var, double > &A)
template FMATVEC_EXPORT std::istream &	operator>> (std::istream &s, Matrix< General, Fixed< 6 >, Var, double > &A)
template FMATVEC_EXPORT std::ostream &	operator<< (std::ostream &s, const Matrix< General, Fixed< 6 >, Var, double > &A)
template FMATVEC_EXPORT std::istream &	operator>> (std::istream &s, Matrix< General, Fixed< 2 >, Fixed< 1 >, double > &A)
template FMATVEC_EXPORT std::ostream &	operator<< (std::ostream &s, const Matrix< General, Fixed< 2 >, Fixed< 1 >, double > &A)
template FMATVEC_EXPORT std::istream &	operator>> (std::istream &s, Matrix< General, Fixed< 3 >, Fixed< 1 >, double > &A)
template FMATVEC_EXPORT std::ostream &	operator<< (std::ostream &s, const Matrix< General, Fixed< 3 >, Fixed< 1 >, double > &A)
template FMATVEC_EXPORT std::istream &	operator>> (std::istream &s, Matrix< General, Fixed< 4 >, Fixed< 1 >, double > &A)
template FMATVEC_EXPORT std::ostream &	operator<< (std::ostream &s, const Matrix< General, Fixed< 4 >, Fixed< 1 >, double > &A)
template FMATVEC_EXPORT std::istream &	operator>> (std::istream &s, Matrix< General, Fixed< 5 >, Fixed< 1 >, double > &A)
template FMATVEC_EXPORT std::ostream &	operator<< (std::ostream &s, const Matrix< General, Fixed< 5 >, Fixed< 1 >, double > &A)
template FMATVEC_EXPORT std::istream &	operator>> (std::istream &s, Matrix< General, Fixed< 6 >, Fixed< 1 >, double > &A)
template FMATVEC_EXPORT std::ostream &	operator<< (std::ostream &s, const Matrix< General, Fixed< 6 >, Fixed< 1 >, double > &A)
template FMATVEC_EXPORT std::istream &	operator>> (std::istream &s, Matrix< General, Fixed< 1 >, Fixed< 2 >, double > &A)
template FMATVEC_EXPORT std::ostream &	operator<< (std::ostream &s, const Matrix< General, Fixed< 1 >, Fixed< 2 >, double > &A)
template FMATVEC_EXPORT std::istream &	operator>> (std::istream &s, Matrix< General, Fixed< 1 >, Fixed< 3 >, double > &A)
template FMATVEC_EXPORT std::ostream &	operator<< (std::ostream &s, const Matrix< General, Fixed< 1 >, Fixed< 3 >, double > &A)
template FMATVEC_EXPORT std::istream &	operator>> (std::istream &s, Matrix< General, Fixed< 1 >, Fixed< 4 >, double > &A)
template FMATVEC_EXPORT std::ostream &	operator<< (std::ostream &s, const Matrix< General, Fixed< 1 >, Fixed< 4 >, double > &A)
template FMATVEC_EXPORT std::istream &	operator>> (std::istream &s, Matrix< General, Fixed< 1 >, Fixed< 5 >, double > &A)
template FMATVEC_EXPORT std::ostream &	operator<< (std::ostream &s, const Matrix< General, Fixed< 1 >, Fixed< 5 >, double > &A)
template FMATVEC_EXPORT std::istream &	operator>> (std::istream &s, Matrix< General, Fixed< 1 >, Fixed< 6 >, double > &A)
template FMATVEC_EXPORT std::ostream &	operator<< (std::ostream &s, const Matrix< General, Fixed< 1 >, Fixed< 6 >, double > &A)
template FMATVEC_EXPORT std::istream &	operator>> (std::istream &s, Matrix< General, Fixed< 2 >, Fixed< 2 >, double > &A)
template FMATVEC_EXPORT std::ostream &	operator<< (std::ostream &s, const Matrix< General, Fixed< 2 >, Fixed< 2 >, double > &A)
template FMATVEC_EXPORT std::istream &	operator>> (std::istream &s, Matrix< General, Fixed< 3 >, Fixed< 3 >, double > &A)
template FMATVEC_EXPORT std::ostream &	operator<< (std::ostream &s, const Matrix< General, Fixed< 3 >, Fixed< 3 >, double > &A)
template FMATVEC_EXPORT std::istream &	operator>> (std::istream &s, Matrix< General, Fixed< 6 >, Fixed< 6 >, double > &A)
template FMATVEC_EXPORT std::ostream &	operator<< (std::ostream &s, const Matrix< General, Fixed< 6 >, Fixed< 6 >, double > &A)
template FMATVEC_EXPORT std::istream &	operator>> (std::istream &s, Matrix< Rotation, Fixed< 3 >, Fixed< 3 >, SymbolicExpression > &A)
template FMATVEC_EXPORT std::ostream &	operator<< (std::ostream &s, const Matrix< Rotation, Fixed< 3 >, Fixed< 3 >, SymbolicExpression > &A)
template FMATVEC_EXPORT std::istream &	operator>> (std::istream &s, Matrix< Symmetric, Ref, Ref, SymbolicExpression > &A)
template FMATVEC_EXPORT std::ostream &	operator<< (std::ostream &s, const Matrix< Symmetric, Ref, Ref, SymbolicExpression > &A)
template FMATVEC_EXPORT std::ostream &	operator<< (std::ostream &s, const Matrix< Symmetric, Var, Var, SymbolicExpression > &A)
template FMATVEC_EXPORT std::istream &	operator>> (std::istream &s, Matrix< Symmetric, Fixed< 2 >, Fixed< 2 >, SymbolicExpression > &A)
template FMATVEC_EXPORT std::ostream &	operator<< (std::ostream &s, const Matrix< Symmetric, Fixed< 2 >, Fixed< 2 >, SymbolicExpression > &A)
template FMATVEC_EXPORT std::istream &	operator>> (std::istream &s, Matrix< Symmetric, Fixed< 3 >, Fixed< 3 >, SymbolicExpression > &A)
template FMATVEC_EXPORT std::ostream &	operator<< (std::ostream &s, const Matrix< Symmetric, Fixed< 3 >, Fixed< 3 >, SymbolicExpression > &A)
template FMATVEC_EXPORT std::istream &	operator>> (std::istream &s, Matrix< General, Ref, Ref, SymbolicExpression > &A)
template FMATVEC_EXPORT std::ostream &	operator<< (std::ostream &s, const Matrix< General, Ref, Ref, SymbolicExpression > &A)
template FMATVEC_EXPORT std::istream &	operator>> (std::istream &s, Matrix< General, Var, Var, SymbolicExpression > &A)
template FMATVEC_EXPORT std::ostream &	operator<< (std::ostream &s, const Matrix< General, Var, Var, SymbolicExpression > &A)
template FMATVEC_EXPORT std::istream &	operator>> (std::istream &s, Matrix< General, Var, Fixed< 1 >, SymbolicExpression > &A)
template FMATVEC_EXPORT std::ostream &	operator<< (std::ostream &s, const Matrix< General, Var, Fixed< 1 >, SymbolicExpression > &A)
template FMATVEC_EXPORT std::istream &	operator>> (std::istream &s, Matrix< General, Var, Fixed< 2 >, SymbolicExpression > &A)
template FMATVEC_EXPORT std::ostream &	operator<< (std::ostream &s, const Matrix< General, Var, Fixed< 2 >, SymbolicExpression > &A)
template FMATVEC_EXPORT std::istream &	operator>> (std::istream &s, Matrix< General, Var, Fixed< 3 >, SymbolicExpression > &A)
template FMATVEC_EXPORT std::ostream &	operator<< (std::ostream &s, const Matrix< General, Var, Fixed< 3 >, SymbolicExpression > &A)
template FMATVEC_EXPORT std::istream &	operator>> (std::istream &s, Matrix< General, Fixed< 1 >, Var, SymbolicExpression > &A)
template FMATVEC_EXPORT std::ostream &	operator<< (std::ostream &s, const Matrix< General, Fixed< 1 >, Var, SymbolicExpression > &A)
template FMATVEC_EXPORT std::istream &	operator>> (std::istream &s, Matrix< General, Fixed< 2 >, Var, SymbolicExpression > &A)
template FMATVEC_EXPORT std::ostream &	operator<< (std::ostream &s, const Matrix< General, Fixed< 2 >, Var, SymbolicExpression > &A)
template FMATVEC_EXPORT std::istream &	operator>> (std::istream &s, Matrix< General, Fixed< 3 >, Var, SymbolicExpression > &A)
template FMATVEC_EXPORT std::ostream &	operator<< (std::ostream &s, const Matrix< General, Fixed< 3 >, Var, SymbolicExpression > &A)
template FMATVEC_EXPORT std::istream &	operator>> (std::istream &s, Matrix< General, Fixed< 2 >, Fixed< 1 >, SymbolicExpression > &A)
template FMATVEC_EXPORT std::ostream &	operator<< (std::ostream &s, const Matrix< General, Fixed< 2 >, Fixed< 1 >, SymbolicExpression > &A)
template FMATVEC_EXPORT std::istream &	operator>> (std::istream &s, Matrix< General, Fixed< 3 >, Fixed< 1 >, SymbolicExpression > &A)
template FMATVEC_EXPORT std::ostream &	operator<< (std::ostream &s, const Matrix< General, Fixed< 3 >, Fixed< 1 >, SymbolicExpression > &A)
template FMATVEC_EXPORT std::istream &	operator>> (std::istream &s, Matrix< General, Fixed< 4 >, Fixed< 1 >, SymbolicExpression > &A)
template FMATVEC_EXPORT std::ostream &	operator<< (std::ostream &s, const Matrix< General, Fixed< 4 >, Fixed< 1 >, SymbolicExpression > &A)
template FMATVEC_EXPORT std::istream &	operator>> (std::istream &s, Matrix< General, Fixed< 5 >, Fixed< 1 >, SymbolicExpression > &A)
template FMATVEC_EXPORT std::ostream &	operator<< (std::ostream &s, const Matrix< General, Fixed< 5 >, Fixed< 1 >, SymbolicExpression > &A)
template FMATVEC_EXPORT std::istream &	operator>> (std::istream &s, Matrix< General, Fixed< 6 >, Fixed< 1 >, SymbolicExpression > &A)
template FMATVEC_EXPORT std::ostream &	operator<< (std::ostream &s, const Matrix< General, Fixed< 6 >, Fixed< 1 >, SymbolicExpression > &A)
template FMATVEC_EXPORT std::istream &	operator>> (std::istream &s, Matrix< General, Fixed< 1 >, Fixed< 2 >, SymbolicExpression > &A)
template FMATVEC_EXPORT std::ostream &	operator<< (std::ostream &s, const Matrix< General, Fixed< 1 >, Fixed< 2 >, SymbolicExpression > &A)
template FMATVEC_EXPORT std::istream &	operator>> (std::istream &s, Matrix< General, Fixed< 1 >, Fixed< 3 >, SymbolicExpression > &A)
template FMATVEC_EXPORT std::ostream &	operator<< (std::ostream &s, const Matrix< General, Fixed< 1 >, Fixed< 3 >, SymbolicExpression > &A)
template FMATVEC_EXPORT std::istream &	operator>> (std::istream &s, Matrix< General, Fixed< 1 >, Fixed< 4 >, SymbolicExpression > &A)
template FMATVEC_EXPORT std::ostream &	operator<< (std::ostream &s, const Matrix< General, Fixed< 1 >, Fixed< 4 >, SymbolicExpression > &A)
template FMATVEC_EXPORT std::istream &	operator>> (std::istream &s, Matrix< General, Fixed< 1 >, Fixed< 5 >, SymbolicExpression > &A)
template FMATVEC_EXPORT std::ostream &	operator<< (std::ostream &s, const Matrix< General, Fixed< 1 >, Fixed< 5 >, SymbolicExpression > &A)
template FMATVEC_EXPORT std::istream &	operator>> (std::istream &s, Matrix< General, Fixed< 1 >, Fixed< 6 >, SymbolicExpression > &A)
template FMATVEC_EXPORT std::ostream &	operator<< (std::ostream &s, const Matrix< General, Fixed< 1 >, Fixed< 6 >, SymbolicExpression > &A)
template FMATVEC_EXPORT std::istream &	operator>> (std::istream &s, Matrix< General, Fixed< 2 >, Fixed< 2 >, SymbolicExpression > &A)
template FMATVEC_EXPORT std::ostream &	operator<< (std::ostream &s, const Matrix< General, Fixed< 2 >, Fixed< 2 >, SymbolicExpression > &A)
template FMATVEC_EXPORT std::istream &	operator>> (std::istream &s, Matrix< General, Fixed< 3 >, Fixed< 3 >, SymbolicExpression > &A)
template FMATVEC_EXPORT std::ostream &	operator<< (std::ostream &s, const Matrix< General, Fixed< 3 >, Fixed< 3 >, SymbolicExpression > &A)
template FMATVEC_EXPORT std::istream &	operator>> (std::istream &s, Matrix< General, Fixed< 6 >, Fixed< 6 >, SymbolicExpression > &A)
template FMATVEC_EXPORT std::ostream &	operator<< (std::ostream &s, const Matrix< General, Fixed< 6 >, Fixed< 6 >, SymbolicExpression > &A)
template FMATVEC_EXPORT std::istream &	operator>> (std::istream &s, Matrix< Rotation, Fixed< 3 >, Fixed< 3 >, IndependentVariable > &A)
template FMATVEC_EXPORT std::ostream &	operator<< (std::ostream &s, const Matrix< Rotation, Fixed< 3 >, Fixed< 3 >, IndependentVariable > &A)
template FMATVEC_EXPORT std::istream &	operator>> (std::istream &s, Matrix< General, Ref, Ref, IndependentVariable > &A)
template FMATVEC_EXPORT std::ostream &	operator<< (std::ostream &s, const Matrix< General, Ref, Ref, IndependentVariable > &A)
template FMATVEC_EXPORT std::istream &	operator>> (std::istream &s, Matrix< General, Var, Fixed< 1 >, IndependentVariable > &A)
template FMATVEC_EXPORT std::ostream &	operator<< (std::ostream &s, const Matrix< General, Var, Fixed< 1 >, IndependentVariable > &A)
template FMATVEC_EXPORT std::istream &	operator>> (std::istream &s, Matrix< General, Fixed< 1 >, Var, IndependentVariable > &A)
template FMATVEC_EXPORT std::ostream &	operator<< (std::ostream &s, const Matrix< General, Fixed< 1 >, Var, IndependentVariable > &A)
template FMATVEC_EXPORT std::istream &	operator>> (std::istream &s, Matrix< General, Fixed< 2 >, Fixed< 1 >, IndependentVariable > &A)
template FMATVEC_EXPORT std::ostream &	operator<< (std::ostream &s, const Matrix< General, Fixed< 2 >, Fixed< 1 >, IndependentVariable > &A)
template FMATVEC_EXPORT std::istream &	operator>> (std::istream &s, Matrix< General, Fixed< 3 >, Fixed< 1 >, IndependentVariable > &A)
template FMATVEC_EXPORT std::ostream &	operator<< (std::ostream &s, const Matrix< General, Fixed< 3 >, Fixed< 1 >, IndependentVariable > &A)
template FMATVEC_EXPORT std::istream &	operator>> (std::istream &s, Matrix< General, Fixed< 4 >, Fixed< 1 >, IndependentVariable > &A)
template FMATVEC_EXPORT std::ostream &	operator<< (std::ostream &s, const Matrix< General, Fixed< 4 >, Fixed< 1 >, IndependentVariable > &A)
template FMATVEC_EXPORT std::istream &	operator>> (std::istream &s, Matrix< General, Fixed< 5 >, Fixed< 1 >, IndependentVariable > &A)
template FMATVEC_EXPORT std::ostream &	operator<< (std::ostream &s, const Matrix< General, Fixed< 5 >, Fixed< 1 >, IndependentVariable > &A)
template FMATVEC_EXPORT std::istream &	operator>> (std::istream &s, Matrix< General, Fixed< 6 >, Fixed< 1 >, IndependentVariable > &A)
template FMATVEC_EXPORT std::ostream &	operator<< (std::ostream &s, const Matrix< General, Fixed< 6 >, Fixed< 1 >, IndependentVariable > &A)
template FMATVEC_EXPORT std::istream &	operator>> (std::istream &s, Matrix< General, Fixed< 1 >, Fixed< 2 >, IndependentVariable > &A)
template FMATVEC_EXPORT std::ostream &	operator<< (std::ostream &s, const Matrix< General, Fixed< 1 >, Fixed< 2 >, IndependentVariable > &A)
template FMATVEC_EXPORT std::istream &	operator>> (std::istream &s, Matrix< General, Fixed< 1 >, Fixed< 3 >, IndependentVariable > &A)
template FMATVEC_EXPORT std::ostream &	operator<< (std::ostream &s, const Matrix< General, Fixed< 1 >, Fixed< 3 >, IndependentVariable > &A)
template FMATVEC_EXPORT std::istream &	operator>> (std::istream &s, Matrix< General, Fixed< 1 >, Fixed< 4 >, IndependentVariable > &A)
template FMATVEC_EXPORT std::ostream &	operator<< (std::ostream &s, const Matrix< General, Fixed< 1 >, Fixed< 4 >, IndependentVariable > &A)
template FMATVEC_EXPORT std::istream &	operator>> (std::istream &s, Matrix< General, Fixed< 1 >, Fixed< 5 >, IndependentVariable > &A)
template FMATVEC_EXPORT std::ostream &	operator<< (std::ostream &s, const Matrix< General, Fixed< 1 >, Fixed< 5 >, IndependentVariable > &A)
template FMATVEC_EXPORT std::istream &	operator>> (std::istream &s, Matrix< General, Fixed< 1 >, Fixed< 6 >, IndependentVariable > &A)
template FMATVEC_EXPORT std::ostream &	operator<< (std::ostream &s, const Matrix< General, Fixed< 1 >, Fixed< 6 >, IndependentVariable > &A)
template FMATVEC_EXPORT std::istream &	operator>> (std::istream &s, Matrix< Diagonal, Ref, Ref, double > &A)
template FMATVEC_EXPORT std::ostream &	operator<< (std::ostream &s, const Matrix< Diagonal, Ref, Ref, double > &A)
template<class Dep , class ATIndep >
Dep	parDer (const Dep &dep, const ATIndep &indep)
template<class ATDep , class ATIndep >
Vector< Fixed< 3 >, ATDep >	parDer (const Matrix< Rotation, Fixed< 3 >, Fixed< 3 >, ATDep > &R, const ATIndep &x)
template<class DepShape , class IndepShape , class ATDep , class ATIndep >
Matrix< General, DepShape, IndepShape, ATDep >	parDer (const Vector< DepShape, ATDep > &dep, const Vector< IndepShape, ATIndep > &indep)
template<class IndepShape , class ATDep , class ATIndep >
RowVector< IndepShape, ATDep >	parDer (const ATDep &dep, const Vector< IndepShape, ATIndep > &indep)
template<class ATDep , class Shape , class ATIndep >
Matrix< General, Fixed< 3 >, Shape, ATDep >	parDer (const Matrix< Rotation, Fixed< 3 >, Fixed< 3 >, ATDep > &R, const Vector< Shape, ATIndep > &x)
template<class Dep , class ATDep , class ATIndep >
Dep	dirDer (const Dep &dep, const ATDep &indepdir, const ATIndep &indep)
template<class ATDep , class ATIndep >
Vector< Fixed< 3 >, ATDep >	dirDer (const Matrix< Rotation, Fixed< 3 >, Fixed< 3 >, ATDep > &R, const ATDep &indepdir, const ATIndep &indep)
template<class Dep , class ShapeIndep , class ATDep , class ATIndep >
Dep	dirDer (const Dep &dep, const Vector< ShapeIndep, ATDep > &indepdir, const Vector< ShapeIndep, ATIndep > &indep)
template<class ATDep , class ShapeIndep , class ATIndep >
Vector< Fixed< 3 >, ATDep >	dirDer (const Matrix< Rotation, Fixed< 3 >, Fixed< 3 >, ATDep > &dep, const Vector< ShapeIndep, ATDep > &indepdir, const Vector< ShapeIndep, ATIndep > &indep)
template<class Ret , class A , class B >
Ret	subst (const Ret &src, const A &a, const B &b)
template<class Dst , class Src >
Dst &	operator^= (Dst &dst, const Src &src)
template<class Func , class ArgS >
ReplaceAT< typenamestd::function< Func >::result_type, SymbolicExpression >::Type	symbolicFuncWrapVecAndMatRet (const std::shared_ptr< Function< Func > > &func, const ArgS &arg, int size1=0, int size2=0)
template<class Func , class Arg1S , class Arg2S >
ReplaceAT< typenamestd::function< Func >::result_type, SymbolicExpression >::Type	symbolicFuncWrapVecAndMatRet (const std::shared_ptr< Function< Func > > &func, const Arg1S &arg1, const Arg2S &arg2, int size1=0, int size2=0)
template<class Func , class ArgS >
ReplaceAT< typenamestd::function< Func >::result_type, SymbolicExpression >::Type	symbolicFunc (const std::shared_ptr< Function< Func > > &func, const ArgS &arg, int size1=0, int size2=0)
template<class Func , class Arg1S , class Arg2S >
ReplaceAT< typenamestd::function< Func >::result_type, SymbolicExpression >::Type	symbolicFunc (const std::shared_ptr< Function< Func > > &func, const Arg1S &arg1, const Arg2S &arg2, int size1=0, int size2=0)
template<typename T >
std::string	toString (const T &value, int precision=0)
template<int N>
std::string	toString (const StringLiteral< N > &value)
template<class T >
std::string	toString (const std::vector< T > &value, int precision=0)
template<class T >
std::string	toString (const std::vector< std::vector< T > > &value, int precision=0)
template<bool value>
void	fmatvec_assert (bool expr, std::string_view file, int line, std::string_view func, std::string_view exprStr)
template<>
void	fmatvec_assert< false > (bool expr, std::string_view file, int line, std::string_view func, std::string_view exprStr)
template<>
void	fmatvec_assert< true > (bool expr, std::string_view file, int line, std::string_view func, std::string_view exprStr)
int	dgels (const CBLAS_TRANSPOSE ctr, const int m, const int n, const int nrhs, double *a, const int lda, double *b, const int ldb)
int	dgelss (const int m, const int n, const int nrhs, double *a, const int lda, double *b, const int ldb, const double rcond)
int	dgeev (const char jobvl, const char jobvr, const int n, double *a, const int lda, double *wr, double *wi, double *vl, const int ldvl, double *vr, const int ldvr)
int	dsygv (const int itype, const char jobz, const char uplo, const int n, double *a, const int lda, double *b, const int ldb, double *w)
int	dgesvd (const char jobu, const char jobvt, const int m, const int n, double *a, const int lda, double *s, double *u, const int ldu, double *vt, const int ldvt)
int	dsyev (const char jobz, const char ul, const int n, double *a, const int lda, double *w)
int	dsyevx (const char jobz, const char range, const enum CBLAS_UPLO cuplo, const int n, double *a, const int lda, const double vl, const double vu, const int il, const int iu, const double abstol, int *m, double *w, double *z, const int ldz)
double	dlange (const char norm, const int m, const int n, const double *a, const int lda)
double	dlansy (const char norm, const char uplo, const int n, const double *a, const int lda)

Variables
DisableEscaping	disableEscaping
EnableEscaping	enableEscaping
FMATVEC_EXPORT double	tildeEPS = 1e-6

Detailed Description

Namespace fmatvec.

Typedef Documentation

BandMat

using fmatvec::BandMat = typedef Matrix<GeneralBand, Ref, Ref, double>

Band matrix.

BandMat is an abbreviation for band matrices of type double.

DiagMat

using fmatvec::DiagMat = typedef Matrix<Diagonal, Ref, Ref, double>

Diagonal matrix.

DiagMat is an abbreviation for diagonal matrices of type double.

Mat

using fmatvec::Mat = typedef Matrix<General, Ref, Ref, double>

General matrix.

Mat is an abbreviation for general matrices of type double.

RowVec

using fmatvec::RowVec = typedef RowVector<Ref, double>

Row vector.

RowVec is an abbreviation for row vectors of type double.

SqrMat

using fmatvec::SqrMat = typedef SquareMatrix<Ref, double>

Square matrix.

SqrMat is an abbreviation for square matrices of type double.

StringLiteral

template<int N>

using fmatvec::StringLiteral = typedef char[N]

Convert a string liternal to std::string.

SymMat

using fmatvec::SymMat = typedef Matrix<Symmetric, Ref, Ref, double>

Symmetric matrix.

SymMat is an abbreviation for symmetric matrices of type double.

Vec

using fmatvec::Vec = typedef Vector<Ref, double>

Vector.

Vec is an abbreviation for vectors of type double.

Function Documentation

bubbleSort()

template<class AT >

Matrix< General, Ref, Ref, AT > fmatvec::bubbleSort	(	const Matrix< General, Ref, Ref, AT > &	A_,
		int	PivotCol
	)

Bubble Sort Algorithm (stable sorting Algorithm )

Values of rowvectors of Matrix A are sorted in ascending order

Parameters

A_	Matrix to be sorted
PivotCol	Column of A used as sorting index

crossProduct()

template<class Row1 , class Row2 , class AT1 , class AT2 >

Vector< Fixed< 3 >, typename OperatorResult< AT1, AT2 >::Type > fmatvec::crossProduct	(	const Vector< Row1, AT1 > &	x,
		const Vector< Row2, AT2 > &	y
	)

Cross product.

This function computes the cross product of two vectors.

Returns

The cross product.

Doolittle_LU_with_Pivoting_Solve()

FMATVEC_EXPORT int fmatvec::Doolittle_LU_with_Pivoting_Solve	(	const double *	A,
		double	B[],
		const int	pivot[],
		double	x[],
		int	n
	)

solve linear system with LU decomposed matrix

Parameters

*LU	Pointer to the first element of the matrix whose elements form the lower and upper triangular matrix factors of A
*B	Pointer to the column vector, (n x 1) matrix, B.
pivot[]	The i-th element is the pivot row interchanged with row i
*x	Solution to the equation Ax = B
n	The number of rows or columns of the matrix LU

Returns

success of routine (1 = Success, -1 Failure (matrix LU is singular)

This routine uses Doolittle's method to solve the linear equation Ax = B. This routine is called after the matrix A has been decomposed into a product of a unit lower triangular matrix L and an upper triangular matrix U with pivoting. The argument LU is a pointer to the matrix the subdiagonal part of which is L and the superdiagonal together with the diagonal part is U. (The diagonal part of L is 1 and is not stored.) The matrix A = LU. The solution proceeds by solving the linear equation Ly = B for y and subsequently solving the linear equation Ux = y for x.

REMARK: Copied and fitted on 28.01.2013 of http://www.mymathlib.com/c_source/matrices/linearsystems/doolittle_pivot.c

dump()

template<class Type , class Row , class Col , class AT >

void fmatvec::dump	(	const char *	str,
		const Matrix< Type, Row, Col, AT > &	A
	)

Matrix dump.

This function dumps a matrix to a file in ASCII-format.

Parameters

is	The filename.
A	A matrix of any shape and type.

eigval() [1/2]

FMATVEC_EXPORT Vector< Ref, double > fmatvec::eigval

(

const Matrix< Symmetric, Ref, Ref, double > &

A

)

Eigenvalues.

This function computes the eigenvalues of a symmetric matrix.

Parameters

A	A symmetric matrix.

Returns

A vector containig the eigenvalues.

eigval() [2/2]

FMATVEC_EXPORT Vector< Ref, std::complex< double > > fmatvec::eigval

(

const SquareMatrix< Ref, double > &

A

)

Eigenvalues.

This function computes the complex eigenvalues of a square matrix.

Parameters

A	A square matrix.

Returns

A vector containig the eigenvalues.

eigvalSel()

FMATVEC_EXPORT Vector< Ref, double > fmatvec::eigvalSel	(	const Matrix< Symmetric, Ref, Ref, double > &	A,
		int	il,
		int	iu,
		double	abstol = 0
	)

Eigenvalues.

This function computes selected eigenvalues of a symmetric matrix. The eigenvalues can be selected by specifying either a range of values or a range of indices for the desired eigenvalues.

Parameters

A	A symmetric matrix.
il	The index of the smallest eigenvalue to be returned
iu	The index of the largest eigenvalue to be returned
abstol	The absolute error tolerance for the eigenvalues

Returns

A vector containig the eigenvalues.

eigvec() [1/3]

FMATVEC_EXPORT int fmatvec::eigvec	(	const Matrix< Symmetric, Ref, Ref, double > &	A,
		const Matrix< Symmetric, Ref, Ref, double > &	B,
		SquareMatrix< Ref, double > &	eigenvectors,
		Vector< Ref, double > &	eigenvalues
	)

Eigenvectors and Eigenvalues.

This function computes all the eigenvectors and the eigenvalues of a real generalized symmetric-definite eigenproblem, of the form A*x=(lambda)*B*x. Here A and B are assumed to be symmetric and B is also positive definite.

Parameters

A	A symmetric matrix.
B	A symmetric, positive definite matrix.
eigenvector	A square matrix in the dimension of A, containing the normalized Eigenvectors at the end of the function.
eigenvalues	A vector in the size of A, containing the Eigenvalues at the end of the function

Returns

void

eigvec() [2/3]

FMATVEC_EXPORT int fmatvec::eigvec	(	const Matrix< SymmetricSparse, Ref, Ref, double > &	A,
		const Matrix< SymmetricSparse, Ref, Ref, double > &	M,
		int	nev,
		double	sigma,
		Matrix< General, Ref, Ref, double > &	eigenvectors,
		Vector< Ref, double > &	eigenvalues,
		double	tol_ = 0
	)

Eigenvectors and Eigenvalues.

This function computes a limited number of eigenvectors and eigenvalues of the general eigenvalue equation A*x=(lambda)*B*x.

Parameters

A	A symmetric sparse matrix.
B	A symmetric sparse, positive definite matrix.
nev	The number of eigenvalues und eigenvectors to be calculated.
sigma	A scalar that determines which eigenvalues are returned.
eigenvector	A matrix, containing the nev eigenvectors et the end of the function.
eigenvalues	A vector, containing the nev eigenvalues closest to sigma at the end of the function.

Returns

void

eigvec() [3/3]

FMATVEC_EXPORT int fmatvec::eigvec	(	const SquareMatrix< Ref, double > &	A,
		SquareMatrix< Ref, std::complex< double > > &	V,
		Vector< Ref, std::complex< double > > &	w
	)

Eigenvectors and Eigenvalues.

This function computes the complex eigenvalues and eigenvectors of a square matrix.

Parameters

A	A square matrix.
eigenvector	A square matrix in the dimension of A, containing the normalized eigenvectors.
eigenvalues	A vector in the size of A, containing the eigenvalues.

Returns

If 0, successful exit. If -i, the i-th argument had an illegal value. If i, the QR algorithm failed to compute all the eigenvalues, and no eigenvectors have been computed.

facLL()

FMATVEC_EXPORT Matrix< Symmetric, Ref, Ref, double > fmatvec::facLL

(

const Matrix< Symmetric, Ref, Ref, double > &

A

)

LL decomposition.

This function computes the Cholesky decomposition of a symmetric matrix according to

\[\boldsymbol{A}=\boldsymbol{L}\,\boldsymbol{L} \]

Parameters

A	A symmetric matrix.

Returns

A symmetric matrix containig the result.

facLU() [1/3]

FMATVEC_EXPORT Matrix< General, Ref, Ref, double > fmatvec::facLU	(	const Matrix< General, Ref, Ref, double > &	A,
		Vector< Ref, int > &	ipiv
	)

LU decomposition.

This function computes the LU decomposition of a general matrix according to

\[\boldsymbol{A}=\boldsymbol{P}\,\boldsymbol{L}\,\boldsymbol{U} \]

Parameters

A	A general matrix.
ipiv	A vector of integers containing the pivot indices.

Returns

A general matrix containig the result.

facLU() [2/3]

FMATVEC_EXPORT SquareMatrix< Ref, double > fmatvec::facLU	(	const SquareMatrix< Ref, double > &	A,
		Vector< Ref, int > &	ipiv
	)

LU decomposition.

This function computes the LU decomposition of a square matrix according to

\[\boldsymbol{A}=\boldsymbol{P}\,\boldsymbol{L}\,\boldsymbol{U} \]

Parameters

A	A square matrix.
ipiv	A vector of integers containing the pivot indices.

Returns

A square matrix containig the result.

facLU() [3/3]

FMATVEC_EXPORT int fmatvec::facLU	(	double *	A,
		int	pivot[],
		int	n
	)

LU decomposition.

This function computes the LU decomposition of a square matrix according to

\[\boldsymbol{A}=\boldsymbol{P}\,\boldsymbol{L}\,\boldsymbol{U} \]

Parameters

A	Pointer to first element of a square matrix.
ipiv	A vector of integers containing the pivot indices.
info	Information about success of routine

Returns

A square matrix containig the result.

Copied and fitted on 28.01.2013 of http://www.mymathlib.com/c_source/matrices/linearsystems/doolittle_pivot.c

inv() [1/3]

FMATVEC_EXPORT Matrix< Diagonal, Ref, Ref, double > fmatvec::inv

(

const Matrix< Diagonal, Ref, Ref, double > &

A

)

Inverse.

This function computes the inverse of a diagonal matrix according to

\[\boldsymbol{A}^{-1} \]

Parameters

A	A diagonal matrix.

Returns

A diagonal matrix containig the result.

inv() [2/3]

FMATVEC_EXPORT Matrix< Symmetric, Ref, Ref, double > fmatvec::inv

(

const Matrix< Symmetric, Ref, Ref, double > &

A

)

Inverse.

This function computes the inverse of a symmetric matrix according to

\[\boldsymbol{A}^{-1} \]

Parameters

A	A symmetric matrix.

Returns

A symmetric matrix containig the result.

inv() [3/3]

FMATVEC_EXPORT SquareMatrix< Ref, double > fmatvec::inv

(

const SquareMatrix< Ref, double > &

A

)

Inverse.

This function computes the inverse of a general matrix according to

\[\boldsymbol{A}^{-1} \]

Parameters

A	A square matrix.

Returns

A square matrix containig the result.

max()

template<class Row , class AT >

AT fmatvec::max

(

const Vector< Row, AT > &

x

)

Maximum value.

This function computes the maximum value of a vector.

Returns

The maximum value.

maxIndex()

template<class Row , class AT >

int fmatvec::maxIndex

(

const Vector< Row, AT > &

x

)

Index of maximum value.

This function computes the index of the maximum value of a vector

Returns

The index of the maximum value.

min()

template<class Row , class AT >

AT fmatvec::min

(

const Vector< Row, AT > &

x

)

Minimum value.

This function computes the minimum value of a vector.

Returns

The minimum value.

minIndex()

template<class Row , class AT >

int fmatvec::minIndex

(

const Vector< Row, AT > &

x

)

Index of minimum value.

This function computes the index of the minimum value of a vector

Returns

The index of the minimum value.

nrm1() [1/2]

FMATVEC_EXPORT double fmatvec::nrm1

(

const Matrix< General, Ref, Ref, double > &

A

)

1-norm

This function computes the largest column sum of the absolute values of a general matrix.

Parameters

A	A general matrix.

Returns

A scalar containig the result.

nrm1() [2/2]

FMATVEC_EXPORT double fmatvec::nrm1

(

const Vector< Ref, double > &

x

)

1-norm

This function computes the sum of the absolute values of a vector.

Parameters

x

A vector.

Returns

A scalar containig the result.

nrm2() [1/2]

FMATVEC_EXPORT double fmatvec::nrm2

(

const Matrix< General, Ref, Ref, double > &

A

)

2-norm

This function computes the largest singular value of a general matrix.

Parameters

A	A general matrix.

Returns

A scalar containig the result.

nrm2() [2/2]

FMATVEC_EXPORT double fmatvec::nrm2

(

const Vector< Ref, double > &

x

)

2-norm

This function computes the the Euclidean norm of a vector.

Parameters

x

A vector.

Returns

A scalar containig the result.

nrmFro()

FMATVEC_EXPORT double fmatvec::nrmFro

(

const Matrix< General, Ref, Ref, double > &

A

)

Frobenius-norm.

This function computes the Frobenius norm of a general matrix.

Parameters

A	A general matrix.

Returns

A scalar containig the result.

nrmInf() [1/3]

FMATVEC_EXPORT double fmatvec::nrmInf

(

const Matrix< General, Ref, Ref, double > &

A

)

Infinity-norm.

This function computes the largest row sum of the absolute values of a general matrix.

Parameters

A	A general matrix.

Returns

A scalar containing the result.

nrmInf() [2/3]

FMATVEC_EXPORT double fmatvec::nrmInf

(

const Matrix< Symmetric, Ref, Ref, double > &

A

)

Infinity-norm.

This function computes the largest row sum of the absolute values of a symmetric matrix.

Parameters

A	A general matrix.

Returns

A scalar containing the result.

nrmInf() [3/3]

FMATVEC_EXPORT double fmatvec::nrmInf

(

const Vector< Ref, double > &

x

)

Infinity-norm.

This function computes the the largest absolute value of a vector.

Parameters

x

A vector.

Returns

A scalar containig the result.

operator!=()

template<class AT , class Type1 , class Row1 , class Col1 , class Type2 , class Row2 , class Col2 >

bool fmatvec::operator!=	(	const Matrix< Type1, Row1, Col1, AT > &	A,
		const Matrix< Type2, Row2, Col2, AT > &	B
	)

Matrix-matrix comparison.

This function compares two matrices.

Returns

True, if the matrices are different, false otherwise.

operator*() [1/6]

template<class Col , class AT1 , class AT2 >

RowVector< Col, typename OperatorResult< AT1, AT2 >::Type > fmatvec::operator*	(	const AT1 &	alpha,
		const RowVector< Col, AT2 > &	x
	)

Scalar-rowvector multiplication.

See also

operator*(const RowVector<Col>, AT2>&, const AT&).

operator*() [2/6]

template<class Row , class AT1 , class AT2 >

Vector< Row, typename OperatorResult< AT1, AT2 >::Type > fmatvec::operator*	(	const AT1 &	alpha,
		const Vector< Row, AT2 > &	x
	)

Scalar-vector multiplication.

See also

operator*(const Vector<Ref,AT1>&x,const AT&).

operator*() [3/6]

template<class Type , class Row , class Col , class AT1 , class AT2 >

Matrix< Type, Row, Col, typename OperatorResult< AT1, AT2 >::Type > fmatvec::operator*	(	const Matrix< Type, Row, Col, AT1 > &	A,
		const AT2 &	alpha
	)

Matrix-scalar multiplication.

This function computes the product of a matrix and a scalar.

Parameters

A	The matrix.
alpha	The scalar.

Returns

The product.

operator*() [4/6]

template<class Col , class AT1 , class AT2 >

RowVector< Col, typename OperatorResult< AT1, AT2 >::Type > fmatvec::operator*	(	const RowVector< Col, AT1 > &	x,
		const AT2 &	alpha
	)

Rowvector-scalar multiplication.

This function computes the product of a rowvector and a scalar.

Returns

The product.

operator*() [5/6]

template<class Col , class Row , class AT1 , class AT2 >

OperatorResult< AT1, AT2 >::Type fmatvec::operator*	(	const RowVector< Col, AT1 > &	x,
		const Vector< Row, AT2 > &	y
	)

Scalar product.

This function computes the product of a vector and a rowvector. The result is a scalar.

Returns

The product.

operator*() [6/6]

template<class Row , class AT1 , class AT2 >

Vector< Row, typename OperatorResult< AT1, AT2 >::Type > fmatvec::operator*	(	const Vector< Row, AT1 > &	x,
		const AT2 &	alpha
	)

Vector-scalar multiplication.

This function computes the product of a vector and a scalar.

Returns

The product.

operator-() [1/4]

template<class Type , class Row , class Col , class AT >

Matrix< Type, Row, Col, typename OperatorResult< AT, AT >::Type > fmatvec::operator-

(

const Matrix< Type, Row, Col, AT > &

A

)

Negation.

This function computes the negation of a vector.

Returns

The negation.

operator-() [2/4]

template<class Col , class AT >

RowVector< Col, typename OperatorResult< AT, AT >::Type > fmatvec::operator-

(

const RowVector< Col, AT > &

a

)

Negation.

This function computes the negation of a rowvector.

Returns

The negation.

operator-() [3/4]

template<class Row , class AT >

SquareMatrix< Row, typename OperatorResult< AT, AT >::Type > fmatvec::operator-

(

const SquareMatrix< Row, AT > &

A

)

Negation.

This function computes the negation of a vector.

Returns

The negation.

operator-() [4/4]

template<class Row , class AT >

Vector< Row, typename OperatorResult< AT, AT >::Type > fmatvec::operator-

(

const Vector< Row, AT > &

x

)

Negation.

This function computes the negation of a vector.

Returns

The negation.

operator<<()

template<class Type , class Row , class Col , class AT >

std::ostream & fmatvec::operator<<	(	std::ostream &	os,
		const Matrix< Type, Row, Col, AT > &	A
	)

Matrix output.

This function writes a matrix into a stream.

Parameters

os	An output stream.
A	A matrix of any shape and type.

Returns

A reference to the output stream.

operator==() [1/2]

template<class AT , class Type1 , class Row1 , class Col1 , class Type2 , class Row2 , class Col2 >

bool fmatvec::operator==	(	const Matrix< Type1, Row1, Col1, AT > &	A,
		const Matrix< Type2, Row2, Col2, AT > &	B
	)

Matrix-matrix comparison.

This function compares two matrices

Returns

True, if the matrices are identical, false otherwise.

operator==() [2/2]

bool fmatvec::operator== ( const Range< Var, Var > &  I, const Range< Var, Var > &  J  )

inline

Equality operator for indices.

Checks for equality of two indices.

Returns

true if two index objects are equal, false otherwise.

operator>>()

template<class Type , class Row , class Col , class AT >

std::istream & fmatvec::operator>>	(	std::istream &	s,
		Matrix< Type, Row, Col, AT > &	A
	)

Matrix input.

This function loads a matrix from a stream.

Parameters

is	An input stream.
A	A matrix of any shape and type.

Returns

A reference to the input stream.

parDer()

FMATVEC_EXPORT SymbolicExpression fmatvec::parDer	(	const SymbolicExpression &	dep,
		const IndependentVariable &	indep
	)

Generate a new SymbolicExpression being the partial derivate of dep with respect to indep (indep must be a symbol).

quickSortMedian()

template<class AT >

Matrix< General, Ref, Ref, AT > fmatvec::quickSortMedian	(	const Matrix< General, Ref, Ref, AT > &	A_,
		int	PivotCol
	)

Modified QuickSort Algorithm (unstable sorting Algorithm )

Values of rowvectors of Matrix A are sorted in ascending order unstabel but very quick sorting Algorithm Pivot Elements as 'Median of three'

Parameters

A_	Matrix to be sorted
PivotCol	Column of A used as sorting index

quicksortmedian_intern()

template<class AT >

void fmatvec::quicksortmedian_intern	(	Matrix< General, Ref, Ref, AT > &	A,
		int	PivotCol,
		RowVector< Ref, AT > &	tmp,
		int	l,
		int	r
	)

internal function of QuickSortMedian

rho() [1/2]

FMATVEC_EXPORT double fmatvec::rho

(

const Matrix< Symmetric, Ref, Ref, double > &

A

)

Spectral radius.

This function computes the spectral radius of a symmetric matrix.

Parameters

A	A symmetric matrix.

Returns

A scalar containig the result.

rho() [2/2]

FMATVEC_EXPORT double fmatvec::rho

(

const SquareMatrix< Ref, double > &

A

)

Spectral radius.

This function computes the spectral radius of a square matrix.

Parameters

A	A square matrix.

Returns

A scalar containig the result.

scalarProduct()

template<class Row , class AT >

AT fmatvec::scalarProduct	(	const Vector< Row, AT > &	x,
		const Vector< Row, AT > &	y
	)

Scalar product.

This function computes the scalar product of two vectors.

Returns

The scalar product.

slvLL() [1/2]

FMATVEC_EXPORT Matrix< General, Ref, Ref, double > fmatvec::slvLL	(	const Matrix< Symmetric, Ref, Ref, double > &	A,
		const Matrix< General, Ref, Ref, double > &	X
	)

Systems of linear equations.

This function solves systems of linear equations according to

\[\boldsymbol{A}\,\boldsymbol{X}=\boldsymbol{B} \]

by a LL decompostion.

Parameters

A	A symmetric matrix.
B	A general matrix containing the right hand sides.

Returns

A general matrix containig the solution.

slvLL() [2/2]

FMATVEC_EXPORT Vector< Ref, double > fmatvec::slvLL	(	const Matrix< Symmetric, Ref, Ref, double > &	A,
		const Vector< Ref, double > &	x
	)

System of linear equations.

This function solves a system of linear equations according to

\[\boldsymbol{A}\,\boldsymbol{x}=\boldsymbol{b} \]

by a LL decompostion.

Parameters

A	A symmetric matrix.
b	A vector containing the right hand side.

Returns

A vector containig the solution.

slvLU() [1/7]

FMATVEC_EXPORT Matrix< General, Ref, Ref, double > fmatvec::slvLU	(	const Matrix< SymmetricSparse, Ref, Ref, double > &	A,
		const Matrix< General, Ref, Ref, double > &	X
	)

System of linear equations.

This function solves a system of sparse linear equations according to

\[\boldsymbol{A}\,\boldsymbol{x}=\boldsymbol{b} \]

by a LU decompostion.

Parameters

A	A symmetric sparse matrix.
b	A vector containing the right hand side.

Returns

A vector containig the solution.

slvLU() [2/7]

FMATVEC_EXPORT Vector< Ref, double > fmatvec::slvLU	(	const Matrix< SymmetricSparse, Ref, Ref, double > &	A,
		const Vector< Ref, double > &	x
	)

Systems of linear equations.

This function solves systems of sparse linear equations according to

\[\boldsymbol{A}\,\boldsymbol{X}=\boldsymbol{B} \]

by a LU decompostion.

Parameters

A	A symmetric sparse matrix.
B	A general matrix containing the right hand sides.

Returns

A general matrix containig the solution.

slvLU() [3/7]

template<int size>

Vector< Fixed< size >, double > fmatvec::slvLU	(	const SquareMatrix< Fixed< size >, double > &	A,
		const Vector< Fixed< size >, double > &	b,
		int &	info
	)

Row interchanges.

This function performs a series of row interchanges on a general matrix.

Parameters

A	A general matrix.
ipiv	A vector of integers containing the pivot indices.

Returns

A Matrix containig the result.

System of linear equations

This function solves a system of linear equations according to

\[\boldsymbol{A}\,\boldsymbol{x}=\boldsymbol{b} \]

by a LU decompostion.

Parameters

A	A square matrix.
b	A vector containing the right hand side.
info	Information about the success of the routine (0 = success)

Returns

A vector containig the solution.

slvLU() [4/7]

FMATVEC_EXPORT Matrix< General, Ref, Ref, double > fmatvec::slvLU	(	const SquareMatrix< Ref, double > &	A,
		const Matrix< General, Ref, Ref, double > &	X
	)

Systems of linear equations.

This function solves systems of linear equations according to

\[\boldsymbol{A}\,\boldsymbol{X}=\boldsymbol{B} \]

by a LU decompostion.

Parameters

A	A square matrix.
B	A general matrix containing the right hand sides.

Returns

A general matrix containig the solution.

slvLU() [5/7]

FMATVEC_EXPORT Vector< Ref, double > fmatvec::slvLU	(	const SquareMatrix< Ref, double > &	A,
		const Vector< Ref, double > &	x
	)

System of linear equations.

This function solves a system of linear equations according to

\[\boldsymbol{A}\,\boldsymbol{x}=\boldsymbol{b} \]

by a LU decompostion.

Parameters

A	A square matrix.
b	A vector containing the right hand side.

Returns

A vector containig the solution.

slvLU() [6/7]

FMATVEC_EXPORT Vector< Ref, double > fmatvec::slvLU	(	const SquareMatrix< Ref, double > &	A,
		const Vector< Ref, double > &	x,
		int &	info
	)

System of linear equations.

This function solves a system of linear equations according to

\[\boldsymbol{A}\,\boldsymbol{x}=\boldsymbol{b} \]

by a LU decompostion.

Parameters

A	A square matrix.
b	A vector containing the right hand side.
info	Information about the success of the routine (0 = success)

Returns

A vector containig the solution.

slvLU() [7/7]

FMATVEC_EXPORT Vector< Ref, std::complex< double > > fmatvec::slvLU	(	const SquareMatrix< Ref, std::complex< double > > &	A,
		const Vector< Ref, std::complex< double > > &	b
	)

System of linear equations.

This function solves a complex system of linear equations according to

\[\boldsymbol{A}\,\boldsymbol{x}=\boldsymbol{b} \]

by a LU decompostion.

Parameters

A	A complex square matrix.
b	A complex vector containing the right hand side.

Returns

A complex vector containig the solution.

slvLUFac() [1/2]

FMATVEC_EXPORT Matrix< General, Ref, Ref, double > fmatvec::slvLUFac	(	const SquareMatrix< Ref, double > &	A,
		const Matrix< General, Ref, Ref, double > &	X,
		const Vector< Ref, int > &	ipiv
	)

Systems of linear equations.

This function solves systems of linear equations according to

\[\boldsymbol{A}\,\boldsymbol{X}=\boldsymbol{B} \]

. The matrix is already decomposed by a LU decompostion using facLU.

Parameters

A	A square matrix decomposed by a LU decompostion using facLU.
B	A general matrix containing the right hand sides.
ipiv	A vector of integers containing the pivot indices.

Returns

A general matrix containig the solution.

slvLUFac() [2/2]

FMATVEC_EXPORT Vector< Ref, double > fmatvec::slvLUFac	(	const SquareMatrix< Ref, double > &	A,
		const Vector< Ref, double > &	x,
		const Vector< Ref, int > &	ipiv
	)

System of linear equations.

This function solves a system of linear equations according to

\[\boldsymbol{A}\,\boldsymbol{x}=\boldsymbol{b} \]

. The matrix is already decomposed by a LU decompostion using facLU.

Parameters

A	A square matrix decomposed by a LU decompostion using facLU.
b	A vector containing the right hand side.
ipiv	A vector of integers containing the pivot indices.

Returns

A vector containig the solution.

slvQR() [1/2]

FMATVEC_EXPORT Matrix< General, Ref, Ref, double > fmatvec::slvQR	(	const SquareMatrix< Ref, double > &	A,
		const Matrix< General, Ref, Ref, double > &	X
	)

Systems of linear equations.

This function solves systems of linear equations according to

\[\boldsymbol{A}\,\boldsymbol{X}=\boldsymbol{B} \]

by a QR decompostion.

Parameters

A	A square matrix.
B	A general matrix containing the right hand sides.

Returns

A general matrix containig the solution.

slvQR() [2/2]

FMATVEC_EXPORT Vector< Ref, double > fmatvec::slvQR	(	const SquareMatrix< Ref, double > &	A,
		const Vector< Ref, double > &	x
	)

System of linear equations.

This function solves a system of linear equations according to

\[\boldsymbol{A}\,\boldsymbol{x}=\boldsymbol{b} \]

by a QR decompostion.

Parameters

A	A square matrix.
b	A vector containing the right hand side.

Returns

A vector containig the solution.

slvQRLQ() [1/2]

FMATVEC_EXPORT Matrix< General, Ref, Ref, double > fmatvec::slvQRLQ	(	const Matrix< General, Ref, Ref, double > &	A,
		const Matrix< General, Ref, Ref, double > &	B
	)

System of overdetermined or underdetermined linear equations.

This function solves the least squares problem of a overdetermined system and solves the minimum norm problem of a underdetermined system. by a QR or LQ decompostion. slvQRLQ is faster than slvLS but cannot handle rank deficient matrices A (A must have full rank).

Parameters

A	A general matrix which must have full rank.
B	A matrix containing the B.cols() number of right hand sides.

Returns

A matrix containig the solutions.

slvQRLQ() [2/2]

FMATVEC_EXPORT Vector< Ref, double > fmatvec::slvQRLQ	(	const Matrix< General, Ref, Ref, double > &	A,
		const Vector< Ref, double > &	b
	)

System of overdetermined or underdetermined linear equations.

This function solves the least squares problem of a overdetermined system and solves the minimum norm problem of a underdetermined system. by a QR or LQ decompostion. slvQRLQ is faster than slvLS but cannot handle rank deficient matrices A (A must have full rank).

Parameters

A	A general matrix which must have full rank.
b	A vector containing the right hand side.

Returns

A vector containig the solution.

svd()

FMATVEC_EXPORT int fmatvec::svd	(	Matrix< General, Ref, Ref, double > &	A,
		Matrix< General, Ref, Ref, double > &	S,
		SquareMatrix< Ref, double > &	U,
		SquareMatrix< Ref, double > &	VT,
		int	Rueckgabe
	)

This funtion computes the SVD

symbolicFunc() [1/2]

template<class Func , class Arg1S , class Arg2S >

ReplaceAT< typenamestd::function< Func >::result_type, SymbolicExpression >::Type fmatvec::symbolicFunc	(	const std::shared_ptr< Function< Func > > &	func,
		const Arg1S &	arg1,
		const Arg2S &	arg2,
		int	size1 = 0,
		int	size2 = 0
	)

Create a symbolic function from the native function func. If func provides derivatives this symbolic function can also be differentiated using parDir(...). Note that func should use a LRUCache, at least if return value of func is a vector (R^n) or a matrix (R^rxc) since func will be called n or r*c times with the same arguments.

symbolicFunc() [2/2]

template<class Func , class ArgS >

ReplaceAT< typenamestd::function< Func >::result_type, SymbolicExpression >::Type fmatvec::symbolicFunc	(	const std::shared_ptr< Function< Func > > &	func,
		const ArgS &	arg,
		int	size1 = 0,
		int	size2 = 0
	)

Create a symbolic function from the native function func. If func provides derivatives this symbolic function can also be differentiated using parDir(...). Note that func should use a LRUCache, at least if return value of func is a vector (R^n) or a matrix (R^rxc) since func will be called n or r*c times with the same arguments.

tilde() [1/2]

template<class Row , class AT >

Vector< Row, AT > fmatvec::tilde	(	const SquareMatrix< Row, AT > &	T,
		double	tol = tildeEPS
	)

Inverse tilde operator.

Example:

tilde(x);

\[ T = \begin{pmatrix} 0 & -x_3 & x_2 \\ x_3 & 0 & -x_1 \\ -x_2 & x_1 & 0\end{pmatrix} \quad \Rightarrow \quad \tilde T = \begin{pmatrix}x_1 \\ x_2 \\ x_3\end{pmatrix} \]

Only in debug builds the consistency of the matrix T is checked with respect to tol. tol can be passed as optional parameter or set globally using the static variable fmatvec::tildeEPS. Use fmatvec::tildeEPS with care since it affects all subsequent calls to tilde! (but its anyway only for debugging)

tilde() [2/2]

template<class Row , class AT >

SquareMatrix< Row, AT > fmatvec::tilde

(

const Vector< Row, AT > &

x

)

Tilde operator.

Example:

tilde(x);

\[ x=\begin{pmatrix}x_1 \\ x_2 \\ x_3\end{pmatrix} \quad \Rightarrow \quad \tilde x = \begin{pmatrix} 0 & -x_3 & x_2 \\ x_3 & 0 & -x_1 \\ -x_2 & x_1 & 0\end{pmatrix} \]

toString() [1/3]

template<class T >

std::string fmatvec::toString	(	const std::vector< std::vector< T > > &	value,
		int	precision = 0
	)

Convert a vector of vectors of values (matrix) to std::string, using the notation e.g. [2, 7; 3, 7; 8, 1].

• precision == 0: use minimum number of digits but ensure bit identical representation when converted back to T.
• precision < 0: use std::numeric_limits<T>::digits10+precision digits
• precision > 0: use precision digits.

toString() [2/3]

template<class T >

std::string fmatvec::toString	(	const std::vector< T > &	value,
		int	precision = 0
	)

Convert a vector of values to std::string, using the notation e.g. [2; 3; 8].

• precision == 0: use minimum number of digits but ensure bit identical representation when converted back to T.
• precision < 0: use std::numeric_limits<T>::digits10+precision digits
• precision > 0: use precision digits.

toString() [3/3]

template<typename T >

std::string fmatvec::toString	(	const T &	value,
		int	precision = 0
	)

Convert value to std::string, using ostream>>operator(T).

• precision == 0: use minimum number of digits but ensure bit identical representation when converted back to T.
• precision < 0: use std::numeric_limits<T>::digits10+precision digits
• precision > 0: use precision digits.

trans() [1/4]

template<class Type , class Row , class Col , class AT >

Matrix< Type, Col, Row, AT > fmatvec::trans

(

const Matrix< Type, Row, Col, AT > &

A

)

Transpose of a matrix.

This function computes the transpose of a matrix.

\[ \boldsymbol{A} \rightarrow \boldsymbol{A}^T \]

The result is a matrix.

Parameters

A	A general matrix.

Returns

The transpose.

trans() [2/4]

template<class Col , class AT >

Vector< Col, AT > fmatvec::trans

(

const RowVector< Col, AT > &

x

)

Transpose of a rowvector.

This function computes the transpose of a rowvector. The result is a vector.

Parameters

x

A vector.

Returns

The transpose.

trans() [3/4]

template<class Row , class AT >

SquareMatrix< Row, AT > fmatvec::trans

(

const SquareMatrix< Row, AT > &

A

)

Transpose of a matrix.

This function computes the transpose of a square matrix.

\[ \boldsymbol{A} \rightarrow \boldsymbol{A}^T \]

The result is a square matrix.

Parameters

A	A square matrix.

Returns

The transpose.

trans() [4/4]

template<class Row , class AT >

RowVector< Row, AT > fmatvec::trans

(

const Vector< Row, AT > &

x

)

Transpose of a vector.

This function computes the transpose of a vector. The result is a rowvector.

Returns

The transpose.

tripleProduct()

template<class Row , class AT >

double fmatvec::tripleProduct	(	const Vector< Row, AT > &	a,
		const Vector< Row, AT > &	x,
		const Vector< Row, AT > &	y
	)

Triple product.

This function computes the triple product of three vectors.

Returns

The triple product.