int main(int argc, char *argv[])
{
dd_MatrixPtr M=NULL;
dd_rowrange i,m;
dd_ErrorType err=dd_NoError;
dd_rowindex newpos;
dd_rowset impl_linset,redset;
time_t starttime, endtime;
dd_DataFileType inputfile;
FILE *reading=NULL;
dd_set_global_constants(); /* First, this must be called. */
if (argc>1) strcpy(inputfile,argv[1]);
if (argc<=1 || !SetInputFile(&reading,argv[1])){
dd_WriteProgramDescription(stdout);
fprintf(stdout,"\ncddlib test program to check redundancy of an H/V-representation.\n");
dd_SetInputFile(&reading,inputfile, &err);
}
if (err==dd_NoError) {
M=dd_PolyFile2Matrix(reading, &err);
}
else {
fprintf(stderr,"Input file not found\n");
goto _L99;
}
if (err!=dd_NoError) goto _L99;
m=M->rowsize;
fprintf(stdout, "Canonicalize the matrix.\n");
time(&starttime);
dd_MatrixCanonicalize(&M, &impl_linset, &redset, &newpos, &err);
time(&endtime);
if (err!=dd_NoError) goto _L99;
fprintf(stdout, "Implicit linearity rows are:"); set_fwrite(stdout, impl_linset);
fprintf(stdout, "\nRedundant rows are:"); set_fwrite(stdout, redset);
fprintf(stdout, "\n");
fprintf(stdout, "Nonredundant representation:\n");
fprintf(stdout, "The new row positions are as follows (orig:new).\nEach redundant row has the new number 0.\nEach deleted duplicated row has a number nagative of the row that\nrepresents its equivalence class.\n");
for (i=1; i<=m; i++){
fprintf(stdout, " %ld:%ld",i, newpos[i]);
}
fprintf(stdout, "\n");
dd_WriteMatrix(stdout, M);
dd_WriteTimes(stdout,starttime,endtime);
set_free(redset);
set_free(impl_linset);
dd_FreeMatrix(M);
free(newpos);
_L99:;
if (err!=dd_NoError) dd_WriteErrorMessages(stderr,err);
return 0;
}
int main(int argc, char *argv[])
{
dd_PolyhedraPtr poly;
dd_LPPtr lp;
dd_MatrixPtr M,A;
dd_ErrorType err=dd_NoError;
dd_DataFileType inputfile,outputfile;
FILE *reading=NULL, *writing;
dd_set_global_constants(); /* First, this must be called. */
if (argc>1) strcpy(inputfile,argv[1]);
if (argc<=1 || !SetInputFile(&reading,argv[1])){
dd_WriteProgramDescription(stdout);
dd_SetInputFile(&reading,inputfile, &err);
}
if (err==dd_NoError) {
M=dd_PolyFile2Matrix(reading, &err);
}
else {
printf("Input file not found\n");
goto _L99;
}
if (err!=dd_NoError) goto _L99;
if (M->objective==dd_LPnone){ /* do representation conversion */
poly=dd_DDMatrix2Poly2(M, dd_LexMin, &err);
/* equivalent to poly=dd_DDMatrix2Poly2(M, &err) when the second argument is set to dd_LexMin. */
if (err!=dd_NoError) goto _L99;
dd_SetWriteFileName(inputfile, outputfile, 'o', poly->representation);
SetWriteFile(&writing, outputfile);
dd_WriteProgramDescription(writing);
dd_WriteRunningMode(writing, poly);
switch (poly->representation) {
case dd_Inequality:
fprintf(writing, "ext_file: Generators\n");
A=dd_CopyGenerators(poly);
dd_WriteMatrix(writing,A);
dd_FreeMatrix(A);
break;
case dd_Generator:
fprintf(writing, "ine_file: Inequalities\n");
A=dd_CopyInequalities(poly);
dd_WriteMatrix(writing,A);
dd_FreeMatrix(A);
break;
default:
break;
}
dd_WriteDDTimes(writing,poly);
fclose(writing);
dd_SetWriteFileName(inputfile, outputfile, 'a', poly->representation);
SetWriteFile(&writing, outputfile);
dd_WriteAdjacency(writing,poly);
fclose(writing);
dd_SetWriteFileName(inputfile, outputfile, 'j', poly->representation);
SetWriteFile(&writing, outputfile);
dd_WriteInputAdjacency(writing,poly);
fclose(writing);
dd_SetWriteFileName(inputfile, outputfile, 'i', poly->representation);
SetWriteFile(&writing, outputfile);
dd_WriteIncidence(writing,poly);
fclose(writing);
dd_SetWriteFileName(inputfile, outputfile, 'n', poly->representation);
SetWriteFile(&writing, outputfile);
dd_WriteInputIncidence(writing,poly);
fclose(writing);
dd_FreeMatrix(M);
dd_FreePolyhedra(poly);
} else { /* solve the LP */
lp=dd_Matrix2LP(M, &err); if (err!=dd_NoError) goto _L99;
dd_LPSolve(lp,dd_DualSimplex,&err); if (err!=dd_NoError) goto _L99;
dd_SetWriteFileName(inputfile, outputfile, 's', M->representation);
SetWriteFile(&writing, outputfile);
dd_WriteLPResult(writing, lp, err);
fclose(writing);
dd_FreeMatrix(M);
dd_FreeLPData(lp);
}
_L99:
if (err!=dd_NoError) dd_WriteErrorMessages(stdout,err);
return 0;
}
dd_MatrixPtr dd_BlockElimination(dd_MatrixPtr M, dd_colset delset, dd_ErrorType *error)
/* Eliminate the variables (columns) delset by
the Block Elimination with dd_DoubleDescription algorithm.
Given (where y is to be eliminated):
c1 + A1 x + B1 y >= 0
c2 + A2 x + B2 y = 0
1. First construct the dual system: z1^T B1 + z2^T B2 = 0, z1 >= 0.
2. Compute the generators of the dual.
3. Then take the linear combination of the original system with each generator.
4. Remove redundant inequalies.
*/
{
dd_MatrixPtr Mdual=NULL, Mproj=NULL, Gdual=NULL;
dd_rowrange i,h,m,mproj,mdual,linsize;
dd_colrange j,k,d,dproj,ddual,delsize;
dd_colindex delindex;
mytype temp,prod;
dd_PolyhedraPtr dualpoly;
dd_ErrorType err=dd_NoError;
dd_boolean localdebug=dd_FALSE;
*error=dd_NoError;
m= M->rowsize;
d= M->colsize;
delindex=(long*)calloc(d+1,sizeof(long));
dd_init(temp);
dd_init(prod);
k=0; delsize=0;
for (j=1; j<=d; j++){
if (set_member(j, delset)){
k++; delsize++;
delindex[k]=j; /* stores the kth deletion column index */
}
}
if (localdebug) dd_WriteMatrix(stdout, M);
linsize=set_card(M->linset);
ddual=m+1;
mdual=delsize + m - linsize; /* #equalitions + dimension of z1 */
/* setup the dual matrix */
Mdual=dd_CreateMatrix(mdual, ddual);
Mdual->representation=dd_Inequality;
for (i = 1; i <= delsize; i++){
set_addelem(Mdual->linset,i); /* equality */
for (j = 1; j <= m; j++) {
dd_set(Mdual->matrix[i-1][j], M->matrix[j-1][delindex[i]-1]);
}
}
k=0;
for (i = 1; i <= m; i++){
if (!set_member(i, M->linset)){
/* set nonnegativity for the dual variable associated with
each non-linearity inequality. */
k++;
dd_set(Mdual->matrix[delsize+k-1][i], dd_one);
}
}
/* 2. Compute the generators of the dual system. */
dualpoly=dd_DDMatrix2Poly(Mdual, &err);
Gdual=dd_CopyGenerators(dualpoly);
/* 3. Take the linear combination of the original system with each generator. */
dproj=d-delsize;
mproj=Gdual->rowsize;
Mproj=dd_CreateMatrix(mproj, dproj);
Mproj->representation=dd_Inequality;
set_copy(Mproj->linset, Gdual->linset);
for (i=1; i<=mproj; i++){
k=0;
for (j=1; j<=d; j++){
if (!set_member(j, delset)){
k++; /* new index of the variable x_j */
dd_set(prod, dd_purezero);
for (h = 1; h <= m; h++){
dd_mul(temp,M->matrix[h-1][j-1],Gdual->matrix[i-1][h]);
dd_add(prod,prod,temp);
}
dd_set(Mproj->matrix[i-1][k-1],prod);
}
}
}
if (localdebug) printf("Size of the projection system: %ld x %ld\n", mproj, dproj);
dd_FreePolyhedra(dualpoly);
free(delindex);
dd_clear(temp);
dd_clear(prod);
dd_FreeMatrix(Mdual);
dd_FreeMatrix(Gdual);
return Mproj;
}
dd_MatrixPtr dd_FourierElimination(dd_MatrixPtr M,dd_ErrorType *error)
/* Eliminate the last variable (column) from the given H-matrix using
the standard Fourier Elimination.
*/
{
dd_MatrixPtr Mnew=NULL;
dd_rowrange i,inew,ip,in,iz,m,mpos=0,mneg=0,mzero=0,mnew;
dd_colrange j,d,dnew;
dd_rowindex posrowindex, negrowindex,zerorowindex;
mytype temp1,temp2;
dd_boolean localdebug=dd_FALSE;
*error=dd_NoError;
m= M->rowsize;
d= M->colsize;
if (d<=1){
*error=dd_ColIndexOutOfRange;
if (localdebug) {
printf("The number of column is too small: %ld for Fourier's Elimination.\n",d);
}
goto _L99;
}
if (M->representation==dd_Generator){
*error=dd_NotAvailForV;
if (localdebug) {
printf("Fourier's Elimination cannot be applied to a V-polyhedron.\n");
}
goto _L99;
}
if (set_card(M->linset)>0){
*error=dd_CannotHandleLinearity;
if (localdebug) {
printf("The Fourier Elimination function does not handle equality in this version.\n");
}
goto _L99;
}
/* Create temporary spaces to be removed at the end of this function */
posrowindex=(long*)calloc(m+1,sizeof(long));
negrowindex=(long*)calloc(m+1,sizeof(long));
zerorowindex=(long*)calloc(m+1,sizeof(long));
dd_init(temp1);
dd_init(temp2);
for (i = 1; i <= m; i++) {
if (dd_Positive(M->matrix[i-1][d-1])){
mpos++;
posrowindex[mpos]=i;
} else if (dd_Negative(M->matrix[i-1][d-1])) {
mneg++;
negrowindex[mneg]=i;
} else {
mzero++;
zerorowindex[mzero]=i;
}
} /*of i*/
if (localdebug) {
dd_WriteMatrix(stdout, M);
printf("No of (+ - 0) rows = (%ld, %ld, %ld)\n", mpos,mneg, mzero);
}
/* The present code generates so many redundant inequalities and thus
is quite useless, except for very small examples
*/
mnew=mzero+mpos*mneg; /* the total number of rows after elimination */
dnew=d-1;
Mnew=dd_CreateMatrix(mnew, dnew);
dd_CopyArow(Mnew->rowvec, M->rowvec, dnew);
/* set_copy(Mnew->linset,M->linset); */
Mnew->numbtype=M->numbtype;
Mnew->representation=M->representation;
Mnew->objective=M->objective;
/* Copy the inequalities independent of x_d to the top of the new matrix. */
for (iz = 1; iz <= mzero; iz++){
for (j = 1; j <= dnew; j++) {
dd_set(Mnew->matrix[iz-1][j-1], M->matrix[zerorowindex[iz]-1][j-1]);
}
}
/* Create the new inequalities by combining x_d positive and negative ones. */
inew=mzero; /* the index of the last x_d zero inequality */
for (ip = 1; ip <= mpos; ip++){
for (in = 1; in <= mneg; in++){
inew++;
dd_neg(temp1, M->matrix[negrowindex[in]-1][d-1]);
for (j = 1; j <= dnew; j++) {
dd_LinearComb(temp2,M->matrix[posrowindex[ip]-1][j-1],temp1,\
M->matrix[negrowindex[in]-1][j-1],\
M->matrix[posrowindex[ip]-1][d-1]);
dd_set(Mnew->matrix[inew-1][j-1],temp2);
}
dd_Normalize(dnew,Mnew->matrix[inew-1]);
}
}
free(posrowindex);
free(negrowindex);
free(zerorowindex);
dd_clear(temp1);
dd_clear(temp2);
_L99:
return Mnew;
}
int main(int argc, char *argv[])
{
dd_MatrixPtr M1=NULL,M2=NULL,M2row=NULL,M1plus=NULL;
dd_colrange d1;
dd_rowrange i,m1,m2,m1plus;
dd_ErrorType err=dd_NoError,err1=dd_NoError,err2=dd_NoError;
dd_rowset delset,rowset2;
dd_Arow cvec; /* certificate */
time_t starttime, endtime;
dd_DataFileType inputfile1,inputfile2;
FILE *reading1=NULL,*reading2=NULL;
dd_set_global_constants(); /* First, this must be called. */
dd_WriteProgramDescription(stdout);
fprintf(stdout,"\ncddlib test program to check redundancy of additional data.\n");
if (argc>2){
strcpy(inputfile1,argv[1]);
strcpy(inputfile2,argv[2]);
}
/*
if (argc<=2){
fprintf(stdout,"\nUsage:\n redexter file1 file2\n");
goto _L99;
}
*/
if (!SetInputFile(&reading1,argv[1])){
fprintf(stdout,"\nSpecify file1.\n");
dd_SetInputFile(&reading1,inputfile1, &err1);
}
if (!SetInputFile(&reading2,argv[2])){
fprintf(stdout,"\nSpecify the secondary file.\n");
dd_SetInputFile(&reading2,inputfile2, &err2);
}
if ((err1==dd_NoError) && (err2==dd_NoError)) {
M1=dd_PolyFile2Matrix(reading1, &err1);
M2=dd_PolyFile2Matrix(reading2, &err2);
}
else {
fprintf(stderr,"Input file(s) not found\n");
goto _L99;
}
if ((err1!=dd_NoError) || (err2!=dd_NoError)) goto _L99;
m1=M1->rowsize;
m2=M2->rowsize;
set_initialize(&delset,m2);
m1plus=m1+1;
if (M1->representation==dd_Generator){
d1=(M1->colsize)+1;
} else {
d1=M1->colsize;
}
dd_InitializeArow(d1,&cvec);
fprintf(stdout, "\nThe first matrix\n");
dd_WriteMatrix(stdout, M1);
fprintf(stdout, "\nThe second matrix\n");
dd_WriteMatrix(stdout, M2);
printf("\nChecking whether each row of the second matrix is redundant w.r.t. the first.\n");
time(&starttime);
for (i=1; i<=m2; i++){
set_initialize(&rowset2,m2);
set_addelem(rowset2, i);
set_compl(delset, rowset2);
M2row=dd_MatrixSubmatrix(M2, delset);
M1plus=dd_MatrixAppend(M1,M2row);
if (dd_Redundant(M1plus, m1plus, cvec, &err)) {
printf("%ld-th row: redundant\n", i);
} else {
printf("%ld-th row: non-redundant\n A certificate:", i);
dd_WriteArow(stdout, cvec, d1);
}
dd_FreeMatrix(M1plus);
dd_FreeMatrix(M2row);
set_free(rowset2);
}
time(&endtime);
dd_WriteTimes(stdout,starttime,endtime);
set_free(delset);
dd_FreeMatrix(M1);
dd_FreeMatrix(M2);
_L99:;
if (err1!=dd_NoError) dd_WriteErrorMessages(stderr,err1);
if (err2!=dd_NoError) dd_WriteErrorMessages(stderr,err2);
return 0;
}
int main(int argc, char *argv[])
{
dd_MatrixPtr M=NULL,M1=NULL,M2=NULL;
dd_colrange j,s,d;
dd_ErrorType err=dd_NoError;
dd_rowset redset,impl_linset;
dd_rowindex newpos;
mytype val;
dd_DataFileType inputfile;
FILE *reading=NULL;
dd_set_global_constants(); /* First, this must be called. */
dd_init(val);
if (argc>1) strcpy(inputfile,argv[1]);
if (argc<=1 || !SetInputFile(&reading,argv[1])){
dd_WriteProgramDescription(stdout);
fprintf(stdout,"\ncddlib test program to apply Fourier's Elimination to an H-polyhedron.\n");
dd_SetInputFile(&reading,inputfile, &err);
}
if (err==dd_NoError) {
M=dd_PolyFile2Matrix(reading, &err);
}
else {
fprintf(stderr,"Input file not found\n");
goto _L99;
}
if (err!=dd_NoError) goto _L99;
d=M->colsize;
M2=dd_CopyMatrix(M);
printf("How many variables to elminate? (max %ld): ",d-1);
scanf("%ld",&s);
if (s>0 && s < d){
for (j=1; j<=s; j++){
M1=dd_FourierElimination(M2, &err);
printf("\nRemove the variable %ld. The resulting redundant system.\n",d-j);
dd_WriteMatrix(stdout, M1);
dd_MatrixCanonicalize(&M1, &impl_linset, &redset, &newpos, &err);
if (err!=dd_NoError) goto _L99;
fprintf(stdout, "\nRedundant rows: ");
set_fwrite(stdout, redset);
dd_FreeMatrix(M2);
M2=M1;
set_free(redset);
set_free(impl_linset);
free(newpos);
}
printf("\nNonredundant representation:\n");
dd_WriteMatrix(stdout, M1);
} else {
printf("Value out of range\n");
}
dd_FreeMatrix(M);
dd_FreeMatrix(M1);
dd_clear(val);
_L99:;
/* if (err!=dd_NoError) dd_WriteErrorMessages(stderr,err); */
dd_free_global_constants(); /* At the end, this should be called. */
return 0;
}