MechSys  1.0
Computing library for simulations in continuum and discrete mechanics
Classes | Functions
LinAlg Namespace Reference

Linear algebra routines. More...

Classes

class  expression
class  exp_un
class  exp_bin
class  exp_ter
struct  res_type
struct  res_type< t_exp, exp_un< typename t_exp::T_exp1, typename t_exp::T_op, typename t_exp::T_res > >
struct  res_type< t_exp, exp_bin< typename t_exp::T_exp1, typename t_exp::T_exp2, typename t_exp::T_op, typename t_exp::T_res > >
class  op_add
class  op_minus
class  op_minus_un
class  op_prod
class  op_prod_sc
class  op_div_sc
class  op_trn
class  op_oto
class  op_oot
class  op_otot
class  Matrix
class  Vector

Functions

double Dot (Vector< double > const &X, Vector< double > const &Y)
 internal product: $ s \gets \{X\} \bullet \{Y\} $
void Gemv (double const a, Matrix< double > const &A, Vector< double > const &X, double const b, Vector< double > &Y)
 GEneral matrix * vector: $ \{Y\} \gets \alpha[A]\{X\} + \beta\{Y\} $.
void Gemm (double const a, Matrix< double > const &A, Matrix< double > const &B, double const b, Matrix< double > &C)
 GEneral matrix x matrix: $ [C] \gets \alpha[A][B] + \beta[C] $.
void Gemtm (double const a, Matrix< double > const &A, Matrix< double > const &B, double const b, Matrix< double > &C)
 GEneral matrix^T x matrix: $ [C] \gets \alpha[A]^T[B] + \beta[C] $.
void Gemmt (double const a, Matrix< double > const &A, Matrix< double > const &B, double const b, Matrix< double > &C)
 GEneral matrix x matrix^T: $ [C] \gets \alpha[A][B]^T+ \beta[C] $.
void Gemtmt (double const a, Matrix< double > const &A, Matrix< double > const &B, double const b, Matrix< double > &C)
 GEneral matrix^T x matrix^T: $ [C] \gets \alpha[A]^T[B]^T + \beta[C] $.
template<typename type >
void _scale (size_t n, type a, type const *ptrX, type *ptrY)
template<typename type >
void _scale (size_t n, type a, type const *ptrX, type b, type const *ptrW, type *ptrY)
template<typename type >
void scale (type a, Vector< type > const &X, Vector< type > &Y)
template<typename type >
void scale (type a, Vector< type > const &X, type b, Vector< type > const &W, Vector< type > &Y)
template<typename type >
void scale (type a, Matrix< type > const &X, Matrix< type > &Y)
template<typename type >
void scale (type a, Matrix< type > const &X, type b, Matrix< type > const &W, Matrix< type > &Y)
template<typename type >
void scalet (type a, Vector< type > const &A, Matrix< type > &B)
template<typename type >
void scalet (type a, Matrix< type > const &A, Matrix< type > &B)
template<typename type >
Vector< type > & _add (Vector< type > const &A, Vector< type > const &B, Vector< type > &R)
template<typename type >
Vector< type > & _minus (Vector< type > const &A, Vector< type > const &B, Vector< type > &R)
template<class type , class t_num1 >
Vector< type > & _prod (t_num1 const &a, Vector< type > const &A, Vector< type > &R)
template<typename type >
Matrix< type > & _trn (Vector< type > const &A, Matrix< type > &R)
template<typename type >
Matrix< type > & _add (Matrix< type > const &A, Matrix< type > const &B, Matrix< type > &R)
template<typename type >
Matrix< type > & _minus (Matrix< type > const &A, Matrix< type > const &B, Matrix< type > &R)
template<class type >
Vector< type > & _prod (Matrix< type > const &A, Vector< type > const &B, Vector< type > &R)
template<class type >
Matrix< type > & _prod (Vector< type > const &A, Matrix< type > const &B, Matrix< type > &R)
template<class type >
Matrix< type > & _prod (Matrix< type > const &A, Matrix< type > const &B, Matrix< type > &R)
template<class type , class t_scalar >
Matrix< type > & _prod (t_scalar const &A, Matrix< type > const &B, Matrix< type > &R)
template<typename type >
Matrix< type > & _trn (Matrix< type > const &A, Matrix< type > &R)
template<class type >
Matrix< type > & _prodt (Matrix< type > const &A, Matrix< type > const &B, Matrix< type > &R)
template<class type >
Matrix< type > & _prod_t (Matrix< type > const &A, Matrix< type > const &B, Matrix< type > &R)
template<class type >
Matrix< type > & _prod_t (Vector< type > const &A, Vector< type > const &B, Matrix< type > &R)
template<class type >
type & _prodt (Vector< type > const &A, Vector< type > const &B, type &R)
template<class type >
Matrix< type > & _prodtt (Matrix< type > const &A, Matrix< type > const &B, Matrix< type > &R)
template<class t_exp , class t_res >
std::ostream & operator<< (std::ostream &os, expression< t_exp, t_res > const &expr)
template<class t_exp , class t_res >
exp_un< t_exp, op_minus_un, t_res > operator- (expression< t_exp, t_res > const &A)
template<class t_exp , class t_res >
expression< t_exp, t_res > operator+ (expression< t_exp, t_res > const &A)
template<class t_obj , class t_exp1 >
exp_bin< t_exp1, t_obj, op_add,
t_obj > 		operator+ (expression< t_exp1, t_obj > const &A, t_obj const &B)
template<class t_obj , class t_exp1 >
exp_bin< t_obj, t_exp1, op_add,
t_obj > 		operator+ (t_obj const &A, expression< t_exp1, t_obj > const &B)
template<class t_obj , class t_exp1 , class t_exp2 >
exp_bin< t_exp1, t_exp2,
op_add, t_obj > 		operator+ (expression< t_exp1, t_obj > const &A, expression< t_exp2, t_obj > const &B)
template<class t_obj , class t_exp1 , class t_exp2 >
exp_bin< t_exp1, t_exp2,
op_minus, t_obj > 		operator- (expression< t_exp1, t_obj > const &A, expression< t_exp2, t_obj > const &B)
template<class t_obj , class t_exp1 >
exp_bin< t_exp1, t_obj,
op_minus, t_obj > 		operator- (expression< t_exp1, t_obj > const &A, t_obj const &B)
template<class t_obj , class t_exp1 >
exp_bin< t_obj, t_exp1,
op_minus, t_obj > 		operator- (t_obj const &A, expression< t_exp1, t_obj > const &B)
 DECLARE_OP_WITH_SCALAR (EXPR_MULT_SCALAR)
 DECLARE_OP_WITH_SCALAR (EXPR_DIV_SCALAR)
