matrix_unary.h

高效的c++科学算法库

// ------------------------------------------------------- -*- c++ -*- --
//
// WARNING: FILE AUTOMATICALLY GENERATED WITH matrix_unary.sed
//
// ----------------------------------------------------------------------
// from:  matrix_unary_e.hxx
// from:  matrix_unary_l.hxx
// from:  matrix_unary_m.hxx
// ----------------------------------------------------------------------

// ---------------------------------------------------------- -*- c++ -*-
// Matrix Unary Operator
// ----------------------------------------------------------------------
// file     = matrix_unary_e.hxx
// name     = OpPlus
// operator = operator+
// ----------------------------------------------------------------------
template <typename T_expr>
inline MatrixExpr<MatrixUnaryOp<MatrixExpr<T_expr>,
                                OpPlus <typename T_expr::value_t> > >
operator+ (MatrixExpr<T_expr> SL_TEXPR_ARG e)
{
  typedef OpPlus <typename T_expr::value_t> op_t;
  typedef MatrixExpr<T_expr> expr_t1;
  typedef MatrixUnaryOp<expr_t1, op_t> expr_t;
  
  return MatrixExpr<expr_t> ( expr_t( e ) );
}
// ---------------------------------------------------------- -*- c++ -*-
// Matrix Unary Operator
// ----------------------------------------------------------------------
// file     = matrix_unary_e.hxx
// name     = OpMinus
// operator = operator-
// ----------------------------------------------------------------------
template <typename T_expr>
inline MatrixExpr<MatrixUnaryOp<MatrixExpr<T_expr>,
                                OpMinus <typename T_expr::value_t> > >
operator- (MatrixExpr<T_expr> SL_TEXPR_ARG e)
{
  typedef OpMinus <typename T_expr::value_t> op_t;
  typedef MatrixExpr<T_expr> expr_t1;
  typedef MatrixUnaryOp<expr_t1, op_t> expr_t;
  
  return MatrixExpr<expr_t> ( expr_t( e ) );
}
// ---------------------------------------------------------- -*- c++ -*-
// Matrix Unary Operator
// ----------------------------------------------------------------------
// file     = matrix_unary_e.hxx
// name     = FctAbs
// operator = abs
// ----------------------------------------------------------------------
template <typename T_expr>
inline MatrixExpr<MatrixUnaryOp<MatrixExpr<T_expr>,
                                FctAbs <typename T_expr::value_t> > >
abs (MatrixExpr<T_expr> SL_TEXPR_ARG e)
{
  typedef FctAbs <typename T_expr::value_t> op_t;
  typedef MatrixExpr<T_expr> expr_t1;
  typedef MatrixUnaryOp<expr_t1, op_t> expr_t;
  
  return MatrixExpr<expr_t> ( expr_t( e ) );
}
// ---------------------------------------------------------- -*- c++ -*-
// Matrix Unary Operator
// ----------------------------------------------------------------------
// file     = matrix_unary_e.hxx
// name     = FctSqrt
// operator = sqrt
// ----------------------------------------------------------------------
template <typename T_expr>
inline MatrixExpr<MatrixUnaryOp<MatrixExpr<T_expr>,
                                FctSqrt <typename T_expr::value_t> > >
sqrt (MatrixExpr<T_expr> SL_TEXPR_ARG e)
{
  typedef FctSqrt <typename T_expr::value_t> op_t;
  typedef MatrixExpr<T_expr> expr_t1;
  typedef MatrixUnaryOp<expr_t1, op_t> expr_t;
  
  return MatrixExpr<expr_t> ( expr_t( e ) );
}
// ---------------------------------------------------------- -*- c++ -*-
// Matrix Unary Operator
// ----------------------------------------------------------------------
// file     = matrix_unary_e.hxx
// name     = FctLn
// operator = ln
// ----------------------------------------------------------------------
template <typename T_expr>
inline MatrixExpr<MatrixUnaryOp<MatrixExpr<T_expr>,
                                FctLn <typename T_expr::value_t> > >
