@startuml

namespace bmqc {

    class SpinString<T> {
        .. T = unsigned types ..
        __ private members __
            - const size_t K
            - const size_t N

            - T representation
        __ private methods __
            - int **operatorPhaseFactor**(size_t p) const
        == constructors ==
            **SpinString**<T>(T representation, size_t K)
            **SpinString**<T>(size_t next_address, const bmqc::AddressingScheme& addressing_scheme)
        __ public methods __
            + T **get_representation**() const
            + size_t **get_K**() const
            + size_t **get_N**() const

            + size_t **next_address**(const bmqc::AddressingScheme& addressing_scheme) const
            + void **nextPermutation**()
            + T **slice**(size_t index_start, size_t index_end) const
            + bool **annihilate**(size_t p)
            + bool **annihilate**(size_t p, int& sign)
            + bool **create**(size_t p)
            + bool **create**(size_t p, int& sign)


    }


    class SpinString {
        .. T = boost::dynamic_bitset<> ..
        == constructors ==
            **SpinString**<boost::dynamic_bitset<>>(const boost::dynamic_bitset<>& representation)
        __ public methods __
            + {static} void **addBit**(boost::dynamic_bitset<>& u, size_t n = 0)
            + {static} void **removeBit**(boost::dynamic_bitset<>& u, size_t n = 0);
    }


    class AddressingScheme {
        __ private data __
            - const size_t K
            - const size_t N
            - bmqc::Matrixi vertex_weights
        == constructors ==
            **AddressingScheme**(size_t K, size_t N)
        __ public methods __
            + const bmqc::Matrixi **get_vertex_weights**() const
    }


    class global {
        __ common __
            typedef std::vector<size_t> **Vectoru**
            typedef std::vector<Vectoru> **Matrixu**
    }
}



bmqc.SpinString ..> bmqc.AddressingScheme


bmqc.AddressingScheme ..> bmqc.global

@enduml
