Fix: fraction rendering

possible

mapytex/__init__.py

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

mapytex/calculus/API/__init__.py

@@ -108,26 +108,35 @@ x^7
 (6 + 6) * x + 4x^2 + 9
 4x^2 + 12x + 9
 
-
+>>> e = Expression.from_str("(2x-3)(-x+2)")
+>>> e_simplified = e.simplify()
+>>> e_simplified
+<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 .renders import render
 from .expression import Expression
-from .tokens.number import Integer, Decimal
+from .tokens import Token
+from .tokens.polynomial import Polynomial
+from .tokens.number import Integer, Decimal, Fraction
+
 
 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,41 +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)
-
-        :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
-        >>> Expression.set_render('tex')
-        >>> Expression.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}
-        >>> Expression.set_render('txt')
-        """
-        from .tokens.token import Token
-
-        Token.set_render(render)
-        cls.RENDER = render
-
     @classmethod
     def from_str(cls, string, typing=True):
         """ Initiate the expression from a string
@@ -136,9 +100,11 @@ class Expression(object):
         :returns: TODO
 
         :example:
-        >>> Expression.random("{a}/{a*k}") # doctest: +SKIP
+        >>> e = Expression.random("{a}/{a*k}")
+        >>> e # doctest: +SKIP
         <Exp: -3 / -15>
-        >>> Expression.random("{a}/{a*k} - 3*{b}", variables_scope={'a':{'min_max':(10, 30)}}) # doctest: +SKIP
+        >>> e = Expression.random("{a}/{a*k} - 3*{b}", variables_scope={'a':{'min_max':(10, 30)}})
+        >>> e # doctest: +SKIP
         <Exp: 18 / 108 - 3 * 9>
         >>> e = Expression.random("{a}*x + {b}*x + 3", ["a>b"], rejected=[0, 1])
         >>> ee = e.simplify()
@@ -172,16 +138,16 @@ 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
 
         :example:
-        
+
         >>> e = Expression.from_str("1 + 2x + 3 + 4x")
         >>> print(e)
         1 + 2x + 3 + 4x
@@ -202,7 +168,8 @@ class Expression(object):
                     return type(leaf)
             else:
                 try:
-                    typed_leaf = typing(leaf.node, leaf.left_value, leaf.right_value)
+                    typed_leaf = typing(
+                        leaf.node, leaf.left_value, leaf.right_value)
                     return typed_leaf.signature
                 except (AttributeError, NotImplementedError, TypingError):
                     return type(leaf)
@@ -219,7 +186,7 @@ class Expression(object):
 
     def _optimize(self, exclude_nodes=["/", "**"]):
         """ Return a copy of self with an optimize tree
-        
+
         :example:
         >>> e = Expression.from_str("2x^2+2x+3x")
         >>> print(e._tree)
@@ -260,7 +227,7 @@ class Expression(object):
 
     def _typing(self):
         """ Build a copy of self with as much typing as possible
-        
+
         :example:
         >>> e = Expression.from_str("2x", typing=False)
         >>> print(e._tree.map_on_leaf(lambda x: type(x).__name__))
@@ -305,7 +272,7 @@ class Expression(object):
 
     def _compute(self):
         """" Compute one step of self
-        
+
         """
         try:
             return Expression(self._tree.apply_on_last_level(compute))
@@ -370,7 +337,7 @@ class Expression(object):
 
     def explain(self):
         """ Yield every calculus step which have lead to self
-        
+
         :example:
         >>> e = Expression.from_str("2+3*4")
         >>> f = e.simplify()

mapytex/calculus/API/renders.py

@@ -12,34 +12,59 @@ 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"""
-    try:
-        return tree2txt(mo_tree)
-    except ValueError:
-        pass
+    def __init__(self, default="txt"):
+        self._default = default
+        self._render = default
+        self.renders = {}
 
-    try:
-        return mo_tree.__txt__
-    except AttributeError:
-        return str(mo_tree)
+    def register_render(self, name, func, attribute):
+        """ register a render """
+        try:
+            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_name(self):
+        return self._render
+
+    @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 getattr(mo_tree, r["attribute"])
+        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")
 
 
-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)
-
-
-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):
@@ -141,7 +141,7 @@ class Decimal(Token):
 
 class Fraction(Token):
 
