matrix_binary.h

高效的c++科学算法库

// ----------------------------------------------------------------------
template <typename T_value,                                              
          typename T_structure,                                          
          typename T_storage,                                            
          typename T_expr>                                               
inline MatrixExpr<MatrixBinaryOp<Matrix<T_value, T_structure, T_storage>,
                  MatrixExpr<T_expr>,                                    
                  OpMul <T_value, typename T_expr::value_t> > >         
operator^ (Matrix<T_value, T_structure, T_storage> SL_TEXPR_ARG m,      
            MatrixExpr<T_expr> SL_TEXPR_ARG e)                           
{                                                                        
  typedef OpMul <T_value, typename T_expr::value_t> op_t;               
  typedef Matrix<T_value, T_structure, T_storage> expr_t1;               
  typedef MatrixExpr<T_expr> expr_t2;                                    
  typedef MatrixBinaryOp<expr_t1, expr_t2, op_t> expr_t;                 
                                                                         
  return MatrixExpr<expr_t> ( expr_t(m, e) );
}
// ---------------------------------------------------------- -*- c++ -*-
// Matrix Operator Expression
// ----------------------------------------------------------------------
// file     = matrix_binary_me.hxx
// name     = OpDiv
// operator = operator%
// ----------------------------------------------------------------------
template <typename T_value,                                              
          typename T_structure,                                          
          typename T_storage,                                            
          typename T_expr>                                               
inline MatrixExpr<MatrixBinaryOp<Matrix<T_value, T_structure, T_storage>,
                  MatrixExpr<T_expr>,                                    
                  OpDiv <T_value, typename T_expr::value_t> > >         
operator% (Matrix<T_value, T_structure, T_storage> SL_TEXPR_ARG m,      
            MatrixExpr<T_expr> SL_TEXPR_ARG e)                           
{                                                                        
  typedef OpDiv <T_value, typename T_expr::value_t> op_t;               
  typedef Matrix<T_value, T_structure, T_storage> expr_t1;               
  typedef MatrixExpr<T_expr> expr_t2;                                    
  typedef MatrixBinaryOp<expr_t1, expr_t2, op_t> expr_t;                 
                                                                         
  return MatrixExpr<expr_t> ( expr_t(m, e) );
}
// ---------------------------------------------------------- -*- c++ -*-
// Matrix Operator Expression
// ----------------------------------------------------------------------
// file     = matrix_binary_me.hxx
// name     = OpEqual
// operator = operator==
// ----------------------------------------------------------------------
template <typename T_value,                                              
          typename T_structure,                                          
          typename T_storage,                                            
          typename T_expr>                                               
inline MatrixExpr<MatrixBinaryOp<Matrix<T_value, T_structure, T_storage>,
                  MatrixExpr<T_expr>,                                    
                  OpEqual <T_value, typename T_expr::value_t> > >         
operator== (Matrix<T_value, T_structure, T_storage> SL_TEXPR_ARG m,      
            MatrixExpr<T_expr> SL_TEXPR_ARG e)                           
{                                                                        
  typedef OpEqual <T_value, typename T_expr::value_t> op_t;               
  typedef Matrix<T_value, T_structure, T_storage> expr_t1;               
  typedef MatrixExpr<T_expr> expr_t2;                                    
  typedef MatrixBinaryOp<expr_t1, expr_t2, op_t> expr_t;                 
                                                                         
  return MatrixExpr<expr_t> ( expr_t(m, e) );
}
// ---------------------------------------------------------- -*- c++ -*-
// Matrix Operator Expression
// ----------------------------------------------------------------------
// file     = matrix_binary_me.hxx
// name     = OpNotEqual
// operator = operator!=
// ----------------------------------------------------------------------
template <typename T_value,                                              
          typename T_structure,                                          
          typename T_storage,                                            
          typename T_expr>                                               
inline MatrixExpr<MatrixBinaryOp<Matrix<T_value, T_structure, T_storage>,
                  MatrixExpr<T_expr>,                                    
                  OpNotEqual <T_value, typename T_expr::value_t> > >         
