Style: apply black

mapytex/calculus/core/typing/__init__.py

@@ -12,6 +12,7 @@ Typing with MO
 
 from .exceptions import TypingError
 from .add import add
+
 # from .minus import minus
 from .multiply import multiply
 from .divide import divide
@@ -25,18 +26,18 @@ from ..MO.polynomial import MOpolynomial
 from itertools import product
 from tabulate import tabulate
 
-MOS = [ MOnumber, MOstr, MOFraction, MOstrPower, MOMonomial, MOpolynomial]
+MOS = [MOnumber, MOstr, MOFraction, MOstrPower, MOMonomial, MOpolynomial]
 
 OPERATIONS = {
-        "+": add,
-        # "-": minus, 
-        "*": multiply,
-        "/": divide,
-        "^": power,
-        }
+    "+": add,
+    # "-": minus,
+    "*": multiply,
+    "/": divide,
+    "^": power,
+}
 
-def typing(node, left_v, right_v,\
-           raiseTypingError = True):
+
+def typing(node, left_v, right_v, raiseTypingError=True):
     """
     Typing a try base on his root node
 
@@ -47,6 +48,7 @@ def typing(node, left_v, right_v,\
         raise NotImplementedError(f"Unknown operation ({node}) in typing")
     return operation(left_v, right_v)
 
+
 def typing_capacities(node):
     """ Test an operation through all MOs
 
@@ -59,21 +61,19 @@ def typing_capacities(node):
 
     """
     op = OPERATIONS[node]
-    lines =  [[node] + [mo.__name__ for mo in MOS]]
+    lines = [[node] + [mo.__name__ for mo in MOS]]
     for left_mo in MOS:
-       lines.append(
-           [left_mo.__name__] + \
-           [(left_mo, i) in op.funcs for i in MOS]
-       )
+        lines.append([left_mo.__name__] + [(left_mo, i) in op.funcs for i in MOS])
     return lines
 
+
 def describe_typing():
     """ Explain which operations are handle by typing """
 
     ans = "Implemented typing operations among MOs\n"
     for op in OPERATIONS:
         ans += "\n"
-        ans += tabulate(typing_capacities(op), tablefmt='grid')
+        ans += tabulate(typing_capacities(op), tablefmt="grid")
 
     return ans
 

mapytex/calculus/core/typing/add.py

@@ -27,6 +27,7 @@ add_doc = """ Add MOs
 
 add = Dispatcher("add", doc=add_doc)
 
+
 @add.register((MOnumber, MOFraction), MOstr)
 def moscalar_mostr(left, right):
     """ add a scalar with a letter to create a MOpolynomial
@@ -41,6 +42,7 @@ def moscalar_mostr(left, right):
     """
     return MOpolynomial(right, [left, 1])
 
+
 @add.register(MOstr, (MOnumber, MOFraction))
 def mostr_moscalar(left, right):
     """ add a scalar with a letter to create a MOpolynomial
@@ -55,6 +57,7 @@ def mostr_moscalar(left, right):
     """
     return MOpolynomial(left, [right, 1])
 
+
 @add.register((MOnumber, MOFraction), MOstrPower)
 def moscalar_mostrpower(left, right):
     """ add a scalar with a letter to create a MOpolynomial
@@ -69,6 +72,7 @@ def moscalar_mostrpower(left, right):
     """
     return MOpolynomial(right.variable, {0: left, right.power: 1})
 
+
 @add.register(MOstrPower, (MOnumber, MOFraction))
 def mostrpower_moscalar(left, right):
     """ add a scalar with a letter to create a MOpolynomial
@@ -83,6 +87,7 @@ def mostrpower_moscalar(left, right):
     """
     return MOpolynomial(left.variable, {0: right, left.power: 1})
 
+
 @add.register((MOnumber, MOFraction), MOMonomial)
 def moscalar_momonomial(left, right):
     """ add a scalar with a MOMonomial to create a MOpolynomial
@@ -95,9 +100,8 @@ def moscalar_momonomial(left, right):
     >>> add(a, b)
     <MOpolynomial 1 / 5 + 3x^4>
     """
