Feat: Init polynomial with coefficients

mapytex/__init__.py

@@ -1,7 +1,7 @@
 #!/usr/bin/env python
 # encoding: utf-8
 
-from .calculus import Expression, Integer, Decimal, random_list
+from .calculus import Expression, Integer, Decimal, random_list, render, Polynomial
 
 # Expression.set_render('tex')
 

mapytex/calculus/API/__init__.py

@@ -108,66 +108,35 @@ x^7
 (6 + 6) * x + 4x^2 + 9
 4x^2 + 12x + 9
 
->>> e = Expression.from_str("(2x+3)(-x+1)")
+>>> e = Expression.from_str("(2x-3)(-x+2)")
 >>> e_simplified = e.simplify()
 >>> e_simplified
-<Quadratic - 2x^2 - x + 3>
+<Quadratic - 2x^2 + 7x - 6>
 >>> for s in e_simplified.explain():
 ...    print(s)
-
+(2x - 3)(- x + 2)
+(2x - 3)(- x + 2)
+2x(- x) + 2x * 2 - 3(- x) - 3 * 2
+2(- 1) * x^(1 + 1) + 2 * 2 * x - 3(- 1) * x - 6
+4x + 3x - 2x^2 - 6
+(4 + 3) * x - 2x^2 - 6
+- 2x^2 + 7x - 6
 """
 
 from .expression import Expression
 from .tokens import Token
-from .tokens.number import Integer, Decimal
-
-
-def set_render(render):
-    """
-    :example:
-    >>> e = Expression.from_str("2+3*4")
-    >>> print(e)
-    2 + 3 * 4
-    >>> e = Expression.from_str("2+3/4")
-    >>> print(e)
-    2 + 3 / 4
-    >>> es = e.simplify()
-    >>> print(es)
-    11 / 4
-    >>> set_render('tex')
-    >>> Expression.RENDER
-    'tex'
-    >>> Token.RENDER
-    'tex'
-    >>> e = Expression.from_str("2+3*4")
-    >>> print(e)
-    2 + 3 \\times 4
-    >>> e = Expression.from_str("2+3/4")
-    >>> print(e)
-    2 + \\dfrac{3}{4}
-    >>> es = e.simplify()
-    >>> print(es)
-    \\dfrac{11}{4}
-    >>> set_render('txt')
-    """
-    Expression.set_render(render)
-    Token.set_render(render)
+from .tokens.polynomial import Polynomial
+from .tokens.number import Integer, Decimal, Fraction
+from .renders import render
 
 
 if __name__ == "__main__":
-    e = Expression.from_str("1+2/3/4/5")
-    et = e._typing()
-    print("typing")
-    print(e._tree)
-    e = et._order()
-    print("order")
-    print(e._tree)
-    e = e._optimize()
-    print("then optimize")
-    print(e._tree)
-    e = et._optimize()
-    print("optimize without order")
-    print(e._tree)
+    e = Expression.from_str("(2x-3)(-x+2)")
+    e_simplified = e.simplify()
+    e_simplified
+    for s in e_simplified.explain():
+        print(s._tree.map_on_leaf(lambda x: type(x)))
+        print(s)
 
 # -----------------------------
 # Reglages pour 'vim'

mapytex/calculus/API/expression.py

@@ -21,7 +21,7 @@ from ..core.random import (
 )
 from ..core.MO import moify
 from .tokens import factory
-from .renders import renders
+from .renders import render
 
 
 class Expression(object):
@@ -42,7 +42,6 @@ class Expression(object):
     14
     """
 
-    RENDER = "txt"
 
     def __init__(self, tree, ancestor=None):
         """
@@ -50,15 +49,6 @@ class Expression(object):
         self._tree = tree
         self._ancestor = ancestor
 
-    @classmethod
-    def set_render(cls, render):
-        """ Define default render function 
-
-        :param render: render name (txt or tex)
-
-        """
-        cls.RENDER = render
-
     @classmethod
     def from_str(cls, string, typing=True):
         """ Initiate the expression from a string
@@ -148,10 +138,10 @@ class Expression(object):
             return cls(t)
 
     def __str__(self):
-        return renders[self.RENDER](self._tree)
+        return render(self._tree)
 
     def __repr__(self):
-        return f"<Exp: {renders['txt'](self._tree)}>"
+        return f"<Exp: {render(self._tree, 'txt')}>"
 
     def _order(self, exclude_nodes=["*", "/", "**"]):
         """ Order the expression base on types

mapytex/calculus/API/renders.py

@@ -12,34 +12,55 @@ Expression
 """
 from ..core import tree2txt, tree2tex
 
+class Render(object):
+    """ Object which render Expression or token """
 
