Symmetry.hpp

Go to the documentation of this file.

#ifndef _H_Symmetry
#define _H_Symmetry
 
#include "Type.hpp"
#include "cytnx_error.hpp"
#include "intrusive_ptr_base.hpp"
#include <string>
#include <cstdio>
#include <iostream>
#include <ostream>
#include "utils/vec_clone.hpp"
 
#ifdef BACKEND_TORCH
#else
namespace cytnx {
  struct __sym {
    enum __stype { U = -1, Z = 0 };
  };
 
  class SymmetryType_class {
   public:
    enum : int {
      Void = -99,
      U = -1,
      Z = 0,
    };
    std::string getname(const int &stype);
  };
 
  extern SymmetryType_class SymType;
 
  // 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 make_pair(this->tmpQs, dim);
    }
  };
 
  class Symmetry_base : public intrusive_ptr_base<Symmetry_base> {
   public:
    int stype_id;
    int n;
    Symmetry_base() : stype_id(SymType.Void){};
    Symmetry_base(const int &n) : stype_id(SymType.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 void print_info() 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 = SymType.U; };
    U1Symmetry(const int &n) { this->Init(n); };
    void Init(const int &n) {
      this->stype_id = SymType.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;
  };
 
  class ZnSymmetry : public Symmetry_base {
   public:
    ZnSymmetry() { this->stype_id = SymType.Z; };
    ZnSymmetry(const int &n) { this->Init(n); };
    void Init(const int &n) {
      this->stype_id = SymType.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;
  };
 
  //=====================================
  // 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 == SymType.U) {
        boost::intrusive_ptr<Symmetry_base> tmp(new U1Symmetry(1));
        this->_impl = tmp;
      } else if (stype == SymType.Z) {
        boost::intrusive_ptr<Symmetry_base> tmp(new ZnSymmetry(n));
        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(SymType.U, 1); }
 
    static Symmetry Zn(const int &n) { return Symmetry(SymType.Z, n); }
 
    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 SymType.getname(this->_impl->stype_id) + std::to_string(this->_impl->n);
    }
 
    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); }
 
    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;
  };
 
  std::ostream &operator<<(std::ostream &os, const Symmetry &in);
 
}  // namespace cytnx
#endif  // BACKEND_TORCH
 
#endif