template<class type >
exp_un< Vector< type >
, op_minus_un, Vector< type > > 		operator- (Vector< type > const &A)
template<class type >
Vector< type > operator+ (Vector< type > const &A)
template<typename type >
exp_bin< Vector< type >
, Vector< type >, op_add,
Vector< type > > 		operator+ (Vector< type > const &A, Vector< type > const &B)
template<typename type >
exp_bin< Vector< type >
, Vector< type >, op_minus,
Vector< type > > 		operator- (Vector< type > const &A, Vector< type > const &B)
template<typename type >
exp_un< Vector< type >, op_trn,
Matrix< type > > 		trn (Vector< type > const &A)
template<class type , class t_exp1 >
exp_un< t_exp1, op_trn, Matrix
< type > > 		trn (expression< t_exp1, Vector< type > > const &A)
 DECLARE_OP_WITH_SCALAR (VECTOR_MULT_SCALAR)
 DECLARE_OP_WITH_SCALAR (VECTOR_DIV_SCALAR)
template<class type >
exp_un< Matrix< type >
, op_minus_un, Matrix< type > > 		operator- (Matrix< type > const &A)
template<class type >
Matrix< type > operator+ (Matrix< type > const &A)
template<typename type >
exp_bin< Matrix< type >
, Matrix< type >, op_add,
Matrix< type > > 		operator+ (Matrix< type > const &A, Matrix< type > const &B)
template<typename type >
exp_bin< Matrix< type >
, Matrix< type >, op_minus,
Matrix< type > > 		operator- (Matrix< type > const &A, Matrix< type > const &B)
template<typename type >
exp_bin< Matrix< type >
, Matrix< type >, op_prod,
Matrix< type > > 		operator* (Matrix< type > const &A, Matrix< type > const &B)
template<typename type >
exp_un< Matrix< type >, op_trn,
Matrix< type > > 		trn (Matrix< type > const &A)
template<class type , class t_exp1 >
exp_un< t_exp1, op_trn, Matrix
< type > > 		trn (expression< t_exp1, Matrix< type > > const &A)
template<typename type >
exp_un< Matrix< type >, op_trn,
Matrix< type > > 		trans (Matrix< type > const &A)
template<class type , class t_exp1 >
exp_un< t_exp1, op_trn, Matrix
< type > > 		trans (expression< t_exp1, Matrix< type > > const &A)
 DECLARE_OP_WITH_SCALAR (MATRIX_MULT_SCALAR)
 DECLARE_OP_WITH_SCALAR (MATRIX_DIV_SCALAR)
