QVectorC.hh

Go to the documentation of this file.

 
#ifndef __QVECTORC_HH_
#define __QVECTORC_HH_
 
#include <gsl/gsl_vector.h>
#include <gsl/gsl_vector_complex_double.h>
#include <iostream>
#include <string>
#include "QObject.hh"
#include "QVector.hh"
#include "QComplex.hh"
 
Q_BEGIN_NAMESPACE
 
//class QVector;
//class QComplex;
class QMatrixC;
 
class QVectorC : public QObject {
public:
  QVectorC();
  explicit QVectorC(const UInt_t size);
  QVectorC(const QVectorC& orig);
  QVectorC(const QVector& re, const QVector& im);
  explicit QVectorC(const QVector& vec);
  //        QVectorC(const QVectorC& orig, UInt_t size, UInt_t ioff = 0);
  //        QVectorC(const QMatrix& mat);
  ~QVectorC();
  void Clear() {Resize(0);};
  
  void SetArray(const double* re, const double* im, UInt_t size);
  inline UInt_t Size() const {return fSize/2;};
  void Initialize(const double re = 0,const double im =0);
  void Initialize(const QComplex val);
  QComplex operator[](const UInt_t i);
  QComplex operator()(const UInt_t i){ return operator[](i); }
  const QComplex operator[] (const UInt_t i) const;
  const QComplex operator() (const UInt_t i) const { return operator[](i); }
  const QVectorC& operator = (const QVectorC& orig);
  QVector& Re();
  QVector& Im();
 
  const QVector& Re() const;
  const QVector& Im() const;
 
  QVector GetMagnitudes() const;
  QVector GetMagnitudesSquare() const;
  QVector GetPhase() const;
 
  inline QVector GetModulus() const {return GetMagnitudes();};
  inline QVector GetModulusSquare() const {return GetMagnitudesSquare();};
  //        const QVectorC& Mult(const QVectorC& other);
  QVectorC Mult(const QVectorC& other) const;
 
  const QVectorC& MultIn(const QVectorC& other);
  QVectorC Mult(const QVector& other) const;
  //        const QVectorC& Div(const QVectorC& other);
  QVectorC Div(const QVectorC& other) const;
 
  //        const QVectorC& Div(const QVectorC& other);
  const QVectorC& DivIn(const QVectorC& other);
  
  QVectorC Div(const QVector &other) const;
  
  const QVectorC& Rebin(const int rebin,bool sum=false);
 
  const QVectorC& Shift(const int nstep);
  const QVectorC& ShiftReal(const double fstep);
  QVectorC  operator-() const;
  const QVectorC& operator*=(const double t);
  const QVectorC& operator*=(const QComplex& t);
  const QVectorC& operator/=(const double v);
  const QVectorC& operator/=(const QComplex& t);
  const QVectorC& operator-=(const QComplex& t);
 
  const QVectorC& operator+=(const QVectorC&v);
  const QVectorC& operator-=(const QVectorC&v);
  QComplex operator*(const QVectorC& other) const;
  QVectorC operator*(const double t) const;
  QMatrixC operator*(const QMatrixC&) const;
  QVectorC operator+(const QVectorC& other) const;
  QVectorC operator-(const QVectorC& other) const;
  QVectorC operator/(const double t) const;
 
  QMatrixC H() const;
 
  QVectorC &Conjugate();
  QVectorC Conj() const;
 
  /*
   * @brief multiplication by complex number @param t @return
   * the same object modified
   */
  QVectorC operator*(const QComplex& t) const;
  QVectorC operator/(const QComplex& t) const;
 
  void Resize(const UInt_t newsize);
  void Append(const QComplex& val);
  void Append(const double re,const double im=0);
  void Append(const QVectorC& vec);
  void SetRe(const QVector& re);
  void SetIm(const QVector& im);
  double Norma() const;
 
  QComplex Sum(UInt_t nelem, UInt_t first = 0) const;
  QComplex Sum() const { return Sum(Size(),0); }
 
  //        double GetRMS(UInt_t nelem, UInt_t first = 0) const; 
  //       double GetMedian() const;
  //     double GetMedianAbsoluteDeviation() const;
  //        inline double GetMax() const {return gsl_vector_max(fMathVec);}
  //        inline double GetMin() const {return gsl_vector_min(fMathVec);}
  //        int GetMaxIndex(UInt_t nelem, UInt_t first) const;
  //    int GetMinIndex(UInt_t nelem, UInt_t first) const;
  //    inline UInt_t GetMaxIndex() const {return gsl_vector_max_index(fMathVec);}
  //    inline UInt_t GetMinIndex() const {return gsl_vector_min_index(fMathVec);}
  //    double* GetArray() const;
  //    const double* GetConstArray() const {return fMathVec ? fMathVec->data : NULL;}
  //  void SetArray(const double *orig, UInt_t size);
  //   void Consolidate();
  //    std::string sqlString() const;
 
  QVector SingleVector() const;
 
  QVector &InterleavedVector() const; 
  
  QVectorC GetSubVector(UInt_t N,UInt_t start=0,UInt_t stride=1);
  const QVectorC GetSubVector(UInt_t N,UInt_t start=0,UInt_t stride=1) const;
 
  void Print(const char *opts="") const;
 
protected: 
  QVectorC(gsl_complex *data,const UInt_t size,const UInt_t Stride);
  
  QVectorC(const QVectorC& orig,const bool dataOwner);
 
  static void ArrayCopy(const gsl_complex* orig,const UInt_t origStride, 
                        gsl_complex *dest,const UInt_t destStride,
                        const UInt_t size);
 
  mutable gsl_vector_complex* fMathVec; 
 
  Int_t fSize; 
 
  UInt_t fAllocSize;
 
  // @brief data stride
  Int_t fStride;
 
  double *fData;//[fSize]
 
  bool fDataOwner;
 
  mutable QVector *fRe; 
  mutable  QVector *fIm; 
 
  mutable QVector *fInterleaved; 
 
  //        void SetMathRange(UInt_t start, UInt_t size);
 
private:
  void SetMathVector() const;
  void SetParts() const;
  void InitCopy(const QVectorC& orig,const bool copyData);
 
  friend class QVectorCView;
  friend class QVectorCConstView;
  friend class QMatrixC;
  friend class QMatrixCArray;
  friend class QRealComplexFFTW3;
  friend class QFFTWRealComplexPlan;
  
  QObjectDef(QVectorC,1);
};
 
// operations other than member functions
// formatted printout
 
Q_END_NAMESPACE
Diana::QVectorC operator*(double t, const Diana::QVectorC&v);
 
std::ostream& operator<<(std::ostream&s,const Diana::QVectorC& v);
const Diana::QVector Re(const Diana::QVectorC &Z);
const Diana::QVector Im(const Diana::QVectorC &Z);
 
#endif