Index.h

Go to the documentation of this file.

/* Copyright 2016 Kristofer Björnson
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
 
#ifndef COM_DAFER45_TBTK_INDEX
#define COM_DAFER45_TBTK_INDEX
 
#include "TBTK/Subindex.h"
#include "TBTK/Serializable.h"
#include "TBTK/Streams.h"
 
#include <vector>
 
namespace TBTK{
 
class Index{
public:
    //TBTKFeature Core.Index.Construction.1 2019-09-19
    Index(){};
 
    //TBTKFeature Core.Index.Construction.2 2019-09-19
    Index(std::initializer_list<Subindex> i) : indices(i){};
 
/*  Index(
        std::initializer_list<unsigned int> i
    ) : indices(i.begin(), i.end()){};*/
 
    //TBTKFeature Core.Index.Construction.3.C++ 2019-09-19
    Index(std::vector<Subindex> i) : indices(i){};
 
//  Index(std::vector<unsigned int> i) : indices(i.begin(), i.end()){};
 
    //TBTKFeature Core.Index.Copy.1 2019-09-19
    //TBTKFeature Core.Index.Copy.2 2019-09-23
    Index(const Index &index) : indices(index.indices){};
 
    //TBTKFeature Core.Index.Construction.4 2019-09-19
    //TBTKFeature Core.Index.Construction.5.C++ 2019-09-19
    Index(const Index &head, const Index &tail);
 
