Mat.h File Reference

Contain the class Mat, Vec, and the associated operators. More...

#include <iterator>
#include <sstream>
#include <iostream>
#include <algorithm>
#include "PlatformSpec.h"
#include "Config.h"
#include "ErrorCheck.h"
#include "TypeTraits.h"
#include "Commainit.h"
#include "Assignment.h"
#include "SIMD/SIMD.h"

Go to the source code of this file.

Namespaces

namespace  exmat
namespace  exmat::PNS

Classes

struct  exmat::ConstErrChkedRow< MAT >
 The ConstErrChkedRow class. More...
struct  exmat::ErrChkedRow< MAT >
 The ErrChkedRow class. More...
class  exmat::Mat< Rep, ErrChecker_ >
 The Mat matrix class. More...
class  exmat::Vec< Rep, ErrChecker_ >
 The Vec vector class. More...

Addition

template<class L, class R, class LC, class RC>
static const exmat::Mat< exmat::ExpMat<
typename exmat::AddExp< typename
L::rep_type, typename R::rep_type
>::rep_type >, typename exmat::ResultantChecker<
LC, RC >::RET > 
operator+ (const exmat::Mat< L, LC > &A, const exmat::Mat< R, RC > &B)
 Addition of two Mat.
template<class L, class R, class LC, class RC>
static const exmat::Vec< exmat::ExpMat<
typename exmat::AddExp< typename
L::rep_type, typename R::rep_type
>::rep_type >, typename exmat::ResultantChecker<
LC, RC >::RET > 
operator+ (const exmat::Vec< L, LC > &A, const exmat::Vec< R, RC > &B)
 Addition of two Vec.
template<class L, class EC>
static const exmat::Mat< exmat::ExpMat<
typename exmat::AddExp< typename
L::rep_type, exmat::ScalarCon<
typename L::value_type
> >::rep_type >, EC > 
operator+ (const exmat::Mat< L, EC > &A, typename L::const_param_type scalar)
 Mat add scalar.
template<class L, class EC>
static const exmat::Mat< exmat::ExpMat<
typename exmat::AddExp< exmat::ScalarCon<
typename L::value_type >,
typename L::rep_type >::rep_type >,
EC > 
operator+ (typename L::const_param_type scalar, const exmat::Mat< L, EC > &A)
 scalar add Mat
template<class L, class EC>
static const exmat::Vec< exmat::ExpMat<
typename exmat::AddExp< typename
L::rep_type, exmat::ScalarCon<
typename L::value_type
> >::rep_type >, EC > 
operator+ (const exmat::Vec< L, EC > &A, typename L::const_param_type scalar)
 Vec add scalar.
template<class L, class EC>
static const exmat::Vec< exmat::ExpMat<
typename exmat::AddExp< exmat::ScalarCon<
typename L::value_type >,
typename L::rep_type >::rep_type >,
EC > 
operator+ (typename L::const_param_type scalar, const exmat::Vec< L, EC > &A)
 scalar add Vec

Subtraction

template<class L, class R, class LC, class RC>
static const exmat::Mat< exmat::ExpMat<
typename exmat::SubExp< typename
L::rep_type, typename R::rep_type
>::rep_type >, typename exmat::ResultantChecker<
LC, RC >::RET > 
operator- (const exmat::Mat< L, LC > &A, const exmat::Mat< R, RC > &B)
 Subtraction of two Mat.
template<class L, class R, class LC, class RC>
static const exmat::Vec< exmat::ExpMat<
typename exmat::SubExp< typename
L::rep_type, typename R::rep_type
>::rep_type >, typename exmat::ResultantChecker<
LC, RC >::RET > 
operator- (const exmat::Vec< L, LC > &A, const exmat::Vec< R, RC > &B)
 Subtraction of two Vec.
template<class L, class EC>
static const exmat::Mat< exmat::ExpMat<
typename exmat::SubExp< typename
L::rep_type, exmat::ScalarCon<
typename L::value_type
> >::rep_type >, EC > 
operator- (const exmat::Mat< L, EC > &A, typename L::const_param_type scalar)
 Mat subtract scalar.
