String formatting for empty expressions
[linpy.git] / pypol / isl.py
1
2 import ctypes, ctypes.util
3 import math
4 import numbers
5 import operator
6 import re
7
8 from decimal import Decimal
9 from fractions import Fraction
10 from functools import wraps
11
12
13 libisl = ctypes.CDLL(ctypes.util.find_library('isl'))
14
15 libisl.isl_printer_get_str.restype = ctypes.c_char_p
16
17
18 class Context:
19
20 __slots__ = ('_ic')
21
22 def __init__(self):
23 self._ic = libisl.isl_ctx_alloc()
24
25 @property
26 def _as_parameter_(self):
27 return self._ic
28
29 def __del__(self):
30 libisl.isl_ctx_free(self)
31
32 def __eq__(self, other):
33 if not isinstance(other, Context):
34 return False
35 return self._ic == other._ic
36
37
38 class Value:
39
40 class _ptr(int):
41 def __new__(cls, iv):
42 return super().__new__(cls, iv)
43 def __repr__(self):
44 return '{}({})'.format(self.__class__.__name__, self)
45
46 _RE_NONFINITE = re.compile(
47 r'^\s*(?P<sign>[-+])?((?P<inf>Inf(inity)?)|(?P<nan>NaN))\s*$',
48 re.IGNORECASE)
49
50 _RE_FRACTION = re.compile(r'^(?P<num>[-+]?\d+)(/(?P<den>\d+))?$')
51
52 __slots__ = ('context', '_iv', '_numerator', '_denominator')
53
54 def __new__(cls, context, numerator=0, denominator=None):
55 self = super().__new__(cls)
56 if not isinstance(context, Context):
57 raise TypeError('first argument should be a context')
58 self.context = context
59 if isinstance(numerator, cls._ptr):
60 assert denominator is None
61 self._iv = numerator
62 if libisl.isl_val_is_rat(self):
63 # retrieve numerator and denominator as strings to avoid integer
64 # overflows
65 ip = libisl.isl_printer_to_str(self.context)
66 ip = libisl.isl_printer_print_val(ip, self)
67 string = libisl.isl_printer_get_str(ip).decode()
68 libisl.isl_printer_free(ip)
69 m = self._RE_FRACTION.match(string)
70 assert m is not None
71 self._numerator = int(m.group('num'))
72 self._denominator = int(m.group('den')) if m.group('den') else 1
73 else:
74 self._numerator = None
75 self._denominator = None
76 return self
77 if isinstance(numerator, str) and denominator is None:
78 m = self._RE_NONFINITE.match(numerator)
79 if m is not None:
80 self._numerator = None
81 self._denominator = None
82 if m.group('inf'):
83 if m.group('sign') == '-':
84 self._iv = libisl.isl_val_neginfty(context)
85 else:
86 self._iv = libisl.isl_val_infty(context)
87 else:
88 assert m.group('nan')
89 self._iv = libisl.isl_val_nan(context)
90 return self
91 try:
92 frac = Fraction(numerator, denominator)
93 except ValueError:
94 raise ValueError('invalid literal for {}: {!r}'.format(
95 cls.__name__, numerator))
96 self._numerator = frac.numerator
97 self._denominator = frac.denominator
98 # values passed as strings to avoid integer overflows
99 if frac.denominator == 1:
100 numerator = str(frac.numerator).encode()
101 self._iv = libisl.isl_val_read_from_str(context, numerator)
102 else:
103 numerator = str(frac.numerator).encode()
104 numerator = libisl.isl_val_read_from_str(context, numerator)
105 denominator = str(frac.denominator).encode()
106 denominator = libisl.isl_val_read_from_str(context, denominator)
107 self._iv = libisl.isl_val_div(numerator, denominator)
108 return self
109
110 @property
111 def _as_parameter_(self):
112 return self._iv
113
114 def __del__(self):
115 libisl.isl_val_free(self)
116 self.context # prevents context from being GC'ed before the value
117
118 @property
119 def numerator(self):
120 if self._numerator is None:
121 raise ValueError('not a rational number')
122 return self._numerator
123
124 @property
125 def denominator(self):
126 if self._denominator is None:
127 raise ValueError('not a rational number')
128 return self._denominator
129
130 def __bool__(self):
131 return not bool(libisl.isl_val_is_zero(self))
132
133 def _polymorphic(func):
134 @wraps(func)
135 def wrapper(self, other):
136 if isinstance(other, Value):
137 return func(self, other)
138 if isinstance(other, numbers.Rational):
139 other = Value(self.context, other)
140 return func(self, other)
141 raise TypeError('operand should be a Value or a Rational')
142 return wrapper
143
144 @_polymorphic
145 def __lt__(self, other):
146 return bool(libisl.isl_val_lt(self, other))
147
148 @_polymorphic
149 def __le__(self, other):
150 return bool(libisl.isl_val_le(self, other))
151
152 @_polymorphic
153 def __gt__(self, other):
154 return bool(libisl.isl_val_gt(self, other))
155
156 @_polymorphic
157 def __ge__(self, other):
158 return bool(libisl.isl_val_ge(self, other))
159
160 @_polymorphic
161 def __eq__(self, other):
162 return bool(libisl.isl_val_eq(self, other))
163
164 # __ne__ is not implemented, ISL semantics does not match Python's on
165 # nan != nan
166
167 def __abs__(self):
168 val = libisl.isl_val_copy(self)
169 val = libisl.isl_val_abs(val)
170 return self.__class__(self.context, self._ptr(val))
171
172 def __pos__(self):
173 return self
174
175 def __neg__(self):
176 val = libisl.isl_val_copy(self)
177 val = libisl.isl_val_neg(val)
178 return self.__class__(self.context, self._ptr(val))
179
180 def __floor__(self):
181 val = libisl.isl_val_copy(self)
182 val = libisl.isl_val_floor(val)
183 return self.__class__(self.context, self._ptr(val))
184
185 def __ceil__(self):
186 val = libisl.isl_val_copy(self)
187 val = libisl.isl_val_ceil(val)
188 return self.__class__(self.context, self._ptr(val))
189
190 def __trunc__(self):
191 val = libisl.isl_val_copy(self)
192 val = libisl.isl_val_trunc(val)
193 return self.__class__(self.context, self._ptr(val))
194
195 @_polymorphic
196 def __add__(self, other):
197 val1 = libisl.isl_val_copy(self)
198 val2 = libisl.isl_val_copy(other)
199 val = libisl.isl_val_add(val1, val2)
200 return self.__class__(self.context, self._ptr(val))
201
202 __radd__ = __add__
203
204 @_polymorphic
205 def __sub__(self, other):
206 val1 = libisl.isl_val_copy(self)
207 val2 = libisl.isl_val_copy(other)
208 val = libisl.isl_val_sub(val1, val2)
209 return self.__class__(self.context, self._ptr(val))
210
211 __rsub__ = __sub__
212
213 @_polymorphic
214 def __mul__(self, other):
215 val1 = libisl.isl_val_copy(self)
216 val2 = libisl.isl_val_copy(other)
217 val = libisl.isl_val_mul(val1, val2)
218 return self.__class__(self.context, self._ptr(val))
219
220 __rmul__ = __mul__
221
222 @_polymorphic
223 def __truediv__(self, other):
224 val1 = libisl.isl_val_copy(self)
225 val2 = libisl.isl_val_copy(other)
226 val = libisl.isl_val_div(val1, val2)
227 return self.__class__(self.context, self._ptr(val))
228
229 __rtruediv__ = __truediv__
230
231 def __float__(self):
232 if libisl.isl_val_is_rat(self):
233 return self.numerator / self.denominator
234 elif libisl.isl_val_is_infty(self):
235 return float('inf')
236 elif libisl.isl_val_is_neginfty(self):
237 return float('-inf')
238 else:
239 assert libisl.isl_val_is_nan(self)
240 return float('nan')
241
242 def is_finite(self):
243 return bool(libisl.isl_val_is_rat(self))
244
245 def is_infinite(self):
246 return bool(libisl.isl_val_is_infty(self) or
247 libisl.isl_val_is_neginfty(self))
248
249 def is_nan(self):
250 return bool(libisl.isl_val_is_nan(self))
251
252 def __str__(self):
253 if libisl.isl_val_is_rat(self):
254 if self.denominator == 1:
255 return '{}'.format(self.numerator)
256 else:
257 return '{}/{}'.format(self.numerator, self.denominator)
258 elif libisl.isl_val_is_infty(self):
259 return 'Infinity'
260 elif libisl.isl_val_is_neginfty(self):
261 return '-Infinity'
262 else:
263 assert libisl.isl_val_is_nan(self)
264 return 'NaN'
265
266 def __repr__(self):
267 return '{}({!r})'.format(self.__class__.__name__, str(self))