extrema.hh

Go to the documentation of this file.

 
#ifndef extrema_hh
#define extrema_hh
 
#include "hp2D.hh"
 
using concepts::Real;
using concepts::Real2d;
 
 
 
namespace alglib
{
  // Forward declaration;
  class real_1d_array;
}
 
 
namespace concepts{
  //template for computing minimum or maximum
  enum Optimize { MIN, MAX };
}
 
 
namespace hp2D{
// *************************************************************** Extrema **
template <concepts::Optimize T>
class Extrema : public concepts::OutputOperator{
 
public:
  Extrema(const concepts::SpaceOnCells<Real>& spc,
          const concepts::ElementFormula<Real>& formula,
          const concepts::ElementFormula<Real2d>* formulaGrad = 0,
          uint np = 2,
          bool report = false);
 
  //return maximum/minimum
  Real get() const;
 
  static Extrema<T>* pt2Object;
 
protected:
  virtual std::ostream& info(std::ostream& os) const override;
 
private:
 
 
  //search points in one cell
  std::vector<std::string> points_;
  //the local (possible global) maximum on the underlying elm
  std::set<Real> extrema_;
  //space on which ElementFormula is given
  const concepts::SpaceOnCells<Real>& spc_;
  //ElementFormula
  const concepts::ElementFormula<Real>& frm_;
  //Gradient of ElementFormula
  const concepts::ElementFormula<Real2d>* frmGrad_;
  //underlying element
  const hp2D::Quad<Real>* elm_;
  // np^2 number of start points
  uint np_;
  //flag for report of convergence
  bool report_;
  //current function max
  Real curFunc_;
  //candidates of positions and vals
  concepts::Sequence<Real> vals_;
 
 
  //returns -1 for T = MAX, 1 for T = MIN
  Real sign_() const;
 
  //returns the extrema on one cell
  Real get_(const concepts::Set<Real>& vals) const;
 
  //computes the maximum on one cell (of type hp2D::Quad<Real> only)
  Real compute_(const hp2D::Quad<concepts::Real>& quad);
 
  void reportOutput_(uint K, const std::string& point,  int terminationType) const;
 
 
  static void Wrapper_To_Call_Grad_(const alglib::real_1d_array &x, double &func, alglib::real_1d_array &grad, void *ptr);
 
  static void Wrapper_To_Call_Fun_(const alglib::real_1d_array &x, double &func, void *ptr);
 
  //evaluation of the gradient
  void evalsG_(const alglib::real_1d_array &x, double &func, alglib::real_1d_array &grad, void *ptr);
 
  //evaluation of the function
  void evalsF_(const alglib::real_1d_array &x, double &func, void *ptr);
 
};
 
}//namespace hp2D
 
#endif //minMax_hh