-def _txt(mo_tree):
-    """ txt render for MOs or Trees"""
+    def __init__(self, default="txt"):
+        self._default = default
+        self._render = default
+        self.renders = {}
+
+    def register_render(self, name, func, attribute):
+        """ register a render """
         try:
-        return tree2txt(mo_tree)
+            self.renders[name]
+        except KeyError:
+            self.renders[name] = {"name": name, "func": func, "attribute": attribute}
+        else:
+            raise ValueError("This render name already exists")
+
+    @property
+    def render(self):
+        return self.renders[self._render]
+
+    def __call__(self, mo_tree, tmp_render=''):
+        if tmp_render:
+            r = self.renders[tmp_render]
+        else:
+            r = self.render
+
+        try:
+            return r["func"](mo_tree)
         except ValueError:
             pass
 
         try:
-        return mo_tree.__txt__
+            return getattr(mo_tree, r["attribute"])
         except AttributeError:
             return str(mo_tree)
 
-
-def _tex(mo_tree):
-    """ Tex render for MOs or Trees"""
-    try:
-        return tree2tex(mo_tree)
-    except ValueError:
-        pass
-
-    try:
-        return mo_tree.__tex__
-    except AttributeError:
-        return str(mo_tree)
+    def set_render(self, render):
+        """ Define the render """
+        if render in self.renders.keys():
+            self._render = render
+        else:
+            raise ValueError("This render does not exists")
 
 
-renders = {"txt": _txt, "tex": _tex}
+
+render = Render()
+render.register_render("txt", tree2txt, "__txt__")
+render.register_render("tex", tree2tex, "__tex__")
 
 # -----------------------------
 # Reglages pour 'vim'

mapytex/calculus/API/tokens/number.py

@@ -18,7 +18,7 @@ from ...core.MO import MO, MOnumber
 from ...core.MO.fraction import MOFraction
 from random import random
 
-__all__ = ["Integer", "Decimal"]
+__all__ = ["Integer", "Decimal", "Fraction"]
 
 
 class Integer(Token):
@@ -237,11 +237,25 @@ class Fraction(Token):
 
     @property
     def numerator(self):
-        return self._mo.numerator
+        """ Get numerator of the fraction
+
+        :example:
+        >>> a = Fraction("3/4")
+        >>> a.numerator
+        <Integer 3>
+        """
+        return Integer(self._mo.numerator)
 
     @property
     def denominator(self):
-        return self._mo.denominator
+        """ Get denominator of the fraction
+
+        :example:
+        >>> a = Fraction("3/4")
+        >>> a.denominator
+        <Integer 4>
+        """
+        return Integer(self._mo.denominator)
 
     @property
     def decimal(self):

mapytex/calculus/API/tokens/polynomial.py

@@ -15,6 +15,7 @@ from .token import Token
 from . import to_be_token
 from ...core.MO import MO
 from ...core.MO.atoms import moify
+from ...core.MO.polynomial import MOpolynomial
 
 __all__ = ["Polynomial", "Quadratic", "Linear"]
 
@@ -44,9 +45,21 @@ class Polynomial(Token):
         return cls(mo, name, ancestor)
 
     @classmethod
-    def from_coefficients(cls, coefficients):
-        """ Initiate polynomial from list of coefficients """
-        pass
+    def from_coefficients(cls, coefficients, variable_name="x", name=""):
+        """ Initiate polynomial from list of coefficients 
+
+        :examples:
+        >>> P = Polynomial.from_coefficients([1, 2, 3])
+        >>> P
+        <Polynomial 3x^2 + 2x + 1>
+        >>> P = Polynomial.from_coefficients([1, 2, -3])
+        >>> P
+        <Polynomial - 3x^2 + 2x + 1>
+        >>> P = Polynomial.from_coefficients([1, 2, 3], "y")
+        >>> P
+        <Polynomial 3y^2 + 2y + 1>
+        """
+        return cls(MOpolynomial(variable_name, coefficients), name)
 
     @classmethod
     def random(cls):

mapytex/calculus/API/tokens/token.py

@@ -10,7 +10,7 @@
 Tokens: practical envelop of math object
 
 """
-from ..renders import renders
+from ..renders import render
 from ...core.MO.atoms import moify
 
 
@@ -18,8 +18,6 @@ class Token(object):
 
     """ Token: practical envelop of an math object """
 
-    RENDER = "txt"
-
     def __init__(self, mo, name="", ancestor=None):
         self._mo = mo
         self.name = name
@@ -34,14 +32,6 @@ class Token(object):
     ):
         raise NotImplemented
 
-    @classmethod
-    def set_render(cls, render):
-        """ Define default render function
-
-        :param render: render name (txt or tex)
-        """
-        cls.RENDER = render
-
     def explain(self):
         """ Yield every calculus step which have lead to self
 
