void
reduce_v(int nlhs, mxArray * plhs[], int nrhs, const mxArray * prhs[])
{
dd_ErrorType err;
dd_MatrixPtr V,V1;
dd_rowset red;
if (nrhs == 1 && nlhs >= 1 && nlhs <= 2 && mxIsStruct(prhs[0])) {
dd_set_global_constants(); /* First, this must be called. */
V = FT_get_V_MatrixPtr(prhs[0]);
red = dd_RedundantRows(V, &err); /* find redundant rows */
if (err == dd_NoError) {
/* remove the red rows */
V1 = dd_MatrixSubmatrix(V, red);
plhs[0] = FT_set_V_MatrixPtr(V1);
dd_FreeMatrix(V1);
if (nlhs == 2) {
plhs[1] = FT_set_Set(red);
}
} else {
dd_WriteErrorMessages(stdout,err);
mexErrMsgTxt("CDD returned an error, see above(!) for details");
}
dd_FreeMatrix(V);
set_free(red);
return;
} else {
mexErrMsgTxt("reduce_v expects an V input struct and produces a V output struct and an optional vector of removed vertices");
}
}
void
adjacency(int nlhs, mxArray * plhs[], int nrhs, const mxArray * prhs[])
{
dd_PolyhedraPtr P;
dd_ErrorType err;
dd_MatrixPtr V;
dd_SetFamilyPtr A;
if (mxIsStruct(prhs[0])) {
V = FT_get_V_MatrixPtr(prhs[0]);
dd_set_global_constants(); /* First, this must be called. */
P = dd_DDMatrix2Poly(V, &err); /* compute the second representation */
if (err == dd_NoError) {
A = dd_CopyInputAdjacency(P);
plhs[0] = FT_set_SetFamilyPtr(A);
dd_FreeSetFamily(A);
} else {
dd_WriteErrorMessages(stdout,err);
mexErrMsgTxt("CDD returned an error, see above(!) for details");
}
dd_FreeMatrix(V);
dd_FreePolyhedra(P);
}
}
void
solve_lp(int nlhs, mxArray * plhs[], int nrhs, const mxArray * prhs[])
{
/* The original LP data m x n matrix
= | b -A |
| c0 c^T |,
where the LP to be solved is to
maximize c^T x + c0
subj. to
A x <= b.
*/
dd_ErrorType error=dd_NoError;
dd_LPSolverType solver=dd_CrissCross; /* either DualSimplex or CrissCross */
dd_LPPtr lp; /* pointer to LP data structure that is not visible by user. */
dd_set_global_constants(); /* First, this must be called once to use cddlib. */
/* Input an LP using the cdd library */
lp = MB_get_LP_MatrixPtr(prhs[0]);
/* Solve the LP by cdd LP solver. */
dd_LPSolve(lp,solver,&error);
if (error!=dd_NoError) dd_WriteErrorMessages(stdout, error);
/* Take the solution. */
plhs[0] = MB_set_LPsol_MatrixPtr(lp);
/* Free allocated spaces. */
dd_FreeLPData(lp);
}
void
adj_extreme(int nlhs, mxArray * plhs[], int nrhs, const mxArray * prhs[])
{
dd_PolyhedraPtr P;
dd_ErrorType err;
dd_MatrixPtr H,V;
dd_SetFamilyPtr A;
if (nrhs == 1 && nlhs == 2 && mxIsStruct(prhs[0])) {
dd_set_global_constants(); /* First, this must be called. */
H = FT_get_H_MatrixPtr(prhs[0]);
P = dd_DDMatrix2Poly(H, &err); /* compute the second representation */
if (err == dd_NoError) {
V = dd_CopyGenerators(P);
A = dd_CopyAdjacency(P);
plhs[0] = FT_set_V_MatrixPtr(V);
plhs[1] = FT_set_SetFamilyPtr(A);
dd_FreeMatrix(V);
dd_FreeSetFamily(A);
} else {
dd_WriteErrorMessages(stdout,err);
mexErrMsgTxt("CDD returned an error, see above(!) for details");
}
dd_FreeMatrix(H);
dd_FreePolyhedra(P);
return;
} else {
mexErrMsgTxt("adj_extreme expects an H input struct and produces a V output struct and the adjacency struct");
}
}
void
hull(int nlhs, mxArray * plhs[], int nrhs, const mxArray * prhs[])
{
dd_PolyhedraPtr P;
dd_ErrorType err;
dd_MatrixPtr H,V;
if (nrhs == 1 && nlhs == 1 && mxIsStruct(prhs[0])) {
V = FT_get_V_MatrixPtr(prhs[0]);
dd_set_global_constants(); /* First, this must be called. */
P = dd_DDMatrix2Poly(V, &err); /* compute the second representation */
if (err == dd_NoError) {
H = dd_CopyInequalities(P);
plhs[0] = FT_set_H_MatrixPtr(H);
dd_FreeMatrix(H);
} else {
dd_WriteErrorMessages(stdout,err);
mexErrMsgTxt("CDD returned an error, see above(!) for details");
}
dd_FreeMatrix(V);
dd_FreePolyhedra(P);
return;
} else {
mexErrMsgTxt("hull expects a V input struct and produces an H output struct");
}
}
void implicit_linear(int nlhs, mxArray * plhs[], int nrhs, const mxArray * prhs[])
{
dd_MatrixPtr H;
dd_rowset rows;
dd_ErrorType err;
if (nrhs == 1 && nlhs <= 2 && mxIsStruct(prhs[0])) {
H = FT_get_H_MatrixPtr(prhs[0]);
dd_set_global_constants(); /* First, this must be called. */
rows = dd_ImplicitLinearityRows(H, &err);
if (err == dd_NoError) {
int total, element, i;
double* pr;
total = set_card(rows);
plhs[0] = mxCreateDoubleMatrix(total, 1, mxREAL);
pr = mxGetPr(plhs[0]);
for (i=1, element=0; i<=rows[0]; i++){
if (set_member(i, rows)) {
pr[element++] = (double)i;
}
}
} else {
dd_WriteErrorMessages(stdout,err);
mexErrMsgTxt("CDD returned an error, see above(!) for details");
}
dd_FreeMatrix(H);
set_free(rows);
return;
} else {
mexErrMsgTxt("hull expects a V input struct and produces an H output struct");
}
}
void
file_ine(int nlhs, mxArray * plhs[], int nrhs, const mxArray * prhs[])
/* Ine file input, V output, similar to extreme */
{
dd_PolyhedraPtr poly;
dd_MatrixPtr M;
dd_ErrorType err;
char *inputfile;
FILE *reading=NULL;
dd_MatrixPtr A, G;
dd_SetFamilyPtr GI,GA;
int buflen, status;
dd_set_global_constants(); /* First, this must be called. */
if (nrhs == 1 && nlhs <=2 && mxIsChar(prhs[0])) {
/* dd_SetInputFile(&reading,inputfile, &err); */
buflen = mxGetN(prhs[0]) + 1;
inputfile= mxCalloc(buflen, sizeof(char));
status = mxGetString(prhs[0], inputfile, buflen);
if ( (reading = fopen(inputfile,"r") )== NULL) {
mxErrMsgTxt("Input file not found\n");
return;
}
printf(" Input file opened. \n");
M=dd_PolyFile2Matrix(reading, &err);
if (err==dd_NoError) {
poly=dd_DDMatrix2Poly(M, &err); /* compute the second representation */
if (err!=dd_NoError) {
dd_WriteErrorMessages(stdout,err);
mxErrMsgTxt("CDD internal error\n");
return;
}
A=dd_CopyInequalities(poly);
G=dd_CopyGenerators(poly);
GI=dd_CopyInputIncidence(poly);
GA=dd_CopyAdjacency(poly);
plhs[0] = FT_set_V_MatrixPtr(G);
plhs[1] = ZH_set_Vlist(GI,GA);
dd_FreePolyhedra(poly);
dd_FreeMatrix(M);
return;
}
}
else {
mexErrMsgTxt("file-ine expects an file input");
}
return;
}
void
find_interior_DS(int nlhs, mxArray * plhs[], int nrhs, const mxArray * prhs[])
{
/* uses Dual Simplex method */
/* We would like to find an iterior point
for a polyhedron in H representation
A x <= b.
*/
dd_ErrorType error=dd_NoError;
dd_LPSolverType solver=dd_DualSimplex;
dd_LPPtr lp, lp1; /* pointer to LP data structure that is not visible by user. */
dd_MatrixPtr A;
int j;
dd_set_global_constants(); /* First, this must be called once to use cddlib. */
/* Input an LP using the cdd library */
/* lp = MB_get_LP_MatrixPtr(prhs[0]); */
if (A=FT_get_H_MatrixPtr(prhs[0])) {
/* set objective */
A->objective = dd_LPmin;
for (j = 0; j < A->colsize; j++)
dd_set_d(A->rowvec[j],0.0);
lp=dd_Matrix2LP(A, &error);
dd_FreeMatrix(A);
}else{
mexErrMsgTxt("Error in the setting of LP matrix.");
}
lp1=dd_MakeLPforInteriorFinding(lp);
dd_LPSolve(lp1,solver,&error);
if (error!=dd_NoError) dd_WriteErrorMessages(stdout, error);
/* Take the solution. */
plhs[0] = MB_set_LPsol_MatrixPtr(lp1);
/* Free allocated spaces. */
dd_FreeLPData(lp);
dd_FreeLPData(lp1);
}
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;
}
int main(int argc, char *argv[])
{
/* The original LP data m x n matrix
= | b -A |
| c0 c^T |,
where the LP to be solved is to
maximize c^T x + c0
subj. to
A x <= b.
*/
dd_ErrorType err=dd_NoError;
dd_LPSolverType solver=dd_DualSimplex;
/* either DualSimplex or CrissCross */
dd_LPPtr lp,lp1;
/* pointer to LP data structure that is not visible by user. */
dd_LPSolutionPtr lps,lps1;
/* pointer to LP solution data that is visible by user. */
dd_MatrixPtr M;
dd_colrange j;
dd_DataFileType inputfile;
dd_set_global_constants();
printf("\n--- Solving an LP with dd_LPSolve, and Finding an Interior Point ---\n");
/* Input an LP using the cdd library */
dd_SetInputFile(&reading,inputfile,&err);
if (err!=dd_NoError) goto _L99;
M=dd_PolyFile2Matrix(reading, &err);
if (err!=dd_NoError) goto _L99;
/* dd_WriteMatrix(stdout, M); */
lp=dd_Matrix2LP(M, &err);
if (err!=dd_NoError) goto _L99;
/* Solve the LP by cdd LP solver. */
printf("\n--- Running dd_LPSolve ---\n");
solver=dd_DualSimplex;
dd_LPSolve(lp, solver, &err); /* Solve the LP */
if (err!=dd_NoError) goto _L99;
/* Write the LP solutions by cdd LP reporter. */
/* dd_WriteLPResult(stdout, lp, err); */
/* dd_WriteLPResult(writing, lp, err); */
/* One can access the solutions by loading them. See dd_WriteLPResult
for outputing the results correctly. */
lps=dd_CopyLPSolution(lp);
if (lps->LPS==dd_Optimal){
printf("Optimal solution found:\n");
printf(" primal_solution\n");
for (j=1; j<lps->d; j++) {
printf(" %3ld : ",j);
dd_WriteNumber(stdout,lps->sol[j]);
printf("\n");
}
printf(" dual_solution\n");
for (j=1; j<lps->d; j++){
if (lps->nbindex[j+1]>0) {
printf(" %3ld : ",lps->nbindex[j+1]);
dd_WriteNumber(stdout,lps->dsol[j]); printf("\n");
}
}
printf(" optimal_value : "); dd_WriteNumber(stdout,lps->optvalue);
printf("\n");
}
/* Find an interior point with cdd LP library. */
printf("\n--- Running dd_FindInteriorPoint ---\n");
lp1=dd_MakeLPforInteriorFinding(lp);
printf("The LP to be solved for finding an interior point:\n");
dd_WriteLP(stdout,lp1);
dd_LPSolve(lp1,solver,&err);
if (err!=dd_NoError) goto _L99;
/* Write an interior point. */
lps1=dd_CopyLPSolution(lp1);
if (dd_Positive(lps1->optvalue)){
printf("\nAn interior point found: (");
for (j=1; j <(lps1->d)-1; j++) {
dd_WriteNumber(stdout,lps1->sol[j]);
}
printf(")\n");
}
if (dd_Negative(lps1->optvalue))
printf("\nThe feasible region is empty.\n");
if (dd_EqualToZero(lps1->optvalue))
printf("\nThe feasible region is nonempty but has no interior point.\n");
/* Free allocated spaces. */
dd_FreeLPSolution(lps);
dd_FreeLPData(lp);
dd_FreeLPSolution(lps1);
dd_FreeLPData(lp1);
dd_FreeMatrix(M);
_L99:;
if (err!=dd_NoError) dd_WriteErrorMessages(stdout, err);
dd_free_global_constants(); /* At the end, this should be called. */
return 0;
}
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;
}
