symmetry.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 SYMMETRY_H_INCLUDED
#define SYMMETRY_H_INCLUDED

#include <vector>
#include "std_vector_implementation.h"
#include "index.h"

namespace csl {

class Permutation{

    IMPLEMENTS_STD_VECTOR(int, permutation)

    private:

    int order;

    int sign;

    int symmetry;

    std::vector<int> permutation;

    public:

    Permutation();

    explicit Permutation(int n);

    explicit Permutation(const std::vector<int>& t_permutation);

    Permutation(int n, const std::vector<int>& list);

    Permutation(int n, const std::vector<int>& list, int sym);

    Permutation(int n,
                const std::vector<std::vector<int> >& list);

    Permutation(const Permutation& permutation) = default;

    ~Permutation(){}

    int getOrder();

    int getSign();

    int getSymmetry() const;

    std::vector<int> getPermutation() const;

    void setSymmetry(int t_symmetry);

    void adjustToSize(size_t newSize);

    void applyRedefinition(const std::vector<size_t>& redefinition);

    Permutation& operator=(const Permutation& t_permutation) = default;

    Permutation operator*(const Permutation& t_permutation) const;

    bool operator==(const Permutation& t_permutation) const;

    bool operator!=(const Permutation& t_permuation) const;

    friend std::ostream& operator<<(std::ostream& fout,
                                    const Permutation& permutation);
};

std::vector<std::vector<int> > permutations(std::vector<int> init);

std::vector<Permutation> permutations(const Permutation& init);

void reducePermutation(std::vector<Permutation>& permutation);

std::vector<Permutation> getSpan(const std::vector<Permutation>& init);

void getSpan(std::vector<Permutation >& spanned, 
             const Permutation&         element);

class Symmetry{
    
    IMPLEMENTS_STD_VECTOR(Permutation, permutation)

    protected:

    int dim;

    bool mustGetSpan = true;

    std::vector<Permutation> permutation;

    public:

    Symmetry();

    Symmetry(int t_dim);

    Symmetry(const Symmetry& t_symmetry) = default;

    ~Symmetry(){}

    int getDim() const;

    size_t getNPermutation() const;

    std::vector<Permutation> getPermutation() const;

    int getSymmetryOf(int i, int j) const;

    void addSymmetry(const Permutation& newPermutation, int sym=1);

    void addSymmetry(const std::vector<int>& newPermutation, int sym=1);

    void addSymmetry(
            const std::vector<std::vector<int>>& newPermutation, 
            int sym=1);

    void adjustPermutationSize();

    void setMustGetSpan(bool t_must);

    bool operator==(const Symmetry& symmetry) const;

    bool operator!=(const Symmetry& symmetry) const;

    Symmetry operator*(const Symmetry& other) const;

    friend std::ostream& operator<<(std::ostream& fout,
                                    const Symmetry& symmetry);
};

class IndexedSymmetry: public Symmetry {

    public:

    IndexedSymmetry();

        
    explicit
    IndexedSymmetry(const IndexStructure& init);

    explicit 
    IndexedSymmetry(const Index& i1,
                    const Index& i2);

    explicit
    IndexedSymmetry(const IndexStructure& init,
                    const Symmetry& initialSym);

    void addSymmetry(const Index& i1,
                     const Index& i2);

    void addSymmetry(const std::pair<Index, Index>& perm,
                     int symmetry = 1);

    void addAntiSymmetry(const Index& i1,
                         const Index& i2);

    void addAntiSymmetry(const std::pair<Index, Index>& perm);


    IndexedSymmetry operator+(const IndexedSymmetry& other) const;

    IndexedSymmetry& operator+=(const IndexedSymmetry& other);

    IndexedSymmetry operator*(const IndexedSymmetry& other) const;

    IndexedSymmetry& operator*=(const IndexedSymmetry& other);

    csl::vector_expr applySymmetry(const Expr& expr) const;

    friend 
    std::ostream& operator<<(std::ostream&          fout,
                             const IndexedSymmetry& sym);

    private:

    size_t findPos(const Index&    index,
                   size_t&         maxPos,
                   IndexStructure& newInit) const;

    std::pair<Symmetry, Symmetry> getCorrespondingSymmetries(
            IndexedSymmetry other,
            IndexStructure& newInit
            ) const;

    private:

    IndexStructure init;
};

} // End of namespace csl

#endif