function.hh

Go to the documentation of this file.

 
#ifndef spcFunction_hh
#define spcFunction_hh
 
#include <cstring>
#include "basics/outputOperator.hh"
#include "basics/vectorsMatrices.hh"
#include "toolbox/array.hh"
#include "element.hh"
 
namespace concepts {
 
  // ****************************************************** ElementFunction **
 
  template<class F, class G = typename Realtype<F>::type>
  class ElementFunction : public virtual OutputOperator {
  public:
    virtual uint n() const = 0;
    virtual void operator() (const Element<G>& elm, const Array<F>& coeff,
                             Array<F>& val, const uint *i) const = 0;
    virtual void operator() (const Element<G>& elm, const uint* j,
                             Array<F>& val, const uint* i) const = 0;
 
    virtual void operator() (const Element<G>& elm, const Array<F>& coeff,
                             Array<F>& val, const Real p, 
                             const Real t = 0.0) const = 0;
    virtual void operator() (const Element<G>& elm, const Array<F>& coeff,
                             Array<F>& val, const Real2d& p,
                             const Real t = 0.0) const = 0;
    virtual void operator() (const Element<G>& elm, const Array<F>& coeff,
                             Array<F>& val, const Real3d& p,
                             const Real t = 0.0) const = 0;
 
    virtual ElementFunction<F,G>* clone() const = 0;
  protected:
    virtual std::ostream& info(std::ostream& os) const {
      return os << concepts::typeOf(*this)<<"()";
    }
  };
 
  // *************************************************************** Squared **
 
  template<class F, class G = typename Realtype<F>::type>
  class Squared : public ElementFunction<F, G> {
  public:
    Squared(ElementFunction<F,G>& fun) : fun_(fun) {}
    virtual ~Squared() {}
    virtual uint n() const { return fun_.n(); }
 
    virtual void operator() (const Element<G>& elm, const Array<F>& coeff,
                             Array<F>& val, const uint *i) const;
    virtual void operator() (const Element<G>& elm, const uint* j,
                             Array<F>& val, const uint* i) const;
    virtual void operator() (const Element<G>& elm, const Array<F>& coeff,
                             Array<F>& val, const Real p,
                             const Real t = 0.0) const;
    virtual void operator() (const Element<G>& elm, const Array<F>& coeff,
                             Array<F>& val, const Real2d& p,
                             const Real t = 0.0) const;
    virtual void operator() (const Element<G>& elm, const Array<F>& coeff,
                             Array<F>& val, const Real3d& p,
                             const Real t = 0.0) const;
 
    virtual Squared<F,G>* clone() const { return new Squared(fun_); }
  protected:
    virtual std::ostream& info(std::ostream& os) const;
  private:
    ElementFunction<F,G>& fun_;
    template<class H>
    void square_(Array<H>& val) const {
      conceptsAssert(val.size() <= n(), Assertion());
      for(uint j=0; j < n(); ++j)
        val[j] = val[j]*val[j];
    }
  };
 
  // ********************************************************** AbsoluteComp **
 
  template<class F, class G = typename Realtype<F>::type>
  class AbsoluteComp : public ElementFunction<F, G> {
  public:
    AbsoluteComp(ElementFunction<F,G>& fun) : fun_(fun) {}
    virtual ~AbsoluteComp() {}
    virtual uint n() const { return fun_.n(); }
 
    virtual void operator() (const Element<G>& elm, const Array<F>& coeff,
                             Array<F>& val, const uint *i) const;
    virtual void operator() (const Element<G>& elm, const uint* j,
                             Array<F>& val, const uint* i) const;
    virtual void operator() (const Element<G>& elm, const Array<F>& coeff,
                             Array<F>& val, const Real p,
                             const Real t = 0.0) const;
    virtual void operator() (const Element<G>& elm, const Array<F>& coeff,
                             Array<F>& val, const Real2d& p,
                             const Real t = 0.0) const;
    virtual void operator() (const Element<G>& elm, const Array<F>& coeff,
                             Array<F>& val, const Real3d& p,
                             const Real t = 0.0) const;
    virtual AbsoluteComp<F,G>* clone() const { return new AbsoluteComp(fun_); }
  protected:
    virtual std::ostream& info(std::ostream& os) const;
  private:
    ElementFunction<F,G>& fun_;
    void absolute_(Array<F>& val) const;
  };
 
  // ************************************************************** Absolute **
 
  template<class F, class G = typename Realtype<F>::type>
  class Absolute : public ElementFunction<F, G> {
  public:
    Absolute(ElementFunction<F,G>& fun) : fun_(fun) {}
    virtual ~Absolute() {}
    virtual uint n() const { return 1; }
 
    virtual void operator() (const Element<G>& elm, const Array<F>& coeff,
                             Array<F>& val, const uint *i) const;
    virtual void operator() (const Element<G>& elm, const uint* j,
                             Array<F>& val, const uint* i) const;
    virtual void operator() (const Element<G>& elm, const Array<F>& coeff,
                             Array<F>& val, const Real p,
                             const Real t = 0.0) const;
    virtual void operator() (const Element<G>& elm, const Array<F>& coeff,
                             Array<F>& val, const Real2d& p,
                             const Real t = 0.0) const;
    virtual void operator() (const Element<G>& elm, const Array<F>& coeff,
                             Array<F>& val, const Real3d& p,
                             const Real t = 0.0) const;
    virtual Absolute<F,G>* clone() const { return new Absolute(fun_); }
  protected:
    virtual std::ostream& info(std::ostream& os) const;
  private:
    ElementFunction<F,G>& fun_;
    F absolute_(const Array<F>& val) const;
  };
 
} // namespace concepts
 
#endif // spcFunction_hh