isl_map.h File Reference

#include <stdio.h>
#include <isl_int.h>
#include <isl_ctx.h>
#include <isl_blk.h>
#include <isl_dim.h>

Define Documentation

#define ISL_BASIC_MAP_FINAL (1 << 0)

Definition at line 41 of file isl_map.h.

#define ISL_BASIC_MAP_EMPTY (1 << 1)

Definition at line 42 of file isl_map.h.

#define ISL_BASIC_MAP_NO_IMPLICIT (1 << 2)

Definition at line 43 of file isl_map.h.

#define ISL_BASIC_MAP_NO_REDUNDANT (1 << 3)

Definition at line 44 of file isl_map.h.

#define ISL_BASIC_MAP_RATIONAL (1 << 4)

Definition at line 45 of file isl_map.h.

#define ISL_BASIC_MAP_NORMALIZED (1 << 5)

Definition at line 46 of file isl_map.h.

#define ISL_BASIC_MAP_NORMALIZED_DIVS (1 << 6)

Definition at line 47 of file isl_map.h.

#define ISL_BASIC_MAP_ALL_EQUALITIES (1 << 7)

Definition at line 48 of file isl_map.h.

#define ISL_MAP_DISJOINT (1 << 0)

Definition at line 82 of file isl_map.h.

#define ISL_MAP_NORMALIZED (1 << 1)

Definition at line 83 of file isl_map.h.

#define ISL_FORMAT_POLYLIB 1

Definition at line 163 of file isl_map.h.

#define ISL_FORMAT_OMEGA 2

Definition at line 164 of file isl_map.h.

Function Documentation

unsigned isl_basic_map_n_in ( const struct isl_basic_map * bmap )

Definition at line 163 of file isl_map.c.

00164 {
00165         return bmap->dim->n_in;
00166 }

unsigned isl_basic_map_n_out ( const struct isl_basic_map * bmap )

Definition at line 168 of file isl_map.c.

00169 {
00170         return bmap->dim->n_out;
00171 }

unsigned isl_basic_map_n_param ( const struct isl_basic_map * bmap )

Definition at line 173 of file isl_map.c.

00174 {
00175         return bmap->dim->nparam;
00176 }

unsigned isl_basic_map_n_div ( const struct isl_basic_map * bmap )

Definition at line 178 of file isl_map.c.

00179 {
00180         return bmap->n_div;
00181 }

unsigned isl_basic_map_total_dim ( const struct isl_basic_map * bmap )

Definition at line 183 of file isl_map.c.

00184 {
00185         return isl_dim_total(bmap->dim) + bmap->n_div;
00186 }

unsigned isl_basic_map_dim	(	const struct isl_basic_map *	bmap,
		enum isl_dim_type	type
	)

Definition at line 92 of file isl_map.c.

00094 {
00095         struct isl_dim *dim = bmap->dim;
00096         switch (type) {
00097         case isl_dim_param:
00098         case isl_dim_in:
00099         case isl_dim_out:       return isl_dim_size(bmap->dim, type);
00100         case isl_dim_div:       return bmap->n_div;
00101         case isl_dim_all:       return isl_basic_map_total_dim(bmap);
00102         }
00103 }

unsigned isl_map_n_in ( const struct isl_map * map )

Definition at line 188 of file isl_map.c.

00189 {
00190         return map->dim->n_in;
00191 }

unsigned isl_map_n_out ( const struct isl_map * map )

Definition at line 193 of file isl_map.c.

00194 {
00195         return map->dim->n_out;
00196 }

unsigned isl_map_n_param ( const struct isl_map * map )

Definition at line 198 of file isl_map.c.

00199 {
00200         return map->dim->nparam;
00201 }

unsigned isl_map_dim	(	const struct isl_map *	map,
		enum isl_dim_type	type
	)

Definition at line 105 of file isl_map.c.

00106 {
00107         return n(map->dim, type);
00108 }

struct isl_basic_map* isl_basic_map_alloc	(	struct isl_ctx *	ctx,
		unsigned	nparam,
		unsigned	in,
		unsigned	out,
		unsigned	extra,
		unsigned	n_eq,
		unsigned	n_ineq
	)			`[read]`

Definition at line 341 of file isl_map.c.

00344 {
00345         struct isl_basic_map *bmap;
00346         struct isl_dim *dim;
00347 
00348         dim = isl_dim_alloc(ctx, nparam, in, out);
00349         if (!dim)
00350                 return NULL;
00351 
00352         bmap = isl_basic_map_alloc_dim(dim, extra, n_eq, n_ineq);
00353         return bmap;
00354 }

struct isl_basic_map* isl_basic_map_identity ( struct isl_dim * set_dim ) [read]

Definition at line 3309 of file isl_map.c.

03310 {
03311         struct isl_dim *dim = isl_dim_map(set_dim);
03312         if (!dim)
03313                 return NULL;
03314         return basic_map_identity(dim);
03315 }

struct isl_basic_map* isl_basic_map_identity_like ( struct isl_basic_map * model ) [read]

Definition at line 3317 of file isl_map.c.

03318 {
03319         if (!model || !model->dim)
03320                 return NULL;
03321         isl_assert(model->ctx,
03322                         model->dim->n_in == model->dim->n_out, return NULL);
03323         return basic_map_identity(isl_dim_copy(model->dim));
03324 }

struct isl_basic_map* isl_basic_map_finalize ( struct isl_basic_map * bmap ) [read]

Definition at line 1125 of file isl_map_simplify.c.

01126 {
01127         bmap = remove_redundant_divs(bmap);
01128         if (!bmap)
01129                 return NULL;
01130         ISL_F_SET(bmap, ISL_BASIC_SET_FINAL);
01131         return bmap;
01132 }

void isl_basic_map_free ( struct isl_basic_map * bmap )

Definition at line 445 of file isl_map.c.

00446 {
00447         if (!bmap)
00448                 return;
00449 
00450         if (--bmap->ref > 0)
00451                 return;
00452 
00453         isl_ctx_deref(bmap->ctx);
00454         free(bmap->div);
00455         isl_blk_free(bmap->ctx, bmap->block2);
00456         free(bmap->ineq);
00457         isl_blk_free(bmap->ctx, bmap->block);
00458         isl_vec_free(bmap->ctx, bmap->sample);
00459         isl_dim_free(bmap->dim);
00460         free(bmap);
00461 }

struct isl_basic_map* isl_basic_map_copy ( struct isl_basic_map * bmap ) [read]

Definition at line 424 of file isl_map.c.

00425 {
00426         if (!bmap)
00427                 return NULL;
00428 
00429         if (ISL_F_ISSET(bmap, ISL_BASIC_SET_FINAL)) {
00430                 bmap->ref++;
00431                 return bmap;
00432         }
00433         return isl_basic_map_dup(bmap);
00434 }

struct isl_basic_map* isl_basic_map_extend	(	struct isl_basic_map *	base,
		unsigned	nparam,
		unsigned	n_in,
		unsigned	n_out,
		unsigned	extra,
		unsigned	n_eq,
		unsigned	n_ineq
	)			`[read]`

Definition at line 886 of file isl_map.c.

00889 {
00890         struct isl_basic_map *bmap;
00891         struct isl_dim *dim;
00892 
00893         if (!base)
00894                 return NULL;
00895         dim = isl_dim_alloc(base->ctx, nparam, n_in, n_out);
00896         if (!dim)
00897                 return NULL;
00898 
00899         bmap = isl_basic_map_extend_dim(base, dim, extra, n_eq, n_ineq);
00900         return bmap;
00901 }

struct isl_basic_map* isl_basic_map_extend_constraints	(	struct isl_basic_map *	base,
		unsigned	n_eq,
		unsigned	n_ineq
	)			`[read]`

Definition at line 877 of file isl_map.c.

00879 {
00880         if (!base)
00881                 return NULL;
00882         return isl_basic_map_extend_dim(base, isl_dim_copy(base->dim),
00883                                         0, n_eq, n_ineq);
00884 }

struct isl_basic_map* isl_basic_map_equal	(	struct isl_dim *	dim,
		unsigned	n_equal
	)			`[read]`

Definition at line 2133 of file isl_map.c.

02134 {
02135         int i;
02136         struct isl_basic_map *bmap;
02137         bmap = isl_basic_map_alloc_dim(dim, 0, n_equal, 0);
02138         if (!bmap)
02139                 return NULL;
02140         for (i = 0; i < n_equal && bmap; ++i)
02141                 bmap = var_equal(bmap, i);
02142         return isl_basic_map_finalize(bmap);
02143 }

struct isl_basic_map* isl_basic_map_less_at	(	struct isl_dim *	dim,
		unsigned	pos
	)			`[read]`

Definition at line 2145 of file isl_map.c.

02146 {
02147         int i;
02148         struct isl_basic_map *bmap;
02149         bmap = isl_basic_map_alloc_dim(dim, 0, pos, 1);
02150         if (!bmap)
02151                 return NULL;
02152         for (i = 0; i < pos && bmap; ++i)
02153                 bmap = var_equal(bmap, i);
02154         if (bmap)
02155                 bmap = var_less(bmap, pos);
02156         return isl_basic_map_finalize(bmap);
02157 }

struct isl_basic_map* isl_basic_map_more_at	(	struct isl_dim *	dim,
		unsigned	pos
	)			`[read]`

Definition at line 2159 of file isl_map.c.

02160 {
02161         int i;
02162         struct isl_basic_map *bmap;
02163         bmap = isl_basic_map_alloc_dim(dim, 0, pos, 1);
02164         if (!bmap)
02165                 return NULL;
02166         for (i = 0; i < pos && bmap; ++i)
02167                 bmap = var_equal(bmap, i);
02168         if (bmap)
02169                 bmap = var_more(bmap, pos);
02170         return isl_basic_map_finalize(bmap);
02171 }

struct isl_basic_map* isl_basic_map_empty	(	struct isl_ctx *	ctx,
		unsigned	nparam,
		unsigned	in,
		unsigned	out
	)			`[read]`

Definition at line 2557 of file isl_map.c.

02559 {
02560         struct isl_basic_map *bmap;
02561         bmap = isl_basic_map_alloc(ctx, nparam, in, out, 0, 1, 0);
02562         bmap = isl_basic_map_set_to_empty(bmap);
02563         return bmap;
02564 }

struct isl_basic_map* isl_basic_map_empty_like ( struct isl_basic_map * model ) [read]

Definition at line 2574 of file isl_map.c.

02575 {
02576         struct isl_basic_map *bmap;
02577         if (!model)
02578                 return NULL;
02579         bmap = isl_basic_map_alloc_dim(isl_dim_copy(model->dim), 0, 1, 0);
02580         bmap = isl_basic_map_set_to_empty(bmap);
02581         return bmap;
02582 }

struct isl_basic_map* isl_basic_map_empty_like_map ( struct isl_map * model ) [read]

Definition at line 2584 of file isl_map.c.

02585 {
02586         struct isl_basic_map *bmap;
02587         if (!model)
02588                 return NULL;
02589         bmap = isl_basic_map_alloc_dim(isl_dim_copy(model->dim), 0, 1, 0);
02590         bmap = isl_basic_map_set_to_empty(bmap);
02591         return bmap;
02592 }

struct isl_basic_map* isl_basic_map_universe ( struct isl_dim * dim ) [read]

Definition at line 2604 of file isl_map.c.

02605 {
02606         struct isl_basic_map *bmap;
02607         bmap = isl_basic_map_alloc_dim(dim, 0, 0, 0);
02608         return bmap;
02609 }

struct isl_basic_map* isl_basic_map_convex_hull ( struct isl_basic_map * bmap ) [read]

