This file is indexed.

/usr/include/coin/IpOrigIpoptNLP.hpp is in coinor-libipopt-dev 3.11.9-2.

This file is owned by root:root, with mode 0o644.

The actual contents of the file can be viewed below.

  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
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
// Copyright (C) 2004, 2010 International Business Machines and others.
// All Rights Reserved.
// This code is published under the Eclipse Public License.
//
// $Id: IpOrigIpoptNLP.hpp 2160 2012-12-26 19:14:42Z stefan $
//
// Authors:  Carl Laird, Andreas Waechter     IBM    2004-08-13

#ifndef __IPORIGIPOPTNLP_HPP__
#define __IPORIGIPOPTNLP_HPP__

#include "IpIpoptNLP.hpp"
#include "IpException.hpp"
#include "IpTimingStatistics.hpp"

namespace Ipopt
{

  /** enumeration for the Hessian information type. */
  enum HessianApproximationType {
    EXACT=0,
    LIMITED_MEMORY
  };

  /** enumeration for the Hessian approximation space. */
  enum HessianApproximationSpace {
    NONLINEAR_VARS=0,
    ALL_VARS
  };

  /** This class maps the traditional NLP into
   *  something that is more useful by Ipopt.
   *  This class takes care of storing the
   *  calculated model results, handles caching,
   *  and (some day) takes care of addition of slacks.
   */
  class OrigIpoptNLP : public IpoptNLP
  {
  public:
    /**@name Constructors/Destructors */
    //@{
    OrigIpoptNLP(const SmartPtr<const Journalist>& jnlst,
                 const SmartPtr<NLP>& nlp,
                 const SmartPtr<NLPScalingObject>& nlp_scaling);

    /** Default destructor */
    virtual ~OrigIpoptNLP();
    //@}

    /** Initialize - overloaded from IpoptNLP */
    virtual bool Initialize(const Journalist& jnlst,
                            const OptionsList& options,
                            const std::string& prefix);

    /** Initialize (create) structures for
     *  the iteration data */
    virtual bool InitializeStructures(SmartPtr<Vector>& x,
                                      bool init_x,
                                      SmartPtr<Vector>& y_c,
                                      bool init_y_c,
                                      SmartPtr<Vector>& y_d,
                                      bool init_y_d,
                                      SmartPtr<Vector>& z_L,
                                      bool init_z_L,
                                      SmartPtr<Vector>& z_U,
                                      bool init_z_U,
                                      SmartPtr<Vector>& v_L,
                                      SmartPtr<Vector>& v_U
                                     );

    /** Method accessing the GetWarmStartIterate of the NLP */
    virtual bool GetWarmStartIterate(IteratesVector& warm_start_iterate)
    {
      return nlp_->GetWarmStartIterate(warm_start_iterate);
    }
    /** Accessor methods for model data */
    //@{
    /** Objective value */
    virtual Number f(const Vector& x);

    /** Objective value (depending in mu) - incorrect version for
     *  OrigIpoptNLP */
    virtual Number f(const Vector& x, Number mu);

    /** Gradient of the objective */
    virtual SmartPtr<const Vector> grad_f(const Vector& x);

    /** Gradient of the objective (depending in mu) - incorrect
     *  version for OrigIpoptNLP */
    virtual SmartPtr<const Vector> grad_f(const Vector& x, Number mu);

    /** Equality constraint residual */
    virtual SmartPtr<const Vector> c(const Vector& x);

    /** Jacobian Matrix for equality constraints */
    virtual SmartPtr<const Matrix> jac_c(const Vector& x);

    /** Inequality constraint residual (reformulated
     *  as equalities with slacks */
    virtual SmartPtr<const Vector> d(const Vector& x);

    /** Jacobian Matrix for inequality constraints*/
    virtual SmartPtr<const Matrix> jac_d(const Vector& x);

