Mapytex/mapytex/calculus/API/expression.py

380 lines
10 KiB
Python
Raw Normal View History

2018-01-21 09:21:13 +00:00
#! /usr/bin/env python
# -*- coding: utf-8 -*-
# vim:fenc=utf-8
#
# Copyright © 2017 lafrite <lafrite@Poivre>
#
# Distributed under terms of the MIT license.
"""
Expression
"""
from ..core import AssocialTree, Tree, compute, typing, TypingError
from .tokens import factory
from .renders import renders
2018-01-21 09:21:13 +00:00
class Expression(object):
"""
Expression class
2018-09-17 14:29:00 +00:00
:example:
>>> e = Expression.from_str("2+3*4")
>>> e2 = e.simplify()
>>> print(e2)
14
>>> for s in e2.explain():
... print(s)
2 + 3 * 4
2 + 12
14
2018-01-21 09:21:13 +00:00
"""
RENDER = 'txt'
2018-09-17 14:29:00 +00:00
def __init__(self, tree, ancestor=None):
2018-01-21 09:21:13 +00:00
"""
"""
2018-09-17 14:29:00 +00:00
self._tree = tree
self._ancestor = ancestor
2018-01-21 09:21:13 +00:00
@classmethod
def from_str(cls, string, typing=True):
2018-01-21 09:21:13 +00:00
""" Initiate the expression from a string
2018-09-20 16:27:40 +00:00
:param string: String to parse to generate the Expression
:returns: the expression
2018-01-21 09:21:13 +00:00
:example:
>>> e = Expression.from_str("2 + 3 * 4")
>>> e
<Exp: 2 + 3 * 4>
>>> e = Expression.from_str("2/3")
>>> e
<Fraction 2 / 3>
>>> e = Expression.from_str("2x + 1")
>>> e
<Linear 2x + 1>
>>> e = Expression.from_str("2x + 1 + 5x^2")
>>> e
<Quadratic 2x + 1 + 5x^2>
>>> e = Expression.from_str("2x + 1 + 5x")
>>> e
<Exp: 2x + 1 + 5x>
2018-01-21 09:21:13 +00:00
"""
2018-09-17 14:29:00 +00:00
t = Tree.from_str(string)
if typing:
tt = cls(t)._typing()
try:
return factory(tt)
except TypeError as e:
return cls(t)
2018-09-17 14:29:00 +00:00
return cls(t)
2018-01-21 09:21:13 +00:00
@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
2018-09-17 14:29:00 +00:00
@classmethod
def set_render(cls, render):
""" Define default render function
:param render: render function Tree -> str
:example:
>>> Expression.RENDER
'txt'
2018-09-17 14:29:00 +00:00
>>> e = Expression.from_str("2+3*4")
>>> print(e)
2 + 3 * 4
>>> Expression.set_render('tex')
>>> Expression.RENDER
'tex'
2018-09-17 14:29:00 +00:00
>>> print(e)
2 + 3 \\times 4
>>> Expression.set_render('txt')
2018-09-17 14:29:00 +00:00
"""
cls.RENDER = render
def __str__(self):
return renders[self.RENDER](self._tree)
2018-09-17 14:29:00 +00:00
def __repr__(self):
return f"<Exp: {renders[self.RENDER](self._tree)}>"
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
>>> #print(e._order())
1 + 3 + 2x + 4x
>>> e = Expression.from_str("x + 6x^3 + 1 + 2x^2 + 3 + 4x^2 + 5x")
>>> print(e._order())
x + 5x + 6x^3 + 2x^2 + 4x^2 + 1 + 3
"""
def signature(leaf):
try:
leaf.node
except AttributeError:
try:
return leaf.signature
except AttributeError:
return type(leaf)
else:
try:
typed_leaf = typing(leaf.node, leaf.left_value, leaf.right_value)
return typed_leaf.signature
except (AttributeError, NotImplementedError, TypingError):
return type(leaf)
try:
self._tree.node
except AttributeError:
return self
organised = AssocialTree.from_any_tree(self._tree).\
organise_by(signature, recursive=True, exclude_nodes=exclude_nodes)
return Expression(organised)
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)
+
> +
| > *
| | > 2
| | > ^
| | | > x
| | | > 2
| > *
| | > 2
| | > x
> *
| > 3
| > x
>>> print(e._optimize()._tree)
+
> *
| > 2
| > ^
| | > x
| | > 2
> +
| > *
| | > 2
| | > x
| > *
| | > 3
| | > x
"""
try:
# TODO: need to test exclude_nodes |ven. oct. 5 08:51:02 CEST 2018
return Expression(self._tree.balance(exclude_nodes=exclude_nodes))
except AttributeError:
return self
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(type))
*
> <class 'mapytex.calculus.core.MO.mo.MOnumber'>
> <class 'mapytex.calculus.core.MO.mo.MOstr'>
>>> typed_e = e._typing()
>>> print(type(typed_e._tree))
<class 'mapytex.calculus.core.MO.monomial.MOMonomial'>
>>> typed_e = e._typing()
>>> print(type(typed_e._tree))
<class 'mapytex.calculus.core.MO.monomial.MOMonomial'>
>>> e = Expression.from_str("2x+3+4/5", typing=False)
>>> print(e._tree.map_on_leaf(type))
+
> +
| > *
| | > <class 'mapytex.calculus.core.MO.mo.MOnumber'>
| | > <class 'mapytex.calculus.core.MO.mo.MOstr'>
| > <class 'mapytex.calculus.core.MO.mo.MOnumber'>
> /
| > <class 'mapytex.calculus.core.MO.mo.MOnumber'>
| > <class 'mapytex.calculus.core.MO.mo.MOnumber'>
>>> typed_e = e._typing()
>>> print(typed_e._tree.map_on_leaf(type))
+
> <class 'mapytex.calculus.core.MO.polynomial.MOpolynomial'>
> <class 'mapytex.calculus.core.MO.fraction.MOFraction'>
"""
try:
return Expression(self._tree.apply(typing))
except AttributeError:
return self
def _compute(self):
"""" Compute one step of self
"""
try:
return Expression(self._tree.apply_on_last_level(compute))
except AttributeError:
return self
def set_ancestor(self, ancestor):
""" Set ancestor """
self._ancestor = ancestor
def _simplify(self, optimize=True):
""" Compute as much as possible the expression
:param optimize: bool to optimize tree when it's possible
:return: an expression
:example:
>>> e = Expression.from_str("2+3*4")
>>> e
<Exp: 2 + 3 * 4>
>>> f = e._simplify()
>>> f
<Exp: 14>
>>> f._ancestor
<Exp: 2 + 12>
"""
typed_exp = self._typing()
if optimize:
organized_exp = typed_exp._order()
opt_exp = organized_exp._optimize()
else:
opt_exp = typed_exp
comp_exp = opt_exp._compute()
if typed_exp == comp_exp:
typed_exp.set_ancestor(self._ancestor)
return typed_exp
else:
comp_exp.set_ancestor(self)
return comp_exp._simplify(optimize=optimize)
def simplify(self, optimize=True):
""" Compute as much as possible the expression
:param optimize: bool to optimize tree when it's possible
:return: an expression
:example:
>>> e = Expression.from_str("2+3*4")
>>> e
<Exp: 2 + 3 * 4>
>>> f = e.simplify()
>>> f
<Integer 14>
>>> f._ancestor
<Exp: 2 + 12>
"""
self._child = self._simplify(optimize=optimize)
return factory(self._child, ancestor=self._child._ancestor)
def explain(self):
""" Yield every calculus step which have lead to self
:example:
>>> e = Expression.from_str("2+3*4")
>>> f = e.simplify()
>>> for s in f.explain():
... print(s)
2 + 3 * 4
2 + 12
14
>>> e = Expression.from_str("1+2+3+4+5+6+7+8+9")
>>> f = e.simplify()
>>> for s in f.explain():
... print(s)
1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9
3 + 7 + 11 + 7 + 17
10 + 11 + 24
10 + 35
45
>>> e = Expression.from_str("1+2+3+4+5+6+7+8+9")
>>> f_no_balance = e.simplify(optimize=False)
>>> for s in f_no_balance.explain():
... print(s)
1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9
3 + 3 + 4 + 5 + 6 + 7 + 8 + 9
6 + 4 + 5 + 6 + 7 + 8 + 9
10 + 5 + 6 + 7 + 8 + 9
15 + 6 + 7 + 8 + 9
21 + 7 + 8 + 9
28 + 8 + 9
36 + 9
45
>>> e = Expression.from_str("1+2+3+4+5*6*7*8*9")
>>> f = e.simplify()
>>> for s in f.explain():
... print(s)
1 + 2 + 3 + 4 + 5 * 6 * 7 * 8 * 9
3 + 7 + 30 * 7 * 72
10 + 210 * 72
10 + 15120
15130
>>> e = Expression.from_str("1+2+3+4+5*6*7*8*9")
>>> f_no_balance = e.simplify(optimize=False)
>>> for s in f_no_balance.explain():
... print(s)
1 + 2 + 3 + 4 + 5 * 6 * 7 * 8 * 9
3 + 3 + 4 + 30 * 7 * 8 * 9
6 + 4 + 210 * 8 * 9
10 + 1680 * 9
10 + 15120
15130
>>> e = Expression.from_str("1+2/3/4/5")
>>> f = e.simplify()
>>> for s in f.explain():
... print(s)
1 + 2 / 3 / 4 / 5
1 + (2 / 3 * 1 / 4) / 5
1 + (2 * 1) / (3 * 4) / 5
1 + 2 / 12 / 5
1 + 2 / 12 * 1 / 5
1 + (2 * 1) / (12 * 5)
1 + 2 / 60
1 / 1 + 2 / 60
(1 * 60) / (1 * 60) + 2 / 60
60 / 60 + 2 / 60
(60 + 2) / 60
62 / 60
"""
try:
yield from self._ancestor.explain()
except AttributeError:
yield self
else:
yield self
2018-01-21 09:21:13 +00:00
# -----------------------------
# Reglages pour 'vim'
# vim:set autoindent expandtab tabstop=4 shiftwidth=4:
# cursor: 16 del