source: branches/dev/Algorithm/IpQualityFunctionMuOracle.hpp @ 529

Last change on this file since 529 was 529, checked in by andreasw, 15 years ago
  • in Vector class, copy cached values in Copy and update them in Scal
  • perform iterative refinement only once for adaptive strategy
  • fix bugs in PDPerturbationHandler
  • avoid some overhead in CalculateQualityFunction?
  • minor changes in timing
  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 10.2 KB
Line 
1// Copyright (C) 2004,2005 International Business Machines and others.
2// All Rights Reserved.
3// This code is published under the Common Public License.
4//
5// $Id: IpQualityFunctionMuOracle.hpp 529 2005-09-29 21:12:38Z andreasw $
6//
7// Authors:  Andreas Waechter             IBM    2004-11-12
8
9#ifndef __IPQUALITYFUNCTIONMUORACLE_HPP__
10#define __IPQUALITYFUNCTIONMUORACLE_HPP__
11
12#include "IpMuOracle.hpp"
13#include "IpPDSystemSolver.hpp"
14#include "IpIpoptCalculatedQuantities.hpp"
15
16namespace Ipopt
17{
18
19  /** Implementation of the probing strategy for computing the
20   *  barrier parameter.
21   */
22  class QualityFunctionMuOracle : public MuOracle
23  {
24  public:
25    /**@name Constructors/Destructors */
26    //@{
27    /** Constructor */
28    QualityFunctionMuOracle(const SmartPtr<PDSystemSolver>& pd_solver);
29    /** Default destructor */
30    virtual ~QualityFunctionMuOracle();
31    //@}
32
33    /** overloaded from AlgorithmStrategyObject */
34    virtual bool InitializeImpl(const OptionsList& options,
35                                const std::string& prefix);
36
37    /** Method for computing the value of the barrier parameter that
38     *  could be used in the current iteration (using the LOQO formula).
39     */
40    virtual Number CalculateMu(Number mu_min, Number mu_max);
41
42    /** Methods for IpoptType */
43    //@{
44    static void RegisterOptions(SmartPtr<RegisteredOptions> roptions);
45    //@}
46
47    /** @name Public enums.  Some of those are also used for the
48     *  quality function */
49    //@{
50    /** enum for norm type */
51    enum NormEnum
52    {
53      NM_NORM_1=0,
54      NM_NORM_2_SQUARED,
55      NM_NORM_MAX,
56      NM_NORM_2
57    };
58    /** enum for centrality type */
59    enum CentralityEnum
60    {
61      CEN_NONE=0,
62      CEN_LOG,
63      CEN_RECIPROCAL,
64      CEN_CUBED_RECIPROCAL
65    };
66    /** enum for the quality function balancing term type */
67    enum BalancingTermEnum
68    {
69      BT_NONE=0,
70      BT_CUBIC
71    };
72    //@}
73
74  private:
75    /**@name Default Compiler Generated Methods
76     * (Hidden to avoid implicit creation/calling).
77     * These methods are not implemented and
78     * we do not want the compiler to implement
79     * them for us, so we declare them private
80     * and do not define them. This ensures that
81     * they will not be implicitly created/called. */
82    //@{
83
84    /** Default Constructor */
85    QualityFunctionMuOracle();
86    /** Copy Constructor */
87    QualityFunctionMuOracle(const QualityFunctionMuOracle&);
88
89    /** Overloaded Equals Operator */
90    void operator=(const QualityFunctionMuOracle&);
91    //@}
92
93    /** Pointer to the object that should be used to solve the
94     *  primal-dual system.
95     */
96    SmartPtr<PDSystemSolver> pd_solver_;
97
98    /** Auxilliary function for computing the average complementarity
99     *  at a point, given step sizes and step
100     */
101    // ToDo Replace pointers by references
102    Number CalculateQualityFunction(Number sigma,
103                                    const Vector& step_aff_x_L,
104                                    const Vector& step_aff_x_U,
105                                    const Vector& step_aff_s_L,
106                                    const Vector& step_aff_s_U,
107                                    const Vector& step_aff_y_c,
108                                    const Vector& step_aff_y_d,
109                                    const Vector& step_aff_z_L,
110                                    const Vector& step_aff_z_U,
111                                    const Vector& step_aff_v_L,
112                                    const Vector& step_aff_v_U,
113                                    const Vector& step_cen_x_L,
114                                    const Vector& step_cen_x_U,
115                                    const Vector& step_cen_s_L,
116                                    const Vector& step_cen_s_U,
117                                    const Vector& step_cen_y_c,
118                                    const Vector& step_cen_y_d,
119                                    const Vector& step_cen_z_L,
120                                    const Vector& step_cen_z_U,
121                                    const Vector& step_cen_v_L,
122                                    const Vector& step_cen_v_U);
123
124    /** Auxilliary function performing the golden section */
125    Number PerformGoldenSection(Number sigma_up,
126                                Number q_up,
127                                Number sigma_lo,
128                                Number q_lo,
129                                Number sigma_tol,
130                                Number qf_tol,
131                                const Vector& step_aff_x_L,
132                                const Vector& step_aff_x_U,
133                                const Vector& step_aff_s_L,
134                                const Vector& step_aff_s_U,
135                                const Vector& step_aff_y_c,
136                                const Vector& step_aff_y_d,
137                                const Vector& step_aff_z_L,
138                                const Vector& step_aff_z_U,
139                                const Vector& step_aff_v_L,
140                                const Vector& step_aff_v_U,
141                                const Vector& step_cen_x_L,
142                                const Vector& step_cen_x_U,
143                                const Vector& step_cen_s_L,
144                                const Vector& step_cen_s_U,
145                                const Vector& step_cen_y_c,
146                                const Vector& step_cen_y_d,
147                                const Vector& step_cen_z_L,
148                                const Vector& step_cen_z_U,
149                                const Vector& step_cen_v_L,
150                                const Vector& step_cen_v_U);
151
152    /** Auxilliary functions for scaling the sigma axis in the golden
153     *  section procedure */
154    //@{
155    Number ScaleSigma(Number sigma);
156    Number UnscaleSigma(Number scaled_sigma);
157    //@}
158
159    /** Auxilliary function performing the golden section in the
160     *  logarithmic scale */
161    /* This doesn't seem to work well, so I took it out for now (AW)
162    Number PerformGoldenSectionLog(Number sigma_up,
163                                     Number sigma_lo,
164                                     Number tol,
165                                     const Vector& step_aff_x_L,
166                                     const Vector& step_aff_x_U,
167                                     const Vector& step_aff_s_L,
168                                     const Vector& step_aff_s_U,
169                                     const Vector& step_aff_y_c,
170                                     const Vector& step_aff_y_d,
171                                     const Vector& step_aff_z_L,
172                                     const Vector& step_aff_z_U,
173                                     const Vector& step_aff_v_L,
174                                     const Vector& step_aff_v_U,
175                                     const Vector& step_cen_x_L,
176                                     const Vector& step_cen_x_U,
177                                     const Vector& step_cen_s_L,
178                                     const Vector& step_cen_s_U,
179                                     const Vector& step_cen_y_c,
180                                     const Vector& step_cen_y_d,
181                                     const Vector& step_cen_z_L,
182                                     const Vector& step_cen_z_U,
183                                     const Vector& step_cen_v_L,
184                                     const Vector& step_cen_v_U);
185    */
186
187    /** @name Algorithmic parameters */
188    //@{
189    /** Upper bound on centering parameter sigma */
190    Number sigma_max_;
191    /** Lower bound on centering parameter sigma */
192    Number sigma_min_;
193    /** Norm to be used for the quality function. */
194    NormEnum quality_function_norm_;
195    /** Flag indicating how centrality should be involved in the
196     *  quality function */
197    CentralityEnum quality_function_centrality_;
198    /** Flag indicating whether we use a balancing term in the quality
199     *  function.
200     */
201    BalancingTermEnum quality_function_balancing_term_;
202    /** Relative tolerance for golden bi-section algorithm in sigma
203     *  space. */
204    Number quality_function_section_sigma_tol_;
205    /** Relative tolerance for golden bi-section algorithm in function
206     *  value space. */
207    Number quality_function_section_qf_tol_;
208    /** Maximal number of bi-section steps in the golden section
209     *  search for sigma. */
210    Index quality_function_max_section_steps_;
211    //@}
212
213    /** @name Temporary work space vectors.  We use those to avoid
214     *  repeated reallocation in CalculateQualityFunction. */
215    //@{
216    SmartPtr<Vector> tmp_step_x_L_;
217    SmartPtr<Vector> tmp_step_x_U_;
218    SmartPtr<Vector> tmp_step_s_L_;
219    SmartPtr<Vector> tmp_step_s_U_;
220    SmartPtr<Vector> tmp_step_z_L_;
221    SmartPtr<Vector> tmp_step_z_U_;
222    SmartPtr<Vector> tmp_step_v_L_;
223    SmartPtr<Vector> tmp_step_v_U_;
224
225    SmartPtr<Vector> tmp_slack_x_L_;
226    SmartPtr<Vector> tmp_slack_x_U_;
227    SmartPtr<Vector> tmp_slack_s_L_;
228    SmartPtr<Vector> tmp_slack_s_U_;
229    SmartPtr<Vector> tmp_z_L_;
230    SmartPtr<Vector> tmp_z_U_;
231    SmartPtr<Vector> tmp_v_L_;
232    SmartPtr<Vector> tmp_v_U_;
233    //@}
234
235    /* Counter for the qualify function evaluations */
236    Index count_qf_evals_;
237
238    /**@name Quantities used many times in CalculateQualityFunction,
239     * which we store here instead of retrieving them from cache every
240     * time.  I (AW) don't know if that really makes a difference, but
241     * some of those things showed up in gprof. */
242    //@{
243    bool initialized_;
244    Index n_dual_;
245    Index n_pri_;
246    Index n_comp_;
247
248    SmartPtr<const Vector> curr_slack_x_L_;
249    SmartPtr<const Vector> curr_slack_x_U_;
250    SmartPtr<const Vector> curr_slack_s_L_;
251    SmartPtr<const Vector> curr_slack_s_U_;
252
253    SmartPtr<const Vector> curr_z_L_;
254    SmartPtr<const Vector> curr_z_U_;
255    SmartPtr<const Vector> curr_v_L_;
256    SmartPtr<const Vector> curr_v_U_;
257
258    Number curr_grad_lag_x_asum_;
259    Number curr_grad_lag_s_asum_;
260    Number curr_c_asum_;
261    Number curr_d_minus_s_asum_;
262
263    Number curr_grad_lag_x_nrm2_;
264    Number curr_grad_lag_s_nrm2_;
265    Number curr_c_nrm2_;
266    Number curr_d_minus_s_nrm2_;
267
268    Number curr_grad_lag_x_amax_;
269    Number curr_grad_lag_s_amax_;
270    Number curr_c_amax_;
271    Number curr_d_minus_s_amax_;
272    //@}
273  };
274
275} // namespace Ipopt
276
277#endif
Note: See TracBrowser for help on using the repository browser.