ln (MatrixExpr<T_expr> SL_TEXPR_ARG e)
{
  typedef FctLn <typename T_expr::value_t> op_t;
  typedef MatrixExpr<T_expr> expr_t1;
  typedef MatrixUnaryOp<expr_t1, op_t> expr_t;
  
  return MatrixExpr<expr_t> ( expr_t( e ) );
}
// ---------------------------------------------------------- -*- c++ -*-
// Matrix Unary Operator
// ----------------------------------------------------------------------
// file     = matrix_unary_e.hxx
// name     = FctLog
// operator = log
// ----------------------------------------------------------------------
template <typename T_expr>
inline MatrixExpr<MatrixUnaryOp<MatrixExpr<T_expr>,
                                FctLog <typename T_expr::value_t> > >
log (MatrixExpr<T_expr> SL_TEXPR_ARG e)
{
  typedef FctLog <typename T_expr::value_t> op_t;
  typedef MatrixExpr<T_expr> expr_t1;
  typedef MatrixUnaryOp<expr_t1, op_t> expr_t;
  
  return MatrixExpr<expr_t> ( expr_t( e ) );
}
// ---------------------------------------------------------- -*- c++ -*-
// Matrix Unary Operator
// ----------------------------------------------------------------------
// file     = matrix_unary_e.hxx
// name     = FctLog10
// operator = log10
// ----------------------------------------------------------------------
template <typename T_expr>
inline MatrixExpr<MatrixUnaryOp<MatrixExpr<T_expr>,
                                FctLog10 <typename T_expr::value_t> > >
log10 (MatrixExpr<T_expr> SL_TEXPR_ARG e)
{
  typedef FctLog10 <typename T_expr::value_t> op_t;
  typedef MatrixExpr<T_expr> expr_t1;
  typedef MatrixUnaryOp<expr_t1, op_t> expr_t;
  
  return MatrixExpr<expr_t> ( expr_t( e ) );
}
// ---------------------------------------------------------- -*- c++ -*-
// Matrix Unary Operator
// ----------------------------------------------------------------------
// file     = matrix_unary_e.hxx
// name     = FctPow10
// operator = pow10
// ----------------------------------------------------------------------
template <typename T_expr>
inline MatrixExpr<MatrixUnaryOp<MatrixExpr<T_expr>,
                                FctPow10 <typename T_expr::value_t> > >
pow10 (MatrixExpr<T_expr> SL_TEXPR_ARG e)
{
  typedef FctPow10 <typename T_expr::value_t> op_t;
  typedef MatrixExpr<T_expr> expr_t1;
  typedef MatrixUnaryOp<expr_t1, op_t> expr_t;
  
  return MatrixExpr<expr_t> ( expr_t( e ) );
}
// ---------------------------------------------------------- -*- c++ -*-
// Matrix Unary Operator
// ----------------------------------------------------------------------
// file     = matrix_unary_e.hxx
// name     = FctExp
// operator = exp
// ----------------------------------------------------------------------
template <typename T_expr>
inline MatrixExpr<MatrixUnaryOp<MatrixExpr<T_expr>,
                                FctExp <typename T_expr::value_t> > >
exp (MatrixExpr<T_expr> SL_TEXPR_ARG e)
{
  typedef FctExp <typename T_expr::value_t> op_t;
  typedef MatrixExpr<T_expr> expr_t1;
  typedef MatrixUnaryOp<expr_t1, op_t> expr_t;
  
  return MatrixExpr<expr_t> ( expr_t( e ) );
}
// ---------------------------------------------------------- -*- c++ -*-
// Matrix Unary Operator
// ----------------------------------------------------------------------
// file     = matrix_unary_e.hxx
// name     = FctSin
// operator = sin
// ----------------------------------------------------------------------
template <typename T_expr>
inline MatrixExpr<MatrixUnaryOp<MatrixExpr<T_expr>,
                                FctSin <typename T_expr::value_t> > >
sin (MatrixExpr<T_expr> SL_TEXPR_ARG e)
{
  typedef FctSin <typename T_expr::value_t> op_t;
  typedef MatrixExpr<T_expr> expr_t1;
  typedef MatrixUnaryOp<expr_t1, op_t> expr_t;
  
  return MatrixExpr<expr_t> ( expr_t( e ) );
}
// ---------------------------------------------------------- -*- c++ -*-
// Matrix Unary Operator
// ----------------------------------------------------------------------
// file     = matrix_unary_e.hxx
// name     = FctCos
// operator = cos
// ----------------------------------------------------------------------
template <typename T_expr>
inline MatrixExpr<MatrixUnaryOp<MatrixExpr<T_expr>,
                                FctCos <typename T_expr::value_t> > >