Definition at line 80 of file isl_convex_hull.c.

00081 {
00082         struct isl_tab *tab;
00083 
00084         if (!bmap)
00085                 return NULL;
00086 
00087         bmap = isl_basic_map_gauss(bmap, NULL);
00088         if (ISL_F_ISSET(bmap, ISL_BASIC_MAP_EMPTY))
00089                 return bmap;
00090         if (ISL_F_ISSET(bmap, ISL_BASIC_MAP_NO_REDUNDANT))
00091                 return bmap;
00092         if (bmap->n_ineq <= 1)
00093                 return bmap;
00094 
00095         tab = isl_tab_from_basic_map(bmap);
00096         tab = isl_tab_detect_equalities(bmap->ctx, tab);
00097         tab = isl_tab_detect_redundant(bmap->ctx, tab);
00098         bmap = isl_basic_map_update_from_tab(bmap, tab);
00099         isl_tab_free(bmap->ctx, tab);
00100         ISL_F_SET(bmap, ISL_BASIC_MAP_NO_IMPLICIT);
00101         ISL_F_SET(bmap, ISL_BASIC_MAP_NO_REDUNDANT);
00102         return bmap;
00103 }

struct isl_basic_map* isl_basic_map_intersect_domain	(	struct isl_basic_map *	bmap,
		struct isl_basic_set *	bset
	)			`[read]`

Definition at line 1544 of file isl_map.c.

01546 {
01547         struct isl_basic_map *bmap_domain;
01548         struct isl_dim *dim;
01549 
01550         if (!bmap || !bset)
01551                 goto error;
01552 
01553         isl_assert(bset->ctx, isl_dim_match(bmap->dim, isl_dim_param,
01554                                         bset->dim, isl_dim_param), goto error);
01555 
01556         if (isl_dim_size(bset->dim, isl_dim_set) != 0)
01557                 isl_assert(bset->ctx,
01558                     isl_basic_map_compatible_domain(bmap, bset), goto error);
01559 
01560         bmap = isl_basic_map_cow(bmap);
01561         bmap = isl_basic_map_extend_dim(bmap, isl_dim_copy(bmap->dim),
01562                         bset->n_div, bset->n_eq, bset->n_ineq);
01563         if (!bmap)
01564                 goto error;
01565         dim = isl_dim_reverse(isl_dim_copy(bset->dim));
01566         bmap_domain = isl_basic_map_from_basic_set(bset, dim);
01567         bmap = add_constraints(bmap, bmap_domain, 0, 0);
01568 
01569         bmap = isl_basic_map_simplify(bmap);
01570         return isl_basic_map_finalize(bmap);
01571 error:
01572         isl_basic_map_free(bmap);
01573         isl_basic_set_free(bset);
01574         return NULL;
01575 }

struct isl_basic_map* isl_basic_map_intersect_range	(	struct isl_basic_map *	bmap,
		struct isl_basic_set *	bset
	)			`[read]`

Definition at line 1577 of file isl_map.c.

01579 {
01580         struct isl_basic_map *bmap_range;
01581 
01582         if (!bmap || !bset)
01583                 goto error;
01584 
01585         isl_assert(bset->ctx, isl_dim_match(bmap->dim, isl_dim_param,
01586                                         bset->dim, isl_dim_param), goto error);
01587 
01588         if (isl_dim_size(bset->dim, isl_dim_set) != 0)
01589                 isl_assert(bset->ctx,
01590                     isl_basic_map_compatible_range(bmap, bset), goto error);
01591 
01592         bmap = isl_basic_map_cow(bmap);
01593         bmap = isl_basic_map_extend_dim(bmap, isl_dim_copy(bmap->dim),
01594                         bset->n_div, bset->n_eq, bset->n_ineq);
01595         if (!bmap)
01596                 goto error;
01597         bmap_range = isl_basic_map_from_basic_set(bset, isl_dim_copy(bset->dim));
01598         bmap = add_constraints(bmap, bmap_range, 0, 0);
01599 
01600         bmap = isl_basic_map_simplify(bmap);
01601         return isl_basic_map_finalize(bmap);
01602 error:
01603         isl_basic_map_free(bmap);
01604         isl_basic_set_free(bset);
01605         return NULL;
01606 }

struct isl_basic_map* isl_basic_map_intersect	(	struct isl_basic_map *	bmap1,
		struct isl_basic_map *	bmap2
	)			`[read]`

Definition at line 1646 of file isl_map.c.

01648 {
01649         struct isl_vec *sample = NULL;
01650 
01651         if (!bmap1 || !bmap2)
01652                 goto error;
01653 
01654         isl_assert(bmap1->ctx, isl_dim_match(bmap1->dim, isl_dim_param,
01655                                      bmap2->dim, isl_dim_param), goto error);
01656         if (isl_dim_total(bmap1->dim) ==
01657                                 isl_dim_size(bmap1->dim, isl_dim_param) &&
01658             isl_dim_total(bmap2->dim) !=
01659                                 isl_dim_size(bmap2->dim, isl_dim_param))
01660                 return isl_basic_map_intersect(bmap2, bmap1);
01661 
01662         if (isl_dim_total(bmap2->dim) !=
01663                                         isl_dim_size(bmap2->dim, isl_dim_param))
01664                 isl_assert(bmap1->ctx,
01665                             isl_dim_equal(bmap1->dim, bmap2->dim), goto error);
01666 
01667         if (bmap1->sample &&
01668             basic_map_contains(bmap1, bmap1->sample) > 0 &&
01669             basic_map_contains(bmap2, bmap1->sample) > 0)
01670                 sample = isl_vec_copy(bmap1->ctx, bmap1->sample);
01671         else if (bmap2->sample &&
01672             basic_map_contains(bmap1, bmap2->sample) > 0 &&
01673             basic_map_contains(bmap2, bmap2->sample) > 0)
01674                 sample = isl_vec_copy(bmap2->ctx, bmap2->sample);
01675 
01676         bmap1 = isl_basic_map_cow(bmap1);
01677         bmap1 = isl_basic_map_extend_dim(bmap1, isl_dim_copy(bmap1->dim),
01678                         bmap2->n_div, bmap2->n_eq, bmap2->n_ineq);
01679         if (!bmap1)
01680                 goto error;
01681         bmap1 = add_constraints(bmap1, bmap2, 0, 0);
01682 
01683         if (sample) {
01684                 isl_vec_free(bmap1->ctx, bmap1->sample);
01685                 bmap1->sample = sample;
01686         }
01687 
01688         bmap1 = isl_basic_map_simplify(bmap1);
01689         return isl_basic_map_finalize(bmap1);
01690 error:
01691         if (sample)
01692                 isl_vec_free(bmap1->ctx, sample);
01693         isl_basic_map_free(bmap1);
01694         isl_basic_map_free(bmap2);
01695         return NULL;
01696 }

struct isl_map* isl_basic_map_union	(	struct isl_basic_map *	bmap1,
		struct isl_basic_map *	bmap2
	)			`[read]`

Definition at line 3561 of file isl_map.c.

03563 {
03564         struct isl_map *map;
03565         if (!bmap1 || !bmap2)
03566                 return NULL;
03567 
03568         isl_assert(map1->ctx, isl_dim_equal(bmap1->dim, bmap2->dim), goto error);
03569 
03570         map = isl_map_alloc_dim(isl_dim_copy(bmap1->dim), 2, 0);
03571         if (!map)
03572                 goto error;
03573         map = isl_map_add(map, bmap1);
03574         map = isl_map_add(map, bmap2);
03575         return map;
03576 error:
03577         isl_basic_map_free(bmap1);
03578         isl_basic_map_free(bmap2);
03579         return NULL;
03580 }

struct isl_basic_map* isl_basic_map_apply_domain	(	struct isl_basic_map *	bmap1,
		struct isl_basic_map *	bmap2
	)			`[read]`

Definition at line 1912 of file isl_map.c.

01914 {
01915         if (!bmap1 || !bmap2)
01916                 goto error;
01917 
01918         isl_assert(ctx,
01919             isl_basic_map_n_in(bmap1) == isl_basic_map_n_in(bmap2), goto error);
01920         isl_assert(ctx,
01921             isl_basic_map_n_param(bmap1) == isl_basic_map_n_param(bmap2),
01922             goto error);
01923 
01924         bmap1 = isl_basic_map_reverse(bmap1);
01925         bmap1 = isl_basic_map_apply_range(bmap1, bmap2);
01926         return isl_basic_map_reverse(bmap1);
01927 error:
01928         isl_basic_map_free(bmap1);
01929         isl_basic_map_free(bmap2);
01930         return NULL;
01931 }

struct isl_basic_map* isl_basic_map_apply_range	(	struct isl_basic_map *	bmap1,
		struct isl_basic_map *	bmap2
	)			`[read]`

Definition at line 1849 of file isl_map.c.

01851 {
01852         struct isl_dim *dim_result = NULL;
01853         struct isl_basic_map *bmap;
01854         unsigned n_in, n_out, n, nparam, total, pos;
01855         struct isl_dim_map *dim_map1, *dim_map2;
01856 
01857         if (!bmap1 || !bmap2)
01858                 goto error;
01859 
01860         dim_result = isl_dim_join(isl_dim_copy(bmap1->dim),
01861                                   isl_dim_copy(bmap2->dim));
01862 
01863         n_in = isl_basic_map_n_in(bmap1);
01864         n_out = isl_basic_map_n_out(bmap2);
01865         n = isl_basic_map_n_out(bmap1);
01866         nparam = isl_basic_map_n_param(bmap1);
01867 
01868         total = nparam + n_in + n_out + bmap1->n_div + bmap2->n_div + n;
01869         dim_map1 = isl_dim_map_alloc(bmap1->ctx, total);
01870         dim_map2 = isl_dim_map_alloc(bmap1->ctx, total);
01871         isl_dim_map_dim(dim_map1, bmap1->dim, isl_dim_param, pos = 0);
01872         isl_dim_map_dim(dim_map2, bmap2->dim, isl_dim_param, pos = 0);
01873         isl_dim_map_dim(dim_map1, bmap1->dim, isl_dim_in, pos += nparam);
01874         isl_dim_map_dim(dim_map2, bmap2->dim, isl_dim_out, pos += n_in);
01875         isl_dim_map_div(dim_map1, bmap1, pos += n_out);
01876         isl_dim_map_div(dim_map2, bmap2, pos += bmap1->n_div);
01877         isl_dim_map_dim(dim_map1, bmap1->dim, isl_dim_out, pos += bmap2->n_div);
01878         isl_dim_map_dim(dim_map2, bmap2->dim, isl_dim_in, pos);
01879 
01880         bmap = isl_basic_map_alloc_dim(dim_result,
01881                         bmap1->n_div + bmap2->n_div + n,
01882                         bmap1->n_eq + bmap2->n_eq,
01883                         bmap1->n_ineq + bmap2->n_ineq);
01884         bmap = add_constraints_dim_map(bmap, bmap1, dim_map1);
01885         bmap = add_constraints_dim_map(bmap, bmap2, dim_map2);
01886         bmap = add_divs(bmap, n);
01887         bmap = isl_basic_map_simplify(bmap);
01888         return isl_basic_map_finalize(bmap);
01889 error:
01890         isl_basic_map_free(bmap1);
01891         isl_basic_map_free(bmap2);
01892         return NULL;
01893 }

struct isl_basic_map* isl_basic_map_reverse ( struct isl_basic_map * bmap ) [read]

Definition at line 1764 of file isl_map.c.

