Qbasis.hpp

Go to the documentation of this file.

#ifndef QBASIS_H_
#define QBASIS_H_
 
#include <numeric>
#include <set>
#include <unordered_map>
#include <unordered_set>
 
#include "tabulate/table.hpp"
// #include "tabulate/tabulate.hpp"
 
#include "yas/serialize.hpp"
#include "yas/std_types.hpp"
 
#include "Xped/Core/Basis.hpp"
#include "Xped/Core/FusionTree.hpp"
#include "Xped/Core/allocators/HeapPolicy.hpp"
#include "Xped/Hash/hash.hpp"
 
namespace Xped {
 
template <typename Symmetry, std::size_t depth = 1, typename AllocationPolicy = HeapPolicy>
class Qbasis
{
    template <typename Symmetry_, std::size_t depth_, typename AllocationPolicy_>
    friend class Qbasis;
 
    typedef typename Symmetry::qType qType;
 
    using ContainerType =
        std::vector<std::tuple<qType, size_t, Basis>, typename AllocationPolicy::template Allocator<std::tuple<qType, std::size_t, Basis>>>;
    template <std::size_t tree_depth>
    using TreeVector = std::vector<FusionTree<tree_depth, Symmetry>, typename AllocationPolicy::template Allocator<FusionTree<tree_depth, Symmetry>>>;
    using TreeType = std::unordered_map<
        qType,
        TreeVector<depth>,
        std::hash<qType>,
        std::equal_to<qType>,
        typename AllocationPolicy::template Allocator<
            std::pair<const qType,
                      std::vector<FusionTree<depth, Symmetry>, typename AllocationPolicy::template Allocator<FusionTree<depth, Symmetry>>>>>>;
 
public:
    Qbasis() = default;
 
    template <typename Container>
    Qbasis(const Container& qins, const size_t& dim)
    {
        for(const auto& qin : qins) { push_back(qin, dim); }
    }
 
    static Qbasis<Symmetry, 1, AllocationPolicy> TrivialBasis();
 
 
    inline std::size_t dim() const
    {
        std::size_t out = 0;
        for(const auto& [qVal, num, plain] : data_) { out += plain.dim(); }
        return out;
    }
 
    inline std::size_t fullDim() const
    {
        std::size_t out = 0;
        for(const auto& [qVal, num, plain] : data_) { out += plain.dim() * Symmetry::degeneracy(qVal); }
        return out;
    }
 
    std::size_t largestSector() const;
 
    inline std::size_t Nq() const { return data_.size(); }
 
    qType getQ(const size_t& num) const;
 
    inline std::vector<qType> qs() const
    {
        std::vector<qType> out;
        out.reserve(data_.size());
        for(auto triple : data_) { out.push_back(std::get<0>(triple)); }
        return out;
    }
    inline std::unordered_set<qType> unordered_qs() const
    {
        std::unordered_set<qType> out;
        for(auto triple : data_) { out.insert(std::get<0>(triple)); }
        return out;
    }
 
    inline std::vector<std::size_t> dims() const
    {
        std::vector<std::size_t> out;
        out.reserve(data_.size());
        for(auto triple : data_) { out.push_back(std::get<2>(triple).dim()); }
        return out;
    }
 
 
    bool IS_PRESENT(const qType& q) const { return cfind(q) != data_.end(); }
    bool NOT_PRESENT(const qType& q) const { return !IS_PRESENT(q); }
 
 
    size_t inner_num(const size_t& outer_num) const;
    size_t inner_dim(const size_t& num_in) const;
    size_t inner_dim(const qType& q) const;
    size_t outer_num(const qType& q) const;
    size_t full_outer_num(const qType& q) const;
    size_t index(const qType& q) const;
 
    qType qn(std::size_t index) const
    {
        assert(index < data_.size());
        return std::get<0>(data_[index]);
    };
 
    void remove(const qType& q);
 
    inline qType maxQ() const
    {
        auto qs = this->qs();
        return *std::max_element(qs.begin(), qs.end());
    }
    inline qType minQ() const
    {
        auto qs = this->qs();
        return *std::min_element(qs.begin(), qs.end());
    }
    // template<typename Iterator>
    // void remove(Iterator& begin, Iterator& end);
 