-    """ Token representing a fraction
+    """ Token representing a fraction of numbers
 
     :example:
     >>> Fraction("3/4")
@@ -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,17 +32,9 @@ 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
-        
+
         :example:
         >>> from mapytex.calculus.API import Expression
         >>> e = Expression.from_str("2+3*4")
@@ -64,25 +54,16 @@ class Token(object):
             yield self
 
     def __repr__(self):
-        return f"<{self.__class__.__name__} {self.__txt__}>"
+        try:
+            return f"<{self.__class__.__name__} {render(self._mo._tree, 'txt')}>"
+        except AttributeError:
+            return f"<{self.__class__.__name__} {render(self._mo, 'txt')}>"
 
     def __str__(self):
-        if self.RENDER == "tex":
-            return self.__tex__
-        elif self.RENDER == "txt":
-            return self.__txt__
-        else:
-            raise ValueError(f"Unknow render {self.RENDER}")
-
-        # return renders[self.RENDER](self._mo)
-
-    @property
-    def __txt__(self):
-        return self._mo.__txt__
-
-    @property
-    def __tex__(self):
-        return self._mo.__tex__
+        try:
+            return render(self._mo._tree)
+        except AttributeError:
+            return render(self._mo)
 
     @property
     def raw(self):
@@ -261,11 +242,10 @@ class Token(object):
         >>> c = a ** 2
         >>> c
         <Decimal 5.29>
+        """
 
-    """
         return self._operate(other, "^")
 
-
     def _roperate(self, other, operation):
         """ Make a operation between 2 Tokens """
         from ..expression import Expression
@@ -315,6 +295,7 @@ class Token(object):
         <Linear x - 3>
         """
         return self._roperate(other, "-")
+
     def __rmul__(self, other):
         """ Multiply 2 Tokens or a Token and a Expression
 
@@ -342,7 +323,6 @@ class Token(object):
         """
         return self._roperate(other, "/")
 
-
     def _get_soul(self, other=None):
         """ Get the builtin soul of self or other """
         if isinstance(other, Token):

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,8 +30,8 @@ Expression is the classe wich handle all calculus. It can randomly generate or i
 
 """
 
-from .API import Expression, Integer, Decimal
-from .core import list_generator
+from .API import Expression, Integer, Decimal, render, Polynomial, Fraction
+from .core import random_list
 from decimal import getcontext
 #getcontext().prec = 2
 

mapytex/calculus/core/MO/atoms.py

@@ -37,7 +37,7 @@ def moify_cor(target):
     >>> for i in [-2, "+", "x", "*", Decimal("3.3")]:
     ...    list2molist.send(i)
     >>> list2molist.throw(STOOOP)
-    [<MOnumber - 2>, '+', <MOstr x>, '*', <MOnumber 3.3>]
+    [<MOnumber -2>, '+', <MOstr x>, '*', <MOnumber 3.3>]
 
     """
     try:
@@ -78,7 +78,7 @@ class MOnumber(Atom):
         >>> MOnumber(23)
         <MOnumber 23>
         >>> MOnumber(-23)
-        <MOnumber - 23>
+        <MOnumber -23>
 
         As expected there will be trouble with float
 
@@ -90,13 +90,13 @@ class MOnumber(Atom):
         >>> MOnumber(Decimal("23.3"))
         <MOnumber 23.3>
         >>> MOnumber(Decimal("-23.3"))
-        <MOnumber - 23.3>
+        <MOnumber -23.3>
 
         Or directly passe a decimal string
         >>> MOnumber("23.3")
         <MOnumber 23.3>
         >>> MOnumber("-23.3")
-        <MOnumber - 23.3>
+        <MOnumber -23.3>
 
         MOnumber initialisation is idempotent
 
@@ -259,7 +259,8 @@ class MOstr(Atom):
                 f"An MOstr should be initiate with a single caracter string, got {val}"
             )
         if not val.isalpha():
-            raise MOError(f"An MOstr should be initiate with a alpha string, got {val}")
+            raise MOError(
+                f"An MOstr should be initiate with a alpha string, got {val}")
 
         Atom.__init__(self, val)
 

mapytex/calculus/core/MO/fraction.py

@@ -32,10 +32,10 @@ class MOFraction(Molecule):
         >>> f = MOFraction(2, 3)
         >>> f
         <MOFraction 2 / 3>
-        >>> print(f.__txt__)
-        2 / 3
-        >>> print(f.__tex__)
-        \\dfrac{2}{3}
+        >>> print(f.tree)
+        /
+         > 2
+         > 3
         >>> print(f)
         2 / 3
         >>> f = MOFraction(2, 3, negative = True)
@@ -44,11 +44,13 @@ class MOFraction(Molecule):
         """
         _numerator = MO.factory(numerator)
         _denominator = MO.factory(denominator)