operator!= (Matrix<T_value, T_structure, T_storage> SL_TEXPR_ARG m,      
            MatrixExpr<T_expr> SL_TEXPR_ARG e)                           
{                                                                        
  typedef OpNotEqual <T_value, typename T_expr::value_t> op_t;               
  typedef Matrix<T_value, T_structure, T_storage> expr_t1;               
  typedef MatrixExpr<T_expr> expr_t2;                                    
  typedef MatrixBinaryOp<expr_t1, expr_t2, op_t> expr_t;                 
                                                                         
  return MatrixExpr<expr_t> ( expr_t(m, e) );
}
// ---------------------------------------------------------- -*- c++ -*-
// Matrix Operator Expression
// ----------------------------------------------------------------------
// file     = matrix_binary_me.hxx
// name     = OpLess
// operator = operator<
// ----------------------------------------------------------------------
template <typename T_value,                                              
          typename T_structure,                                          
          typename T_storage,                                            
          typename T_expr>                                               
inline MatrixExpr<MatrixBinaryOp<Matrix<T_value, T_structure, T_storage>,
                  MatrixExpr<T_expr>,                                    
                  OpLess <T_value, typename T_expr::value_t> > >         
operator< (Matrix<T_value, T_structure, T_storage> SL_TEXPR_ARG m,      
            MatrixExpr<T_expr> SL_TEXPR_ARG e)                           
{                                                                        
  typedef OpLess <T_value, typename T_expr::value_t> op_t;               
  typedef Matrix<T_value, T_structure, T_storage> expr_t1;               
  typedef MatrixExpr<T_expr> expr_t2;                                    
  typedef MatrixBinaryOp<expr_t1, expr_t2, op_t> expr_t;                 
                                                                         
  return MatrixExpr<expr_t> ( expr_t(m, e) );
}
// ---------------------------------------------------------- -*- c++ -*-
// Matrix Operator Expression
// ----------------------------------------------------------------------
// file     = matrix_binary_me.hxx
// name     = OpGreater
// operator = operator>
// ----------------------------------------------------------------------
template <typename T_value,                                              
          typename T_structure,                                          
          typename T_storage,                                            
          typename T_expr>                                               
inline MatrixExpr<MatrixBinaryOp<Matrix<T_value, T_structure, T_storage>,
                  MatrixExpr<T_expr>,                                    
                  OpGreater <T_value, typename T_expr::value_t> > >         
operator> (Matrix<T_value, T_structure, T_storage> SL_TEXPR_ARG m,      
            MatrixExpr<T_expr> SL_TEXPR_ARG e)                           
{                                                                        
  typedef OpGreater <T_value, typename T_expr::value_t> op_t;               
  typedef Matrix<T_value, T_structure, T_storage> expr_t1;               
  typedef MatrixExpr<T_expr> expr_t2;                                    
  typedef MatrixBinaryOp<expr_t1, expr_t2, op_t> expr_t;                 
                                                                         
  return MatrixExpr<expr_t> ( expr_t(m, e) );
}
// ---------------------------------------------------------- -*- c++ -*-
// Matrix Operator Expression
// ----------------------------------------------------------------------
// file     = matrix_binary_me.hxx
// name     = OpLessOrEqual
// operator = operator<=
// ----------------------------------------------------------------------
template <typename T_value,                                              
          typename T_structure,                                          
          typename T_storage,                                            
          typename T_expr>                                               
inline MatrixExpr<MatrixBinaryOp<Matrix<T_value, T_structure, T_storage>,
                  MatrixExpr<T_expr>,                                    
                  OpLessOrEqual <T_value, typename T_expr::value_t> > >         