    /** Hessian of the Lagrangian */
    virtual SmartPtr<const SymMatrix> h(const Vector& x,
                                        Number obj_factor,
                                        const Vector& yc,
                                        const Vector& yd
                                       );

    /** Hessian of the Lagrangian (depending in mu) - incorrect
     *  version for OrigIpoptNLP */
    virtual SmartPtr<const SymMatrix> h(const Vector& x,
                                        Number obj_factor,
                                        const Vector& yc,
                                        const Vector& yd,
                                        Number mu);

    /** Provides a Hessian matrix from the correct matrix space with
     *  uninitialized values.  This can be used in LeastSquareMults to
     *  obtain a "zero Hessian". */
    virtual SmartPtr<const SymMatrix> uninitialized_h();

    /** Lower bounds on x */
    virtual SmartPtr<const Vector> x_L() const
    {
      return x_L_;
    }

    /** Permutation matrix (x_L_ -> x) */
    virtual SmartPtr<const Matrix> Px_L() const
    {
      return Px_L_;
    }

    /** Upper bounds on x */
    virtual SmartPtr<const Vector> x_U() const
    {
      return x_U_;
    }

    /** Permutation matrix (x_U_ -> x */
    virtual SmartPtr<const Matrix> Px_U() const
    {
      return Px_U_;
    }

    /** Lower bounds on d */
    virtual SmartPtr<const Vector> d_L() const
    {
      return d_L_;
    }

    /** Permutation matrix (d_L_ -> d) */
    virtual SmartPtr<const Matrix> Pd_L() const
    {
      return Pd_L_;
    }

    /** Upper bounds on d */
    virtual SmartPtr<const Vector> d_U() const
    {
      return d_U_;
    }

    /** Permutation matrix (d_U_ -> d */
    virtual SmartPtr<const Matrix> Pd_U() const
    {
      return Pd_U_;
    }

    virtual SmartPtr<const SymMatrixSpace> HessianMatrixSpace() const
    {
      return h_space_;
    }
    //@}

    /** Accessor method for vector/matrix spaces pointers */
    virtual void GetSpaces(SmartPtr<const VectorSpace>& x_space,
                           SmartPtr<const VectorSpace>& c_space,
                           SmartPtr<const VectorSpace>& d_space,
                           SmartPtr<const VectorSpace>& x_l_space,
                           SmartPtr<const MatrixSpace>& px_l_space,
                           SmartPtr<const VectorSpace>& x_u_space,
                           SmartPtr<const MatrixSpace>& px_u_space,
                           SmartPtr<const VectorSpace>& d_l_space,
                           SmartPtr<const MatrixSpace>& pd_l_space,
                           SmartPtr<const VectorSpace>& d_u_space,
                           SmartPtr<const MatrixSpace>& pd_u_space,
                           SmartPtr<const MatrixSpace>& Jac_c_space,
                           SmartPtr<const MatrixSpace>& Jac_d_space,
                           SmartPtr<const SymMatrixSpace>& Hess_lagrangian_space);

    /** Method for adapting the variable bounds.  This is called if
     *  slacks are becoming too small */
    virtual void AdjustVariableBounds(const Vector& new_x_L,
                                      const Vector& new_x_U,
                                      const Vector& new_d_L,
                                      const Vector& new_d_U);

    /** @name Counters for the number of function evaluations. */
    //@{
    virtual Index f_evals() const
    {
      return f_evals_;
    }
    virtual Index grad_f_evals() const
    {
      return grad_f_evals_;
    }
    virtual Index c_evals() const
    {
      return c_evals_;
    }
    virtual Index jac_c_evals() const
    {
      return jac_c_evals_;
    }
    virtual Index d_evals() const
    {
      return d_evals_;
    }
    virtual Index jac_d_evals() const
    {
      return jac_d_evals_;
    }
    virtual Index h_evals() const
    {
      return h_evals_;
    }
    //@}

