Ejemplo n.º 1
0
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;
}
Ejemplo n.º 2
0
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;
}
Ejemplo n.º 3
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;
}
Ejemplo n.º 4
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;
}
Ejemplo n.º 5
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;
}
Ejemplo n.º 6
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;
}