This file is indexed.

/usr/include/coin/ClpParameters.hpp is in coinor-libclp-dev 1.15.10-3+b1.

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
/* $Id: ClpParameters.hpp 2045 2014-08-13 15:05:38Z tkr $ */
// Copyright (C) 2000, 2002, International Business Machines
// Corporation and others.  All Rights Reserved.
// This code is licensed under the terms of the Eclipse Public License (EPL).

#ifndef _ClpParameters_H
#define _ClpParameters_H

/** This is where to put any useful stuff.

*/
enum ClpIntParam {
     /** The maximum number of iterations Clp can execute in the simplex methods
      */
     ClpMaxNumIteration = 0,
     /** The maximum number of iterations Clp can execute in hotstart before
         terminating */
     ClpMaxNumIterationHotStart,
     /** The name discipline; specifies how the solver will handle row and
         column names.
       - 0: Auto names: Names cannot be set by the client. Names of the form
        Rnnnnnnn or Cnnnnnnn are generated on demand when a name for a
        specific row or column is requested; nnnnnnn is derived from the row
        or column index. Requests for a vector of names return a vector with
        zero entries.
       - 1: Lazy names: Names supplied by the client are retained. Names of the
        form Rnnnnnnn or Cnnnnnnn are generated on demand if no name has been
        supplied by the client. Requests for a vector of names return a
        vector sized to the largest index of a name supplied by the client;
        some entries in the vector may be null strings.
       - 2: Full names: Names supplied by the client are retained. Names of the
        form Rnnnnnnn or Cnnnnnnn are generated on demand if no name has been
        supplied by the client. Requests for a vector of names return a
        vector sized to match the constraint system, and all entries will
        contain either the name specified by the client or a generated name.
     */
     ClpNameDiscipline,
     /** Just a marker, so that we can allocate a static sized array to store
         parameters. */
     ClpLastIntParam
};

enum ClpDblParam {
     /** Set Dual objective limit. This is to be used as a termination criteria
         in methods where the dual objective monotonically changes (dual
         simplex). */
     ClpDualObjectiveLimit,
     /** Primal objective limit. This is to be used as a termination
         criteria in methods where the primal objective monotonically changes
         (e.g., primal simplex) */
     ClpPrimalObjectiveLimit,
     /** The maximum amount the dual constraints can be violated and still be
         considered feasible. */
     ClpDualTolerance,
     /** The maximum amount the primal constraints can be violated and still be
         considered feasible. */
     ClpPrimalTolerance,
     /** Objective function constant. This the value of the constant term in
         the objective function. */
     ClpObjOffset,
     /// Maximum time in seconds - after, this action is as max iterations
     ClpMaxSeconds,
     /// Maximum wallclock running time in seconds - after, this action is as max iterations
     ClpMaxWallSeconds,
     /// Tolerance to use in presolve
     ClpPresolveTolerance,
     /** Just a marker, so that we can allocate a static sized array to store
         parameters. */
     ClpLastDblParam
};


enum ClpStrParam {
     /** Name of the problem. This is the found on the Name card of
         an mps file. */
     ClpProbName = 0,
     /** Just a marker, so that we can allocate a static sized array to store
         parameters. */
     ClpLastStrParam
};

/// Copy (I don't like complexity of Coin version)
template <class T> inline void
ClpDisjointCopyN( const T * array, const int size, T * newArray)
{
     memcpy(reinterpret_cast<void *> (newArray), array, size * sizeof(T));
}
/// And set
template <class T> inline void
ClpFillN( T * array, const int size, T value)
{
     int i;
     for (i = 0; i < size; i++)
          array[i] = value;
}
/// This returns a non const array filled with input from scalar or actual array
template <class T> inline T*
ClpCopyOfArray( const T * array, const int size, T value)
{
     T * arrayNew = new T[size];
     if (array)
          ClpDisjointCopyN(array, size, arrayNew);
     else
          ClpFillN ( arrayNew, size, value);
     return arrayNew;
}

/// This returns a non const array filled with actual array (or NULL)
template <class T> inline T*
ClpCopyOfArray( const T * array, const int size)
{
     if (array) {
          T * arrayNew = new T[size];
          ClpDisjointCopyN(array, size, arrayNew);
          return arrayNew;
     } else {
          return NULL;
     }
}
/// For a structure to be used by trusted code
typedef struct {
     int typeStruct; // allocated as 1,2 etc
     int typeCall;
     void * data;
} ClpTrustedData;
#endif