symmetry.h

Go to the documentation of this file.

 
/*
 *  GiNaC Copyright (C) 1999-2026 Johannes Gutenberg University Mainz, Germany
 *
 *  This program 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 2 of the License, or
 *  (at your option) any later version.
 *
 *  This program 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 this program.  If not, see <https://www.gnu.org/licenses/>.
 */
 
#ifndef GINAC_SYMMETRY_H
#define GINAC_SYMMETRY_H
 
#include "ex.h"
#include "archive.h"
 
#include <set>
 
namespace GiNaC {
 
class sy_is_less;
class sy_swap;
 
class symmetry : public basic
{
    friend class sy_is_less;
    friend class sy_swap;
    friend int canonicalize(exvector::iterator v, const symmetry &symm);
 
    GINAC_DECLARE_REGISTERED_CLASS(symmetry, basic)
 
    // types
public:
    typedef enum {
        none,          
        symmetric,     
        antisymmetric, 
        cyclic         
    } symmetry_type;
 
    // other constructors
public:
    symmetry(unsigned i);
 
    symmetry(symmetry_type t, const symmetry &c1, const symmetry &c2);
 
    // functions overriding virtual functions from base classes
public:
    void archive(archive_node& n) const override;
    void read_archive(const archive_node& n, lst& syms) override;
protected:
    unsigned calchash() const override;
 
    // non-virtual functions in this class
public:
    symmetry_type get_type() const {return type;}
 
    void set_type(symmetry_type t) {type = t;}
 
    symmetry &add(const symmetry &c);
 
    void validate(unsigned n);
 
    bool has_symmetry() const {return type != none || !children.empty(); }
    bool has_nonsymmetric() const;
    bool has_cyclic() const;
protected:
    void do_print(const print_context & c, unsigned level) const;
    void do_print_tree(const print_tree & c, unsigned level) const;
 
    // member variables
private:
    symmetry_type type;
 
    std::set<unsigned> indices;
 
    exvector children;
};
GINAC_DECLARE_UNARCHIVER(symmetry); 
 
 
// global functions
 
inline symmetry sy_none() { return symmetry(); }
inline symmetry sy_none(const symmetry &c1, const symmetry &c2) { return symmetry(symmetry::none, c1, c2); }
inline symmetry sy_none(const symmetry &c1, const symmetry &c2, const symmetry &c3) { return symmetry(symmetry::none, c1, c2).add(c3); }
inline symmetry sy_none(const symmetry &c1, const symmetry &c2, const symmetry &c3, const symmetry &c4) { return symmetry(symmetry::none, c1, c2).add(c3).add(c4); }
 
inline symmetry sy_symm() { symmetry s; s.set_type(symmetry::symmetric); return s; }
inline symmetry sy_symm(const symmetry &c1, const symmetry &c2) { return symmetry(symmetry::symmetric, c1, c2); }
inline symmetry sy_symm(const symmetry &c1, const symmetry &c2, const symmetry &c3) { return symmetry(symmetry::symmetric, c1, c2).add(c3); }
inline symmetry sy_symm(const symmetry &c1, const symmetry &c2, const symmetry &c3, const symmetry &c4) { return symmetry(symmetry::symmetric, c1, c2).add(c3).add(c4); }
 
inline symmetry sy_anti() { symmetry s; s.set_type(symmetry::antisymmetric); return s; }
inline symmetry sy_anti(const symmetry &c1, const symmetry &c2) { return symmetry(symmetry::antisymmetric, c1, c2); }
inline symmetry sy_anti(const symmetry &c1, const symmetry &c2, const symmetry &c3) { return symmetry(symmetry::antisymmetric, c1, c2).add(c3); }
inline symmetry sy_anti(const symmetry &c1, const symmetry &c2, const symmetry &c3, const symmetry &c4) { return symmetry(symmetry::antisymmetric, c1, c2).add(c3).add(c4); }
 
inline symmetry sy_cycl() { symmetry s; s.set_type(symmetry::cyclic); return s; }
inline symmetry sy_cycl(const symmetry &c1, const symmetry &c2) { return symmetry(symmetry::cyclic, c1, c2); }
inline symmetry sy_cycl(const symmetry &c1, const symmetry &c2, const symmetry &c3) { return symmetry(symmetry::cyclic, c1, c2).add(c3); }
inline symmetry sy_cycl(const symmetry &c1, const symmetry &c2, const symmetry &c3, const symmetry &c4) { return symmetry(symmetry::cyclic, c1, c2).add(c3).add(c4); }
 
// These return references to preallocated common symmetries (similar to
// the numeric flyweights).
const symmetry & not_symmetric();
const symmetry & symmetric2();
const symmetry & symmetric3();
const symmetry & symmetric4();
const symmetry & antisymmetric2();
const symmetry & antisymmetric3();
const symmetry & antisymmetric4();
 
extern int canonicalize(exvector::iterator v, const symmetry &symm);
 
ex symmetrize(const ex & e, exvector::const_iterator first, exvector::const_iterator last);
 
inline ex symmetrize(const ex & e, const exvector & v)
{
    return symmetrize(e, v.begin(), v.end());
}
 
ex antisymmetrize(const ex & e, exvector::const_iterator first, exvector::const_iterator last);
 
inline ex antisymmetrize(const ex & e, const exvector & v)
{
    return antisymmetrize(e, v.begin(), v.end());
}
 
ex symmetrize_cyclic(const ex & e, exvector::const_iterator first, exvector::const_iterator last);
 
inline ex symmetrize_cyclic(const ex & e, const exvector & v)
{
    return symmetrize(e, v.begin(), v.end());
}
 
} // namespace GiNaC
 
#endif // ndef GINAC_SYMMETRY_H