template<class L, class EC>
static const exmat::Mat< exmat::ExpMat<
typename exmat::SubExp< exmat::ScalarCon<
typename L::value_type >,
typename L::rep_type >::rep_type >,
EC > 
operator- (typename L::const_param_type scalar, const exmat::Mat< L, EC > &A)
 scalar subtract Mat
template<class L, class EC>
static const exmat::Vec< exmat::ExpMat<
typename exmat::SubExp< typename
L::rep_type, exmat::ScalarCon<
typename L::value_type
> >::rep_type >, EC > 
operator- (const exmat::Vec< L, EC > &A, typename L::const_param_type scalar)
 Vec subtract scalar.
template<class L, class EC>
static const exmat::Vec< exmat::ExpMat<
typename exmat::SubExp< exmat::ScalarCon<
typename L::value_type >,
typename L::rep_type >::rep_type >,
EC > 
operator- (typename L::const_param_type scalar, const exmat::Vec< L, EC > &A)
 scalar subtract Vec

Multiplication

template<class L, class R, class LC, class RC>
static const exmat::Mat< exmat::ExpMat<
typename exmat::MulExp< typename
L::rep_type, typename R::rep_type
>::rep_type >, typename exmat::ResultantChecker<
LC, RC >::RET > 
operator * (const exmat::Mat< L, LC > &A, const exmat::Mat< R, RC > &B)
 Multiplication of two Mat.
template<class L, class EC>
static const exmat::Mat< exmat::ExpMat<
typename exmat::ScalarMulExp<
typename L::rep_type, exmat::ScalarCon<
typename L::value_type
> >::rep_type >, EC > 
operator * (const exmat::Mat< L, EC > &A, typename L::const_param_type scalar)
 Multiplication of Mat with scalar.
template<class L, class EC>
static const exmat::Mat< exmat::ExpMat<
typename exmat::ScalarMulExp<
exmat::ScalarCon< typename
L::value_type >, typename
L::rep_type >::rep_type >,
EC > 
operator * (typename L::const_param_type scalar, const exmat::Mat< L, EC > &A)
 Multiplication of scalar with Mat.
template<class L, class R, class LC, class RC>
static const exmat::Vec< exmat::ExpMat<
typename exmat::MulExp< typename
L::rep_type, typename R::rep_type
>::rep_type >, typename exmat::ResultantChecker<
LC, RC >::RET > 
operator * (const exmat::Vec< L, LC > &A, const exmat::Vec< R, RC > &B)
 Multiplication of two Vec.
template<class L, class R, class LC, class RC>
static const exmat::Vec< exmat::ExpMat<
typename exmat::MulExp< typename
L::rep_type, typename R::rep_type
>::rep_type >, typename exmat::ResultantChecker<
LC, RC >::RET > 
operator * (const exmat::Mat< L, LC > &A, const exmat::Vec< R, RC > &B)
 Multiplication of Mat with column Vec.
template<class L, class R, class LC, class RC>
static const exmat::Vec< exmat::ExpMat<
typename exmat::MulExp< typename
L::rep_type, typename R::rep_type
>::rep_type >, typename exmat::ResultantChecker<
LC, RC >::RET > 
operator * (const exmat::Vec< L, LC > &A, const exmat::Mat< R, RC > &B)
 Multiplication of column Vec with Mat.
template<class L, class EC>
static const exmat::Vec< exmat::ExpMat<
typename exmat::ScalarMulExp<
typename L::rep_type, exmat::ScalarCon<
typename L::value_type
> >::rep_type >, EC > 
operator * (const exmat::Vec< L, EC > &A, typename L::const_param_type scalar)
 Multiplication of Vec with scalar.
template<class L, class EC>
static const exmat::Vec< exmat::ExpMat<
typename exmat::ScalarMulExp<
exmat::ScalarCon< typename
L::value_type >, typename
L::rep_type >::rep_type >,
EC > 
operator * (typename L::const_param_type scalar, const exmat::Vec< L, EC > &A)
 Multiplication of scalar with Vec.

Division

template<class L, class EC>
static const exmat::Mat< exmat::ExpMat<
typename exmat::ScalarDivExp<
typename L::rep_type, exmat::ScalarCon<
typename L::value_type
> >::rep_type >, EC > 
operator/ (const exmat::Mat< L, EC > &A, typename L::const_param_type scalar)
 Division of a Mat with a scalar.