01765 {
01766         struct isl_dim *dim;
01767         struct isl_basic_set *bset;
01768         unsigned in;
01769 
01770         if (!bmap)
01771                 return NULL;
01772         bmap = isl_basic_map_cow(bmap);
01773         if (!bmap)
01774                 return NULL;
01775         dim = isl_dim_reverse(isl_dim_copy(bmap->dim));
01776         in = isl_basic_map_n_in(bmap);
01777         bset = isl_basic_set_from_basic_map(bmap);
01778         bset = isl_basic_set_swap_vars(bset, in);
01779         return isl_basic_map_from_basic_set(bset, dim);
01780 }

struct isl_basic_set* isl_basic_map_domain ( struct isl_basic_map * bmap ) [read]

Definition at line 2413 of file isl_map.c.

02414 {
02415         struct isl_basic_set *domain;
02416         unsigned n_out;
02417         if (!bmap)
02418                 return NULL;
02419         n_out = isl_basic_map_n_out(bmap);
02420         domain = isl_basic_set_from_basic_map(bmap);
02421         return isl_basic_set_project_out(domain, n_out, 0);
02422 }

struct isl_basic_set* isl_basic_map_range ( struct isl_basic_map * bmap ) [read]

Definition at line 2424 of file isl_map.c.

02425 {
02426         return isl_basic_map_domain(isl_basic_map_reverse(bmap));
02427 }

struct isl_basic_map* isl_basic_map_remove	(	struct isl_basic_map *	bmap,
		enum isl_dim_type	type,
		unsigned	first,
		unsigned	n
	)			`[read]`

Definition at line 1161 of file isl_map.c.

01163 {
01164         if (!bmap)
01165                 return NULL;
01166         isl_assert(bmap->ctx, first + n <= isl_basic_map_dim(bmap, type),
01167                         goto error);
01168         if (n == 0)
01169                 return bmap;
01170         bmap = isl_basic_map_eliminate_vars(bmap,
01171                         isl_basic_map_offset(bmap, type) - 1 + first, n);
01172         bmap = isl_basic_map_drop(bmap, type, first, n);
01173         return bmap;
01174 error:
01175         isl_basic_map_free(bmap);
01176         return NULL;
01177 }

struct isl_basic_map* isl_basic_map_from_basic_set	(	struct isl_basic_set *	bset,
		struct isl_dim *	dim
	)			`[read]`

Definition at line 2173 of file isl_map.c.

02175 {
02176         struct isl_basic_map *bmap;
02177 
02178         bset = isl_basic_set_cow(bset);
02179         if (!bset || !dim)
02180                 goto error;
02181 
02182         isl_assert(bset->ctx, isl_dim_compatible(bset->dim, dim), goto error);
02183         isl_dim_free(bset->dim);
02184         bmap = (struct isl_basic_map *) bset;
02185         bmap->dim = dim;
02186         return isl_basic_map_finalize(bmap);
02187 error:
02188         isl_basic_set_free(bset);
02189         isl_dim_free(dim);
02190         return NULL;
02191 }

struct isl_basic_set* isl_basic_set_from_basic_map ( struct isl_basic_map * bmap ) [read]

Definition at line 2193 of file isl_map.c.

02194 {
02195         if (!bmap)
02196                 goto error;
02197         if (bmap->dim->n_in == 0)
02198                 return (struct isl_basic_set *)bmap;
02199         bmap = isl_basic_map_cow(bmap);
02200         if (!bmap)
02201                 goto error;
02202         bmap->dim = isl_dim_cow(bmap->dim);
02203         if (!bmap->dim)
02204                 goto error;
02205         bmap->dim->n_out += bmap->dim->n_in;
02206         bmap->dim->n_in = 0;
02207         bmap = isl_basic_map_finalize(bmap);
02208         return (struct isl_basic_set *)bmap;
02209 error:
02210         isl_basic_map_free(bmap);
02211         return NULL;
02212 }

struct isl_basic_map* isl_basic_map_simplify ( struct isl_basic_map * bmap ) [read]

Definition at line 1028 of file isl_map_simplify.c.

01029 {
01030         int progress = 1;
01031         if (!bmap)
01032                 return NULL;
01033         while (progress) {
01034                 progress = 0;
01035                 bmap = isl_basic_map_normalize_constraints(bmap);
01036                 bmap = remove_duplicate_divs(bmap, &progress);
01037                 bmap = eliminate_divs_eq(bmap, &progress);
01038                 bmap = eliminate_divs_ineq(bmap, &progress);
01039                 bmap = isl_basic_map_gauss(bmap, &progress);
01040                 /* requires equalities in normal form */
01041                 bmap = normalize_divs(bmap, &progress);
01042                 bmap = remove_duplicate_constraints(bmap, &progress);
01043         }
01044         return bmap;
01045 }

struct isl_basic_map* isl_basic_map_detect_equalities ( struct isl_basic_map * bmap ) [read]

Definition at line 480 of file isl_affine_hull.c.

00482 {
00483         int i, j;
00484         struct isl_basic_set *hull = NULL;
00485 
00486         if (!bmap)
00487                 return NULL;
00488         if (bmap->n_ineq == 0)
00489                 return bmap;
00490         if (ISL_F_ISSET(bmap, ISL_BASIC_MAP_EMPTY))
00491                 return bmap;
00492         if (ISL_F_ISSET(bmap, ISL_BASIC_MAP_ALL_EQUALITIES))
00493                 return bmap;
00494         if (ISL_F_ISSET(bmap, ISL_BASIC_MAP_RATIONAL))
00495                 return isl_basic_map_implicit_equalities(bmap);
00496 
00497         hull = equalities_in_underlying_set(isl_basic_map_copy(bmap));
00498         if (!hull)
00499                 goto error;
00500         if (ISL_F_ISSET(hull, ISL_BASIC_SET_EMPTY)) {
00501                 isl_basic_set_free(hull);
00502                 return isl_basic_map_set_to_empty(bmap);
00503         }
00504         bmap = isl_basic_map_extend_dim(bmap, isl_dim_copy(bmap->dim), 0,
00505                                         hull->n_eq, 0);
00506         for (i = 0; i < hull->n_eq; ++i) {
00507                 j = isl_basic_map_alloc_equality(bmap);
00508                 if (j < 0)
00509                         goto error;
00510                 isl_seq_cpy(bmap->eq[j], hull->eq[i],
00511                                 1 + isl_basic_set_total_dim(hull));
00512         }
00513         isl_basic_set_free(hull);
00514         ISL_F_SET(bmap, ISL_BASIC_MAP_NO_IMPLICIT | ISL_BASIC_MAP_ALL_EQUALITIES);
00515         bmap = isl_basic_map_simplify(bmap);
00516         return isl_basic_map_finalize(bmap);
00517 error:
00518         isl_basic_set_free(hull);
00519         isl_basic_map_free(bmap);
00520         return NULL;
00521 }

struct isl_basic_map* isl_basic_map_read_from_file	(	struct isl_ctx *	ctx,
		FILE *	input,
		unsigned	nparam,
		unsigned	input_format
	)			`[read]`

Definition at line 141 of file isl_input.c.

00143 {
00144         if (input_format == ISL_FORMAT_OMEGA)
00145                 return isl_basic_map_read_from_file_omega(ctx, input);
00146         else
00147                 isl_assert(ctx, 0, return NULL);
00148 }

struct isl_basic_map* isl_basic_map_fix_si	(	struct isl_basic_map *	bmap,
		enum isl_dim_type	type,
		unsigned	pos,
		int	value
	)			`[read]`

Definition at line 2775 of file isl_map.c.

02777 {
02778         if (!bmap)
02779                 return NULL;
02780         isl_assert(bmap->ctx, pos < isl_basic_map_dim(bmap, type), goto error);
02781         return isl_basic_map_fix_pos(bmap, isl_basic_map_offset(bmap, type) + pos,
02782                                         value);
02783 error:
02784         isl_basic_map_free(bmap);
02785         return NULL;
02786 }

struct isl_basic_map* isl_basic_map_sum	(	struct isl_basic_map *	bmap1,
		struct isl_basic_map *	bmap2
	)			`[read]`

Definition at line 1936 of file isl_map.c.

01938 {
01939         unsigned n_in, n_out, nparam, total, pos;
01940         struct isl_basic_map *bmap = NULL;
01941         struct isl_dim_map *dim_map1, *dim_map2;
01942         int i;
01943 
01944         if (!bmap1 || !bmap2)
01945                 goto error;
01946 
01947         isl_assert(bmap1->ctx, isl_dim_equal(bmap1->dim, bmap2->dim),
01948                 goto error);
01949 
01950         nparam = isl_basic_map_n_param(bmap1);
01951         n_in = isl_basic_map_n_in(bmap1);
01952         n_out = isl_basic_map_n_out(bmap1);
01953 
01954         total = nparam + n_in + n_out + bmap1->n_div + bmap2->n_div + 2 * n_out;
01955         dim_map1 = isl_dim_map_alloc(bmap1->ctx, total);
01956         dim_map2 = isl_dim_map_alloc(bmap2->ctx, total);
01957         isl_dim_map_dim(dim_map1, bmap1->dim, isl_dim_param, pos = 0);
01958         isl_dim_map_dim(dim_map2, bmap2->dim, isl_dim_param, pos);
01959         isl_dim_map_dim(dim_map1, bmap1->dim, isl_dim_in, pos += nparam);
01960         isl_dim_map_dim(dim_map2, bmap2->dim, isl_dim_in, pos);
01961         isl_dim_map_div(dim_map1, bmap1, pos += n_in + n_out);
01962         isl_dim_map_div(dim_map2, bmap2, pos += bmap1->n_div);
01963         isl_dim_map_dim(dim_map1, bmap1->dim, isl_dim_out, pos += bmap2->n_div);
01964         isl_dim_map_dim(dim_map2, bmap2->dim, isl_dim_out, pos += n_out);
01965 
01966         bmap = isl_basic_map_alloc_dim(isl_dim_copy(bmap1->dim),
01967                         bmap1->n_div + bmap2->n_div + 2 * n_out,
01968                         bmap1->n_eq + bmap2->n_eq + n_out,
01969                         bmap1->n_ineq + bmap2->n_ineq);
01970         for (i = 0; i < n_out; ++i) {
01971                 int j = isl_basic_map_alloc_equality(bmap);
01972                 if (j < 0)
01973                         goto error;
01974                 isl_seq_clr(bmap->eq[j], 1+total);
01975                 isl_int_set_si(bmap->eq[j][1+nparam+n_in+i], -1);
01976                 isl_int_set_si(bmap->eq[j][1+pos+i], 1);
01977                 isl_int_set_si(bmap->eq[j][1+pos-n_out+i], 1);
01978         }
01979         bmap = add_constraints_dim_map(bmap, bmap1, dim_map1);
01980         bmap = add_constraints_dim_map(bmap, bmap2, dim_map2);
01981         bmap = add_divs(bmap, 2 * n_out);
01982 
01983         bmap = isl_basic_map_simplify(bmap);
01984         return isl_basic_map_finalize(bmap);
01985 error:
01986         isl_basic_map_free(bmap);
01987         isl_basic_map_free(bmap1);
01988         isl_basic_map_free(bmap2);
01989         return NULL;
01990 }

struct isl_basic_map* isl_basic_map_neg ( struct isl_basic_map * bmap ) [read]

Definition at line 1994 of file isl_map.c.

