1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
|
// Copyright (C) 2008 International Business Machines and others.
// All Rights Reserved.
// This code is published under the Eclipse Public License.
//
// $Id: IpTNLPReducer.hpp 1861 2010-12-21 21:34:47Z andreasw $
//
// Authors: Andreas Waechter IBM 2008-08-10
#ifndef __IPTNLPREDUCER_HPP__
#define __IPTNLPREDUCER_HPP__
#include "IpTNLP.hpp"
namespace Ipopt
{
/** This is a wrapper around a given TNLP class that takes out a
* list of constraints that are given to the constructor. It is
* provided for convenience, if one wants to experiment with
* problems that consist of only a subset of the constraints. But
* keep in mind that this is not efficient, since behind the scenes
* we are still evaluation all functions and derivatives, and are
* making copies of the original data. */
class TNLPReducer : public TNLP
{
public:
/**@name Constructors/Destructors */
//@{
/** Constructor is given the indices of the constraints that
* should be taken out of the problem statement, as well as the
* original TNLP. */
TNLPReducer(TNLP& tnlp, Index n_g_skip, const Index* index_g_skip,
Index n_xL_skip, const Index* index_xL_skip,
Index n_xU_skip, const Index* index_xU_skip,
Index n_x_fix, const Index* index_f_fix);
/** Default destructor */
virtual ~TNLPReducer();
//@}
/** @name Overloaded methods from TNLP */
virtual bool get_nlp_info(Index& n, Index& m, Index& nnz_jac_g,
Index& nnz_h_lag, IndexStyleEnum& index_style);
virtual bool get_bounds_info(Index n, Number* x_l, Number* x_u,
Index m, Number* g_l, Number* g_u);
virtual bool get_scaling_parameters(Number& obj_scaling,
bool& use_x_scaling, Index n,
Number* x_scaling,
bool& use_g_scaling, Index m,
Number* g_scaling);
virtual bool get_variables_linearity(Index n, LinearityType* var_types);
virtual bool get_constraints_linearity(Index m, LinearityType* const_types);
virtual bool get_starting_point(Index n, bool init_x, Number* x,
bool init_z, Number* z_L, Number* z_U,
Index m, bool init_lambda,
Number* lambda);
virtual bool get_warm_start_iterate(IteratesVector& warm_start_iterate);
virtual bool eval_f(Index n, const Number* x, bool new_x,
Number& obj_value);
virtual bool eval_grad_f(Index n, const Number* x, bool new_x,
Number* grad_f);
virtual bool eval_g(Index n, const Number* x, bool new_x,
Index m, Number* g);
virtual bool eval_jac_g(Index n, const Number* x, bool new_x,
Index m, Index nele_jac, Index* iRow,
Index *jCol, Number* values);
virtual bool eval_h(Index n, const Number* x, bool new_x,
Number obj_factor, Index m, const Number* lambda,
bool new_lambda, Index nele_hess,
Index* iRow, Index* jCol, Number* values);
virtual void finalize_solution(SolverReturn status,
Index n, const Number* x, const Number* z_L, const Number* z_U,
Index m, const Number* g, const Number* lambda,
Number obj_value,
const IpoptData* ip_data,
IpoptCalculatedQuantities* ip_cq);
virtual bool intermediate_callback(AlgorithmMode mode,
Index iter, Number obj_value,
Number inf_pr, Number inf_du,
Number mu, Number d_norm,
Number regularization_size,
Number alpha_du, Number alpha_pr,
Index ls_trials,
const IpoptData* ip_data,
IpoptCalculatedQuantities* ip_cq);
virtual Index get_number_of_nonlinear_variables();
virtual bool get_list_of_nonlinear_variables(Index num_nonlin_vars,
Index* pos_nonlin_vars);
//@}
private:
/**@name Default Compiler Generated Methods
* (Hidden to avoid implicit creation/calling).
* These methods are not implemented and
* we do not want the compiler to implement
* them for us, so we declare them private
* and do not define them. This ensures that
* they will not be implicitly created/called. */
//@{
/** Default Constructor */
TNLPReducer();
/** Copy Constructor */
TNLPReducer(const TNLPReducer&);
/** Overloaded Equals Operator */
void operator=(const TNLPReducer&);
//@}
/** @name original TNLP */
//@{
SmartPtr<TNLP> tnlp_;
Index m_orig_;
Index nnz_jac_g_orig_;
//@}
/** Number of constraints to be skipped */
Index n_g_skip_;
/** Array of indices of the constraints that are to be skipped.
* This is provided at the beginning in the constructor. */
Index* index_g_skip_;
/** Index style for original problem. Internally, we use C-Style
* now. */
IndexStyleEnum index_style_orig_;
/** Map from original constraints to new constraints. A -1 means
* that a constraint is skipped. */
Index* g_keep_map_;
/** Number of constraints in reduced NLP */
Index m_reduced_;
/** Number of Jacobian nonzeros in the reduced NLP */
Index nnz_jac_g_reduced_;
/** Number of Jacobian nonzeros that are skipped */
Index nnz_jac_g_skipped_;
/** Array of Jacobian elements that are to be skipped. This is in
* increasing order. */
Index* jac_g_skipped_;
/** Number of lower variable bounds to be skipped. */
Index n_xL_skip_;
/** Array of indices of the lower variable bounds to be skipped. */
Index* index_xL_skip_;
/** Number of upper variable bounds to be skipped. */
Index n_xU_skip_;
/** Array of indices of the upper variable bounds to be skipped. */
Index* index_xU_skip_;
/** Number of variables that are to be fixed to initial value. */
Index n_x_fix_;
/** Array of indices of the variables that are to be fixed. */
Index* index_x_fix_;
};
} // namespace Ipopt
#endif
|