template<class L, class EC>
static const exmat::Vec< exmat::ExpMat<
typename exmat::ScalarDivExp<
typename L::rep_type, exmat::ScalarCon<
typename L::value_type
> >::rep_type >, EC > 
operator/ (const exmat::Vec< L, EC > &A, typename L::const_param_type scalar)
 Division of a Vectors with a scalar.

Defines

#define Mak_Op(LT, RT, OT, op, OpName)
 Macro to create operators for 2 Mat.
#define Mak_ScalarOp1(OT, op, OpName)
 Macro to create operators for Mat and scalar.
#define Mak_ScalarOp2(OT, op, OpName)
 Macro to create operators for scalar and Mat.
#define EXMAT_DERIVEDCLASS_IMP(NAME, MatOrVec)
#define EXMAT_DERIVEDCLASS_Mak_Op(LT, RT, OT, op, OpName)
 Macro that inserting operator functions.
#define EXMAT_DERIVEDCLASS_DEFALUTOPS(ClassName, MatOrVec)
 Create all the default (self and scalar + - * /) operators.

Functions

template<class Rep, class ErrChecker>
std::istream & operator>> (std::istream &is, exmat::Mat< Rep, ErrChecker > &mat)
 Input stream operator, for dense matrix/vector only.
template<class Rep, class ErrChecker>
std::ostream & operator<< (std::ostream &os, const exmat::Mat< Rep, ErrChecker > &mat)
 Output stream operator, for dense matrix/vector only.
template<class Rep, class ErrChecker>
static const Mat< ExpMat<
SubExp< ScalarCon< typename
Rep::value_type >, Rep > >,
ErrChecker > 
exmat::operator- (const Mat< Rep, ErrChecker > &mat)
 Negate operator.
template<class Rep, class ErrChecker>
static const Vec< ExpMat<
SubExp< ScalarCon< typename
Rep::value_type >, typename
Rep::rep_type > >, ErrChecker > 
exmat::operator- (const Vec< Rep, ErrChecker > &vec)
 Negate operator.


Detailed Description

Contain the class Mat, Vec, and the associated operators.

Author:
Ricky Lung Man Tat
Details for Mat.h

Define Documentation

#define EXMAT_DERIVEDCLASS_IMP NAME,
MatOrVec   ) 
 

Value:

public:                                                         \
typedef typename super_type::rep_type   rep_type;               \
typedef typename super_type::ErrChecker ErrChecker;             \
typedef typename super_type::value_type value_type;             \
EXMAT_INLINE2 NAME(value_type s) : super_type(s) {}             \
EXMAT_INLINE2 NAME(const std::string& s) : super_type(s) {}     \
template<class Rep2, class EC2> EXMAT_INLINE2                   \
NAME(::exmat::MatOrVec<Rep2,EC2>& A) : super_type(A) {}         \
template<class Rep2, class EC2> EXMAT_INLINE2                   \
NAME(const ::exmat::MatOrVec<Rep2,EC2>& A) : super_type(A) {}   \
template<class Rep2> EXMAT_INLINE2                              \
NAME(::exmat::ExpMat<Rep2>& A) : super_type(A) {}               \
template<class Rep2> EXMAT_INLINE2                              \
NAME(const ::exmat::ExpMat<Rep2>& A) : super_type(A) {}         \
template<class T1, class T2> EXMAT_INLINE2                      \
NAME(const T1& t1, const T2& t2) : super_type(t1, t2) {}        \
template<class T1, class T2, class T3> EXMAT_INLINE2            \
NAME(const T1& t1, const T2& t2, const T3& t3)                  \
 : super_type(t1, t2, t3) {}                                    \
template<class T1, class T2, class T3, class T4> EXMAT_INLINE2  \
NAME(const T1& t1, const T2& t2, const T3& t3, const T4& t4)    \
 : super_type(t1, t2, t3, t4) {}                                \
private:
Macro that inserting necessary constructor and member functions for derived class of Mat or Vec


Generated on Sat May 6 23:12:03 2006 for Exmat by  doxygen 1.4.6-NO