main(int argc, char **argv)
{
#ifdef __APPLE__
char end = get_end();
#else
extern char end;
#endif
char *sbrk(int);
fflush(stdout);
initializeStuff(argc, argv);
yyparse();
finishUp();
if (emitPrint)
printf("storage high water mark 0x%x == %d\n", sbrk(0) - &end,
sbrk(0) - &end);
if (errorFlag)
chokePukeAndDie();
else
exit(0);
}
void CoinPresolveMatrix::setMatrix (const CoinPackedMatrix *mtx)
{
/*
Check to make sure the matrix will fit and is column ordered.
*/
if (mtx->isColOrdered() == false)
{ throw CoinError("source matrix must be column ordered",
"setMatrix","CoinPrePostsolveMatrix") ; }
int numCols = mtx->getNumCols() ;
if (numCols > ncols0_)
{ throw CoinError("source matrix exceeds allocated capacity",
"setMatrix","CoinPrePostsolveMatrix") ; }
/*
Acquire the actual size, but allocate the matrix storage to the
requested capacity. The column-major rep is part of the PrePostsolve
object, the row-major rep belongs to the Presolve object.
*/
ncols_ = numCols ;
nrows_ = mtx->getNumRows() ;
nelems_ = mtx->getNumElements() ;
bulk0_ = static_cast<CoinBigIndex> (bulkRatio_*nelems0_) ;
if (mcstrt_ == 0) mcstrt_ = new CoinBigIndex [ncols0_+1] ;
if (hincol_ == 0) hincol_ = new int [ncols0_+1] ;
if (hrow_ == 0) hrow_ = new int [bulk0_] ;
if (colels_ == 0) colels_ = new double [bulk0_] ;
if (mrstrt_ == 0) mrstrt_ = new CoinBigIndex [nrows0_+1] ;
if (hinrow_ == 0) hinrow_ = new int [nrows0_+1] ;
if (hcol_ == 0) hcol_ = new int [bulk0_] ;
if (rowels_ == 0) rowels_ = new double [bulk0_] ;
/*
Grab the corresponding vectors from the source matrix.
*/
const CoinBigIndex *src_mcstrt = mtx->getVectorStarts() ;
const int *src_hincol = mtx->getVectorLengths() ;
const double *src_colels = mtx->getElements() ;
const int *src_hrow = mtx->getIndices() ;
/*
Bulk copy the column starts and lengths.
*/
CoinMemcpyN(src_mcstrt,mtx->getSizeVectorStarts(),mcstrt_) ;
CoinMemcpyN(src_hincol,mtx->getSizeVectorLengths(),hincol_) ;
/*
Copy the coefficients column by column in case there are gaps between
the columns in the bulk storage area. The assert is just in case the
gaps are *really* big.
*/
assert(src_mcstrt[ncols_] <= bulk0_) ;
int j;
for ( j = 0 ; j < numCols ; j++)
{ int lenj = src_hincol[j] ;
CoinBigIndex offset = mcstrt_[j] ;
CoinMemcpyN(src_colels+offset,lenj,colels_+offset) ;
CoinMemcpyN(src_hrow+offset,lenj,hrow_+offset) ; }
/*
Now make a row-major copy. Start by counting the number of coefficients in
each row; we can do this directly in hinrow. Given the number of
coefficients in a row, we know how to lay out the bulk storage area.
*/
CoinZeroN(hinrow_,nrows0_+1) ;
for ( j = 0 ; j < ncols_ ; j++)
{ int *rowIndices = hrow_+mcstrt_[j] ;
int lenj = hincol_[j] ;
for (int k = 0 ; k < lenj ; k++)
{ int i = rowIndices[k] ;
hinrow_[i]++ ; } }
/*
Initialize mrstrt[i] to the start of row i+1. As we drop each coefficient
and column index into the bulk storage arrays, we'll decrement and store.
When we're done, mrstrt[i] will point to the start of row i, as it should.
*/
int totalCoeffs = 0 ;
int i;
for ( i = 0 ; i < nrows_ ; i++)
{ totalCoeffs += hinrow_[i] ;
mrstrt_[i] = totalCoeffs ; }
mrstrt_[nrows_] = totalCoeffs ;
for ( j = ncols_-1 ; j >= 0 ; j--)
{ int lenj = hincol_[j] ;
double *colCoeffs = colels_+mcstrt_[j] ;
int *rowIndices = hrow_+mcstrt_[j] ;
for (int k = 0 ; k < lenj ; k++)
{ int ri;
ri = rowIndices[k] ;
double aij = colCoeffs[k] ;
CoinBigIndex l = --mrstrt_[ri] ;
rowels_[l] = aij ;
hcol_[l] = j ; } }
/*
Now the support structures. The entry for original column j should start
out as j; similarly for row i. originalColumn_ and originalRow_ belong to
the PrePostsolve object.
*/
if (originalColumn_ == 0) originalColumn_ = new int [ncols0_] ;
if (originalRow_ == 0) originalRow_ = new int [nrows0_] ;
for ( j = 0 ; j < ncols0_ ; j++)
originalColumn_[j] = j ;
for ( i = 0 ; i < nrows0_ ; i++)
originalRow_[i] = i ;
/*
We have help to set up the clink_ and rlink_ vectors (aids for matrix bulk
storage management). clink_ and rlink_ belong to the Presolve object. Once
this is done, it's safe to set mrstrt_[nrows_] and mcstrt_[ncols_] to the
full size of the bulk storage area.
*/
if (clink_ == 0) clink_ = new presolvehlink [ncols0_+1] ;
if (rlink_ == 0) rlink_ = new presolvehlink [nrows0_+1] ;
presolve_make_memlists(/*mcstrt_,*/hincol_,clink_,ncols_) ;
presolve_make_memlists(/*mrstrt_,*/hinrow_,rlink_,nrows_) ;
mcstrt_[ncols_] = bulk0_ ;
mrstrt_[nrows_] = bulk0_ ;
/*
No rows or columns have been changed just yet. colChanged_ and rowChanged_
belong to the Presolve object.
*/
if (colChanged_ == 0) colChanged_ = new unsigned char [ncols0_] ;
CoinZeroN(colChanged_,ncols0_) ;
if (rowChanged_ == 0) rowChanged_ = new unsigned char [nrows0_] ;
CoinZeroN(rowChanged_,nrows0_) ;
/*
Finally, allocate the various *ToDo arrays. These are used to track the rows
and columns which should be processed in a given round of presolve
transforms. These belong to the Presolve object. Setting number*ToDo to 0
is all the initialization that's required here.
*/
rowsToDo_ = new int [nrows0_] ;
numberRowsToDo_ = 0 ;
nextRowsToDo_ = new int [nrows0_] ;
numberNextRowsToDo_ = 0 ;
colsToDo_ = new int [ncols0_] ;
numberColsToDo_ = 0 ;
nextColsToDo_ = new int [ncols0_] ;
numberNextColsToDo_ = 0 ;
initializeStuff();
return ; }
