| /src/external/mit/isl/dist/ |
| isl_affine_hull.c | 355 * If so, add them to "hull" and return the updated hull.
358 * check whether it already belongs to "hull" as this test is typically
362 __isl_take isl_basic_set *hull, __isl_take isl_vec *sample,
368 dim = isl_basic_set_dim(hull, isl_dim_set);
378 contains = isl_basic_set_contains(hull, sample);
391 hull = affine_hull(hull, point);
401 return hull;
404 isl_basic_set_free(hull);
481 isl_basic_set *hull; local
502 struct isl_basic_set *hull; local
629 struct isl_basic_set *hull = NULL; local
735 struct isl_basic_set *hull; local
860 struct isl_basic_set *hull = NULL; local
908 struct isl_basic_set *hull = NULL; local
1212 struct isl_basic_map *hull = NULL; local
[all...] |
| isl_convex_hull.c | 251 /* Given a facet "facet" of the convex hull of "set" and a facet "ridge"
252 * of that facet, compute the other facet of the convex hull that contains
270 * Since the ridge contains the origin, the cone of the convex hull
278 * convex hull to 1 and minimizing x_2.
279 * Now, each element in the cone of the convex hull is the sum
380 * If the affine hull of this intersection has only one equality,
443 /* Given the bounding constraint "c" of a facet of the convex hull of "set",
524 * in the resulting convex hull. That is, we compute the ridges
525 * of the resulting convex hull contained in the facet.
527 * of the convex hull. There is no need to wrap around the ridge
607 struct isl_basic_set *hull; local
749 struct isl_basic_set *hull = NULL; local
954 struct isl_basic_set *hull; local
1230 struct isl_basic_set *hull; local
1754 struct isl_basic_set *hull; local
1772 struct isl_basic_set *hull; local
1982 isl_basic_map *hull; local
2336 struct isl_basic_set *hull = NULL; local
2379 isl_basic_map *hull; local
2398 isl_basic_map *hull; local
2430 struct isl_basic_map *hull; local
2655 isl_basic_map *hull; local
2777 isl_basic_set *hull = NULL; local
2890 isl_basic_set *hull; local
2954 isl_basic_map *hull; local
3084 struct isl_basic_set *hull; local
[all...] |
| isl_scheduler_clustering.c | 1389 isl_basic_map *hull; local
1405 hull = isl_map_affine_hull(isl_map_copy(edge->map));
1406 hull = isl_basic_map_transform_dims(hull, isl_dim_in, 0,
1408 hull = isl_basic_map_transform_dims(hull, isl_dim_out, 0,
1410 hull = isl_basic_map_project_out(hull,
1412 hull = isl_basic_map_project_out(hull,
[all...] |
| isl_stride.c | 294 * In particular, compute the affine hull and then check if
295 * any of the constraints in the hull impose any stride on the dimension.
302 isl_basic_set *hull; local
304 hull = isl_set_affine_hull(isl_set_copy(set));
310 if (isl_basic_set_foreach_constraint(hull, &detect_stride, data) < 0)
324 isl_basic_set_free(hull);
327 isl_basic_set_free(hull);
|
| isl_scheduler.c | 498 isl_set_free(node->hull);
777 /* Perform a compression on "node" where "hull" represents the constraints
793 __isl_take isl_set *hull, __isl_take isl_multi_aff *compress,
799 node->hull = hull;
803 hull = isl_set_preimage_multi_aff(hull,
805 node->hull = isl_set_intersect(node->hull, hull);
848 isl_set *hull; local
1037 isl_basic_set *hull; local
1300 isl_map *hull; local
4816 isl_basic_set *hull; local
[all...] |
| isl_scheduler.h | 43 * If compressed is set, then hull represents the constraints
73 isl_set *hull; member in struct:isl_sched_node
|
| isl_ast_codegen.c | 884 isl_basic_set *hull; local
893 hull = isl_set_simple_hull(enforced_i);
894 enforced = isl_basic_set_intersect(enforced, hull);
1478 isl_basic_set *hull; local
1489 hull = isl_set_unshifted_simple_hull(isl_set_copy(domain));
1490 bounds = isl_basic_set_intersect(bounds, hull);
1977 * of each slice is replaced by its simple hull.
2565 * by computing its simple hull. We then iterate through them,
2580 isl_basic_set *hull; local
2582 hull = isl_set_simple_hull(isl_set_copy(domain))
3295 isl_basic_set *hull; local
3390 isl_basic_set *hull; local
3421 isl_set *hull; local
3624 isl_basic_set *hull; local
[all...] |
| isl_aff.c | 2308 isl_basic_set *hull; local
2313 hull = isl_set_affine_hull(context);
2314 return isl_aff_substitute_equalities_lifted(aff, hull);
5283 __isl_take isl_map *map, __isl_take isl_basic_map *hull, int d, int i)
5304 ls = isl_basic_map_get_local_space(hull);
5307 v = isl_basic_map_inequality_extract_output_upper_bound(hull, i, d);
5308 isl_basic_map_free(hull);
5333 isl_basic_map_free(hull);
5377 isl_basic_map *hull; local
5379 hull = isl_map_unshifted_simple_hull(isl_map_copy(map))
5669 isl_basic_map *hull; local
[all...] |
| isl_coalesce.c | 314 /* Compute the hash of the (apparent) affine hull of info->bmap (with
320 isl_basic_map *hull; local
323 hull = isl_basic_map_copy(info->bmap);
324 hull = isl_basic_map_plain_affine_hull(hull);
325 n_div = isl_basic_map_dim(hull, isl_dim_div);
327 hull = isl_basic_map_free(hull);
328 hull = isl_basic_map_drop_constraints_involving_dims(hull,
[all...] |
| isl_ast_build_expr.c | 901 isl_basic_set *hull; local
916 hull = isl_set_simple_hull(isl_set_copy(data->build->domain));
917 hull = isl_basic_set_remove_divs(hull);
920 r = isl_basic_set_foreach_constraint(hull, &check_parallel_or_opposite,
922 isl_basic_set_free(hull);
1731 * after subtracting the previous disjuncts of "set", the simple hull
|
| isl_ast_graft.c | 212 * Otherwise, we return the unshifted simple hull of the guards.
218 * compute the unshifted hull of the result using only constraints
225 * are non-convex. Taking the simple hull would remove information
237 isl_basic_set *hull; local
284 hull = isl_set_unshifted_simple_hull_from_set_list(guard, set_list);
285 guard = isl_set_from_basic_set(hull);
931 * The enforced set is initialized to the simple hull of the enforced sets
|
| isl_output.c | 1147 * "hull" describes constraints shared by all disjuncts of "map".
1150 * Print the disjuncts as a conjunction of "hull" and
1151 * the result of removing the constraints of "hull" from "map".
1152 * If this result turns out to be the universe, then simply print "hull".
1155 __isl_keep isl_space *space, __isl_take isl_basic_map *hull,
1160 p = print_disjunct(hull, space, p, latex);
1161 map = isl_map_plain_gist_basic_map(isl_map_copy(map), hull);
1199 isl_basic_map *hull; local
1202 hull = isl_map_plain_unshifted_simple_hull(isl_map_copy(map));
1203 is_universe = isl_basic_map_plain_is_universe(hull);
[all...] |
| isl_map_simplify.c | 3628 isl_basic_map *hull; local
3630 hull = isl_map_unshifted_simple_hull(context);
3631 return isl_map_plain_gist_basic_map(map, hull);
3666 * Simply taking the simple hull may drop constraints that are
3679 isl_basic_map *hull; local
3714 hull = isl_map_simple_hull(context);
3723 hull = isl_map_unshifted_simple_hull_from_map_list(context,
3726 return isl_map_gist_basic_map(map, hull);
|
| isl_test.c | 1474 "hull should not have any constraints",
1480 /* Inputs for simple hull tests, consisting of
1481 * the specific simple hull function, the input set and the expected result.
1486 const char *hull; member in struct:__anon23690
1505 /* Basic tests for various simple hull functions.
1511 isl_basic_set *hull, *expected; local
1518 str = simple_hull_tests[i].hull;
1520 hull = simple_hull_tests[i].fn(set);
1521 equal = isl_basic_set_is_equal(hull, expected);
1522 isl_basic_set_free(hull);
1651 const char *hull; member in struct:__anon23692
[all...] |
| /src/games/sail/ |
| assorted.c | 53 int guns, car, pc, hull; local
61 hull = on->specs->hull;
135 hull -= ghits;
143 hull -= hhits;
144 hull = hull < 0 ? 0 : hull;
148 send_hull(on, hull);
244 if (!hull)
[all...] |
| pl_6.c | 62 c = sgetch("Repair (hull, guns, rigging)? ", (struct ship *)0, 1);
82 if (ptr->hull < max) {
83 FIX(hull, max);
84 send_hull(ms, ptr->hull);
|
| extern.h | 103 #define HULL 0
199 char hull; member in struct:shipspecs
|
| pl_7.c | 629 wprintw(stat_w, "Hull %2d\n", mc->hull);
|
| sync.c | 799 ship->specs->hull = a;
|
| /src/external/mit/xorg/lib/libGLU/ |
| Makefile | 65 hull.cc \
|
| /src/external/mit/isl/dist/doc/ |
| implementation.tex | 105 \section{Simple Hull}\label{s:simple hull}
110 (rational) convex hull. For integer sets, the obvious choice
111 would be the integer hull.
112 However, {\tt isl} currently does not support an integer hull operation
114 The convex hull operation is supported, but it is also fairly
117 Usually, it is not required to compute the exact integer hull,
118 and an overapproximation of this hull is sufficient.
119 The ``simple hull'' of a set is such an overapproximation
123 This means that the simple hull is relatively cheap to comput
[all...] |