template<class type >
exp_bin< Vector< type >
, Matrix< type >, op_prod,
Matrix< type > > 		operator* (Vector< type > const &A, Matrix< type > const &B)
template<typename type >
exp_bin< Matrix< type >
, Vector< type >, op_prod,
Vector< type > > 		operator* (Matrix< type > const &A, Vector< type > const &B)
template<class type , class t_exp1 >
exp_bin< t_exp1, Vector< type >
, op_prod, Vector< type > > 		operator* (expression< t_exp1, Matrix< type > > const &A, Vector< type > const &B)
template<class type , class t_exp1 >
exp_bin< t_exp1, Matrix< type >
, op_prod, Matrix< type > > 		operator* (expression< t_exp1, Matrix< type > > const &A, Matrix< type > const &B)
template<class type , class t_exp1 >
exp_bin< Matrix< type >
, t_exp1, op_prod, Matrix
< type > > 		operator* (Matrix< type > const &A, expression< t_exp1, Matrix< type > > const &B)
template<class type , class t_exp1 , class t_exp2 >
exp_bin< t_exp1, t_exp2,
op_prod, Matrix< type > > 		operator* (expression< t_exp1, Matrix< type > > const &A, expression< t_exp2, Matrix< type > > const &B)
template<class type , class t_exp1 , class t_exp2 >
exp_bin< t_exp1, t_exp2,
op_prod, Vector< type > > 		operator* (expression< t_exp1, Matrix< type > > const &A, expression< t_exp2, Vector< type > > const &B)
template<class type , class t_exp1 , class t_exp2 >
exp_bin< t_exp1, t_exp2,
op_prod, Matrix< type > > 		operator* (expression< t_exp1, Vector< type > > const &A, expression< t_exp2, Matrix< type > > const &B)
template<class type >
exp_bin< Vector< type >
, Vector< type >, op_oto, type > 		operator* (exp_un< Vector< type >, op_trn, Matrix< type > > const &A, Vector< type > const &B)
template<class type >
exp_bin< Vector< type >
, Vector< type >, op_oot,
Matrix< type > > 		operator* (Vector< type > const &A, exp_un< Vector< type >, op_trn, Matrix< type > > const &B)
template<class type >
exp_bin< Matrix< type >
, Matrix< type >, op_oto,
Matrix< type > > 		operator* (exp_un< Matrix< type >, op_trn, Matrix< type > > const &A, Matrix< type > const &B)
template<class type >
exp_bin< Matrix< type >
, Matrix< type >, op_oot,
Matrix< type > > 		operator* (Matrix< type > const &A, exp_un< Matrix< type >, op_trn, Matrix< type > > const &B)
template<class type >
exp_bin< Matrix< type >
, Matrix< type >, op_otot,
Matrix< type > > 		operator* (exp_un< Matrix< type >, op_trn, Matrix< type > > const &A, exp_un< Matrix< type >, op_trn, Matrix< type > > const &B)
template<typename Value_T >
std::ostream & operator<< (std::ostream &os, const Matrix< Value_T > &M)
template<typename Value_T >
std::ostream & operator<< (std::ostream &os, const LinAlg::Vector< Value_T > &V)

Detailed Description

Linear algebra routines.

Function Documentation

