Coverage Report

Created: 2017-03-28 09:59

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