+
         base_tree = Tree("/", _numerator, _denominator)
         if negative:
             tree = Tree("-", None, base_tree)
         else:
             tree = base_tree
+
         Molecule.__init__(self, tree)
 
         self._numerator = _numerator

mapytex/calculus/core/MO/mo.py

@@ -57,20 +57,12 @@ class MO(ABC):
         pass
 
     def __repr__(self):
-        return f"<{self.__class__.__name__} {self.__txt__}>"
+        return f"<{self.__class__.__name__} {self.__str__()}>"
 
     @abstractmethod
     def __str__(self):
         pass
 
-    @abstractmethod
-    def __txt__(self):
-        pass
-
-    @abstractmethod
-    def __tex__(self):
-        pass
-
     def __hash__(self):
         try:
             return self._tree.__hash__()
@@ -161,21 +153,21 @@ class Molecule(MO):
 
     It is a wrapping of tree
 
-    Its wrapping tree can be access throw .tree property
+    Its wrapping tree can be access through .tree property
     """
 
     MAINOP = None
 
-    def __init__(self, value):
+    def __init__(self, tree):
         """ Initiate the MO
 
         It should be idempotent.
 
         """
         try:
-            self._tree = value._tree
+            self._tree = tree._tree
         except AttributeError:
-            self._tree = value
+            self._tree = tree
 
         self.is_scalar = True
         self._signature = None
@@ -186,18 +178,10 @@ class Molecule(MO):
 
     @property
     def content(self):
-        return self._tree
+        return self.tree
 
     def __str__(self):
-        return str(self.__txt__)
-
-    @property
-    def __txt__(self):
-        return tree2txt(self._tree)
-
-    @property
-    def __tex__(self):
-        return tree2tex(self._tree)
+        return tree2txt(self.tree)
 
 
 # -----------------------------

mapytex/calculus/core/MO/monomial.py

@@ -31,10 +31,10 @@ class MOstrPower(Molecule):
         <MOstrPower x^2>
         >>> print(s)
         x^2
-        >>> print(s.__txt__)
-        x^2
-        >>> print(s.__tex__)
-        x^{2}
+        >>> print(s.tree)
+        ^
+         > x
+         > 2
         >>> MOstrPower(3, 1)
         Traceback (most recent call last):
         ...
@@ -59,7 +59,8 @@ class MOstrPower(Molecule):
         """
         _variable = MO.factory(variable)
         if not isinstance(_variable, MOstr):
-            raise MOError("The variable of a monomial should be convertible into MOstr")
+            raise MOError(
+                "The variable of a monomial should be convertible into MOstr")
         self._variable = _variable
 
         _power = MO.factory(power)
@@ -102,7 +103,7 @@ class MOstrPower(Molecule):
     @property
     def signature(self):
         """ Name of the mo in the API
-        
+
         :example:
         >>> MOstrPower("x", 3).signature
         'monome3'
@@ -123,7 +124,8 @@ class MOstrPower(Molecule):
         """
         if self._power > 2:
             return Tree(
-                "*", self.power, MOstrPower(self.variable, self._power._value - 1)
+                "*", self.power, MOstrPower(self.variable,
+                                            self._power._value - 1)
             )
         return Tree("*", self.power, MOstr(self.variable))
 
@@ -147,22 +149,20 @@ class MOMonomial(Molecule):
         <MOMonomial 4x>
         >>> print(m)
         4x
-        >>> print(m.__txt__)
-        4x
-        >>> print(m.__tex__)
-        4x
+        >>> print(m.tree)
+        *
+         > 4
+         > x
         >>> x = MOstrPower('x', 2)
         >>> MOMonomial(4, x)
         <MOMonomial 4x^2>