template<typename type >
Vector<type>& LinAlg::_add ( Vector< type > const &  A,
Vector< type > const &  B,
Vector< type > &  R 
) [inline]
template<typename type >
Matrix<type>& LinAlg::_add ( Matrix< type > const &  A,
Matrix< type > const &  B,
Matrix< type > &  R 
) [inline]
template<typename type >
Vector<type>& LinAlg::_minus ( Vector< type > const &  A,
Vector< type > const &  B,
Vector< type > &  R 
) [inline]
template<typename type >
Matrix<type>& LinAlg::_minus ( Matrix< type > const &  A,
Matrix< type > const &  B,
Matrix< type > &  R 
) [inline]
template<class type , class t_num1 >
Vector<type>& LinAlg::_prod ( t_num1 const &  a,
Vector< type > const &  A,
Vector< type > &  R 
) [inline]
template<class type >
Vector<type>& LinAlg::_prod ( Matrix< type > const &  A,
Vector< type > const &  B,
Vector< type > &  R 
) [inline]
template<class type >
Matrix<type>& LinAlg::_prod ( Vector< type > const &  A,
Matrix< type > const &  B,
Matrix< type > &  R 
) [inline]
template<class type >
Matrix<type>& LinAlg::_prod ( Matrix< type > const &  A,
Matrix< type > const &  B,
Matrix< type > &  R 
) [inline]
template<class type , class t_scalar >
Matrix<type>& LinAlg::_prod ( t_scalar const &  A,
Matrix< type > const &  B,
Matrix< type > &  R 
) [inline]
template<class type >
Matrix<type>& LinAlg::_prod_t ( Matrix< type > const &  A,
Matrix< type > const &  B,
Matrix< type > &  R 
) [inline]
template<class type >
Matrix<type>& LinAlg::_prod_t ( Vector< type > const &  A,
Vector< type > const &  B,
Matrix< type > &  R 
) [inline]
template<class type >
Matrix<type>& LinAlg::_prodt ( Matrix< type > const &  A,
Matrix< type > const &  B,
Matrix< type > &  R 
) [inline]
template<class type >
type& LinAlg::_prodt ( Vector< type > const &  A,
Vector< type > const &  B,
type &  R 
) [inline]
template<class type >
Matrix<type>& LinAlg::_prodtt ( Matrix< type > const &  A,
Matrix< type > const &  B,
Matrix< type > &  R 
) [inline]
template<typename type >
void LinAlg::_scale ( size_t  n,
type  a,
type const *  ptrX,
type *  ptrY 
) [inline]
template<typename type >
void LinAlg::_scale ( size_t  n,
type  a,
type const *  ptrX,
type  b,
type const *  ptrW,
type *  ptrY 
) [inline]
template<typename type >
Matrix<type>& LinAlg::_trn ( Vector< type > const &  A,
Matrix< type > &  R 
) [inline]
template<typename type >
Matrix<type>& LinAlg::_trn ( Matrix< type > const &  A,
Matrix< type > &  R 
) [inline]
LinAlg::DECLARE_OP_WITH_SCALAR ( EXPR_MULT_SCALAR  )
LinAlg::DECLARE_OP_WITH_SCALAR ( EXPR_DIV_SCALAR  )
LinAlg::DECLARE_OP_WITH_SCALAR ( VECTOR_MULT_SCALAR  )
LinAlg::DECLARE_OP_WITH_SCALAR ( VECTOR_DIV_SCALAR  )
LinAlg::DECLARE_OP_WITH_SCALAR ( MATRIX_MULT_SCALAR  )
LinAlg::DECLARE_OP_WITH_SCALAR ( MATRIX_DIV_SCALAR  )
double LinAlg::Dot ( Vector< double > const &  X,
Vector< double > const &  Y 
) [inline]

internal product: $ s \gets \{X\} \bullet \{Y\} $

void LinAlg::Gemm ( double const  a,
Matrix< double > const &  A,
Matrix< double > const &  B,
double const  b,
Matrix< double > &  C 
) [inline]

GEneral matrix x matrix: $ [C] \gets \alpha[A][B] + \beta[C] $.

void LinAlg::Gemmt ( double const  a,
Matrix< double > const &  A,
Matrix< double > const &  B,
double const  b,
Matrix< double > &  C 
) [inline]

GEneral matrix x matrix^T: $ [C] \gets \alpha[A][B]^T+ \beta[C] $.

void LinAlg::Gemtm ( double const  a,
Matrix< double > const &  A,
Matrix< double > const &  B,
double const  b,
Matrix< double > &  C 
) [inline]

GEneral matrix^T x matrix: $ [C] \gets \alpha[A]^T[B] + \beta[C] $.

void LinAlg::Gemtmt ( double const  a,
Matrix< double > const &  A,
Matrix< double > const &  B,
double const  b,
Matrix< double > &  C 
) [inline]

GEneral matrix^T x matrix^T: $ [C] \gets \alpha[A]^T[B]^T + \beta[C] $.

void LinAlg::Gemv ( double const  a,
Matrix< double > const &  A,
Vector< double > const &  X,
double const  b,
Vector< double > &  Y 
) [inline]

GEneral matrix * vector: $ \{Y\} \gets \alpha[A]\{X\} + \beta\{Y\} $.

