test.c

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