//  Index(std::initializer_list<std::initializer_list<Subindex>> indexList);
 
    //TBTKFeature Core.Index.Construction.8.C++ 2019-09-19
    Index(const std::vector<std::vector<Subindex>> &indexList);
 
    //TBTKFeature Core.Index.Construction.6 2019-09-19
    //TBTKFeature Core.Index.Construction.7.C++ 2019-09-19
    Index(std::initializer_list<Index> indexList);
 
    Index(std::vector<Index> indexList);
 
    //TBTKFeature Core.Index.Construction.9 2019-09-19
    Index(const std::string &indexString);
 
    //TBTKFeature Core.Index.Serialization.1 2019-09-19
    Index(const std::string &serialization, Serializable::Mode mode);
 
    //TBTKFeature Core.Index.Equals.1 2019-09-19
    //TBTKFeature Core.Index.Equals.2 2019-09-19
    //TBTKFeature Core.Index.Equals.3 2019-09-19
    //TBTKFeature Core.Index.Equals.4 2019-09-21
    //TBTKFeature Core.Index.Equals.5 2019-09-19
    //TBTKFeature Core.Index.Equals.6 2019-09-19
    //TBTKFeature Core.Index.Equals.7 2019-09-19
    //TBTKFeature Core.Index.Equals.8 2019-09-19
    //TBTKFeature Core.Index.Equals.9 2019-09-19
    //TBTKFeature Core.Index.Equals.10 2019-09-19
    bool equals(const Index &index, bool allowWildcard = false) const;
 
    //TBTKFeature Core.Index.at.1 2019-09-19
    Subindex& at(unsigned int n);
 
    //TBTKFeature Core.Index.at.2.C++ 2019-09-19
    const Subindex& at(unsigned int n) const;
 
    //TBTKFeature Core.Index.getSize.1 2019-09-19
    //TBTKFeature Core.Index.getSize.2 2019-09-19
    //TBTKFeature Core.Index.getSize.3 2019-09-19
    //TBTKFeature Core.Index.getSize.4 2019-09-19
    //TBTKFeature Core.Index.getSize.5 2019-09-19
    unsigned int getSize() const;
 
    void reserve(unsigned int size);
 
    //TBTKFeature Core.Index.pushBack.1 2019-09-19
    void pushBack(Subindex subindex);
 
    //TBTKFeature Core.Index.popFront.1 2019-09-19
    Subindex popFront();
 
    //TBTKFeature Core.Index.popBack.1 2019-09-19
    Subindex popBack();
 
    //TBTKFeature Core.Index.insert.1 2019-10-28
    void insert(unsigned int n, Subindex subindex);
 
    //TBTKFeature Core.Index.erase.1 2019-10-28
    Subindex erase(unsigned int n);
 
    //TBTKFeature Core.Index.getUnitRange.1 2019-09-19
    Index getUnitRange();
 
    //TBTKFeature Core.Index.getSubIndex.1 2019-09-21
    Index getSubIndex(int first, int last) const;
 
    //TBTKFeature Core.Index.split.1 2019-09-19
    std::vector<Index> split() const;
 
    //TBTKFeature Core.Index.isPatternIndex.1 2019-09-19
    //TBTKFeature Core.Index.isPatternIndex.2 2019-09-19
    //TBTKFeature Core.Index.isPatternIndex.3 2019-09-19
    //TBTKFeature Core.Index.isPatternIndex.4 2019-09-19
    //TBTKFeature Core.Index.isPatternIndex.5 2019-09-19
    //TBTKFeature Core.Index.isPatternIndex.6 2019-09-19
    //TBTKFeature Core.Index.isPatternIndex.7 2019-09-19
    //TBTKFeature Core.Index.isPatternIndex.8 2019-09-19
    bool isPatternIndex() const;
 
    void print() const;
 
    //TBTKFeature Core.Index.toString.1 2019-09-19
    //TBTKFeature Core.Index.toString.2 2019-09-19
    std::string toString() const;
 
    friend std::ostream& operator<<(
        std::ostream &stream,
        const Index &index
    );
 
    //TBTKFeature Core.Index.operator<.1.C++ 2019-09-19
    //TBTKFeature Core.Index.operator<.2.C++ 2019-09-19
    //TBTKFeature Core.Index.operator<.3.C++ 2019-09-19
    //TBTKFeature Core.Index.operator<.4.C++ 2019-09-19
    //TBTKFeature Core.Index.operator<.5.C++ 2019-09-19
    friend bool operator<(const Index &i1, const Index &i2);
 
    //TBTKFeature Core.Index.operator>.1.C++ 2019-09-19
    //TBTKFeature Core.Index.operator>.2.C++ 2019-09-19
    //TBTKFeature Core.Index.operator>.3.C++ 2019-09-19
    //TBTKFeature Core.Index.operator>.4.C++ 2019-09-19
    //TBTKFeature Core.Index.operator>.5.C++ 2019-09-19
    friend bool operator>(const Index &i1, const Index &i2);
 
    //TBTKFeature Core.Index.operator[].1.C++ 2019-09-19
    //TBTKFeature Core.Index.operator[].2.C++ 2019-09-19
    Subindex& operator[](unsigned int subindex);
 
    //TBTKFeature Core.Index.operator[].1.C++ 2019-09-19
    //TBTKFeature Core.Index.operator[].2.C++ 2019-09-19
    const Subindex& operator[](unsigned int subindex) const;
 
    //TBTKFeature Core.Index.Serialization.1 2019-09-19
    std::string serialize(Serializable::Mode mode) const;
 
    unsigned int getSizeInBytes() const;
private:
    std::vector<Subindex> indices;
};
 
inline void Index::print() const{
    Streams::out << "{";
    for(unsigned int n = 0; n < indices.size(); n++){
        if(n != 0)
            Streams::out << ", ";
        Streams::out << indices.at(n);
    }
    Streams::out << "}\n";
}
 