    /** Solution Routines - overloaded from IpoptNLP*/
    //@{
    void FinalizeSolution(SolverReturn status,
                          const Vector& x, const Vector& z_L, const Vector& z_U,
                          const Vector& c, const Vector& d,
                          const Vector& y_c, const Vector& y_d,
                          Number obj_value,
                          const IpoptData* ip_data,
                          IpoptCalculatedQuantities* ip_cq);
    bool IntermediateCallBack(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,
                              SmartPtr<const IpoptData> ip_data,
                              SmartPtr<IpoptCalculatedQuantities> ip_cq);
    //@}

    /** @name Methods for IpoptType */
    //@{
    /** Called by IpoptType to register the options */
    static void RegisterOptions(SmartPtr<RegisteredOptions> roptions);
    //@}

    /** Accessor method to the underlying NLP */
    SmartPtr<NLP> nlp()
    {
      return nlp_;
    }

    /**@name Methods related to function evaluation timing. */
    //@{

    /** Reset the timing statistics */
    void ResetTimes();

    void PrintTimingStatistics(Journalist& jnlst,
                               EJournalLevel level,
                               EJournalCategory category) const;

    const TimedTask& f_eval_time() const
    {
      return f_eval_time_;
    }
    const TimedTask& grad_f_eval_time() const
    {
      return grad_f_eval_time_;
    }
    const TimedTask& c_eval_time() const
    {
      return c_eval_time_;
    }
    const TimedTask& jac_c_eval_time() const
    {
      return jac_c_eval_time_;
    }
    const TimedTask& d_eval_time() const
    {
      return d_eval_time_;
    }
    const TimedTask& jac_d_eval_time() const
    {
      return jac_d_eval_time_;
    }
    const TimedTask& h_eval_time() const
    {
      return h_eval_time_;
    }

    Number TotalFunctionEvaluationCpuTime() const;
    Number TotalFunctionEvaluationSysTime() const;
    Number TotalFunctionEvaluationWallclockTime() const;
    //@}

  private:
    /** journalist */
    SmartPtr<const Journalist> jnlst_;

    /** Pointer to the NLP */
    SmartPtr<NLP> nlp_;

    /** Necessary Vector/Matrix spaces */
    //@{
    SmartPtr<const VectorSpace> x_space_;
    SmartPtr<const VectorSpace> c_space_;
    SmartPtr<const VectorSpace> d_space_;
    SmartPtr<const VectorSpace> x_l_space_;
    SmartPtr<const MatrixSpace> px_l_space_;
    SmartPtr<const VectorSpace> x_u_space_;
    SmartPtr<const MatrixSpace> px_u_space_;
    SmartPtr<const VectorSpace> d_l_space_;
    SmartPtr<const MatrixSpace> pd_l_space_;
    SmartPtr<const VectorSpace> d_u_space_;
    SmartPtr<const MatrixSpace> pd_u_space_;
    SmartPtr<const MatrixSpace> jac_c_space_;
    SmartPtr<const MatrixSpace> jac_d_space_;
    SmartPtr<const SymMatrixSpace> h_space_;

    SmartPtr<const MatrixSpace> scaled_jac_c_space_;
    SmartPtr<const MatrixSpace> scaled_jac_d_space_;
    SmartPtr<const SymMatrixSpace> scaled_h_space_;
    //@}
    /**@name Storage for Model Quantities */
    //@{
    /** Objective function */
    CachedResults<Number> f_cache_;

    /** Gradient of the objective function */
    CachedResults<SmartPtr<const Vector> > grad_f_cache_;

    /** Equality constraint residuals */
    CachedResults<SmartPtr<const Vector> > c_cache_;

    /** Jacobian Matrix for equality constraints
     *  (current iteration) */
    CachedResults<SmartPtr<const Matrix> > jac_c_cache_;

    /** Inequality constraint residual (reformulated
     *  as equalities with slacks */
    CachedResults<SmartPtr<const Vector> > d_cache_;