template<typename type >
exp_bin<Matrix<type>, Matrix<type>, op_prod, Matrix<type> > LinAlg::operator* ( Matrix< type > const &  A,
Matrix< type > const &  B 
) [inline]
template<class type >
exp_bin<Vector<type>, Matrix<type>, op_prod, Matrix<type> > LinAlg::operator* ( Vector< type > const &  A,
Matrix< type > const &  B 
) [inline]
template<typename type >
exp_bin<Matrix<type>, Vector<type>, op_prod, Vector<type> > LinAlg::operator* ( Matrix< type > const &  A,
Vector< type > const &  B 
) [inline]
template<class type , class t_exp1 >
exp_bin< t_exp1, Vector<type>, op_prod, Vector<type> > LinAlg::operator* ( expression< t_exp1, Matrix< type > > const &  A,
Vector< type > const &  B 
) [inline]
template<class type , class t_exp1 >
exp_bin< t_exp1, Matrix<type>, op_prod, Matrix<type> > LinAlg::operator* ( expression< t_exp1, Matrix< type > > const &  A,
Matrix< type > const &  B 
) [inline]
template<class type , class t_exp1 >
exp_bin<Matrix<type>, t_exp1, op_prod, Matrix<type> > LinAlg::operator* ( Matrix< type > const &  A,
expression< t_exp1, Matrix< type > > const &  B 
) [inline]
template<class type , class t_exp1 , class t_exp2 >
exp_bin< t_exp1, t_exp2, op_prod, Matrix<type> > LinAlg::operator* ( expression< t_exp1, Matrix< type > > const &  A,
expression< t_exp2, Matrix< type > > const &  B 
) [inline]
template<class type , class t_exp1 , class t_exp2 >
exp_bin< t_exp1, t_exp2, op_prod, Vector<type> > LinAlg::operator* ( expression< t_exp1, Matrix< type > > const &  A,
expression< t_exp2, Vector< type > > const &  B 
) [inline]
template<class type , class t_exp1 , class t_exp2 >
exp_bin< t_exp1, t_exp2, op_prod, Matrix<type> > LinAlg::operator* ( expression< t_exp1, Vector< type > > const &  A,
expression< t_exp2, Matrix< type > > const &  B 
) [inline]
template<class type >
exp_bin<Vector<type>, Vector<type>, op_oto, type > LinAlg::operator* ( exp_un< Vector< type >, op_trn, Matrix< type > > const &  A,
Vector< type > const &  B 
) [inline]
template<class type >
exp_bin<Vector<type>,Vector<type>, op_oot, Matrix<type> > LinAlg::operator* ( Vector< type > const &  A,
exp_un< Vector< type >, op_trn, Matrix< type > > const &  B 
) [inline]
template<class type >
exp_bin<Matrix<type>, Matrix<type>, op_oto, Matrix<type> > LinAlg::operator* ( exp_un< Matrix< type >, op_trn, Matrix< type > > const &  A,
Matrix< type > const &  B 
) [inline]
template<class type >
exp_bin<Matrix<type>, Matrix<type>, op_oot, Matrix<type> > LinAlg::operator* ( Matrix< type > const &  A,
exp_un< Matrix< type >, op_trn, Matrix< type > > const &  B 
) [inline]
template<class type >
exp_bin<Matrix<type>, Matrix<type>, op_otot, Matrix<type> > LinAlg::operator* ( exp_un< Matrix< type >, op_trn, Matrix< type > > const &  A,
exp_un< Matrix< type >, op_trn, Matrix< type > > const &  B 
) [inline]
template<class t_exp , class t_res >
expression<t_exp, t_res> LinAlg::operator+ ( expression< t_exp, t_res > const &  A) [inline]
template<class t_obj , class t_exp1 >
exp_bin< t_exp1, t_obj, op_add, t_obj > LinAlg::operator+ ( expression< t_exp1, t_obj > const &  A,
t_obj const &  B 
) [inline]
template<class t_obj , class t_exp1 >
exp_bin< t_obj, t_exp1, op_add, t_obj > LinAlg::operator+ ( t_obj const &  A,
expression< t_exp1, t_obj > const &  B 
) [inline]
template<class t_obj , class t_exp1 , class t_exp2 >
exp_bin< t_exp1, t_exp2, op_add, t_obj > LinAlg::operator+ ( expression< t_exp1, t_obj > const &  A,
expression< t_exp2, t_obj > const &  B 
) [inline]
template<class type >
Vector<type> LinAlg::operator+ ( Vector< type > const &  A) [inline]
template<typename type >
exp_bin<Vector<type>, Vector<type>, op_add, Vector<type> > LinAlg::operator+ ( Vector< type > const &  A,
Vector< type > const &  B 
) [inline]
template<class type >
Matrix<type> LinAlg::operator+ ( Matrix< type > const &  A) [inline]
template<typename type >
exp_bin<Matrix<type>, Matrix<type>, op_add, Matrix<type> > LinAlg::operator+ ( Matrix< type > const &  A,
Matrix< type > const &  B 
) [inline]
template<class t_exp , class t_res >
exp_un< t_exp, op_minus_un, t_res > LinAlg::operator- ( expression< t_exp, t_res > const &  A) [inline]
template<class t_obj , class t_exp1 , class t_exp2 >
exp_bin< t_exp1, t_exp2, op_minus, t_obj > LinAlg::operator- ( expression< t_exp1, t_obj > const &  A,
expression< t_exp2, t_obj > const &  B 
) [inline]
template<class t_obj , class t_exp1 >
exp_bin< t_exp1, t_obj, op_minus, t_obj > LinAlg::operator- ( expression< t_exp1, t_obj > const &  A,
t_obj const &  B 
) [inline]
template<class t_obj , class t_exp1 >
exp_bin< t_obj, t_exp1, op_minus, t_obj > LinAlg::operator- ( t_obj const &  A,
expression< t_exp1, t_obj > const &  B 
) [inline]
template<class type >
exp_un< Vector<type>, op_minus_un, Vector<type> > LinAlg::operator- ( Vector< type > const &  A) [inline]
template<typename type >
exp_bin<Vector<type>, Vector<type>, op_minus, Vector<type> > LinAlg::operator- ( Vector< type > const &  A,
Vector< type > const &  B 
) [inline]
template<class type >
exp_un< Matrix<type>, op_minus_un, Matrix<type> > LinAlg::operator- ( Matrix< type > const &  A) [inline]
template<typename type >
exp_bin<Matrix<type>, Matrix<type>, op_minus, Matrix<type> > LinAlg::operator- ( Matrix< type > const &  A,
Matrix< type > const &  B 
) [inline]
template<typename Value_T >
std::ostream& LinAlg::operator<< ( std::ostream &  os,
const LinAlg::Vector< Value_T > &  V 
)