01995 {
01996         int i, j;
01997         unsigned off, n;
01998 
01999         bmap = isl_basic_map_cow(bmap);
02000         if (!bmap)
02001                 return NULL;
02002 
02003         n = isl_basic_map_dim(bmap, isl_dim_out);
02004         off = isl_basic_map_offset(bmap, isl_dim_out);
02005         for (i = 0; i < bmap->n_eq; ++i)
02006                 for (j = 0; j < n; ++j)
02007                         isl_int_neg(bmap->eq[i][off+j], bmap->eq[i][off+j]);
02008         for (i = 0; i < bmap->n_ineq; ++i)
02009                 for (j = 0; j < n; ++j)
02010                         isl_int_neg(bmap->ineq[i][off+j], bmap->ineq[i][off+j]);
02011         for (i = 0; i < bmap->n_div; ++i)
02012                 for (j = 0; j < n; ++j)
02013                         isl_int_neg(bmap->div[i][1+off+j], bmap->div[i][1+off+j]);
02014         return isl_basic_map_finalize(bmap);
02015 }

struct isl_basic_map* isl_basic_map_floordiv	(	struct isl_basic_map *	bmap,
		isl_int	d
	)			`[read]`

Definition at line 2020 of file isl_map.c.

02022 {
02023         unsigned n_in, n_out, nparam, total, pos;
02024         struct isl_basic_map *result = NULL;
02025         struct isl_dim_map *dim_map;
02026         int i;
02027 
02028         if (!bmap)
02029                 return NULL;
02030 
02031         nparam = isl_basic_map_n_param(bmap);
02032         n_in = isl_basic_map_n_in(bmap);
02033         n_out = isl_basic_map_n_out(bmap);
02034 
02035         total = nparam + n_in + n_out + bmap->n_div + n_out;
02036         dim_map = isl_dim_map_alloc(bmap->ctx, total);
02037         isl_dim_map_dim(dim_map, bmap->dim, isl_dim_param, pos = 0);
02038         isl_dim_map_dim(dim_map, bmap->dim, isl_dim_in, pos += nparam);
02039         isl_dim_map_div(dim_map, bmap, pos += n_in + n_out);
02040         isl_dim_map_dim(dim_map, bmap->dim, isl_dim_out, pos += bmap->n_div);
02041 
02042         result = isl_basic_map_alloc_dim(isl_dim_copy(bmap->dim),
02043                         bmap->n_div + n_out,
02044                         bmap->n_eq, bmap->n_ineq + 2 * n_out);
02045         result = add_constraints_dim_map(result, bmap, dim_map);
02046         result = add_divs(result, n_out);
02047         for (i = 0; i < n_out; ++i) {
02048                 int j;
02049                 j = isl_basic_map_alloc_inequality(result);
02050                 if (j < 0)
02051                         goto error;
02052                 isl_seq_clr(result->ineq[j], 1+total);
02053                 isl_int_neg(result->ineq[j][1+nparam+n_in+i], d);
02054                 isl_int_set_si(result->ineq[j][1+pos+i], 1);
02055                 j = isl_basic_map_alloc_inequality(result);
02056                 if (j < 0)
02057                         goto error;
02058                 isl_seq_clr(result->ineq[j], 1+total);
02059                 isl_int_set(result->ineq[j][1+nparam+n_in+i], d);
02060                 isl_int_set_si(result->ineq[j][1+pos+i], -1);
02061                 isl_int_sub_ui(result->ineq[j][0], d, 1);
02062         }
02063 
02064         result = isl_basic_map_simplify(result);
02065         return isl_basic_map_finalize(result);
02066 error:
02067         isl_basic_map_free(result);
02068         return NULL;
02069 }

int isl_basic_map_is_equal	(	struct isl_basic_map *	bmap1,
		struct isl_basic_map *	bmap2
	)

Definition at line 3381 of file isl_map.c.

03383 {
03384         int is_subset;
03385 
03386         if (!bmap1 || !bmap2)
03387                 return -1;
03388         is_subset = isl_basic_map_is_subset(bmap1, bmap2);
03389         if (is_subset != 1)
03390                 return is_subset;
03391         is_subset = isl_basic_map_is_subset(bmap2, bmap1);
03392         return is_subset;
03393 }

struct isl_map* isl_basic_map_lexmax	(	struct isl_basic_map *	bmap,
		struct isl_basic_set *	dom,
		struct isl_set **	empty
	)			`[read]`

Definition at line 2910 of file isl_map.c.

02913 {
02914         return isl_pip_basic_map_lexmax(bmap, dom, empty);
02915 }

struct isl_map* isl_basic_map_lexmin	(	struct isl_basic_map *	bmap,
		struct isl_basic_set *	dom,
		struct isl_set **	empty
	)			`[read]`

Definition at line 2917 of file isl_map.c.

02920 {
02921         return isl_pip_basic_map_lexmin(bmap, dom, empty);
02922 }

void isl_basic_map_dump	(	struct isl_basic_map *	bmap,
		FILE *	out,
		int	indent
	)

Definition at line 1353 of file isl_map.c.

01354 {
01355         if (!bmap) {
01356                 fprintf(out, "null basic map\n");
01357                 return;
01358         }
01359 
01360         fprintf(out, "%*s", indent, "");
01361         fprintf(out, "ref: %d, nparam: %d, in: %d, out: %d, extra: %d, "
01362                         "flags: %x, n_name: %d\n",
01363                 bmap->ref,
01364                 bmap->dim->nparam, bmap->dim->n_in, bmap->dim->n_out,
01365                 bmap->extra, bmap->flags, bmap->dim->n_name);
01366         dump(bmap, out, indent);
01367 }

struct isl_basic_map* isl_map_copy_basic_map ( struct isl_map * map ) [read]

Definition at line 3904 of file isl_map.c.

03905 {
03906         struct isl_basic_map *bmap;
03907         if (!map || map->n == 0)
03908                 return NULL;
03909         bmap = map->p[map->n-1];
03910         isl_assert(map->ctx, ISL_F_ISSET(bmap, ISL_BASIC_SET_FINAL), return NULL);
03911         return isl_basic_map_copy(bmap);
03912 }

struct isl_map* isl_map_drop_basic_map	(	struct isl_map *	map,
		struct isl_basic_map *	bmap
	)			`[read]`

Definition at line 3919 of file isl_map.c.

03921 {
03922         int i;
03923 
03924         if (!map || !bmap)
03925                 goto error;
03926         for (i = map->n-1; i >= 0; --i) {
03927                 if (map->p[i] != bmap)
03928                         continue;
03929                 map = isl_map_cow(map);
03930                 if (!map)
03931                         goto error;
03932                 isl_basic_map_free(map->p[i]);
03933                 if (i != map->n-1) {
03934                         ISL_F_CLR(map, ISL_SET_NORMALIZED);
03935                         map->p[i] = map->p[map->n-1];
03936                 }
03937                 map->n--;
03938                 return map;
03939         }
03940         isl_basic_map_free(bmap);
03941         return map;
03942 error:
03943         isl_map_free(map);
03944         isl_basic_map_free(bmap);
03945         return NULL;
03946 }

int isl_basic_map_fast_is_fixed	(	struct isl_basic_map *	bmap,
		enum isl_dim_type	type,
		unsigned	pos,
		isl_int *	val
	)

Definition at line 4095 of file isl_map.c.

04097 {
04098         if (pos >= isl_basic_map_dim(bmap, type))
04099                 return -1;
04100         return isl_basic_map_fast_has_fixed_var(bmap,
04101                 isl_basic_map_offset(bmap, type) - 1 + pos, val);
04102 }

int isl_basic_map_is_universe ( struct isl_basic_map * bmap )

Definition at line 3483 of file isl_map.c.

03484 {
03485         if (!bmap)
03486                 return -1;
03487         return bmap->n_eq == 0 && bmap->n_ineq == 0;
03488 }

int isl_basic_map_fast_is_empty ( struct isl_basic_map * bmap )

Definition at line 3542 of file isl_map.c.

03543 {
03544         if (!bmap)
03545                 return -1;
03546         return ISL_F_ISSET(bmap, ISL_BASIC_MAP_EMPTY);
03547 }

int isl_basic_map_is_empty ( struct isl_basic_map * bmap )

Definition at line 3497 of file isl_map.c.

03498 {
03499         struct isl_basic_set *bset = NULL;
03500         struct isl_vec *sample = NULL;
03501         int empty;
03502         unsigned total;
03503 
03504         if (!bmap)
03505                 return -1;
03506 
03507         if (ISL_F_ISSET(bmap, ISL_BASIC_MAP_EMPTY))
03508                 return 1;
03509 
03510         if (ISL_F_ISSET(bmap, ISL_BASIC_MAP_RATIONAL)) {
03511                 struct isl_basic_map *copy = isl_basic_map_copy(bmap);
03512                 copy = isl_basic_map_convex_hull(copy);
03513                 empty = ISL_F_ISSET(copy, ISL_BASIC_MAP_EMPTY);
03514                 isl_basic_map_free(copy);
03515                 return empty;
03516         }
03517 
03518         total = 1 + isl_basic_map_total_dim(bmap);
03519         if (bmap->sample && bmap->sample->size == total) {
03520                 int contains = basic_map_contains(bmap, bmap->sample);
03521                 if (contains < 0)
03522                         return -1;
03523                 if (contains)
03524                         return 0;
03525         }
03526         bset = isl_basic_map_underlying_set(isl_basic_map_copy(bmap));
03527         if (!bset)
03528                 return -1;
03529         sample = isl_basic_set_sample(bset);
03530         if (!sample)
03531                 return -1;
03532         empty = sample->size == 0;
03533         if (bmap->sample)
03534                 isl_vec_free(bmap->ctx, bmap->sample);
03535         bmap->sample = sample;
03536         if (empty)
03537                 ISL_F_SET(bmap, ISL_BASIC_MAP_EMPTY);
03538 
03539         return empty;
03540 }

int isl_basic_map_is_subset	(	struct isl_basic_map *	bmap1,
		struct isl_basic_map *	bmap2
	)

Definition at line 3360 of file isl_map.c.

03362 {
03363         int is_subset;
03364         struct isl_map *map1;
03365         struct isl_map *map2;
03366 
03367         if (!bmap1 || !bmap2)
03368                 return -1;
03369 
03370         map1 = isl_map_from_basic_map(isl_basic_map_copy(bmap1));
03371         map2 = isl_map_from_basic_map(isl_basic_map_copy(bmap2));
03372 
03373         is_subset = isl_map_is_subset(map1, map2);
03374 
03375         isl_map_free(map1);
03376         isl_map_free(map2);
03377 
03378         return is_subset;
03379 }

int isl_basic_map_is_strict_subset	(	struct isl_basic_map *	bmap1,
		struct isl_basic_map *	bmap2
	)

Definition at line 3467 of file isl_map.c.

03469 {
03470         int is_subset;
03471 
03472         if (!bmap1 || !bmap2)
03473                 return -1;
03474         is_subset = isl_basic_map_is_subset(bmap1, bmap2);
03475         if (is_subset != 1)
03476                 return is_subset;
03477         is_subset = isl_basic_map_is_subset(bmap2, bmap1);
03478         if (is_subset == -1)
03479                 return is_subset;
03480         return !is_subset;
03481 }

struct isl_map* isl_map_alloc	(	struct isl_ctx *	ctx,
		unsigned	nparam,
		unsigned	in,
		unsigned	out,
		int	n,
		unsigned	flags
	)			`[read]`

Definition at line 2542 of file isl_map.c.

02545 {
02546         struct isl_map *map;
02547         struct isl_dim *dims;
02548 
02549         dims = isl_dim_alloc(ctx, nparam, in, out);
02550         if (!dims)
02551                 return NULL;
02552 
02553         map = isl_map_alloc_dim(dims, n, flags);
02554         return map;
02555 }

struct isl_map* isl_map_universe ( struct isl_dim * dim ) [read]

Definition at line 2656 of file isl_map.c.