    /** Jacobian Matrix for inequality constraints
     *  (current iteration) */
    CachedResults<SmartPtr<const Matrix> > jac_d_cache_;

    /** Hessian of the lagrangian
     *  (current iteration) */
    CachedResults<SmartPtr<const SymMatrix> > h_cache_;

    /** Unscaled version of x vector */
    CachedResults<SmartPtr<const Vector> > unscaled_x_cache_;

    /** Lower bounds on x */
    SmartPtr<const Vector> x_L_;

    /** Permutation matrix (x_L_ -> x) */
    SmartPtr<const Matrix> Px_L_;

    /** Upper bounds on x */
    SmartPtr<const Vector> x_U_;

    /** Permutation matrix (x_U_ -> x */
    SmartPtr<const Matrix> Px_U_;

    /** Lower bounds on d */
    SmartPtr<const Vector> d_L_;

    /** Permutation matrix (d_L_ -> d) */
    SmartPtr<const Matrix> Pd_L_;

    /** Upper bounds on d */
    SmartPtr<const Vector> d_U_;

    /** Permutation matrix (d_U_ -> d */
    SmartPtr<const Matrix> Pd_U_;

    /** Original unmodified lower bounds on x */
    SmartPtr<const Vector> orig_x_L_;

    /** Original unmodified upper bounds on x */
    SmartPtr<const Vector> orig_x_U_;
    //@}

    /**@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 */
    OrigIpoptNLP();

    /** Copy Constructor */
    OrigIpoptNLP(const OrigIpoptNLP&);

    /** Overloaded Equals Operator */
    void operator=(const OrigIpoptNLP&);
    //@}

    /** @name auxilliary functions */
    //@{
    /** relax the bounds by a relative move of relax_bound_factor.
     *  Here, relax_bound_factor should be negative (or zero) for
     *  lower bounds, and positive (or zero) for upper bounds.
     */
    void relax_bounds(Number bound_relax_factor, Vector& bounds);
    /** Method for getting the unscaled version of the x vector */
    SmartPtr<const Vector> get_unscaled_x(const Vector& x);
    //@}

    /** @name Algorithmic parameters */
    //@{
    /** relaxation factor for the bounds */
    Number bound_relax_factor_;
    /** Flag indicating whether the primal variables should be
     *  projected back into original bounds are optimization. */
    bool honor_original_bounds_;
    /** Flag indicating whether the TNLP with identical structure has
     *  already been solved before. */
    bool warm_start_same_structure_;
    /** Flag indicating what Hessian information is to be used. */
    HessianApproximationType hessian_approximation_;
    /** Flag indicating in which space Hessian is to be approximated. */
    HessianApproximationSpace hessian_approximation_space_;
    /** Flag indicating whether it is desired to check if there are
     *  Nan or Inf entries in first and second derivative matrices. */
    bool check_derivatives_for_naninf_;
    /** Flag indicating if we need to ask for equality constraint
     *  Jacobians only once */
    bool jac_c_constant_;
    /** Flag indicating if we need to ask for inequality constraint
     *  Jacobians only once */
    bool jac_d_constant_;
    /** Flag indicating if we need to ask for Hessian only once */
    bool hessian_constant_;
    //@}

    /** @name Counters for the function evaluations */
    //@{
    Index f_evals_;
    Index grad_f_evals_;
    Index c_evals_;
    Index jac_c_evals_;
    Index d_evals_;
    Index jac_d_evals_;
    Index h_evals_;
    //@}

    /** Flag indicating if initialization method has been called */
    bool initialized_;

    /**@name Timing statistics for the function evaluations. */
    //@{
    TimedTask f_eval_time_;
    TimedTask grad_f_eval_time_;
    TimedTask c_eval_time_;
    TimedTask jac_c_eval_time_;
    TimedTask d_eval_time_;
    TimedTask jac_d_eval_time_;
    TimedTask h_eval_time_;
    //@}
  };

} // namespace Ipopt

#endif