symmetry.h

Go to the documentation of this file.

/*
 *  GiNaC Copyright (C) 1999-2011 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, write to the Free Software
 *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
 */

#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);

    // 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;

    void archive(archive_node& n) const;
    void read_archive(const archive_node& n, lst& syms);
protected:
    void do_print(const print_context & c, unsigned level) const;
    void do_print_tree(const print_tree & c, unsigned level) const;
    unsigned calchash() 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