Ipopt  3.12.9
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros
IpIpoptData.hpp
Go to the documentation of this file.
1 // Copyright (C) 2004, 2009 International Business Machines and others.
2 // All Rights Reserved.
3 // This code is published under the Eclipse Public License.
4 //
5 // $Id: IpIpoptData.hpp 2706 2018-01-15 04:11:56Z stefan $
6 //
7 // Authors: Carl Laird, Andreas Waechter IBM 2004-08-13
8 
9 #ifndef __IPIPOPTDATA_HPP__
10 #define __IPIPOPTDATA_HPP__
11 
12 #include "IpSymMatrix.hpp"
13 #include "IpOptionsList.hpp"
14 #include "IpIteratesVector.hpp"
15 #include "IpRegOptions.hpp"
16 #include "IpTimingStatistics.hpp"
17 
18 namespace Ipopt
19 {
20 
21  /* Forward declaration */
22  class IpoptNLP;
23 
29  {
30  public:
35  {}
36 
39  {}
41 
45  virtual bool Initialize(const Journalist& jnlst,
46  const OptionsList& options,
47  const std::string& prefix) = 0;
48 
50  virtual bool InitializeDataStructures() = 0;
51 
55  virtual void AcceptTrialPoint() = 0;
56 
57  private:
68 
70  void operator=(const IpoptAdditionalData&);
72  };
73 
83  class IpoptData : public ReferencedObject
84  {
85  public:
90  Number cpu_time_start = -1.);
91 
93  virtual ~IpoptData();
95 
98  bool want_x,
99  bool want_y_c,
100  bool want_y_d,
101  bool want_z_L,
102  bool want_z_U);
103 
107  bool Initialize(const Journalist& jnlst,
108  const OptionsList& options,
109  const std::string& prefix);
110 
114  inline
116 
121  // SmartPtr<IteratesVector> curr_container() const;
122 
124  inline
126 
131  //SmartPtr<IteratesVector> trial_container() const;
132 
137  inline
138  void set_trial(SmartPtr<IteratesVector>& trial);
139 
144  const Vector& delta_x,
145  const Vector& delta_s);
151  const Vector& delta_y_c,
152  const Vector& delta_y_d);
158  const Vector& delta_z_L,
159  const Vector& delta_z_U,
160  const Vector& delta_v_L,
161  const Vector& delta_v_U);
162 
166  // void set_trial(const SmartPtr<IteratesVector>& trial_iterates);
167  // void set_trial(SmartPtr<const IteratesVector>& trial_iterates);
168 
170  inline
172 
177  inline
178  void set_delta(SmartPtr<IteratesVector>& delta);
179 
186  inline
188 
190  inline
192 
197  inline
198  void set_delta_aff(SmartPtr<IteratesVector>& delta_aff);
199 
202  {
204  return W_;
205  }
206 
209  {
210  W_ = W;
211  }
212 
219 
227  bool HaveDeltas() const
228  {
229  return have_deltas_;
230  }
231 
237  void SetHaveDeltas(bool have_deltas)
238  {
239  have_deltas_ = have_deltas;
240  }
242 
249 
257  bool HaveAffineDeltas() const
258  {
259  return have_affine_deltas_;
260  }
261 
267  void SetHaveAffineDeltas(bool have_affine_deltas)
268  {
269  have_affine_deltas_ = have_affine_deltas;
270  }
272 
276  inline
277  void CopyTrialToCurrent();
278 
281  void AcceptTrialPoint();
283 
287  {
288  return iter_count_;
289  }
291  {
293  }
294 
295  Number curr_mu() const
296  {
298  return curr_mu_;
299  }
300  void Set_mu(Number mu)
301  {
302  curr_mu_ = mu;
303  mu_initialized_ = true;
304  }
305  bool MuInitialized() const
306  {
307  return mu_initialized_;
308  }
309 
310  Number curr_tau() const
311  {
313  return curr_tau_;
314  }
315  void Set_tau(Number tau)
316  {
317  curr_tau_ = tau;
318  tau_initialized_ = true;
319  }
320  bool TauInitialized() const
321  {
322  return tau_initialized_;
323  }
324 
325  void SetFreeMuMode(bool free_mu_mode)
326  {
327  free_mu_mode_ = free_mu_mode;
328  }
329  bool FreeMuMode() const
330  {
331  return free_mu_mode_;
332  }
333 
336  void Set_tiny_step_flag(bool flag)
337  {
338  tiny_step_flag_ = flag;
339  }
341  {
342  return tiny_step_flag_;
343  }
345 
352  Number tol() const
353  {
355  return tol_;
356  }
365  {
366  tol_ = tol;
367  }
369 
375  {
377  return cpu_time_start_;
378  }
379 
383  {
384  return info_regu_x_;
385  }
386  void Set_info_regu_x(Number regu_x)
387  {
388  info_regu_x_ = regu_x;
389  }
391  {
392  return info_alpha_primal_;
393  }
394  void Set_info_alpha_primal(Number alpha_primal)
395  {
396  info_alpha_primal_ = alpha_primal;
397  }
399  {
401  }
403  {
405  }
407  {
408  return info_alpha_dual_;
409  }
410  void Set_info_alpha_dual(Number alpha_dual)
411  {
412  info_alpha_dual_ = alpha_dual;
413  }
415  {
416  return info_ls_count_;
417  }
418  void Set_info_ls_count(Index ls_count)
419  {
420  info_ls_count_ = ls_count;
421  }
422  bool info_skip_output() const
423  {
424  return info_skip_output_;
425  }
426  void Append_info_string(const std::string& add_str)
427  {
428  info_string_ += add_str;
429  }
430  const std::string& info_string() const
431  {
432  return info_string_;
433  }
437  {
439  }
440 
443  {
444  return info_last_output_;
445  }
448  {
450  }
451 
455  {
457  }
461  {
463  }
467  {
469  }
470 
472  void ResetInfo()
473  {
474  info_regu_x_ = 0;
475  info_alpha_primal_ = 0;
476  info_alpha_dual_ = 0.;
478  info_skip_output_ = false;
479  info_string_.erase();
480  }
482 
485  {
486  return timing_statistics_;
487  }
488 
491  {
493  }
494 
496  bool HaveAddData()
497  {
498  return IsValid(add_data_);
499  }
500 
503  {
504  return *add_data_;
505  }
506 
509  {
511  add_data_ = add_data;
512  }
513 
515  void setPDPert(Number pd_pert_x, Number pd_pert_s,
516  Number pd_pert_c, Number pd_pert_d)
517  {
518  pd_pert_x_ = pd_pert_x;
519  pd_pert_s_ = pd_pert_s;
520  pd_pert_c_ = pd_pert_c;
521  pd_pert_d_ = pd_pert_d;
522  }
523 
525  void getPDPert(Number& pd_pert_x, Number& pd_pert_s,
526  Number& pd_pert_c, Number& pd_pert_d)
527  {
528  pd_pert_x = pd_pert_x_;
529  pd_pert_s = pd_pert_s_;
530  pd_pert_c = pd_pert_c_;
531  pd_pert_d = pd_pert_d_;
532  }
533 
536  static void RegisterOptions(const SmartPtr<RegisteredOptions>& roptions);
538 
539  private:
545 
549 
552 
565 
580 
583 
587 
591 
595 
599 
608 
616 
633  std::string info_string_;
640 
643 
647 
650 
654 
663 
673  IpoptData(const IpoptData&);
674 
676  void operator=(const IpoptData&);
678 
679 #if COIN_IPOPT_CHECKLEVEL > 0
680 
684  TaggedObject::Tag debug_curr_tag_;
685  TaggedObject::Tag debug_trial_tag_;
686  TaggedObject::Tag debug_delta_tag_;
687  TaggedObject::Tag debug_delta_aff_tag_;
688  TaggedObject::Tag debug_curr_tag_sum_;
689  TaggedObject::Tag debug_trial_tag_sum_;
690  TaggedObject::Tag debug_delta_tag_sum_;
691  TaggedObject::Tag debug_delta_aff_tag_sum_;
693 #endif
694 
695  };
696 
697  inline
699  {
700  DBG_ASSERT(IsNull(curr_) || (curr_->GetTag() == debug_curr_tag_ && curr_->GetTagSum() == debug_curr_tag_sum_) );
701 
702  return curr_;
703  }
704 
705  inline
707  {
708  DBG_ASSERT(IsNull(trial_) || (trial_->GetTag() == debug_trial_tag_ && trial_->GetTagSum() == debug_trial_tag_sum_) );
709 
710  return trial_;
711  }
712 
713  inline
715  {
716  DBG_ASSERT(IsNull(delta_) || (delta_->GetTag() == debug_delta_tag_ && delta_->GetTagSum() == debug_delta_tag_sum_) );
717 
718  return delta_;
719  }
720 
721  inline
723  {
724  DBG_ASSERT(IsNull(delta_aff_) || (delta_aff_->GetTag() == debug_delta_aff_tag_ && delta_aff_->GetTagSum() == debug_delta_aff_tag_sum_) );
725 
726  return delta_aff_;
727  }
728 
729  inline
731  {
732  curr_ = trial_;
733 #if COIN_IPOPT_CHECKLEVEL > 0
734 
735  if (IsValid(curr_)) {
736  debug_curr_tag_ = curr_->GetTag();
737  debug_curr_tag_sum_ = curr_->GetTagSum();
738  }
739  else {
740  debug_curr_tag_ = 0;
741  debug_curr_tag_sum_ = 0;
742  }
743 #endif
744 
745  }
746 
747  inline
749  {
750  trial_ = ConstPtr(trial);
751 
752 #if COIN_IPOPT_CHECKLEVEL > 0
753  // verify the correct space
755  if (IsValid(trial)) {
756  debug_trial_tag_ = trial->GetTag();
757  debug_trial_tag_sum_ = trial->GetTagSum();
758  }
759  else {
760  debug_trial_tag_ = 0;
761  debug_trial_tag_sum_ = 0;
762  }
763 #endif
764 
765  trial = NULL;
766  }
767 
768  inline
770  {
771  delta_ = ConstPtr(delta);
772 #if COIN_IPOPT_CHECKLEVEL > 0
773 
774  if (IsValid(delta)) {
775  debug_delta_tag_ = delta->GetTag();
776  debug_delta_tag_sum_ = delta->GetTagSum();
777  }
778  else {
779  debug_delta_tag_ = 0;
780  debug_delta_tag_sum_ = 0;
781  }
782 #endif
783 
784  delta = NULL;
785  }
786 
787  inline
789  {
790  delta_ = delta;
791 #if COIN_IPOPT_CHECKLEVEL > 0
792 
793  if (IsValid(delta)) {
794  debug_delta_tag_ = delta->GetTag();
795  debug_delta_tag_sum_ = delta->GetTagSum();
796  }
797  else {
798  debug_delta_tag_ = 0;
799  debug_delta_tag_sum_ = 0;
800  }
801 #endif
802 
803  delta = NULL;
804  }
805 
806  inline
808  {
809  delta_aff_ = ConstPtr(delta_aff);
810 #if COIN_IPOPT_CHECKLEVEL > 0
811 
812  if (IsValid(delta_aff)) {
813  debug_delta_aff_tag_ = delta_aff->GetTag();
814  debug_delta_aff_tag_sum_ = delta_aff->GetTagSum();
815  }
816  else {
817  debug_delta_aff_tag_ = 0;
818  debug_delta_aff_tag_sum_ = delta_aff->GetTagSum();
819  }
820 #endif
821 
822  delta_aff = NULL;
823  }
824 
825 } // namespace Ipopt
826 
827 #endif
const std::string & info_string() const
bool IsValid(const SmartPtr< U > &smart_ptr)
Definition: IpSmartPtr.hpp:579
char info_alpha_primal_char() const
void SetTrialBoundMultipliersFromStep(Number alpha, const Vector &delta_z_L, const Vector &delta_z_U, const Vector &delta_v_L, const Vector &delta_v_U)
Set the value of the trial values for the bound multipliers (z_L, z_U, v_L, v_U) from provided step w...
void Set_info_regu_x(Number regu_x)
void set_delta(SmartPtr< IteratesVector > &delta)
Set the current delta - like the trial point, this method copies the pointer for efficiency (no copy ...
Number info_regu_x_
Size of regularization for the Hessian.
int info_iters_since_header_
number of iteration summaries actually printed since last summary header was printed ...
void Append_info_string(const std::string &add_str)
void getPDPert(Number &pd_pert_x, Number &pd_pert_s, Number &pd_pert_c, Number &pd_pert_d)
Get the current perturbation of the primal-dual system.
Number curr_tau_
current fraction to the boundary parameter
Number info_last_output()
gives time when the last summary output line was printed
void Set_mu(Number mu)
void SetHaveAffineDeltas(bool have_affine_deltas)
Method for setting the HaveDeltas flag.
Number curr_mu_
current barrier parameter
SmartPtr< IpoptAdditionalData > add_data_
Object for the data specific for the Chen-Goldfarb penalty method algorithm.
void ResetInfo()
Reset all info fields.
Number info_alpha_dual() const
void Set_info_alpha_dual(Number alpha_dual)
Index iter_count() const
Number cpu_time_start() const
Cpu time counter at the beginning of the optimization.
void set_delta_aff(SmartPtr< IteratesVector > &delta_aff)
Set the affine delta - like the trial point, this method copies the pointer for efficiency (no copy a...
IpoptAdditionalData()
Default Constructor.
Definition: IpIpoptData.hpp:34
static void RegisterOptions(const SmartPtr< RegisteredOptions > &roptions)
Methods for IpoptType.
bool HaveAffineDeltas() const
Returns true, if the affine-scaling step have been already computed for the current iteration...
void Set_info_ls_count(Index ls_count)
TimingStatistics timing_statistics_
TimingStatistics object collecting all Ipopt timing statistics.
double Number
Type of all numbers.
Definition: IpTypes.hpp:17
void Set_tiny_step_flag(bool flag)
Setting the flag that indicates if a tiny step (below machine precision) has been detected...
Vector Base Class.
Definition: IpVector.hpp:47
bool IsNull(const SmartPtr< U > &smart_ptr)
Definition: IpSmartPtr.hpp:585
void Set_info_last_output(Number info_last_output)
sets time when the last summary output line was printed
void Set_iter_count(Index iter_count)
int info_iters_since_header()
gives number of iteration summaries actually printed since last summary header was printed ...
Number cpu_time_start_
CPU time counter at begin of optimization.
Number curr_mu() const
Number info_last_output_
time when the last summary output line was printed
void Set_info_alpha_primal_char(char info_alpha_primal_char)
SmartPtr< const SymMatrix > W()
Hessian or Hessian approximation (do not hold on to it, it might be changed)
void SetFreeMuMode(bool free_mu_mode)
SmartPtr< const IteratesVector > delta() const
ToDo: I may need to add versions of set_trial like the following, but I am not sure.
bool HaveAddData()
Check if additional data has been set.
void Set_W(SmartPtr< const SymMatrix > W)
Set Hessian approximation.
Number info_alpha_primal_
Primal step size.
virtual ~IpoptData()
Default destructor.
TimingStatistics & TimingStats()
Return Timing Statistics Object.
SmartPtr< const IteratesVector > trial() const
Get the current point in a copied container that is non-const.
SmartPtr< const IteratesVector > curr_
Main iteration variables (current iteration)
This class collects all timing statistics for Ipopt.
std::string info_string_
any string of characters for the end of the output line
Template class for Smart Pointers.
Definition: IpSmartPtr.hpp:172
ReferencedObject class.
This class stores a list of user set options.
bool info_skip_output_
true, if next summary output line should not be printed (eg after restoration phase.
virtual bool Initialize(const Journalist &jnlst, const OptionsList &options, const std::string &prefix)=0
This method is called to initialize the global algorithmic parameters.
bool FreeMuMode() const
VectorSpace base class, corresponding to the Vector base class.
Definition: IpVector.hpp:390
bool have_affine_deltas_
The following flag is set to true, if some other part of the algorithm (like the method for computing...
void operator=(const IpoptAdditionalData &)
Overloaded Equals Operator.
SmartPtr< const IteratesVector > delta_aff_
U * GetRawPtr(const SmartPtr< U > &smart_ptr)
Definition: IpSmartPtr.hpp:560
bool info_skip_output() const
Number tol_
Overall convergence tolerance.
SmartPtr< const IteratesVector > delta_
virtual ~IpoptAdditionalData()
Default destructor.
Definition: IpIpoptData.hpp:38
void SetTrialPrimalVariablesFromStep(Number alpha, const Vector &delta_x, const Vector &delta_s)
Set the values of the primal trial variables (x and s) from provided Step with step length alpha...
bool Initialize(const Journalist &jnlst, const OptionsList &options, const std::string &prefix)
This method must be called to initialize the global algorithmic parameters.
bool have_prototypes_
flag for debugging whether we have already curr_ values available (from which new Vectors can be gene...
void Inc_info_iters_since_header()
increases number of iteration summaries actually printed since last summary header was printed ...
Number CpuTime()
method determining CPU time
IpoptAdditionalData & AdditionalData()
Get access to additional data object.
Class to organize all the data required by the algorithm.
Definition: IpIpoptData.hpp:83
bool InitializeDataStructures(IpoptNLP &ip_nlp, bool want_x, bool want_y_c, bool want_y_d, bool want_z_L, bool want_z_U)
Initialize Data Structures.
Number curr_tau() const
int Index
Type of all indices of vectors, matrices etc.
Definition: IpTypes.hpp:19
virtual void AcceptTrialPoint()=0
Do whatever is necessary to accept a trial point as current iterate.
SmartPtr< const IteratesVector > curr() const
Current point.
#define DBG_ASSERT(test)
Definition: IpDebug.hpp:38
Number info_alpha_dual_
Dual step size.
bool tiny_step_flag_
flag indicating if a tiny step has been detected
void SetHaveDeltas(bool have_deltas)
Method for setting the HaveDeltas flag.
SmartPtr< IteratesVectorSpace > iterates_space_
VectorSpace for all the iterates.
unsigned int Tag
Type for the Tag values.
IpoptData(SmartPtr< IpoptAdditionalData > add_data=NULL, Number cpu_time_start=-1.)
Constructor.
void Set_info_skip_output(bool info_skip_output)
Set this to true, if the next time when output is written, the summary line should not be printed...
SmartPtr< const U > ConstPtr(const SmartPtr< U > &smart_ptr)
Definition: IpSmartPtr.hpp:572
Index info_ls_count() const
Index iter_count_
iteration count
SmartPtr< const IteratesVector > delta_aff() const
Affine Delta.
void ResetCpuStartTime()
Resetting CPU Start Time.
void SetTrialEqMultipliersFromStep(Number alpha, const Vector &delta_y_c, const Vector &delta_y_d)
Set the values of the trial values for the equality constraint multipliers (y_c and y_d) from provide...
void Set_info_iters_since_header(int info_iters_since_header)
sets number of iteration summaries actually printed since last summary header was printed ...
void Set_tol(Number tol)
Set a new value for the tolerance.
Class responsible for all message output.
bool free_mu_mode_
flag indicating whether the algorithm is in the free mu mode
char info_alpha_primal_char_
Info character for primal step size.
bool TauInitialized() const
void operator=(const IpoptData &)
Overloaded Equals Operator.
SmartPtr< const SymMatrix > W_
Hessian (approximation) - might be changed elsewhere!
bool initialize_called_
flag indicating if Initialize method has been called (for debugging)
bool MuInitialized() const
void Set_tau(Number tau)
void AcceptTrialPoint()
Set the current iterate values from the trial values.
void SetAddData(SmartPtr< IpoptAdditionalData > add_data)
Set a new pointer for additional Ipopt data.
void setPDPert(Number pd_pert_x, Number pd_pert_s, Number pd_pert_c, Number pd_pert_d)
Set the perturbation of the primal-dual system.
This is the abstract base class for classes that map the traditional NLP into something that is more ...
Definition: IpIpoptNLP.hpp:28
Base class for additional data that is special to a particular type of algorithm, such as the CG pena...
Definition: IpIpoptData.hpp:28
bool have_deltas_
The following flag is set to true, if some other part of the algorithm (like the method for computing...
Number info_regu_x() const
virtual bool InitializeDataStructures()=0
Initialize Data Structures at the beginning.
Number info_alpha_primal() const
bool HaveDeltas() const
Returns true, if the primal-dual step have been already computed for the current iteration.
void Set_info_alpha_primal(Number alpha_primal)
void set_trial(SmartPtr< IteratesVector > &trial)
Get Trial point in a copied container that is non-const.
Number tol() const
Overall convergence tolerance.
void CopyTrialToCurrent()
Copy the trial values to the current values.
SmartPtr< const IteratesVector > trial_
Main iteration variables (trial calculations)
Index info_ls_count_
Number of backtracking trial steps.