Outputs a vector.

template<typename Value_T >
std::ostream& LinAlg::operator<< ( std::ostream &  os,
const Matrix< Value_T > &  M 
)

Outputs a dense matrix.

template<class t_exp , class t_res >
std::ostream& LinAlg::operator<< ( std::ostream &  os,
expression< t_exp, t_res > const &  expr 
)
template<typename type >
void LinAlg::scale ( type  a,
Vector< type > const &  X,
Vector< type > &  Y 
) [inline]
template<typename type >
void LinAlg::scale ( type  a,
Vector< type > const &  X,
type  b,
Vector< type > const &  W,
Vector< type > &  Y 
) [inline]
template<typename type >
void LinAlg::scale ( type  a,
Matrix< type > const &  X,
Matrix< type > &  Y 
) [inline]
template<typename type >
void LinAlg::scale ( type  a,
Matrix< type > const &  X,
type  b,
Matrix< type > const &  W,
Matrix< type > &  Y 
) [inline]
template<typename type >
void LinAlg::scalet ( type  a,
Vector< type > const &  A,
Matrix< type > &  B 
) [inline]
template<typename type >
void LinAlg::scalet ( type  a,
Matrix< type > const &  A,
Matrix< type > &  B 
) [inline]
template<typename type >
exp_un<Matrix<type>, op_trn, Matrix<type> > LinAlg::trans ( Matrix< type > const &  A) [inline]
template<class type , class t_exp1 >
exp_un< t_exp1, op_trn, Matrix<type> > LinAlg::trans ( expression< t_exp1, Matrix< type > > const &  A) [inline]
template<typename type >
exp_un<Vector<type>, op_trn, Matrix<type> > LinAlg::trn ( Vector< type > const &  A) [inline]
template<class type , class t_exp1 >
exp_un< t_exp1, op_trn, Matrix<type> > LinAlg::trn ( expression< t_exp1, Vector< type > > const &  A) [inline]
template<typename type >
exp_un<Matrix<type>, op_trn, Matrix<type> > LinAlg::trn ( Matrix< type > const &  A) [inline]
template<class type , class t_exp1 >
exp_un< t_exp1, op_trn, Matrix<type> > LinAlg::trn ( expression< t_exp1, Matrix< type > > const &  A) [inline]
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Defines
Generated on Mon Mar 5 2012 14:27:32 for MechSys by   doxygen 1.7.6.1