snappy 3.0.3__cp38-cp38-macosx_11_0_arm64.whl → 3.2__cp38-cp38-macosx_11_0_arm64.whl

snappy/ptolemy/numericalSolutionsToGroebnerBasis.py

@@ -1,8 +1,8 @@
-from __future__ import print_function
 from .polynomial import Polynomial
 from .component import NonZeroDimensionalComponent
 from ..pari import pari
 
+
 def numerical_solutions_with_one(polys):
 
     solutions = numerical_solutions(polys)
@@ -13,8 +13,9 @@ def numerical_solutions_with_one(polys):
 
     return solutions
 
+
 class PariPolynomialAndVariables:
-    def __init__(self, polynomial, variables = None):
+    def __init__(self, polynomial, variables=None):
 
         if isinstance(polynomial, Polynomial):
 
@@ -32,21 +33,21 @@ class PariPolynomialAndVariables:
     def substitute(self, var, value):
 
         return PariPolynomialAndVariables(
-            polynomial = self.pari_polynomial.substpol(var, value),
-            variables = [ v for v in self.variables if not v == var ])
-
+            polynomial=self.pari_polynomial.substpol(var, value),
+            variables=[ v for v in self.variables if not v == var ])
 
     def get_roots(self):
         return self.pari_polynomial.polroots(
-            precision = 3.4 * pari.get_real_precision())
+            precision=3.4 * pari.get_real_precision())
+
 
 def numerical_solutions(polys):
 
     # Divide out lowest power variables
-    polysReduced = [ poly.factor_out_variables() for poly in polys ] 
+    polysReduced = [ poly.factor_out_variables() for poly in polys ]
 
     # Filter out 0
-    polysFiltered = [ poly 
+    polysFiltered = [ poly
                       for poly in polysReduced
                       if (not poly.is_constant()) or poly.get_constant() == 0 ]
 
@@ -58,26 +59,29 @@ def numerical_solutions(polys):
 
     polysAndVars = [
         PariPolynomialAndVariables(poly) for poly in polysFiltered ]
-        
+
     solutions = _numerical_solutions_recursion(polysAndVars, { })
 
     number_variables = (
         len(
             set(sum(
                 [poly.variables() for poly in polys],[ ]))))
-    
+
     return [
-        solution if len(solution) == number_variables 
+        solution if len(solution) == number_variables
         else NonZeroDimensionalComponent()
         for solution in solutions]
 
+
 def _get_first(l):
     if l:
         return l[0]
     return None
 
+
 def _remove(l, element):
-    return [x for x in l if not x is element]
+    return [x for x in l if x is not element]
+
 
 def _numerical_solutions_recursion(polysAndVars, solutionDict):
 
@@ -88,10 +92,10 @@ def _numerical_solutions_recursion(polysAndVars, solutionDict):
                                   for poly in polysAndVars
                                   if poly.get_variable_if_univariate() ])
 
-    if not univariatePoly is None:
+    if univariatePoly is not None:
         variable = univariatePoly.get_variable_if_univariate()
         variableDicts = [ ]
-        
+
         for solution in univariatePoly.get_roots():
 
             newSolutionDict = solutionDict.copy()

snappy/ptolemy/polynomial.py

@@ -1,28 +1,23 @@
-from __future__ import print_function
-
 import re
 import operator
 from fractions import Fraction
-import sys
-if sys.version > '3':
-    long = int
-    unicode = str
 
 #######################################################
-### Public Definitions of Monomial and Polynomial class
+# Public Definitions of Monomial and Polynomial class
 
-# The coefficients of a polynomial can be any type, the 
-# policy for mixed coefficients is defined in 
+# The coefficients of a polynomial can be any type, the
+# policy for mixed coefficients is defined in
 # _storage_type_policy and _operator_type_policy.
 
-### Definition of Monomial Class
+# Definition of Monomial Class
+
 
-class Monomial(object):
+class Monomial():
 
     @classmethod
     def from_variable_name(cls, var):
         """Construct a monomial with a single variable given as a string."""
-        assert isinstance(var, str) or isinstance(var, unicode)
+        assert isinstance(var, str)
         return Monomial(1, ((var, 1),))
 
     # Constructs a constant monomial
@@ -48,7 +43,7 @@ class Monomial(object):
         else:
             assert isinstance(vars, tuple)
             for var, expo in vars:
-                assert isinstance(var, str) or isinstance(var, unicode)
+                assert isinstance(var, str)
                 assert isinstance(expo, int)
                 assert expo > 0
             self._vars = vars
