689 lines
17 KiB
Python
689 lines
17 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.
|
|
|
|
"""
|
|
Tree class
|
|
|
|
"""
|
|
|
|
from .tree_tools import (to_nested_parenthesis,
|
|
infix_str_concatenate,
|
|
postfix_concatenate,
|
|
show_tree,
|
|
)
|
|
from .coroutine import *
|
|
from .str2 import str2
|
|
from .operator import OPERATORS
|
|
|
|
__all__ = ["Tree", "MutableTree"]
|
|
|
|
|
|
class Tree(object):
|
|
|
|
"""
|
|
Binary tree
|
|
|
|
This is the chosen structure to manage calculus in PyMath.
|
|
|
|
The class is not mutable to preserve its integrity.
|
|
|
|
"""
|
|
|
|
def __init__(self, node, left_value, right_value):
|
|
"""
|
|
Initiate a tree with tuple (node, (left value, right value))
|
|
|
|
:example:
|
|
|
|
>>> t = Tree("+", 1, 2)
|
|
>>> t.node
|
|
'+'
|
|
>>> t.left_value
|
|
1
|
|
>>> t.right_value
|
|
2
|
|
"""
|
|
if node is None or right_value is None:
|
|
raise TypeError("Tree can't have an empty node or an empty right leaf")
|
|
|
|
self.node = node
|
|
|
|
self.left_value = left_value
|
|
self.right_value = right_value
|
|
|
|
@classmethod
|
|
def from_str(cls, expression):
|
|
""" Initiate a tree from an string expression
|
|
|
|
:example:
|
|
|
|
>>> t = MutableTree.fromStr("2+3*4")
|
|
>>> print(t)
|
|
+
|
|
> 2
|
|
> *
|
|
| > 3
|
|
| > 4
|
|
>>> t = MutableTree.fromStr("(2+3)*4")
|
|
>>> print(t)
|
|
*
|
|
> +
|
|
| > 2
|
|
| > 3
|
|
> 4
|
|
"""
|
|
t = MutableTree.from_str(expression)
|
|
return cls.from_mutable_tree(t)
|
|
|
|
@classmethod
|
|
def from_nested_parenthesis(cls, nested_parenthesis):
|
|
"""
|
|
Initiate recursively a tree with tuple (node, (left value, right value))
|
|
|
|
:example:
|
|
|
|
>>> nested_par = ("+", (1, 2))
|
|
>>> t = Tree.from_nested_parenthesis(nested_par)
|
|
>>> t.node
|
|
'+'
|
|
>>> t.left_value
|
|
1
|
|
>>> t.right_value
|
|
2
|
|
>>> nested_par = ("+", (
|
|
... ("*", (3, 4)),
|
|
... 2))
|
|
>>> t = Tree.from_nested_parenthesis(nested_par)
|
|
>>> t.node
|
|
'+'
|
|
>>> type(t.left_value)
|
|
<class 'mapytex.calculus.core.tree.Tree'>
|
|
>>> t.right_value
|
|
2
|
|
|
|
"""
|
|
try:
|
|
nested_len = len(nested_parenthesis)
|
|
num_len = len(nested_parenthesis[1])
|
|
except TypeError:
|
|
raise ValueError("Nested parenthesis are not composed of lists")
|
|
|
|
if nested_len != 2 and \
|
|
num_len != 2:
|
|
raise ValueError("Nested parenthesis don't have right shape")
|
|
|
|
node = nested_parenthesis[0]
|
|
|
|
try:
|
|
left_value = Tree.from_nested_parenthesis(nested_parenthesis[1][0])
|
|
except ValueError:
|
|
left_value = nested_parenthesis[1][0]
|
|
try:
|
|
right_value = Tree.from_nested_parenthesis(nested_parenthesis[1][1])
|
|
except ValueError:
|
|
right_value = nested_parenthesis[1][1]
|
|
|
|
return cls(node, left_value, right_value)
|
|
|
|
@classmethod
|
|
def from_mutable_tree(cls, mutable_tree):
|
|
""" Initial a Tree from a MutableTree
|
|
|
|
:example:
|
|
>>> t = MutableTree("*", 1, 2)
|
|
>>> print(Tree.from_mutable_tree(t))
|
|
*
|
|
> 1
|
|
> 2
|
|
>>> t1 = MutableTree("*", 1, 2)
|
|
>>> t2 = MutableTree("*", t1, 3)
|
|
>>> print(Tree.from_mutable_tree(t2))
|
|
*
|
|
> *
|
|
| > 1
|
|
| > 2
|
|
> 3
|
|
>>> t = MutableTree("*", 1)
|
|
>>> print(t)
|
|
*
|
|
> 1
|
|
> None
|
|
>>> Tree.from_mutable_tree(t)
|
|
Traceback (most recent call last):
|
|
...
|
|
TypeError: Tree can't have empty node or leaf
|
|
|
|
"""
|
|
node = mutable_tree.node
|
|
left_value = mutable_tree.left_value
|
|
right_value = mutable_tree.right_value
|
|
|
|
if node is None or \
|
|
left_value is None or \
|
|
right_value is None:
|
|
raise TypeError("Tree can't have empty node or leaf")
|
|
|
|
try:
|
|
l_value = Tree.from_mutable_tree(left_value)
|
|
except AttributeError:
|
|
l_value = left_value
|
|
|
|
try:
|
|
r_value = Tree.from_mutable_tree(right_value)
|
|
except AttributeError:
|
|
r_value = right_value
|
|
|
|
return cls(node, l_value, r_value)
|
|
|
|
def map_on_leaf(self, function):
|
|
""" Map on leafs a function
|
|
|
|
:param function: take leaf value returns other value
|
|
:returns: Tree with calculated leaf
|
|
|
|
:example:
|
|
|
|
>>> nested_par = ("+", (
|
|
... ("*", (3, 4)),
|
|
... 2))
|
|
>>> t = Tree.from_nested_parenthesis(nested_par)
|
|
>>> print(t)
|
|
+
|
|
> *
|
|
| > 3
|
|
| > 4
|
|
> 2
|
|
>>> print(t.map_on_leaf(lambda x:2*x))
|
|
+
|
|
> *
|
|
| > 6
|
|
| > 8
|
|
> 4
|
|
|
|
"""
|
|
try:
|
|
left_applied = self.left_value.map_on_leaf(function)
|
|
except AttributeError:
|
|
left_applied = function(self.left_value)
|
|
|
|
try:
|
|
right_applied = self.right_value.map_on_leaf(function)
|
|
except AttributeError:
|
|
right_applied = function(self.right_value)
|
|
|
|
return Tree(self.node, left_applied, right_applied)
|
|
|
|
def apply_on_last_level(self, function):
|
|
""" Apply the function on last level of the tree before leaf
|
|
|
|
:param function: (op, a, a) -> b
|
|
:returns: b if it is a 1 level Tree, Tree otherwise
|
|
|
|
|
|
:example:
|
|
|
|
>>> nested_par = ("+", (
|
|
... ("*", (3, 4)),
|
|
... 2))
|
|
>>> t = Tree.from_nested_parenthesis(nested_par)
|
|
>>> print(t)
|
|
+
|
|
> *
|
|
| > 3
|
|
| > 4
|
|
> 2
|
|
>>> from .tree_tools import infix_str_concatenate
|
|
>>> tt = t.apply_on_last_level(lambda *x: infix_str_concatenate(*x))
|
|
>>> print(tt)
|
|
+
|
|
> 3 * 4
|
|
> 2
|
|
>>> from .evaluate import compute
|
|
>>> tt = t.apply_on_last_level(compute)
|
|
>>> print(tt)
|
|
+
|
|
> 12
|
|
> 2
|
|
>>> ttt = tt.apply_on_last_level(compute)
|
|
>>> print(ttt)
|
|
14
|
|
"""
|
|
left_is_leaf = 0
|
|
right_is_leaf = 0
|
|
try:
|
|
left_applied = self.left_value.apply_on_last_level(function)
|
|
except AttributeError:
|
|
left_applied = self.left_value
|
|
left_is_leaf = 1
|
|
|
|
try:
|
|
right_applied = self.right_value.apply_on_last_level(function)
|
|
except AttributeError:
|
|
right_applied = self.right_value
|
|
right_is_leaf = 1
|
|
|
|
if left_is_leaf and right_is_leaf:
|
|
return function(self.node, self.left_value, self.right_value)
|
|
else:
|
|
return Tree(self.node, left_applied, right_applied)
|
|
|
|
def apply(self, function):
|
|
""" Apply the function on every node of the tree
|
|
|
|
:param function: (op, a, a) -> b
|
|
:returns: b
|
|
|
|
:example:
|
|
|
|
>>> def to_nested(op, left, right):
|
|
... return (op, (left, right))
|
|
>>> nested_par = ("+", (1, 2))
|
|
>>> t = Tree.from_nested_parenthesis(nested_par)
|
|
>>> t.apply(to_nested)
|
|
('+', (1, 2))
|
|
|
|
>>> nested_par = ("+", (
|
|
... ("*", (3, 4)),
|
|
... 2))
|
|
>>> t = Tree.from_nested_parenthesis(nested_par)
|
|
>>> t.apply(to_nested)
|
|
('+', (('*', (3, 4)), 2))
|
|
|
|
>>> from .evaluate import compute
|
|
>>> t.apply(compute)
|
|
14
|
|
|
|
"""
|
|
try:
|
|
left_value = self.left_value.apply(function)
|
|
except AttributeError:
|
|
left_value = self.left_value
|
|
|
|
try:
|
|
right_value = self.right_value.apply(function)
|
|
except AttributeError:
|
|
right_value = self.right_value
|
|
|
|
return function(self.node, left_value, right_value)
|
|
|
|
def to_nested_parenthesis(self):
|
|
""" Transform the Tree into its nested parenthesis description
|
|
:example:
|
|
|
|
>>> nested_par = ("+", (1, 2))
|
|
>>> t = Tree.from_nested_parenthesis(nested_par)
|
|
>>> t.to_nested_parenthesis()
|
|
('+', (1, 2))
|
|
>>> nested_par = ("+", (
|
|
... ("*", (3, 4)),
|
|
... 2))
|
|
>>> t = Tree.from_nested_parenthesis(nested_par)
|
|
>>> t.to_nested_parenthesis()
|
|
('+', (('*', (3, 4)), 2))
|
|
"""
|
|
return self.apply(to_nested_parenthesis)
|
|
|
|
def to_postfix(self):
|
|
""" Transform the Tree into postfix notation
|
|
|
|
:example:
|
|
|
|
>>> nested_par = ("+", (1, 2))
|
|
>>> t = Tree.from_nested_parenthesis(nested_par)
|
|
>>> t.to_postfix()
|
|
[1, 2, '+']
|
|
>>> nested_par = ("+", (
|
|
... ("*", (3, 4)),
|
|
... 2))
|
|
>>> t = Tree.from_nested_parenthesis(nested_par)
|
|
>>> t.to_postfix()
|
|
[3, 4, '*', 2, '+']
|
|
>>> nested_par = ("+", (
|
|
... ("*", (3, 4)),
|
|
... ("*", (5, 6)),
|
|
... ))
|
|
>>> t = Tree.from_nested_parenthesis(nested_par)
|
|
>>> t.to_postfix()
|
|
[3, 4, '*', 5, 6, '*', '+']
|
|
"""
|
|
return self.apply(postfix_concatenate)
|
|
|
|
def __str__(self):
|
|
""" Overload str method
|
|
|
|
:example:
|
|
|
|
>>> nested_par = ("+", (1, 2))
|
|
>>> t = Tree.from_nested_parenthesis(nested_par)
|
|
>>> print(t)
|
|
+
|
|
> 1
|
|
> 2
|
|
>>> nested_par = ("+", (
|
|
... ("*", (3, 4)),
|
|
... 2))
|
|
>>> t = Tree.from_nested_parenthesis(nested_par)
|
|
>>> print(t)
|
|
+
|
|
> *
|
|
| > 3
|
|
| > 4
|
|
> 2
|
|
>>> nested_par = ("+", (
|
|
... ("*", (1, 2)),
|
|
... ("*", (3, 4)),
|
|
... ))
|
|
>>> t = Tree.from_nested_parenthesis(nested_par)
|
|
>>> print(t)
|
|
+
|
|
> *
|
|
| > 1
|
|
| > 2
|
|
> *
|
|
| > 3
|
|
| > 4
|
|
"""
|
|
return self.apply(show_tree)
|
|
|
|
|
|
class MutableTree(Tree):
|
|
|
|
"""
|
|
Mutable Tree.
|
|
|
|
It is used to build a new tree before fixing it into a Tree
|
|
|
|
"""
|
|
def __init__(self,
|
|
node = None,
|
|
left_value = None,
|
|
right_value = None):
|
|
"""
|
|
Initiate a tree with potentialy None values
|
|
|
|
:Example:
|
|
|
|
>>> t = MutableTree()
|
|
>>> t.node, t.left_value, t.right_value
|
|
(None, None, None)
|
|
>>> t = MutableTree('*', 1)
|
|
>>> t.node, t.left_value, t.right_value
|
|
('*', 1, None)
|
|
"""
|
|
|
|
self.node = node
|
|
|
|
self.left_value = left_value
|
|
self.right_value = right_value
|
|
|
|
@classmethod
|
|
def fromStr(cls, expression):
|
|
""" Initiate the MutableTree
|
|
|
|
:example:
|
|
>>> t = MutableTree.fromStr("2+3*4")
|
|
>>> print(t)
|
|
+
|
|
> 2
|
|
> *
|
|
| > 3
|
|
| > 4
|
|
>>> t = MutableTree.fromStr("(2+3)*4")
|
|
>>> print(t)
|
|
*
|
|
> +
|
|
| > 2
|
|
| > 3
|
|
> 4
|
|
>>> t = MutableTree.fromStr("4*(-2+3)")
|
|
>>> print(t)
|
|
*
|
|
> 4
|
|
> +
|
|
| > -
|
|
| | > None
|
|
| | > 2
|
|
| > 3
|
|
"""
|
|
str2mutTree = str2(cls.sink)
|
|
return str2mutTree(expression)
|
|
|
|
@classmethod
|
|
@coroutine
|
|
def sink(cls):
|
|
""" Sink which build a build a mutabletree
|
|
|
|
Returns the built tree when STOOOP is thrown
|
|
|
|
:example:
|
|
>>> sink = MutableTree.sink()
|
|
>>> for i in ["1", "+", "2", "*", "3"]:
|
|
... sink.send(i)
|
|
>>> a = sink.throw(STOOOP)
|
|
>>> print(a)
|
|
+
|
|
> 1
|
|
> *
|
|
| > 2
|
|
| > 3
|
|
>>> sink = MutableTree.sink()
|
|
>>> for i in ["1", "*", "2", "+", "3"]:
|
|
... sink.send(i)
|
|
>>> a = sink.throw(STOOOP)
|
|
>>> print(a)
|
|
+
|
|
> *
|
|
| > 1
|
|
| > 2
|
|
> 3
|
|
>>> sink = MutableTree.sink()
|
|
>>> for i in ["-", "1", "+", "2"]:
|
|
... sink.send(i)
|
|
>>> a = sink.throw(STOOOP)
|
|
>>> print(a)
|
|
+
|
|
> -
|
|
| > None
|
|
| > 1
|
|
> 2
|
|
|
|
"""
|
|
ans = cls()
|
|
try:
|
|
while True:
|
|
c = yield
|
|
if c is not None:
|
|
if c in OPERATORS.keys():
|
|
try:
|
|
ans.set_node(c)
|
|
except ValueError:
|
|
if OPERATORS[c]["precedence"] > OPERATORS[ans.node]["precedence"]:
|
|
ans.append_bot(c)
|
|
else:
|
|
ans.append_top(c)
|
|
else:
|
|
ans.append(c)
|
|
except STOOOP:
|
|
yield ans
|
|
|
|
def set_node(self, value):
|
|
""" Set the node value.
|
|
Once it has been changed it can't be changed again.
|
|
|
|
:example:
|
|
>>> t = MutableTree()
|
|
>>> t.node
|
|
>>> t.set_node("*")
|
|
>>> t.node
|
|
'*'
|
|
>>> t.set_node("+")
|
|
Traceback (most recent call last):
|
|
...
|
|
ValueError: The node of the tree is already set
|
|
"""
|
|
if self.node is None:
|
|
self.node = value
|
|
else:
|
|
raise ValueError("The node of the tree is already set")
|
|
|
|
def set_left_value(self, value):
|
|
""" Set the left value.
|
|
Once it has been changed it can't be changed again.
|
|
|
|
:example:
|
|
>>> t = MutableTree()
|
|
>>> t.left_value
|
|
>>> t.set_left_value(1)
|
|
>>> t.left_value
|
|
1
|
|
>>> t.set_left_value(2)
|
|
Traceback (most recent call last):
|
|
...
|
|
ValueError: The left branch is full, use set_right_value
|
|
"""
|
|
if self.left_value is None:
|
|
self.left_value = value
|
|
else:
|
|
try:
|
|
self.left_value.append(value)
|
|
except AttributeError:
|
|
raise ValueError("The left branch is full, use set_right_value")
|
|
|
|
def set_right_value(self, value):
|
|
""" Set the right value.
|
|
Once it has been changed it can't be changed again.
|
|
|
|
:example:
|
|
>>> t = MutableTree()
|
|
>>> t.right_value
|
|
>>> t.set_right_value(2)
|
|
>>> t.right_value
|
|
2
|
|
>>> t.set_right_value(3)
|
|
Traceback (most recent call last):
|
|
...
|
|
ValueError: The right branch is full, use append_top or append_bot
|
|
>>> # potentielle source de problèmes??
|
|
>>> t = MutableTree()
|
|
>>> t.set_right_value([1])
|
|
>>> t.right_value
|
|
[1]
|
|
>>> t.set_right_value(3)
|
|
"""
|
|
if self.right_value is None:
|
|
self.right_value = value
|
|
else:
|
|
try:
|
|
self.right_value.append(value)
|
|
except AttributeError:
|
|
raise ValueError("The right branch is full, use append_top or append_bot")
|
|
|
|
def append(self, value):
|
|
""" Append the value at the bottom of the tree.
|
|
|
|
In order to enable operator with arity 1, left value can be set only
|
|
before the node is set, assuming that those operator are placed before
|
|
operand.
|
|
|
|
It tries to add it on left branch first.
|
|
If it fails, the value is appened on right branch.
|
|
|
|
:example:
|
|
>>> t = MutableTree()
|
|
>>> t.append(1)
|
|
>>> t.set_node("*")
|
|
>>> t.append(2)
|
|
>>> print(t)
|
|
*
|
|
> 1
|
|
> 2
|
|
>>> t.append(3)
|
|
Traceback (most recent call last):
|
|
...
|
|
ValueError: The right branch is full, use append_top or append_bot
|
|
|
|
>>> t1 = MutableTree()
|
|
>>> t1.append(1)
|
|
>>> t1.set_node("*")
|
|
>>> t2 = MutableTree()
|
|
>>> t1.append(t2)
|
|
>>> t1.append(2)
|
|
>>> t2.set_node("+")
|
|
>>> t1.append(3)
|
|
>>> print(t1)
|
|
*
|
|
> 1
|
|
> +
|
|
| > 2
|
|
| > 3
|
|
|
|
>>> t1 = MutableTree()
|
|
>>> t1.set_node("-")
|
|
>>> t1.append(1)
|
|
>>> print(t1)
|
|
-
|
|
> None
|
|
> 1
|
|
"""
|
|
if self.node is None:
|
|
try:
|
|
self.set_left_value(value)
|
|
except ValueError:
|
|
self.set_right_value(value)
|
|
else:
|
|
self.set_right_value(value)
|
|
|
|
def append_top(self, value):
|
|
""" Append node into the tree at the top
|
|
|
|
:example:
|
|
|
|
>>> t = MutableTree("*", 1, 2)
|
|
>>> t.append_top("+")
|
|
>>> print(t)
|
|
+
|
|
> *
|
|
| > 1
|
|
| > 2
|
|
> None
|
|
"""
|
|
|
|
self_cp = MutableTree()
|
|
self_cp.set_node(self.node)
|
|
self_cp.set_left_value(self.left_value)
|
|
self_cp.set_right_value(self.right_value)
|
|
|
|
self.left_value, self.node, self.right_value = self_cp, value, None
|
|
|
|
def append_bot(self, value):
|
|
""" Append node into the tree at the bottom right_value
|
|
|
|
:example:
|
|
|
|
>>> t = MutableTree("*", 1, 2)
|
|
>>> t.append_bot("+")
|
|
>>> print(t)
|
|
*
|
|
> 1
|
|
> +
|
|
| > 2
|
|
| > None
|
|
"""
|
|
|
|
rv = self.right_value
|
|
nright_value = MutableTree()
|
|
nright_value.set_node(value)
|
|
nright_value.set_left_value(rv)
|
|
|
|
self.right_value = nright_value
|
|
|
|
# -----------------------------
|
|
# Reglages pour 'vim'
|
|
# vim:set autoindent expandtab tabstop=4 shiftwidth=4:
|
|
# cursor: 16 del
|