| from ctypes import * |
| |
| isl = cdll.LoadLibrary("libisl.so") |
| libc = cdll.LoadLibrary("libc.so.6") |
| |
| class Error(Exception): |
| pass |
| |
| class Context: |
| defaultInstance = None |
| |
| def __init__(self): |
| ptr = isl.isl_ctx_alloc() |
| self.ptr = ptr |
| |
| def __del__(self): |
| isl.isl_ctx_free(self) |
| |
| def from_param(self): |
| return self.ptr |
| |
| @staticmethod |
| def getDefaultInstance(): |
| if Context.defaultInstance == None: |
| Context.defaultInstance = Context() |
| return Context.defaultInstance |
| |
| isl.isl_ctx_alloc.restype = c_void_p |
| isl.isl_ctx_free.argtypes = [Context] |
| |
| class union_map: |
| def __init__(self, *args, **keywords): |
| if "ptr" in keywords: |
| self.ctx = keywords["ctx"] |
| self.ptr = keywords["ptr"] |
| return |
| if len(args) == 1 and args[0].__class__ is map: |
| self.ctx = Context.getDefaultInstance() |
| self.ptr = isl.isl_union_map_from_map(isl.isl_map_copy(args[0].ptr)) |
| return |
| if len(args) == 1 and type(args[0]) == str: |
| self.ctx = Context.getDefaultInstance() |
| self.ptr = isl.isl_union_map_read_from_str(self.ctx, args[0]) |
| return |
| raise Error |
| def __del__(self): |
| if hasattr(self, 'ptr'): |
| isl.isl_union_map_free(self.ptr) |
| def __str__(self): |
| ptr = isl.isl_union_map_to_str(self.ptr) |
| res = str(cast(ptr, c_char_p).value) |
| libc.free(ptr) |
| return res |
| def __repr__(self): |
| return 'isl.union_map("%s")' % str(self) |
| def affine_hull(self): |
| res = isl.isl_union_map_affine_hull(isl.isl_union_map_copy(self.ptr)) |
| return union_map(ctx=self.ctx, ptr=res) |
| def polyhedral_hull(self): |
| res = isl.isl_union_map_polyhedral_hull(isl.isl_union_map_copy(self.ptr)) |
| return union_map(ctx=self.ctx, ptr=res) |
| def coalesce(self): |
| res = isl.isl_union_map_coalesce(isl.isl_union_map_copy(self.ptr)) |
| return union_map(ctx=self.ctx, ptr=res) |
| def lexmin(self): |
| res = isl.isl_union_map_lexmin(isl.isl_union_map_copy(self.ptr)) |
| return union_map(ctx=self.ctx, ptr=res) |
| def lexmax(self): |
| res = isl.isl_union_map_lexmax(isl.isl_union_map_copy(self.ptr)) |
| return union_map(ctx=self.ctx, ptr=res) |
| def union(self, arg1): |
| try: |
| if not arg1.__class__ is union_map: |
| arg1 = union_map(arg1) |
| except: |
| raise |
| res = isl.isl_union_map_union(isl.isl_union_map_copy(self.ptr), isl.isl_union_map_copy(arg1.ptr)) |
| return union_map(ctx=self.ctx, ptr=res) |
| def subtract(self, arg1): |
| try: |
| if not arg1.__class__ is union_map: |
| arg1 = union_map(arg1) |
| except: |
| raise |
| res = isl.isl_union_map_subtract(isl.isl_union_map_copy(self.ptr), isl.isl_union_map_copy(arg1.ptr)) |
| return union_map(ctx=self.ctx, ptr=res) |
| def intersect(self, arg1): |
| try: |
| if not arg1.__class__ is union_map: |
| arg1 = union_map(arg1) |
| except: |
| raise |
| res = isl.isl_union_map_intersect(isl.isl_union_map_copy(self.ptr), isl.isl_union_map_copy(arg1.ptr)) |
| return union_map(ctx=self.ctx, ptr=res) |
| def intersect_params(self, arg1): |
| try: |
| if not arg1.__class__ is set: |
| arg1 = set(arg1) |
| except: |
| raise |
| res = isl.isl_union_map_intersect_params(isl.isl_union_map_copy(self.ptr), isl.isl_set_copy(arg1.ptr)) |
| return union_map(ctx=self.ctx, ptr=res) |
| def gist(self, arg1): |
| try: |
| if not arg1.__class__ is union_map: |
| arg1 = union_map(arg1) |
| except: |
| raise |
| res = isl.isl_union_map_gist(isl.isl_union_map_copy(self.ptr), isl.isl_union_map_copy(arg1.ptr)) |
| return union_map(ctx=self.ctx, ptr=res) |
| def gist_params(self, arg1): |
| try: |
| if not arg1.__class__ is set: |
| arg1 = set(arg1) |
| except: |
| raise |
| res = isl.isl_union_map_gist_params(isl.isl_union_map_copy(self.ptr), isl.isl_set_copy(arg1.ptr)) |
| return union_map(ctx=self.ctx, ptr=res) |
| def gist_domain(self, arg1): |
| try: |
| if not arg1.__class__ is union_set: |
| arg1 = union_set(arg1) |
| except: |
| raise |
| res = isl.isl_union_map_gist_domain(isl.isl_union_map_copy(self.ptr), isl.isl_union_set_copy(arg1.ptr)) |
| return union_map(ctx=self.ctx, ptr=res) |
| def intersect_domain(self, arg1): |
| try: |
| if not arg1.__class__ is union_set: |
| arg1 = union_set(arg1) |
| except: |
| raise |
| res = isl.isl_union_map_intersect_domain(isl.isl_union_map_copy(self.ptr), isl.isl_union_set_copy(arg1.ptr)) |
| return union_map(ctx=self.ctx, ptr=res) |
| def intersect_range(self, arg1): |
| try: |
| if not arg1.__class__ is union_set: |
| arg1 = union_set(arg1) |
| except: |
| raise |
| res = isl.isl_union_map_intersect_range(isl.isl_union_map_copy(self.ptr), isl.isl_union_set_copy(arg1.ptr)) |
| return union_map(ctx=self.ctx, ptr=res) |
| def apply_domain(self, arg1): |
| try: |
| if not arg1.__class__ is union_map: |
| arg1 = union_map(arg1) |
| except: |
| raise |
| res = isl.isl_union_map_apply_domain(isl.isl_union_map_copy(self.ptr), isl.isl_union_map_copy(arg1.ptr)) |
| return union_map(ctx=self.ctx, ptr=res) |
| def apply_range(self, arg1): |
| try: |
| if not arg1.__class__ is union_map: |
| arg1 = union_map(arg1) |
| except: |
| raise |
| res = isl.isl_union_map_apply_range(isl.isl_union_map_copy(self.ptr), isl.isl_union_map_copy(arg1.ptr)) |
| return union_map(ctx=self.ctx, ptr=res) |
| def reverse(self): |
| res = isl.isl_union_map_reverse(isl.isl_union_map_copy(self.ptr)) |
| return union_map(ctx=self.ctx, ptr=res) |
| def detect_equalities(self): |
| res = isl.isl_union_map_detect_equalities(self.ptr) |
| return union_map(ctx=self.ctx, ptr=res) |
| def deltas(self): |
| res = isl.isl_union_map_deltas(isl.isl_union_map_copy(self.ptr)) |
| return union_set(ctx=self.ctx, ptr=res) |
| def is_empty(self): |
| res = isl.isl_union_map_is_empty(self.ptr) |
| return res |
| def is_single_valued(self): |
| res = isl.isl_union_map_is_single_valued(self.ptr) |
| return res |
| def is_injective(self): |
| res = isl.isl_union_map_is_injective(self.ptr) |
| return res |
| def is_bijective(self): |
| res = isl.isl_union_map_is_bijective(self.ptr) |
| return res |
| def is_subset(self, arg1): |
| try: |
| if not arg1.__class__ is union_map: |
| arg1 = union_map(arg1) |
| except: |
| raise |
| res = isl.isl_union_map_is_subset(self.ptr, arg1.ptr) |
| return res |
| def is_equal(self, arg1): |
| try: |
| if not arg1.__class__ is union_map: |
| arg1 = union_map(arg1) |
| except: |
| raise |
| res = isl.isl_union_map_is_equal(self.ptr, arg1.ptr) |
| return res |
| def is_strict_subset(self, arg1): |
| try: |
| if not arg1.__class__ is union_map: |
| arg1 = union_map(arg1) |
| except: |
| raise |
| res = isl.isl_union_map_is_strict_subset(self.ptr, arg1.ptr) |
| return res |
| def foreach_map(self, arg1): |
| exc_info = [None] |
| fn = CFUNCTYPE(c_int, c_void_p, c_void_p) |
| def cb_func(cb_arg0, cb_arg1): |
| cb_arg0 = map(ctx=self.ctx, ptr=cb_arg0) |
| try: |
| arg1(cb_arg0) |
| except: |
| import sys |
| exc_info[0] = sys.exc_info() |
| return -1 |
| return 0 |
| cb = fn(cb_func) |
| res = isl.isl_union_map_foreach_map(self.ptr, cb, None) |
| if exc_info[0] != None: |
| raise exc_info[0][0], exc_info[0][1], exc_info[0][2] |
| return res |
| |
| isl.isl_union_map_from_map.restype = c_void_p |
| isl.isl_union_map_from_map.argtypes = [c_void_p] |
| isl.isl_union_map_read_from_str.restype = c_void_p |
| isl.isl_union_map_read_from_str.argtypes = [Context, c_char_p] |
| isl.isl_union_map_affine_hull.restype = c_void_p |
| isl.isl_union_map_polyhedral_hull.restype = c_void_p |
| isl.isl_union_map_coalesce.restype = c_void_p |
| isl.isl_union_map_lexmin.restype = c_void_p |
| isl.isl_union_map_lexmax.restype = c_void_p |
| isl.isl_union_map_union.restype = c_void_p |
| isl.isl_union_map_subtract.restype = c_void_p |
| isl.isl_union_map_intersect.restype = c_void_p |
| isl.isl_union_map_intersect_params.restype = c_void_p |
| isl.isl_union_map_gist.restype = c_void_p |
| isl.isl_union_map_gist_params.restype = c_void_p |
| isl.isl_union_map_gist_domain.restype = c_void_p |
| isl.isl_union_map_intersect_domain.restype = c_void_p |
| isl.isl_union_map_intersect_range.restype = c_void_p |
| isl.isl_union_map_apply_domain.restype = c_void_p |
| isl.isl_union_map_apply_range.restype = c_void_p |
| isl.isl_union_map_reverse.restype = c_void_p |
| isl.isl_union_map_detect_equalities.restype = c_void_p |
| isl.isl_union_map_deltas.restype = c_void_p |
| isl.isl_union_map_free.argtypes = [c_void_p] |
| isl.isl_union_map_to_str.argtypes = [c_void_p] |
| isl.isl_union_map_to_str.restype = POINTER(c_char) |
| |
| class map(union_map): |
| def __init__(self, *args, **keywords): |
| if "ptr" in keywords: |
| self.ctx = keywords["ctx"] |
| self.ptr = keywords["ptr"] |
| return |
| if len(args) == 1 and type(args[0]) == str: |
| self.ctx = Context.getDefaultInstance() |
| self.ptr = isl.isl_map_read_from_str(self.ctx, args[0]) |
| return |
| if len(args) == 1 and args[0].__class__ is basic_map: |
| self.ctx = Context.getDefaultInstance() |
| self.ptr = isl.isl_map_from_basic_map(isl.isl_basic_map_copy(args[0].ptr)) |
| return |
| raise Error |
| def __del__(self): |
| if hasattr(self, 'ptr'): |
| isl.isl_map_free(self.ptr) |
| def __str__(self): |
| ptr = isl.isl_map_to_str(self.ptr) |
| res = str(cast(ptr, c_char_p).value) |
| libc.free(ptr) |
| return res |
| def __repr__(self): |
| return 'isl.map("%s")' % str(self) |
| def lexmin(self): |
| res = isl.isl_map_lexmin(isl.isl_map_copy(self.ptr)) |
| return map(ctx=self.ctx, ptr=res) |
| def lexmax(self): |
| res = isl.isl_map_lexmax(isl.isl_map_copy(self.ptr)) |
| return map(ctx=self.ctx, ptr=res) |
| def reverse(self): |
| res = isl.isl_map_reverse(isl.isl_map_copy(self.ptr)) |
| return map(ctx=self.ctx, ptr=res) |
| def union(self, arg1): |
| try: |
| if not arg1.__class__ is map: |
| arg1 = map(arg1) |
| except: |
| return union_map(self).union(arg1) |
| res = isl.isl_map_union(isl.isl_map_copy(self.ptr), isl.isl_map_copy(arg1.ptr)) |
| return map(ctx=self.ctx, ptr=res) |
| def intersect_domain(self, arg1): |
| try: |
| if not arg1.__class__ is set: |
| arg1 = set(arg1) |
| except: |
| return union_map(self).intersect_domain(arg1) |
| res = isl.isl_map_intersect_domain(isl.isl_map_copy(self.ptr), isl.isl_set_copy(arg1.ptr)) |
| return map(ctx=self.ctx, ptr=res) |
| def intersect_range(self, arg1): |
| try: |
| if not arg1.__class__ is set: |
| arg1 = set(arg1) |
| except: |
| return union_map(self).intersect_range(arg1) |
| res = isl.isl_map_intersect_range(isl.isl_map_copy(self.ptr), isl.isl_set_copy(arg1.ptr)) |
| return map(ctx=self.ctx, ptr=res) |
| def apply_domain(self, arg1): |
| try: |
| if not arg1.__class__ is map: |
| arg1 = map(arg1) |
| except: |
| return union_map(self).apply_domain(arg1) |
| res = isl.isl_map_apply_domain(isl.isl_map_copy(self.ptr), isl.isl_map_copy(arg1.ptr)) |
| return map(ctx=self.ctx, ptr=res) |
| def apply_range(self, arg1): |
| try: |
| if not arg1.__class__ is map: |
| arg1 = map(arg1) |
| except: |
| return union_map(self).apply_range(arg1) |
| res = isl.isl_map_apply_range(isl.isl_map_copy(self.ptr), isl.isl_map_copy(arg1.ptr)) |
| return map(ctx=self.ctx, ptr=res) |
| def intersect(self, arg1): |
| try: |
| if not arg1.__class__ is map: |
| arg1 = map(arg1) |
| except: |
| return union_map(self).intersect(arg1) |
| res = isl.isl_map_intersect(isl.isl_map_copy(self.ptr), isl.isl_map_copy(arg1.ptr)) |
| return map(ctx=self.ctx, ptr=res) |
| def intersect_params(self, arg1): |
| try: |
| if not arg1.__class__ is set: |
| arg1 = set(arg1) |
| except: |
| return union_map(self).intersect_params(arg1) |
| res = isl.isl_map_intersect_params(isl.isl_map_copy(self.ptr), isl.isl_set_copy(arg1.ptr)) |
| return map(ctx=self.ctx, ptr=res) |
| def subtract(self, arg1): |
| try: |
| if not arg1.__class__ is map: |
| arg1 = map(arg1) |
| except: |
| return union_map(self).subtract(arg1) |
| res = isl.isl_map_subtract(isl.isl_map_copy(self.ptr), isl.isl_map_copy(arg1.ptr)) |
| return map(ctx=self.ctx, ptr=res) |
| def deltas(self): |
| res = isl.isl_map_deltas(isl.isl_map_copy(self.ptr)) |
| return set(ctx=self.ctx, ptr=res) |
| def detect_equalities(self): |
| res = isl.isl_map_detect_equalities(isl.isl_map_copy(self.ptr)) |
| return map(ctx=self.ctx, ptr=res) |
| def affine_hull(self): |
| res = isl.isl_map_affine_hull(isl.isl_map_copy(self.ptr)) |
| return basic_map(ctx=self.ctx, ptr=res) |
| def polyhedral_hull(self): |
| res = isl.isl_map_polyhedral_hull(isl.isl_map_copy(self.ptr)) |
| return basic_map(ctx=self.ctx, ptr=res) |
| def flatten(self): |
| res = isl.isl_map_flatten(isl.isl_map_copy(self.ptr)) |
| return map(ctx=self.ctx, ptr=res) |
| def flatten_domain(self): |
| res = isl.isl_map_flatten_domain(isl.isl_map_copy(self.ptr)) |
| return map(ctx=self.ctx, ptr=res) |
| def flatten_range(self): |
| res = isl.isl_map_flatten_range(isl.isl_map_copy(self.ptr)) |
| return map(ctx=self.ctx, ptr=res) |
| def sample(self): |
| res = isl.isl_map_sample(isl.isl_map_copy(self.ptr)) |
| return basic_map(ctx=self.ctx, ptr=res) |
| def is_empty(self): |
| res = isl.isl_map_is_empty(self.ptr) |
| return res |
| def is_subset(self, arg1): |
| try: |
| if not arg1.__class__ is map: |
| arg1 = map(arg1) |
| except: |
| return union_map(self).is_subset(arg1) |
| res = isl.isl_map_is_subset(self.ptr, arg1.ptr) |
| return res |
| def is_strict_subset(self, arg1): |
| try: |
| if not arg1.__class__ is map: |
| arg1 = map(arg1) |
| except: |
| return union_map(self).is_strict_subset(arg1) |
| res = isl.isl_map_is_strict_subset(self.ptr, arg1.ptr) |
| return res |
| def is_equal(self, arg1): |
| try: |
| if not arg1.__class__ is map: |
| arg1 = map(arg1) |
| except: |
| return union_map(self).is_equal(arg1) |
| res = isl.isl_map_is_equal(self.ptr, arg1.ptr) |
| return res |
| def is_single_valued(self): |
| res = isl.isl_map_is_single_valued(self.ptr) |
| return res |
| def is_injective(self): |
| res = isl.isl_map_is_injective(self.ptr) |
| return res |
| def is_bijective(self): |
| res = isl.isl_map_is_bijective(self.ptr) |
| return res |
| def gist(self, arg1): |
| try: |
| if not arg1.__class__ is map: |
| arg1 = map(arg1) |
| except: |
| return union_map(self).gist(arg1) |
| res = isl.isl_map_gist(isl.isl_map_copy(self.ptr), isl.isl_map_copy(arg1.ptr)) |
| return map(ctx=self.ctx, ptr=res) |
| def gist_domain(self, arg1): |
| try: |
| if not arg1.__class__ is set: |
| arg1 = set(arg1) |
| except: |
| return union_map(self).gist_domain(arg1) |
| res = isl.isl_map_gist_domain(isl.isl_map_copy(self.ptr), isl.isl_set_copy(arg1.ptr)) |
| return map(ctx=self.ctx, ptr=res) |
| def coalesce(self): |
| res = isl.isl_map_coalesce(isl.isl_map_copy(self.ptr)) |
| return map(ctx=self.ctx, ptr=res) |
| def foreach_basic_map(self, arg1): |
| exc_info = [None] |
| fn = CFUNCTYPE(c_int, c_void_p, c_void_p) |
| def cb_func(cb_arg0, cb_arg1): |
| cb_arg0 = basic_map(ctx=self.ctx, ptr=cb_arg0) |
| try: |
| arg1(cb_arg0) |
| except: |
| import sys |
| exc_info[0] = sys.exc_info() |
| return -1 |
| return 0 |
| cb = fn(cb_func) |
| res = isl.isl_map_foreach_basic_map(self.ptr, cb, None) |
| if exc_info[0] != None: |
| raise exc_info[0][0], exc_info[0][1], exc_info[0][2] |
| return res |
| |
| isl.isl_map_read_from_str.restype = c_void_p |
| isl.isl_map_read_from_str.argtypes = [Context, c_char_p] |
| isl.isl_map_from_basic_map.restype = c_void_p |
| isl.isl_map_from_basic_map.argtypes = [c_void_p] |
| isl.isl_map_lexmin.restype = c_void_p |
| isl.isl_map_lexmax.restype = c_void_p |
| isl.isl_map_reverse.restype = c_void_p |
| isl.isl_map_union.restype = c_void_p |
| isl.isl_map_intersect_domain.restype = c_void_p |
| isl.isl_map_intersect_range.restype = c_void_p |
| isl.isl_map_apply_domain.restype = c_void_p |
| isl.isl_map_apply_range.restype = c_void_p |
| isl.isl_map_intersect.restype = c_void_p |
| isl.isl_map_intersect_params.restype = c_void_p |
| isl.isl_map_subtract.restype = c_void_p |
| isl.isl_map_deltas.restype = c_void_p |
| isl.isl_map_detect_equalities.restype = c_void_p |
| isl.isl_map_affine_hull.restype = c_void_p |
| isl.isl_map_polyhedral_hull.restype = c_void_p |
| isl.isl_map_flatten.restype = c_void_p |
| isl.isl_map_flatten_domain.restype = c_void_p |
| isl.isl_map_flatten_range.restype = c_void_p |
| isl.isl_map_sample.restype = c_void_p |
| isl.isl_map_gist.restype = c_void_p |
| isl.isl_map_gist_domain.restype = c_void_p |
| isl.isl_map_coalesce.restype = c_void_p |
| isl.isl_map_free.argtypes = [c_void_p] |
| isl.isl_map_to_str.argtypes = [c_void_p] |
| isl.isl_map_to_str.restype = POINTER(c_char) |
| |
| class basic_map(map): |
| def __init__(self, *args, **keywords): |
| if "ptr" in keywords: |
| self.ctx = keywords["ctx"] |
| self.ptr = keywords["ptr"] |
| return |
| if len(args) == 1 and type(args[0]) == str: |
| self.ctx = Context.getDefaultInstance() |
| self.ptr = isl.isl_basic_map_read_from_str(self.ctx, args[0]) |
| return |
| raise Error |
| def __del__(self): |
| if hasattr(self, 'ptr'): |
| isl.isl_basic_map_free(self.ptr) |
| def __str__(self): |
| ptr = isl.isl_basic_map_to_str(self.ptr) |
| res = str(cast(ptr, c_char_p).value) |
| libc.free(ptr) |
| return res |
| def __repr__(self): |
| return 'isl.basic_map("%s")' % str(self) |
| def intersect_domain(self, arg1): |
| try: |
| if not arg1.__class__ is basic_set: |
| arg1 = basic_set(arg1) |
| except: |
| return map(self).intersect_domain(arg1) |
| res = isl.isl_basic_map_intersect_domain(isl.isl_basic_map_copy(self.ptr), isl.isl_basic_set_copy(arg1.ptr)) |
| return basic_map(ctx=self.ctx, ptr=res) |
| def intersect_range(self, arg1): |
| try: |
| if not arg1.__class__ is basic_set: |
| arg1 = basic_set(arg1) |
| except: |
| return map(self).intersect_range(arg1) |
| res = isl.isl_basic_map_intersect_range(isl.isl_basic_map_copy(self.ptr), isl.isl_basic_set_copy(arg1.ptr)) |
| return basic_map(ctx=self.ctx, ptr=res) |
| def intersect(self, arg1): |
| try: |
| if not arg1.__class__ is basic_map: |
| arg1 = basic_map(arg1) |
| except: |
| return map(self).intersect(arg1) |
| res = isl.isl_basic_map_intersect(isl.isl_basic_map_copy(self.ptr), isl.isl_basic_map_copy(arg1.ptr)) |
| return basic_map(ctx=self.ctx, ptr=res) |
| def union(self, arg1): |
| try: |
| if not arg1.__class__ is basic_map: |
| arg1 = basic_map(arg1) |
| except: |
| return map(self).union(arg1) |
| res = isl.isl_basic_map_union(isl.isl_basic_map_copy(self.ptr), isl.isl_basic_map_copy(arg1.ptr)) |
| return map(ctx=self.ctx, ptr=res) |
| def apply_domain(self, arg1): |
| try: |
| if not arg1.__class__ is basic_map: |
| arg1 = basic_map(arg1) |
| except: |
| return map(self).apply_domain(arg1) |
| res = isl.isl_basic_map_apply_domain(isl.isl_basic_map_copy(self.ptr), isl.isl_basic_map_copy(arg1.ptr)) |
| return basic_map(ctx=self.ctx, ptr=res) |
| def apply_range(self, arg1): |
| try: |
| if not arg1.__class__ is basic_map: |
| arg1 = basic_map(arg1) |
| except: |
| return map(self).apply_range(arg1) |
| res = isl.isl_basic_map_apply_range(isl.isl_basic_map_copy(self.ptr), isl.isl_basic_map_copy(arg1.ptr)) |
| return basic_map(ctx=self.ctx, ptr=res) |
| def affine_hull(self): |
| res = isl.isl_basic_map_affine_hull(isl.isl_basic_map_copy(self.ptr)) |
| return basic_map(ctx=self.ctx, ptr=res) |
| def reverse(self): |
| res = isl.isl_basic_map_reverse(isl.isl_basic_map_copy(self.ptr)) |
| return basic_map(ctx=self.ctx, ptr=res) |
| def sample(self): |
| res = isl.isl_basic_map_sample(isl.isl_basic_map_copy(self.ptr)) |
| return basic_map(ctx=self.ctx, ptr=res) |
| def detect_equalities(self): |
| res = isl.isl_basic_map_detect_equalities(isl.isl_basic_map_copy(self.ptr)) |
| return basic_map(ctx=self.ctx, ptr=res) |
| def is_equal(self, arg1): |
| try: |
| if not arg1.__class__ is basic_map: |
| arg1 = basic_map(arg1) |
| except: |
| return map(self).is_equal(arg1) |
| res = isl.isl_basic_map_is_equal(self.ptr, arg1.ptr) |
| return res |
| def lexmin(self): |
| res = isl.isl_basic_map_lexmin(isl.isl_basic_map_copy(self.ptr)) |
| return map(ctx=self.ctx, ptr=res) |
| def lexmax(self): |
| res = isl.isl_basic_map_lexmax(isl.isl_basic_map_copy(self.ptr)) |
| return map(ctx=self.ctx, ptr=res) |
| def is_empty(self): |
| res = isl.isl_basic_map_is_empty(self.ptr) |
| return res |
| def deltas(self): |
| res = isl.isl_basic_map_deltas(isl.isl_basic_map_copy(self.ptr)) |
| return basic_set(ctx=self.ctx, ptr=res) |
| def flatten(self): |
| res = isl.isl_basic_map_flatten(isl.isl_basic_map_copy(self.ptr)) |
| return basic_map(ctx=self.ctx, ptr=res) |
| def flatten_domain(self): |
| res = isl.isl_basic_map_flatten_domain(isl.isl_basic_map_copy(self.ptr)) |
| return basic_map(ctx=self.ctx, ptr=res) |
| def flatten_range(self): |
| res = isl.isl_basic_map_flatten_range(isl.isl_basic_map_copy(self.ptr)) |
| return basic_map(ctx=self.ctx, ptr=res) |
| def gist(self, arg1): |
| try: |
| if not arg1.__class__ is basic_map: |
| arg1 = basic_map(arg1) |
| except: |
| return map(self).gist(arg1) |
| res = isl.isl_basic_map_gist(isl.isl_basic_map_copy(self.ptr), isl.isl_basic_map_copy(arg1.ptr)) |
| return basic_map(ctx=self.ctx, ptr=res) |
| |
| isl.isl_basic_map_read_from_str.restype = c_void_p |
| isl.isl_basic_map_read_from_str.argtypes = [Context, c_char_p] |
| isl.isl_basic_map_intersect_domain.restype = c_void_p |
| isl.isl_basic_map_intersect_range.restype = c_void_p |
| isl.isl_basic_map_intersect.restype = c_void_p |
| isl.isl_basic_map_union.restype = c_void_p |
| isl.isl_basic_map_apply_domain.restype = c_void_p |
| isl.isl_basic_map_apply_range.restype = c_void_p |
| isl.isl_basic_map_affine_hull.restype = c_void_p |
| isl.isl_basic_map_reverse.restype = c_void_p |
| isl.isl_basic_map_sample.restype = c_void_p |
| isl.isl_basic_map_detect_equalities.restype = c_void_p |
| isl.isl_basic_map_lexmin.restype = c_void_p |
| isl.isl_basic_map_lexmax.restype = c_void_p |
| isl.isl_basic_map_deltas.restype = c_void_p |
| isl.isl_basic_map_flatten.restype = c_void_p |
| isl.isl_basic_map_flatten_domain.restype = c_void_p |
| isl.isl_basic_map_flatten_range.restype = c_void_p |
| isl.isl_basic_map_gist.restype = c_void_p |
| isl.isl_basic_map_free.argtypes = [c_void_p] |
| isl.isl_basic_map_to_str.argtypes = [c_void_p] |
| isl.isl_basic_map_to_str.restype = POINTER(c_char) |
| |
| class union_set: |
| def __init__(self, *args, **keywords): |
| if "ptr" in keywords: |
| self.ctx = keywords["ctx"] |
| self.ptr = keywords["ptr"] |
| return |
| if len(args) == 1 and args[0].__class__ is set: |
| self.ctx = Context.getDefaultInstance() |
| self.ptr = isl.isl_union_set_from_set(isl.isl_set_copy(args[0].ptr)) |
| return |
| if len(args) == 1 and type(args[0]) == str: |
| self.ctx = Context.getDefaultInstance() |
| self.ptr = isl.isl_union_set_read_from_str(self.ctx, args[0]) |
| return |
| raise Error |
| def __del__(self): |
| if hasattr(self, 'ptr'): |
| isl.isl_union_set_free(self.ptr) |
| def __str__(self): |
| ptr = isl.isl_union_set_to_str(self.ptr) |
| res = str(cast(ptr, c_char_p).value) |
| libc.free(ptr) |
| return res |
| def __repr__(self): |
| return 'isl.union_set("%s")' % str(self) |
| def identity(self): |
| res = isl.isl_union_set_identity(isl.isl_union_set_copy(self.ptr)) |
| return union_map(ctx=self.ctx, ptr=res) |
| def detect_equalities(self): |
| res = isl.isl_union_set_detect_equalities(isl.isl_union_set_copy(self.ptr)) |
| return union_set(ctx=self.ctx, ptr=res) |
| def affine_hull(self): |
| res = isl.isl_union_set_affine_hull(isl.isl_union_set_copy(self.ptr)) |
| return union_set(ctx=self.ctx, ptr=res) |
| def polyhedral_hull(self): |
| res = isl.isl_union_set_polyhedral_hull(isl.isl_union_set_copy(self.ptr)) |
| return union_set(ctx=self.ctx, ptr=res) |
| def coalesce(self): |
| res = isl.isl_union_set_coalesce(isl.isl_union_set_copy(self.ptr)) |
| return union_set(ctx=self.ctx, ptr=res) |
| def lexmin(self): |
| res = isl.isl_union_set_lexmin(isl.isl_union_set_copy(self.ptr)) |
| return union_set(ctx=self.ctx, ptr=res) |
| def lexmax(self): |
| res = isl.isl_union_set_lexmax(isl.isl_union_set_copy(self.ptr)) |
| return union_set(ctx=self.ctx, ptr=res) |
| def subtract(self, arg1): |
| try: |
| if not arg1.__class__ is union_set: |
| arg1 = union_set(arg1) |
| except: |
| raise |
| res = isl.isl_union_set_subtract(isl.isl_union_set_copy(self.ptr), isl.isl_union_set_copy(arg1.ptr)) |
| return union_set(ctx=self.ctx, ptr=res) |
| def intersect(self, arg1): |
| try: |
| if not arg1.__class__ is union_set: |
| arg1 = union_set(arg1) |
| except: |
| raise |
| res = isl.isl_union_set_intersect(isl.isl_union_set_copy(self.ptr), isl.isl_union_set_copy(arg1.ptr)) |
| return union_set(ctx=self.ctx, ptr=res) |
| def intersect_params(self, arg1): |
| try: |
| if not arg1.__class__ is set: |
| arg1 = set(arg1) |
| except: |
| raise |
| res = isl.isl_union_set_intersect_params(isl.isl_union_set_copy(self.ptr), isl.isl_set_copy(arg1.ptr)) |
| return union_set(ctx=self.ctx, ptr=res) |
| def gist(self, arg1): |
| try: |
| if not arg1.__class__ is union_set: |
| arg1 = union_set(arg1) |
| except: |
| raise |
| res = isl.isl_union_set_gist(isl.isl_union_set_copy(self.ptr), isl.isl_union_set_copy(arg1.ptr)) |
| return union_set(ctx=self.ctx, ptr=res) |
| def gist_params(self, arg1): |
| try: |
| if not arg1.__class__ is set: |
| arg1 = set(arg1) |
| except: |
| raise |
| res = isl.isl_union_set_gist_params(isl.isl_union_set_copy(self.ptr), isl.isl_set_copy(arg1.ptr)) |
| return union_set(ctx=self.ctx, ptr=res) |
| def apply(self, arg1): |
| try: |
| if not arg1.__class__ is union_map: |
| arg1 = union_map(arg1) |
| except: |
| raise |
| res = isl.isl_union_set_apply(isl.isl_union_set_copy(self.ptr), isl.isl_union_map_copy(arg1.ptr)) |
| return union_set(ctx=self.ctx, ptr=res) |
| def is_empty(self): |
| res = isl.isl_union_set_is_empty(self.ptr) |
| return res |
| def is_subset(self, arg1): |
| try: |
| if not arg1.__class__ is union_set: |
| arg1 = union_set(arg1) |
| except: |
| raise |
| res = isl.isl_union_set_is_subset(self.ptr, arg1.ptr) |
| return res |
| def is_equal(self, arg1): |
| try: |
| if not arg1.__class__ is union_set: |
| arg1 = union_set(arg1) |
| except: |
| raise |
| res = isl.isl_union_set_is_equal(self.ptr, arg1.ptr) |
| return res |
| def is_strict_subset(self, arg1): |
| try: |
| if not arg1.__class__ is union_set: |
| arg1 = union_set(arg1) |
| except: |
| raise |
| res = isl.isl_union_set_is_strict_subset(self.ptr, arg1.ptr) |
| return res |
| def foreach_set(self, arg1): |
| exc_info = [None] |
| fn = CFUNCTYPE(c_int, c_void_p, c_void_p) |
| def cb_func(cb_arg0, cb_arg1): |
| cb_arg0 = set(ctx=self.ctx, ptr=cb_arg0) |
| try: |
| arg1(cb_arg0) |
| except: |
| import sys |
| exc_info[0] = sys.exc_info() |
| return -1 |
| return 0 |
| cb = fn(cb_func) |
| res = isl.isl_union_set_foreach_set(self.ptr, cb, None) |
| if exc_info[0] != None: |
| raise exc_info[0][0], exc_info[0][1], exc_info[0][2] |
| return res |
| |
| isl.isl_union_set_from_set.restype = c_void_p |
| isl.isl_union_set_from_set.argtypes = [c_void_p] |
| isl.isl_union_set_read_from_str.restype = c_void_p |
| isl.isl_union_set_read_from_str.argtypes = [Context, c_char_p] |
| isl.isl_union_set_identity.restype = c_void_p |
| isl.isl_union_set_detect_equalities.restype = c_void_p |
| isl.isl_union_set_affine_hull.restype = c_void_p |
| isl.isl_union_set_polyhedral_hull.restype = c_void_p |
| isl.isl_union_set_coalesce.restype = c_void_p |
| isl.isl_union_set_lexmin.restype = c_void_p |
| isl.isl_union_set_lexmax.restype = c_void_p |
| isl.isl_union_set_subtract.restype = c_void_p |
| isl.isl_union_set_intersect.restype = c_void_p |
| isl.isl_union_set_intersect_params.restype = c_void_p |
| isl.isl_union_set_gist.restype = c_void_p |
| isl.isl_union_set_gist_params.restype = c_void_p |
| isl.isl_union_set_apply.restype = c_void_p |
| isl.isl_union_set_free.argtypes = [c_void_p] |
| isl.isl_union_set_to_str.argtypes = [c_void_p] |
| isl.isl_union_set_to_str.restype = POINTER(c_char) |
| |
| class set(union_set): |
| def __init__(self, *args, **keywords): |
| if "ptr" in keywords: |
| self.ctx = keywords["ctx"] |
| self.ptr = keywords["ptr"] |
| return |
| if len(args) == 1 and type(args[0]) == str: |
| self.ctx = Context.getDefaultInstance() |
| self.ptr = isl.isl_set_read_from_str(self.ctx, args[0]) |
| return |
| if len(args) == 1 and args[0].__class__ is basic_set: |
| self.ctx = Context.getDefaultInstance() |
| self.ptr = isl.isl_set_from_basic_set(isl.isl_basic_set_copy(args[0].ptr)) |
| return |
| raise Error |
| def __del__(self): |
| if hasattr(self, 'ptr'): |
| isl.isl_set_free(self.ptr) |
| def __str__(self): |
| ptr = isl.isl_set_to_str(self.ptr) |
| res = str(cast(ptr, c_char_p).value) |
| libc.free(ptr) |
| return res |
| def __repr__(self): |
| return 'isl.set("%s")' % str(self) |
| def intersect(self, arg1): |
| try: |
| if not arg1.__class__ is set: |
| arg1 = set(arg1) |
| except: |
| return union_set(self).intersect(arg1) |
| res = isl.isl_set_intersect(isl.isl_set_copy(self.ptr), isl.isl_set_copy(arg1.ptr)) |
| return set(ctx=self.ctx, ptr=res) |
| def intersect_params(self, arg1): |
| try: |
| if not arg1.__class__ is set: |
| arg1 = set(arg1) |
| except: |
| return union_set(self).intersect_params(arg1) |
| res = isl.isl_set_intersect_params(isl.isl_set_copy(self.ptr), isl.isl_set_copy(arg1.ptr)) |
| return set(ctx=self.ctx, ptr=res) |
| def subtract(self, arg1): |
| try: |
| if not arg1.__class__ is set: |
| arg1 = set(arg1) |
| except: |
| return union_set(self).subtract(arg1) |
| res = isl.isl_set_subtract(isl.isl_set_copy(self.ptr), isl.isl_set_copy(arg1.ptr)) |
| return set(ctx=self.ctx, ptr=res) |
| def complement(self): |
| res = isl.isl_set_complement(isl.isl_set_copy(self.ptr)) |
| return set(ctx=self.ctx, ptr=res) |
| def apply(self, arg1): |
| try: |
| if not arg1.__class__ is map: |
| arg1 = map(arg1) |
| except: |
| return union_set(self).apply(arg1) |
| res = isl.isl_set_apply(isl.isl_set_copy(self.ptr), isl.isl_map_copy(arg1.ptr)) |
| return set(ctx=self.ctx, ptr=res) |
| def is_empty(self): |
| res = isl.isl_set_is_empty(self.ptr) |
| return res |
| def is_subset(self, arg1): |
| try: |
| if not arg1.__class__ is set: |
| arg1 = set(arg1) |
| except: |
| return union_set(self).is_subset(arg1) |
| res = isl.isl_set_is_subset(self.ptr, arg1.ptr) |
| return res |
| def is_strict_subset(self, arg1): |
| try: |
| if not arg1.__class__ is set: |
| arg1 = set(arg1) |
| except: |
| return union_set(self).is_strict_subset(arg1) |
| res = isl.isl_set_is_strict_subset(self.ptr, arg1.ptr) |
| return res |
| def is_equal(self, arg1): |
| try: |
| if not arg1.__class__ is set: |
| arg1 = set(arg1) |
| except: |
| return union_set(self).is_equal(arg1) |
| res = isl.isl_set_is_equal(self.ptr, arg1.ptr) |
| return res |
| def gist(self, arg1): |
| try: |
| if not arg1.__class__ is set: |
| arg1 = set(arg1) |
| except: |
| return union_set(self).gist(arg1) |
| res = isl.isl_set_gist(isl.isl_set_copy(self.ptr), isl.isl_set_copy(arg1.ptr)) |
| return set(ctx=self.ctx, ptr=res) |
| def coalesce(self): |
| res = isl.isl_set_coalesce(isl.isl_set_copy(self.ptr)) |
| return set(ctx=self.ctx, ptr=res) |
| def foreach_basic_set(self, arg1): |
| exc_info = [None] |
| fn = CFUNCTYPE(c_int, c_void_p, c_void_p) |
| def cb_func(cb_arg0, cb_arg1): |
| cb_arg0 = basic_set(ctx=self.ctx, ptr=cb_arg0) |
| try: |
| arg1(cb_arg0) |
| except: |
| import sys |
| exc_info[0] = sys.exc_info() |
| return -1 |
| return 0 |
| cb = fn(cb_func) |
| res = isl.isl_set_foreach_basic_set(self.ptr, cb, None) |
| if exc_info[0] != None: |
| raise exc_info[0][0], exc_info[0][1], exc_info[0][2] |
| return res |
| def lexmin(self): |
| res = isl.isl_set_lexmin(isl.isl_set_copy(self.ptr)) |
| return set(ctx=self.ctx, ptr=res) |
| def lexmax(self): |
| res = isl.isl_set_lexmax(isl.isl_set_copy(self.ptr)) |
| return set(ctx=self.ctx, ptr=res) |
| def detect_equalities(self): |
| res = isl.isl_set_detect_equalities(isl.isl_set_copy(self.ptr)) |
| return set(ctx=self.ctx, ptr=res) |
| def affine_hull(self): |
| res = isl.isl_set_affine_hull(isl.isl_set_copy(self.ptr)) |
| return basic_set(ctx=self.ctx, ptr=res) |
| def polyhedral_hull(self): |
| res = isl.isl_set_polyhedral_hull(isl.isl_set_copy(self.ptr)) |
| return basic_set(ctx=self.ctx, ptr=res) |
| def union(self, arg1): |
| try: |
| if not arg1.__class__ is set: |
| arg1 = set(arg1) |
| except: |
| return union_set(self).union(arg1) |
| res = isl.isl_set_union(isl.isl_set_copy(self.ptr), isl.isl_set_copy(arg1.ptr)) |
| return set(ctx=self.ctx, ptr=res) |
| def identity(self): |
| res = isl.isl_set_identity(isl.isl_set_copy(self.ptr)) |
| return map(ctx=self.ctx, ptr=res) |
| def is_wrapping(self): |
| res = isl.isl_set_is_wrapping(self.ptr) |
| return res |
| def flatten(self): |
| res = isl.isl_set_flatten(isl.isl_set_copy(self.ptr)) |
| return set(ctx=self.ctx, ptr=res) |
| |
| isl.isl_set_read_from_str.restype = c_void_p |
| isl.isl_set_read_from_str.argtypes = [Context, c_char_p] |
| isl.isl_set_from_basic_set.restype = c_void_p |
| isl.isl_set_from_basic_set.argtypes = [c_void_p] |
| isl.isl_set_intersect.restype = c_void_p |
| isl.isl_set_intersect_params.restype = c_void_p |
| isl.isl_set_subtract.restype = c_void_p |
| isl.isl_set_complement.restype = c_void_p |
| isl.isl_set_apply.restype = c_void_p |
| isl.isl_set_gist.restype = c_void_p |
| isl.isl_set_coalesce.restype = c_void_p |
| isl.isl_set_lexmin.restype = c_void_p |
| isl.isl_set_lexmax.restype = c_void_p |
| isl.isl_set_detect_equalities.restype = c_void_p |
| isl.isl_set_affine_hull.restype = c_void_p |
| isl.isl_set_polyhedral_hull.restype = c_void_p |
| isl.isl_set_union.restype = c_void_p |
| isl.isl_set_identity.restype = c_void_p |
| isl.isl_set_flatten.restype = c_void_p |
| isl.isl_set_free.argtypes = [c_void_p] |
| isl.isl_set_to_str.argtypes = [c_void_p] |
| isl.isl_set_to_str.restype = POINTER(c_char) |
| |
| class basic_set(set): |
| def __init__(self, *args, **keywords): |
| if "ptr" in keywords: |
| self.ctx = keywords["ctx"] |
| self.ptr = keywords["ptr"] |
| return |
| if len(args) == 1 and type(args[0]) == str: |
| self.ctx = Context.getDefaultInstance() |
| self.ptr = isl.isl_basic_set_read_from_str(self.ctx, args[0]) |
| return |
| raise Error |
| def __del__(self): |
| if hasattr(self, 'ptr'): |
| isl.isl_basic_set_free(self.ptr) |
| def __str__(self): |
| ptr = isl.isl_basic_set_to_str(self.ptr) |
| res = str(cast(ptr, c_char_p).value) |
| libc.free(ptr) |
| return res |
| def __repr__(self): |
| return 'isl.basic_set("%s")' % str(self) |
| def gist(self, arg1): |
| try: |
| if not arg1.__class__ is basic_set: |
| arg1 = basic_set(arg1) |
| except: |
| return set(self).gist(arg1) |
| res = isl.isl_basic_set_gist(isl.isl_basic_set_copy(self.ptr), isl.isl_basic_set_copy(arg1.ptr)) |
| return basic_set(ctx=self.ctx, ptr=res) |
| def intersect(self, arg1): |
| try: |
| if not arg1.__class__ is basic_set: |
| arg1 = basic_set(arg1) |
| except: |
| return set(self).intersect(arg1) |
| res = isl.isl_basic_set_intersect(isl.isl_basic_set_copy(self.ptr), isl.isl_basic_set_copy(arg1.ptr)) |
| return basic_set(ctx=self.ctx, ptr=res) |
| def intersect_params(self, arg1): |
| try: |
| if not arg1.__class__ is basic_set: |
| arg1 = basic_set(arg1) |
| except: |
| return set(self).intersect_params(arg1) |
| res = isl.isl_basic_set_intersect_params(isl.isl_basic_set_copy(self.ptr), isl.isl_basic_set_copy(arg1.ptr)) |
| return basic_set(ctx=self.ctx, ptr=res) |
| def apply(self, arg1): |
| try: |
| if not arg1.__class__ is basic_map: |
| arg1 = basic_map(arg1) |
| except: |
| return set(self).apply(arg1) |
| res = isl.isl_basic_set_apply(isl.isl_basic_set_copy(self.ptr), isl.isl_basic_map_copy(arg1.ptr)) |
| return basic_set(ctx=self.ctx, ptr=res) |
| def affine_hull(self): |
| res = isl.isl_basic_set_affine_hull(isl.isl_basic_set_copy(self.ptr)) |
| return basic_set(ctx=self.ctx, ptr=res) |
| def detect_equalities(self): |
| res = isl.isl_basic_set_detect_equalities(isl.isl_basic_set_copy(self.ptr)) |
| return basic_set(ctx=self.ctx, ptr=res) |
| def is_equal(self, arg1): |
| res = isl.isl_basic_set_is_equal(self.ptr, arg1.ptr) |
| return res |
| def lexmin(self): |
| res = isl.isl_basic_set_lexmin(isl.isl_basic_set_copy(self.ptr)) |
| return set(ctx=self.ctx, ptr=res) |
| def lexmax(self): |
| res = isl.isl_basic_set_lexmax(isl.isl_basic_set_copy(self.ptr)) |
| return set(ctx=self.ctx, ptr=res) |
| def union(self, arg1): |
| try: |
| if not arg1.__class__ is basic_set: |
| arg1 = basic_set(arg1) |
| except: |
| return set(self).union(arg1) |
| res = isl.isl_basic_set_union(isl.isl_basic_set_copy(self.ptr), isl.isl_basic_set_copy(arg1.ptr)) |
| return set(ctx=self.ctx, ptr=res) |
| def is_empty(self): |
| res = isl.isl_basic_set_is_empty(self.ptr) |
| return res |
| def is_wrapping(self): |
| res = isl.isl_basic_set_is_wrapping(self.ptr) |
| return res |
| def flatten(self): |
| res = isl.isl_basic_set_flatten(isl.isl_basic_set_copy(self.ptr)) |
| return basic_set(ctx=self.ctx, ptr=res) |
| |
| isl.isl_basic_set_read_from_str.restype = c_void_p |
| isl.isl_basic_set_read_from_str.argtypes = [Context, c_char_p] |
| isl.isl_basic_set_gist.restype = c_void_p |
| isl.isl_basic_set_intersect.restype = c_void_p |
| isl.isl_basic_set_intersect_params.restype = c_void_p |
| isl.isl_basic_set_apply.restype = c_void_p |
| isl.isl_basic_set_affine_hull.restype = c_void_p |
| isl.isl_basic_set_detect_equalities.restype = c_void_p |
| isl.isl_basic_set_lexmin.restype = c_void_p |
| isl.isl_basic_set_lexmax.restype = c_void_p |
| isl.isl_basic_set_union.restype = c_void_p |
| isl.isl_basic_set_flatten.restype = c_void_p |
| isl.isl_basic_set_free.argtypes = [c_void_p] |
| isl.isl_basic_set_to_str.argtypes = [c_void_p] |
| isl.isl_basic_set_to_str.restype = POINTER(c_char) |
| |
| class pw_qpolynomial: |
| def __init__(self, *args, **keywords): |
| if "ptr" in keywords: |
| self.ctx = keywords["ctx"] |
| self.ptr = keywords["ptr"] |
| return |
| raise Error |
| def __del__(self): |
| if hasattr(self, 'ptr'): |
| isl.isl_pw_qpolynomial_free(self.ptr) |
| def __str__(self): |
| ptr = isl.isl_pw_qpolynomial_to_str(self.ptr) |
| res = str(cast(ptr, c_char_p).value) |
| libc.free(ptr) |
| return res |
| def __repr__(self): |
| return 'isl.pw_qpolynomial("%s")' % str(self) |
| |
| isl.isl_pw_qpolynomial_free.argtypes = [c_void_p] |
| isl.isl_pw_qpolynomial_to_str.argtypes = [c_void_p] |
| isl.isl_pw_qpolynomial_to_str.restype = POINTER(c_char) |
| |
| class union_pw_qpolynomial: |
| def __init__(self, *args, **keywords): |
| if "ptr" in keywords: |
| self.ctx = keywords["ctx"] |
| self.ptr = keywords["ptr"] |
| return |
| raise Error |
| def __del__(self): |
| if hasattr(self, 'ptr'): |
| isl.isl_union_pw_qpolynomial_free(self.ptr) |
| def __str__(self): |
| ptr = isl.isl_union_pw_qpolynomial_to_str(self.ptr) |
| res = str(cast(ptr, c_char_p).value) |
| libc.free(ptr) |
| return res |
| def __repr__(self): |
| return 'isl.union_pw_qpolynomial("%s")' % str(self) |
| |
| isl.isl_union_pw_qpolynomial_free.argtypes = [c_void_p] |
| isl.isl_union_pw_qpolynomial_to_str.argtypes = [c_void_p] |
| isl.isl_union_pw_qpolynomial_to_str.restype = POINTER(c_char) |
