/*
--------------------------------------------------------
purpose -- to return a pointer to the location of
matrix entry (irow,jcol) if present.
if entry (irow,jcol) is not present then
(*ppReal,*ppImag) is (NULL,NULL)
else entry (irow,jcol) is present then
(*ppReal,*ppImag) is the location of the matrix entry
endif
created -- 98may01, cca
--------------------------------------------------------
*/
void
SubMtx_locationOfComplexEntry (
SubMtx *mtx,
int irow,
int jcol,
double **ppReal,
double **ppImag
) {
/*
---------------
check the input
---------------
*/
if ( mtx == NULL || irow < 0 || irow >= mtx->nrow || jcol < 0
|| jcol >= mtx->ncol || ppReal == NULL || ppImag == NULL ) {
fprintf(stderr,
"\n fatal error in SubMtx_locationOfComplexEntry(%p,%d,%d,%p,%p)"
"\n bad input\n", mtx, irow, jcol, ppReal, ppImag) ;
exit(-1) ;
}
if ( ! SUBMTX_IS_COMPLEX(mtx) ) {
fprintf(stderr,
"\n fatal error in SubMtx_locationOfComplexEntry(%p,%d,%d,%p,%p)"
"\n bad type %d, must be SPOOLES_COMPLEX\n",
mtx, irow, jcol, ppReal, ppImag, mtx->type) ;
exit(-1) ;
}
*ppReal = NULL ;
*ppImag = NULL ;
switch ( mtx->mode ) {
case SUBMTX_DENSE_ROWS :
case SUBMTX_DENSE_COLUMNS : {
double *entries ;
int inc1, inc2, ncol, nrow, offset ;
SubMtx_denseInfo(mtx, &nrow, &ncol, &inc1, &inc2, &entries) ;
if ( irow >= 0 && irow < nrow && jcol >= 0 && jcol < ncol ) {
offset = irow*inc1 + jcol*inc2 ;
*ppReal = entries + 2*offset ;
*ppImag = entries + 2*offset + 1 ;
}
} break ;
case SUBMTX_SPARSE_ROWS : {
double *entries ;
int ii, jj, nent, nrow, offset, *indices, *sizes ;
SubMtx_sparseRowsInfo(mtx, &nrow, &nent, &sizes, &indices, &entries);
if ( irow >= 0 && irow < nrow ) {
for ( ii = offset = 0 ; ii < irow ; ii++ ) {
offset += sizes[ii] ;
}
for ( ii = 0, jj = offset ; ii < sizes[irow] ; ii++, jj++ ) {
if ( indices[jj] == jcol ) {
*ppReal = entries + 2*jj ;
*ppImag = entries + 2*jj + 1 ;
break ;
}
}
}
} break ;
case SUBMTX_SPARSE_COLUMNS : {
double *entries ;
int ii, jj, nent, ncol, offset, *indices, *sizes ;
SubMtx_sparseColumnsInfo(mtx, &ncol, &nent,
&sizes, &indices, &entries) ;
if ( jcol >= 0 && jcol < ncol ) {
for ( ii = offset = 0 ; ii < jcol ; ii++ ) {
offset += sizes[ii] ;
}
for ( ii = 0, jj = offset ; ii < sizes[jcol] ; ii++, jj++ ) {
if ( indices[jj] == irow ) {
*ppReal = entries + 2*jj ;
*ppImag = entries + 2*jj + 1 ;
break ;
}
}
}
} break ;
case SUBMTX_SPARSE_TRIPLES : {
double *entries ;
int ii, nent, *colids, *rowids ;
SubMtx_sparseTriplesInfo(mtx, &nent, &rowids, &colids, &entries) ;
for ( ii = 0 ; ii < nent ; ii++ ) {
if ( irow == rowids[ii] && jcol == colids[ii] ) {
*ppReal = entries + 2*ii ;
*ppImag = entries + 2*ii + 1 ;
break ;
}
}
} break ;
case SUBMTX_DENSE_SUBROWS : {
double *entries ;
int ii, joff, nent, nrow, offset, *firstlocs, *sizes ;
SubMtx_denseSubrowsInfo(mtx, &nrow, &nent,
&firstlocs, &sizes, &entries) ;
if ( irow >= 0 && irow < nrow && sizes[irow] != 0 ) {
for ( ii = offset = 0 ; ii < irow ; ii++ ) {
offset += sizes[ii] ;
}
if ( 0 <= (joff = jcol - firstlocs[irow])
&& joff < sizes[irow] ) {
offset += joff ;
*ppReal = entries + 2*offset ;
*ppImag = entries + 2*offset + 1 ;
break ;
}
}
} break ;
case SUBMTX_DENSE_SUBCOLUMNS : {
double *entries ;
int ii, ioff, nent, ncol, offset, *firstlocs, *sizes ;
SubMtx_denseSubcolumnsInfo(mtx, &ncol, &nent,
&firstlocs, &sizes, &entries) ;
if ( jcol >= 0 && jcol < ncol && sizes[jcol] != 0 ) {
for ( ii = offset = 0 ; ii < jcol ; ii++ ) {
offset += sizes[jcol] ;
}
if ( 0 <= (ioff = irow - firstlocs[jcol])
&& ioff < sizes[jcol] ) {
offset += ioff ;
*ppReal = entries + 2*offset ;
*ppImag = entries + 2*offset + 1 ;
break ;
}
}
} break ;
case SUBMTX_DIAGONAL : {
double *entries ;
int ncol ;
if ( irow >= 0 && jcol >= 0 && irow == jcol ) {
SubMtx_diagonalInfo(mtx, &ncol, &entries) ;
if ( irow < ncol && jcol < ncol ) {
*ppReal = entries + 2*irow ;
*ppImag = entries + 2*irow + 1 ;
}
}
} break ;
case SUBMTX_BLOCK_DIAGONAL_SYM :
case SUBMTX_BLOCK_DIAGONAL_HERM : {
double *entries ;
int ii, ipivot, jrow, kk, m, ncol, nent, size ;
int *pivotsizes ;
if ( irow >= 0 && jcol >= 0 ) {
SubMtx_blockDiagonalInfo(mtx, &ncol, &nent,
&pivotsizes, &entries) ;
if ( irow < ncol && jcol < ncol ) {
for ( jrow = ipivot = kk = 0 ; jrow <= irow ; ipivot++ ) {
size = m = pivotsizes[ipivot] ;
for ( ii = 0 ; ii < m ; ii++, jrow++ ) {
if ( jrow == irow ) {
if ( jrow - irow > m - ii ) {
kk = -1 ;
} else {
kk += jrow - irow ;
}
} else {
kk += size-- ;
}
}
}
if ( kk != -1 ) {
*ppReal = entries + 2*kk ;
*ppImag = entries + 2*kk + 1 ;
}
}
}
} break ;
default :
fprintf(stderr,
"\n fatal error in SubMtx_locationOfComplexEntry(%p,%d,%d,%p,%p)"
"\n bad mode %d", mtx, irow, jcol, ppReal, ppImag, mtx->mode) ;
exit(-1) ;
break ;
}
return ; }
/*
-------------------------------------------------------
purpose -- to find matrix entry (irow,jcol) if present.
return value --
if entry (irow,jcol) is not present then
*pValue is 0.0
return value is -1
else entry (irow,jcol) is present then
*pValue is the matrix entry
return value is offset into entries array
endif
created -- 98may01, cca
-------------------------------------------------------
*/
int
SubMtx_realEntry (
SubMtx *mtx,
int irow,
int jcol,
double *pValue
) {
/*
---------------
check the input
---------------
*/
if ( mtx == NULL || irow < 0 || irow >= mtx->nrow || jcol < 0
|| jcol >= mtx->ncol || pValue == NULL ) {
fprintf(stderr,
"\n fatal error in SubMtx_realEntry(%p,%d,%d,%p)"
"\n bad input\n", mtx, irow, jcol, pValue) ;
exit(-1) ;
}
if ( ! SUBMTX_IS_REAL(mtx) ) {
fprintf(stderr,
"\n fatal error in SubMtx_realEntry(%p,%d,%d,%p)"
"\n bad type %d, must be SPOOLES_REAL\n",
mtx, irow, jcol, pValue, mtx->type) ;
exit(-1) ;
}
*pValue = 0 ;
switch ( mtx->mode ) {
case SUBMTX_DENSE_ROWS :
case SUBMTX_DENSE_COLUMNS : {
double *entries ;
int inc1, inc2, ncol, nrow, offset ;
SubMtx_denseInfo(mtx, &nrow, &ncol, &inc1, &inc2, &entries) ;
if ( irow < 0 || irow >= nrow || jcol < 0 || jcol >= ncol ) {
return(-1) ;
}
offset = irow*inc1 + jcol*inc2 ;
*pValue = entries[offset] ;
return(offset) ;
} break ;
case SUBMTX_SPARSE_ROWS : {
double *entries ;
int ii, jj, nent, nrow, offset, *indices, *sizes ;
SubMtx_sparseRowsInfo(mtx, &nrow, &nent, &sizes, &indices, &entries) ;
if ( irow < 0 || irow >= nrow ) {
return(-1) ;
}
for ( ii = offset = 0 ; ii < irow ; ii++ ) {
offset += sizes[ii] ;
}
for ( ii = 0, jj = offset ; ii < sizes[irow] ; ii++, jj++ ) {
if ( indices[jj] == jcol ) {
*pValue = entries[jj] ;
return(jj) ;
}
}
return(-1) ;
} break ;
case SUBMTX_SPARSE_COLUMNS : {
double *entries ;
int ii, jj, nent, ncol, offset, *indices, *sizes ;
SubMtx_sparseColumnsInfo(mtx, &ncol, &nent,
&sizes, &indices, &entries) ;
if ( jcol < 0 || jcol >= ncol ) {
return(-1) ;
}
for ( ii = offset = 0 ; ii < jcol ; ii++ ) {
offset += sizes[ii] ;
}
for ( ii = 0, jj = offset ; ii < sizes[jcol] ; ii++, jj++ ) {
if ( indices[jj] == irow ) {
*pValue = entries[jj] ;
return(jj) ;
}
}
return(-1) ;
} break ;
case SUBMTX_SPARSE_TRIPLES : {
double *entries ;
int ii, nent, *colids, *rowids ;
SubMtx_sparseTriplesInfo(mtx, &nent, &rowids, &colids, &entries) ;
for ( ii = 0 ; ii < nent ; ii++ ) {
if ( irow == rowids[ii] && jcol == colids[ii] ) {
*pValue = entries[ii] ;
return(ii) ;
}
}
return(-1) ;
} break ;
case SUBMTX_DENSE_SUBROWS : {
double *entries ;
int ii, joff, nent, nrow, offset, *firstlocs, *sizes ;
SubMtx_denseSubrowsInfo(mtx, &nrow, &nent,
&firstlocs, &sizes, &entries) ;
if ( irow < 0 || irow >= nrow || sizes[irow] == 0 ) {
return(-1) ;
}
for ( ii = offset = 0 ; ii < irow ; ii++ ) {
offset += sizes[ii] ;
}
if ( 0 <= (joff = jcol - firstlocs[irow]) && joff < sizes[irow] ) {
offset += joff ;
*pValue = entries[offset] ;
return(offset) ;
}
return(-1) ;
} break ;
case SUBMTX_DENSE_SUBCOLUMNS : {
double *entries ;
int ii, ioff, nent, ncol, offset, *firstlocs, *sizes ;
SubMtx_denseSubcolumnsInfo(mtx, &ncol, &nent,
&firstlocs, &sizes, &entries) ;
if ( jcol < 0 || jcol >= ncol || sizes[jcol] == 0 ) {
return(-1) ;
}
for ( ii = offset = 0 ; ii < jcol ; ii++ ) {
offset += sizes[ii] ;
}
if ( 0 <= (ioff = irow - firstlocs[jcol]) && ioff < sizes[jcol] ) {
offset += ioff ;
*pValue = entries[offset] ;
return(offset) ;
}
return(-1) ;
} break ;
case SUBMTX_DIAGONAL : {
double *entries ;
int ncol ;
if ( irow < 0 || jcol < 0 || irow != jcol ) {
return(-1) ;
}
SubMtx_diagonalInfo(mtx, &ncol, &entries) ;
if ( irow >= ncol || jcol >= ncol ) {
return(-1) ;
}
*pValue = entries[irow] ;
return(irow) ;
} break ;
case SUBMTX_BLOCK_DIAGONAL_SYM : {
double *entries ;
int ii, ipivot, jrow, kk, m, ncol, nent, size ;
int *pivotsizes ;
if ( irow < 0 || jcol < 0 ) {
return(-1) ;
}
if ( irow > jcol ) {
ii = irow ;
irow = jcol ;
jcol = ii ;
}
SubMtx_blockDiagonalInfo(mtx, &ncol, &nent, &pivotsizes, &entries) ;
if ( irow >= ncol || jcol >= ncol ) {
return(-1) ;
}
for ( jrow = ipivot = kk = 0 ; jrow <= irow ; ipivot++ ) {
size = m = pivotsizes[ipivot] ;
for ( ii = 0 ; ii < m ; ii++, jrow++ ) {
if ( jrow == irow ) {
if ( jcol - irow > m - ii - 1 ) {
return(-1) ;
} else {
kk += jcol - irow ;
*pValue = entries[kk] ;
return(kk) ;
}
} else {
kk += size-- ;
}
}
}
return(kk) ;
} break ;
case SUBMTX_BLOCK_DIAGONAL_HERM : {
double sign ;
double *entries ;
int ii, ipivot, jrow, kk, m, ncol, nent, size ;
int *pivotsizes ;
if ( irow < 0 || jcol < 0 ) {
return(-1) ;
}
if ( irow > jcol ) {
ii = irow ;
irow = jcol ;
jcol = ii ;
sign = -1.0 ;
} else {
sign = 1.0 ;
}
SubMtx_blockDiagonalInfo(mtx, &ncol, &nent, &pivotsizes, &entries) ;
if ( irow >= ncol || jcol >= ncol ) {
return(-1) ;
}
for ( jrow = ipivot = kk = 0 ; jrow <= irow ; ipivot++ ) {
size = m = pivotsizes[ipivot] ;
for ( ii = 0 ; ii < m ; ii++, jrow++ ) {
if ( jrow == irow ) {
if ( jcol - irow > m - ii - 1 ) {
return(-1) ;
} else {
kk += jcol - irow ;
*pValue = entries[kk] ;
return(kk) ;
}
} else {
kk += size-- ;
}
}
}
return(kk) ;
} break ;
default :
fprintf(stderr,
"\n fatal error in SubMtx_realEntry(%p,%d,%d,%p)"
"\n bad mode %d", mtx, irow, jcol, pValue, mtx->mode) ;
exit(-1) ;
break ;
}
return(-1) ; }
/*
----------------------------------------------------------------
purpose -- for each U_{J,bnd{J}} matrix, remove from hash table,
split into their U_{J,K} submatrices and insert
into the hash table.
created -- 98may04, cca
----------------------------------------------------------------
*/
void
FrontMtx_splitUpperMatrices (
FrontMtx *frontmtx,
int msglvl,
FILE *msgFile
) {
SubMtx *mtxUJ, *mtxUJJ, *mtxUJK ;
SubMtxManager *manager ;
double *entUJ, *entUJK ;
int count, first, ii, inc1, inc2, jcol, jj, J, K, nbytes,
ncolJ, ncolUJ, ncolUJK, nentUJ, nentUJK, neqns, nfront,
nJ, nrowUJ, nrowUJK, offset, v ;
int *colindJ, *colindUJ, *colindUJK, *colmap, *indicesUJ,
*indicesUJK, *locmap, *rowindUJ, *rowindUJK, *sizesUJ,
*sizesUJK ;
I2Ohash *upperhash ;
/*
---------------
check the input
---------------
*/
if ( frontmtx == NULL || (msglvl > 0 && msgFile == NULL) ) {
fprintf(stderr,
"\n fatal error in FrontMtx_splitUpperMatrices(%p,%d,%p)"
"\n bad input\n", frontmtx, msglvl, msgFile) ;
spoolesFatal();
}
nfront = FrontMtx_nfront(frontmtx) ;
neqns = FrontMtx_neqns(frontmtx) ;
upperhash = frontmtx->upperhash ;
manager = frontmtx->manager ;
/*
-----------------------------------
construct the column and local maps
-----------------------------------
*/
colmap = IVinit(neqns, -1) ;
locmap = IVinit(neqns, -1) ;
for ( J = 0 ; J < nfront ; J++ ) {
if ( (nJ = FrontMtx_frontSize(frontmtx, J)) > 0 ) {
FrontMtx_columnIndices(frontmtx, J, &ncolJ, &colindJ) ;
if ( ncolJ > 0 && colindJ != NULL ) {
for ( ii = 0 ; ii < nJ ; ii++ ) {
v = colindJ[ii] ;
colmap[v] = J ;
locmap[v] = ii ;
}
}
}
}
if ( msglvl > 2 ) {
fprintf(msgFile, "\n\n colmap[]") ;
IVfprintf(msgFile, neqns, colmap) ;
fprintf(msgFile, "\n\n locmap[]") ;
IVfprintf(msgFile, neqns, locmap) ;
fflush(msgFile) ;
}
/*
---------------------------------------------
move the U_{J,J} matrices into the hash table
---------------------------------------------
*/
for ( J = 0 ; J < nfront ; J++ ) {
if ( (mtxUJJ = FrontMtx_upperMtx(frontmtx, J, J)) != NULL ) {
I2Ohash_insert(frontmtx->upperhash, J, J, mtxUJJ) ;
}
}
/*
------------------------------------------------------------
now split the U_{J,bnd{J}} matrices into U_{J,K} matrices.
note: columns of U_{J,bnd{J}} are assumed to be in ascending
order with respect to the column ordering of the matrix.
------------------------------------------------------------
*/
for ( J = 0 ; J < nfront ; J++ ) {
mtxUJ = FrontMtx_upperMtx(frontmtx, J, nfront) ;
if ( msglvl > 2 ) {
fprintf(msgFile, "\n\n ### J = %d, mtxUJ = %p", J, mtxUJ) ;
fflush(msgFile) ;
}
if ( mtxUJ != NULL ) {
if ( msglvl > 2 ) {
SubMtx_writeForHumanEye(mtxUJ, msgFile) ;
fflush(msgFile) ;
}
SubMtx_columnIndices(mtxUJ, &ncolUJ, &colindUJ) ;
SubMtx_rowIndices(mtxUJ, &nrowUJ, &rowindUJ) ;
if ( msglvl > 2 ) {
fprintf(msgFile, "\n column indices for J") ;
IVfprintf(msgFile, ncolUJ, colindUJ) ;
fprintf(msgFile, "\n row indices for UJ") ;
IVfprintf(msgFile, nrowUJ, rowindUJ) ;
fflush(msgFile) ;
}
if ( (K = colmap[colindUJ[0]]) == colmap[colindUJ[ncolUJ-1]] ) {
if ( msglvl > 2 ) {
fprintf(msgFile, "\n front %d supports only %d", J, K) ;
fflush(msgFile) ;
}
/*
-------------------------------------------------
U_{J,bnd{J}} is one submatrix, bnd{J} \subseteq K
set row and column indices and change column id
-------------------------------------------------
*/
IVramp(nrowUJ, rowindUJ, 0, 1) ;
for ( ii = 0 ; ii < ncolUJ ; ii++ ) {
colindUJ[ii] = locmap[colindUJ[ii]] ;
}
SubMtx_setFields(mtxUJ, mtxUJ->type, mtxUJ->mode, J, K,
mtxUJ->nrow, mtxUJ->ncol, mtxUJ->nent) ;
/*
mtxUJ->colid = K ;
*/
if ( msglvl > 2 ) {
fprintf(msgFile, "\n\n ## inserting U(%d,%d) ", J, K) ;
SubMtx_writeForHumanEye(mtxUJ, msgFile) ;
fflush(msgFile) ;
}
I2Ohash_insert(upperhash, J, K, (void *) mtxUJ) ;
} else {
/*
-----------------------------------
split U_{J,bnd{J}} into submatrices
-----------------------------------
*/
nJ = FrontMtx_frontSize(frontmtx, J) ;
if ( SUBMTX_IS_DENSE_COLUMNS(mtxUJ) ) {
SubMtx_denseInfo(mtxUJ,
&nrowUJ, &ncolUJ, &inc1, &inc2, &entUJ) ;
} else if ( SUBMTX_IS_SPARSE_COLUMNS(mtxUJ) ) {
SubMtx_sparseColumnsInfo(mtxUJ, &ncolUJ, &nentUJ,
&sizesUJ, &indicesUJ, &entUJ) ;
offset = 0 ;
count = sizesUJ[0] ;
}
first = 0 ;
K = colmap[colindUJ[0]] ;
for ( jcol = 1 ; jcol <= ncolUJ ; jcol++ ) {
if ( msglvl > 2 ) {
fprintf(msgFile, "\n jcol = %d", jcol) ;
if ( jcol < ncolUJ ) {
fprintf(msgFile, ", colmap[%d] = %d",
colindUJ[jcol], colmap[colindUJ[jcol]]);
}
fflush(msgFile) ;
}
if ( jcol == ncolUJ || K != colmap[colindUJ[jcol]] ) {
ncolUJK = jcol - first ;
if ( SUBMTX_IS_DENSE_COLUMNS(mtxUJ) ) {
nentUJK = nJ*ncolUJK ;
} else if ( SUBMTX_IS_SPARSE_COLUMNS(mtxUJ) ) {
if ( count == 0 ) {
goto no_entries ;
}
nentUJK = count ;
}
nbytes = SubMtx_nbytesNeeded(mtxUJ->type, mtxUJ->mode,
nJ, ncolUJK, nentUJK) ;
if ( msglvl > 2 ) {
fprintf(msgFile,
"\n ncolUJK %d, nentUJK %d, nbytes %d",
ncolUJK, nentUJK, nbytes) ;
fflush(msgFile) ;
}
mtxUJK = SubMtxManager_newObjectOfSizeNbytes(manager,
nbytes) ;
SubMtx_init(mtxUJK, mtxUJ->type, mtxUJ->mode, J, K,
nJ, ncolUJK, nentUJK) ;
if ( SUBMTX_IS_DENSE_COLUMNS(mtxUJ) ) {
SubMtx_denseInfo(mtxUJK,
&nrowUJK, &ncolUJK, &inc1, &inc2, &entUJK) ;
if ( FRONTMTX_IS_REAL(frontmtx) ) {
DVcopy(nentUJK, entUJK, entUJ + first*nJ) ;
} else if ( FRONTMTX_IS_COMPLEX(frontmtx) ) {
DVcopy(2*nentUJK, entUJK, entUJ + 2*first*nJ) ;
}
} else if ( SUBMTX_IS_SPARSE_COLUMNS(mtxUJ) ) {
SubMtx_sparseColumnsInfo(mtxUJK, &ncolUJK, &nentUJK,
&sizesUJK, &indicesUJK, &entUJK) ;
IVcopy(ncolUJK, sizesUJK, sizesUJ + first) ;
IVcopy(nentUJK, indicesUJK, indicesUJ + offset) ;
if ( FRONTMTX_IS_REAL(frontmtx) ) {
DVcopy(nentUJK, entUJK, entUJ + offset) ;
} else if ( FRONTMTX_IS_COMPLEX(frontmtx) ) {
DVcopy(2*nentUJK, entUJK, entUJ + 2*offset) ;
}
count = 0 ;
offset += nentUJK ;
}
/*
-------------------------------------
initialize the row and column indices
-------------------------------------
*/
if ( msglvl > 2 ) {
fprintf(msgFile, "\n setting row and column indices");
fflush(msgFile) ;
}
SubMtx_rowIndices(mtxUJK, &nrowUJK, &rowindUJK) ;
IVramp(nJ, rowindUJK, 0, 1) ;
SubMtx_columnIndices(mtxUJK, &ncolUJK, &colindUJK) ;
for ( ii = 0, jj = first ; ii < ncolUJK ; ii++, jj++ ) {
colindUJK[ii] = locmap[colindUJ[jj]] ;
}
/*
----------------------------------
insert U_{J,K} into the hash table
----------------------------------
*/
if ( msglvl > 2 ) {
fprintf(msgFile,
"\n\n ## inserting U(%d,%d) ", J, K) ;
SubMtx_writeForHumanEye(mtxUJK, msgFile) ;
fflush(msgFile) ;
}
I2Ohash_insert(upperhash, J, K, (void *) mtxUJK) ;
/*
-----------------------------------
we jump to here if there were no
entries to be stored in the matrix.
-----------------------------------
*/
no_entries :
/*
----------------------------------------------------
reset first and K to new first location and front id
----------------------------------------------------
*/
first = jcol ;
if ( jcol < ncolUJ ) {
K = colmap[colindUJ[jcol]] ;
}
}
if ( jcol < ncolUJ && SUBMTX_IS_SPARSE_COLUMNS(mtxUJ) ) {
count += sizesUJ[jcol] ;
}
}
/*
--------------------------------------------
give U_{J,bnd{J}} back to the matrix manager
--------------------------------------------
*/
SubMtxManager_releaseObject(manager, mtxUJ) ;
}
}
}
/*
------------------------
free the working storage
------------------------
*/
IVfree(colmap) ;
IVfree(locmap) ;
return ; }
