isl_transitive_closure.c

   1 /*
   2  * Copyright 2010      INRIA Saclay
   3  *
   4  * Use of this software is governed by the GNU LGPLv2.1 license
   5  *
   6  * Written by Sven Verdoolaege, INRIA Saclay - Ile-de-France,
   7  * Parc Club Orsay Universite, ZAC des vignes, 4 rue Jacques Monod,
   8  * 91893 Orsay, France
   9  */
  10
  11 #include "isl_map.h"
  12 #include "isl_map_private.h"
  13 #include "isl_seq.h"
  14 #include <isl_lp.h>
  15
  16 /* Given a map that represents a path with the length of the path
  17  * encoded as the difference between the last output coordindate
  18  * and the last input coordinate, set this length to either
  19  * exactly "length" (if "exactly" is set) or at least "length"
  20  * (if "exactly" is not set).
  21  */
  22 static __isl_give isl_map *set_path_length(__isl_take isl_map *map,
  23         int exactly, int length)
  24 {
  25         struct isl_dim *dim;
  26         struct isl_basic_map *bmap;
  27         unsigned d;
  28         unsigned nparam;
  29         int k;
  30         isl_int *c;
  31
  32         if (!map)
  33                 return NULL;
  34
  35         dim = isl_map_get_dim(map);
  36         d = isl_dim_size(dim, isl_dim_in);
  37         nparam = isl_dim_size(dim, isl_dim_param);
  38         bmap = isl_basic_map_alloc_dim(dim, 0, 1, 1);
  39         if (exactly) {
  40                 k = isl_basic_map_alloc_equality(bmap);
  41                 c = bmap->eq[k];
  42         } else {
  43                 k = isl_basic_map_alloc_inequality(bmap);
  44                 c = bmap->ineq[k];
  45         }
  46         if (k < 0)
  47                 goto error;
  48         isl_seq_clr(c, 1 + isl_basic_map_total_dim(bmap));
  49         isl_int_set_si(c[0], -length);
  50         isl_int_set_si(c[1 + nparam + d - 1], -1);
  51         isl_int_set_si(c[1 + nparam + d + d - 1], 1);
  52
  53         bmap = isl_basic_map_finalize(bmap);
  54         map = isl_map_intersect(map, isl_map_from_basic_map(bmap));
  55
  56         return map;
  57 error:
  58         isl_basic_map_free(bmap);
  59         isl_map_free(map);
  60         return NULL;
  61 }
  62
  63 /* Check whether the overapproximation of the power of "map" is exactly
  64  * the power of "map".  Let R be "map" and A_k the overapproximation.
  65  * The approximation is exact if
  66  *
  67  *      A_1 = R
  68  *      A_k = A_{k-1} \circ R                   k >= 2
  69  *
  70  * Since A_k is known to be an overapproximation, we only need to check
  71  *
  72  *      A_1 \subset R
  73  *      A_k \subset A_{k-1} \circ R             k >= 2
  74  *
  75  * In practice, "app" has an extra input and output coordinate
  76  * to encode the length of the path.  So, we first need to add
  77  * this coordinate to "map" and set the length of the path to
  78  * one.
  79  */
  80 static int check_power_exactness(__isl_take isl_map *map,
  81         __isl_take isl_map *app)
  82 {
  83         int exact;
  84         isl_map *app_1;
  85         isl_map *app_2;
  86
  87         map = isl_map_add(map, isl_dim_in, 1);
  88         map = isl_map_add(map, isl_dim_out, 1);
  89         map = set_path_length(map, 1, 1);
  90
  91         app_1 = set_path_length(isl_map_copy(app), 1, 1);
  92
  93         exact = isl_map_is_subset(app_1, map);
  94         isl_map_free(app_1);
  95
  96         if (!exact || exact < 0) {
  97                 isl_map_free(app);
  98                 isl_map_free(map);
  99                 return exact;
 100         }
 101
 102         app_1 = set_path_length(isl_map_copy(app), 0, 1);
 103         app_2 = set_path_length(app, 0, 2);
 104         app_1 = isl_map_apply_range(map, app_1);
 105
 106         exact = isl_map_is_subset(app_2, app_1);
 107
 108         isl_map_free(app_1);
 109         isl_map_free(app_2);
 110
 111         return exact;
 112 }
 113
 114 /* Check whether the overapproximation of the power of "map" is exactly
 115  * the power of "map", possibly after projecting out the power (if "project"
 116  * is set).
 117  *
 118  * If "project" is set and if "steps" can only result in acyclic paths,
 119  * then we check
 120  *
 121  *      A = R \cup (A \circ R)
 122  *
 123  * where A is the overapproximation with the power projected out, i.e.,
 124  * an overapproximation of the transitive closure.
 125  * More specifically, since A is known to be an overapproximation, we check
 126  *
 127  *      A \subset R \cup (A \circ R)
 128  *
 129  * Otherwise, we check if the power is exact.
 130  *
 131  * Note that "app" has an extra input and output coordinate to encode
 132  * the length of the part.  If we are only interested in the transitive
 133  * closure, then we can simply project out these coordinates first.
 134  */
 135 static int check_exactness(__isl_take isl_map *map, __isl_take isl_map *app,
 136         int project)
 137 {
 138         isl_map *test;
 139         int exact;
 140         unsigned d;
 141
 142         if (!project)
 143                 return check_power_exactness(map, app);
 144
 145         d = isl_map_dim(map, isl_dim_in);
 146         app = set_path_length(app, 0, 1);
 147         app = isl_map_project_out(app, isl_dim_in, d, 1);
 148         app = isl_map_project_out(app, isl_dim_out, d, 1);
 149
 150         test = isl_map_apply_range(isl_map_copy(map), isl_map_copy(app));
 151         test = isl_map_union(test, isl_map_copy(map));
 152
 153         exact = isl_map_is_subset(app, test);
 154
 155         isl_map_free(app);
 156         isl_map_free(test);
 157
 158         isl_map_free(map);
 159
 160         return exact;
 161 error:
 162         isl_map_free(app);
 163         isl_map_free(map);
 164         return -1;
 165 }
 166
 167 /*
 168  * The transitive closure implementation is based on the paper
 169  * "Computing the Transitive Closure of a Union of Affine Integer
 170  * Tuple Relations" by Anna Beletska, Denis Barthou, Wlodzimierz Bielecki and
 171  * Albert Cohen.
 172  */
 173
 174 /* Given a set of n offsets v_i (the rows of "steps"), construct a relation
 175  * of the given dimension specification (Z^{n+1} -> Z^{n+1})
 176  * that maps an element x to any element that can be reached
 177  * by taking a non-negative number of steps along any of
 178  * the extended offsets v'_i = [v_i 1].
 179  * That is, construct
 180  *
 181  * { [x] -> [y] : exists k_i >= 0, y = x + \sum_i k_i v'_i }
 182  *
 183  * For any element in this relation, the number of steps taken
 184  * is equal to the difference in the final coordinates.
 185  */
 186 static __isl_give isl_map *path_along_steps(__isl_take isl_dim *dim,
 187         __isl_keep isl_mat *steps)
 188 {
 189         int i, j, k;
 190         struct isl_basic_map *path = NULL;
 191         unsigned d;
 192         unsigned n;
 193         unsigned nparam;
 194
 195         if (!dim || !steps)
 196                 goto error;
 197
 198         d = isl_dim_size(dim, isl_dim_in);
 199         n = steps->n_row;
 200         nparam = isl_dim_size(dim, isl_dim_param);
 201
 202         path = isl_basic_map_alloc_dim(isl_dim_copy(dim), n, d, n);
 203
 204         for (i = 0; i < n; ++i) {
 205                 k = isl_basic_map_alloc_div(path);
 206                 if (k < 0)
 207                         goto error;
 208                 isl_assert(steps->ctx, i == k, goto error);
 209                 isl_int_set_si(path->div[k][0], 0);
 210         }
 211
 212         for (i = 0; i < d; ++i) {
 213                 k = isl_basic_map_alloc_equality(path);
 214                 if (k < 0)
 215                         goto error;
 216                 isl_seq_clr(path->eq[k], 1 + isl_basic_map_total_dim(path));
 217                 isl_int_set_si(path->eq[k][1 + nparam + i], 1);
 218                 isl_int_set_si(path->eq[k][1 + nparam + d + i], -1);
 219                 if (i == d - 1)
 220                         for (j = 0; j < n; ++j)
 221                                 isl_int_set_si(path->eq[k][1 + nparam + 2 * d + j], 1);
 222                 else
 223                         for (j = 0; j < n; ++j)
 224                                 isl_int_set(path->eq[k][1 + nparam + 2 * d + j],
 225                                             steps->row[j][i]);
 226         }
 227
 228         for (i = 0; i < n; ++i) {
 229                 k = isl_basic_map_alloc_inequality(path);
 230                 if (k < 0)
 231                         goto error;
 232                 isl_seq_clr(path->ineq[k], 1 + isl_basic_map_total_dim(path));
 233                 isl_int_set_si(path->ineq[k][1 + nparam + 2 * d + i], 1);
 234         }
 235
 236         isl_dim_free(dim);
 237
 238         path = isl_basic_map_simplify(path);
 239         path = isl_basic_map_finalize(path);
 240         return isl_map_from_basic_map(path);
 241 error:
 242         isl_dim_free(dim);
 243         isl_basic_map_free(path);
 244         return NULL;
 245 }
 246
 247 #define IMPURE          0
 248 #define PURE_PARAM      1
 249 #define PURE_VAR        2
 250 #define MIXED           3
 251
 252 /* Return PURE_PARAM if only the coefficients of the parameters are non-zero.
 253  * Return PURE_VAR if only the coefficients of the set variables are non-zero.
 254  * Return MIXED if only the coefficients of the parameters and the set
 255  *      variables are non-zero and if moreover the parametric constant
 256  *      can never attain positive values.
 257  * Return IMPURE otherwise.
 258  */
 259 static int purity(__isl_keep isl_basic_set *bset, isl_int *c, int *div_purity,
 260         int eq)
 261 {
 262         unsigned d;
 263         unsigned n_div;
 264         unsigned nparam;
 265         int k;
 266         int empty;
 267         int i;
 268         int p = 0, v = 0;
 269
 270         n_div = isl_basic_set_dim(bset, isl_dim_div);
 271         d = isl_basic_set_dim(bset, isl_dim_set);
 272         nparam = isl_basic_set_dim(bset, isl_dim_param);
 273
 274         for (i = 0; i < n_div; ++i) {
 275                 if (isl_int_is_zero(c[1 + nparam + d + i]))
 276                         continue;
 277                 switch (div_purity[i]) {
 278                 case PURE_PARAM: p = 1; break;
 279                 case PURE_VAR: v = 1; break;
 280                 default: return IMPURE;
 281                 }
 282         }
 283         if (!p && isl_seq_first_non_zero(c + 1, nparam) == -1)
 284                 return PURE_VAR;
 285         if (!v && isl_seq_first_non_zero(c + 1 + nparam, d) == -1)
 286                 return PURE_PARAM;
 287         if (eq)
 288                 return IMPURE;
 289
 290         bset = isl_basic_set_copy(bset);
 291         bset = isl_basic_set_cow(bset);
 292         bset = isl_basic_set_extend_constraints(bset, 0, 1);
 293         k = isl_basic_set_alloc_inequality(bset);
 294         if (k < 0)
 295                 goto error;
 296         isl_seq_clr(bset->ineq[k], 1 + isl_basic_set_total_dim(bset));
 297         isl_seq_cpy(bset->ineq[k], c, 1 + nparam);
 298         for (i = 0; i < n_div; ++i) {
 299                 if (div_purity[i] != PURE_PARAM)
 300                         continue;
 301                 isl_int_set(bset->ineq[k][1 + nparam + d + i],
 302                             c[1 + nparam + d + i]);
 303         }
 304         isl_int_sub_ui(bset->ineq[k][0], bset->ineq[k][0], 1);
 305         empty = isl_basic_set_is_empty(bset);
 306         isl_basic_set_free(bset);
 307
 308         return empty < 0 ? -1 : empty ? MIXED : IMPURE;
 309 error:
 310         isl_basic_set_free(bset);
 311         return -1;
 312 }
 313
 314 /* Return an array of integers indicating the type of each div in bset.
 315  * If the div is (recursively) defined in terms of only the parameters,
 316  * then the type is PURE_PARAM.
 317  * If the div is (recursively) defined in terms of only the set variables,
 318  * then the type is PURE_VAR.
 319  * Otherwise, the type is IMPURE.
 320  */
 321 static __isl_give int *get_div_purity(__isl_keep isl_basic_set *bset)
 322 {
 323         int i, j;
 324         int *div_purity;
 325         unsigned d;
 326         unsigned n_div;
 327         unsigned nparam;
 328
 329         if (!bset)
 330                 return NULL;
 331
 332         n_div = isl_basic_set_dim(bset, isl_dim_div);
 333         d = isl_basic_set_dim(bset, isl_dim_set);
 334         nparam = isl_basic_set_dim(bset, isl_dim_param);
 335
 336         div_purity = isl_alloc_array(bset->ctx, int, n_div);
 337         if (!div_purity)
 338                 return NULL;
 339
 340         for (i = 0; i < bset->n_div; ++i) {
 341                 int p = 0, v = 0;
 342                 if (isl_int_is_zero(bset->div[i][0])) {
 343                         div_purity[i] = IMPURE;
 344                         continue;
 345                 }
 346                 if (isl_seq_first_non_zero(bset->div[i] + 2, nparam) != -1)
 347                         p = 1;
 348                 if (isl_seq_first_non_zero(bset->div[i] + 2 + nparam, d) != -1)
 349                         v = 1;
 350                 for (j = 0; j < i; ++j) {
 351                         if (isl_int_is_zero(bset->div[i][2 + nparam + d + j]))
 352                                 continue;
 353                         switch (div_purity[j]) {
 354                         case PURE_PARAM: p = 1; break;
 355                         case PURE_VAR: v = 1; break;
 356                         default: p = v = 1; break;
 357                         }
 358                 }
 359                 div_purity[i] = v ? p ? IMPURE : PURE_VAR : PURE_PARAM;
 360         }
 361
 362         return div_purity;
 363 }
 364
 365 /* Given a path with the as yet unconstrained length at position "pos",
 366  * check if setting the length to zero results in only the identity
 367  * mapping.
 368  */
 369 int empty_path_is_identity(__isl_keep isl_basic_map *path, unsigned pos)
 370 {
 371         isl_basic_map *test = NULL;
 372         isl_basic_map *id = NULL;
 373         int k;
 374         int is_id;
 375
 376         test = isl_basic_map_copy(path);
 377         test = isl_basic_map_extend_constraints(test, 1, 0);
 378         k = isl_basic_map_alloc_equality(test);
 379         if (k < 0)
 380                 goto error;
 381         isl_seq_clr(test->eq[k], 1 + isl_basic_map_total_dim(test));
 382         isl_int_set_si(test->eq[k][pos], 1);
 383         id = isl_basic_map_identity(isl_dim_domain(isl_basic_map_get_dim(path)));
 384         is_id = isl_basic_map_is_subset(test, id);
 385         isl_basic_map_free(test);
 386         isl_basic_map_free(id);
 387         return is_id;
 388 error:
 389         isl_basic_map_free(test);
 390         return -1;
 391 }
 392
 393 __isl_give isl_basic_map *add_delta_constraints(__isl_take isl_basic_map *path,
 394         __isl_keep isl_basic_set *delta, unsigned off, unsigned nparam,
 395         unsigned d, int *div_purity, int eq)
 396 {
 397         int i, k;
 398         int n = eq ? delta->n_eq : delta->n_ineq;
 399         isl_int **delta_c = eq ? delta->eq : delta->ineq;
 400         isl_int **path_c = eq ? path->eq : path->ineq;
 401         unsigned n_div;
 402
 403         n_div = isl_basic_set_dim(delta, isl_dim_div);
 404
 405         for (i = 0; i < n; ++i) {
 406                 int p = purity(delta, delta_c[i], div_purity, eq);
 407                 if (p < 0)
 408                         goto error;
 409                 if (p == IMPURE)
 410                         continue;
 411                 if (eq)
 412                         k = isl_basic_map_alloc_equality(path);
 413                 else
 414                         k = isl_basic_map_alloc_inequality(path);
 415                 if (k < 0)
 416                         goto error;
 417                 isl_seq_clr(path_c[k], 1 + isl_basic_map_total_dim(path));
 418                 if (p == PURE_VAR) {
 419                         isl_seq_cpy(path_c[k] + off,
 420                                     delta_c[i] + 1 + nparam, d);
 421                         isl_int_set(path_c[k][off + d], delta_c[i][0]);
 422                 } else if (p == PURE_PARAM) {
 423                         isl_seq_cpy(path_c[k], delta_c[i], 1 + nparam);
 424                 } else {
 425                         isl_seq_cpy(path_c[k] + off,
 426                                     delta_c[i] + 1 + nparam, d);
 427                         isl_seq_cpy(path_c[k], delta_c[i], 1 + nparam);
 428                 }
 429                 isl_seq_cpy(path_c[k] + off - n_div,
 430                             delta_c[i] + 1 + nparam + d, n_div);
 431         }
 432
 433         return path;
 434 error:
 435         isl_basic_map_free(path);
 436         return NULL;
 437 }
 438
 439 /* Given a set of offsets "delta", construct a relation of the
 440  * given dimension specification (Z^{n+1} -> Z^{n+1}) that
 441  * is an overapproximation of the relations that
 442  * maps an element x to any element that can be reached
 443  * by taking a non-negative number of steps along any of
 444  * the elements in "delta".
 445  * That is, construct an approximation of
 446  *
 447  *      { [x] -> [y] : exists f \in \delta, k \in Z :
 448  *                                      y = x + k [f, 1] and k >= 0 }
 449  *
 450  * For any element in this relation, the number of steps taken
 451  * is equal to the difference in the final coordinates.
 452  *
 453  * In particular, let delta be defined as
 454  *
 455  *      \delta = [p] -> { [x] : A x + a >= and B p + b >= 0 and
 456  *                              C x + C'p + c >= 0 and
 457  *                              D x + D'p + d >= 0 }
 458  *
 459  * where the constraints C x + C'p + c >= 0 are such that the parametric
 460  * constant term of each constraint j, "C_j x + C'_j p + c_j",
 461  * can never attain positive values, then the relation is constructed as
 462  *
 463  *      { [x] -> [y] : exists [f, k] \in Z^{n+1} : y = x + f and
 464  *                      A f + k a >= 0 and B p + b >= 0 and
 465  *                      C f + C'p + c >= 0 and k >= 1 }
 466  *      union { [x] -> [x] }
 467  *
 468  * If the zero-length paths happen to correspond exactly to the identity
 469  * mapping, then we return
 470  *
 471  *      { [x] -> [y] : exists [f, k] \in Z^{n+1} : y = x + f and
 472  *                      A f + k a >= 0 and B p + b >= 0 and
 473  *                      C f + C'p + c >= 0 and k >= 0 }
 474  *
 475  * instead.
 476  *
 477  * Existentially quantified variables in \delta are handled by
 478  * classifying them as independent of the parameters, purely
 479  * parameter dependent and others.  Constraints containing
 480  * any of the other existentially quantified variables are removed.
 481  * This is safe, but leads to an additional overapproximation.
 482  */
 483 static __isl_give isl_map *path_along_delta(__isl_take isl_dim *dim,
 484         __isl_take isl_basic_set *delta)
 485 {
 486         isl_basic_map *path = NULL;
 487         unsigned d;
 488         unsigned n_div;
 489         unsigned nparam;
 490         unsigned off;
 491         int i, k;
 492         int is_id;
 493         int *div_purity = NULL;
 494
 495         if (!delta)
 496                 goto error;
 497         n_div = isl_basic_set_dim(delta, isl_dim_div);
 498         d = isl_basic_set_dim(delta, isl_dim_set);
 499         nparam = isl_basic_set_dim(delta, isl_dim_param);
 500         path = isl_basic_map_alloc_dim(isl_dim_copy(dim), n_div + d + 1,
 501                         d + 1 + delta->n_eq, delta->n_ineq + 1);
 502         off = 1 + nparam + 2 * (d + 1) + n_div;
 503
 504         for (i = 0; i < n_div + d + 1; ++i) {
 505                 k = isl_basic_map_alloc_div(path);
 506                 if (k < 0)
 507                         goto error;
 508                 isl_int_set_si(path->div[k][0], 0);
 509         }
 510
 511         for (i = 0; i < d + 1; ++i) {
 512                 k = isl_basic_map_alloc_equality(path);
 513                 if (k < 0)
 514                         goto error;
 515                 isl_seq_clr(path->eq[k], 1 + isl_basic_map_total_dim(path));
 516                 isl_int_set_si(path->eq[k][1 + nparam + i], 1);
 517                 isl_int_set_si(path->eq[k][1 + nparam + d + 1 + i], -1);
 518                 isl_int_set_si(path->eq[k][off + i], 1);
 519         }
 520
 521         div_purity = get_div_purity(delta);
 522         if (!div_purity)
 523                 goto error;
 524
 525         path = add_delta_constraints(path, delta, off, nparam, d, div_purity, 1);
 526         path = add_delta_constraints(path, delta, off, nparam, d, div_purity, 0);
 527
 528         is_id = empty_path_is_identity(path, off + d);
 529         if (is_id < 0)
 530                 goto error;
 531
 532         k = isl_basic_map_alloc_inequality(path);
 533         if (k < 0)
 534                 goto error;
 535         isl_seq_clr(path->ineq[k], 1 + isl_basic_map_total_dim(path));
 536         if (!is_id)
 537                 isl_int_set_si(path->ineq[k][0], -1);
 538         isl_int_set_si(path->ineq[k][off + d], 1);
 539
 540         free(div_purity);
 541         isl_basic_set_free(delta);
 542         path = isl_basic_map_finalize(path);
 543         if (is_id) {
 544                 isl_dim_free(dim);
 545                 return isl_map_from_basic_map(path);
 546         }
 547         return isl_basic_map_union(path,
 548                                 isl_basic_map_identity(isl_dim_domain(dim)));
 549 error:
 550         free(div_purity);
 551         isl_dim_free(dim);
 552         isl_basic_set_free(delta);
 553         isl_basic_map_free(path);
 554         return NULL;
 555 }
 556
 557 /* Given a dimenion specification Z^{n+1} -> Z^{n+1} and a parameter "param",
 558  * construct a map that equates the parameter to the difference
 559  * in the final coordinates and imposes that this difference is positive.
 560  * That is, construct
 561  *
 562  *      { [x,x_s] -> [y,y_s] : k = y_s - x_s > 0 }
 563  */
 564 static __isl_give isl_map *equate_parameter_to_length(__isl_take isl_dim *dim,
 565         unsigned param)
 566 {
 567         struct isl_basic_map *bmap;
 568         unsigned d;
 569         unsigned nparam;
 570         int k;
 571
 572         d = isl_dim_size(dim, isl_dim_in);
 573         nparam = isl_dim_size(dim, isl_dim_param);
 574         bmap = isl_basic_map_alloc_dim(dim, 0, 1, 1);
 575         k = isl_basic_map_alloc_equality(bmap);
 576         if (k < 0)
 577                 goto error;
 578         isl_seq_clr(bmap->eq[k], 1 + isl_basic_map_total_dim(bmap));
 579         isl_int_set_si(bmap->eq[k][1 + param], -1);
 580         isl_int_set_si(bmap->eq[k][1 + nparam + d - 1], -1);
 581         isl_int_set_si(bmap->eq[k][1 + nparam + d + d - 1], 1);
 582
 583         k = isl_basic_map_alloc_inequality(bmap);
 584         if (k < 0)
 585                 goto error;
 586         isl_seq_clr(bmap->ineq[k], 1 + isl_basic_map_total_dim(bmap));
 587         isl_int_set_si(bmap->ineq[k][1 + param], 1);
 588         isl_int_set_si(bmap->ineq[k][0], -1);
 589
 590         bmap = isl_basic_map_finalize(bmap);
 591         return isl_map_from_basic_map(bmap);
 592 error:
 593         isl_basic_map_free(bmap);
 594         return NULL;
 595 }
 596
 597 /* Check whether "path" is acyclic, where the last coordinates of domain
 598  * and range of path encode the number of steps taken.
 599  * That is, check whether
 600  *
 601  *      { d | d = y - x and (x,y) in path }
 602  *
 603  * does not contain any element with positive last coordinate (positive length)
 604  * and zero remaining coordinates (cycle).
 605  */
 606 static int is_acyclic(__isl_take isl_map *path)
 607 {
 608         int i;
 609         int acyclic;
 610         unsigned dim;
 611         struct isl_set *delta;
 612
 613         delta = isl_map_deltas(path);
 614         dim = isl_set_dim(delta, isl_dim_set);
 615         for (i = 0; i < dim; ++i) {
 616                 if (i == dim -1)
 617                         delta = isl_set_lower_bound_si(delta, isl_dim_set, i, 1);
 618                 else
 619                         delta = isl_set_fix_si(delta, isl_dim_set, i, 0);
 620         }
 621
 622         acyclic = isl_set_is_empty(delta);
 623         isl_set_free(delta);
 624
 625         return acyclic;
 626 }
 627
 628 /* Given a union of basic maps R = \cup_i R_i \subseteq D \times D
 629  * and a dimension specification (Z^{n+1} -> Z^{n+1}),
 630  * construct a map that is an overapproximation of the map
 631  * that takes an element from the space D \times Z to another
 632  * element from the same space, such that the first n coordinates of the
 633  * difference between them is a sum of differences between images
 634  * and pre-images in one of the R_i and such that the last coordinate
 635  * is equal to the number of steps taken.
 636  * That is, let
 637  *
 638  *      \Delta_i = { y - x | (x, y) in R_i }
 639  *
 640  * then the constructed map is an overapproximation of
 641  *
 642  *      { (x) -> (x + d) | \exists k_i >= 0, \delta_i \in \Delta_i :
 643  *                              d = (\sum_i k_i \delta_i, \sum_i k_i) }
 644  *
 645  * The elements of the singleton \Delta_i's are collected as the
 646  * rows of the steps matrix.  For all these \Delta_i's together,
 647  * a single path is constructed.
 648  * For each of the other \Delta_i's, we compute an overapproximation
 649  * of the paths along elements of \Delta_i.
 650  * Since each of these paths performs an addition, composition is
 651  * symmetric and we can simply compose all resulting paths in any order.
 652  */
 653 static __isl_give isl_map *construct_extended_path(__isl_take isl_dim *dim,
 654         __isl_keep isl_map *map, int *project)
 655 {
 656         struct isl_mat *steps = NULL;
 657         struct isl_map *path = NULL;
 658         unsigned d;
 659         int i, j, n;
 660
 661         d = isl_map_dim(map, isl_dim_in);
 662
 663         path = isl_map_identity(isl_dim_domain(isl_dim_copy(dim)));
 664
 665         steps = isl_mat_alloc(map->ctx, map->n, d);
 666         if (!steps)
 667                 goto error;
 668
 669         n = 0;
 670         for (i = 0; i < map->n; ++i) {
 671                 struct isl_basic_set *delta;
 672
 673                 delta = isl_basic_map_deltas(isl_basic_map_copy(map->p[i]));
 674
 675                 for (j = 0; j < d; ++j) {
 676                         int fixed;
 677
 678                         fixed = isl_basic_set_fast_dim_is_fixed(delta, j,
 679                                                             &steps->row[n][j]);
 680                         if (fixed < 0) {
 681                                 isl_basic_set_free(delta);
 682                                 goto error;
 683                         }
 684                         if (!fixed)
 685                                 break;
 686                 }
 687
 688
 689                 if (j < d) {
 690                         path = isl_map_apply_range(path,
 691                                 path_along_delta(isl_dim_copy(dim), delta));
 692                         path = isl_map_coalesce(path);
 693                 } else {
 694                         isl_basic_set_free(delta);
 695                         ++n;
 696                 }
 697         }
 698
 699         if (n > 0) {
 700                 steps->n_row = n;
 701                 path = isl_map_apply_range(path,
 702                                 path_along_steps(isl_dim_copy(dim), steps));
 703         }
 704
 705         if (project && *project) {
 706                 *project = is_acyclic(isl_map_copy(path));
 707                 if (*project < 0)
 708                         goto error;
 709         }
 710
 711         isl_dim_free(dim);
 712         isl_mat_free(steps);
 713         return path;
 714 error:
 715         isl_dim_free(dim);
 716         isl_mat_free(steps);
 717         isl_map_free(path);
 718         return NULL;
 719 }
 720
 721 /* Given a union of basic maps R = \cup_i R_i \subseteq D \times D
 722  * and a dimension specification (Z^{n+1} -> Z^{n+1}),
 723  * construct a map that is an overapproximation of the map
 724  * that takes an element from the dom R \times Z to an
 725  * element from ran R \times Z, such that the first n coordinates of the
 726  * difference between them is a sum of differences between images
 727  * and pre-images in one of the R_i and such that the last coordinate
 728  * is equal to the number of steps taken.
 729  * That is, let
 730  *
 731  *      \Delta_i = { y - x | (x, y) in R_i }
 732  *
 733  * then the constructed map is an overapproximation of
 734  *
 735  *      { (x) -> (x + d) | \exists k_i >= 1, \delta_i \in \Delta_i :
 736  *                              d = (\sum_i k_i \delta_i, \sum_i k_i) and
 737  *                              x in dom R and x + d in ran R }
 738  */
 739 static __isl_give isl_map *construct_component(__isl_take isl_dim *dim,
 740         __isl_keep isl_map *map, int *exact, int project)
 741 {
 742         struct isl_set *domain = NULL;
 743         struct isl_set *range = NULL;
 744         struct isl_set *overlap;
 745         struct isl_map *app = NULL;
 746         struct isl_map *path = NULL;
 747
 748         domain = isl_map_domain(isl_map_copy(map));
 749         domain = isl_set_coalesce(domain);
 750         range = isl_map_range(isl_map_copy(map));
 751         range = isl_set_coalesce(range);
 752         overlap = isl_set_intersect(isl_set_copy(domain), isl_set_copy(range));
 753         if (isl_set_is_empty(overlap) == 1) {
 754                 isl_set_free(domain);
 755                 isl_set_free(range);
 756                 isl_set_free(overlap);
 757                 isl_dim_free(dim);
 758
 759                 map = isl_map_copy(map);
 760                 map = isl_map_add(map, isl_dim_in, 1);
 761                 map = isl_map_add(map, isl_dim_out, 1);
 762                 map = set_path_length(map, 1, 1);
 763                 return map;
 764         }
 765         isl_set_free(overlap);
 766         app = isl_map_from_domain_and_range(domain, range);
 767         app = isl_map_add(app, isl_dim_in, 1);
 768         app = isl_map_add(app, isl_dim_out, 1);
 769
 770         path = construct_extended_path(isl_dim_copy(dim), map,
 771                                         exact && *exact ? &project : NULL);
 772         app = isl_map_intersect(app, path);
 773
 774         if (exact && *exact &&
 775             (*exact = check_exactness(isl_map_copy(map), isl_map_copy(app),
 776                                       project)) < 0)
 777                 goto error;
 778
 779         isl_dim_free(dim);
 780         app = set_path_length(app, 0, 1);
 781         return app;
 782 error:
 783         isl_dim_free(dim);
 784         isl_map_free(app);
 785         return NULL;
 786 }
 787
 788 /* Call construct_component and, if "project" is set, project out
 789  * the final coordinates.
 790  */
 791 static __isl_give isl_map *construct_projected_component(
 792         __isl_take isl_dim *dim,
 793         __isl_keep isl_map *map, int *exact, int project)
 794 {
 795         isl_map *app;
 796         unsigned d;
 797
 798         if (!dim)
 799                 return NULL;
 800         d = isl_dim_size(dim, isl_dim_in);
 801
 802         app = construct_component(dim, map, exact, project);
 803         if (project) {
 804                 app = isl_map_project_out(app, isl_dim_in, d - 1, 1);
 805                 app = isl_map_project_out(app, isl_dim_out, d - 1, 1);
 806         }
 807         return app;
 808 }
 809
 810 /* Structure for representing the nodes in the graph being traversed
 811  * using Tarjan's algorithm.
 812  * index represents the order in which nodes are visited.
 813  * min_index is the index of the root of a (sub)component.
 814  * on_stack indicates whether the node is currently on the stack.
 815  */
 816 struct basic_map_sort_node {
 817         int index;
 818         int min_index;
 819         int on_stack;
 820 };
 821 /* Structure for representing the graph being traversed
 822  * using Tarjan's algorithm.
 823  * len is the number of nodes
 824  * node is an array of nodes
 825  * stack contains the nodes on the path from the root to the current node
 826  * sp is the stack pointer
 827  * index is the index of the last node visited
 828  * order contains the elements of the components separated by -1
 829  * op represents the current position in order
 830  */
 831 struct basic_map_sort {
 832         int len;
 833         struct basic_map_sort_node *node;
 834         int *stack;
 835         int sp;
 836         int index;
 837         int *order;
 838         int op;
 839 };
 840
 841 static void basic_map_sort_free(struct basic_map_sort *s)
 842 {
 843         if (!s)
 844                 return;
 845         free(s->node);
 846         free(s->stack);
 847         free(s->order);
 848         free(s);
 849 }
 850
 851 static struct basic_map_sort *basic_map_sort_alloc(struct isl_ctx *ctx, int len)
 852 {
 853         struct basic_map_sort *s;
 854         int i;
 855
 856         s = isl_calloc_type(ctx, struct basic_map_sort);
 857         if (!s)
 858                 return NULL;
 859         s->len = len;
 860         s->node = isl_alloc_array(ctx, struct basic_map_sort_node, len);
 861         if (!s->node)
 862                 goto error;
 863         for (i = 0; i < len; ++i)
 864                 s->node[i].index = -1;
 865         s->stack = isl_alloc_array(ctx, int, len);
 866         if (!s->stack)
 867                 goto error;
 868         s->order = isl_alloc_array(ctx, int, 2 * len);
 869         if (!s->order)
 870                 goto error;
 871
 872         s->sp = 0;
 873         s->index = 0;
 874         s->op = 0;
 875
 876         return s;
 877 error:
 878         basic_map_sort_free(s);
 879         return NULL;
 880 }
 881
 882 /* Check whether in the computation of the transitive closure
 883  * "bmap1" (R_1) should follow (or be part of the same component as)
 884  * "bmap2" (R_2).
 885  *
 886  * That is check whether
 887  *
 888  *      R_1 \circ R_2
 889  *
 890  * is a subset of
 891  *
 892  *      R_2 \circ R_1
 893  *
 894  * If so, then there is no reason for R_1 to immediately follow R_2
 895  * in any path.
 896  */
 897 static int basic_map_follows(__isl_keep isl_basic_map *bmap1,
 898         __isl_keep isl_basic_map *bmap2)
 899 {
 900         struct isl_map *map12 = NULL;
 901         struct isl_map *map21 = NULL;
 902         int subset;
 903
 904         map21 = isl_map_from_basic_map(
 905                         isl_basic_map_apply_range(
 906                                 isl_basic_map_copy(bmap2),
 907                                 isl_basic_map_copy(bmap1)));
 908         subset = isl_map_is_empty(map21);
 909         if (subset < 0)
 910                 goto error;
 911         if (subset) {
 912                 isl_map_free(map21);
 913                 return 0;
 914         }
 915
 916         map12 = isl_map_from_basic_map(
 917                         isl_basic_map_apply_range(
 918                                 isl_basic_map_copy(bmap1),
 919                                 isl_basic_map_copy(bmap2)));
 920
 921         subset = isl_map_is_subset(map21, map12);
 922
 923         isl_map_free(map12);
 924         isl_map_free(map21);
 925
 926         return subset < 0 ? -1 : !subset;
 927 error:
 928         isl_map_free(map21);
 929         return -1;
 930 }
 931
 932 /* Perform Tarjan's algorithm for computing the strongly connected components
 933  * in the graph with the disjuncts of "map" as vertices and with an
 934  * edge between any pair of disjuncts such that the first has
 935  * to be applied after the second.
 936  */
 937 static int power_components_tarjan(struct basic_map_sort *s,
 938         __isl_keep isl_map *map, int i)
 939 {
 940         int j;
 941
 942         s->node[i].index = s->index;
 943         s->node[i].min_index = s->index;
 944         s->node[i].on_stack = 1;
 945         s->index++;
 946         s->stack[s->sp++] = i;
 947
 948         for (j = s->len - 1; j >= 0; --j) {
 949                 int f;
 950
 951                 if (j == i)
 952                         continue;
 953                 if (s->node[j].index >= 0 &&
 954                         (!s->node[j].on_stack ||
 955                          s->node[j].index > s->node[i].min_index))
 956                         continue;
 957
 958                 f = basic_map_follows(map->p[i], map->p[j]);
 959                 if (f < 0)
 960                         return -1;
 961                 if (!f)
 962                         continue;
 963
 964                 if (s->node[j].index < 0) {
 965                         power_components_tarjan(s, map, j);
 966                         if (s->node[j].min_index < s->node[i].min_index)
 967                                 s->node[i].min_index = s->node[j].min_index;
 968                 } else if (s->node[j].index < s->node[i].min_index)
 969                         s->node[i].min_index = s->node[j].index;
 970         }
 971
 972         if (s->node[i].index != s->node[i].min_index)
 973                 return 0;
 974
 975         do {
 976                 j = s->stack[--s->sp];
 977                 s->node[j].on_stack = 0;
 978                 s->order[s->op++] = j;
 979         } while (j != i);
 980         s->order[s->op++] = -1;
 981
 982         return 0;
 983 }
 984
 985 /* Given a union of basic maps R = \cup_i R_i \subseteq D \times D
 986  * and a dimension specification (Z^{n+1} -> Z^{n+1}),
 987  * construct a map that is an overapproximation of the map
 988  * that takes an element from the dom R \times Z to an
 989  * element from ran R \times Z, such that the first n coordinates of the
 990  * difference between them is a sum of differences between images
 991  * and pre-images in one of the R_i and such that the last coordinate
 992  * is equal to the number of steps taken.
 993  * If "project" is set, then these final coordinates are not included,
 994  * i.e., a relation of type Z^n -> Z^n is returned.
 995  * That is, let
 996  *
 997  *      \Delta_i = { y - x | (x, y) in R_i }
 998  *
 999  * then the constructed map is an overapproximation of
1000  *
1001  *      { (x) -> (x + d) | \exists k_i >= 0, \delta_i \in \Delta_i :
1002  *                              d = (\sum_i k_i \delta_i, \sum_i k_i) and
1003  *                              x in dom R and x + d in ran R }
1004  *
1005  * or
1006  *
1007  *      { (x) -> (x + d) | \exists k_i >= 0, \delta_i \in \Delta_i :
1008  *                              d = (\sum_i k_i \delta_i) and
1009  *                              x in dom R and x + d in ran R }
1010  *
1011  * if "project" is set.
1012  *
1013  * We first split the map into strongly connected components, perform
1014  * the above on each component and then join the results in the correct
1015  * order, at each join also taking in the union of both arguments
1016  * to allow for paths that do not go through one of the two arguments.
1017  */
1018 static __isl_give isl_map *construct_power_components(__isl_take isl_dim *dim,
1019         __isl_keep isl_map *map, int *exact, int project)
1020 {
1021         int i, n;
1022         struct isl_map *path = NULL;
1023         struct basic_map_sort *s = NULL;
1024
1025         if (!map)
1026                 goto error;
1027         if (map->n <= 1)
1028                 return construct_projected_component(dim, map, exact, project);
1029
1030         s = basic_map_sort_alloc(map->ctx, map->n);
1031         if (!s)
1032                 goto error;
1033         for (i = map->n - 1; i >= 0; --i) {
1034                 if (s->node[i].index >= 0)
1035                         continue;
1036                 if (power_components_tarjan(s, map, i) < 0)
1037                         goto error;
1038         }
1039
1040         i = 0;
1041         n = map->n;
1042         if (project)
1043                 path = isl_map_empty(isl_map_get_dim(map));
1044         else
1045                 path = isl_map_empty(isl_dim_copy(dim));
1046         while (n) {
1047                 struct isl_map *comp;
1048                 isl_map *path_comp, *path_comb;
1049                 comp = isl_map_alloc_dim(isl_map_get_dim(map), n, 0);
1050                 while (s->order[i] != -1) {
1051                         comp = isl_map_add_basic_map(comp,
1052                                     isl_basic_map_copy(map->p[s->order[i]]));
1053                         --n;
1054                         ++i;
1055                 }
1056                 path_comp = construct_projected_component(isl_dim_copy(dim),
1057                                                 comp, exact, project);
1058                 path_comb = isl_map_apply_range(isl_map_copy(path),
1059                                                 isl_map_copy(path_comp));
1060                 path = isl_map_union(path, path_comp);
1061                 path = isl_map_union(path, path_comb);
1062                 isl_map_free(comp);
1063                 ++i;
1064         }
1065
1066         basic_map_sort_free(s);
1067         isl_dim_free(dim);
1068
1069         return path;
1070 error:
1071         basic_map_sort_free(s);
1072         isl_dim_free(dim);
1073         return NULL;
1074 }
1075
1076 /* Given a union of basic maps R = \cup_i R_i \subseteq D \times D,
1077  * construct a map that is an overapproximation of the map
1078  * that takes an element from the space D to another
1079  * element from the same space, such that the difference between
1080  * them is a strictly positive sum of differences between images
1081  * and pre-images in one of the R_i.
1082  * The number of differences in the sum is equated to parameter "param".
1083  * That is, let
1084  *
1085  *      \Delta_i = { y - x | (x, y) in R_i }
1086  *
1087  * then the constructed map is an overapproximation of
1088  *
1089  *      { (x) -> (x + d) | \exists k_i >= 0, \delta_i \in \Delta_i :
1090  *                              d = \sum_i k_i \delta_i and k = \sum_i k_i > 0 }
1091  * or
1092  *
1093  *      { (x) -> (x + d) | \exists k_i >= 0, \delta_i \in \Delta_i :
1094  *                              d = \sum_i k_i \delta_i and \sum_i k_i > 0 }
1095  *
1096  * if "project" is set.
1097  *
1098  * If "project" is not set, then
1099  * we first construct an extended mapping with an extra coordinate
1100  * that indicates the number of steps taken.  In particular,
1101  * the difference in the last coordinate is equal to the number
1102  * of steps taken to move from a domain element to the corresponding
1103  * image element(s).
1104  * In the final step, this difference is equated to the parameter "param"
1105  * and made positive.  The extra coordinates are subsequently projected out.
1106  */
1107 static __isl_give isl_map *construct_power(__isl_keep isl_map *map,
1108         unsigned param, int *exact, int project)
1109 {
1110         struct isl_map *app = NULL;
1111         struct isl_map *diff;
1112         struct isl_dim *dim = NULL;
1113         unsigned d;
1114
1115         if (!map)
1116                 return NULL;
1117
1118         dim = isl_map_get_dim(map);
1119
1120         d = isl_dim_size(dim, isl_dim_in);
1121         dim = isl_dim_add(dim, isl_dim_in, 1);
1122         dim = isl_dim_add(dim, isl_dim_out, 1);
1123
1124         app = construct_power_components(isl_dim_copy(dim), map,
1125                                         exact, project);
1126
1127         if (project) {
1128                 isl_dim_free(dim);
1129         } else {
1130                 diff = equate_parameter_to_length(dim, param);
1131                 app = isl_map_intersect(app, diff);
1132                 app = isl_map_project_out(app, isl_dim_in, d, 1);
1133                 app = isl_map_project_out(app, isl_dim_out, d, 1);
1134         }
1135
1136         return app;
1137 }
1138
1139 /* Compute the positive powers of "map", or an overapproximation.
1140  * The power is given by parameter "param".  If the result is exact,
1141  * then *exact is set to 1.
1142  *
1143  * If project is set, then we are actually interested in the transitive
1144  * closure, so we can use a more relaxed exactness check.
1145  * The lengths of the paths are also projected out instead of being
1146  * equated to "param" (which is then ignored in this case).
1147  */
1148 static __isl_give isl_map *map_power(__isl_take isl_map *map, unsigned param,
1149         int *exact, int project)
1150 {
1151         struct isl_map *app = NULL;
1152
1153         if (exact)
1154                 *exact = 1;
1155
1156         map = isl_map_coalesce(map);
1157         if (!map)
1158                 return NULL;
1159
1160         if (isl_map_fast_is_empty(map))
1161                 return map;
1162
1163         isl_assert(map->ctx, project || param < isl_map_dim(map, isl_dim_param),
1164                 goto error);
1165         isl_assert(map->ctx,
1166                 isl_map_dim(map, isl_dim_in) == isl_map_dim(map, isl_dim_out),
1167                 goto error);
1168
1169         app = construct_power(map, param, exact, project);
1170
1171         isl_map_free(map);
1172         return app;
1173 error:
1174         isl_map_free(map);
1175         isl_map_free(app);
1176         return NULL;
1177 }
1178
1179 /* Compute the positive powers of "map", or an overapproximation.
1180  * The power is given by parameter "param".  If the result is exact,
1181  * then *exact is set to 1.
1182  */
1183 __isl_give isl_map *isl_map_power(__isl_take isl_map *map, unsigned param,
1184         int *exact)
1185 {
1186         return map_power(map, param, exact, 0);
1187 }
1188
1189 /* Check whether equality i of bset is a pure stride constraint
1190  * on a single dimensions, i.e., of the form
1191  *
1192  *      v = k e
1193  *
1194  * with k a constant and e an existentially quantified variable.
1195  */
1196 static int is_eq_stride(__isl_keep isl_basic_set *bset, int i)
1197 {
1198         int k;
1199         unsigned nparam;
1200         unsigned d;
1201         unsigned n_div;
1202         int pos1;
1203         int pos2;
1204
1205         if (!bset)
1206                 return -1;
1207
1208         if (!isl_int_is_zero(bset->eq[i][0]))
1209                 return 0;
1210
1211         nparam = isl_basic_set_dim(bset, isl_dim_param);
1212         d = isl_basic_set_dim(bset, isl_dim_set);
1213         n_div = isl_basic_set_dim(bset, isl_dim_div);
1214
1215         if (isl_seq_first_non_zero(bset->eq[i] + 1, nparam) != -1)
1216                 return 0;
1217         pos1 = isl_seq_first_non_zero(bset->eq[i] + 1 + nparam, d);
1218         if (pos1 == -1)
1219                 return 0;
1220         if (isl_seq_first_non_zero(bset->eq[i] + 1 + nparam + pos1 + 1,
1221                                         d - pos1 - 1) != -1)
1222                 return 0;
1223
1224         pos2 = isl_seq_first_non_zero(bset->eq[i] + 1 + nparam + d, n_div);
1225         if (pos2 == -1)
1226                 return 0;
1227         if (isl_seq_first_non_zero(bset->eq[i] + 1 + nparam + d  + pos2 + 1,
1228                                    n_div - pos2 - 1) != -1)
1229                 return 0;
1230         if (!isl_int_is_one(bset->eq[i][1 + nparam + pos1]) &&
1231             !isl_int_is_negone(bset->eq[i][1 + nparam + pos1]))
1232                 return 0;
1233
1234         return 1;
1235 }
1236
1237 /* Given a map, compute the smallest superset of this map that is of the form
1238  *
1239  *      { i -> j : L <= j - i <= U and exists a_p: j_p - i_p = M_p a_p }
1240  *
1241  * (where p ranges over the (non-parametric) dimensions),
1242  * compute the transitive closure of this map, i.e.,
1243  *
1244  *      { i -> j : exists k > 0:
1245  *              k L <= j - i <= k U and exists a: j_p - i_p = M_p a_p }
1246  *
1247  * and intersect domain and range of this transitive closure with
1248  * domain and range of the original map.
1249  *
1250  * If with_id is set, then try to include as much of the identity mapping
1251  * as possible, by computing
1252  *
1253  *      { i -> j : exists k >= 0:
1254  *              k L <= j - i <= k U and exists a: j_p - i_p = M_p a_p }
1255  *
1256  * instead (i.e., allow k = 0) and by intersecting domain and range
1257  * with the union of the domain and the range of the original map.
1258  *
1259  * In practice, we compute the difference set
1260  *
1261  *      delta  = { j - i | i -> j in map },
1262  *
1263  * look for stride constraint on the individual dimensions and compute
1264  * (constant) lower and upper bounds for each individual dimension,
1265  * adding a constraint for each bound not equal to infinity.
1266  */
1267 static __isl_give isl_map *box_closure(__isl_take isl_map *map, int with_id)
1268 {
1269         int i;
1270         int k;
1271         unsigned d;
1272         unsigned nparam;
1273         unsigned total;
1274         isl_dim *dim;
1275         isl_set *delta;
1276         isl_set *domain = NULL;
1277         isl_set *range = NULL;
1278         isl_map *app = NULL;
1279         isl_basic_set *aff = NULL;
1280         isl_basic_map *bmap = NULL;
1281         isl_vec *obj = NULL;
1282         isl_int opt;
1283
1284         isl_int_init(opt);
1285
1286         delta = isl_map_deltas(isl_map_copy(map));
1287
1288         aff = isl_set_affine_hull(isl_set_copy(delta));
1289         if (!aff)
1290                 goto error;
1291         dim = isl_map_get_dim(map);
1292         d = isl_dim_size(dim, isl_dim_in);
1293         nparam = isl_dim_size(dim, isl_dim_param);
1294         total = isl_dim_total(dim);
1295         bmap = isl_basic_map_alloc_dim(dim,
1296                                         aff->n_div + 1, aff->n_div, 2 * d + 1);
1297         for (i = 0; i < aff->n_div + 1; ++i) {
1298                 k = isl_basic_map_alloc_div(bmap);
1299                 if (k < 0)
1300                         goto error;
1301                 isl_int_set_si(bmap->div[k][0], 0);
1302         }
1303         for (i = 0; i < aff->n_eq; ++i) {
1304                 if (!is_eq_stride(aff, i))
1305                         continue;
1306                 k = isl_basic_map_alloc_equality(bmap);
1307                 if (k < 0)
1308                         goto error;
1309                 isl_seq_clr(bmap->eq[k], 1 + nparam);
1310                 isl_seq_cpy(bmap->eq[k] + 1 + nparam + d,
1311                                 aff->eq[i] + 1 + nparam, d);
1312                 isl_seq_neg(bmap->eq[k] + 1 + nparam,
1313                                 aff->eq[i] + 1 + nparam, d);
1314                 isl_seq_cpy(bmap->eq[k] + 1 + nparam + 2 * d,
1315                                 aff->eq[i] + 1 + nparam + d, aff->n_div);
1316                 isl_int_set_si(bmap->eq[k][1 + total + aff->n_div], 0);
1317         }
1318         obj = isl_vec_alloc(map->ctx, 1 + nparam + d);
1319         if (!obj)
1320                 goto error;
1321         isl_seq_clr(obj->el, 1 + nparam + d);
1322         for (i = 0; i < d; ++ i) {
1323                 enum isl_lp_result res;
1324
1325                 isl_int_set_si(obj->el[1 + nparam + i], 1);
1326
1327                 res = isl_set_solve_lp(delta, 0, obj->el, map->ctx->one, &opt,
1328                                         NULL, NULL);
1329                 if (res == isl_lp_error)
1330                         goto error;
1331                 if (res == isl_lp_ok) {
1332                         k = isl_basic_map_alloc_inequality(bmap);
1333                         if (k < 0)
1334                                 goto error;
1335                         isl_seq_clr(bmap->ineq[k],
1336                                         1 + nparam + 2 * d + bmap->n_div);
1337                         isl_int_set_si(bmap->ineq[k][1 + nparam + i], -1);
1338                         isl_int_set_si(bmap->ineq[k][1 + nparam + d + i], 1);
1339                         isl_int_neg(bmap->ineq[k][1 + nparam + 2 * d + aff->n_div], opt);
1340                 }
1341
1342                 res = isl_set_solve_lp(delta, 1, obj->el, map->ctx->one, &opt,
1343                                         NULL, NULL);
1344                 if (res == isl_lp_error)
1345                         goto error;
1346                 if (res == isl_lp_ok) {
1347                         k = isl_basic_map_alloc_inequality(bmap);
1348                         if (k < 0)
1349                                 goto error;
1350                         isl_seq_clr(bmap->ineq[k],
1351                                         1 + nparam + 2 * d + bmap->n_div);
1352                         isl_int_set_si(bmap->ineq[k][1 + nparam + i], 1);
1353                         isl_int_set_si(bmap->ineq[k][1 + nparam + d + i], -1);
1354                         isl_int_set(bmap->ineq[k][1 + nparam + 2 * d + aff->n_div], opt);
1355                 }
1356
1357                 isl_int_set_si(obj->el[1 + nparam + i], 0);
1358         }
1359         k = isl_basic_map_alloc_inequality(bmap);
1360         if (k < 0)
1361                 goto error;
1362         isl_seq_clr(bmap->ineq[k],
1363                         1 + nparam + 2 * d + bmap->n_div);
1364         if (!with_id)
1365                 isl_int_set_si(bmap->ineq[k][0], -1);
1366         isl_int_set_si(bmap->ineq[k][1 + nparam + 2 * d + aff->n_div], 1);
1367
1368         domain = isl_map_domain(isl_map_copy(map));
1369         domain = isl_set_coalesce(domain);
1370         range = isl_map_range(isl_map_copy(map));
1371         range = isl_set_coalesce(range);
1372         if (with_id) {
1373                 domain = isl_set_union(domain, range);
1374                 domain = isl_set_coalesce(domain);
1375                 range = isl_set_copy(domain);
1376         }
1377         app = isl_map_from_domain_and_range(domain, range);
1378
1379         isl_vec_free(obj);
1380         isl_basic_set_free(aff);
1381         isl_map_free(map);
1382         bmap = isl_basic_map_finalize(bmap);
1383         isl_set_free(delta);
1384         isl_int_clear(opt);
1385
1386         map = isl_map_from_basic_map(bmap);
1387         map = isl_map_intersect(map, app);
1388
1389         return map;
1390 error:
1391         isl_vec_free(obj);
1392         isl_basic_map_free(bmap);
1393         isl_basic_set_free(aff);
1394         isl_map_free(map);
1395         isl_set_free(delta);
1396         isl_int_clear(opt);
1397         return NULL;
1398 }
1399
1400 /* Check whether app is the transitive closure of map.
1401  * In particular, check that app is acyclic and, if so,
1402  * check that
1403  *
1404  *      app \subset (map \cup (map \circ app))
1405  */
1406 static int check_exactness_omega(__isl_keep isl_map *map,
1407         __isl_keep isl_map *app)
1408 {
1409         isl_set *delta;
1410         int i;
1411         int is_empty, is_exact;
1412         unsigned d;
1413         isl_map *test;
1414
1415         delta = isl_map_deltas(isl_map_copy(app));
1416         d = isl_set_dim(delta, isl_dim_set);
1417         for (i = 0; i < d; ++i)
1418                 delta = isl_set_fix_si(delta, isl_dim_set, i, 0);
1419         is_empty = isl_set_is_empty(delta);
1420         isl_set_free(delta);
1421         if (is_empty < 0)
1422                 return -1;
1423         if (!is_empty)
1424                 return 0;
1425
1426         test = isl_map_apply_range(isl_map_copy(app), isl_map_copy(map));
1427         test = isl_map_union(test, isl_map_copy(map));
1428         is_exact = isl_map_is_subset(app, test);
1429         isl_map_free(test);
1430
1431         return is_exact;
1432 }
1433
1434 /* Check if basic map M_i can be combined with all the other
1435  * basic maps such that
1436  *
1437  *      (\cup_j M_j)^+
1438  *
1439  * can be computed as
1440  *
1441  *      M_i \cup (\cup_{j \ne i} M_i^* \circ M_j \circ M_i^*)^+
1442  *
1443  * In particular, check if we can compute a compact representation
1444  * of
1445  *
1446  *              M_i^* \circ M_j \circ M_i^*
1447  *
1448  * for each j != i.
1449  * Let M_i^? be an extension of M_i^+ that allows paths
1450  * of length zero, i.e., the result of box_closure(., 1).
1451  * The criterion, as proposed by Kelly et al., is that
1452  * id = M_i^? - M_i^+ can be represented as a basic map
1453  * and that
1454  *
1455  *      id \circ M_j \circ id = M_j
1456  *
1457  * for each j != i.
1458  *
1459  * If this function returns 1, then tc and qc are set to
1460  * M_i^+ and M_i^?, respectively.
1461  */
1462 static int can_be_split_off(__isl_keep isl_map *map, int i,
1463         __isl_give isl_map **tc, __isl_give isl_map **qc)
1464 {
1465         isl_map *map_i, *id;
1466         int j = -1;
1467
1468         map_i = isl_map_from_basic_map(isl_basic_map_copy(map->p[i]));
1469         *tc = box_closure(isl_map_copy(map_i), 0);
1470         *qc = box_closure(map_i, 1);
1471         id = isl_map_subtract(isl_map_copy(*qc), isl_map_copy(*tc));
1472
1473         if (!id || !*qc)
1474                 goto error;
1475         if (id->n != 1 || (*qc)->n != 1)
1476                 goto done;
1477
1478         for (j = 0; j < map->n; ++j) {
1479                 isl_map *map_j, *test;
1480                 int is_ok;
1481
1482                 if (i == j)
1483                         continue;
1484                 map_j = isl_map_from_basic_map(
1485                                         isl_basic_map_copy(map->p[j]));
1486                 test = isl_map_apply_range(isl_map_copy(id),
1487                                                 isl_map_copy(map_j));
1488                 test = isl_map_apply_range(test, isl_map_copy(id));
1489                 is_ok = isl_map_is_equal(test, map_j);
1490                 isl_map_free(map_j);
1491                 isl_map_free(test);
1492                 if (is_ok < 0)
1493                         goto error;
1494                 if (!is_ok)
1495                         break;
1496         }
1497
1498 done:
1499         isl_map_free(id);
1500         if (j == map->n)
1501                 return 1;
1502
1503         isl_map_free(*qc);
1504         isl_map_free(*tc);
1505         *qc = NULL;
1506         *tc = NULL;
1507
1508         return 0;
1509 error:
1510         isl_map_free(id);
1511         isl_map_free(*qc);
1512         isl_map_free(*tc);
1513         *qc = NULL;
1514         *tc = NULL;
1515         return -1;
1516 }
1517
1518 /* Compute an overapproximation of the transitive closure of "map"
1519  * using a variation of the algorithm from
1520  * "Transitive Closure of Infinite Graphs and its Applications"
1521  * by Kelly et al.
1522  *
1523  * We first check whether we can can split of any basic map M_i and
1524  * compute
1525  *
1526  *      (\cup_j M_j)^+
1527  *
1528  * as
1529  *
1530  *      M_i \cup (\cup_{j \ne i} M_i^* \circ M_j \circ M_i^*)^+
1531  *
1532  * using a recursive call on the remaining map.
1533  *
1534  * If not, we simply call box_closure on the whole map.
1535  */
1536 static __isl_give isl_map *compute_closure_omega(__isl_take isl_map *map)
1537 {
1538         int i, j;
1539
1540         if (!map)
1541                 return NULL;
1542         if (map->n == 1)
1543                 return box_closure(map, 0);
1544
1545         map = isl_map_cow(map);
1546         if (!map)
1547                 goto error;
1548
1549         for (i = 0; i < map->n; ++i) {
1550                 int ok;
1551                 isl_map *qc, *tc;
1552                 ok = can_be_split_off(map, i, &tc, &qc);
1553                 if (ok < 0)
1554                         goto error;
1555                 if (!ok)
1556                         continue;
1557
1558                 isl_basic_map_free(map->p[i]);
1559                 if (i != map->n - 1)
1560                         map->p[i] = map->p[map->n - 1];
1561                 map->n--;
1562
1563                 map = isl_map_apply_range(isl_map_copy(qc), map);
1564                 map = isl_map_apply_range(map, qc);
1565
1566                 return isl_map_union(tc, compute_closure_omega(map));
1567         }
1568
1569         return box_closure(map, 0);
1570 error:
1571         isl_map_free(map);
1572         return NULL;
1573 }
1574
1575 /* Compute an overapproximation of the transitive closure of "map"
1576  * using a variation of the algorithm from
1577  * "Transitive Closure of Infinite Graphs and its Applications"
1578  * by Kelly et al. and check whether the result is definitely exact.
1579  */
1580 static __isl_give isl_map *transitive_closure_omega(__isl_take isl_map *map,
1581         int *exact)
1582 {
1583         isl_map *app;
1584
1585         app = compute_closure_omega(isl_map_copy(map));
1586
1587         if (exact)
1588                 *exact = check_exactness_omega(map, app);
1589
1590         isl_map_free(map);
1591         return app;
1592 }
1593
1594 /* Compute the transitive closure  of "map", or an overapproximation.
1595  * If the result is exact, then *exact is set to 1.
1596  * Simply use map_power to compute the powers of map, but tell
1597  * it to project out the lengths of the paths instead of equating
1598  * the length to a parameter.
1599  */
1600 __isl_give isl_map *isl_map_transitive_closure(__isl_take isl_map *map,
1601         int *exact)
1602 {
1603         unsigned param;
1604
1605         if (!map)
1606                 goto error;
1607
1608         if (map->ctx->opt->closure == ISL_CLOSURE_OMEGA)
1609                 return transitive_closure_omega(map, exact);
1610
1611         param = isl_map_dim(map, isl_dim_param);
1612         map = map_power(map, param, exact, 1);
1613
1614         return map;
1615 error:
1616         isl_map_free(map);
1617         return NULL;
1618 }