@@ -71,15 +66,17 @@ class Monomial(object):
         e.g., "+ 3 * x".
         """
 
-        v = [     var if expo == 1 
-             else "%s^%s" % (var, expo) 
+        v = [var if expo == 1
+             else "%s^%s" % (var, expo)
              for var, expo in self._vars]
 
         coefficient_sign, coefficient_str = (
             print_coefficient_method(self._coefficient))
 
-        if coefficient_str: v = [coefficient_str] + v
-        if not v: v = [ "1" ]
+        if coefficient_str:
+            v = [coefficient_str] + v
+        if not v:
+            v = ["1"]
 
         sign_less_str = " * ".join(v)
 
@@ -87,9 +84,9 @@ class Monomial(object):
             return coefficient_sign + " " + sign_less_str
 
         return sign_less_str
-        
+
     def get_coefficient(self):
-        """Return the coefficient.""" 
+        """Return the coefficient."""
         return self._coefficient
 
     def coefficient_type(self):
@@ -106,7 +103,7 @@ class Monomial(object):
         """Return a list containing the variable names."""
         return [var[0] for var in self._vars if var[1] > 0]
 
-    def degree(self, var = None):
+    def degree(self, var=None):
         """Return the total degree of this monomial."""
         return sum([this_degree
                     for this_var, this_degree in self._vars
@@ -123,24 +120,24 @@ class Monomial(object):
 
         # Compute the variables
         var_dict = _combine_dicts(
-            [dict(self._vars),dict(other._vars)],
+            [dict(self._vars), dict(other._vars)],
             operator.add)
 
         return Monomial(coefficient, var_dict)
 
     def __pow__(self, other):
-        
+
         assert isinstance(other, int)
         assert other >= 0
-        
+
         if other == 0:
             return Monomial.constant_monomial(1)
         if other == 1:
             return self
-        if other % 2 == 1:
-            return self * (self ** (other-1))
-        return (self * self) ** (other//2)
-        
+        if other % 2:
+            return self * (self ** (other - 1))
+        return (self * self) ** (other // 2)
+
     def __neg__(self):
         """Negate this monomial."""
         return Monomial(-self._coefficient, self._vars)
@@ -165,7 +162,7 @@ class Monomial(object):
 
     def split_variable(self, variable):
         """Split the specified variable from the others."""
-        remaining_terms = { }
+        remaining_terms = {}
         exponent = 0
         for var, expo in self._vars:
             if var == variable:
@@ -180,13 +177,13 @@ class Monomial(object):
 
         vars = [(var, expo - d[var]) for var, expo in self._vars]
         vars = tuple([(var, expo) for var, expo in vars if expo > 0])
-        
+
         return Monomial(self.get_coefficient(), vars)
 
 
-### Definition of Polynomial class
+# Definition of Polynomial class
 
-class Polynomial(object):
+class Polynomial():
 
     """
     >>> m1 = Monomial(1, (('t', 1), ('x', 1), ('y', 1)))
@@ -257,16 +254,16 @@ class Polynomial(object):
     @classmethod
     def constant_polynomial(cls, constant):
         """Construct a constant polynomial."""
-        return Polynomial( (Monomial.constant_monomial(constant),))
+        return Polynomial((Monomial.constant_monomial(constant),))
 
     @classmethod
     def from_variable_name(cls, var):
         """Construct a polynomial consisting of a single variable."""
-        return Polynomial( (Monomial.from_variable_name(var),))
+        return Polynomial((Monomial.from_variable_name(var),))
 
-    ### constructor takes a tuple of polynomials which are combined
+    # constructor takes a tuple of polynomials which are combined
 
-    def __init__(self, monomials = ()):
+    def __init__(self, monomials=()):
 
         # combine monomials with the same variables and exponents
         # and bring them into canonical order
@@ -278,7 +275,7 @@ class Polynomial(object):
         # and value being the coefficient
 
         list_of_vars_coeff_dicts = [
-            { monomial.get_vars() : monomial.get_coefficient() }
+            {monomial.get_vars(): monomial.get_coefficient()}
             for monomial in monomials]
 
         # combine the dictionaries using sum
@@ -319,28 +316,28 @@ class Polynomial(object):
         if isinstance(other, Polynomial):
             assert other.is_constant()
             other = other.get_constant()
-        
+
         assert isinstance(other, int)
         assert other >= 0
         if other == 0:
             return Polynomial((Monomial.constant_monomial(1),))
         if other == 1:
             return self
