Ipopt Documentation  
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 // Authors: Carl Laird, Andreas Waechter IBM 2004-08-13
6 
7 #ifndef __IPIPOPTDATA_HPP__
8 #define __IPIPOPTDATA_HPP__
9 
10 #include "IpSymMatrix.hpp"
11 #include "IpOptionsList.hpp"
12 #include "IpIteratesVector.hpp"
13 #include "IpRegOptions.hpp"
14 #include "IpTimingStatistics.hpp"
15 
16 namespace Ipopt
17 {
18 
19 /* Forward declaration */
20 class IpoptNLP;
21 
30 {
31 public:
33 
36  { }
37 
40  { }
42 
48  virtual bool Initialize(
49  const Journalist& jnlst,
50  const OptionsList& options,
51  const std::string& prefix
52  ) = 0;
53 
55  virtual bool InitializeDataStructures() = 0;
56 
62  virtual void AcceptTrialPoint() = 0;
63 
64 private:
74 
77  const IpoptAdditionalData&
78  );
79 
81  void operator=(
82  const IpoptAdditionalData&
83  );
85 };
86 
98 {
99 public:
101 
103  IpoptData(
104  SmartPtr<IpoptAdditionalData> add_data = NULL
105  );
106 
108  virtual ~IpoptData();
110 
112  bool InitializeDataStructures(
113  IpoptNLP& ip_nlp,
114  bool want_x,
115  bool want_y_c,
116  bool want_y_d,
117  bool want_z_L,
118  bool want_z_U
119  );
120 
126  bool Initialize(
127  const Journalist& jnlst,
128  const OptionsList& options,
129  const std::string& prefix
130  );
131 
133 
135  inline SmartPtr<const IteratesVector> curr() const;
136 
142  // SmartPtr<IteratesVector> curr_container() const;
144  inline SmartPtr<const IteratesVector> trial() const;
145 
151  //SmartPtr<IteratesVector> trial_container() const;
158  inline
159  void set_trial(
161  );
162  /* ToDo: I may need to add versions of set_trial like the
163  * following, but I am not sure
164  */
165  // void set_trial(const SmartPtr<IteratesVector>& trial_iterates);
166  // void set_trial(SmartPtr<const IteratesVector>& trial_iterates);
167 
171  void SetTrialPrimalVariablesFromStep(
172  Number alpha,
173  const Vector& delta_x,
174  const Vector& delta_s
175  );
180  void SetTrialEqMultipliersFromStep(
181  Number alpha,
182  const Vector& delta_y_c,
183  const Vector& delta_y_d
184  );
189  void SetTrialBoundMultipliersFromStep(
190  Number alpha,
191  const Vector& delta_z_L,
192  const Vector& delta_z_U,
193  const Vector& delta_v_L,
194  const Vector& delta_v_U
195  );
196 
198  inline SmartPtr<const IteratesVector> delta() const;
199 
206  inline
207  void set_delta(
209  );
210 
219  inline
220  void set_delta(
222  );
223 
225  inline SmartPtr<const IteratesVector> delta_aff() const;
226 
233  inline
234  void set_delta_aff(
235  SmartPtr<IteratesVector>& delta_aff
236  );
237 
240  {
241  return W_;
242  }
243 
245  void Set_W(
247  )
248  {
249  W_ = W;
250  }
251 
260 
271  bool HaveDeltas() const
272  {
273  return have_deltas_;
274  }
275 
285  bool have_deltas
286  )
287  {
288  have_deltas_ = have_deltas;
289  }
291 
300 
311  bool HaveAffineDeltas() const
312  {
313  return have_affine_deltas_;
314  }
315 
325  bool have_affine_deltas
326  )
327  {
328  have_affine_deltas_ = have_affine_deltas;
329  }
331 
333 
335  inline
336  void CopyTrialToCurrent();
337 
339  void AcceptTrialPoint();
341 
343  Index iter_count() const
345  {
346  return iter_count_;
347  }
349  Index iter_count
350  )
351  {
352  iter_count_ = iter_count;
353  }
354 
355  Number curr_mu() const
356  {
357  DBG_ASSERT(mu_initialized_);
358  return curr_mu_;
359  }
360  void Set_mu(
361  Number mu
362  )
363  {
364  curr_mu_ = mu;
365  mu_initialized_ = true;
366  }
367  bool MuInitialized() const
368  {
369  return mu_initialized_;
370  }
371 
372  Number curr_tau() const
373  {
374  DBG_ASSERT(tau_initialized_);
375  return curr_tau_;
376  }
377  void Set_tau(
378  Number tau
379  )
380  {
381  curr_tau_ = tau;
382  tau_initialized_ = true;
383  }
384  bool TauInitialized() const
385  {
386  return tau_initialized_;
387  }
388 
390  bool free_mu_mode
391  )
392  {
393  free_mu_mode_ = free_mu_mode;
394  }
395  bool FreeMuMode() const
396  {
397  return free_mu_mode_;
398  }
399 
404  bool flag
405  )
406  {
407  tiny_step_flag_ = flag;
408  }
410  {
411  return tiny_step_flag_;
412  }
414 
422 
424  Number tol() const
425  {
426  DBG_ASSERT(initialize_called_);
427  return tol_;
428  }
439  void Set_tol(
440  Number tol
441  )
442  {
443  tol_ = tol;
444  }
446 
456  {
457  return timing_statistics_.OverallAlgorithm().StartCpuTime();
458  }
459 
461  Number info_regu_x() const
463  {
464  return info_regu_x_;
465  }
467  Number regu_x
468  )
469  {
470  info_regu_x_ = regu_x;
471  }
473  {
474  return info_alpha_primal_;
475  }
477  Number alpha_primal
478  )
479  {
480  info_alpha_primal_ = alpha_primal;
481  }
483  {
484  return info_alpha_primal_char_;
485  }
487  char info_alpha_primal_char
488  )
489  {
490  info_alpha_primal_char_ = info_alpha_primal_char;
491  }
493  {
494  return info_alpha_dual_;
495  }
497  Number alpha_dual
498  )
499  {
500  info_alpha_dual_ = alpha_dual;
501  }
503  {
504  return info_ls_count_;
505  }
507  Index ls_count
508  )
509  {
510  info_ls_count_ = ls_count;
511  }
512  bool info_skip_output() const
513  {
514  return info_skip_output_;
515  }
517  const std::string& add_str
518  )
519  {
520  info_string_ += add_str;
521  }
522  const std::string& info_string() const
523  {
524  return info_string_;
525  }
530  bool info_skip_output
531  )
532  {
533  info_skip_output_ = info_skip_output;
534  }
535 
538  {
539  return info_last_output_;
540  }
543  Number info_last_output
544  )
545  {
546  info_last_output_ = info_last_output;
547  }
548 
553  {
554  return info_iters_since_header_;
555  }
560  {
561  info_iters_since_header_++;
562  }
567  int info_iters_since_header
568  )
569  {
570  info_iters_since_header_ = info_iters_since_header;
571  }
572 
574  void ResetInfo()
575  {
576  info_regu_x_ = 0;
577  info_alpha_primal_ = 0;
578  info_alpha_dual_ = 0.;
579  info_alpha_primal_char_ = ' ';
580  info_skip_output_ = false;
581  info_string_.erase();
582  }
584 
587  {
588  return timing_statistics_;
589  }
590 
592  bool HaveAddData()
593  {
594  return IsValid(add_data_);
595  }
596 
599  {
600  return *add_data_;
601  }
602 
606  )
607  {
608  // cppcheck-suppress assertWithSideEffect
609  DBG_ASSERT(!HaveAddData());
610  add_data_ = add_data;
611  }
612 
614  void setPDPert(
615  Number pd_pert_x,
616  Number pd_pert_s,
617  Number pd_pert_c,
618  Number pd_pert_d
619  )
620  {
621  pd_pert_x_ = pd_pert_x;
622  pd_pert_s_ = pd_pert_s;
623  pd_pert_c_ = pd_pert_c;
624  pd_pert_d_ = pd_pert_d;
625  }
626 
628  void getPDPert(
629  Number& pd_pert_x,
630  Number& pd_pert_s,
631  Number& pd_pert_c,
632  Number& pd_pert_d
633  )
634  {
635  pd_pert_x = pd_pert_x_;
636  pd_pert_s = pd_pert_s_;
637  pd_pert_c = pd_pert_c_;
638  pd_pert_d = pd_pert_d_;
639  }
640 
641  static void RegisterOptions(
642  const SmartPtr<RegisteredOptions>& roptions
643  );
644 
645 private:
647 
650 
653 
656 
667  // ToDo we could cue off of a null delta_
670 
686  // ToDo we could cue off of a null delta_aff_
689 
692 
696 
700 
703 
708 
716 
720 
722 
728 
730 
746  std::string info_string_;
754 
757 
760 
765 
767  Number pd_pert_x_;
773 
783 
785  IpoptData(
786  const IpoptData&
787  );
788 
790  void operator=(
791  const IpoptData&
792  );
794 
795 #if IPOPT_CHECKLEVEL > 0
796 
799  TaggedObject::Tag debug_curr_tag_;
801  TaggedObject::Tag debug_trial_tag_;
802  TaggedObject::Tag debug_delta_tag_;
803  TaggedObject::Tag debug_delta_aff_tag_;
804  TaggedObject::Tag debug_curr_tag_sum_;
805  TaggedObject::Tag debug_trial_tag_sum_;
806  TaggedObject::Tag debug_delta_tag_sum_;
807  TaggedObject::Tag debug_delta_aff_tag_sum_;
809 #endif
810 
811 };
812 
814 {
815  DBG_ASSERT(IsNull(curr_) || (curr_->GetTag() == debug_curr_tag_ && curr_->GetTagSum() == debug_curr_tag_sum_) );
816 
817  return curr_;
818 }
819 
821 {
822  DBG_ASSERT(IsNull(trial_) || (trial_->GetTag() == debug_trial_tag_ && trial_->GetTagSum() == debug_trial_tag_sum_) );
823 
824  return trial_;
825 }
826 
828 {
829  DBG_ASSERT(IsNull(delta_) || (delta_->GetTag() == debug_delta_tag_ && delta_->GetTagSum() == debug_delta_tag_sum_) );
830 
831  return delta_;
832 }
833 
835 {
836  DBG_ASSERT(IsNull(delta_aff_) || (delta_aff_->GetTag() == debug_delta_aff_tag_ && delta_aff_->GetTagSum() == debug_delta_aff_tag_sum_) );
837 
838  return delta_aff_;
839 }
840 
841 inline
843 {
844  curr_ = trial_;
845 #if IPOPT_CHECKLEVEL > 0
846 
847  if (IsValid(curr_))
848  {
849  debug_curr_tag_ = curr_->GetTag();
850  debug_curr_tag_sum_ = curr_->GetTagSum();
851  }
852  else
853  {
854  debug_curr_tag_ = 0;
855  debug_curr_tag_sum_ = 0;
856  }
857 #endif
858 
859 }
860 
861 inline
864 )
865 {
866  trial_ = ConstPtr(trial);
867 
868 #if IPOPT_CHECKLEVEL > 0
869  // verify the correct space
870  DBG_ASSERT(trial_->OwnerSpace() == static_cast<VectorSpace*>(GetRawPtr(iterates_space_)));
871  if (IsValid(trial))
872  {
873  debug_trial_tag_ = trial->GetTag();
874  debug_trial_tag_sum_ = trial->GetTagSum();
875  }
876  else
877  {
878  debug_trial_tag_ = 0;
879  debug_trial_tag_sum_ = 0;
880  }
881 #endif
882 
883  trial = NULL;
884 }
885 
886 inline
889 )
890 {
891  delta_ = ConstPtr(delta);
892 #if IPOPT_CHECKLEVEL > 0
893 
894  if (IsValid(delta))
895  {
896  debug_delta_tag_ = delta->GetTag();
897  debug_delta_tag_sum_ = delta->GetTagSum();
898  }
899  else
900  {
901  debug_delta_tag_ = 0;
902  debug_delta_tag_sum_ = 0;
903  }
904 #endif
905 
906  delta = NULL;
907 }
908 
909 inline
912 )
913 {
914  delta_ = delta;
915 #if IPOPT_CHECKLEVEL > 0
916 
917  if (IsValid(delta))
918  {
919  debug_delta_tag_ = delta->GetTag();
920  debug_delta_tag_sum_ = delta->GetTagSum();
921  }
922  else
923  {
924  debug_delta_tag_ = 0;
925  debug_delta_tag_sum_ = 0;
926  }
927 #endif
928 
929  delta = NULL;
930 }
931 
932 inline
934  SmartPtr<IteratesVector>& delta_aff
935 )
936 {
938 #if IPOPT_CHECKLEVEL > 0
939 
940  if (IsValid(delta_aff))
941  {
942  debug_delta_aff_tag_ = delta_aff->GetTag();
943  debug_delta_aff_tag_sum_ = delta_aff->GetTagSum();
944  }
945  else
946  {
947  debug_delta_aff_tag_ = 0;
948  debug_delta_aff_tag_sum_ = delta_aff->GetTagSum();
949  }
950 #endif
951 
952  delta_aff = NULL;
953 }
954 
955 } // namespace Ipopt
956 
957 #endif
bool IsValid(const SmartPtr< U > &smart_ptr)
Definition: IpSmartPtr.hpp:672
void Set_info_regu_x(Number regu_x)
void set_delta(SmartPtr< IteratesVector > &delta)
Set the current delta.
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.
void Set_info_alpha_dual(Number alpha_dual)
IPOPT_DEPRECATED Number cpu_time_start() const
Cpu time counter at the beginning of the optimization.
#define IPOPTLIB_EXPORT
Definition: config.h:94
void set_delta_aff(SmartPtr< IteratesVector > &delta_aff)
Set the affine delta.
bool HaveDeltas() const
Returns true, if the primal-dual step have been already computed for the current iteration.
IpoptAdditionalData()
Default Constructor.
Definition: IpIpoptData.hpp:35
void Set_info_ls_count(Index ls_count)
TimingStatistics timing_statistics_
TimingStatistics object collecting all Ipopt timing statistics.
bool info_skip_output() const
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:680
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 ...
bool FreeMuMode() const
SmartPtr< const IteratesVector > trial() const
Get the current point in a copied container that is non-const.
bool HaveAffineDeltas() const
Returns true, if the affine-scaling step have been already computed for the current iteration...
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)
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.
ipindex Index
Type of all indices of vectors, matrices etc.
Definition: IpTypes.hpp:20
Number curr_tau() const
This file contains a base class for all exceptions and a set of macros to help with exceptions...
TimingStatistics & TimingStats()
Return Timing Statistics Object.
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:164
Storing the reference count of all the smart pointers that currently reference it.
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).
VectorSpace base class, corresponding to the Vector base class.
Definition: IpVector.hpp:472
bool have_affine_deltas_
The following flag is set to true, if some other part of the algorithm (like the method for computing...
SmartPtr< const IteratesVector > delta_aff_
U * GetRawPtr(const SmartPtr< U > &smart_ptr)
Definition: IpSmartPtr.hpp:649
SmartPtr< const IteratesVector > delta() const
get the current delta
Number curr_mu() const
char info_alpha_primal_char() const
Number tol_
Overall convergence tolerance.
SmartPtr< const IteratesVector > delta_
virtual ~IpoptAdditionalData()
Destructor.
Definition: IpIpoptData.hpp:39
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 ...
IpoptAdditionalData & AdditionalData()
Get access to additional data object.
Class to organize all the data required by the algorithm.
Definition: IpIpoptData.hpp:97
ipnumber Number
Type of all numbers.
Definition: IpTypes.hpp:17
const std::string & info_string() const
Number info_alpha_dual() const
#define DBG_ASSERT(test)
Definition: IpDebug.hpp:27
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< const IteratesVector > delta_aff() const
Affine Delta.
SmartPtr< IteratesVectorSpace > iterates_space_
VectorSpace for all the iterates.
unsigned int Tag
Type for the Tag values.
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:663
Index iter_count_
iteration count
bool MuInitialized() const
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 TauInitialized() const
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.
SmartPtr< const SymMatrix > W_
Hessian (approximation) - might be changed elsewhere!
Index info_ls_count() const
bool initialize_called_
flag indicating if Initialize method has been called (for debugging)
void Set_tau(Number tau)
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:35
Number info_alpha_primal() const
SmartPtr< const IteratesVector > curr() const
Current point.
#define IPOPT_DEPRECATED
macro to declare symbols as deprecated
Definition: IpTypes.h:25
Base class for additional data that is special to a particular type of algorithm, such as the CG pena...
Definition: IpIpoptData.hpp:29
bool have_deltas_
The following flag is set to true, if some other part of the algorithm (like the method for computing...
Number tol() const
Overall convergence tolerance.
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.
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.