02657 {
02658         struct isl_map *map;
02659         if (!dim)
02660                 return NULL;
02661         map = isl_map_alloc_dim(isl_dim_copy(dim), 1, ISL_MAP_DISJOINT);
02662         map = isl_map_add(map, isl_basic_map_universe(dim));
02663         return map;
02664 }

struct isl_map* isl_map_empty ( struct isl_dim * dim ) [read]

Definition at line 2625 of file isl_map.c.

02626 {
02627         return isl_map_alloc_dim(dim, 0, ISL_MAP_DISJOINT);
02628 }

struct isl_map* isl_map_empty_like ( struct isl_map * model ) [read]

Definition at line 2630 of file isl_map.c.

02631 {
02632         if (!model)
02633                 return NULL;
02634         return isl_map_alloc_dim(isl_dim_copy(model->dim), 0, ISL_MAP_DISJOINT);
02635 }

struct isl_map* isl_map_empty_like_basic_map ( struct isl_basic_map * model ) [read]

Definition at line 2637 of file isl_map.c.

02638 {
02639         if (!model)
02640                 return NULL;
02641         return isl_map_alloc_dim(isl_dim_copy(model->dim), 0, ISL_MAP_DISJOINT);
02642 }

struct isl_map* isl_map_dup ( struct isl_map * map ) [read]

Definition at line 2676 of file isl_map.c.

02677 {
02678         int i;
02679         struct isl_map *dup;
02680 
02681         if (!map)
02682                 return NULL;
02683         dup = isl_map_alloc_dim(isl_dim_copy(map->dim), map->n, map->flags);
02684         for (i = 0; i < map->n; ++i)
02685                 dup = isl_map_add(dup, isl_basic_map_copy(map->p[i]));
02686         return dup;
02687 }

struct isl_map* isl_map_add	(	struct isl_map *	map,
		struct isl_basic_map *	bmap
	)			`[read]`

Definition at line 2689 of file isl_map.c.

02690 {
02691         if (!bmap || !map)
02692                 goto error;
02693         isl_assert(map->ctx, isl_dim_equal(map->dim, bmap->dim), goto error);
02694         isl_assert(map->ctx, map->n < map->size, goto error);
02695         map->p[map->n] = bmap;
02696         map->n++;
02697         ISL_F_CLR(map, ISL_MAP_NORMALIZED);
02698         return map;
02699 error:
02700         if (map)
02701                 isl_map_free(map);
02702         if (bmap)
02703                 isl_basic_map_free(bmap);
02704         return NULL;
02705 }

struct isl_map* isl_map_identity ( struct isl_dim * set_dim ) [read]

Definition at line 3332 of file isl_map.c.

03333 {
03334         struct isl_dim *dim = isl_dim_map(set_dim);
03335         if (!dim)
03336                 return NULL;
03337         return map_identity(dim);
03338 }

struct isl_map* isl_map_identity_like ( struct isl_basic_map * model ) [read]

Definition at line 3340 of file isl_map.c.

03341 {
03342         if (!model || !model->dim)
03343                 return NULL;
03344         isl_assert(model->ctx,
03345                         model->dim->n_in == model->dim->n_out, return NULL);
03346         return map_identity(isl_dim_copy(model->dim));
03347 }

struct isl_map* isl_map_finalize ( struct isl_map * map ) [read]

Definition at line 1157 of file isl_map_simplify.c.

01158 {
01159         int i;
01160 
01161         if (!map)
01162                 return NULL;
01163         for (i = 0; i < map->n; ++i) {
01164                 map->p[i] = isl_basic_map_finalize(map->p[i]);
01165                 if (!map->p[i])
01166                         goto error;
01167         }
01168         ISL_F_CLR(map, ISL_MAP_NORMALIZED);
01169         return map;
01170 error:
01171         isl_map_free(map);
01172         return NULL;
01173 }

void isl_map_free ( struct isl_map * map )

Definition at line 2707 of file isl_map.c.

02708 {
02709         int i;
02710 
02711         if (!map)
02712                 return;
02713 
02714         if (--map->ref > 0)
02715                 return;
02716 
02717         isl_ctx_deref(map->ctx);
02718         for (i = 0; i < map->n; ++i)
02719                 isl_basic_map_free(map->p[i]);
02720         isl_dim_free(map->dim);
02721         free(map);
02722 }

struct isl_map* isl_map_copy ( struct isl_map * map ) [read]

Definition at line 436 of file isl_map.c.

00437 {
00438         if (!map)
00439                 return NULL;
00440 
00441         map->ref++;
00442         return map;
00443 }

struct isl_map* isl_map_extend	(	struct isl_map *	base,
		unsigned	nparam,
		unsigned	n_in,
		unsigned	n_out
	)			`[read]`

Definition at line 2724 of file isl_map.c.

02726 {
02727         int i;
02728 
02729         base = isl_map_cow(base);
02730         if (!base)
02731                 return NULL;
02732 
02733         base->dim = isl_dim_extend(base->dim, nparam, n_in, n_out);
02734         if (!base->dim)
02735                 goto error;
02736         for (i = 0; i < base->n; ++i) {
02737                 base->p[i] = isl_basic_map_extend_dim(base->p[i],
02738                                 isl_dim_copy(base->dim), 0, 0, 0);
02739                 if (!base->p[i])
02740                         goto error;
02741         }
02742         return base;
02743 error:
02744         isl_map_free(base);
02745         return NULL;
02746 }

struct isl_map* isl_map_reverse ( struct isl_map * map ) [read]

Definition at line 2886 of file isl_map.c.

02887 {
02888         int i;
02889         unsigned t;
02890 
02891         map = isl_map_cow(map);
02892         if (!map)
02893                 return NULL;
02894 
02895         map->dim = isl_dim_reverse(map->dim);
02896         if (!map->dim)
02897                 goto error;
02898         for (i = 0; i < map->n; ++i) {
02899                 map->p[i] = isl_basic_map_reverse(map->p[i]);
02900                 if (!map->p[i])
02901                         goto error;
02902         }
02903         ISL_F_CLR(map, ISL_MAP_NORMALIZED);
02904         return map;
02905 error:
02906         isl_map_free(map);
02907         return NULL;
02908 }

struct isl_map* isl_map_union	(	struct isl_map *	map1,
		struct isl_map *	map2
	)			`[read]`

Definition at line 3098 of file isl_map.c.

03099 {
03100         map1 = isl_map_union_disjoint(map1, map2);
03101         if (!map1)
03102                 return NULL;
03103         if (map1->n > 1)
03104                 ISL_F_CLR(map1, ISL_MAP_DISJOINT);
03105         return map1;
03106 }

struct isl_map* isl_map_union_disjoint	(	struct isl_map *	map1,
		struct isl_map *	map2
	)			`[read]`

Definition at line 3047 of file isl_map.c.

03049 {
03050         int i;
03051         unsigned flags = 0;
03052         struct isl_map *map = NULL;
03053 
03054         if (!map1 || !map2)
03055                 goto error;
03056 
03057         if (map1->n == 0) {
03058                 isl_map_free(map1);
03059                 return map2;
03060         }
03061         if (map2->n == 0) {
03062                 isl_map_free(map2);
03063                 return map1;
03064         }
03065 
03066         isl_assert(map1->ctx, isl_dim_equal(map1->dim, map2->dim), goto error);
03067 
03068         if (ISL_F_ISSET(map1, ISL_MAP_DISJOINT) &&
03069             ISL_F_ISSET(map2, ISL_MAP_DISJOINT))
03070                 ISL_FL_SET(flags, ISL_MAP_DISJOINT);
03071 
03072         map = isl_map_alloc_dim(isl_dim_copy(map1->dim),
03073                                 map1->n + map2->n, flags);
03074         if (!map)
03075                 goto error;
03076         for (i = 0; i < map1->n; ++i) {
03077                 map = isl_map_add(map,
03078                                   isl_basic_map_copy(map1->p[i]));
03079                 if (!map)
03080                         goto error;
03081         }
03082         for (i = 0; i < map2->n; ++i) {
03083                 map = isl_map_add(map,
03084                                   isl_basic_map_copy(map2->p[i]));
03085                 if (!map)
03086                         goto error;
03087         }
03088         isl_map_free(map1);
03089         isl_map_free(map2);
03090         return map;
03091 error:
03092         isl_map_free(map);
03093         isl_map_free(map1);
03094         isl_map_free(map2);
03095         return NULL;
03096 }

struct isl_map* isl_map_intersect_domain	(	struct isl_map *	map,
		struct isl_set *	set
	)			`[read]`

Definition at line 3158 of file isl_map.c.

03160 {
03161         return isl_map_reverse(
03162                 isl_map_intersect_range(isl_map_reverse(map), set));
03163 }

struct isl_map* isl_map_intersect_range	(	struct isl_map *	map,
		struct isl_set *	set
	)			`[read]`

Definition at line 3122 of file isl_map.c.

03124 {
03125         unsigned flags = 0;
03126         struct isl_map *result;
03127         int i, j;
03128 
03129         if (!map || !set)
03130                 goto error;
03131 
03132         if (ISL_F_ISSET(map, ISL_MAP_DISJOINT) &&
03133             ISL_F_ISSET(set, ISL_MAP_DISJOINT))
03134                 ISL_FL_SET(flags, ISL_MAP_DISJOINT);
03135 
03136         result = isl_map_alloc_dim(isl_dim_copy(map->dim),
03137                                         map->n * set->n, flags);
03138         if (!result)
03139                 goto error;
03140         for (i = 0; i < map->n; ++i)
03141                 for (j = 0; j < set->n; ++j) {
03142                         result = isl_map_add(result,
03143                             isl_basic_map_intersect_range(
03144                                 isl_basic_map_copy(map->p[i]),
03145                                 isl_basic_set_copy(set->p[j])));
03146                         if (!result)
03147                                 goto error;
03148                 }
03149         isl_map_free(map);
03150         isl_set_free(set);
03151         return result;
03152 error:
03153         isl_map_free(map);
03154         isl_set_free(set);
03155         return NULL;
03156 }

struct isl_map* isl_map_apply_domain	(	struct isl_map *	map1,
		struct isl_map *	map2
	)			`[read]`

Definition at line 3165 of file isl_map.c.

03167 {
03168         if (!map1 || !map2)
03169                 goto error;
03170         map1 = isl_map_reverse(map1);
03171         map1 = isl_map_apply_range(map1, map2);
03172         return isl_map_reverse(map1);
03173 error:
03174         isl_map_free(map1);
03175         isl_map_free(map2);
03176         return NULL;
03177 }

struct isl_map* isl_map_apply_range	(	struct isl_map *	map1,
		struct isl_map *	map2
	)			`[read]`

Definition at line 3179 of file isl_map.c.

03181 {
03182         struct isl_dim *dim_result;
03183         struct isl_map *result;
03184         int i, j;
03185         unsigned nparam;
03186         unsigned n_in;
03187         unsigned n_out;
03188 
03189         if (!map1 || !map2)
03190                 goto error;
03191 
03192         dim_result = isl_dim_join(isl_dim_copy(map1->dim),
03193                                   isl_dim_copy(map2->dim));
03194 
03195         result = isl_map_alloc_dim(dim_result, map1->n * map2->n, 0);
03196         if (!result)
03197                 goto error;
03198         for (i = 0; i < map1->n; ++i)
03199                 for (j = 0; j < map2->n; ++j) {
03200                         result = isl_map_add(result,
03201                             isl_basic_map_apply_range(
03202                                 isl_basic_map_copy(map1->p[i]),
03203                                 isl_basic_map_copy(map2->p[j])));
03204                         if (!result)
03205                                 goto error;
03206                 }
03207         isl_map_free(map1);
03208         isl_map_free(map2);
03209         if (result && result->n <= 1)
03210                 ISL_F_SET(result, ISL_MAP_DISJOINT);
03211         return result;
03212 error:
03213         isl_map_free(map1);
03214         isl_map_free(map2);
03215         return NULL;
03216 }

