Feat: testing list random generator

mapytex/__init__.py

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

mapytex/calculus/__init__.py

@@ -12,7 +12,6 @@ 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
 >>> render.set_render("txt")
 >>> e = Expression.from_str("2x + 6 - 3x")
 >>> print(e)
@@ -27,16 +26,23 @@ Expression is the classe wich handle all calculus. It can randomly generate or i
 (2 - 3) * x + 6
 - x + 6
 
+Create random Expression
+========================
+
+>>> e = random.expression("{a} / {b} + {c} / {d}")
+>>> print(e) # doctest: +SKIP 
+- 3 / - 10 + 3 / 5
 
 """
 
-from .API import Expression, Integer, Decimal, render, Polynomial, Fraction
-#from .core import random_list
-from decimal import getcontext
+from .API import render, Expression
+#from decimal import getcontext
+from . import random
+
 #getcontext().prec = 2
 
 
-__all__ = ["Expression"]
+__all__ = ["render",  "Expression", "random"]
 
 
 # -----------------------------

mapytex/calculus/random/__init__.py

@@ -0,0 +1,19 @@
+from .list import list_generator as list
+from .expression import expression_generator as expression
+
+__all__ = ["list", "expression"]
+
+"""
+Generate random stuffs
+======================
+
+list_generator
+==============
+
+Generate random lists
+
+expression_generator
+====================
+
+Generate random Expression
+"""

mapytex/calculus/random/core/generate.py

@@ -8,9 +8,15 @@
 
 
 from random import choice
+import math
+
+EVAL_FUN = {**math.__dict__}
 
 
-def complete_variable_configs(variables, global_config:dict={}, configs:dict={})->dict:
+
+def complete_variable_configs(
+    variables, global_config: dict = {}, configs: dict = {}
+) -> dict:
     """Completes variables configurations with the global configuration
 
     :param variables: list of random variables to generate
@@ -47,7 +53,10 @@ def complete_variable_configs(variables, global_config:dict={}, configs:dict={})
 
 
 def random_generator(
-        variables:list[str], conditions:list[str]=[], global_config:dict={}, configs:dict={},
+    variables: list[str],
+    conditions: list[str] = [],
+    global_config: dict = {},
+    configs: dict = {},
 ) -> dict[str, int]:
     """Generate random variables
 
@@ -57,6 +66,8 @@ def random_generator(
     :param configs: global parameters
     :return: dictionnary of generated variables
 
+    In variables and configurations, you have access to all math module functions
+
     :example:
     >>> gene = random_generator(["a", "b"],
     ...                  ["a > 0"],
@@ -81,9 +92,7 @@ def random_generator(
     >>> gene["a"] % gene["b"]
     0
     """