operator<= (Matrix<T_value, T_structure, T_storage> SL_TEXPR_ARG m,      
            MatrixExpr<T_expr> SL_TEXPR_ARG e)                           
{                                                                        
  typedef OpLessOrEqual <T_value, typename T_expr::value_t> op_t;               
  typedef Matrix<T_value, T_structure, T_storage> expr_t1;               
  typedef MatrixExpr<T_expr> expr_t2;                                    
  typedef MatrixBinaryOp<expr_t1, expr_t2, op_t> expr_t;                 
                                                                         
  return MatrixExpr<expr_t> ( expr_t(m, e) );
}
// ---------------------------------------------------------- -*- c++ -*-
// Matrix Operator Expression
// ----------------------------------------------------------------------
// file     = matrix_binary_me.hxx
// name     = OpGreaterOrEqual
// operator = operator>=
// ----------------------------------------------------------------------
template <typename T_value,                                              
          typename T_structure,                                          
          typename T_storage,                                            
          typename T_expr>                                               
inline MatrixExpr<MatrixBinaryOp<Matrix<T_value, T_structure, T_storage>,
                  MatrixExpr<T_expr>,                                    
                  OpGreaterOrEqual <T_value, typename T_expr::value_t> > >         
operator>= (Matrix<T_value, T_structure, T_storage> SL_TEXPR_ARG m,      
            MatrixExpr<T_expr> SL_TEXPR_ARG e)                           
{                                                                        
  typedef OpGreaterOrEqual <T_value, typename T_expr::value_t> op_t;               
  typedef Matrix<T_value, T_structure, T_storage> expr_t1;               
  typedef MatrixExpr<T_expr> expr_t2;                                    
  typedef MatrixBinaryOp<expr_t1, expr_t2, op_t> expr_t;                 
                                                                         
  return MatrixExpr<expr_t> ( expr_t(m, e) );
}
// ---------------------------------------------------------- -*- c++ -*-
// Matrix Operator Expression
// ----------------------------------------------------------------------
// file     = matrix_binary_me.hxx
// name     = OpAnd
// operator = operator&&
// ----------------------------------------------------------------------
template <typename T_value,                                              
          typename T_structure,                                          
          typename T_storage,                                            
          typename T_expr>                                               
inline MatrixExpr<MatrixBinaryOp<Matrix<T_value, T_structure, T_storage>,
                  MatrixExpr<T_expr>,                                    
                  OpAnd <T_value, typename T_expr::value_t> > >         
operator&& (Matrix<T_value, T_structure, T_storage> SL_TEXPR_ARG m,      
            MatrixExpr<T_expr> SL_TEXPR_ARG e)                           
{                                                                        
  typedef OpAnd <T_value, typename T_expr::value_t> op_t;               
  typedef Matrix<T_value, T_structure, T_storage> expr_t1;               
  typedef MatrixExpr<T_expr> expr_t2;                                    
  typedef MatrixBinaryOp<expr_t1, expr_t2, op_t> expr_t;                 
                                                                         
  return MatrixExpr<expr_t> ( expr_t(m, e) );
}
// ---------------------------------------------------------- -*- c++ -*-
// Matrix Operator Expression
// ----------------------------------------------------------------------
// file     = matrix_binary_me.hxx
// name     = OpOr
// operator = operator||
// ----------------------------------------------------------------------
template <typename T_value,                                              
          typename T_structure,                                          
          typename T_storage,                                            
          typename T_expr>                                               
inline MatrixExpr<MatrixBinaryOp<Matrix<T_value, T_structure, T_storage>,
                  MatrixExpr<T_expr>,                                    
                  OpOr <T_value, typename T_expr::value_t> > >         
operator|| (Matrix<T_value, T_structure, T_storage> SL_TEXPR_ARG m,      
            MatrixExpr<T_expr> SL_TEXPR_ARG e)                           
{                                                                        
  typedef OpOr <T_value, typename T_expr::value_t> op_t;               
  typedef Matrix<T_value, T_structure, T_storage> expr_t1;               
  typedef MatrixExpr<T_expr> expr_t2;                                    
  typedef MatrixBinaryOp<expr_t1, expr_t2, op_t> expr_t;