index.h

Go to the documentation of this file.

// This file is part of MARTY.
// 
// MARTY is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// 
// MARTY is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
// 
// You should have received a copy of the GNU General Public License
// along with MARTY. If not, see <https://www.gnu.org/licenses/>.

#ifndef INDEX_H_INCLUDED
#define INDEX_H_INCLUDED

#include <string>
#include <string_view>
#include <vector>
#include <map>
#include "std_vector_implementation.h"

namespace csl {
    class Space;
}

namespace cslIndex{

    enum Type{

        Free, 
        Dummy, 
        Fixed, 
    };

    enum TensorType{

        Generic,
        Metric, 
        Delta, 
    };
}

namespace csl {

class Index{

    public:

    using ID_type = unsigned int;

    private:

    const Space* space = nullptr;

    ID_type id;

    char nameOrValue;

    char type;

    public:

    Index();

    explicit Index(const std::string& t_name,
                   unsigned short     t_id = 0);

    Index(char value);

    Index(const Index& index) = default;

    Index(const std::string& t_name,\
          const Space*       t_space,
          unsigned short     t_id = 0);

    ~Index(){};

    std::string_view getName() const;

    std::string getIndexCodeName() const;

    inline ID_type getID() const {
        return id;
    }

    inline char getValue() const {
        return nameOrValue;
    }

    bool getSign() const {
        return nameOrValue >= 0;
    }

    inline bool getFree() const {
        return type == 0;
    }

    inline cslIndex::Type getType() const {
        return static_cast<cslIndex::Type>(type);
    }

    int getMax() const;

    inline const Space* getSpace() const {
        return space;
    }

    Index rename() const;

    Index getFlipped() const;

    void setName(const std::string& t_name);

    void setID(ID_type t_id);

    void setSpace(const Space* t_space);

    void setValue(char t_value);

    void setSign(bool t_sign);

    void flipSign();

    void setFree(bool t_free);

    void setType(cslIndex::Type t_type);

    bool testContraction(const Index& t_index) const;

    void print() const;

    std::string printLaTeX() const;

    void printDefinition(
            std::ostream &out,
            int           indentSize
            ) const;

    Index& operator=(const Index& index) = default;

    Index& operator=(int t_value);

    bool compareWithDummy(const Index& t_index) const;

    bool compareWithoutSign(const Index& t_index) const;

    bool exactMatch(const Index& t_index) const;

    Index& operator++();

    Index operator++(int);

    bool operator==(const Index& t_index) const;


    bool operator==(int value) const;

    bool operator==(size_t value) const;

    bool operator!=(const Index& t_index) const;

    bool operator!=(int value) const;

    bool operator!=(size_t value) const;

    bool operator|=(const Index& index) const;

    bool operator&=(const Index& index) const;

    bool operator<(const Index& index) const;

    bool operator>(const Index& index) const;

    bool operator<=(const Index& index) const;

    bool operator>=(const Index& index) const;

    friend std::ostream& operator<<(std::ostream& fout, const Index& index);
};

std::vector<Index> integerToIndices(const std::vector<int>& indices);

Index operator!(const Index& index);

Index operator+(const Index& index);

Index operator-(const Index& index);

class IndexStructure{

    IMPLEMENTS_STD_VECTOR_NO_OP(Index, index)

    private:

    std::vector<Index> index;

    public:

    IndexStructure();

    explicit IndexStructure(int t_nIndices);

    IndexStructure(const IndexStructure& structure);

    IndexStructure(IndexStructure&&) = default;

    IndexStructure& operator=(IndexStructure&&) = default;

    explicit IndexStructure(const std::initializer_list<Index>& structure);

    explicit IndexStructure(const std::vector<Index>& structure);

    ~IndexStructure(){}

    std::vector<Index> const &getIndex() const;

    const std::vector<Index>& getIndexView() const;

    std::vector<Index>& getIndex();


    std::vector<Index>::const_iterator find(const Index& t_index) const;

    std::vector<Index>::iterator find(const Index& t_index);

    IndexStructure getFreeStructure() const;

    IndexStructure getSinglePermutation(int i1, int i2) const;

    IndexStructure getPermutation(const std::vector<int>& permutation) const;

    void setIndex(const Index& newIndex, int iIndex=0);

    void reset();

    IndexStructure& operator=(const IndexStructure& structure) = default;

    IndexStructure& operator+=(const Index& newIndex);

    IndexStructure& operator+=(const IndexStructure& structure);

    IndexStructure operator+(const csl::Index& index) const;

    IndexStructure operator+(const IndexStructure& structure) const;

    bool hasCommonIndex(csl::IndexStructure const &other) const;

    bool exactMatch(const IndexStructure& structure) const;
    
    bool compareWithDummy(const IndexStructure& structure) const;

    bool compareWithDummy(const IndexStructure& structure,
                          std::map<Index,Index>& constraints,
                          bool keepAllCosntraints = false) const;

    bool operator==(const IndexStructure& structure) const;

    bool operator!=(const IndexStructure& structure) const;

    bool operator|=(const IndexStructure& structure) const;

    bool operator&=(const IndexStructure& structure) const;

    bool operator<(const IndexStructure& structure) const;

    bool operator>(const IndexStructure& structure) const;

    bool operator<=(const IndexStructure& structure) const;

    bool operator>=(const IndexStructure& structure) const;

    Index operator[](int i) const;

    Index& operator[](int i);

    friend std::ostream& operator<<(std::ostream&         fout,
                                    const IndexStructure& structure);
};

// Inline functions

inline IndexStructure::IndexStructure() {}
inline IndexStructure::IndexStructure(int t_nIndices)
    : index(std::vector<Index>(t_nIndices,Index())){}
inline IndexStructure::IndexStructure(const IndexStructure& t_index):
    index(t_index.index){}
inline IndexStructure::IndexStructure(const std::initializer_list<Index>& t_index):
    IndexStructure(std::vector<Index>(t_index)){}


} // End of namespace csl

#endif