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 "Streams.h"

#include <vector>

namespace TBTK{

enum {
    IDX_SUM_ALL = -1, IDX_ALL = -1,
    IDX_X = -2,
    IDX_Y = -3,
    IDX_Z = -4,
    IDX_SPIN = -5
};

class Index{
public:
    Index(std::initializer_list<int> i) : indices(i){};

    Index(std::vector<int> i) : indices(i){};

    Index(const Index &index) : indices(index.indices){};

    Index(const Index &head, const Index &tail);

    bool equals(const Index &index, bool allowWildcard = false) const;

    int& at(unsigned int n);

    const int& at(unsigned int n) const;

    unsigned int size() const;

    void push_back(int subindex);

    int popFront();

    int popBack();

    Index getUnitRange();

    Index getSubIndex(int first, int last);

    void print() const;

    std::string toString() const;

    friend bool operator<(const Index &i1, const Index &i2);

    friend bool operator>(const Index &i1, const Index &i2);
private:
    std::vector<int> indices;
};

inline void Index::print() const{
    Util::Streams::out << "{";
    for(unsigned int n = 0; n < indices.size(); n++){
        if(n != 0)
            Util::Streams::out << ", ";
        Util::Streams::out << indices.at(n);
    }
    Util::Streams::out << "}\n";
}

inline std::string Index::toString() const{
    std::string str = "{";
    for(unsigned int n = 0; n < indices.size(); n++){
        if(n != 0)
            str += ", ";
        str += std::to_string(indices.at(n));
    }
    str += "}";

    return str;
}

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) == IDX_ALL ||
                        index.indices.at(n) == IDX_ALL
                    )
                        continue;
                    else
                        return false;
                }
            }
        }
    }
    else{
        return false;
    }

    return true;
}

inline int& Index::at(unsigned int n){
    return indices.at(n);
}

inline const int& Index::at(unsigned int n) const{
    return indices.at(n);
}

inline unsigned int Index::size() const{
    return indices.size();
}

inline void Index::push_back(int subindex){
    indices.push_back(subindex);
}

inline int Index::popFront(){
    int first = indices.at(0);
    indices.erase(indices.begin());

    return first;
}

inline int Index::popBack(){
    int last = indices.back();
    indices.pop_back();

    return last;
}

};  //End of namespace TBTK

#endif