Symmetry.hpp

Go to the documentation of this file.

#ifndef CYTNX_SYMMETRY_H_
#define CYTNX_SYMMETRY_H_
 
#include <fstream>
#include <ostream>
#include <string>
#include <vector>
 
#include "boost/smart_ptr/intrusive_ptr.hpp"
 
#include "cytnx_error.hpp"
#include "intrusive_ptr_base.hpp"
#include "Type.hpp"
#include "utils/dynamic_arg_resolver.hpp"
 
namespace cytnx {
  enum SymmetryType : int { Void = -99, U = -1, Z = 0, fPar = -2, fNum = -3 };
 
  enum fermionParity : bool { EVEN = false, ODD = true };
 
  // helper class, has implicitly conversion to vector<int64>!
  class Qs {
   private:
    std::vector<cytnx_int64> tmpQs;
 
   public:
    template <class... Ts>
    Qs(const cytnx_int64 &e1, const Ts... elems) {
      this->tmpQs = dynamic_arg_int64_resolver(e1, elems...);
    }
 
    Qs(const std::vector<cytnx_int64> &qin) { this->tmpQs = qin; }
 
    // interprete as 2d vector directly implicitly convert!
    explicit operator std::vector<cytnx_int64>() const { return this->tmpQs; };
 
    std::pair<std::vector<cytnx_int64>, cytnx_uint64> operator>>(const cytnx_uint64 &dim) {
      return std::make_pair(this->tmpQs, dim);
    }
  };
 
  class Symmetry_base : public intrusive_ptr_base<Symmetry_base> {
   public:
    int stype_id;
    int n;
    Symmetry_base() : stype_id(SymmetryType::Void){};
    Symmetry_base(const int &n) : stype_id(SymmetryType::Void) { this->Init(n); };
    Symmetry_base(const Symmetry_base &rhs);
    Symmetry_base &operator=(const Symmetry_base &rhs);
 
    std::vector<cytnx_int64> combine_rule(const std::vector<cytnx_int64> &inL,
                                          const std::vector<cytnx_int64> &inR);
    cytnx_int64 combine_rule(const cytnx_int64 &inL, const cytnx_int64 &inR,
                             const bool &is_reverse);
 
    cytnx_int64 reverse_rule(const cytnx_int64 &in);
 
    virtual void Init(const int &n){};
    virtual boost::intrusive_ptr<Symmetry_base> clone() { return nullptr; };
    virtual bool check_qnum(
      const cytnx_int64 &in_qnum);  // check the passed in qnums satisfy the symmetry requirement.
    virtual bool check_qnums(const std::vector<cytnx_int64> &in_qnums);
    virtual void combine_rule_(std::vector<cytnx_int64> &out, const std::vector<cytnx_int64> &inL,
                               const std::vector<cytnx_int64> &inR);
    virtual void combine_rule_(cytnx_int64 &out, const cytnx_int64 &inL, const cytnx_int64 &inR,
                               const bool &is_reverse);
    virtual void reverse_rule_(cytnx_int64 &out, const cytnx_int64 &in);
    virtual fermionParity get_fermion_parity(const cytnx_int64 &in_qnum) const;
    virtual bool is_fermionic() const { return false; };
 
    virtual void print_info() const;
    virtual std::string stype_str() const;
    // virtual std::vector<cytnx_int64>& combine_rule(const std::vector<cytnx_int64> &inL, const
    // std::vector<cytnx_int64> &inR);
  };
 
  class U1Symmetry : public Symmetry_base {
   public:
    U1Symmetry() { this->stype_id = SymmetryType::U; };
    U1Symmetry(const int &n) { this->Init(n); };
    void Init(const int &n) {
      this->stype_id = SymmetryType::U;
      this->n = n;
      if (n != 1) cytnx_error_msg(1, "%s", "[ERROR] U1Symmetry should set n = 1");
    }
    boost::intrusive_ptr<Symmetry_base> clone() {
      boost::intrusive_ptr<Symmetry_base> out(new U1Symmetry(this->n));
      return out;
    }
    bool check_qnum(const cytnx_int64 &in_qnum);
    bool check_qnums(const std::vector<cytnx_int64> &in_qnums);
    void combine_rule_(std::vector<cytnx_int64> &out, const std::vector<cytnx_int64> &inL,
                       const std::vector<cytnx_int64> &inR);
    void combine_rule_(cytnx_int64 &out, const cytnx_int64 &inL, const cytnx_int64 &inR,
                       const bool &is_reverse);
    void reverse_rule_(cytnx_int64 &out, const cytnx_int64 &in);
    void print_info() const;
    std::string stype_str() const override { return "U1"; };
  };
 