-    complete_scope = complete_variable_configs(
-        variables, global_config, configs
-    )
+    complete_scope = complete_variable_configs(variables, global_config, configs)
     choices_list = {
         v: list(
             set(
@@ -101,9 +110,7 @@ def random_generator(
 
     generate_variable = {v: choice(choices_list[v]) for v in variables}
 
-    while not all([eval(c, __builtins__, generate_variable) for c in conditions]):
+    while not all([eval(c, EVAL_FUN, generate_variable) for c in conditions]):
         generate_variable = {v: choice(choices_list[v]) for v in variables}
 
     return generate_variable
-
-

mapytex/calculus/random/core/grammar.py

@@ -1,3 +1,6 @@
+import math
+
+EVAL_FUN = {**math.__dict__}
 
 def extract_letters(words: list[str]) -> set[str]:
     """Extracts unique letters from a list of words
@@ -25,11 +28,16 @@ def eval_words(words:list[str], values:dict[str,int]) -> dict[str, int]:
     :param values: Dictionary of letters:value
     :return: Dictionary of evaluated words from generated values
 
+    In words, you have access to all math module functions
+
     :example:
     >>> leafs = ["a", "a*k"]
     >>> generated_values = {"a":2, "k":3}
     >>> eval_words(leafs, generated_values)
     {'a': 2, 'a*k': 6}
+    >>> leafs = ["exp(a)", "gcd(a, k)"]
+    >>> generated_values = {"a":2, "k":3}
+    >>> eval_words(leafs, generated_values)
+    {'exp(a)': 7.38905609893065, 'gcd(a, k)': 1}
     """
-    return {word: eval(word, values) for word in words}
-
+    return {word: eval(word, EVAL_FUN, values) for word in words}

mapytex/calculus/random/core/int_gene.py

@@ -111,8 +111,7 @@ def filter_random(min_value=-10, max_value=10, rejected=[0, 1], accept_callbacks
 
 class FilterRandom(object):
 
-    """ Integer random generator which filter then choose candidate
-    """
+    """Integer random generator which filter then choose candidate"""
 
     # TODO: Faire un cache pour éviter de reconstruire les listes à chaque fois |ven. déc. 21 19:07:42 CET 2018
 

mapytex/calculus/random/core/leaf.py

@@ -53,9 +53,7 @@ def look_for_rdleaf(target):
 
 
 class RdLeaf:
-    """ Random leaf
-
-    """
+    """Random leaf"""
 
     def __init__(self, name):
         self._name = name

mapytex/calculus/random/core/random_tree.py

@@ -4,6 +4,7 @@ from .grammar import extract_letters, eval_words
 from .generate import random_generator
 from .str2 import rdstr2
 
+
 class RandomTree(MutableTree):
     """MutableTree that accept {a} syntax for random generation
 
@@ -61,7 +62,6 @@ class RandomTree(MutableTree):
                 rd_leafs.append(leaf.name)
         return rd_leafs
 
-        
     @property
     def random_value(self) -> set[str]:
         """Get set of random values to generate
@@ -77,7 +77,6 @@ class RandomTree(MutableTree):
         """
         return extract_letters(self.random_leaves)
 
-
     def eval_random_leaves(self, leaves_value: dict[str, int]):
         """Given random leaves value get the tree
 
@@ -93,14 +92,18 @@ class RandomTree(MutableTree):
          > 2
          > 6
         """
+
         def replace(leaf):
             try:
                 return leaf.replace(leaves_value)
             except AttributeError:
                 return leaf
+
         return self.map_on_leaf(replace).map_on_leaf(moify)
 
-    def generate(self, conditions:list[str]=[], global_config:dict={} , configs:dict={}) -> Tree:
+    def generate(
+        self, conditions: list[str] = [], global_config: dict = {}, configs: dict = {}
+    ) -> Tree:
         """Generate a random version of self
 
         :param conditions: list of conditions
@@ -108,6 +111,8 @@ class RandomTree(MutableTree):
         :param configs: specific configuration for each generated values
 
         """
-        generated_values = random_generator(self.random_value, conditions, global_config, configs)
+        generated_values = random_generator(
+            self.random_value, conditions, global_config, configs
+        )
         leaves = eval_words(self.random_leaves, generated_values)
         return self.eval_random_leaves(leaves)

mapytex/calculus/random/core/str2.py

@@ -1,11 +1,17 @@
-
 from ...core.operator import is_operator
 from functools import partial
-from ...core.str2 import concurent_broadcast, lookforNumbers, pparser, missing_times, lookfor
+from ...core.str2 import (
+    concurent_broadcast,
+    lookforNumbers,
+    pparser,
+    missing_times,
+    lookfor,
+)
 from ...core.coroutine import STOOOP
 from ...core.MO import moify_cor
 from .leaf import look_for_rdleaf
 
+
 def rdstr2(sink):
     """Return a pipeline which parse random expression and with sink as endpoint
 
@@ -22,8 +28,7 @@ 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(" ", ""):
@@ -33,4 +38,3 @@ def rdstr2(sink):
         return a
 
     return pipeline
-

mapytex/calculus/random/expression.py

@@ -6,7 +6,13 @@ DEFAUTL_CONFIG = {
     "min_max": (-10, 10),
 }
 
-def expression_generator(template:str, conditions:list[str]=[], global_config:dict={}, configs:dict={}):
+
+def expression_generator(
+    template: str,
+    conditions: list[str] = [],
+    global_config: dict = {},
+    configs: dict = {},
+):
     """Generate a random expression
 
     :param template: the template of the expression
@@ -31,5 +37,7 @@ def expression_generator(template:str, conditions:list[str]=[], global_config:di
 
     """
     rd_tree = RandomTree.from_str(template)
-    generated_tree = rd_tree.generate(conditions, dict(DEFAUTL_CONFIG, **global_config), configs)
+    generated_tree = rd_tree.generate(
+        conditions, dict(DEFAUTL_CONFIG, **global_config), configs
+    )
     return Expression._post_processing(generated_tree)

mapytex/calculus/random/list.py

@@ -17,7 +17,13 @@ DEFAUTL_CONFIG = {
     "min_max": (-10, 10),
 }
 
-def list_generator(var_list:list[str], conditions:list[str]=[], global_config:dict={}, configs:dict={})->list[int]:
+
+def list_generator(
+    template: list[str],
+    conditions: list[str] = [],
+    global_config: dict = {},
+    configs: dict = {},
+) -> list[int]:
     """Generate random computed values from the list
 
     :param rd_variables: list of random variables to generate (can be computed value - "a*b")
@@ -50,7 +56,9 @@ def list_generator(var_list:list[str], conditions:list[str]=[], global_config:di
     >>> a not in [2, 3, 5, 7]
     True
     """
-    rv = extract_letters(var_list)
-    rv_gen = random_generator(rv, conditions, dict(DEFAUTL_CONFIG, **global_config), configs)
-    generated = eval_words(var_list, rv_gen)
-    return [generated[v] for v in var_list]
+    rv = extract_letters(template)
+    rv_gen = random_generator(
+        rv, conditions, dict(DEFAUTL_CONFIG, **global_config), configs
+    )
+    generated = eval_words(template, rv_gen)
+    return [generated[v] for v in template]

test/calculus/api/random/test_random.py

@@ -1,6 +0,0 @@
-import pytest
-import mapytex
-
-def test_random_function():
-    assert 1 == 1
-    #mapytex.random("{a}")

test/calculus/core/test_render.py

@@ -17,7 +17,7 @@ def test_changing_render():
 
 def test_changing_rending():
     e = mapytex.Expression.from_str("2*3")
-    f = mapytex.Fraction("2/3")
+    f = mapytex.Expression.from_str("2/3")
     assert str(e) == "2 * 3"
     assert str(f) == "2 / 3"
     mapytex.render.set_render("tex")

test/calculus/random/test_list_generator.py

@@ -0,0 +1,55 @@
+import mapytex
+
+def test_generate_list():
+    random_list = mapytex.random.list(["a", "b"])
+    assert len(random_list) == 2
+    random_list = mapytex.random.list(["a", "b", "c"])
+    assert len(random_list) == 3
+    random_list = mapytex.random.list(["a", "b", "a", "b"])
+    assert random_list[0] == random_list[2]
+    assert random_list[1] == random_list[3]
+
+def test_generate_list_calculus():
+    random_list = mapytex.random.list(["a", "b", "a+b"])
+    assert random_list[0] + random_list[1] == random_list[2]
+
+    random_list = mapytex.random.list(["a", "b", "a-b"])
+    assert random_list[0] - random_list[1] == random_list[2]
+
+    random_list = mapytex.random.list(["a", "b", "a*b"])
+    assert random_list[0] * random_list[1] == random_list[2]
+
+    random_list = mapytex.random.list(["a", "b", "a/b"])
+    assert random_list[0] / random_list[1] == random_list[2]
+
+def test_generate_list_calculus_math():
+    import math
+    a, b, gcd = mapytex.random.list(["a", "b", "gcd(a, b)"])
+    assert math.gcd(a, b) == gcd
+    a, b, exp, log = mapytex.random.list(["a", "b", "exp(a)", "log(b)"])
+    assert math.exp(a) == exp
+    assert math.log(b) == log
+
+
+def test_generate_list_conditions():
+    a, b = mapytex.random.list(["a", "b"], conditions=["a + b == 10"])
+    assert a + b == 10
+    a, b = mapytex.random.list(["a", "b"], conditions=["a * b > 0", "a + b == 10"])
+    assert a + b == 10
+    assert a * b > 0
+
+def test_generate_list_conditions_math():
+    import math
+    a, b = mapytex.random.list(["a", "b"], conditions=["gcd(a, b) == 3"])
+    assert math.gcd(a, b) == 3
+
+def test_generate_list_global_config():
+    global_config = {"rejected": [0, 1, 2, 3]}
+    a, = mapytex.random.list(["a"], global_config=global_config)
+    assert a not in global_config["rejected"]
+
+    global_config = {"min_max": (20, 30)}
+    a, = mapytex.random.list(["a"], global_config=global_config)
+    assert a >= 20
+    assert a <= 30
+