CPPLapack Code

//=============================================================================
//! Real Double-precision Symmetric Sparse Matrix Class
class zhsmatrix
{
private:
  //// objects ////
  long N; //!< matrix row and column size (NOT accessible)
  long CAP; //!< the length of data arrays (NOT accessible)
  long VOL; //!< the number of non-zero components (NOT accessible)
  std::complex<double>* Array; //!< 1D array to store non-zero matrix data (NOT accessible)
  long* Indx; //!< 1D array to store the i-index of non-zero matrix components (NOT accessible)
  long* Jndx; //!< 1D array to store the j-index of non-zero matrix components (NOT accessible)
  std::vector< std::pair<long,long> >* Line; //!< array of vector to store the entry information of component for each row and column
  
public:
  //// const references ////
  long const& n; //!< matrix row and column size (readable)
  long const& cap; //!<  the length of data arrays (readable)
  long const& vol; //!< the number of non-zero components (readable)
  std::complex<double>* const& array; //!< 1D array to store matrix data (readable)
  long* const& indx; //!< 1D array to store the i-index of non-zero matrix components (readable)
  long* const& jndx; //!< 1D array to store the j-index of non-zero matrix components (readable)
  std::vector< std::pair<long,long> >* const& line; //!< array of vector to store the entry information of component for each row and column (readable)
  long const& m; //!< matrix row and column size (readable)
  long const& M; //!< matrix row and column size (readable)
  
  //// constructor ////
  inline zhsmatrix();
  inline zhsmatrix(const zhsmatrix&);
  inline zhsmatrix(const _zhsmatrix&);
  //inline zhsmatrix(const zhematrix&);
  //inline zhsmatrix(const _zhematrix&);
  inline zhsmatrix(const long&, const long=0);
  inline zhsmatrix(const char*);
  inline zhsmatrix(const zgematrix&);
  inline ~zhsmatrix(); //destructor
  
  //// cast ////
  inline _zgematrix to_zgematrix() const;
  
  //// io ////
  inline std::complex<double> operator()(const long&, const long&) const;
  inline std::complex<double>& operator()(const long&, const long&);
  inline zhsmatrix& put(const long&, const long&, const std::complex<double>&);
  inline zhsmatrix& fput(const long&, const long&, const std::complex<double>&);
  inline zhsmatrix& del(const long, const long); //<-- NOT (const long&)
  inline zhsmatrix& fdel(const long); //<-- NOT (const long&)
  inline friend std::ostream& operator<<(std::ostream&, const zhsmatrix&);
  inline void write(const char *) const;
  inline void read(const char *);

  //// misc ////
  inline void clear();
  inline zhsmatrix& zero();
  inline void chsign();
  inline void copy(const zhsmatrix&);
  inline void shallow_copy(const _zhsmatrix&);
  inline void resize(const long&, const long=0);
  inline void stretch(const long&);
  inline void expand(const long&);
  inline bool isListed(const long&, const long&);
  inline long number(const long&, const long&);
  //inline void unique();
  inline void checkup();
  inline friend void swap(zhsmatrix&, zhsmatrix&);
  inline friend _zhsmatrix _(zhsmatrix&);
  
  //// calc ////
  inline friend _zhsmatrix t(const zhsmatrix&);
  inline friend void idamax(long&, long&, const zhsmatrix&);
  inline friend std::complex<double> damax(const zhsmatrix&);
  
  //// unary ////
  inline friend const zhsmatrix& operator+(const zhsmatrix&);
  inline friend _zhsmatrix operator-(const zhsmatrix&);
  
  //// operators with zhsmatrix ////
  inline zhsmatrix& operator=(const zhsmatrix&);
  inline zhsmatrix& operator+=(const zhsmatrix&);
  inline zhsmatrix& operator-=(const zhsmatrix&);
  
  //// operators with _zhsmatrix ////
  inline zhsmatrix& operator=(const _zhsmatrix&);
  inline zhsmatrix& operator+=(const _zhsmatrix&);
  inline zhsmatrix& operator-=(const _zhsmatrix&);
  
  //// operators with double ////
  inline zhsmatrix& operator*=(const double&);
  inline zhsmatrix& operator/=(const double&);
  //// operators with std::complex<std::complex<std::complex<double>>> ////
  inline zhsmatrix& operator*=(const std::complex<double>&);
  inline zhsmatrix& operator/=(const std::complex<double>&);

  //// + ////
  inline friend _zgematrix operator+(const  zhsmatrix&, const  zgematrix&);
  inline friend _zgematrix operator+(const  zhsmatrix&, const _zgematrix&);
  inline friend _zgematrix operator+(const  zgematrix&, const  zhsmatrix&);
  inline friend _zgematrix operator+(const _zgematrix&, const  zhsmatrix&);
  
  inline friend _zgematrix operator+(const  zhsmatrix&, const  zgbmatrix&);
  inline friend _zgematrix operator+(const  zhsmatrix&, const _zgbmatrix&);
  inline friend _zgematrix operator+(const  zgbmatrix&, const  zhsmatrix&);
  inline friend _zgematrix operator+(const _zgbmatrix&, const  zhsmatrix&);
  
