Skip to content

Commit

Permalink
Add parameter to select order algorithm.
Browse files Browse the repository at this point in the history
  • Loading branch information
Raniere Silva committed Feb 27, 2013
1 parent e1377fd commit 3c382a8
Show file tree
Hide file tree
Showing 5 changed files with 146 additions and 65 deletions.
8 changes: 8 additions & 0 deletions DOC/specifications_file.rst
View file
Original file line number Diff line number Diff line change
Expand Up @@ -115,6 +115,14 @@ descriptions below, we assume that PCx is involed with the comand ::

**Default**: 10^{-8}.

``OrderAlg {value}``
Specify the ordering algorithm to be use. The list of algorithm avaliable are:

0. The natural order are used.
1. The multiple minimum degree ordering.

**Default**: 1.

``preprocess {yes}/{no}``
Synonymous with ``presolver``.

Expand Down
162 changes: 101 additions & 61 deletions SRC/Ng-Peyton.c
View file
Original file line number Diff line number Diff line change
Expand Up @@ -142,13 +142,27 @@ FreeNgPeytonType(NgPeyton)
Free((char *) NgPeyton);
}

/*****************************************************************/
/* Ordering auxiliar functions */
/*****************************************************************/

int ordinc(int dimension, int *InvPerm, int *Perm){
int i;
for (i = 1; i <= dimension; i++) {
InvPerm[i - 1] = i;
Perm[i - 1] = i;
}
return 0;
}

/*****************************************************************/
/* Ordering and symbolic factorization routine */
/*****************************************************************/

int
Order(Factor)
Order(Factor, OrderAlg)
FactorType *Factor;
int OrderAlg;
{
int WorkSize, *Work, dimension, col, entry, flag;
int *ColumnCount, offset, row, NumCols, nonzeros;
Expand Down Expand Up @@ -183,31 +197,34 @@ Order(Factor)
offset = 0;
for (col = 0; col < NumCols; col++)
{
if (Factor->AAT->pEndRow[col] -
Factor->AAT->pBeginRow[col] + 1 == 0)
{
/* empty column in AAT */
printf("There is an empty column in the matrix A A^T.\n");
printf("This will cause an error in the Ng-Peyton matrix");
printf(" ordering\n");
printf("routine. You can avoid this problem by selecting");
printf(" the\n");
printf("presolve option in the specifications file.\n");
return FACTORIZE_ERROR;
}
for (entry = Factor->AAT->pBeginRow[col] - 1;
entry <= Factor->AAT->pEndRow[col] - 1; entry++)
{
row = Factor->AAT->Row[entry];
if (row != col + 1)
TempRow[entry - offset] = Factor->AAT->Row[entry];
else
offset++;
}
if (Factor->AAT->pEndRow[col] -
Factor->AAT->pBeginRow[col] + 1 == 0)
{
/* empty column in AAT */
printf("There is an empty column in the matrix A A^T.\n");
printf("This will cause an error in the Ng-Peyton matrix");
printf(" ordering\n");
printf("routine. You can avoid this problem by selecting");
printf(" the\n");
printf("presolve option in the specifications file.\n");
return FACTORIZE_ERROR;
}
for (entry = Factor->AAT->pBeginRow[col] - 1;
entry <= Factor->AAT->pEndRow[col] - 1; entry++)
{
row = Factor->AAT->Row[entry];
if (row != col + 1)
TempRow[entry - offset] = Factor->AAT->Row[entry];
else
offset++;
}
}

/* Fill in pSuperNodeCols and SuperNodeRows (as temp space) since this data
* structure will be destroyed by ordmmd. */
* structure will be destroyed by ordmmd.
*
* (pSuperNodeCols, SuperNodeRows) - The Adjacency Structure.
* */

for (col = 0; col < NumCols + 1; col++)
NgPeyton->pSuperNodeCols[col] = TempBeginRow[col];
Expand All @@ -217,22 +234,44 @@ Order(Factor)
for (entry = 0; entry < nonzeros; entry++)
NgPeyton->SuperNodeRows[entry] = TempRow[entry];

/* call multiple minimum degree routine */

ordmmd(&dimension, NgPeyton->pSuperNodeCols,
NgPeyton->SuperNodeRows,
Factor->InvPerm, Factor->Perm,
&WorkSize, Work, &(NgPeyton->NumCompressedCols), &flag);

if (flag)
printf("ordmmd error flag = %d\n", flag);

if (flag == -1)
{
printf("Size of work array, %d, is larger than WorkSize\n", WorkSize);
printf("in Order().\n");
return FACTORIZE_ERROR;
}
/* Select and apply order algorithm. */

switch (OrderAlg) {
case 0:
flag = ordinc(dimension, Factor->InvPerm, Factor->Perm);

if (flag)
printf("ordinc error flag = %d\n", flag);

if (flag == -1)
{
printf("Size of work array, %d, is larger than WorkSize\n", WorkSize);
printf("in Order().\n");
return FACTORIZE_ERROR;
}
break;
case 1:
/* call multiple minimum degree routine */

ordmmd(&dimension, NgPeyton->pSuperNodeCols,
NgPeyton->SuperNodeRows,
Factor->InvPerm, Factor->Perm,
&WorkSize, Work, &(NgPeyton->NumCompressedCols), &flag);

if (flag)
printf("ordmmd error flag = %d\n", flag);

if (flag == -1)
{
printf("Size of work array, %d, is larger than WorkSize\n", WorkSize);
printf("in Order().\n");
return FACTORIZE_ERROR;
}
break;
case 2:
break;
}

/* Symbolic Factorization Initialization: Compute supernode partition and
* storage requirements */

Expand All @@ -241,21 +280,21 @@ Order(Factor)
ColumnCount = NewInt(dimension, "ColumnCount");

sfinit(&dimension, &nonzeros,
TempBeginRow, TempRow,
Factor->Perm, Factor->InvPerm, ColumnCount,
&(Factor->NonzerosL), &(NgPeyton->NumCompressedCols),
&(NgPeyton->NumSuperNodes), NgPeyton->mapColumnToSupernode,
NgPeyton->SuperPartitioning,
&WorkSize, Work, &flag);
TempBeginRow, TempRow,
Factor->Perm, Factor->InvPerm, ColumnCount,
&(Factor->NonzerosL), &(NgPeyton->NumCompressedCols),
&(NgPeyton->NumSuperNodes), NgPeyton->mapColumnToSupernode,
NgPeyton->SuperPartitioning,
&WorkSize, Work, &flag);

