matrix_binary.h

高效的c++科学算法库

// ------------------------------------------------------- -*- c++ -*- --
//
// WARNING: FILE AUTOMATICALLY GENERATED WITH matrix_binary.sed
//
// ----------------------------------------------------------------------
// from:  matrix_binary_ee.hxx
// from:  matrix_binary_el.hxx
// from:  matrix_binary_em.hxx
// from:  matrix_binary_es.hxx
// from:  matrix_binary_le.hxx
// from:  matrix_binary_ll.hxx
// from:  matrix_binary_lm.hxx
// from:  matrix_binary_ls.hxx
// from:  matrix_binary_me.hxx
// from:  matrix_binary_ml.hxx
// from:  matrix_binary_mm.hxx
// from:  matrix_binary_ms.hxx
// from:  matrix_binary_se.hxx
// from:  matrix_binary_sl.hxx
// from:  matrix_binary_sm.hxx
// ----------------------------------------------------------------------

// ---------------------------------------------------------- -*- c++ -*-
// Expression Operator Expression
// ----------------------------------------------------------------------
// file     = matrix_binary_ee.hxx
// name     = OpAdd
// operator = operator+
// ----------------------------------------------------------------------
template <typename T1_expr, typename T2_expr>
inline MatrixExpr<MatrixBinaryOp<MatrixExpr<T1_expr>,
                                 MatrixExpr<T2_expr>,
                                 OpAdd <typename T1_expr::value_t,
                                         typename T2_expr::value_t> > >
operator+ (MatrixExpr<T1_expr> SL_TEXPR_ARG e1,                        
            MatrixExpr<T2_expr> SL_TEXPR_ARG e2)   
{                       
  typedef OpAdd <typename T1_expr::value_t,
                  typename T2_expr::value_t> op_t;
  typedef MatrixExpr<T1_expr> expr_t1;                      
  typedef MatrixExpr<T2_expr> expr_t2;
  typedef MatrixBinaryOp<expr_t1, expr_t2, op_t> expr_t;                
  return MatrixExpr<expr_t> ( expr_t(e1, e2) );
}

// ---------------------------------------------------------- -*- c++ -*-
// Expression Operator Expression
// ----------------------------------------------------------------------
// file     = matrix_binary_ee.hxx
// name     = OpSub
// operator = operator-
// ----------------------------------------------------------------------
template <typename T1_expr, typename T2_expr>
inline MatrixExpr<MatrixBinaryOp<MatrixExpr<T1_expr>,
                                 MatrixExpr<T2_expr>,
                                 OpSub <typename T1_expr::value_t,
                                         typename T2_expr::value_t> > >
operator- (MatrixExpr<T1_expr> SL_TEXPR_ARG e1,                        
            MatrixExpr<T2_expr> SL_TEXPR_ARG e2)   
{                       
  typedef OpSub <typename T1_expr::value_t,
                  typename T2_expr::value_t> op_t;
  typedef MatrixExpr<T1_expr> expr_t1;                      
  typedef MatrixExpr<T2_expr> expr_t2;
  typedef MatrixBinaryOp<expr_t1, expr_t2, op_t> expr_t;                
  return MatrixExpr<expr_t> ( expr_t(e1, e2) );
}

// ---------------------------------------------------------- -*- c++ -*-
// Expression Operator Expression
// ----------------------------------------------------------------------
// file     = matrix_binary_ee.hxx
// name     = OpMul
// operator = operator^
// ----------------------------------------------------------------------
template <typename T1_expr, typename T2_expr>
inline MatrixExpr<MatrixBinaryOp<MatrixExpr<T1_expr>,
                                 MatrixExpr<T2_expr>,
                                 OpMul <typename T1_expr::value_t,
                                         typename T2_expr::value_t> > >
operator^ (MatrixExpr<T1_expr> SL_TEXPR_ARG e1,                        
            MatrixExpr<T2_expr> SL_TEXPR_ARG e2)   
{                       
  typedef OpMul <typename T1_expr::value_t,
                  typename T2_expr::value_t> op_t;
  typedef MatrixExpr<T1_expr> expr_t1;                      
  typedef MatrixExpr<T2_expr> expr_t2;
  typedef MatrixBinaryOp<expr_t1, expr_t2, op_t> expr_t;                
  return MatrixExpr<expr_t> ( expr_t(e1, e2) );
}

// ---------------------------------------------------------- -*- c++ -*-
// Expression Operator Expression
// ----------------------------------------------------------------------
// file     = matrix_binary_ee.hxx
// name     = OpDiv
// operator = operator%
// ----------------------------------------------------------------------
template <typename T1_expr, typename T2_expr>
inline MatrixExpr<MatrixBinaryOp<MatrixExpr<T1_expr>,
                                 MatrixExpr<T2_expr>,
                                 OpDiv <typename T1_expr::value_t,
                                         typename T2_expr::value_t> > >
operator% (MatrixExpr<T1_expr> SL_TEXPR_ARG e1,                        
            MatrixExpr<T2_expr> SL_TEXPR_ARG e2)   
{                       
  typedef OpDiv <typename T1_expr::value_t,
                  typename T2_expr::value_t> op_t;
  typedef MatrixExpr<T1_expr> expr_t1;                      
  typedef MatrixExpr<T2_expr> expr_t2;
  typedef MatrixBinaryOp<expr_t1, expr_t2, op_t> expr_t;                
  return MatrixExpr<expr_t> ( expr_t(e1, e2) );
}