-        if other % 2 == 1:
-            return self * (self ** (other-1))
-        return (self * self) ** (other//2)
+        if other % 2:
+            return self * (self ** (other - 1))
+        return (self * self) ** (other // 2)
 
     def __mul__(self, other):
         monomials = []
-        
+
         for m in self._monomials:
             for n in other._monomials:
                 monomials.append(m * n)
-                
+
         return Polynomial(tuple(monomials))
 
     def __mod__(self, other):
-        
+
         assert isinstance(other, Polynomial)
         assert self.is_univariate()
         assert other.is_univariate()
@@ -351,10 +348,10 @@ class Polynomial(object):
 
         other = other.convert_coefficients(Fraction)
         other = other * Polynomial.constant_polynomial(
-            Fraction(1,1) / other.leading_coefficient())
+            Fraction(1, 1) / other.leading_coefficient())
 
         variable = other.variables()[0]
-        assert ((not other.variables()) 
+        assert ((not other.variables())
                 or other.variables()[0] == variable)
 
         rest = self
@@ -381,7 +378,7 @@ class Polynomial(object):
 
     def to_string(self, print_coefficient_method):
         s = " ".join([monomial.to_string(print_coefficient_method,
-                                         force_print_sign = True)
+                                         force_print_sign=True)
                       for monomial in self._monomials])
         if s and s[0] == '+':
             return s[1:].lstrip()
@@ -391,15 +388,14 @@ class Polynomial(object):
         """Convert all coefficients using conversion_function."""
 
         return Polynomial(tuple(
-                [monomial.convert_coefficient(conversion_function)
-                 for monomial in self._monomials]))
-    
+            [monomial.convert_coefficient(conversion_function)
+             for monomial in self._monomials]))
+
     def substitute(self, d):
