hp2D/edgeMinMax.hh

Go to the documentation of this file.

/* @file edgeMinMax.hh  Class for rules for polynomial degrees of edges

   @author Kersten Schmidt, 2008
 */

#ifndef hp2DedgeMinMax_hh
#define hp2DedgeMinMax_hh

#include "basics/outputOperator.hh"
#include "basics/cloneable.hh"

namespace hp2D {

  // ********************************************************** PolyEdgeRule **

  class PolyEdgeRule : public concepts::OutputOperator,
           public concepts::Cloneable {
  public:
    virtual PolyEdgeRule* clone() const = 0;
    virtual void pUnderChildren(ushort& p, ushort pChild) const = 0;
    virtual void pFromChildren(ushort& p, ushort pChild) const {
      p = std::min(p, pChild); // seems to be equal as 
    }
    virtual void pEdge(ushort& p, ushort pEdge) const = 0;
  protected:
    virtual std::ostream& info(std::ostream& os) const {
      return os << "PolyEdgeRule()";
    }
  };
    
    
  // *********************************************************** PolyEdgeMax **

  class PolyEdgeMax : public PolyEdgeRule {
  public:
    virtual PolyEdgeMax* clone() const { return new PolyEdgeMax(); }
    virtual void pUnderChildren(ushort& p, ushort pChild) const {
      p = std::max(p, pChild);
    }
    virtual void pFromChildren(ushort& p, ushort pChild) const {
      p = std::max(p, pChild);
    }
    virtual void pEdge(ushort& p, ushort pInner) const {
      p = std::max(p, pInner);
    }
  protected:
    virtual std::ostream& info(std::ostream& os) const {
      return os << "PolyEdgeMax()";
    }
  };

  // *********************************************************** PolyEdgeMin **

  class PolyEdgeMin : public PolyEdgeRule {
  public:
    virtual PolyEdgeMin* clone() const { return new PolyEdgeMin(); }
    virtual void pUnderChildren(ushort& p, ushort pChild) const {
      p = std::min(p, pChild);
    }
    virtual void pEdge(ushort& p, ushort pInner) const {
      p = std::min(p, pInner);
    }
  protected:
    virtual std::ostream& info(std::ostream& os) const {
      return os << "PolyEdgeMin()";
    }
  };

  // ********************************************** PolyEdgeMinNeighMaxChild **

  class PolyEdgeMinNeighMaxChild : public PolyEdgeRule {
  public:
    virtual PolyEdgeMinNeighMaxChild* clone() const { 
      return new PolyEdgeMinNeighMaxChild(); }
    virtual void pUnderChildren(ushort& p, ushort pChild) const {
      p = std::max(p, pChild);
    }
    virtual void pEdge(ushort& p, ushort pInner) const {
      p = std::min(p, pInner);
    }
  protected:
    virtual std::ostream& info(std::ostream& os) const {
      return os << "PolyEdgeMinNeighMaxChild()";
    }
  };

} // namespace hp2D

#endif // hp2DedgeMinMax_hh