matrix_binary.h

高效的c++科学算法库

// ----------------------------------------------------------------------
template <typename T1_expr, typename T2_expr>
inline MatrixExpr<MatrixBinaryOp<MatrixExpr<T1_expr>,
                                 MatrixExpr<T2_expr>,
                                 OpGreaterOrEqual <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 OpGreaterOrEqual <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     = OpAnd
// operator = operator&&
// ----------------------------------------------------------------------
template <typename T1_expr, typename T2_expr>
inline MatrixExpr<MatrixBinaryOp<MatrixExpr<T1_expr>,
                                 MatrixExpr<T2_expr>,
                                 OpAnd <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 OpAnd <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     = OpOr
// operator = operator||
// ----------------------------------------------------------------------
template <typename T1_expr, typename T2_expr>
inline MatrixExpr<MatrixBinaryOp<MatrixExpr<T1_expr>,
                                 MatrixExpr<T2_expr>,
                                 OpOr <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 OpOr <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     = FctPow
// operator = pow
// ----------------------------------------------------------------------
template <typename T1_expr, typename T2_expr>
inline MatrixExpr<MatrixBinaryOp<MatrixExpr<T1_expr>,
                                 MatrixExpr<T2_expr>,
                                 FctPow <typename T1_expr::value_t,
                                         typename T2_expr::value_t> > >
pow (MatrixExpr<T1_expr> SL_TEXPR_ARG e1,                        
            MatrixExpr<T2_expr> SL_TEXPR_ARG e2)   
{                       
  typedef FctPow <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     = FctATan2
// operator = atan2
// ----------------------------------------------------------------------
template <typename T1_expr, typename T2_expr>
inline MatrixExpr<MatrixBinaryOp<MatrixExpr<T1_expr>,
                                 MatrixExpr<T2_expr>,
                                 FctATan2 <typename T1_expr::value_t,
                                         typename T2_expr::value_t> > >
atan2 (MatrixExpr<T1_expr> SL_TEXPR_ARG e1,                        
            MatrixExpr<T2_expr> SL_TEXPR_ARG e2)   
{                       
  typedef FctATan2 <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     = FctHypot
// operator = hypot
// ----------------------------------------------------------------------
template <typename T1_expr, typename T2_expr>
inline MatrixExpr<MatrixBinaryOp<MatrixExpr<T1_expr>,
                                 MatrixExpr<T2_expr>,
                                 FctHypot <typename T1_expr::value_t,
                                         typename T2_expr::value_t> > >
hypot (MatrixExpr<T1_expr> SL_TEXPR_ARG e1,                        
            MatrixExpr<T2_expr> SL_TEXPR_ARG e2)   
{                       
  typedef FctHypot <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     = FctJN
// operator = jn
// ----------------------------------------------------------------------
template <typename T1_expr, typename T2_expr>
inline MatrixExpr<MatrixBinaryOp<MatrixExpr<T1_expr>,
                                 MatrixExpr<T2_expr>,
                                 FctJN <typename T1_expr::value_t,
                                         typename T2_expr::value_t> > >
jn (MatrixExpr<T1_expr> SL_TEXPR_ARG e1,                        
            MatrixExpr<T2_expr> SL_TEXPR_ARG e2)   
{                       
  typedef FctJN <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     = FctYN
// operator = yn
// ----------------------------------------------------------------------
template <typename T1_expr, typename T2_expr>
inline MatrixExpr<MatrixBinaryOp<MatrixExpr<T1_expr>,
                                 MatrixExpr<T2_expr>,
                                 FctYN <typename T1_expr::value_t,
                                         typename T2_expr::value_t> > >
yn (MatrixExpr<T1_expr> SL_TEXPR_ARG e1,                        
            MatrixExpr<T2_expr> SL_TEXPR_ARG e2)   
{                       
  typedef FctYN <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     = CopySign
// operator = copysign
// ----------------------------------------------------------------------
template <typename T1_expr, typename T2_expr>
inline MatrixExpr<MatrixBinaryOp<MatrixExpr<T1_expr>,
                                 MatrixExpr<T2_expr>,
                                 CopySign <typename T1_expr::value_t,
                                         typename T2_expr::value_t> > >
copysign (MatrixExpr<T1_expr> SL_TEXPR_ARG e1,                        
            MatrixExpr<T2_expr> SL_TEXPR_ARG e2)   
{                       
  typedef CopySign <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 Matrix
// ----------------------------------------------------------------------
// file     = matrix_binary_em.hxx
// name     = OpAdd
// operator = operator+
// ----------------------------------------------------------------------
template <typename T_expr,
          typename T_value,
          typename T_structure,
          typename T_storage> 
inline MatrixExpr<MatrixBinaryOp<MatrixExpr<T_expr>,                                   
                  Matrix<T_value, T_structure, T_storage>,                             
                  OpAdd <typename T_expr::value_t, T_value> > >                       
operator+ (MatrixExpr<T_expr> SL_TEXPR_ARG e,                                         
            Matrix<T_value, T_structure, T_storage> SL_TEXPR_ARG m)                    
{                                                                                      
  typedef OpAdd <typename T_expr::value_t, T_value> op_t;                             
  typedef MatrixExpr<T_expr> expr_t1;                                                  
  typedef Matrix<T_value, T_structure, T_storage> expr_t2;                             
  typedef MatrixBinaryOp<expr_t1, expr_t2, op_t> expr_t;                               
                                                                                       
  return MatrixExpr<expr_t> ( expr_t(e, m) );                                          
}

// ---------------------------------------------------------- -*- c++ -*-
// Expression Operator Matrix
// ----------------------------------------------------------------------
// file     = matrix_binary_em.hxx
// name     = OpSub
// operator = operator-
// ----------------------------------------------------------------------
template <typename T_expr,
          typename T_value,