    void truncate(const std::unordered_set<qType>& qs, const std::size_t& M);
 
    size_t leftOffset(const FusionTree<depth, Symmetry>& tree, const std::array<size_t, depth>& plain = std::array<std::size_t, depth>()) const;
    size_t rightOffset(const FusionTree<depth, Symmetry>& tree, const std::array<size_t, depth>& plain = std::array<std::size_t, depth>()) const;
 
    void push_back(const qType& q, const size_t& inner_dim);
 
    void push_back(const qType& q, const size_t& inner_dim, const TreeVector<depth>& tree);
 
    void setRandom(const std::size_t& fullSize, const std::size_t& max_sectorSize = 5ul);
 
    inline void clear()
    {
        data_.clear();
        trees.clear();
        curr_dim = 0;
    }
 
    Qbasis<Symmetry, depth + 1, AllocationPolicy> combine(const Qbasis<Symmetry, 1, AllocationPolicy>& other, bool CONJ = false) const;
 
    Qbasis<Symmetry, depth, AllocationPolicy> add(const Qbasis<Symmetry, depth, AllocationPolicy>& other) const;
 
    std::pair<std::vector<std::size_t>, Qbasis<Symmetry, depth, AllocationPolicy>> shift(qType qshift) const;
 
    Qbasis<Symmetry, depth, AllocationPolicy> intersection(const Qbasis<Symmetry, depth, AllocationPolicy>& other) const;
 
    Qbasis<Symmetry, depth, AllocationPolicy> conj() const;
 
    Qbasis<Symmetry, 1, AllocationPolicy> forgetHistory() const;
 
    std::string print() const;
 
    std::string info() const;
 
    std::string printTrees() const;
 
    bool operator==(const Qbasis<Symmetry, depth, AllocationPolicy>& other) const;
 
    inline auto begin() { return data_.begin(); }
    inline auto end() { return data_.end(); }
 
    inline auto cbegin() const { return data_.cbegin(); }
    inline auto cend() const { return data_.cend(); }
 
    // void swap (Qbasis<Symmetry,depth> &other) { this->data.swap(other.data()); }
 
    std::vector<std::size_t> sort();
 
    inline bool IS_SORTED() const { return IS_SORTED_; }
    inline bool IS_CONJ() const { return CONJ; }
 
    inline void SET_CONJ() { CONJ = true; }
 
    inline const auto& tree(const qType& q) const
    {
        auto it = trees.find(q);
        assert(it != trees.end());
        return it->second;
    }
 
    inline TreeType& allTrees() { return trees; }
 
    template <typename Ar>
    void serialize(Ar& ar)
    {
        ar& YAS_OBJECT_NVP("Qbasis", ("data", data_), ("curr_dim", curr_dim), ("trees", trees), ("IS_SORTED", IS_SORTED_), ("CONJ", CONJ));
    }
 
private:
    typename ContainerType::const_iterator cfind(const qType& q) const;
 
    typename ContainerType::iterator find(const qType& q);
 
    // vector with entry: {Quantumnumber (QN), state number of the first plain state for this QN, all plain states for this QN in a Basis object.}
    //[{q1,0,plain_q1}, {q2,dim(plain_q1),plain_q2}, {q3,dim(plain_q1)+dim(plain_q2),plain_q3}, ..., {qi, sum_j^(i-1)dim(plain_qj), plain_qi}]
    ContainerType data_{};
    std::size_t curr_dim = 0;
    TreeType trees{};
 
    bool IS_SORTED_ = false;
    bool CONJ = false;
};
 
template <typename Symmetry, std::size_t depth, typename AllocationPolicy>
std::ostream& operator<<(std::ostream& os, const Qbasis<Symmetry, depth, AllocationPolicy>& basis)
{
    os << basis.print();
    return os;
}
 
} // namespace Xped
 
#ifndef XPED_COMPILED_LIB
#    include "Core/Qbasis.cpp"
#endif
 
#endif