-    return MOpolynomial(right.variable, 
-                        {right.power: right.coefficient, 0: left}
-                        )
+    return MOpolynomial(right.variable, {right.power: right.coefficient, 0: left})
+
 
 @add.register(MOMonomial, (MOnumber, MOFraction))
 def momonial_moscalar(left, right):
@@ -112,9 +116,8 @@ def momonial_moscalar(left, right):
     <MOpolynomial 3x^4 + 1 / 5>
 
     """
-    return MOpolynomial(left.variable,
-                        {0: right, left.power: left.coefficient}
-                        )
+    return MOpolynomial(left.variable, {0: right, left.power: left.coefficient})
+
 
 @add.register((MOnumber, MOFraction), MOpolynomial)
 def moscalar_mopolynomial(left, right):
@@ -129,13 +132,16 @@ def moscalar_mopolynomial(left, right):
     <MOpolynomial 1 / 5 + 3x^2 + 2x>
     """
     if 0 in right.coefficients.keys():
-        raise NotImplementedError(f"Polynomial with constant ({right.coefficients[0]}), calculus to do")
+        raise NotImplementedError(
+            f"Polynomial with constant ({right.coefficients[0]}), calculus to do"
+        )
 
     new_coefs = {**right.coefficients}
     #! Need to be add at the end to be printed at the beginning
     new_coefs[0] = left
     return MOpolynomial(right.variable, new_coefs)
 
+
 @add.register(MOpolynomial, (MOnumber, MOFraction))
 def mopolynomial_moscalar(left, right):
     """ add a scalar with a MOpolynomial to create a MOpolynomial
@@ -156,6 +162,7 @@ def mopolynomial_moscalar(left, right):
     new_coefs = {**new_coefs, **left.coefficients}
     return MOpolynomial(left.variable, new_coefs)
 
+
 @add.register(MOstr, MOstr)
 def mostr_mostr(left, right):
     """ add 2 mostr
@@ -167,7 +174,8 @@ def mostr_mostr(left, right):
     """
     if left != right:
         raise NotImplementedError("Can't add 2 Mostr without same letter")
-    return MOMonomial(2, left) 
+    return MOMonomial(2, left)
+
 
 @add.register(MOstr, MOstrPower)
 def mostr_mostrpower(left, right):
@@ -182,8 +190,9 @@ def mostr_mostrpower(left, right):
     <MOpolynomial x^2 + x>
     """
     if left != right.variable:
-        raise 
-    return MOpolynomial(left , {1: 1, right.power: 1})
+        raise
+    return MOpolynomial(left, {1: 1, right.power: 1})
+
 
 @add.register(MOstrPower, MOstr)
 def mostrpower_mostr(left, right):
@@ -198,8 +207,9 @@ def mostrpower_mostr(left, right):
     <MOpolynomial x^2 + x>
     """
     if right != left.variable:
-        raise 
-    return MOpolynomial(right , {1: 1, left.power: 1})
+        raise
+    return MOpolynomial(right, {1: 1, left.power: 1})
+
 
 @add.register(MOstrPower, MOstrPower)
 def mostrpower_mostrpower(left, right):
@@ -213,9 +223,12 @@ def mostrpower_mostrpower(left, right):
     if left.variable != right.variable:
         raise NotImplementedError("Can't add 2 Mostrpower without same letter")
     if left.power != right.power:
-        raise NotImplementedError("Can't add 2 Mostrpower with compute if not same degree")
+        raise NotImplementedError(
+            "Can't add 2 Mostrpower with compute if not same degree"
+        )
+
+    return MOMonomial(2, left.variable, left.power)
 
-    return MOMonomial(2, left.variable, left.power) 
 
 @add.register(MOstr, MOpolynomial)
 def mostr_mopolynomial(left, right):
@@ -234,6 +247,7 @@ def mostr_mopolynomial(left, right):
     new_coefs[1] = 1
     return MOpolynomial(right.variable, new_coefs)
 
+
 @add.register(MOpolynomial, MOstr)
 def mopolynomial_mostr(left, right):
     """ add a str with a MOpolynomial to create a MOpolynomial
