test.c

   1 #include <assert.h>
   2 #include <stdio.h>
   3 #include <string.h>
   4 #include <unistd.h>
   5 #include <barvinok/util.h>
   6 #include <barvinok/barvinok.h>
   7 #include <barvinok/sample.h>
   8 #include "config.h"
   9 #include "evalue_read.h"
  10 #include "lattice_width.h"
  11
  12 #ifdef HAVE_SYS_TIMES_H
  13
  14 #include <sys/times.h>
  15
  16 static void time_diff(struct tms *before, struct tms *after)
  17 {
  18     long ticks = sysconf(_SC_CLK_TCK);
  19     printf("User: %g; Sys: %g\n",
  20             (0.0 + after->tms_utime - before->tms_utime) / ticks,
  21             (0.0 + after->tms_stime - before->tms_stime) / ticks);
  22 }
  23
  24 #else
  25
  26 struct tms {};
  27 static void times(struct tms* time)
  28 {
  29 }
  30 static void time_diff(struct tms *before, struct tms *after)
  31 {
  32 }
  33
  34 #endif
  35
  36 int main(int argc, char **argv)
  37 {
  38     int i, nbPol, nbVec, nbMat, func, j, n;
  39     Polyhedron *A, *B, *C, *D, *E, *F, *G;
  40     char s[128];
  41     struct barvinok_options *options = barvinok_options_new_with_defaults();
  42
  43     argc = barvinok_options_parse(options, argc, argv, ISL_ARG_ALL);
  44
  45     nbPol = nbVec = nbMat = 0;
  46     fgets(s, 128, stdin);
  47     while ((*s=='#') ||
  48             ((sscanf(s, "D %d", &nbPol) < 1) &&
  49              (sscanf(s, "V %d", &nbVec) < 1) &&
  50              (sscanf(s, "M %d", &nbMat) < 1)))
  51         fgets(s, 128, stdin);
  52
  53     for (i = 0; i < nbPol; ++i) {
  54         Matrix *M = Matrix_Read();
  55         A = Constraints2Polyhedron(M, options->MaxRays);
  56         Matrix_Free(M);
  57         fgets(s, 128, stdin);
  58         while ((*s=='#') || (sscanf(s, "F %d", &func)<1))
  59             fgets(s, 128, stdin);
  60
  61         switch(func) {
  62         case 0: {
  63             Value cb, ck;
  64             value_init(cb);
  65             value_init(ck);
  66             fgets(s, 128, stdin);
  67             /* workaround for apparent bug in older gmps */
  68             *strchr(s, '\n') = '\0';
  69             while ((*s=='#') || (value_read(ck, s) != 0)) {
  70                 fgets(s, 128, stdin);
  71                 /* workaround for apparent bug in older gmps */
  72                 *strchr(s, '\n') = '\0';
  73             }
  74             barvinok_count_with_options(A, &cb, options);
  75             if (value_ne(cb, ck))
  76                 return -1;
  77             value_clear(cb);
  78             value_clear(ck);
  79             break;
  80         }
  81         case 1:
  82             Polyhedron_Print(stdout, P_VALUE_FMT, A);
  83             B = Polyhedron_Polar(A, options->MaxRays);
  84             Polyhedron_Print(stdout, P_VALUE_FMT, B);
  85             C = Polyhedron_Polar(B, options->MaxRays);
  86             Polyhedron_Print(stdout, P_VALUE_FMT, C);
  87             Polyhedron_Free(C);
  88             Polyhedron_Free(B);
  89             break;
  90         case 2:
  91             Polyhedron_Print(stdout, P_VALUE_FMT, A);
  92             for (j = 0; j < A->NbRays; ++j) {
  93                 B = supporting_cone(A, j);
  94                 Polyhedron_Print(stdout, P_VALUE_FMT, B);
  95                 Polyhedron_Free(B);
  96             }
  97             break;
  98         case 3:
  99             Polyhedron_Print(stdout, P_VALUE_FMT, A);
 100             C = B = NULL;
 101             barvinok_decompose(A,&B,&C);
 102             puts("Pos:");
 103             Polyhedron_Print(stdout, P_VALUE_FMT, B);
 104             puts("Neg:");
 105             Polyhedron_Print(stdout, P_VALUE_FMT, C);
 106             Domain_Free(B);
 107             Domain_Free(C);
 108             break;
 109         case 4: {
 110             Value cm, cb;
 111             struct tms tms_before, tms_between, tms_after;
 112             value_init(cm);
 113             value_init(cb);
 114             Polyhedron_Print(stdout, P_VALUE_FMT, A);
 115             times(&tms_before);
 116             manual_count(A, &cm);
 117             times(&tms_between);
 118             barvinok_count(A, &cb, 100);
 119             times(&tms_after);
 120             printf("manual: ");
 121             value_print(stdout, P_VALUE_FMT, cm);
 122             puts("");
 123             time_diff(&tms_before, &tms_between);
 124             printf("Barvinok: ");
 125             value_print(stdout, P_VALUE_FMT, cb);
 126             puts("");
 127             time_diff(&tms_between, &tms_after);
 128             value_clear(cm);
 129             value_clear(cb);
 130             break;
 131         }
 132         case 5:
 133             Polyhedron_Print(stdout, P_VALUE_FMT, A);
 134             B = triangulate_cone(A, 100);
 135             Polyhedron_Print(stdout, P_VALUE_FMT, B);
 136             check_triangulization(A, B);
 137             Domain_Free(B);
 138             break;
 139         case 6:
 140             Polyhedron_Print(stdout, P_VALUE_FMT, A);
 141             B = remove_equalities(A, options->MaxRays);
 142             Polyhedron_Print(stdout, P_VALUE_FMT, B);
 143             Polyhedron_Free(B);
 144             break;
 145         case 8: {
 146             evalue *EP;
 147             Matrix *M = Matrix_Read();
 148             const char **param_name;
 149             C = Constraints2Polyhedron(M, options->MaxRays);
 150             Matrix_Free(M);
 151             Polyhedron_Print(stdout, P_VALUE_FMT, A);
 152             Polyhedron_Print(stdout, P_VALUE_FMT, C);
 153             EP = barvinok_enumerate_with_options(A, C, options);
 154             param_name = Read_ParamNames(stdin, C->Dimension);
 155             print_evalue(stdout, EP, (const char**)param_name);
 156             evalue_free(EP);
 157             Polyhedron_Free(C);
 158         }
 159         case 9:
 160             Polyhedron_Print(stdout, P_VALUE_FMT, A);
 161             Polyhedron_Polarize(A);
 162             C = B = NULL;
 163             barvinok_decompose(A,&B,&C);
 164             for (D = B; D; D = D->next)
 165                 Polyhedron_Polarize(D);
 166             for (D = C; D; D = D->next)
 167                 Polyhedron_Polarize(D);
 168             puts("Pos:");
 169             Polyhedron_Print(stdout, P_VALUE_FMT, B);
 170             puts("Neg:");
 171             Polyhedron_Print(stdout, P_VALUE_FMT, C);
 172             Domain_Free(B);
 173             Domain_Free(C);
 174             break;
 175         case 10: {
 176             evalue *EP;
 177             Value cb, ck;
 178
 179             value_init(cb);
 180             value_init(ck);
 181             fgets(s, 128, stdin);
 182             sscanf(s, "%d", &n);
 183             for (j = 0; j < n; ++j) {
 184                 Polyhedron *P;
 185                 M = Matrix_Read();
 186                 P = Constraints2Polyhedron(M, options->MaxRays);
 187                 Matrix_Free(M);
 188                 A = DomainConcat(P, A);
 189             }
 190             fgets(s, 128, stdin);
 191             /* workaround for apparent bug in older gmps */
 192             *strchr(s, '\n') = '\0';
 193             while ((*s=='#') || (value_read(ck, s) != 0)) {
 194                 fgets(s, 128, stdin);
 195                 /* workaround for apparent bug in older gmps */
 196                 *strchr(s, '\n') = '\0';
 197             }
 198             C = Universe_Polyhedron(0);
 199             EP = barvinok_enumerate_union(A, C, options->MaxRays);
 200             value_set_double(cb, compute_evalue(EP, &ck)+.25);
 201             if (value_ne(cb, ck))
 202                 return -1;
 203             Domain_Free(C);
 204             value_clear(cb);
 205             value_clear(ck);
 206             evalue_free(EP);
 207             break;
 208         }
 209         case 11: {
 210             evalue *expected, *computed;
 211             unsigned nvar, nparam;
 212             const char **pp;
 213
 214             expected = evalue_read_from_file(stdin, NULL, &pp, &nvar, &nparam,
 215                                              options->MaxRays);
 216             C = Universe_Polyhedron(0);
 217             computed = Polyhedron_Lattice_Width(A, C, options);
 218             assert(value_zero_p(computed->d));
 219             assert(computed->x.p->type == partition);
 220             if (!eequal(expected, &computed->x.p->arr[1]))
 221                 return -1;
 222             free(pp);
 223             Domain_Free(C);
 224             evalue_free(computed);
 225             evalue_free(expected);
 226             break;
 227         }
 228         case 12: {
 229             Vector *sample;
 230             int has_sample;
 231             fgets(s, 128, stdin);
 232             sscanf(s, "%d", &has_sample);
 233
 234             sample = Polyhedron_Sample(A, options);
 235             if (!sample && has_sample)
 236                 return -1;
 237             if (sample && !has_sample)
 238                 return -1;
 239             if (sample && !in_domain(A, sample->p))
 240                 return -1;
 241             Vector_Free(sample);
 242         }
 243         }
 244         Domain_Free(A);
 245     }
 246     for (i = 0; i < nbVec; ++i) {
 247         int ok;
 248         Vector *V = Vector_Read();
 249         Matrix *M = Matrix_Alloc(V->Size, V->Size);
 250         Vector_Copy(V->p, M->p[0], V->Size);
 251         ok = unimodular_complete(M, 1);
 252         assert(ok);
 253         Matrix_Print(stdout, P_VALUE_FMT, M);
 254         Matrix_Free(M);
 255         Vector_Free(V);
 256     }
 257     for (i = 0; i < nbMat; ++i) {
 258         Matrix *U, *V, *S;
 259         Matrix *M = Matrix_Read();
 260         Smith(M, &U, &V, &S);
 261         Matrix_Print(stdout, P_VALUE_FMT, U);
 262         Matrix_Print(stdout, P_VALUE_FMT, V);
 263         Matrix_Print(stdout, P_VALUE_FMT, S);
 264         Matrix_Free(M);
 265         Matrix_Free(U);
 266         Matrix_Free(V);
 267         Matrix_Free(S);
 268     }
 269
 270     barvinok_options_free(options);
 271     return 0;
 272 }