Polly 24.0.0git
typed_cpp.h
Go to the documentation of this file.
1/// These are automatically generated templated C++ bindings for isl.
2///
3/// isl is a library for computing with integer sets and maps described by
4/// Presburger formulas. On top of this, isl provides various tools for
5/// polyhedral compilation, ranging from dependence analysis over scheduling
6/// to AST generation.
7
8#ifndef ISL_TYPED_CPP
9#define ISL_TYPED_CPP
10
11#include <type_traits>
12
13#include <isl/cpp.h>
14
15namespace isl {
16namespace typed {
17
18template <typename Domain, typename Range>
19struct pair {};
20
21struct Anonymous;
22
23
24template <typename...>
25struct aff;
26
27template <typename...Ts>
28using aff_on = aff<Ts..., Anonymous>;
29
30template <typename...>
31struct aff_list;
32
33template <typename...Ts>
35
36template <typename...>
37struct basic_map;
38
39template <typename...>
40struct basic_set;
41
42template <typename...>
43struct fixed_box;
44
45template <typename...>
46struct id;
47
48template <typename...>
49struct id_list;
50
51template <typename...>
52struct map;
53
54template <typename...>
55struct map_list;
56
57template <typename...>
58struct multi_aff;
59
60template <typename...>
61struct multi_id;
62
63template <typename...>
65
66template <typename...>
68
69template <typename...>
70struct multi_val;
71
72template <typename...>
73struct point;
74
75template <typename...>
76struct pw_aff;
77
78template <typename...Ts>
79using pw_aff_on = pw_aff<Ts..., Anonymous>;
80
81template <typename...>
83
84template <typename...Ts>
86
87template <typename...>
89
90template <typename...>
92
93template <typename...>
94struct set;
95
96template <typename...>
97struct set_list;
98
99template <typename...>
100struct space;
101
102template <typename...>
104
105template <typename...>
107
108template <typename...Ts>
110
111template <typename...>
113
114template <typename...Ts>
116
117template <typename...>
119
120template <typename...>
122
123template <typename...>
125
126template <typename...>
127struct val;
128
129template <typename...>
130struct val_list;
131
132template <>
133struct aff<Anonymous> : public isl::aff {
134 template <typename...>
135 friend struct aff;
136 template <typename...>
137 friend struct aff_list;
138 template <typename...>
139 friend struct basic_map;
140 template <typename...>
141 friend struct basic_set;
142 template <typename...>
143 friend struct fixed_box;
144 template <typename...>
145 friend struct id;
146 template <typename...>
147 friend struct id_list;
148 template <typename...>
149 friend struct map;
150 template <typename...>
151 friend struct map_list;
152 template <typename...>
153 friend struct multi_aff;
154 template <typename...>
155 friend struct multi_id;
156 template <typename...>
157 friend struct multi_pw_aff;
158 template <typename...>
159 friend struct multi_union_pw_aff;
160 template <typename...>
161 friend struct multi_val;
162 template <typename...>
163 friend struct point;
164 template <typename...>
165 friend struct pw_aff;
166 template <typename...>
167 friend struct pw_aff_list;
168 template <typename...>
169 friend struct pw_multi_aff;
170 template <typename...>
171 friend struct pw_multi_aff_list;
172 template <typename...>
173 friend struct set;
174 template <typename...>
175 friend struct set_list;
176 template <typename...>
177 friend struct space;
178 template <typename...>
179 friend struct union_map;
180 template <typename...>
181 friend struct union_pw_aff;
182 template <typename...>
183 friend struct union_pw_aff_list;
184 template <typename...>
185 friend struct union_pw_multi_aff;
186 template <typename...>
187 friend struct union_set;
188 template <typename...>
189 friend struct union_set_list;
190 template <typename...>
191 friend struct val;
192 template <typename...>
193 friend struct val_list;
194
195 aff() = default;
196 aff(const isl::aff &obj) : isl::aff(obj) {}
197 static aff from(const isl::aff &obj) {
198 return aff(obj);
199 }
200 inline explicit aff(const isl::ctx &ctx, const std::string &str);
212 template <typename Range>
215 inline typed::map<Anonymous> as_map() const = delete;
221 inline typed::aff<Anonymous> at(int pos) const;
223 inline typed::basic_set<> bind(const std::string &id) const;
229 inline typed::pw_aff<Anonymous> cond(const typed::pw_aff<Anonymous> &pwaff_true, const typed::pw_aff<Anonymous> &pwaff_false) const;
233 inline typed::set<> domain() const;
234 inline typed::aff<Anonymous> domain_reverse() const = delete;
238 inline typed::set<Anonymous> ge_set(const typed::aff<> &aff2) const = delete;
239 inline typed::set<Anonymous> ge_set(const typed::pw_aff<> &pwaff2) const = delete;
247 inline typed::set<Anonymous> gt_set(const typed::aff<> &aff2) const = delete;
248 inline typed::set<Anonymous> gt_set(const typed::pw_aff<> &pwaff2) const = delete;
250 template <typename Domain>
257 inline typed::set<Anonymous> le_set(const typed::aff<> &aff2) const = delete;
258 inline typed::set<Anonymous> le_set(const typed::pw_aff<> &pwaff2) const = delete;
260 inline typed::set<Anonymous> lt_set(const typed::aff<> &aff2) const = delete;
261 inline typed::set<Anonymous> lt_set(const typed::pw_aff<> &pwaff2) const = delete;
271 inline typed::aff<Anonymous> mod(long mod) const;
273 inline typed::set<> params() const;
276 template <typename Range>
278 template <typename Range>
280 template <typename Range>
283 inline typed::pw_aff<Anonymous> pullback(const typed::multi_pw_aff<> &mpa) const = delete;
286 inline typed::aff<Anonymous> pullback(const typed::aff<> &ma) const = delete;
296 inline typed::aff<Anonymous> scale(long v) const;
299 inline typed::aff<Anonymous> scale_down(long v) const;
304 template <typename Domain2>
306 template <typename Domain2>
307 inline typed::multi_aff<Domain2> set_range_tuple(const std::string &id) const;
325 template <typename Domain>
333};
334
335template <typename Domain>
336struct aff<Domain, Anonymous> : public isl::aff {
337 template <typename...>
338 friend struct aff;
339 template <typename...>
340 friend struct aff_list;
341 template <typename...>
342 friend struct basic_map;
343 template <typename...>
344 friend struct basic_set;
345 template <typename...>
346 friend struct fixed_box;
347 template <typename...>
348 friend struct id;
349 template <typename...>
350 friend struct id_list;
351 template <typename...>
352 friend struct map;
353 template <typename...>
354 friend struct map_list;
355 template <typename...>
356 friend struct multi_aff;
357 template <typename...>
358 friend struct multi_id;
359 template <typename...>
360 friend struct multi_pw_aff;
361 template <typename...>
362 friend struct multi_union_pw_aff;
363 template <typename...>
364 friend struct multi_val;
365 template <typename...>
366 friend struct point;
367 template <typename...>
368 friend struct pw_aff;
369 template <typename...>
370 friend struct pw_aff_list;
371 template <typename...>
372 friend struct pw_multi_aff;
373 template <typename...>
374 friend struct pw_multi_aff_list;
375 template <typename...>
376 friend struct set;
377 template <typename...>
378 friend struct set_list;
379 template <typename...>
380 friend struct space;
381 template <typename...>
382 friend struct union_map;
383 template <typename...>
384 friend struct union_pw_aff;
385 template <typename...>
386 friend struct union_pw_aff_list;
387 template <typename...>
388 friend struct union_pw_multi_aff;
389 template <typename...>
390 friend struct union_set;
391 template <typename...>
392 friend struct union_set_list;
393 template <typename...>
394 friend struct val;
395 template <typename...>
396 friend struct val_list;
397
398 aff() = default;
399 template <typename Arg1,
400 typename std::enable_if<
401 std::is_base_of<Domain, Arg1>{},
402 bool>::type = true>
404 private:
405 template <typename base,
406 typename std::enable_if<
407 std::is_same<base, isl::aff>{}, bool>::type = true>
408 aff(const base &obj) : isl::aff(obj) {}
409 public:
410 static aff from(const isl::aff &obj) {
411 return aff(obj);
412 }
413 inline explicit aff(const isl::ctx &ctx, const std::string &str);
425 template <typename Range2>
432 inline typed::set<Domain, Anonymous> as_set() const = delete;
436 inline typed::basic_set<Domain> bind(const std::string &id) const;
485 inline typed::set<> params() const;
488 template <typename Domain2, typename Range2>
490 template <typename Domain2, typename Range2>
492 template <typename Domain2, typename Range2>
494 template <typename Domain2>
497 template <typename Domain2>
500 template <typename Domain2>
503 template <typename Domain2>
506 template <typename Domain2>
512 template <typename Range2>
514 template <typename Range2>
516 template <typename Range2>
518 template <typename Range2>
520 template <typename Range2>
531 template <typename Range2>
533 template <typename Range2>
534 inline typed::multi_aff<Domain, Range2> set_range_tuple(const std::string &id) const;
559};
560
561template <typename Domain2, typename Range2>
563 template <typename...>
564 friend struct aff;
565 template <typename...>
566 friend struct aff_list;
567 template <typename...>
568 friend struct basic_map;
569 template <typename...>
570 friend struct basic_set;
571 template <typename...>
572 friend struct fixed_box;
573 template <typename...>
574 friend struct id;
575 template <typename...>
576 friend struct id_list;
577 template <typename...>
578 friend struct map;
579 template <typename...>
580 friend struct map_list;
581 template <typename...>
582 friend struct multi_aff;
583 template <typename...>
584 friend struct multi_id;
585 template <typename...>
586 friend struct multi_pw_aff;
587 template <typename...>
588 friend struct multi_union_pw_aff;
589 template <typename...>
590 friend struct multi_val;
591 template <typename...>
592 friend struct point;
593 template <typename...>
594 friend struct pw_aff;
595 template <typename...>
596 friend struct pw_aff_list;
597 template <typename...>
598 friend struct pw_multi_aff;
599 template <typename...>
600 friend struct pw_multi_aff_list;
601 template <typename...>
602 friend struct set;
603 template <typename...>
604 friend struct set_list;
605 template <typename...>
606 friend struct space;
607 template <typename...>
608 friend struct union_map;
609 template <typename...>
610 friend struct union_pw_aff;
611 template <typename...>
612 friend struct union_pw_aff_list;
613 template <typename...>
614 friend struct union_pw_multi_aff;
615 template <typename...>
616 friend struct union_set;
617 template <typename...>
618 friend struct union_set_list;
619 template <typename...>
620 friend struct val;
621 template <typename...>
622 friend struct val_list;
623
624 aff() = default;
625 template <typename Arg1, typename Arg2,
626 typename std::enable_if<
627 std::is_base_of<Domain2, Arg1>{} &&
628 std::is_base_of<Range2, Arg2>{},
629 bool>::type = true>
631 private:
632 template <typename base,
633 typename std::enable_if<
634 std::is_same<base, isl::aff>{}, bool>::type = true>
635 aff(const base &obj) : isl::aff(obj) {}
636 public:
637 static aff from(const isl::aff &obj) {
638 return aff(obj);
639 }
640 inline explicit aff(const isl::ctx &ctx, const std::string &str);
652 template <typename Arg1>
663 inline typed::basic_set<pair<Domain2, Range2>> bind(const std::string &id) const;
712 inline typed::set<> params() const;
713 template <typename Domain3>
715 template <typename Domain3>
717 template <typename Arg1, typename Arg2>
719 template <typename Arg1, typename Arg2>
721 template <typename Arg1, typename Arg2>
723 template <typename Arg1>
726 template <typename Arg1>
729 template <typename Arg1>
732 template <typename Arg1>
735 template <typename Arg1>
741 template <typename Arg1>
743 template <typename Arg1>
745 template <typename Arg1>
747 template <typename Arg1>
749 template <typename Arg1>
760 template <typename Arg1>
762 template <typename Arg1>
763 inline typed::multi_aff<pair<Domain2, Range2>, Arg1> set_range_tuple(const std::string &id) const;
788};
789
790template <>
792 template <typename...>
793 friend struct aff;
794 template <typename...>
795 friend struct aff_list;
796 template <typename...>
797 friend struct basic_map;
798 template <typename...>
799 friend struct basic_set;
800 template <typename...>
801 friend struct fixed_box;
802 template <typename...>
803 friend struct id;
804 template <typename...>
805 friend struct id_list;
806 template <typename...>
807 friend struct map;
808 template <typename...>
809 friend struct map_list;
810 template <typename...>
811 friend struct multi_aff;
812 template <typename...>
813 friend struct multi_id;
814 template <typename...>
815 friend struct multi_pw_aff;
816 template <typename...>
817 friend struct multi_union_pw_aff;
818 template <typename...>
819 friend struct multi_val;
820 template <typename...>
821 friend struct point;
822 template <typename...>
823 friend struct pw_aff;
824 template <typename...>
825 friend struct pw_aff_list;
826 template <typename...>
827 friend struct pw_multi_aff;
828 template <typename...>
829 friend struct pw_multi_aff_list;
830 template <typename...>
831 friend struct set;
832 template <typename...>
833 friend struct set_list;
834 template <typename...>
835 friend struct space;
836 template <typename...>
837 friend struct union_map;
838 template <typename...>
839 friend struct union_pw_aff;
840 template <typename...>
841 friend struct union_pw_aff_list;
842 template <typename...>
843 friend struct union_pw_multi_aff;
844 template <typename...>
845 friend struct union_set;
846 template <typename...>
847 friend struct union_set_list;
848 template <typename...>
849 friend struct val;
850 template <typename...>
851 friend struct val_list;
852
853 aff_list() = default;
856 return aff_list(obj);
857 }
858 inline explicit aff_list(const isl::ctx &ctx, int n);
859 inline explicit aff_list(const typed::aff<Anonymous> &el);
860 inline explicit aff_list(const isl::ctx &ctx, const std::string &str);
862 inline typed::aff<Anonymous> at(int index) const;
863 inline typed::aff<Anonymous> get_at(int index) const = delete;
864 inline typed::aff_list<Anonymous> drop(unsigned int first, unsigned int n) const;
865 inline void foreach(const std::function<void(typed::aff<Anonymous>)> &fn) const;
866 inline void foreach_scc(const std::function<bool(typed::aff<Anonymous>, typed::aff<Anonymous>)> &follows, const std::function<void(typed::aff_list<Anonymous>)> &fn) const;
867 inline typed::aff_list<Anonymous> set_at(int index, const typed::aff<Anonymous> &el) const;
868};
869
870template <typename Domain>
872 template <typename...>
873 friend struct aff;
874 template <typename...>
875 friend struct aff_list;
876 template <typename...>
877 friend struct basic_map;
878 template <typename...>
879 friend struct basic_set;
880 template <typename...>
881 friend struct fixed_box;
882 template <typename...>
883 friend struct id;
884 template <typename...>
885 friend struct id_list;
886 template <typename...>
887 friend struct map;
888 template <typename...>
889 friend struct map_list;
890 template <typename...>
891 friend struct multi_aff;
892 template <typename...>
893 friend struct multi_id;
894 template <typename...>
895 friend struct multi_pw_aff;
896 template <typename...>
897 friend struct multi_union_pw_aff;
898 template <typename...>
899 friend struct multi_val;
900 template <typename...>
901 friend struct point;
902 template <typename...>
903 friend struct pw_aff;
904 template <typename...>
905 friend struct pw_aff_list;
906 template <typename...>
907 friend struct pw_multi_aff;
908 template <typename...>
909 friend struct pw_multi_aff_list;
910 template <typename...>
911 friend struct set;
912 template <typename...>
913 friend struct set_list;
914 template <typename...>
915 friend struct space;
916 template <typename...>
917 friend struct union_map;
918 template <typename...>
919 friend struct union_pw_aff;
920 template <typename...>
921 friend struct union_pw_aff_list;
922 template <typename...>
923 friend struct union_pw_multi_aff;
924 template <typename...>
925 friend struct union_set;
926 template <typename...>
927 friend struct union_set_list;
928 template <typename...>
929 friend struct val;
930 template <typename...>
931 friend struct val_list;
932
933 aff_list() = default;
934 template <typename Arg1,
935 typename std::enable_if<
936 std::is_base_of<Domain, Arg1>{},
937 bool>::type = true>
939 private:
940 template <typename base,
941 typename std::enable_if<
942 std::is_same<base, isl::aff_list>{}, bool>::type = true>
943 aff_list(const base &obj) : isl::aff_list(obj) {}
944 public:
946 return aff_list(obj);
947 }
948 inline explicit aff_list(const isl::ctx &ctx, int n);
949 inline explicit aff_list(const typed::aff<Domain, Anonymous> &el);
950 inline explicit aff_list(const isl::ctx &ctx, const std::string &str);
952 inline typed::aff<Domain, Anonymous> at(int index) const;
953 inline typed::aff<Domain, Anonymous> get_at(int index) const = delete;
954 inline typed::aff_list<Domain, Anonymous> drop(unsigned int first, unsigned int n) const;
955 inline void foreach(const std::function<void(typed::aff<Domain, Anonymous>)> &fn) const;
956 inline void foreach_scc(const std::function<bool(typed::aff<Domain, Anonymous>, typed::aff<Domain, Anonymous>)> &follows, const std::function<void(typed::aff_list<Domain, Anonymous>)> &fn) const;
958};
959
960template <typename Domain, typename Range>
962 template <typename...>
963 friend struct aff;
964 template <typename...>
965 friend struct aff_list;
966 template <typename...>
967 friend struct basic_map;
968 template <typename...>
969 friend struct basic_set;
970 template <typename...>
971 friend struct fixed_box;
972 template <typename...>
973 friend struct id;
974 template <typename...>
975 friend struct id_list;
976 template <typename...>
977 friend struct map;
978 template <typename...>
979 friend struct map_list;
980 template <typename...>
981 friend struct multi_aff;
982 template <typename...>
983 friend struct multi_id;
984 template <typename...>
985 friend struct multi_pw_aff;
986 template <typename...>
987 friend struct multi_union_pw_aff;
988 template <typename...>
989 friend struct multi_val;
990 template <typename...>
991 friend struct point;
992 template <typename...>
993 friend struct pw_aff;
994 template <typename...>
995 friend struct pw_aff_list;
996 template <typename...>
997 friend struct pw_multi_aff;
998 template <typename...>
999 friend struct pw_multi_aff_list;
1000 template <typename...>
1001 friend struct set;
1002 template <typename...>
1003 friend struct set_list;
1004 template <typename...>
1005 friend struct space;
1006 template <typename...>
1007 friend struct union_map;
1008 template <typename...>
1009 friend struct union_pw_aff;
1010 template <typename...>
1011 friend struct union_pw_aff_list;
1012 template <typename...>
1013 friend struct union_pw_multi_aff;
1014 template <typename...>
1015 friend struct union_set;
1016 template <typename...>
1017 friend struct union_set_list;
1018 template <typename...>
1019 friend struct val;
1020 template <typename...>
1021 friend struct val_list;
1022
1023 basic_map() = default;
1024 template <typename Arg1, typename Arg2,
1025 typename std::enable_if<
1026 std::is_base_of<Domain, Arg1>{} &&
1027 std::is_base_of<Range, Arg2>{},
1028 bool>::type = true>
1030 private:
1031 template <typename base,
1032 typename std::enable_if<
1033 std::is_same<base, isl::basic_map>{}, bool>::type = true>
1034 basic_map(const base &obj) : isl::basic_map(obj) {}
1035 public:
1037 return basic_map(obj);
1038 }
1039 inline explicit basic_map(const isl::ctx &ctx, const std::string &str);
1040 template <typename Domain2>
1042 template <typename Domain2>
1044 template <typename Domain2>
1046 template <typename Range2>
1048 template <typename Range2>
1050 template <typename Range2>
1059 inline typed::map<Domain, Range> curry() const = delete;
1067 template <typename Domain2>
1069 template <typename Domain2>
1073 inline typed::map<Domain, Range> eq_at(const typed::multi_pw_aff<> &mpa) const = delete;
1075 inline bool every_map(const std::function<bool(typed::map<Domain, Range>)> &test) const;
1079 inline void foreach_basic_map(const std::function<void(typed::basic_map<Domain, Range>)> &fn) const;
1080 inline void foreach_map(const std::function<void(typed::map<Domain, Range>)> &fn) const;
1119 inline typed::set<> params() const;
1120 template <typename Domain2>
1122 template <typename Domain2>
1124 template <typename Domain2>
1126 template <typename Domain2>
1128 template <typename Range2>
1130 template <typename Range2>
1132 template <typename Range2>
1134 template <typename Domain2, typename Range2>
1136 template <typename Domain2, typename Range2>
1140 inline typed::map<Domain, Range> project_out_param(const std::string &id) const;
1142 inline typed::set<Range> range() const;
1147 template <typename Range2>
1149 template <typename Range2>
1154 template <typename Domain2>
1156 template <typename Domain2>
1157 inline typed::map<Domain2, Range> set_domain_tuple(const std::string &id) const;
1158 template <typename Range2>
1160 template <typename Range2>
1161 inline typed::map<Domain, Range2> set_range_tuple(const std::string &id) const;
1168 inline typed::map<Domain, Range> uncurry() const = delete;
1174};
1175
1176template <typename Domain, typename Range, typename Range2>
1178 template <typename...>
1179 friend struct aff;
1180 template <typename...>
1181 friend struct aff_list;
1182 template <typename...>
1183 friend struct basic_map;
1184 template <typename...>
1185 friend struct basic_set;
1186 template <typename...>
1187 friend struct fixed_box;
1188 template <typename...>
1189 friend struct id;
1190 template <typename...>
1191 friend struct id_list;
1192 template <typename...>
1193 friend struct map;
1194 template <typename...>
1195 friend struct map_list;
1196 template <typename...>
1197 friend struct multi_aff;
1198 template <typename...>
1199 friend struct multi_id;
1200 template <typename...>
1201 friend struct multi_pw_aff;
1202 template <typename...>
1203 friend struct multi_union_pw_aff;
1204 template <typename...>
1205 friend struct multi_val;
1206 template <typename...>
1207 friend struct point;
1208 template <typename...>
1209 friend struct pw_aff;
1210 template <typename...>
1211 friend struct pw_aff_list;
1212 template <typename...>
1213 friend struct pw_multi_aff;
1214 template <typename...>
1215 friend struct pw_multi_aff_list;
1216 template <typename...>
1217 friend struct set;
1218 template <typename...>
1219 friend struct set_list;
1220 template <typename...>
1221 friend struct space;
1222 template <typename...>
1223 friend struct union_map;
1224 template <typename...>
1225 friend struct union_pw_aff;
1226 template <typename...>
1227 friend struct union_pw_aff_list;
1228 template <typename...>
1229 friend struct union_pw_multi_aff;
1230 template <typename...>
1231 friend struct union_set;
1232 template <typename...>
1233 friend struct union_set_list;
1234 template <typename...>
1235 friend struct val;
1236 template <typename...>
1237 friend struct val_list;
1238
1239 basic_map() = default;
1240 template <typename Arg1, typename Arg2, typename Arg3,
1241 typename std::enable_if<
1242 std::is_base_of<Domain, Arg1>{} &&
1243 std::is_base_of<Range, Arg2>{} &&
1244 std::is_base_of<Range2, Arg3>{},
1245 bool>::type = true>
1247 private:
1248 template <typename base,
1249 typename std::enable_if<
1250 std::is_same<base, isl::basic_map>{}, bool>::type = true>
1251 basic_map(const base &obj) : isl::basic_map(obj) {}
1252 public:
1254 return basic_map(obj);
1255 }
1256 inline explicit basic_map(const isl::ctx &ctx, const std::string &str);
1257 template <typename Domain2>
1259 template <typename Domain2>
1261 template <typename Domain2>
1263 template <typename Arg3>
1265 template <typename Arg3>
1267 template <typename Arg3>
1284 template <typename Domain2>
1286 template <typename Domain2>
1292 inline bool every_map(const std::function<bool(typed::map<pair<Domain, Range>, Range2>)> &test) const;
1296 inline void foreach_basic_map(const std::function<void(typed::basic_map<pair<Domain, Range>, Range2>)> &fn) const;
1297 inline void foreach_map(const std::function<void(typed::map<pair<Domain, Range>, Range2>)> &fn) const;
1336 inline typed::set<> params() const;
1337 template <typename Domain2>
1339 template <typename Domain2>
1341 template <typename Domain2>
1343 template <typename Domain2>
1345 template <typename Arg3>
1347 template <typename Arg3>
1349 template <typename Arg3>
1351 template <typename Domain2, typename Arg3>
1353 template <typename Domain2, typename Arg3>
1357 inline typed::map<pair<Domain, Range>, Range2> project_out_param(const std::string &id) const;
1364 template <typename Arg3>
1366 template <typename Arg3>
1372 inline typed::map<pair<Domain, Range>, Range2> set_domain_tuple(const std::string &id) const = delete;
1373 template <typename Arg2>
1375 template <typename Arg2>
1376 inline typed::map<pair<Domain, Range>, Arg2> set_range_tuple(const std::string &id) const;
1389};
1390
1391template <typename Domain>
1393 template <typename...>
1394 friend struct aff;
1395 template <typename...>
1396 friend struct aff_list;
1397 template <typename...>
1398 friend struct basic_map;
1399 template <typename...>
1400 friend struct basic_set;
1401 template <typename...>
1402 friend struct fixed_box;
1403 template <typename...>
1404 friend struct id;
1405 template <typename...>
1406 friend struct id_list;
1407 template <typename...>
1408 friend struct map;
1409 template <typename...>
1410 friend struct map_list;
1411 template <typename...>
1412 friend struct multi_aff;
1413 template <typename...>
1414 friend struct multi_id;
1415 template <typename...>
1416 friend struct multi_pw_aff;
1417 template <typename...>
1418 friend struct multi_union_pw_aff;
1419 template <typename...>
1420 friend struct multi_val;
1421 template <typename...>
1422 friend struct point;
1423 template <typename...>
1424 friend struct pw_aff;
1425 template <typename...>
1426 friend struct pw_aff_list;
1427 template <typename...>
1428 friend struct pw_multi_aff;
1429 template <typename...>
1430 friend struct pw_multi_aff_list;
1431 template <typename...>
1432 friend struct set;
1433 template <typename...>
1434 friend struct set_list;
1435 template <typename...>
1436 friend struct space;
1437 template <typename...>
1438 friend struct union_map;
1439 template <typename...>
1440 friend struct union_pw_aff;
1441 template <typename...>
1442 friend struct union_pw_aff_list;
1443 template <typename...>
1444 friend struct union_pw_multi_aff;
1445 template <typename...>
1446 friend struct union_set;
1447 template <typename...>
1448 friend struct union_set_list;
1449 template <typename...>
1450 friend struct val;
1451 template <typename...>
1452 friend struct val_list;
1453
1454 basic_map() = default;
1455 template <typename Arg1,
1456 typename std::enable_if<
1457 std::is_base_of<Domain, Arg1>{},
1458 bool>::type = true>
1460 private:
1461 template <typename base,
1462 typename std::enable_if<
1463 std::is_same<base, isl::basic_map>{}, bool>::type = true>
1464 basic_map(const base &obj) : isl::basic_map(obj) {}
1465 public:
1467 return basic_map(obj);
1468 }
1469 inline explicit basic_map(const isl::ctx &ctx, const std::string &str);
1470 template <typename Domain2>
1472 template <typename Domain2>
1474 template <typename Domain2>
1476 template <typename Range2>
1478 template <typename Range2>
1480 template <typename Range2>
1489 inline typed::map<Domain, Domain> curry() const = delete;
1497 template <typename Domain2>
1499 template <typename Domain2>
1503 template <typename Range>
1505 template <typename Range>
1507 inline bool every_map(const std::function<bool(typed::map<Domain, Domain>)> &test) const;
1511 inline void foreach_basic_map(const std::function<void(typed::basic_map<Domain, Domain>)> &fn) const;
1512 inline void foreach_map(const std::function<void(typed::map<Domain, Domain>)> &fn) const;
1539 template <typename Range>
1541 template <typename Range>
1543 template <typename Range>
1545 template <typename Range>
1555 inline typed::set<> params() const;
1556 template <typename Domain2>
1558 template <typename Domain2>
1560 template <typename Domain2>
1562 template <typename Domain2>
1564 template <typename Range2>
1566 template <typename Range2>
1568 template <typename Range2>
1570 template <typename Domain2, typename Range2>
1572 template <typename Domain2, typename Range2>
1576 inline typed::map<Domain, Domain> project_out_param(const std::string &id) const;
1583 template <typename Range2>
1585 template <typename Range2>
1590 template <typename Domain2>
1592 template <typename Domain2>
1593 inline typed::map<Domain2, Domain> set_domain_tuple(const std::string &id) const;
1594 template <typename Range2>
1596 template <typename Range2>
1597 inline typed::map<Domain, Range2> set_range_tuple(const std::string &id) const;
1604 inline typed::map<Domain, Domain> uncurry() const = delete;
1610};
1611
1612template <typename Domain, typename Range, typename Range2>
1614 template <typename...>
1615 friend struct aff;
1616 template <typename...>
1617 friend struct aff_list;
1618 template <typename...>
1619 friend struct basic_map;
1620 template <typename...>
1621 friend struct basic_set;
1622 template <typename...>
1623 friend struct fixed_box;
1624 template <typename...>
1625 friend struct id;
1626 template <typename...>
1627 friend struct id_list;
1628 template <typename...>
1629 friend struct map;
1630 template <typename...>
1631 friend struct map_list;
1632 template <typename...>
1633 friend struct multi_aff;
1634 template <typename...>
1635 friend struct multi_id;
1636 template <typename...>
1637 friend struct multi_pw_aff;
1638 template <typename...>
1639 friend struct multi_union_pw_aff;
1640 template <typename...>
1641 friend struct multi_val;
1642 template <typename...>
1643 friend struct point;
1644 template <typename...>
1645 friend struct pw_aff;
1646 template <typename...>
1647 friend struct pw_aff_list;
1648 template <typename...>
1649 friend struct pw_multi_aff;
1650 template <typename...>
1651 friend struct pw_multi_aff_list;
1652 template <typename...>
1653 friend struct set;
1654 template <typename...>
1655 friend struct set_list;
1656 template <typename...>
1657 friend struct space;
1658 template <typename...>
1659 friend struct union_map;
1660 template <typename...>
1661 friend struct union_pw_aff;
1662 template <typename...>
1663 friend struct union_pw_aff_list;
1664 template <typename...>
1665 friend struct union_pw_multi_aff;
1666 template <typename...>
1667 friend struct union_set;
1668 template <typename...>
1669 friend struct union_set_list;
1670 template <typename...>
1671 friend struct val;
1672 template <typename...>
1673 friend struct val_list;
1674
1675 basic_map() = default;
1676 template <typename Arg1, typename Arg2, typename Arg3,
1677 typename std::enable_if<
1678 std::is_base_of<Domain, Arg1>{} &&
1679 std::is_base_of<Range, Arg2>{} &&
1680 std::is_base_of<Range2, Arg3>{},
1681 bool>::type = true>
1683 private:
1684 template <typename base,
1685 typename std::enable_if<
1686 std::is_same<base, isl::basic_map>{}, bool>::type = true>
1687 basic_map(const base &obj) : isl::basic_map(obj) {}
1688 public:
1690 return basic_map(obj);
1691 }
1692 inline explicit basic_map(const isl::ctx &ctx, const std::string &str);
1693 template <typename Domain2>
1695 template <typename Domain2>
1697 template <typename Domain2>
1699 template <typename Arg3>
1701 template <typename Arg3>
1703 template <typename Arg3>
1720 template <typename Domain2>
1722 template <typename Domain2>
1728 inline bool every_map(const std::function<bool(typed::map<Domain, pair<Range, Range2>>)> &test) const;
1732 inline void foreach_basic_map(const std::function<void(typed::basic_map<Domain, pair<Range, Range2>>)> &fn) const;
1733 inline void foreach_map(const std::function<void(typed::map<Domain, pair<Range, Range2>>)> &fn) const;
1772 inline typed::set<> params() const;
1773 template <typename Domain2>
1775 template <typename Domain2>
1777 template <typename Domain2>
1779 template <typename Domain2>
1781 template <typename Arg3>
1783 template <typename Arg3>
1785 template <typename Arg3>
1787 template <typename Domain2, typename Arg3>
1789 template <typename Domain2, typename Arg3>
1793 inline typed::map<Domain, pair<Range, Range2>> project_out_param(const std::string &id) const;
1800 template <typename Arg3>
1802 template <typename Arg3>
1807 template <typename Domain2>
1809 template <typename Domain2>
1810 inline typed::map<Domain2, pair<Range, Range2>> set_domain_tuple(const std::string &id) const;
1812 inline typed::map<Domain, pair<Range, Range2>> set_range_tuple(const std::string &id) const = delete;
1825};
1826
1827template <typename T1, typename T2>
1828struct basic_map<pair<T1, T2>, pair<T1, T2>> : public isl::basic_map {
1829 template <typename...>
1830 friend struct aff;
1831 template <typename...>
1832 friend struct aff_list;
1833 template <typename...>
1834 friend struct basic_map;
1835 template <typename...>
1836 friend struct basic_set;
1837 template <typename...>
1838 friend struct fixed_box;
1839 template <typename...>
1840 friend struct id;
1841 template <typename...>
1842 friend struct id_list;
1843 template <typename...>
1844 friend struct map;
1845 template <typename...>
1846 friend struct map_list;
1847 template <typename...>
1848 friend struct multi_aff;
1849 template <typename...>
1850 friend struct multi_id;
1851 template <typename...>
1852 friend struct multi_pw_aff;
1853 template <typename...>
1854 friend struct multi_union_pw_aff;
1855 template <typename...>
1856 friend struct multi_val;
1857 template <typename...>
1858 friend struct point;
1859 template <typename...>
1860 friend struct pw_aff;
1861 template <typename...>
1862 friend struct pw_aff_list;
1863 template <typename...>
1864 friend struct pw_multi_aff;
1865 template <typename...>
1866 friend struct pw_multi_aff_list;
1867 template <typename...>
1868 friend struct set;
1869 template <typename...>
1870 friend struct set_list;
1871 template <typename...>
1872 friend struct space;
1873 template <typename...>
1874 friend struct union_map;
1875 template <typename...>
1876 friend struct union_pw_aff;
1877 template <typename...>
1878 friend struct union_pw_aff_list;
1879 template <typename...>
1880 friend struct union_pw_multi_aff;
1881 template <typename...>
1882 friend struct union_set;
1883 template <typename...>
1884 friend struct union_set_list;
1885 template <typename...>
1886 friend struct val;
1887 template <typename...>
1888 friend struct val_list;
1889
1890 basic_map() = default;
1891 template <typename Arg1, typename Arg2,
1892 typename std::enable_if<
1893 std::is_base_of<T1, Arg1>{} &&
1894 std::is_base_of<T2, Arg2>{},
1895 bool>::type = true>
1897 private:
1898 template <typename base,
1899 typename std::enable_if<
1900 std::is_same<base, isl::basic_map>{}, bool>::type = true>
1901 basic_map(const base &obj) : isl::basic_map(obj) {}
1902 public:
1904 return basic_map(obj);
1905 }
1906 inline explicit basic_map(const isl::ctx &ctx, const std::string &str);
1907 template <typename Domain2>
1909 template <typename Domain2>
1911 template <typename Domain2>
1913 template <typename Range2>
1915 template <typename Range2>
1917 template <typename Range2>
1934 template <typename Domain2>
1936 template <typename Domain2>
1940 template <typename Range>
1942 template <typename Range>
1944 inline bool every_map(const std::function<bool(typed::map<pair<T1, T2>, pair<T1, T2>>)> &test) const;
1948 inline void foreach_basic_map(const std::function<void(typed::basic_map<pair<T1, T2>, pair<T1, T2>>)> &fn) const;
1949 inline void foreach_map(const std::function<void(typed::map<pair<T1, T2>, pair<T1, T2>>)> &fn) const;
1976 template <typename Range>
1978 template <typename Range>
1980 template <typename Range>
1982 template <typename Range>
1992 inline typed::set<> params() const;
1993 template <typename Domain2>
1995 template <typename Domain2>
1997 template <typename Domain2>
1999 template <typename Domain2>
2001 template <typename Range2>
2003 template <typename Range2>
2005 template <typename Range2>
2007 template <typename Domain2, typename Range2>
2009 template <typename Domain2, typename Range2>
2013 inline typed::map<pair<T1, T2>, pair<T1, T2>> project_out_param(const std::string &id) const;
2020 template <typename Range2>
2022 template <typename Range2>
2028 inline typed::map<pair<T1, T2>, pair<T1, T2>> set_domain_tuple(const std::string &id) const = delete;
2030 inline typed::map<pair<T1, T2>, pair<T1, T2>> set_range_tuple(const std::string &id) const = delete;
2037 inline typed::map<pair<pair<T1, T2>, T1>, T2> uncurry() const;
2043};
2044
2045template <typename T1, typename T2, typename Range, typename Range2>
2046struct basic_map<pair<T1, T2>, pair<Range, Range2>> : public isl::basic_map {
2047 template <typename...>
2048 friend struct aff;
2049 template <typename...>
2050 friend struct aff_list;
2051 template <typename...>
2052 friend struct basic_map;
2053 template <typename...>
2054 friend struct basic_set;
2055 template <typename...>
2056 friend struct fixed_box;
2057 template <typename...>
2058 friend struct id;
2059 template <typename...>
2060 friend struct id_list;
2061 template <typename...>
2062 friend struct map;
2063 template <typename...>
2064 friend struct map_list;
2065 template <typename...>
2066 friend struct multi_aff;
2067 template <typename...>
2068 friend struct multi_id;
2069 template <typename...>
2070 friend struct multi_pw_aff;
2071 template <typename...>
2072 friend struct multi_union_pw_aff;
2073 template <typename...>
2074 friend struct multi_val;
2075 template <typename...>
2076 friend struct point;
2077 template <typename...>
2078 friend struct pw_aff;
2079 template <typename...>
2080 friend struct pw_aff_list;
2081 template <typename...>
2082 friend struct pw_multi_aff;
2083 template <typename...>
2084 friend struct pw_multi_aff_list;
2085 template <typename...>
2086 friend struct set;
2087 template <typename...>
2088 friend struct set_list;
2089 template <typename...>
2090 friend struct space;
2091 template <typename...>
2092 friend struct union_map;
2093 template <typename...>
2094 friend struct union_pw_aff;
2095 template <typename...>
2096 friend struct union_pw_aff_list;
2097 template <typename...>
2098 friend struct union_pw_multi_aff;
2099 template <typename...>
2100 friend struct union_set;
2101 template <typename...>
2102 friend struct union_set_list;
2103 template <typename...>
2104 friend struct val;
2105 template <typename...>
2106 friend struct val_list;
2107
2108 basic_map() = default;
2109 template <typename Arg1, typename Arg2, typename Arg3, typename Arg4,
2110 typename std::enable_if<
2111 std::is_base_of<T1, Arg1>{} &&
2112 std::is_base_of<T2, Arg2>{} &&
2113 std::is_base_of<Range, Arg3>{} &&
2114 std::is_base_of<Range2, Arg4>{},
2115 bool>::type = true>
2117 private:
2118 template <typename base,
2119 typename std::enable_if<
2120 std::is_same<base, isl::basic_map>{}, bool>::type = true>
2121 basic_map(const base &obj) : isl::basic_map(obj) {}
2122 public:
2124 return basic_map(obj);
2125 }
2126 inline explicit basic_map(const isl::ctx &ctx, const std::string &str);
2127 template <typename Domain2>
2129 template <typename Domain2>
2131 template <typename Domain2>
2133 template <typename Arg2>
2135 template <typename Arg2>
2137 template <typename Arg2>
2154 template <typename Domain2>
2156 template <typename Domain2>
2162 inline bool every_map(const std::function<bool(typed::map<pair<T1, T2>, pair<Range, Range2>>)> &test) const;
2166 inline void foreach_basic_map(const std::function<void(typed::basic_map<pair<T1, T2>, pair<Range, Range2>>)> &fn) const;
2167 inline void foreach_map(const std::function<void(typed::map<pair<T1, T2>, pair<Range, Range2>>)> &fn) const;
2206 inline typed::set<> params() const;
2207 template <typename Domain2>
2209 template <typename Domain2>
2211 template <typename Domain2>
2213 template <typename Domain2>
2215 template <typename Arg2>
2217 template <typename Arg2>
2219 template <typename Arg2>
2221 template <typename Domain2, typename Arg2>
2223 template <typename Domain2, typename Arg2>
2234 template <typename Arg2>
2236 template <typename Arg2>
2242 inline typed::map<pair<T1, T2>, pair<Range, Range2>> set_domain_tuple(const std::string &id) const = delete;
2244 inline typed::map<pair<T1, T2>, pair<Range, Range2>> set_range_tuple(const std::string &id) const = delete;
2257};
2258
2259template <>
2260struct basic_set<> : public isl::basic_set {
2261 template <typename...>
2262 friend struct aff;
2263 template <typename...>
2264 friend struct aff_list;
2265 template <typename...>
2266 friend struct basic_map;
2267 template <typename...>
2268 friend struct basic_set;
2269 template <typename...>
2270 friend struct fixed_box;
2271 template <typename...>
2272 friend struct id;
2273 template <typename...>
2274 friend struct id_list;
2275 template <typename...>
2276 friend struct map;
2277 template <typename...>
2278 friend struct map_list;
2279 template <typename...>
2280 friend struct multi_aff;
2281 template <typename...>
2282 friend struct multi_id;
2283 template <typename...>
2284 friend struct multi_pw_aff;
2285 template <typename...>
2286 friend struct multi_union_pw_aff;
2287 template <typename...>
2288 friend struct multi_val;
2289 template <typename...>
2290 friend struct point;
2291 template <typename...>
2292 friend struct pw_aff;
2293 template <typename...>
2294 friend struct pw_aff_list;
2295 template <typename...>
2296 friend struct pw_multi_aff;
2297 template <typename...>
2298 friend struct pw_multi_aff_list;
2299 template <typename...>
2300 friend struct set;
2301 template <typename...>
2302 friend struct set_list;
2303 template <typename...>
2304 friend struct space;
2305 template <typename...>
2306 friend struct union_map;
2307 template <typename...>
2308 friend struct union_pw_aff;
2309 template <typename...>
2310 friend struct union_pw_aff_list;
2311 template <typename...>
2312 friend struct union_pw_multi_aff;
2313 template <typename...>
2314 friend struct union_set;
2315 template <typename...>
2316 friend struct union_set_list;
2317 template <typename...>
2318 friend struct val;
2319 template <typename...>
2320 friend struct val_list;
2321
2322 basic_set() = default;
2323 private:
2324 template <typename base,
2325 typename std::enable_if<
2326 std::is_same<base, isl::basic_set>{}, bool>::type = true>
2327 basic_set(const base &obj) : isl::basic_set(obj) {}
2328 public:
2330 return basic_set(obj);
2331 }
2332 inline /* implicit */ basic_set(const typed::point<> &pnt);
2333 inline explicit basic_set(const isl::ctx &ctx, const std::string &str);
2334 inline typed::basic_set<> apply(const typed::basic_map<> &bmap) const = delete;
2335 inline typed::set<> apply(const typed::map<> &map) const = delete;
2336 inline typed::union_set<> apply(const typed::union_map<> &umap) const = delete;
2338 inline typed::set<> as_set() const = delete;
2339 inline typed::set<> bind(const typed::multi_id<> &tuple) const = delete;
2340 inline typed::set<> coalesce() const;
2343 inline bool every_set(const std::function<bool(typed::set<>)> &test) const;
2345 inline void foreach_basic_set(const std::function<void(typed::basic_set<>)> &fn) const;
2346 inline void foreach_point(const std::function<void(typed::point<>)> &fn) const;
2347 inline void foreach_set(const std::function<void(typed::set<>)> &fn) const;
2352 inline typed::set<> gist_params(const typed::set<> &context) const = delete;
2353 inline typed::map<> identity() const = delete;
2355 inline typed::map<> insert_domain(const typed::space<> &domain) const = delete;
2359 inline typed::basic_set<> intersect(const typed::point<> &bset2) const;
2360 inline typed::basic_set<> intersect_params(const typed::basic_set<> &bset2) const = delete;
2361 inline typed::set<> intersect_params(const typed::set<> &params) const = delete;
2362 inline typed::basic_set<> intersect_params(const typed::point<> &bset2) const = delete;
2363 inline typed::fixed_box<> lattice_tile() const = delete;
2364 inline typed::set<> lexmax() const = delete;
2366 inline typed::set<> lexmin() const = delete;
2368 inline typed::set<> lower_bound(const typed::multi_pw_aff<> &lower) const = delete;
2369 inline typed::set<> lower_bound(const typed::multi_val<> &lower) const = delete;
2371 inline typed::val<> max_val(const typed::aff<> &obj) const = delete;
2373 inline typed::val<> min_val(const typed::aff<> &obj) const = delete;
2375 inline typed::pw_aff<Anonymous> param_pw_aff_on_domain(const std::string &id) const;
2376 inline typed::basic_set<> params() const = delete;
2378 inline typed::set<> preimage(const typed::multi_aff<> &ma) const = delete;
2379 inline typed::set<> preimage(const typed::multi_pw_aff<> &mpa) const = delete;
2380 inline typed::set<> preimage(const typed::pw_multi_aff<> &pma) const = delete;
2381 inline typed::union_set<> preimage(const typed::union_pw_multi_aff<> &upma) const = delete;
2382 inline typed::set<> product(const typed::set<> &set2) const = delete;
2385 inline typed::set<> project_out_param(const std::string &id) const;
2389 template <typename Domain>
2393 inline typed::space<> space() const;
2396 inline typed::set<> to_set() const;
2398 inline typed::map<> translation() const = delete;
2399 template <typename Domain>
2402 inline typed::set<> unite(const typed::basic_set<> &bset2) const;
2403 inline typed::set<> unite(const typed::set<> &set2) const;
2404 inline typed::union_set<> unite(const typed::union_set<> &uset2) const;
2405 inline typed::set<> unite(const typed::point<> &bset2) const;
2406 inline typed::map<> unwrap() const = delete;
2407 inline typed::set<> upper_bound(const typed::multi_pw_aff<> &upper) const = delete;
2408 inline typed::set<> upper_bound(const typed::multi_val<> &upper) const = delete;
2409 inline typed::set<> wrapped_reverse() const = delete;
2410};
2411
2412template <typename Domain>
2414 template <typename...>
2415 friend struct aff;
2416 template <typename...>
2417 friend struct aff_list;
2418 template <typename...>
2419 friend struct basic_map;
2420 template <typename...>
2421 friend struct basic_set;
2422 template <typename...>
2423 friend struct fixed_box;
2424 template <typename...>
2425 friend struct id;
2426 template <typename...>
2427 friend struct id_list;
2428 template <typename...>
2429 friend struct map;
2430 template <typename...>
2431 friend struct map_list;
2432 template <typename...>
2433 friend struct multi_aff;
2434 template <typename...>
2435 friend struct multi_id;
2436 template <typename...>
2437 friend struct multi_pw_aff;
2438 template <typename...>
2439 friend struct multi_union_pw_aff;
2440 template <typename...>
2441 friend struct multi_val;
2442 template <typename...>
2443 friend struct point;
2444 template <typename...>
2445 friend struct pw_aff;
2446 template <typename...>
2447 friend struct pw_aff_list;
2448 template <typename...>
2449 friend struct pw_multi_aff;
2450 template <typename...>
2451 friend struct pw_multi_aff_list;
2452 template <typename...>
2453 friend struct set;
2454 template <typename...>
2455 friend struct set_list;
2456 template <typename...>
2457 friend struct space;
2458 template <typename...>
2459 friend struct union_map;
2460 template <typename...>
2461 friend struct union_pw_aff;
2462 template <typename...>
2463 friend struct union_pw_aff_list;
2464 template <typename...>
2465 friend struct union_pw_multi_aff;
2466 template <typename...>
2467 friend struct union_set;
2468 template <typename...>
2469 friend struct union_set_list;
2470 template <typename...>
2471 friend struct val;
2472 template <typename...>
2473 friend struct val_list;
2474
2475 basic_set() = default;
2476 template <typename Arg1,
2477 typename std::enable_if<
2478 std::is_base_of<Domain, Arg1>{},
2479 bool>::type = true>
2481 private:
2482 template <typename base,
2483 typename std::enable_if<
2484 std::is_same<base, isl::basic_set>{}, bool>::type = true>
2485 basic_set(const base &obj) : isl::basic_set(obj) {}
2486 public:
2488 return basic_set(obj);
2489 }
2490 inline /* implicit */ basic_set(const typed::point<Domain> &pnt);
2491 inline explicit basic_set(const isl::ctx &ctx, const std::string &str);
2492 template <typename Range>
2494 template <typename Range>
2496 template <typename Range>
2504 inline bool every_set(const std::function<bool(typed::set<Domain>)> &test) const;
2506 inline void foreach_basic_set(const std::function<void(typed::basic_set<Domain>)> &fn) const;
2507 inline void foreach_point(const std::function<void(typed::point<Domain>)> &fn) const;
2508 inline void foreach_set(const std::function<void(typed::set<Domain>)> &fn) const;
2516 template <typename Arg1>
2533 inline typed::val<Domain> max_val(const typed::aff<> &obj) const = delete;
2535 inline typed::val<Domain> min_val(const typed::aff<> &obj) const = delete;
2540 template <typename Domain2>
2542 template <typename Domain2>
2544 template <typename Domain2>
2546 template <typename Domain2>
2548 template <typename Range>
2552 inline typed::set<Domain> project_out_param(const std::string &id) const;
2556 template <typename Range>
2567 template <typename Arg1>
2573 inline typed::map<Domain> unwrap() const = delete;
2576 inline typed::set<Domain> wrapped_reverse() const = delete;
2577};
2578
2579template <typename Domain, typename Range>
2581 template <typename...>
2582 friend struct aff;
2583 template <typename...>
2584 friend struct aff_list;
2585 template <typename...>
2586 friend struct basic_map;
2587 template <typename...>
2588 friend struct basic_set;
2589 template <typename...>
2590 friend struct fixed_box;
2591 template <typename...>
2592 friend struct id;
2593 template <typename...>
2594 friend struct id_list;
2595 template <typename...>
2596 friend struct map;
2597 template <typename...>
2598 friend struct map_list;
2599 template <typename...>
2600 friend struct multi_aff;
2601 template <typename...>
2602 friend struct multi_id;
2603 template <typename...>
2604 friend struct multi_pw_aff;
2605 template <typename...>
2606 friend struct multi_union_pw_aff;
2607 template <typename...>
2608 friend struct multi_val;
2609 template <typename...>
2610 friend struct point;
2611 template <typename...>
2612 friend struct pw_aff;
2613 template <typename...>
2614 friend struct pw_aff_list;
2615 template <typename...>
2616 friend struct pw_multi_aff;
2617 template <typename...>
2618 friend struct pw_multi_aff_list;
2619 template <typename...>
2620 friend struct set;
2621 template <typename...>
2622 friend struct set_list;
2623 template <typename...>
2624 friend struct space;
2625 template <typename...>
2626 friend struct union_map;
2627 template <typename...>
2628 friend struct union_pw_aff;
2629 template <typename...>
2630 friend struct union_pw_aff_list;
2631 template <typename...>
2632 friend struct union_pw_multi_aff;
2633 template <typename...>
2634 friend struct union_set;
2635 template <typename...>
2636 friend struct union_set_list;
2637 template <typename...>
2638 friend struct val;
2639 template <typename...>
2640 friend struct val_list;
2641
2642 basic_set() = default;
2643 template <typename Arg1, typename Arg2,
2644 typename std::enable_if<
2645 std::is_base_of<Domain, Arg1>{} &&
2646 std::is_base_of<Range, Arg2>{},
2647 bool>::type = true>
2649 private:
2650 template <typename base,
2651 typename std::enable_if<
2652 std::is_same<base, isl::basic_set>{}, bool>::type = true>
2653 basic_set(const base &obj) : isl::basic_set(obj) {}
2654 public:
2656 return basic_set(obj);
2657 }
2658 inline /* implicit */ basic_set(const typed::point<pair<Domain, Range>> &pnt);
2659 inline explicit basic_set(const isl::ctx &ctx, const std::string &str);
2660 template <typename Arg2>
2662 template <typename Arg2>
2664 template <typename Arg2>
2672 inline bool every_set(const std::function<bool(typed::set<pair<Domain, Range>>)> &test) const;
2674 inline void foreach_basic_set(const std::function<void(typed::basic_set<pair<Domain, Range>>)> &fn) const;
2675 inline void foreach_point(const std::function<void(typed::point<pair<Domain, Range>>)> &fn) const;
2676 inline void foreach_set(const std::function<void(typed::set<pair<Domain, Range>>)> &fn) const;
2684 template <typename Arg2>
2708 template <typename Domain2>
2710 template <typename Domain2>
2712 template <typename Domain2>
2714 template <typename Domain2>
2716 template <typename Arg2>
2720 inline typed::set<pair<Domain, Range>> project_out_param(const std::string &id) const;
2724 template <typename Arg2>
2735 template <typename Arg2>
2745};
2746
2747template <typename Domain>
2749 template <typename...>
2750 friend struct aff;
2751 template <typename...>
2752 friend struct aff_list;
2753 template <typename...>
2754 friend struct basic_map;
2755 template <typename...>
2756 friend struct basic_set;
2757 template <typename...>
2758 friend struct fixed_box;
2759 template <typename...>
2760 friend struct id;
2761 template <typename...>
2762 friend struct id_list;
2763 template <typename...>
2764 friend struct map;
2765 template <typename...>
2766 friend struct map_list;
2767 template <typename...>
2768 friend struct multi_aff;
2769 template <typename...>
2770 friend struct multi_id;
2771 template <typename...>
2772 friend struct multi_pw_aff;
2773 template <typename...>
2774 friend struct multi_union_pw_aff;
2775 template <typename...>
2776 friend struct multi_val;
2777 template <typename...>
2778 friend struct point;
2779 template <typename...>
2780 friend struct pw_aff;
2781 template <typename...>
2782 friend struct pw_aff_list;
2783 template <typename...>
2784 friend struct pw_multi_aff;
2785 template <typename...>
2786 friend struct pw_multi_aff_list;
2787 template <typename...>
2788 friend struct set;
2789 template <typename...>
2790 friend struct set_list;
2791 template <typename...>
2792 friend struct space;
2793 template <typename...>
2794 friend struct union_map;
2795 template <typename...>
2796 friend struct union_pw_aff;
2797 template <typename...>
2798 friend struct union_pw_aff_list;
2799 template <typename...>
2800 friend struct union_pw_multi_aff;
2801 template <typename...>
2802 friend struct union_set;
2803 template <typename...>
2804 friend struct union_set_list;
2805 template <typename...>
2806 friend struct val;
2807 template <typename...>
2808 friend struct val_list;
2809
2810 fixed_box() = default;
2811 template <typename Arg1,
2812 typename std::enable_if<
2813 std::is_base_of<Domain, Arg1>{},
2814 bool>::type = true>
2816 private:
2817 template <typename base,
2818 typename std::enable_if<
2819 std::is_same<base, isl::fixed_box>{}, bool>::type = true>
2820 fixed_box(const base &obj) : isl::fixed_box(obj) {}
2821 public:
2823 return fixed_box(obj);
2824 }
2825 inline explicit fixed_box(const isl::ctx &ctx, const std::string &str);
2827 inline typed::multi_aff<Domain> get_offset() const = delete;
2829 inline typed::multi_val<Domain> get_size() const = delete;
2831 inline typed::space<Domain> get_space() const = delete;
2832};
2833
2834template <typename Domain, typename Range>
2836 template <typename...>
2837 friend struct aff;
2838 template <typename...>
2839 friend struct aff_list;
2840 template <typename...>
2841 friend struct basic_map;
2842 template <typename...>
2843 friend struct basic_set;
2844 template <typename...>
2845 friend struct fixed_box;
2846 template <typename...>
2847 friend struct id;
2848 template <typename...>
2849 friend struct id_list;
2850 template <typename...>
2851 friend struct map;
2852 template <typename...>
2853 friend struct map_list;
2854 template <typename...>
2855 friend struct multi_aff;
2856 template <typename...>
2857 friend struct multi_id;
2858 template <typename...>
2859 friend struct multi_pw_aff;
2860 template <typename...>
2861 friend struct multi_union_pw_aff;
2862 template <typename...>
2863 friend struct multi_val;
2864 template <typename...>
2865 friend struct point;
2866 template <typename...>
2867 friend struct pw_aff;
2868 template <typename...>
2869 friend struct pw_aff_list;
2870 template <typename...>
2871 friend struct pw_multi_aff;
2872 template <typename...>
2873 friend struct pw_multi_aff_list;
2874 template <typename...>
2875 friend struct set;
2876 template <typename...>
2877 friend struct set_list;
2878 template <typename...>
2879 friend struct space;
2880 template <typename...>
2881 friend struct union_map;
2882 template <typename...>
2883 friend struct union_pw_aff;
2884 template <typename...>
2885 friend struct union_pw_aff_list;
2886 template <typename...>
2887 friend struct union_pw_multi_aff;
2888 template <typename...>
2889 friend struct union_set;
2890 template <typename...>
2891 friend struct union_set_list;
2892 template <typename...>
2893 friend struct val;
2894 template <typename...>
2895 friend struct val_list;
2896
2897 fixed_box() = default;
2898 template <typename Arg1, typename Arg2,
2899 typename std::enable_if<
2900 std::is_base_of<Domain, Arg1>{} &&
2901 std::is_base_of<Range, Arg2>{},
2902 bool>::type = true>
2904 private:
2905 template <typename base,
2906 typename std::enable_if<
2907 std::is_same<base, isl::fixed_box>{}, bool>::type = true>
2908 fixed_box(const base &obj) : isl::fixed_box(obj) {}
2909 public:
2911 return fixed_box(obj);
2912 }
2913 inline explicit fixed_box(const isl::ctx &ctx, const std::string &str);
2920};
2921
2922template <>
2923struct id<Anonymous> : public isl::id {
2924 template <typename...>
2925 friend struct aff;
2926 template <typename...>
2927 friend struct aff_list;
2928 template <typename...>
2929 friend struct basic_map;
2930 template <typename...>
2931 friend struct basic_set;
2932 template <typename...>
2933 friend struct fixed_box;
2934 template <typename...>
2935 friend struct id;
2936 template <typename...>
2937 friend struct id_list;
2938 template <typename...>
2939 friend struct map;
2940 template <typename...>
2941 friend struct map_list;
2942 template <typename...>
2943 friend struct multi_aff;
2944 template <typename...>
2945 friend struct multi_id;
2946 template <typename...>
2947 friend struct multi_pw_aff;
2948 template <typename...>
2949 friend struct multi_union_pw_aff;
2950 template <typename...>
2951 friend struct multi_val;
2952 template <typename...>
2953 friend struct point;
2954 template <typename...>
2955 friend struct pw_aff;
2956 template <typename...>
2957 friend struct pw_aff_list;
2958 template <typename...>
2959 friend struct pw_multi_aff;
2960 template <typename...>
2961 friend struct pw_multi_aff_list;
2962 template <typename...>
2963 friend struct set;
2964 template <typename...>
2965 friend struct set_list;
2966 template <typename...>
2967 friend struct space;
2968 template <typename...>
2969 friend struct union_map;
2970 template <typename...>
2971 friend struct union_pw_aff;
2972 template <typename...>
2973 friend struct union_pw_aff_list;
2974 template <typename...>
2975 friend struct union_pw_multi_aff;
2976 template <typename...>
2977 friend struct union_set;
2978 template <typename...>
2979 friend struct union_set_list;
2980 template <typename...>
2981 friend struct val;
2982 template <typename...>
2983 friend struct val_list;
2984
2985 id() = default;
2986 id(const isl::id &obj) : isl::id(obj) {}
2987 static id from(const isl::id &obj) {
2988 return id(obj);
2989 }
2990 inline explicit id(const isl::ctx &ctx, const std::string &str);
2991 inline std::string get_name() const = delete;
2992};
2993
2994template <>
2996 template <typename...>
2997 friend struct aff;
2998 template <typename...>
2999 friend struct aff_list;
3000 template <typename...>
3001 friend struct basic_map;
3002 template <typename...>
3003 friend struct basic_set;
3004 template <typename...>
3005 friend struct fixed_box;
3006 template <typename...>
3007 friend struct id;
3008 template <typename...>
3009 friend struct id_list;
3010 template <typename...>
3011 friend struct map;
3012 template <typename...>
3013 friend struct map_list;
3014 template <typename...>
3015 friend struct multi_aff;
3016 template <typename...>
3017 friend struct multi_id;
3018 template <typename...>
3019 friend struct multi_pw_aff;
3020 template <typename...>
3021 friend struct multi_union_pw_aff;
3022 template <typename...>
3023 friend struct multi_val;
3024 template <typename...>
3025 friend struct point;
3026 template <typename...>
3027 friend struct pw_aff;
3028 template <typename...>
3029 friend struct pw_aff_list;
3030 template <typename...>
3031 friend struct pw_multi_aff;
3032 template <typename...>
3033 friend struct pw_multi_aff_list;
3034 template <typename...>
3035 friend struct set;
3036 template <typename...>
3037 friend struct set_list;
3038 template <typename...>
3039 friend struct space;
3040 template <typename...>
3041 friend struct union_map;
3042 template <typename...>
3043 friend struct union_pw_aff;
3044 template <typename...>
3045 friend struct union_pw_aff_list;
3046 template <typename...>
3047 friend struct union_pw_multi_aff;
3048 template <typename...>
3049 friend struct union_set;
3050 template <typename...>
3051 friend struct union_set_list;
3052 template <typename...>
3053 friend struct val;
3054 template <typename...>
3055 friend struct val_list;
3056
3057 id_list() = default;
3059 static id_list from(const isl::id_list &obj) {
3060 return id_list(obj);
3061 }
3062 inline explicit id_list(const isl::ctx &ctx, int n);
3063 inline explicit id_list(const typed::id<Anonymous> &el);
3064 inline explicit id_list(const isl::ctx &ctx, const std::string &str);
3066 inline typed::id_list<Anonymous> add(const std::string &el) const;
3067 inline typed::id<Anonymous> at(int index) const;
3068 inline typed::id<Anonymous> get_at(int index) const = delete;
3069 inline typed::id_list<Anonymous> drop(unsigned int first, unsigned int n) const;
3070 inline void foreach(const std::function<void(typed::id<Anonymous>)> &fn) const;
3071 inline void foreach_scc(const std::function<bool(typed::id<Anonymous>, typed::id<Anonymous>)> &follows, const std::function<void(typed::id_list<Anonymous>)> &fn) const;
3072 inline typed::id_list<Anonymous> set_at(int index, const typed::id<Anonymous> &el) const;
3073 inline typed::id_list<Anonymous> set_at(int index, const std::string &el) const;
3074};
3075
3076template <typename Domain, typename Range>
3078 template <typename...>
3079 friend struct aff;
3080 template <typename...>
3081 friend struct aff_list;
3082 template <typename...>
3083 friend struct basic_map;
3084 template <typename...>
3085 friend struct basic_set;
3086 template <typename...>
3087 friend struct fixed_box;
3088 template <typename...>
3089 friend struct id;
3090 template <typename...>
3091 friend struct id_list;
3092 template <typename...>
3093 friend struct map;
3094 template <typename...>
3095 friend struct map_list;
3096 template <typename...>
3097 friend struct multi_aff;
3098 template <typename...>
3099 friend struct multi_id;
3100 template <typename...>
3101 friend struct multi_pw_aff;
3102 template <typename...>
3103 friend struct multi_union_pw_aff;
3104 template <typename...>
3105 friend struct multi_val;
3106 template <typename...>
3107 friend struct point;
3108 template <typename...>
3109 friend struct pw_aff;
3110 template <typename...>
3111 friend struct pw_aff_list;
3112 template <typename...>
3113 friend struct pw_multi_aff;
3114 template <typename...>
3115 friend struct pw_multi_aff_list;
3116 template <typename...>
3117 friend struct set;
3118 template <typename...>
3119 friend struct set_list;
3120 template <typename...>
3121 friend struct space;
3122 template <typename...>
3123 friend struct union_map;
3124 template <typename...>
3125 friend struct union_pw_aff;
3126 template <typename...>
3127 friend struct union_pw_aff_list;
3128 template <typename...>
3129 friend struct union_pw_multi_aff;
3130 template <typename...>
3131 friend struct union_set;
3132 template <typename...>
3133 friend struct union_set_list;
3134 template <typename...>
3135 friend struct val;
3136 template <typename...>
3137 friend struct val_list;
3138
3139 map() = default;
3140 template <typename Arg1, typename Arg2,
3141 typename std::enable_if<
3142 std::is_base_of<Domain, Arg1>{} &&
3143 std::is_base_of<Range, Arg2>{},
3144 bool>::type = true>
3146 private:
3147 template <typename base,
3148 typename std::enable_if<
3149 std::is_same<base, isl::map>{}, bool>::type = true>
3150 map(const base &obj) : isl::map(obj) {}
3151 public:
3152 static map from(const isl::map &obj) {
3153 return map(obj);
3154 }
3155 inline /* implicit */ map(const typed::basic_map<Domain, Range> &bmap);
3156 inline explicit map(const isl::ctx &ctx, const std::string &str);
3157 template <typename Domain2>
3159 template <typename Domain2>
3161 template <typename Domain2>
3163 template <typename Range2>
3165 template <typename Range2>
3167 template <typename Range2>
3176 inline typed::map<Domain, Range> curry() const = delete;
3177 inline typed::set<Domain, Range> deltas() const = delete;
3184 template <typename Domain2>
3186 template <typename Domain2>
3188 template <typename Domain2>
3193 inline typed::map<Domain, Range> eq_at(const typed::multi_pw_aff<> &mpa) const = delete;
3195 inline typed::map<Domain, Range> eq_at(const typed::aff<> &mpa) const = delete;
3196 inline typed::map<Domain, Range> eq_at(const typed::multi_aff<> &mpa) const = delete;
3197 inline typed::map<Domain, Range> eq_at(const typed::pw_aff<> &mpa) const = delete;
3198 inline typed::map<Domain, Range> eq_at(const typed::pw_multi_aff<> &mpa) const = delete;
3199 inline bool every_map(const std::function<bool(typed::map<Domain, Range>)> &test) const;
3203 inline void foreach_basic_map(const std::function<void(typed::basic_map<Domain, Range>)> &fn) const;
3204 inline void foreach_map(const std::function<void(typed::map<Domain, Range>)> &fn) const;
3240 inline typed::map<Domain, Range> lex_ge_at(const typed::aff<> &mpa) const = delete;
3241 inline typed::map<Domain, Range> lex_ge_at(const typed::multi_aff<> &mpa) const = delete;
3242 inline typed::map<Domain, Range> lex_ge_at(const typed::pw_aff<> &mpa) const = delete;
3245 inline typed::map<Domain, Range> lex_gt_at(const typed::aff<> &mpa) const = delete;
3246 inline typed::map<Domain, Range> lex_gt_at(const typed::multi_aff<> &mpa) const = delete;
3247 inline typed::map<Domain, Range> lex_gt_at(const typed::pw_aff<> &mpa) const = delete;
3250 inline typed::map<Domain, Range> lex_le_at(const typed::aff<> &mpa) const = delete;
3251 inline typed::map<Domain, Range> lex_le_at(const typed::multi_aff<> &mpa) const = delete;
3252 inline typed::map<Domain, Range> lex_le_at(const typed::pw_aff<> &mpa) const = delete;
3255 inline typed::map<Domain, Range> lex_lt_at(const typed::aff<> &mpa) const = delete;
3256 inline typed::map<Domain, Range> lex_lt_at(const typed::multi_aff<> &mpa) const = delete;
3257 inline typed::map<Domain, Range> lex_lt_at(const typed::pw_aff<> &mpa) const = delete;
3271 inline typed::set<> params() const;
3272 template <typename Domain2>
3274 template <typename Domain2>
3276 template <typename Domain2>
3278 template <typename Domain2>
3280 template <typename Range2>
3282 template <typename Range2>
3284 template <typename Range2>
3286 template <typename Domain2, typename Range2>
3288 template <typename Domain2, typename Range2>
3290 template <typename Domain2, typename Range2>
3294 inline typed::map<Domain, Range> project_out_param(const std::string &id) const;
3296 inline typed::set<Range> range() const;
3302 template <typename Range2>
3304 template <typename Range2>
3306 template <typename Range2>
3313 template <typename Domain2>
3315 template <typename Domain2>
3316 inline typed::map<Domain2, Range> set_domain_tuple(const std::string &id) const;
3317 template <typename Range2>
3319 template <typename Range2>
3320 inline typed::map<Domain, Range2> set_range_tuple(const std::string &id) const;
3329 inline typed::map<Domain, Range> uncurry() const = delete;
3340};
3341
3342template <typename Domain, typename Range, typename Range2>
3343struct map<pair<Domain, Range>, Range2> : public isl::map {
3344 template <typename...>
3345 friend struct aff;
3346 template <typename...>
3347 friend struct aff_list;
3348 template <typename...>
3349 friend struct basic_map;
3350 template <typename...>
3351 friend struct basic_set;
3352 template <typename...>
3353 friend struct fixed_box;
3354 template <typename...>
3355 friend struct id;
3356 template <typename...>
3357 friend struct id_list;
3358 template <typename...>
3359 friend struct map;
3360 template <typename...>
3361 friend struct map_list;
3362 template <typename...>
3363 friend struct multi_aff;
3364 template <typename...>
3365 friend struct multi_id;
3366 template <typename...>
3367 friend struct multi_pw_aff;
3368 template <typename...>
3369 friend struct multi_union_pw_aff;
3370 template <typename...>
3371 friend struct multi_val;
3372 template <typename...>
3373 friend struct point;
3374 template <typename...>
3375 friend struct pw_aff;
3376 template <typename...>
3377 friend struct pw_aff_list;
3378 template <typename...>
3379 friend struct pw_multi_aff;
3380 template <typename...>
3381 friend struct pw_multi_aff_list;
3382 template <typename...>
3383 friend struct set;
3384 template <typename...>
3385 friend struct set_list;
3386 template <typename...>
3387 friend struct space;
3388 template <typename...>
3389 friend struct union_map;
3390 template <typename...>
3391 friend struct union_pw_aff;
3392 template <typename...>
3393 friend struct union_pw_aff_list;
3394 template <typename...>
3395 friend struct union_pw_multi_aff;
3396 template <typename...>
3397 friend struct union_set;
3398 template <typename...>
3399 friend struct union_set_list;
3400 template <typename...>
3401 friend struct val;
3402 template <typename...>
3403 friend struct val_list;
3404
3405 map() = default;
3406 template <typename Arg1, typename Arg2, typename Arg3,
3407 typename std::enable_if<
3408 std::is_base_of<Domain, Arg1>{} &&
3409 std::is_base_of<Range, Arg2>{} &&
3410 std::is_base_of<Range2, Arg3>{},
3411 bool>::type = true>
3412 map(const map<pair<Arg1, Arg2>, Arg3> &obj) : isl::map(obj) {}
3413 private:
3414 template <typename base,
3415 typename std::enable_if<
3416 std::is_same<base, isl::map>{}, bool>::type = true>
3417 map(const base &obj) : isl::map(obj) {}
3418 public:
3419 static map from(const isl::map &obj) {
3420 return map(obj);
3421 }
3422 inline /* implicit */ map(const typed::basic_map<pair<Domain, Range>, Range2> &bmap);
3423 inline explicit map(const isl::ctx &ctx, const std::string &str);
3424 template <typename Domain2>
3426 template <typename Domain2>
3428 template <typename Domain2>
3430 template <typename Arg3>
3432 template <typename Arg3>
3434 template <typename Arg3>
3451 template <typename Domain2>
3453 template <typename Domain2>
3455 template <typename Domain2>
3462 inline typed::map<pair<Domain, Range>, Range2> eq_at(const typed::aff<> &mpa) const = delete;
3464 inline typed::map<pair<Domain, Range>, Range2> eq_at(const typed::pw_aff<> &mpa) const = delete;
3466 inline bool every_map(const std::function<bool(typed::map<pair<Domain, Range>, Range2>)> &test) const;
3470 inline void foreach_basic_map(const std::function<void(typed::basic_map<pair<Domain, Range>, Range2>)> &fn) const;
3471 inline void foreach_map(const std::function<void(typed::map<pair<Domain, Range>, Range2>)> &fn) const;
3538 inline typed::set<> params() const;
3539 template <typename Domain2>
3541 template <typename Domain2>
3543 template <typename Domain2>
3545 template <typename Domain2>
3547 template <typename Arg3>
3549 template <typename Arg3>
3551 template <typename Arg3>
3553 template <typename Domain2, typename Arg3>
3555 template <typename Domain2, typename Arg3>
3557 template <typename Domain2, typename Arg3>
3561 inline typed::map<pair<Domain, Range>, Range2> project_out_param(const std::string &id) const;
3569 template <typename Arg3>
3571 template <typename Arg3>
3573 template <typename Arg3>
3581 inline typed::map<pair<Domain, Range>, Range2> set_domain_tuple(const std::string &id) const = delete;
3582 template <typename Arg2>
3584 template <typename Arg2>
3585 inline typed::map<pair<Domain, Range>, Arg2> set_range_tuple(const std::string &id) const;
3605};
3606
3607template <typename Domain>
3608struct map<Domain, Domain> : public isl::map {
3609 template <typename...>
3610 friend struct aff;
3611 template <typename...>
3612 friend struct aff_list;
3613 template <typename...>
3614 friend struct basic_map;
3615 template <typename...>
3616 friend struct basic_set;
3617 template <typename...>
3618 friend struct fixed_box;
3619 template <typename...>
3620 friend struct id;
3621 template <typename...>
3622 friend struct id_list;
3623 template <typename...>
3624 friend struct map;
3625 template <typename...>
3626 friend struct map_list;
3627 template <typename...>
3628 friend struct multi_aff;
3629 template <typename...>
3630 friend struct multi_id;
3631 template <typename...>
3632 friend struct multi_pw_aff;
3633 template <typename...>
3634 friend struct multi_union_pw_aff;
3635 template <typename...>
3636 friend struct multi_val;
3637 template <typename...>
3638 friend struct point;
3639 template <typename...>
3640 friend struct pw_aff;
3641 template <typename...>
3642 friend struct pw_aff_list;
3643 template <typename...>
3644 friend struct pw_multi_aff;
3645 template <typename...>
3646 friend struct pw_multi_aff_list;
3647 template <typename...>
3648 friend struct set;
3649 template <typename...>
3650 friend struct set_list;
3651 template <typename...>
3652 friend struct space;
3653 template <typename...>
3654 friend struct union_map;
3655 template <typename...>
3656 friend struct union_pw_aff;
3657 template <typename...>
3658 friend struct union_pw_aff_list;
3659 template <typename...>
3660 friend struct union_pw_multi_aff;
3661 template <typename...>
3662 friend struct union_set;
3663 template <typename...>
3664 friend struct union_set_list;
3665 template <typename...>
3666 friend struct val;
3667 template <typename...>
3668 friend struct val_list;
3669
3670 map() = default;
3671 template <typename Arg1,
3672 typename std::enable_if<
3673 std::is_base_of<Domain, Arg1>{},
3674 bool>::type = true>
3676 private:
3677 template <typename base,
3678 typename std::enable_if<
3679 std::is_same<base, isl::map>{}, bool>::type = true>
3680 map(const base &obj) : isl::map(obj) {}
3681 public:
3682 static map from(const isl::map &obj) {
3683 return map(obj);
3684 }
3685 inline /* implicit */ map(const typed::basic_map<Domain, Domain> &bmap);
3686 inline explicit map(const isl::ctx &ctx, const std::string &str);
3687 template <typename Domain2>
3689 template <typename Domain2>
3691 template <typename Domain2>
3693 template <typename Range2>
3695 template <typename Range2>
3697 template <typename Range2>
3706 inline typed::map<Domain, Domain> curry() const = delete;
3714 template <typename Domain2>
3716 template <typename Domain2>
3718 template <typename Domain2>
3723 template <typename Range>
3725 template <typename Range>
3728 template <typename Range>
3731 template <typename Range>
3733 inline bool every_map(const std::function<bool(typed::map<Domain, Domain>)> &test) const;
3737 inline void foreach_basic_map(const std::function<void(typed::basic_map<Domain, Domain>)> &fn) const;
3738 inline void foreach_map(const std::function<void(typed::map<Domain, Domain>)> &fn) const;
3773 template <typename Range>
3776 template <typename Range>
3779 template <typename Range>
3781 template <typename Range>
3784 template <typename Range>
3787 template <typename Range>
3789 template <typename Range>
3792 template <typename Range>
3795 template <typename Range>
3797 template <typename Range>
3800 template <typename Range>
3803 template <typename Range>
3817 inline typed::set<> params() const;
3818 template <typename Domain2>
3820 template <typename Domain2>
3822 template <typename Domain2>
3824 template <typename Domain2>
3826 template <typename Range2>
3828 template <typename Range2>
3830 template <typename Range2>
3832 template <typename Domain2, typename Range2>
3834 template <typename Domain2, typename Range2>
3836 template <typename Domain2, typename Range2>
3840 inline typed::map<Domain, Domain> project_out_param(const std::string &id) const;
3848 template <typename Range2>
3850 template <typename Range2>
3852 template <typename Range2>
3859 template <typename Domain2>
3861 template <typename Domain2>
3862 inline typed::map<Domain2, Domain> set_domain_tuple(const std::string &id) const;
3863 template <typename Range2>
3865 template <typename Range2>
3866 inline typed::map<Domain, Range2> set_range_tuple(const std::string &id) const;
3875 inline typed::map<Domain, Domain> uncurry() const = delete;
3886};
3887
3888template <typename Domain, typename Range, typename Range2>
3889struct map<Domain, pair<Range, Range2>> : public isl::map {
3890 template <typename...>
3891 friend struct aff;
3892 template <typename...>
3893 friend struct aff_list;
3894 template <typename...>
3895 friend struct basic_map;
3896 template <typename...>
3897 friend struct basic_set;
3898 template <typename...>
3899 friend struct fixed_box;
3900 template <typename...>
3901 friend struct id;
3902 template <typename...>
3903 friend struct id_list;
3904 template <typename...>
3905 friend struct map;
3906 template <typename...>
3907 friend struct map_list;
3908 template <typename...>
3909 friend struct multi_aff;
3910 template <typename...>
3911 friend struct multi_id;
3912 template <typename...>
3913 friend struct multi_pw_aff;
3914 template <typename...>
3915 friend struct multi_union_pw_aff;
3916 template <typename...>
3917 friend struct multi_val;
3918 template <typename...>
3919 friend struct point;
3920 template <typename...>
3921 friend struct pw_aff;
3922 template <typename...>
3923 friend struct pw_aff_list;
3924 template <typename...>
3925 friend struct pw_multi_aff;
3926 template <typename...>
3927 friend struct pw_multi_aff_list;
3928 template <typename...>
3929 friend struct set;
3930 template <typename...>
3931 friend struct set_list;
3932 template <typename...>
3933 friend struct space;
3934 template <typename...>
3935 friend struct union_map;
3936 template <typename...>
3937 friend struct union_pw_aff;
3938 template <typename...>
3939 friend struct union_pw_aff_list;
3940 template <typename...>
3941 friend struct union_pw_multi_aff;
3942 template <typename...>
3943 friend struct union_set;
3944 template <typename...>
3945 friend struct union_set_list;
3946 template <typename...>
3947 friend struct val;
3948 template <typename...>
3949 friend struct val_list;
3950
3951 map() = default;
3952 template <typename Arg1, typename Arg2, typename Arg3,
3953 typename std::enable_if<
3954 std::is_base_of<Domain, Arg1>{} &&
3955 std::is_base_of<Range, Arg2>{} &&
3956 std::is_base_of<Range2, Arg3>{},
3957 bool>::type = true>
3958 map(const map<Arg1, pair<Arg2, Arg3>> &obj) : isl::map(obj) {}
3959 private:
3960 template <typename base,
3961 typename std::enable_if<
3962 std::is_same<base, isl::map>{}, bool>::type = true>
3963 map(const base &obj) : isl::map(obj) {}
3964 public:
3965 static map from(const isl::map &obj) {
3966 return map(obj);
3967 }
3968 inline /* implicit */ map(const typed::basic_map<Domain, pair<Range, Range2>> &bmap);
3969 inline explicit map(const isl::ctx &ctx, const std::string &str);
3970 template <typename Domain2>
3972 template <typename Domain2>
3974 template <typename Domain2>
3976 template <typename Arg3>
3978 template <typename Arg3>
3980 template <typename Arg3>
3997 template <typename Domain2>
3999 template <typename Domain2>
4001 template <typename Domain2>
4012 inline bool every_map(const std::function<bool(typed::map<Domain, pair<Range, Range2>>)> &test) const;
4016 inline void foreach_basic_map(const std::function<void(typed::basic_map<Domain, pair<Range, Range2>>)> &fn) const;
4017 inline void foreach_map(const std::function<void(typed::map<Domain, pair<Range, Range2>>)> &fn) const;
4084 inline typed::set<> params() const;
4085 template <typename Domain2>
4087 template <typename Domain2>
4089 template <typename Domain2>
4091 template <typename Domain2>
4093 template <typename Arg3>
4095 template <typename Arg3>
4097 template <typename Arg3>
4099 template <typename Domain2, typename Arg3>
4101 template <typename Domain2, typename Arg3>
4103 template <typename Domain2, typename Arg3>
4107 inline typed::map<Domain, pair<Range, Range2>> project_out_param(const std::string &id) const;
4115 template <typename Arg3>
4117 template <typename Arg3>
4119 template <typename Arg3>
4126 template <typename Domain2>
4128 template <typename Domain2>
4129 inline typed::map<Domain2, pair<Range, Range2>> set_domain_tuple(const std::string &id) const;
4131 inline typed::map<Domain, pair<Range, Range2>> set_range_tuple(const std::string &id) const = delete;
4151};
4152
4153template <typename T1, typename T2>
4154struct map<pair<T1, T2>, pair<T1, T2>> : public isl::map {
4155 template <typename...>
4156 friend struct aff;
4157 template <typename...>
4158 friend struct aff_list;
4159 template <typename...>
4160 friend struct basic_map;
4161 template <typename...>
4162 friend struct basic_set;
4163 template <typename...>
4164 friend struct fixed_box;
4165 template <typename...>
4166 friend struct id;
4167 template <typename...>
4168 friend struct id_list;
4169 template <typename...>
4170 friend struct map;
4171 template <typename...>
4172 friend struct map_list;
4173 template <typename...>
4174 friend struct multi_aff;
4175 template <typename...>
4176 friend struct multi_id;
4177 template <typename...>
4178 friend struct multi_pw_aff;
4179 template <typename...>
4180 friend struct multi_union_pw_aff;
4181 template <typename...>
4182 friend struct multi_val;
4183 template <typename...>
4184 friend struct point;
4185 template <typename...>
4186 friend struct pw_aff;
4187 template <typename...>
4188 friend struct pw_aff_list;
4189 template <typename...>
4190 friend struct pw_multi_aff;
4191 template <typename...>
4192 friend struct pw_multi_aff_list;
4193 template <typename...>
4194 friend struct set;
4195 template <typename...>
4196 friend struct set_list;
4197 template <typename...>
4198 friend struct space;
4199 template <typename...>
4200 friend struct union_map;
4201 template <typename...>
4202 friend struct union_pw_aff;
4203 template <typename...>
4204 friend struct union_pw_aff_list;
4205 template <typename...>
4206 friend struct union_pw_multi_aff;
4207 template <typename...>
4208 friend struct union_set;
4209 template <typename...>
4210 friend struct union_set_list;
4211 template <typename...>
4212 friend struct val;
4213 template <typename...>
4214 friend struct val_list;
4215
4216 map() = default;
4217 template <typename Arg1, typename Arg2,
4218 typename std::enable_if<
4219 std::is_base_of<T1, Arg1>{} &&
4220 std::is_base_of<T2, Arg2>{},
4221 bool>::type = true>
4223 private:
4224 template <typename base,
4225 typename std::enable_if<
4226 std::is_same<base, isl::map>{}, bool>::type = true>
4227 map(const base &obj) : isl::map(obj) {}
4228 public:
4229 static map from(const isl::map &obj) {
4230 return map(obj);
4231 }
4232 inline /* implicit */ map(const typed::basic_map<pair<T1, T2>, pair<T1, T2>> &bmap);
4233 inline explicit map(const isl::ctx &ctx, const std::string &str);
4234 template <typename Domain2>
4236 template <typename Domain2>
4238 template <typename Domain2>
4240 template <typename Range2>
4242 template <typename Range2>
4244 template <typename Range2>
4261 template <typename Domain2>
4263 template <typename Domain2>
4265 template <typename Domain2>
4270 template <typename Range>
4272 template <typename Range>
4275 template <typename Range>
4278 template <typename Range>
4280 inline bool every_map(const std::function<bool(typed::map<pair<T1, T2>, pair<T1, T2>>)> &test) const;
4284 inline void foreach_basic_map(const std::function<void(typed::basic_map<pair<T1, T2>, pair<T1, T2>>)> &fn) const;
4285 inline void foreach_map(const std::function<void(typed::map<pair<T1, T2>, pair<T1, T2>>)> &fn) const;
4320 template <typename Range>
4323 template <typename Range>
4326 template <typename Range>
4328 template <typename Range>
4331 template <typename Range>
4334 template <typename Range>
4336 template <typename Range>
4339 template <typename Range>
4342 template <typename Range>
4344 template <typename Range>
4347 template <typename Range>
4350 template <typename Range>
4364 inline typed::set<> params() const;
4365 template <typename Domain2>
4367 template <typename Domain2>
4369 template <typename Domain2>
4371 template <typename Domain2>
4373 template <typename Range2>
4375 template <typename Range2>
4377 template <typename Range2>
4379 template <typename Domain2, typename Range2>
4381 template <typename Domain2, typename Range2>
4383 template <typename Domain2, typename Range2>
4387 inline typed::map<pair<T1, T2>, pair<T1, T2>> project_out_param(const std::string &id) const;
4395 template <typename Range2>
4397 template <typename Range2>
4399 template <typename Range2>
4407 inline typed::map<pair<T1, T2>, pair<T1, T2>> set_domain_tuple(const std::string &id) const = delete;
4409 inline typed::map<pair<T1, T2>, pair<T1, T2>> set_range_tuple(const std::string &id) const = delete;
4418 inline typed::map<pair<pair<T1, T2>, T1>, T2> uncurry() const;
4429};
4430
4431template <typename T1, typename T2, typename Range, typename Range2>
4432struct map<pair<T1, T2>, pair<Range, Range2>> : public isl::map {
4433 template <typename...>
4434 friend struct aff;
4435 template <typename...>
4436 friend struct aff_list;
4437 template <typename...>
4438 friend struct basic_map;
4439 template <typename...>
4440 friend struct basic_set;
4441 template <typename...>
4442 friend struct fixed_box;
4443 template <typename...>
4444 friend struct id;
4445 template <typename...>
4446 friend struct id_list;
4447 template <typename...>
4448 friend struct map;
4449 template <typename...>
4450 friend struct map_list;
4451 template <typename...>
4452 friend struct multi_aff;
4453 template <typename...>
4454 friend struct multi_id;
4455 template <typename...>
4456 friend struct multi_pw_aff;
4457 template <typename...>
4458 friend struct multi_union_pw_aff;
4459 template <typename...>
4460 friend struct multi_val;
4461 template <typename...>
4462 friend struct point;
4463 template <typename...>
4464 friend struct pw_aff;
4465 template <typename...>
4466 friend struct pw_aff_list;
4467 template <typename...>
4468 friend struct pw_multi_aff;
4469 template <typename...>
4470 friend struct pw_multi_aff_list;
4471 template <typename...>
4472 friend struct set;
4473 template <typename...>
4474 friend struct set_list;
4475 template <typename...>
4476 friend struct space;
4477 template <typename...>
4478 friend struct union_map;
4479 template <typename...>
4480 friend struct union_pw_aff;
4481 template <typename...>
4482 friend struct union_pw_aff_list;
4483 template <typename...>
4484 friend struct union_pw_multi_aff;
4485 template <typename...>
4486 friend struct union_set;
4487 template <typename...>
4488 friend struct union_set_list;
4489 template <typename...>
4490 friend struct val;
4491 template <typename...>
4492 friend struct val_list;
4493
4494 map() = default;
4495 template <typename Arg1, typename Arg2, typename Arg3, typename Arg4,
4496 typename std::enable_if<
4497 std::is_base_of<T1, Arg1>{} &&
4498 std::is_base_of<T2, Arg2>{} &&
4499 std::is_base_of<Range, Arg3>{} &&
4500 std::is_base_of<Range2, Arg4>{},
4501 bool>::type = true>
4503 private:
4504 template <typename base,
4505 typename std::enable_if<
4506 std::is_same<base, isl::map>{}, bool>::type = true>
4507 map(const base &obj) : isl::map(obj) {}
4508 public:
4509 static map from(const isl::map &obj) {
4510 return map(obj);
4511 }
4512 inline /* implicit */ map(const typed::basic_map<pair<T1, T2>, pair<Range, Range2>> &bmap);
4513 inline explicit map(const isl::ctx &ctx, const std::string &str);
4514 template <typename Domain2>
4516 template <typename Domain2>
4518 template <typename Domain2>
4520 template <typename Arg2>
4522 template <typename Arg2>
4524 template <typename Arg2>
4541 template <typename Domain2>
4543 template <typename Domain2>
4545 template <typename Domain2>
4556 inline bool every_map(const std::function<bool(typed::map<pair<T1, T2>, pair<Range, Range2>>)> &test) const;
4560 inline void foreach_basic_map(const std::function<void(typed::basic_map<pair<T1, T2>, pair<Range, Range2>>)> &fn) const;
4561 inline void foreach_map(const std::function<void(typed::map<pair<T1, T2>, pair<Range, Range2>>)> &fn) const;
4628 inline typed::set<> params() const;
4629 template <typename Domain2>
4631 template <typename Domain2>
4633 template <typename Domain2>
4635 template <typename Domain2>
4637 template <typename Arg2>
4639 template <typename Arg2>
4641 template <typename Arg2>
4643 template <typename Domain2, typename Arg2>
4645 template <typename Domain2, typename Arg2>
4647 template <typename Domain2, typename Arg2>
4659 template <typename Arg2>
4661 template <typename Arg2>
4663 template <typename Arg2>
4671 inline typed::map<pair<T1, T2>, pair<Range, Range2>> set_domain_tuple(const std::string &id) const = delete;
4673 inline typed::map<pair<T1, T2>, pair<Range, Range2>> set_range_tuple(const std::string &id) const = delete;
4693};
4694
4695template <typename Domain, typename Range>
4697 template <typename...>
4698 friend struct aff;
4699 template <typename...>
4700 friend struct aff_list;
4701 template <typename...>
4702 friend struct basic_map;
4703 template <typename...>
4704 friend struct basic_set;
4705 template <typename...>
4706 friend struct fixed_box;
4707 template <typename...>
4708 friend struct id;
4709 template <typename...>
4710 friend struct id_list;
4711 template <typename...>
4712 friend struct map;
4713 template <typename...>
4714 friend struct map_list;
4715 template <typename...>
4716 friend struct multi_aff;
4717 template <typename...>
4718 friend struct multi_id;
4719 template <typename...>
4720 friend struct multi_pw_aff;
4721 template <typename...>
4722 friend struct multi_union_pw_aff;
4723 template <typename...>
4724 friend struct multi_val;
4725 template <typename...>
4726 friend struct point;
4727 template <typename...>
4728 friend struct pw_aff;
4729 template <typename...>
4730 friend struct pw_aff_list;
4731 template <typename...>
4732 friend struct pw_multi_aff;
4733 template <typename...>
4734 friend struct pw_multi_aff_list;
4735 template <typename...>
4736 friend struct set;
4737 template <typename...>
4738 friend struct set_list;
4739 template <typename...>
4740 friend struct space;
4741 template <typename...>
4742 friend struct union_map;
4743 template <typename...>
4744 friend struct union_pw_aff;
4745 template <typename...>
4746 friend struct union_pw_aff_list;
4747 template <typename...>
4748 friend struct union_pw_multi_aff;
4749 template <typename...>
4750 friend struct union_set;
4751 template <typename...>
4752 friend struct union_set_list;
4753 template <typename...>
4754 friend struct val;
4755 template <typename...>
4756 friend struct val_list;
4757
4758 map_list() = default;
4759 template <typename Arg1, typename Arg2,
4760 typename std::enable_if<
4761 std::is_base_of<Domain, Arg1>{} &&
4762 std::is_base_of<Range, Arg2>{},
4763 bool>::type = true>
4765 private:
4766 template <typename base,
4767 typename std::enable_if<
4768 std::is_same<base, isl::map_list>{}, bool>::type = true>
4769 map_list(const base &obj) : isl::map_list(obj) {}
4770 public:
4772 return map_list(obj);
4773 }
4774 inline explicit map_list(const isl::ctx &ctx, int n);
4775 inline explicit map_list(const typed::map<Domain, Range> &el);
4776 inline explicit map_list(const isl::ctx &ctx, const std::string &str);
4779 inline typed::map<Domain, Range> at(int index) const;
4780 inline typed::map<Domain, Range> get_at(int index) const = delete;
4781 inline typed::map_list<Domain, Range> drop(unsigned int first, unsigned int n) const;
4782 inline void foreach(const std::function<void(typed::map<Domain, Range>)> &fn) const;
4783 inline void foreach_scc(const std::function<bool(typed::map<Domain, Range>, typed::map<Domain, Range>)> &follows, const std::function<void(typed::map_list<Domain, Range>)> &fn) const;
4785};
4786
4787template <typename Domain>
4789 template <typename...>
4790 friend struct aff;
4791 template <typename...>
4792 friend struct aff_list;
4793 template <typename...>
4794 friend struct basic_map;
4795 template <typename...>
4796 friend struct basic_set;
4797 template <typename...>
4798 friend struct fixed_box;
4799 template <typename...>
4800 friend struct id;
4801 template <typename...>
4802 friend struct id_list;
4803 template <typename...>
4804 friend struct map;
4805 template <typename...>
4806 friend struct map_list;
4807 template <typename...>
4808 friend struct multi_aff;
4809 template <typename...>
4810 friend struct multi_id;
4811 template <typename...>
4812 friend struct multi_pw_aff;
4813 template <typename...>
4814 friend struct multi_union_pw_aff;
4815 template <typename...>
4816 friend struct multi_val;
4817 template <typename...>
4818 friend struct point;
4819 template <typename...>
4820 friend struct pw_aff;
4821 template <typename...>
4822 friend struct pw_aff_list;
4823 template <typename...>
4824 friend struct pw_multi_aff;
4825 template <typename...>
4826 friend struct pw_multi_aff_list;
4827 template <typename...>
4828 friend struct set;
4829 template <typename...>
4830 friend struct set_list;
4831 template <typename...>
4832 friend struct space;
4833 template <typename...>
4834 friend struct union_map;
4835 template <typename...>
4836 friend struct union_pw_aff;
4837 template <typename...>
4838 friend struct union_pw_aff_list;
4839 template <typename...>
4840 friend struct union_pw_multi_aff;
4841 template <typename...>
4842 friend struct union_set;
4843 template <typename...>
4844 friend struct union_set_list;
4845 template <typename...>
4846 friend struct val;
4847 template <typename...>
4848 friend struct val_list;
4849
4850 multi_aff() = default;
4851 template <typename Arg1,
4852 typename std::enable_if<
4853 std::is_base_of<Domain, Arg1>{},
4854 bool>::type = true>
4856 private:
4857 template <typename base,
4858 typename std::enable_if<
4859 std::is_same<base, isl::multi_aff>{}, bool>::type = true>
4860 multi_aff(const base &obj) : isl::multi_aff(obj) {}
4861 public:
4863 return multi_aff(obj);
4864 }
4865 inline /* implicit */ multi_aff(const typed::aff<Domain> &aff);
4867 inline explicit multi_aff(const isl::ctx &ctx, const std::string &str);
4877 template <typename Range>
4879 inline typed::map<Domain> as_map() const = delete;
4885 inline typed::aff<Anonymous> at(int pos) const;
4886 inline typed::aff<Domain> get_at(int pos) const = delete;
4893 inline typed::set<> domain() const;
4906 template <typename Arg1>
4914 inline typed::aff_list<Domain> get_list() const = delete;
4922 template <typename Range>
4924 template <typename Range>
4926 template <typename Range>
4929 inline typed::multi_aff<Domain> pullback(const typed::multi_aff<> &ma2) const = delete;
4933 inline typed::multi_aff<Domain> pullback(const typed::aff<> &ma2) const = delete;
4937 inline typed::multi_aff<Domain> range_product(const typed::multi_aff<> &multi2) const = delete;
4942 inline typed::multi_aff<Domain> range_product(const typed::aff<> &multi2) const = delete;
4943 inline typed::id<Domain> get_range_tuple_id() const = delete;
4946 inline typed::multi_aff<Domain> scale(long v) const;
4953 template <typename Domain2>
4955 template <typename Domain2>
4956 inline typed::multi_aff<Domain2> set_range_tuple(const std::string &id) const;
4958 inline typed::space<Domain> get_space() const = delete;
4972 template <typename Arg1>
4978};
4979
4980template <typename Domain, typename Range>
4982 template <typename...>
4983 friend struct aff;
4984 template <typename...>
4985 friend struct aff_list;
4986 template <typename...>
4987 friend struct basic_map;
4988 template <typename...>
4989 friend struct basic_set;
4990 template <typename...>
4991 friend struct fixed_box;
4992 template <typename...>
4993 friend struct id;
4994 template <typename...>
4995 friend struct id_list;
4996 template <typename...>
4997 friend struct map;
4998 template <typename...>
4999 friend struct map_list;
5000 template <typename...>
5001 friend struct multi_aff;
5002 template <typename...>
5003 friend struct multi_id;
5004 template <typename...>
5005 friend struct multi_pw_aff;
5006 template <typename...>
5007 friend struct multi_union_pw_aff;
5008 template <typename...>
5009 friend struct multi_val;
5010 template <typename...>
5011 friend struct point;
5012 template <typename...>
5013 friend struct pw_aff;
5014 template <typename...>
5015 friend struct pw_aff_list;
5016 template <typename...>
5017 friend struct pw_multi_aff;
5018 template <typename...>
5019 friend struct pw_multi_aff_list;
5020 template <typename...>
5021 friend struct set;
5022 template <typename...>
5023 friend struct set_list;
5024 template <typename...>
5025 friend struct space;
5026 template <typename...>
5027 friend struct union_map;
5028 template <typename...>
5029 friend struct union_pw_aff;
5030 template <typename...>
5031 friend struct union_pw_aff_list;
5032 template <typename...>
5033 friend struct union_pw_multi_aff;
5034 template <typename...>
5035 friend struct union_set;
5036 template <typename...>
5037 friend struct union_set_list;
5038 template <typename...>
5039 friend struct val;
5040 template <typename...>
5041 friend struct val_list;
5042
5043 multi_aff() = default;
5044 template <typename Arg1, typename Arg2,
5045 typename std::enable_if<
5046 std::is_base_of<Domain, Arg1>{} &&
5047 std::is_base_of<Range, Arg2>{},
5048 bool>::type = true>
5050 private:
5051 template <typename base,
5052 typename std::enable_if<
5053 std::is_same<base, isl::multi_aff>{}, bool>::type = true>
5054 multi_aff(const base &obj) : isl::multi_aff(obj) {}
5055 public:
5057 return multi_aff(obj);
5058 }
5059 inline /* implicit */ multi_aff(const typed::aff<Domain, Range> &aff);
5061 inline explicit multi_aff(const isl::ctx &ctx, const std::string &str);
5071 template <typename Range2>
5077 inline typed::set<Domain, Range> as_set() const = delete;
5080 inline typed::aff<Domain, Range> get_at(int pos) const = delete;
5115 template <typename Domain2, typename Range2>
5117 template <typename Domain2, typename Range2>
5119 template <typename Domain2, typename Range2>
5121 template <typename Domain2>
5123 template <typename Domain2>
5126 template <typename Domain2>
5129 template <typename Domain2>
5132 template <typename Domain2>
5135 template <typename Domain2>
5141 template <typename Range2>
5143 template <typename Range2>
5145 template <typename Range2>
5147 template <typename Range2>
5149 template <typename Range2>
5162 template <typename Range2>
5164 template <typename Range2>
5165 inline typed::multi_aff<Domain, Range2> set_range_tuple(const std::string &id) const;
5186};
5187
5188template <typename Domain2, typename Range2, typename Range>
5190 template <typename...>
5191 friend struct aff;
5192 template <typename...>
5193 friend struct aff_list;
5194 template <typename...>
5195 friend struct basic_map;
5196 template <typename...>
5197 friend struct basic_set;
5198 template <typename...>
5199 friend struct fixed_box;
5200 template <typename...>
5201 friend struct id;
5202 template <typename...>
5203 friend struct id_list;
5204 template <typename...>
5205 friend struct map;
5206 template <typename...>
5207 friend struct map_list;
5208 template <typename...>
5209 friend struct multi_aff;
5210 template <typename...>
5211 friend struct multi_id;
5212 template <typename...>
5213 friend struct multi_pw_aff;
5214 template <typename...>
5215 friend struct multi_union_pw_aff;
5216 template <typename...>
5217 friend struct multi_val;
5218 template <typename...>
5219 friend struct point;
5220 template <typename...>
5221 friend struct pw_aff;
5222 template <typename...>
5223 friend struct pw_aff_list;
5224 template <typename...>
5225 friend struct pw_multi_aff;
5226 template <typename...>
5227 friend struct pw_multi_aff_list;
5228 template <typename...>
5229 friend struct set;
5230 template <typename...>
5231 friend struct set_list;
5232 template <typename...>
5233 friend struct space;
5234 template <typename...>
5235 friend struct union_map;
5236 template <typename...>
5237 friend struct union_pw_aff;
5238 template <typename...>
5239 friend struct union_pw_aff_list;
5240 template <typename...>
5241 friend struct union_pw_multi_aff;
5242 template <typename...>
5243 friend struct union_set;
5244 template <typename...>
5245 friend struct union_set_list;
5246 template <typename...>
5247 friend struct val;
5248 template <typename...>
5249 friend struct val_list;
5250
5251 multi_aff() = default;
5252 template <typename Arg1, typename Arg2, typename Arg3,
5253 typename std::enable_if<
5254 std::is_base_of<Domain2, Arg1>{} &&
5255 std::is_base_of<Range2, Arg2>{} &&
5256 std::is_base_of<Range, Arg3>{},
5257 bool>::type = true>
5259 private:
5260 template <typename base,
5261 typename std::enable_if<
5262 std::is_same<base, isl::multi_aff>{}, bool>::type = true>
5263 multi_aff(const base &obj) : isl::multi_aff(obj) {}
5264 public:
5266 return multi_aff(obj);
5267 }
5268 inline /* implicit */ multi_aff(const typed::aff<pair<Domain2, Range2>, Range> &aff);
5270 inline explicit multi_aff(const isl::ctx &ctx, const std::string &str);
5280 template <typename Arg2>
5289 inline typed::aff<pair<Domain2, Range2>, Range> get_at(int pos) const = delete;
5322 template <typename Domain3>
5324 template <typename Domain3>
5326 template <typename Arg2, typename Arg3>
5328 template <typename Arg2, typename Arg3>
5330 template <typename Arg2, typename Arg3>
5332 template <typename Arg2>
5334 template <typename Arg2>
5337 template <typename Arg2>
5340 template <typename Arg2>
5343 template <typename Arg2>
5346 template <typename Arg2>
5352 template <typename Arg2>
5354 template <typename Arg2>
5356 template <typename Arg2>
5358 template <typename Arg2>
5360 template <typename Arg2>
5373 template <typename Arg1>
5375 template <typename Arg1>
5376 inline typed::multi_aff<pair<Domain2, Range2>, Arg1> set_range_tuple(const std::string &id) const;
5397};
5398
5399template <typename Domain, typename Range, typename Range2>
5401 template <typename...>
5402 friend struct aff;
5403 template <typename...>
5404 friend struct aff_list;
5405 template <typename...>
5406 friend struct basic_map;
5407 template <typename...>
5408 friend struct basic_set;
5409 template <typename...>
5410 friend struct fixed_box;
5411 template <typename...>
5412 friend struct id;
5413 template <typename...>
5414 friend struct id_list;
5415 template <typename...>
5416 friend struct map;
5417 template <typename...>
5418 friend struct map_list;
5419 template <typename...>
5420 friend struct multi_aff;
5421 template <typename...>
5422 friend struct multi_id;
5423 template <typename...>
5424 friend struct multi_pw_aff;
5425 template <typename...>
5426 friend struct multi_union_pw_aff;
5427 template <typename...>
5428 friend struct multi_val;
5429 template <typename...>
5430 friend struct point;
5431 template <typename...>
5432 friend struct pw_aff;
5433 template <typename...>
5434 friend struct pw_aff_list;
5435 template <typename...>
5436 friend struct pw_multi_aff;
5437 template <typename...>
5438 friend struct pw_multi_aff_list;
5439 template <typename...>
5440 friend struct set;
5441 template <typename...>
5442 friend struct set_list;
5443 template <typename...>
5444 friend struct space;
5445 template <typename...>
5446 friend struct union_map;
5447 template <typename...>
5448 friend struct union_pw_aff;
5449 template <typename...>
5450 friend struct union_pw_aff_list;
5451 template <typename...>
5452 friend struct union_pw_multi_aff;
5453 template <typename...>
5454 friend struct union_set;
5455 template <typename...>
5456 friend struct union_set_list;
5457 template <typename...>
5458 friend struct val;
5459 template <typename...>
5460 friend struct val_list;
5461
5462 multi_aff() = default;
5463 template <typename Arg1, typename Arg2, typename Arg3,
5464 typename std::enable_if<
5465 std::is_base_of<Domain, Arg1>{} &&
5466 std::is_base_of<Range, Arg2>{} &&
5467 std::is_base_of<Range2, Arg3>{},
5468 bool>::type = true>
5470 private:
5471 template <typename base,
5472 typename std::enable_if<
5473 std::is_same<base, isl::multi_aff>{}, bool>::type = true>
5474 multi_aff(const base &obj) : isl::multi_aff(obj) {}
5475 public:
5477 return multi_aff(obj);
5478 }
5479 inline /* implicit */ multi_aff(const typed::aff<Domain, pair<Range, Range2>> &aff);
5481 inline explicit multi_aff(const isl::ctx &ctx, const std::string &str);
5491 template <typename Arg3>
5535 template <typename Domain2, typename Arg3>
5537 template <typename Domain2, typename Arg3>
5539 template <typename Domain2, typename Arg3>
5541 template <typename Domain2>
5543 template <typename Domain2>
5546 template <typename Domain2>
5549 template <typename Domain2>
5552 template <typename Domain2>
5555 template <typename Domain2>
5561 template <typename Arg3>
5563 template <typename Arg3>
5565 template <typename Arg3>
5567 template <typename Arg3>
5569 template <typename Arg3>
5583 inline typed::multi_aff<Domain, pair<Range, Range2>> set_range_tuple(const std::string &id) const = delete;
5604};
5605
5606template <typename T1, typename T2, typename Range, typename Range2>
5607struct multi_aff<pair<T1, T2>, pair<Range, Range2>> : public isl::multi_aff {
5608 template <typename...>
5609 friend struct aff;
5610 template <typename...>
5611 friend struct aff_list;
5612 template <typename...>
5613 friend struct basic_map;
5614 template <typename...>
5615 friend struct basic_set;
5616 template <typename...>
5617 friend struct fixed_box;
5618 template <typename...>
5619 friend struct id;
5620 template <typename...>
5621 friend struct id_list;
5622 template <typename...>
5623 friend struct map;
5624 template <typename...>
5625 friend struct map_list;
5626 template <typename...>
5627 friend struct multi_aff;
5628 template <typename...>
5629 friend struct multi_id;
5630 template <typename...>
5631 friend struct multi_pw_aff;
5632 template <typename...>
5633 friend struct multi_union_pw_aff;
5634 template <typename...>
5635 friend struct multi_val;
5636 template <typename...>
5637 friend struct point;
5638 template <typename...>
5639 friend struct pw_aff;
5640 template <typename...>
5641 friend struct pw_aff_list;
5642 template <typename...>
5643 friend struct pw_multi_aff;
5644 template <typename...>
5645 friend struct pw_multi_aff_list;
5646 template <typename...>
5647 friend struct set;
5648 template <typename...>
5649 friend struct set_list;
5650 template <typename...>
5651 friend struct space;
5652 template <typename...>
5653 friend struct union_map;
5654 template <typename...>
5655 friend struct union_pw_aff;
5656 template <typename...>
5657 friend struct union_pw_aff_list;
5658 template <typename...>
5659 friend struct union_pw_multi_aff;
5660 template <typename...>
5661 friend struct union_set;
5662 template <typename...>
5663 friend struct union_set_list;
5664 template <typename...>
5665 friend struct val;
5666 template <typename...>
5667 friend struct val_list;
5668
5669 multi_aff() = default;
5670 template <typename Arg1, typename Arg2, typename Arg3, typename Arg4,
5671 typename std::enable_if<
5672 std::is_base_of<T1, Arg1>{} &&
5673 std::is_base_of<T2, Arg2>{} &&
5674 std::is_base_of<Range, Arg3>{} &&
5675 std::is_base_of<Range2, Arg4>{},
5676 bool>::type = true>
5678 private:
5679 template <typename base,
5680 typename std::enable_if<
5681 std::is_same<base, isl::multi_aff>{}, bool>::type = true>
5682 multi_aff(const base &obj) : isl::multi_aff(obj) {}
5683 public:
5685 return multi_aff(obj);
5686 }
5689 inline explicit multi_aff(const isl::ctx &ctx, const std::string &str);
5699 template <typename Arg2>
5741 template <typename Domain3>
5743 template <typename Domain3>
5745 template <typename Domain2, typename Arg2>
5747 template <typename Domain2, typename Arg2>
5749 template <typename Domain2, typename Arg2>
5751 template <typename Domain2>
5753 template <typename Domain2>
5756 template <typename Domain2>
5759 template <typename Domain2>
5762 template <typename Domain2>
5765 template <typename Domain2>
5771 template <typename Arg2>
5773 template <typename Arg2>
5775 template <typename Arg2>
5777 template <typename Arg2>
5779 template <typename Arg2>
5793 inline typed::multi_aff<pair<T1, T2>, pair<Range, Range2>> set_range_tuple(const std::string &id) const = delete;
5814};
5815
5816template <typename Domain>
5818 template <typename...>
5819 friend struct aff;
5820 template <typename...>
5821 friend struct aff_list;
5822 template <typename...>
5823 friend struct basic_map;
5824 template <typename...>
5825 friend struct basic_set;
5826 template <typename...>
5827 friend struct fixed_box;
5828 template <typename...>
5829 friend struct id;
5830 template <typename...>
5831 friend struct id_list;
5832 template <typename...>
5833 friend struct map;
5834 template <typename...>
5835 friend struct map_list;
5836 template <typename...>
5837 friend struct multi_aff;
5838 template <typename...>
5839 friend struct multi_id;
5840 template <typename...>
5841 friend struct multi_pw_aff;
5842 template <typename...>
5843 friend struct multi_union_pw_aff;
5844 template <typename...>
5845 friend struct multi_val;
5846 template <typename...>
5847 friend struct point;
5848 template <typename...>
5849 friend struct pw_aff;
5850 template <typename...>
5851 friend struct pw_aff_list;
5852 template <typename...>
5853 friend struct pw_multi_aff;
5854 template <typename...>
5855 friend struct pw_multi_aff_list;
5856 template <typename...>
5857 friend struct set;
5858 template <typename...>
5859 friend struct set_list;
5860 template <typename...>
5861 friend struct space;
5862 template <typename...>
5863 friend struct union_map;
5864 template <typename...>
5865 friend struct union_pw_aff;
5866 template <typename...>
5867 friend struct union_pw_aff_list;
5868 template <typename...>
5869 friend struct union_pw_multi_aff;
5870 template <typename...>
5871 friend struct union_set;
5872 template <typename...>
5873 friend struct union_set_list;
5874 template <typename...>
5875 friend struct val;
5876 template <typename...>
5877 friend struct val_list;
5878
5879 multi_id() = default;
5880 template <typename Arg1,
5881 typename std::enable_if<
5882 std::is_base_of<Domain, Arg1>{},
5883 bool>::type = true>
5885 private:
5886 template <typename base,
5887 typename std::enable_if<
5888 std::is_same<base, isl::multi_id>{}, bool>::type = true>
5889 multi_id(const base &obj) : isl::multi_id(obj) {}
5890 public:
5892 return multi_id(obj);
5893 }
5895 inline explicit multi_id(const isl::ctx &ctx, const std::string &str);
5896 inline typed::id<Anonymous> at(int pos) const;
5897 inline typed::id<Domain> get_at(int pos) const = delete;
5899 inline typed::id_list<Domain> get_list() const = delete;
5900 inline typed::multi_id<Domain> range_product(const typed::multi_id<> &multi2) const = delete;
5902 inline typed::multi_id<Domain> set_at(int pos, const std::string &el) const;
5904 inline typed::space<Domain> get_space() const = delete;
5905};
5906
5907template <typename Domain>
5909 template <typename...>
5910 friend struct aff;
5911 template <typename...>
5912 friend struct aff_list;
5913 template <typename...>
5914 friend struct basic_map;
5915 template <typename...>
5916 friend struct basic_set;
5917 template <typename...>
5918 friend struct fixed_box;
5919 template <typename...>
5920 friend struct id;
5921 template <typename...>
5922 friend struct id_list;
5923 template <typename...>
5924 friend struct map;
5925 template <typename...>
5926 friend struct map_list;
5927 template <typename...>
5928 friend struct multi_aff;
5929 template <typename...>
5930 friend struct multi_id;
5931 template <typename...>
5932 friend struct multi_pw_aff;
5933 template <typename...>
5934 friend struct multi_union_pw_aff;
5935 template <typename...>
5936 friend struct multi_val;
5937 template <typename...>
5938 friend struct point;
5939 template <typename...>
5940 friend struct pw_aff;
5941 template <typename...>
5942 friend struct pw_aff_list;
5943 template <typename...>
5944 friend struct pw_multi_aff;
5945 template <typename...>
5946 friend struct pw_multi_aff_list;
5947 template <typename...>
5948 friend struct set;
5949 template <typename...>
5950 friend struct set_list;
5951 template <typename...>
5952 friend struct space;
5953 template <typename...>
5954 friend struct union_map;
5955 template <typename...>
5956 friend struct union_pw_aff;
5957 template <typename...>
5958 friend struct union_pw_aff_list;
5959 template <typename...>
5960 friend struct union_pw_multi_aff;
5961 template <typename...>
5962 friend struct union_set;
5963 template <typename...>
5964 friend struct union_set_list;
5965 template <typename...>
5966 friend struct val;
5967 template <typename...>
5968 friend struct val_list;
5969
5970 multi_pw_aff() = default;
5971 template <typename Arg1,
5972 typename std::enable_if<
5973 std::is_base_of<Domain, Arg1>{},
5974 bool>::type = true>
5976 private:
5977 template <typename base,
5978 typename std::enable_if<
5979 std::is_same<base, isl::multi_pw_aff>{}, bool>::type = true>
5981 public:
5983 return multi_pw_aff(obj);
5984 }
5985 inline /* implicit */ multi_pw_aff(const typed::aff<Domain> &aff);
5986 inline /* implicit */ multi_pw_aff(const typed::multi_aff<Domain> &ma);
5987 inline /* implicit */ multi_pw_aff(const typed::pw_aff<Domain> &pa);
5989 inline /* implicit */ multi_pw_aff(const typed::pw_multi_aff<Domain> &pma);
5990 inline explicit multi_pw_aff(const isl::ctx &ctx, const std::string &str);
6000 inline typed::map<Domain> as_map() const = delete;
6004 inline typed::pw_aff<Domain> get_at(int pos) const = delete;
6009 inline typed::set<> domain() const;
6019 template <typename Arg1>
6029 inline typed::pw_aff_list<Domain> get_list() const = delete;
6043 template <typename Range>
6046 template <typename Range>
6049 template <typename Range>
6057 inline typed::multi_pw_aff<Domain> range_product(const typed::aff<> &multi2) const = delete;
6059 inline typed::multi_pw_aff<Domain> range_product(const typed::pw_aff<> &multi2) const = delete;
6061 inline typed::id<Domain> get_range_tuple_id() const = delete;
6070 template <typename Domain2>
6072 template <typename Domain2>
6073 inline typed::multi_pw_aff<Domain2> set_range_tuple(const std::string &id) const;
6075 inline typed::space<Domain> get_space() const = delete;
6082 template <typename Arg1>
6090};
6091
6092template <typename Domain, typename Range>
6094 template <typename...>
6095 friend struct aff;
6096 template <typename...>
6097 friend struct aff_list;
6098 template <typename...>
6099 friend struct basic_map;
6100 template <typename...>
6101 friend struct basic_set;
6102 template <typename...>
6103 friend struct fixed_box;
6104 template <typename...>
6105 friend struct id;
6106 template <typename...>
6107 friend struct id_list;
6108 template <typename...>
6109 friend struct map;
6110 template <typename...>
6111 friend struct map_list;
6112 template <typename...>
6113 friend struct multi_aff;
6114 template <typename...>
6115 friend struct multi_id;
6116 template <typename...>
6117 friend struct multi_pw_aff;
6118 template <typename...>
6119 friend struct multi_union_pw_aff;
6120 template <typename...>
6121 friend struct multi_val;
6122 template <typename...>
6123 friend struct point;
6124 template <typename...>
6125 friend struct pw_aff;
6126 template <typename...>
6127 friend struct pw_aff_list;
6128 template <typename...>
6129 friend struct pw_multi_aff;
6130 template <typename...>
6131 friend struct pw_multi_aff_list;
6132 template <typename...>
6133 friend struct set;
6134 template <typename...>
6135 friend struct set_list;
6136 template <typename...>
6137 friend struct space;
6138 template <typename...>
6139 friend struct union_map;
6140 template <typename...>
6141 friend struct union_pw_aff;
6142 template <typename...>
6143 friend struct union_pw_aff_list;
6144 template <typename...>
6145 friend struct union_pw_multi_aff;
6146 template <typename...>
6147 friend struct union_set;
6148 template <typename...>
6149 friend struct union_set_list;
6150 template <typename...>
6151 friend struct val;
6152 template <typename...>
6153 friend struct val_list;
6154
6155 multi_pw_aff() = default;
6156 template <typename Arg1, typename Arg2,
6157 typename std::enable_if<
6158 std::is_base_of<Domain, Arg1>{} &&
6159 std::is_base_of<Range, Arg2>{},
6160 bool>::type = true>
6162 private:
6163 template <typename base,
6164 typename std::enable_if<
6165 std::is_same<base, isl::multi_pw_aff>{}, bool>::type = true>
6167 public:
6169 return multi_pw_aff(obj);
6170 }
6171 inline /* implicit */ multi_pw_aff(const typed::aff<Domain, Range> &aff);
6172 inline /* implicit */ multi_pw_aff(const typed::multi_aff<Domain, Range> &ma);
6173 inline /* implicit */ multi_pw_aff(const typed::pw_aff<Domain, Range> &pa);
6176 inline explicit multi_pw_aff(const isl::ctx &ctx, const std::string &str);
6188 inline typed::set<Domain, Range> as_set() const = delete;
6190 inline typed::pw_aff<Domain, Range> get_at(int pos) const = delete;
6228 template <typename Domain2, typename Range2>
6230 template <typename Domain2>
6232 template <typename Domain2, typename Range2>
6234 template <typename Domain2>
6236 template <typename Domain2, typename Range2>
6238 template <typename Domain2>
6241 template <typename Domain2>
6244 template <typename Domain2>
6247 template <typename Domain2>
6250 template <typename Range2>
6252 template <typename Range2>
6255 template <typename Range2>
6258 template <typename Range2>
6269 template <typename Range2>
6271 template <typename Range2>
6272 inline typed::multi_pw_aff<Domain, Range2> set_range_tuple(const std::string &id) const;
6288};
6289
6290template <typename Domain2, typename Range2, typename Range>
6292 template <typename...>
6293 friend struct aff;
6294 template <typename...>
6295 friend struct aff_list;
6296 template <typename...>
6297 friend struct basic_map;
6298 template <typename...>
6299 friend struct basic_set;
6300 template <typename...>
6301 friend struct fixed_box;
6302 template <typename...>
6303 friend struct id;
6304 template <typename...>
6305 friend struct id_list;
6306 template <typename...>
6307 friend struct map;
6308 template <typename...>
6309 friend struct map_list;
6310 template <typename...>
6311 friend struct multi_aff;
6312 template <typename...>
6313 friend struct multi_id;
6314 template <typename...>
6315 friend struct multi_pw_aff;
6316 template <typename...>
6317 friend struct multi_union_pw_aff;
6318 template <typename...>
6319 friend struct multi_val;
6320 template <typename...>
6321 friend struct point;
6322 template <typename...>
6323 friend struct pw_aff;
6324 template <typename...>
6325 friend struct pw_aff_list;
6326 template <typename...>
6327 friend struct pw_multi_aff;
6328 template <typename...>
6329 friend struct pw_multi_aff_list;
6330 template <typename...>
6331 friend struct set;
6332 template <typename...>
6333 friend struct set_list;
6334 template <typename...>
6335 friend struct space;
6336 template <typename...>
6337 friend struct union_map;
6338 template <typename...>
6339 friend struct union_pw_aff;
6340 template <typename...>
6341 friend struct union_pw_aff_list;
6342 template <typename...>
6343 friend struct union_pw_multi_aff;
6344 template <typename...>
6345 friend struct union_set;
6346 template <typename...>
6347 friend struct union_set_list;
6348 template <typename...>
6349 friend struct val;
6350 template <typename...>
6351 friend struct val_list;
6352
6353 multi_pw_aff() = default;
6354 template <typename Arg1, typename Arg2, typename Arg3,
6355 typename std::enable_if<
6356 std::is_base_of<Domain2, Arg1>{} &&
6357 std::is_base_of<Range2, Arg2>{} &&
6358 std::is_base_of<Range, Arg3>{},
6359 bool>::type = true>
6361 private:
6362 template <typename base,
6363 typename std::enable_if<
6364 std::is_same<base, isl::multi_pw_aff>{}, bool>::type = true>
6366 public:
6368 return multi_pw_aff(obj);
6369 }
6370 inline /* implicit */ multi_pw_aff(const typed::aff<pair<Domain2, Range2>, Range> &aff);
6375 inline explicit multi_pw_aff(const isl::ctx &ctx, const std::string &str);
6427 template <typename Arg2, typename Arg3>
6429 template <typename Arg2>
6431 template <typename Arg2, typename Arg3>
6433 template <typename Arg2>
6435 template <typename Arg2, typename Arg3>
6437 template <typename Arg2>
6440 template <typename Arg2>
6443 template <typename Arg2>
6446 template <typename Arg2>
6449 template <typename Arg2>
6451 template <typename Arg2>
6454 template <typename Arg2>
6457 template <typename Arg2>
6468 template <typename Arg1>
6470 template <typename Arg1>
6471 inline typed::multi_pw_aff<pair<Domain2, Range2>, Arg1> set_range_tuple(const std::string &id) const;
6487};
6488
6489template <typename Domain>
6491 template <typename...>
6492 friend struct aff;
6493 template <typename...>
6494 friend struct aff_list;
6495 template <typename...>
6496 friend struct basic_map;
6497 template <typename...>
6498 friend struct basic_set;
6499 template <typename...>
6500 friend struct fixed_box;
6501 template <typename...>
6502 friend struct id;
6503 template <typename...>
6504 friend struct id_list;
6505 template <typename...>
6506 friend struct map;
6507 template <typename...>
6508 friend struct map_list;
6509 template <typename...>
6510 friend struct multi_aff;
6511 template <typename...>
6512 friend struct multi_id;
6513 template <typename...>
6514 friend struct multi_pw_aff;
6515 template <typename...>
6516 friend struct multi_union_pw_aff;
6517 template <typename...>
6518 friend struct multi_val;
6519 template <typename...>
6520 friend struct point;
6521 template <typename...>
6522 friend struct pw_aff;
6523 template <typename...>
6524 friend struct pw_aff_list;
6525 template <typename...>
6526 friend struct pw_multi_aff;
6527 template <typename...>
6528 friend struct pw_multi_aff_list;
6529 template <typename...>
6530 friend struct set;
6531 template <typename...>
6532 friend struct set_list;
6533 template <typename...>
6534 friend struct space;
6535 template <typename...>
6536 friend struct union_map;
6537 template <typename...>
6538 friend struct union_pw_aff;
6539 template <typename...>
6540 friend struct union_pw_aff_list;
6541 template <typename...>
6542 friend struct union_pw_multi_aff;
6543 template <typename...>
6544 friend struct union_set;
6545 template <typename...>
6546 friend struct union_set_list;
6547 template <typename...>
6548 friend struct val;
6549 template <typename...>
6550 friend struct val_list;
6551
6553 template <typename Arg1,
6554 typename std::enable_if<
6555 std::is_base_of<Domain, Arg1>{},
6556 bool>::type = true>
6558 private:
6559 template <typename base,
6560 typename std::enable_if<
6561 std::is_same<base, isl::multi_union_pw_aff>{}, bool>::type = true>
6563 public:
6567 inline /* implicit */ multi_union_pw_aff(const typed::multi_pw_aff<Domain> &mpa);
6568 inline /* implicit */ multi_union_pw_aff(const typed::union_pw_aff<Domain> &upa);
6570 inline explicit multi_union_pw_aff(const isl::ctx &ctx, const std::string &str);
6575 inline typed::union_pw_aff<Domain> get_at(int pos) const = delete;
6603 inline typed::id<Domain> get_range_tuple_id() const = delete;
6611 template <typename Domain2>
6613 template <typename Domain2>
6614 inline typed::multi_union_pw_aff<Domain2> set_range_tuple(const std::string &id) const;
6616 inline typed::space<Domain> get_space() const = delete;
6623};
6624
6625template <typename Domain, typename Range>
6627 template <typename...>
6628 friend struct aff;
6629 template <typename...>
6630 friend struct aff_list;
6631 template <typename...>
6632 friend struct basic_map;
6633 template <typename...>
6634 friend struct basic_set;
6635 template <typename...>
6636 friend struct fixed_box;
6637 template <typename...>
6638 friend struct id;
6639 template <typename...>
6640 friend struct id_list;
6641 template <typename...>
6642 friend struct map;
6643 template <typename...>
6644 friend struct map_list;
6645 template <typename...>
6646 friend struct multi_aff;
6647 template <typename...>
6648 friend struct multi_id;
6649 template <typename...>
6650 friend struct multi_pw_aff;
6651 template <typename...>
6652 friend struct multi_union_pw_aff;
6653 template <typename...>
6654 friend struct multi_val;
6655 template <typename...>
6656 friend struct point;
6657 template <typename...>
6658 friend struct pw_aff;
6659 template <typename...>
6660 friend struct pw_aff_list;
6661 template <typename...>
6662 friend struct pw_multi_aff;
6663 template <typename...>
6664 friend struct pw_multi_aff_list;
6665 template <typename...>
6666 friend struct set;
6667 template <typename...>
6668 friend struct set_list;
6669 template <typename...>
6670 friend struct space;
6671 template <typename...>
6672 friend struct union_map;
6673 template <typename...>
6674 friend struct union_pw_aff;
6675 template <typename...>
6676 friend struct union_pw_aff_list;
6677 template <typename...>
6678 friend struct union_pw_multi_aff;
6679 template <typename...>
6680 friend struct union_set;
6681 template <typename...>
6682 friend struct union_set_list;
6683 template <typename...>
6684 friend struct val;
6685 template <typename...>
6686 friend struct val_list;
6687
6689 template <typename Arg1, typename Arg2,
6690 typename std::enable_if<
6691 std::is_base_of<Domain, Arg1>{} &&
6692 std::is_base_of<Range, Arg2>{},
6693 bool>::type = true>
6695 private:
6696 template <typename base,
6697 typename std::enable_if<
6698 std::is_same<base, isl::multi_union_pw_aff>{}, bool>::type = true>
6700 public:
6707 inline explicit multi_union_pw_aff(const isl::ctx &ctx, const std::string &str);
6733 template <typename Domain2>
6736 template <typename Domain2>
6739 template <typename Domain2>
6742 template <typename Domain2>
6745 template <typename Range2>
6747 template <typename Range2>
6758 template <typename Range2>
6760 template <typename Range2>
6770};
6771
6772template <typename Domain>
6774 template <typename...>
6775 friend struct aff;
6776 template <typename...>
6777 friend struct aff_list;
6778 template <typename...>
6779 friend struct basic_map;
6780 template <typename...>
6781 friend struct basic_set;
6782 template <typename...>
6783 friend struct fixed_box;
6784 template <typename...>
6785 friend struct id;
6786 template <typename...>
6787 friend struct id_list;
6788 template <typename...>
6789 friend struct map;
6790 template <typename...>
6791 friend struct map_list;
6792 template <typename...>
6793 friend struct multi_aff;
6794 template <typename...>
6795 friend struct multi_id;
6796 template <typename...>
6797 friend struct multi_pw_aff;
6798 template <typename...>
6799 friend struct multi_union_pw_aff;
6800 template <typename...>
6801 friend struct multi_val;
6802 template <typename...>
6803 friend struct point;
6804 template <typename...>
6805 friend struct pw_aff;
6806 template <typename...>
6807 friend struct pw_aff_list;
6808 template <typename...>
6809 friend struct pw_multi_aff;
6810 template <typename...>
6811 friend struct pw_multi_aff_list;
6812 template <typename...>
6813 friend struct set;
6814 template <typename...>
6815 friend struct set_list;
6816 template <typename...>
6817 friend struct space;
6818 template <typename...>
6819 friend struct union_map;
6820 template <typename...>
6821 friend struct union_pw_aff;
6822 template <typename...>
6823 friend struct union_pw_aff_list;
6824 template <typename...>
6825 friend struct union_pw_multi_aff;
6826 template <typename...>
6827 friend struct union_set;
6828 template <typename...>
6829 friend struct union_set_list;
6830 template <typename...>
6831 friend struct val;
6832 template <typename...>
6833 friend struct val_list;
6834
6835 multi_val() = default;
6836 template <typename Arg1,
6837 typename std::enable_if<
6838 std::is_base_of<Domain, Arg1>{},
6839 bool>::type = true>
6841 private:
6842 template <typename base,
6843 typename std::enable_if<
6844 std::is_same<base, isl::multi_val>{}, bool>::type = true>
6845 multi_val(const base &obj) : isl::multi_val(obj) {}
6846 public:
6848 return multi_val(obj);
6849 }
6851 inline explicit multi_val(const isl::ctx &ctx, const std::string &str);
6854 inline typed::multi_val<Domain> add(long v) const;
6855 inline typed::val<Anonymous> at(int pos) const;
6856 inline typed::val<Domain> get_at(int pos) const = delete;
6858 inline typed::val_list<Domain> get_list() const = delete;
6862 template <typename Range>
6864 inline typed::multi_val<Domain> range_product(const typed::multi_val<> &multi2) const = delete;
6865 inline typed::id<Domain> get_range_tuple_id() const = delete;
6868 inline typed::multi_val<Domain> scale(long v) const;
6873 inline typed::multi_val<Domain> set_at(int pos, long el) const;
6874 template <typename Domain2>
6876 template <typename Domain2>
6877 inline typed::multi_val<Domain2> set_range_tuple(const std::string &id) const;
6879 inline typed::space<Domain> get_space() const = delete;
6881};
6882
6883template <>
6884struct point<> : public isl::point {
6885 template <typename...>
6886 friend struct aff;
6887 template <typename...>
6888 friend struct aff_list;
6889 template <typename...>
6890 friend struct basic_map;
6891 template <typename...>
6892 friend struct basic_set;
6893 template <typename...>
6894 friend struct fixed_box;
6895 template <typename...>
6896 friend struct id;
6897 template <typename...>
6898 friend struct id_list;
6899 template <typename...>
6900 friend struct map;
6901 template <typename...>
6902 friend struct map_list;
6903 template <typename...>
6904 friend struct multi_aff;
6905 template <typename...>
6906 friend struct multi_id;
6907 template <typename...>
6908 friend struct multi_pw_aff;
6909 template <typename...>
6910 friend struct multi_union_pw_aff;
6911 template <typename...>
6912 friend struct multi_val;
6913 template <typename...>
6914 friend struct point;
6915 template <typename...>
6916 friend struct pw_aff;
6917 template <typename...>
6918 friend struct pw_aff_list;
6919 template <typename...>
6920 friend struct pw_multi_aff;
6921 template <typename...>
6922 friend struct pw_multi_aff_list;
6923 template <typename...>
6924 friend struct set;
6925 template <typename...>
6926 friend struct set_list;
6927 template <typename...>
6928 friend struct space;
6929 template <typename...>
6930 friend struct union_map;
6931 template <typename...>
6932 friend struct union_pw_aff;
6933 template <typename...>
6934 friend struct union_pw_aff_list;
6935 template <typename...>
6936 friend struct union_pw_multi_aff;
6937 template <typename...>
6938 friend struct union_set;
6939 template <typename...>
6940 friend struct union_set_list;
6941 template <typename...>
6942 friend struct val;
6943 template <typename...>
6944 friend struct val_list;
6945
6946 point() = default;
6947 private:
6948 template <typename base,
6949 typename std::enable_if<
6950 std::is_same<base, isl::point>{}, bool>::type = true>
6951 point(const base &obj) : isl::point(obj) {}
6952 public:
6953 static point from(const isl::point &obj) {
6954 return point(obj);
6955 }
6956 inline typed::basic_set<> apply(const typed::basic_map<> &bmap) const = delete;
6957 inline typed::set<> apply(const typed::map<> &map) const = delete;
6958 inline typed::union_set<> apply(const typed::union_map<> &umap) const = delete;
6960 inline typed::set<> as_set() const = delete;
6961 inline typed::set<> bind(const typed::multi_id<> &tuple) const = delete;
6962 inline typed::set<> coalesce() const;
6965 inline bool every_set(const std::function<bool(typed::set<>)> &test) const;
6967 inline void foreach_basic_set(const std::function<void(typed::basic_set<>)> &fn) const;
6968 inline void foreach_point(const std::function<void(typed::point<>)> &fn) const;
6969 inline void foreach_set(const std::function<void(typed::set<>)> &fn) const;
6973 inline typed::set<> gist_params(const typed::set<> &context) const = delete;
6974 inline typed::map<> identity() const = delete;
6976 inline typed::map<> insert_domain(const typed::space<> &domain) const = delete;
6980 inline typed::basic_set<> intersect_params(const typed::basic_set<> &bset2) const = delete;
6981 inline typed::set<> intersect_params(const typed::set<> &params) const = delete;
6982 inline typed::fixed_box<> lattice_tile() const = delete;
6983 inline typed::set<> lexmax() const = delete;
6985 inline typed::set<> lexmin() const = delete;
6987 inline typed::set<> lower_bound(const typed::multi_pw_aff<> &lower) const = delete;
6988 inline typed::set<> lower_bound(const typed::multi_val<> &lower) const = delete;
6990 inline typed::val<> max_val(const typed::aff<> &obj) const = delete;
6992 inline typed::val<> min_val(const typed::aff<> &obj) const = delete;
6993 inline typed::multi_val<> multi_val() const = delete;
6994 inline typed::multi_val<> get_multi_val() const = delete;
6996 inline typed::pw_aff<Anonymous> param_pw_aff_on_domain(const std::string &id) const;
6997 inline typed::basic_set<> params() const = delete;
6999 inline typed::set<> preimage(const typed::multi_aff<> &ma) const = delete;
7000 inline typed::set<> preimage(const typed::multi_pw_aff<> &mpa) const = delete;
7001 inline typed::set<> preimage(const typed::pw_multi_aff<> &pma) const = delete;
7002 inline typed::union_set<> preimage(const typed::union_pw_multi_aff<> &upma) const = delete;
7003 inline typed::set<> product(const typed::set<> &set2) const = delete;
7006 inline typed::set<> project_out_param(const std::string &id) const;
7010 template <typename Domain>
7014 inline typed::space<> space() const;
7017 inline typed::set<> to_set() const;
7019 inline typed::map<> translation() const = delete;
7020 template <typename Domain>
7023 inline typed::set<> unite(const typed::basic_set<> &bset2) const;
7024 inline typed::set<> unite(const typed::set<> &set2) const;
7025 inline typed::union_set<> unite(const typed::union_set<> &uset2) const;
7026 inline typed::map<> unwrap() const = delete;
7027 inline typed::set<> upper_bound(const typed::multi_pw_aff<> &upper) const = delete;
7028 inline typed::set<> upper_bound(const typed::multi_val<> &upper) const = delete;
7029 inline typed::set<> wrapped_reverse() const = delete;
7030};
7031
7032template <typename Domain>
7033struct point<Domain> : public isl::point {
7034 template <typename...>
7035 friend struct aff;
7036 template <typename...>
7037 friend struct aff_list;
7038 template <typename...>
7039 friend struct basic_map;
7040 template <typename...>
7041 friend struct basic_set;
7042 template <typename...>
7043 friend struct fixed_box;
7044 template <typename...>
7045 friend struct id;
7046 template <typename...>
7047 friend struct id_list;
7048 template <typename...>
7049 friend struct map;
7050 template <typename...>
7051 friend struct map_list;
7052 template <typename...>
7053 friend struct multi_aff;
7054 template <typename...>
7055 friend struct multi_id;
7056 template <typename...>
7057 friend struct multi_pw_aff;
7058 template <typename...>
7059 friend struct multi_union_pw_aff;
7060 template <typename...>
7061 friend struct multi_val;
7062 template <typename...>
7063 friend struct point;
7064 template <typename...>
7065 friend struct pw_aff;
7066 template <typename...>
7067 friend struct pw_aff_list;
7068 template <typename...>
7069 friend struct pw_multi_aff;
7070 template <typename...>
7071 friend struct pw_multi_aff_list;
7072 template <typename...>
7073 friend struct set;
7074 template <typename...>
7075 friend struct set_list;
7076 template <typename...>
7077 friend struct space;
7078 template <typename...>
7079 friend struct union_map;
7080 template <typename...>
7081 friend struct union_pw_aff;
7082 template <typename...>
7083 friend struct union_pw_aff_list;
7084 template <typename...>
7085 friend struct union_pw_multi_aff;
7086 template <typename...>
7087 friend struct union_set;
7088 template <typename...>
7089 friend struct union_set_list;
7090 template <typename...>
7091 friend struct val;
7092 template <typename...>
7093 friend struct val_list;
7094
7095 point() = default;
7096 template <typename Arg1,
7097 typename std::enable_if<
7098 std::is_base_of<Domain, Arg1>{},
7099 bool>::type = true>
7101 private:
7102 template <typename base,
7103 typename std::enable_if<
7104 std::is_same<base, isl::point>{}, bool>::type = true>
7105 point(const base &obj) : isl::point(obj) {}
7106 public:
7107 static point from(const isl::point &obj) {
7108 return point(obj);
7109 }
7110 template <typename Range>
7112 template <typename Range>
7114 template <typename Range>
7122 inline bool every_set(const std::function<bool(typed::set<Domain>)> &test) const;
7124 inline void foreach_basic_set(const std::function<void(typed::basic_set<Domain>)> &fn) const;
7125 inline void foreach_point(const std::function<void(typed::point<Domain>)> &fn) const;
7126 inline void foreach_set(const std::function<void(typed::set<Domain>)> &fn) const;
7133 template <typename Arg1>
7148 inline typed::val<Domain> max_val(const typed::aff<> &obj) const = delete;
7150 inline typed::val<Domain> min_val(const typed::aff<> &obj) const = delete;
7157 template <typename Domain2>
7159 template <typename Domain2>
7161 template <typename Domain2>
7163 template <typename Domain2>
7165 template <typename Range>
7169 inline typed::set<Domain> project_out_param(const std::string &id) const;
7173 template <typename Range>
7184 template <typename Arg1>
7189 inline typed::map<Domain> unwrap() const = delete;
7192 inline typed::set<Domain> wrapped_reverse() const = delete;
7193};
7194
7195template <typename Domain, typename Range>
7196struct point<pair<Domain, Range>> : public isl::point {
7197 template <typename...>
7198 friend struct aff;
7199 template <typename...>
7200 friend struct aff_list;
7201 template <typename...>
7202 friend struct basic_map;
7203 template <typename...>
7204 friend struct basic_set;
7205 template <typename...>
7206 friend struct fixed_box;
7207 template <typename...>
7208 friend struct id;
7209 template <typename...>
7210 friend struct id_list;
7211 template <typename...>
7212 friend struct map;
7213 template <typename...>
7214 friend struct map_list;
7215 template <typename...>
7216 friend struct multi_aff;
7217 template <typename...>
7218 friend struct multi_id;
7219 template <typename...>
7220 friend struct multi_pw_aff;
7221 template <typename...>
7222 friend struct multi_union_pw_aff;
7223 template <typename...>
7224 friend struct multi_val;
7225 template <typename...>
7226 friend struct point;
7227 template <typename...>
7228 friend struct pw_aff;
7229 template <typename...>
7230 friend struct pw_aff_list;
7231 template <typename...>
7232 friend struct pw_multi_aff;
7233 template <typename...>
7234 friend struct pw_multi_aff_list;
7235 template <typename...>
7236 friend struct set;
7237 template <typename...>
7238 friend struct set_list;
7239 template <typename...>
7240 friend struct space;
7241 template <typename...>
7242 friend struct union_map;
7243 template <typename...>
7244 friend struct union_pw_aff;
7245 template <typename...>
7246 friend struct union_pw_aff_list;
7247 template <typename...>
7248 friend struct union_pw_multi_aff;
7249 template <typename...>
7250 friend struct union_set;
7251 template <typename...>
7252 friend struct union_set_list;
7253 template <typename...>
7254 friend struct val;
7255 template <typename...>
7256 friend struct val_list;
7257
7258 point() = default;
7259 template <typename Arg1, typename Arg2,
7260 typename std::enable_if<
7261 std::is_base_of<Domain, Arg1>{} &&
7262 std::is_base_of<Range, Arg2>{},
7263 bool>::type = true>
7265 private:
7266 template <typename base,
7267 typename std::enable_if<
7268 std::is_same<base, isl::point>{}, bool>::type = true>
7269 point(const base &obj) : isl::point(obj) {}
7270 public:
7271 static point from(const isl::point &obj) {
7272 return point(obj);
7273 }
7274 template <typename Arg2>
7276 template <typename Arg2>
7278 template <typename Arg2>
7286 inline bool every_set(const std::function<bool(typed::set<pair<Domain, Range>>)> &test) const;
7288 inline void foreach_basic_set(const std::function<void(typed::basic_set<pair<Domain, Range>>)> &fn) const;
7289 inline void foreach_point(const std::function<void(typed::point<pair<Domain, Range>>)> &fn) const;
7290 inline void foreach_set(const std::function<void(typed::set<pair<Domain, Range>>)> &fn) const;
7297 template <typename Arg2>
7321 template <typename Domain2>
7323 template <typename Domain2>
7325 template <typename Domain2>
7327 template <typename Domain2>
7329 template <typename Arg2>
7333 inline typed::set<pair<Domain, Range>> project_out_param(const std::string &id) const;
7337 template <typename Arg2>
7348 template <typename Arg2>
7357};
7358
7359template <>
7360struct pw_aff<Anonymous> : public isl::pw_aff {
7361 template <typename...>
7362 friend struct aff;
7363 template <typename...>
7364 friend struct aff_list;
7365 template <typename...>
7366 friend struct basic_map;
7367 template <typename...>
7368 friend struct basic_set;
7369 template <typename...>
7370 friend struct fixed_box;
7371 template <typename...>
7372 friend struct id;
7373 template <typename...>
7374 friend struct id_list;
7375 template <typename...>
7376 friend struct map;
7377 template <typename...>
7378 friend struct map_list;
7379 template <typename...>
7380 friend struct multi_aff;
7381 template <typename...>
7382 friend struct multi_id;
7383 template <typename...>
7384 friend struct multi_pw_aff;
7385 template <typename...>
7386 friend struct multi_union_pw_aff;
7387 template <typename...>
7388 friend struct multi_val;
7389 template <typename...>
7390 friend struct point;
7391 template <typename...>
7392 friend struct pw_aff;
7393 template <typename...>
7394 friend struct pw_aff_list;
7395 template <typename...>
7396 friend struct pw_multi_aff;
7397 template <typename...>
7398 friend struct pw_multi_aff_list;
7399 template <typename...>
7400 friend struct set;
7401 template <typename...>
7402 friend struct set_list;
7403 template <typename...>
7404 friend struct space;
7405 template <typename...>
7406 friend struct union_map;
7407 template <typename...>
7408 friend struct union_pw_aff;
7409 template <typename...>
7410 friend struct union_pw_aff_list;
7411 template <typename...>
7412 friend struct union_pw_multi_aff;
7413 template <typename...>
7414 friend struct union_set;
7415 template <typename...>
7416 friend struct union_set_list;
7417 template <typename...>
7418 friend struct val;
7419 template <typename...>
7420 friend struct val_list;
7421
7422 pw_aff() = default;
7424 static pw_aff from(const isl::pw_aff &obj) {
7425 return pw_aff(obj);
7426 }
7427 inline /* implicit */ pw_aff(const typed::aff<Anonymous> &aff);
7428 inline explicit pw_aff(const isl::ctx &ctx, const std::string &str);
7439 template <typename Range>
7442 inline typed::map<Anonymous> as_map() const = delete;
7450 inline typed::set<> bind(const typed::id<Anonymous> &id) const;
7451 inline typed::set<> bind(const std::string &id) const;
7456 inline typed::pw_aff<Anonymous> cond(const typed::pw_aff<Anonymous> &pwaff_true, const typed::pw_aff<Anonymous> &pwaff_false) const;
7457 inline typed::set<> domain() const;
7462 inline typed::set<Anonymous> ge_set(const typed::pw_aff<> &pwaff2) const = delete;
7463 inline typed::set<Anonymous> ge_set(const typed::aff<> &pwaff2) const = delete;
7471 inline typed::set<Anonymous> gt_set(const typed::pw_aff<> &pwaff2) const = delete;
7472 inline typed::set<Anonymous> gt_set(const typed::aff<> &pwaff2) const = delete;
7474 template <typename Domain>
7485 inline typed::set<Anonymous> le_set(const typed::pw_aff<> &pwaff2) const = delete;
7486 inline typed::set<Anonymous> le_set(const typed::aff<> &pwaff2) const = delete;
7488 inline typed::set<Anonymous> lt_set(const typed::pw_aff<> &pwaff2) const = delete;
7489 inline typed::set<Anonymous> lt_set(const typed::aff<> &pwaff2) const = delete;
7503 inline typed::set<> params() const;
7506 template <typename Range>
7508 template <typename Range>
7522 inline typed::pw_aff<Anonymous> scale(long v) const;
7529 template <typename Domain2>
7531 template <typename Domain2>
7532 inline typed::pw_multi_aff<Domain2> set_range_tuple(const std::string &id) const;
7534 inline typed::space<Anonymous> get_space() const = delete;
7550 template <typename Domain>
7559};
7560
7561template <typename Domain>
7563 template <typename...>
7564 friend struct aff;
7565 template <typename...>
7566 friend struct aff_list;
7567 template <typename...>
7568 friend struct basic_map;
7569 template <typename...>
7570 friend struct basic_set;
7571 template <typename...>
7572 friend struct fixed_box;
7573 template <typename...>
7574 friend struct id;
7575 template <typename...>
7576 friend struct id_list;
7577 template <typename...>
7578 friend struct map;
7579 template <typename...>
7580 friend struct map_list;
7581 template <typename...>
7582 friend struct multi_aff;
7583 template <typename...>
7584 friend struct multi_id;
7585 template <typename...>
7586 friend struct multi_pw_aff;
7587 template <typename...>
7588 friend struct multi_union_pw_aff;
7589 template <typename...>
7590 friend struct multi_val;
7591 template <typename...>
7592 friend struct point;
7593 template <typename...>
7594 friend struct pw_aff;
7595 template <typename...>
7596 friend struct pw_aff_list;
7597 template <typename...>
7598 friend struct pw_multi_aff;
7599 template <typename...>
7600 friend struct pw_multi_aff_list;
7601 template <typename...>
7602 friend struct set;
7603 template <typename...>
7604 friend struct set_list;
7605 template <typename...>
7606 friend struct space;
7607 template <typename...>
7608 friend struct union_map;
7609 template <typename...>
7610 friend struct union_pw_aff;
7611 template <typename...>
7612 friend struct union_pw_aff_list;
7613 template <typename...>
7614 friend struct union_pw_multi_aff;
7615 template <typename...>
7616 friend struct union_set;
7617 template <typename...>
7618 friend struct union_set_list;
7619 template <typename...>
7620 friend struct val;
7621 template <typename...>
7622 friend struct val_list;
7623
7624 pw_aff() = default;
7625 template <typename Arg1,
7626 typename std::enable_if<
7627 std::is_base_of<Domain, Arg1>{},
7628 bool>::type = true>
7630 private:
7631 template <typename base,
7632 typename std::enable_if<
7633 std::is_same<base, isl::pw_aff>{}, bool>::type = true>
7634 pw_aff(const base &obj) : isl::pw_aff(obj) {}
7635 public:
7636 static pw_aff from(const isl::pw_aff &obj) {
7637 return pw_aff(obj);
7638 }
7639 inline /* implicit */ pw_aff(const typed::aff<Domain, Anonymous> &aff);
7640 inline explicit pw_aff(const isl::ctx &ctx, const std::string &str);
7651 template <typename Range2>
7658 inline typed::set<Domain, Anonymous> as_set() const = delete;
7663 inline typed::set<Domain> bind(const std::string &id) const;
7714 inline typed::set<> params() const;
7717 template <typename Domain2, typename Range2>
7719 template <typename Domain2, typename Range2>
7721 template <typename Domain2>
7724 template <typename Domain2>
7727 template <typename Domain2>
7730 template <typename Domain2>
7736 template <typename Range2>
7738 template <typename Range2>
7740 template <typename Range2>
7742 template <typename Range2>
7752 template <typename Range2>
7754 template <typename Range2>
7755 inline typed::pw_multi_aff<Domain, Range2> set_range_tuple(const std::string &id) const;
7781};
7782
7783template <typename Domain2, typename Range2>
7785 template <typename...>
7786 friend struct aff;
7787 template <typename...>
7788 friend struct aff_list;
7789 template <typename...>
7790 friend struct basic_map;
7791 template <typename...>
7792 friend struct basic_set;
7793 template <typename...>
7794 friend struct fixed_box;
7795 template <typename...>
7796 friend struct id;
7797 template <typename...>
7798 friend struct id_list;
7799 template <typename...>
7800 friend struct map;
7801 template <typename...>
7802 friend struct map_list;
7803 template <typename...>
7804 friend struct multi_aff;
7805 template <typename...>
7806 friend struct multi_id;
7807 template <typename...>
7808 friend struct multi_pw_aff;
7809 template <typename...>
7810 friend struct multi_union_pw_aff;
7811 template <typename...>
7812 friend struct multi_val;
7813 template <typename...>
7814 friend struct point;
7815 template <typename...>
7816 friend struct pw_aff;
7817 template <typename...>
7818 friend struct pw_aff_list;
7819 template <typename...>
7820 friend struct pw_multi_aff;
7821 template <typename...>
7822 friend struct pw_multi_aff_list;
7823 template <typename...>
7824 friend struct set;
7825 template <typename...>
7826 friend struct set_list;
7827 template <typename...>
7828 friend struct space;
7829 template <typename...>
7830 friend struct union_map;
7831 template <typename...>
7832 friend struct union_pw_aff;
7833 template <typename...>
7834 friend struct union_pw_aff_list;
7835 template <typename...>
7836 friend struct union_pw_multi_aff;
7837 template <typename...>
7838 friend struct union_set;
7839 template <typename...>
7840 friend struct union_set_list;
7841 template <typename...>
7842 friend struct val;
7843 template <typename...>
7844 friend struct val_list;
7845
7846 pw_aff() = default;
7847 template <typename Arg1, typename Arg2,
7848 typename std::enable_if<
7849 std::is_base_of<Domain2, Arg1>{} &&
7850 std::is_base_of<Range2, Arg2>{},
7851 bool>::type = true>
7853 private:
7854 template <typename base,
7855 typename std::enable_if<
7856 std::is_same<base, isl::pw_aff>{}, bool>::type = true>
7857 pw_aff(const base &obj) : isl::pw_aff(obj) {}
7858 public:
7859 static pw_aff from(const isl::pw_aff &obj) {
7860 return pw_aff(obj);
7861 }
7862 inline /* implicit */ pw_aff(const typed::aff<pair<Domain2, Range2>, Anonymous> &aff);
7863 inline explicit pw_aff(const isl::ctx &ctx, const std::string &str);
7874 template <typename Arg1>
7886 inline typed::set<pair<Domain2, Range2>> bind(const std::string &id) const;
7937 inline typed::set<> params() const;
7938 template <typename Domain3>
7940 template <typename Domain3>
7942 template <typename Arg1, typename Arg2>
7944 template <typename Arg1, typename Arg2>
7946 template <typename Arg1>
7949 template <typename Arg1>
7952 template <typename Arg1>
7955 template <typename Arg1>
7961 template <typename Arg1>
7963 template <typename Arg1>
7965 template <typename Arg1>
7967 template <typename Arg1>
7977 template <typename Arg1>
7979 template <typename Arg1>
7980 inline typed::pw_multi_aff<pair<Domain2, Range2>, Arg1> set_range_tuple(const std::string &id) const;
8006};
8007
8008template <>
8010 template <typename...>
8011 friend struct aff;
8012 template <typename...>
8013 friend struct aff_list;
8014 template <typename...>
8015 friend struct basic_map;
8016 template <typename...>
8017 friend struct basic_set;
8018 template <typename...>
8019 friend struct fixed_box;
8020 template <typename...>
8021 friend struct id;
8022 template <typename...>
8023 friend struct id_list;
8024 template <typename...>
8025 friend struct map;
8026 template <typename...>
8027 friend struct map_list;
8028 template <typename...>
8029 friend struct multi_aff;
8030 template <typename...>
8031 friend struct multi_id;
8032 template <typename...>
8033 friend struct multi_pw_aff;
8034 template <typename...>
8035 friend struct multi_union_pw_aff;
8036 template <typename...>
8037 friend struct multi_val;
8038 template <typename...>
8039 friend struct point;
8040 template <typename...>
8041 friend struct pw_aff;
8042 template <typename...>
8043 friend struct pw_aff_list;
8044 template <typename...>
8045 friend struct pw_multi_aff;
8046 template <typename...>
8047 friend struct pw_multi_aff_list;
8048 template <typename...>
8049 friend struct set;
8050 template <typename...>
8051 friend struct set_list;
8052 template <typename...>
8053 friend struct space;
8054 template <typename...>
8055 friend struct union_map;
8056 template <typename...>
8057 friend struct union_pw_aff;
8058 template <typename...>
8059 friend struct union_pw_aff_list;
8060 template <typename...>
8061 friend struct union_pw_multi_aff;
8062 template <typename...>
8063 friend struct union_set;
8064 template <typename...>
8065 friend struct union_set_list;
8066 template <typename...>
8067 friend struct val;
8068 template <typename...>
8069 friend struct val_list;
8070
8071 pw_aff_list() = default;
8074 return pw_aff_list(obj);
8075 }
8076 inline explicit pw_aff_list(const isl::ctx &ctx, int n);
8077 inline explicit pw_aff_list(const typed::pw_aff<Anonymous> &el);
8078 inline explicit pw_aff_list(const isl::ctx &ctx, const std::string &str);
8081 inline typed::pw_aff<Anonymous> at(int index) const;
8082 inline typed::pw_aff<Anonymous> get_at(int index) const = delete;
8083 inline typed::pw_aff_list<Anonymous> drop(unsigned int first, unsigned int n) const;
8084 inline void foreach(const std::function<void(typed::pw_aff<Anonymous>)> &fn) const;
8085 inline void foreach_scc(const std::function<bool(typed::pw_aff<Anonymous>, typed::pw_aff<Anonymous>)> &follows, const std::function<void(typed::pw_aff_list<Anonymous>)> &fn) const;
8087};
8088
8089template <typename Domain>
8091 template <typename...>
8092 friend struct aff;
8093 template <typename...>
8094 friend struct aff_list;
8095 template <typename...>
8096 friend struct basic_map;
8097 template <typename...>
8098 friend struct basic_set;
8099 template <typename...>
8100 friend struct fixed_box;
8101 template <typename...>
8102 friend struct id;
8103 template <typename...>
8104 friend struct id_list;
8105 template <typename...>
8106 friend struct map;
8107 template <typename...>
8108 friend struct map_list;
8109 template <typename...>
8110 friend struct multi_aff;
8111 template <typename...>
8112 friend struct multi_id;
8113 template <typename...>
8114 friend struct multi_pw_aff;
8115 template <typename...>
8116 friend struct multi_union_pw_aff;
8117 template <typename...>
8118 friend struct multi_val;
8119 template <typename...>
8120 friend struct point;
8121 template <typename...>
8122 friend struct pw_aff;
8123 template <typename...>
8124 friend struct pw_aff_list;
8125 template <typename...>
8126 friend struct pw_multi_aff;
8127 template <typename...>
8128 friend struct pw_multi_aff_list;
8129 template <typename...>
8130 friend struct set;
8131 template <typename...>
8132 friend struct set_list;
8133 template <typename...>
8134 friend struct space;
8135 template <typename...>
8136 friend struct union_map;
8137 template <typename...>
8138 friend struct union_pw_aff;
8139 template <typename...>
8140 friend struct union_pw_aff_list;
8141 template <typename...>
8142 friend struct union_pw_multi_aff;
8143 template <typename...>
8144 friend struct union_set;
8145 template <typename...>
8146 friend struct union_set_list;
8147 template <typename...>
8148 friend struct val;
8149 template <typename...>
8150 friend struct val_list;
8151
8152 pw_aff_list() = default;
8153 template <typename Arg1,
8154 typename std::enable_if<
8155 std::is_base_of<Domain, Arg1>{},
8156 bool>::type = true>
8158 private:
8159 template <typename base,
8160 typename std::enable_if<
8161 std::is_same<base, isl::pw_aff_list>{}, bool>::type = true>
8162 pw_aff_list(const base &obj) : isl::pw_aff_list(obj) {}
8163 public:
8165 return pw_aff_list(obj);
8166 }
8167 inline explicit pw_aff_list(const isl::ctx &ctx, int n);
8169 inline explicit pw_aff_list(const isl::ctx &ctx, const std::string &str);
8172 inline typed::pw_aff<Domain, Anonymous> at(int index) const;
8173 inline typed::pw_aff<Domain, Anonymous> get_at(int index) const = delete;
8174 inline typed::pw_aff_list<Domain, Anonymous> drop(unsigned int first, unsigned int n) const;
8175 inline void foreach(const std::function<void(typed::pw_aff<Domain, Anonymous>)> &fn) const;
8176 inline void foreach_scc(const std::function<bool(typed::pw_aff<Domain, Anonymous>, typed::pw_aff<Domain, Anonymous>)> &follows, const std::function<void(typed::pw_aff_list<Domain, Anonymous>)> &fn) const;
8178};
8179
8180template <typename Domain>
8182 template <typename...>
8183 friend struct aff;
8184 template <typename...>
8185 friend struct aff_list;
8186 template <typename...>
8187 friend struct basic_map;
8188 template <typename...>
8189 friend struct basic_set;
8190 template <typename...>
8191 friend struct fixed_box;
8192 template <typename...>
8193 friend struct id;
8194 template <typename...>
8195 friend struct id_list;
8196 template <typename...>
8197 friend struct map;
8198 template <typename...>
8199 friend struct map_list;
8200 template <typename...>
8201 friend struct multi_aff;
8202 template <typename...>
8203 friend struct multi_id;
8204 template <typename...>
8205 friend struct multi_pw_aff;
8206 template <typename...>
8207 friend struct multi_union_pw_aff;
8208 template <typename...>
8209 friend struct multi_val;
8210 template <typename...>
8211 friend struct point;
8212 template <typename...>
8213 friend struct pw_aff;
8214 template <typename...>
8215 friend struct pw_aff_list;
8216 template <typename...>
8217 friend struct pw_multi_aff;
8218 template <typename...>
8219 friend struct pw_multi_aff_list;
8220 template <typename...>
8221 friend struct set;
8222 template <typename...>
8223 friend struct set_list;
8224 template <typename...>
8225 friend struct space;
8226 template <typename...>
8227 friend struct union_map;
8228 template <typename...>
8229 friend struct union_pw_aff;
8230 template <typename...>
8231 friend struct union_pw_aff_list;
8232 template <typename...>
8233 friend struct union_pw_multi_aff;
8234 template <typename...>
8235 friend struct union_set;
8236 template <typename...>
8237 friend struct union_set_list;
8238 template <typename...>
8239 friend struct val;
8240 template <typename...>
8241 friend struct val_list;
8242
8243 pw_multi_aff() = default;
8244 template <typename Arg1,
8245 typename std::enable_if<
8246 std::is_base_of<Domain, Arg1>{},
8247 bool>::type = true>
8249 private:
8250 template <typename base,
8251 typename std::enable_if<
8252 std::is_same<base, isl::pw_multi_aff>{}, bool>::type = true>
8254 public:
8256 return pw_multi_aff(obj);
8257 }
8258 inline /* implicit */ pw_multi_aff(const typed::multi_aff<Domain> &ma);
8259 inline /* implicit */ pw_multi_aff(const typed::pw_aff<Domain> &pa);
8260 inline explicit pw_multi_aff(const isl::ctx &ctx, const std::string &str);
8270 template <typename Range>
8272 inline typed::map<Domain> as_map() const = delete;
8279 inline typed::pw_aff<Domain> get_at(int pos) const = delete;
8284 inline typed::set<> domain() const;
8296 template <typename Arg1>
8317 template <typename Range>
8319 template <typename Range>
8321 template <typename Range>
8337 inline typed::id<Domain> get_range_tuple_id() const = delete;
8346 template <typename Domain2>
8348 template <typename Domain2>
8349 inline typed::pw_multi_aff<Domain2> set_range_tuple(const std::string &id) const;
8351 inline typed::space<Domain> get_space() const = delete;
8365 template <typename Arg1>
8373};
8374
8375template <typename Domain, typename Range>
8377 template <typename...>
8378 friend struct aff;
8379 template <typename...>
8380 friend struct aff_list;
8381 template <typename...>
8382 friend struct basic_map;
8383 template <typename...>
8384 friend struct basic_set;
8385 template <typename...>
8386 friend struct fixed_box;
8387 template <typename...>
8388 friend struct id;
8389 template <typename...>
8390 friend struct id_list;
8391 template <typename...>
8392 friend struct map;
8393 template <typename...>
8394 friend struct map_list;
8395 template <typename...>
8396 friend struct multi_aff;
8397 template <typename...>
8398 friend struct multi_id;
8399 template <typename...>
8400 friend struct multi_pw_aff;
8401 template <typename...>
8402 friend struct multi_union_pw_aff;
8403 template <typename...>
8404 friend struct multi_val;
8405 template <typename...>
8406 friend struct point;
8407 template <typename...>
8408 friend struct pw_aff;
8409 template <typename...>
8410 friend struct pw_aff_list;
8411 template <typename...>
8412 friend struct pw_multi_aff;
8413 template <typename...>
8414 friend struct pw_multi_aff_list;
8415 template <typename...>
8416 friend struct set;
8417 template <typename...>
8418 friend struct set_list;
8419 template <typename...>
8420 friend struct space;
8421 template <typename...>
8422 friend struct union_map;
8423 template <typename...>
8424 friend struct union_pw_aff;
8425 template <typename...>
8426 friend struct union_pw_aff_list;
8427 template <typename...>
8428 friend struct union_pw_multi_aff;
8429 template <typename...>
8430 friend struct union_set;
8431 template <typename...>
8432 friend struct union_set_list;
8433 template <typename...>
8434 friend struct val;
8435 template <typename...>
8436 friend struct val_list;
8437
8438 pw_multi_aff() = default;
8439 template <typename Arg1, typename Arg2,
8440 typename std::enable_if<
8441 std::is_base_of<Domain, Arg1>{} &&
8442 std::is_base_of<Range, Arg2>{},
8443 bool>::type = true>
8445 private:
8446 template <typename base,
8447 typename std::enable_if<
8448 std::is_same<base, isl::pw_multi_aff>{}, bool>::type = true>
8450 public:
8452 return pw_multi_aff(obj);
8453 }
8454 inline /* implicit */ pw_multi_aff(const typed::multi_aff<Domain, Range> &ma);
8455 inline /* implicit */ pw_multi_aff(const typed::pw_aff<Domain, Range> &pa);
8456 inline explicit pw_multi_aff(const isl::ctx &ctx, const std::string &str);
8466 template <typename Range2>
8472 inline typed::set<Domain, Range> as_set() const = delete;
8475 inline typed::pw_aff<Domain, Range> get_at(int pos) const = delete;
8512 template <typename Domain2, typename Range2>
8514 template <typename Domain2, typename Range2>
8516 template <typename Domain2, typename Range2>
8518 template <typename Domain2>
8520 template <typename Domain2>
8523 template <typename Domain2>
8526 template <typename Domain2>
8529 template <typename Domain2>
8535 template <typename Range2>
8537 template <typename Range2>
8539 template <typename Range2>
8541 template <typename Range2>
8543 template <typename Range2>
8555 template <typename Range2>
8557 template <typename Range2>
8558 inline typed::pw_multi_aff<Domain, Range2> set_range_tuple(const std::string &id) const;
8581};
8582
8583template <typename Domain2, typename Range2, typename Range>
8585 template <typename...>
8586 friend struct aff;
8587 template <typename...>
8588 friend struct aff_list;
8589 template <typename...>
8590 friend struct basic_map;
8591 template <typename...>
8592 friend struct basic_set;
8593 template <typename...>
8594 friend struct fixed_box;
8595 template <typename...>
8596 friend struct id;
8597 template <typename...>
8598 friend struct id_list;
8599 template <typename...>
8600 friend struct map;
8601 template <typename...>
8602 friend struct map_list;
8603 template <typename...>
8604 friend struct multi_aff;
8605 template <typename...>
8606 friend struct multi_id;
8607 template <typename...>
8608 friend struct multi_pw_aff;
8609 template <typename...>
8610 friend struct multi_union_pw_aff;
8611 template <typename...>
8612 friend struct multi_val;
8613 template <typename...>
8614 friend struct point;
8615 template <typename...>
8616 friend struct pw_aff;
8617 template <typename...>
8618 friend struct pw_aff_list;
8619 template <typename...>
8620 friend struct pw_multi_aff;
8621 template <typename...>
8622 friend struct pw_multi_aff_list;
8623 template <typename...>
8624 friend struct set;
8625 template <typename...>
8626 friend struct set_list;
8627 template <typename...>
8628 friend struct space;
8629 template <typename...>
8630 friend struct union_map;
8631 template <typename...>
8632 friend struct union_pw_aff;
8633 template <typename...>
8634 friend struct union_pw_aff_list;
8635 template <typename...>
8636 friend struct union_pw_multi_aff;
8637 template <typename...>
8638 friend struct union_set;
8639 template <typename...>
8640 friend struct union_set_list;
8641 template <typename...>
8642 friend struct val;
8643 template <typename...>
8644 friend struct val_list;
8645
8646 pw_multi_aff() = default;
8647 template <typename Arg1, typename Arg2, typename Arg3,
8648 typename std::enable_if<
8649 std::is_base_of<Domain2, Arg1>{} &&
8650 std::is_base_of<Range2, Arg2>{} &&
8651 std::is_base_of<Range, Arg3>{},
8652 bool>::type = true>
8654 private:
8655 template <typename base,
8656 typename std::enable_if<
8657 std::is_same<base, isl::pw_multi_aff>{}, bool>::type = true>
8659 public:
8661 return pw_multi_aff(obj);
8662 }
8665 inline explicit pw_multi_aff(const isl::ctx &ctx, const std::string &str);
8675 template <typename Arg2>
8717 template <typename Domain3>
8719 template <typename Domain3>
8721 template <typename Domain3>
8723 template <typename Domain3>
8725 template <typename Arg2, typename Arg3>
8727 template <typename Arg2, typename Arg3>
8729 template <typename Arg2, typename Arg3>
8731 template <typename Arg2>
8733 template <typename Arg2>
8736 template <typename Arg2>
8739 template <typename Arg2>
8742 template <typename Arg2>
8748 template <typename Arg2>
8750 template <typename Arg2>
8752 template <typename Arg2>
8754 template <typename Arg2>
8756 template <typename Arg2>
8768 template <typename Arg1>
8770 template <typename Arg1>
8771 inline typed::pw_multi_aff<pair<Domain2, Range2>, Arg1> set_range_tuple(const std::string &id) const;
8794};
8795
8796template <typename Domain, typename Range, typename Range2>
8798 template <typename...>
8799 friend struct aff;
8800 template <typename...>
8801 friend struct aff_list;
8802 template <typename...>
8803 friend struct basic_map;
8804 template <typename...>
8805 friend struct basic_set;
8806 template <typename...>
8807 friend struct fixed_box;
8808 template <typename...>
8809 friend struct id;
8810 template <typename...>
8811 friend struct id_list;
8812 template <typename...>
8813 friend struct map;
8814 template <typename...>
8815 friend struct map_list;
8816 template <typename...>
8817 friend struct multi_aff;
8818 template <typename...>
8819 friend struct multi_id;
8820 template <typename...>
8821 friend struct multi_pw_aff;
8822 template <typename...>
8823 friend struct multi_union_pw_aff;
8824 template <typename...>
8825 friend struct multi_val;
8826 template <typename...>
8827 friend struct point;
8828 template <typename...>
8829 friend struct pw_aff;
8830 template <typename...>
8831 friend struct pw_aff_list;
8832 template <typename...>
8833 friend struct pw_multi_aff;
8834 template <typename...>
8835 friend struct pw_multi_aff_list;
8836 template <typename...>
8837 friend struct set;
8838 template <typename...>
8839 friend struct set_list;
8840 template <typename...>
8841 friend struct space;
8842 template <typename...>
8843 friend struct union_map;
8844 template <typename...>
8845 friend struct union_pw_aff;
8846 template <typename...>
8847 friend struct union_pw_aff_list;
8848 template <typename...>
8849 friend struct union_pw_multi_aff;
8850 template <typename...>
8851 friend struct union_set;
8852 template <typename...>
8853 friend struct union_set_list;
8854 template <typename...>
8855 friend struct val;
8856 template <typename...>
8857 friend struct val_list;
8858
8859 pw_multi_aff() = default;
8860 template <typename Arg1, typename Arg2, typename Arg3,
8861 typename std::enable_if<
8862 std::is_base_of<Domain, Arg1>{} &&
8863 std::is_base_of<Range, Arg2>{} &&
8864 std::is_base_of<Range2, Arg3>{},
8865 bool>::type = true>
8867 private:
8868 template <typename base,
8869 typename std::enable_if<
8870 std::is_same<base, isl::pw_multi_aff>{}, bool>::type = true>
8872 public:
8874 return pw_multi_aff(obj);
8875 }
8877 inline /* implicit */ pw_multi_aff(const typed::pw_aff<Domain, pair<Range, Range2>> &pa);
8878 inline explicit pw_multi_aff(const isl::ctx &ctx, const std::string &str);
8888 template <typename Arg3>
8934 template <typename Domain2, typename Arg3>
8936 template <typename Domain2, typename Arg3>
8938 template <typename Domain2, typename Arg3>
8940 template <typename Domain2>
8942 template <typename Domain2>
8945 template <typename Domain2>
8948 template <typename Domain2>
8951 template <typename Domain2>
8957 template <typename Arg3>
8959 template <typename Arg3>
8961 template <typename Arg3>
8963 template <typename Arg3>
8965 template <typename Arg3>
8978 inline typed::pw_multi_aff<Domain, pair<Range, Range2>> set_range_tuple(const std::string &id) const = delete;
9001};
9002
9003template <typename T1, typename T2, typename Range, typename Range2>
9005 template <typename...>
9006 friend struct aff;
9007 template <typename...>
9008 friend struct aff_list;
9009 template <typename...>
9010 friend struct basic_map;
9011 template <typename...>
9012 friend struct basic_set;
9013 template <typename...>
9014 friend struct fixed_box;
9015 template <typename...>
9016 friend struct id;
9017 template <typename...>
9018 friend struct id_list;
9019 template <typename...>
9020 friend struct map;
9021 template <typename...>
9022 friend struct map_list;
9023 template <typename...>
9024 friend struct multi_aff;
9025 template <typename...>
9026 friend struct multi_id;
9027 template <typename...>
9028 friend struct multi_pw_aff;
9029 template <typename...>
9030 friend struct multi_union_pw_aff;
9031 template <typename...>
9032 friend struct multi_val;
9033 template <typename...>
9034 friend struct point;
9035 template <typename...>
9036 friend struct pw_aff;
9037 template <typename...>
9038 friend struct pw_aff_list;
9039 template <typename...>
9040 friend struct pw_multi_aff;
9041 template <typename...>
9042 friend struct pw_multi_aff_list;
9043 template <typename...>
9044 friend struct set;
9045 template <typename...>
9046 friend struct set_list;
9047 template <typename...>
9048 friend struct space;
9049 template <typename...>
9050 friend struct union_map;
9051 template <typename...>
9052 friend struct union_pw_aff;
9053 template <typename...>
9054 friend struct union_pw_aff_list;
9055 template <typename...>
9056 friend struct union_pw_multi_aff;
9057 template <typename...>
9058 friend struct union_set;
9059 template <typename...>
9060 friend struct union_set_list;
9061 template <typename...>
9062 friend struct val;
9063 template <typename...>
9064 friend struct val_list;
9065
9066 pw_multi_aff() = default;
9067 template <typename Arg1, typename Arg2, typename Arg3, typename Arg4,
9068 typename std::enable_if<
9069 std::is_base_of<T1, Arg1>{} &&
9070 std::is_base_of<T2, Arg2>{} &&
9071 std::is_base_of<Range, Arg3>{} &&
9072 std::is_base_of<Range2, Arg4>{},
9073 bool>::type = true>
9075 private:
9076 template <typename base,
9077 typename std::enable_if<
9078 std::is_same<base, isl::pw_multi_aff>{}, bool>::type = true>
9080 public:
9082 return pw_multi_aff(obj);
9083 }
9086 inline explicit pw_multi_aff(const isl::ctx &ctx, const std::string &str);
9096 template <typename Arg2>
9138 template <typename Domain3>
9140 template <typename Domain3>
9142 template <typename Domain3>
9144 template <typename Domain3>
9146 template <typename Domain2, typename Arg2>
9148 template <typename Domain2, typename Arg2>
9150 template <typename Domain2, typename Arg2>
9152 template <typename Domain2>
9154 template <typename Domain2>
9157 template <typename Domain2>
9160 template <typename Domain2>
9163 template <typename Domain2>
9169 template <typename Arg2>
9171 template <typename Arg2>
9173 template <typename Arg2>
9175 template <typename Arg2>
9177 template <typename Arg2>
9190 inline typed::pw_multi_aff<pair<T1, T2>, pair<Range, Range2>> set_range_tuple(const std::string &id) const = delete;
9213};
9214
9215template <typename Domain>
9217 template <typename...>
9218 friend struct aff;
9219 template <typename...>
9220 friend struct aff_list;
9221 template <typename...>
9222 friend struct basic_map;
9223 template <typename...>
9224 friend struct basic_set;
9225 template <typename...>
9226 friend struct fixed_box;
9227 template <typename...>
9228 friend struct id;
9229 template <typename...>
9230 friend struct id_list;
9231 template <typename...>
9232 friend struct map;
9233 template <typename...>
9234 friend struct map_list;
9235 template <typename...>
9236 friend struct multi_aff;
9237 template <typename...>
9238 friend struct multi_id;
9239 template <typename...>
9240 friend struct multi_pw_aff;
9241 template <typename...>
9242 friend struct multi_union_pw_aff;
9243 template <typename...>
9244 friend struct multi_val;
9245 template <typename...>
9246 friend struct point;
9247 template <typename...>
9248 friend struct pw_aff;
9249 template <typename...>
9250 friend struct pw_aff_list;
9251 template <typename...>
9252 friend struct pw_multi_aff;
9253 template <typename...>
9254 friend struct pw_multi_aff_list;
9255 template <typename...>
9256 friend struct set;
9257 template <typename...>
9258 friend struct set_list;
9259 template <typename...>
9260 friend struct space;
9261 template <typename...>
9262 friend struct union_map;
9263 template <typename...>
9264 friend struct union_pw_aff;
9265 template <typename...>
9266 friend struct union_pw_aff_list;
9267 template <typename...>
9268 friend struct union_pw_multi_aff;
9269 template <typename...>
9270 friend struct union_set;
9271 template <typename...>
9272 friend struct union_set_list;
9273 template <typename...>
9274 friend struct val;
9275 template <typename...>
9276 friend struct val_list;
9277
9279 template <typename Arg1,
9280 typename std::enable_if<
9281 std::is_base_of<Domain, Arg1>{},
9282 bool>::type = true>
9284 private:
9285 template <typename base,
9286 typename std::enable_if<
9287 std::is_same<base, isl::pw_multi_aff_list>{}, bool>::type = true>
9289 public:
9293 inline explicit pw_multi_aff_list(const isl::ctx &ctx, int n);
9295 inline explicit pw_multi_aff_list(const isl::ctx &ctx, const std::string &str);
9299 inline typed::pw_multi_aff<Domain> at(int index) const;
9300 inline typed::pw_multi_aff<Domain> get_at(int index) const = delete;
9301 inline typed::pw_multi_aff_list<Domain> drop(unsigned int first, unsigned int n) const;
9302 inline void foreach(const std::function<void(typed::pw_multi_aff<Domain>)> &fn) const;
9303 inline void foreach_scc(const std::function<bool(typed::pw_multi_aff<Domain>, typed::pw_multi_aff<Domain>)> &follows, const std::function<void(typed::pw_multi_aff_list<Domain>)> &fn) const;
9305};
9306
9307template <typename Domain, typename Range>
9309 template <typename...>
9310 friend struct aff;
9311 template <typename...>
9312 friend struct aff_list;
9313 template <typename...>
9314 friend struct basic_map;
9315 template <typename...>
9316 friend struct basic_set;
9317 template <typename...>
9318 friend struct fixed_box;
9319 template <typename...>
9320 friend struct id;
9321 template <typename...>
9322 friend struct id_list;
9323 template <typename...>
9324 friend struct map;
9325 template <typename...>
9326 friend struct map_list;
9327 template <typename...>
9328 friend struct multi_aff;
9329 template <typename...>
9330 friend struct multi_id;
9331 template <typename...>
9332 friend struct multi_pw_aff;
9333 template <typename...>
9334 friend struct multi_union_pw_aff;
9335 template <typename...>
9336 friend struct multi_val;
9337 template <typename...>
9338 friend struct point;
9339 template <typename...>
9340 friend struct pw_aff;
9341 template <typename...>
9342 friend struct pw_aff_list;
9343 template <typename...>
9344 friend struct pw_multi_aff;
9345 template <typename...>
9346 friend struct pw_multi_aff_list;
9347 template <typename...>
9348 friend struct set;
9349 template <typename...>
9350 friend struct set_list;
9351 template <typename...>
9352 friend struct space;
9353 template <typename...>
9354 friend struct union_map;
9355 template <typename...>
9356 friend struct union_pw_aff;
9357 template <typename...>
9358 friend struct union_pw_aff_list;
9359 template <typename...>
9360 friend struct union_pw_multi_aff;
9361 template <typename...>
9362 friend struct union_set;
9363 template <typename...>
9364 friend struct union_set_list;
9365 template <typename...>
9366 friend struct val;
9367 template <typename...>
9368 friend struct val_list;
9369
9371 template <typename Arg1, typename Arg2,
9372 typename std::enable_if<
9373 std::is_base_of<Domain, Arg1>{} &&
9374 std::is_base_of<Range, Arg2>{},
9375 bool>::type = true>
9377 private:
9378 template <typename base,
9379 typename std::enable_if<
9380 std::is_same<base, isl::pw_multi_aff_list>{}, bool>::type = true>
9382 public:
9386 inline explicit pw_multi_aff_list(const isl::ctx &ctx, int n);
9388 inline explicit pw_multi_aff_list(const isl::ctx &ctx, const std::string &str);
9393 inline typed::pw_multi_aff<Domain, Range> get_at(int index) const = delete;
9394 inline typed::pw_multi_aff_list<Domain, Range> drop(unsigned int first, unsigned int n) const;
9395 inline void foreach(const std::function<void(typed::pw_multi_aff<Domain, Range>)> &fn) const;
9396 inline void foreach_scc(const std::function<bool(typed::pw_multi_aff<Domain, Range>, typed::pw_multi_aff<Domain, Range>)> &follows, const std::function<void(typed::pw_multi_aff_list<Domain, Range>)> &fn) const;
9398};
9399
9400template <>
9401struct set<> : public isl::set {
9402 template <typename...>
9403 friend struct aff;
9404 template <typename...>
9405 friend struct aff_list;
9406 template <typename...>
9407 friend struct basic_map;
9408 template <typename...>
9409 friend struct basic_set;
9410 template <typename...>
9411 friend struct fixed_box;
9412 template <typename...>
9413 friend struct id;
9414 template <typename...>
9415 friend struct id_list;
9416 template <typename...>
9417 friend struct map;
9418 template <typename...>
9419 friend struct map_list;
9420 template <typename...>
9421 friend struct multi_aff;
9422 template <typename...>
9423 friend struct multi_id;
9424 template <typename...>
9425 friend struct multi_pw_aff;
9426 template <typename...>
9427 friend struct multi_union_pw_aff;
9428 template <typename...>
9429 friend struct multi_val;
9430 template <typename...>
9431 friend struct point;
9432 template <typename...>
9433 friend struct pw_aff;
9434 template <typename...>
9435 friend struct pw_aff_list;
9436 template <typename...>
9437 friend struct pw_multi_aff;
9438 template <typename...>
9439 friend struct pw_multi_aff_list;
9440 template <typename...>
9441 friend struct set;
9442 template <typename...>
9443 friend struct set_list;
9444 template <typename...>
9445 friend struct space;
9446 template <typename...>
9447 friend struct union_map;
9448 template <typename...>
9449 friend struct union_pw_aff;
9450 template <typename...>
9451 friend struct union_pw_aff_list;
9452 template <typename...>
9453 friend struct union_pw_multi_aff;
9454 template <typename...>
9455 friend struct union_set;
9456 template <typename...>
9457 friend struct union_set_list;
9458 template <typename...>
9459 friend struct val;
9460 template <typename...>
9461 friend struct val_list;
9462
9463 set() = default;
9464 private:
9465 template <typename base,
9466 typename std::enable_if<
9467 std::is_same<base, isl::set>{}, bool>::type = true>
9468 set(const base &obj) : isl::set(obj) {}
9469 public:
9470 static set from(const isl::set &obj) {
9471 return set(obj);
9472 }
9473 inline /* implicit */ set(const typed::basic_set<> &bset);
9474 inline /* implicit */ set(const typed::point<> &pnt);
9475 inline explicit set(const isl::ctx &ctx, const std::string &str);
9476 inline typed::set<> apply(const typed::map<> &map) const = delete;
9477 inline typed::union_set<> apply(const typed::union_map<> &umap) const = delete;
9478 inline typed::set<> apply(const typed::basic_map<> &map) const = delete;
9480 inline typed::set<> as_set() const = delete;
9481 inline typed::set<> bind(const typed::multi_id<> &tuple) const = delete;
9482 inline typed::set<> coalesce() const;
9485 inline bool every_set(const std::function<bool(typed::set<>)> &test) const;
9487 inline void foreach_basic_set(const std::function<void(typed::basic_set<>)> &fn) const;
9488 inline void foreach_point(const std::function<void(typed::point<>)> &fn) const;
9489 inline void foreach_set(const std::function<void(typed::set<>)> &fn) const;
9494 inline typed::set<> gist_params(const typed::set<> &context) const = delete;
9496 inline typed::set<> gist_params(const typed::point<> &context) const = delete;
9497 inline typed::map<> identity() const = delete;
9499 inline typed::map<> insert_domain(const typed::space<> &domain) const = delete;
9504 inline typed::set<> intersect_params(const typed::set<> &params) const = delete;
9507 inline typed::fixed_box<> lattice_tile() const = delete;
9508 inline typed::fixed_box<> get_lattice_tile() const = delete;
9509 inline typed::set<> lexmax() const = delete;
9511 inline typed::set<> lexmin() const = delete;
9513 inline typed::set<> lower_bound(const typed::multi_pw_aff<> &lower) const = delete;
9514 inline typed::set<> lower_bound(const typed::multi_val<> &lower) const = delete;
9516 inline typed::val<> max_val(const typed::aff<> &obj) const = delete;
9518 inline typed::val<> min_val(const typed::aff<> &obj) const = delete;
9520 inline typed::pw_aff<Anonymous> param_pw_aff_on_domain(const std::string &id) const;
9521 inline typed::set<> params() const = delete;
9524 inline typed::set<> preimage(const typed::multi_aff<> &ma) const = delete;
9525 inline typed::set<> preimage(const typed::multi_pw_aff<> &mpa) const = delete;
9526 inline typed::set<> preimage(const typed::pw_multi_aff<> &pma) const = delete;
9527 inline typed::union_set<> preimage(const typed::union_pw_multi_aff<> &upma) const = delete;
9528 inline typed::set<> product(const typed::set<> &set2) const = delete;
9529 inline typed::set<> product(const typed::basic_set<> &set2) const = delete;
9530 inline typed::set<> product(const typed::point<> &set2) const = delete;
9533 inline typed::set<> project_out_param(const std::string &id) const;
9537 template <typename Domain>
9542 inline typed::space<> space() const;
9543 inline typed::space<> get_space() const = delete;
9544 inline typed::val<> get_stride(int pos) const = delete;
9550 inline typed::map<> translation() const = delete;
9551 template <typename Domain>
9554 inline typed::set<> unite(const typed::set<> &set2) const;
9555 inline typed::union_set<> unite(const typed::union_set<> &uset2) const;
9559 inline typed::map<> unwrap() const = delete;
9560 inline typed::set<> upper_bound(const typed::multi_pw_aff<> &upper) const = delete;
9561 inline typed::set<> upper_bound(const typed::multi_val<> &upper) const = delete;
9562 inline typed::set<> wrapped_reverse() const = delete;
9563};
9564
9565template <typename Domain>
9566struct set<Domain> : public isl::set {
9567 template <typename...>
9568 friend struct aff;
9569 template <typename...>
9570 friend struct aff_list;
9571 template <typename...>
9572 friend struct basic_map;
9573 template <typename...>
9574 friend struct basic_set;
9575 template <typename...>
9576 friend struct fixed_box;
9577 template <typename...>
9578 friend struct id;
9579 template <typename...>
9580 friend struct id_list;
9581 template <typename...>
9582 friend struct map;
9583 template <typename...>
9584 friend struct map_list;
9585 template <typename...>
9586 friend struct multi_aff;
9587 template <typename...>
9588 friend struct multi_id;
9589 template <typename...>
9590 friend struct multi_pw_aff;
9591 template <typename...>
9592 friend struct multi_union_pw_aff;
9593 template <typename...>
9594 friend struct multi_val;
9595 template <typename...>
9596 friend struct point;
9597 template <typename...>
9598 friend struct pw_aff;
9599 template <typename...>
9600 friend struct pw_aff_list;
9601 template <typename...>
9602 friend struct pw_multi_aff;
9603 template <typename...>
9604 friend struct pw_multi_aff_list;
9605 template <typename...>
9606 friend struct set;
9607 template <typename...>
9608 friend struct set_list;
9609 template <typename...>
9610 friend struct space;
9611 template <typename...>
9612 friend struct union_map;
9613 template <typename...>
9614 friend struct union_pw_aff;
9615 template <typename...>
9616 friend struct union_pw_aff_list;
9617 template <typename...>
9618 friend struct union_pw_multi_aff;
9619 template <typename...>
9620 friend struct union_set;
9621 template <typename...>
9622 friend struct union_set_list;
9623 template <typename...>
9624 friend struct val;
9625 template <typename...>
9626 friend struct val_list;
9627
9628 set() = default;
9629 template <typename Arg1,
9630 typename std::enable_if<
9631 std::is_base_of<Domain, Arg1>{},
9632 bool>::type = true>
9633 set(const set<Arg1> &obj) : isl::set(obj) {}
9634 private:
9635 template <typename base,
9636 typename std::enable_if<
9637 std::is_same<base, isl::set>{}, bool>::type = true>
9638 set(const base &obj) : isl::set(obj) {}
9639 public:
9640 static set from(const isl::set &obj) {
9641 return set(obj);
9642 }
9643 inline /* implicit */ set(const typed::basic_set<Domain> &bset);
9644 inline /* implicit */ set(const typed::point<Domain> &pnt);
9645 inline explicit set(const isl::ctx &ctx, const std::string &str);
9646 template <typename Range>
9648 template <typename Range>
9650 template <typename Range>
9658 inline bool every_set(const std::function<bool(typed::set<Domain>)> &test) const;
9660 inline void foreach_basic_set(const std::function<void(typed::basic_set<Domain>)> &fn) const;
9661 inline void foreach_point(const std::function<void(typed::point<Domain>)> &fn) const;
9662 inline void foreach_set(const std::function<void(typed::set<Domain>)> &fn) const;
9672 template <typename Arg1>
9690 inline typed::val<Domain> max_val(const typed::aff<> &obj) const = delete;
9692 inline typed::val<Domain> min_val(const typed::aff<> &obj) const = delete;
9695 inline typed::set<> params() const;
9698 template <typename Domain2>
9700 template <typename Domain2>
9702 template <typename Domain2>
9704 template <typename Domain2>
9706 template <typename Range>
9708 template <typename Range>
9710 template <typename Range>
9714 inline typed::set<Domain> project_out_param(const std::string &id) const;
9718 template <typename Range>
9724 inline typed::space<Domain> get_space() const = delete;
9725 inline typed::val<Domain> get_stride(int pos) const = delete;
9733 template <typename Arg1>
9740 inline typed::map<Domain> unwrap() const = delete;
9743 inline typed::set<Domain> wrapped_reverse() const = delete;
9744};
9745
9746template <typename Domain, typename Range>
9747struct set<pair<Domain, Range>> : public isl::set {
9748 template <typename...>
9749 friend struct aff;
9750 template <typename...>
9751 friend struct aff_list;
9752 template <typename...>
9753 friend struct basic_map;
9754 template <typename...>
9755 friend struct basic_set;
9756 template <typename...>
9757 friend struct fixed_box;
9758 template <typename...>
9759 friend struct id;
9760 template <typename...>
9761 friend struct id_list;
9762 template <typename...>
9763 friend struct map;
9764 template <typename...>
9765 friend struct map_list;
9766 template <typename...>
9767 friend struct multi_aff;
9768 template <typename...>
9769 friend struct multi_id;
9770 template <typename...>
9771 friend struct multi_pw_aff;
9772 template <typename...>
9773 friend struct multi_union_pw_aff;
9774 template <typename...>
9775 friend struct multi_val;
9776 template <typename...>
9777 friend struct point;
9778 template <typename...>
9779 friend struct pw_aff;
9780 template <typename...>
9781 friend struct pw_aff_list;
9782 template <typename...>
9783 friend struct pw_multi_aff;
9784 template <typename...>
9785 friend struct pw_multi_aff_list;
9786 template <typename...>
9787 friend struct set;
9788 template <typename...>
9789 friend struct set_list;
9790 template <typename...>
9791 friend struct space;
9792 template <typename...>
9793 friend struct union_map;
9794 template <typename...>
9795 friend struct union_pw_aff;
9796 template <typename...>
9797 friend struct union_pw_aff_list;
9798 template <typename...>
9799 friend struct union_pw_multi_aff;
9800 template <typename...>
9801 friend struct union_set;
9802 template <typename...>
9803 friend struct union_set_list;
9804 template <typename...>
9805 friend struct val;
9806 template <typename...>
9807 friend struct val_list;
9808
9809 set() = default;
9810 template <typename Arg1, typename Arg2,
9811 typename std::enable_if<
9812 std::is_base_of<Domain, Arg1>{} &&
9813 std::is_base_of<Range, Arg2>{},
9814 bool>::type = true>
9816 private:
9817 template <typename base,
9818 typename std::enable_if<
9819 std::is_same<base, isl::set>{}, bool>::type = true>
9820 set(const base &obj) : isl::set(obj) {}
9821 public:
9822 static set from(const isl::set &obj) {
9823 return set(obj);
9824 }
9825 inline /* implicit */ set(const typed::basic_set<pair<Domain, Range>> &bset);
9826 inline /* implicit */ set(const typed::point<pair<Domain, Range>> &pnt);
9827 inline explicit set(const isl::ctx &ctx, const std::string &str);
9828 template <typename Arg2>
9830 template <typename Arg2>
9832 template <typename Arg2>
9840 inline bool every_set(const std::function<bool(typed::set<pair<Domain, Range>>)> &test) const;
9842 inline void foreach_basic_set(const std::function<void(typed::basic_set<pair<Domain, Range>>)> &fn) const;
9843 inline void foreach_point(const std::function<void(typed::point<pair<Domain, Range>>)> &fn) const;
9844 inline void foreach_set(const std::function<void(typed::set<pair<Domain, Range>>)> &fn) const;
9854 template <typename Arg2>