  class ZnSymmetry : public Symmetry_base {
   public:
    ZnSymmetry() { this->stype_id = SymmetryType::Z; };
    ZnSymmetry(const int &n) { this->Init(n); };
    void Init(const int &n) {
      this->stype_id = SymmetryType::Z;
      this->n = n;
      if (n <= 1) cytnx_error_msg(1, "%s", "[ERROR] ZnSymmetry can only have n > 1");
    }
    boost::intrusive_ptr<Symmetry_base> clone() {
      boost::intrusive_ptr<Symmetry_base> out(new ZnSymmetry(this->n));
      return out;
    }
    bool check_qnum(const cytnx_int64 &in_qnum);
    bool check_qnums(const std::vector<cytnx_int64> &in_qnums);
    void combine_rule_(std::vector<cytnx_int64> &out, const std::vector<cytnx_int64> &inL,
                       const std::vector<cytnx_int64> &inR);
    void combine_rule_(cytnx_int64 &out, const cytnx_int64 &inL, const cytnx_int64 &inR,
                       const bool &is_reverse);
    void reverse_rule_(cytnx_int64 &out, const cytnx_int64 &in);
    void print_info() const;
    std::string stype_str() const override { return "Z" + std::to_string(this->n); };
  };
 
  class FermionParitySymmetry : public Symmetry_base {
   public:
    FermionParitySymmetry() {
      this->stype_id = SymmetryType::fPar;
      this->n = -2;
    };
    boost::intrusive_ptr<Symmetry_base> clone() {
      boost::intrusive_ptr<Symmetry_base> out(new FermionParitySymmetry());
      return out;
    }
    bool check_qnum(const cytnx_int64 &in_qnum);
    bool check_qnums(const std::vector<cytnx_int64> &in_qnums);
    void combine_rule_(std::vector<cytnx_int64> &out, const std::vector<cytnx_int64> &inL,
                       const std::vector<cytnx_int64> &inR);
    void combine_rule_(cytnx_int64 &out, const cytnx_int64 &inL, const cytnx_int64 &inR,
                       const bool &is_reverse);
    void reverse_rule_(cytnx_int64 &out, const cytnx_int64 &in);
    fermionParity get_fermion_parity(const cytnx_int64 &in_qnum) const override;
    bool is_fermionic() const override { return true; };
    void print_info() const;
    std::string stype_str() const override { return "fP"; }
  };
 
  class FermionNumberSymmetry : public Symmetry_base {
   public:
    FermionNumberSymmetry() {
      this->stype_id = SymmetryType::fNum;
      this->n = -1;
    };
    boost::intrusive_ptr<Symmetry_base> clone() {
      boost::intrusive_ptr<Symmetry_base> out(new FermionNumberSymmetry());
      return out;
    }
    bool check_qnum(const cytnx_int64 &in_qnum);
    bool check_qnums(const std::vector<cytnx_int64> &in_qnums);
    void combine_rule_(std::vector<cytnx_int64> &out, const std::vector<cytnx_int64> &inL,
                       const std::vector<cytnx_int64> &inR);
    void combine_rule_(cytnx_int64 &out, const cytnx_int64 &inL, const cytnx_int64 &inR,
                       const bool &is_reverse);
    void reverse_rule_(cytnx_int64 &out, const cytnx_int64 &in);
    fermionParity get_fermion_parity(const cytnx_int64 &in_qnum) const override;
    bool is_fermionic() const override { return true; };
    void print_info() const;
    std::string stype_str() const override { return "f#"; }
  };
 
  //=====================================
  // this is API
  class Symmetry {
   public:
    //[Note] these two are hide from user.
    boost::intrusive_ptr<Symmetry_base> _impl;
 
