isl_test.c

   1 #include <assert.h>
   2 #include <stdio.h>
   3 #include <limits.h>
   4 #include <isl_ctx.h>
   5 #include <isl_set.h>
   6 #include <isl_constraint.h>
   7
   8 static char *srcdir;
   9
  10 void test_read(struct isl_ctx *ctx)
  11 {
  12         char filename[PATH_MAX];
  13         FILE *input;
  14         int n;
  15         struct isl_basic_set *bset1, *bset2;
  16         const char *str = "{[y]: Exists ( alpha : 2alpha = y)}";
  17
  18         n = snprintf(filename, sizeof(filename),
  19                         "%s/test_inputs/set.omega", srcdir);
  20         assert(n < sizeof(filename));
  21         input = fopen(filename, "r");
  22         assert(input);
  23
  24         bset1 = isl_basic_set_read_from_file(ctx, input, 0, ISL_FORMAT_OMEGA);
  25         bset2 = isl_basic_set_read_from_str(ctx, str, 0, ISL_FORMAT_OMEGA);
  26
  27         assert(isl_basic_set_is_equal(bset1, bset2) == 1);
  28
  29         isl_basic_set_free(bset1);
  30         isl_basic_set_free(bset2);
  31
  32         fclose(input);
  33 }
  34
  35 /* Construct the basic set { [i] : 5 <= i <= N } */
  36 void test_construction(struct isl_ctx *ctx)
  37 {
  38         isl_int v;
  39         struct isl_dim *dim;
  40         struct isl_basic_set *bset;
  41         struct isl_constraint *c;
  42
  43         isl_int_init(v);
  44
  45         dim = isl_dim_set_alloc(ctx, 1, 1);
  46         bset = isl_basic_set_universe(dim);
  47
  48         c = isl_inequality_alloc(isl_dim_copy(bset->dim));
  49         isl_int_set_si(v, -1);
  50         isl_constraint_set_coefficient(c, isl_dim_set, 0, v);
  51         isl_int_set_si(v, 1);
  52         isl_constraint_set_coefficient(c, isl_dim_param, 0, v);
  53         bset = isl_basic_set_add_constraint(bset, c);
  54
  55         c = isl_inequality_alloc(isl_dim_copy(bset->dim));
  56         isl_int_set_si(v, 1);
  57         isl_constraint_set_coefficient(c, isl_dim_set, 0, v);
  58         isl_int_set_si(v, -5);
  59         isl_constraint_set_constant(c, v);
  60         bset = isl_basic_set_add_constraint(bset, c);
  61
  62         isl_basic_set_free(bset);
  63
  64         isl_int_clear(v);
  65 }
  66
  67 void test_application_case(struct isl_ctx *ctx, const char *name)
  68 {
  69         char filename[PATH_MAX];
  70         FILE *input;
  71         int n;
  72         struct isl_basic_set *bset1, *bset2;
  73         struct isl_basic_map *bmap;
  74
  75         n = snprintf(filename, sizeof(filename),
  76                         "%s/test_inputs/%s.omega", srcdir, name);
  77         assert(n < sizeof(filename));
  78         input = fopen(filename, "r");
  79         assert(input);
  80
  81         bset1 = isl_basic_set_read_from_file(ctx, input, 0, ISL_FORMAT_OMEGA);
  82         bmap = isl_basic_map_read_from_file(ctx, input, 0, ISL_FORMAT_OMEGA);
  83
  84         bset1 = isl_basic_set_apply(bset1, bmap);
  85
  86         bset2 = isl_basic_set_read_from_file(ctx, input, 0, ISL_FORMAT_OMEGA);
  87
  88         assert(isl_basic_set_is_equal(bset1, bset2) == 1);
  89
  90         isl_basic_set_free(bset1);
  91         isl_basic_set_free(bset2);
  92
  93         fclose(input);
  94 }
  95
  96 void test_application(struct isl_ctx *ctx)
  97 {
  98         test_application_case(ctx, "application");
  99         test_application_case(ctx, "application2");
 100 }
 101
 102 void test_affine_hull_case(struct isl_ctx *ctx, const char *name)
 103 {
 104         char filename[PATH_MAX];
 105         FILE *input;
 106         int n;
 107         struct isl_basic_set *bset1, *bset2;
 108
 109         n = snprintf(filename, sizeof(filename),
 110                         "%s/test_inputs/%s.polylib", srcdir, name);
 111         assert(n < sizeof(filename));
 112         input = fopen(filename, "r");
 113         assert(input);
 114
 115         bset1 = isl_basic_set_read_from_file(ctx, input, 0, ISL_FORMAT_POLYLIB);
 116         bset2 = isl_basic_set_read_from_file(ctx, input, 0, ISL_FORMAT_POLYLIB);
 117
 118         bset1 = isl_basic_set_affine_hull(bset1);
 119
 120         assert(isl_basic_set_is_equal(bset1, bset2) == 1);
 121
 122         isl_basic_set_free(bset1);
 123         isl_basic_set_free(bset2);
 124
 125         fclose(input);
 126 }
 127
 128 void test_affine_hull(struct isl_ctx *ctx)
 129 {
 130         test_affine_hull_case(ctx, "affine2");
 131         test_affine_hull_case(ctx, "affine");
 132 }
 133
 134 void test_convex_hull_case(struct isl_ctx *ctx, const char *name)
 135 {
 136         char filename[PATH_MAX];
 137         FILE *input;
 138         int n;
 139         struct isl_basic_set *bset1, *bset2;
 140         struct isl_set *set;
 141
 142         n = snprintf(filename, sizeof(filename),
 143                         "%s/test_inputs/%s.polylib", srcdir, name);
 144         assert(n < sizeof(filename));
 145         input = fopen(filename, "r");
 146         assert(input);
 147
 148         bset1 = isl_basic_set_read_from_file(ctx, input, 0, ISL_FORMAT_POLYLIB);
 149         bset2 = isl_basic_set_read_from_file(ctx, input, 0, ISL_FORMAT_POLYLIB);
 150
 151         set = isl_basic_set_union(bset1, bset2);
 152         bset1 = isl_set_convex_hull(set);
 153
 154         bset2 = isl_basic_set_read_from_file(ctx, input, 0, ISL_FORMAT_POLYLIB);
 155
 156         assert(isl_basic_set_is_equal(bset1, bset2) == 1);
 157
 158         isl_basic_set_free(bset1);
 159         isl_basic_set_free(bset2);
 160
 161         fclose(input);
 162 }
 163
 164 void test_convex_hull(struct isl_ctx *ctx)
 165 {
 166         test_convex_hull_case(ctx, "convex0");
 167         test_convex_hull_case(ctx, "convex1");
 168         test_convex_hull_case(ctx, "convex2");
 169         test_convex_hull_case(ctx, "convex3");
 170         test_convex_hull_case(ctx, "convex4");
 171         test_convex_hull_case(ctx, "convex5");
 172         test_convex_hull_case(ctx, "convex6");
 173         test_convex_hull_case(ctx, "convex7");
 174         test_convex_hull_case(ctx, "convex8");
 175         test_convex_hull_case(ctx, "convex9");
 176         test_convex_hull_case(ctx, "convex10");
 177         test_convex_hull_case(ctx, "convex11");
 178 }
 179
 180 void test_gist_case(struct isl_ctx *ctx, const char *name)
 181 {
 182         char filename[PATH_MAX];
 183         FILE *input;
 184         int n;
 185         struct isl_basic_set *bset1, *bset2;
 186         struct isl_set *set;
 187
 188         n = snprintf(filename, sizeof(filename),
 189                         "%s/test_inputs/%s.polylib", srcdir, name);
 190         assert(n < sizeof(filename));
 191         input = fopen(filename, "r");
 192         assert(input);
 193
 194         bset1 = isl_basic_set_read_from_file(ctx, input, 0, ISL_FORMAT_POLYLIB);
 195         bset2 = isl_basic_set_read_from_file(ctx, input, 0, ISL_FORMAT_POLYLIB);
 196
 197         bset1 = isl_basic_set_gist(bset1, bset2);
 198
 199         bset2 = isl_basic_set_read_from_file(ctx, input, 0, ISL_FORMAT_POLYLIB);
 200
 201         assert(isl_basic_set_is_equal(bset1, bset2) == 1);
 202
 203         isl_basic_set_free(bset1);
 204         isl_basic_set_free(bset2);
 205
 206         fclose(input);
 207 }
 208
 209 void test_gist(struct isl_ctx *ctx)
 210 {
 211         test_gist_case(ctx, "gist1");
 212 }
 213
 214 int main()
 215 {
 216         struct isl_ctx *ctx;
 217
 218         srcdir = getenv("srcdir");
 219
 220         ctx = isl_ctx_alloc();
 221         test_read(ctx);
 222         test_construction(ctx);
 223         test_application(ctx);
 224         test_affine_hull(ctx);
 225         test_convex_hull(ctx);
 226         test_gist(ctx);
 227         isl_ctx_free(ctx);
 228         return 0;
 229 }