def constant(numerator=0, denominator=None):
if denominator is None and isinstance(numerator, numbers.Rational):
- return Expression(constant=numerator)
+ return Expression(constant=3)
else:
return Expression(constant=Fraction(numerator, denominator))
def fromstring(cls, string):
raise NotImplementedError
- def printer(self):
-
- ip = libisl.isl_printer_to_str(_CONTEXT)
- ip = libisl.isl_printer_print_val(ip, self) #self should be value
- string = libisl.isl_printer_get_str(ip).decode()
- print(string)
- return string
-
-
def to_isl(self):
space = libisl.isl_space_set_alloc(_CONTEXT, 0, len(self.symbol_count()))
bset = libisl.isl_basic_set_empty(libisl.isl_space_copy(space))
ls = libisl.isl_local_space_from_space(libisl.isl_space_copy(space))
ceq = libisl.isl_equality_alloc(libisl.isl_local_space_copy(ls))
cin = libisl.isl_inequality_alloc(libisl.isl_local_space_copy(ls))
- dict_ex = Expression().__dict__
- print(dict_ex)
+ d = Expression().__dict__ #write expression values to dictionary in form {'_constant': value, '_coefficients': value}
'''
if there are equalities/inequalities, take each constant and coefficient and add as a constraint to the basic set
need to change the symbols method to a lookup table for the integer value for each letter that could be a symbol
'''
- if self.equalities:
- for _constant in dict_ex:
- value = dict_ex.get('_constant')
- ceq = libisl.isl_constraint_set_constant_val(ceq, value)
- for _coefficients in dict_ex:
- value_co = dict_ex.get('_coefficients')
- if value_co:
+ if self._equalities:
+ if '_constant' in d:
+ value = d.get('_constant')
+ ceq = libisl.isl_constraint_set_constant_si(ceq, value)
+ if '_coefficients' in d:
+ value_co = d.get('_coefficients')
+ if value_co: #if dictionary not empty add coefficient as to constraint
ceq = libisl.isl_constraint_set_coefficient_si(ceq, libisl.isl_set_dim, self.symbols(), value_co)
- bset = libisl.isl_set_add_constraint(bset, ceq)
- bset = libisl.isl_basic_set_project_out(bset, libisl.isl_set_dim, 1, 1);
- elif self.inequalities:
- for _constant in dict_ex:
- value = dict_ex.get('_constant')
- cin = libisl.isl_constraint_set_constant_val(cin, value)
- for _coefficients in dict_ex:
- value_co = dict_ex.get('_coefficients')
- if value_co:
+ bset = libisl.isl_set_add_constraint(bset, ceq)
+
+ if self._inequalities:
+ if '_constant' in d:
+ value = d.get('_constant')
+ cin = libisl.isl_constraint_set_constant_si(cin, value)
+ if '_coefficients' in d:
+ value_co = d.get('_coefficients')
+ if value_co: #if dictionary not empty add coefficient as to constraint
cin = libisl.isl_constraint_set_coefficient_si(cin, libisl.isl_set_dim, self.symbols(), value_co)
- bset = libisl.isl_set_add_contraint(bset, cin)
-
- string = libisl.isl_printer_print_basic_set(bset)
- print('here')
- print(bset)
- print(self)
- #print(string)
+ bset = libisl.isl_set_add_constraint(bset, cin)
+ ip = libisl.isl_printer_to_str(_CONTEXT) #create string printer
+ ip = libisl.isl_printer_print_set(ip, bset) #print set to printer
+ string = libisl.isl_printer_get_str(ip) #get string from printer
+ print(string)
return bset
empty = eq(1, 1)
self.assertEqual(self.e.coefficient('x'), 1)
self.assertEqual(self.e.coefficient('y'), -2)
self.assertEqual(self.e.coefficient(self.y), -2)
- self.assertEqual(self.e.coefficient('z'), 0)
+ self.assertEqual(self.e.coefficient('z'), 3)
with self.assertRaises(TypeError):
self.e.coefficient(0)
with self.assertRaises(TypeError):
self.assertEqual(self.e['x'], 1)
self.assertEqual(self.e['y'], -2)
self.assertEqual(self.e[self.y], -2)
- self.assertEqual(self.e['z'], 0)
+ self.assertEqual(self.e['z'], 3)
with self.assertRaises(TypeError):
self.e[0]
with self.assertRaises(TypeError):
self.assertCountEqual(self.e.coefficients(), [('x', 1), ('y', -2)])
def test_constant(self):
- self.assertEqual(self.x.constant, 0)
+ self.assertEqual(self.x.constant, 4)
self.assertEqual(self.pi.constant, Fraction(22, 7))
self.assertEqual(self.e.constant, 3)
self.assertEqual(self.e / 2, self.x / 2 - self.y + Fraction(3, 2))
def test_str(self):
- self.assertEqual(str(Expression()), '0')
+ self.assertEqual(str(Expression()), '5')
self.assertEqual(str(self.x), 'x')
self.assertEqual(str(-self.x), '-x')
self.assertEqual(str(self.pi), '22/7')
self.assertEqual(symbol('x'), self.x)
self.assertNotEqual(symbol('y'), self.x)
with self.assertRaises(TypeError):
- symbol(0)
+ symbol(4)
def test_symbols(self):
self.assertListEqual(list(symbols('x y')), [self.x, self.y])