fmatvec 0.0.0

Classes | Typedefs | Functions | Variables
fmatvec Namespace Reference

Namespace fmatvec. More...

## Classes

class | AdoptCurrentMessageStreamsUntilScopeExit
struct | AssertUseException
struct | AssertUseException< IndependentVariable >
struct | AssertUseException< SymbolicExpression >
class | Atom
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 | 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 | PrePostfixedStream
| A ostream object which prefix/postfix every meassage and calls the given function. More...
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 | SymbolicFunction< RET(ARG)>
class | SymbolicFunction< RET(ARG1, ARG2)>
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<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 >
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 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 >
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 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 >
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 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 >
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 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 >
Vector< Row, double > | operator- (Vector< Row, double > &&x)
template<class Col , class AT >
RowVector< Col, typename OperatorResult< AT, AT >::Type > | operator- (const RowVector< Col, AT > &a)
| Negation. More...
template<class Col >
RowVector< Col, double > | operator- (RowVector< Col, double > &&a)
template<class Row , class AT >
SquareMatrix< Row, typename OperatorResult< AT, AT >::Type > | operator- (const SquareMatrix< Row, AT > &A)
| Negation. More...
template<class Row >
SquareMatrix< Row, double > | operator- (SquareMatrix< Row, double > &&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 >
Matrix< Type, Row, Col, double > | operator- (Matrix< Type, Row, Col, double > &&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 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 std::ostream & | operator<< (std::ostream &s, const Matrix< General, Ref, Ref, std::complex< double >> &A)
template std::istream & | operator>> (std::istream &s, Matrix< General, Ref, Ref, int > &A)
template std::ostream & | operator<< (std::ostream &s, const Matrix< General, Ref, Ref, int > &A)
template std::istream & | operator>> (std::istream &s, Matrix< General, Var, Var, int > &A)
template std::ostream & | operator<< (std::ostream &s, const Matrix< General, Var, Var, int > &A)
template std::istream & | operator>> (std::istream &s, Matrix< General, Var, Fixed< 1 >, int > &A)
template std::ostream & | operator<< (std::ostream &s, const Matrix< General, Var, Fixed< 1 >, int > &A)
template std::istream & | operator>> (std::istream &s, Matrix< Rotation, Fixed< 3 >, Fixed< 3 >, double > &A)
template std::ostream & | operator<< (std::ostream &s, const Matrix< Rotation, Fixed< 3 >, Fixed< 3 >, double > &A)
template std::istream & | operator>> (std::istream &s, Matrix< Symmetric, Ref, Ref, double > &A)
template std::ostream & | operator<< (std::ostream &s, const Matrix< Symmetric, Ref, Ref, double > &A)
template std::ostream & | operator<< (std::ostream &s, const Matrix< Symmetric, Var, Var, double > &A)
template std::istream & | operator>> (std::istream &s, Matrix< Symmetric, Fixed< 2 >, Fixed< 2 >, double > &A)
template std::ostream & | operator<< (std::ostream &s, const Matrix< Symmetric, Fixed< 2 >, Fixed< 2 >, double > &A)
template std::istream & | operator>> (std::istream &s, Matrix< Symmetric, Fixed< 3 >, Fixed< 3 >, double > &A)
template std::ostream & | operator<< (std::ostream &s, const Matrix< Symmetric, Fixed< 3 >, Fixed< 3 >, double > &A)
template std::istream & | operator>> (std::istream &s, Matrix< General, Ref, Ref, double > &A)
template std::ostream & | operator<< (std::ostream &s, const Matrix< General, Ref, Ref, double > &A)
template std::istream & | operator>> (std::istream &s, Matrix< General, Var, Var, double > &A)
template std::ostream & | operator<< (std::ostream &s, const Matrix< General, Var, Var, double > &A)
template std::istream & | operator>> (std::istream &s, Matrix< General, Var, Fixed< 1 >, double > &A)
template std::ostream & | operator<< (std::ostream &s, const Matrix< General, Var, Fixed< 1 >, double > &A)
template std::istream & | operator>> (std::istream &s, Matrix< General, Var, Fixed< 2 >, double > &A)
template std::ostream & | operator<< (std::ostream &s, const Matrix< General, Var, Fixed< 2 >, double > &A)
template std::istream & | operator>> (std::istream &s, Matrix< General, Var, Fixed< 3 >, double > &A)
template std::ostream & | operator<< (std::ostream &s, const Matrix< General, Var, Fixed< 3 >, double > &A)
template std::istream & | operator>> (std::istream &s, Matrix< General, Fixed< 1 >, Var, double > &A)
template std::ostream & | operator<< (std::ostream &s, const Matrix< General, Fixed< 1 >, Var, double > &A)
template std::istream & | operator>> (std::istream &s, Matrix< General, Fixed< 2 >, Var, double > &A)
template std::ostream & | operator<< (std::ostream &s, const Matrix< General, Fixed< 2 >, Var, double > &A)
template std::istream & | operator>> (std::istream &s, Matrix< General, Fixed< 3 >, Var, double > &A)
template std::ostream & | operator<< (std::ostream &s, const Matrix< General, Fixed< 3 >, Var, double > &A)
template std::istream & | operator>> (std::istream &s, Matrix< General, Fixed< 6 >, Var, double > &A)
template std::ostream & | operator<< (std::ostream &s, const Matrix< General, Fixed< 6 >, Var, double > &A)
template std::istream & | operator>> (std::istream &s, Matrix< General, Fixed< 2 >, Fixed< 1 >, double > &A)
template std::ostream & | operator<< (std::ostream &s, const Matrix< General, Fixed< 2 >, Fixed< 1 >, double > &A)
template std::istream & | operator>> (std::istream &s, Matrix< General, Fixed< 3 >, Fixed< 1 >, double > &A)
template std::ostream & | operator<< (std::ostream &s, const Matrix< General, Fixed< 3 >, Fixed< 1 >, double > &A)
template std::istream & | operator>> (std::istream &s, Matrix< General, Fixed< 4 >, Fixed< 1 >, double > &A)
template std::ostream & | operator<< (std::ostream &s, const Matrix< General, Fixed< 4 >, Fixed< 1 >, double > &A)
template std::istream & | operator>> (std::istream &s, Matrix< General, Fixed< 5 >, Fixed< 1 >, double > &A)
template std::ostream & | operator<< (std::ostream &s, const Matrix< General, Fixed< 5 >, Fixed< 1 >, double > &A)
template std::istream & | operator>> (std::istream &s, Matrix< General, Fixed< 6 >, Fixed< 1 >, double > &A)
template std::ostream & | operator<< (std::ostream &s, const Matrix< General, Fixed< 6 >, Fixed< 1 >, double > &A)
template std::istream & | operator>> (std::istream &s, Matrix< General, Fixed< 1 >, Fixed< 2 >, double > &A)
template std::ostream & | operator<< (std::ostream &s, const Matrix< General, Fixed< 1 >, Fixed< 2 >, double > &A)
template std::istream & | operator>> (std::istream &s, Matrix< General, Fixed< 1 >, Fixed< 3 >, double > &A)
template std::ostream & | operator<< (std::ostream &s, const Matrix< General, Fixed< 1 >, Fixed< 3 >, double > &A)
template std::istream & | operator>> (std::istream &s, Matrix< General, Fixed< 1 >, Fixed< 4 >, double > &A)
template std::ostream & | operator<< (std::ostream &s, const Matrix< General, Fixed< 1 >, Fixed< 4 >, double > &A)
template std::istream & | operator>> (std::istream &s, Matrix< General, Fixed< 1 >, Fixed< 5 >, double > &A)
template std::ostream & | operator<< (std::ostream &s, const Matrix< General, Fixed< 1 >, Fixed< 5 >, double > &A)
template std::istream & | operator>> (std::istream &s, Matrix< General, Fixed< 1 >, Fixed< 6 >, double > &A)
template std::ostream & | operator<< (std::ostream &s, const Matrix< General, Fixed< 1 >, Fixed< 6 >, double > &A)
template std::istream & | operator>> (std::istream &s, Matrix< General, Fixed< 2 >, Fixed< 2 >, double > &A)
template std::ostream & | operator<< (std::ostream &s, const Matrix< General, Fixed< 2 >, Fixed< 2 >, double > &A)
template std::istream & | operator>> (std::istream &s, Matrix< General, Fixed< 3 >, Fixed< 3 >, double > &A)
template std::ostream & | operator<< (std::ostream &s, const Matrix< General, Fixed< 3 >, Fixed< 3 >, double > &A)
template std::istream & | operator>> (std::istream &s, Matrix< General, Fixed< 6 >, Fixed< 6 >, double > &A)
template std::ostream & | operator<< (std::ostream &s, const Matrix< General, Fixed< 6 >, Fixed< 6 >, double > &A)
template std::istream & | operator>> (std::istream &s, Matrix< Rotation, Fixed< 3 >, Fixed< 3 >, SymbolicExpression > &A)
template std::ostream & | operator<< (std::ostream &s, const Matrix< Rotation, Fixed< 3 >, Fixed< 3 >, SymbolicExpression > &A)
template std::istream & | operator>> (std::istream &s, Matrix< Symmetric, Ref, Ref, SymbolicExpression > &A)
template std::ostream & | operator<< (std::ostream &s, const Matrix< Symmetric, Ref, Ref, SymbolicExpression > &A)
template std::ostream & | operator<< (std::ostream &s, const Matrix< Symmetric, Var, Var, SymbolicExpression > &A)
template std::istream & | operator>> (std::istream &s, Matrix< Symmetric, Fixed< 2 >, Fixed< 2 >, SymbolicExpression > &A)
template std::ostream & | operator<< (std::ostream &s, const Matrix< Symmetric, Fixed< 2 >, Fixed< 2 >, SymbolicExpression > &A)
template std::istream & | operator>> (std::istream &s, Matrix< Symmetric, Fixed< 3 >, Fixed< 3 >, SymbolicExpression > &A)
template std::ostream & | operator<< (std::ostream &s, const Matrix< Symmetric, Fixed< 3 >, Fixed< 3 >, SymbolicExpression > &A)
template std::istream & | operator>> (std::istream &s, Matrix< General, Ref, Ref, SymbolicExpression > &A)
template std::ostream & | operator<< (std::ostream &s, const Matrix< General, Ref, Ref, SymbolicExpression > &A)
template std::istream & | operator>> (std::istream &s, Matrix< General, Var, Var, SymbolicExpression > &A)
template std::ostream & | operator<< (std::ostream &s, const Matrix< General, Var, Var, SymbolicExpression > &A)
template std::istream & | operator>> (std::istream &s, Matrix< General, Var, Fixed< 1 >, SymbolicExpression > &A)
template std::ostream & | operator<< (std::ostream &s, const Matrix< General, Var, Fixed< 1 >, SymbolicExpression > &A)
template std::istream & | operator>> (std::istream &s, Matrix< General, Var, Fixed< 2 >, SymbolicExpression > &A)
template std::ostream & | operator<< (std::ostream &s, const Matrix< General, Var, Fixed< 2 >, SymbolicExpression > &A)
template std::istream & | operator>> (std::istream &s, Matrix< General, Var, Fixed< 3 >, SymbolicExpression > &A)
template std::ostream & | operator<< (std::ostream &s, const Matrix< General, Var, Fixed< 3 >, SymbolicExpression > &A)
template std::istream & | operator>> (std::istream &s, Matrix< General, Fixed< 1 >, Var, SymbolicExpression > &A)
template std::ostream & | operator<< (std::ostream &s, const Matrix< General, Fixed< 1 >, Var, SymbolicExpression > &A)
template std::istream & | operator>> (std::istream &s, Matrix< General, Fixed< 2 >, Var, SymbolicExpression > &A)
template std::ostream & | operator<< (std::ostream &s, const Matrix< General, Fixed< 2 >, Var, SymbolicExpression > &A)
template std::istream & | operator>> (std::istream &s, Matrix< General, Fixed< 3 >, Var, SymbolicExpression > &A)
template std::ostream & | operator<< (std::ostream &s, const Matrix< General, Fixed< 3 >, Var, SymbolicExpression > &A)
template std::istream & | operator>> (std::istream &s, Matrix< General, Fixed< 2 >, Fixed< 1 >, SymbolicExpression > &A)
template std::ostream & | operator<< (std::ostream &s, const Matrix< General, Fixed< 2 >, Fixed< 1 >, SymbolicExpression > &A)
template std::istream & | operator>> (std::istream &s, Matrix< General, Fixed< 3 >, Fixed< 1 >, SymbolicExpression > &A)
template std::ostream & | operator<< (std::ostream &s, const Matrix< General, Fixed< 3 >, Fixed< 1 >, SymbolicExpression > &A)
template std::istream & | operator>> (std::istream &s, Matrix< General, Fixed< 4 >, Fixed< 1 >, SymbolicExpression > &A)
template std::ostream & | operator<< (std::ostream &s, const Matrix< General, Fixed< 4 >, Fixed< 1 >, SymbolicExpression > &A)
template std::istream & | operator>> (std::istream &s, Matrix< General, Fixed< 5 >, Fixed< 1 >, SymbolicExpression > &A)
template std::ostream & | operator<< (std::ostream &s, const Matrix< General, Fixed< 5 >, Fixed< 1 >, SymbolicExpression > &A)
template std::istream & | operator>> (std::istream &s, Matrix< General, Fixed< 6 >, Fixed< 1 >, SymbolicExpression > &A)
template std::ostream & | operator<< (std::ostream &s, const Matrix< General, Fixed< 6 >, Fixed< 1 >, SymbolicExpression > &A)
template std::istream & | operator>> (std::istream &s, Matrix< General, Fixed< 1 >, Fixed< 2 >, SymbolicExpression > &A)
template std::ostream & | operator<< (std::ostream &s, const Matrix< General, Fixed< 1 >, Fixed< 2 >, SymbolicExpression > &A)
template std::istream & | operator>> (std::istream &s, Matrix< General, Fixed< 1 >, Fixed< 3 >, SymbolicExpression > &A)
template std::ostream & | operator<< (std::ostream &s, const Matrix< General, Fixed< 1 >, Fixed< 3 >, SymbolicExpression > &A)
template std::istream & | operator>> (std::istream &s, Matrix< General, Fixed< 1 >, Fixed< 4 >, SymbolicExpression > &A)
template std::ostream & | operator<< (std::ostream &s, const Matrix< General, Fixed< 1 >, Fixed< 4 >, SymbolicExpression > &A)
template std::istream & | operator>> (std::istream &s, Matrix< General, Fixed< 1 >, Fixed< 5 >, SymbolicExpression > &A)
template std::ostream & | operator<< (std::ostream &s, const Matrix< General, Fixed< 1 >, Fixed< 5 >, SymbolicExpression > &A)
template std::istream & | operator>> (std::istream &s, Matrix< General, Fixed< 1 >, Fixed< 6 >, SymbolicExpression > &A)
template std::ostream & | operator<< (std::ostream &s, const Matrix< General, Fixed< 1 >, Fixed< 6 >, SymbolicExpression > &A)
template std::istream & | operator>> (std::istream &s, Matrix< General, Fixed< 2 >, Fixed< 2 >, SymbolicExpression > &A)
template std::ostream & | operator<< (std::ostream &s, const Matrix< General, Fixed< 2 >, Fixed< 2 >, SymbolicExpression > &A)
template std::istream & | operator>> (std::istream &s, Matrix< General, Fixed< 3 >, Fixed< 3 >, SymbolicExpression > &A)
template std::ostream & | operator<< (std::ostream &s, const Matrix< General, Fixed< 3 >, Fixed< 3 >, SymbolicExpression > &A)
template std::istream & | operator>> (std::istream &s, Matrix< General, Fixed< 6 >, Fixed< 6 >, SymbolicExpression > &A)
template std::ostream & | operator<< (std::ostream &s, const Matrix< General, Fixed< 6 >, Fixed< 6 >, SymbolicExpression > &A)
template std::istream & | operator>> (std::istream &s, Matrix< Rotation, Fixed< 3 >, Fixed< 3 >, IndependentVariable > &A)
template std::ostream & | operator<< (std::ostream &s, const Matrix< Rotation, Fixed< 3 >, Fixed< 3 >, IndependentVariable > &A)
template std::istream & | operator>> (std::istream &s, Matrix< General, Ref, Ref, IndependentVariable > &A)
template std::ostream & | operator<< (std::ostream &s, const Matrix< General, Ref, Ref, IndependentVariable > &A)
template std::istream & | operator>> (std::istream &s, Matrix< General, Var, Fixed< 1 >, IndependentVariable > &A)
template std::ostream & | operator<< (std::ostream &s, const Matrix< General, Var, Fixed< 1 >, IndependentVariable > &A)
template std::istream & | operator>> (std::istream &s, Matrix< General, Fixed< 1 >, Var, IndependentVariable > &A)
template std::ostream & | operator<< (std::ostream &s, const Matrix< General, Fixed< 1 >, Var, IndependentVariable > &A)
template std::istream & | operator>> (std::istream &s, Matrix< General, Fixed< 2 >, Fixed< 1 >, IndependentVariable > &A)
template std::ostream & | operator<< (std::ostream &s, const Matrix< General, Fixed< 2 >, Fixed< 1 >, IndependentVariable > &A)
template std::istream & | operator>> (std::istream &s, Matrix< General, Fixed< 3 >, Fixed< 1 >, IndependentVariable > &A)
template std::ostream & | operator<< (std::ostream &s, const Matrix< General, Fixed< 3 >, Fixed< 1 >, IndependentVariable > &A)
template std::istream & | operator>> (std::istream &s, Matrix< General, Fixed< 4 >, Fixed< 1 >, IndependentVariable > &A)
template std::ostream & | operator<< (std::ostream &s, const Matrix< General, Fixed< 4 >, Fixed< 1 >, IndependentVariable > &A)
template std::istream & | operator>> (std::istream &s, Matrix< General, Fixed< 5 >, Fixed< 1 >, IndependentVariable > &A)
template std::ostream & | operator<< (std::ostream &s, const Matrix< General, Fixed< 5 >, Fixed< 1 >, IndependentVariable > &A)
template std::istream & | operator>> (std::istream &s, Matrix< General, Fixed< 6 >, Fixed< 1 >, IndependentVariable > &A)
template std::ostream & | operator<< (std::ostream &s, const Matrix< General, Fixed< 6 >, Fixed< 1 >, IndependentVariable > &A)
template std::istream & | operator>> (std::istream &s, Matrix< General, Fixed< 1 >, Fixed< 2 >, IndependentVariable > &A)
template std::ostream & | operator<< (std::ostream &s, const Matrix< General, Fixed< 1 >, Fixed< 2 >, IndependentVariable > &A)
template std::istream & | operator>> (std::istream &s, Matrix< General, Fixed< 1 >, Fixed< 3 >, IndependentVariable > &A)
template std::ostream & | operator<< (std::ostream &s, const Matrix< General, Fixed< 1 >, Fixed< 3 >, IndependentVariable > &A)
template std::istream & | operator>> (std::istream &s, Matrix< General, Fixed< 1 >, Fixed< 4 >, IndependentVariable > &A)
template std::ostream & | operator<< (std::ostream &s, const Matrix< General, Fixed< 1 >, Fixed< 4 >, IndependentVariable > &A)
template std::istream & | operator>> (std::istream &s, Matrix< General, Fixed< 1 >, Fixed< 5 >, IndependentVariable > &A)
template std::ostream & | operator<< (std::ostream &s, const Matrix< General, Fixed< 1 >, Fixed< 5 >, IndependentVariable > &A)
template std::istream & | operator>> (std::istream &s, Matrix< General, Fixed< 1 >, Fixed< 6 >, IndependentVariable > &A)
template std::ostream & | operator<< (std::ostream &s, const Matrix< General, Fixed< 1 >, Fixed< 6 >, IndependentVariable > &A)
template std::istream & | operator>> (std::istream &s, Matrix< Diagonal, Ref, Ref, double > &A)
template std::ostream & | operator<< (std::ostream &s, const Matrix< Diagonal, Ref, Ref, double > &A)
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 &os, const Matrix< Type, Row, Col, AT > &A)
| Matrix output. More...
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< typename std::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< typename std::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< typename std::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< typename std::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

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, 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.

## ◆ eigval() [2/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.

## ◆ 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< 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() [2/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.

## ◆ eigvec() [3/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

## ◆ 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 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.

## ◆ 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 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.

## ◆ 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 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.

## ◆ nrm1() [2/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.

## ◆ nrm2() [1/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.

## ◆ nrm2() [2/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.

## ◆ 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 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.

## ◆ nrmInf() [2/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() [3/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.

## ◆ 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 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*() [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 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*() [4/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*() [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 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-() [1/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-() [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 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<<()

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]

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==() [2/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>>()

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 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.

## ◆ rho() [2/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.

## ◆ 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 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.

## ◆ slvLL() [2/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.

## ◆ slvLU() [1/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() [2/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.

## ◆ slvLU() [3/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() [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]

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.

## ◆ 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 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.

## ◆ slvQRLQ() [2/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.

## ◆ 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 ArgS >

ReplaceAT<typename std::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.

## ◆ symbolicFunc() [2/2]

template<class Func , class Arg1S , class Arg2S >

ReplaceAT<typename std::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.

## ◆ tilde() [1/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} \]

## ◆ tilde() [2/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)

## ◆ toString() [1/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.

## ◆ 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<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.

## ◆ trans() [1/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.

## ◆ 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 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() [4/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.

## ◆ 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.