@@ -250,6 +264,7 @@ def mopolynomial_mostr(left, right):
     new_coefs = {**new_coefs, **left.coefficients}
     return MOpolynomial(left.variable, new_coefs)
 
+
 @add.register(MOstrPower, MOpolynomial)
 def mostrpower_mopolynomial(left, right):
     """ add a strPower with a MOpolynomial to create a MOpolynomial
@@ -267,6 +282,7 @@ def mostrpower_mopolynomial(left, right):
     new_coefs[left.power] = 1
     return MOpolynomial(right.variable, new_coefs)
 
+
 @add.register(MOpolynomial, MOstrPower)
 def mopolynomial_mostrpower(left, right):
     """ add a strPower with a MOpolynomial to create a MOpolynomial
@@ -283,6 +299,7 @@ def mopolynomial_mostrpower(left, right):
     new_coefs = {**new_coefs, **left.coefficients}
     return MOpolynomial(left.variable, new_coefs)
 
+
 @add.register(MOMonomial, MOpolynomial)
 def momonomial_mopolynomial(left, right):
     """ add a Monomial with a MOpolynomial to create a MOpolynomial
@@ -300,6 +317,7 @@ def momonomial_mopolynomial(left, right):
     new_coefs[left.power] = left.coefficient
     return MOpolynomial(right.variable, new_coefs)
 
+
 @add.register(MOpolynomial, MOMonomial)
 def mopolynomial_momonomial(left, right):
     """ add a Monomial with a MOpolynomial to create a MOpolynomial
@@ -316,6 +334,7 @@ def mopolynomial_momonomial(left, right):
     new_coefs = {**new_coefs, **left.coefficients}
     return MOpolynomial(left.variable, new_coefs)
 
+
 @add.register(MOpolynomial, MOpolynomial)
 def mopolynomial_mopolynomial(left, right):
     """ add a polynomial with a MOpolynomial to create a MOpolynomial
@@ -327,13 +346,14 @@ def mopolynomial_mopolynomial(left, right):
     >>> add(b, a)
     <MOpolynomial 4x^3 + 2x + 3x^2 + 1>
     """
-    common_degree = set(left.monomials.keys()).intersection(right.monomials.keys()) 
+    common_degree = set(left.monomials.keys()).intersection(right.monomials.keys())
     if common_degree:
         raise NotImplementedError("Degree in common, need to compute")
 
     new_coefs = {**right.coefficients, **left.coefficients}
     return MOpolynomial(right.variable, new_coefs)
 
+
 @add.register(MOstr, MOMonomial)
 def mostr_monomial(left, right):
     """ add a mostr with a MOMonomial to create a MOpolynomial
@@ -346,9 +366,8 @@ def mostr_monomial(left, right):
     if right.power == 1:
         raise NotImplementedError("Monomial is deg 1, need to compute")
 
-    return MOpolynomial(right.variable, 
-                        {right.power: right.coefficient, 1: 1}
-                        )
+    return MOpolynomial(right.variable, {right.power: right.coefficient, 1: 1})
+
 
 @add.register(MOMonomial, MOstr)
 def monomial_mostr(left, right):
@@ -362,9 +381,8 @@ def monomial_mostr(left, right):
     if left.power == 1:
         raise NotImplementedError("Monomial is deg 1, need to compute")
 
-    return MOpolynomial(left.variable, 
-                        {1: 1, left.power: left.coefficient}
-                        )
+    return MOpolynomial(left.variable, {1: 1, left.power: left.coefficient})
+
 
 @add.register(MOstrPower, MOMonomial)
 def mostrpower_monomial(left, right):
@@ -376,11 +394,12 @@ def mostrpower_monomial(left, right):
     <MOpolynomial x^2 + 3x^4>
     """
     if left.power == right.power:
-        raise NotImplementedError("MostrPower and MOMonomial are same degree, need to compute")
+        raise NotImplementedError(
+            "MostrPower and MOMonomial are same degree, need to compute"
+        )
+
+    return MOpolynomial(right.variable, {right.power: right.coefficient, left.power: 1})
 