cos (MatrixExpr<T_expr> SL_TEXPR_ARG e)
{
  typedef FctCos <typename T_expr::value_t> op_t;
  typedef MatrixExpr<T_expr> expr_t1;
  typedef MatrixUnaryOp<expr_t1, op_t> expr_t;
  
  return MatrixExpr<expr_t> ( expr_t( e ) );
}
// ---------------------------------------------------------- -*- c++ -*-
// Matrix Unary Operator
// ----------------------------------------------------------------------
// file     = matrix_unary_e.hxx
// name     = FctTan
// operator = tan
// ----------------------------------------------------------------------
template <typename T_expr>
inline MatrixExpr<MatrixUnaryOp<MatrixExpr<T_expr>,
                                FctTan <typename T_expr::value_t> > >
tan (MatrixExpr<T_expr> SL_TEXPR_ARG e)
{
  typedef FctTan <typename T_expr::value_t> op_t;
  typedef MatrixExpr<T_expr> expr_t1;
  typedef MatrixUnaryOp<expr_t1, op_t> expr_t;
  
  return MatrixExpr<expr_t> ( expr_t( e ) );
}
// ---------------------------------------------------------- -*- c++ -*-
// Matrix Unary Operator
// ----------------------------------------------------------------------
// file     = matrix_unary_e.hxx
// name     = FctSinH
// operator = sinh
// ----------------------------------------------------------------------
template <typename T_expr>
inline MatrixExpr<MatrixUnaryOp<MatrixExpr<T_expr>,
                                FctSinH <typename T_expr::value_t> > >
sinh (MatrixExpr<T_expr> SL_TEXPR_ARG e)
{
  typedef FctSinH <typename T_expr::value_t> op_t;
  typedef MatrixExpr<T_expr> expr_t1;
  typedef MatrixUnaryOp<expr_t1, op_t> expr_t;
  
  return MatrixExpr<expr_t> ( expr_t( e ) );
}
// ---------------------------------------------------------- -*- c++ -*-
// Matrix Unary Operator
// ----------------------------------------------------------------------
// file     = matrix_unary_e.hxx
// name     = FctCosH
// operator = cosh
// ----------------------------------------------------------------------
template <typename T_expr>
inline MatrixExpr<MatrixUnaryOp<MatrixExpr<T_expr>,
                                FctCosH <typename T_expr::value_t> > >
cosh (MatrixExpr<T_expr> SL_TEXPR_ARG e)
{
  typedef FctCosH <typename T_expr::value_t> op_t;
  typedef MatrixExpr<T_expr> expr_t1;
  typedef MatrixUnaryOp<expr_t1, op_t> expr_t;
  
  return MatrixExpr<expr_t> ( expr_t( e ) );
}
// ---------------------------------------------------------- -*- c++ -*-
// Matrix Unary Operator
// ----------------------------------------------------------------------
// file     = matrix_unary_e.hxx
// name     = FctTanH
// operator = tanh
// ----------------------------------------------------------------------
template <typename T_expr>
inline MatrixExpr<MatrixUnaryOp<MatrixExpr<T_expr>,
                                FctTanH <typename T_expr::value_t> > >
tanh (MatrixExpr<T_expr> SL_TEXPR_ARG e)
{
  typedef FctTanH <typename T_expr::value_t> op_t;
  typedef MatrixExpr<T_expr> expr_t1;
  typedef MatrixUnaryOp<expr_t1, op_t> expr_t;
  
  return MatrixExpr<expr_t> ( expr_t( e ) );
}
// ---------------------------------------------------------- -*- c++ -*-
// Matrix Unary Operator
// ----------------------------------------------------------------------
// file     = matrix_unary_e.hxx
// name     = FctASinH
// operator = asinh
// ----------------------------------------------------------------------
template <typename T_expr>
inline MatrixExpr<MatrixUnaryOp<MatrixExpr<T_expr>,
                                FctASinH <typename T_expr::value_t> > >
asinh (MatrixExpr<T_expr> SL_TEXPR_ARG e)
{
  typedef FctASinH <typename T_expr::value_t> op_t;
  typedef MatrixExpr<T_expr> expr_t1;
  typedef MatrixUnaryOp<expr_t1, op_t> expr_t;
  
  return MatrixExpr<expr_t> ( expr_t( e ) );
}
// ---------------------------------------------------------- -*- c++ -*-
// Matrix Unary Operator
// ----------------------------------------------------------------------