newton_search.h

Go to the documentation of this file.

#ifndef NEWTON_SEARCH_H
#define NEWTON_SEARCH_H

#include <itpp/base/vec.h>
#include <itpp/base/array.h>
#include <limits>


namespace itpp
{



enum Newton_Search_Method {BFGS};

class Newton_Search
{
public:
  Newton_Search();
  ~Newton_Search() {};

  void set_function(double(*function)(const vec&));
  void set_gradient(vec(*gradient)(const vec&));
  void set_functions(double(*function)(const vec&), vec(*gradient)(const vec&)) { set_function(function); set_gradient(gradient); }

  void set_start_point(const vec &x, const mat &D);

  void set_start_point(const vec &x);

  vec get_solution();

  bool search();
  bool search(vec &xn);
  bool search(const vec &x0, vec &xn);

  void set_stop_values(double epsilon_1, double epsilon_2);
  double get_epsilon_1() { return stop_epsilon_1; }
  double get_epsilon_2() { return stop_epsilon_2; }

  void set_max_evaluations(int value);
  int get_max_evaluations() { return max_evaluations; }

  void set_initial_stepsize(double value);
  double get_initial_stepsize() { return initial_stepsize; }

  void set_method(const Newton_Search_Method &method);

  double get_function_value();
  double get_stop_1();
  double get_stop_2();
  int get_no_iterations();
  int get_no_function_evaluations();

  void enable_trace() { trace = true; }
  void disable_trace() { trace = false; }

  void get_trace(Array<vec> & xvalues, vec &Fvalues, vec &ngvalues, vec &dvalues);

private:
  int n; // dimension of problem, size(x)
  double(*f)(const vec&);  // function to minimize
  vec(*df_dx)(const vec&);  // df/dx, gradient of f

  // start variables
  vec x_start;
  mat D_start;

  // solution variables
  vec x_end;

  // trace variables
  Array<vec> x_values;
  vec F_values, ng_values, Delta_values;

  Newton_Search_Method method;

  // Parameters
  double initial_stepsize; // opts(1)
  double stop_epsilon_1; // opts(2)
  double stop_epsilon_2; // opt(3)
  int max_evaluations; // opts(4)

  // output parameters
  int no_feval; // number of function evaluations
  int no_iter; // number of iterations
  double F, ng, nh; // function value, stop_1, stop_2 values at solution point

  bool init, finished, trace;
};



enum Line_Search_Method {Soft, Exact};

class Line_Search
{
public:
  Line_Search();
  ~Line_Search() {};

  void set_function(double(*function)(const vec&));
  void set_gradient(vec(*gradient)(const vec&));
  void set_functions(double(*function)(const vec&), vec(*gradient)(const vec&)) { set_function(function); set_gradient(gradient); }

  void set_start_point(const vec &x, double F, const vec &g, const vec &h);

  void get_solution(vec &xn, double &Fn, vec &gn);

  bool search();
  bool search(vec &xn, double &Fn, vec &gn);
  bool search(const vec &x, double F, const vec &g, const vec &h, vec &xn,
              double &Fn, vec &gn);


  double get_alpha();
  double get_slope_ratio();
  int get_no_function_evaluations();


  void set_stop_values(double rho, double beta);
  double get_rho() { return stop_rho; }
  double get_beta() { return stop_beta; }

  void set_max_iterations(int value);
  int get_max_iterations() { return max_iterations; }

  void set_max_stepsize(double value);
  double get_max_stepsize() { return max_stepsize; }

  void set_method(const Line_Search_Method &method);

  void enable_trace() { trace = true; }
  void disable_trace() { trace = false; }

  void get_trace(vec &alphavalues, vec &Fvalues, vec &dFvalues);

private:
  int n; // dimension of problem, size(x)
  double(*f)(const vec&);  // function to minimize
  vec(*df_dx)(const vec&);  // df/dx, gradient of f

  // start variables
  vec x_start, g_start, h_start;
  double F_start;

  // solution variables
  vec x_end, g_end;
  double F_end;

  // trace variables
  vec alpha_values, F_values, dF_values;

  bool init; // true if functions and starting points are set
  bool finished; // true if functions and starting points are set
  bool trace; // true if trace is enabled

  // Parameters
  Line_Search_Method method;
  double stop_rho; // opts(2)
  double stop_beta; // opts(3)
  int max_iterations; // opts(4)
  double max_stepsize; // opts(5)

  // output parameters
  double alpha; // end value of alpha, info(1)
  double slope_ratio; // slope ratio at xn, info(2)
  int no_feval; // info(3)
};

vec fminunc(double(*function)(const vec&), vec(*gradient)(const vec&), const vec &x0);


} // namespace itpp

#endif // #ifndef NEWTON_SEARCH_H

---