flake8 corr (not finish yet)
This commit is contained in:
Benjamin Bertrand
parent
b6da1e24a1
commit
edd83fe56a
@ -4,8 +4,7 @@
|
||||
from .explicable import Explicable
|
||||
from .expression import Expression
|
||||
from .operator import op
|
||||
from .generic import spe_zip, expand_list, isNumber, transpose_fill, flatten_list, isPolynom, isNumerand, postfix_op
|
||||
from .render import txt, tex
|
||||
from .generic import spe_zip, isNumber, transpose_fill, flatten_list, isPolynom, postfix_op
|
||||
from functools import wraps
|
||||
|
||||
|
||||
@ -15,7 +14,6 @@ def power_cache(fun):
|
||||
|
||||
@wraps(fun)
|
||||
def cached_fun(self, power):
|
||||
#print("cache -> ", cache)
|
||||
if (tuple(self._coef), power) in cache.keys():
|
||||
return cache[(tuple(self._coef), power)]
|
||||
else:
|
||||
@ -346,8 +344,6 @@ class AbstractPolynom(Explicable):
|
||||
with Expression.tmp_render():
|
||||
coef_steps += list(coef_exp.simplify().explain())
|
||||
|
||||
#print('\t 1.coef_steps -> ', coef_steps)
|
||||
|
||||
else:
|
||||
try:
|
||||
with Expression.tmp_render():
|
||||
@ -355,12 +351,9 @@ class AbstractPolynom(Explicable):
|
||||
except AttributeError:
|
||||
coef_steps = [coef]
|
||||
|
||||
#print('\t 3.coef_steps -> ', coef_steps)
|
||||
# On ajoute toutes ces étapes
|
||||
coefs_steps.append(coef_steps)
|
||||
|
||||
#print('\t coefs_steps -> ', coefs_steps)
|
||||
|
||||
# On retourne la matrice
|
||||
steps = []
|
||||
for coefs in transpose_fill(coefs_steps):
|
||||
@ -586,16 +579,6 @@ class AbstractPolynom(Explicable):
|
||||
def __xor__(self, power):
|
||||
return self.__pow__(power)
|
||||
|
||||
if __name__ == '__main__':
|
||||
P = AbstractPolynom([[1, 2], [3, 4, 5], 6])
|
||||
Q = P.reduce()
|
||||
for i in Q.explain():
|
||||
print(i)
|
||||
|
||||
#import doctest
|
||||
# doctest.testmod()
|
||||
|
||||
|
||||
# -----------------------------
|
||||
# Reglages pour 'vim'
|
||||
# vim:set autoindent expandtab tabstop=4 shiftwidth=4:
|
||||
|
||||
@ -33,7 +33,7 @@ class Explicable(Renderable):
|
||||
2 + 10 \times 4
|
||||
2 + 40
|
||||
42
|
||||
|
||||
|
||||
"""
|
||||
old_s = ''
|
||||
# les étapes pour l'atteindre
|
||||
@ -88,8 +88,11 @@ class Explicable(Renderable):
|
||||
"""
|
||||
self.steps = steps + self.steps
|
||||
|
||||
|
||||
class Explicable_int(int, Explicable):
|
||||
|
||||
""" An Explicable_int is an int which can be explain """
|
||||
|
||||
isNumber = True
|
||||
|
||||
def __init__(self, val):
|
||||
@ -107,8 +110,11 @@ class Explicable_int(int, Explicable):
|
||||
def __tex__(self):
|
||||
return str(self._val)
|
||||
|
||||
|
||||
class Explicable_Decimal(Decimal, Explicable):
|
||||
|
||||
""" An Explicable_Decimal is an decimal which can be explain """
|
||||
|
||||
isNumber = True
|
||||
|
||||
def __init__(self, val):
|
||||
@ -127,7 +133,6 @@ class Explicable_Decimal(Decimal, Explicable):
|
||||
return str(self._val)
|
||||
|
||||
|
||||
|
||||
# -----------------------------
|
||||
# Reglages pour 'vim'
|
||||
# vim:set autoindent expandtab tabstop=4 shiftwidth=4:
|
||||
|
||||
@ -2,9 +2,9 @@
|
||||
# encoding: utf-8
|
||||
|
||||
# debuging
|
||||
#from debug.tools import report
|
||||
# from debug.tools import report
|
||||
|
||||
from .generic import Stack, flatten_list, expand_list, isNumber, isOperator, isNumerand
|
||||
from .generic import flatten_list, expand_list, isOperator, isNumerand
|
||||
from .str2tokens import str2tokens
|
||||
from .operator import op
|
||||
from .explicable import Explicable, Explicable_int, Explicable_Decimal
|
||||
@ -14,6 +14,7 @@ from .random_expression import RdExpression
|
||||
|
||||
__all__ = ['Expression']
|
||||
|
||||
|
||||
def pstf_factory(pstf_tokens):
|
||||
"""Factory which tranform postfix tokens list into an Expression or the simpliest object type ready to be rendered
|
||||
|
||||
@ -38,9 +39,7 @@ def pstf_factory(pstf_tokens):
|
||||
< Fraction 1 / 2>
|
||||
|
||||
"""
|
||||
try:
|
||||
l_pstf_token = len(pstf_tokens)
|
||||
except TypeError:
|
||||
if len(pstf_tokens) == 1:
|
||||
if isinstance(pstf_tokens[0], int):
|
||||
return Explicable_int(pstf_tokens[0])
|
||||
elif isinstance(pstf_tokens[0], Decimal):
|
||||
@ -49,22 +48,9 @@ def pstf_factory(pstf_tokens):
|
||||
return Explicable_Decimal(Decimal(str(pstf_tokens[0])))
|
||||
elif hasattr(pstf_tokens[0], 'STR_RENDER'):
|
||||
return pstf_tokens[0]
|
||||
else:
|
||||
return Expression(self)
|
||||
else:
|
||||
if l_pstf_token == 1:
|
||||
if isinstance(pstf_tokens[0], int):
|
||||
return Explicable_int(pstf_tokens[0])
|
||||
elif isinstance(pstf_tokens[0], Decimal):
|
||||
return Explicable_Decimal(pstf_tokens[0])
|
||||
elif isinstance(pstf_tokens[0], float):
|
||||
return Explicable_Decimal(Decimal(str(pstf_tokens[0])))
|
||||
elif hasattr(pstf_tokens[0], 'STR_RENDER'):
|
||||
return pstf_tokens[0]
|
||||
else:
|
||||
return Expression(self)
|
||||
else:
|
||||
return Expression(pstf_tokens)
|
||||
|
||||
return Expression(pstf_tokens)
|
||||
|
||||
|
||||
class Expression(Explicable):
|
||||
"""A calculus expression. Today it can andle only expression with numbers later it will be able to manipulate unknown"""
|
||||
@ -84,7 +70,6 @@ class Expression(Explicable):
|
||||
|
||||
@classmethod
|
||||
def tmp_render(cls, render=lambda _, x: pstf_factory(x)):
|
||||
# def tmp_render(cls, render=lambda _, x: Expression(x)):
|
||||
""" Same ad tmp_render for Renderable but default render is Expression
|
||||
|
||||
>>> exp = Expression("2*3/5")
|
||||
@ -179,9 +164,9 @@ class Expression(Explicable):
|
||||
try:
|
||||
self.simplified = self.postfix_tokens[0].simplify()
|
||||
except AttributeError:
|
||||
if isinstance(self.postfix_tokens[0],int):
|
||||
if isinstance(self.postfix_tokens[0], int):
|
||||
self.simplified = Explicable_int(self.postfix_tokens[0])
|
||||
elif isinstance(self.postfix_tokens[0],Decimal):
|
||||
elif isinstance(self.postfix_tokens[0], Decimal):
|
||||
self.simplified = Explicable_Decimal(self.postfix_tokens[0])
|
||||
else:
|
||||
self.simplified = self
|
||||
@ -411,36 +396,10 @@ class Expression(Explicable):
|
||||
class ExpressionError(Exception):
|
||||
pass
|
||||
|
||||
|
||||
class ComputeError(Exception):
|
||||
pass
|
||||
|
||||
if __name__ == '__main__':
|
||||
print('\n')
|
||||
A = Expression("( -8 x + 8 ) ( -8 - ( -6 x ) )")
|
||||
Ar = A.simplify()
|
||||
for i in Ar.explain():
|
||||
print(i)
|
||||
# print("------------")
|
||||
# for i in Ar.explain():
|
||||
# print(i)
|
||||
|
||||
# print(type(Ar))
|
||||
|
||||
# print('\n-----------')
|
||||
#A = Expression("-6 / 3 + 10 / -5")
|
||||
#Ar = A.simplify()
|
||||
# for i in Ar.explain():
|
||||
# print(i)
|
||||
|
||||
# print('\n-----------')
|
||||
#A = Expression("1/3 + 4/6")
|
||||
#Ar = A.simplify()
|
||||
# for i in Ar.explain():
|
||||
# print(i)
|
||||
|
||||
#import doctest
|
||||
# doctest.testmod()
|
||||
|
||||
# -----------------------------
|
||||
# Reglages pour 'vim'
|
||||
# vim:set autoindent expandtab tabstop=4 shiftwidth=4:
|
||||
|
||||
@ -6,7 +6,6 @@ from .generic import isNumber, postfix_op
|
||||
from .operator import op
|
||||
from .expression import Expression
|
||||
from .explicable import Explicable
|
||||
from .render import txt, tex
|
||||
from copy import copy
|
||||
|
||||
|
||||
@ -329,7 +328,7 @@ class Fraction(Explicable):
|
||||
if other == 0:
|
||||
exp = Expression([0])
|
||||
elif other == 1:
|
||||
exp = copy(self)
|
||||
exp = copy(self)
|
||||
|
||||
elif isinstance(other, int):
|
||||
gcd1 = gcd(other, self._denom)
|
||||
@ -340,7 +339,7 @@ class Fraction(Explicable):
|
||||
denom_s = [int(self._denom / gcd1), gcd1, op.mul]
|
||||
steps.append(Expression(num_s + denom_s + [op.div]))
|
||||
|
||||
num = [self._num] + [int(other / gcd1), op.mul]* (int(other / gcd1) != 1)
|
||||
num = [self._num] + [int(other / gcd1), op.mul] * (int(other / gcd1) != 1)
|
||||
denom = [int(self._denom / gcd1)]
|
||||
else:
|
||||
num = [self._num, other, op.mul]
|
||||
@ -379,8 +378,8 @@ class Fraction(Explicable):
|
||||
num2 = [number._num]
|
||||
denom1 = [self._denom]
|
||||
|
||||
steps.append(Expression(num1_s + num2_s + [op.mul] + \
|
||||
denom1_s + denom2_s + [op.mul, op.div]))
|
||||
steps.append(Expression(num1_s + num2_s + [op.mul] +
|
||||
denom1_s + denom2_s + [op.mul, op.div]))
|
||||
|
||||
exp = Expression(postfix_op(num1 + num2, op.mul, 1) +
|
||||
postfix_op(denom1 + denom2, op.mul, 1) +
|
||||
@ -527,74 +526,6 @@ class Fraction(Explicable):
|
||||
return Fraction(self._num, self._denom)
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
f = Fraction(1, 12)
|
||||
g = Fraction(6, 12)
|
||||
for i in g.simplify().explain():
|
||||
print("g = ", i)
|
||||
h = Fraction(1, -5)
|
||||
t = Fraction(10, 3)
|
||||
print("---------")
|
||||
for i in (0 + h).explain():
|
||||
print('0 + h = ', i)
|
||||
# print("---------")
|
||||
#print(str(f) , "+", str(t))
|
||||
# for i in (f + t):
|
||||
# print(i)
|
||||
# print("---------")
|
||||
#print(str(f) , "+", str(g))
|
||||
# for i in (f + g):
|
||||
# print(i)
|
||||
# print("---------")
|
||||
#print(str(f) , "-", str(g))
|
||||
# for i in (f - g):
|
||||
# print(i)
|
||||
# print("---------")
|
||||
#print(str(f) , "*", str(g))
|
||||
# for i in (f * g):
|
||||
# print(i)
|
||||
# print("---------")
|
||||
#print(str(h) , "+", str(t))
|
||||
# for i in (h + t):
|
||||
# print(i)
|
||||
# print("---------")
|
||||
#print(str(h) , "-", str(t))
|
||||
# for i in (h - t):
|
||||
# print(i)
|
||||
# print("---------")
|
||||
#print(str(h) , "*", str(t))
|
||||
# for i in (h * t):
|
||||
# print(i)
|
||||
# print("---------")
|
||||
#print("-", str(h) )
|
||||
# for i in (-h):
|
||||
# print(i)
|
||||
# print("---------")
|
||||
#print(str(h) , "/", str(t))
|
||||
# for i in (h / t):
|
||||
# print(i)
|
||||
# print("---------")
|
||||
#print(str(h) , "+", str(0))
|
||||
# for i in (h + 0):
|
||||
# print(i)
|
||||
# print("---------")
|
||||
#print(str(h) , "*", str(1))
|
||||
# for i in (h * 1):
|
||||
# print(i)
|
||||
# print("---------")
|
||||
#print(str(h) , "*", str(0))
|
||||
# for i in (h * 0):
|
||||
# print(i)
|
||||
# print("---------")
|
||||
#print(str(h) , "*", str(4))
|
||||
# for i in (h * 4):
|
||||
# print(i)
|
||||
|
||||
# print(f.simplify())
|
||||
|
||||
import doctest
|
||||
doctest.testmod()
|
||||
|
||||
# -----------------------------
|
||||
# Reglages pour 'vim'
|
||||
# vim:set autoindent expandtab tabstop=4 shiftwidth=4:
|
||||
|
||||
@ -3,6 +3,7 @@
|
||||
|
||||
from .operator import Operator, save_mainOp
|
||||
|
||||
|
||||
class Add(Operator):
|
||||
r""" The operator +
|
||||
|
||||
@ -26,13 +27,13 @@ class Add(Operator):
|
||||
"""
|
||||
|
||||
_CARACT = {
|
||||
"operator" : "+", \
|
||||
"name" : "add",\
|
||||
"priority" : 1, \
|
||||
"arity" : 2, \
|
||||
"actions" : ("__add__","__radd__"), \
|
||||
"txt" : "{op1} + {op2}",\
|
||||
"tex" : "{op1} + {op2}",\
|
||||
"operator": "+",
|
||||
"name": "add",
|
||||
"priority": 1,
|
||||
"arity": 2,
|
||||
"actions": ("__add__", "__radd__"),
|
||||
"txt": "{op1} + {op2}",
|
||||
"tex": "{op1} + {op2}",
|
||||
}
|
||||
|
||||
def __init__(self):
|
||||
@ -50,20 +51,19 @@ class Add(Operator):
|
||||
if args[1][0] == "-":
|
||||
op1 = self.l_parenthesis(args[0], True)
|
||||
op2 = self.r_parenthesis(args[1][1:], True)
|
||||
ans = link.replace('+','-').format(op1 = op1, op2 = op2)
|
||||
ans = link.replace('+', '-').format(op1=op1, op2=op2)
|
||||
|
||||
ans = save_mainOp(ans, self)
|
||||
return ans
|
||||
else:
|
||||
op1 = self.l_parenthesis(args[0], True)
|
||||
op2 = self.r_parenthesis(args[1], True)
|
||||
ans = link.format(op1 = op1, op2 = op2)
|
||||
ans = link.format(op1=op1, op2=op2)
|
||||
|
||||
ans = save_mainOp(ans, self)
|
||||
return ans
|
||||
|
||||
|
||||
|
||||
# -----------------------------
|
||||
# Reglages pour 'vim'
|
||||
# vim:set autoindent expandtab tabstop=4 shiftwidth=4:
|
||||
|
||||
@ -3,6 +3,7 @@
|
||||
|
||||
from .operator import Operator, save_mainOp
|
||||
|
||||
|
||||
class Div(Operator):
|
||||
r""" The operator /
|
||||
|
||||
@ -26,12 +27,12 @@ class Div(Operator):
|
||||
"""
|
||||
|
||||
_CARACT = {
|
||||
"operator" : "/", \
|
||||
"name" : "div",\
|
||||
"priority" : 5, \
|
||||
"arity" : 2, \
|
||||
"txt" : "{op1} / {op2}",\
|
||||
"tex" : "\\frac{{ {op1} }}{{ {op2} }}",\
|
||||
"operator": "/",
|
||||
"name": "div",
|
||||
"priority": 5,
|
||||
"arity": 2,
|
||||
"txt": "{op1} / {op2}",
|
||||
"tex": "\\frac{{ {op1} }}{{ {op2} }}",
|
||||
}
|
||||
|
||||
def __init__(self):
|
||||
@ -43,11 +44,11 @@ class Div(Operator):
|
||||
return op1
|
||||
else:
|
||||
from ..fraction import Fraction
|
||||
return Fraction(op1,op2)
|
||||
return Fraction(op1, op2)
|
||||
|
||||
def __tex__(self, *args):
|
||||
# Pas besoin de parenthèses en plus pour \frac
|
||||
replacement = {"op"+str(i+1): op for (i,op) in enumerate(args)}
|
||||
replacement = {"op"+str(i+1): op for (i, op) in enumerate(args)}
|
||||
|
||||
ans = self.tex.format(**replacement)
|
||||
ans = save_mainOp(ans, self)
|
||||
|
||||
@ -4,6 +4,7 @@
|
||||
|
||||
from .operator import Operator, save_mainOp
|
||||
|
||||
|
||||
class Mul(Operator):
|
||||
r""" The operator *
|
||||
|
||||
@ -30,13 +31,13 @@ class Mul(Operator):
|
||||
"""
|
||||
|
||||
_CARACT = {
|
||||
"operator" : "*", \
|
||||
"name" : "mul",\
|
||||
"priority" : 4, \
|
||||
"arity" : 2, \
|
||||
"actions" : ("__mul__","__rmul__"), \
|
||||
"txt" : "{op1} * {op2}",\
|
||||
"tex" : "{op1} \\times {op2}",\
|
||||
"operator": "*",
|
||||
"name": "mul",
|
||||
"priority": 4,
|
||||
"arity": 2,
|
||||
"actions": ("__mul__", "__rmul__"),
|
||||
"txt": "{op1} * {op2}",
|
||||
"tex": "{op1} \\times {op2}",
|
||||
}
|
||||
|
||||
def __init__(self):
|
||||
@ -106,17 +107,14 @@ class Mul(Operator):
|
||||
op2 = self.r_parenthesis(args[1], True)
|
||||
|
||||
if not self.is_visible(op1, op2):
|
||||
ans = "{op1} {op2}".format(op1 = op1, op2 = op2)
|
||||
ans = "{op1} {op2}".format(op1=op1, op2=op2)
|
||||
else:
|
||||
ans = link.format(op1 = op1, op2 = op2)
|
||||
ans = link.format(op1=op1, op2=op2)
|
||||
|
||||
ans = save_mainOp(ans, self)
|
||||
return ans
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
# -----------------------------
|
||||
# Reglages pour 'vim'
|
||||
# vim:set autoindent expandtab tabstop=4 shiftwidth=4:
|
||||
|
||||
@ -1,17 +1,16 @@
|
||||
#!/usr/bin/env python
|
||||
# encoding: utf-8
|
||||
|
||||
#from debug.tools import report
|
||||
# from debug.tools import report
|
||||
|
||||
from ..generic import flatten_list
|
||||
|
||||
from ..generic import flatten_list, isNumber
|
||||
from functools import wraps
|
||||
import types
|
||||
|
||||
class Operator():
|
||||
|
||||
"""The operator class, is a string (representation of the operator) with its arity"""
|
||||
|
||||
def __init__(self, operator = "", name = "", priority = 0, actions = ("",""), txt = "", tex = "", arity = 2, **kwrds):
|
||||
def __init__(self, operator="", name="", priority=0, actions=("", ""), txt="", tex="", arity=2, **kwrds):
|
||||
""" Create an Operator """
|
||||
self.operator = operator
|
||||
self.name = name
|
||||
@ -29,8 +28,7 @@ class Operator():
|
||||
return getattr(args[0], self.actions)()
|
||||
|
||||
elif self.arity == 2:
|
||||
#if type(args[1]) == int:
|
||||
if issubclass(type(args[1]),int):
|
||||
if issubclass(type(args[1]), int):
|
||||
return getattr(args[0], self.actions[0])(args[1])
|
||||
else:
|
||||
return getattr(args[1], self.actions[1])(args[0])
|
||||
@ -45,12 +43,12 @@ class Operator():
|
||||
"""
|
||||
if self.arity == 1:
|
||||
op1 = self.l_parenthesis(args[0], True)
|
||||
ans = link.format(op1 = op1)
|
||||
ans = link.format(op1=op1)
|
||||
|
||||
elif self.arity == 2:
|
||||
op1 = self.l_parenthesis(args[0], True)
|
||||
op2 = self.r_parenthesis(args[1], True)
|
||||
ans = link.format(op1 = op1, op2 = op2)
|
||||
ans = link.format(op1=op1, op2=op2)
|
||||
|
||||
ans = save_mainOp(ans, self)
|
||||
return ans
|
||||
@ -174,7 +172,7 @@ class Operator():
|
||||
ans = opl
|
||||
elif opl.mainOp.priority < self.priority:
|
||||
ans = flatten_list(["(", opl, ")"])
|
||||
except AttributeError as e:
|
||||
except AttributeError:
|
||||
# op has not the attribute priority
|
||||
pass
|
||||
|
||||
@ -214,6 +212,7 @@ class Operator():
|
||||
except AttributeError:
|
||||
return False
|
||||
|
||||
|
||||
def save_mainOp(obj, mainOp):
|
||||
"""Create a temporary class build over built-in type to stock the main operation of a calculus
|
||||
|
||||
|
||||
@ -2,7 +2,6 @@
|
||||
# encoding: utf-8
|
||||
|
||||
|
||||
import types
|
||||
from .add import Add
|
||||
from .div import Div
|
||||
from .mul import Mul
|
||||
@ -20,7 +19,7 @@ class Operator_set(object):
|
||||
""" Initiate the operator_set """
|
||||
self._operators = {}
|
||||
|
||||
def get_op(self, op, arity = 2):
|
||||
def get_op(self, op, arity=2):
|
||||
r"""Return the corresponding operator
|
||||
|
||||
:op: symbole of the op
|
||||
@ -31,7 +30,7 @@ class Operator_set(object):
|
||||
>>> op.get_op('+')
|
||||
+
|
||||
>>> mul = op.get_op('*')
|
||||
Traceback (most recent call last):
|
||||
Traceback (most recent call last):
|
||||
...
|
||||
KeyError: '* (arity: 2) is not available'
|
||||
>>> op.store_operator(Mul())
|
||||
@ -42,7 +41,7 @@ class Operator_set(object):
|
||||
'{op1} * {op2}'
|
||||
>>> op.store_operator(Sub1())
|
||||
>>> sub1 = op.get_op('-')
|
||||
Traceback (most recent call last):
|
||||
Traceback (most recent call last):
|
||||
...
|
||||
KeyError: '- (arity: 2) is not available'
|
||||
>>> sub1 = op.get_op('-', 1)
|
||||
@ -52,7 +51,7 @@ class Operator_set(object):
|
||||
try:
|
||||
return getattr(self, self._operators[(op, arity)])
|
||||
except KeyError:
|
||||
raise KeyError("{theOp} (arity: {arity}) is not available".format(theOp = op, arity = arity))
|
||||
raise KeyError("{theOp} (arity: {arity}) is not available".format(theOp=op, arity=arity))
|
||||
|
||||
def available_op(self):
|
||||
""" Get the set of available operators strings
|
||||
@ -72,8 +71,7 @@ class Operator_set(object):
|
||||
return set([i[0] for i in self._operators])
|
||||
|
||||
def can_be_operator(cls, symbole):
|
||||
r"""
|
||||
Tell if the symbole can be an operator
|
||||
r"""Tell if the symbole can be an operator
|
||||
|
||||
>>> op = Operator_set()
|
||||
>>> op.can_be_operator("+")
|
||||
@ -81,7 +79,7 @@ class Operator_set(object):
|
||||
>>> op.store_operator(Add())
|
||||
>>> op.can_be_operator("+")
|
||||
True
|
||||
|
||||
|
||||
"""
|
||||
if type(symbole) == str:
|
||||
return symbole in [i[0] for i in cls._operators]
|
||||
@ -89,7 +87,7 @@ class Operator_set(object):
|
||||
return False
|
||||
|
||||
def store_operator(self, operator):
|
||||
""" Save the operator as a method and
|
||||
""" Save the operator as a method and
|
||||
|
||||
:param operator: the operator (the class) (it will be accessible through .name method name.
|
||||
|
||||
@ -105,7 +103,7 @@ class Operator_set(object):
|
||||
>>> a.tex
|
||||
'{op1} + {op2}'
|
||||
>>> op.store_operator("+")
|
||||
Traceback (most recent call last):
|
||||
Traceback (most recent call last):
|
||||
...
|
||||
ValueError: + is not en Operator it's a <class 'str'>
|
||||
"""
|
||||
|
||||
@ -4,7 +4,6 @@
|
||||
|
||||
from .expression import Expression
|
||||
from .operator import op
|
||||
from .generic import isNumerand
|
||||
from .random_expression import RdExpression
|
||||
from .abstract_polynom import AbstractPolynom
|
||||
|
||||
@ -182,8 +181,6 @@ for name, func in inspect.getmembers(Polynom):
|
||||
setattr(Polynom, name, polynom_factory(func))
|
||||
|
||||
|
||||
|
||||
|
||||
# -----------------------------
|
||||
# Reglages pour 'vim'
|
||||
# vim:set autoindent expandtab tabstop=4 shiftwidth=4:
|
||||
|
||||
@ -242,23 +242,6 @@ class Polynom_deg2(Polynom):
|
||||
return "\\tkzTabVar{-/{}, +/{$" + str(beta) + "$}, -/{}}"
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
#from .render import txt
|
||||
# with Expression.tmp_render(txt):
|
||||
# P = Polynom_deg2([2, 3, 4])
|
||||
# print(P)
|
||||
|
||||
# print("\nDelta")
|
||||
# for i in P.delta.explain():
|
||||
# print(i)
|
||||
# print("\nBeta")
|
||||
# for i in P.beta.explain():
|
||||
# print(i)
|
||||
|
||||
import doctest
|
||||
doctest.testmod()
|
||||
|
||||
|
||||
# -----------------------------
|
||||
# Reglages pour 'vim'
|
||||
# vim:set autoindent expandtab tabstop=4 shiftwidth=4:
|
||||
|
||||
@ -6,8 +6,6 @@ import re
|
||||
import pyparsing
|
||||
from .generic import flatten_list
|
||||
|
||||
from .arithmetic import gcd
|
||||
|
||||
|
||||
def random_str(form, conditions=[], val_min=-10, val_max=10):
|
||||
""" Create a random string using RdExpression class """
|
||||
@ -41,9 +39,6 @@ class RdExpression(object):
|
||||
:returns: set for elements which have to be replaced
|
||||
|
||||
"""
|
||||
# pattern = "\{(.*?)\}" #select inside {} non greedy way
|
||||
#varia_form = re.findall(pattern, self._form)
|
||||
|
||||
# TODO: Bug with varia with spaces |dim. nov. 23 10:44:34 CET 2014
|
||||
varia_form = flatten_list([eval(str(i[0])) for i in pyparsing.nestedExpr(
|
||||
'{', '}').searchString(self._form)])
|
||||
@ -157,31 +152,6 @@ def desc_rdExp(rdExp):
|
||||
print('')
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
form = "({a};{b})"
|
||||
cond = []
|
||||
print(random_str(form, cond))
|
||||
|
||||
form = "{a+a*10}*4 + {a} + 2*{b}"
|
||||
cond = [
|
||||
"{a} + {b} in [1, 2, 3, 4, 5]",
|
||||
"abs({a}) not in [1]",
|
||||
"{b} not in [1]",
|
||||
"gcd({a},{b}) == 1"]
|
||||
print(random_str(form, cond))
|
||||
|
||||
form = "{a+a*10}*4 + {a} + 2*{b}"
|
||||
cond = [
|
||||
"{a-b} + {b} in list(range(20))",
|
||||
"abs({a}) not in [1]",
|
||||
"{b} not in [1]",
|
||||
"gcd({a},{b}) == 1"]
|
||||
print(random_str(form, cond))
|
||||
|
||||
import doctest
|
||||
doctest.testmod()
|
||||
|
||||
|
||||
# -----------------------------
|
||||
# Reglages pour 'vim'
|
||||
# vim:set autoindent expandtab tabstop=4 shiftwidth=4:
|
||||
|
||||
@ -56,6 +56,7 @@ def txt_render(token):
|
||||
|
||||
txt = Render(txt_render)
|
||||
|
||||
|
||||
def tex_render(token):
|
||||
def render(*args):
|
||||
try:
|
||||
@ -65,6 +66,7 @@ def tex_render(token):
|
||||
return render
|
||||
tex = Render(tex_render)
|
||||
|
||||
|
||||
def p2i_render(token):
|
||||
def render(*args):
|
||||
try:
|
||||
@ -74,6 +76,7 @@ def p2i_render(token):
|
||||
return render
|
||||
p2i = Render(p2i_render)
|
||||
|
||||
|
||||
class Renderable(object):
|
||||
"""
|
||||
A Renderable object is an object which can work with Render class. It means that it has to have attribute postfix_tokens.
|
||||
|
||||
@ -1,12 +1,12 @@
|
||||
#!/usr/bin/env python
|
||||
# encoding: utf-8
|
||||
|
||||
from .generic import Stack, isOperator, isNumber, isPolynom
|
||||
from .generic import Stack, isNumber, isPolynom
|
||||
from .operator import op
|
||||
from decimal import Decimal
|
||||
|
||||
import logging
|
||||
#logging.basicConfig(filename='str2tokens_debug.log',level=logging.DEBUG)
|
||||
# logging.basicConfig(filename='str2tokens_debug.log',level=logging.DEBUG)
|
||||
|
||||
|
||||
def str2tokens(exp):
|
||||
@ -46,7 +46,7 @@ def str2in_tokens(exp):
|
||||
|
||||
for character in exp:
|
||||
if character.isdigit():
|
||||
tokens += feed_digit(character, tokens.pop(), tokens[-1])
|
||||
tokens += feed_digit(character, tokens.pop(), tokens[-1])
|
||||
|
||||
elif character == "(":
|
||||
tokens += hidden_meaning_time(tokens[-1])
|
||||
@ -70,6 +70,7 @@ def str2in_tokens(exp):
|
||||
|
||||
return tokens[2:]
|
||||
|
||||
|
||||
def feed_digit(character, tok_b, tok_bb):
|
||||
""" Feed token when a digit is detected
|
||||
|
||||
@ -117,6 +118,7 @@ def feed_digit(character, tok_b, tok_bb):
|
||||
else:
|
||||
return [tok_b, int(character)]
|
||||
|
||||
|
||||
def hidden_meaning_time(tok_b):
|
||||
""" Return a "*" character if it is hidden meaning
|
||||
|
||||
@ -141,6 +143,7 @@ def hidden_meaning_time(tok_b):
|
||||
return ["*"]
|
||||
return []
|
||||
|
||||
|
||||
def feed_alpha(character):
|
||||
""" Feed token when an alpha character is detected
|
||||
|
||||
@ -152,6 +155,7 @@ def feed_alpha(character):
|
||||
from pymath.calculus.polynom import Polynom
|
||||
return Polynom([0, 1], letter=character)
|
||||
|
||||
|
||||
def feed_dot(tok_b):
|
||||
r""" Build Decimal with the previous token
|
||||
|
||||
@ -202,7 +206,11 @@ def in2post_fix(infix_tokens):
|
||||
|
||||
for (pos_token, token) in enumerate(infix_tokens):
|
||||
|
||||
logging.debug(str(postfix_tokens)+ " | "+ str(opStack)+ " | "+ str(infix_tokens[(pos_token+1):])+ " | "+ str(arity_Stack))
|
||||
logging.debug(str(postfix_tokens) +
|
||||
" | " + str(opStack) +
|
||||
" | " + str(infix_tokens[(pos_token+1):]) +
|
||||
" | " + str(arity_Stack)
|
||||
)
|
||||
if token == ")":
|
||||
next_op = opStack.pop()
|
||||
while next_op != op.par:
|
||||
@ -217,7 +225,7 @@ def in2post_fix(infix_tokens):
|
||||
|
||||
elif op.can_be_operator(token):
|
||||
if token == "(":
|
||||
opStack.push(op.get_op(token,0))
|
||||
opStack.push(op.get_op(token, 0))
|
||||
# Set next arity counter
|
||||
arity_Stack.push(0)
|
||||
else:
|
||||
@ -232,19 +240,27 @@ def in2post_fix(infix_tokens):
|
||||
postfix_tokens.append(next_op)
|
||||
|
||||
opStack.push(token_op)
|
||||
logging.debug("--"+ token+ " -> "+ str(arity + 1))
|
||||
logging.debug("--" + token + " -> " + str(arity + 1))
|
||||
else:
|
||||
postfix_tokens.append(token)
|
||||
arity = arity_Stack.pop()
|
||||
arity_Stack.push(arity + 1)
|
||||
|
||||
logging.debug(str(postfix_tokens)+ " | "+ str(opStack)+ " | "+ str(infix_tokens[(pos_token+1):])+ " | "+ str(arity_Stack))
|
||||
logging.debug(str(postfix_tokens) +
|
||||
" | " + str(opStack) +
|
||||
" | " + str(infix_tokens[(pos_token+1):]) +
|
||||
" | " + str(arity_Stack)
|
||||
)
|
||||
|
||||
while not opStack.isEmpty():
|
||||
next_op = opStack.pop()
|
||||
postfix_tokens.append(next_op)
|
||||
|
||||
logging.debug(str(postfix_tokens)+ " | "+ str(opStack)+ " | "+ str(infix_tokens[(pos_token+1):])+ " | "+ str(arity_Stack))
|
||||
logging.debug(str(postfix_tokens) +
|
||||
" | " + str(opStack) +
|
||||
" | " + str(infix_tokens[(pos_token+1):]) +
|
||||
" | " + str(arity_Stack)
|
||||
)
|
||||
|
||||
if arity_Stack.peek() != 1:
|
||||
raise ValueError(
|
||||
@ -255,29 +271,6 @@ def in2post_fix(infix_tokens):
|
||||
return postfix_tokens
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
#a, s, m, d, p = Operator("+"), Operator("-"), Operator("*"), Operator("/"), Operator("^")
|
||||
#in_tokens = str2in_tokens("2+3*4")
|
||||
#print("\t in_tokens :" + str(in_tokens))
|
||||
#
|
||||
# print(in2post_fix(in_tokens))
|
||||
|
||||
#print(in2post_fix([op.par, 2, op.add, 5, op.sub, 1, ')', op.div, op.par, 3, op.mul, 4, ')']))
|
||||
#print(in2post_fix([op.sub1, op.par, op.sub1, 2, ')']))
|
||||
#print(in2post_fix([op.sub1, op.par, op.sub1, 2, op.add, 3, op.mul, 4, ')']))
|
||||
|
||||
print(str2tokens('2*3+4'))
|
||||
print("\n------")
|
||||
print(str2tokens('2x+4'))
|
||||
print("\n------")
|
||||
print(str2tokens('xx+4'))
|
||||
print("\n------")
|
||||
print(str2tokens('x(2+1)+4'))
|
||||
print("\n------")
|
||||
#import doctest
|
||||
# doctest.testmod()
|
||||
|
||||
|
||||
# -----------------------------
|
||||
# Reglages pour 'vim'
|
||||
# vim:set autoindent expandtab tabstop=4 shiftwidth=4:
|
||||
|
||||
Loading…
Reference in New Issue
Block a user