Simplex.h

Go to the documentation of this file.

// -*- C++ -*-

// CONTINUE: Write tests for the diameter functionality.

#if !defined(__numerical_Simplex_h__)
#define __numerical_Simplex_h__

// If we are debugging the whole numerical package.
#if defined(DEBUG_numerical) && !defined(DEBUG_Simplex)
#define DEBUG_Simplex
#endif

#ifdef DEBUG_Simplex
// Debug the base class.
#ifndef DEBUG_Opt
#define DEBUG_Opt
#endif
#endif

#include "Opt.h"

#include "../../geom/mesh/simplex/Simplex.h"

BEGIN_NAMESPACE_NUMERICAL


template<int N, class Function, typename T = typename Function::result_type,
         typename Point = typename Function::argument_type>
class Simplex :
  public Opt<N,Function,T,Point> {
private:

  // 
  // Private types
  //

  typedef Opt<N,Function,T,Point> Base;

public:

  //
  // Public types.
  //
  
  typedef typename Base::function_type function_type;

  typedef typename Base::number_type number_type;

  typedef typename Base::point_type point_type;

private:

  //
  // Private types.
  //

  typedef ads::FixedArray<N+1,point_type> point_container;

  typedef typename point_container::const_iterator point_const_iterator;

  //
  // Member data that the user can set.
  //

  // The fractional error tolerance.
  number_type _tolerance;

  // The initial offset size used to generate the simplex.
  number_type _offset;

  //
  // Other member data.
  //

  // The vertices of the simplex.
  ads::FixedArray<N+1,point_type> _vertices;

  // The objective function values at the vertices.
  ads::FixedArray<N+1,number_type> _values;

  // The sums of the coordinates of the vertices in the simplex.
  point_type _coordinate_sums;

  // The diameter of a hypercube that has the same volume as the simplex.
  number_type _diameter;

  //
  // Not implemented.
  //
  
  // Default constructor not implemented.
  Simplex();

  // Copy constructor not implemented.
  Simplex(const Simplex&);

  // Assignment operator not implemented.
  Simplex&
  operator=(const Simplex&);

public:

  //--------------------------------------------------------------------------
  // @{

  Simplex(const function_type& function, 
          const number_type tolerance = 
          std::sqrt(std::numeric_limits<number_type>::epsilon()),
          const number_type offset = 
          std::pow(std::numeric_limits<number_type>::epsilon(), 0.25),
          const int max_function_calls = 10000);

  virtual
  ~Simplex()
  {}

  // @}
  //--------------------------------------------------------------------------
  // @{

  //
  // Inherited from Opt.
  //

#if 0
  static
  int
  dimension() {
    return Base::dimension();
  }
#endif

  using Base::dimension;

  using Base::function;

  using Base::max_function_calls;

  using Base::num_function_calls;

  // @}
  //--------------------------------------------------------------------------
  // @{

  bool 
  find_minimum(const point_type& starting_point);

  bool 
  find_minimum(const ads::FixedArray<N + 1,point_type>& vertices);

  point_type
  minimum_point() const {
    return _vertices[0];
  }

  number_type
  minimum_value() const {
    return _values[0];
  }

  number_type
  diameter() const {
    return _diameter;
  }
  
  // @}
  //--------------------------------------------------------------------------
  // @{

  //
  // Inherited from Opt
  //

  using Base::set_max_function_calls;

  using Base::reset_num_function_calls;

  using Base::set_are_checking_function_calls;

  //
  // New.
  //
  
  void
  set_tolerance(const number_type tolerance) {
    _tolerance = tolerance;
  }

  void
  set_offset(const number_type offset) {
    _offset = offset;
  }

  // @}

private:

  // Initialize the simplex.
  void 
  initialize(const point_type& starting_point, const number_type offset);

  // Initialize the simplex.
  void 
  initialize(const ads::FixedArray<N + 1,point_type>& vertices);

  // Initialize given the vertices of the simplex.
  void 
  initialize_given_vertices();

  // Sum the coordinates of the vertices.
  void
  sum_coordinates();

  bool
  find_minimum();

  // Move the high point.
  /*
    Extrapolate by the given factor through the face of the simplex across
    from the high point.  Replace the high point if the new point is better.
    \param ihi is the index of the high point.
    \param factor is the scaling factor on where to move the point.
    For example, -1 reflects the point and 0.5 contracts the point.
  */
  number_type
  move_high_point(const int ihi, const number_type factor);

  // Compute the diameter
  void
  compute_diameter();

protected:

  //--------------------------------------------------------------------------
  // @{


  using Base::evaluate_function;

  // @}

};

END_NAMESPACE_NUMERICAL

#define __Simplex_ipp__
#include "Simplex.ipp"
#undef __Simplex_ipp__

#endif

---