FreePOOMA  2.4.1
Classes | Defines | Functions
TinyMatrixOperators.h File Reference
#include "PETE/PETE.h"
#include "PETE/TypeComputations.h"
#include "Tiny/BinaryTinyMatrixOp.h"
#include "Tiny/UnaryTinyMatrixOp.h"
Include dependency graph for TinyMatrixOperators.h:
This graph shows which files directly or indirectly include this file:

Classes

class  TinyMatrixEngine< D1, D2, T, BinaryTinyMatrixOp< V1, V2, FnDot > >
struct  TinyMatrixDotTinyMatrix< T1, T2, I, J, K, L >
struct  TinyMatrixDotTinyMatrix< T1, T2, I, J, K, 1 >
struct  TinyMatrixEngineElem< D1, D2, T, BinaryTinyMatrixOp< T1, T2, FnDot >, I, J >
struct  BinaryReturn< TinyMatrix< D1, D2, T1, E1 >, TinyMatrix< D2, D3, T2, E2 >, FnDot >
struct  BinaryReturn< TinyMatrix< D1, D2, T1, E1 >, TinyMatrix< D1, D2, T2, E2 >, OpEQ >
struct  BinaryReturn< TinyMatrix< D1, D2, T1, E1 >, TinyMatrix< D1, D2, T2, E2 >, OpNE >

Defines

#define POOMA_TINYMATRIX_UNARY_OPERATOR(FUNC, TAG)
#define POOMA_TINYMATRIX_BINARY_OPERATOR(FUNC, TAG)
#define POOMA_TINYMATRIX_ACCUM_OPERATOR(FUNC, TAG)

Functions

template<int D1, int D2, int D3, class T1 , class T2 , class E1 , class E2 >
BinaryReturn< TinyMatrix< D1,
D2, T1, E1 >, TinyMatrix< D2,
D3, T2, E2 >, FnDot >::Type_t 
dot (const TinyMatrix< D1, D2, T1, E1 > &v1, const TinyMatrix< D2, D3, T2, E2 > &v2)
template<int D1, int D2, class T1 , class T2 , class E1 , class E2 >
BinaryReturn< TinyMatrix< D1,
D2, T1, E1 >, TinyMatrix< D1,
D2, T2, E2 >, OpEQ >::Type_t 
operator== (const TinyMatrix< D1, D2, T1, E1 > &t1, const TinyMatrix< D1, D2, T2, E2 > &t2)
template<int D1, int D2, class T1 , class T2 , class E1 , class E2 >
BinaryReturn< TinyMatrix< D1,
D2, T1, E1 >, TinyMatrix< D1,
D2, T2, E2 >, OpNE >::Type_t 
operator!= (const TinyMatrix< D1, D2, T1, E1 > &t1, const TinyMatrix< D1, D2, T2, E2 > &t2)

Define Documentation

#define POOMA_TINYMATRIX_UNARY_OPERATOR (   FUNC,
  TAG 
)
Value:
\
template <int D1, int D2, class T, class E>                                   \
struct UnaryReturn< TinyMatrix<D1,D2,T,E>, TAG >                              \
{                                                                             \
  typedef TinyMatrix< D1, D2, typename UnaryReturn<T,TAG>::Type_t, E >        \
    Type_t;                                                                   \
};                                                                            \
                                                                              \
template <int D1, int D2, class T, class E>                                   \
inline typename UnaryReturn< TinyMatrix<D1,D2,T,E>, TAG >::Type_t             \
FUNC( const TinyMatrix<D1,D2,T,E>& v1 )                                       \
{                                                                             \
  typedef TinyMatrix<D1,D2,T,E> V1;                                           \
  typedef typename UnaryReturn<T,TAG>::Type_t T3;                             \
  typedef TinyMatrix< D1, D2, T3, UnaryTinyMatrixOp<V1,TAG> > Expr_t;         \
  typedef typename UnaryReturn<V1,TAG>::Type_t Return_t;                      \
  return Return_t( Expr_t(v1) );                                              \
}
#define POOMA_TINYMATRIX_BINARY_OPERATOR (   FUNC,
  TAG 
)
#define POOMA_TINYMATRIX_ACCUM_OPERATOR (   FUNC,
  TAG 
)
Value:
\
template <int D1, int D2, class T1, class T2, class E1, class E2>             \
inline const TinyMatrix<D1,D2,T1,E1>&                                         \
FUNC( TinyMatrix<D1,D2,T1,E1>& v1, const TinyMatrix<D1,D2,T2,E2>& v2 )        \
{                                                                             \
  typedef TinyMatrix<D1,D2,T1,E1> Left_t;                                     \
  typedef TinyMatrix<D1,D2,T2,E2> Right_t;                                    \
  TinyMatrixAssign<Left_t,Right_t,TAG,0,D1,0,D2>::apply(v1,v2,TAG());         \
  return v1;                                                                  \
}                                                                             \
                                                                              \
template <int D1, int D2, class T1, class T2, class E1>                       \
inline const TinyMatrix<D1,D2,T1,E1>&                                         \
FUNC( TinyMatrix<D1,D2,T1,E1>& v1, const T2& v2 )                             \
{                                                                             \
  TinyMatrixAssign<TinyMatrix<D1,D2,T1,E1>,T2,TAG,0,D1,0,D2>::                \
    apply(v1,v2,TAG());                                                       \
  return v1;                                                                  \
}

Function Documentation

template<int D1, int D2, int D3, class T1 , class T2 , class E1 , class E2 >
BinaryReturn< TinyMatrix<D1,D2,T1,E1>,TinyMatrix<D2,D3,T2,E2> , FnDot >::Type_t dot ( const TinyMatrix< D1, D2, T1, E1 > &  v1,
const TinyMatrix< D2, D3, T2, E2 > &  v2 
) [inline]
template<int D1, int D2, class T1 , class T2 , class E1 , class E2 >
BinaryReturn< TinyMatrix<D1,D2,T1,E1>,TinyMatrix<D1,D2,T2,E2> , OpEQ >::Type_t operator== ( const TinyMatrix< D1, D2, T1, E1 > &  t1,
const TinyMatrix< D1, D2, T2, E2 > &  t2 
) [inline]
template<int D1, int D2, class T1 , class T2 , class E1 , class E2 >
BinaryReturn< TinyMatrix<D1,D2,T1,E1>,TinyMatrix<D1,D2,T2,E2> , OpNE >::Type_t operator!= ( const TinyMatrix< D1, D2, T1, E1 > &  t1,
const TinyMatrix< D1, D2, T2, E2 > &  t2 
) [inline]