struct isl_map* isl_map_product	(	struct isl_map *	map1,
		struct isl_map *	map2
	)			`[read]`

Definition at line 4528 of file isl_map.c.

04529 {
04530         unsigned flags = 0;
04531         struct isl_map *result;
04532         int i, j;
04533 
04534         if (!map1 || !map2)
04535                 goto error;
04536 
04537         isl_assert(map1->ctx, isl_dim_match(map1->dim, isl_dim_param,
04538                                          map2->dim, isl_dim_param), goto error);
04539 
04540         if (ISL_F_ISSET(map1, ISL_MAP_DISJOINT) &&
04541             ISL_F_ISSET(map2, ISL_MAP_DISJOINT))
04542                 ISL_FL_SET(flags, ISL_MAP_DISJOINT);
04543 
04544         result = isl_map_alloc_dim(isl_dim_product(isl_dim_copy(map1->dim),
04545                                                    isl_dim_copy(map2->dim)),
04546                                 map1->n * map2->n, flags);
04547         if (!result)
04548                 goto error;
04549         for (i = 0; i < map1->n; ++i)
04550                 for (j = 0; j < map2->n; ++j) {
04551                         struct isl_basic_map *part;
04552                         part = isl_basic_map_product(
04553                                     isl_basic_map_copy(map1->p[i]),
04554                                     isl_basic_map_copy(map2->p[j]));
04555                         if (isl_basic_map_is_empty(part))
04556                                 isl_basic_map_free(part);
04557                         else
04558                                 result = isl_map_add(result, part);
04559                         if (!result)
04560                                 goto error;
04561                 }
04562         isl_map_free(map1);
04563         isl_map_free(map2);
04564         return result;
04565 error:
04566         isl_map_free(map1);
04567         isl_map_free(map2);
04568         return NULL;
04569 }

struct isl_map* isl_map_intersect	(	struct isl_map *	map1,
		struct isl_map *	map2
	)			`[read]`

Definition at line 1707 of file isl_map.c.

01708 {
01709         unsigned flags = 0;
01710         struct isl_map *result;
01711         int i, j;
01712 
01713         if (!map1 || !map2)
01714                 goto error;
01715 
01716         isl_assert(map1->ctx, isl_dim_match(map1->dim, isl_dim_param,
01717                                          map2->dim, isl_dim_param), goto error);
01718         if (isl_dim_total(map1->dim) ==
01719                                 isl_dim_size(map1->dim, isl_dim_param) &&
01720             isl_dim_total(map2->dim) != isl_dim_size(map2->dim, isl_dim_param))
01721                 return isl_map_intersect(map2, map1);
01722 
01723         if (isl_dim_total(map2->dim) != isl_dim_size(map2->dim, isl_dim_param))
01724                 isl_assert(map1->ctx,
01725                             isl_dim_equal(map1->dim, map2->dim), goto error);
01726 
01727         if (ISL_F_ISSET(map1, ISL_MAP_DISJOINT) &&
01728             ISL_F_ISSET(map2, ISL_MAP_DISJOINT))
01729                 ISL_FL_SET(flags, ISL_MAP_DISJOINT);
01730 
01731         result = isl_map_alloc_dim(isl_dim_copy(map1->dim),
01732                                 map1->n * map2->n, flags);
01733         if (!result)
01734                 goto error;
01735         for (i = 0; i < map1->n; ++i)
01736                 for (j = 0; j < map2->n; ++j) {
01737                         struct isl_basic_map *part;
01738                         part = isl_basic_map_intersect(
01739                                     isl_basic_map_copy(map1->p[i]),
01740                                     isl_basic_map_copy(map2->p[j]));
01741                         if (isl_basic_map_is_empty(part))
01742                                 isl_basic_map_free(part);
01743                         else
01744                                 result = isl_map_add(result, part);
01745                         if (!result)
01746                                 goto error;
01747                 }
01748         isl_map_free(map1);
01749         isl_map_free(map2);
01750         return result;
01751 error:
01752         isl_map_free(map1);
01753         isl_map_free(map2);
01754         return NULL;
01755 }

struct isl_map* isl_map_subtract	(	struct isl_map *	map1,
		struct isl_map *	map2
	)			`[read]`

Definition at line 3824 of file isl_map.c.

03825 {
03826         int i;
03827         if (!map1 || !map2)
03828                 goto error;
03829 
03830         isl_assert(map1->ctx, isl_dim_equal(map1->dim, map2->dim), goto error);
03831 
03832         if (isl_map_is_empty(map2)) {
03833                 isl_map_free(map2);
03834                 return map1;
03835         }
03836 
03837         map1 = isl_map_compute_divs(map1);
03838         map2 = isl_map_compute_divs(map2);
03839         if (!map1 || !map2)
03840                 goto error;
03841 
03842         for (i = 0; map1 && i < map2->n; ++i)
03843                 map1 = subtract(map1, map2->p[i]);
03844 
03845         isl_map_free(map2);
03846         return map1;
03847 error:
03848         isl_map_free(map1);
03849         isl_map_free(map2);
03850         return NULL;
03851 }

struct isl_map* isl_map_fix_input_si	(	struct isl_map *	map,
		unsigned	input,
		int	value
	)			`[read]`

Definition at line 2832 of file isl_map.c.

02834 {
02835         return isl_map_fix_si(map, isl_dim_in, input, value);
02836 }

struct isl_map* isl_map_fix_si	(	struct isl_map *	map,
		enum isl_dim_type	type,
		unsigned	pos,
		int	value
	)			`[read]`

Definition at line 2810 of file isl_map.c.

02812 {
02813         int i;
02814 
02815         map = isl_map_cow(map);
02816         if (!map)
02817                 return NULL;
02818 
02819         isl_assert(ctx, pos < isl_map_dim(map, type), goto error);
02820         for (i = 0; i < map->n; ++i) {
02821                 map->p[i] = isl_basic_map_fix_si(map->p[i], type, pos, value);
02822                 if (!map->p[i])
02823                         goto error;
02824         }
02825         ISL_F_CLR(map, ISL_MAP_NORMALIZED);
02826         return map;
02827 error:
02828         isl_map_free(map);
02829         return NULL;
02830 }

struct isl_basic_set* isl_basic_map_deltas ( struct isl_basic_map * bmap ) [read]

Definition at line 3221 of file isl_map.c.

03222 {
03223         struct isl_basic_set *bset;
03224         unsigned dim;
03225         unsigned nparam;
03226         int i;
03227 
03228         if (!bmap)
03229                 goto error;
03230         dim = isl_basic_map_n_in(bmap);
03231         nparam = isl_basic_map_n_param(bmap);
03232         isl_assert(bmap->ctx, dim == isl_basic_map_n_out(bmap), goto error);
03233         bset = isl_basic_set_from_basic_map(bmap);
03234         bset = isl_basic_set_cow(bset);
03235         bset = isl_basic_set_extend(bset, nparam, 3*dim, 0, dim, 0);
03236         bset = isl_basic_set_swap_vars(bset, 2*dim);
03237         for (i = 0; i < dim; ++i) {
03238                 int j = isl_basic_map_alloc_equality(
03239                                             (struct isl_basic_map *)bset);
03240                 if (j < 0)
03241                         goto error;
03242                 isl_seq_clr(bset->eq[j], 1 + isl_basic_set_total_dim(bset));
03243                 isl_int_set_si(bset->eq[j][1+nparam+i], 1);
03244                 isl_int_set_si(bset->eq[j][1+nparam+dim+i], 1);
03245                 isl_int_set_si(bset->eq[j][1+nparam+2*dim+i], -1);
03246         }
03247         return isl_basic_set_project_out(bset, 2*dim, 0);
03248 error:
03249         isl_basic_map_free(bmap);
03250         return NULL;
03251 }

struct isl_set* isl_map_deltas ( struct isl_map * map ) [read]

Definition at line 3256 of file isl_map.c.

03257 {
03258         int i;
03259         struct isl_set *result;
03260 
03261         if (!map)
03262                 return NULL;
03263 
03264         isl_assert(map->ctx, isl_map_n_in(map) == isl_map_n_out(map), goto error);
03265         result = isl_set_alloc(map->ctx, isl_map_n_param(map),
03266                                         isl_map_n_in(map), map->n, map->flags);
03267         if (!result)
03268                 goto error;
03269         for (i = 0; i < map->n; ++i)
03270                 result = isl_set_add(result,
03271                           isl_basic_map_deltas(isl_basic_map_copy(map->p[i])));
03272         isl_map_free(map);
03273         return result;
03274 error:
03275         isl_map_free(map);
03276         return NULL;
03277 }

struct isl_set* isl_map_range ( struct isl_map * map ) [read]

Definition at line 2429 of file isl_map.c.

02430 {
02431         int i;
02432         struct isl_set *set;
02433 
02434         if (!map)
02435                 goto error;
02436         map = isl_map_cow(map);
02437         if (!map)
02438                 goto error;
02439 
02440         set = (struct isl_set *) map;
02441         if (set->dim->n_in != 0) {
02442                 set->dim = isl_dim_drop_inputs(set->dim, 0, set->dim->n_in);
02443                 if (!set->dim)
02444                         goto error;
02445         }
02446         for (i = 0; i < map->n; ++i) {
02447                 set->p[i] = isl_basic_map_range(map->p[i]);
02448                 if (!set->p[i])
02449                         goto error;
02450         }
02451         ISL_F_CLR(set, ISL_MAP_DISJOINT);
02452         ISL_F_CLR(set, ISL_SET_NORMALIZED);
02453         return set;
02454 error:
02455         isl_map_free(map);
02456         return NULL;
02457 }

struct isl_map* isl_map_detect_equalities ( struct isl_map * map ) [read]

Definition at line 523 of file isl_affine_hull.c.

00524 {
00525         struct isl_basic_map *bmap;
00526         int i;
00527 
00528         if (!map)
00529                 return NULL;
00530 
00531         for (i = 0; i < map->n; ++i) {
00532                 bmap = isl_basic_map_copy(map->p[i]);
00533                 bmap = isl_basic_map_detect_equalities(bmap);
00534                 if (!bmap)
00535                         goto error;
00536                 isl_basic_map_free(map->p[i]);
00537                 map->p[i] = bmap;
00538         }
00539 
00540         return map;
00541 error:
00542         isl_map_free(map);
00543         return NULL;
00544 }

struct isl_basic_map* isl_map_affine_hull ( struct isl_map * map ) [read]

Definition at line 566 of file isl_affine_hull.c.

