test.c

   1 #include <assert.h>
   2 #include <stdio.h>
   3 #include <string.h>
   4 #include <unistd.h>
   5 #include <sys/times.h>
   6 #include <polylib/polylibgmp.h>
   7 #include <util.h>
   8 #include <barvinok.h>
   9
  10 static void time_diff(struct tms *before, struct tms *after)
  11 {
  12     long ticks = sysconf(_SC_CLK_TCK);
  13     printf("User: %g; Sys: %g\n",
  14             (0.0 + after->tms_utime - before->tms_utime) / ticks,
  15             (0.0 + after->tms_stime - before->tms_stime) / ticks);
  16 }
  17
  18 int main()
  19 {
  20     int i, nbPol, nbVec, func, j;
  21     Polyhedron *A, *B, *C, *D, *E, *F, *G;
  22     char s[128];
  23
  24     nbPol = nbVec = 0;
  25     fgets(s, 128, stdin);
  26     while ((*s=='#') ||
  27             ((sscanf(s, "D %d", &nbPol)<1) && (sscanf(s, "V %d", &nbVec)<1)) )
  28         fgets(s, 128, stdin);
  29
  30     for (i = 0; i < nbPol; ++i) {
  31         Matrix *M = Matrix_Read();
  32         A = Constraints2Polyhedron(M, 600);
  33         Matrix_Free(M);
  34         fgets(s, 128, stdin);
  35         while ((*s=='#') || (sscanf(s, "F %d", &func)<1))
  36             fgets(s, 128, stdin);
  37
  38         switch(func) {
  39         case 0: {
  40             Value cb, ck;
  41             value_init(cb);
  42             value_init(ck);
  43             fgets(s, 128, stdin);
  44             /* workaround for apparent bug in older gmps */
  45             *strchr(s, '\n') = '\0';
  46             while ((*s=='#') || (value_read(ck, s) != 0)) {
  47                 fgets(s, 128, stdin);
  48                 /* workaround for apparent bug in older gmps */
  49                 *strchr(s, '\n') = '\0';
  50             }
  51             barvinok_count(A, &cb, 100);
  52             if (value_ne(cb, ck))
  53                 return -1;
  54             value_clear(cb);
  55             value_clear(ck);
  56             break;
  57         }
  58         case 1:
  59             Polyhedron_Print(stdout, P_VALUE_FMT, A);
  60             B = Polyhedron_Polar(A, 600);
  61             Polyhedron_Print(stdout, P_VALUE_FMT, B);
  62             C = Polyhedron_Polar(B, 600);
  63             Polyhedron_Print(stdout, P_VALUE_FMT, C);
  64             Polyhedron_Free(C);
  65             Polyhedron_Free(B);
  66             break;
  67         case 2:
  68             Polyhedron_Print(stdout, P_VALUE_FMT, A);
  69             for (j = 0; j < A->NbRays; ++j) {
  70                 B = supporting_cone(A, j);
  71                 Polyhedron_Print(stdout, P_VALUE_FMT, B);
  72                 Polyhedron_Free(B);
  73             }
  74             break;
  75         case 3:
  76             Polyhedron_Print(stdout, P_VALUE_FMT, A);
  77             C = B = NULL;
  78             barvinok_decompose(A,&B,&C);
  79             puts("Pos:");
  80             Polyhedron_Print(stdout, P_VALUE_FMT, B);
  81             puts("Neg:");
  82             Polyhedron_Print(stdout, P_VALUE_FMT, C);
  83             Domain_Free(B);
  84             Domain_Free(C);
  85             break;
  86         case 4: {
  87             Value cm, cb;
  88             struct tms tms_before, tms_between, tms_after;
  89             value_init(cm);
  90             value_init(cb);
  91             Polyhedron_Print(stdout, P_VALUE_FMT, A);
  92             times(&tms_before);
  93             manual_count(A, &cm);
  94             times(&tms_between);
  95             barvinok_count(A, &cb, 100);
  96             times(&tms_after);
  97             printf("manual: ");
  98             value_print(stdout, P_VALUE_FMT, cm);
  99             puts("");
 100             time_diff(&tms_before, &tms_between);
 101             printf("Barvinok: ");
 102             value_print(stdout, P_VALUE_FMT, cb);
 103             puts("");
 104             time_diff(&tms_between, &tms_after);
 105             value_clear(cm);
 106             value_clear(cb);
 107             break;
 108         }
 109         case 5:
 110             Polyhedron_Print(stdout, P_VALUE_FMT, A);
 111             B = triangularize_cone(A, 100);
 112             Polyhedron_Print(stdout, P_VALUE_FMT, B);
 113             check_triangulization(A, B);
 114             Domain_Free(B);
 115             break;
 116         case 6:
 117             Polyhedron_Print(stdout, P_VALUE_FMT, A);
 118             B = remove_equalities(A);
 119             Polyhedron_Print(stdout, P_VALUE_FMT, B);
 120             Polyhedron_Free(B);
 121             break;
 122         case 7: {
 123             Value f;
 124             value_init(f);
 125             Polyhedron_Print(stdout, P_VALUE_FMT, A);
 126             B = Polyhedron_Reduce(A, &f);
 127             Polyhedron_Print(stdout, P_VALUE_FMT, B);
 128             Polyhedron_Free(B);
 129             printf("factor: ");
 130             value_print(stdout, P_VALUE_FMT, f);
 131             puts("");
 132             value_clear(f);
 133             break;
 134         }
 135         case 8: {
 136             Enumeration *en;
 137             Matrix *M = Matrix_Read();
 138             char **param_name;
 139             C = Constraints2Polyhedron(M, 600);
 140             Matrix_Free(M);
 141             Polyhedron_Print(stdout, P_VALUE_FMT, A);
 142             Polyhedron_Print(stdout, P_VALUE_FMT, C);
 143             en = barvinok_enumerate(A, C, 600);
 144             param_name = Read_ParamNames(stdin, C->Dimension);
 145             print_evalue(stdout, &en->EP, param_name);
 146             Enumeration_Free(en);
 147             Polyhedron_Free(C);
 148         }
 149         case 9:
 150             Polyhedron_Print(stdout, P_VALUE_FMT, A);
 151             Polyhedron_Polarize(A);
 152             C = B = NULL;
 153             barvinok_decompose(A,&B,&C);
 154             for (D = B; D; D = D->next)
 155                 Polyhedron_Polarize(D);
 156             for (D = C; D; D = D->next)
 157                 Polyhedron_Polarize(D);
 158             puts("Pos:");
 159             Polyhedron_Print(stdout, P_VALUE_FMT, B);
 160             puts("Neg:");
 161             Polyhedron_Print(stdout, P_VALUE_FMT, C);
 162             Domain_Free(B);
 163             Domain_Free(C);
 164             break;
 165         }
 166         Polyhedron_Free(A);
 167     }
 168     for (i = 0; i < nbVec; ++i) {
 169         Vector *V = Vector_Read();
 170         Matrix *M = unimodular_complete(V);
 171         Matrix_Print(stdout, P_VALUE_FMT, M);
 172         Matrix_Free(M);
 173         Vector_Free(V);
 174     }
 175
 176     return 0;
 177 }