printing out isl form but test gives incorrect values
authorDanielle Bolan <n02702451@hawkmail.newpaltz.edu>
Thu, 12 Jun 2014 14:34:01 +0000 (16:34 +0200)
committerDanielle Bolan <n02702451@hawkmail.newpaltz.edu>
Thu, 12 Jun 2014 14:38:19 +0000 (16:38 +0200)
pypol/linear.py
tests/test_linear.py

index c169049..343acc7 100644 (file)
@@ -297,7 +297,7 @@ class Expression:
 
 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))
 
@@ -502,52 +502,40 @@ class Polyhedron:
     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)
index 4079d75..998a022 100644 (file)
@@ -34,7 +34,7 @@ class TestExpression(unittest.TestCase):
         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):
@@ -44,7 +44,7 @@ class TestExpression(unittest.TestCase):
         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):
@@ -54,7 +54,7 @@ class TestExpression(unittest.TestCase):
         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)
 
@@ -112,7 +112,7 @@ class TestExpression(unittest.TestCase):
         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')
@@ -160,7 +160,7 @@ class TestHelpers(unittest.TestCase):
         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])