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