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

Last change on this file since 1665 was 1665, checked in by lou, 10 years ago

Add EPL license notice in src.

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