@@ -64,10 +54,10 @@ class Token(object):
             yield self
 
     def __repr__(self):
-        return f"<{self.__class__.__name__} {renders['txt'](self._mo)}>"
+        return f"<{self.__class__.__name__} {render(self._mo, 'txt')}>"
 
     def __str__(self):
-        return renders[self.RENDER](self._mo)
+        return render(self._mo)
 
     @property
     def raw(self):

mapytex/calculus/__init__.py

@@ -13,7 +13,7 @@ Make calculus as a student
 Expression is the classe wich handle all calculus. It can randomly generate or import calculus, simplify them and explain them as a student would do.
 
 >>> from mapytex.calculus import Expression
->>> Expression.set_render("txt")
+>>> render.set_render("txt")
 >>> e = Expression.from_str("2x + 6 - 3x")
 >>> print(e)
 2x + 6 - 3x
@@ -30,7 +30,7 @@ Expression is the classe wich handle all calculus. It can randomly generate or i
 
 """
 
-from .API import Expression, Integer, Decimal
+from .API import Expression, Integer, Decimal, render, Polynomial
 from .core import random_list
 from decimal import getcontext
 #getcontext().prec = 2

mapytex/calculus/core/renders/tree2tex.py

@@ -91,9 +91,11 @@ def mul2tex(left, right):
     '- 3x'
     >>> mul2tex(a, a)
     'x \\times x'
+    >>> mul2tex(a, MO.factory(-3))
+    'x(- 3)'
     """
     left_ = render_with_parenthesis(left, "*")
-    right_ = render_with_parenthesis(right, "*")
+    right_ = render_with_parenthesis(right, "*", is_at_right=True)
 
     display_time = True
     # if (right_[0].isalpha() and (left_.isnumeric() or left_.isdecimal())) or right_[
@@ -183,23 +185,17 @@ def pow2tex(left, right):
     return f"{left_}^{{{right_}}}"
 
 
-def render_with_parenthesis(subtree, operator):
+def render_with_parenthesis(subtree, operator, is_at_right=False):
     subtree_need_parenthesis = False
     try:
         subtree.node
     except AttributeError:
-        try:
-            if (
-                OPERATORS[subtree.MAINOP]["precedence"]
-                < OPERATORS[operator]["precedence"]
-            ):
-                subtree_need_parenthesis = True
-        except (AttributeError, KeyError):
-            pass
         try:
             subtree_ = subtree.__tex__
         except AttributeError:
             subtree_ = str(subtree)
+        if subtree_.startswith("-") and OPERATORS["-"]["precedence"] < OPERATORS[operator]["precedence"] and is_at_right:
+            subtree_need_parenthesis = True
     else:
         if OPERATORS[subtree.node]["precedence"] < OPERATORS[operator]["precedence"]:
             subtree_need_parenthesis = True

mapytex/calculus/core/renders/tree2txt.py

@@ -91,11 +91,13 @@ def mul2txt(left, right):
     '- 3x'
     >>> mul2txt(a, a)
     'x * x'
+    >>> mul2txt(a, MO.factory(-3))
+    'x(- 3)'
     """
     display_time = True
 
     left_ = render_with_parenthesis(left, "*")
-    right_ = render_with_parenthesis(right, "*")
+    right_ = render_with_parenthesis(right, "*", is_at_right=True)
 
     if right_[0].isalpha():
         # TODO: C'est bien beurk en dessous... |ven. déc. 21 12:03:07 CET 2018
@@ -187,23 +189,22 @@ def pow2txt(left, right):
     return f"{left_}^{right_}"
 
 
-def render_with_parenthesis(subtree, operator):
+def tree_with_parenthesis(subtree, operator):
+    """ Assuming the subtree is a tree, then have .node """
+    pass
+
+
+def render_with_parenthesis(subtree, operator, is_at_right=False):
     subtree_need_parenthesis = False
     try:
         subtree.node
     except AttributeError:
-        try:
-            if (
-                OPERATORS[subtree.MAINOP]["precedence"]
-                < OPERATORS[operator]["precedence"]
-            ):
-                subtree_need_parenthesis = True
-        except (AttributeError, KeyError):
-            pass
         try:
             subtree_ = subtree.__txt__
         except AttributeError:
             subtree_ = str(subtree)
+        if subtree_.startswith("-") and OPERATORS["-"]["precedence"] < OPERATORS[operator]["precedence"] and is_at_right:
+            subtree_need_parenthesis = True
     else:
         if OPERATORS[subtree.node]["precedence"] < OPERATORS[operator]["precedence"]:
             subtree_need_parenthesis = True