// Will create the actual numerical factorization of the given ATA matrix
// provided the symbolic factor with id factorId
bool FactorATA_UseSymbolic(const int matrixID, const int symbFactorId) {
if (matrixID >= (int)matrixArray.size() || symbFactorId >= (int)factorArray.size()
|| matrixID < 0 || symbFactorId < 0)
return false;
if (factorArray[symbFactorId].hasNumericalValues) {
taucs_supernodal_factor_free_numeric(factorArray[symbFactorId].SL);
}
factorArray[symbFactorId].hasNumericalValues = true;
taucs_ccs_free(factorArray[symbFactorId].PAP);
return matrixArray[matrixID]->FactorATA_UseSymbolic(factorArray[symbFactorId].SL,
&factorArray[symbFactorId].PAP,
factorArray[symbFactorId].perm,
factorArray[symbFactorId].invperm);
}
/* Factorize - filling in rowsDropped and returning number dropped */
int
ClpCholeskyTaucs::factorize(const double * diagonal, int * rowsDropped)
{
const CoinBigIndex * columnStart = model_->clpMatrix()->getVectorStarts();
const int * columnLength = model_->clpMatrix()->getVectorLengths();
const int * row = model_->clpMatrix()->getIndices();
const double * element = model_->clpMatrix()->getElements();
const CoinBigIndex * rowStart = rowCopyT_->getVectorStarts();
const int * rowLength = rowCopyT_->getVectorLengths();
const int * column = rowCopyT_->getIndices();
const double * elementByRow = rowCopyT_->getElements();
int numberColumns = model_->clpMatrix()->getNumCols();
int iRow;
double * work = new double[numberRows_];
CoinZeroN(work, numberRows_);
const double * diagonalSlack = diagonal + numberColumns;
int newDropped = 0;
double largest;
//perturbation
double perturbation = model_->diagonalPerturbation() * model_->diagonalNorm();
perturbation = perturbation * perturbation;
if (perturbation > 1.0) {
//if (model_->model()->logLevel()&4)
std::cout << "large perturbation " << perturbation << std::endl;
perturbation = sqrt(perturbation);
perturbation = 1.0;
}
for (iRow = 0; iRow < numberRows_; iRow++) {
double * put = sparseFactorT_ + choleskyStartT_[iRow];
int * which = choleskyRowT_ + choleskyStartT_[iRow];
int number = choleskyStartT_[iRow+1] - choleskyStartT_[iRow];
if (!rowLength[iRow])
rowsDropped_[iRow] = 1;
if (!rowsDropped_[iRow]) {
CoinBigIndex startRow = rowStart[iRow];
CoinBigIndex endRow = rowStart[iRow] + rowLength[iRow];
work[iRow] = diagonalSlack[iRow];
for (CoinBigIndex k = startRow; k < endRow; k++) {
int iColumn = column[k];
CoinBigIndex start = columnStart[iColumn];
CoinBigIndex end = columnStart[iColumn] + columnLength[iColumn];
double multiplier = diagonal[iColumn] * elementByRow[k];
for (CoinBigIndex j = start; j < end; j++) {
int jRow = row[j];
if (jRow >= iRow && !rowsDropped_[jRow]) {
double value = element[j] * multiplier;
work[jRow] += value;
}
}
}
int j;
for (j = 0; j < number; j++) {
int jRow = which[j];
put[j] = work[jRow];
work[jRow] = 0.0;
}
} else {
// dropped
int j;
for (j = 1; j < number; j++) {
put[j] = 0.0;
}
put[0] = 1.0;
}
}
//check sizes
double largest2 = maximumAbsElement(sparseFactorT_, sizeFactorT_);
largest2 *= 1.0e-19;
largest = CoinMin(largest2, 1.0e-11);
int numberDroppedBefore = 0;
for (iRow = 0; iRow < numberRows_; iRow++) {
int dropped = rowsDropped_[iRow];
// Move to int array
rowsDropped[iRow] = dropped;
if (!dropped) {
CoinBigIndex start = choleskyStartT_[iRow];
double diagonal = sparseFactorT_[start];
if (diagonal > largest2) {
sparseFactorT_[start] = diagonal + perturbation;
} else {
sparseFactorT_[start] = diagonal + perturbation;
rowsDropped[iRow] = 2;
numberDroppedBefore++;
}
}
}
taucs_supernodal_factor_free_numeric(factorization_);
// need to permute
taucs_ccs_matrix * permuted = taucs_ccs_permute_symmetrically(matrix_, permuteInverse_, permute_);
int rCode = taucs_ccs_factor_llt_numeric(permuted, factorization_);
taucs_ccs_free(permuted);
if (rCode)
printf("return code of %d from factor\n", rCode);
delete [] work;
choleskyCondition_ = 1.0;
bool cleanCholesky;
if (model_->numberIterations() < 200)
cleanCholesky = true;
else
cleanCholesky = false;
/*
How do I find out where 1.0e100's are in cholesky?
*/
if (cleanCholesky) {
//drop fresh makes some formADAT easier
int oldDropped = numberRowsDropped_;
if (newDropped || numberRowsDropped_) {
std::cout << "Rank " << numberRows_ - newDropped << " ( " <<
newDropped << " dropped)";
if (newDropped > oldDropped)
std::cout << " ( " << newDropped - oldDropped << " dropped this time)";
std::cout << std::endl;
newDropped = 0;
for (int i = 0; i < numberRows_; i++) {
char dropped = rowsDropped[i];
rowsDropped_[i] = dropped;
if (dropped == 2) {
//dropped this time
rowsDropped[newDropped++] = i;
rowsDropped_[i] = 0;
}
}
numberRowsDropped_ = newDropped;
newDropped = -(1 + newDropped);
}
} else {
if (newDropped) {
newDropped = 0;
for (int i = 0; i < numberRows_; i++) {
char dropped = rowsDropped[i];
int oldDropped = rowsDropped_[i];
rowsDropped_[i] = dropped;
if (dropped == 2) {
assert (!oldDropped);
//dropped this time
rowsDropped[newDropped++] = i;
rowsDropped_[i] = 1;
}
}
}
numberRowsDropped_ += newDropped;
if (numberRowsDropped_) {
std::cout << "Rank " << numberRows_ - numberRowsDropped_ << " ( " <<
numberRowsDropped_ << " dropped)";
if (newDropped) {
std::cout << " ( " << newDropped << " dropped this time)";
}
std::cout << std::endl;
}
}
status_ = 0;
return newDropped;
}
DllExport void FreeNumericFactor( struct SymbolicSolver_tag *sp )
{
struct SymbolicSolver_tag * s = (struct SymbolicSolver_tag *) sp;
taucs_supernodal_factor_free_numeric(s->factorization);
}
