iscc: add lexicographic operators
[barvinok.git] / test.c
blob0d8b2ffbc5d329cdf1b273066575163cba3466b9
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"
12 #ifdef HAVE_SYS_TIMES_H
14 #include <sys/times.h>
16 static void time_diff(struct tms *before, struct tms *after)
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);
24 #else
26 struct tms {};
27 static void times(struct tms* time)
30 static void time_diff(struct tms *before, struct tms *after)
34 #endif
36 int main(int argc, char **argv)
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();
43 argc = barvinok_options_parse(options, argc, argv, ISL_ARG_ALL);
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);
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);
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';
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;
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);
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;
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);
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;
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);
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';
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;
209 case 11: {
210 evalue *expected, *computed;
211 unsigned nvar, nparam;
212 const char **pp;
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;
228 case 12: {
229 Vector *sample;
230 int has_sample;
231 fgets(s, 128, stdin);
232 sscanf(s, "%d", &has_sample);
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);
244 Domain_Free(A);
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);
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);
270 barvinok_options_free(options);
271 return 0;