This file is indexed.

/usr/include/coin/ClpObjective.hpp is in coinor-libclp-dev 1.12.0-2.1.

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
/* $Id: ClpObjective.hpp 1525 2010-02-26 17:27:59Z mjs $ */
// Copyright (C) 2002, International Business Machines
// Corporation and others.  All Rights Reserved.
#ifndef ClpObjective_H
#define ClpObjective_H


//#############################################################################
class ClpSimplex;
class ClpModel;

/** Objective Abstract Base Class

Abstract Base Class for describing an objective function

*/
class ClpObjective  {

public:

     ///@name Stuff
     //@{

     /** Returns gradient.  If Linear then solution may be NULL,
         also returns an offset (to be added to current one)
         If refresh is false then uses last solution
         Uses model for scaling
         includeLinear 0 - no, 1 as is, 2 as feasible
     */
     virtual double * gradient(const ClpSimplex * model,
                               const double * solution,
                               double & offset, bool refresh,
                               int includeLinear = 2) = 0;
     /** Returns reduced gradient.Returns an offset (to be added to current one).
     */
     virtual double reducedGradient(ClpSimplex * model, double * region,
                                    bool useFeasibleCosts) = 0;
     /** Returns step length which gives minimum of objective for
         solution + theta * change vector up to maximum theta.

         arrays are numberColumns+numberRows
         Also sets current objective, predicted  and at maximumTheta
     */
     virtual double stepLength(ClpSimplex * model,
                               const double * solution,
                               const double * change,
                               double maximumTheta,
                               double & currentObj,
                               double & predictedObj,
                               double & thetaObj) = 0;
     /// Return objective value (without any ClpModel offset) (model may be NULL)
     virtual double objectiveValue(const ClpSimplex * model, const double * solution) const = 0;
     /// Resize objective
     virtual void resize(int newNumberColumns) = 0;
     /// Delete columns in  objective
     virtual void deleteSome(int numberToDelete, const int * which) = 0;
     /// Scale objective
     virtual void reallyScale(const double * columnScale) = 0;
     /** Given a zeroed array sets nonlinear columns to 1.
         Returns number of nonlinear columns
      */
     virtual int markNonlinear(char * which);
     /// Say we have new primal solution - so may need to recompute
     virtual void newXValues() {}
     //@}


     ///@name Constructors and destructors
     //@{
     /// Default Constructor
     ClpObjective();

     /// Copy constructor
     ClpObjective(const ClpObjective &);

     /// Assignment operator
     ClpObjective & operator=(const ClpObjective& rhs);

     /// Destructor
     virtual ~ClpObjective ();

     /// Clone
     virtual ClpObjective * clone() const = 0;
     /** Subset clone.  Duplicates are allowed
         and order is as given.
         Derived classes need not provide this as it may not always make
         sense */
     virtual ClpObjective * subsetClone (int numberColumns,
                                         const int * whichColumns) const;

     //@}

     ///@name Other
     //@{
     /// Returns type (above 63 is extra information)
     inline int type() {
          return type_;
     }
     /// Whether activated
     inline int activated() const {
          return activated_;
     }
     /// Set whether activated
     inline void setActivated(int value) {
          activated_ = value;
     }

     /// Objective offset
     inline double nonlinearOffset () const {
          return offset_;
     }
     //@}

     //---------------------------------------------------------------------------

protected:
     ///@name Protected member data
     //@{
     /// Value of non-linear part of objective
     double offset_;
     /// Type of objective - linear is 1
     int type_;
     /// Whether activated
     int activated_;
     //@}
};

#endif