Feat: Expression can be generated randomly!!!

mapytex/calculus/API/expression.py

@@ -11,6 +11,8 @@ Expression
 
 """
 from ..core import AssocialTree, Tree, compute, typing, TypingError
+from ..core.random import extract_rdleaf, extract_rv, random_generator, compute_leafs, replace_rdleaf
+from ..core.MO import moify
 from .tokens import factory
 from .renders import renders
 
@@ -68,26 +70,61 @@ class Expression(object):
         """
         t = Tree.from_str(string)
         if typing:
+            return cls._post_precessing(t)
+
+        return cls(t)
+
+    @classmethod
+    def random(
+        cls,
+        template,
+        conditions=[],
+        rejected=[0],
+        min_max=(-10, 10),
+        variables_scope={},
+        shuffle=False,
+    ):
+        """ Initiate randomly the expression
+
+        :param template: the template of the expression
+        :param conditions: conditions on randomly generate variable
+        :param rejected: Values to reject for all random variables
+        :param min_max: Min and max value for all random variables
+        :param variables_scope: Dictionnary for each random varaibles to fic rejected and min_max
+        :param shuffle: allowing to shuffle the tree
+        :returns: TODO
+
+        :example:
+        >>> Expression.random("{a}/{a*k}") # doctest: +SKIP
+        <Exp: -3 / -15>
+        >>> Expression.random("{a}/{a*k} - 3*{b}", variables_scope={'a':{'min_max':(10, 30)}})
+        <Exp: 18 / 108 - 3 * 9>
+
+        """
+        rd_t = Tree.from_str(template, random=True)
+        leafs = extract_rdleaf(rd_t)
+        rd_varia = extract_rv(leafs)
+        generated = random_generator(
+            rd_varia, conditions, rejected, min_max, variables_scope
+        )
+        computed = compute_leafs(leafs, generated)
+        t = replace_rdleaf(rd_t, computed).map_on_leaf(moify)
+        t = cls._post_precessing(t)
+
+        if shuffle:
+            raise NotImplemented("Can't suffle expression yet")
+
+        return cls(t)
+
+    @classmethod
+    def _post_precessing(cls, t):
+        """ Post process the tree by typing it """
         tt = cls(t)._typing()
         try:
             return factory(tt)
         except TypeError as e:
             return cls(t)
 
-        return cls(t)
-
-    @classmethod
-    def random(self, template, conditions=[], shuffle=False):
-        """ Initiate randomly the expression 
-
-        :param template: the template of the expression
-        :param conditions: conditions on randomly generate variable
-        :param shuffle: allowing to shuffle the tree
-        :returns: TODO
-
-        """
-        pass
-
     @classmethod
     def set_render(cls, render):
         """ Define default render function 

mapytex/calculus/core/random/leaf.py

@@ -31,6 +31,7 @@ def look_for_rdleaf(target):
     except TypeError:
         target_ = target
 
+    stacking = False
     try:
         while True:
             tok = yield

mapytex/calculus/core/tree.py

@@ -11,7 +11,7 @@ Tree class
 
 from .tree_tools import to_nested_parenthesis, postfix_concatenate, show_tree
 from .coroutine import coroutine, STOOOP
-from .str2 import str2
+from .str2 import str2, rdstr2
 from .operator import OPERATORS, is_operator
 
 __all__ = ["Tree", "MutableTree"]
@@ -51,7 +51,7 @@ class Tree:
         self.right_value = right_value
 
     @classmethod
-    def from_str(cls, expression, convert_to_mo=True):
+    def from_str(cls, expression, convert_to_mo=True, random=False):
         """ Initiate a tree from an string expression
 
         :example:
@@ -77,9 +77,17 @@ class Tree:
          > *
          | > 3
          | > n
+        >>> t = Tree.from_str("2+{n}*x", random=True)
+        >>> print(t)
+        +
+         > 2
+         > *
+         | > {n}
+         | > x
+
 
         """
-        t = MutableTree.from_str(expression, convert_to_mo)
+        t = MutableTree.from_str(expression, convert_to_mo, random)
         return cls.from_any_tree(t)
 
     @classmethod
@@ -890,7 +898,7 @@ class MutableTree(Tree):
         self.right_value = right_value
 
     @classmethod
-    def from_str(cls, expression, convert_to_mo=True):
+    def from_str(cls, expression, convert_to_mo=True, random=False):
         """ Initiate the MutableTree
 
         :example:
@@ -948,6 +956,10 @@ class MutableTree(Tree):
          | > x
 
         """
+        if random:
+            str_2_mut_tree = rdstr2(cls.sink)
+            return str_2_mut_tree(expression)
+        else:
             str_2_mut_tree = str2(cls.sink, convert_to_mo)
             return str_2_mut_tree(expression)