-    return MOpolynomial(right.variable, 
-                        {right.power: right.coefficient, left.power: 1}
-                        )
 
 @add.register(MOMonomial, MOstrPower)
 def monomial_mostrpower(left, right):
@@ -392,11 +411,12 @@ def monomial_mostrpower(left, right):
     <MOpolynomial 3x^4 + x^3>
     """
     if left.power == right.power:
-        raise NotImplementedError("MostrPower and MOMonomial are same degree, need to compute")
+        raise NotImplementedError(
+            "MostrPower and MOMonomial are same degree, need to compute"
+        )
+
+    return MOpolynomial(left.variable, {right.power: 1, left.power: left.coefficient})
 
-    return MOpolynomial(left.variable, 
-                        {right.power: 1, left.power: left.coefficient}
-                        )
 
 @add.register(MOMonomial, MOMonomial)
 def monomial_momonomial(left, right):
@@ -410,9 +430,9 @@ def monomial_momonomial(left, right):
     if left.power == right.power:
         raise NotImplementedError("MOMonomials are same degree, need to compute")
 
-    return MOpolynomial(left.variable, 
-                        {right.power: right.coefficient, left.power: left.coefficient}
-                        )
+    return MOpolynomial(
+        left.variable, {right.power: right.coefficient, left.power: left.coefficient}
+    )
 
 
 # -----------------------------

mapytex/calculus/core/typing/divide.py

@@ -24,6 +24,7 @@ divide_doc = """ Typing trees a divide root
 
 divide = Dispatcher("divide", doc=divide_doc)
 
+
 @divide.register(MOnumber, MOnumber)
 def monumber_monumber(left, right):
     """ A divide tree with 2 MOnumbers is a MOFraction

mapytex/calculus/core/typing/exceptions.py

@@ -10,9 +10,11 @@
 Exceptions for typing trees 
 """
 
+
 class TypingError(Exception):
     pass
 
+
 # -----------------------------
 # Reglages pour 'vim'
 # vim:set autoindent expandtab tabstop=4 shiftwidth=4:

mapytex/calculus/core/typing/multiply.py

@@ -26,6 +26,7 @@ multiply_doc = """ Multiply MOs
 
 multiply = Dispatcher("multiply", doc=multiply_doc)
 
+
 @multiply.register((MOnumber, MOFraction), MOstr)
 def moscalar_mostr(left, right):
     """ Multiply a scalar with a letter to create a MOMonomial
@@ -40,6 +41,7 @@ def moscalar_mostr(left, right):
     """
     return MOMonomial(left, right)
 
+
 @multiply.register(MOstr, (MOnumber, MOFraction))
 def mostr_moscalar(left, right):
     """ Multiply a scalar with a letter to create a MOMonomial
@@ -54,6 +56,7 @@ def mostr_moscalar(left, right):
     """
     return MOMonomial(right, left)
 
+
 @multiply.register((MOnumber, MOFraction), MOstrPower)
 def moscalar_mostrpower(left, right):
     """ Multiply a scalar with a MOstrPower
@@ -66,6 +69,7 @@ def moscalar_mostrpower(left, right):
     """
     return MOMonomial(left, right)
 
+
 @multiply.register(MOstrPower, (MOnumber, MOFraction))
 def mostrpower_moscalar(left, right):
     """ Multiply a MOstrPower with a scalar
@@ -78,6 +82,7 @@ def mostrpower_moscalar(left, right):
     """
     return MOMonomial(right, left)
 
+
 # -----------------------------
 # Reglages pour 'vim'
 # vim:set autoindent expandtab tabstop=4 shiftwidth=4:

mapytex/calculus/core/typing/power.py

@@ -25,6 +25,7 @@ power_doc = """ Typing Power of MOs
 
 power = Dispatcher("power", doc=power_doc)
 
+
 @power.register(MOstr, MOnumber)
 def mostr_monumber(left, right):
     """ Create MOstrPower over powered MOstr
@@ -38,7 +39,6 @@ def mostr_monumber(left, right):
     return MOstrPower(left, right)
 
 
-
 # -----------------------------
 # Reglages pour 'vim'
 # vim:set autoindent expandtab tabstop=4 shiftwidth=4: