ClpNetworkBasis Class Reference

#include <ClpNetworkBasis.hpp>

List of all members.

Public Member Functions
Constructors and destructor and copy
	ClpNetworkBasis ()
	Default constructor.
	ClpNetworkBasis (const ClpSimplex *model, int numberRows, const double *pivotRegion, const int *permuteBack, const int *startColumn, const int *numberInColumn, const int *indexRow, const double *element)
	Constructor from CoinFactorization.
	ClpNetworkBasis (const ClpNetworkBasis &other)
	Copy constructor.
	~ClpNetworkBasis ()
	Destructor.
ClpNetworkBasis &	operator= (const ClpNetworkBasis &other)
	= copy
Do factorization
int	factorize (const ClpMatrixBase *matrix, int rowIsBasic[], int columnIsBasic[])
rank one updates which do exist
int	replaceColumn (CoinIndexedVector *column, int pivotRow)
various uses of factorization (return code number elements)
which user may want to know about
double	updateColumn (CoinIndexedVector *regionSparse, CoinIndexedVector *regionSparse2, int pivotRow)
int	updateColumn (CoinIndexedVector *regionSparse, double array[]) const
int	updateColumnTranspose (CoinIndexedVector *regionSparse, double array[]) const
int	updateColumnTranspose (CoinIndexedVector *regionSparse, CoinIndexedVector *regionSparse2) const
Private Member Functions
void	check ()
void	print ()
Private Attributes
data
double	slackValue_
	Whether slack value is +1 or -1.
int	numberRows_
	Number of Rows in factorization.
int	numberColumns_
	Number of Columns in factorization.
const ClpSimplex *	model_
	model
int *	parent_
	Parent for each column.
int *	descendant_
	Descendant.
int *	pivot_
	Pivot row.
int *	rightSibling_
	Right sibling.
int *	leftSibling_
	Left sibling.
double *	sign_
	Sign of pivot.
int *	stack_
	Stack.
int *	permute_
	Permute into array.
int *	permuteBack_
	Permute back array.
int *	stack2_
	Second stack.
int *	depth_
	Depth.
char *	mark_
	To mark rows.

---

Detailed Description

This deals with Factorization and Updates for network structures

Definition at line 21 of file ClpNetworkBasis.hpp.

---

Member Function Documentation

int ClpNetworkBasis::factorize (  const ClpMatrixBase *  matrix, int  rowIsBasic[], int  columnIsBasic[] )

When part of LP - given by basic variables. Actually does factorization. Arrays passed in have non negative value to say basic. If status is okay, basic variables have pivot row - this is only needed if increasingRows_ >1. If status is singular, then basic variables have pivot row and ones thrown out have -1 returns 0 -okay, -1 singular, -2 too many in basis

int ClpNetworkBasis::replaceColumn (  CoinIndexedVector *  column, int  pivotRow )

Replaces one Column to basis, returns 0=OK, 1=Probably OK, 2=singular!! Definition at line 368 of file ClpNetworkBasis.cpp. References CoinIndexedVector::clear(), CoinIndexedVector::denseVector(), depth_, descendant_, CoinIndexedVector::getIndices(), CoinIndexedVector::getNumElements(), leftSibling_, ClpModel::logLevel(), model_, ClpModel::numberIterations(), numberRows_, parent_, permute_, permuteBack_, ClpSimplex::pivotVariable(), rightSibling_, ClpSimplex::sequenceIn(), sign_, stack_, and ClpSimplex::unpack(). { // When things have settled down then redo this to make more elegant // I am sure lots of loops can be combined // regionSparse is empty assert (!regionSparse->getNumElements()); model_->unpack(regionSparse, model_->sequenceIn()); // arc given by pivotRow is leaving basis //int kParent = parent_[pivotRow]; // arc coming in has these two nodes int * indices = regionSparse->getIndices(); int iRow0 = indices[0]; int iRow1; if (regionSparse->getNumElements()==2) iRow1 = indices[1]; else iRow1 = numberRows_; double sign = -regionSparse->denseVector()[iRow0]; regionSparse->clear(); // and outgoing model_->unpack(regionSparse,model_->pivotVariable()[pivotRow]); int jRow0 = indices[0]; int jRow1; if (regionSparse->getNumElements()==2) jRow1 = indices[1]; else jRow1 = numberRows_; regionSparse->clear(); // get correct pivotRow //#define FULL_DEBUG #ifdef FULL_DEBUG printf ("irow %d %d, jrow %d %d\n", iRow0,iRow1,jRow0,jRow1); #endif if (parent_[jRow0]==jRow1) { int newPivot = jRow0; if (newPivot!=pivotRow) { #ifdef FULL_DEBUG printf("pivot row of %d permuted to %d\n",pivotRow,newPivot); #endif pivotRow = newPivot; } } else { //assert (parent_[jRow1]==jRow0); int newPivot = jRow1; if (newPivot!=pivotRow) { #ifdef FULL_DEBUG printf("pivot row of %d permuted to %d\n",pivotRow,newPivot); #endif pivotRow = newPivot; } } bool extraPrint = (model_->numberIterations()>-3)&& (model_->logLevel()>10); if (extraPrint) print(); #ifdef FULL_DEBUG printf("In %d (region= %g, stored %g) %d (%g) pivoting on %d (%g)\n", iRow1, sign, sign_[iRow1], iRow0, sign_[iRow0] ,pivotRow,sign_[pivotRow]); #endif // see which path outgoing pivot is on int kRow = -1; int jRow = iRow1; while (jRow!=numberRows_) { if (jRow==pivotRow) { kRow = iRow1; break; } else { jRow = parent_[jRow]; } } if (kRow<0) { jRow = iRow0; while (jRow!=numberRows_) { if (jRow==pivotRow) { kRow = iRow0; break; } else { jRow = parent_[jRow]; } } } //assert (kRow>=0); if (iRow0==kRow) { iRow0 = iRow1; iRow1 = kRow; sign = -sign; } // pivot row is on path from iRow1 back to root // get stack of nodes to change // Also get precursors for cleaning order int nStack=1; stack_[0]=iRow0; while (kRow!=pivotRow) { stack_[nStack++] = kRow; if (sign*sign_[kRow]<0.0) { sign_[kRow]= -sign_[kRow]; } else { sign = -sign; } kRow = parent_[kRow]; //sign *= sign_[kRow]; } stack_[nStack++]=pivotRow; if (sign*sign_[pivotRow]<0.0) { sign_[pivotRow]= -sign_[pivotRow]; } else { sign = -sign; } int iParent = parent_[pivotRow]; while (nStack>1) { int iLeft; int iRight; kRow = stack_[--nStack]; int newParent = stack_[nStack-1]; #ifdef FULL_DEBUG printf("row %d, old parent %d, new parent %d, pivotrow %d\n",kRow, iParent,newParent,pivotRow); #endif int i1 = permuteBack_[pivotRow]; int i2 = permuteBack_[kRow]; permuteBack_[pivotRow]=i2; permuteBack_[kRow]=i1; // do Btran permutation permute_[i1]=kRow; permute_[i2]=pivotRow; pivotRow = kRow; // Take out of old parent iLeft = leftSibling_[kRow]; iRight = rightSibling_[kRow]; if (iLeft<0) { // take out of tree if (iRight>=0) { leftSibling_[iRight]=iLeft; descendant_[iParent]=iRight; } else { #ifdef FULL_DEBUG printf("Saying %d (old parent of %d) has no descendants\n", iParent, kRow); #endif descendant_[iParent]=-1; } } else { // take out of tree rightSibling_[iLeft] = iRight; if (iRight>=0) leftSibling_[iRight]=iLeft; } leftSibling_[kRow]=-1; rightSibling_[kRow]=-1; // now insert new one // make this descendant of that if (descendant_[newParent]>=0) { // we will have a sibling int jRight = descendant_[newParent]; rightSibling_[kRow]=jRight; leftSibling_[jRight]=kRow; } else { rightSibling_[kRow]=-1; } descendant_[newParent] = kRow; leftSibling_[kRow]=-1; parent_[kRow]=newParent; iParent = kRow; } // now redo all depths from stack_[1] // This must be possible to combine - but later { int iPivot = stack_[1]; int iDepth=depth_[parent_[iPivot]]; //depth of parent iDepth ++; //correct for this one int nStack = 1; stack_[0]=iPivot; while (nStack) { // take off int iNext = stack_[--nStack]; if (iNext>=0) { // add stack level depth_[iNext]=nStack+iDepth; stack_[nStack++] = rightSibling_[iNext]; if (descendant_[iNext]>=0) stack_[nStack++] = descendant_[iNext]; } } } if (extraPrint) print(); //check(); return 0; }

int ClpNetworkBasis::updateColumn (  CoinIndexedVector *  regionSparse, double  array[] )  const

Updates one column (FTRAN) to/from array For large problems you should ALWAYS know where the nonzeros are, so please try and migrate to previous method after you have got code working using this simple method - thank you! (the only exception is if you know input is dense e.g. rhs) Definition at line 861 of file ClpNetworkBasis.cpp. References CoinIndexedVector::clear(), CoinIndexedVector::denseVector(), depth_, CoinIndexedVector::getIndices(), mark_, numberRows_, parent_, permuteBack_, sign_, stack2_, and stack_. { regionSparse->clear ( ); double *region = regionSparse->denseVector ( ); int numberNonZero = 0; int *regionIndex = regionSparse->getIndices ( ); int i; // set up linked lists at each depth // stack2 is start, stack is next int greatestDepth=-1; for (i=0;i<numberRows_;i++) { double value = region2[i]; if (value) { region2[i]=0.0; region[i]=value; regionIndex[numberNonZero++]=i; int j=i; int iDepth = depth_[j]; if (iDepth>greatestDepth) greatestDepth = iDepth; // and back until marked while (!mark_[j]) { int iNext = stack2_[iDepth]; stack2_[iDepth]=j; stack_[j]=iNext; mark_[j]=1; iDepth--; j=parent_[j]; } } } numberNonZero=0; for (;greatestDepth>=0; greatestDepth--) { int iPivot = stack2_[greatestDepth]; stack2_[greatestDepth]=-1; while (iPivot>=0) { mark_[iPivot]=0; double pivotValue = region[iPivot]; if (pivotValue) { // put back now ? int iBack = permuteBack_[iPivot]; numberNonZero++; int otherRow = parent_[iPivot]; region2[iBack] = pivotValue*sign_[iPivot]; region[iPivot] =0.0; region[otherRow] += pivotValue; } iPivot = stack_[iPivot]; } } region[numberRows_]=0.0; return numberNonZero; }

double ClpNetworkBasis::updateColumn (  CoinIndexedVector *  regionSparse, CoinIndexedVector *  regionSparse2, int  pivotRow )

Updates one column (FTRAN) from region, Returns pivot value if "pivotRow" >=0 Definition at line 564 of file ClpNetworkBasis.cpp. References CoinIndexedVector::clear(), CoinIndexedVector::denseVector(), depth_, CoinIndexedVector::getIndices(), CoinIndexedVector::getNumElements(), mark_, numberRows_, CoinIndexedVector::packedMode(), parent_, permuteBack_, CoinIndexedVector::setNumElements(), sign_, stack2_, and stack_. { regionSparse->clear ( ); double *region = regionSparse->denseVector ( ); double *region2 = regionSparse2->denseVector ( ); int *regionIndex2 = regionSparse2->getIndices ( ); int numberNonZero = regionSparse2->getNumElements ( ); int *regionIndex = regionSparse->getIndices ( ); int i; bool doTwo = (numberNonZero==2); int i0=-1; int i1=-1; if (doTwo) { i0 = regionIndex2[0]; i1 = regionIndex2[1]; } double returnValue=0.0; bool packed = regionSparse2->packedMode(); if (packed) { if (doTwo&&region2[0]*region2[1]<0.0) { region[i0] = region2[0]; region2[0]=0.0; region[i1] = region2[1]; region2[1]=0.0; int iDepth0 = depth_[i0]; int iDepth1 = depth_[i1]; if (iDepth1>iDepth0) { int temp = i0; i0 = i1; i1 = temp; temp = iDepth0; iDepth0 = iDepth1; iDepth1 = temp; } numberNonZero=0; if (pivotRow<0) { while (iDepth0>iDepth1) { double pivotValue = region[i0]; // put back now ? int iBack = permuteBack_[i0]; region2[numberNonZero] = pivotValue*sign_[i0]; regionIndex2[numberNonZero++] = iBack; int otherRow = parent_[i0]; region[i0] =0.0; region[otherRow] += pivotValue; iDepth0--; i0 = otherRow; } while (i0!=i1) { double pivotValue = region[i0]; // put back now ? int iBack = permuteBack_[i0]; region2[numberNonZero] = pivotValue*sign_[i0]; regionIndex2[numberNonZero++] = iBack; int otherRow = parent_[i0]; region[i0] =0.0; region[otherRow] += pivotValue; i0 = otherRow; double pivotValue1 = region[i1]; // put back now ? int iBack1 = permuteBack_[i1]; region2[numberNonZero] = pivotValue1*sign_[i1]; regionIndex2[numberNonZero++] = iBack1; int otherRow1 = parent_[i1]; region[i1] =0.0; region[otherRow1] += pivotValue1; i1 = otherRow1; } } else { while (iDepth0>iDepth1) { double pivotValue = region[i0]; // put back now ? int iBack = permuteBack_[i0]; double value = pivotValue*sign_[i0]; region2[numberNonZero] = value; regionIndex2[numberNonZero++] = iBack; if (iBack==pivotRow) returnValue = value; int otherRow = parent_[i0]; region[i0] =0.0; region[otherRow] += pivotValue; iDepth0--; i0 = otherRow; } while (i0!=i1) { double pivotValue = region[i0]; // put back now ? int iBack = permuteBack_[i0]; double value = pivotValue*sign_[i0]; region2[numberNonZero] = value; regionIndex2[numberNonZero++] = iBack; if (iBack==pivotRow) returnValue = value; int otherRow = parent_[i0]; region[i0] =0.0; region[otherRow] += pivotValue; i0 = otherRow; double pivotValue1 = region[i1]; // put back now ? int iBack1 = permuteBack_[i1]; value = pivotValue1*sign_[i1]; region2[numberNonZero] = value; regionIndex2[numberNonZero++] = iBack1; if (iBack1==pivotRow) returnValue = value; int otherRow1 = parent_[i1]; region[i1] =0.0; region[otherRow1] += pivotValue1; i1 = otherRow1; } } } else { // set up linked lists at each depth // stack2 is start, stack is next int greatestDepth=-1; //mark_[numberRows_]=1; for (i=0;i<numberNonZero;i++) { int j = regionIndex2[i]; double value = region2[i]; region2[i]=0.0; region[j]=value; regionIndex[i]=j; int iDepth = depth_[j]; if (iDepth>greatestDepth) greatestDepth = iDepth; // and back until marked while (!mark_[j]) { int iNext = stack2_[iDepth]; stack2_[iDepth]=j; stack_[j]=iNext; mark_[j]=1; iDepth--; j=parent_[j]; } } numberNonZero=0; if (pivotRow<0) { for (;greatestDepth>=0; greatestDepth--) { int iPivot = stack2_[greatestDepth]; stack2_[greatestDepth]=-1; while (iPivot>=0) { mark_[iPivot]=0; double pivotValue = region[iPivot]; if (pivotValue) { // put back now ? int iBack = permuteBack_[iPivot]; region2[numberNonZero] = pivotValue*sign_[iPivot]; regionIndex2[numberNonZero++] = iBack; int otherRow = parent_[iPivot]; region[iPivot] =0.0; region[otherRow] += pivotValue; } iPivot = stack_[iPivot]; } } } else { for (;greatestDepth>=0; greatestDepth--) { int iPivot = stack2_[greatestDepth]; stack2_[greatestDepth]=-1; while (iPivot>=0) { mark_[iPivot]=0; double pivotValue = region[iPivot]; if (pivotValue) { // put back now ? int iBack = permuteBack_[iPivot]; double value = pivotValue*sign_[iPivot]; region2[numberNonZero] = value; regionIndex2[numberNonZero++] = iBack; if (iBack==pivotRow) returnValue = value; int otherRow = parent_[iPivot]; region[iPivot] =0.0; region[otherRow] += pivotValue; } iPivot = stack_[iPivot]; } } } } } else { if (doTwo&&region2[i0]*region2[i1]<0.0) { // If just +- 1 then could go backwards on depth until join region[i0] = region2[i0]; region2[i0]=0.0; region[i1] = region2[i1]; region2[i1]=0.0; int iDepth0 = depth_[i0]; int iDepth1 = depth_[i1]; if (iDepth1>iDepth0) { int temp = i0; i0 = i1; i1 = temp; temp = iDepth0; iDepth0 = iDepth1; iDepth1 = temp; } numberNonZero=0; while (iDepth0>iDepth1) { double pivotValue = region[i0]; // put back now ? int iBack = permuteBack_[i0]; regionIndex2[numberNonZero++] = iBack; int otherRow = parent_[i0]; region2[iBack] = pivotValue*sign_[i0]; region[i0] =0.0; region[otherRow] += pivotValue; iDepth0--; i0 = otherRow; } while (i0!=i1) { double pivotValue = region[i0]; // put back now ? int iBack = permuteBack_[i0]; regionIndex2[numberNonZero++] = iBack; int otherRow = parent_[i0]; region2[iBack] = pivotValue*sign_[i0]; region[i0] =0.0; region[otherRow] += pivotValue; i0 = otherRow; double pivotValue1 = region[i1]; // put back now ? int iBack1 = permuteBack_[i1]; regionIndex2[numberNonZero++] = iBack1; int otherRow1 = parent_[i1]; region2[iBack1] = pivotValue1*sign_[i1]; region[i1] =0.0; region[otherRow1] += pivotValue1; i1 = otherRow1; } } else { // set up linked lists at each depth // stack2 is start, stack is next int greatestDepth=-1; //mark_[numberRows_]=1; for (i=0;i<numberNonZero;i++) { int j = regionIndex2[i]; double value = region2[j]; region2[j]=0.0; region[j]=value; regionIndex[i]=j; int iDepth = depth_[j]; if (iDepth>greatestDepth) greatestDepth = iDepth; // and back until marked while (!mark_[j]) { int iNext = stack2_[iDepth]; stack2_[iDepth]=j; stack_[j]=iNext; mark_[j]=1; iDepth--; j=parent_[j]; } } numberNonZero=0; for (;greatestDepth>=0; greatestDepth--) { int iPivot = stack2_[greatestDepth]; stack2_[greatestDepth]=-1; while (iPivot>=0) { mark_[iPivot]=0; double pivotValue = region[iPivot]; if (pivotValue) { // put back now ? int iBack = permuteBack_[iPivot]; regionIndex2[numberNonZero++] = iBack; int otherRow = parent_[iPivot]; region2[iBack] = pivotValue*sign_[iPivot]; region[iPivot] =0.0; region[otherRow] += pivotValue; } iPivot = stack_[iPivot]; } } } if (pivotRow>=0) returnValue = region2[pivotRow]; } region[numberRows_]=0.0; regionSparse2->setNumElements(numberNonZero); #ifdef FULL_DEBUG { int i; for (i=0;i<numberRows_;i++) { assert(!mark_[i]); assert (stack2_[i]==-1); } } #endif return returnValue; }

int ClpNetworkBasis::updateColumnTranspose (  CoinIndexedVector *  regionSparse, CoinIndexedVector *  regionSparse2 )  const

Updates one column (BTRAN) from region2 Definition at line 988 of file ClpNetworkBasis.cpp. References CoinIndexedVector::clear(), CoinIndexedVector::denseVector(), depth_, descendant_, CoinIndexedVector::getIndices(), CoinIndexedVector::getNumElements(), mark_, numberRows_, CoinIndexedVector::packedMode(), parent_, permute_, rightSibling_, CoinIndexedVector::setNumElements(), sign_, stack2_, and stack_. { // permute in - presume small number so copy back // so will end up in right place regionSparse->clear ( ); double *region = regionSparse->denseVector ( ); double *region2 = regionSparse2->denseVector ( ); int *regionIndex2 = regionSparse2->getIndices ( ); int numberNonZero2 = regionSparse2->getNumElements ( ); int *regionIndex = regionSparse->getIndices ( ); int i; int numberNonZero=0; bool packed = regionSparse2->packedMode(); if (packed) { for (i=0;i<numberNonZero2;i++) { int k = regionIndex2[i]; int j = permute_[k]; double value = region2[i]; region2[i]=0.0; region[j]=value; mark_[j]=1; regionIndex[numberNonZero++]=j; } // set up linked lists at each depth // stack2 is start, stack is next int greatestDepth=-1; int smallestDepth=numberRows_; //mark_[numberRows_]=1; for (i=0;i<numberNonZero2;i++) { int j = regionIndex[i]; regionIndex2[i]=j; // add in int iDepth = depth_[j]; smallestDepth = min(iDepth,smallestDepth) ; greatestDepth = max(iDepth,greatestDepth) ; int jNext = stack2_[iDepth]; stack2_[iDepth]=j; stack_[j]=jNext; // and put all descendants on list int iChild = descendant_[j]; while (iChild>=0) { if (!mark_[iChild]) { regionIndex2[numberNonZero++] = iChild; mark_[iChild]=1; } iChild = rightSibling_[iChild]; } } for (;i<numberNonZero;i++) { int j = regionIndex2[i]; // add in int iDepth = depth_[j]; smallestDepth = min(iDepth,smallestDepth) ; greatestDepth = max(iDepth,greatestDepth) ; int jNext = stack2_[iDepth]; stack2_[iDepth]=j; stack_[j]=jNext; // and put all descendants on list int iChild = descendant_[j]; while (iChild>=0) { if (!mark_[iChild]) { regionIndex2[numberNonZero++] = iChild; mark_[iChild]=1; } iChild = rightSibling_[iChild]; } } numberNonZero2=0; region[numberRows_]=0.0; int iDepth; for (iDepth=smallestDepth;iDepth<=greatestDepth; iDepth++) { int iPivot = stack2_[iDepth]; stack2_[iDepth]=-1; while (iPivot>=0) { mark_[iPivot]=0; double pivotValue = region[iPivot]; int otherRow = parent_[iPivot]; double otherValue = region[otherRow]; pivotValue = sign_[iPivot]*pivotValue+otherValue; region[iPivot]=pivotValue; if (pivotValue) { region2[numberNonZero2]=pivotValue; regionIndex2[numberNonZero2++]=iPivot; } iPivot = stack_[iPivot]; } } // zero out for (i=0;i<numberNonZero2;i++) { int k = regionIndex2[i]; region[k]=0.0; } } else { for (i=0;i<numberNonZero2;i++) { int k = regionIndex2[i]; int j = permute_[k]; double value = region2[k]; region2[k]=0.0; region[j]=value; mark_[j]=1; regionIndex[numberNonZero++]=j; } // copy back // set up linked lists at each depth // stack2 is start, stack is next int greatestDepth=-1; int smallestDepth=numberRows_; //mark_[numberRows_]=1; for (i=0;i<numberNonZero2;i++) { int j = regionIndex[i]; double value = region[j]; region[j]=0.0; region2[j]=value; regionIndex2[i]=j; // add in int iDepth = depth_[j]; smallestDepth = min(iDepth,smallestDepth) ; greatestDepth = max(iDepth,greatestDepth) ; int jNext = stack2_[iDepth]; stack2_[iDepth]=j; stack_[j]=jNext; // and put all descendants on list int iChild = descendant_[j]; while (iChild>=0) { if (!mark_[iChild]) { regionIndex2[numberNonZero++] = iChild; mark_[iChild]=1; } iChild = rightSibling_[iChild]; } } for (;i<numberNonZero;i++) { int j = regionIndex2[i]; // add in int iDepth = depth_[j]; smallestDepth = min(iDepth,smallestDepth) ; greatestDepth = max(iDepth,greatestDepth) ; int jNext = stack2_[iDepth]; stack2_[iDepth]=j; stack_[j]=jNext; // and put all descendants on list int iChild = descendant_[j]; while (iChild>=0) { if (!mark_[iChild]) { regionIndex2[numberNonZero++] = iChild; mark_[iChild]=1; } iChild = rightSibling_[iChild]; } } numberNonZero2=0; region2[numberRows_]=0.0; int iDepth; for (iDepth=smallestDepth;iDepth<=greatestDepth; iDepth++) { int iPivot = stack2_[iDepth]; stack2_[iDepth]=-1; while (iPivot>=0) { mark_[iPivot]=0; double pivotValue = region2[iPivot]; int otherRow = parent_[iPivot]; double otherValue = region2[otherRow]; pivotValue = sign_[iPivot]*pivotValue+otherValue; region2[iPivot]=pivotValue; if (pivotValue) regionIndex2[numberNonZero2++]=iPivot; iPivot = stack_[iPivot]; } } } regionSparse2->setNumElements(numberNonZero2); #ifdef FULL_DEBUG { int i; for (i=0;i<numberRows_;i++) { assert(!mark_[i]); assert (stack2_[i]==-1); } } #endif return numberNonZero2; }

int ClpNetworkBasis::updateColumnTranspose (  CoinIndexedVector *  regionSparse, double  array[] )  const

Updates one column transpose (BTRAN) For large problems you should ALWAYS know where the nonzeros are, so please try and migrate to previous method after you have got code working using this simple method - thank you! (the only exception is if you know input is dense e.g. dense objective) returns number of nonzeros Definition at line 922 of file ClpNetworkBasis.cpp. References CoinIndexedVector::denseVector(), depth_, descendant_, CoinIndexedVector::getIndices(), mark_, numberRows_, parent_, permute_, rightSibling_, sign_, stack2_, and stack_. { // permute in after copying // so will end up in right place double *region = regionSparse->denseVector ( ); int *regionIndex = regionSparse->getIndices ( ); int i; int numberNonZero=0; memcpy(region,region2,numberRows_*sizeof(double)); for (i=0;i<numberRows_;i++) { double value = region[i]; if (value) { int k = permute_[i]; region[i]=0.0; region2[k]=value; regionIndex[numberNonZero++]=k; mark_[k]=1; } } // copy back // set up linked lists at each depth // stack2 is start, stack is next int greatestDepth=-1; int smallestDepth=numberRows_; for (i=0;i<numberNonZero;i++) { int j = regionIndex[i]; // add in int iDepth = depth_[j]; smallestDepth = min(iDepth,smallestDepth) ; greatestDepth = max(iDepth,greatestDepth) ; int jNext = stack2_[iDepth]; stack2_[iDepth]=j; stack_[j]=jNext; // and put all descendants on list int iChild = descendant_[j]; while (iChild>=0) { if (!mark_[iChild]) { regionIndex[numberNonZero++] = iChild; mark_[iChild]=1; } iChild = rightSibling_[iChild]; } } numberNonZero=0; region2[numberRows_]=0.0; int iDepth; for (iDepth=smallestDepth;iDepth<=greatestDepth; iDepth++) { int iPivot = stack2_[iDepth]; stack2_[iDepth]=-1; while (iPivot>=0) { mark_[iPivot]=0; double pivotValue = region2[iPivot]; int otherRow = parent_[iPivot]; double otherValue = region2[otherRow]; pivotValue = sign_[iPivot]*pivotValue+otherValue; region2[iPivot]=pivotValue; if (pivotValue) numberNonZero++; iPivot = stack_[iPivot]; } } return numberNonZero; }

---

The documentation for this class was generated from the following files:

• ClpNetworkBasis.hpp
• ClpNetworkBasis.cpp

---