matrix_complex.h

高效的c++科学算法库

// ------------------------------------------------------- -*- c++ -*- --
//
// WARNING: FILE AUTOMATICALLY GENERATED WITH matrix_complex.sed
//
// ----------------------------------------------------------------------
// from:  matrix_complex_e.hxx
// from:  matrix_complex_l.hxx
// from:  matrix_complex_m.hxx
// ----------------------------------------------------------------------

// ---------------------------------------------------------- -*- c++ -*-
// Matrix Unary Operator
// ----------------------------------------------------------------------
// file     = matrix_complex_e.hxx
// name     = OpConj
// operator = operator~
// ----------------------------------------------------------------------
template <typename T_expr>
inline MatrixExpr<MatrixUnaryOp<MatrixExpr<T_expr>,
                                OpConj <typename T_expr::value_t> > >
operator~ (MatrixExpr<T_expr> SL_TEXPR_ARG e)
{
  typedef OpConj <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_complex_e.hxx
// name     = FctReal
// operator = real
// ----------------------------------------------------------------------
template <typename T_expr>
inline MatrixExpr<MatrixUnaryOp<MatrixExpr<T_expr>,
                                FctReal <typename T_expr::value_t> > >
real (MatrixExpr<T_expr> SL_TEXPR_ARG e)
{
  typedef FctReal <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_complex_e.hxx
// name     = FctImag
// operator = imag
// ----------------------------------------------------------------------
template <typename T_expr>
inline MatrixExpr<MatrixUnaryOp<MatrixExpr<T_expr>,
                                FctImag <typename T_expr::value_t> > >
imag (MatrixExpr<T_expr> SL_TEXPR_ARG e)
{
  typedef FctImag <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_complex_e.hxx
// name     = FctReal
// operator = re
// ----------------------------------------------------------------------
template <typename T_expr>
inline MatrixExpr<MatrixUnaryOp<MatrixExpr<T_expr>,
                                FctReal <typename T_expr::value_t> > >
re (MatrixExpr<T_expr> SL_TEXPR_ARG e)
{
  typedef FctReal <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_complex_e.hxx
// name     = FctImag
// operator = im
// ----------------------------------------------------------------------
template <typename T_expr>
inline MatrixExpr<MatrixUnaryOp<MatrixExpr<T_expr>,
                                FctImag <typename T_expr::value_t> > >
im (MatrixExpr<T_expr> SL_TEXPR_ARG e)
{
  typedef FctImag <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_complex_e.hxx
// name     = FctExRI
// operator = exri
// ----------------------------------------------------------------------
template <typename T_expr>
inline MatrixExpr<MatrixUnaryOp<MatrixExpr<T_expr>,
                                FctExRI <typename T_expr::value_t> > >
exri (MatrixExpr<T_expr> SL_TEXPR_ARG e)
{
  typedef FctExRI <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_complex_e.hxx
// name     = FctConj
// operator = conj
// ----------------------------------------------------------------------
template <typename T_expr>
inline MatrixExpr<MatrixUnaryOp<MatrixExpr<T_expr>,
                                FctConj <typename T_expr::value_t> > >
conj (MatrixExpr<T_expr> SL_TEXPR_ARG e)
{
  typedef FctConj <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_complex_e.hxx
// name     = FctSign
// operator = sign
// ----------------------------------------------------------------------
template <typename T_expr>
inline MatrixExpr<MatrixUnaryOp<MatrixExpr<T_expr>,
                                FctSign <typename T_expr::value_t> > >
sign (MatrixExpr<T_expr> SL_TEXPR_ARG e)
{
  typedef FctSign <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_complex_e.hxx
// name     = FctNorm
// operator = norm
// ----------------------------------------------------------------------
template <typename T_expr>
inline MatrixExpr<MatrixUnaryOp<MatrixExpr<T_expr>,
                                FctNorm <typename T_expr::value_t> > >
norm (MatrixExpr<T_expr> SL_TEXPR_ARG e)
{
  typedef FctNorm <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_complex_e.hxx
// name     = FctArg
// operator = arg
// ----------------------------------------------------------------------
template <typename T_expr>
inline MatrixExpr<MatrixUnaryOp<MatrixExpr<T_expr>,
                                FctArg <typename T_expr::value_t> > >
arg (MatrixExpr<T_expr> SL_TEXPR_ARG e)
{
  typedef FctArg <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_complex_e.hxx
// name     = FctRect
// operator = rect
// ----------------------------------------------------------------------
template <typename T_expr>
inline MatrixExpr<MatrixUnaryOp<MatrixExpr<T_expr>,
                                FctRect <typename T_expr::value_t> > >
rect (MatrixExpr<T_expr> SL_TEXPR_ARG e)
{
  typedef FctRect <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_complex_e.hxx
// name     = FctPolar
// operator = polar
// ----------------------------------------------------------------------
template <typename T_expr>
inline MatrixExpr<MatrixUnaryOp<MatrixExpr<T_expr>,
                                FctPolar <typename T_expr::value_t> > >
polar (MatrixExpr<T_expr> SL_TEXPR_ARG e)
{
  typedef FctPolar <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_complex_l.hxx
// name     = OpConj
// operator = operator~
// ----------------------------------------------------------------------
inline MatrixExpr<MatrixUnaryOp<LoopIndex, OpConj <Index> > >
operator~ (LoopIndex SL_TEXPR_ARG l)                        
{                                                            
  typedef OpConj <Index> op_t;                               
  typedef LoopIndex expr_t1;                                 
  typedef MatrixUnaryOp<expr_t1, op_t> expr_t;               
                                                             
  return MatrixExpr<expr_t> ( expr_t( l ) );                 
}
// ---------------------------------------------------------- -*- c++ -*-
// Matrix Unary Operator
// ----------------------------------------------------------------------
// file     = matrix_complex_l.hxx
// name     = FctReal
// operator = real
// ----------------------------------------------------------------------
inline MatrixExpr<MatrixUnaryOp<LoopIndex, FctReal <Index> > >
real (LoopIndex SL_TEXPR_ARG l)                        
{                                                            
  typedef FctReal <Index> op_t;                               
  typedef LoopIndex expr_t1;                                 
  typedef MatrixUnaryOp<expr_t1, op_t> expr_t;               
                                                             
  return MatrixExpr<expr_t> ( expr_t( l ) );                 
}
// ---------------------------------------------------------- -*- c++ -*-
// Matrix Unary Operator
// ----------------------------------------------------------------------
// file     = matrix_complex_l.hxx
// name     = FctImag
// operator = imag
// ----------------------------------------------------------------------
inline MatrixExpr<MatrixUnaryOp<LoopIndex, FctImag <Index> > >
imag (LoopIndex SL_TEXPR_ARG l)                        
{                                                            
  typedef FctImag <Index> op_t;                               
  typedef LoopIndex expr_t1;                                 
  typedef MatrixUnaryOp<expr_t1, op_t> expr_t;               
                                                             
  return MatrixExpr<expr_t> ( expr_t( l ) );                 
}
// ---------------------------------------------------------- -*- c++ -*-
// Matrix Unary Operator
// ----------------------------------------------------------------------
// file     = matrix_complex_l.hxx
// name     = FctReal
// operator = re
// ----------------------------------------------------------------------
inline MatrixExpr<MatrixUnaryOp<LoopIndex, FctReal <Index> > >
re (LoopIndex SL_TEXPR_ARG l)                        
{                                                            
  typedef FctReal <Index> op_t;                               
  typedef LoopIndex expr_t1;                                 
  typedef MatrixUnaryOp<expr_t1, op_t> expr_t;               
                                                             
  return MatrixExpr<expr_t> ( expr_t( l ) );                 
}
// ---------------------------------------------------------- -*- c++ -*-
// Matrix Unary Operator
// ----------------------------------------------------------------------
// file     = matrix_complex_l.hxx
// name     = FctImag
// operator = im
// ----------------------------------------------------------------------
inline MatrixExpr<MatrixUnaryOp<LoopIndex, FctImag <Index> > >
im (LoopIndex SL_TEXPR_ARG l)                        
{                                                            
  typedef FctImag <Index> op_t;                               
  typedef LoopIndex expr_t1;                                 
  typedef MatrixUnaryOp<expr_t1, op_t> expr_t;               
                                                             
  return MatrixExpr<expr_t> ( expr_t( l ) );                 
}
// ---------------------------------------------------------- -*- c++ -*-
// Matrix Unary Operator
// ----------------------------------------------------------------------
// file     = matrix_complex_l.hxx
// name     = FctExRI
// operator = exri
// ----------------------------------------------------------------------