-        >>> m = MOMonomial(4, 'x')
+        >>> m = MOMonomial(-1, 'x')
         >>> m
-        <MOMonomial 4x>
-        >>> print(m)
-        4x
-        >>> print(m.__txt__)
-        4x
-        >>> print(m.__tex__)
-        4x
+        <MOMonomial - x>
+        >>> print(m.tree)
+        -
+         > None
+         > x
         >>> MOMonomial(4, 'x', 1)
         <MOMonomial 4x>
         >>> MOMonomial(4, 'x', 2)
@@ -170,6 +170,13 @@ class MOMonomial(Molecule):
         >>> x2 = MOstrPower('x', 2)
         >>> MOMonomial(4, x2, 3)
         <MOMonomial 4x^6>
+        >>> m = MOMonomial(-1, 'x', 2)
+        >>> m
+        <MOMonomial - x^2>
+        >>> print(m.tree)
+        -
+         > None
+         > x^2
         >>> MOMonomial(0, x)
         Traceback (most recent call last):
             ...
@@ -199,34 +206,21 @@ class MOMonomial(Molecule):
         self._power = _power
 
         try:
-            if self._coefficient.value != 1:
-                _tree = Tree("*", self._coefficient, self.strpower)
-            else:
+            if self.coefficient.value == 1:
                 _tree = self.strpower
+            else:
+                _tree = Tree("*", self.coefficient, self.strpower)
         except AttributeError:
-            _tree = Tree("*", self._coefficient, self.strpower)
+            _tree = Tree("*", self.coefficient, self.strpower)
 
         Molecule.__init__(self, _tree)
 
-    def __str__(self):
-        if self._coefficient != -1:
-            return super(MOMonomial, self).__str__()
-        else:
-            return "- " + self.strpower.__str__()
-
     @property
-    def __txt__(self):
-        if self._coefficient != -1:
-            return super(MOMonomial, self).__txt__
-        else:
-            return "- " + self.strpower.__txt__
+    def tree(self):
+        if self._coefficient == -1:
+            return Tree("-", None, self.strpower)
 
-    @property
-    def __tex__(self):
-        if self._coefficient != -1:
-            return super(MOMonomial, self).__tex__
-        else:
-            return "- " + self.strpower.__tex__
+        return Tree("*", self.coefficient, self.strpower)
 
     @property
     def coefficient(self):
@@ -265,7 +259,7 @@ class MOMonomial(Molecule):
     @property
     def signature(self):
         """ Name of the mo in the API
-        
+
         :example:
         >>> MOMonomial(2, "x").signature
         'monome1'

mapytex/calculus/core/__init__.py

@@ -66,7 +66,7 @@ from .tree import Tree, AssocialTree
 from .compute import compute
 from .typing import typing, TypingError
 from .renders import tree2txt, tree2tex
-from .random import list_generator
+from .random import list_generator as random_list
 
 
 # -----------------------------

mapytex/calculus/core/compute/__init__.py

@@ -40,7 +40,7 @@ def compute(node, left_v, right_v):
     >>> compute("+", MOnumber(1), MOnumber(2))
     <MOnumber 3>
     >>> compute("-", None, MOnumber(2))
-    <MOnumber - 2>
+    <MOnumber -2>
     >>> compute("*", MOnumber(1), MOnumber(2))
     <MOnumber 2>
     >>> compute("~", MOnumber(1), MOnumber(2))
@@ -70,7 +70,8 @@ def compute_capacities(node):
     op = OPERATIONS[node]
     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
 
 

mapytex/calculus/core/compute/minus.py

@@ -35,7 +35,7 @@ def monumber(_, right):
 
     >>> a = MOnumber(4)
     >>> minus(None, a)
-    <MOnumber - 4>
+    <MOnumber -4>
 
     """
     return MO.factory(-right.value)

mapytex/calculus/core/random/__init__.py