if (flag)
printf("sfinit error flag = %d\n", flag);

if (flag == -1)
{
printf("Size of Work array, %d, is larger than WorkSize\n", WorkSize);
printf("in Order().\n");
return FACTORIZE_ERROR;
printf("Size of Work array, %d, is larger than WorkSize\n", WorkSize);
printf("in Order().\n");
return FACTORIZE_ERROR;
}

printf("Cholesky factor will have density %8.5f\n",
Expand All @@ -268,40 +307,41 @@ Order(Factor)

NgPeyton->SuperNodeRows =
(int *) Realloc(NgPeyton->SuperNodeRows,
Factor->NonzerosL * sizeof(int), "SuperNodeRows");
Factor->NonzerosL * sizeof(int), "SuperNodeRows");

/* Perform supernodal symbolic factorization */

WorkSize = NgPeyton->NumSuperNodes + 2 * dimension + 1;
Work = (int *) Realloc(Work, WorkSize * sizeof(int), "Work");

symfct(&dimension, &nonzeros,
TempBeginRow, TempRow,
Factor->Perm, Factor->InvPerm,
ColumnCount,
&(NgPeyton->NumSuperNodes), NgPeyton->SuperPartitioning,
NgPeyton->mapColumnToSupernode, &(NgPeyton->NumCompressedCols),
NgPeyton->pSuperNodeCols, NgPeyton->SuperNodeRows,
NgPeyton->pBeginRowL, &WorkSize, Work, &flag);
TempBeginRow, TempRow,
Factor->Perm, Factor->InvPerm,
ColumnCount,
&(NgPeyton->NumSuperNodes), NgPeyton->SuperPartitioning,
NgPeyton->mapColumnToSupernode, &(NgPeyton->NumCompressedCols),
NgPeyton->pSuperNodeCols, NgPeyton->SuperNodeRows,
NgPeyton->pBeginRowL, &WorkSize, Work, &flag);

