matrix_unary.h

高效的c++科学算法库

// file     = matrix_unary_e.hxx
// name     = FctACosH
// operator = acosh
// ----------------------------------------------------------------------
template <typename T_expr>
inline MatrixExpr<MatrixUnaryOp<MatrixExpr<T_expr>,
                                FctACosH <typename T_expr::value_t> > >
acosh (MatrixExpr<T_expr> SL_TEXPR_ARG e)
{
  typedef FctACosH <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     = FctATanH
// operator = atanh
// ----------------------------------------------------------------------
template <typename T_expr>
inline MatrixExpr<MatrixUnaryOp<MatrixExpr<T_expr>,
                                FctATanH <typename T_expr::value_t> > >
atanh (MatrixExpr<T_expr> SL_TEXPR_ARG e)
{
  typedef FctATanH <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     = FctCeil
// operator = ceil
// ----------------------------------------------------------------------
template <typename T_expr>
inline MatrixExpr<MatrixUnaryOp<MatrixExpr<T_expr>,
                                FctCeil <typename T_expr::value_t> > >
ceil (MatrixExpr<T_expr> SL_TEXPR_ARG e)
{
  typedef FctCeil <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     = FctFloor
// operator = floor
// ----------------------------------------------------------------------
template <typename T_expr>
inline MatrixExpr<MatrixUnaryOp<MatrixExpr<T_expr>,
                                FctFloor <typename T_expr::value_t> > >
floor (MatrixExpr<T_expr> SL_TEXPR_ARG e)
{
  typedef FctFloor <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     = FctRint
// operator = rint
// ----------------------------------------------------------------------
template <typename T_expr>
inline MatrixExpr<MatrixUnaryOp<MatrixExpr<T_expr>,
                                FctRint <typename T_expr::value_t> > >
rint (MatrixExpr<T_expr> SL_TEXPR_ARG e)
{
  typedef FctRint <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     = FctErF
// operator = erf
// ----------------------------------------------------------------------
template <typename T_expr>
inline MatrixExpr<MatrixUnaryOp<MatrixExpr<T_expr>,
                                FctErF <typename T_expr::value_t> > >
erf (MatrixExpr<T_expr> SL_TEXPR_ARG e)
{
  typedef FctErF <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     = FctErFC
// operator = erfc
// ----------------------------------------------------------------------
template <typename T_expr>
inline MatrixExpr<MatrixUnaryOp<MatrixExpr<T_expr>,
                                FctErFC <typename T_expr::value_t> > >
erfc (MatrixExpr<T_expr> SL_TEXPR_ARG e)
{
  typedef FctErFC <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     = FctJ0
// operator = j0
// ----------------------------------------------------------------------
template <typename T_expr>
inline MatrixExpr<MatrixUnaryOp<MatrixExpr<T_expr>,
                                FctJ0 <typename T_expr::value_t> > >
j0 (MatrixExpr<T_expr> SL_TEXPR_ARG e)
{
  typedef FctJ0 <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     = FctJ1
// operator = j1
// ----------------------------------------------------------------------
template <typename T_expr>
inline MatrixExpr<MatrixUnaryOp<MatrixExpr<T_expr>,
                                FctJ1 <typename T_expr::value_t> > >
j1 (MatrixExpr<T_expr> SL_TEXPR_ARG e)
{
  typedef FctJ1 <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     = FctY0
// operator = y0
// ----------------------------------------------------------------------
template <typename T_expr>
inline MatrixExpr<MatrixUnaryOp<MatrixExpr<T_expr>,
                                FctY0 <typename T_expr::value_t> > >
y0 (MatrixExpr<T_expr> SL_TEXPR_ARG e)
{
  typedef FctY0 <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     = FctY1
// operator = y1
// ----------------------------------------------------------------------
template <typename T_expr>
inline MatrixExpr<MatrixUnaryOp<MatrixExpr<T_expr>,
                                FctY1 <typename T_expr::value_t> > >
y1 (MatrixExpr<T_expr> SL_TEXPR_ARG e)
{
  typedef FctY1 <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     = FctExpM1
// operator = expm1
// ----------------------------------------------------------------------
template <typename T_expr>
inline MatrixExpr<MatrixUnaryOp<MatrixExpr<T_expr>,
                                FctExpM1 <typename T_expr::value_t> > >
expm1 (MatrixExpr<T_expr> SL_TEXPR_ARG e)
{
  typedef FctExpM1 <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     = FctLn1P
// operator = log1p
// ----------------------------------------------------------------------
template <typename T_expr>
inline MatrixExpr<MatrixUnaryOp<MatrixExpr<T_expr>,
                                FctLn1P <typename T_expr::value_t> > >
log1p (MatrixExpr<T_expr> SL_TEXPR_ARG e)
{
  typedef FctLn1P <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     = FctCbRt
// operator = cbrt
// ----------------------------------------------------------------------
template <typename T_expr>
inline MatrixExpr<MatrixUnaryOp<MatrixExpr<T_expr>,
                                FctCbRt <typename T_expr::value_t> > >
cbrt (MatrixExpr<T_expr> SL_TEXPR_ARG e)
{
  typedef FctCbRt <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     = FctLGamma
// operator = lgamma
// ----------------------------------------------------------------------
template <typename T_expr>
inline MatrixExpr<MatrixUnaryOp<MatrixExpr<T_expr>,
                                FctLGamma <typename T_expr::value_t> > >
lgamma (MatrixExpr<T_expr> SL_TEXPR_ARG e)
{
  typedef FctLGamma <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     = FctIsNaN
// operator = isnan
// ----------------------------------------------------------------------
template <typename T_expr>
inline MatrixExpr<MatrixUnaryOp<MatrixExpr<T_expr>,
                                FctIsNaN <typename T_expr::value_t> > >
isnan (MatrixExpr<T_expr> SL_TEXPR_ARG e)
{
  typedef FctIsNaN <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     = FctIsInf
// operator = isinf
// ----------------------------------------------------------------------
template <typename T_expr>
inline MatrixExpr<MatrixUnaryOp<MatrixExpr<T_expr>,
                                FctIsInf <typename T_expr::value_t> > >
isinf (MatrixExpr<T_expr> SL_TEXPR_ARG e)
{
  typedef FctIsInf <typename T_expr::value_t> op_t;
  typedef MatrixExpr<T_expr> expr_t1;
  typedef MatrixUnaryOp<expr_t1, op_t> expr_t;