inline std::string Index::toString() const{
    std::string str = "{";
    bool isFirstIndex = true;
    for(unsigned int n = 0; n < indices.size(); n++){
        Subindex subindex = indices.at(n);
        if(!isFirstIndex && !subindex.isIndexSeparator())
            str += ", ";
        else
            isFirstIndex = false;
        if(subindex.isWildcard()){
            str += "IDX_ALL";
        }
        else if(subindex.isSummationIndex()){
            str += "IDX_SUM_ALL";
        }
        else if(subindex.isRangeIndex()){
            switch(subindex){
            case IDX_X:
                str += "IDX_X";
                break;
            case IDX_Y:
                str += "IDX_Y";
                break;
            case IDX_Z:
                str += "IDX_Z";
                break;
            default:
                TBTKExit(
                    "Index::toString()",
                    "This should never happen, contact the"
                    << " developer.",
                    ""
                );
            }
        }
        else if(subindex.isSpinIndex()){
            str += "IDX_SPIN";
        }
        else if(subindex.isIndexSeparator()){
            str += "}, {";
            isFirstIndex = true;
        }
        else if(subindex.isLabeledWildcard()){
            str += "IDX_ALL_(";
            str += std::to_string(subindex.getWildcardLabel());
            str += ")";
        }
        else{
            str += std::to_string(subindex);
        }
    }
    str += "}";
 
    return str;
}
 
inline std::ostream& operator<<(std::ostream &stream, const Index &index){
    stream << index.toString();
 
    return stream;
}
 
inline bool Index::equals(const Index &index, bool allowWildcard) const{
    if(indices.size() == index.indices.size()){
        for(unsigned int n = 0; n < indices.size(); n++){
            if(indices.at(n) != index.indices.at(n)){
                if(!allowWildcard)
                    return false;
                else{
                    if(
                        indices.at(n).isWildcard() ||
                        index.indices.at(n).isWildcard()
                    ){
                        continue;
                    }
                    else if(
                        indices.at(n).isLabeledWildcard()
                    ){
                        for(
                            unsigned int c = 0;
                            c < indices.size();
                            c++
                        ){
                            if(
                                indices.at(c)
                                == indices.at(n)
                                && index.indices.at(c)
                                != index.indices.at(n)
                            ){
                                return false;
                            }
                        }
                    }
                    else if(
                        index.indices.at(n).isLabeledWildcard()
                    ){
                        for(
                            unsigned int c = 0;
                            c < indices.size();
                            c++
                        ){
                            if(
                                index.indices.at(c)
                                == index.indices.at(n)
                                && indices.at(c)
                                != indices.at(n)
                            ){
                                return false;
                            }
                        }
                    }
                    else{
                        return false;
                    }
                }
            }
        }
    }
    else{
        return false;
    }
 
    return true;
}
 
inline Subindex& Index::at(unsigned int n){
    return indices.at(n);
}
 
inline const Subindex& Index::at(unsigned int n) const{
    return indices.at(n);
}
 
inline unsigned int Index::getSize() const{
    return indices.size();
}
 
inline void Index::reserve(unsigned int size){
    indices.reserve(size);
}
 
inline void Index::pushBack(Subindex subindex){
    indices.push_back(subindex);
}
 
inline Subindex Index::popFront(){
    Subindex first = indices.at(0);
    indices.erase(indices.begin());
 
    return first;
}
 
inline Subindex Index::popBack(){
    Subindex last = indices.back();
    indices.pop_back();
 
    return last;
}
 
inline void Index::insert(unsigned int n, Subindex subindex){
    indices.insert(indices.begin() + n, subindex);
}
 
inline Subindex Index::erase(unsigned int n){
    Subindex subindex = indices[n];
    indices.erase(indices.begin() + n);
 
    return subindex;
}
 
inline std::vector<Index> Index::split() const{
    std::vector<Index> components;
    components.push_back(Index());
    for(unsigned int n = 0; n < indices.size(); n++){
        if(indices[n].isIndexSeparator())
            components.push_back(Index());
        else
            components.back().pushBack(indices[n]);
    }
 
    return components;
}
 
inline bool Index::isPatternIndex() const{
    for(unsigned int n = 0; n < indices.size(); n++)
        if(indices.at(n) < 0)
            return true;
 
    return false;
}
 
inline Subindex& Index::operator[](unsigned int subindex){
    return indices[subindex];
}
 
inline const Subindex& Index::operator[](unsigned int subindex) const{
    return indices[subindex];
}
 
inline unsigned int Index::getSizeInBytes() const{
    return sizeof(*this) + sizeof(int)*indices.capacity();
}
 
};  //End of namespace TBTK
 
#endif