289 lines
8.1 KiB
Python
289 lines
8.1 KiB
Python
#! /usr/bin/env python
|
|
# -*- coding: utf-8 -*-
|
|
# vim:fenc=utf-8
|
|
#
|
|
# Copyright © 2017 lafrite <lafrite@Poivre>
|
|
#
|
|
# Distributed under terms of the MIT license.
|
|
|
|
"""
|
|
Tools to extract random leafs, random variables, generate random values and
|
|
fill new trees
|
|
|
|
Flow
|
|
----
|
|
|
|
Tree with RdLeaf
|
|
|
|
|
| Extract rdLeaf
|
|
|
|
|
List of leafs to generate
|
|
|
|
|
| extract_rv
|
|
|
|
|
List random variables to generate
|
|
|
|
|
| Generate
|
|
|
|
|
Dictionnary of generated random variables
|
|
|
|
|
| Compute leafs
|
|
|
|
|
Dictionnary of computed leafs
|
|
|
|
|
| Replace
|
|
|
|
|
Tree with RdLeaf replaced by generated values
|
|
|
|
:example:
|
|
|
|
>>> from ..tree import Tree
|
|
>>> rd_t = Tree("/", RdLeaf("a"), RdLeaf("a*k"))
|
|
>>> print(rd_t)
|
|
/
|
|
> {a}
|
|
> {a*k}
|
|
>>> leafs = extract_rdleaf(rd_t)
|
|
>>> leafs
|
|
['a', 'a*k']
|
|
>>> rd_varia = extract_rv(leafs)
|
|
>>> sorted(list(rd_varia))
|
|
['a', 'k']
|
|
>>> generated = random_generator(rd_varia, conditions=['a%2+1'])
|
|
>>> generated # doctest: +SKIP
|
|
{'a': 7, 'k': 4}
|
|
>>> computed = compute_leafs(leafs, generated)
|
|
>>> computed # doctest: +SKIP
|
|
{'a': 7, 'a*k': 28}
|
|
>>> replaced = replace_rdleaf(rd_t, computed)
|
|
>>> print(replaced) # doctest: +SKIP
|
|
/
|
|
> 7
|
|
> 28
|
|
|
|
List generator
|
|
--------------
|
|
|
|
This function ignores tree structure and works with lists
|
|
|
|
>>> values = list_generator(["a", "a*b", "b", "c"], conditions=["b%c==1"])
|
|
>>> values # doctest: +SKIP
|
|
{'a': -8, 'a*b': -40, 'b': 5, 'c': 4}
|
|
"""
|
|
|
|
__all__ = ["list_generator"]
|
|
|
|
from random import choice
|
|
from functools import reduce
|
|
from .leaf import RdLeaf
|
|
|
|
|
|
def extract_rdleaf(tree):
|
|
""" Extract rdLeaf in a Tree
|
|
|
|
:example:
|
|
>>> from ..tree import Tree
|
|
>>> rd_t = Tree("+", RdLeaf("a"), RdLeaf("a*k"))
|
|
>>> extract_rdleaf(rd_t)
|
|
['a', 'a*k']
|
|
>>> rd_t = Tree("+", RdLeaf("a"), 2)
|
|
>>> extract_rdleaf(rd_t)
|
|
['a']
|
|
"""
|
|
rd_leafs = []
|
|
for leaf in tree.get_leafs():
|
|
try:
|
|
leaf.rdleaf
|
|
except AttributeError:
|
|
pass
|
|
else:
|
|
rd_leafs.append(leaf.name)
|
|
return rd_leafs
|
|
|
|
|
|
def extract_rv(leafs):
|
|
""" Extract the set of random values from the leaf list
|
|
|
|
:param leafs: list of leafs
|
|
:return: set of random values
|
|
|
|
:example:
|
|
>>> leafs = ["a", "a*k"]
|
|
>>> extract_rv(leafs) == {'a', 'k'}
|
|
True
|
|
"""
|
|
rd_values = set()
|
|
for leaf in leafs:
|
|
for c in leaf:
|
|
if c.isalpha():
|
|
rd_values.add(c)
|
|
return rd_values
|
|
|
|
|
|
def compute_leafs(leafs, generated_values):
|
|
""" Compute leafs from generated random values
|
|
|
|
:param generated_values: Dictionnary of name:generated value
|
|
:param leafs: list of leafs
|
|
:return: Dictionnary of evaluated leafs from generated values
|
|
|
|
:example:
|
|
>>> leafs = ["a", "a*k"]
|
|
>>> generated_values = {"a":2, "k":3}
|
|
>>> compute_leafs(leafs, generated_values)
|
|
{'a': 2, 'a*k': 6}
|
|
"""
|
|
return {leaf: eval(leaf, generated_values) for leaf in leafs}
|
|
|
|
|
|
def replace_rdleaf(tree, computed_leafs):
|
|
""" Replace RdLeaf by the corresponding computed value
|
|
|
|
>>> from ..tree import Tree
|
|
>>> rd_t = Tree("+", RdLeaf("a"), RdLeaf("a*k"))
|
|
>>> computed_leafs = {'a': 2, 'a*k': 6}
|
|
>>> print(replace_rdleaf(rd_t, computed_leafs))
|
|
+
|
|
> 2
|
|
> 6
|
|
"""
|
|
|
|
def replace(leaf):
|
|
try:
|
|
return leaf.replace(computed_leafs)
|
|
except AttributeError:
|
|
return leaf
|
|
|
|
return tree.map_on_leaf(replace)
|
|
|
|
|
|
def random_generator(
|
|
rd_variables, conditions=[], rejected=[0], min_max=(-10, 10), variables_scope={}
|
|
):
|
|
""" Generate random variables
|
|
|
|
:param rd_variables: list of random variables to generate
|
|
:param conditions: condition over variables
|
|
: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
|
|
:return: dictionnary of generated variables
|
|
|
|
:example:
|
|
>>> gene = random_generator(["a", "b"],
|
|
... ["a > 0"],
|
|
... [0], (-10, 10),
|
|
... {"a": {"rejected": [0, 1]},
|
|
... "b": {"min_max": (-5, 0)}})
|
|
>>> gene["a"] > 0
|
|
True
|
|
>>> gene["a"] != 0
|
|
True
|
|
>>> gene["b"] < 0
|
|
True
|
|
>>> gene = random_generator(["a", "b"],
|
|
... ["a % b == 0"],
|
|
... [0, 1], (-10, 10))
|
|
>>> gene["a"] not in [0, 1]
|
|
True
|
|
>>> gene["b"] in list(range(-10, 11))
|
|
True
|
|
>>> gene["a"] % gene["b"]
|
|
0
|
|
"""
|
|
complete_scope = build_variable_scope(
|
|
rd_variables, rejected, min_max, variables_scope
|
|
)
|
|
choices_list = {
|
|
v: list(
|
|
set(
|
|
range(
|
|
complete_scope[v]["min_max"][0], complete_scope[v]["min_max"][1] + 1
|
|
)
|
|
).difference(complete_scope[v]["rejected"])
|
|
)
|
|
for v in rd_variables
|
|
}
|
|
|
|
# quantity_choices = reduce(lambda x,y : x*y,
|
|
# [len(choices_list[v]) for v in choices_list])
|
|
# TODO: améliorer la méthode de rejet avec un cache |dim. mai 12 17:04:11 CEST 2019
|
|
|
|
generate_variable = {v: choice(choices_list[v]) for v in rd_variables}
|
|
|
|
while not all([eval(c, __builtins__, generate_variable) for c in conditions]):
|
|
generate_variable = {v: choice(choices_list[v]) for v in rd_variables}
|
|
|
|
return generate_variable
|
|
|
|
|
|
def build_variable_scope(rd_variables, rejected, min_max, variables_scope):
|
|
""" Build variables scope from incomplete one
|
|
|
|
:param rd_variables: list of random variables to generate
|
|
:param rejected: Rejected values for the generator
|
|
:param min_max: (min, max) limits in between variables will be generated
|
|
:param variables_scope: rejected and min_max define for individual variables
|
|
:return: complete variable scope
|
|
|
|
:example:
|
|
>>> completed = build_variable_scope(["a", "b", "c", "d"], [0], (-10, 10),
|
|
... {"a": {"rejected": [0, 1]},
|
|
... "b": {"min_max": (-5, 0)},
|
|
... "c": {"rejected": [2], "min_max": (0, 5)}})
|
|
>>> complete = {'a': {'rejected': [0, 1], 'min_max': (-10, 10)},
|
|
... 'b': {'rejected': [0], 'min_max': (-5, 0)},
|
|
... 'c': {'rejected': [2], 'min_max': (0, 5)},
|
|
... 'd': {'rejected': [0], 'min_max': (-10, 10)}}
|
|
>>> completed == complete
|
|
True
|
|
"""
|
|
complete_scope = variables_scope.copy()
|
|
for v in rd_variables:
|
|
try:
|
|
complete_scope[v]
|
|
except KeyError:
|
|
complete_scope[v] = {"rejected": rejected, "min_max": min_max}
|
|
else:
|
|
try:
|
|
complete_scope[v]["rejected"]
|
|
except KeyError:
|
|
complete_scope[v]["rejected"] = rejected
|
|
try:
|
|
complete_scope[v]["min_max"]
|
|
except KeyError:
|
|
complete_scope[v]["min_max"] = min_max
|
|
return complete_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")
|
|
:param conditions: condition over variables
|
|
: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:
|
|
>>> 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
|
|
>>> 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)
|
|
if dictionnary:
|
|
return generated
|
|
return [generated[v] for v in var_list]
|