Coverage Report

Created: 2018-10-23 09:19

/Users/buildslave/jenkins/workspace/clang-stage2-coverage-R/llvm/tools/polly/lib/External/isl/include/isl/isl-noexceptions.h
Line
Count
Source (jump to first uncovered line)
1
/// These are automatically generated checked C++ bindings for isl.
2
///
3
/// isl is a library for computing with integer sets and maps described by
4
/// Presburger formulas. On top of this, isl provides various tools for
5
/// polyhedral compilation, ranging from dependence analysis over scheduling
6
/// to AST generation.
7
8
#ifndef ISL_CPP_CHECKED
9
#define ISL_CPP_CHECKED
10
11
#include <isl/val.h>
12
#include <isl/aff.h>
13
#include <isl/set.h>
14
#include <isl/space.h>
15
#include <isl/id.h>
16
#include <isl/map.h>
17
#include <isl/vec.h>
18
#include <isl/ilp.h>
19
#include <isl/union_set.h>
20
#include <isl/union_map.h>
21
#include <isl/flow.h>
22
#include <isl/schedule.h>
23
#include <isl/schedule_node.h>
24
#include <isl/ast_build.h>
25
#include <isl/constraint.h>
26
#include <isl/polynomial.h>
27
#include <isl/mat.h>
28
#include <isl/fixed_box.h>
29
30
#include <stdio.h>
31
#include <stdlib.h>
32
33
#include <functional>
34
#include <string>
35
36
namespace isl {
37
inline namespace noexceptions {
38
39
#define ISLPP_STRINGIZE_(X) #X
40
#define ISLPP_STRINGIZE(X) ISLPP_STRINGIZE_(X)
41
42
#define ISLPP_ASSERT(test, message)                          \
43
67.0k
  do {                                                       \
44
67.0k
    if (test)                                                \
45
67.0k
      break;                                                 \
46
67.0k
    fputs("Assertion \"" #test "\" failed at " __FILE__      \
47
0
      ":" ISLPP_STRINGIZE(__LINE__) "\n  " message "\n",     \
48
0
      stderr);                                               \
49
0
    abort();                                                 \
50
67.0k
  } while (
00
)
51
52
class boolean {
53
private:
54
  mutable bool checked = false;
55
  isl_bool val;
56
57
  friend boolean manage(isl_bool val);
58
68.6k
  boolean(isl_bool val): val(val) {}
59
public:
60
  boolean()
61
0
      : val(isl_bool_error) {}
62
84.7k
  ~boolean() {
63
84.7k
    // ISLPP_ASSERT(checked, "IMPLEMENTATION ERROR: Unchecked state");
64
84.7k
  }
65
66
  /* implicit */ boolean(bool val)
67
16.1k
      : val(val ? isl_bool_true : isl_bool_false) {}
68
69
83.2k
  bool is_error() const { checked = true; return val == isl_bool_error; }
70
1.15k
  bool is_false() const { checked = true; return val == isl_bool_false; }
71
83.6k
  bool is_true() const { checked = true; return val == isl_bool_true; }
72
73
67.0k
  operator bool() const {
74
67.0k
    // ISLPP_ASSERT(checked, "IMPLEMENTATION ERROR: Unchecked error state");
75
67.0k
    ISLPP_ASSERT(!is_error(), "IMPLEMENTATION ERROR: Unhandled error state");
76
67.0k
    return is_true();
77
67.0k
  }
78
79
16.1k
  boolean operator!() const {
80
16.1k
    if (is_error())
81
0
      return *this;
82
16.1k
    return !is_true();
83
16.1k
  }
84
};
85
86
68.6k
inline boolean manage(isl_bool val) {
87
68.6k
  return boolean(val);
88
68.6k
}
89
90
class ctx {
91
  isl_ctx *ptr;
92
public:
93
  /* implicit */ ctx(isl_ctx *ctx)
94
52.0k
      : ptr(ctx) {}
95
51.7k
  isl_ctx *release() {
96
51.7k
    auto tmp = ptr;
97
51.7k
    ptr = nullptr;
98
51.7k
    return tmp;
99
51.7k
  }
100
62.1k
  isl_ctx *get() {
101
62.1k
    return ptr;
102
62.1k
  }
103
};
104
105
/* Class encapsulating an isl_stat value.
106
 */
107
class stat {
108
private:
109
  mutable bool checked = false;
110
  isl_stat val;
111
112
  friend stat manage(isl_stat val);
113
public:
114
510
  constexpr stat(isl_stat val) : val(val) {}
115
303
  static stat ok() {
116
303
    return stat(isl_stat_ok);
117
303
  }
118
3
  static stat error() {
119
3
    return stat(isl_stat_error);
120
3
  }
121
0
  stat() : val(isl_stat_error) {}
122
510
  ~stat() {
123
510
    // ISLPP_ASSERT(checked, "IMPLEMENTATION ERROR: Unchecked state");
124
510
  }
125
126
306
  isl_stat release() {
127
306
    checked = true;
128
306
    return val;
129
306
  }
130
131
199
  bool is_error() const {
132
199
    checked = true;
133
199
    return val == isl_stat_error;
134
199
  }
135
  bool is_ok() const {
136
    checked = true;
137
    return val == isl_stat_ok;
138
  }
139
};
140
141
142
inline stat manage(isl_stat val)
143
204
{
144
204
  return stat(val);
145
204
}
146
147
enum class dim {
148
  cst = isl_dim_cst,
149
  param = isl_dim_param,
150
  in = isl_dim_in,
151
  out = isl_dim_out,
152
  set = isl_dim_set,
153
  div = isl_dim_div,
154
  all = isl_dim_all
155
};
156
157
}
158
} // namespace isl
159
160
namespace isl {
161
162
inline namespace noexceptions {
163
164
// forward declarations
165
class aff;
166
class aff_list;
167
class ast_build;
168
class ast_expr;
169
class ast_expr_list;
170
class ast_node;
171
class ast_node_list;
172
class basic_map;
173
class basic_map_list;
174
class basic_set;
175
class basic_set_list;
176
class constraint;
177
class constraint_list;
178
class fixed_box;
179
class id;
180
class id_list;
181
class id_to_ast_expr;
182
class local_space;
183
class map;
184
class map_list;
185
class mat;
186
class multi_aff;
187
class multi_pw_aff;
188
class multi_union_pw_aff;
189
class multi_val;
190
class point;
191
class pw_aff;
192
class pw_aff_list;
193
class pw_multi_aff;
194
class pw_multi_aff_list;
195
class pw_qpolynomial;
196
class pw_qpolynomial_fold_list;
197
class pw_qpolynomial_list;
198
class qpolynomial;
199
class schedule;
200
class schedule_constraints;
201
class schedule_node;
202
class set;
203
class set_list;
204
class space;
205
class term;
206
class union_access_info;
207
class union_flow;
208
class union_map;
209
class union_map_list;
210
class union_pw_aff;
211
class union_pw_aff_list;
212
class union_pw_multi_aff;
213
class union_pw_multi_aff_list;
214
class union_pw_qpolynomial;
215
class union_set;
216
class union_set_list;
217
class val;
218
class val_list;
219
class vec;
220
221
// declarations for isl::aff
222
inline aff manage(__isl_take isl_aff *ptr);
223
inline aff manage_copy(__isl_keep isl_aff *ptr);
224
225
class aff {
226
  friend inline aff manage(__isl_take isl_aff *ptr);
227
  friend inline aff manage_copy(__isl_keep isl_aff *ptr);
228
229
  isl_aff *ptr = nullptr;
230
231
  inline explicit aff(__isl_take isl_aff *ptr);
232
233
public:
234
  inline /* implicit */ aff();
235
  inline /* implicit */ aff(const aff &obj);
236
  inline /* implicit */ aff(std::nullptr_t);
237
  inline explicit aff(local_space ls);
238
  inline explicit aff(local_space ls, val val);
239
  inline explicit aff(ctx ctx, const std::string &str);
240
  inline aff &operator=(aff obj);
241
  inline ~aff();
242
  inline __isl_give isl_aff *copy() const &;
243
  inline __isl_give isl_aff *copy() && = delete;
244
  inline __isl_keep isl_aff *get() const;
245
  inline __isl_give isl_aff *release();
246
  inline bool is_null() const;
247
  inline explicit operator bool() const;
248
  inline ctx get_ctx() const;
249
  inline std::string to_str() const;
250
  inline void dump() const;
251
252
  inline aff add(aff aff2) const;
253
  inline aff add_coefficient_si(isl::dim type, int pos, int v) const;
254
  inline aff add_coefficient_val(isl::dim type, int pos, val v) const;
255
  inline aff add_constant_num_si(int v) const;
256
  inline aff add_constant_si(int v) const;
257
  inline aff add_constant_val(val v) const;
258
  inline aff add_dims(isl::dim type, unsigned int n) const;
259
  inline aff align_params(space model) const;
260
  inline aff ceil() const;
261
  inline int coefficient_sgn(isl::dim type, int pos) const;
262
  inline int dim(isl::dim type) const;
263
  inline aff div(aff aff2) const;
264
  inline aff drop_dims(isl::dim type, unsigned int first, unsigned int n) const;
265
  inline basic_set eq_basic_set(aff aff2) const;
266
  inline set eq_set(aff aff2) const;
267
  inline val eval(point pnt) const;
268
  inline int find_dim_by_name(isl::dim type, const std::string &name) const;
269
  inline aff floor() const;
270
  inline aff from_range() const;
271
  inline basic_set ge_basic_set(aff aff2) const;
272
  inline set ge_set(aff aff2) const;
273
  inline val get_coefficient_val(isl::dim type, int pos) const;
274
  inline val get_constant_val() const;
275
  inline val get_denominator_val() const;
276
  inline std::string get_dim_name(isl::dim type, unsigned int pos) const;
277
  inline aff get_div(int pos) const;
278
  inline local_space get_domain_local_space() const;
279
  inline space get_domain_space() const;
280
  inline uint32_t get_hash() const;
281
  inline local_space get_local_space() const;
282
  inline space get_space() const;
283
  inline aff gist(set context) const;
284
  inline aff gist_params(set context) const;
285
  inline basic_set gt_basic_set(aff aff2) const;
286
  inline set gt_set(aff aff2) const;
287
  inline aff insert_dims(isl::dim type, unsigned int first, unsigned int n) const;
288
  inline boolean involves_dims(isl::dim type, unsigned int first, unsigned int n) const;
289
  inline boolean is_cst() const;
290
  inline boolean is_nan() const;
291
  inline basic_set le_basic_set(aff aff2) const;
292
  inline set le_set(aff aff2) const;
293
  inline basic_set lt_basic_set(aff aff2) const;
294
  inline set lt_set(aff aff2) const;
295
  inline aff mod(val mod) const;
296
  inline aff move_dims(isl::dim dst_type, unsigned int dst_pos, isl::dim src_type, unsigned int src_pos, unsigned int n) const;
297
  inline aff mul(aff aff2) const;
298
  static inline aff nan_on_domain(local_space ls);
299
  inline set ne_set(aff aff2) const;
300
  inline aff neg() const;
301
  inline basic_set neg_basic_set() const;
302
  static inline aff param_on_domain_space_id(space space, id id);
303
  inline boolean plain_is_equal(const aff &aff2) const;
304
  inline boolean plain_is_zero() const;
305
  inline aff project_domain_on_params() const;
306
  inline aff pullback(multi_aff ma) const;
307
  inline aff pullback_aff(aff aff2) const;
308
  inline aff scale(val v) const;
309
  inline aff scale_down(val v) const;
310
  inline aff scale_down_ui(unsigned int f) const;
311
  inline aff set_coefficient_si(isl::dim type, int pos, int v) const;
312
  inline aff set_coefficient_val(isl::dim type, int pos, val v) const;
313
  inline aff set_constant_si(int v) const;
314
  inline aff set_constant_val(val v) const;
315
  inline aff set_dim_id(isl::dim type, unsigned int pos, id id) const;
316
  inline aff set_tuple_id(isl::dim type, id id) const;
317
  inline aff sub(aff aff2) const;
318
  static inline aff var_on_domain(local_space ls, isl::dim type, unsigned int pos);
319
  inline basic_set zero_basic_set() const;
320
};
321
322
// declarations for isl::aff_list
323
inline aff_list manage(__isl_take isl_aff_list *ptr);
324
inline aff_list manage_copy(__isl_keep isl_aff_list *ptr);
325
326
class aff_list {
327
  friend inline aff_list manage(__isl_take isl_aff_list *ptr);
328
  friend inline aff_list manage_copy(__isl_keep isl_aff_list *ptr);
329
330
  isl_aff_list *ptr = nullptr;
331
332
  inline explicit aff_list(__isl_take isl_aff_list *ptr);
333
334
public:
335
  inline /* implicit */ aff_list();
336
  inline /* implicit */ aff_list(const aff_list &obj);
337
  inline /* implicit */ aff_list(std::nullptr_t);
338
  inline aff_list &operator=(aff_list obj);
339
  inline ~aff_list();
340
  inline __isl_give isl_aff_list *copy() const &;
341
  inline __isl_give isl_aff_list *copy() && = delete;
342
  inline __isl_keep isl_aff_list *get() const;
343
  inline __isl_give isl_aff_list *release();
344
  inline bool is_null() const;
345
  inline explicit operator bool() const;
346
  inline ctx get_ctx() const;
347
  inline void dump() const;
348
349
  inline aff_list add(aff el) const;
350
  static inline aff_list alloc(ctx ctx, int n);
351
  inline aff_list concat(aff_list list2) const;
352
  inline aff_list drop(unsigned int first, unsigned int n) const;
353
  inline stat foreach(const std::function<stat(aff)> &fn) const;
354
  static inline aff_list from_aff(aff el);
355
  inline aff get_aff(int index) const;
356
  inline aff get_at(int index) const;
357
  inline aff_list insert(unsigned int pos, aff el) const;
358
  inline int n_aff() const;
359
  inline aff_list reverse() const;
360
  inline aff_list set_aff(int index, aff el) const;
361
  inline int size() const;
362
  inline aff_list swap(unsigned int pos1, unsigned int pos2) const;
363
};
364
365
// declarations for isl::ast_build
366
inline ast_build manage(__isl_take isl_ast_build *ptr);
367
inline ast_build manage_copy(__isl_keep isl_ast_build *ptr);
368
369
class ast_build {
370
  friend inline ast_build manage(__isl_take isl_ast_build *ptr);
371
  friend inline ast_build manage_copy(__isl_keep isl_ast_build *ptr);
372
373
  isl_ast_build *ptr = nullptr;
374
375
  inline explicit ast_build(__isl_take isl_ast_build *ptr);
376
377
public:
378
  inline /* implicit */ ast_build();
379
  inline /* implicit */ ast_build(const ast_build &obj);
380
  inline /* implicit */ ast_build(std::nullptr_t);
381
  inline explicit ast_build(ctx ctx);
382
  inline ast_build &operator=(ast_build obj);
383
  inline ~ast_build();
384
  inline __isl_give isl_ast_build *copy() const &;
385
  inline __isl_give isl_ast_build *copy() && = delete;
386
  inline __isl_keep isl_ast_build *get() const;
387
  inline __isl_give isl_ast_build *release();
388
  inline bool is_null() const;
389
  inline explicit operator bool() const;
390
  inline ctx get_ctx() const;
391
392
  inline ast_expr access_from(pw_multi_aff pma) const;
393
  inline ast_expr access_from(multi_pw_aff mpa) const;
394
  inline ast_node ast_from_schedule(union_map schedule) const;
395
  inline ast_expr call_from(pw_multi_aff pma) const;
396
  inline ast_expr call_from(multi_pw_aff mpa) const;
397
  inline ast_expr expr_from(set set) const;
398
  inline ast_expr expr_from(pw_aff pa) const;
399
  static inline ast_build from_context(set set);
400
  inline union_map get_schedule() const;
401
  inline space get_schedule_space() const;
402
  inline ast_node node_from_schedule(schedule schedule) const;
403
  inline ast_node node_from_schedule_map(union_map schedule) const;
404
  inline ast_build restrict(set set) const;
405
};
406
407
// declarations for isl::ast_expr
408
inline ast_expr manage(__isl_take isl_ast_expr *ptr);
409
inline ast_expr manage_copy(__isl_keep isl_ast_expr *ptr);
410
411
class ast_expr {
412
  friend inline ast_expr manage(__isl_take isl_ast_expr *ptr);
413
  friend inline ast_expr manage_copy(__isl_keep isl_ast_expr *ptr);
414
415
  isl_ast_expr *ptr = nullptr;
416
417
  inline explicit ast_expr(__isl_take isl_ast_expr *ptr);
418
419
public:
420
  inline /* implicit */ ast_expr();
421
  inline /* implicit */ ast_expr(const ast_expr &obj);
422
  inline /* implicit */ ast_expr(std::nullptr_t);
423
  inline ast_expr &operator=(ast_expr obj);
424
  inline ~ast_expr();
425
  inline __isl_give isl_ast_expr *copy() const &;
426
  inline __isl_give isl_ast_expr *copy() && = delete;
427
  inline __isl_keep isl_ast_expr *get() const;
428
  inline __isl_give isl_ast_expr *release();
429
  inline bool is_null() const;
430
  inline explicit operator bool() const;
431
  inline ctx get_ctx() const;
432
  inline std::string to_str() const;
433
  inline void dump() const;
434
435
  inline ast_expr access(ast_expr_list indices) const;
436
  inline ast_expr add(ast_expr expr2) const;
437
  inline ast_expr address_of() const;
438
  inline ast_expr call(ast_expr_list arguments) const;
439
  inline ast_expr div(ast_expr expr2) const;
440
  inline ast_expr eq(ast_expr expr2) const;
441
  static inline ast_expr from_id(id id);
442
  static inline ast_expr from_val(val v);
443
  inline ast_expr ge(ast_expr expr2) const;
444
  inline id get_id() const;
445
  inline ast_expr get_op_arg(int pos) const;
446
  inline int get_op_n_arg() const;
447
  inline val get_val() const;
448
  inline ast_expr gt(ast_expr expr2) const;
449
  inline boolean is_equal(const ast_expr &expr2) const;
450
  inline ast_expr le(ast_expr expr2) const;
451
  inline ast_expr lt(ast_expr expr2) const;
452
  inline ast_expr mul(ast_expr expr2) const;
453
  inline ast_expr neg() const;
454
  inline ast_expr pdiv_q(ast_expr expr2) const;
455
  inline ast_expr pdiv_r(ast_expr expr2) const;
456
  inline ast_expr set_op_arg(int pos, ast_expr arg) const;
457
  inline ast_expr sub(ast_expr expr2) const;
458
  inline ast_expr substitute_ids(id_to_ast_expr id2expr) const;
459
  inline std::string to_C_str() const;
460
};
461
462
// declarations for isl::ast_expr_list
463
inline ast_expr_list manage(__isl_take isl_ast_expr_list *ptr);
464
inline ast_expr_list manage_copy(__isl_keep isl_ast_expr_list *ptr);
465
466
class ast_expr_list {
467
  friend inline ast_expr_list manage(__isl_take isl_ast_expr_list *ptr);
468
  friend inline ast_expr_list manage_copy(__isl_keep isl_ast_expr_list *ptr);
469
470
  isl_ast_expr_list *ptr = nullptr;
471
472
  inline explicit ast_expr_list(__isl_take isl_ast_expr_list *ptr);
473
474
public:
475
  inline /* implicit */ ast_expr_list();
476
  inline /* implicit */ ast_expr_list(const ast_expr_list &obj);
477
  inline /* implicit */ ast_expr_list(std::nullptr_t);
478
  inline ast_expr_list &operator=(ast_expr_list obj);
479
  inline ~ast_expr_list();
480
  inline __isl_give isl_ast_expr_list *copy() const &;
481
  inline __isl_give isl_ast_expr_list *copy() && = delete;
482
  inline __isl_keep isl_ast_expr_list *get() const;
483
  inline __isl_give isl_ast_expr_list *release();
484
  inline bool is_null() const;
485
  inline explicit operator bool() const;
486
  inline ctx get_ctx() const;
487
  inline void dump() const;
488
489
  inline ast_expr_list add(ast_expr el) const;
490
  static inline ast_expr_list alloc(ctx ctx, int n);
491
  inline ast_expr_list concat(ast_expr_list list2) const;
492
  inline ast_expr_list drop(unsigned int first, unsigned int n) const;
493
  inline stat foreach(const std::function<stat(ast_expr)> &fn) const;
494
  static inline ast_expr_list from_ast_expr(ast_expr el);
495
  inline ast_expr get_ast_expr(int index) const;
496
  inline ast_expr get_at(int index) const;
497
  inline ast_expr_list insert(unsigned int pos, ast_expr el) const;
498
  inline int n_ast_expr() const;
499
  inline ast_expr_list reverse() const;
500
  inline ast_expr_list set_ast_expr(int index, ast_expr el) const;
501
  inline int size() const;
502
  inline ast_expr_list swap(unsigned int pos1, unsigned int pos2) const;
503
};
504
505
// declarations for isl::ast_node
506
inline ast_node manage(__isl_take isl_ast_node *ptr);
507
inline ast_node manage_copy(__isl_keep isl_ast_node *ptr);
508
509
class ast_node {
510
  friend inline ast_node manage(__isl_take isl_ast_node *ptr);
511
  friend inline ast_node manage_copy(__isl_keep isl_ast_node *ptr);
512
513
  isl_ast_node *ptr = nullptr;
514
515
  inline explicit ast_node(__isl_take isl_ast_node *ptr);
516
517
public:
518
  inline /* implicit */ ast_node();
519
  inline /* implicit */ ast_node(const ast_node &obj);
520
  inline /* implicit */ ast_node(std::nullptr_t);
521
  inline ast_node &operator=(ast_node obj);
522
  inline ~ast_node();
523
  inline __isl_give isl_ast_node *copy() const &;
524
  inline __isl_give isl_ast_node *copy() && = delete;
525
  inline __isl_keep isl_ast_node *get() const;
526
  inline __isl_give isl_ast_node *release();
527
  inline bool is_null() const;
528
  inline explicit operator bool() const;
529
  inline ctx get_ctx() const;
530
  inline std::string to_str() const;
531
  inline void dump() const;
532
533
  static inline ast_node alloc_user(ast_expr expr);
534
  inline ast_node_list block_get_children() const;
535
  inline ast_node for_get_body() const;
536
  inline ast_expr for_get_cond() const;
537
  inline ast_expr for_get_inc() const;
538
  inline ast_expr for_get_init() const;
539
  inline ast_expr for_get_iterator() const;
540
  inline boolean for_is_degenerate() const;
541
  inline id get_annotation() const;
542
  inline ast_expr if_get_cond() const;
543
  inline ast_node if_get_else() const;
544
  inline ast_node if_get_then() const;
545
  inline boolean if_has_else() const;
546
  inline id mark_get_id() const;
547
  inline ast_node mark_get_node() const;
548
  inline ast_node set_annotation(id annotation) const;
549
  inline std::string to_C_str() const;
550
  inline ast_expr user_get_expr() const;
551
};
552
553
// declarations for isl::ast_node_list
554
inline ast_node_list manage(__isl_take isl_ast_node_list *ptr);
555
inline ast_node_list manage_copy(__isl_keep isl_ast_node_list *ptr);
556
557
class ast_node_list {
558
  friend inline ast_node_list manage(__isl_take isl_ast_node_list *ptr);
559
  friend inline ast_node_list manage_copy(__isl_keep isl_ast_node_list *ptr);
560
561
  isl_ast_node_list *ptr = nullptr;
562
563
  inline explicit ast_node_list(__isl_take isl_ast_node_list *ptr);
564
565
public:
566
  inline /* implicit */ ast_node_list();
567
  inline /* implicit */ ast_node_list(const ast_node_list &obj);
568
  inline /* implicit */ ast_node_list(std::nullptr_t);
569
  inline ast_node_list &operator=(ast_node_list obj);
570
  inline ~ast_node_list();
571
  inline __isl_give isl_ast_node_list *copy() const &;
572
  inline __isl_give isl_ast_node_list *copy() && = delete;
573
  inline __isl_keep isl_ast_node_list *get() const;
574
  inline __isl_give isl_ast_node_list *release();
575
  inline bool is_null() const;
576
  inline explicit operator bool() const;
577
  inline ctx get_ctx() const;
578
  inline void dump() const;
579
580
  inline ast_node_list add(ast_node el) const;
581
  static inline ast_node_list alloc(ctx ctx, int n);
582
  inline ast_node_list concat(ast_node_list list2) const;
583
  inline ast_node_list drop(unsigned int first, unsigned int n) const;
584
  inline stat foreach(const std::function<stat(ast_node)> &fn) const;
585
  static inline ast_node_list from_ast_node(ast_node el);
586
  inline ast_node get_ast_node(int index) const;
587
  inline ast_node get_at(int index) const;
588
  inline ast_node_list insert(unsigned int pos, ast_node el) const;
589
  inline int n_ast_node() const;
590
  inline ast_node_list reverse() const;
591
  inline ast_node_list set_ast_node(int index, ast_node el) const;
592
  inline int size() const;
593
  inline ast_node_list swap(unsigned int pos1, unsigned int pos2) const;
594
};
595
596
// declarations for isl::basic_map
597
inline basic_map manage(__isl_take isl_basic_map *ptr);
598
inline basic_map manage_copy(__isl_keep isl_basic_map *ptr);
599
600
class basic_map {
601
  friend inline basic_map manage(__isl_take isl_basic_map *ptr);
602
  friend inline basic_map manage_copy(__isl_keep isl_basic_map *ptr);
603
604
  isl_basic_map *ptr = nullptr;
605
606
  inline explicit basic_map(__isl_take isl_basic_map *ptr);
607
608
public:
609
  inline /* implicit */ basic_map();
610
  inline /* implicit */ basic_map(const basic_map &obj);
611
  inline /* implicit */ basic_map(std::nullptr_t);
612
  inline explicit basic_map(ctx ctx, const std::string &str);
613
  inline basic_map &operator=(basic_map obj);
614
  inline ~basic_map();
615
  inline __isl_give isl_basic_map *copy() const &;
616
  inline __isl_give isl_basic_map *copy() && = delete;
617
  inline __isl_keep isl_basic_map *get() const;
618
  inline __isl_give isl_basic_map *release();
619
  inline bool is_null() const;
620
  inline explicit operator bool() const;
621
  inline ctx get_ctx() const;
622
  inline std::string to_str() const;
623
  inline void dump() const;
624
625
  inline basic_map add_constraint(constraint constraint) const;
626
  inline basic_map add_dims(isl::dim type, unsigned int n) const;
627
  inline basic_map affine_hull() const;
628
  inline basic_map align_params(space model) const;
629
  inline basic_map apply_domain(basic_map bmap2) const;
630
  inline basic_map apply_range(basic_map bmap2) const;
631
  inline boolean can_curry() const;
632
  inline boolean can_uncurry() const;
633
  inline boolean can_zip() const;
634
  inline basic_map curry() const;
635
  inline basic_set deltas() const;
636
  inline basic_map deltas_map() const;
637
  inline basic_map detect_equalities() const;
638
  inline unsigned int dim(isl::dim type) const;
639
  inline basic_set domain() const;
640
  inline basic_map domain_map() const;
641
  inline basic_map domain_product(basic_map bmap2) const;
642
  inline basic_map drop_constraints_involving_dims(isl::dim type, unsigned int first, unsigned int n) const;
643
  inline basic_map drop_constraints_not_involving_dims(isl::dim type, unsigned int first, unsigned int n) const;
644
  inline basic_map drop_unused_params() const;
645
  inline basic_map eliminate(isl::dim type, unsigned int first, unsigned int n) const;
646
  static inline basic_map empty(space space);
647
  static inline basic_map equal(space dim, unsigned int n_equal);
648
  inline mat equalities_matrix(isl::dim c1, isl::dim c2, isl::dim c3, isl::dim c4, isl::dim c5) const;
649
  inline basic_map equate(isl::dim type1, int pos1, isl::dim type2, int pos2) const;
650
  inline int find_dim_by_name(isl::dim type, const std::string &name) const;
651
  inline basic_map fix_si(isl::dim type, unsigned int pos, int value) const;
652
  inline basic_map fix_val(isl::dim type, unsigned int pos, val v) const;
653
  inline basic_map flat_product(basic_map bmap2) const;
654
  inline basic_map flat_range_product(basic_map bmap2) const;
655
  inline basic_map flatten() const;
656
  inline basic_map flatten_domain() const;
657
  inline basic_map flatten_range() const;
658
  inline stat foreach_constraint(const std::function<stat(constraint)> &fn) const;
659
  static inline basic_map from_aff(aff aff);
660
  static inline basic_map from_aff_list(space domain_space, aff_list list);
661
  static inline basic_map from_constraint(constraint constraint);
662
  static inline basic_map from_domain(basic_set bset);
663
  static inline basic_map from_domain_and_range(basic_set domain, basic_set range);
664
  static inline basic_map from_multi_aff(multi_aff maff);
665
  static inline basic_map from_qpolynomial(qpolynomial qp);
666
  static inline basic_map from_range(basic_set bset);
667
  inline constraint_list get_constraint_list() const;
668
  inline std::string get_dim_name(isl::dim type, unsigned int pos) const;
669
  inline aff get_div(int pos) const;
670
  inline local_space get_local_space() const;
671
  inline space get_space() const;
672
  inline std::string get_tuple_name(isl::dim type) const;
673
  inline basic_map gist(basic_map context) const;
674
  inline basic_map gist_domain(basic_set context) const;
675
  inline boolean has_dim_id(isl::dim type, unsigned int pos) const;
676
  static inline basic_map identity(space dim);
677
  inline boolean image_is_bounded() const;
678
  inline mat inequalities_matrix(isl::dim c1, isl::dim c2, isl::dim c3, isl::dim c4, isl::dim c5) const;
679
  inline basic_map insert_dims(isl::dim type, unsigned int pos, unsigned int n) const;
680
  inline basic_map intersect(basic_map bmap2) const;
681
  inline basic_map intersect_domain(basic_set bset) const;
682
  inline basic_map intersect_range(basic_set bset) const;
683
  inline boolean involves_dims(isl::dim type, unsigned int first, unsigned int n) const;
684
  inline boolean is_disjoint(const basic_map &bmap2) const;
685
  inline boolean is_empty() const;
686
  inline boolean is_equal(const basic_map &bmap2) const;
687
  inline boolean is_rational() const;
688
  inline boolean is_single_valued() const;
689
  inline boolean is_strict_subset(const basic_map &bmap2) const;
690
  inline boolean is_subset(const basic_map &bmap2) const;
691
  inline boolean is_universe() const;
692
  static inline basic_map less_at(space dim, unsigned int pos);
693
  inline map lexmax() const;
694
  inline map lexmin() const;
695
  inline pw_multi_aff lexmin_pw_multi_aff() const;
696
  inline basic_map lower_bound_si(isl::dim type, unsigned int pos, int value) const;
697
  static inline basic_map more_at(space dim, unsigned int pos);
698
  inline basic_map move_dims(isl::dim dst_type, unsigned int dst_pos, isl::dim src_type, unsigned int src_pos, unsigned int n) const;
699
  inline int n_constraint() const;
700
  static inline basic_map nat_universe(space dim);
701
  inline basic_map neg() const;
702
  inline basic_map order_ge(isl::dim type1, int pos1, isl::dim type2, int pos2) const;
703
  inline basic_map order_gt(isl::dim type1, int pos1, isl::dim type2, int pos2) const;
704
  inline val plain_get_val_if_fixed(isl::dim type, unsigned int pos) const;
705
  inline boolean plain_is_empty() const;
706
  inline boolean plain_is_universe() const;
707
  inline basic_map preimage_domain_multi_aff(multi_aff ma) const;
708
  inline basic_map preimage_range_multi_aff(multi_aff ma) const;
709
  inline basic_map product(basic_map bmap2) const;
710
  inline basic_map project_out(isl::dim type, unsigned int first, unsigned int n) const;
711
  inline basic_set range() const;
712
  inline basic_map range_map() const;
713
  inline basic_map range_product(basic_map bmap2) const;
714
  inline basic_map remove_dims(isl::dim type, unsigned int first, unsigned int n) const;
715
  inline basic_map remove_divs() const;
716
  inline basic_map remove_divs_involving_dims(isl::dim type, unsigned int first, unsigned int n) const;
717
  inline basic_map remove_redundancies() const;
718
  inline basic_map reverse() const;
719
  inline basic_map sample() const;
720
  inline basic_map set_tuple_id(isl::dim type, id id) const;
721
  inline basic_map set_tuple_name(isl::dim type, const std::string &s) const;
722
  inline basic_map sum(basic_map bmap2) const;
723
  inline basic_map uncurry() const;
724
  inline map unite(basic_map bmap2) const;
725
  static inline basic_map universe(space space);
726
  inline basic_map upper_bound_si(isl::dim type, unsigned int pos, int value) const;
727
  inline basic_set wrap() const;
728
  inline basic_map zip() const;
729
};
730
731
// declarations for isl::basic_map_list
732
inline basic_map_list manage(__isl_take isl_basic_map_list *ptr);
733
inline basic_map_list manage_copy(__isl_keep isl_basic_map_list *ptr);
734
735
class basic_map_list {
736
  friend inline basic_map_list manage(__isl_take isl_basic_map_list *ptr);
737
  friend inline basic_map_list manage_copy(__isl_keep isl_basic_map_list *ptr);
738
739
  isl_basic_map_list *ptr = nullptr;
740
741
  inline explicit basic_map_list(__isl_take isl_basic_map_list *ptr);
742
743
public:
744
  inline /* implicit */ basic_map_list();
745
  inline /* implicit */ basic_map_list(const basic_map_list &obj);
746
  inline /* implicit */ basic_map_list(std::nullptr_t);
747
  inline basic_map_list &operator=(basic_map_list obj);
748
  inline ~basic_map_list();
749
  inline __isl_give isl_basic_map_list *copy() const &;
750
  inline __isl_give isl_basic_map_list *copy() && = delete;
751
  inline __isl_keep isl_basic_map_list *get() const;
752
  inline __isl_give isl_basic_map_list *release();
753
  inline bool is_null() const;
754
  inline explicit operator bool() const;
755
  inline ctx get_ctx() const;
756
  inline void dump() const;
757
758
  inline basic_map_list add(basic_map el) const;
759
  static inline basic_map_list alloc(ctx ctx, int n);
760
  inline basic_map_list concat(basic_map_list list2) const;
761
  inline basic_map_list drop(unsigned int first, unsigned int n) const;
762
  inline stat foreach(const std::function<stat(basic_map)> &fn) const;
763
  static inline basic_map_list from_basic_map(basic_map el);
764
  inline basic_map get_at(int index) const;
765
  inline basic_map get_basic_map(int index) const;
766
  inline basic_map_list insert(unsigned int pos, basic_map el) const;
767
  inline int n_basic_map() const;
768
  inline basic_map_list reverse() const;
769
  inline basic_map_list set_basic_map(int index, basic_map el) const;
770
  inline int size() const;
771
  inline basic_map_list swap(unsigned int pos1, unsigned int pos2) const;
772
};
773
774
// declarations for isl::basic_set
775
inline basic_set manage(__isl_take isl_basic_set *ptr);
776
inline basic_set manage_copy(__isl_keep isl_basic_set *ptr);
777
778
class basic_set {
779
  friend inline basic_set manage(__isl_take isl_basic_set *ptr);
780
  friend inline basic_set manage_copy(__isl_keep isl_basic_set *ptr);
781
782
  isl_basic_set *ptr = nullptr;
783
784
  inline explicit basic_set(__isl_take isl_basic_set *ptr);
785
786
public:
787
  inline /* implicit */ basic_set();
788
  inline /* implicit */ basic_set(const basic_set &obj);
789
  inline /* implicit */ basic_set(std::nullptr_t);
790
  inline explicit basic_set(ctx ctx, const std::string &str);
791
  inline /* implicit */ basic_set(point pnt);
792
  inline basic_set &operator=(basic_set obj);
793
  inline ~basic_set();
794
  inline __isl_give isl_basic_set *copy() const &;
795
  inline __isl_give isl_basic_set *copy() && = delete;
796
  inline __isl_keep isl_basic_set *get() const;
797
  inline __isl_give isl_basic_set *release();
798
  inline bool is_null() const;
799
  inline explicit operator bool() const;
800
  inline ctx get_ctx() const;
801
  inline std::string to_str() const;
802
  inline void dump() const;
803
804
  inline basic_set affine_hull() const;
805
  inline basic_set align_params(space model) const;
806
  inline basic_set apply(basic_map bmap) const;
807
  static inline basic_set box_from_points(point pnt1, point pnt2);
808
  inline basic_set coefficients() const;
809
  inline basic_set detect_equalities() const;
810
  inline unsigned int dim(isl::dim type) const;
811
  inline val dim_max_val(int pos) const;
812
  inline basic_set drop_constraints_involving_dims(isl::dim type, unsigned int first, unsigned int n) const;
813
  inline basic_set drop_constraints_not_involving_dims(isl::dim type, unsigned int first, unsigned int n) const;
814
  inline basic_set drop_unused_params() const;
815
  inline basic_set eliminate(isl::dim type, unsigned int first, unsigned int n) const;
816
  static inline basic_set empty(space space);
817
  inline mat equalities_matrix(isl::dim c1, isl::dim c2, isl::dim c3, isl::dim c4) const;
818
  inline basic_set fix_si(isl::dim type, unsigned int pos, int value) const;
819
  inline basic_set fix_val(isl::dim type, unsigned int pos, val v) const;
820
  inline basic_set flat_product(basic_set bset2) const;
821
  inline basic_set flatten() const;
822
  inline stat foreach_bound_pair(isl::dim type, unsigned int pos, const std::function<stat(constraint, constraint, basic_set)> &fn) const;
823
  inline stat foreach_constraint(const std::function<stat(constraint)> &fn) const;
824
  static inline basic_set from_constraint(constraint constraint);
825
  static inline basic_set from_multi_aff(multi_aff ma);
826
  inline basic_set from_params() const;
827
  inline constraint_list get_constraint_list() const;
828
  inline id get_dim_id(isl::dim type, unsigned int pos) const;
829
  inline std::string get_dim_name(isl::dim type, unsigned int pos) const;
830
  inline aff get_div(int pos) const;
831
  inline local_space get_local_space() const;
832
  inline space get_space() const;
833
  inline std::string get_tuple_name() const;
834
  inline basic_set gist(basic_set context) const;
835
  inline mat inequalities_matrix(isl::dim c1, isl::dim c2, isl::dim c3, isl::dim c4) const;
836
  inline basic_set insert_dims(isl::dim type, unsigned int pos, unsigned int n) const;
837
  inline basic_set intersect(basic_set bset2) const;
838
  inline basic_set intersect_params(basic_set bset2) const;
839
  inline boolean involves_dims(isl::dim type, unsigned int first, unsigned int n) const;
840
  inline boolean is_bounded() const;
841
  inline boolean is_disjoint(const basic_set &bset2) const;
842
  inline boolean is_empty() const;
843
  inline boolean is_equal(const basic_set &bset2) const;
844
  inline int is_rational() const;
845
  inline boolean is_subset(const basic_set &bset2) const;
846
  inline boolean is_universe() const;
847
  inline boolean is_wrapping() const;
848
  inline set lexmax() const;
849
  inline set lexmin() const;
850
  inline basic_set lower_bound_val(isl::dim type, unsigned int pos, val value) const;
851
  inline val max_val(const aff &obj) const;
852
  inline basic_set move_dims(isl::dim dst_type, unsigned int dst_pos, isl::dim src_type, unsigned int src_pos, unsigned int n) const;
853
  inline int n_constraint() const;
854
  inline unsigned int n_dim() const;
855
  static inline basic_set nat_universe(space dim);
856
  inline basic_set neg() const;
857
  inline basic_set params() const;
858
  inline boolean plain_is_empty() const;
859
  inline boolean plain_is_equal(const basic_set &bset2) const;
860
  inline boolean plain_is_universe() const;
861
  static inline basic_set positive_orthant(space space);
862
  inline basic_set preimage_multi_aff(multi_aff ma) const;
863
  inline basic_set project_out(isl::dim type, unsigned int first, unsigned int n) const;
864
  inline mat reduced_basis() const;
865
  inline basic_set remove_dims(isl::dim type, unsigned int first, unsigned int n) const;
866
  inline basic_set remove_divs() const;
867
  inline basic_set remove_divs_involving_dims(isl::dim type, unsigned int first, unsigned int n) const;
868
  inline basic_set remove_redundancies() const;
869
  inline basic_set remove_unknown_divs() const;
870
  inline basic_set sample() const;
871
  inline point sample_point() const;
872
  inline basic_set set_tuple_id(id id) const;
873
  inline basic_set set_tuple_name(const std::string &s) const;
874
  inline basic_set solutions() const;
875
  inline set unite(basic_set bset2) const;
876
  static inline basic_set universe(space space);
877
  inline basic_map unwrap() const;
878
  inline basic_set upper_bound_val(isl::dim type, unsigned int pos, val value) const;
879
};
880
881
// declarations for isl::basic_set_list
882
inline basic_set_list manage(__isl_take isl_basic_set_list *ptr);
883
inline basic_set_list manage_copy(__isl_keep isl_basic_set_list *ptr);
884
885
class basic_set_list {
886
  friend inline basic_set_list manage(__isl_take isl_basic_set_list *ptr);
887
  friend inline basic_set_list manage_copy(__isl_keep isl_basic_set_list *ptr);
888
889
  isl_basic_set_list *ptr = nullptr;
890
891
  inline explicit basic_set_list(__isl_take isl_basic_set_list *ptr);
892
893
public:
894
  inline /* implicit */ basic_set_list();
895
  inline /* implicit */ basic_set_list(const basic_set_list &obj);
896
  inline /* implicit */ basic_set_list(std::nullptr_t);
897
  inline basic_set_list &operator=(basic_set_list obj);
898
  inline ~basic_set_list();
899
  inline __isl_give isl_basic_set_list *copy() const &;
900
  inline __isl_give isl_basic_set_list *copy() && = delete;
901
  inline __isl_keep isl_basic_set_list *get() const;
902
  inline __isl_give isl_basic_set_list *release();
903
  inline bool is_null() const;
904
  inline explicit operator bool() const;
905
  inline ctx get_ctx() const;
906
  inline void dump() const;
907
908
  inline basic_set_list add(basic_set el) const;
909
  static inline basic_set_list alloc(ctx ctx, int n);
910
  inline basic_set_list coefficients() const;
911
  inline basic_set_list concat(basic_set_list list2) const;
912
  inline basic_set_list drop(unsigned int first, unsigned int n) const;
913
  inline stat foreach(const std::function<stat(basic_set)> &fn) const;
914
  static inline basic_set_list from_basic_set(basic_set el);
915
  inline basic_set get_at(int index) const;
916
  inline basic_set get_basic_set(int index) const;
917
  inline basic_set_list insert(unsigned int pos, basic_set el) const;
918
  inline int n_basic_set() const;
919
  inline basic_set_list reverse() const;
920
  inline basic_set_list set_basic_set(int index, basic_set el) const;
921
  inline int size() const;
922
  inline basic_set_list swap(unsigned int pos1, unsigned int pos2) const;
923
};
924
925
// declarations for isl::constraint
926
inline constraint manage(__isl_take isl_constraint *ptr);
927
inline constraint manage_copy(__isl_keep isl_constraint *ptr);
928
929
class constraint {
930
  friend inline constraint manage(__isl_take isl_constraint *ptr);
931
  friend inline constraint manage_copy(__isl_keep isl_constraint *ptr);
932
933
  isl_constraint *ptr = nullptr;
934
935
  inline explicit constraint(__isl_take isl_constraint *ptr);
936
937
public:
938
  inline /* implicit */ constraint();
939
  inline /* implicit */ constraint(const constraint &obj);
940
  inline /* implicit */ constraint(std::nullptr_t);
941
  inline constraint &operator=(constraint obj);
942
  inline ~constraint();
943
  inline __isl_give isl_constraint *copy() const &;
944
  inline __isl_give isl_constraint *copy() && = delete;
945
  inline __isl_keep isl_constraint *get() const;
946
  inline __isl_give isl_constraint *release();
947
  inline bool is_null() const;
948
  inline explicit operator bool() const;
949
  inline ctx get_ctx() const;
950
  inline void dump() const;
951
952
  static inline constraint alloc_equality(local_space ls);
953
  static inline constraint alloc_inequality(local_space ls);
954
  inline int cmp_last_non_zero(const constraint &c2) const;
955
  inline aff get_aff() const;
956
  inline aff get_bound(isl::dim type, int pos) const;
957
  inline val get_coefficient_val(isl::dim type, int pos) const;
958
  inline val get_constant_val() const;
959
  inline std::string get_dim_name(isl::dim type, unsigned int pos) const;
960
  inline aff get_div(int pos) const;
961
  inline local_space get_local_space() const;
962
  inline space get_space() const;
963
  inline boolean involves_dims(isl::dim type, unsigned int first, unsigned int n) const;
964
  inline int is_div_constraint() const;
965
  inline boolean is_lower_bound(isl::dim type, unsigned int pos) const;
966
  inline boolean is_upper_bound(isl::dim type, unsigned int pos) const;
967
  inline int plain_cmp(const constraint &c2) const;
968
  inline constraint set_coefficient_si(isl::dim type, int pos, int v) const;
969
  inline constraint set_coefficient_val(isl::dim type, int pos, val v) const;
970
  inline constraint set_constant_si(int v) const;
971
  inline constraint set_constant_val(val v) const;
972
};
973
974
// declarations for isl::constraint_list
975
inline constraint_list manage(__isl_take isl_constraint_list *ptr);
976
inline constraint_list manage_copy(__isl_keep isl_constraint_list *ptr);
977
978
class constraint_list {
979
  friend inline constraint_list manage(__isl_take isl_constraint_list *ptr);
980
  friend inline constraint_list manage_copy(__isl_keep isl_constraint_list *ptr);
981
982
  isl_constraint_list *ptr = nullptr;
983
984
  inline explicit constraint_list(__isl_take isl_constraint_list *ptr);
985
986
public:
987
  inline /* implicit */ constraint_list();
988
  inline /* implicit */ constraint_list(const constraint_list &obj);
989
  inline /* implicit */ constraint_list(std::nullptr_t);
990
  inline constraint_list &operator=(constraint_list obj);
991
  inline ~constraint_list();
992
  inline __isl_give isl_constraint_list *copy() const &;
993
  inline __isl_give isl_constraint_list *copy() && = delete;
994
  inline __isl_keep isl_constraint_list *get() const;
995
  inline __isl_give isl_constraint_list *release();
996
  inline bool is_null() const;
997
  inline explicit operator bool() const;
998
  inline ctx get_ctx() const;
999
  inline void dump() const;
1000
1001
  inline constraint_list add(constraint el) const;
1002
  static inline constraint_list alloc(ctx ctx, int n);
1003
  inline constraint_list concat(constraint_list list2) const;
1004
  inline constraint_list drop(unsigned int first, unsigned int n) const;
1005
  inline stat foreach(const std::function<stat(constraint)> &fn) const;
1006
  static inline constraint_list from_constraint(constraint el);
1007
  inline constraint get_at(int index) const;
1008
  inline constraint get_constraint(int index) const;
1009
  inline constraint_list insert(unsigned int pos, constraint el) const;
1010
  inline int n_constraint() const;
1011
  inline constraint_list reverse() const;
1012
  inline constraint_list set_constraint(int index, constraint el) const;
1013
  inline int size() const;
1014
  inline constraint_list swap(unsigned int pos1, unsigned int pos2) const;
1015
};
1016
1017
// declarations for isl::fixed_box
1018
inline fixed_box manage(__isl_take isl_fixed_box *ptr);
1019
inline fixed_box manage_copy(__isl_keep isl_fixed_box *ptr);
1020
1021
class fixed_box {
1022
  friend inline fixed_box manage(__isl_take isl_fixed_box *ptr);
1023
  friend inline fixed_box manage_copy(__isl_keep isl_fixed_box *ptr);
1024
1025
  isl_fixed_box *ptr = nullptr;
1026
1027
  inline explicit fixed_box(__isl_take isl_fixed_box *ptr);
1028
1029
public:
1030
  inline /* implicit */ fixed_box();
1031
  inline /* implicit */ fixed_box(const fixed_box &obj);
1032
  inline /* implicit */ fixed_box(std::nullptr_t);
1033
  inline fixed_box &operator=(fixed_box obj);
1034
  inline ~fixed_box();
1035
  inline __isl_give isl_fixed_box *copy() const &;
1036
  inline __isl_give isl_fixed_box *copy() && = delete;
1037
  inline __isl_keep isl_fixed_box *get() const;
1038
  inline __isl_give isl_fixed_box *release();
1039
  inline bool is_null() const;
1040
  inline explicit operator bool() const;
1041
  inline ctx get_ctx() const;
1042
1043
  inline multi_aff get_offset() const;
1044
  inline multi_val get_size() const;
1045
  inline space get_space() const;
1046
  inline boolean is_valid() const;
1047
};
1048
1049
// declarations for isl::id
1050
inline id manage(__isl_take isl_id *ptr);
1051
inline id manage_copy(__isl_keep isl_id *ptr);
1052
1053
class id {
1054
  friend inline id manage(__isl_take isl_id *ptr);
1055
  friend inline id manage_copy(__isl_keep isl_id *ptr);
1056
1057
  isl_id *ptr = nullptr;
1058
1059
  inline explicit id(__isl_take isl_id *ptr);
1060
1061
public:
1062
  inline /* implicit */ id();
1063
  inline /* implicit */ id(const id &obj);
1064
  inline /* implicit */ id(std::nullptr_t);
1065
  inline id &operator=(id obj);
1066
  inline ~id();
1067
  inline __isl_give isl_id *copy() const &;
1068
  inline __isl_give isl_id *copy() && = delete;
1069
  inline __isl_keep isl_id *get() const;
1070
  inline __isl_give isl_id *release();
1071
  inline bool is_null() const;
1072
  inline explicit operator bool() const;
1073
  inline ctx get_ctx() const;
1074
  inline std::string to_str() const;
1075
  inline void dump() const;
1076
1077
  static inline id alloc(ctx ctx, const std::string &name, void * user);
1078
  inline uint32_t get_hash() const;
1079
  inline std::string get_name() const;
1080
  inline void * get_user() const;
1081
};
1082
1083
// declarations for isl::id_list
1084
inline id_list manage(__isl_take isl_id_list *ptr);
1085
inline id_list manage_copy(__isl_keep isl_id_list *ptr);
1086
1087
class id_list {
1088
  friend inline id_list manage(__isl_take isl_id_list *ptr);
1089
  friend inline id_list manage_copy(__isl_keep isl_id_list *ptr);
1090
1091
  isl_id_list *ptr = nullptr;
1092
1093
  inline explicit id_list(__isl_take isl_id_list *ptr);
1094
1095
public:
1096
  inline /* implicit */ id_list();
1097
  inline /* implicit */ id_list(const id_list &obj);
1098
  inline /* implicit */ id_list(std::nullptr_t);
1099
  inline id_list &operator=(id_list obj);
1100
  inline ~id_list();
1101
  inline __isl_give isl_id_list *copy() const &;
1102
  inline __isl_give isl_id_list *copy() && = delete;
1103
  inline __isl_keep isl_id_list *get() const;
1104
  inline __isl_give isl_id_list *release();
1105
  inline bool is_null() const;
1106
  inline explicit operator bool() const;
1107
  inline ctx get_ctx() const;
1108
  inline void dump() const;
1109
1110
  inline id_list add(id el) const;
1111
  static inline id_list alloc(ctx ctx, int n);
1112
  inline id_list concat(id_list list2) const;
1113
  inline id_list drop(unsigned int first, unsigned int n) const;
1114
  inline stat foreach(const std::function<stat(id)> &fn) const;
1115
  static inline id_list from_id(id el);
1116
  inline id get_at(int index) const;
1117
  inline id get_id(int index) const;
1118
  inline id_list insert(unsigned int pos, id el) const;
1119
  inline int n_id() const;
1120
  inline id_list reverse() const;
1121
  inline id_list set_id(int index, id el) const;
1122
  inline int size() const;
1123
  inline id_list swap(unsigned int pos1, unsigned int pos2) const;
1124
};
1125
1126
// declarations for isl::id_to_ast_expr
1127
inline id_to_ast_expr manage(__isl_take isl_id_to_ast_expr *ptr);
1128
inline id_to_ast_expr manage_copy(__isl_keep isl_id_to_ast_expr *ptr);
1129
1130
class id_to_ast_expr {
1131
  friend inline id_to_ast_expr manage(__isl_take isl_id_to_ast_expr *ptr);
1132
  friend inline id_to_ast_expr manage_copy(__isl_keep isl_id_to_ast_expr *ptr);
1133
1134
  isl_id_to_ast_expr *ptr = nullptr;
1135
1136
  inline explicit id_to_ast_expr(__isl_take isl_id_to_ast_expr *ptr);
1137
1138
public:
1139
  inline /* implicit */ id_to_ast_expr();
1140
  inline /* implicit */ id_to_ast_expr(const id_to_ast_expr &obj);
1141
  inline /* implicit */ id_to_ast_expr(std::nullptr_t);
1142
  inline id_to_ast_expr &operator=(id_to_ast_expr obj);
1143
  inline ~id_to_ast_expr();
1144
  inline __isl_give isl_id_to_ast_expr *copy() const &;
1145
  inline __isl_give isl_id_to_ast_expr *copy() && = delete;
1146
  inline __isl_keep isl_id_to_ast_expr *get() const;
1147
  inline __isl_give isl_id_to_ast_expr *release();
1148
  inline bool is_null() const;
1149
  inline explicit operator bool() const;
1150
  inline ctx get_ctx() const;
1151
  inline void dump() const;
1152
1153
  static inline id_to_ast_expr alloc(ctx ctx, int min_size);
1154
  inline id_to_ast_expr drop(id key) const;
1155
  inline stat foreach(const std::function<stat(id, ast_expr)> &fn) const;
1156
  inline ast_expr get(id key) const;
1157
  inline boolean has(const id &key) const;
1158
  inline id_to_ast_expr set(id key, ast_expr val) const;
1159
};
1160
1161
// declarations for isl::local_space
1162
inline local_space manage(__isl_take isl_local_space *ptr);
1163
inline local_space manage_copy(__isl_keep isl_local_space *ptr);
1164
1165
class local_space {
1166
  friend inline local_space manage(__isl_take isl_local_space *ptr);
1167
  friend inline local_space manage_copy(__isl_keep isl_local_space *ptr);
1168
1169
  isl_local_space *ptr = nullptr;
1170
1171
  inline explicit local_space(__isl_take isl_local_space *ptr);
1172
1173
public:
1174
  inline /* implicit */ local_space();
1175
  inline /* implicit */ local_space(const local_space &obj);
1176
  inline /* implicit */ local_space(std::nullptr_t);
1177
  inline explicit local_space(space dim);
1178
  inline local_space &operator=(local_space obj);
1179
  inline ~local_space();
1180
  inline __isl_give isl_local_space *copy() const &;
1181
  inline __isl_give isl_local_space *copy() && = delete;
1182
  inline __isl_keep isl_local_space *get() const;
1183
  inline __isl_give isl_local_space *release();
1184
  inline bool is_null() const;
1185
  inline explicit operator bool() const;
1186
  inline ctx get_ctx() const;
1187
  inline void dump() const;
1188
1189
  inline local_space add_dims(isl::dim type, unsigned int n) const;
1190
  inline int dim(isl::dim type) const;
1191
  inline local_space domain() const;
1192
  inline local_space drop_dims(isl::dim type, unsigned int first, unsigned int n) const;
1193
  inline int find_dim_by_name(isl::dim type, const std::string &name) const;
1194
  inline local_space flatten_domain() const;
1195
  inline local_space flatten_range() const;
1196
  inline local_space from_domain() const;
1197
  inline id get_dim_id(isl::dim type, unsigned int pos) const;
1198
  inline std::string get_dim_name(isl::dim type, unsigned int pos) const;
1199
  inline aff get_div(int pos) const;
1200
  inline space get_space() const;
1201
  inline boolean has_dim_id(isl::dim type, unsigned int pos) const;
1202
  inline boolean has_dim_name(isl::dim type, unsigned int pos) const;
1203
  inline local_space insert_dims(isl::dim type, unsigned int first, unsigned int n) const;
1204
  inline local_space intersect(local_space ls2) const;
1205
  inline boolean is_equal(const local_space &ls2) const;
1206
  inline boolean is_params() const;
1207
  inline boolean is_set() const;
1208
  inline local_space range() const;
1209
  inline local_space set_dim_id(isl::dim type, unsigned int pos, id id) const;
1210
  inline local_space set_from_params() const;
1211
  inline local_space set_tuple_id(isl::dim type, id id) const;
1212
  inline local_space wrap() const;
1213
};
1214
1215
// declarations for isl::map
1216
inline map manage(__isl_take isl_map *ptr);
1217
inline map manage_copy(__isl_keep isl_map *ptr);
1218
1219
class map {
1220
  friend inline map manage(__isl_take isl_map *ptr);
1221
  friend inline map manage_copy(__isl_keep isl_map *ptr);
1222
1223
  isl_map *ptr = nullptr;
1224
1225
  inline explicit map(__isl_take isl_map *ptr);
1226
1227
public:
1228
  inline /* implicit */ map();
1229
  inline /* implicit */ map(const map &obj);
1230
  inline /* implicit */ map(std::nullptr_t);
1231
  inline explicit map(ctx ctx, const std::string &str);
1232
  inline /* implicit */ map(basic_map bmap);
1233
  inline map &operator=(map obj);
1234
  inline ~map();
1235
  inline __isl_give isl_map *copy() const &;
1236
  inline __isl_give isl_map *copy() && = delete;
1237
  inline __isl_keep isl_map *get() const;
1238
  inline __isl_give isl_map *release();
1239
  inline bool is_null() const;
1240
  inline explicit operator bool() const;
1241
  inline ctx get_ctx() const;
1242
  inline std::string to_str() const;
1243
  inline void dump() const;
1244
1245
  inline map add_constraint(constraint constraint) const;
1246
  inline map add_dims(isl::dim type, unsigned int n) const;
1247
  inline basic_map affine_hull() const;
1248
  inline map align_params(space model) const;
1249
  inline map apply_domain(map map2) const;
1250
  inline map apply_range(map map2) const;
1251
  inline boolean can_curry() const;
1252
  inline boolean can_range_curry() const;
1253
  inline boolean can_uncurry() const;
1254
  inline boolean can_zip() const;
1255
  inline map coalesce() const;
1256
  inline map complement() const;
1257
  inline basic_map convex_hull() const;
1258
  inline map curry() const;
1259
  inline set deltas() const;
1260
  inline map deltas_map() const;
1261
  inline map detect_equalities() const;
1262
  inline unsigned int dim(isl::dim type) const;
1263
  inline pw_aff dim_max(int pos) const;
1264
  inline pw_aff dim_min(int pos) const;
1265
  inline set domain() const;
1266
  inline map domain_factor_domain() const;
1267
  inline map domain_factor_range() const;
1268
  inline boolean domain_is_wrapping() const;
1269
  inline map domain_map() const;
1270
  inline map domain_product(map map2) const;
1271
  inline map drop_constraints_involving_dims(isl::dim type, unsigned int first, unsigned int n) const;
1272
  inline map drop_constraints_not_involving_dims(isl::dim type, unsigned int first, unsigned int n) const;
1273
  inline map drop_unused_params() const;
1274
  inline map eliminate(isl::dim type, unsigned int first, unsigned int n) const;
1275
  static inline map empty(space space);
1276
  inline map equate(isl::dim type1, int pos1, isl::dim type2, int pos2) const;
1277
  inline map factor_domain() const;
1278
  inline map factor_range() const;
1279
  inline int find_dim_by_id(isl::dim type, const id &id) const;
1280
  inline int find_dim_by_name(isl::dim type, const std::string &name) const;
1281
  inline map fix_si(isl::dim type, unsigned int pos, int value) const;
1282
  inline map fix_val(isl::dim type, unsigned int pos, val v) const;
1283
  inline map fixed_power_val(val exp) const;
1284
  inline map flat_domain_product(map map2) const;
1285
  inline map flat_product(map map2) const;
1286
  inline map flat_range_product(map map2) const;
1287
  inline map flatten() const;
1288
  inline map flatten_domain() const;
1289
  inline map flatten_range() const;
1290
  inline map floordiv_val(val d) const;
1291
  inline stat foreach_basic_map(const std::function<stat(basic_map)> &fn) const;
1292
  static inline map from_aff(aff aff);
1293
  static inline map from_domain(set set);
1294
  static inline map from_domain_and_range(set domain, set range);
1295
  static inline map from_multi_aff(multi_aff maff);
1296
  static inline map from_multi_pw_aff(multi_pw_aff mpa);
1297
  static inline map from_pw_aff(pw_aff pwaff);
1298
  static inline map from_pw_multi_aff(pw_multi_aff pma);
1299
  static inline map from_range(set set);
1300
  static inline map from_union_map(union_map umap);
1301
  inline basic_map_list get_basic_map_list() const;
1302
  inline id get_dim_id(isl::dim type, unsigned int pos) const;
1303
  inline std::string get_dim_name(isl::dim type, unsigned int pos) const;
1304
  inline uint32_t get_hash() const;
1305
  inline fixed_box get_range_simple_fixed_box_hull() const;
1306
  inline space get_space() const;
1307
  inline id get_tuple_id(isl::dim type) const;
1308
  inline std::string get_tuple_name(isl::dim type) const;
1309
  inline map gist(map context) const;
1310
  inline map gist_basic_map(basic_map context) const;
1311
  inline map gist_domain(set context) const;
1312
  inline map gist_params(set context) const;
1313
  inline map gist_range(set context) const;
1314
  inline boolean has_dim_id(isl::dim type, unsigned int pos) const;
1315
  inline boolean has_dim_name(isl::dim type, unsigned int pos) const;
1316
  inline boolean has_equal_space(const map &map2) const;
1317
  inline boolean has_tuple_id(isl::dim type) const;
1318
  inline boolean has_tuple_name(isl::dim type) const;
1319
  static inline map identity(space dim);
1320
  inline map insert_dims(isl::dim type, unsigned int pos, unsigned int n) const;
1321
  inline map intersect(map map2) const;
1322
  inline map intersect_domain(set set) const;
1323
  inline map intersect_domain_factor_range(map factor) const;
1324
  inline map intersect_params(set params) const;
1325
  inline map intersect_range(set set) const;
1326
  inline map intersect_range_factor_range(map factor) const;
1327
  inline boolean involves_dims(isl::dim type, unsigned int first, unsigned int n) const;
1328
  inline boolean is_bijective() const;
1329
  inline boolean is_disjoint(const map &map2) const;
1330
  inline boolean is_empty() const;
1331
  inline boolean is_equal(const map &map2) const;
1332
  inline boolean is_identity() const;
1333
  inline boolean is_injective() const;
1334
  inline boolean is_product() const;
1335
  inline boolean is_single_valued() const;
1336
  inline boolean is_strict_subset(const map &map2) const;
1337
  inline boolean is_subset(const map &map2) const;
1338
  inline int is_translation() const;
1339
  static inline map lex_ge(space set_dim);
1340
  static inline map lex_ge_first(space dim, unsigned int n);
1341
  inline map lex_ge_map(map map2) const;
1342
  static inline map lex_gt(space set_dim);
1343
  static inline map lex_gt_first(space dim, unsigned int n);
1344
  inline map lex_gt_map(map map2) const;
1345
  static inline map lex_le(space set_dim);
1346
  static inline map lex_le_first(space dim, unsigned int n);
1347
  inline map lex_le_map(map map2) const;
1348
  static inline map lex_lt(space set_dim);
1349
  static inline map lex_lt_first(space dim, unsigned int n);
1350
  inline map lex_lt_map(map map2) const;
1351
  inline map lexmax() const;
1352
  inline pw_multi_aff lexmax_pw_multi_aff() const;
1353
  inline map lexmin() const;
1354
  inline pw_multi_aff lexmin_pw_multi_aff() const;
1355
  inline map lower_bound_si(isl::dim type, unsigned int pos, int value) const;
1356
  inline map move_dims(isl::dim dst_type, unsigned int dst_pos, isl::dim src_type, unsigned int src_pos, unsigned int n) const;
1357
  inline int n_basic_map() const;
1358
  static inline map nat_universe(space dim);
1359
  inline map neg() const;
1360
  inline map oppose(isl::dim type1, int pos1, isl::dim type2, int pos2) const;
1361
  inline map order_ge(isl::dim type1, int pos1, isl::dim type2, int pos2) const;
1362
  inline map order_gt(isl::dim type1, int pos1, isl::dim type2, int pos2) const;
1363
  inline map order_le(isl::dim type1, int pos1, isl::dim type2, int pos2) const;
1364
  inline map order_lt(isl::dim type1, int pos1, isl::dim type2, int pos2) const;
1365
  inline set params() const;
1366
  inline val plain_get_val_if_fixed(isl::dim type, unsigned int pos) const;
1367
  inline boolean plain_is_empty() const;
1368
  inline boolean plain_is_equal(const map &map2) const;
1369
  inline boolean plain_is_injective() const;
1370
  inline boolean plain_is_single_valued() const;
1371
  inline boolean plain_is_universe() const;
1372
  inline basic_map plain_unshifted_simple_hull() const;
1373
  inline basic_map polyhedral_hull() const;
1374
  inline map preimage_domain_multi_aff(multi_aff ma) const;
1375
  inline map preimage_domain_multi_pw_aff(multi_pw_aff mpa) const;
1376
  inline map preimage_domain_pw_multi_aff(pw_multi_aff pma) const;
1377
  inline map preimage_range_multi_aff(multi_aff ma) const;
1378
  inline map preimage_range_pw_multi_aff(pw_multi_aff pma) const;
1379
  inline map product(map map2) const;
1380
  inline map project_out(isl::dim type, unsigned int first, unsigned int n) const;
1381
  inline set range() const;
1382
  inline map range_curry() const;
1383
  inline map range_factor_domain() const;
1384
  inline map range_factor_range() const;
1385
  inline boolean range_is_wrapping() const;
1386
  inline map range_map() const;
1387
  inline map range_product(map map2) const;
1388
  inline map remove_dims(isl::dim type, unsigned int first, unsigned int n) const;
1389
  inline map remove_divs() const;
1390
  inline map remove_divs_involving_dims(isl::dim type, unsigned int first, unsigned int n) const;
1391
  inline map remove_redundancies() const;
1392
  inline map remove_unknown_divs() const;
1393
  inline map reset_tuple_id(isl::dim type) const;
1394
  inline map reset_user() const;
1395
  inline map reverse() const;
1396
  inline basic_map sample() const;
1397
  inline map set_dim_id(isl::dim type, unsigned int pos, id id) const;
1398
  inline map set_tuple_id(isl::dim type, id id) const;
1399
  inline map set_tuple_name(isl::dim type, const std::string &s) const;
1400
  inline basic_map simple_hull() const;
1401
  inline map subtract(map map2) const;
1402
  inline map subtract_domain(set dom) const;
1403
  inline map subtract_range(set dom) const;
1404
  inline map sum(map map2) const;
1405
  inline map uncurry() const;
1406
  inline map unite(map map2) const;
1407
  static inline map universe(space space);
1408
  inline basic_map unshifted_simple_hull() const;
1409
  inline basic_map unshifted_simple_hull_from_map_list(map_list list) const;
1410
  inline map upper_bound_si(isl::dim type, unsigned int pos, int value) const;
1411
  inline set wrap() const;
1412
  inline map zip() const;
1413
};
1414
1415
// declarations for isl::map_list
1416
inline map_list manage(__isl_take isl_map_list *ptr);
1417
inline map_list manage_copy(__isl_keep isl_map_list *ptr);
1418
1419
class map_list {
1420
  friend inline map_list manage(__isl_take isl_map_list *ptr);
1421
  friend inline map_list manage_copy(__isl_keep isl_map_list *ptr);
1422
1423
  isl_map_list *ptr = nullptr;
1424
1425
  inline explicit map_list(__isl_take isl_map_list *ptr);
1426
1427
public:
1428
  inline /* implicit */ map_list();
1429
  inline /* implicit */ map_list(const map_list &obj);
1430
  inline /* implicit */ map_list(std::nullptr_t);
1431
  inline map_list &operator=(map_list obj);
1432
  inline ~map_list();
1433
  inline __isl_give isl_map_list *copy() const &;
1434
  inline __isl_give isl_map_list *copy() && = delete;
1435
  inline __isl_keep isl_map_list *get() const;
1436
  inline __isl_give isl_map_list *release();
1437
  inline bool is_null() const;
1438
  inline explicit operator bool() const;
1439
  inline ctx get_ctx() const;
1440
  inline void dump() const;
1441
1442
  inline map_list add(map el) const;
1443
  static inline map_list alloc(ctx ctx, int n);
1444
  inline map_list concat(map_list list2) const;
1445
  inline map_list drop(unsigned int first, unsigned int n) const;
1446
  inline stat foreach(const std::function<stat(map)> &fn) const;
1447
  static inline map_list from_map(map el);
1448
  inline map get_at(int index) const;
1449
  inline map get_map(int index) const;
1450
  inline map_list insert(unsigned int pos, map el) const;
1451
  inline int n_map() const;
1452
  inline map_list reverse() const;
1453
  inline map_list set_map(int index, map el) const;
1454
  inline int size() const;
1455
  inline map_list swap(unsigned int pos1, unsigned int pos2) const;
1456
};
1457
1458
// declarations for isl::mat
1459
inline mat manage(__isl_take isl_mat *ptr);
1460
inline mat manage_copy(__isl_keep isl_mat *ptr);
1461
1462
class mat {
1463
  friend inline mat manage(__isl_take isl_mat *ptr);
1464
  friend inline mat manage_copy(__isl_keep isl_mat *ptr);
1465
1466
  isl_mat *ptr = nullptr;
1467
1468
  inline explicit mat(__isl_take isl_mat *ptr);
1469
1470
public:
1471
  inline /* implicit */ mat();
1472
  inline /* implicit */ mat(const mat &obj);
1473
  inline /* implicit */ mat(std::nullptr_t);
1474
  inline mat &operator=(mat obj);
1475
  inline ~mat();
1476
  inline __isl_give isl_mat *copy() const &;
1477
  inline __isl_give isl_mat *copy() && = delete;
1478
  inline __isl_keep isl_mat *get() const;
1479
  inline __isl_give isl_mat *release();
1480
  inline bool is_null() const;
1481
  inline explicit operator bool() const;
1482
  inline ctx get_ctx() const;
1483
  inline void dump() const;
1484
1485
  inline mat add_rows(unsigned int n) const;
1486
  inline mat add_zero_cols(unsigned int n) const;
1487
  inline mat add_zero_rows(unsigned int n) const;
1488
  inline mat aff_direct_sum(mat right) const;
1489
  static inline mat alloc(ctx ctx, unsigned int n_row, unsigned int n_col);
1490
  inline int cols() const;
1491
  inline mat concat(mat bot) const;
1492
  inline mat diagonal(mat mat2) const;
1493
  inline mat drop_cols(unsigned int col, unsigned int n) const;
1494
  inline mat drop_rows(unsigned int row, unsigned int n) const;
1495
  static inline mat from_row_vec(vec vec);
1496
  inline val get_element_val(int row, int col) const;
1497
  inline boolean has_linearly_independent_rows(const mat &mat2) const;
1498
  inline int initial_non_zero_cols() const;
1499
  inline mat insert_cols(unsigned int col, unsigned int n) const;
1500
  inline mat insert_rows(unsigned int row, unsigned int n) const;
1501
  inline mat insert_zero_cols(unsigned int first, unsigned int n) const;
1502
  inline mat insert_zero_rows(unsigned int row, unsigned int n) const;
1503
  inline mat inverse_product(mat right) const;
1504
  inline boolean is_equal(const mat &mat2) const;
1505
  inline mat lin_to_aff() const;
1506
  inline mat move_cols(unsigned int dst_col, unsigned int src_col, unsigned int n) const;
1507
  inline mat normalize() const;
1508
  inline mat normalize_row(int row) const;
1509
  inline mat product(mat right) const;
1510
  inline int rank() const;
1511
  inline mat right_inverse() const;
1512
  inline mat right_kernel() const;
1513
  inline mat row_basis() const;
1514
  inline mat row_basis_extension(mat mat2) const;
1515
  inline int rows() const;
1516
  inline mat set_element_si(int row, int col, int v) const;
1517
  inline mat set_element_val(int row, int col, val v) const;
1518
  inline mat swap_cols(unsigned int i, unsigned int j) const;
1519
  inline mat swap_rows(unsigned int i, unsigned int j) const;
1520
  inline mat transpose() const;
1521
  inline mat unimodular_complete(int row) const;
1522
  inline mat vec_concat(vec bot) const;
1523
  inline vec vec_inverse_product(vec vec) const;
1524
  inline vec vec_product(vec vec) const;
1525
};
1526
1527
// declarations for isl::multi_aff
1528
inline multi_aff manage(__isl_take isl_multi_aff *ptr);
1529
inline multi_aff manage_copy(__isl_keep isl_multi_aff *ptr);
1530
1531
class multi_aff {
1532
  friend inline multi_aff manage(__isl_take isl_multi_aff *ptr);
1533
  friend inline multi_aff manage_copy(__isl_keep isl_multi_aff *ptr);
1534
1535
  isl_multi_aff *ptr = nullptr;
1536
1537
  inline explicit multi_aff(__isl_take isl_multi_aff *ptr);
1538
1539
public:
1540
  inline /* implicit */ multi_aff();
1541
  inline /* implicit */ multi_aff(const multi_aff &obj);
1542
  inline /* implicit */ multi_aff(std::nullptr_t);
1543
  inline /* implicit */ multi_aff(aff aff);
1544
  inline explicit multi_aff(ctx ctx, const std::string &str);
1545
  inline multi_aff &operator=(multi_aff obj);
1546
  inline ~multi_aff();
1547
  inline __isl_give isl_multi_aff *copy() const &;
1548
  inline __isl_give isl_multi_aff *copy() && = delete;
1549
  inline __isl_keep isl_multi_aff *get() const;
1550
  inline __isl_give isl_multi_aff *release();
1551
  inline bool is_null() const;
1552
  inline explicit operator bool() const;
1553
  inline ctx get_ctx() const;
1554
  inline std::string to_str() const;
1555
  inline void dump() const;
1556
1557
  inline multi_aff add(multi_aff multi2) const;
1558
  inline multi_aff add_dims(isl::dim type, unsigned int n) const;
1559
  inline multi_aff align_params(space model) const;
1560
  inline unsigned int dim(isl::dim type) const;
1561
  static inline multi_aff domain_map(space space);
1562
  inline multi_aff drop_dims(isl::dim type, unsigned int first, unsigned int n) const;
1563
  inline multi_aff factor_range() const;
1564
  inline int find_dim_by_id(isl::dim type, const id &id) const;
1565
  inline int find_dim_by_name(isl::dim type, const std::string &name) const;
1566
  inline multi_aff flat_range_product(multi_aff multi2) const;
1567
  inline multi_aff flatten_domain() const;
1568
  inline multi_aff flatten_range() const;
1569
  inline multi_aff floor() const;
1570
  static inline multi_aff from_aff_list(space space, aff_list list);
1571
  inline multi_aff from_range() const;
1572
  inline aff get_aff(int pos) const;
1573
  inline id get_dim_id(isl::dim type, unsigned int pos) const;
1574
  inline space get_domain_space() const;
1575
  inline space get_space() const;
1576
  inline id get_tuple_id(isl::dim type) const;
1577
  inline std::string get_tuple_name(isl::dim type) const;
1578
  inline multi_aff gist(set context) const;
1579
  inline multi_aff gist_params(set context) const;
1580
  inline boolean has_tuple_id(isl::dim type) const;
1581
  static inline multi_aff identity(space space);
1582
  inline multi_aff insert_dims(isl::dim type, unsigned int first, unsigned int n) const;
1583
  inline boolean involves_dims(isl::dim type, unsigned int first, unsigned int n) const;
1584
  inline boolean involves_nan() const;
1585
  inline set lex_ge_set(multi_aff ma2) const;
1586
  inline set lex_gt_set(multi_aff ma2) const;
1587
  inline set lex_le_set(multi_aff ma2) const;
1588
  inline set lex_lt_set(multi_aff ma2) const;
1589
  inline multi_aff mod_multi_val(multi_val mv) const;
1590
  inline multi_aff move_dims(isl::dim dst_type, unsigned int dst_pos, isl::dim src_type, unsigned int src_pos, unsigned int n) const;
1591
  static inline multi_aff multi_val_on_space(space space, multi_val mv);
1592
  inline multi_aff neg() const;
1593
  inline int plain_cmp(const multi_aff &multi2) const;
1594
  inline boolean plain_is_equal(const multi_aff &multi2) const;
1595
  inline multi_aff product(multi_aff multi2) const;
1596
  inline multi_aff project_domain_on_params() const;
1597
  static inline multi_aff project_out_map(space space, isl::dim type, unsigned int first, unsigned int n);
1598
  inline multi_aff pullback(multi_aff ma2) const;
1599
  inline multi_aff range_factor_domain() const;
1600
  inline multi_aff range_factor_range() const;
1601
  inline boolean range_is_wrapping() const;
1602
  static inline multi_aff range_map(space space);
1603
  inline multi_aff range_product(multi_aff multi2) const;
1604
  inline multi_aff range_splice(unsigned int pos, multi_aff multi2) const;
1605
  inline multi_aff reset_tuple_id(isl::dim type) const;
1606
  inline multi_aff reset_user() const;
1607
  inline multi_aff scale_down_multi_val(multi_val mv) const;
1608
  inline multi_aff scale_down_val(val v) const;
1609
  inline multi_aff scale_multi_val(multi_val mv) const;
1610
  inline multi_aff scale_val(val v) const;
1611
  inline multi_aff set_aff(int pos, aff el) const;
1612
  inline multi_aff set_dim_id(isl::dim type, unsigned int pos, id id) const;
1613
  inline multi_aff set_tuple_id(isl::dim type, id id) const;
1614
  inline multi_aff set_tuple_name(isl::dim type, const std::string &s) const;
1615
  inline multi_aff splice(unsigned int in_pos, unsigned int out_pos, multi_aff multi2) const;
1616
  inline multi_aff sub(multi_aff multi2) const;
1617
  static inline multi_aff zero(space space);
1618
};
1619
1620
// declarations for isl::multi_pw_aff
1621
inline multi_pw_aff manage(__isl_take isl_multi_pw_aff *ptr);
1622
inline multi_pw_aff manage_copy(__isl_keep isl_multi_pw_aff *ptr);
1623
1624
class multi_pw_aff {
1625
  friend inline multi_pw_aff manage(__isl_take isl_multi_pw_aff *ptr);
1626
  friend inline multi_pw_aff manage_copy(__isl_keep isl_multi_pw_aff *ptr);
1627
1628
  isl_multi_pw_aff *ptr = nullptr;
1629
1630
  inline explicit multi_pw_aff(__isl_take isl_multi_pw_aff *ptr);
1631
1632
public:
1633
  inline /* implicit */ multi_pw_aff();
1634
  inline /* implicit */ multi_pw_aff(const multi_pw_aff &obj);
1635
  inline /* implicit */ multi_pw_aff(std::nullptr_t);
1636
  inline /* implicit */ multi_pw_aff(multi_aff ma);
1637
  inline /* implicit */ multi_pw_aff(pw_aff pa);
1638
  inline /* implicit */ multi_pw_aff(pw_multi_aff pma);
1639
  inline explicit multi_pw_aff(ctx ctx, const std::string &str);
1640
  inline multi_pw_aff &operator=(multi_pw_aff obj);
1641
  inline ~multi_pw_aff();
1642
  inline __isl_give isl_multi_pw_aff *copy() const &;
1643
  inline __isl_give isl_multi_pw_aff *copy() && = delete;
1644
  inline __isl_keep isl_multi_pw_aff *get() const;
1645
  inline __isl_give isl_multi_pw_aff *release();
1646
  inline bool is_null() const;
1647
  inline explicit operator bool() const;
1648
  inline ctx get_ctx() const;
1649
  inline std::string to_str() const;
1650
  inline void dump() const;
1651
1652
  inline multi_pw_aff add(multi_pw_aff multi2) const;
1653
  inline multi_pw_aff add_dims(isl::dim type, unsigned int n) const;
1654
  inline multi_pw_aff align_params(space model) const;
1655
  inline multi_pw_aff coalesce() const;
1656
  inline unsigned int dim(isl::dim type) const;
1657
  inline set domain() const;
1658
  inline multi_pw_aff drop_dims(isl::dim type, unsigned int first, unsigned int n) const;
1659
  inline map eq_map(multi_pw_aff mpa2) const;
1660
  inline multi_pw_aff factor_range() const;
1661
  inline int find_dim_by_id(isl::dim type, const id &id) const;
1662
  inline int find_dim_by_name(isl::dim type, const std::string &name) const;
1663
  inline multi_pw_aff flat_range_product(multi_pw_aff multi2) const;
1664
  inline multi_pw_aff flatten_range() const;
1665
  static inline multi_pw_aff from_pw_aff_list(space space, pw_aff_list list);
1666
  inline multi_pw_aff from_range() const;
1667
  inline id get_dim_id(isl::dim type, unsigned int pos) const;
1668
  inline space get_domain_space() const;
1669
  inline uint32_t get_hash() const;
1670
  inline pw_aff get_pw_aff(int pos) const;
1671
  inline space get_space() const;
1672
  inline id get_tuple_id(isl::dim type) const;
1673
  inline std::string get_tuple_name(isl::dim type) const;
1674
  inline multi_pw_aff gist(set set) const;
1675
  inline multi_pw_aff gist_params(set set) const;
1676
  inline boolean has_tuple_id(isl::dim type) const;
1677
  static inline multi_pw_aff identity(space space);
1678
  inline multi_pw_aff insert_dims(isl::dim type, unsigned int first, unsigned int n) const;
1679
  inline multi_pw_aff intersect_domain(set domain) const;
1680
  inline multi_pw_aff intersect_params(set set) const;
1681
  inline boolean involves_dims(isl::dim type, unsigned int first, unsigned int n) const;
1682
  inline boolean involves_nan() const;
1683
  inline boolean is_cst() const;
1684
  inline boolean is_equal(const multi_pw_aff &mpa2) const;
1685
  inline map lex_gt_map(multi_pw_aff mpa2) const;
1686
  inline map lex_lt_map(multi_pw_aff mpa2) const;
1687
  inline multi_pw_aff mod_multi_val(multi_val mv) const;
1688
  inline multi_pw_aff move_dims(isl::dim dst_type, unsigned int dst_pos, isl::dim src_type, unsigned int src_pos, unsigned int n) const;
1689
  inline multi_pw_aff neg() const;
1690
  inline boolean plain_is_equal(const multi_pw_aff &multi2) const;
1691
  inline multi_pw_aff product(multi_pw_aff multi2) const;
1692
  inline multi_pw_aff project_domain_on_params() const;
1693
  inline multi_pw_aff pullback(multi_aff ma) const;
1694
  inline multi_pw_aff pullback(pw_multi_aff pma) const;
1695
  inline multi_pw_aff pullback(multi_pw_aff mpa2) const;
1696
  inline multi_pw_aff range_factor_domain() const;
1697
  inline multi_pw_aff range_factor_range() const;
1698
  inline boolean range_is_wrapping() const;
1699
  inline multi_pw_aff range_product(multi_pw_aff multi2) const;
1700
  inline multi_pw_aff range_splice(unsigned int pos, multi_pw_aff multi2) const;
1701
  inline multi_pw_aff reset_tuple_id(isl::dim type) const;
1702
  inline multi_pw_aff reset_user() const;
1703
  inline multi_pw_aff scale_down_multi_val(multi_val mv) const;
1704
  inline multi_pw_aff scale_down_val(val v) const;
1705
  inline multi_pw_aff scale_multi_val(multi_val mv) const;
1706
  inline multi_pw_aff scale_val(val v) const;
1707
  inline multi_pw_aff set_dim_id(isl::dim type, unsigned int pos, id id) const;
1708
  inline multi_pw_aff set_pw_aff(int pos, pw_aff el) const;
1709
  inline multi_pw_aff set_tuple_id(isl::dim type, id id) const;
1710
  inline multi_pw_aff set_tuple_name(isl::dim type, const std::string &s) const;
1711
  inline multi_pw_aff splice(unsigned int in_pos, unsigned int out_pos, multi_pw_aff multi2) const;
1712
  inline multi_pw_aff sub(multi_pw_aff multi2) const;
1713
  static inline multi_pw_aff zero(space space);
1714
};
1715
1716
// declarations for isl::multi_union_pw_aff
1717
inline multi_union_pw_aff manage(__isl_take isl_multi_union_pw_aff *ptr);
1718
inline multi_union_pw_aff manage_copy(__isl_keep isl_multi_union_pw_aff *ptr);
1719
1720
class multi_union_pw_aff {
1721
  friend inline multi_union_pw_aff manage(__isl_take isl_multi_union_pw_aff *ptr);
1722
  friend inline multi_union_pw_aff manage_copy(__isl_keep isl_multi_union_pw_aff *ptr);
1723
1724
  isl_multi_union_pw_aff *ptr = nullptr;
1725
1726
  inline explicit multi_union_pw_aff(__isl_take isl_multi_union_pw_aff *ptr);
1727
1728
public:
1729
  inline /* implicit */ multi_union_pw_aff();
1730
  inline /* implicit */ multi_union_pw_aff(const multi_union_pw_aff &obj);
1731
  inline /* implicit */ multi_union_pw_aff(std::nullptr_t);
1732
  inline /* implicit */ multi_union_pw_aff(union_pw_aff upa);
1733
  inline /* implicit */ multi_union_pw_aff(multi_pw_aff mpa);
1734
  inline explicit multi_union_pw_aff(union_pw_multi_aff upma);
1735
  inline explicit multi_union_pw_aff(ctx ctx, const std::string &str);
1736
  inline multi_union_pw_aff &operator=(multi_union_pw_aff obj);
1737
  inline ~multi_union_pw_aff();
1738
  inline __isl_give isl_multi_union_pw_aff *copy() const &;
1739
  inline __isl_give isl_multi_union_pw_aff *copy() && = delete;
1740
  inline __isl_keep isl_multi_union_pw_aff *get() const;
1741
  inline __isl_give isl_multi_union_pw_aff *release();
1742
  inline bool is_null() const;
1743
  inline explicit operator bool() const;
1744
  inline ctx get_ctx() const;
1745
  inline std::string to_str() const;
1746
  inline void dump() const;
1747
1748
  inline multi_union_pw_aff add(multi_union_pw_aff multi2) const;
1749
  inline multi_union_pw_aff align_params(space model) const;
1750
  inline union_pw_aff apply_aff(aff aff) const;
1751
  inline union_pw_aff apply_pw_aff(pw_aff pa) const;
1752
  inline multi_union_pw_aff apply_pw_multi_aff(pw_multi_aff pma) const;
1753
  inline multi_union_pw_aff coalesce() const;
1754
  inline unsigned int dim(isl::dim type) const;
1755
  inline union_set domain() const;
1756
  inline multi_union_pw_aff drop_dims(isl::dim type, unsigned int first, unsigned int n) const;
1757
  inline multi_pw_aff extract_multi_pw_aff(space space) const;
1758
  inline multi_union_pw_aff factor_range() const;
1759
  inline int find_dim_by_id(isl::dim type, const id &id) const;
1760
  inline int find_dim_by_name(isl::dim type, const std::string &name) const;
1761
  inline multi_union_pw_aff flat_range_product(multi_union_pw_aff multi2) const;
1762
  inline multi_union_pw_aff flatten_range() const;
1763
  inline multi_union_pw_aff floor() const;
1764
  static inline multi_union_pw_aff from_multi_aff(multi_aff ma);
1765
  inline multi_union_pw_aff from_range() const;
1766
  static inline multi_union_pw_aff from_union_map(union_map umap);
1767
  static inline multi_union_pw_aff from_union_pw_aff_list(space space, union_pw_aff_list list);
1768
  inline id get_dim_id(isl::dim type, unsigned int pos) const;
1769
  inline space get_domain_space() const;
1770
  inline space get_space() const;
1771
  inline id get_tuple_id(isl::dim type) const;
1772
  inline std::string get_tuple_name(isl::dim type) const;
1773
  inline union_pw_aff get_union_pw_aff(int pos) const;
1774
  inline multi_union_pw_aff gist(union_set context) const;
1775
  inline multi_union_pw_aff gist_params(set context) const;
1776
  inline boolean has_tuple_id(isl::dim type) const;
1777
  inline multi_union_pw_aff intersect_domain(union_set uset) const;
1778
  inline multi_union_pw_aff intersect_params(set params) const;
1779
  inline multi_union_pw_aff intersect_range(set set) const;
1780
  inline boolean involves_nan() const;
1781
  inline multi_val max_multi_val() const;
1782
  inline multi_val min_multi_val() const;
1783
  inline multi_union_pw_aff mod_multi_val(multi_val mv) const;
1784
  static inline multi_union_pw_aff multi_aff_on_domain(union_set domain, multi_aff ma);
1785
  static inline multi_union_pw_aff multi_val_on_domain(union_set domain, multi_val mv);
1786
  inline multi_union_pw_aff neg() const;
1787
  inline boolean plain_is_equal(const multi_union_pw_aff &multi2) const;
1788
  inline multi_union_pw_aff pullback(union_pw_multi_aff upma) const;
1789
  static inline multi_union_pw_aff pw_multi_aff_on_domain(union_set domain, pw_multi_aff pma);
1790
  inline multi_union_pw_aff range_factor_domain() const;
1791
  inline multi_union_pw_aff range_factor_range() const;
1792
  inline boolean range_is_wrapping() const;
1793
  inline multi_union_pw_aff range_product(multi_union_pw_aff multi2) const;
1794
  inline multi_union_pw_aff range_splice(unsigned int pos, multi_union_pw_aff multi2) const;
1795
  inline multi_union_pw_aff reset_tuple_id(isl::dim type) const;
1796
  inline multi_union_pw_aff reset_user() const;
1797
  inline multi_union_pw_aff scale_down_multi_val(multi_val mv) const;
1798
  inline multi_union_pw_aff scale_down_val(val v) const;
1799
  inline multi_union_pw_aff scale_multi_val(multi_val mv) const;
1800
  inline multi_union_pw_aff scale_val(val v) const;
1801
  inline multi_union_pw_aff set_dim_id(isl::dim type, unsigned int pos, id id) const;
1802
  inline multi_union_pw_aff set_tuple_id(isl::dim type, id id) const;
1803
  inline multi_union_pw_aff set_tuple_name(isl::dim type, const std::string &s) const;
1804
  inline multi_union_pw_aff set_union_pw_aff(int pos, union_pw_aff el) const;
1805
  inline multi_union_pw_aff sub(multi_union_pw_aff multi2) const;
1806
  inline multi_union_pw_aff union_add(multi_union_pw_aff mupa2) const;
1807
  static inline multi_union_pw_aff zero(space space);
1808
  inline union_set zero_union_set() const;
1809
};
1810
1811
// declarations for isl::multi_val
1812
inline multi_val manage(__isl_take isl_multi_val *ptr);
1813
inline multi_val manage_copy(__isl_keep isl_multi_val *ptr);
1814
1815
class multi_val {
1816
  friend inline multi_val manage(__isl_take isl_multi_val *ptr);
1817
  friend inline multi_val manage_copy(__isl_keep isl_multi_val *ptr);
1818
1819
  isl_multi_val *ptr = nullptr;
1820
1821
  inline explicit multi_val(__isl_take isl_multi_val *ptr);
1822
1823
public:
1824
  inline /* implicit */ multi_val();
1825
  inline /* implicit */ multi_val(const multi_val &obj);
1826
  inline /* implicit */ multi_val(std::nullptr_t);
1827
  inline multi_val &operator=(multi_val obj);
1828
  inline ~multi_val();
1829
  inline __isl_give isl_multi_val *copy() const &;
1830
  inline __isl_give isl_multi_val *copy() && = delete;
1831
  inline __isl_keep isl_multi_val *get() const;
1832
  inline __isl_give isl_multi_val *release();
1833
  inline bool is_null() const;
1834
  inline explicit operator bool() const;
1835
  inline ctx get_ctx() const;
1836
  inline std::string to_str() const;
1837
  inline void dump() const;
1838
1839
  inline multi_val add(multi_val multi2) const;
1840
  inline multi_val add_dims(isl::dim type, unsigned int n) const;
1841
  inline multi_val add_val(val v) const;
1842
  inline multi_val align_params(space model) const;
1843
  inline unsigned int dim(isl::dim type) const;
1844
  inline multi_val drop_dims(isl::dim type, unsigned int first, unsigned int n) const;
1845
  inline multi_val factor_range() const;
1846
  inline int find_dim_by_id(isl::dim type, const id &id) const;
1847
  inline int find_dim_by_name(isl::dim type, const std::string &name) const;
1848
  inline multi_val flat_range_product(multi_val multi2) const;
1849
  inline multi_val flatten_range() const;
1850
  inline multi_val from_range() const;
1851
  static inline multi_val from_val_list(space space, val_list list);
1852
  inline id get_dim_id(isl::dim type, unsigned int pos) const;
1853
  inline space get_domain_space() const;
1854
  inline space get_space() const;
1855
  inline id get_tuple_id(isl::dim type) const;
1856
  inline std::string get_tuple_name(isl::dim type) const;
1857
  inline val get_val(int pos) const;
1858
  inline boolean has_tuple_id(isl::dim type) const;
1859
  inline multi_val insert_dims(isl::dim type, unsigned int first, unsigned int n) const;
1860
  inline boolean involves_dims(isl::dim type, unsigned int first, unsigned int n) const;
1861
  inline boolean involves_nan() const;
1862
  inline multi_val mod_multi_val(multi_val mv) const;
1863
  inline multi_val mod_val(val v) const;
1864
  inline multi_val neg() const;
1865
  inline boolean plain_is_equal(const multi_val &multi2) const;
1866
  inline multi_val product(multi_val multi2) const;
1867
  inline multi_val project_domain_on_params() const;
1868
  inline multi_val range_factor_domain() const;
1869
  inline multi_val range_factor_range() const;
1870
  inline boolean range_is_wrapping() const;
1871
  inline multi_val range_product(multi_val multi2) const;
1872
  inline multi_val range_splice(unsigned int pos, multi_val multi2) const;
1873
  static inline multi_val read_from_str(ctx ctx, const std::string &str);
1874
  inline multi_val reset_tuple_id(isl::dim type) const;
1875
  inline multi_val reset_user() const;
1876
  inline multi_val scale_down_multi_val(multi_val mv) const;
1877
  inline multi_val scale_down_val(val v) const;
1878
  inline multi_val scale_multi_val(multi_val mv) const;
1879
  inline multi_val scale_val(val v) const;
1880
  inline multi_val set_dim_id(isl::dim type, unsigned int pos, id id) const;
1881
  inline multi_val set_tuple_id(isl::dim type, id id) const;
1882
  inline multi_val set_tuple_name(isl::dim type, const std::string &s) const;
1883
  inline multi_val set_val(int pos, val el) const;
1884
  inline multi_val splice(unsigned int in_pos, unsigned int out_pos, multi_val multi2) const;
1885
  inline multi_val sub(multi_val multi2) const;
1886
  static inline multi_val zero(space space);
1887
};
1888
1889
// declarations for isl::point
1890
inline point manage(__isl_take isl_point *ptr);
1891
inline point manage_copy(__isl_keep isl_point *ptr);
1892
1893
class point {
1894
  friend inline point manage(__isl_take isl_point *ptr);
1895
  friend inline point manage_copy(__isl_keep isl_point *ptr);
1896
1897
  isl_point *ptr = nullptr;
1898
1899
  inline explicit point(__isl_take isl_point *ptr);
1900
1901
public:
1902
  inline /* implicit */ point();
1903
  inline /* implicit */ point(const point &obj);
1904
  inline /* implicit */ point(std::nullptr_t);
1905
  inline explicit point(space dim);
1906
  inline point &operator=(point obj);
1907
  inline ~point();
1908
  inline __isl_give isl_point *copy() const &;
1909
  inline __isl_give isl_point *copy() && = delete;
1910
  inline __isl_keep isl_point *get() const;
1911
  inline __isl_give isl_point *release();
1912
  inline bool is_null() const;
1913
  inline explicit operator bool() const;
1914
  inline ctx get_ctx() const;
1915
  inline std::string to_str() const;
1916
  inline void dump() const;
1917
1918
  inline point add_ui(isl::dim type, int pos, unsigned int val) const;
1919
  inline val get_coordinate_val(isl::dim type, int pos) const;
1920
  inline space get_space() const;
1921
  inline point set_coordinate_val(isl::dim type, int pos, val v) const;
1922
  inline point sub_ui(isl::dim type, int pos, unsigned int val) const;
1923
};
1924
1925
// declarations for isl::pw_aff
1926
inline pw_aff manage(__isl_take isl_pw_aff *ptr);
1927
inline pw_aff manage_copy(__isl_keep isl_pw_aff *ptr);
1928
1929
class pw_aff {
1930
  friend inline pw_aff manage(__isl_take isl_pw_aff *ptr);
1931
  friend inline pw_aff manage_copy(__isl_keep isl_pw_aff *ptr);
1932
1933
  isl_pw_aff *ptr = nullptr;
1934
1935
  inline explicit pw_aff(__isl_take isl_pw_aff *ptr);
1936
1937
public:
1938
  inline /* implicit */ pw_aff();
1939
  inline /* implicit */ pw_aff(const pw_aff &obj);
1940
  inline /* implicit */ pw_aff(std::nullptr_t);
1941
  inline /* implicit */ pw_aff(aff aff);
1942
  inline explicit pw_aff(local_space ls);
1943
  inline explicit pw_aff(set domain, val v);
1944
  inline explicit pw_aff(ctx ctx, const std::string &str);
1945
  inline pw_aff &operator=(pw_aff obj);
1946
  inline ~pw_aff();
1947
  inline __isl_give isl_pw_aff *copy() const &;
1948
  inline __isl_give isl_pw_aff *copy() && = delete;
1949
  inline __isl_keep isl_pw_aff *get() const;
1950
  inline __isl_give isl_pw_aff *release();
1951
  inline bool is_null() const;
1952
  inline explicit operator bool() const;
1953
  inline ctx get_ctx() const;
1954
  inline std::string to_str() const;
1955
  inline void dump() const;
1956
1957
  inline pw_aff add(pw_aff pwaff2) const;
1958
  inline pw_aff add_dims(isl::dim type, unsigned int n) const;
1959
  inline pw_aff align_params(space model) const;
1960
  static inline pw_aff alloc(set set, aff aff);
1961
  inline pw_aff ceil() const;
1962
  inline pw_aff coalesce() const;
1963
  inline pw_aff cond(pw_aff pwaff_true, pw_aff pwaff_false) const;
1964
  inline unsigned int dim(isl::dim type) const;
1965
  inline pw_aff div(pw_aff pa2) const;
1966
  inline set domain() const;
1967
  inline pw_aff drop_dims(isl::dim type, unsigned int first, unsigned int n) const;
1968
  inline pw_aff drop_unused_params() const;
1969
  static inline pw_aff empty(space dim);
1970
  inline map eq_map(pw_aff pa2) const;
1971
  inline set eq_set(pw_aff pwaff2) const;
1972
  inline val eval(point pnt) const;
1973
  inline int find_dim_by_name(isl::dim type, const std::string &name) const;
1974
  inline pw_aff floor() const;
1975
  inline stat foreach_piece(const std::function<stat(set, aff)> &fn) const;
1976
  inline pw_aff from_range() const;
1977
  inline set ge_set(pw_aff pwaff2) const;
1978
  inline id get_dim_id(isl::dim type, unsigned int pos) const;
1979
  inline std::string get_dim_name(isl::dim type, unsigned int pos) const;
1980
  inline space get_domain_space() const;
1981
  inline uint32_t get_hash() const;
1982
  inline space get_space() const;
1983
  inline id get_tuple_id(isl::dim type) const;
1984
  inline pw_aff gist(set context) const;
1985
  inline pw_aff gist_params(set context) const;
1986
  inline map gt_map(pw_aff pa2) const;
1987
  inline set gt_set(pw_aff pwaff2) const;
1988
  inline boolean has_dim_id(isl::dim type, unsigned int pos) const;
1989
  inline boolean has_tuple_id(isl::dim type) const;
1990
  inline pw_aff insert_dims(isl::dim type, unsigned int first, unsigned int n) const;
1991
  inline pw_aff intersect_domain(set set) const;
1992
  inline pw_aff intersect_params(set set) const;
1993
  inline boolean involves_dims(isl::dim type, unsigned int first, unsigned int n) const;
1994
  inline boolean involves_nan() const;
1995
  inline boolean is_cst() const;
1996
  inline boolean is_empty() const;
1997
  inline boolean is_equal(const pw_aff &pa2) const;
1998
  inline set le_set(pw_aff pwaff2) const;
1999
  inline map lt_map(pw_aff pa2) const;
2000
  inline set lt_set(pw_aff pwaff2) const;
2001
  inline pw_aff max(pw_aff pwaff2) const;
2002
  inline pw_aff min(pw_aff pwaff2) const;
2003
  inline pw_aff mod(val mod) const;
2004
  inline pw_aff move_dims(isl::dim dst_type, unsigned int dst_pos, isl::dim src_type, unsigned int src_pos, unsigned int n) const;
2005
  inline pw_aff mul(pw_aff pwaff2) const;
2006
  inline int n_piece() const;
2007
  static inline pw_aff nan_on_domain(local_space ls);
2008
  inline set ne_set(pw_aff pwaff2) const;
2009
  inline pw_aff neg() const;
2010
  inline set non_zero_set() const;
2011
  inline set nonneg_set() const;
2012
  inline set params() const;
2013
  inline int plain_cmp(const pw_aff &pa2) const;
2014
  inline boolean plain_is_equal(const pw_aff &pwaff2) const;
2015
  inline set pos_set() const;
2016
  inline pw_aff project_domain_on_params() const;
2017
  inline pw_aff pullback(multi_aff ma) const;
2018
  inline pw_aff pullback(pw_multi_aff pma) const;
2019
  inline pw_aff pullback(multi_pw_aff mpa) const;
2020
  inline pw_aff reset_tuple_id(isl::dim type) const;
2021
  inline pw_aff reset_user() const;
2022
  inline pw_aff scale(val v) const;
2023
  inline pw_aff scale_down(val f) const;
2024
  inline pw_aff set_dim_id(isl::dim type, unsigned int pos, id id) const;
2025
  inline pw_aff set_tuple_id(isl::dim type, id id) const;
2026
  inline pw_aff sub(pw_aff pwaff2) const;
2027
  inline pw_aff subtract_domain(set set) const;
2028
  inline pw_aff tdiv_q(pw_aff pa2) const;
2029
  inline pw_aff tdiv_r(pw_aff pa2) const;
2030
  inline pw_aff union_add(pw_aff pwaff2) const;
2031
  inline pw_aff union_max(pw_aff pwaff2) const;
2032
  inline pw_aff union_min(pw_aff pwaff2) const;
2033
  static inline pw_aff var_on_domain(local_space ls, isl::dim type, unsigned int pos);
2034
  inline set zero_set() const;
2035
};
2036
2037
// declarations for isl::pw_aff_list
2038
inline pw_aff_list manage(__isl_take isl_pw_aff_list *ptr);
2039
inline pw_aff_list manage_copy(__isl_keep isl_pw_aff_list *ptr);
2040
2041
class pw_aff_list {
2042
  friend inline pw_aff_list manage(__isl_take isl_pw_aff_list *ptr);
2043
  friend inline pw_aff_list manage_copy(__isl_keep isl_pw_aff_list *ptr);
2044
2045
  isl_pw_aff_list *ptr = nullptr;
2046
2047
  inline explicit pw_aff_list(__isl_take isl_pw_aff_list *ptr);
2048
2049
public:
2050
  inline /* implicit */ pw_aff_list();
2051
  inline /* implicit */ pw_aff_list(const pw_aff_list &obj);
2052
  inline /* implicit */ pw_aff_list(std::nullptr_t);
2053
  inline pw_aff_list &operator=(pw_aff_list obj);
2054
  inline ~pw_aff_list();
2055
  inline __isl_give isl_pw_aff_list *copy() const &;
2056
  inline __isl_give isl_pw_aff_list *copy() && = delete;
2057
  inline __isl_keep isl_pw_aff_list *get() const;
2058
  inline __isl_give isl_pw_aff_list *release();
2059
  inline bool is_null() const;
2060
  inline explicit operator bool() const;
2061
  inline ctx get_ctx() const;
2062
  inline void dump() const;
2063
2064
  inline pw_aff_list add(pw_aff el) const;
2065
  static inline pw_aff_list alloc(ctx ctx, int n);
2066
  inline pw_aff_list concat(pw_aff_list list2) const;
2067
  inline pw_aff_list drop(unsigned int first, unsigned int n) const;
2068
  inline set eq_set(pw_aff_list list2) const;
2069
  inline stat foreach(const std::function<stat(pw_aff)> &fn) const;
2070
  static inline pw_aff_list from_pw_aff(pw_aff el);
2071
  inline set ge_set(pw_aff_list list2) const;
2072
  inline pw_aff get_at(int index) const;
2073
  inline pw_aff get_pw_aff(int index) const;
2074
  inline set gt_set(pw_aff_list list2) const;
2075
  inline pw_aff_list insert(unsigned int pos, pw_aff el) const;
2076
  inline set le_set(pw_aff_list list2) const;
2077
  inline set lt_set(pw_aff_list list2) const;
2078
  inline pw_aff max() const;
2079
  inline pw_aff min() const;
2080
  inline int n_pw_aff() const;
2081
  inline set ne_set(pw_aff_list list2) const;
2082
  inline pw_aff_list reverse() const;
2083
  inline pw_aff_list set_pw_aff(int index, pw_aff el) const;
2084
  inline int size() const;
2085
  inline pw_aff_list swap(unsigned int pos1, unsigned int pos2) const;
2086
};
2087
2088
// declarations for isl::pw_multi_aff
2089
inline pw_multi_aff manage(__isl_take isl_pw_multi_aff *ptr);
2090
inline pw_multi_aff manage_copy(__isl_keep isl_pw_multi_aff *ptr);
2091
2092
class pw_multi_aff {
2093
  friend inline pw_multi_aff manage(__isl_take isl_pw_multi_aff *ptr);
2094
  friend inline pw_multi_aff manage_copy(__isl_keep isl_pw_multi_aff *ptr);
2095
2096
  isl_pw_multi_aff *ptr = nullptr;
2097
2098
  inline explicit pw_multi_aff(__isl_take isl_pw_multi_aff *ptr);
2099
2100
public:
2101
  inline /* implicit */ pw_multi_aff();
2102
  inline /* implicit */ pw_multi_aff(const pw_multi_aff &obj);
2103
  inline /* implicit */ pw_multi_aff(std::nullptr_t);
2104
  inline /* implicit */ pw_multi_aff(multi_aff ma);
2105
  inline /* implicit */ pw_multi_aff(pw_aff pa);
2106
  inline explicit pw_multi_aff(ctx ctx, const std::string &str);
2107
  inline pw_multi_aff &operator=(pw_multi_aff obj);
2108
  inline ~pw_multi_aff();
2109
  inline __isl_give isl_pw_multi_aff *copy() const &;
2110
  inline __isl_give isl_pw_multi_aff *copy() && = delete;
2111
  inline __isl_keep isl_pw_multi_aff *get() const;
2112
  inline __isl_give isl_pw_multi_aff *release();
2113
  inline bool is_null() const;
2114
  inline explicit operator bool() const;
2115
  inline ctx get_ctx() const;
2116
  inline std::string to_str() const;
2117
  inline void dump() const;
2118
2119
  inline pw_multi_aff add(pw_multi_aff pma2) const;
2120
  inline pw_multi_aff align_params(space model) const;
2121
  static inline pw_multi_aff alloc(set set, multi_aff maff);
2122
  inline pw_multi_aff coalesce() const;
2123
  inline unsigned int dim(isl::dim type) const;
2124
  inline set domain() const;
2125
  inline pw_multi_aff drop_dims(isl::dim type, unsigned int first, unsigned int n) const;
2126
  inline pw_multi_aff drop_unused_params() const;
2127
  static inline pw_multi_aff empty(space space);
2128
  inline int find_dim_by_name(isl::dim type, const std::string &name) const;
2129
  inline pw_multi_aff fix_si(isl::dim type, unsigned int pos, int value) const;
2130
  inline pw_multi_aff flat_range_product(pw_multi_aff pma2) const;
2131
  inline stat foreach_piece(const std::function<stat(set, multi_aff)> &fn) const;
2132
  static inline pw_multi_aff from_domain(set set);
2133
  static inline pw_multi_aff from_map(map map);
2134
  static inline pw_multi_aff from_multi_pw_aff(multi_pw_aff mpa);
2135
  static inline pw_multi_aff from_set(set set);
2136
  inline id get_dim_id(isl::dim type, unsigned int pos) const;
2137
  inline std::string get_dim_name(isl::dim type, unsigned int pos) const;
2138
  inline space get_domain_space() const;
2139
  inline pw_aff get_pw_aff(int pos) const;
2140
  inline space get_space() const;
2141
  inline id get_tuple_id(isl::dim type) const;
2142
  inline std::string get_tuple_name(isl::dim type) const;
2143
  inline pw_multi_aff gist(set set) const;
2144
  inline pw_multi_aff gist_params(set set) const;
2145
  inline boolean has_tuple_id(isl::dim type) const;
2146
  inline boolean has_tuple_name(isl::dim type) const;
2147
  static inline pw_multi_aff identity(space space);
2148
  inline pw_multi_aff intersect_domain(set set) const;
2149
  inline pw_multi_aff intersect_params(set set) const;
2150
  inline boolean involves_dims(isl::dim type, unsigned int first, unsigned int n) const;
2151
  inline boolean involves_nan() const;
2152
  inline boolean is_equal(const pw_multi_aff &pma2) const;
2153
  static inline pw_multi_aff multi_val_on_domain(set domain, multi_val mv);
2154
  inline int n_piece() const;
2155
  inline pw_multi_aff neg() const;
2156
  inline boolean plain_is_equal(const pw_multi_aff &pma2) const;
2157
  inline pw_multi_aff product(pw_multi_aff pma2) const;
2158
  inline pw_multi_aff project_domain_on_params() const;
2159
  static inline pw_multi_aff project_out_map(space space, isl::dim type, unsigned int first, unsigned int n);
2160
  inline pw_multi_aff pullback(multi_aff ma) const;
2161
  inline pw_multi_aff pullback(pw_multi_aff pma2) const;
2162
  static inline pw_multi_aff range_map(space space);
2163
  inline pw_multi_aff range_product(pw_multi_aff pma2) const;
2164
  inline pw_multi_aff reset_tuple_id(isl::dim type) const;
2165
  inline pw_multi_aff reset_user() const;
2166
  inline pw_multi_aff scale_down_val(val v) const;
2167
  inline pw_multi_aff scale_multi_val(multi_val mv) const;
2168
  inline pw_multi_aff scale_val(val v) const;
2169
  inline pw_multi_aff set_dim_id(isl::dim type, unsigned int pos, id id) const;
2170
  inline pw_multi_aff set_pw_aff(unsigned int pos, pw_aff pa) const;
2171
  inline pw_multi_aff set_tuple_id(isl::dim type, id id) const;
2172
  inline pw_multi_aff sub(pw_multi_aff pma2) const;
2173
  inline pw_multi_aff subtract_domain(set set) const;
2174
  inline pw_multi_aff union_add(pw_multi_aff pma2) const;
2175
  inline pw_multi_aff union_lexmax(pw_multi_aff pma2) const;
2176
  inline pw_multi_aff union_lexmin(pw_multi_aff pma2) const;
2177
  static inline pw_multi_aff zero(space space);
2178
};
2179
2180
// declarations for isl::pw_multi_aff_list
2181
inline pw_multi_aff_list manage(__isl_take isl_pw_multi_aff_list *ptr);
2182
inline pw_multi_aff_list manage_copy(__isl_keep isl_pw_multi_aff_list *ptr);
2183
2184
class pw_multi_aff_list {
2185
  friend inline pw_multi_aff_list manage(__isl_take isl_pw_multi_aff_list *ptr);
2186
  friend inline pw_multi_aff_list manage_copy(__isl_keep isl_pw_multi_aff_list *ptr);
2187
2188
  isl_pw_multi_aff_list *ptr = nullptr;
2189
2190
  inline explicit pw_multi_aff_list(__isl_take isl_pw_multi_aff_list *ptr);
2191
2192
public:
2193
  inline /* implicit */ pw_multi_aff_list();
2194
  inline /* implicit */ pw_multi_aff_list(const pw_multi_aff_list &obj);
2195
  inline /* implicit */ pw_multi_aff_list(std::nullptr_t);
2196
  inline pw_multi_aff_list &operator=(pw_multi_aff_list obj);
2197
  inline ~pw_multi_aff_list();
2198
  inline __isl_give isl_pw_multi_aff_list *copy() const &;
2199
  inline __isl_give isl_pw_multi_aff_list *copy() && = delete;
2200
  inline __isl_keep isl_pw_multi_aff_list *get() const;
2201
  inline __isl_give isl_pw_multi_aff_list *release();
2202
  inline bool is_null() const;
2203
  inline explicit operator bool() const;
2204
  inline ctx get_ctx() const;
2205
  inline void dump() const;
2206
2207
  inline pw_multi_aff_list add(pw_multi_aff el) const;
2208
  static inline pw_multi_aff_list alloc(ctx ctx, int n);
2209
  inline pw_multi_aff_list concat(pw_multi_aff_list list2) const;
2210
  inline pw_multi_aff_list drop(unsigned int first, unsigned int n) const;
2211
  inline stat foreach(const std::function<stat(pw_multi_aff)> &fn) const;
2212
  static inline pw_multi_aff_list from_pw_multi_aff(pw_multi_aff el);
2213
  inline pw_multi_aff get_at(int index) const;
2214
  inline pw_multi_aff get_pw_multi_aff(int index) const;
2215
  inline pw_multi_aff_list insert(unsigned int pos, pw_multi_aff el) const;
2216
  inline int n_pw_multi_aff() const;
2217
  inline pw_multi_aff_list reverse() const;
2218
  inline pw_multi_aff_list set_pw_multi_aff(int index, pw_multi_aff el) const;
2219
  inline int size() const;
2220
  inline pw_multi_aff_list swap(unsigned int pos1, unsigned int pos2) const;
2221
};
2222
2223
// declarations for isl::pw_qpolynomial
2224
inline pw_qpolynomial manage(__isl_take isl_pw_qpolynomial *ptr);
2225
inline pw_qpolynomial manage_copy(__isl_keep isl_pw_qpolynomial *ptr);
2226
2227
class pw_qpolynomial {
2228
  friend inline pw_qpolynomial manage(__isl_take isl_pw_qpolynomial *ptr);
2229
  friend inline pw_qpolynomial manage_copy(__isl_keep isl_pw_qpolynomial *ptr);
2230
2231
  isl_pw_qpolynomial *ptr = nullptr;
2232
2233
  inline explicit pw_qpolynomial(__isl_take isl_pw_qpolynomial *ptr);
2234
2235
public:
2236
  inline /* implicit */ pw_qpolynomial();
2237
  inline /* implicit */ pw_qpolynomial(const pw_qpolynomial &obj);
2238
  inline /* implicit */ pw_qpolynomial(std::nullptr_t);
2239
  inline explicit pw_qpolynomial(ctx ctx, const std::string &str);
2240
  inline pw_qpolynomial &operator=(pw_qpolynomial obj);
2241
  inline ~pw_qpolynomial();
2242
  inline __isl_give isl_pw_qpolynomial *copy() const &;
2243
  inline __isl_give isl_pw_qpolynomial *copy() && = delete;
2244
  inline __isl_keep isl_pw_qpolynomial *get() const;
2245
  inline __isl_give isl_pw_qpolynomial *release();
2246
  inline bool is_null() const;
2247
  inline explicit operator bool() const;
2248
  inline ctx get_ctx() const;
2249
  inline std::string to_str() const;
2250
  inline void dump() const;
2251
2252
  inline pw_qpolynomial add(pw_qpolynomial pwqp2) const;
2253
  inline pw_qpolynomial add_dims(isl::dim type, unsigned int n) const;
2254
  static inline pw_qpolynomial alloc(set set, qpolynomial qp);
2255
  inline pw_qpolynomial coalesce() const;
2256
  inline unsigned int dim(isl::dim type) const;
2257
  inline set domain() const;
2258
  inline pw_qpolynomial drop_dims(isl::dim type, unsigned int first, unsigned int n) const;
2259
  inline pw_qpolynomial drop_unused_params() const;
2260
  inline val eval(point pnt) const;
2261
  inline int find_dim_by_name(isl::dim type, const std::string &name) const;
2262
  inline pw_qpolynomial fix_val(isl::dim type, unsigned int n, val v) const;
2263
  inline stat foreach_piece(const std::function<stat(set, qpolynomial)> &fn) const;
2264
  static inline pw_qpolynomial from_pw_aff(pw_aff pwaff);
2265
  static inline pw_qpolynomial from_qpolynomial(qpolynomial qp);
2266
  inline pw_qpolynomial from_range() const;
2267
  inline space get_domain_space() const;
2268
  inline space get_space() const;
2269
  inline pw_qpolynomial gist(set context) const;
2270
  inline pw_qpolynomial gist_params(set context) const;
2271
  inline boolean has_equal_space(const pw_qpolynomial &pwqp2) const;
2272
  inline pw_qpolynomial insert_dims(isl::dim type, unsigned int first, unsigned int n) const;
2273
  inline pw_qpolynomial intersect_domain(set set) const;
2274
  inline pw_qpolynomial intersect_params(set set) const;
2275
  inline boolean involves_dims(isl::dim type, unsigned int first, unsigned int n) const;
2276
  inline boolean involves_nan() const;
2277
  inline boolean is_zero() const;
2278
  inline val max() const;
2279
  inline val min() const;
2280
  inline pw_qpolynomial move_dims(isl::dim dst_type, unsigned int dst_pos, isl::dim src_type, unsigned int src_pos, unsigned int n) const;
2281
  inline pw_qpolynomial mul(pw_qpolynomial pwqp2) const;
2282
  inline int n_piece() const;
2283
  inline pw_qpolynomial neg() const;
2284
  inline boolean plain_is_equal(const pw_qpolynomial &pwqp2) const;
2285
  inline pw_qpolynomial pow(unsigned int exponent) const;
2286
  inline pw_qpolynomial project_domain_on_params() const;
2287
  inline pw_qpolynomial reset_domain_space(space dim) const;
2288
  inline pw_qpolynomial reset_user() const;
2289
  inline pw_qpolynomial scale_down_val(val v) const;
2290
  inline pw_qpolynomial scale_val(val v) const;
2291
  inline pw_qpolynomial split_dims(isl::dim type, unsigned int first, unsigned int n) const;
2292
  inline pw_qpolynomial split_periods(int max_periods) const;
2293
  inline pw_qpolynomial sub(pw_qpolynomial pwqp2) const;
2294
  inline pw_qpolynomial subtract_domain(set set) const;
2295
  inline pw_qpolynomial to_polynomial(int sign) const;
2296
  static inline pw_qpolynomial zero(space dim);
2297
};
2298
2299
// declarations for isl::pw_qpolynomial_fold_list
2300
inline pw_qpolynomial_fold_list manage(__isl_take isl_pw_qpolynomial_fold_list *ptr);
2301
inline pw_qpolynomial_fold_list manage_copy(__isl_keep isl_pw_qpolynomial_fold_list *ptr);
2302
2303
class pw_qpolynomial_fold_list {
2304
  friend inline pw_qpolynomial_fold_list manage(__isl_take isl_pw_qpolynomial_fold_list *ptr);
2305
  friend inline pw_qpolynomial_fold_list manage_copy(__isl_keep isl_pw_qpolynomial_fold_list *ptr);
2306
2307
  isl_pw_qpolynomial_fold_list *ptr = nullptr;
2308
2309
  inline explicit pw_qpolynomial_fold_list(__isl_take isl_pw_qpolynomial_fold_list *ptr);
2310
2311
public:
2312
  inline /* implicit */ pw_qpolynomial_fold_list();
2313
  inline /* implicit */ pw_qpolynomial_fold_list(const pw_qpolynomial_fold_list &obj);
2314
  inline /* implicit */ pw_qpolynomial_fold_list(std::nullptr_t);
2315
  inline pw_qpolynomial_fold_list &operator=(pw_qpolynomial_fold_list obj);
2316
  inline ~pw_qpolynomial_fold_list();
2317
  inline __isl_give isl_pw_qpolynomial_fold_list *copy() const &;
2318
  inline __isl_give isl_pw_qpolynomial_fold_list *copy() && = delete;
2319
  inline __isl_keep isl_pw_qpolynomial_fold_list *get() const;
2320
  inline __isl_give isl_pw_qpolynomial_fold_list *release();
2321
  inline bool is_null() const;
2322
  inline explicit operator bool() const;
2323
  inline ctx get_ctx() const;
2324
  inline void dump() const;
2325
2326
};
2327
2328
// declarations for isl::pw_qpolynomial_list
2329
inline pw_qpolynomial_list manage(__isl_take isl_pw_qpolynomial_list *ptr);
2330
inline pw_qpolynomial_list manage_copy(__isl_keep isl_pw_qpolynomial_list *ptr);
2331
2332
class pw_qpolynomial_list {
2333
  friend inline pw_qpolynomial_list manage(__isl_take isl_pw_qpolynomial_list *ptr);
2334
  friend inline pw_qpolynomial_list manage_copy(__isl_keep isl_pw_qpolynomial_list *ptr);
2335
2336
  isl_pw_qpolynomial_list *ptr = nullptr;
2337
2338
  inline explicit pw_qpolynomial_list(__isl_take isl_pw_qpolynomial_list *ptr);
2339
2340
public:
2341
  inline /* implicit */ pw_qpolynomial_list();
2342
  inline /* implicit */ pw_qpolynomial_list(const pw_qpolynomial_list &obj);
2343
  inline /* implicit */ pw_qpolynomial_list(std::nullptr_t);
2344
  inline pw_qpolynomial_list &operator=(pw_qpolynomial_list obj);
2345
  inline ~pw_qpolynomial_list();
2346
  inline __isl_give isl_pw_qpolynomial_list *copy() const &;
2347
  inline __isl_give isl_pw_qpolynomial_list *copy() && = delete;
2348
  inline __isl_keep isl_pw_qpolynomial_list *get() const;
2349
  inline __isl_give isl_pw_qpolynomial_list *release();
2350
  inline bool is_null() const;
2351
  inline explicit operator bool() const;
2352
  inline ctx get_ctx() const;
2353
  inline void dump() const;
2354
2355
  inline pw_qpolynomial_list add(pw_qpolynomial el) const;
2356
  static inline pw_qpolynomial_list alloc(ctx ctx, int n);
2357
  inline pw_qpolynomial_list concat(pw_qpolynomial_list list2) const;
2358
  inline pw_qpolynomial_list drop(unsigned int first, unsigned int n) const;
2359
  inline stat foreach(const std::function<stat(pw_qpolynomial)> &fn) const;
2360
  static inline pw_qpolynomial_list from_pw_qpolynomial(pw_qpolynomial el);
2361
  inline pw_qpolynomial get_at(int index) const;
2362
  inline pw_qpolynomial get_pw_qpolynomial(int index) const;
2363
  inline pw_qpolynomial_list insert(unsigned int pos, pw_qpolynomial el) const;
2364
  inline int n_pw_qpolynomial() const;
2365
  inline pw_qpolynomial_list reverse() const;
2366
  inline pw_qpolynomial_list set_pw_qpolynomial(int index, pw_qpolynomial el) const;
2367
  inline int size() const;
2368
  inline pw_qpolynomial_list swap(unsigned int pos1, unsigned int pos2) const;
2369
};
2370
2371
// declarations for isl::qpolynomial
2372
inline qpolynomial manage(__isl_take isl_qpolynomial *ptr);
2373
inline qpolynomial manage_copy(__isl_keep isl_qpolynomial *ptr);
2374
2375
class qpolynomial {
2376
  friend inline qpolynomial manage(__isl_take isl_qpolynomial *ptr);
2377
  friend inline qpolynomial manage_copy(__isl_keep isl_qpolynomial *ptr);
2378
2379
  isl_qpolynomial *ptr = nullptr;
2380
2381
  inline explicit qpolynomial(__isl_take isl_qpolynomial *ptr);
2382
2383
public:
2384
  inline /* implicit */ qpolynomial();
2385
  inline /* implicit */ qpolynomial(const qpolynomial &obj);
2386
  inline /* implicit */ qpolynomial(std::nullptr_t);
2387
  inline qpolynomial &operator=(qpolynomial obj);
2388
  inline ~qpolynomial();
2389
  inline __isl_give isl_qpolynomial *copy() const &;
2390
  inline __isl_give isl_qpolynomial *copy() && = delete;
2391
  inline __isl_keep isl_qpolynomial *get() const;
2392
  inline __isl_give isl_qpolynomial *release();
2393
  inline bool is_null() const;
2394
  inline explicit operator bool() const;
2395
  inline ctx get_ctx() const;
2396
  inline void dump() const;
2397
2398
  inline qpolynomial add(qpolynomial qp2) const;
2399
  inline qpolynomial add_dims(isl::dim type, unsigned int n) const;
2400
  inline qpolynomial align_params(space model) const;
2401
  inline stat as_polynomial_on_domain(const basic_set &bset, const std::function<stat(basic_set, qpolynomial)> &fn) const;
2402
  inline unsigned int dim(isl::dim type) const;
2403
  inline qpolynomial drop_dims(isl::dim type, unsigned int first, unsigned int n) const;
2404
  inline val eval(point pnt) const;
2405
  inline stat foreach_term(const std::function<stat(term)> &fn) const;
2406
  static inline qpolynomial from_aff(aff aff);
2407
  static inline qpolynomial from_constraint(constraint c, isl::dim type, unsigned int pos);
2408
  static inline qpolynomial from_term(term term);
2409
  inline val get_constant_val() const;
2410
  inline space get_domain_space() const;
2411
  inline space get_space() const;
2412
  inline qpolynomial gist(set context) const;
2413
  inline qpolynomial gist_params(set context) const;
2414
  inline qpolynomial homogenize() const;
2415
  static inline qpolynomial infty_on_domain(space dim);
2416
  inline qpolynomial insert_dims(isl::dim type, unsigned int first, unsigned int n) const;
2417
  inline boolean involves_dims(isl::dim type, unsigned int first, unsigned int n) const;
2418
  inline boolean is_infty() const;
2419
  inline boolean is_nan() const;
2420
  inline boolean is_neginfty() const;
2421
  inline boolean is_zero() const;
2422
  inline qpolynomial move_dims(isl::dim dst_type, unsigned int dst_pos, isl::dim src_type, unsigned int src_pos, unsigned int n) const;
2423
  inline qpolynomial mul(qpolynomial qp2) const;
2424
  static inline qpolynomial nan_on_domain(space dim);
2425
  inline qpolynomial neg() const;
2426
  static inline qpolynomial neginfty_on_domain(space dim);
2427
  static inline qpolynomial one_on_domain(space dim);
2428
  inline boolean plain_is_equal(const qpolynomial &qp2) const;
2429
  inline qpolynomial pow(unsigned int power) const;
2430
  inline qpolynomial project_domain_on_params() const;
2431
  inline qpolynomial scale_down_val(val v) const;
2432
  inline qpolynomial scale_val(val v) const;
2433
  inline int sgn() const;
2434
  inline qpolynomial sub(qpolynomial qp2) const;
2435
  static inline qpolynomial val_on_domain(space space, val val);
2436
  static inline qpolynomial var_on_domain(space dim, isl::dim type, unsigned int pos);
2437
  static inline qpolynomial zero_on_domain(space dim);
2438
};
2439
2440
// declarations for isl::schedule
2441
inline schedule manage(__isl_take isl_schedule *ptr);
2442
inline schedule manage_copy(__isl_keep isl_schedule *ptr);
2443
2444
class schedule {
2445
  friend inline schedule manage(__isl_take isl_schedule *ptr);
2446
  friend inline schedule manage_copy(__isl_keep isl_schedule *ptr);
2447
2448
  isl_schedule *ptr = nullptr;
2449
2450
  inline explicit schedule(__isl_take isl_schedule *ptr);
2451
2452
public:
2453
  inline /* implicit */ schedule();
2454
  inline /* implicit */ schedule(const schedule &obj);
2455
  inline /* implicit */ schedule(std::nullptr_t);
2456
  inline explicit schedule(ctx ctx, const std::string &str);
2457
  inline schedule &operator=(schedule obj);
2458
  inline ~schedule();
2459
  inline __isl_give isl_schedule *copy() const &;
2460
  inline __isl_give isl_schedule *copy() && = delete;
2461
  inline __isl_keep isl_schedule *get() const;
2462
  inline __isl_give isl_schedule *release();
2463
  inline bool is_null() const;
2464
  inline explicit operator bool() const;
2465
  inline ctx get_ctx() const;
2466
  inline std::string to_str() const;
2467
  inline void dump() const;
2468
2469
  inline schedule align_params(space space) const;
2470
  static inline schedule empty(space space);
2471
  static inline schedule from_domain(union_set domain);
2472
  inline union_set get_domain() const;
2473
  inline union_map get_map() const;
2474
  inline schedule_node get_root() const;
2475
  inline schedule gist_domain_params(set context) const;
2476
  inline schedule insert_context(set context) const;
2477
  inline schedule insert_guard(set guard) const;
2478
  inline schedule insert_partial_schedule(multi_union_pw_aff partial) const;
2479
  inline schedule intersect_domain(union_set domain) const;
2480
  inline boolean plain_is_equal(const schedule &schedule2) const;
2481
  inline schedule pullback(union_pw_multi_aff upma) const;
2482
  inline schedule reset_user() const;
2483
  inline schedule sequence(schedule schedule2) const;
2484
};
2485
2486
// declarations for isl::schedule_constraints
2487
inline schedule_constraints manage(__isl_take isl_schedule_constraints *ptr);
2488
inline schedule_constraints manage_copy(__isl_keep isl_schedule_constraints *ptr);
2489
2490
class schedule_constraints {
2491
  friend inline schedule_constraints manage(__isl_take isl_schedule_constraints *ptr);
2492
  friend inline schedule_constraints manage_copy(__isl_keep isl_schedule_constraints *ptr);
2493
2494
  isl_schedule_constraints *ptr = nullptr;
2495
2496
  inline explicit schedule_constraints(__isl_take isl_schedule_constraints *ptr);
2497
2498
public:
2499
  inline /* implicit */ schedule_constraints();
2500
  inline /* implicit */ schedule_constraints(const schedule_constraints &obj);
2501
  inline /* implicit */ schedule_constraints(std::nullptr_t);
2502
  inline explicit schedule_constraints(ctx ctx, const std::string &str);
2503
  inline schedule_constraints &operator=(schedule_constraints obj);
2504
  inline ~schedule_constraints();
2505
  inline __isl_give isl_schedule_constraints *copy() const &;
2506
  inline __isl_give isl_schedule_constraints *copy() && = delete;
2507
  inline __isl_keep isl_schedule_constraints *get() const;
2508
  inline __isl_give isl_schedule_constraints *release();
2509
  inline bool is_null() const;
2510
  inline explicit operator bool() const;
2511
  inline ctx get_ctx() const;
2512
  inline std::string to_str() const;
2513
  inline void dump() const;
2514
2515
  inline schedule_constraints apply(union_map umap) const;
2516
  inline schedule compute_schedule() const;
2517
  inline union_map get_coincidence() const;
2518
  inline union_map get_conditional_validity() const;
2519
  inline union_map get_conditional_validity_condition() const;
2520
  inline set get_context() const;
2521
  inline union_set get_domain() const;
2522
  inline union_map get_proximity() const;
2523
  inline union_map get_validity() const;
2524
  static inline schedule_constraints on_domain(union_set domain);
2525
  inline schedule_constraints set_coincidence(union_map coincidence) const;
2526
  inline schedule_constraints set_conditional_validity(union_map condition, union_map validity) const;
2527
  inline schedule_constraints set_context(set context) const;
2528
  inline schedule_constraints set_proximity(union_map proximity) const;
2529
  inline schedule_constraints set_validity(union_map validity) const;
2530
};
2531
2532
// declarations for isl::schedule_node
2533
inline schedule_node manage(__isl_take isl_schedule_node *ptr);
2534
inline schedule_node manage_copy(__isl_keep isl_schedule_node *ptr);
2535
2536
class schedule_node {
2537
  friend inline schedule_node manage(__isl_take isl_schedule_node *ptr);
2538
  friend inline schedule_node manage_copy(__isl_keep isl_schedule_node *ptr);
2539
2540
  isl_schedule_node *ptr = nullptr;
2541
2542
  inline explicit schedule_node(__isl_take isl_schedule_node *ptr);
2543
2544
public:
2545
  inline /* implicit */ schedule_node();
2546
  inline /* implicit */ schedule_node(const schedule_node &obj);
2547
  inline /* implicit */ schedule_node(std::nullptr_t);
2548
  inline schedule_node &operator=(schedule_node obj);
2549
  inline ~schedule_node();
2550
  inline __isl_give isl_schedule_node *copy() const &;
2551
  inline __isl_give isl_schedule_node *copy() && = delete;
2552
  inline __isl_keep isl_schedule_node *get() const;
2553
  inline __isl_give isl_schedule_node *release();
2554
  inline bool is_null() const;
2555
  inline explicit operator bool() const;
2556
  inline ctx get_ctx() const;
2557
  inline std::string to_str() const;
2558
  inline void dump() const;
2559
2560
  inline schedule_node align_params(space space) const;
2561
  inline schedule_node ancestor(int generation) const;
2562
  inline boolean band_member_get_coincident(int pos) const;
2563
  inline schedule_node band_member_set_coincident(int pos, int coincident) const;
2564
  inline schedule_node band_set_ast_build_options(union_set options) const;
2565
  inline schedule_node child(int pos) const;
2566
  inline set context_get_context() const;
2567
  inline schedule_node cut() const;
2568
  inline union_set domain_get_domain() const;
2569
  inline union_pw_multi_aff expansion_get_contraction() const;
2570
  inline union_map expansion_get_expansion() const;
2571
  inline union_map extension_get_extension() const;
2572
  inline union_set filter_get_filter() const;
2573
  inline schedule_node first_child() const;
2574
  inline stat foreach_ancestor_top_down(const std::function<stat(schedule_node)> &fn) const;
2575
  static inline schedule_node from_domain(union_set domain);
2576
  static inline schedule_node from_extension(union_map extension);
2577
  inline int get_ancestor_child_position(const schedule_node &ancestor) const;
2578
  inline schedule_node get_child(int pos) const;
2579
  inline int get_child_position() const;
2580
  inline union_set get_domain() const;
2581
  inline multi_union_pw_aff get_prefix_schedule_multi_union_pw_aff() const;
2582
  inline union_map get_prefix_schedule_relation() const;
2583
  inline union_map get_prefix_schedule_union_map() const;
2584
  inline union_pw_multi_aff get_prefix_schedule_union_pw_multi_aff() const;
2585
  inline schedule get_schedule() const;
2586
  inline int get_schedule_depth() const;
2587
  inline schedule_node get_shared_ancestor(const schedule_node &node2) const;
2588
  inline union_pw_multi_aff get_subtree_contraction() const;
2589
  inline union_map get_subtree_expansion() const;
2590
  inline union_map get_subtree_schedule_union_map() const;
2591
  inline int get_tree_depth() const;
2592
  inline union_set get_universe_domain() const;
2593
  inline schedule_node graft_after(schedule_node graft) const;
2594
  inline schedule_node graft_before(schedule_node graft) const;
2595
  inline schedule_node group(id group_id) const;
2596
  inline set guard_get_guard() const;
2597
  inline boolean has_children() const;
2598
  inline boolean has_next_sibling() const;
2599
  inline boolean has_parent() const;
2600
  inline boolean has_previous_sibling() const;
2601
  inline schedule_node insert_context(set context) const;
2602
  inline schedule_node insert_filter(union_set filter) const;
2603
  inline schedule_node insert_guard(set context) const;
2604
  inline schedule_node insert_mark(id mark) const;
2605
  inline schedule_node insert_partial_schedule(multi_union_pw_aff schedule) const;
2606
  inline schedule_node insert_sequence(union_set_list filters) const;
2607
  inline schedule_node insert_set(union_set_list filters) const;
2608
  inline boolean is_equal(const schedule_node &node2) const;
2609
  inline boolean is_subtree_anchored() const;
2610
  inline id mark_get_id() const;
2611
  inline int n_children() const;
2612
  inline schedule_node next_sibling() const;
2613
  inline schedule_node order_after(union_set filter) const;
2614
  inline schedule_node order_before(union_set filter) const;
2615
  inline schedule_node parent() const;
2616
  inline schedule_node previous_sibling() const;
2617
  inline schedule_node reset_user() const;
2618
  inline schedule_node root() const;
2619
  inline schedule_node sequence_splice_child(int pos) const;
2620
};
2621
2622
// declarations for isl::set
2623
inline set manage(__isl_take isl_set *ptr);
2624
inline set manage_copy(__isl_keep isl_set *ptr);
2625
2626
class set {
2627
  friend inline set manage(__isl_take isl_set *ptr);
2628
  friend inline set manage_copy(__isl_keep isl_set *ptr);
2629
2630
  isl_set *ptr = nullptr;
2631
2632
  inline explicit set(__isl_take isl_set *ptr);
2633
2634
public:
2635
  inline /* implicit */ set();
2636
  inline /* implicit */ set(const set &obj);
2637
  inline /* implicit */ set(std::nullptr_t);
2638
  inline explicit set(ctx ctx, const std::string &str);
2639
  inline /* implicit */ set(basic_set bset);
2640
  inline /* implicit */ set(point pnt);
2641
  inline explicit set(union_set uset);
2642
  inline set &operator=(set obj);
2643
  inline ~set();
2644
  inline __isl_give isl_set *copy() const &;
2645
  inline __isl_give isl_set *copy() && = delete;
2646
  inline __isl_keep isl_set *get() const;
2647
  inline __isl_give isl_set *release();
2648
  inline bool is_null() const;
2649
  inline explicit operator bool() const;
2650
  inline ctx get_ctx() const;
2651
  inline std::string to_str() const;
2652
  inline void dump() const;
2653
2654
  inline set add_constraint(constraint constraint) const;
2655
  inline set add_dims(isl::dim type, unsigned int n) const;
2656
  inline basic_set affine_hull() const;
2657
  inline set align_params(space model) const;
2658
  inline set apply(map map) const;
2659
  inline basic_set bounded_simple_hull() const;
2660
  static inline set box_from_points(point pnt1, point pnt2);
2661
  inline set coalesce() const;
2662
  inline basic_set coefficients() const;
2663
  inline set complement() const;
2664
  inline basic_set convex_hull() const;
2665
  inline val count_val() const;
2666
  inline set detect_equalities() const;
2667
  inline unsigned int dim(isl::dim type) const;
2668
  inline boolean dim_has_any_lower_bound(isl::dim type, unsigned int pos) const;
2669
  inline boolean dim_has_any_upper_bound(isl::dim type, unsigned int pos) const;
2670
  inline boolean dim_has_lower_bound(isl::dim type, unsigned int pos) const;
2671
  inline boolean dim_has_upper_bound(isl::dim type, unsigned int pos) const;
2672
  inline boolean dim_is_bounded(isl::dim type, unsigned int pos) const;
2673
  inline pw_aff dim_max(int pos) const;
2674
  inline pw_aff dim_min(int pos) const;
2675
  inline set drop_constraints_involving_dims(isl::dim type, unsigned int first, unsigned int n) const;
2676
  inline set drop_constraints_not_involving_dims(isl::dim type, unsigned int first, unsigned int n) const;
2677
  inline set drop_unused_params() const;
2678
  inline set eliminate(isl::dim type, unsigned int first, unsigned int n) const;
2679
  static inline set empty(space space);
2680
  inline set equate(isl::dim type1, int pos1, isl::dim type2, int pos2) const;
2681
  inline int find_dim_by_id(isl::dim type, const id &id) const;
2682
  inline int find_dim_by_name(isl::dim type, const std::string &name) const;
2683
  inline set fix_si(isl::dim type, unsigned int pos, int value) const;
2684
  inline set fix_val(isl::dim type, unsigned int pos, val v) const;
2685
  inline set flat_product(set set2) const;
2686
  inline set flatten() const;
2687
  inline map flatten_map() const;
2688
  inline int follows_at(const set &set2, int pos) const;
2689
  inline stat foreach_basic_set(const std::function<stat(basic_set)> &fn) const;
2690
  inline stat foreach_point(const std::function<stat(point)> &fn) const;
2691
  static inline set from_multi_aff(multi_aff ma);
2692
  static inline set from_multi_pw_aff(multi_pw_aff mpa);
2693
  inline set from_params() const;
2694
  static inline set from_pw_aff(pw_aff pwaff);
2695
  static inline set from_pw_multi_aff(pw_multi_aff pma);
2696
  inline basic_set_list get_basic_set_list() const;
2697
  inline id get_dim_id(isl::dim type, unsigned int pos) const;
2698
  inline std::string get_dim_name(isl::dim type, unsigned int pos) const;
2699
  inline space get_space() const;
2700
  inline val get_stride(int pos) const;
2701
  inline id get_tuple_id() const;
2702
  inline std::string get_tuple_name() const;
2703
  inline set gist(set context) const;
2704
  inline set gist_basic_set(basic_set context) const;
2705
  inline set gist_params(set context) const;
2706
  inline boolean has_dim_id(isl::dim type, unsigned int pos) const;
2707
  inline boolean has_dim_name(isl::dim type, unsigned int pos) const;
2708
  inline boolean has_equal_space(const set &set2) const;
2709
  inline boolean has_tuple_id() const;
2710
  inline boolean has_tuple_name() const;
2711
  inline map identity() const;
2712
  inline pw_aff indicator_function() const;
2713
  inline set insert_dims(isl::dim type, unsigned int pos, unsigned int n) const;
2714
  inline set intersect(set set2) const;
2715
  inline set intersect_params(set params) const;
2716
  inline boolean involves_dims(isl::dim type, unsigned int first, unsigned int n) const;
2717
  inline boolean is_bounded() const;
2718
  inline boolean is_box() const;
2719
  inline boolean is_disjoint(const set &set2) const;
2720
  inline boolean is_empty() const;
2721
  inline boolean is_equal(const set &set2) const;
2722
  inline boolean is_params() const;
2723
  inline boolean is_singleton() const;
2724
  inline boolean is_strict_subset(const set &set2) const;
2725
  inline boolean is_subset(const set &set2) const;
2726
  inline boolean is_wrapping() const;
2727
  inline map lex_ge_set(set set2) const;
2728
  inline map lex_gt_set(set set2) const;
2729
  inline map lex_le_set(set set2) const;
2730
  inline map lex_lt_set(set set2) const;
2731
  inline set lexmax() const;
2732
  inline pw_multi_aff lexmax_pw_multi_aff() const;
2733
  inline set lexmin() const;
2734
  inline pw_multi_aff lexmin_pw_multi_aff() const;
2735
  inline set lower_bound_si(isl::dim type, unsigned int pos, int value) const;
2736
  inline set lower_bound_val(isl::dim type, unsigned int pos, val value) const;
2737
  inline val max_val(const aff &obj) const;
2738
  inline val min_val(const aff &obj) const;
2739
  inline set move_dims(isl::dim dst_type, unsigned int dst_pos, isl::dim src_type, unsigned int src_pos, unsigned int n) const;
2740
  inline int n_basic_set() const;
2741
  inline unsigned int n_dim() const;
2742
  static inline set nat_universe(space dim);
2743
  inline set neg() const;
2744
  inline set params() const;
2745
  inline int plain_cmp(const set &set2) const;
2746
  inline val plain_get_val_if_fixed(isl::dim type, unsigned int pos) const;
2747
  inline boolean plain_is_disjoint(const set &set2) const;
2748
  inline boolean plain_is_empty() const;
2749
  inline boolean plain_is_equal(const set &set2) const;
2750
  inline boolean plain_is_universe() const;
2751
  inline basic_set plain_unshifted_simple_hull() const;
2752
  inline basic_set polyhedral_hull() const;
2753
  inline set preimage_multi_aff(multi_aff ma) const;
2754
  inline set preimage_multi_pw_aff(multi_pw_aff mpa) const;
2755
  inline set preimage_pw_multi_aff(pw_multi_aff pma) const;
2756
  inline set product(set set2) const;
2757
  inline map project_onto_map(isl::dim type, unsigned int first, unsigned int n) const;
2758
  inline set project_out(isl::dim type, unsigned int first, unsigned int n) const;
2759
  inline set remove_dims(isl::dim type, unsigned int first, unsigned int n) const;
2760
  inline set remove_divs() const;
2761
  inline set remove_divs_involving_dims(isl::dim type, unsigned int first, unsigned int n) const;
2762
  inline set remove_redundancies() const;
2763
  inline set remove_unknown_divs() const;
2764
  inline set reset_space(space dim) const;
2765
  inline set reset_tuple_id() const;
2766
  inline set reset_user() const;
2767
  inline basic_set sample() const;
2768
  inline point sample_point() const;
2769
  inline set set_dim_id(isl::dim type, unsigned int pos, id id) const;
2770
  inline set set_tuple_id(id id) const;
2771
  inline set set_tuple_name(const std::string &s) const;
2772
  inline basic_set simple_hull() const;
2773
  inline int size() const;
2774
  inline basic_set solutions() const;
2775
  inline set split_dims(isl::dim type, unsigned int first, unsigned int n) const;
2776
  inline set subtract(set set2) const;
2777
  inline set sum(set set2) const;
2778
  inline set unite(set set2) const;
2779
  static inline set universe(space space);
2780
  inline basic_set unshifted_simple_hull() const;
2781
  inline basic_set unshifted_simple_hull_from_set_list(set_list list) const;
2782
  inline map unwrap() const;
2783
  inline set upper_bound_si(isl::dim type, unsigned int pos, int value) const;
2784
  inline set upper_bound_val(isl::dim type, unsigned int pos, val value) const;
2785
  inline map wrapped_domain_map() const;
2786
};
2787
2788
// declarations for isl::set_list
2789
inline set_list manage(__isl_take isl_set_list *ptr);
2790
inline set_list manage_copy(__isl_keep isl_set_list *ptr);
2791
2792
class set_list {
2793
  friend inline set_list manage(__isl_take isl_set_list *ptr);
2794
  friend inline set_list manage_copy(__isl_keep isl_set_list *ptr);
2795
2796
  isl_set_list *ptr = nullptr;
2797
2798
  inline explicit set_list(__isl_take isl_set_list *ptr);
2799
2800
public:
2801
  inline /* implicit */ set_list();
2802
  inline /* implicit */ set_list(const set_list &obj);
2803
  inline /* implicit */ set_list(std::nullptr_t);
2804
  inline set_list &operator=(set_list obj);
2805
  inline ~set_list();
2806
  inline __isl_give isl_set_list *copy() const &;
2807
  inline __isl_give isl_set_list *copy() && = delete;
2808
  inline __isl_keep isl_set_list *get() const;
2809
  inline __isl_give isl_set_list *release();
2810
  inline bool is_null() const;
2811
  inline explicit operator bool() const;
2812
  inline ctx get_ctx() const;
2813
  inline void dump() const;
2814
2815
  inline set_list add(set el) const;
2816
  static inline set_list alloc(ctx ctx, int n);
2817
  inline set_list concat(set_list list2) const;
2818
  inline set_list drop(unsigned int first, unsigned int n) const;
2819
  inline stat foreach(const std::function<stat(set)> &fn) const;
2820
  static inline set_list from_set(set el);
2821
  inline set get_at(int index) const;
2822
  inline set get_set(int index) const;
2823
  inline set_list insert(unsigned int pos, set el) const;
2824
  inline int n_set() const;
2825
  inline set_list reverse() const;
2826
  inline set_list set_set(int index, set el) const;
2827
  inline int size() const;
2828
  inline set_list swap(unsigned int pos1, unsigned int pos2) const;
2829
  inline set unite() const;
2830
};
2831
2832
// declarations for isl::space
2833
inline space manage(__isl_take isl_space *ptr);
2834
inline space manage_copy(__isl_keep isl_space *ptr);
2835
2836
class space {
2837
  friend inline space manage(__isl_take isl_space *ptr);
2838
  friend inline space manage_copy(__isl_keep isl_space *ptr);
2839
2840
  isl_space *ptr = nullptr;
2841
2842
  inline explicit space(__isl_take isl_space *ptr);
2843
2844
public:
2845
  inline /* implicit */ space();
2846
  inline /* implicit */ space(const space &obj);
2847
  inline /* implicit */ space(std::nullptr_t);
2848
  inline explicit space(ctx ctx, unsigned int nparam, unsigned int n_in, unsigned int n_out);
2849
  inline explicit space(ctx ctx, unsigned int nparam, unsigned int dim);
2850
  inline space &operator=(space obj);
2851
  inline ~space();
2852
  inline __isl_give isl_space *copy() const &;
2853
  inline __isl_give isl_space *copy() && = delete;
2854
  inline __isl_keep isl_space *get() const;
2855
  inline __isl_give isl_space *release();
2856
  inline bool is_null() const;
2857
  inline explicit operator bool() const;
2858
  inline ctx get_ctx() const;
2859
  inline std::string to_str() const;
2860
  inline void dump() const;
2861
2862
  inline space add_dims(isl::dim type, unsigned int n) const;
2863
  inline space add_param_id(id id) const;
2864
  inline space align_params(space dim2) const;
2865
  inline boolean can_curry() const;
2866
  inline boolean can_range_curry() const;
2867
  inline boolean can_uncurry() const;
2868
  inline boolean can_zip() const;
2869
  inline space curry() const;
2870
  inline unsigned int dim(isl::dim type) const;
2871
  inline space domain() const;
2872
  inline space domain_factor_domain() const;
2873
  inline space domain_factor_range() const;
2874
  inline boolean domain_is_wrapping() const;
2875
  inline space domain_map() const;
2876
  inline space domain_product(space right) const;
2877
  inline space drop_dims(isl::dim type, unsigned int first, unsigned int num) const;
2878
  inline space factor_domain() const;
2879
  inline space factor_range() const;
2880
  inline int find_dim_by_id(isl::dim type, const id &id) const;
2881
  inline int find_dim_by_name(isl::dim type, const std::string &name) const;
2882
  inline space flatten_domain() const;
2883
  inline space flatten_range() const;
2884
  inline space from_domain() const;
2885
  inline space from_range() const;
2886
  inline id get_dim_id(isl::dim type, unsigned int pos) const;
2887
  inline std::string get_dim_name(isl::dim type, unsigned int pos) const;
2888
  inline id get_tuple_id(isl::dim type) const;
2889
  inline std::string get_tuple_name(isl::dim type) const;
2890
  inline boolean has_dim_id(isl::dim type, unsigned int pos) const;
2891
  inline boolean has_dim_name(isl::dim type, unsigned int pos) const;
2892
  inline boolean has_equal_params(const space &space2) const;
2893
  inline boolean has_equal_tuples(const space &space2) const;
2894
  inline boolean has_tuple_id(isl::dim type) const;
2895
  inline boolean has_tuple_name(isl::dim type) const;
2896
  inline space insert_dims(isl::dim type, unsigned int pos, unsigned int n) const;
2897
  inline boolean is_domain(const space &space2) const;
2898
  inline boolean is_equal(const space &space2) const;
2899
  inline boolean is_map() const;
2900
  inline boolean is_params() const;
2901
  inline boolean is_product() const;
2902
  inline boolean is_range(const space &space2) const;
2903
  inline boolean is_set() const;
2904
  inline boolean is_wrapping() const;
2905
  inline space join(space right) const;
2906
  inline space map_from_domain_and_range(space range) const;
2907
  inline space map_from_set() const;
2908
  inline space move_dims(isl::dim dst_type, unsigned int dst_pos, isl::dim src_type, unsigned int src_pos, unsigned int n) const;
2909
  inline space params() const;
2910
  static inline space params_alloc(ctx ctx, unsigned int nparam);
2911
  inline space product(space right) const;
2912
  inline space range() const;
2913
  inline space range_curry() const;
2914
  inline space range_factor_domain() const;
2915
  inline space range_factor_range() const;
2916
  inline boolean range_is_wrapping() const;
2917
  inline space range_map() const;
2918
  inline space range_product(space right) const;
2919
  inline space reset_tuple_id(isl::dim type) const;
2920
  inline space reset_user() const;
2921
  inline space reverse() const;
2922
  inline space set_dim_id(isl::dim type, unsigned int pos, id id) const;
2923
  inline space set_from_params() const;
2924
  inline space set_tuple_id(isl::dim type, id id) const;
2925
  inline space set_tuple_name(isl::dim type, const std::string &s) const;
2926
  inline boolean tuple_is_equal(isl::dim type1, const space &space2, isl::dim type2) const;
2927
  inline space uncurry() const;
2928
  inline space unwrap() const;
2929
  inline space wrap() const;
2930
  inline space zip() const;
2931
};
2932
2933
// declarations for isl::term
2934
inline term manage(__isl_take isl_term *ptr);
2935
inline term manage_copy(__isl_keep isl_term *ptr);
2936
2937
class term {
2938
  friend inline term manage(__isl_take isl_term *ptr);
2939
  friend inline term manage_copy(__isl_keep isl_term *ptr);
2940
2941
  isl_term *ptr = nullptr;
2942
2943
  inline explicit term(__isl_take isl_term *ptr);
2944
2945
public:
2946
  inline /* implicit */ term();
2947
  inline /* implicit */ term(const term &obj);
2948
  inline /* implicit */ term(std::nullptr_t);
2949
  inline term &operator=(term obj);
2950
  inline ~term();
2951
  inline __isl_give isl_term *copy() const &;
2952
  inline __isl_give isl_term *copy() && = delete;
2953
  inline __isl_keep isl_term *get() const;
2954
  inline __isl_give isl_term *release();
2955
  inline bool is_null() const;
2956
  inline explicit operator bool() const;
2957
  inline ctx get_ctx() const;
2958
2959
  inline unsigned int dim(isl::dim type) const;
2960
  inline val get_coefficient_val() const;
2961
  inline aff get_div(unsigned int pos) const;
2962
  inline int get_exp(isl::dim type, unsigned int pos) const;
2963
};
2964
2965
// declarations for isl::union_access_info
2966
inline union_access_info manage(__isl_take isl_union_access_info *ptr);
2967
inline union_access_info manage_copy(__isl_keep isl_union_access_info *ptr);
2968
2969
class union_access_info {
2970
  friend inline union_access_info manage(__isl_take isl_union_access_info *ptr);
2971
  friend inline union_access_info manage_copy(__isl_keep isl_union_access_info *ptr);
2972
2973
  isl_union_access_info *ptr = nullptr;
2974
2975
  inline explicit union_access_info(__isl_take isl_union_access_info *ptr);
2976
2977
public:
2978
  inline /* implicit */ union_access_info();
2979
  inline /* implicit */ union_access_info(const union_access_info &obj);
2980
  inline /* implicit */ union_access_info(std::nullptr_t);
2981
  inline explicit union_access_info(union_map sink);
2982
  inline union_access_info &operator=(union_access_info obj);
2983
  inline ~union_access_info();
2984
  inline __isl_give isl_union_access_info *copy() const &;
2985
  inline __isl_give isl_union_access_info *copy() && = delete;
2986
  inline __isl_keep isl_union_access_info *get() const;
2987
  inline __isl_give isl_union_access_info *release();
2988
  inline bool is_null() const;
2989
  inline explicit operator bool() const;
2990
  inline ctx get_ctx() const;
2991
  inline std::string to_str() const;
2992
2993
  inline union_flow compute_flow() const;
2994
  inline union_access_info set_kill(union_map kill) const;
2995
  inline union_access_info set_may_source(union_map may_source) const;
2996
  inline union_access_info set_must_source(union_map must_source) const;
2997
  inline union_access_info set_schedule(schedule schedule) const;
2998
  inline union_access_info set_schedule_map(union_map schedule_map) const;
2999
};
3000
3001
// declarations for isl::union_flow
3002
inline union_flow manage(__isl_take isl_union_flow *ptr);
3003
inline union_flow manage_copy(__isl_keep isl_union_flow *ptr);
3004
3005
class union_flow {
3006
  friend inline union_flow manage(__isl_take isl_union_flow *ptr);
3007
  friend inline union_flow manage_copy(__isl_keep isl_union_flow *ptr);
3008
3009
  isl_union_flow *ptr = nullptr;
3010
3011
  inline explicit union_flow(__isl_take isl_union_flow *ptr);
3012
3013
public:
3014
  inline /* implicit */ union_flow();
3015
  inline /* implicit */ union_flow(const union_flow &obj);
3016
  inline /* implicit */ union_flow(std::nullptr_t);
3017
  inline union_flow &operator=(union_flow obj);
3018
  inline ~union_flow();
3019
  inline __isl_give isl_union_flow *copy() const &;
3020
  inline __isl_give isl_union_flow *copy() && = delete;
3021
  inline __isl_keep isl_union_flow *get() const;
3022
  inline __isl_give isl_union_flow *release();
3023
  inline bool is_null() const;
3024
  inline explicit operator bool() const;
3025
  inline ctx get_ctx() const;
3026
  inline std::string to_str() const;
3027
3028
  inline union_map get_full_may_dependence() const;
3029
  inline union_map get_full_must_dependence() const;
3030
  inline union_map get_may_dependence() const;
3031
  inline union_map get_may_no_source() const;
3032
  inline union_map get_must_dependence() const;
3033
  inline union_map get_must_no_source() const;
3034
};
3035
3036
// declarations for isl::union_map
3037
inline union_map manage(__isl_take isl_union_map *ptr);
3038
inline union_map manage_copy(__isl_keep isl_union_map *ptr);
3039
3040
class union_map {
3041
  friend inline union_map manage(__isl_take isl_union_map *ptr);
3042
  friend inline union_map manage_copy(__isl_keep isl_union_map *ptr);
3043
3044
  isl_union_map *ptr = nullptr;
3045
3046
  inline explicit union_map(__isl_take isl_union_map *ptr);
3047
3048
public:
3049
  inline /* implicit */ union_map();
3050
  inline /* implicit */ union_map(const union_map &obj);
3051
  inline /* implicit */ union_map(std::nullptr_t);
3052
  inline explicit union_map(union_pw_multi_aff upma);
3053
  inline /* implicit */ union_map(basic_map bmap);
3054
  inline /* implicit */ union_map(map map);
3055
  inline explicit union_map(ctx ctx, const std::string &str);
3056
  inline union_map &operator=(union_map obj);
3057
  inline ~union_map();
3058
  inline __isl_give isl_union_map *copy() const &;
3059
  inline __isl_give isl_union_map *copy() && = delete;
3060
  inline __isl_keep isl_union_map *get() const;
3061
  inline __isl_give isl_union_map *release();
3062
  inline bool is_null() const;
3063
  inline explicit operator bool() const;
3064
  inline ctx get_ctx() const;
3065
  inline std::string to_str() const;
3066
  inline void dump() const;
3067
3068
  inline union_map add_map(map map) const;
3069
  inline union_map affine_hull() const;
3070
  inline union_map align_params(space model) const;
3071
  inline union_map apply_domain(union_map umap2) const;
3072
  inline union_map apply_range(union_map umap2) const;
3073
  inline union_map coalesce() const;
3074
  inline boolean contains(const space &space) const;
3075
  inline union_map curry() const;
3076
  inline union_set deltas() const;
3077
  inline union_map deltas_map() const;
3078
  inline union_map detect_equalities() const;
3079
  inline unsigned int dim(isl::dim type) const;
3080
  inline union_set domain() const;
3081
  inline union_map domain_factor_domain() const;
3082
  inline union_map domain_factor_range() const;
3083
  inline union_map domain_map() const;
3084
  inline union_pw_multi_aff domain_map_union_pw_multi_aff() const;
3085
  inline union_map domain_product(union_map umap2) const;
3086
  static inline union_map empty(space space);
3087
  inline union_map eq_at(multi_union_pw_aff mupa) const;
3088
  inline map extract_map(space dim) const;
3089
  inline union_map factor_domain() const;
3090
  inline union_map factor_range() const;
3091
  inline int find_dim_by_name(isl::dim type, const std::string &name) const;
3092
  inline union_map fixed_power(val exp) const;
3093
  inline union_map flat_domain_product(union_map umap2) const;
3094
  inline union_map flat_range_product(union_map umap2) const;
3095
  inline stat foreach_map(const std::function<stat(map)> &fn) const;
3096
  static inline union_map from(multi_union_pw_aff mupa);
3097
  static inline union_map from_domain(union_set uset);
3098
  static inline union_map from_domain_and_range(union_set domain, union_set range);
3099
  static inline union_map from_range(union_set uset);
3100
  static inline union_map from_union_pw_aff(union_pw_aff upa);
3101
  inline id get_dim_id(isl::dim type, unsigned int pos) const;
3102
  inline uint32_t get_hash() const;
3103
  inline map_list get_map_list() const;
3104
  inline space get_space() const;
3105
  inline union_map gist(union_map context) const;
3106
  inline union_map gist_domain(union_set uset) const;
3107
  inline union_map gist_params(set set) const;
3108
  inline union_map gist_range(union_set uset) const;
3109
  inline union_map intersect(union_map umap2) const;
3110
  inline union_map intersect_domain(union_set uset) const;
3111
  inline union_map intersect_params(set set) const;
3112
  inline union_map intersect_range(union_set uset) const;
3113
  inline union_map intersect_range_factor_range(union_map factor) const;
3114
  inline boolean involves_dims(isl::dim type, unsigned int first, unsigned int n) const;
3115
  inline boolean is_bijective() const;
3116
  inline boolean is_disjoint(const union_map &umap2) const;
3117
  inline boolean is_empty() const;
3118
  inline boolean is_equal(const union_map &umap2) const;
3119
  inline boolean is_identity() const;
3120
  inline boolean is_injective() const;
3121
  inline boolean is_single_valued() const;
3122
  inline boolean is_strict_subset(const union_map &umap2) const;
3123
  inline boolean is_subset(const union_map &umap2) const;
3124
  inline union_map lex_ge_union_map(union_map umap2) const;
3125
  inline union_map lex_gt_at_multi_union_pw_aff(multi_union_pw_aff mupa) const;
3126
  inline union_map lex_gt_union_map(union_map umap2) const;
3127
  inline union_map lex_le_union_map(union_map umap2) const;
3128
  inline union_map lex_lt_at_multi_union_pw_aff(multi_union_pw_aff mupa) const;
3129
  inline union_map lex_lt_union_map(union_map umap2) const;
3130
  inline union_map lexmax() const;
3131
  inline union_map lexmin() const;
3132
  inline int n_map() const;
3133
  inline set params() const;
3134
  inline boolean plain_is_empty() const;
3135
  inline boolean plain_is_injective() const;
3136
  inline union_map polyhedral_hull() const;
3137
  inline union_map preimage_domain_multi_aff(multi_aff ma) const;
3138
  inline union_map preimage_domain_multi_pw_aff(multi_pw_aff mpa) const;
3139
  inline union_map preimage_domain_pw_multi_aff(pw_multi_aff pma) const;
3140
  inline union_map preimage_domain_union_pw_multi_aff(union_pw_multi_aff upma) const;
3141
  inline union_map preimage_range_multi_aff(multi_aff ma) const;
3142
  inline union_map preimage_range_pw_multi_aff(pw_multi_aff pma) const;
3143
  inline union_map preimage_range_union_pw_multi_aff(union_pw_multi_aff upma) const;
3144
  inline union_map product(union_map umap2) const;
3145
  inline union_map project_out(isl::dim type, unsigned int first, unsigned int n) const;
3146
  inline union_map project_out_all_params() const;
3147
  inline union_set range() const;
3148
  inline union_map range_curry() const;
3149
  inline union_map range_factor_domain() const;
3150
  inline union_map range_factor_range() const;
3151
  inline union_map range_map() const;
3152
  inline union_map range_product(union_map umap2) const;
3153
  inline union_map remove_divs() const;
3154
  inline union_map remove_redundancies() const;
3155
  inline union_map reset_user() const;
3156
  inline union_map reverse() const;
3157
  inline basic_map sample() const;
3158
  inline union_map simple_hull() const;
3159
  inline union_map subtract(union_map umap2) const;
3160
  inline union_map subtract_domain(union_set dom) const;
3161
  inline union_map subtract_range(union_set dom) const;
3162
  inline union_map uncurry() const;
3163
  inline union_map unite(union_map umap2) const;
3164
  inline union_map universe() const;
3165
  inline union_set wrap() const;
3166
  inline union_map zip() const;
3167
};
3168
3169
// declarations for isl::union_map_list
3170
inline union_map_list manage(__isl_take isl_union_map_list *ptr);
3171
inline union_map_list manage_copy(__isl_keep isl_union_map_list *ptr);
3172
3173
class union_map_list {
3174
  friend inline union_map_list manage(__isl_take isl_union_map_list *ptr);
3175
  friend inline union_map_list manage_copy(__isl_keep isl_union_map_list *ptr);
3176
3177
  isl_union_map_list *ptr = nullptr;
3178
3179
  inline explicit union_map_list(__isl_take isl_union_map_list *ptr);
3180
3181
public:
3182
  inline /* implicit */ union_map_list();
3183
  inline /* implicit */ union_map_list(const union_map_list &obj);
3184
  inline /* implicit */ union_map_list(std::nullptr_t);
3185
  inline union_map_list &operator=(union_map_list obj);
3186
  inline ~union_map_list();
3187
  inline __isl_give isl_union_map_list *copy() const &;
3188
  inline __isl_give isl_union_map_list *copy() && = delete;
3189
  inline __isl_keep isl_union_map_list *get() const;
3190
  inline __isl_give isl_union_map_list *release();
3191
  inline bool is_null() const;
3192
  inline explicit operator bool() const;
3193
  inline ctx get_ctx() const;
3194
  inline void dump() const;
3195
3196
  inline union_map_list add(union_map el) const;
3197
  static inline union_map_list alloc(ctx ctx, int n);
3198
  inline union_map_list concat(union_map_list list2) const;
3199
  inline union_map_list drop(unsigned int first, unsigned int n) const;
3200
  inline stat foreach(const std::function<stat(union_map)> &fn) const;
3201
  static inline union_map_list from_union_map(union_map el);
3202
  inline union_map get_at(int index) const;
3203
  inline union_map get_union_map(int index) const;
3204
  inline union_map_list insert(unsigned int pos, union_map el) const;
3205
  inline int n_union_map() const;
3206
  inline union_map_list reverse() const;
3207
  inline union_map_list set_union_map(int index, union_map el) const;
3208
  inline int size() const;
3209
  inline union_map_list swap(unsigned int pos1, unsigned int pos2) const;
3210
};
3211
3212
// declarations for isl::union_pw_aff
3213
inline union_pw_aff manage(__isl_take isl_union_pw_aff *ptr);
3214
inline union_pw_aff manage_copy(__isl_keep isl_union_pw_aff *ptr);
3215
3216
class union_pw_aff {
3217
  friend inline union_pw_aff manage(__isl_take isl_union_pw_aff *ptr);
3218
  friend inline union_pw_aff manage_copy(__isl_keep isl_union_pw_aff *ptr);
3219
3220
  isl_union_pw_aff *ptr = nullptr;
3221
3222
  inline explicit union_pw_aff(__isl_take isl_union_pw_aff *ptr);
3223
3224
public:
3225
  inline /* implicit */ union_pw_aff();
3226
  inline /* implicit */ union_pw_aff(const union_pw_aff &obj);
3227
  inline /* implicit */ union_pw_aff(std::nullptr_t);
3228
  inline /* implicit */ union_pw_aff(pw_aff pa);
3229
  inline explicit union_pw_aff(union_set domain, val v);
3230
  inline explicit union_pw_aff(ctx ctx, const std::string &str);
3231
  inline union_pw_aff &operator=(union_pw_aff obj);
3232
  inline ~union_pw_aff();
3233
  inline __isl_give isl_union_pw_aff *copy() const &;
3234
  inline __isl_give isl_union_pw_aff *copy() && = delete;
3235
  inline __isl_keep isl_union_pw_aff *get() const;
3236
  inline __isl_give isl_union_pw_aff *release();
3237
  inline bool is_null() const;
3238
  inline explicit operator bool() const;
3239
  inline ctx get_ctx() const;
3240
  inline std::string to_str() const;
3241
  inline void dump() const;
3242
3243
  inline union_pw_aff add(union_pw_aff upa2) const;
3244
  inline union_pw_aff add_pw_aff(pw_aff pa) const;
3245
  static inline union_pw_aff aff_on_domain(union_set domain, aff aff);
3246
  inline union_pw_aff align_params(space model) const;
3247
  inline union_pw_aff coalesce() const;
3248
  inline unsigned int dim(isl::dim type) const;
3249
  inline union_set domain() const;
3250
  inline union_pw_aff drop_dims(isl::dim type, unsigned int first, unsigned int n) const;
3251
  static inline union_pw_aff empty(space space);
3252
  inline pw_aff extract_pw_aff(space space) const;
3253
  inline int find_dim_by_name(isl::dim type, const std::string &name) const;
3254
  inline union_pw_aff floor() const;
3255
  inline stat foreach_pw_aff(const std::function<stat(pw_aff)> &fn) const;
3256
  inline pw_aff_list get_pw_aff_list() const;
3257
  inline space get_space() const;
3258
  inline union_pw_aff gist(union_set context) const;
3259
  inline union_pw_aff gist_params(set context) const;
3260
  inline union_pw_aff intersect_domain(union_set uset) const;
3261
  inline union_pw_aff intersect_params(set set) const;
3262
  inline boolean involves_nan() const;
3263
  inline val max_val() const;
3264
  inline val min_val() const;
3265
  inline union_pw_aff mod_val(val f) const;
3266
  inline int n_pw_aff() const;
3267
  inline union_pw_aff neg() const;
3268
  static inline union_pw_aff param_on_domain_id(union_set domain, id id);
3269
  inline boolean plain_is_equal(const union_pw_aff &upa2) const;
3270
  inline union_pw_aff pullback(union_pw_multi_aff upma) const;
3271
  static inline union_pw_aff pw_aff_on_domain(union_set domain, pw_aff pa);
3272
  inline union_pw_aff reset_user() const;
3273
  inline union_pw_aff scale_down_val(val v) const;
3274
  inline union_pw_aff scale_val(val v) const;
3275
  inline union_pw_aff sub(union_pw_aff upa2) const;
3276
  inline union_pw_aff subtract_domain(union_set uset) const;
3277
  inline union_pw_aff union_add(union_pw_aff upa2) const;
3278
  inline union_set zero_union_set() const;
3279
};
3280
3281
// declarations for isl::union_pw_aff_list
3282
inline union_pw_aff_list manage(__isl_take isl_union_pw_aff_list *ptr);
3283
inline union_pw_aff_list manage_copy(__isl_keep isl_union_pw_aff_list *ptr);
3284
3285
class union_pw_aff_list {
3286
  friend inline union_pw_aff_list manage(__isl_take isl_union_pw_aff_list *ptr);
3287
  friend inline union_pw_aff_list manage_copy(__isl_keep isl_union_pw_aff_list *ptr);
3288
3289
  isl_union_pw_aff_list *ptr = nullptr;
3290
3291
  inline explicit union_pw_aff_list(__isl_take isl_union_pw_aff_list *ptr);
3292
3293
public:
3294
  inline /* implicit */ union_pw_aff_list();
3295
  inline /* implicit */ union_pw_aff_list(const union_pw_aff_list &obj);
3296
  inline /* implicit */ union_pw_aff_list(std::nullptr_t);
3297
  inline union_pw_aff_list &operator=(union_pw_aff_list obj);
3298
  inline ~union_pw_aff_list();
3299
  inline __isl_give isl_union_pw_aff_list *copy() const &;
3300
  inline __isl_give isl_union_pw_aff_list *copy() && = delete;
3301
  inline __isl_keep isl_union_pw_aff_list *get() const;
3302
  inline __isl_give isl_union_pw_aff_list *release();
3303
  inline bool is_null() const;
3304
  inline explicit operator bool() const;
3305
  inline ctx get_ctx() const;
3306
  inline void dump() const;
3307
3308
  inline union_pw_aff_list add(union_pw_aff el) const;
3309
  static inline union_pw_aff_list alloc(ctx ctx, int n);
3310
  inline union_pw_aff_list concat(union_pw_aff_list list2) const;
3311
  inline union_pw_aff_list drop(unsigned int first, unsigned int n) const;
3312
  inline stat foreach(const std::function<stat(union_pw_aff)> &fn) const;
3313
  static inline union_pw_aff_list from_union_pw_aff(union_pw_aff el);
3314
  inline union_pw_aff get_at(int index) const;
3315
  inline union_pw_aff get_union_pw_aff(int index) const;
3316
  inline union_pw_aff_list insert(unsigned int pos, union_pw_aff el) const;
3317
  inline int n_union_pw_aff() const;
3318
  inline union_pw_aff_list reverse() const;
3319
  inline union_pw_aff_list set_union_pw_aff(int index, union_pw_aff el) const;
3320
  inline int size() const;
3321
  inline union_pw_aff_list swap(unsigned int pos1, unsigned int pos2) const;
3322
};
3323
3324
// declarations for isl::union_pw_multi_aff
3325
inline union_pw_multi_aff manage(__isl_take isl_union_pw_multi_aff *ptr);
3326
inline union_pw_multi_aff manage_copy(__isl_keep isl_union_pw_multi_aff *ptr);
3327
3328
class union_pw_multi_aff {
3329
  friend inline union_pw_multi_aff manage(__isl_take isl_union_pw_multi_aff *ptr);
3330
  friend inline union_pw_multi_aff manage_copy(__isl_keep isl_union_pw_multi_aff *ptr);
3331
3332
  isl_union_pw_multi_aff *ptr = nullptr;
3333
3334
  inline explicit union_pw_multi_aff(__isl_take isl_union_pw_multi_aff *ptr);
3335
3336
public:
3337
  inline /* implicit */ union_pw_multi_aff();
3338
  inline /* implicit */ union_pw_multi_aff(const union_pw_multi_aff &obj);
3339
  inline /* implicit */ union_pw_multi_aff(std::nullptr_t);
3340
  inline /* implicit */ union_pw_multi_aff(aff aff);
3341
  inline /* implicit */ union_pw_multi_aff(pw_multi_aff pma);
3342
  inline explicit union_pw_multi_aff(union_set uset);
3343
  inline explicit union_pw_multi_aff(union_map umap);
3344
  inline explicit union_pw_multi_aff(ctx ctx, const std::string &str);
3345
  inline /* implicit */ union_pw_multi_aff(union_pw_aff upa);
3346
  inline explicit union_pw_multi_aff(multi_union_pw_aff mupa);
3347
  inline union_pw_multi_aff &operator=(union_pw_multi_aff obj);
3348
  inline ~union_pw_multi_aff();
3349
  inline __isl_give isl_union_pw_multi_aff *copy() const &;
3350
  inline __isl_give isl_union_pw_multi_aff *copy() && = delete;
3351
  inline __isl_keep isl_union_pw_multi_aff *get() const;
3352
  inline __isl_give isl_union_pw_multi_aff *release();
3353
  inline bool is_null() const;
3354
  inline explicit operator bool() const;
3355
  inline ctx get_ctx() const;
3356
  inline std::string to_str() const;
3357
  inline void dump() const;
3358
3359
  inline union_pw_multi_aff add(union_pw_multi_aff upma2) const;
3360
  inline union_pw_multi_aff add_pw_multi_aff(pw_multi_aff pma) const;
3361
  inline union_pw_multi_aff align_params(space model) const;
3362
  inline union_pw_multi_aff coalesce() const;
3363
  inline unsigned int dim(isl::dim type) const;
3364
  inline union_set domain() const;
3365
  inline union_pw_multi_aff drop_dims(isl::dim type, unsigned int first, unsigned int n) const;
3366
  static inline union_pw_multi_aff empty(space space);
3367
  inline pw_multi_aff extract_pw_multi_aff(space space) const;
3368
  inline int find_dim_by_name(isl::dim type, const std::string &name) const;
3369
  inline union_pw_multi_aff flat_range_product(union_pw_multi_aff upma2) const;
3370
  inline stat foreach_pw_multi_aff(const std::function<stat(pw_multi_aff)> &fn) const;
3371
  static inline union_pw_multi_aff from_union_set(union_set uset);
3372
  inline pw_multi_aff_list get_pw_multi_aff_list() const;
3373
  inline space get_space() const;
3374
  inline union_pw_aff get_union_pw_aff(int pos) const;
3375
  inline union_pw_multi_aff gist(union_set context) const;
3376
  inline union_pw_multi_aff gist_params(set context) const;
3377
  inline union_pw_multi_aff intersect_domain(union_set uset) const;
3378
  inline union_pw_multi_aff intersect_params(set set) const;
3379
  inline boolean involves_nan() const;
3380
  static inline union_pw_multi_aff multi_val_on_domain(union_set domain, multi_val mv);
3381
  inline int n_pw_multi_aff() const;
3382
  inline union_pw_multi_aff neg() const;
3383
  inline boolean plain_is_equal(const union_pw_multi_aff &upma2) const;
3384
  inline union_pw_multi_aff pullback(union_pw_multi_aff upma2) const;
3385
  inline union_pw_multi_aff reset_user() const;
3386
  inline union_pw_multi_aff scale_down_val(val val) const;
3387
  inline union_pw_multi_aff scale_multi_val(multi_val mv) const;
3388
  inline union_pw_multi_aff scale_val(val val) const;
3389
  inline union_pw_multi_aff sub(union_pw_multi_aff upma2) const;
3390
  inline union_pw_multi_aff subtract_domain(union_set uset) const;
3391
  inline union_pw_multi_aff union_add(union_pw_multi_aff upma2) const;
3392
};
3393
3394
// declarations for isl::union_pw_multi_aff_list
3395
inline union_pw_multi_aff_list manage(__isl_take isl_union_pw_multi_aff_list *ptr);
3396
inline union_pw_multi_aff_list manage_copy(__isl_keep isl_union_pw_multi_aff_list *ptr);
3397
3398
class union_pw_multi_aff_list {
3399
  friend inline union_pw_multi_aff_list manage(__isl_take isl_union_pw_multi_aff_list *ptr);
3400
  friend inline union_pw_multi_aff_list manage_copy(__isl_keep isl_union_pw_multi_aff_list *ptr);
3401
3402
  isl_union_pw_multi_aff_list *ptr = nullptr;
3403
3404
  inline explicit union_pw_multi_aff_list(__isl_take isl_union_pw_multi_aff_list *ptr);
3405
3406
public:
3407
  inline /* implicit */ union_pw_multi_aff_list();
3408
  inline /* implicit */ union_pw_multi_aff_list(const union_pw_multi_aff_list &obj);
3409
  inline /* implicit */ union_pw_multi_aff_list(std::nullptr_t);
3410
  inline union_pw_multi_aff_list &operator=(union_pw_multi_aff_list obj);
3411
  inline ~union_pw_multi_aff_list();
3412
  inline __isl_give isl_union_pw_multi_aff_list *copy() const &;
3413
  inline __isl_give isl_union_pw_multi_aff_list *copy() && = delete;
3414
  inline __isl_keep isl_union_pw_multi_aff_list *get() const;
3415
  inline __isl_give isl_union_pw_multi_aff_list *release();
3416
  inline bool is_null() const;
3417
  inline explicit operator bool() const;
3418
  inline ctx get_ctx() const;
3419
  inline void dump() const;
3420
3421
  inline union_pw_multi_aff_list add(union_pw_multi_aff el) const;
3422
  static inline union_pw_multi_aff_list alloc(ctx ctx, int n);
3423
  inline union_pw_multi_aff_list concat(union_pw_multi_aff_list list2) const;
3424
  inline union_pw_multi_aff_list drop(unsigned int first, unsigned int n) const;
3425
  inline stat foreach(const std::function<stat(union_pw_multi_aff)> &fn) const;
3426
  static inline union_pw_multi_aff_list from_union_pw_multi_aff(union_pw_multi_aff el);
3427
  inline union_pw_multi_aff get_at(int index) const;
3428
  inline union_pw_multi_aff get_union_pw_multi_aff(int index) const;
3429
  inline union_pw_multi_aff_list insert(unsigned int pos, union_pw_multi_aff el) const;
3430
  inline int n_union_pw_multi_aff() const;
3431
  inline union_pw_multi_aff_list reverse() const;
3432
  inline union_pw_multi_aff_list set_union_pw_multi_aff(int index, union_pw_multi_aff el) const;
3433
  inline int size() const;
3434
  inline union_pw_multi_aff_list swap(unsigned int pos1, unsigned int pos2) const;
3435
};
3436
3437
// declarations for isl::union_pw_qpolynomial
3438
inline union_pw_qpolynomial manage(__isl_take isl_union_pw_qpolynomial *ptr);
3439
inline union_pw_qpolynomial manage_copy(__isl_keep isl_union_pw_qpolynomial *ptr);
3440
3441
class union_pw_qpolynomial {
3442
  friend inline union_pw_qpolynomial manage(__isl_take isl_union_pw_qpolynomial *ptr);
3443
  friend inline union_pw_qpolynomial manage_copy(__isl_keep isl_union_pw_qpolynomial *ptr);
3444
3445
  isl_union_pw_qpolynomial *ptr = nullptr;
3446
3447
  inline explicit union_pw_qpolynomial(__isl_take isl_union_pw_qpolynomial *ptr);
3448
3449
public:
3450
  inline /* implicit */ union_pw_qpolynomial();
3451
  inline /* implicit */ union_pw_qpolynomial(const union_pw_qpolynomial &obj);
3452
  inline /* implicit */ union_pw_qpolynomial(std::nullptr_t);
3453
  inline explicit union_pw_qpolynomial(ctx ctx, const std::string &str);
3454
  inline union_pw_qpolynomial &operator=(union_pw_qpolynomial obj);
3455
  inline ~union_pw_qpolynomial();
3456
  inline __isl_give isl_union_pw_qpolynomial *copy() const &;
3457
  inline __isl_give isl_union_pw_qpolynomial *copy() && = delete;
3458
  inline __isl_keep isl_union_pw_qpolynomial *get() const;
3459
  inline __isl_give isl_union_pw_qpolynomial *release();
3460
  inline bool is_null() const;
3461
  inline explicit operator bool() const;
3462
  inline ctx get_ctx() const;
3463
  inline std::string to_str() const;
3464
3465
  inline union_pw_qpolynomial add(union_pw_qpolynomial upwqp2) const;
3466
  inline union_pw_qpolynomial add_pw_qpolynomial(pw_qpolynomial pwqp) const;
3467
  inline union_pw_qpolynomial align_params(space model) const;
3468
  inline union_pw_qpolynomial coalesce() const;
3469
  inline unsigned int dim(isl::dim type) const;
3470
  inline union_set domain() const;
3471
  inline union_pw_qpolynomial drop_dims(isl::dim type, unsigned int first, unsigned int n) const;
3472
  inline val eval(point pnt) const;
3473
  inline pw_qpolynomial extract_pw_qpolynomial(space dim) const;
3474
  inline int find_dim_by_name(isl::dim type, const std::string &name) const;
3475
  inline stat foreach_pw_qpolynomial(const std::function<stat(pw_qpolynomial)> &fn) const;
3476
  static inline union_pw_qpolynomial from_pw_qpolynomial(pw_qpolynomial pwqp);
3477
  inline pw_qpolynomial_list get_pw_qpolynomial_list() const;
3478
  inline space get_space() const;
3479
  inline union_pw_qpolynomial gist(union_set context) const;
3480
  inline union_pw_qpolynomial gist_params(set context) const;
3481
  inline union_pw_qpolynomial intersect_domain(union_set uset) const;
3482
  inline union_pw_qpolynomial intersect_params(set set) const;
3483
  inline boolean involves_nan() const;
3484
  inline union_pw_qpolynomial mul(union_pw_qpolynomial upwqp2) const;
3485
  inline int n_pw_qpolynomial() const;
3486
  inline union_pw_qpolynomial neg() const;
3487
  inline boolean plain_is_equal(const union_pw_qpolynomial &upwqp2) const;
3488
  inline union_pw_qpolynomial reset_user() const;
3489
  inline union_pw_qpolynomial scale_down_val(val v) const;
3490
  inline union_pw_qpolynomial scale_val(val v) const;
3491
  inline union_pw_qpolynomial sub(union_pw_qpolynomial upwqp2) const;
3492
  inline union_pw_qpolynomial subtract_domain(union_set uset) const;
3493
  inline union_pw_qpolynomial to_polynomial(int sign) const;
3494
  static inline union_pw_qpolynomial zero(space dim);
3495
};
3496
3497
// declarations for isl::union_set
3498
inline union_set manage(__isl_take isl_union_set *ptr);
3499
inline union_set manage_copy(__isl_keep isl_union_set *ptr);
3500
3501
class union_set {
3502
  friend inline union_set manage(__isl_take isl_union_set *ptr);
3503
  friend inline union_set manage_copy(__isl_keep isl_union_set *ptr);
3504
3505
  isl_union_set *ptr = nullptr;
3506
3507
  inline explicit union_set(__isl_take isl_union_set *ptr);
3508
3509
public:
3510
  inline /* implicit */ union_set();
3511
  inline /* implicit */ union_set(const union_set &obj);
3512
  inline /* implicit */ union_set(std::nullptr_t);
3513
  inline /* implicit */ union_set(basic_set bset);
3514
  inline /* implicit */ union_set(set set);
3515
  inline /* implicit */ union_set(point pnt);
3516
  inline explicit union_set(ctx ctx, const std::string &str);
3517
  inline union_set &operator=(union_set obj);
3518
  inline ~union_set();
3519
  inline __isl_give isl_union_set *copy() const &;
3520
  inline __isl_give isl_union_set *copy() && = delete;
3521
  inline __isl_keep isl_union_set *get() const;
3522
  inline __isl_give isl_union_set *release();
3523
  inline bool is_null() const;
3524
  inline explicit operator bool() const;
3525
  inline ctx get_ctx() const;
3526
  inline std::string to_str() const;
3527
  inline void dump() const;
3528
3529
  inline union_set add_set(set set) const;
3530
  inline union_set affine_hull() const;
3531
  inline union_set align_params(space model) const;
3532
  inline union_set apply(union_map umap) const;
3533
  inline union_set coalesce() const;
3534
  inline union_set coefficients() const;
3535
  inline schedule compute_schedule(union_map validity, union_map proximity) const;
3536
  inline boolean contains(const space &space) const;
3537
  inline union_set detect_equalities() const;
3538
  inline unsigned int dim(isl::dim type) const;
3539
  static inline union_set empty(space space);
3540
  inline set extract_set(space dim) const;
3541
  inline stat foreach_point(const std::function<stat(point)> &fn) const;
3542
  inline stat foreach_set(const std::function<stat(set)> &fn) const;
3543
  inline basic_set_list get_basic_set_list() const;
3544
  inline uint32_t get_hash() const;
3545
  inline set_list get_set_list() const;
3546
  inline space get_space() const;
3547
  inline union_set gist(union_set context) const;
3548
  inline union_set gist_params(set set) const;
3549
  inline union_map identity() const;
3550
  inline union_pw_multi_aff identity_union_pw_multi_aff() const;
3551
  inline union_set intersect(union_set uset2) const;
3552
  inline union_set intersect_params(set set) const;
3553
  inline boolean is_disjoint(const union_set &uset2) const;
3554
  inline boolean is_empty() const;
3555
  inline boolean is_equal(const union_set &uset2) const;
3556
  inline boolean is_params() const;
3557
  inline boolean is_strict_subset(const union_set &uset2) const;
3558
  inline boolean is_subset(const union_set &uset2) const;
3559
  inline union_map lex_ge_union_set(union_set uset2) const;
3560
  inline union_map lex_gt_union_set(union_set uset2) const;
3561
  inline union_map lex_le_union_set(union_set uset2) const;
3562
  inline union_map lex_lt_union_set(union_set uset2) const;
3563
  inline union_set lexmax() const;
3564
  inline union_set lexmin() const;
3565
  inline multi_val min_multi_union_pw_aff(const multi_union_pw_aff &obj) const;
3566
  inline int n_set() const;
3567
  inline set params() const;
3568
  inline union_set polyhedral_hull() const;
3569
  inline union_set preimage(multi_aff ma) const;
3570
  inline union_set preimage(pw_multi_aff pma) const;
3571
  inline union_set preimage(union_pw_multi_aff upma) const;
3572
  inline union_set product(union_set uset2) const;
3573
  inline union_set project_out(isl::dim type, unsigned int first, unsigned int n) const;
3574
  inline union_set remove_divs() const;
3575
  inline union_set remove_redundancies() const;
3576
  inline union_set reset_user() const;
3577
  inline basic_set sample() const;
3578
  inline point sample_point() const;
3579
  inline union_set simple_hull() const;
3580
  inline union_set solutions() const;
3581
  inline union_set subtract(union_set uset2) const;
3582
  inline union_set unite(union_set uset2) const;
3583
  inline union_set universe() const;
3584
  inline union_map unwrap() const;
3585
  inline union_map wrapped_domain_map() const;
3586
};
3587
3588
// declarations for isl::union_set_list
3589
inline union_set_list manage(__isl_take isl_union_set_list *ptr);
3590
inline union_set_list manage_copy(__isl_keep isl_union_set_list *ptr);
3591
3592
class union_set_list {
3593
  friend inline union_set_list manage(__isl_take isl_union_set_list *ptr);
3594
  friend inline union_set_list manage_copy(__isl_keep isl_union_set_list *ptr);
3595
3596
  isl_union_set_list *ptr = nullptr;
3597
3598
  inline explicit union_set_list(__isl_take isl_union_set_list *ptr);
3599
3600
public:
3601
  inline /* implicit */ union_set_list();
3602
  inline /* implicit */ union_set_list(const union_set_list &obj);
3603
  inline /* implicit */ union_set_list(std::nullptr_t);
3604
  inline union_set_list &operator=(union_set_list obj);
3605
  inline ~union_set_list();
3606
  inline __isl_give isl_union_set_list *copy() const &;
3607
  inline __isl_give isl_union_set_list *copy() && = delete;
3608
  inline __isl_keep isl_union_set_list *get() const;
3609
  inline __isl_give isl_union_set_list *release();
3610
  inline bool is_null() const;
3611
  inline explicit operator bool() const;
3612
  inline ctx get_ctx() const;
3613
  inline void dump() const;
3614
3615
  inline union_set_list add(union_set el) const;
3616
  static inline union_set_list alloc(ctx ctx, int n);
3617
  inline union_set_list concat(union_set_list list2) const;
3618
  inline union_set_list drop(unsigned int first, unsigned int n) const;
3619
  inline stat foreach(const std::function<stat(union_set)> &fn) const;
3620
  static inline union_set_list from_union_set(union_set el);
3621
  inline union_set get_at(int index) const;
3622
  inline union_set get_union_set(int index) const;
3623
  inline union_set_list insert(unsigned int pos, union_set el) const;
3624
  inline int n_union_set() const;
3625
  inline union_set_list reverse() const;
3626
  inline union_set_list set_union_set(int index, union_set el) const;
3627
  inline int size() const;
3628
  inline union_set_list swap(unsigned int pos1, unsigned int pos2) const;
3629
  inline union_set unite() const;
3630
};
3631
3632
// declarations for isl::val
3633
inline val manage(__isl_take isl_val *ptr);
3634
inline val manage_copy(__isl_keep isl_val *ptr);
3635
3636
class val {
3637
  friend inline val manage(__isl_take isl_val *ptr);
3638
  friend inline val manage_copy(__isl_keep isl_val *ptr);
3639
3640
  isl_val *ptr = nullptr;
3641
3642
  inline explicit val(__isl_take isl_val *ptr);
3643
3644
public:
3645
  inline /* implicit */ val();
3646
  inline /* implicit */ val(const val &obj);
3647
  inline /* implicit */ val(std::nullptr_t);
3648
  inline explicit val(ctx ctx, const std::string &str);
3649
  inline explicit val(ctx ctx, long i);
3650
  inline val &operator=(val obj);
3651
  inline ~val();
3652
  inline __isl_give isl_val *copy() const &;
3653
  inline __isl_give isl_val *copy() && = delete;
3654
  inline __isl_keep isl_val *get() const;
3655
  inline __isl_give isl_val *release();
3656
  inline bool is_null() const;
3657
  inline explicit operator bool() const;
3658
  inline ctx get_ctx() const;
3659
  inline std::string to_str() const;
3660
  inline void dump() const;
3661
3662
  inline val abs() const;
3663
  inline boolean abs_eq(const val &v2) const;
3664
  inline val add(val v2) const;
3665
  inline val add_ui(unsigned long v2) const;
3666
  inline val ceil() const;
3667
  inline int cmp_si(long i) const;
3668
  inline val div(val v2) const;
3669
  inline val div_ui(unsigned long v2) const;
3670
  inline boolean eq(const val &v2) const;
3671
  inline val floor() const;
3672
  inline val gcd(val v2) const;
3673
  inline boolean ge(const val &v2) const;
3674
  inline uint32_t get_hash() const;
3675
  inline long get_num_si() const;
3676
  inline boolean gt(const val &v2) const;
3677
  inline boolean gt_si(long i) const;
3678
  static inline val infty(ctx ctx);
3679
  static inline val int_from_ui(ctx ctx, unsigned long u);
3680
  inline val inv() const;
3681
  inline boolean is_divisible_by(const val &v2) const;
3682
  inline boolean is_infty() const;
3683
  inline boolean is_int() const;
3684
  inline boolean is_nan() const;
3685
  inline boolean is_neg() const;
3686
  inline boolean is_neginfty() const;
3687
  inline boolean is_negone() const;
3688
  inline boolean is_nonneg() const;
3689
  inline boolean is_nonpos() const;
3690
  inline boolean is_one() const;
3691
  inline boolean is_pos() const;
3692
  inline boolean is_rat() const;
3693
  inline boolean is_zero() const;
3694
  inline boolean le(const val &v2) const;
3695
  inline boolean lt(const val &v2) const;
3696
  inline val max(val v2) const;
3697
  inline val min(val v2) const;
3698
  inline val mod(val v2) const;
3699
  inline val mul(val v2) const;
3700
  inline val mul_ui(unsigned long v2) const;
3701
  inline size_t n_abs_num_chunks(size_t size) const;
3702
  static inline val nan(ctx ctx);
3703
  inline boolean ne(const val &v2) const;
3704
  inline val neg() const;
3705
  static inline val neginfty(ctx ctx);
3706
  static inline val negone(ctx ctx);
3707
  static inline val one(ctx ctx);
3708
  inline val pow2() const;
3709
  inline val set_si(long i) const;
3710
  inline int sgn() const;
3711
  inline val sub(val v2) const;
3712
  inline val sub_ui(unsigned long v2) const;
3713
  inline val trunc() const;
3714
  static inline val zero(ctx ctx);
3715
};
3716
3717
// declarations for isl::val_list
3718
inline val_list manage(__isl_take isl_val_list *ptr);
3719
inline val_list manage_copy(__isl_keep isl_val_list *ptr);
3720
3721
class val_list {
3722
  friend inline val_list manage(__isl_take isl_val_list *ptr);
3723
  friend inline val_list manage_copy(__isl_keep isl_val_list *ptr);
3724
3725
  isl_val_list *ptr = nullptr;
3726
3727
  inline explicit val_list(__isl_take isl_val_list *ptr);
3728
3729
public:
3730
  inline /* implicit */ val_list();
3731
  inline /* implicit */ val_list(const val_list &obj);
3732
  inline /* implicit */ val_list(std::nullptr_t);
3733
  inline val_list &operator=(val_list obj);
3734
  inline ~val_list();
3735
  inline __isl_give isl_val_list *copy() const &;
3736
  inline __isl_give isl_val_list *copy() && = delete;
3737
  inline __isl_keep isl_val_list *get() const;
3738
  inline __isl_give isl_val_list *release();
3739
  inline bool is_null() const;
3740
  inline explicit operator bool() const;
3741
  inline ctx get_ctx() const;
3742
  inline void dump() const;
3743
3744
  inline val_list add(val el) const;
3745
  static inline val_list alloc(ctx ctx, int n);
3746
  inline val_list concat(val_list list2) const;
3747
  inline val_list drop(unsigned int first, unsigned int n) const;
3748
  inline stat foreach(const std::function<stat(val)> &fn) const;
3749
  static inline val_list from_val(val el);
3750
  inline val get_at(int index) const;
3751
  inline val get_val(int index) const;
3752
  inline val_list insert(unsigned int pos, val el) const;
3753
  inline int n_val() const;
3754
  inline val_list reverse() const;
3755
  inline val_list set_val(int index, val el) const;
3756
  inline int size() const;
3757
  inline val_list swap(unsigned int pos1, unsigned int pos2) const;
3758
};
3759
3760
// declarations for isl::vec
3761
inline vec manage(__isl_take isl_vec *ptr);
3762
inline vec manage_copy(__isl_keep isl_vec *ptr);
3763
3764
class vec {
3765
  friend inline vec manage(__isl_take isl_vec *ptr);
3766
  friend inline vec manage_copy(__isl_keep isl_vec *ptr);
3767
3768
  isl_vec *ptr = nullptr;
3769
3770
  inline explicit vec(__isl_take isl_vec *ptr);
3771
3772
public:
3773
  inline /* implicit */ vec();
3774
  inline /* implicit */ vec(const vec &obj);
3775
  inline /* implicit */ vec(std::nullptr_t);
3776
  inline vec &operator=(vec obj);
3777
  inline ~vec();
3778
  inline __isl_give isl_vec *copy() const &;
3779
  inline __isl_give isl_vec *copy() && = delete;
3780
  inline __isl_keep isl_vec *get() const;
3781
  inline __isl_give isl_vec *release();
3782
  inline bool is_null() const;
3783
  inline explicit operator bool() const;
3784
  inline ctx get_ctx() const;
3785
  inline void dump() const;
3786
3787
  inline vec add(vec vec2) const;
3788
  inline vec add_els(unsigned int n) const;
3789
  static inline vec alloc(ctx ctx, unsigned int size);
3790
  inline vec ceil() const;
3791
  inline vec clr() const;
3792
  inline int cmp_element(const vec &vec2, int pos) const;
3793
  inline vec concat(vec vec2) const;
3794
  inline vec drop_els(unsigned int pos, unsigned int n) const;
3795
  inline vec extend(unsigned int size) const;
3796
  inline val get_element_val(int pos) const;
3797
  inline vec insert_els(unsigned int pos, unsigned int n) const;
3798
  inline vec insert_zero_els(unsigned int pos, unsigned int n) const;
3799
  inline boolean is_equal(const vec &vec2) const;
3800
  inline vec mat_product(mat mat) const;
3801
  inline vec move_els(unsigned int dst_col, unsigned int src_col, unsigned int n) const;
3802
  inline vec neg() const;
3803
  inline vec set_element_si(int pos, int v) const;
3804
  inline vec set_element_val(int pos, val v) const;
3805
  inline vec set_si(int v) const;
3806
  inline vec set_val(val v) const;
3807
  inline int size() const;
3808
  inline vec sort() const;
3809
  static inline vec zero(ctx ctx, unsigned int size);
3810
  inline vec zero_extend(unsigned int size) const;
3811
};
3812
3813
// implementations for isl::aff
3814
2.73k
aff manage(__isl_take isl_aff *ptr) {
3815
2.73k
  return aff(ptr);
3816
2.73k
}
3817
0
aff manage_copy(__isl_keep isl_aff *ptr) {
3818
0
  ptr = isl_aff_copy(ptr);
3819
0
  return aff(ptr);
3820
0
}
3821
3822
aff::aff()
3823
548
    : ptr(nullptr) {}
3824
3825
aff::aff(const aff &obj)
3826
    : ptr(nullptr)
3827
1.69k
{
3828
1.69k
  ptr = obj.copy();
3829
1.69k
}
3830
aff::aff(std::nullptr_t)
3831
    : ptr(nullptr) {}
3832
3833
3834
aff::aff(__isl_take isl_aff *ptr)
3835
2.73k
    : ptr(ptr) {}
3836
3837
aff::aff(local_space ls)
3838
551
{
3839
551
  auto res = isl_aff_zero_on_domain(ls.release());
3840
551
  ptr = res;
3841
551
}
3842
aff::aff(local_space ls, val val)
3843
25
{
3844
25
  auto res = isl_aff_val_on_domain(ls.release(), val.release());
3845
25
  ptr = res;
3846
25
}
3847
aff::aff(ctx ctx, const std::string &str)
3848
{
3849
  auto res = isl_aff_read_from_str(ctx.release(), str.c_str());
3850
  ptr = res;
3851
}
3852
3853
2.10k
aff &aff::operator=(aff obj) {
3854
2.10k
  std::swap(this->ptr, obj.ptr);
3855
2.10k
  return *this;
3856
2.10k
}
3857
3858
5.56k
aff::~aff() {
3859
5.56k
  if (ptr)
3860
3.43k
    isl_aff_free(ptr);
3861
5.56k
}
3862
3863
3.29k
__isl_give isl_aff *aff::copy() const & {
3864
3.29k
  return isl_aff_copy(ptr);
3865
3.29k
}
3866
3867
322
__isl_keep isl_aff *aff::get() const {
3868
322
  return ptr;
3869
322
}
3870
3871
1.57k
__isl_give isl_aff *aff::release() {
3872
1.57k
  isl_aff *tmp = ptr;
3873
1.57k
  ptr = nullptr;
3874
1.57k
  return tmp;
3875
1.57k
}
3876
3877
0
bool aff::is_null() const {
3878
0
  return ptr == nullptr;
3879
0
}
3880
0
aff::operator bool() const {
3881
0
  return !is_null();
3882
0
}
3883
3884
3885
0
ctx aff::get_ctx() const {
3886
0
  return ctx(isl_aff_get_ctx(ptr));
3887
0
}
3888
0
std::string aff::to_str() const {
3889
0
  char *Tmp = isl_aff_to_str(get());
3890
0
  if (!Tmp)
3891
0
    return "";
3892
0
  std::string S(Tmp);
3893
0
  free(Tmp);
3894
0
  return S;
3895
0
}
3896
3897
3898
0
void aff::dump() const {
3899
0
  isl_aff_dump(get());
3900
0
}
3901
3902
3903
aff aff::add(aff aff2) const
3904
17
{
3905
17
  auto res = isl_aff_add(copy(), aff2.release());
3906
17
  return manage(res);
3907
17
}
3908
3909
aff aff::add_coefficient_si(isl::dim type, int pos, int v) const
3910
0
{
3911
0
  auto res = isl_aff_add_coefficient_si(copy(), static_cast<enum isl_dim_type>(type), pos, v);
3912
0
  return manage(res);
3913
0
}
3914
3915
aff aff::add_coefficient_val(isl::dim type, int pos, val v) const
3916
0
{
3917
0
  auto res = isl_aff_add_coefficient_val(copy(), static_cast<enum isl_dim_type>(type), pos, v.release());
3918
0
  return manage(res);
3919
0
}
3920
3921
aff aff::add_constant_num_si(int v) const
3922
0
{
3923
0
  auto res = isl_aff_add_constant_num_si(copy(), v);
3924
0
  return manage(res);
3925
0
}
3926
3927
aff aff::add_constant_si(int v) const
3928
547
{
3929
547
  auto res = isl_aff_add_constant_si(copy(), v);
3930
547
  return manage(res);
3931
547
}
3932
3933
aff aff::add_constant_val(val v) const
3934
0
{
3935
0
  auto res = isl_aff_add_constant_val(copy(), v.release());
3936
0
  return manage(res);
3937
0
}
3938
3939
aff aff::add_dims(isl::dim type, unsigned int n) const
3940
0
{
3941
0
  auto res = isl_aff_add_dims(copy(), static_cast<enum isl_dim_type>(type), n);
3942
0
  return manage(res);
3943
0
}
3944
3945
aff aff::align_params(space model) const
3946
0
{
3947
0
  auto res = isl_aff_align_params(copy(), model.release());
3948
0
  return manage(res);
3949
0
}
3950
3951
aff aff::ceil() const
3952
0
{
3953
0
  auto res = isl_aff_ceil(copy());
3954
0
  return manage(res);
3955
0
}
3956
3957
int aff::coefficient_sgn(isl::dim type, int pos) const
3958
0
{
3959
0
  auto res = isl_aff_coefficient_sgn(get(), static_cast<enum isl_dim_type>(type), pos);
3960
0
  return res;
3961
0
}
3962
3963
int aff::dim(isl::dim type) const
3964
0
{
3965
0
  auto res = isl_aff_dim(get(), static_cast<enum isl_dim_type>(type));
3966
0
  return res;
3967
0
}
3968
3969
aff aff::div(aff aff2) const
3970
17
{
3971
17
  auto res = isl_aff_div(copy(), aff2.release());
3972
17
  return manage(res);
3973
17
}
3974
3975
aff aff::drop_dims(isl::dim type, unsigned int first, unsigned int n) const
3976
0
{
3977
0
  auto res = isl_aff_drop_dims(copy(), static_cast<enum isl_dim_type>(type), first, n);
3978
0
  return manage(res);
3979
0
}
3980
3981
basic_set aff::eq_basic_set(aff aff2) const
3982
0
{
3983
0
  auto res = isl_aff_eq_basic_set(copy(), aff2.release());
3984
0
  return manage(res);
3985
0
}
3986
3987
set aff::eq_set(aff aff2) const
3988
0
{
3989
0
  auto res = isl_aff_eq_set(copy(), aff2.release());
3990
0
  return manage(res);
3991
0
}
3992
3993
val aff::eval(point pnt) const
3994
0
{
3995
0
  auto res = isl_aff_eval(copy(), pnt.release());
3996
0
  return manage(res);
3997
0
}
3998
3999
int aff::find_dim_by_name(isl::dim type, const std::string &name) const
4000
0
{
4001
0
  auto res = isl_aff_find_dim_by_name(get(), static_cast<enum isl_dim_type>(type), name.c_str());
4002
0
  return res;
4003
0
}
4004
4005
aff aff::floor() const
4006
17
{
4007
17
  auto res = isl_aff_floor(copy());
4008
17
  return manage(res);
4009
17
}
4010
4011
aff aff::from_range() const
4012
0
{
4013
0
  auto res = isl_aff_from_range(copy());
4014
0
  return manage(res);
4015
0
}
4016
4017
basic_set aff::ge_basic_set(aff aff2) const
4018
0
{
4019
0
  auto res = isl_aff_ge_basic_set(copy(), aff2.release());
4020
0
  return manage(res);
4021
0
}
4022
4023
set aff::ge_set(aff aff2) const
4024
0
{
4025
0
  auto res = isl_aff_ge_set(copy(), aff2.release());
4026
0
  return manage(res);
4027
0
}
4028
4029
val aff::get_coefficient_val(isl::dim type, int pos) const
4030
0
{
4031
0
  auto res = isl_aff_get_coefficient_val(get(), static_cast<enum isl_dim_type>(type), pos);
4032
0
  return manage(res);
4033
0
}
4034
4035
val aff::get_constant_val() const
4036
158
{
4037
158
  auto res = isl_aff_get_constant_val(get());
4038
158
  return manage(res);
4039
158
}
4040
4041
val aff::get_denominator_val() const
4042
5
{
4043
5
  auto res = isl_aff_get_denominator_val(get());
4044
5
  return manage(res);
4045
5
}
4046
4047
std::string aff::get_dim_name(isl::dim type, unsigned int pos) const
4048
0
{
4049
0
  auto res = isl_aff_get_dim_name(get(), static_cast<enum isl_dim_type>(type), pos);
4050
0
  std::string tmp(res);
4051
0
  return tmp;
4052
0
}
4053
4054
aff aff::get_div(int pos) const
4055
0
{
4056
0
  auto res = isl_aff_get_div(get(), pos);
4057
0
  return manage(res);
4058
0
}
4059
4060
local_space aff::get_domain_local_space() const
4061
0
{
4062
0
  auto res = isl_aff_get_domain_local_space(get());
4063
0
  return manage(res);
4064
0
}
4065
4066
space aff::get_domain_space() const
4067
0
{
4068
0
  auto res = isl_aff_get_domain_space(get());
4069
0
  return manage(res);
4070
0
}
4071
4072
uint32_t aff::get_hash() const
4073
0
{
4074
0
  auto res = isl_aff_get_hash(get());
4075
0
  return res;
4076
0
}
4077
4078
local_space aff::get_local_space() const
4079
0
{
4080
0
  auto res = isl_aff_get_local_space(get());
4081
0
  return manage(res);
4082
0
}
4083
4084
space aff::get_space() const
4085
0
{
4086
0
  auto res = isl_aff_get_space(get());
4087
0
  return manage(res);
4088
0
}
4089
4090
aff aff::gist(set context) const
4091
0
{
4092
0
  auto res = isl_aff_gist(copy(), context.release());
4093
0
  return manage(res);
4094
0
}
4095
4096
aff aff::gist_params(set context) const
4097
0
{
4098
0
  auto res = isl_aff_gist_params(copy(), context.release());
4099
0
  return manage(res);
4100
0
}
4101
4102
basic_set aff::gt_basic_set(aff aff2) const
4103
0
{
4104
0
  auto res = isl_aff_gt_basic_set(copy(), aff2.release());
4105
0
  return manage(res);
4106
0
}
4107
4108
set aff::gt_set(aff aff2) const
4109
0
{
4110
0
  auto res = isl_aff_gt_set(copy(), aff2.release());
4111
0
  return manage(res);
4112
0
}
4113
4114
aff aff::insert_dims(isl::dim type, unsigned int first, unsigned int n) const
4115
0
{
4116
0
  auto res = isl_aff_insert_dims(copy(), static_cast<enum isl_dim_type>(type), first, n);
4117
0
  return manage(res);
4118
0
}
4119
4120
boolean aff::involves_dims(isl::dim type, unsigned int first, unsigned int n) const
4121
0
{
4122
0
  auto res = isl_aff_involves_dims(get(), static_cast<enum isl_dim_type>(type), first, n);
4123
0
  return manage(res);
4124
0
}
4125
4126
boolean aff::is_cst() const
4127
159
{
4128
159
  auto res = isl_aff_is_cst(get());
4129
159
  return manage(res);
4130
159
}
4131
4132
boolean aff::is_nan() const
4133
0
{
4134
0
  auto res = isl_aff_is_nan(get());
4135
0
  return manage(res);
4136
0
}
4137
4138
basic_set aff::le_basic_set(aff aff2) const
4139
0
{
4140
0
  auto res = isl_aff_le_basic_set(copy(), aff2.release());
4141
0
  return manage(res);
4142
0
}
4143
4144
set aff::le_set(aff aff2) const
4145
0
{
4146
0
  auto res = isl_aff_le_set(copy(), aff2.release());
4147
0
  return manage(res);
4148
0
}
4149
4150
basic_set aff::lt_basic_set(aff aff2) const
4151
0
{
4152
0
  auto res = isl_aff_lt_basic_set(copy(), aff2.release());
4153
0
  return manage(res);
4154
0
}
4155
4156
set aff::lt_set(aff aff2) const
4157
0
{
4158
0
  auto res = isl_aff_lt_set(copy(), aff2.release());
4159
0
  return manage(res);
4160
0
}
4161
4162
aff aff::mod(val mod) const
4163
17
{
4164
17
  auto res = isl_aff_mod_val(copy(), mod.release());
4165
17
  return manage(res);
4166
17
}
4167
4168
aff aff::move_dims(isl::dim dst_type, unsigned int dst_pos, isl::dim src_type, unsigned int src_pos, unsigned int n) const
4169
0
{
4170
0
  auto res = isl_aff_move_dims(copy(), static_cast<enum isl_dim_type>(dst_type), dst_pos, static_cast<enum isl_dim_type>(src_type), src_pos, n);
4171
0
  return manage(res);
4172
0
}
4173
4174
aff aff::mul(aff aff2) const
4175
0
{
4176
0
  auto res = isl_aff_mul(copy(), aff2.release());
4177
0
  return manage(res);
4178
0
}
4179
4180
aff aff::nan_on_domain(local_space ls)
4181
0
{
4182
0
  auto res = isl_aff_nan_on_domain(ls.release());
4183
0
  return manage(res);
4184
0
}
4185
4186
set aff::ne_set(aff aff2) const
4187
0
{
4188
0
  auto res = isl_aff_ne_set(copy(), aff2.release());
4189
0
  return manage(res);
4190
0
}
4191
4192
aff aff::neg() const
4193
0
{
4194
0
  auto res = isl_aff_neg(copy());
4195
0
  return manage(res);
4196
0
}
4197
4198
basic_set aff::neg_basic_set() const
4199
0
{
4200
0
  auto res = isl_aff_neg_basic_set(copy());
4201
0
  return manage(res);
4202
0
}
4203
4204
aff aff::param_on_domain_space_id(space space, id id)
4205
0
{
4206
0
  auto res = isl_aff_param_on_domain_space_id(space.release(), id.release());
4207
0
  return manage(res);
4208
0
}
4209
4210
boolean aff::plain_is_equal(const aff &aff2) const
4211
0
{
4212
0
  auto res = isl_aff_plain_is_equal(get(), aff2.get());
4213
0
  return manage(res);
4214
0
}
4215
4216
boolean aff::plain_is_zero() const
4217
0
{
4218
0
  auto res = isl_aff_plain_is_zero(get());
4219
0
  return manage(res);
4220
0
}
4221
4222
aff aff::project_domain_on_params() const
4223
0
{
4224
0
  auto res = isl_aff_project_domain_on_params(copy());
4225
0
  return manage(res);
4226
0
}
4227
4228
aff aff::pullback(multi_aff ma) const
4229
34
{
4230
34
  auto res = isl_aff_pullback_multi_aff(copy(), ma.release());
4231
34
  return manage(res);
4232
34
}
4233
4234
aff aff::pullback_aff(aff aff2) const
4235
0
{
4236
0
  auto res = isl_aff_pullback_aff(copy(), aff2.release());
4237
0
  return manage(res);
4238
0
}
4239
4240
aff aff::scale(val v) const
4241
0
{
4242
0
  auto res = isl_aff_scale_val(copy(), v.release());
4243
0
  return manage(res);
4244
0
}
4245
4246
aff aff::scale_down(val v) const
4247
0
{
4248
0
  auto res = isl_aff_scale_down_val(copy(), v.release());
4249
0
  return manage(res);
4250
0
}
4251
4252
aff aff::scale_down_ui(unsigned int f) const
4253
0
{
4254
0
  auto res = isl_aff_scale_down_ui(copy(), f);
4255
0
  return manage(res);
4256
0
}
4257
4258
aff aff::set_coefficient_si(isl::dim type, int pos, int v) const
4259
0
{
4260
0
  auto res = isl_aff_set_coefficient_si(copy(), static_cast<enum isl_dim_type>(type), pos, v);
4261
0
  return manage(res);
4262
0
}
4263
4264
aff aff::set_coefficient_val(isl::dim type, int pos, val v) const
4265
0
{
4266
0
  auto res = isl_aff_set_coefficient_val(copy(), static_cast<enum isl_dim_type>(type), pos, v.release());
4267
0
  return manage(res);
4268
0
}
4269
4270
aff aff::set_constant_si(int v) const
4271
942
{
4272
942
  auto res = isl_aff_set_constant_si(copy(), v);
4273
942
  return manage(res);
4274
942
}
4275
4276
aff aff::set_constant_val(val v) const
4277
0
{
4278
0
  auto res = isl_aff_set_constant_val(copy(), v.release());
4279
0
  return manage(res);
4280
0
}
4281
4282
aff aff::set_dim_id(isl::dim type, unsigned int pos, id id) const
4283
0
{
4284
0
  auto res = isl_aff_set_dim_id(copy(), static_cast<enum isl_dim_type>(type), pos, id.release());
4285
0
  return manage(res);
4286
0
}
4287
4288
aff aff::set_tuple_id(isl::dim type, id id) const
4289
0
{
4290
0
  auto res = isl_aff_set_tuple_id(copy(), static_cast<enum isl_dim_type>(type), id.release());
4291
0
  return manage(res);
4292
0
}
4293
4294
aff aff::sub(aff aff2) const
4295
0
{
4296
0
  auto res = isl_aff_sub(copy(), aff2.release());
4297
0
  return manage(res);
4298
0
}
4299
4300
aff aff::var_on_domain(local_space ls, isl::dim type, unsigned int pos)
4301
41
{
4302
41
  auto res = isl_aff_var_on_domain(ls.release(), static_cast<enum isl_dim_type>(type), pos);
4303
41
  return manage(res);
4304
41
}
4305
4306
basic_set aff::zero_basic_set() const
4307
0
{
4308
0
  auto res = isl_aff_zero_basic_set(copy());
4309
0
  return manage(res);
4310
0
}
4311
4312
// implementations for isl::aff_list
4313
0
aff_list manage(__isl_take isl_aff_list *ptr) {
4314
0
  return aff_list(ptr);
4315
0
}
4316
0
aff_list manage_copy(__isl_keep isl_aff_list *ptr) {
4317
0
  ptr = isl_aff_list_copy(ptr);
4318
0
  return aff_list(ptr);
4319
0
}
4320
4321
aff_list::aff_list()
4322
    : ptr(nullptr) {}
4323
4324
aff_list::aff_list(const aff_list &obj)
4325
    : ptr(nullptr)
4326
{
4327
  ptr = obj.copy();
4328
}
4329
aff_list::aff_list(std::nullptr_t)
4330
    : ptr(nullptr) {}
4331
4332
4333
aff_list::aff_list(__isl_take isl_aff_list *ptr)
4334
    : ptr(ptr) {}
4335
4336
4337
0
aff_list &aff_list::operator=(aff_list obj) {
4338
0
  std::swap(this->ptr, obj.ptr);
4339
0
  return *this;
4340
0
}
4341
4342
aff_list::~aff_list() {
4343
  if (ptr)
4344
    isl_aff_list_free(ptr);
4345
}
4346
4347
0
__isl_give isl_aff_list *aff_list::copy() const & {
4348
0
  return isl_aff_list_copy(ptr);
4349
0
}
4350
4351
0
__isl_keep isl_aff_list *aff_list::get() const {
4352
0
  return ptr;
4353
0
}
4354
4355
0
__isl_give isl_aff_list *aff_list::release() {
4356
0
  isl_aff_list *tmp = ptr;
4357
0
  ptr = nullptr;
4358
0
  return tmp;
4359
0
}
4360
4361
0
bool aff_list::is_null() const {
4362
0
  return ptr == nullptr;
4363
0
}
4364
0
aff_list::operator bool() const {
4365
0
  return !is_null();
4366
0
}
4367
4368
4369
0
ctx aff_list::get_ctx() const {
4370
0
  return ctx(isl_aff_list_get_ctx(ptr));
4371
0
}
4372
4373
0
void aff_list::dump() const {
4374
0
  isl_aff_list_dump(get());
4375
0
}
4376
4377
4378
aff_list aff_list::add(aff el) const
4379
0
{
4380
0
  auto res = isl_aff_list_add(copy(), el.release());
4381
0
  return manage(res);
4382
0
}
4383
4384
aff_list aff_list::alloc(ctx ctx, int n)
4385
0
{
4386
0
  auto res = isl_aff_list_alloc(ctx.release(), n);
4387
0
  return manage(res);
4388
0
}
4389
4390
aff_list aff_list::concat(aff_list list2) const
4391
0
{
4392
0
  auto res = isl_aff_list_concat(copy(), list2.release());
4393
0
  return manage(res);
4394
0
}
4395
4396
aff_list aff_list::drop(unsigned int first, unsigned int n) const
4397
0
{
4398
0
  auto res = isl_aff_list_drop(copy(), first, n);
4399
0
  return manage(res);
4400
0
}
4401
4402
stat aff_list::foreach(const std::function<stat(aff)> &fn) const
4403
0
{
4404
0
  struct fn_data {
4405
0
    const std::function<stat(aff)> *func;
4406
0
  } fn_data = { &fn };
4407
0
  auto fn_lambda = [](isl_aff *arg_0, void *arg_1) -> isl_stat {
4408
0
    auto *data = static_cast<struct fn_data *>(arg_1);
4409
0
    stat ret = (*data->func)(manage(arg_0));
4410
0
    return ret.release();
4411
0
  };
4412
0
  auto res = isl_aff_list_foreach(get(), fn_lambda, &fn_data);
4413
0
  return manage(res);
4414
0
}
4415
4416
aff_list aff_list::from_aff(aff el)
4417
0
{
4418
0
  auto res = isl_aff_list_from_aff(el.release());
4419
0
  return manage(res);
4420
0
}
4421
4422
aff aff_list::get_aff(int index) const
4423
0
{
4424
0
  auto res = isl_aff_list_get_aff(get(), index);
4425
0
  return manage(res);
4426
0
}
4427
4428
aff aff_list::get_at(int index) const
4429
0
{
4430
0
  auto res = isl_aff_list_get_at(get(), index);
4431
0
  return manage(res);
4432
0
}
4433
4434
aff_list aff_list::insert(unsigned int pos, aff el) const
4435
0
{
4436
0
  auto res = isl_aff_list_insert(copy(), pos, el.release());
4437
0
  return manage(res);
4438
0
}
4439
4440
int aff_list::n_aff() const
4441
0
{
4442
0
  auto res = isl_aff_list_n_aff(get());
4443
0
  return res;
4444
0
}
4445
4446
aff_list aff_list::reverse() const
4447
0
{
4448
0
  auto res = isl_aff_list_reverse(copy());
4449
0
  return manage(res);
4450
0
}
4451
4452
aff_list aff_list::set_aff(int index, aff el) const
4453
0
{
4454
0
  auto res = isl_aff_list_set_aff(copy(), index, el.release());
4455
0
  return manage(res);
4456
0
}
4457
4458
int aff_list::size() const
4459
0
{
4460
0
  auto res = isl_aff_list_size(get());
4461
0
  return res;
4462
0
}
4463
4464
aff_list aff_list::swap(unsigned int pos1, unsigned int pos2) const
4465
0
{
4466
0
  auto res = isl_aff_list_swap(copy(), pos1, pos2);
4467
0
  return manage(res);
4468
0
}
4469
4470
// implementations for isl::ast_build
4471
11
ast_build manage(__isl_take isl_ast_build *ptr) {
4472
11
  return ast_build(ptr);
4473
11
}
4474
697
ast_build manage_copy(__isl_keep isl_ast_build *ptr) {
4475
697
  ptr = isl_ast_build_copy(ptr);
4476
697
  return ast_build(ptr);
4477
697
}
4478
4479
ast_build::ast_build()
4480
    : ptr(nullptr) {}
4481
4482
ast_build::ast_build(const ast_build &obj)
4483
    : ptr(nullptr)
4484
532
{
4485
532
  ptr = obj.copy();
4486
532
}
4487
ast_build::ast_build(std::nullptr_t)
4488
9.19k
    : ptr(nullptr) {}
4489
4490
4491
ast_build::ast_build(__isl_take isl_ast_build *ptr)
4492
708
    : ptr(ptr) {}
4493
4494
ast_build::ast_build(ctx ctx)
4495
{
4496
  auto res = isl_ast_build_alloc(ctx.release());
4497
  ptr = res;
4498
}
4499
4500
521
ast_build &ast_build::operator=(ast_build obj) {
4501
521
  std::swap(this->ptr, obj.ptr);
4502
521
  return *this;
4503
521
}
4504
4505
10.3k
ast_build::~ast_build() {
4506
10.3k
  if (ptr)
4507
1.24k
    isl_ast_build_free(ptr);
4508
10.3k
}
4509
4510
543
__isl_give isl_ast_build *ast_build::copy() const & {
4511
543
  return isl_ast_build_copy(ptr);
4512
543
}
4513
4514
702
__isl_keep isl_ast_build *ast_build::get() const {
4515
702
  return ptr;
4516
702
}
4517
4518
0
__isl_give isl_ast_build *ast_build::release() {
4519
0
  isl_ast_build *tmp = ptr;
4520
0
  ptr = nullptr;
4521
0
  return tmp;
4522
0
}
4523
4524
0
bool ast_build::is_null() const {
4525
0
  return ptr == nullptr;
4526
0
}
4527
0
ast_build::operator bool() const {
4528
0
  return !is_null();
4529
0
}
4530
4531
4532
346
ctx ast_build::get_ctx() const {
4533
346
  return ctx(isl_ast_build_get_ctx(ptr));
4534
346
}
4535
4536
4537
ast_expr ast_build::access_from(pw_multi_aff pma) const
4538
678
{
4539
678
  auto res = isl_ast_build_access_from_pw_multi_aff(get(), pma.release());
4540
678
  return manage(res);
4541
678
}
4542
4543
ast_expr ast_build::access_from(multi_pw_aff mpa) const
4544
0
{
4545
0
  auto res = isl_ast_build_access_from_multi_pw_aff(get(), mpa.release());
4546
0
  return manage(res);
4547
0
}
4548
4549
ast_node ast_build::ast_from_schedule(union_map schedule) const
4550
0
{
4551
0
  auto res = isl_ast_build_ast_from_schedule(get(), schedule.release());
4552
0
  return manage(res);
4553
0
}
4554
4555
ast_expr ast_build::call_from(pw_multi_aff pma) const
4556
0
{
4557
0
  auto res = isl_ast_build_call_from_pw_multi_aff(get(), pma.release());
4558
0
  return manage(res);
4559
0
}
4560
4561
ast_expr ast_build::call_from(multi_pw_aff mpa) const
4562
0
{
4563
0
  auto res = isl_ast_build_call_from_multi_pw_aff(get(), mpa.release());
4564
0
  return manage(res);
4565
0
}
4566
4567
ast_expr ast_build::expr_from(set set) const
4568
10
{
4569
10
  auto res = isl_ast_build_expr_from_set(get(), set.release());
4570
10
  return manage(res);
4571
10
}
4572
4573
ast_expr ast_build::expr_from(pw_aff pa) const
4574
1
{
4575
1
  auto res = isl_ast_build_expr_from_pw_aff(get(), pa.release());
4576
1
  return manage(res);
4577
1
}
4578
4579
ast_build ast_build::from_context(set set)
4580
0
{
4581
0
  auto res = isl_ast_build_from_context(set.release());
4582
0
  return manage(res);
4583
0
}
4584
4585
union_map ast_build::get_schedule() const
4586
13
{
4587
13
  auto res = isl_ast_build_get_schedule(get());
4588
13
  return manage(res);
4589
13
}
4590
4591
space ast_build::get_schedule_space() const
4592
0
{
4593
0
  auto res = isl_ast_build_get_schedule_space(get());
4594
0
  return manage(res);
4595
0
}
4596
4597
ast_node ast_build::node_from_schedule(schedule schedule) const
4598
0
{
4599
0
  auto res = isl_ast_build_node_from_schedule(get(), schedule.release());
4600
0
  return manage(res);
4601
0
}
4602
4603
ast_node ast_build::node_from_schedule_map(union_map schedule) const
4604
0
{
4605
0
  auto res = isl_ast_build_node_from_schedule_map(get(), schedule.release());
4606
0
  return manage(res);
4607
0
}
4608
4609
ast_build ast_build::restrict(set set) const
4610
11
{
4611
11
  auto res = isl_ast_build_restrict(copy(), set.release());
4612
11
  return manage(res);
4613
11
}
4614
4615
// implementations for isl::ast_expr
4616
7.31k
ast_expr manage(__isl_take isl_ast_expr *ptr) {
4617
7.31k
  return ast_expr(ptr);
4618
7.31k
}
4619
289
ast_expr manage_copy(__isl_keep isl_ast_expr *ptr) {
4620
289
  ptr = isl_ast_expr_copy(ptr);
4621
289
  return ast_expr(ptr);
4622
289
}
4623
4624
ast_expr::ast_expr()
4625
513
    : ptr(nullptr) {}
4626
4627
ast_expr::ast_expr(const ast_expr &obj)
4628
    : ptr(nullptr)
4629
3.37k
{
4630
3.37k
  ptr = obj.copy();
4631
3.37k
}
4632
ast_expr::ast_expr(std::nullptr_t)
4633
    : ptr(nullptr) {}
4634
4635
4636
ast_expr::ast_expr(__isl_take isl_ast_expr *ptr)
4637
7.60k
    : ptr(ptr) {}
4638
4639
4640
1.01k
ast_expr &ast_expr::operator=(ast_expr obj) {
4641
1.01k
  std::swap(this->ptr, obj.ptr);
4642
1.01k
  return *this;
4643
1.01k
}
4644
4645
11.4k
ast_expr::~ast_expr() {
4646
11.4k
  if (ptr)
4647
9.22k
    isl_ast_expr_free(ptr);
4648
11.4k
}
4649
4650
4.40k
__isl_give isl_ast_expr *ast_expr::copy() const & {
4651
4.40k
  return isl_ast_expr_copy(ptr);
4652
4.40k
}
4653
4654
10.8k
__isl_keep isl_ast_expr *ast_expr::get() const {
4655
10.8k
  return ptr;
4656
10.8k
}
4657
4658
1.75k
__isl_give isl_ast_expr *ast_expr::release() {
4659
1.75k
  isl_ast_expr *tmp = ptr;
4660
1.75k
  ptr = nullptr;
4661
1.75k
  return tmp;
4662
1.75k
}
4663
4664
340
bool ast_expr::is_null() const {
4665
340
  return ptr == nullptr;
4666
340
}
4667
0
ast_expr::operator bool() const {
4668
0
  return !is_null();
4669
0
}
4670
4671
4672
0
ctx ast_expr::get_ctx() const {
4673
0
  return ctx(isl_ast_expr_get_ctx(ptr));
4674
0
}
4675
0
std::string ast_expr::to_str() const {
4676
0
  char *Tmp = isl_ast_expr_to_str(get());
4677
0
  if (!Tmp)
4678
0
    return "";
4679
0
  std::string S(Tmp);
4680
0
  free(Tmp);
4681
0
  return S;
4682
0
}
4683
4684
4685
0
void ast_expr::dump() const {
4686
0
  isl_ast_expr_dump(get());
4687
0
}
4688
4689
4690
ast_expr ast_expr::access(ast_expr_list indices) const
4691
0
{
4692
0
  auto res = isl_ast_expr_access(copy(), indices.release());
4693
0
  return manage(res);
4694
0
}
4695
4696
ast_expr ast_expr::add(ast_expr expr2) const
4697
0
{
4698
0
  auto res = isl_ast_expr_add(copy(), expr2.release());
4699
0
  return manage(res);
4700
0
}
4701
4702
ast_expr ast_expr::address_of() const
4703
676
{
4704
676
  auto res = isl_ast_expr_address_of(copy());
4705
676
  return manage(res);
4706
676
}
4707
4708
ast_expr ast_expr::call(ast_expr_list arguments) const
4709
0
{
4710
0
  auto res = isl_ast_expr_call(copy(), arguments.release());
4711
0
  return manage(res);
4712
0
}
4713
4714
ast_expr ast_expr::div(ast_expr expr2) const
4715
0
{
4716
0
  auto res = isl_ast_expr_div(copy(), expr2.release());
4717
0
  return manage(res);
4718
0
}
4719
4720
ast_expr ast_expr::eq(ast_expr expr2) const
4721
0
{
4722
0
  auto res = isl_ast_expr_eq(copy(), expr2.release());
4723
0
  return manage(res);
4724
0
}
4725
4726
ast_expr ast_expr::from_id(id id)
4727
0
{
4728
0
  auto res = isl_ast_expr_from_id(id.release());
4729
0
  return manage(res);
4730
0
}
4731
4732
ast_expr ast_expr::from_val(val v)
4733
346
{
4734
346
  auto res = isl_ast_expr_from_val(v.release());
4735
346
  return manage(res);
4736
346
}
4737
4738
ast_expr ast_expr::ge(ast_expr expr2) const
4739
0
{
4740
0
  auto res = isl_ast_expr_ge(copy(), expr2.release());
4741
0
  return manage(res);
4742
0
}
4743
4744
id ast_expr::get_id() const
4745
956
{
4746
956
  auto res = isl_ast_expr_get_id(get());
4747
956
  return manage(res);
4748
956
}
4749
4750
ast_expr ast_expr::get_op_arg(int pos) const
4751
3.54k
{
4752
3.54k
  auto res = isl_ast_expr_get_op_arg(get(), pos);
4753
3.54k
  return manage(res);
4754
3.54k
}
4755
4756
int ast_expr::get_op_n_arg() const
4757
0
{
4758
0
  auto res = isl_ast_expr_get_op_n_arg(get());
4759
0
  return res;
4760
0
}
4761
4762
val ast_expr::get_val() const
4763
931
{
4764
931
  auto res = isl_ast_expr_get_val(get());
4765
931
  return manage(res);
4766
931
}
4767
4768
ast_expr ast_expr::gt(ast_expr expr2) const
4769
0
{
4770
0
  auto res = isl_ast_expr_gt(copy(), expr2.release());
4771
0
  return manage(res);
4772
0
}
4773
4774
boolean ast_expr::is_equal(const ast_expr &expr2) const
4775
0
{
4776
0
  auto res = isl_ast_expr_is_equal(get(), expr2.get());
4777
0
  return manage(res);
4778
0
}
4779
4780
ast_expr ast_expr::le(ast_expr expr2) const
4781
338
{
4782
338
  auto res = isl_ast_expr_le(copy(), expr2.release());
4783
338
  return manage(res);
4784
338
}
4785
4786
ast_expr ast_expr::lt(ast_expr expr2) const
4787
0
{
4788
0
  auto res = isl_ast_expr_lt(copy(), expr2.release());
4789
0
  return manage(res);
4790
0
}
4791
4792
ast_expr ast_expr::mul(ast_expr expr2) const
4793
0
{
4794
0
  auto res = isl_ast_expr_mul(copy(), expr2.release());
4795
0
  return manage(res);
4796
0
}
4797
4798
ast_expr ast_expr::neg() const
4799
0
{
4800
0
  auto res = isl_ast_expr_neg(copy());
4801
0
  return manage(res);
4802
0
}
4803
4804
ast_expr ast_expr::pdiv_q(ast_expr expr2) const
4805
0
{
4806
0
  auto res = isl_ast_expr_pdiv_q(copy(), expr2.release());
4807
0
  return manage(res);
4808
0
}
4809
4810
ast_expr ast_expr::pdiv_r(ast_expr expr2) const
4811
0
{
4812
0
  auto res = isl_ast_expr_pdiv_r(copy(), expr2.release());
4813
0
  return manage(res);
4814
0
}
4815
4816
ast_expr ast_expr::set_op_arg(int pos, ast_expr arg) const
4817
0
{
4818
0
  auto res = isl_ast_expr_set_op_arg(copy(), pos, arg.release());
4819
0
  return manage(res);
4820
0
}
4821
4822
ast_expr ast_expr::sub(ast_expr expr2) const
4823
0
{
4824
0
  auto res = isl_ast_expr_sub(copy(), expr2.release());
4825
0
  return manage(res);
4826
0
}
4827
4828
ast_expr ast_expr::substitute_ids(id_to_ast_expr id2expr) const
4829
0
{
4830
0
  auto res = isl_ast_expr_substitute_ids(copy(), id2expr.release());
4831
0
  return manage(res);
4832
0
}
4833
4834
std::string ast_expr::to_C_str() const
4835
0
{
4836
0
  auto res = isl_ast_expr_to_C_str(get());
4837
0
  std::string tmp(res);
4838
0
  free(res);
4839
0
  return tmp;
4840
0
}
4841
4842
// implementations for isl::ast_expr_list
4843
0
ast_expr_list manage(__isl_take isl_ast_expr_list *ptr) {
4844
0
  return ast_expr_list(ptr);
4845
0
}
4846
0
ast_expr_list manage_copy(__isl_keep isl_ast_expr_list *ptr) {
4847
0
  ptr = isl_ast_expr_list_copy(ptr);
4848
0
  return ast_expr_list(ptr);
4849
0
}
4850
4851
ast_expr_list::ast_expr_list()
4852
    : ptr(nullptr) {}
4853
4854
ast_expr_list::ast_expr_list(const ast_expr_list &obj)
4855
    : ptr(nullptr)
4856
{
4857
  ptr = obj.copy();
4858
}
4859
ast_expr_list::ast_expr_list(std::nullptr_t)
4860
    : ptr(nullptr) {}
4861
4862
4863
ast_expr_list::ast_expr_list(__isl_take isl_ast_expr_list *ptr)
4864
    : ptr(ptr) {}
4865
4866
4867
0
ast_expr_list &ast_expr_list::operator=(ast_expr_list obj) {
4868
0
  std::swap(this->ptr, obj.ptr);
4869
0
  return *this;
4870
0
}
4871
4872
ast_expr_list::~ast_expr_list() {
4873
  if (ptr)
4874
    isl_ast_expr_list_free(ptr);
4875
}
4876
4877
0
__isl_give isl_ast_expr_list *ast_expr_list::copy() const & {
4878
0
  return isl_ast_expr_list_copy(ptr);
4879
0
}
4880
4881
0
__isl_keep isl_ast_expr_list *ast_expr_list::get() const {
4882
0
  return ptr;
4883
0
}
4884
4885
0
__isl_give isl_ast_expr_list *ast_expr_list::release() {
4886
0
  isl_ast_expr_list *tmp = ptr;
4887
0
  ptr = nullptr;
4888
0
  return tmp;
4889
0
}
4890
4891
0
bool ast_expr_list::is_null() const {
4892
0
  return ptr == nullptr;
4893
0
}
4894
0
ast_expr_list::operator bool() const {
4895
0
  return !is_null();
4896
0
}
4897
4898
4899
0
ctx ast_expr_list::get_ctx() const {
4900
0
  return ctx(isl_ast_expr_list_get_ctx(ptr));
4901
0
}
4902
4903
0
void ast_expr_list::dump() const {
4904
0
  isl_ast_expr_list_dump(get());
4905
0
}
4906
4907
4908
ast_expr_list ast_expr_list::add(ast_expr el) const
4909
0
{
4910
0
  auto res = isl_ast_expr_list_add(copy(), el.release());
4911
0
  return manage(res);
4912
0
}
4913
4914
ast_expr_list ast_expr_list::alloc(ctx ctx, int n)
4915
0
{
4916
0
  auto res = isl_ast_expr_list_alloc(ctx.release(), n);
4917
0
  return manage(res);
4918
0
}
4919
4920
ast_expr_list ast_expr_list::concat(ast_expr_list list2) const
4921
0
{
4922
0
  auto res = isl_ast_expr_list_concat(copy(), list2.release());
4923
0
  return manage(res);
4924
0
}
4925
4926
ast_expr_list ast_expr_list::drop(unsigned int first, unsigned int n) const
4927
0
{
4928
0
  auto res = isl_ast_expr_list_drop(copy(), first, n);
4929
0
  return manage(res);
4930
0
}
4931
4932
stat ast_expr_list::foreach(const std::function<stat(ast_expr)> &fn) const
4933
0
{
4934
0
  struct fn_data {
4935
0
    const std::function<stat(ast_expr)> *func;
4936
0
  } fn_data = { &fn };
4937
0
  auto fn_lambda = [](isl_ast_expr *arg_0, void *arg_1) -> isl_stat {
4938
0
    auto *data = static_cast<struct fn_data *>(arg_1);
4939
0
    stat ret = (*data->func)(manage(arg_0));
4940
0
    return ret.release();
4941
0
  };
4942
0
  auto res = isl_ast_expr_list_foreach(get(), fn_lambda, &fn_data);
4943
0
  return manage(res);
4944
0
}
4945
4946
ast_expr_list ast_expr_list::from_ast_expr(ast_expr el)
4947
0
{
4948
0
  auto res = isl_ast_expr_list_from_ast_expr(el.release());
4949
0
  return manage(res);
4950
0
}
4951
4952
ast_expr ast_expr_list::get_ast_expr(int index) const
4953
0
{
4954
0
  auto res = isl_ast_expr_list_get_ast_expr(get(), index);
4955
0
  return manage(res);
4956
0
}
4957
4958
ast_expr ast_expr_list::get_at(int index) const
4959
0
{
4960
0
  auto res = isl_ast_expr_list_get_at(get(), index);
4961
0
  return manage(res);
4962
0
}
4963
4964
ast_expr_list ast_expr_list::insert(unsigned int pos, ast_expr el) const
4965
0
{
4966
0
  auto res = isl_ast_expr_list_insert(copy(), pos, el.release());
4967
0
  return manage(res);
4968
0
}
4969
4970
int ast_expr_list::n_ast_expr() const
4971
0
{
4972
0
  auto res = isl_ast_expr_list_n_ast_expr(get());
4973
0
  return res;
4974
0
}
4975
4976
ast_expr_list ast_expr_list::reverse() const
4977
0
{
4978
0
  auto res = isl_ast_expr_list_reverse(copy());
4979
0
  return manage(res);
4980
0
}
4981
4982
ast_expr_list ast_expr_list::set_ast_expr(int index, ast_expr el) const
4983
0
{
4984
0
  auto res = isl_ast_expr_list_set_ast_expr(copy(), index, el.release());
4985
0
  return manage(res);
4986
0
}
4987
4988
int ast_expr_list::size() const
4989
0
{
4990
0
  auto res = isl_ast_expr_list_size(get());
4991
0
  return res;
4992
0
}
4993
4994
ast_expr_list ast_expr_list::swap(unsigned int pos1, unsigned int pos2) const
4995
0
{
4996
0
  auto res = isl_ast_expr_list_swap(copy(), pos1, pos2);
4997
0
  return manage(res);
4998
0
}
4999
5000
// implementations for isl::ast_node
5001
859
ast_node manage(__isl_take isl_ast_node *ptr) {
5002
859
  return ast_node(ptr);
5003
859
}
5004
54
ast_node manage_copy(__isl_keep isl_ast_node *ptr) {
5005
54
  ptr = isl_ast_node_copy(ptr);
5006
54
  return ast_node(ptr);
5007
54
}
5008
5009
ast_node::ast_node()
5010
    : ptr(nullptr) {}
5011
5012
ast_node::ast_node(const ast_node &obj)
5013
    : ptr(nullptr)
5014
577
{
5015
577
  ptr = obj.copy();
5016
577
}
5017
ast_node::ast_node(std::nullptr_t)
5018
    : ptr(nullptr) {}
5019
5020
5021
ast_node::ast_node(__isl_take isl_ast_node *ptr)
5022
913
    : ptr(ptr) {}
5023
5024
5025
0
ast_node &ast_node::operator=(ast_node obj) {
5026
0
  std::swap(this->ptr, obj.ptr);
5027
0
  return *this;
5028
0
}
5029
5030
1.49k
ast_node::~ast_node() {
5031
1.49k
  if (ptr)
5032
1.21k
    isl_ast_node_free(ptr);
5033
1.49k
}
5034
5035
577
__isl_give isl_ast_node *ast_node::copy() const & {
5036
577
  return isl_ast_node_copy(ptr);
5037
577
}
5038
5039
2.43k
__isl_keep isl_ast_node *ast_node::get() const {
5040
2.43k
  return ptr;
5041
2.43k
}
5042
5043
278
__isl_give isl_ast_node *ast_node::release() {
5044
278
  isl_ast_node *tmp = ptr;
5045
278
  ptr = nullptr;
5046
278
  return tmp;
5047
278
}
5048
5049
0
bool ast_node::is_null() const {
5050
0
  return ptr == nullptr;
5051
0
}
5052
0
ast_node::operator bool() const {
5053
0
  return !is_null();
5054
0
}
5055
5056
5057
0
ctx ast_node::get_ctx() const {
5058
0
  return ctx(isl_ast_node_get_ctx(ptr));
5059
0
}
5060
0
std::string ast_node::to_str() const {
5061
0
  char *Tmp = isl_ast_node_to_str(get());
5062
0
  if (!Tmp)
5063
0
    return "";
5064
0
  std::string S(Tmp);
5065
0
  free(Tmp);
5066
0
  return S;
5067
0
}
5068
5069
5070
0
void ast_node::dump() const {
5071
0
  isl_ast_node_dump(get());
5072
0
}
5073
5074
5075
ast_node ast_node::alloc_user(ast_expr expr)
5076
0
{
5077
0
  auto res = isl_ast_node_alloc_user(expr.release());
5078
0
  return manage(res);
5079
0
}
5080
5081
ast_node_list ast_node::block_get_children() const
5082
2
{
5083
2
  auto res = isl_ast_node_block_get_children(get());
5084
2
  return manage(res);
5085
2
}
5086
5087
ast_node ast_node::for_get_body() const
5088
578
{
5089
578
  auto res = isl_ast_node_for_get_body(get());
5090
578
  return manage(res);
5091
578
}
5092
5093
ast_expr ast_node::for_get_cond() const
5094
329
{
5095
329
  auto res = isl_ast_node_for_get_cond(get());
5096
329
  return manage(res);
5097
329
}
5098
5099
ast_expr ast_node::for_get_inc() const
5100
299
{
5101
299
  auto res = isl_ast_node_for_get_inc(get());
5102
299
  return manage(res);
5103
299
}
5104
5105
ast_expr ast_node::for_get_init() const
5106
299
{
5107
299
  auto res = isl_ast_node_for_get_init(get());
5108
299
  return manage(res);
5109
299
}
5110
5111
ast_expr ast_node::for_get_iterator() const
5112
607
{
5113
607
  auto res = isl_ast_node_for_get_iterator(get());
5114
607
  return manage(res);
5115
607
}
5116
5117
boolean ast_node::for_is_degenerate() const
5118
0
{
5119
0
  auto res = isl_ast_node_for_is_degenerate(get());
5120
0
  return manage(res);
5121
0
}
5122
5123
id ast_node::get_annotation() const
5124
0
{
5125
0
  auto res = isl_ast_node_get_annotation(get());
5126
0
  return manage(res);
5127
0
}
5128
5129
ast_expr ast_node::if_get_cond() const
5130
0
{
5131
0
  auto res = isl_ast_node_if_get_cond(get());
5132
0
  return manage(res);
5133
0
}
5134
5135
ast_node ast_node::if_get_else() const
5136
0
{
5137
0
  auto res = isl_ast_node_if_get_else(get());
5138
0
  return manage(res);
5139
0
}
5140
5141
ast_node ast_node::if_get_then() const
5142
0
{
5143
0
  auto res = isl_ast_node_if_get_then(get());
5144
0
  return manage(res);
5145
0
}
5146
5147
boolean ast_node::if_has_else() const
5148
0
{
5149
0
  auto res = isl_ast_node_if_has_else(get());
5150
0
  return manage(res);
5151
0
}
5152
5153
id ast_node::mark_get_id() const
5154
19
{
5155
19
  auto res = isl_ast_node_mark_get_id(get());
5156
19
  return manage(res);
5157
19
}
5158
5159
ast_node ast_node::mark_get_node() const
5160
0
{
5161
0
  auto res = isl_ast_node_mark_get_node(get());
5162
0
  return manage(res);
5163
0
}
5164
5165
ast_node ast_node::set_annotation(id annotation) const
5166
0
{
5167
0
  auto res = isl_ast_node_set_annotation(copy(), annotation.release());
5168
0
  return manage(res);
5169
0
}
5170
5171
std::string ast_node::to_C_str() const
5172
0
{
5173
0
  auto res = isl_ast_node_to_C_str(get());
5174
0
  std::string tmp(res);
5175
0
  free(res);
5176
0
  return tmp;
5177
0
}
5178
5179
ast_expr ast_node::user_get_expr() const
5180
2
{
5181
2
  auto res = isl_ast_node_user_get_expr(get());
5182
2
  return manage(res);
5183
2
}
5184
5185
// implementations for isl::ast_node_list
5186
2
ast_node_list manage(__isl_take isl_ast_node_list *ptr) {
5187
2
  return ast_node_list(ptr);
5188
2
}
5189
0
ast_node_list manage_copy(__isl_keep isl_ast_node_list *ptr) {
5190
0
  ptr = isl_ast_node_list_copy(ptr);
5191
0
  return ast_node_list(ptr);
5192
0
}
5193
5194
ast_node_list::ast_node_list()
5195
    : ptr(nullptr) {}
5196
5197
ast_node_list::ast_node_list(const ast_node_list &obj)
5198
    : ptr(nullptr)
5199
{
5200
  ptr = obj.copy();
5201
}
5202
ast_node_list::ast_node_list(std::nullptr_t)
5203
    : ptr(nullptr) {}
5204
5205
5206
ast_node_list::ast_node_list(__isl_take isl_ast_node_list *ptr)
5207
2
    : ptr(ptr) {}
5208
5209
5210
0
ast_node_list &ast_node_list::operator=(ast_node_list obj) {
5211
0
  std::swap(this->ptr, obj.ptr);
5212
0
  return *this;
5213
0
}
5214
5215
2
ast_node_list::~ast_node_list() {
5216
2
  if (ptr)
5217
2
    isl_ast_node_list_free(ptr);
5218
2
}
5219
5220
0
__isl_give isl_ast_node_list *ast_node_list::copy() const & {
5221
0
  return isl_ast_node_list_copy(ptr);
5222
0
}
5223
5224
5
__isl_keep isl_ast_node_list *ast_node_list::get() const {
5225
5
  return ptr;
5226
5
}
5227
5228
0
__isl_give isl_ast_node_list *ast_node_list::release() {
5229
0
  isl_ast_node_list *tmp = ptr;
5230
0
  ptr = nullptr;
5231
0
  return tmp;
5232
0
}
5233
5234
0
bool ast_node_list::is_null() const {
5235
0
  return ptr == nullptr;
5236
0
}
5237
0
ast_node_list::operator bool() const {
5238
0
  return !is_null();
5239
0
}
5240
5241
5242
0
ctx ast_node_list::get_ctx() const {
5243
0
  return ctx(isl_ast_node_list_get_ctx(ptr));
5244
0
}
5245
5246
0
void ast_node_list::dump() const {
5247
0
  isl_ast_node_list_dump(get());
5248
0
}
5249
5250
5251
ast_node_list ast_node_list::add(ast_node el) const
5252
0
{
5253
0
  auto res = isl_ast_node_list_add(copy(), el.release());
5254
0
  return manage(res);
5255
0
}
5256
5257
ast_node_list ast_node_list::alloc(ctx ctx, int n)
5258
0
{
5259
0
  auto res = isl_ast_node_list_alloc(ctx.release(), n);
5260
0
  return manage(res);
5261
0
}
5262
5263
ast_node_list ast_node_list::concat(ast_node_list list2) const
5264
0
{
5265
0
  auto res = isl_ast_node_list_concat(copy(), list2.release());
5266
0
  return manage(res);
5267
0
}
5268
5269
ast_node_list ast_node_list::drop(unsigned int first, unsigned int n) const
5270
0
{
5271
0
  auto res = isl_ast_node_list_drop(copy(), first, n);
5272
0
  return manage(res);
5273
0
}
5274
5275
stat ast_node_list::foreach(const std::function<stat(ast_node)> &fn) const
5276
0
{
5277
0
  struct fn_data {
5278
0
    const std::function<stat(ast_node)> *func;
5279
0
  } fn_data = { &fn };
5280
0
  auto fn_lambda = [](isl_ast_node *arg_0, void *arg_1) -> isl_stat {
5281
0
    auto *data = static_cast<struct fn_data *>(arg_1);
5282
0
    stat ret = (*data->func)(manage(arg_0));
5283
0
    return ret.release();
5284
0
  };
5285
0
  auto res = isl_ast_node_list_foreach(get(), fn_lambda, &fn_data);
5286
0
  return manage(res);
5287
0
}
5288
5289
ast_node_list ast_node_list::from_ast_node(ast_node el)
5290
0
{
5291
0
  auto res = isl_ast_node_list_from_ast_node(el.release());
5292
0
  return manage(res);
5293
0
}
5294
5295
ast_node ast_node_list::get_ast_node(int index) const
5296
0
{
5297
0
  auto res = isl_ast_node_list_get_ast_node(get(), index);
5298
0
  return manage(res);
5299
0
}
5300
5301
ast_node ast_node_list::get_at(int index) const
5302
3
{
5303
3
  auto res = isl_ast_node_list_get_at(get(), index);
5304
3
  return manage(res);
5305
3
}
5306
5307
ast_node_list ast_node_list::insert(unsigned int pos, ast_node el) const
5308
0
{
5309
0
  auto res = isl_ast_node_list_insert(copy(), pos, el.release());
5310
0
  return manage(res);
5311
0
}
5312
5313
int ast_node_list::n_ast_node() const
5314
0
{
5315
0
  auto res = isl_ast_node_list_n_ast_node(get());
5316
0
  return res;
5317
0
}
5318
5319
ast_node_list ast_node_list::reverse() const
5320
0
{
5321
0
  auto res = isl_ast_node_list_reverse(copy());
5322
0
  return manage(res);
5323
0
}
5324
5325
ast_node_list ast_node_list::set_ast_node(int index, ast_node el) const
5326
0
{
5327
0
  auto res = isl_ast_node_list_set_ast_node(copy(), index, el.release());
5328
0
  return manage(res);
5329
0
}
5330
5331
int ast_node_list::size() const
5332
2
{
5333
2
  auto res = isl_ast_node_list_size(get());
5334
2
  return res;
5335
2
}
5336
5337
ast_node_list ast_node_list::swap(unsigned int pos1, unsigned int pos2) const
5338
0
{
5339
0
  auto res = isl_ast_node_list_swap(copy(), pos1, pos2);
5340
0
  return manage(res);
5341
0
}
5342
5343
// implementations for isl::basic_map
5344
2.02k
basic_map manage(__isl_take isl_basic_map *ptr) {
5345
2.02k
  return basic_map(ptr);
5346
2.02k
}
5347
0
basic_map manage_copy(__isl_keep isl_basic_map *ptr) {
5348
0
  ptr = isl_basic_map_copy(ptr);
5349
0
  return basic_map(ptr);
5350
0
}
5351
5352
basic_map::basic_map()
5353
0
    : ptr(nullptr) {}
5354
5355
basic_map::basic_map(const basic_map &obj)
5356
    : ptr(nullptr)
5357
543
{
5358
543
  ptr = obj.copy();
5359
543
}
5360
basic_map::basic_map(std::nullptr_t)
5361
    : ptr(nullptr) {}
5362
5363
5364
basic_map::basic_map(__isl_take isl_basic_map *ptr)
5365
2.02k
    : ptr(ptr) {}
5366
5367
basic_map::basic_map(ctx ctx, const std::string &str)
5368
{
5369
  auto res = isl_basic_map_read_from_str(ctx.release(), str.c_str());
5370
  ptr = res;
5371
}
5372
5373
1.34k
basic_map &basic_map::operator=(basic_map obj) {
5374
1.34k
  std::swap(this->ptr, obj.ptr);
5375
1.34k
  return *this;
5376
1.34k
}
5377
5378
2.57k
basic_map::~basic_map() {
5379
2.57k
  if (ptr)
5380
2.09k
    isl_basic_map_free(ptr);
5381
2.57k
}
5382
5383
1.89k
__isl_give isl_basic_map *basic_map::copy() const & {
5384
1.89k
  return isl_basic_map_copy(ptr);
5385
1.89k
}
5386
5387
208
__isl_keep isl_basic_map *basic_map::get() const {
5388
208
  return ptr;
5389
208
}
5390
5391
476
__isl_give isl_basic_map *basic_map::release() {
5392
476
  isl_basic_map *tmp = ptr;
5393
476
  ptr = nullptr;
5394
476
  return tmp;
5395
476
}
5396
5397
0
bool basic_map::is_null() const {
5398
0
  return ptr == nullptr;
5399
0
}
5400
0
basic_map::operator bool() const {
5401
0
  return !is_null();
5402
0
}
5403
5404
5405
0
ctx basic_map::get_ctx() const {
5406
0
  return ctx(isl_basic_map_get_ctx(ptr));
5407
0
}
5408
0
std::string basic_map::to_str() const {
5409
0
  char *Tmp = isl_basic_map_to_str(get());
5410
0
  if (!Tmp)
5411
0
    return "";
5412
0
  std::string S(Tmp);