source: trunk/Clp/src/ClpCholeskyBase.hpp @ 2470

Last change on this file since 2470 was 2385, checked in by unxusr, 11 months ago

formatting

  • Property svn:eol-style set to native
  • Property svn:keywords set to Id
File size: 8.1 KB
Line 
1/* $Id: ClpCholeskyBase.hpp 2385 2019-01-06 19:43:06Z stefan $ */
2// Copyright (C) 2003, 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 ClpCholeskyBase_H
7#define ClpCholeskyBase_H
8
9#include "CoinPragma.hpp"
10#include "CoinTypes.hpp"
11//#define CLP_LONG_CHOLESKY 0
12#ifndef CLP_LONG_CHOLESKY
13#define CLP_LONG_CHOLESKY 0
14#endif
15/* valid combinations are
16   CLP_LONG_CHOLESKY 0 and COIN_LONG_WORK 0
17   CLP_LONG_CHOLESKY 1 and COIN_LONG_WORK 1
18   CLP_LONG_CHOLESKY 2 and COIN_LONG_WORK 1
19*/
20#if COIN_LONG_WORK == 0
21#if CLP_LONG_CHOLESKY > 0
22#define CHOLESKY_BAD_COMBINATION
23#endif
24#else
25#if CLP_LONG_CHOLESKY == 0
26#define CHOLESKY_BAD_COMBINATION
27#endif
28#endif
29#ifdef CHOLESKY_BAD_COMBINATION
30#warning("Bad combination of CLP_LONG_CHOLESKY and COIN_BIG_DOUBLE/COIN_LONG_WORK");
31"Bad combination of CLP_LONG_CHOLESKY and COIN_LONG_WORK"
32#endif
33#if CLP_LONG_CHOLESKY > 1
34  typedef long double longDouble;
35#define CHOL_SMALL_VALUE 1.0e-15
36#elif CLP_LONG_CHOLESKY == 1
37typedef double longDouble;
38#define CHOL_SMALL_VALUE 1.0e-11
39#else
40typedef double longDouble;
41#define CHOL_SMALL_VALUE 1.0e-11
42#endif
43class ClpInterior;
44class ClpCholeskyDense;
45class ClpMatrixBase;
46
47/** Base class for Clp Cholesky factorization
48    Will do better factorization.  very crude ordering
49
50    Derived classes may be using more sophisticated methods
51*/
52
53class ClpCholeskyBase {
54
55public:
56  /**@name Virtual methods that the derived classes may provide  */
57  //@{
58  /** Orders rows and saves pointer to matrix.and model.
59      returns non-zero if not enough memory.
60      You can use preOrder to set up ADAT
61      If using default symbolic etc then must set sizeFactor_ to
62      size of input matrix to order (and to symbolic).
63      Also just permute_ and permuteInverse_ should be created */
64  virtual int order(ClpInterior *model);
65  /** Does Symbolic factorization given permutation.
66         This is called immediately after order.  If user provides this then
67         user must provide factorize and solve.  Otherwise the default factorization is used
68         returns non-zero if not enough memory */
69  virtual int symbolic();
70  /** Factorize - filling in rowsDropped and returning number dropped.
71         If return code negative then out of memory */
72  virtual int factorize(const CoinWorkDouble *diagonal, int *rowsDropped);
73  /** Uses factorization to solve. */
74  virtual void solve(CoinWorkDouble *region);
75  /** Uses factorization to solve. - given as if KKT.
76      region1 is rows+columns, region2 is rows */
77  virtual void solveKKT(CoinWorkDouble *region1, CoinWorkDouble *region2, const CoinWorkDouble *diagonal,
78    CoinWorkDouble diagonalScaleFactor);
79
80private:
81  /// AMD ordering
82  int orderAMD();
83
84public:
85  //@}
86
87  /**@name Gets */
88  //@{
89  /// status.  Returns status
90  inline int status() const
91  {
92    return status_;
93  }
94  /// numberRowsDropped.  Number of rows gone
95  inline int numberRowsDropped() const
96  {
97    return numberRowsDropped_;
98  }
99  /// reset numberRowsDropped and rowsDropped.
100  void resetRowsDropped();
101  /// rowsDropped - which rows are gone
102  inline char *rowsDropped() const
103  {
104    return rowsDropped_;
105  }
106  /// choleskyCondition.
107  inline double choleskyCondition() const
108  {
109    return choleskyCondition_;
110  }
111  /// goDense i.e. use dense factoriaztion if > this (default 0.7).
112  inline double goDense() const
113  {
114    return goDense_;
115  }
116  /// goDense i.e. use dense factoriaztion if > this (default 0.7).
117  inline void setGoDense(double value)
118  {
119    goDense_ = value;
120  }
121  /// rank.  Returns rank
122  inline int rank() const
123  {
124    return numberRows_ - numberRowsDropped_;
125  }
126  /// Return number of rows
127  inline int numberRows() const
128  {
129    return numberRows_;
130  }
131  /// Return size
132  inline int size() const
133  {
134    return sizeFactor_;
135  }
136  /// Return sparseFactor
137  inline longDouble *sparseFactor() const
138  {
139    return sparseFactor_;
140  }
141  /// Return diagonal
142  inline longDouble *diagonal() const
143  {
144    return diagonal_;
145  }
146  /// Return workDouble
147  inline longDouble *workDouble() const
148  {
149    return workDouble_;
150  }
151  /// If KKT on
152  inline bool kkt() const
153  {
154    return doKKT_;
155  }
156  /// Set KKT
157  inline void setKKT(bool yesNo)
158  {
159    doKKT_ = yesNo;
160  }
161  /// Set integer parameter
162  inline void setIntegerParameter(int i, int value)
163  {
164    integerParameters_[i] = value;
165  }
166  /// get integer parameter
167  inline int getIntegerParameter(int i)
168  {
169    return integerParameters_[i];
170  }
171  /// Set double parameter
172  inline void setDoubleParameter(int i, double value)
173  {
174    doubleParameters_[i] = value;
175  }
176  /// get double parameter
177  inline double getDoubleParameter(int i)
178  {
179    return doubleParameters_[i];
180  }
181  //@}
182
183public:
184  /**@name Constructors, destructor
185      */
186  //@{
187  /** Constructor which has dense columns activated.
188         Default is off. */
189  ClpCholeskyBase(int denseThreshold = -1);
190  /** Destructor (has to be public) */
191  virtual ~ClpCholeskyBase();
192  /// Copy
193  ClpCholeskyBase(const ClpCholeskyBase &);
194  /// Assignment
195  ClpCholeskyBase &operator=(const ClpCholeskyBase &);
196  //@}
197  //@{
198  ///@name Other
199  /// Clone
200  virtual ClpCholeskyBase *clone() const;
201
202  /// Returns type
203  inline int type() const
204  {
205    if (doKKT_)
206      return 100;
207    else
208      return type_;
209  }
210
211protected:
212  /// Sets type
213  inline void setType(int type)
214  {
215    type_ = type;
216  }
217  /// model.
218  inline void setModel(ClpInterior *model)
219  {
220    model_ = model;
221  }
222  //@}
223
224  /**@name Symbolic, factor and solve */
225  //@{
226  /** Symbolic1  - works out size without clever stuff.
227         Uses upper triangular as much easier.
228         Returns size
229      */
230  int symbolic1(const int *Astart, const int *Arow);
231  /** Symbolic2  - Fills in indices
232         Uses lower triangular so can do cliques etc
233      */
234  void symbolic2(const int *Astart, const int *Arow);
235  /** Factorize - filling in rowsDropped and returning number dropped
236         in integerParam.
237      */
238  void factorizePart2(int *rowsDropped);
239  /** solve - 1 just first half, 2 just second half - 3 both.
240     If 1 and 2 then diagonal has sqrt of inverse otherwise inverse
241     */
242  void solve(CoinWorkDouble *region, int type);
243  /// Forms ADAT - returns nonzero if not enough memory
244  int preOrder(bool lowerTriangular, bool includeDiagonal, bool doKKT);
245  /// Updates dense part (broken out for profiling)
246  void updateDense(longDouble *d, /*longDouble * work,*/ int *first);
247  //@}
248
249protected:
250  /**@name Data members
251        The data members are protected to allow access for derived classes. */
252  //@{
253  /// type (may be useful) if > 20 do KKT
254  int type_;
255  /// Doing full KKT (only used if default symbolic and factorization)
256  bool doKKT_;
257  /// Go dense at this fraction
258  double goDense_;
259  /// choleskyCondition.
260  double choleskyCondition_;
261  /// model.
262  ClpInterior *model_;
263  /// numberTrials.  Number of trials before rejection
264  int numberTrials_;
265  /// numberRows.  Number of Rows in factorization
266  int numberRows_;
267  /// status.  Status of factorization
268  int status_;
269  /// rowsDropped
270  char *rowsDropped_;
271  /// permute inverse.
272  int *permuteInverse_;
273  /// main permute.
274  int *permute_;
275  /// numberRowsDropped.  Number of rows gone
276  int numberRowsDropped_;
277  /// sparseFactor.
278  longDouble *sparseFactor_;
279  /// choleskyStart - element starts
280  int *choleskyStart_;
281  /// choleskyRow (can be shorter than sparsefactor)
282  int *choleskyRow_;
283  /// Index starts
284  int *indexStart_;
285  /// Diagonal
286  longDouble *diagonal_;
287  /// double work array
288  longDouble *workDouble_;
289  /// link array
290  int *link_;
291  // Integer work array
292  int *workInteger_;
293  // Clique information
294  int *clique_;
295  /// sizeFactor.
296  int sizeFactor_;
297  /// Size of index array
298  int sizeIndex_;
299  /// First dense row
300  int firstDense_;
301  /// integerParameters
302  int integerParameters_[64];
303  /// doubleParameters;
304  double doubleParameters_[64];
305  /// Row copy of matrix
306  ClpMatrixBase *rowCopy_;
307  /// Dense indicators
308  char *whichDense_;
309  /// Dense columns (updated)
310  longDouble *denseColumn_;
311  /// Dense cholesky
312  ClpCholeskyDense *dense_;
313  /// Dense threshold (for taking out of Cholesky)
314  int denseThreshold_;
315  //@}
316};
317
318#endif
319
320/* vi: softtabstop=2 shiftwidth=2 expandtab tabstop=2
321*/
Note: See TracBrowser for help on using the repository browser.