-        """ 
+        """
         Take a dictionary mapping variable name -> polynomial and
         replace each variable by the corresponding polynomial.
         """
-
         variables = self.variables()
 
         skip_computation = True
@@ -410,18 +406,18 @@ class Polynomial(object):
 
         if skip_computation:
             return self
-        
+
         def substitute_monomial(monomial):
             vars = monomial.get_vars()
             new_vars = []
 
             for var, expo in vars:
                 if var not in d:
-                    new_vars.append((var,expo))
+                    new_vars.append((var, expo))
 
             poly = Polynomial((
-                    Monomial(monomial.get_coefficient(),
-                             tuple(new_vars)),))
+                Monomial(monomial.get_coefficient(),
+                         tuple(new_vars)),))
 
             for var, expo in vars:
                 if var in d:
@@ -430,8 +426,8 @@ class Polynomial(object):
             return poly
 
         return sum([substitute_monomial(monomial)
-                     for monomial in self._monomials], Polynomial(()))
-                                    
+                    for monomial in self._monomials], Polynomial(()))
+
     def variables(self):
         """Return a list of all variables in the polynomial."""
         all_variables = [monomial.variables() for monomial in self._monomials]
@@ -478,11 +474,11 @@ class Polynomial(object):
         """Assert univariance; return True iff this polynomial is monic."""
         return self.leading_coefficient() == 1
 
-    def get_coefficients(self, conversion_function = lambda x:x):
+    def get_coefficients(self, conversion_function=lambda x: x):
         """Assert univariance; return the coefficients in degree order."""
         assert self.is_univariate()
         degree = self.degree()
-        list_of_coefficients = (degree + 1) * [ conversion_function(0) ]
+        list_of_coefficients = (degree + 1) * [conversion_function(0)]
         for monomial in self._monomials:
             list_of_coefficients[degree - monomial.degree()] = (
                 conversion_function(monomial.get_coefficient()))
@@ -532,8 +528,8 @@ class Polynomial(object):
         return self._monomials
 
     def factor_out_variables(self):
-        
-        if self._monomials == ():
+
+        if not self._monomials:
             return self
 
         def intersect(lists):
@@ -543,45 +539,47 @@ class Polynomial(object):
             return s
 
         non_trivial_variables = intersect(
-            [ monomial.variables() for monomial in self._monomials])
+            [monomial.variables() for monomial in self._monomials])
 
-        lowest_powers = dict([ (var,1000000) for var in non_trivial_variables ])
+        lowest_powers = {var: 1000000 for var in non_trivial_variables}
 
-        def safe_dict(d,var):
+        def safe_dict(d, var):
             if var in d:
                 return d[var]
-            else:
-                return 0
+            return 0
 
         for monomial in self._monomials:
             for var, expo in monomial.get_vars():
-                lowest_powers[var] = min(safe_dict(lowest_powers,var), expo)
+                lowest_powers[var] = min(safe_dict(lowest_powers, var), expo)
 
-        return Polynomial(tuple([ monomial.reduce_exponents(lowest_powers)
-                                  for monomial in self._monomials]))
+        return Polynomial(tuple([monomial.reduce_exponents(lowest_powers)
+                                 for monomial in self._monomials]))
 
 ###############################################################
-### Default functions for parsing and printing the coefficients
+# Default functions for parsing and printing the coefficients
+
+# The user will rewrite these for other types and supply to
+# the respective methods of Monomial and Polynomial.
 
-### The user will rewrite these for other types and supply to
-### the respective methods of Monomial and Polynomial.
 
 def parse_int_coefficient(s):
-    coeff, rest = re.match('([0-9]*)(.*)',s).groups()
+    coeff, rest = re.match('([0-9]*)(.*)', s).groups()
     if coeff:
         coeff = int(coeff)
     else:
         coeff = None
     return coeff, rest
 
+
 def parse_int_or_fraction(s):
-    m = re.match('([0-9]+/[0-9]+)(.*)',s)
+    m = re.match('([0-9]+/[0-9]+)(.*)', s)
     if m:
         frac, rest = m.groups()
         return Fraction(frac), rest
-    
+
     return parse_int_coefficient(s)
 
+
 def parenthesis_coefficient_method(i):
     if isinstance(i, int) or isinstance(i, Fraction):
         return default_print_coefficient_method(i)
@@ -589,6 +587,7 @@ def parenthesis_coefficient_method(i):
     else:
         return '+', '(%s)' % repr(i)
 
+
 def default_print_coefficient_method(i):
     try:
         sign = '+' if i >= 0 else '-'
@@ -597,9 +596,10 @@ def default_print_coefficient_method(i):
         else:
             print_str = str(abs(i))
         return sign, print_str
-    except:
+    except (TypeError, ValueError):
         return uncomparable_print_coefficient_method(i)
 
+
 def uncomparable_print_coefficient_method(i):
     print_str = str(i)
     if '+' in print_str or '-' in print_str:
@@ -607,19 +607,20 @@ def uncomparable_print_coefficient_method(i):
     else:
         return '+', print_str
 
+
 ##############################################################################
-### Private Definitions
+# Private Definitions
 
-### Methods defining what coefficient types can be mixed a polynomial
-### Type Mixing Policy: only int can be mixed with another type
+# Methods defining what coefficient types can be mixed a polynomial
+# Type Mixing Policy: only int can be mixed with another type
 
 def _storage_type_policy(type_a, type_b):
     assert isinstance(type_a, type)
     assert isinstance(type_b, type)
-    
-    if type_a in [int, long]:
+
+    if type_a in [int]:
         return type_b
-    if type_b in [int, long]:
+    if type_b in [int]:
         return type_a
 
     if not type_a == type_b:
@@ -629,63 +630,67 @@ def _storage_type_policy(type_a, type_b):
 
     return type_a
 
-def _operator_type_policy(obj_a, obj_b, op = operator.add):
+
+def _operator_type_policy(obj_a, obj_b, op=operator.add):
 
     try:
 
         if type(obj_a) == type(obj_b):
             return op(obj_a, obj_b)
-        if type(obj_a) in [int, long]:
+        if type(obj_a) in [int]:
             return op(type(obj_b)(obj_a), obj_b)
-        if type(obj_b) in [int, long]:
+        if type(obj_b) in [int]:
             return op(type(obj_a)(obj_b), obj_a)
 
         raise Exception
 
-    except:
+    except (TypeError, ValueError):
 
         print(obj_a, obj_b)
         print(type(obj_a), type(obj_b))
-    
-        raise Exception("In _operatore_type_policy, cannot apply operator")
 
-### Definitions of parsable operators and their precedence
+        raise Exception("In _operator_type_policy, cannot apply operator")
+
+# Definitions of parsable operators and their precedence
+
 
 _operators = {
-    '+' : operator.add,
-    '-' : operator.sub,
-    '*' : operator.mul,
-    '^' : operator.pow
-    }
+    '+': operator.add,
+    '-': operator.sub,
+    '*': operator.mul,
+    '^': operator.pow}
 
 _operator_precedence = {
-    None : 0,
-    '+' : 1,
-    '-' : 1,
-    '*' : 2,
-    '^' : 3
-    }
+    None: 0,
+    '+': 1,
+    '-': 1,
+    '*': 2,
+    '^': 3}
+
 
 def _apply_operator(op, l, r):
-    return _operators[op](l,r)
+    return _operators[op](l, r)
+
+# Helper functions for parsing
 
-### Helper functions for parsing
 
 def _coefficient_is_non_trivial(c):
 
     if isinstance(c, Polynomial):
         return c._monomials
-    
+
     return not c == 0
 
+
 def _parse_variable(s):
-    r = re.match(r'([_A-Za-z][_A-Za-z0-9]*)(.*)$',s)
+    r = re.match(r'([_A-Za-z][_A-Za-z0-9]*)(.*)$', s)
     if r:
         return r.groups()
     else:
         return None, s
 
-### Parsing function for Polynomial
+# Parsing function for Polynomial
+
 
 def _parse_polynomial_from_string(s, parse_coefficient_function):
 
@@ -697,7 +702,7 @@ def _parse_polynomial_from_string(s, parse_coefficient_function):
 
     # Has there been an operand since the opening parenthesis
     # e.g. parse things like "(+ x)"
-    no_operand_since_opening_parenthesis = [ True ] 
+    no_operand_since_opening_parenthesis = [True]
 
     def debug_print(s):
         print("=" * 75)
@@ -708,19 +713,19 @@ def _parse_polynomial_from_string(s, parse_coefficient_function):
     # pop the top operator from the stack and apply it to the
     # two top operands from the stack, repeat as long as there are preceding
     # operators left on the stack.
-    def eval_preceding_operators_on_stack(operator = None):
+    def eval_preceding_operators_on_stack(operator=None):
         while operator_stack:
             top_operator = operator_stack[-1]
-            
+
             # stop if the top operator is "("
             if top_operator == '(':
                 return
-            
+
             # or if the top operator is not preceding
             if (_operator_precedence[top_operator] <
-                _operator_precedence[operator]):
+                    _operator_precedence[operator]):
                 return
-            
+
             top_operator = operator_stack.pop()
             r = operand_stack.pop()
             l = operand_stack.pop()
@@ -735,7 +740,7 @@ def _parse_polynomial_from_string(s, parse_coefficient_function):
 
         # parse constants or variables and push them onto the operand stack
         constant, rest = parse_coefficient_function(s)
-        if not constant is None:
+        if constant is not None:
             operand_stack.append(Polynomial.constant_polynomial(constant))
             no_operand_since_opening_parenthesis[0] = False
             return rest
@@ -753,8 +758,8 @@ def _parse_polynomial_from_string(s, parse_coefficient_function):
         # onto the operand stack as to emulate parsing "(0 + 3)"
 
         next_char, rest = s[0], s[1:]
-        
-        if next_char in list(_operators.keys()):
+
+        if next_char in _operators:
             operator = next_char
             eval_preceding_operators_on_stack(operator)
             operator_stack.append(operator)
@@ -791,7 +796,7 @@ def _parse_polynomial_from_string(s, parse_coefficient_function):
         s = process_next_token(s)
 
     # finish any remaining operators on the stack
-    # debug_print(s)        
+    # debug_print(s)
     eval_preceding_operators_on_stack(None)
     # debug_print(s)
 
@@ -807,11 +812,12 @@ def _parse_polynomial_from_string(s, parse_coefficient_function):
     assert (len(operand_stack) == 1
             or (
                 len(operand_stack) == 2 and
-                operand_stack[0] == Polynomial())) 
+                operand_stack[0] == Polynomial()))
 
     return operand_stack[-1]
 
-### Other help functions to deal with the internal representation
+
+# ## Other help functions to deal with the internal representation
 
 # take a dictionary and turn it into a tuple of pairs sorted by keys
 
@@ -821,11 +827,11 @@ def _dict_to_ordered_tuple_of_pairs(d):
     ...      { 'key3':'value3', 'key1':'value1', 'key2':'value2' })
     (('key1', 'value1'), ('key2', 'value2'), ('key3', 'value3'))
     """
-
     l = list(d.items())
-    l.sort(key = lambda x:x[0])
+    l.sort(key=lambda x: x[0])
     return tuple(l)
 
+
 # given a list of dictionaries, combine values of the different
 # dictionaries having the same key using combine_function.