matrix_complex.h

高效的c++科学算法库

inline MatrixExpr<MatrixUnaryOp<LoopIndex, FctExRI <Index> > >
exri (LoopIndex SL_TEXPR_ARG l)                        
{                                                            
  typedef FctExRI <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     = FctConj
// operator = conj
// ----------------------------------------------------------------------
inline MatrixExpr<MatrixUnaryOp<LoopIndex, FctConj <Index> > >
conj (LoopIndex SL_TEXPR_ARG l)                        
{                                                            
  typedef FctConj <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     = FctSign
// operator = sign
// ----------------------------------------------------------------------
inline MatrixExpr<MatrixUnaryOp<LoopIndex, FctSign <Index> > >
sign (LoopIndex SL_TEXPR_ARG l)                        
{                                                            
  typedef FctSign <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     = FctNorm
// operator = norm
// ----------------------------------------------------------------------
inline MatrixExpr<MatrixUnaryOp<LoopIndex, FctNorm <Index> > >
norm (LoopIndex SL_TEXPR_ARG l)                        
{                                                            
  typedef FctNorm <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     = FctArg
// operator = arg
// ----------------------------------------------------------------------
inline MatrixExpr<MatrixUnaryOp<LoopIndex, FctArg <Index> > >
arg (LoopIndex SL_TEXPR_ARG l)                        
{                                                            
  typedef FctArg <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     = FctRect
// operator = rect
// ----------------------------------------------------------------------
inline MatrixExpr<MatrixUnaryOp<LoopIndex, FctRect <Index> > >
rect (LoopIndex SL_TEXPR_ARG l)                        
{                                                            
  typedef FctRect <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     = FctPolar
// operator = polar
// ----------------------------------------------------------------------
inline MatrixExpr<MatrixUnaryOp<LoopIndex, FctPolar <Index> > >
polar (LoopIndex SL_TEXPR_ARG l)                        
{                                                            
  typedef FctPolar <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_m.hxx
// name     = OpConj
// operator = operator~
// ----------------------------------------------------------------------
template <typename T_value, typename T_structure, typename T_storage>      
inline MatrixExpr<MatrixUnaryOp<Matrix<T_value,T_structure, T_storage>,
                  OpConj <T_value> > > 
operator~ (Matrix<T_value, T_structure, T_storage> SL_TEXPR_ARG m)    
{        
  typedef OpConj <T_value> op_t;
  typedef Matrix<T_value, T_structure, T_storage> expr_t1;
  typedef MatrixUnaryOp<expr_t1, op_t> expr_t;                             
  return MatrixExpr<expr_t> ( expr_t( m ) );
}
// ---------------------------------------------------------- -*- c++ -*-
// Matrix Unary Operator
// ----------------------------------------------------------------------
// file     = matrix_complex_m.hxx
// name     = FctReal
// operator = real
// ----------------------------------------------------------------------
template <typename T_value, typename T_structure, typename T_storage>      
inline MatrixExpr<MatrixUnaryOp<Matrix<T_value,T_structure, T_storage>,
                  FctReal <T_value> > > 
real (Matrix<T_value, T_structure, T_storage> SL_TEXPR_ARG m)    
{        
  typedef FctReal <T_value> op_t;
  typedef Matrix<T_value, T_structure, T_storage> expr_t1;
  typedef MatrixUnaryOp<expr_t1, op_t> expr_t;                             
  return MatrixExpr<expr_t> ( expr_t( m ) );
}
// ---------------------------------------------------------- -*- c++ -*-
// Matrix Unary Operator
// ----------------------------------------------------------------------
// file     = matrix_complex_m.hxx
// name     = FctImag
// operator = imag
// ----------------------------------------------------------------------
template <typename T_value, typename T_structure, typename T_storage>      
inline MatrixExpr<MatrixUnaryOp<Matrix<T_value,T_structure, T_storage>,
                  FctImag <T_value> > > 
imag (Matrix<T_value, T_structure, T_storage> SL_TEXPR_ARG m)    
{        
  typedef FctImag <T_value> op_t;
  typedef Matrix<T_value, T_structure, T_storage> expr_t1;
  typedef MatrixUnaryOp<expr_t1, op_t> expr_t;                             
  return MatrixExpr<expr_t> ( expr_t( m ) );
}
// ---------------------------------------------------------- -*- c++ -*-
// Matrix Unary Operator
// ----------------------------------------------------------------------
// file     = matrix_complex_m.hxx
// name     = FctReal
// operator = re
// ----------------------------------------------------------------------
template <typename T_value, typename T_structure, typename T_storage>      
inline MatrixExpr<MatrixUnaryOp<Matrix<T_value,T_structure, T_storage>,
                  FctReal <T_value> > > 
re (Matrix<T_value, T_structure, T_storage> SL_TEXPR_ARG m)    
{        
  typedef FctReal <T_value> op_t;
  typedef Matrix<T_value, T_structure, T_storage> expr_t1;
  typedef MatrixUnaryOp<expr_t1, op_t> expr_t;                             
  return MatrixExpr<expr_t> ( expr_t( m ) );
}
// ---------------------------------------------------------- -*- c++ -*-
// Matrix Unary Operator
// ----------------------------------------------------------------------
// file     = matrix_complex_m.hxx
// name     = FctImag
// operator = im
// ----------------------------------------------------------------------
template <typename T_value, typename T_structure, typename T_storage>      
inline MatrixExpr<MatrixUnaryOp<Matrix<T_value,T_structure, T_storage>,
                  FctImag <T_value> > > 
im (Matrix<T_value, T_structure, T_storage> SL_TEXPR_ARG m)    
{        
  typedef FctImag <T_value> op_t;
  typedef Matrix<T_value, T_structure, T_storage> expr_t1;
  typedef MatrixUnaryOp<expr_t1, op_t> expr_t;                             
  return MatrixExpr<expr_t> ( expr_t( m ) );
}
// ---------------------------------------------------------- -*- c++ -*-
// Matrix Unary Operator
// ----------------------------------------------------------------------
// file     = matrix_complex_m.hxx
// name     = FctExRI
// operator = exri
// ----------------------------------------------------------------------
template <typename T_value, typename T_structure, typename T_storage>      
inline MatrixExpr<MatrixUnaryOp<Matrix<T_value,T_structure, T_storage>,
                  FctExRI <T_value> > > 
exri (Matrix<T_value, T_structure, T_storage> SL_TEXPR_ARG m)    
{        
  typedef FctExRI <T_value> op_t;
  typedef Matrix<T_value, T_structure, T_storage> expr_t1;
  typedef MatrixUnaryOp<expr_t1, op_t> expr_t;                             
  return MatrixExpr<expr_t> ( expr_t( m ) );
}
// ---------------------------------------------------------- -*- c++ -*-
// Matrix Unary Operator
// ----------------------------------------------------------------------
// file     = matrix_complex_m.hxx
// name     = FctConj
// operator = conj
// ----------------------------------------------------------------------
template <typename T_value, typename T_structure, typename T_storage>      
inline MatrixExpr<MatrixUnaryOp<Matrix<T_value,T_structure, T_storage>,
                  FctConj <T_value> > > 
conj (Matrix<T_value, T_structure, T_storage> SL_TEXPR_ARG m)    
{        
  typedef FctConj <T_value> op_t;
  typedef Matrix<T_value, T_structure, T_storage> expr_t1;
  typedef MatrixUnaryOp<expr_t1, op_t> expr_t;                             
  return MatrixExpr<expr_t> ( expr_t( m ) );
}
// ---------------------------------------------------------- -*- c++ -*-
// Matrix Unary Operator
// ----------------------------------------------------------------------
// file     = matrix_complex_m.hxx
// name     = FctSign
// operator = sign
// ----------------------------------------------------------------------
template <typename T_value, typename T_structure, typename T_storage>      
inline MatrixExpr<MatrixUnaryOp<Matrix<T_value,T_structure, T_storage>,
                  FctSign <T_value> > > 
sign (Matrix<T_value, T_structure, T_storage> SL_TEXPR_ARG m)    
{        
  typedef FctSign <T_value> op_t;
  typedef Matrix<T_value, T_structure, T_storage> expr_t1;
  typedef MatrixUnaryOp<expr_t1, op_t> expr_t;                             
  return MatrixExpr<expr_t> ( expr_t( m ) );
}
// ---------------------------------------------------------- -*- c++ -*-
// Matrix Unary Operator
// ----------------------------------------------------------------------
// file     = matrix_complex_m.hxx
// name     = FctNorm
// operator = norm
// ----------------------------------------------------------------------
template <typename T_value, typename T_structure, typename T_storage>      
inline MatrixExpr<MatrixUnaryOp<Matrix<T_value,T_structure, T_storage>,
                  FctNorm <T_value> > > 
norm (Matrix<T_value, T_structure, T_storage> SL_TEXPR_ARG m)    
{        
  typedef FctNorm <T_value> op_t;
  typedef Matrix<T_value, T_structure, T_storage> expr_t1;
  typedef MatrixUnaryOp<expr_t1, op_t> expr_t;                             
  return MatrixExpr<expr_t> ( expr_t( m ) );
}
// ---------------------------------------------------------- -*- c++ -*-
// Matrix Unary Operator
// ----------------------------------------------------------------------
// file     = matrix_complex_m.hxx
// name     = FctArg
// operator = arg
// ----------------------------------------------------------------------
template <typename T_value, typename T_structure, typename T_storage>      
inline MatrixExpr<MatrixUnaryOp<Matrix<T_value,T_structure, T_storage>,
                  FctArg <T_value> > > 
arg (Matrix<T_value, T_structure, T_storage> SL_TEXPR_ARG m)    
{        
  typedef FctArg <T_value> op_t;
  typedef Matrix<T_value, T_structure, T_storage> expr_t1;
  typedef MatrixUnaryOp<expr_t1, op_t> expr_t;                             
  return MatrixExpr<expr_t> ( expr_t( m ) );
}
// ---------------------------------------------------------- -*- c++ -*-
// Matrix Unary Operator
// ----------------------------------------------------------------------
// file     = matrix_complex_m.hxx
// name     = FctRect
// operator = rect
// ----------------------------------------------------------------------
template <typename T_value, typename T_structure, typename T_storage>      
inline MatrixExpr<MatrixUnaryOp<Matrix<T_value,T_structure, T_storage>,
                  FctRect <T_value> > > 
rect (Matrix<T_value, T_structure, T_storage> SL_TEXPR_ARG m)    
{        
  typedef FctRect <T_value> op_t;
  typedef Matrix<T_value, T_structure, T_storage> expr_t1;
  typedef MatrixUnaryOp<expr_t1, op_t> expr_t;                             
  return MatrixExpr<expr_t> ( expr_t( m ) );
}
// ---------------------------------------------------------- -*- c++ -*-
// Matrix Unary Operator
// ----------------------------------------------------------------------
// file     = matrix_complex_m.hxx
// name     = FctPolar
// operator = polar
// ----------------------------------------------------------------------
template <typename T_value, typename T_structure, typename T_storage>      
inline MatrixExpr<MatrixUnaryOp<Matrix<T_value,T_structure, T_storage>,
                  FctPolar <T_value> > > 
polar (Matrix<T_value, T_structure, T_storage> SL_TEXPR_ARG m)    
{        
  typedef FctPolar <T_value> op_t;
  typedef Matrix<T_value, T_structure, T_storage> expr_t1;
  typedef MatrixUnaryOp<expr_t1, op_t> expr_t;                             
  return MatrixExpr<expr_t> ( expr_t( m ) );
}
// ----------------------------------------------------------------------
// end of file