00567 {
00568         int i;
00569         struct isl_basic_map *model = NULL;
00570         struct isl_basic_map *hull = NULL;
00571         struct isl_set *set;
00572 
00573         if (!map)
00574                 return NULL;
00575 
00576         if (map->n == 0) {
00577                 hull = isl_basic_map_empty_like_map(map);
00578                 isl_map_free(map);
00579                 return hull;
00580         }
00581 
00582         map = isl_map_detect_equalities(map);
00583         map = isl_map_align_divs(map);
00584         if (!map)
00585                 return NULL;
00586         model = isl_basic_map_copy(map->p[0]);
00587         set = isl_map_underlying_set(map);
00588         set = isl_set_cow(set);
00589         if (!set)
00590                 goto error;
00591 
00592         for (i = 0; i < set->n; ++i) {
00593                 set->p[i] = isl_basic_set_cow(set->p[i]);
00594                 set->p[i] = isl_basic_set_affine_hull(set->p[i]);
00595                 set->p[i] = isl_basic_set_gauss(set->p[i], NULL);
00596                 if (!set->p[i])
00597                         goto error;
00598         }
00599         set = isl_set_remove_empty_parts(set);
00600         if (set->n == 0) {
00601                 hull = isl_basic_map_empty_like(model);
00602                 isl_basic_map_free(model);
00603         } else {
00604                 struct isl_basic_set *bset;
00605                 while (set->n > 1) {
00606                         set->p[0] = affine_hull(set->p[0], set->p[--set->n]);
00607                         if (!set->p[0])
00608                                 goto error;
00609                 }
00610                 bset = isl_basic_set_copy(set->p[0]);
00611                 hull = isl_basic_map_overlying_set(bset, model);
00612         }
00613         isl_set_free(set);
00614         hull = isl_basic_map_simplify(hull);
00615         return isl_basic_map_finalize(hull);
00616 error:
00617         isl_basic_map_free(model);
00618         isl_set_free(set);
00619         return NULL;
00620 }

struct isl_map* isl_map_remove	(	struct isl_map *	map,
		enum isl_dim_type	type,
		unsigned	first,
		unsigned	n
	)			`[read]`

Definition at line 1179 of file isl_map.c.

01181 {
01182         int i;
01183         unsigned nparam;
01184 
01185         if (n == 0)
01186                 return map;
01187 
01188         map = isl_map_cow(map);
01189         if (!map)
01190                 return NULL;
01191         isl_assert(map->ctx, first + n <= isl_map_dim(map, type), goto error);
01192         
01193         for (i = 0; i < map->n; ++i) {
01194                 map->p[i] = isl_basic_map_eliminate_vars(map->p[i],
01195                         isl_basic_map_offset(map->p[i], type) - 1 + first, n);
01196                 if (!map->p[i])
01197                         goto error;
01198         }
01199         map = isl_map_drop(map, type, first, n);
01200         return map;
01201 error:
01202         isl_map_free(map);
01203         return NULL;
01204 }

struct isl_map* isl_map_remove_inputs	(	struct isl_map *	map,
		unsigned	first,
		unsigned	n
	)			`[read]`

Definition at line 1207 of file isl_map.c.

01209 {
01210         return isl_map_remove(map, isl_dim_in, first, n);
01211 }

struct isl_set* isl_map_domain ( struct isl_map * bmap ) [read]

Definition at line 3018 of file isl_map.c.

03019 {
03020         int i;
03021         struct isl_set *set;
03022 
03023         if (!map)
03024                 goto error;
03025 
03026         map = isl_map_cow(map);
03027         if (!map)
03028                 return NULL;
03029 
03030         set = (struct isl_set *)map;
03031         set->dim = isl_dim_domain(set->dim);
03032         if (!set->dim)
03033                 goto error;
03034         for (i = 0; i < map->n; ++i) {
03035                 set->p[i] = isl_basic_map_domain(map->p[i]);
03036                 if (!set->p[i])
03037                         goto error;
03038         }
03039         ISL_F_CLR(set, ISL_MAP_DISJOINT);
03040         ISL_F_CLR(set, ISL_SET_NORMALIZED);
03041         return set;
03042 error:
03043         isl_map_free(map);
03044         return NULL;
03045 }

struct isl_map* isl_map_from_basic_map ( struct isl_basic_map * bmap ) [read]

Definition at line 1454 of file isl_map.c.

01455 {
01456         struct isl_map *map;
01457 
01458         if (!bmap)
01459                 return NULL;
01460 
01461         map = isl_map_alloc_dim(isl_dim_copy(bmap->dim), 1, ISL_MAP_DISJOINT);
01462         if (!map) {
01463                 isl_basic_map_free(bmap);
01464                 return NULL;
01465         }
01466         return isl_map_add(map, bmap);
01467 }

struct isl_map* isl_map_from_range ( struct isl_set * set ) [read]

Definition at line 2484 of file isl_map.c.

02485 {
02486         return (struct isl_map *)set;
02487 }

struct isl_map* isl_map_from_set	(	struct isl_set *	set,
		struct isl_dim *	dim
	)			`[read]`

Definition at line 2459 of file isl_map.c.

02460 {
02461         int i;
02462         struct isl_map *map = NULL;
02463 
02464         set = isl_set_cow(set);
02465         if (!set || !dim)
02466                 goto error;
02467         isl_assert(set->ctx, isl_dim_compatible(set->dim, dim), goto error);
02468         map = (struct isl_map *)set;
02469         for (i = 0; i < set->n; ++i) {
02470                 map->p[i] = isl_basic_map_from_basic_set(
02471                                 set->p[i], isl_dim_copy(dim));
02472                 if (!map->p[i])
02473                         goto error;
02474         }
02475         isl_dim_free(map->dim);
02476         map->dim = dim;
02477         return map;
02478 error:
02479         isl_dim_free(dim);
02480         isl_set_free(set);
02481         return NULL;
02482 }

struct isl_set* isl_set_from_map ( struct isl_map * map ) [read]

Definition at line 2489 of file isl_map.c.

02490 {
02491         int i;
02492         struct isl_set *set = NULL;
02493 
02494         if (!map)
02495                 return NULL;
02496         map = isl_map_cow(map);
02497         if (!map)
02498                 return NULL;
02499         map->dim = isl_dim_cow(map->dim);
02500         if (!map->dim)
02501                 goto error;
02502         map->dim->n_out += map->dim->n_in;
02503         map->dim->n_in = 0;
02504         set = (struct isl_set *)map;
02505         for (i = 0; i < map->n; ++i) {
02506                 set->p[i] = isl_basic_set_from_basic_map(map->p[i]);
02507                 if (!set->p[i])
02508                         goto error;
02509         }
02510         return set;
02511 error:
02512         isl_map_free(map);
02513         return NULL;
02514 }

int isl_map_fast_is_empty ( struct isl_map * map )

Definition at line 3419 of file isl_map.c.

03420 {
03421         return map->n == 0;
03422 }

int isl_map_is_empty ( struct isl_map * map )

Definition at line 3402 of file isl_map.c.

03403 {
03404         int i;
03405         int is_empty;
03406 
03407         if (!map)
03408                 return -1;
03409         for (i = 0; i < map->n; ++i) {
03410                 is_empty = isl_basic_map_is_empty(map->p[i]);
03411                 if (is_empty < 0)
03412                         return -1;
03413                 if (!is_empty)
03414                         return 0;
03415         }
03416         return 1;
03417 }

int isl_map_is_subset	(	struct isl_map *	map1,
		struct isl_map *	map2
	)

Definition at line 3429 of file isl_map.c.

03430 {
03431         int i;
03432         int is_subset = 0;
03433         struct isl_map *diff;
03434 
03435         if (!map1 || !map2)
03436                 return -1;
03437 
03438         if (isl_map_is_empty(map1))
03439                 return 1;
03440 
03441         if (isl_map_is_empty(map2))
03442                 return 0;
03443 
03444         diff = isl_map_subtract(isl_map_copy(map1), isl_map_copy(map2));
03445         if (!diff)
03446                 return -1;
03447 
03448         is_subset = isl_map_is_empty(diff);
03449         isl_map_free(diff);
03450 
03451         return is_subset;
03452 }

int isl_map_is_equal	(	struct isl_map *	map1,
		struct isl_map *	map2
	)

Definition at line 3454 of file isl_map.c.

03455 {
03456         int is_subset;
03457 
03458         if (!map1 || !map2)
03459                 return -1;
03460         is_subset = isl_map_is_subset(map1, map2);
03461         if (is_subset != 1)
03462                 return is_subset;
03463         is_subset = isl_map_is_subset(map2, map1);
03464         return is_subset;
03465 }

void isl_map_dump	(	struct isl_map *	map,
		FILE *	out,
		int	indent
	)

Definition at line 1523 of file isl_map.c.

01524 {
01525         int i;
01526 
01527         if (!map) {
01528                 fprintf(out, "null map\n");
01529                 return;
01530         }
01531 
01532         fprintf(out, "%*s", indent, "");
01533         fprintf(out, "ref: %d, n: %d, nparam: %d, in: %d, out: %d, "
01534                      "flags: %x, n_name: %d\n",
01535                         map->ref, map->n, map->dim->nparam, map->dim->n_in,
01536                         map->dim->n_out, map->flags, map->dim->n_name);
01537         for (i = 0; i < map->n; ++i) {
01538                 fprintf(out, "%*s", indent, "");
01539                 fprintf(out, "basic map %d:\n", i);
01540                 isl_basic_map_dump(map->p[i], out, indent+4);
01541         }
01542 }

int isl_map_fast_input_is_fixed	(	struct isl_map *	map,
		unsigned	in,
		isl_int *	val
	)

Definition at line 4115 of file isl_map.c.

04116 {
04117         return isl_map_fast_has_fixed_var(map, isl_map_n_param(map) + in, val);
04118 }

struct isl_map* isl_map_coalesce ( struct isl_map * map ) [read]

Definition at line 553 of file isl_coalesce.c.

00554 {
00555         int i;
00556         unsigned n;
00557         struct isl_ctx *ctx;
00558         struct isl_tab **tabs = NULL;
00559 
00560         if (!map)
00561                 return NULL;
00562 
00563         if (map->n <= 1)
00564                 return map;
00565 
00566         map = isl_map_align_divs(map);
00567 
00568         tabs = isl_calloc_array(map->ctx, struct isl_tab *, map->n);
00569         if (!tabs)
00570                 goto error;
00571 
00572         n = map->n;
00573         ctx = map->ctx;
00574         for (i = 0; i < map->n; ++i) {
00575                 tabs[i] = isl_tab_from_basic_map(map->p[i]);
00576                 if (!tabs[i])
00577                         goto error;
00578                 if (!ISL_F_ISSET(map->p[i], ISL_BASIC_MAP_NO_IMPLICIT))
00579                         tabs[i] = isl_tab_detect_equalities(map->ctx, tabs[i]);
00580                 if (!ISL_F_ISSET(map->p[i], ISL_BASIC_MAP_NO_REDUNDANT))
00581                         tabs[i] = isl_tab_detect_redundant(map->ctx, tabs[i]);
00582         }
00583         for (i = map->n - 1; i >= 0; --i)
00584                 if (tabs[i]->empty)
00585                         drop(map, i, tabs);
00586 
00587         map = coalesce(map, tabs);
00588 
00589         if (map)
00590                 for (i = 0; i < map->n; ++i) {
00591                         map->p[i] = isl_basic_map_update_from_tab(map->p[i],
00592                                                                     tabs[i]);
00593                         map->p[i] = isl_basic_map_finalize(map->p[i]);
00594                         if (!map->p[i])
00595                                 goto error;
00596                         ISL_F_SET(map->p[i], ISL_BASIC_MAP_NO_IMPLICIT);
00597                         ISL_F_SET(map->p[i], ISL_BASIC_MAP_NO_REDUNDANT);
00598                 }
00599 
00600         for (i = 0; i < n; ++i)
00601                 isl_tab_free(ctx, tabs[i]);
00602 
00603         free(tabs);
00604 
00605         return map;
00606 error:
00607         if (tabs)
00608                 for (i = 0; i < n; ++i)
00609                         isl_tab_free(ctx, tabs[i]);
00610         free(tabs);
00611         return NULL;
00612 }

int isl_map_fast_is_equal	(	struct isl_map *	map1,
		struct isl_map *	map2
	)

Definition at line 4360 of file isl_map.c.