if (flag)
printf("symfct error flag = %d\n", flag);

if (flag == -1)
{
printf("Size of Work array, %d, is larger than WorkSize\n", WorkSize);
printf("in Order().\n");
return FACTORIZE_ERROR;
printf("Size of Work array, %d, is larger than WorkSize\n", WorkSize);
printf("in Order().\n");
return FACTORIZE_ERROR;
}
if (flag == -2)
{
printf("Inconsistency in the input to symfct in Order().\n");
return FACTORIZE_ERROR;
printf("Inconsistency in the input to symfct in Order().\n");
return FACTORIZE_ERROR;
}
Free((char *) ColumnCount);
Free((char *) Work);
Free((char *) TempBeginRow);
Free((char *) TempRow);

return 0;
}

Expand Down
2 changes: 1 addition & 1 deletion SRC/PCx.c
View file
Original file line number Diff line number Diff line change
Expand Up @@ -207,7 +207,7 @@ PCx(LP, Solution, Inputs)
Free((char*) Factor->maskDense);
Factor->maskDense = maskDense;

status = Order(Factor);
status = Order(Factor, Inputs->OrderAlg);
if (status != 0)
{
printf("Error return from Order() routine.\n");
Expand Down
3 changes: 3 additions & 0 deletions SRC/main.h
View file
Original file line number Diff line number Diff line change
Expand Up @@ -228,6 +228,9 @@ typedef struct Parameters {
int UnrollingLevel; /* Unrolling level for Ng-Peyton routines */

double CenterExponent; /* Exponent for computing centering parameter */

int OrderAlg; /* Ordering algorithm to use. 0 = dont't use any
algorithm, 1 = multiple minimum degree (default). */
} Parameters;


Expand Down
36 changes: 33 additions & 3 deletions SRC/parameters.c
View file
Original file line number Diff line number Diff line change
Expand Up @@ -110,6 +110,8 @@ NewParameters()
ptr->UnrollingLevel = 4;

ptr->CenterExponent = 3.0;

ptr->OrderAlg = 1;

return ptr;
}
Expand Down Expand Up @@ -221,7 +223,7 @@ ParseSpecsFile(parameters, infile)
char *basename, *suffix;
int len;

int NumKeys = 23;
int NumKeys = 24;
static char *KeyWord[] = {"max", "min", "solution",
"objectivename", "rhsname", "rangename",
"boundname", "history", "presolve",
Expand All @@ -230,7 +232,7 @@ ParseSpecsFile(parameters, infile)
"unrollinglevel", "iterationlimit",
"centerexp", "refinement", "stepfactor",
"scaling", "hocorrections",
"maxcorrections"};
"maxcorrections", "orderalg"};

/* Try finding specs file under some different names. Give priority to
* filenames that include this particular problem name */
Expand Down Expand Up @@ -488,7 +490,7 @@ ParseSpecsFile(parameters, infile)
parameters->IterationLimit);
}
break;
case 17:
case 17: /* centerexponent */
if (second == NULL)
{
printf(" Missing numerical value for CenterExp");
Expand Down Expand Up @@ -581,6 +583,34 @@ ParseSpecsFile(parameters, infile)
parameters->MaxCorrections);
}
break;
case 23: /* Order Algorithm */
if (second == NULL)
{
parameters->OrderAlg = 1;
printf(" Order Algorithm to be");
printf(" multiple minimum degree.\n");
}
else
{
switch (atoi(second)) {
case 0:
parameters->OrderAlg = 0;
printf(" Order Algorithm to be disable\n");
break;
case 2:
parameters->OrderAlg = 2;
printf(" Order Algorithm to be");
printf(" Reverse Cuthill-McKee.\n");
break;
case 1:
default:
parameters->OrderAlg = 1;
printf(" Order Algorithm to be");
printf(" multiple minimum degree.\n");
break;
}
}
break;
} /* end switch */
do
{
Expand Down

0 comments on commit 3c382a8

Please sign in to comment.