complex.hh

Go to the documentation of this file.

 
#ifndef complex_hh
#define complex_hh
 
#include <complex>
#include "basis.hh"
#include "basics/exceptions.hh"
#include "basics/typedefs.hh"
 
namespace concepts {
 
  // ************************************************************* CmplxPart **
 
  class CmplxPart : public Function<Real> {
  public:
    inline CmplxPart(const Function<Cmplx>& fnc) :
      Function<Real>(fnc.dim()), cfnc_(&fnc), fnc_(0) {}
    inline CmplxPart(Function<Cmplx>& fnc) :
      Function<Real>(fnc.dim()), cfnc_(0), fnc_(&fnc) {}
 
    virtual Function<Real>& operator=(const Function<Real>& fnc) {
      throw conceptsException(MissingFeature("not implemented"));
      return *this;
    }
  protected:
    virtual std::ostream& info(std::ostream& os) const;
    const Function<Cmplx>* cfnc_;
    Function<Cmplx>* fnc_;
  };
 
  // ************************************************************** RealPart **
  
  class RealPart : public CmplxPart {
  public:
    inline RealPart(const Function<Cmplx>& fnc) : CmplxPart(fnc) {}
    inline RealPart(Function<Cmplx>& fnc) : CmplxPart(fnc) {}
 
    virtual Real& operator()(uint i) {
      conceptsAssert(this->fnc_, Assertion());
      return *(Real*)&(*this->fnc_)(i);
    }
    virtual Real operator()(uint i) const { 
      if (this->fnc_)
        return std::real((*this->fnc_)(i));
      return std::real((*this->cfnc_)(i));
    }
  protected:
    virtual std::ostream& info(std::ostream& os) const;
  };
 
  // ************************************************************** ImagPart **
 
  class ImagPart : public CmplxPart {
  public:
    inline ImagPart(const Function<Cmplx>& fnc) : CmplxPart(fnc) {}
    inline ImagPart(Function<Cmplx>& fnc) : CmplxPart(fnc) {}
 
    virtual Real& operator()(uint i) {
      conceptsAssert(this->fnc_, Assertion());
      return *((Real*)&(*this->fnc_)(i)+1);
    }
    virtual Real operator()(uint i) const { 
      if (this->fnc_)
        return std::imag((*this->fnc_)(i));
      return std::imag((*this->cfnc_)(i));
    }
  protected:
    virtual std::ostream& info(std::ostream& os) const;
  };
 
  // ******************************************************* ComplexFunction **
 
  class ComplexFunction : public Function<Cmplx> {
  public:
    inline ComplexFunction(const Function<Real>& fnc) :
      Function<Cmplx>(fnc.dim()), cfnc_(fnc) {}
    virtual Function<Cmplx>& operator=(const Function<Cmplx>& fnc) {
      throw conceptsException(MissingFeature("not assignable"));
      return *this;
    }
 
    virtual Cmplx& operator()(uint i) {
      throw conceptsException(MissingFeature("not assignable"));
      return dummy_;
    }
    virtual Cmplx operator()(uint i) const { 
      return cfnc_(i);
    }
  protected:
    virtual std::ostream& info(std::ostream& os) const;
  private:
    const Function<Real>& cfnc_;
    Cmplx dummy_;
  };
 
} // namespace concepts
 
#endif // complex_hh