@@ -71,7 +71,7 @@ This function ignores tree structure and works with lists
 {'a': -8, 'a*b': -40, 'b': 5, 'c': 4}
 """
 
-__all__ = ["generator"]
+__all__ = ["list_generator"]
 
 from random import choice
 from functools import reduce
@@ -256,7 +256,7 @@ def build_variable_scope(rd_variables, rejected, min_max, variables_scope):
     return complete_scope
 
     
-def list_generator(var_list, conditions=[], rejected=[0], min_max=(-10, 10), variables_scope={}):
+def list_generator(var_list, conditions=[], rejected=[0], min_max=(-10, 10), variables_scope={}, dictionnary=False):
     """ Generate random computed values from the list
 
     :param rd_variables: list of random variables to generate (can be computed value - "a*b")
@@ -264,17 +264,25 @@ def list_generator(var_list, conditions=[], rejected=[0], min_max=(-10, 10), var
     :param rejected: Rejected values for the generator (default [0])
     :param min_max: (min, max) limits in between variables will be generated
     :param variables_scope: rejected and min_max define for individual variables
+    :param dictionnary: the return value will be a dictionnary with var_list as keys (default False)
     :return: dictionnary of generated variables
 
     :example:
-    >>> values = list_generator(["a", "a*b", "b", "c"])
-    >>> values  # doctest: +SKIP
-    >>> values["a"] * values["b"] == values["a*b"]
+    >>> a, ab, b, c = list_generator(["a", "a*b", "b", "c"])
+    >>> a, ab, b, c # doctest: +SKIP
+    (5, -20, -4, -3)
+    >>> a * b == ab
     True
-    >>> values["a*b"] # doctest: +SKIP
-    >>> values["a"] * values["b"] # doctest: +SKIP
+    >>> ab # doctest: +SKIP
+    -20
+    >>> a, b # doctest: +SKIP
+    5, -4
+    >>> list_generator(["a", "a*b", "b", "c"], dictionnary=True) # doctest: +SKIP
+    {'a': -3, 'a*b': 18, 'b': -6, 'c': -4}
     """
     rv = extract_rv(var_list)
     rv_gen = random_generator(rv, conditions, rejected, min_max, variables_scope)
     generated = compute_leafs(var_list, rv_gen)
-    return generated
+    if dictionnary:
+        return generated
+    return [generated[v] for v in var_list]

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
@@ -210,7 +206,8 @@ def render_with_parenthesis(subtree, operator):
     return subtree_
 
 
-OPERATOR2TEX = {"+": plus2tex, "-": minus2tex, "*": mul2tex, "/": div2tex, "^": pow2tex}
+OPERATOR2TEX = {"+": plus2tex, "-": minus2tex,
+                "*": mul2tex, "/": div2tex, "^": pow2tex}
 
 
 def tree2tex(tree):
@@ -230,8 +227,17 @@ def tree2tex(tree):
     from ..tree import Tree
 
     if not isinstance(tree, Tree):
-        raise ValueError(f"Can only render a Tree (got {type(tree).__name__}: {tree})")
-    return OPERATOR2TEX[tree.node](tree.left_value, tree.right_value)
+        raise ValueError(
+            f"Can only render a Tree (got {type(tree).__name__}: {tree})")
+
+    def expand(leaf):
+        try:
+            return leaf.tree
+        except AttributeError:
+            return leaf
+    expanded_tree = tree.map_on_leaf(expand)
+
+    return OPERATOR2TEX[expanded_tree.node](expanded_tree.left_value, expanded_tree.right_value)
 
 
 # -----------------------------

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
@@ -214,7 +215,8 @@ def render_with_parenthesis(subtree, operator):
     return subtree_
 
 
-OPERATOR2TXT = {"+": plus2txt, "-": minus2txt, "*": mul2txt, "/": div2txt, "^": pow2txt}
+OPERATOR2TXT = {"+": plus2txt, "-": minus2txt,
+                "*": mul2txt, "/": div2txt, "^": pow2txt}
 
 
 def tree2txt(tree):
@@ -234,8 +236,17 @@ def tree2txt(tree):
     from ..tree import Tree
 
     if not isinstance(tree, Tree):
-        raise ValueError(f"Can only render a Tree (got {type(tree).__name__}: {tree})")
-    return OPERATOR2TXT[tree.node](tree.left_value, tree.right_value)
+        raise ValueError(
+            f"Can only render a Tree (got {type(tree).__name__}: {tree})")
+
+    def expand(leaf):
+        try:
+            return leaf.tree
+        except AttributeError:
+            return leaf
+    expanded_tree = tree.map_on_leaf(expand)
+
+    return OPERATOR2TXT[expanded_tree.node](expanded_tree.left_value, expanded_tree.right_value)
 
 
 # -----------------------------

mapytex/calculus/core/str2.py

@@ -271,7 +271,7 @@ def concurent_broadcast(target, lookfors=[]):
     >>> a = searcher.throw(STOOOP)
     >>> print(a)
     ['az', 'ABC', 'a', 'b', 'az', 'b']
-    
+
     >>> lfop = lookfor(something_in("+-*/()"), lambda x: f"op{x}")
     >>> searcher = concurent_broadcast(list_sink, [lfop])
     >>> for i in '12+3+234':
@@ -484,7 +484,8 @@ def lookforNumbers(target):
                         if current.replace("-", "", 1).isdigit():
                             current += tok
                         else:
-                            raise ParsingError(f"Can't build decimal with '{current}'")
+                            raise ParsingError(
+                                f"Can't build decimal with '{current}'")
                     elif tok == "-":
                         if current == "":
                             current = tok
@@ -802,7 +803,8 @@ def str2(sink, convert_to_mo=True):
                 operator_corout(missing_times(moify_cor(pparser(sink))))
             )
         else:
-            str2_corout = lookforNumbers(operator_corout(missing_times(pparser(sink))))
+            str2_corout = lookforNumbers(
+                operator_corout(missing_times(pparser(sink))))
 
         for i in expression.replace(" ", ""):
             str2_corout.send(i)
@@ -819,7 +821,7 @@ def rdstr2(sink):
     :example:
     >>> rdstr2list = rdstr2(list_sink)
     >>> rdstr2list("{a}+{a*b}-2")
-    [<RdLeaf a>, '+', <RdLeaf a*b>, '+', <MOnumber - 2>]
+    [<RdLeaf a>, '+', <RdLeaf a*b>, '+', <MOnumber -2>]
     >>> rdstr2list("{a}({b}x+{c})")
     [<RdLeaf a>, '*', [<RdLeaf b>, '*', <MOstr x>, '+', <RdLeaf c>]]
     """
@@ -828,7 +830,8 @@ def rdstr2(sink):
 
     def pipeline(expression):
         str2_corout = look_for_rdleaf(
-            lookforNumbers(operator_corout(missing_times(moify_cor(pparser(sink)))))
+            lookforNumbers(operator_corout(
+                missing_times(moify_cor(pparser(sink)))))
         )
 
         for i in expression.replace(" ", ""):

requirements.txt

@@ -21,6 +21,6 @@ pyparsing==2.3.0
 pytest==3.10.1
 simplegeneric==0.8.1
 six==1.11.0
-tabulate==0.8.2
+tabulate==0.8.7
 traitlets==4.3.2
 wcwidth==0.1.7

setup.py

@@ -7,7 +7,7 @@ except ImportError:
 
 setup(
     name="mapytex",
-    version="2.3",
+    version="2.3.2",
     description="Computing like a student",
     author="Benjamin Bertrand",
     author_email="programming@opytex.org",

test/calculus/core/test_render.py

@@ -0,0 +1,31 @@
+import mapytex
+
+def test_default_render():
+    assert mapytex.render.render_name == "txt"
+
+def test_default_rending():
+    e = mapytex.Expression("2*3")
+    assert str(e) == "2*3"
+
+def test_changing_render():
+    assert mapytex.render.render_name == "txt"
+    mapytex.render.set_render("tex")
+    assert mapytex.render.render_name == "tex"
+    mapytex.render.set_render("txt")
+    assert mapytex.render.render_name == "txt"
+
+
+def test_changing_rending():
+    e = mapytex.Expression.from_str("2*3")
+    f = mapytex.Fraction("2/3")
+    assert str(e) == "2 * 3"
+    assert str(f) == "2 / 3"
+    mapytex.render.set_render("tex")
+    assert str(e) == "2 \\times 3"
+    assert str(f) == "\\dfrac{2}{3}"
+    mapytex.render.set_render("txt")
+    assert str(e) == "2 * 3"
+    assert str(f) == "2 / 3"
+
+
+