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 
596  {
597  return timing_statistics_;
598  }
599 
601  bool HaveAddData()
602  {
603  return IsValid(add_data_);
604  }
605 
608  {
609  return *add_data_;
610  }
611 
615  )
616  {
617  // cppcheck-suppress assertWithSideEffect
618  DBG_ASSERT(!HaveAddData());
619  add_data_ = add_data;
620  }
621 
623  void setPDPert(
624  Number pd_pert_x,
625  Number pd_pert_s,
626  Number pd_pert_c,
627  Number pd_pert_d
628  )
629  {
630  pd_pert_x_ = pd_pert_x;
631  pd_pert_s_ = pd_pert_s;
632  pd_pert_c_ = pd_pert_c;
633  pd_pert_d_ = pd_pert_d;
634  }
635 
637  void getPDPert(
638  Number& pd_pert_x,
639  Number& pd_pert_s,
640  Number& pd_pert_c,
641  Number& pd_pert_d
642  )
643  {
644  pd_pert_x = pd_pert_x_;
645  pd_pert_s = pd_pert_s_;
646  pd_pert_c = pd_pert_c_;
647  pd_pert_d = pd_pert_d_;
648  }
649 
650  static void RegisterOptions(
651  const SmartPtr<RegisteredOptions>& roptions
652  );
653 
654 private:
656 
659 
662 
665 
676  // ToDo we could cue off of a null delta_
679 
695  // ToDo we could cue off of a null delta_aff_
698 
701 
705 
709 
712 
717 
725 
729 
731 
737 
739 
755  std::string info_string_;
763 
766 
769 
774 
776  Number pd_pert_x_;
782 
792 
794  IpoptData(
795  const IpoptData&
796  );
797 
799  void operator=(
800  const IpoptData&
801  );
803 
804 #if IPOPT_CHECKLEVEL > 0
805 
808  TaggedObject::Tag debug_curr_tag_;
810  TaggedObject::Tag debug_trial_tag_;
811  TaggedObject::Tag debug_delta_tag_;
812  TaggedObject::Tag debug_delta_aff_tag_;
813  TaggedObject::Tag debug_curr_tag_sum_;
814  TaggedObject::Tag debug_trial_tag_sum_;
815  TaggedObject::Tag debug_delta_tag_sum_;
816  TaggedObject::Tag debug_delta_aff_tag_sum_;
818 #endif
819 
820 };
821 
823 {
824  DBG_ASSERT(IsNull(curr_) || (curr_->GetTag() == debug_curr_tag_ && curr_->GetTagSum() == debug_curr_tag_sum_) );
825 
826  return curr_;
827 }
828 
830 {
831  DBG_ASSERT(IsNull(trial_) || (trial_->GetTag() == debug_trial_tag_ && trial_->GetTagSum() == debug_trial_tag_sum_) );
832 
833  return trial_;
834 }
835 
837 {
838  DBG_ASSERT(IsNull(delta_) || (delta_->GetTag() == debug_delta_tag_ && delta_->GetTagSum() == debug_delta_tag_sum_) );
839 
840  return delta_;
841 }
842 
844 {
845  DBG_ASSERT(IsNull(delta_aff_) || (delta_aff_->GetTag() == debug_delta_aff_tag_ && delta_aff_->GetTagSum() == debug_delta_aff_tag_sum_) );
846 
847  return delta_aff_;
848 }
849 
850 inline
852 {
853  curr_ = trial_;
854 #if IPOPT_CHECKLEVEL > 0
855 
856  if (IsValid(curr_))
857  {
858  debug_curr_tag_ = curr_->GetTag();
859  debug_curr_tag_sum_ = curr_->GetTagSum();
860  }
861  else
862  {
863  debug_curr_tag_ = 0;
864  debug_curr_tag_sum_ = 0;
865  }
866 #endif
867 
868 }
869 
870 inline
873 )
874 {
875  trial_ = ConstPtr(trial);
876 
877 #if IPOPT_CHECKLEVEL > 0
878  // verify the correct space
879  DBG_ASSERT(trial_->OwnerSpace() == static_cast<VectorSpace*>(GetRawPtr(iterates_space_)));
880  if (IsValid(trial))
881  {
882  debug_trial_tag_ = trial->GetTag();
883  debug_trial_tag_sum_ = trial->GetTagSum();
884  }
885  else
886  {
887  debug_trial_tag_ = 0;
888  debug_trial_tag_sum_ = 0;
889  }
890 #endif
891 
892  trial = NULL;
893 }
894 
895 inline
898 )
899 {
900  delta_ = ConstPtr(delta);
901 #if IPOPT_CHECKLEVEL > 0
902 
903  if (IsValid(delta))
904  {
905  debug_delta_tag_ = delta->GetTag();
906  debug_delta_tag_sum_ = delta->GetTagSum();
907  }
908  else
909  {
910  debug_delta_tag_ = 0;
911  debug_delta_tag_sum_ = 0;
912  }
913 #endif
914 
915  delta = NULL;
916 }
917 
918 inline
921 )
922 {
923  delta_ = delta;
924 #if IPOPT_CHECKLEVEL > 0
925 
926  if (IsValid(delta))
927  {
928  debug_delta_tag_ = delta->GetTag();
929  debug_delta_tag_sum_ = delta->GetTagSum();
930  }
931  else
932  {
933  debug_delta_tag_ = 0;
934  debug_delta_tag_sum_ = 0;
935  }
936 #endif
937 
938  delta = NULL;
939 }
940 
941 inline
943  SmartPtr<IteratesVector>& delta_aff
944 )
945 {
947 #if IPOPT_CHECKLEVEL > 0
948 
949  if (IsValid(delta_aff))
950  {
951  debug_delta_aff_tag_ = delta_aff->GetTag();
952  debug_delta_aff_tag_sum_ = delta_aff->GetTagSum();
953  }
954  else
955  {
956  debug_delta_aff_tag_ = 0;
957  debug_delta_aff_tag_sum_ = delta_aff->GetTagSum();
958  }
959 #endif
960 
961  delta_aff = NULL;
962 }
963 
964 } // namespace Ipopt
965 
966 #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)
const TimingStatistics & TimingStats() const
Return Timing Statistics Object.
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.