04361 {
04362         int i;
04363         int equal;
04364 
04365         if (!map1 || !map2)
04366                 return -1;
04367 
04368         if (map1 == map2)
04369                 return 1;
04370         if (!isl_dim_equal(map1->dim, map2->dim))
04371                 return 0;
04372 
04373         map1 = isl_map_copy(map1);
04374         map2 = isl_map_copy(map2);
04375         map1 = isl_map_normalize(map1);
04376         map2 = isl_map_normalize(map2);
04377         if (!map1 || !map2)
04378                 goto error;
04379         equal = map1->n == map2->n;
04380         for (i = 0; equal && i < map1->n; ++i) {
04381                 equal = isl_basic_map_fast_is_equal(map1->p[i], map2->p[i]);
04382                 if (equal < 0)
04383                         goto error;
04384         }
04385         isl_map_free(map1);
04386         isl_map_free(map2);
04387         return equal;
04388 error:
04389         isl_map_free(map1);
04390         isl_map_free(map2);
04391         return -1;
04392 }


Data Structures
struct	isl_basic_map
struct	isl_map
Defines
#define	ISL_BASIC_MAP_FINAL (1 << 0)
#define	ISL_BASIC_MAP_EMPTY (1 << 1)
#define	ISL_BASIC_MAP_NO_IMPLICIT (1 << 2)
#define	ISL_BASIC_MAP_NO_REDUNDANT (1 << 3)
#define	ISL_BASIC_MAP_RATIONAL (1 << 4)
#define	ISL_BASIC_MAP_NORMALIZED (1 << 5)
#define	ISL_BASIC_MAP_NORMALIZED_DIVS (1 << 6)
#define	ISL_BASIC_MAP_ALL_EQUALITIES (1 << 7)
#define	ISL_MAP_DISJOINT (1 << 0)
#define	ISL_MAP_NORMALIZED (1 << 1)
#define	ISL_FORMAT_POLYLIB 1
#define	ISL_FORMAT_OMEGA 2
Functions
unsigned	isl_basic_map_n_in (const struct isl_basic_map *bmap)
unsigned	isl_basic_map_n_out (const struct isl_basic_map *bmap)
unsigned	isl_basic_map_n_param (const struct isl_basic_map *bmap)
unsigned	isl_basic_map_n_div (const struct isl_basic_map *bmap)
unsigned	isl_basic_map_total_dim (const struct isl_basic_map *bmap)
unsigned	isl_basic_map_dim (const struct isl_basic_map *bmap, enum isl_dim_type type)
unsigned	isl_map_n_in (const struct isl_map *map)
unsigned	isl_map_n_out (const struct isl_map *map)
unsigned	isl_map_n_param (const struct isl_map *map)
unsigned	isl_map_dim (const struct isl_map *map, enum isl_dim_type type)
struct isl_basic_map *	isl_basic_map_alloc (struct isl_ctx *ctx, unsigned nparam, unsigned in, unsigned out, unsigned extra, unsigned n_eq, unsigned n_ineq)
struct isl_basic_map *	isl_basic_map_identity (struct isl_dim *set_dim)
struct isl_basic_map *	isl_basic_map_identity_like (struct isl_basic_map *model)
struct isl_basic_map *	isl_basic_map_finalize (struct isl_basic_map *bmap)
void	isl_basic_map_free (struct isl_basic_map *bmap)
struct isl_basic_map *	isl_basic_map_copy (struct isl_basic_map *bmap)
struct isl_basic_map *	isl_basic_map_extend (struct isl_basic_map *base, unsigned nparam, unsigned n_in, unsigned n_out, unsigned extra, unsigned n_eq, unsigned n_ineq)
struct isl_basic_map *	isl_basic_map_extend_constraints (struct isl_basic_map *base, unsigned n_eq, unsigned n_ineq)
struct isl_basic_map *	isl_basic_map_equal (struct isl_dim *dim, unsigned n_equal)
struct isl_basic_map *	isl_basic_map_less_at (struct isl_dim *dim, unsigned pos)
struct isl_basic_map *	isl_basic_map_more_at (struct isl_dim *dim, unsigned pos)
struct isl_basic_map *	isl_basic_map_empty (struct isl_ctx *ctx, unsigned nparam, unsigned in, unsigned out)
struct isl_basic_map *	isl_basic_map_empty_like (struct isl_basic_map *model)
struct isl_basic_map *	isl_basic_map_empty_like_map (struct isl_map *model)
struct isl_basic_map *	isl_basic_map_universe (struct isl_dim *dim)
struct isl_basic_map *	isl_basic_map_convex_hull (struct isl_basic_map *bmap)
struct isl_basic_map *	isl_basic_map_intersect_domain (struct isl_basic_map bmap, struct isl_basic_set bset)
struct isl_basic_map *	isl_basic_map_intersect_range (struct isl_basic_map bmap, struct isl_basic_set bset)
struct isl_basic_map *	isl_basic_map_intersect (struct isl_basic_map bmap1, struct isl_basic_map bmap2)
struct isl_map *	isl_basic_map_union (struct isl_basic_map bmap1, struct isl_basic_map bmap2)
struct isl_basic_map *	isl_basic_map_apply_domain (struct isl_basic_map bmap1, struct isl_basic_map bmap2)
struct isl_basic_map *	isl_basic_map_apply_range (struct isl_basic_map bmap1, struct isl_basic_map bmap2)
struct isl_basic_map *	isl_basic_map_reverse (struct isl_basic_map *bmap)
struct isl_basic_set *	isl_basic_map_domain (struct isl_basic_map *bmap)
struct isl_basic_set *	isl_basic_map_range (struct isl_basic_map *bmap)
struct isl_basic_map *	isl_basic_map_remove (struct isl_basic_map *bmap, enum isl_dim_type type, unsigned first, unsigned n)
struct isl_basic_map *	isl_basic_map_from_basic_set (struct isl_basic_set bset, struct isl_dim dim)
struct isl_basic_set *	isl_basic_set_from_basic_map (struct isl_basic_map *bmap)
struct isl_basic_map *	isl_basic_map_simplify (struct isl_basic_map *bmap)
struct isl_basic_map *	isl_basic_map_detect_equalities (struct isl_basic_map *bmap)
struct isl_basic_map *	isl_basic_map_read_from_file (struct isl_ctx ctx, FILE input, unsigned nparam, unsigned input_format)
struct isl_basic_map *	isl_basic_map_fix_si (struct isl_basic_map *bmap, enum isl_dim_type type, unsigned pos, int value)
struct isl_basic_map *	isl_basic_map_sum (struct isl_basic_map bmap1, struct isl_basic_map bmap2)
struct isl_basic_map *	isl_basic_map_neg (struct isl_basic_map *bmap)
struct isl_basic_map *	isl_basic_map_floordiv (struct isl_basic_map *bmap, isl_int d)
int	isl_basic_map_is_equal (struct isl_basic_map bmap1, struct isl_basic_map bmap2)
struct isl_map *	isl_basic_map_lexmax (struct isl_basic_map bmap, struct isl_basic_set dom, struct isl_set **empty)
struct isl_map *	isl_basic_map_lexmin (struct isl_basic_map bmap, struct isl_basic_set dom, struct isl_set **empty)
void	isl_basic_map_dump (struct isl_basic_map bmap, FILE out, int indent)
struct isl_basic_map *	isl_map_copy_basic_map (struct isl_map *map)
struct isl_map *	isl_map_drop_basic_map (struct isl_map map, struct isl_basic_map bmap)
int	isl_basic_map_fast_is_fixed (struct isl_basic_map bmap, enum isl_dim_type type, unsigned pos, isl_int val)
int	isl_basic_map_is_universe (struct isl_basic_map *bmap)
int	isl_basic_map_fast_is_empty (struct isl_basic_map *bmap)
int	isl_basic_map_is_empty (struct isl_basic_map *bmap)
int	isl_basic_map_is_subset (struct isl_basic_map bmap1, struct isl_basic_map bmap2)
int	isl_basic_map_is_strict_subset (struct isl_basic_map bmap1, struct isl_basic_map bmap2)
struct isl_map *	isl_map_alloc (struct isl_ctx *ctx, unsigned nparam, unsigned in, unsigned out, int n, unsigned flags)
struct isl_map *	isl_map_universe (struct isl_dim *dim)
struct isl_map *	isl_map_empty (struct isl_dim *dim)
struct isl_map *	isl_map_empty_like (struct isl_map *model)
struct isl_map *	isl_map_empty_like_basic_map (struct isl_basic_map *model)
struct isl_map *	isl_map_dup (struct isl_map *map)
struct isl_map *	isl_map_add (struct isl_map map, struct isl_basic_map bmap)
struct isl_map *	isl_map_identity (struct isl_dim *set_dim)
struct isl_map *	isl_map_identity_like (struct isl_basic_map *model)
struct isl_map *	isl_map_finalize (struct isl_map *map)
void	isl_map_free (struct isl_map *map)
struct isl_map *	isl_map_copy (struct isl_map *map)
struct isl_map *	isl_map_extend (struct isl_map *base, unsigned nparam, unsigned n_in, unsigned n_out)
struct isl_map *	isl_map_reverse (struct isl_map *map)
struct isl_map *	isl_map_union (struct isl_map map1, struct isl_map map2)
struct isl_map *	isl_map_union_disjoint (struct isl_map map1, struct isl_map map2)
struct isl_map *	isl_map_intersect_domain (struct isl_map map, struct isl_set set)
struct isl_map *	isl_map_intersect_range (struct isl_map map, struct isl_set set)
struct isl_map *	isl_map_apply_domain (struct isl_map map1, struct isl_map map2)
struct isl_map *	isl_map_apply_range (struct isl_map map1, struct isl_map map2)
struct isl_map *	isl_map_product (struct isl_map map1, struct isl_map map2)
struct isl_map *	isl_map_intersect (struct isl_map map1, struct isl_map map2)
struct isl_map *	isl_map_subtract (struct isl_map map1, struct isl_map map2)
struct isl_map *	isl_map_fix_input_si (struct isl_map *map, unsigned input, int value)
struct isl_map *	isl_map_fix_si (struct isl_map *map, enum isl_dim_type type, unsigned pos, int value)
struct isl_basic_set *	isl_basic_map_deltas (struct isl_basic_map *bmap)
struct isl_set *	isl_map_deltas (struct isl_map *map)
struct isl_set *	isl_map_range (struct isl_map *map)
struct isl_map *	isl_map_detect_equalities (struct isl_map *map)
struct isl_basic_map *	isl_map_affine_hull (struct isl_map *map)
struct isl_map *	isl_map_remove (struct isl_map *map, enum isl_dim_type type, unsigned first, unsigned n)
struct isl_map *	isl_map_remove_inputs (struct isl_map *map, unsigned first, unsigned n)
struct isl_set *	isl_map_domain (struct isl_map *bmap)
struct isl_map *	isl_map_from_basic_map (struct isl_basic_map *bmap)
struct isl_map *	isl_map_from_range (struct isl_set *set)
struct isl_map *	isl_map_from_set (struct isl_set set, struct isl_dim dim)
struct isl_set *	isl_set_from_map (struct isl_map *map)
int	isl_map_fast_is_empty (struct isl_map *map)
int	isl_map_is_empty (struct isl_map *map)
int	isl_map_is_subset (struct isl_map map1, struct isl_map map2)
int	isl_map_is_equal (struct isl_map map1, struct isl_map map2)
void	isl_map_dump (struct isl_map map, FILE out, int indent)
int	isl_map_fast_input_is_fixed (struct isl_map map, unsigned in, isl_int val)
struct isl_map *	isl_map_coalesce (struct isl_map *map)
int	isl_map_fast_is_equal (struct isl_map map1, struct isl_map map2)

isl_map.h File Reference

Data Structures

Defines

Functions

Define Documentation

Function Documentation