source: trunk/Clp/src/ClpPackedMatrix.hpp @ 2271

Last change on this file since 2271 was 2271, checked in by forrest, 21 months ago

change some ints to CoinBigIndex?

  • Property svn:eol-style set to native
  • Property svn:keywords set to Id
File size: 30.7 KB
Line 
1/* $Id: ClpPackedMatrix.hpp 2271 2017-08-14 08:50:39Z forrest $ */
2// Copyright (C) 2002, International Business Machines
3// Corporation and others.  All Rights Reserved.
4// This code is licensed under the terms of the Eclipse Public License (EPL).
5
6#ifndef ClpPackedMatrix_H
7#define ClpPackedMatrix_H
8
9#include "CoinPragma.hpp"
10
11#include "ClpMatrixBase.hpp"
12#include "ClpPrimalColumnSteepest.hpp"
13
14/** This implements CoinPackedMatrix as derived from ClpMatrixBase.
15
16    It adds a few methods that know about model as well as matrix
17
18    For details see CoinPackedMatrix */
19
20class ClpPackedMatrix2;
21class ClpPackedMatrix3;
22class CoinDoubleArrayWithLength;
23class ClpPackedMatrix : public ClpMatrixBase {
24
25public:
26     /**@name Useful methods */
27     //@{
28     /// Return a complete CoinPackedMatrix
29     virtual CoinPackedMatrix * getPackedMatrix() const {
30          return matrix_;
31     }
32     /** Whether the packed matrix is column major ordered or not. */
33     virtual bool isColOrdered() const {
34          return matrix_->isColOrdered();
35     }
36     /** Number of entries in the packed matrix. */
37     virtual  CoinBigIndex getNumElements() const {
38          return matrix_->getNumElements();
39     }
40     /** Number of columns. */
41     virtual int getNumCols() const {
42          return matrix_->getNumCols();
43     }
44     /** Number of rows. */
45     virtual int getNumRows() const {
46          return matrix_->getNumRows();
47     }
48
49     /** A vector containing the elements in the packed matrix. Note that there
50         might be gaps in this list, entries that do not belong to any
51         major-dimension vector. To get the actual elements one should look at
52         this vector together with vectorStarts and vectorLengths. */
53     virtual const double * getElements() const {
54          return matrix_->getElements();
55     }
56     /// Mutable elements
57     inline double * getMutableElements() const {
58          return matrix_->getMutableElements();
59     }
60     /** A vector containing the minor indices of the elements in the packed
61          matrix. Note that there might be gaps in this list, entries that do not
62          belong to any major-dimension vector. To get the actual elements one
63          should look at this vector together with vectorStarts and
64          vectorLengths. */
65     virtual const int * getIndices() const {
66          return matrix_->getIndices();
67     }
68
69     virtual const CoinBigIndex * getVectorStarts() const {
70          return matrix_->getVectorStarts();
71     }
72     /** The lengths of the major-dimension vectors. */
73     virtual const int * getVectorLengths() const {
74          return matrix_->getVectorLengths();
75     }
76     /** The length of a single major-dimension vector. */
77     virtual int getVectorLength(int index) const {
78          return matrix_->getVectorSize(index);
79     }
80
81     /** Delete the columns whose indices are listed in <code>indDel</code>. */
82     virtual void deleteCols(const int numDel, const int * indDel);
83     /** Delete the rows whose indices are listed in <code>indDel</code>. */
84     virtual void deleteRows(const int numDel, const int * indDel);
85#ifndef CLP_NO_VECTOR
86     /// Append Columns
87     virtual void appendCols(int number, const CoinPackedVectorBase * const * columns);
88     /// Append Rows
89     virtual void appendRows(int number, const CoinPackedVectorBase * const * rows);
90#endif
91     /** Append a set of rows/columns to the end of the matrix. Returns number of errors
92         i.e. if any of the new rows/columns contain an index that's larger than the
93         number of columns-1/rows-1 (if numberOther>0) or duplicates
94         If 0 then rows, 1 if columns */
95     virtual int appendMatrix(int number, int type,
96                              const CoinBigIndex * starts, const int * index,
97                              const double * element, int numberOther = -1);
98     /** Replace the elements of a vector.  The indices remain the same.
99         This is only needed if scaling and a row copy is used.
100         At most the number specified will be replaced.
101         The index is between 0 and major dimension of matrix */
102     virtual void replaceVector(const int index,
103                                const int numReplace, const double * newElements) {
104          matrix_->replaceVector(index, numReplace, newElements);
105     }
106     /** Modify one element of packed matrix.  An element may be added.
107         This works for either ordering If the new element is zero it will be
108         deleted unless keepZero true */
109     virtual void modifyCoefficient(int row, int column, double newElement,
110                                    bool keepZero = false) {
111          matrix_->modifyCoefficient(row, column, newElement, keepZero);
112     }
113     /** Returns a new matrix in reverse order without gaps */
114     virtual ClpMatrixBase * reverseOrderedCopy() const;
115     /// Returns number of elements in column part of basis
116     virtual int countBasis(const int * whichColumn,
117                                     int & numberColumnBasic);
118     /// Fills in column part of basis
119     virtual void fillBasis(ClpSimplex * model,
120                            const int * whichColumn,
121                            int & numberColumnBasic,
122                            int * row, int * start,
123                            int * rowCount, int * columnCount,
124                            CoinFactorizationDouble * element);
125     /** Creates scales for column copy (rowCopy in model may be modified)
126         returns non-zero if no scaling done */
127     virtual int scale(ClpModel * model, ClpSimplex * simplex = NULL) const ;
128     /** Scales rowCopy if column copy scaled
129         Only called if scales already exist */
130     virtual void scaleRowCopy(ClpModel * model) const ;
131     /// Creates scaled column copy if scales exist
132     void createScaledMatrix(ClpSimplex * model) const;
133     /** Realy really scales column copy
134         Only called if scales already exist.
135         Up to user ro delete */
136     virtual ClpMatrixBase * scaledColumnCopy(ClpModel * model) const ;
137     /** Checks if all elements are in valid range.  Can just
138         return true if you are not paranoid.  For Clp I will
139         probably expect no zeros.  Code can modify matrix to get rid of
140         small elements.
141         check bits (can be turned off to save time) :
142         1 - check if matrix has gaps
143         2 - check if zero elements
144         4 - check and compress duplicates
145         8 - report on large and small
146     */
147     virtual bool allElementsInRange(ClpModel * model,
148                                     double smallest, double largest,
149                                     int check = 15);
150     /** Returns largest and smallest elements of both signs.
151         Largest refers to largest absolute value.
152     */
153     virtual void rangeOfElements(double & smallestNegative, double & largestNegative,
154                                  double & smallestPositive, double & largestPositive);
155
156     /** Unpacks a column into an CoinIndexedvector
157      */
158     virtual void unpack(const ClpSimplex * model, CoinIndexedVector * rowArray,
159                         int column) const ;
160     /** Unpacks a column into an CoinIndexedvector
161      ** in packed foramt
162         Note that model is NOT const.  Bounds and objective could
163         be modified if doing column generation (just for this variable) */
164     virtual void unpackPacked(ClpSimplex * model,
165                               CoinIndexedVector * rowArray,
166                               int column) const;
167     /** Adds multiple of a column into an CoinIndexedvector
168         You can use quickAdd to add to vector */
169     virtual void add(const ClpSimplex * model, CoinIndexedVector * rowArray,
170                      int column, double multiplier) const ;
171     /** Adds multiple of a column into an array */
172     virtual void add(const ClpSimplex * model, double * array,
173                      int column, double multiplier) const;
174     /// Allow any parts of a created CoinPackedMatrix to be deleted
175     virtual void releasePackedMatrix() const { }
176     /** Given positive integer weights for each row fills in sum of weights
177         for each column (and slack).
178         Returns weights vector
179     */
180     virtual CoinBigIndex * dubiousWeights(const ClpSimplex * model, int * inputWeights) const;
181     /// Says whether it can do partial pricing
182     virtual bool canDoPartialPricing() const;
183     /// Partial pricing
184     virtual void partialPricing(ClpSimplex * model, double start, double end,
185                                 int & bestSequence, int & numberWanted);
186     /// makes sure active columns correct
187     virtual int refresh(ClpSimplex * model);
188     // Really scale matrix
189     virtual void reallyScale(const double * rowScale, const double * columnScale);
190     /** Set the dimensions of the matrix. In effect, append new empty
191         columns/rows to the matrix. A negative number for either dimension
192         means that that dimension doesn't change. Otherwise the new dimensions
193         MUST be at least as large as the current ones otherwise an exception
194         is thrown. */
195     virtual void setDimensions(int numrows, int numcols);
196     //@}
197
198     /**@name Matrix times vector methods */
199     //@{
200     /** Return <code>y + A * scalar *x</code> in <code>y</code>.
201         @pre <code>x</code> must be of size <code>numColumns()</code>
202         @pre <code>y</code> must be of size <code>numRows()</code> */
203     virtual void times(double scalar,
204                        const double * x, double * y) const;
205     /// And for scaling
206     virtual void times(double scalar,
207                        const double * x, double * y,
208                        const double * rowScale,
209                        const double * columnScale) const;
210     /** Return <code>y + x * scalar * A</code> in <code>y</code>.
211         @pre <code>x</code> must be of size <code>numRows()</code>
212         @pre <code>y</code> must be of size <code>numColumns()</code> */
213     virtual void transposeTimes(double scalar,
214                                 const double * x, double * y) const;
215     /// And for scaling
216     virtual void transposeTimes(double scalar,
217                                 const double * x, double * y,
218                                 const double * rowScale,
219                                 const double * columnScale,
220                                 double * spare = NULL) const;
221     /** Return <code>y - pi * A</code> in <code>y</code>.
222         @pre <code>pi</code> must be of size <code>numRows()</code>
223         @pre <code>y</code> must be of size <code>numColumns()</code>
224     This just does subset (but puts in correct place in y) */
225     void transposeTimesSubset( int number,
226                                const int * which,
227                                const double * pi, double * y,
228                                const double * rowScale,
229                                const double * columnScale,
230                                double * spare = NULL) const;
231     /** Return <code>x * scalar * A + y</code> in <code>z</code>.
232     Can use y as temporary array (will be empty at end)
233     Note - If x packed mode - then z packed mode
234     Squashes small elements and knows about ClpSimplex */
235     virtual void transposeTimes(const ClpSimplex * model, double scalar,
236                                 const CoinIndexedVector * x,
237                                 CoinIndexedVector * y,
238                                 CoinIndexedVector * z) const;
239     /** Return <code>x * scalar * A + y</code> in <code>z</code>.
240     Note - If x packed mode - then z packed mode
241     This does by column and knows no gaps
242     Squashes small elements and knows about ClpSimplex */
243     void transposeTimesByColumn(const ClpSimplex * model, double scalar,
244                                 const CoinIndexedVector * x,
245                                 CoinIndexedVector * y,
246                                 CoinIndexedVector * z) const;
247     /** Return <code>x * scalar * A + y</code> in <code>z</code>.
248     Can use y as temporary array (will be empty at end)
249     Note - If x packed mode - then z packed mode
250     Squashes small elements and knows about ClpSimplex.
251     This version uses row copy*/
252     virtual void transposeTimesByRow(const ClpSimplex * model, double scalar,
253                                      const CoinIndexedVector * x,
254                                      CoinIndexedVector * y,
255                                      CoinIndexedVector * z) const;
256     /** Return <code>x *A</code> in <code>z</code> but
257     just for indices in y.
258     Note - z always packed mode */
259     virtual void subsetTransposeTimes(const ClpSimplex * model,
260                                       const CoinIndexedVector * x,
261                                       const CoinIndexedVector * y,
262                                       CoinIndexedVector * z) const;
263     /** Returns true if can combine transposeTimes and subsetTransposeTimes
264         and if it would be faster */
265     virtual bool canCombine(const ClpSimplex * model,
266                             const CoinIndexedVector * pi) const;
267     /** Updates two arrays for steepest and does devex weights
268         Returns nonzero if updates reduced cost and infeas -
269         new infeas in dj1 */
270     virtual int transposeTimes2(const ClpSimplex * model,
271                                 const CoinIndexedVector * pi1, CoinIndexedVector * dj1,
272                                 const CoinIndexedVector * pi2,
273                                 CoinIndexedVector * spare,
274                                 double * infeas, double * reducedCost,
275                                  double referenceIn, double devex,
276                                  // Array for exact devex to say what is in reference framework
277                                  unsigned int * reference,
278                                  double * weights, double scaleFactor);
279     /// Updates second array for steepest and does devex weights
280     virtual void subsetTimes2(const ClpSimplex * model,
281                               CoinIndexedVector * dj1,
282                               const CoinIndexedVector * pi2, CoinIndexedVector * dj2,
283                               double referenceIn, double devex,
284                               // Array for exact devex to say what is in reference framework
285                               unsigned int * reference,
286                               double * weights, double scaleFactor);
287     /// Sets up an effective RHS
288     void useEffectiveRhs(ClpSimplex * model);
289#if COIN_LONG_WORK
290     // For long double versions
291     virtual void times(CoinWorkDouble scalar,
292                        const CoinWorkDouble * x, CoinWorkDouble * y) const ;
293     virtual void transposeTimes(CoinWorkDouble scalar,
294                                 const CoinWorkDouble * x, CoinWorkDouble * y) const ;
295#endif
296//@}
297
298     /**@name Other */
299     //@{
300     /// Returns CoinPackedMatrix (non const)
301     inline CoinPackedMatrix * matrix() const {
302          return matrix_;
303     }
304     /** Just sets matrix_ to NULL so it can be used elsewhere.
305         used in GUB
306     */
307     inline void setMatrixNull() {
308          matrix_ = NULL;
309     }
310     /// Say we want special column copy
311     inline void makeSpecialColumnCopy() {
312          flags_ |= 16;
313     }
314     /// Say we don't want special column copy
315     void releaseSpecialColumnCopy();
316     /// Are there zeros?
317     inline bool zeros() const {
318          return ((flags_ & 1) != 0);
319     }
320     /// Do we want special column copy
321     inline bool wantsSpecialColumnCopy() const {
322          return ((flags_ & 16) != 0);
323     }
324     /// Flags
325     inline int flags() const {
326          return flags_;
327     }
328     /// Sets flags_ correctly
329     inline void checkGaps() {
330          flags_ = (matrix_->hasGaps()) ? (flags_ | 2) : (flags_ & (~2));
331     }
332     /// number of active columns (normally same as number of columns)
333     inline int numberActiveColumns() const
334     { return numberActiveColumns_;}
335     /// Set number of active columns (normally same as number of columns)
336     inline void setNumberActiveColumns(int value)
337     { numberActiveColumns_ = value;}
338     //@}
339
340
341     /**@name Constructors, destructor */
342     //@{
343     /** Default constructor. */
344     ClpPackedMatrix();
345     /** Destructor */
346     virtual ~ClpPackedMatrix();
347     //@}
348
349     /**@name Copy method */
350     //@{
351     /** The copy constructor. */
352     ClpPackedMatrix(const ClpPackedMatrix&);
353     /** The copy constructor from an CoinPackedMatrix. */
354     ClpPackedMatrix(const CoinPackedMatrix&);
355     /** Subset constructor (without gaps).  Duplicates are allowed
356         and order is as given */
357     ClpPackedMatrix (const ClpPackedMatrix & wholeModel,
358                      int numberRows, const int * whichRows,
359                      int numberColumns, const int * whichColumns);
360     ClpPackedMatrix (const CoinPackedMatrix & wholeModel,
361                      int numberRows, const int * whichRows,
362                      int numberColumns, const int * whichColumns);
363
364     /** This takes over ownership (for space reasons) */
365     ClpPackedMatrix(CoinPackedMatrix * matrix);
366
367     ClpPackedMatrix& operator=(const ClpPackedMatrix&);
368     /// Clone
369     virtual ClpMatrixBase * clone() const ;
370     /// Copy contents - resizing if necessary - otherwise re-use memory
371     virtual void copy(const ClpPackedMatrix * from);
372     /** Subset clone (without gaps).  Duplicates are allowed
373         and order is as given */
374     virtual ClpMatrixBase * subsetClone (
375          int numberRows, const int * whichRows,
376          int numberColumns, const int * whichColumns) const ;
377     /// make special row copy
378     void specialRowCopy(ClpSimplex * model, const ClpMatrixBase * rowCopy);
379     /// make special column copy
380     void specialColumnCopy(ClpSimplex * model);
381     /// Correct sequence in and out to give true value
382     virtual void correctSequence(const ClpSimplex * model, int & sequenceIn, int & sequenceOut) ;
383     //@}
384private:
385     /// Meat of transposeTimes by column when not scaled
386     int gutsOfTransposeTimesUnscaled(const double * COIN_RESTRICT pi,
387                                      int * COIN_RESTRICT index,
388                                      double * COIN_RESTRICT array,
389                                      const double tolerance) const;
390     /// Meat of transposeTimes by column when scaled
391     int gutsOfTransposeTimesScaled(const double * COIN_RESTRICT pi,
392                                    const double * COIN_RESTRICT columnScale,
393                                    int * COIN_RESTRICT index,
394                                    double * COIN_RESTRICT array,
395                                    const double tolerance) const;
396     /// Meat of transposeTimes by column when not scaled and skipping
397     int gutsOfTransposeTimesUnscaled(const double * COIN_RESTRICT pi,
398                                      int * COIN_RESTRICT index,
399                                      double * COIN_RESTRICT array,
400                                      const unsigned char * status,
401                                      const double tolerance) const;
402     /** Meat of transposeTimes by column when not scaled and skipping
403         and doing part of dualColumn */
404     int gutsOfTransposeTimesUnscaled(const double * COIN_RESTRICT pi,
405                                      int * COIN_RESTRICT index,
406                                      double * COIN_RESTRICT array,
407                                      const unsigned char * status,
408                                      int * COIN_RESTRICT spareIndex,
409                                      double * COIN_RESTRICT spareArray,
410                                      const double * COIN_RESTRICT reducedCost,
411                                      double & upperTheta,
412                                      double acceptablePivot,
413                                      double dualTolerance,
414                                      int & numberRemaining,
415                                      const double zeroTolerance) const;
416     /// Meat of transposeTimes by column when scaled and skipping
417     int gutsOfTransposeTimesScaled(const double * COIN_RESTRICT pi,
418                                    const double * COIN_RESTRICT columnScale,
419                                    int * COIN_RESTRICT index,
420                                    double * COIN_RESTRICT array,
421                                    const unsigned char * status,
422                                    const double tolerance) const;
423     /// Meat of transposeTimes by row n > K if packed - returns number nonzero
424     int gutsOfTransposeTimesByRowGEK(const CoinIndexedVector * COIN_RESTRICT piVector,
425                                      int * COIN_RESTRICT index,
426                                      double * COIN_RESTRICT output,
427                                      int numberColumns,
428                                      const double tolerance,
429                                      const double scalar) const;
430     /// Meat of transposeTimes by row n > 2 if packed - returns number nonzero
431     int gutsOfTransposeTimesByRowGE3(const CoinIndexedVector * COIN_RESTRICT piVector,
432                                      int * COIN_RESTRICT index,
433                                      double * COIN_RESTRICT output,
434                                      double * COIN_RESTRICT array2,
435                                      const double tolerance,
436                                      const double scalar) const;
437     /// Meat of transposeTimes by row n > 2 if packed - returns number nonzero
438     int gutsOfTransposeTimesByRowGE3a(const CoinIndexedVector * COIN_RESTRICT piVector,
439                                      int * COIN_RESTRICT index,
440                                      double * COIN_RESTRICT output,
441                                      int * COIN_RESTRICT lookup,
442                                      char * COIN_RESTRICT marked,
443                                      const double tolerance,
444                                      const double scalar) const;
445     /// Meat of transposeTimes by row n == 2 if packed
446     void gutsOfTransposeTimesByRowEQ2(const CoinIndexedVector * piVector, CoinIndexedVector * output,
447                                       CoinIndexedVector * spareVector, const double tolerance, const double scalar) const;
448     /// Meat of transposeTimes by row n == 1 if packed
449     void gutsOfTransposeTimesByRowEQ1(const CoinIndexedVector * piVector, CoinIndexedVector * output,
450                                       const double tolerance, const double scalar) const;
451     /// Gets rid of special copies
452     void clearCopies();
453
454
455protected:
456     /// Check validity
457     void checkFlags(int type) const;
458     /**@name Data members
459        The data members are protected to allow access for derived classes. */
460     //@{
461     /// Data
462     CoinPackedMatrix * matrix_;
463     /// number of active columns (normally same as number of columns)
464     int numberActiveColumns_;
465     /** Flags -
466         1 - has zero elements
467         2 - has gaps
468         4 - has special row copy
469         8 - has special column copy
470         16 - wants special column copy
471     */
472     mutable int flags_;
473     /// Special row copy
474     ClpPackedMatrix2 * rowCopy_;
475     /// Special column copy
476     ClpPackedMatrix3 * columnCopy_;
477     //@}
478};
479#ifdef THREAD
480#include <pthread.h>
481typedef struct {
482     double acceptablePivot;
483     const ClpSimplex * model;
484     double * spare;
485     int * spareIndex;
486     double * arrayTemp;
487     int * indexTemp;
488     int * numberInPtr;
489  //double * bestPossiblePtr;
490     double * upperThetaPtr;
491     int * posFreePtr;
492     double * freePivotPtr;
493     int * numberOutPtr;
494     const unsigned short * count;
495     const double * pi;
496     const CoinBigIndex * rowStart;
497     const double * element;
498     const unsigned short * column;
499     int offset;
500     int numberInRowArray;
501     int numberLook;
502} dualColumn0Struct;
503#endif
504class ClpPackedMatrix2 {
505
506public:
507     /**@name Useful methods */
508     //@{
509     /** Return <code>x * -1 * A in <code>z</code>.
510     Note - x packed and z will be packed mode
511     Squashes small elements and knows about ClpSimplex */
512     void transposeTimes(const ClpSimplex * model,
513                         const CoinPackedMatrix * rowCopy,
514                         const CoinIndexedVector * x,
515                         CoinIndexedVector * spareArray,
516                         CoinIndexedVector * z) const;
517     /// Returns true if copy has useful information
518     inline bool usefulInfo() const {
519          return rowStart_ != NULL;
520     }
521     //@}
522
523
524     /**@name Constructors, destructor */
525     //@{
526     /** Default constructor. */
527     ClpPackedMatrix2();
528     /** Constructor from copy. */
529     ClpPackedMatrix2(ClpSimplex * model, const CoinPackedMatrix * rowCopy);
530     /** Destructor */
531     virtual ~ClpPackedMatrix2();
532     //@}
533
534     /**@name Copy method */
535     //@{
536     /** The copy constructor. */
537     ClpPackedMatrix2(const ClpPackedMatrix2&);
538     ClpPackedMatrix2& operator=(const ClpPackedMatrix2&);
539     //@}
540
541
542protected:
543     /**@name Data members
544        The data members are protected to allow access for derived classes. */
545     //@{
546     /// Number of blocks
547     int numberBlocks_;
548     /// Number of rows
549     int numberRows_;
550     /// Column offset for each block (plus one at end)
551     int * offset_;
552     /// Counts of elements in each part of row
553     mutable unsigned short * count_;
554     /// Row starts
555     mutable CoinBigIndex * rowStart_;
556     /// columns within block
557     unsigned short * column_;
558     /// work arrays
559     double * work_;
560#ifdef THREAD
561     pthread_t * threadId_;
562     dualColumn0Struct * info_;
563#endif
564     //@}
565};
566typedef struct {
567  CoinBigIndex startElements_; // point to data
568  CoinBigIndex startRows_; // point to data later
569  int startIndices_; // point to column_
570  int numberInBlock_;
571  int numberScan_; // i.e. miss out basic and fixed
572  /* order is -
573     free or superbasic
574     at lower
575     at upper
576     fixed or basic */
577  int firstAtLower_;
578  int firstAtUpper_;
579  int firstBasic_; // or fixed
580  int numberElements_; // number elements per column
581  int numberOnes_; // later
582} blockStruct;
583class ClpPackedMatrix3 {
584
585public:
586     /**@name Useful methods */
587     //@{
588     /** Return <code>x * -1 * A in <code>z</code>.
589     Note - x packed and z will be packed mode
590     Squashes small elements and knows about ClpSimplex */
591     void transposeTimes(const ClpSimplex * model,
592                         const double * pi,
593                         CoinIndexedVector * output) const;
594     /// This version does dualColumn0
595     /// Updates two arrays for steepest
596     void transposeTimes(const ClpSimplex * model,
597                         const double * pi,
598                         CoinIndexedVector * output,
599                         CoinIndexedVector * candidate,
600                         const CoinIndexedVector * rowArray) const;
601     void transposeTimes2(const ClpSimplex * model,
602                          const double * pi, CoinIndexedVector * dj1,
603                          const double * piWeight,
604                          double * COIN_RESTRICT infeas, 
605                          double * COIN_RESTRICT reducedCost,
606                          double referenceIn, double devex,
607                          // Array for exact devex to say what is in reference framework
608                          unsigned int * reference,
609                          double * weights, double scaleFactor);
610     //@}
611
612
613     /**@name Constructors, destructor */
614     //@{
615     /** Default constructor. */
616     ClpPackedMatrix3();
617     /** Constructor from copy. */
618     ClpPackedMatrix3(ClpSimplex * model, const CoinPackedMatrix * columnCopy);
619     /** Destructor */
620     virtual ~ClpPackedMatrix3();
621     //@}
622
623     /**@name Copy method */
624     //@{
625     /** The copy constructor. */
626     ClpPackedMatrix3(const ClpPackedMatrix3&);
627     ClpPackedMatrix3& operator=(const ClpPackedMatrix3&);
628     //@}
629     /**@name Sort methods */
630     //@{
631     /** Sort blocks */
632     void sortBlocks(const ClpSimplex * model);
633     /// Swap one variable
634     void swapOne(const ClpSimplex * model, const ClpPackedMatrix * matrix,
635                  int iColumn);
636     /// Part of above
637     void swapOne(int iBlock, int kA, int kB);
638     /** Debug - check blocks */
639     void checkBlocks(const ClpSimplex * model);
640     /**
641        type - 1 redo infeasible, 2 choose sequenceIn, 3 both
642        returns sequenceIn (or -1) for type 2
643     */
644     int redoInfeasibilities(const ClpSimplex * model,
645                             ClpPrimalColumnSteepest * pivotChoose,
646                             int type);
647  /// Get temporary array (aligned)
648     //@}
649
650
651protected:
652     /**@name Data members
653        The data members are protected to allow access for derived classes. */
654     //@{
655     /// Number of blocks
656     int numberBlocks_;
657     /// Number of columns
658     int numberColumns_;
659     /// Number of columns including gaps
660     int numberColumnsWithGaps_;
661#if ABOCA_LITE
662     /// Number of chunks
663     int numberChunks_;
664#endif
665     /// Number of elements (including gaps)
666     CoinBigIndex numberElements_;
667     /// Maximum size of any block
668     int maxBlockSize_;
669     /// Column indices and reverse lookup (within block)
670     int * column_;
671     /// Starts for odd/long vectors??
672     CoinBigIndex * start_;
673     /// Rows
674     int * row_;
675     /// Elements
676     double * element_;
677     /// Temporary work area (aligned)
678     CoinDoubleArrayWithLength * temporary_;
679#if ABOCA_LITE
680     /// Chunk ends (could have more than cpus)
681     int endChunk_[2*ABOCA_LITE+1];
682#endif
683     /// Blocks (ordinary start at 0 and go to first block)
684     blockStruct * block_;
685     /// If active
686     int ifActive_;
687     //@}
688};
689#elif INCLUDE_MATRIX3_PRICING
690      int iColumn=*column;
691      column++;
692      if (fabs(value) > zeroTolerance) {
693        double thisWeight = weights[iColumn];
694        double pivot = value * scaleFactor;
695        double pivotSquared = pivot * pivot;
696        thisWeight += pivotSquared * devex + pivot * modification;
697        if (thisWeight < DEVEX_TRY_NORM) {
698          if (referenceIn < 0.0) {
699            // steepest
700            thisWeight = CoinMax(DEVEX_TRY_NORM, DEVEX_ADD_ONE + pivotSquared);
701          } else {
702            // exact
703            thisWeight = referenceIn * pivotSquared;
704            if (reference(iColumn))
705              thisWeight += 1.0;
706            thisWeight = CoinMax(thisWeight, DEVEX_TRY_NORM);
707          }
708        }
709        // out basic or fixed
710        weights[iColumn] = thisWeight;
711        value = reducedCost[iColumn]-value;
712        reducedCost[iColumn] = value;
713        unsigned char thisStatus=status[iColumn]&7;
714        assert (thisStatus!=0&&thisStatus!=4);
715        if (thisStatus==3) {
716          //} else if ((thisStatus&1)!=0) {
717          // basic or fixed
718          //value=0.0;
719        } else {
720          assert (thisStatus==2);
721          value=-value;
722        }
723        if (value < dualTolerance) {
724          value *= value;
725          if (value>bestRatio*weights[iColumn]) {
726            bestSequence = iColumn;
727            bestRatio = value/weights[iColumn];
728#if NO_CHANGE_MULTIPLIER != 1
729            bestRatio2 = bestRatio * NO_CHANGE_MULTIPLIER;
730#endif
731          }
732        }
733      } else {
734        // interesting - was faster without this?!
735        value = reducedCost[iColumn];
736        unsigned char thisStatus=status[iColumn]&7;
737        assert (thisStatus!=0&&thisStatus!=4);
738        if (thisStatus==3) {
739        } else if ((thisStatus&1)!=0) {
740          // basic or fixed
741          value=0.0;
742        } else {
743          value=-value;
744        }
745        if (value < dualTolerance) {
746          value *= value;
747          if (value>bestRatio2*weights[iColumn]) {
748            bestSequence = iColumn;
749            bestRatio2 = value/weights[iColumn];
750#if NO_CHANGE_MULTIPLIER != 1
751            bestRatio = bestRatio2 * INVERSE_MULTIPLIER;
752#endif
753          }
754        }
755      }
756#endif
Note: See TracBrowser for help on using the repository browser.