// ---------------------------------------------------------- -*- c++ -*-
// Expression Operator Expression
// ----------------------------------------------------------------------
// file     = matrix_binary_ee.hxx
// name     = OpEqual
// operator = operator==
// ----------------------------------------------------------------------
template <typename T1_expr, typename T2_expr>
inline MatrixExpr<MatrixBinaryOp<MatrixExpr<T1_expr>,
                                 MatrixExpr<T2_expr>,
                                 OpEqual <typename T1_expr::value_t,
                                         typename T2_expr::value_t> > >
operator== (MatrixExpr<T1_expr> SL_TEXPR_ARG e1,                        
            MatrixExpr<T2_expr> SL_TEXPR_ARG e2)   
{                       
  typedef OpEqual <typename T1_expr::value_t,
                  typename T2_expr::value_t> op_t;
  typedef MatrixExpr<T1_expr> expr_t1;                      
  typedef MatrixExpr<T2_expr> expr_t2;
  typedef MatrixBinaryOp<expr_t1, expr_t2, op_t> expr_t;                
  return MatrixExpr<expr_t> ( expr_t(e1, e2) );
}

// ---------------------------------------------------------- -*- c++ -*-
// Expression Operator Expression
// ----------------------------------------------------------------------
// file     = matrix_binary_ee.hxx
// name     = OpNotEqual
// operator = operator!=
// ----------------------------------------------------------------------
template <typename T1_expr, typename T2_expr>
inline MatrixExpr<MatrixBinaryOp<MatrixExpr<T1_expr>,
                                 MatrixExpr<T2_expr>,
                                 OpNotEqual <typename T1_expr::value_t,
                                         typename T2_expr::value_t> > >
operator!= (MatrixExpr<T1_expr> SL_TEXPR_ARG e1,                        
            MatrixExpr<T2_expr> SL_TEXPR_ARG e2)   
{                       
  typedef OpNotEqual <typename T1_expr::value_t,
                  typename T2_expr::value_t> op_t;
  typedef MatrixExpr<T1_expr> expr_t1;                      
  typedef MatrixExpr<T2_expr> expr_t2;
  typedef MatrixBinaryOp<expr_t1, expr_t2, op_t> expr_t;                
  return MatrixExpr<expr_t> ( expr_t(e1, e2) );
}

// ---------------------------------------------------------- -*- c++ -*-
// Expression Operator Expression
// ----------------------------------------------------------------------
// file     = matrix_binary_ee.hxx
// name     = OpLess
// operator = operator<
// ----------------------------------------------------------------------
template <typename T1_expr, typename T2_expr>
inline MatrixExpr<MatrixBinaryOp<MatrixExpr<T1_expr>,
                                 MatrixExpr<T2_expr>,
                                 OpLess <typename T1_expr::value_t,
                                         typename T2_expr::value_t> > >
operator< (MatrixExpr<T1_expr> SL_TEXPR_ARG e1,                        
            MatrixExpr<T2_expr> SL_TEXPR_ARG e2)   
{                       
  typedef OpLess <typename T1_expr::value_t,
                  typename T2_expr::value_t> op_t;
  typedef MatrixExpr<T1_expr> expr_t1;                      
  typedef MatrixExpr<T2_expr> expr_t2;
  typedef MatrixBinaryOp<expr_t1, expr_t2, op_t> expr_t;                
  return MatrixExpr<expr_t> ( expr_t(e1, e2) );
}

// ---------------------------------------------------------- -*- c++ -*-
// Expression Operator Expression
// ----------------------------------------------------------------------
// file     = matrix_binary_ee.hxx
// name     = OpGreater
// operator = operator>
// ----------------------------------------------------------------------
template <typename T1_expr, typename T2_expr>
inline MatrixExpr<MatrixBinaryOp<MatrixExpr<T1_expr>,
                                 MatrixExpr<T2_expr>,
                                 OpGreater <typename T1_expr::value_t,
                                         typename T2_expr::value_t> > >
operator> (MatrixExpr<T1_expr> SL_TEXPR_ARG e1,                        
            MatrixExpr<T2_expr> SL_TEXPR_ARG e2)   
{                       
  typedef OpGreater <typename T1_expr::value_t,
                  typename T2_expr::value_t> op_t;
  typedef MatrixExpr<T1_expr> expr_t1;                      
  typedef MatrixExpr<T2_expr> expr_t2;
  typedef MatrixBinaryOp<expr_t1, expr_t2, op_t> expr_t;                
  return MatrixExpr<expr_t> ( expr_t(e1, e2) );
}

// ---------------------------------------------------------- -*- c++ -*-
// Expression Operator Expression
// ----------------------------------------------------------------------
// file     = matrix_binary_ee.hxx
// name     = OpLessOrEqual
// operator = operator<=
// ----------------------------------------------------------------------
template <typename T1_expr, typename T2_expr>
inline MatrixExpr<MatrixBinaryOp<MatrixExpr<T1_expr>,
                                 MatrixExpr<T2_expr>,
                                 OpLessOrEqual <typename T1_expr::value_t,
                                         typename T2_expr::value_t> > >
operator<= (MatrixExpr<T1_expr> SL_TEXPR_ARG e1,                        
            MatrixExpr<T2_expr> SL_TEXPR_ARG e2)   
{                       
  typedef OpLessOrEqual <typename T1_expr::value_t,
                  typename T2_expr::value_t> op_t;
  typedef MatrixExpr<T1_expr> expr_t1;                      
  typedef MatrixExpr<T2_expr> expr_t2;
  typedef MatrixBinaryOp<expr_t1, expr_t2, op_t> expr_t;                
  return MatrixExpr<expr_t> ( expr_t(e1, e2) );
}

// ---------------------------------------------------------- -*- c++ -*-
// Expression Operator Expression
// ----------------------------------------------------------------------
// file     = matrix_binary_ee.hxx
// name     = OpGreaterOrEqual
// operator = operator>=