  inline friend _zgematrix operator+(const  zhsmatrix&, const  zhematrix&);
  inline friend _zgematrix operator+(const  zhsmatrix&, const _zhematrix&);
  inline friend _zgematrix operator+(const  zhematrix&, const  zhsmatrix&);
  inline friend _zgematrix operator+(const _zhematrix&, const  zhsmatrix&);
  
  inline friend _zhsmatrix operator+(const  zhsmatrix&, const  zhsmatrix&);
  inline friend _zhsmatrix operator+(const  zhsmatrix&, const _zhsmatrix&);
  inline friend _zhsmatrix operator+(const _zhsmatrix&, const  zhsmatrix&);
  
  //// - ////
  inline friend _zgematrix operator-(const  zhsmatrix&, const  zgematrix&);
  inline friend _zgematrix operator-(const  zhsmatrix&, const _zgematrix&);
  inline friend _zgematrix operator-(const  zgematrix&, const  zhsmatrix&);
  inline friend _zgematrix operator-(const _zgematrix&, const  zhsmatrix&);
  
  inline friend _zgematrix operator-(const  zhsmatrix&, const  zgbmatrix&);
  inline friend _zgematrix operator-(const  zhsmatrix&, const _zgbmatrix&);
  inline friend _zgematrix operator-(const  zgbmatrix&, const  zhsmatrix&);
  inline friend _zgematrix operator-(const _zgbmatrix&, const  zhsmatrix&);
  
  inline friend _zgematrix operator-(const  zhsmatrix&, const  zhematrix&);
  inline friend _zgematrix operator-(const  zhsmatrix&, const _zhematrix&);
  inline friend _zgematrix operator-(const  zhematrix&, const  zhsmatrix&);
  inline friend _zgematrix operator-(const _zhematrix&, const  zhsmatrix&);
  
  inline friend _zhsmatrix operator-(const  zhsmatrix&, const  zhsmatrix&);
  inline friend _zhsmatrix operator-(const  zhsmatrix&, const _zhsmatrix&);
  inline friend _zhsmatrix operator-(const _zhsmatrix&, const  zhsmatrix&);
  
  //// * ////
  inline friend _zgematrix operator*(const  zhsmatrix&, const  zgematrix&);
  inline friend _zgematrix operator*(const  zhsmatrix&, const _zgematrix&);  
  inline friend _zgematrix operator*(const  zgematrix&, const  zhsmatrix&);
  inline friend _zgematrix operator*(const _zgematrix&, const  zhsmatrix&);
  
  inline friend _zgematrix operator*(const  zhsmatrix&, const  zgbmatrix&);
  inline friend _zgematrix operator*(const  zhsmatrix&, const _zgbmatrix&);  
  inline friend _zgematrix operator*(const  zgbmatrix&, const  zhsmatrix&);
  inline friend _zgematrix operator*(const _zgbmatrix&, const  zhsmatrix&);
  
  inline friend _zgematrix operator*(const  zhematrix&, const  zhsmatrix&);
  inline friend _zgematrix operator*(const _zhematrix&, const  zhsmatrix&);
  inline friend _zgematrix operator*(const  zhsmatrix&, const  zhematrix&);
  inline friend _zgematrix operator*(const  zhsmatrix&, const _zhematrix&);

  inline friend _zgsmatrix operator*(const  zhsmatrix&, const  zhsmatrix&);
  inline friend _zgsmatrix operator*(const  zhsmatrix&, const _zhsmatrix&);
  inline friend _zgsmatrix operator*(const _zhsmatrix&, const  zhsmatrix&);
  
  inline friend _zcovector operator*(const  zhsmatrix&, const  zcovector&);
  inline friend _zcovector operator*(const  zhsmatrix&, const _zcovector&);
  
  inline friend _zrovector operator*(const  zrovector&, const  zhsmatrix&);
  inline friend _zrovector operator*(const _zrovector&, const  zhsmatrix&);
  
  inline friend _zhsmatrix operator*(const  zhsmatrix&, const  double&);
  inline friend _zhsmatrix operator*(const  double&,    const  zhsmatrix&);
  
  inline friend _zhsmatrix operator*(const  zhsmatrix&, const  std::complex<double>&);
  inline friend _zhsmatrix operator*(const  std::complex<double>&, const  zhsmatrix&);
  
  //// / ////
  inline friend _zhsmatrix operator/(const  zhsmatrix&, const double&);
  inline friend _zhsmatrix operator/(const  zhsmatrix&, const std::complex<double>&);

  //// friend classes ////
  friend class  zgematrix;
  friend class _zgematrix;
  friend class  zgbmatrix;
  friend class _zgbmatrix;
  friend class  zhematrix;
  friend class _zhematrix;
  friend class  zgsmatrix;
  friend class _zgsmatrix;
  friend class _zhsmatrix;
  friend class  zcovector;
  friend class _zcovector;
  friend class  zrovector;
  friend class _zrovector;
};