    Symmetry(const int &stype = -1, const int &n = 0) : _impl(new Symmetry_base()) {
      this->Init(stype, n);
    };  // default is U1Symmetry
 
    void Init(const int &stype = -1, const int &n = 0) {
      if (stype == SymmetryType::U) {
        boost::intrusive_ptr<Symmetry_base> tmp(new U1Symmetry(1));
        this->_impl = tmp;
      } else if (stype == SymmetryType::Z) {
        boost::intrusive_ptr<Symmetry_base> tmp(new ZnSymmetry(n));
        this->_impl = tmp;
      } else if (stype == SymmetryType::fPar) {
        boost::intrusive_ptr<Symmetry_base> tmp(new FermionParitySymmetry());
        this->_impl = tmp;
      } else if (stype == SymmetryType::fNum) {
        boost::intrusive_ptr<Symmetry_base> tmp(new FermionNumberSymmetry());
        this->_impl = tmp;
      } else {
        cytnx_error_msg(1, "%s", "[ERROR] invalid symmetry type.");
      }
    }
    Symmetry &operator=(const Symmetry &rhs) {
      this->_impl = rhs._impl;
      return *this;
    }
    Symmetry(const Symmetry &rhs) { this->_impl = rhs._impl; }
 
    //[genenrators]
    static Symmetry U1() { return Symmetry(SymmetryType::U, 1); }
 
    static Symmetry Zn(const int &n) { return Symmetry(SymmetryType::Z, n); }
 
    static Symmetry FermionParity() { return Symmetry(SymmetryType::fPar); }
 
    static Symmetry FermionNumber() { return Symmetry(SymmetryType::fNum); }
 
    Symmetry clone() const {
      Symmetry out;
      out._impl = this->_impl->clone();
      return out;
    }
 
    int stype() const { return this->_impl->stype_id; }
 
    int &n() const { return this->_impl->n; }
 
    std::string stype_str() const { return this->_impl->stype_str(); }
 
    bool check_qnum(const cytnx_int64 &qnum) { return this->_impl->check_qnum(qnum); }
 
    bool check_qnums(const std::vector<cytnx_int64> &qnums) {
      return this->_impl->check_qnums(qnums);
    }
 
    std::vector<cytnx_int64> combine_rule(const std::vector<cytnx_int64> &inL,
                                          const std::vector<cytnx_int64> &inR) {
      return this->_impl->combine_rule(inL, inR);
    }
 
    void combine_rule_(std::vector<cytnx_int64> &out, const std::vector<cytnx_int64> &inL,
                       const std::vector<cytnx_int64> &inR) {
      this->_impl->combine_rule_(out, inL, inR);
    }
 
    cytnx_int64 combine_rule(const cytnx_int64 &inL, const cytnx_int64 &inR,
                             const bool &is_reverse = false) const {
      return this->_impl->combine_rule(inL, inR, is_reverse);
    }
 
    void combine_rule_(cytnx_int64 &out, const cytnx_int64 &inL, const cytnx_int64 &inR,
                       const bool &is_reverse = false) {
      this->_impl->combine_rule_(out, inL, inR, is_reverse);
    }
 
    void reverse_rule_(cytnx_int64 &out, const cytnx_int64 &in) {
      this->_impl->reverse_rule_(out, in);
    }
 
    cytnx_int64 reverse_rule(const cytnx_int64 &in) const { return this->_impl->reverse_rule(in); }
 
    fermionParity get_fermion_parity(const cytnx_int64 &in_qnum) const {
      return this->_impl->get_fermion_parity(in_qnum);
    }
 
    bool is_fermionic() const { return this->_impl->is_fermionic(); }
 
    void Save(const std::string &fname) const;
 
    void Save(const char *fname) const;
 
    static Symmetry Load(const std::string &fname);
 
    static Symmetry Load(const char *fname);
 
    void _Save(std::fstream &f) const;
    void _Load(std::fstream &f);
 
    void print_info() const { this->_impl->print_info(); }
 
    bool operator==(const Symmetry &rhs) const;
 
    bool operator!=(const Symmetry &rhs) const;
  };  // Symmetry
 
  std::ostream &operator<<(std::ostream &os, const Symmetry &in);
 
};  // namespace cytnx
#endif  // CYTNX_SYMMETRY_H_