/usr/include/coin/ClpCholeskyDense.hpp is in coinor-libclp-dev 1.15.10-3+b1.
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 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 | /* $Id: ClpCholeskyDense.hpp 1910 2013-01-27 02:00:13Z stefan $ */
/*
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 ClpCholeskyDense_H
#define ClpCholeskyDense_H
#include "ClpCholeskyBase.hpp"
class ClpMatrixBase;
class ClpCholeskyDense : public ClpCholeskyBase {
public:
/**@name Virtual methods that the derived classes provides */
/**@{*/
/** Orders rows and saves pointer to matrix.and model.
Returns non-zero if not enough memory */
virtual int order(ClpInterior * model) ;
/** Does Symbolic factorization given permutation.
This is called immediately after order. If user provides this then
user must provide factorize and solve. Otherwise the default factorization is used
returns non-zero if not enough memory */
virtual int symbolic();
/** Factorize - filling in rowsDropped and returning number dropped.
If return code negative then out of memory */
virtual int factorize(const CoinWorkDouble * diagonal, int * rowsDropped) ;
/** Uses factorization to solve. */
virtual void solve (CoinWorkDouble * region) ;
/**@}*/
/**@name Non virtual methods for ClpCholeskyDense */
/**@{*/
/** Reserves space.
If factor not NULL then just uses passed space
Returns non-zero if not enough memory */
int reserveSpace(const ClpCholeskyBase * factor, int numberRows) ;
/** Returns space needed */
CoinBigIndex space( int numberRows) const;
/** part 2 of Factorize - filling in rowsDropped */
void factorizePart2(int * rowsDropped) ;
/** part 2 of Factorize - filling in rowsDropped - blocked */
void factorizePart3(int * rowsDropped) ;
/** Forward part of solve */
void solveF1(longDouble * a, int n, CoinWorkDouble * region);
void solveF2(longDouble * a, int n, CoinWorkDouble * region, CoinWorkDouble * region2);
/** Backward part of solve */
void solveB1(longDouble * a, int n, CoinWorkDouble * region);
void solveB2(longDouble * a, int n, CoinWorkDouble * region, CoinWorkDouble * region2);
int bNumber(const longDouble * array, int &, int&);
/** A */
inline longDouble * aMatrix() const {
return sparseFactor_;
}
/** Diagonal */
inline longDouble * diagonal() const {
return diagonal_;
}
/**@}*/
/**@name Constructors, destructor */
/**@{*/
/** Default constructor. */
ClpCholeskyDense();
/** Destructor */
virtual ~ClpCholeskyDense();
/** Copy */
ClpCholeskyDense(const ClpCholeskyDense&);
/** Assignment */
ClpCholeskyDense& operator=(const ClpCholeskyDense&);
/** Clone */
virtual ClpCholeskyBase * clone() const ;
/**@}*/
private:
/**@name Data members */
/**@{*/
/** Just borrowing space */
bool borrowSpace_;
/**@}*/
};
/* structure for C */
typedef struct {
longDouble * diagonal_;
longDouble * a;
longDouble * work;
int * rowsDropped;
double doubleParameters_[1]; /* corresponds to 10 */
int integerParameters_[2]; /* corresponds to 34, nThreads */
int n;
int numberBlocks;
} ClpCholeskyDenseC;
extern "C" {
void ClpCholeskySpawn(void *);
}
/**Non leaf recursive factor */
void
ClpCholeskyCfactor(ClpCholeskyDenseC * thisStruct,
longDouble * a, int n, int numberBlocks,
longDouble * diagonal, longDouble * work, int * rowsDropped);
/**Non leaf recursive triangle rectangle update */
void
ClpCholeskyCtriRec(ClpCholeskyDenseC * thisStruct,
longDouble * aTri, int nThis,
longDouble * aUnder, longDouble * diagonal,
longDouble * work,
int nLeft, int iBlock, int jBlock,
int numberBlocks);
/**Non leaf recursive rectangle triangle update */
void
ClpCholeskyCrecTri(ClpCholeskyDenseC * thisStruct,
longDouble * aUnder, int nTri, int nDo,
int iBlock, int jBlock, longDouble * aTri,
longDouble * diagonal, longDouble * work,
int numberBlocks);
/** Non leaf recursive rectangle rectangle update,
nUnder is number of rows in iBlock,
nUnderK is number of rows in kBlock
*/
void
ClpCholeskyCrecRec(ClpCholeskyDenseC * thisStruct,
longDouble * above, int nUnder, int nUnderK,
int nDo, longDouble * aUnder, longDouble *aOther,
longDouble * work,
int iBlock, int jBlock,
int numberBlocks);
/**Leaf recursive factor */
void
ClpCholeskyCfactorLeaf(ClpCholeskyDenseC * thisStruct,
longDouble * a, int n,
longDouble * diagonal, longDouble * work,
int * rowsDropped);
/**Leaf recursive triangle rectangle update */
void
ClpCholeskyCtriRecLeaf(/*ClpCholeskyDenseC * thisStruct,*/
longDouble * aTri, longDouble * aUnder,
longDouble * diagonal, longDouble * work,
int nUnder);
/**Leaf recursive rectangle triangle update */
void
ClpCholeskyCrecTriLeaf(/*ClpCholeskyDenseC * thisStruct, */
longDouble * aUnder, longDouble * aTri,
/*longDouble * diagonal,*/ longDouble * work, int nUnder);
/** Leaf recursive rectangle rectangle update,
nUnder is number of rows in iBlock,
nUnderK is number of rows in kBlock
*/
void
ClpCholeskyCrecRecLeaf(/*ClpCholeskyDenseC * thisStruct, */
const longDouble * COIN_RESTRICT above,
const longDouble * COIN_RESTRICT aUnder,
longDouble * COIN_RESTRICT aOther,
const longDouble * COIN_RESTRICT work,
int nUnder);
#endif
|