symmetry.hh

Go to the documentation of this file.

 
#ifndef symmetry_hh
#define symmetry_hh
 
#include "basics/typedefs.hh"
#include "topology.hh"
 
namespace concepts
{
  template<class T>
  class Symmetry {
  public:
    Symmetry();
 
    ~Symmetry();
  };
 
  template<>
  class Symmetry<Edge> {
  public:
    Symmetry(const Z2 value) : value_(value) {};
    Symmetry(const Symmetry<Edge>& other) {value_ = other.value_; };
    void operator= (const Symmetry<Edge>& other) {this->value_ = other.value_; };
    friend Symmetry<Edge> operator* (const Symmetry<Edge> & i, const Symmetry<Edge> & j)
    {
      return Symmetry<Edge>(i.value_ ^ j.value_);
    }
    Real evaluate(const Real x)
    {
      if (this->value_ == 1)
        return 1.0-x;
      return x;
    };
    Real evaluateInverse(const Real x)
    {
      return evaluate(x);
    }
 
  protected:
    Z2 value_;
  };
 
  template<>
  class Symmetry<Quad> {
  public:
    Symmetry(const std::array<Z2, 3> value) : value_(value) {} ; 
    Symmetry(const Z2 ix, const Z2 iy, const Z2 ip)
    {
      value_[0] = ix;
      value_[1] = iy;
      value_[2] = ip;
    };
    Symmetry(const Symmetry<Quad>& other) {value_ = other.value_; };
    void operator= (const Symmetry<Quad>& other) {this->value_ = other.value_; };
    friend Symmetry<Quad> operator*(const Symmetry<Quad>& i, const Symmetry<Quad>& j)
    {
      // Sy o Sp = Sp o Sx
      // Sx o Sp = Sp o Sy
      // Sy o Sx = Sx o Sy -> symmetries Sx and Sy can commute
      Z2 ix = i.value_[0];
      Z2 iy = i.value_[1];
      Z2 ip = i.value_[2];
      Z2 jx = j.value_[0];
      Z2 jy = j.value_[1];
      Z2 jp = j.value_[2];
      if (jp == 1)
        std::swap(ix,iy);
      // in this case, it would return Symmetry(iy^jx, ix^jy, ip^jp);
      return Symmetry(ix^jx, iy^jy, ip^jp);
    }
    Real2d evaluate(const Real2d p)
    {
      Real x = p[0], y = p[1];
      // Presence of the symmetry S_x
      if (value_[0])
        x = 1.0 - x;
      // Presence of the symmetry S_y
      if (value_[1])
        y = 1.0 - y;
      // Presence of the symmetry S_p
      if (value_[2])
        std::swap(x,y);
      return Real2d(x,y);
    };
    Real2d evaluateInverse(const Real2d p)
    {
      Real x = p[0], y = p[1];
      // Presence of the symmetry S_p
      if (value_[2])
        std::swap(x,y);
      // Presence of the symmetry S_y
      if (value_[1])
        y = 1.0 - y;
      // Presence of the symmetry S_x
      if (value_[0])
        x = 1.0 - x;
      return Real2d(x,y);
    };
  protected:
    std::array<Z2, 3> value_;
  };
 
 
  Real3d evaluatepermutation(const Real3d p, const int index);
 
}
 
#endif // symmetry_hh