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
|
/* $Id: ClpPlusMinusOneMatrix.hpp 2078 2015-01-05 12:39:49Z forrest $ */
// Copyright (C) 2003, International Business Machines
// Corporation and others. All Rights Reserved.
// This code is licensed under the terms of the Eclipse Public License (EPL).
#ifndef ClpPlusMinusOneMatrix_H
#define ClpPlusMinusOneMatrix_H
#include "CoinPragma.hpp"
#include "ClpMatrixBase.hpp"
/** This implements a simple +- one matrix as derived from ClpMatrixBase.
*/
class ClpPlusMinusOneMatrix : public ClpMatrixBase {
public:
/**@name Useful methods */
//@{
/// Return a complete CoinPackedMatrix
virtual CoinPackedMatrix * getPackedMatrix() const;
/** Whether the packed matrix is column major ordered or not. */
virtual bool isColOrdered() const ;
/** Number of entries in the packed matrix. */
virtual CoinBigIndex getNumElements() const;
/** Number of columns. */
virtual int getNumCols() const {
return numberColumns_;
}
/** Number of rows. */
virtual int getNumRows() const {
return numberRows_;
}
/** A vector containing the elements in the packed matrix. Note that there
might be gaps in this list, entries that do not belong to any
major-dimension vector. To get the actual elements one should look at
this vector together with vectorStarts and vectorLengths. */
virtual const double * getElements() const;
/** A vector containing the minor indices of the elements in the packed
matrix. Note that there might be gaps in this list, entries that do not
belong to any major-dimension vector. To get the actual elements one
should look at this vector together with vectorStarts and
vectorLengths. */
virtual const int * getIndices() const {
return indices_;
}
// and for advanced use
int * getMutableIndices() const {
return indices_;
}
virtual const CoinBigIndex * getVectorStarts() const;
/** The lengths of the major-dimension vectors. */
virtual const int * getVectorLengths() const;
/** Delete the columns whose indices are listed in <code>indDel</code>. */
virtual void deleteCols(const int numDel, const int * indDel);
/** Delete the rows whose indices are listed in <code>indDel</code>. */
virtual void deleteRows(const int numDel, const int * indDel);
/// Append Columns
virtual void appendCols(int number, const CoinPackedVectorBase * const * columns);
/// Append Rows
virtual void appendRows(int number, const CoinPackedVectorBase * const * rows);
#ifndef SLIM_CLP
/** Append a set of rows/columns to the end of the matrix. Returns number of errors
i.e. if any of the new rows/columns contain an index that's larger than the
number of columns-1/rows-1 (if numberOther>0) or duplicates
If 0 then rows, 1 if columns */
virtual int appendMatrix(int number, int type,
const CoinBigIndex * starts, const int * index,
const double * element, int numberOther = -1);
#endif
/** Returns a new matrix in reverse order without gaps */
virtual ClpMatrixBase * reverseOrderedCopy() const;
/// Returns number of elements in column part of basis
virtual CoinBigIndex countBasis(
const int * whichColumn,
int & numberColumnBasic);
/// Fills in column part of basis
virtual void fillBasis(ClpSimplex * model,
const int * whichColumn,
int & numberColumnBasic,
int * row, int * start,
int * rowCount, int * columnCount,
CoinFactorizationDouble * element);
/** Given positive integer weights for each row fills in sum of weights
for each column (and slack).
Returns weights vector
*/
virtual CoinBigIndex * dubiousWeights(const ClpSimplex * model, int * inputWeights) const;
/** Returns largest and smallest elements of both signs.
Largest refers to largest absolute value.
*/
virtual void rangeOfElements(double & smallestNegative, double & largestNegative,
double & smallestPositive, double & largestPositive);
/** Unpacks a column into an CoinIndexedvector
*/
virtual void unpack(const ClpSimplex * model, CoinIndexedVector * rowArray,
int column) const ;
/** Unpacks a column into an CoinIndexedvector
** in packed foramt
Note that model is NOT const. Bounds and objective could
be modified if doing column generation (just for this variable) */
virtual void unpackPacked(ClpSimplex * model,
CoinIndexedVector * rowArray,
int column) const;
/** Adds multiple of a column into an CoinIndexedvector
You can use quickAdd to add to vector */
virtual void add(const ClpSimplex * model, CoinIndexedVector * rowArray,
int column, double multiplier) const ;
/** Adds multiple of a column into an array */
virtual void add(const ClpSimplex * model, double * array,
int column, double multiplier) const;
/// Allow any parts of a created CoinMatrix to be deleted
virtual void releasePackedMatrix() const;
/** Set the dimensions of the matrix. In effect, append new empty
columns/rows to the matrix. A negative number for either dimension
means that that dimension doesn't change. Otherwise the new dimensions
MUST be at least as large as the current ones otherwise an exception
is thrown. */
virtual void setDimensions(int numrows, int numcols);
/// Just checks matrix valid - will say if dimensions not quite right if detail
void checkValid(bool detail) const;
//@}
/**@name Matrix times vector methods */
//@{
/** Return <code>y + A * scalar *x</code> in <code>y</code>.
@pre <code>x</code> must be of size <code>numColumns()</code>
@pre <code>y</code> must be of size <code>numRows()</code> */
virtual void times(double scalar,
const double * x, double * y) const;
/// And for scaling
virtual void times(double scalar,
const double * x, double * y,
const double * rowScale,
const double * columnScale) const;
/** Return <code>y + x * scalar * A</code> in <code>y</code>.
@pre <code>x</code> must be of size <code>numRows()</code>
@pre <code>y</code> must be of size <code>numColumns()</code> */
virtual void transposeTimes(double scalar,
const double * x, double * y) const;
/// And for scaling
virtual void transposeTimes(double scalar,
const double * x, double * y,
const double * rowScale,
const double * columnScale, double * spare = NULL) const;
/** Return <code>x * scalar * A + y</code> in <code>z</code>.
Can use y as temporary array (will be empty at end)
Note - If x packed mode - then z packed mode
Squashes small elements and knows about ClpSimplex */
virtual void transposeTimes(const ClpSimplex * model, double scalar,
const CoinIndexedVector * x,
CoinIndexedVector * y,
CoinIndexedVector * z) const;
/** Return <code>x * scalar * A + y</code> in <code>z</code>.
Can use y as temporary array (will be empty at end)
Note - If x packed mode - then z packed mode
Squashes small elements and knows about ClpSimplex.
This version uses row copy*/
virtual void transposeTimesByRow(const ClpSimplex * model, double scalar,
const CoinIndexedVector * x,
CoinIndexedVector * y,
CoinIndexedVector * z) const;
/** Return <code>x *A</code> in <code>z</code> but
just for indices in y.
Note - z always packed mode */
virtual void subsetTransposeTimes(const ClpSimplex * model,
const CoinIndexedVector * x,
const CoinIndexedVector * y,
CoinIndexedVector * z) const;
/** Returns true if can combine transposeTimes and subsetTransposeTimes
and if it would be faster */
virtual bool canCombine(const ClpSimplex * model,
const CoinIndexedVector * pi) const;
/// Updates two arrays for steepest
virtual void transposeTimes2(const ClpSimplex * model,
const CoinIndexedVector * pi1, CoinIndexedVector * dj1,
const CoinIndexedVector * pi2,
CoinIndexedVector * spare,
double referenceIn, double devex,
// Array for exact devex to say what is in reference framework
unsigned int * reference,
double * weights, double scaleFactor);
/// Updates second array for steepest and does devex weights
virtual void subsetTimes2(const ClpSimplex * model,
CoinIndexedVector * dj1,
const CoinIndexedVector * pi2, CoinIndexedVector * dj2,
double referenceIn, double devex,
// Array for exact devex to say what is in reference framework
unsigned int * reference,
double * weights, double scaleFactor);
//@}
/**@name Other */
//@{
/// Return starts of +1s
inline CoinBigIndex * startPositive() const {
return startPositive_;
}
/// Return starts of -1s
inline CoinBigIndex * startNegative() const {
return startNegative_;
}
//@}
/**@name Constructors, destructor */
//@{
/** Default constructor. */
ClpPlusMinusOneMatrix();
/** Destructor */
virtual ~ClpPlusMinusOneMatrix();
//@}
/**@name Copy method */
//@{
/** The copy constructor. */
ClpPlusMinusOneMatrix(const ClpPlusMinusOneMatrix&);
/** The copy constructor from an CoinPlusMinusOneMatrix.
If not a valid matrix then getIndices will be NULL and
startPositive[0] will have number of +1,
startPositive[1] will have number of -1,
startPositive[2] will have number of others,
*/
ClpPlusMinusOneMatrix(const CoinPackedMatrix&);
/// Constructor from arrays
ClpPlusMinusOneMatrix(int numberRows, int numberColumns,
bool columnOrdered, const int * indices,
const CoinBigIndex * startPositive, const CoinBigIndex * startNegative);
/** Subset constructor (without gaps). Duplicates are allowed
and order is as given */
ClpPlusMinusOneMatrix (const ClpPlusMinusOneMatrix & wholeModel,
int numberRows, const int * whichRows,
int numberColumns, const int * whichColumns);
ClpPlusMinusOneMatrix& operator=(const ClpPlusMinusOneMatrix&);
/// Clone
virtual ClpMatrixBase * clone() const ;
/** Subset clone (without gaps). Duplicates are allowed
and order is as given */
virtual ClpMatrixBase * subsetClone (
int numberRows, const int * whichRows,
int numberColumns, const int * whichColumns) const ;
/// pass in copy (object takes ownership)
void passInCopy(int numberRows, int numberColumns,
bool columnOrdered, int * indices,
CoinBigIndex * startPositive, CoinBigIndex * startNegative);
/// Says whether it can do partial pricing
virtual bool canDoPartialPricing() const;
/// Partial pricing
virtual void partialPricing(ClpSimplex * model, double start, double end,
int & bestSequence, int & numberWanted);
//@}
protected:
/**@name Data members
The data members are protected to allow access for derived classes. */
//@{
/// For fake CoinPackedMatrix
mutable CoinPackedMatrix * matrix_;
mutable int * lengths_;
/// Start of +1's for each
CoinBigIndex * COIN_RESTRICT startPositive_;
/// Start of -1's for each
CoinBigIndex * COIN_RESTRICT startNegative_;
/// Data -1, then +1 rows in pairs (row==-1 if one entry)
int * COIN_RESTRICT indices_;
/// Number of rows
int numberRows_;
/// Number of columns
int numberColumns_;
#ifdef CLP_PLUS_ONE_MATRIX
/** Other flags (could have columnOrdered_?)
1 bit - says just +1
*/
mutable int otherFlags_;
#endif
/// True if column ordered
bool columnOrdered_;
//@}
};
#endif
|
