Mapytex/pymath/render.py

211 lines
7.0 KiB
Python
Raw Normal View History

2013-12-08 20:02:19 +00:00
#!/usr/bin/env python
# encoding: utf-8
from .generic import Stack,flatten_list
from .fraction import Fraction
from .operator import Operator
2013-12-08 20:02:19 +00:00
2014-02-27 17:02:34 +00:00
__all__ = ['Render']
2013-12-08 20:02:19 +00:00
class Render(object):
"""A class which aims to create render functions from three dictionnaries:
- op_infix: dict of caracters or two argument functions
2013-12-08 20:02:19 +00:00
- op_postfix: dict of 2 arguments functions
- other: dict of caracters
Those three dictionnaries while define how a postfix expression will be transform into a string.
"""
PRIORITY = {"^": 4,"*" : 3, "/": 3, ":": 3, "+": 2, "-":2, "(": 1}
2013-12-08 20:02:19 +00:00
2014-02-28 08:43:54 +00:00
def __init__(self, op_infix = {}, op_postfix = {}, other = {}, join = " ", type_render = {str: str, int: str, Fraction: str}):
2013-12-08 20:02:19 +00:00
"""Initiate the render
@param op_infix: the dictionnary of infix operator with how they have to be render
@param op_postfix: the dictionnary of postfix operator with how they have to be render
@param other: other caracters like parenthesis.
2013-12-08 20:38:11 +00:00
@param raw: the caracter for joining the list of tokens (if False then it returns the list of tokens)
@param type_render: how to render number (str or tex for fractions for example)
2013-12-08 20:02:19 +00:00
"""
self.op_infix = op_infix
self.op_postfix = op_postfix
self.other = other
2013-12-08 20:38:11 +00:00
# TODO: there may be issues with PRIORITY if a sign does not appear in PRIORITY
self.join = join
self.type_render = type_render
2013-12-08 20:02:19 +00:00
self.operators = list(self.op_infix.keys()) + list(self.op_postfix.keys()) + list(self.other.keys())
def __call__(self, postfix_tokens):
"""Make the object acting like a function
:param postfix_tokens: the list of postfix tokens to be render
:returns: the render string
"""
operandeStack = Stack()
for token in postfix_tokens:
if self.isOperator(token):
2013-12-08 20:02:19 +00:00
op2 = operandeStack.pop()
if self.needPar(op2, token, "after"):
2013-12-08 20:38:11 +00:00
op2 = [self.other["("] , op2 , self.other[")"]]
2013-12-08 20:02:19 +00:00
op1 = operandeStack.pop()
if self.needPar(op1, token, "before"):
2013-12-08 20:38:11 +00:00
op1 = [self.other["("] , op1 , self.other[")"]]
2013-12-08 20:02:19 +00:00
if token in self.op_infix:
if type(self.op_infix[token]) == str:
res = flist([op1 , self.op_infix[token] , op2])
else:
res = flist([self.op_infix[token](op1, op2)])
2013-12-08 20:02:19 +00:00
elif token in self.op_postfix:
2013-12-08 20:38:11 +00:00
res = flist([self.op_postfix[token](op1, op2)])
2013-12-08 20:02:19 +00:00
# Trick to remember the main op when the render will be done!
res.mainOp = token
operandeStack.push(res)
else:
operandeStack.push(token)
# Manip pour gerer les cas de listes imbriquées dans d'autres listes
2013-12-08 20:02:19 +00:00
infix_tokens = operandeStack.pop()
2013-12-08 20:38:11 +00:00
if type(infix_tokens) == list or type(infix_tokens) == flist:
2013-12-08 20:02:19 +00:00
infix_tokens = flatten_list(infix_tokens)
elif self.isNumerande(infix_tokens):
2013-12-08 20:02:19 +00:00
infix_tokens = [infix_tokens]
2013-12-08 20:38:11 +00:00
if self.join:
return self.join.join(flatten_list([self.render_from_type(t) for t in infix_tokens]))
2013-12-08 20:38:11 +00:00
else:
return infix_tokens
2013-12-08 20:02:19 +00:00
def render_from_type(self, op):
""" If the op is a numerande, it transforms it with type_render conditions
:param op: the operator
:returns: the op transformed if it's necessary
"""
if self.isNumerande(op):
return self.type_render[type(op)](op)
else:
return op
2013-12-08 20:02:19 +00:00
# ---------------------
# Tools for placing parenthesis in infix notation
def needPar(self, operande, operator, posi = "after"):
"""Says whether or not the operande needs parenthesis
:param operande: the operande
:param operator: the operator
:param posi: "after"(default) if the operande will be after the operator, "before" othewise
:returns: bollean
"""
# Si l'operande est negatif
if self.isNumber(operande) \
2014-02-25 16:02:15 +00:00
and operande < 0 \
and posi == "after":
2013-12-08 20:02:19 +00:00
return 1
2014-02-26 11:48:41 +00:00
# Pas de parenthèses si c'est une lettre ou une fraction
elif (type(operande) == str and operande.isalpha()) \
or type(operande) == Fraction:
return 0
2013-12-08 20:02:19 +00:00
elif not self.isNumber(operande):
2014-02-26 11:48:41 +00:00
# Si c'est une grande expression
2013-12-08 20:02:19 +00:00
stand_alone = self.get_main_op(operande)
# Si la priorité de l'operande est plus faible que celle de l'opérateur
minor_priority = self.PRIORITY[self.get_main_op(operande)] < self.PRIORITY[operator]
# Si l'opérateur est - ou / pour after ou / ou ^ pour before
special = (operator in "-/" and posi == "after") or (operator in "/^" and posi == "before")
2013-12-08 20:02:19 +00:00
return stand_alone and (minor_priority or special)
else:
return 0
def get_main_op(self, tokens):
"""Getting the main operation of the list of tokens
:param exp: the list of tokens
:returns: the main operation (+, -, * or /) or 0 if the expression is only one element
"""
if hasattr(tokens, "mainOp"):
return tokens.mainOp
if len(tokens) == 1:
# Si l'expression n'est qu'un élément
return 0
parStack = Stack()
main_op = []
for token in tokens:
if token == "(":
parStack.push(token)
elif token == ")":
parStack.pop()
elif self.isOperator(token) and parStack.isEmpty():
main_op.append(token)
return min(main_op, key = lambda s: self.PRIORITY[s])
## ---------------------
## Recognize numbers and operators
@staticmethod
def isNumber( exp):
"""Check if the expression can be a number which means int or Fraction
2013-12-08 20:02:19 +00:00
:param exp: an expression
:returns: True if the expression can be a number and false otherwise
"""
return type(exp) == int \
or type(exp) == Fraction
#return type(exp) == int or type(exp) == Fraction
2013-12-08 20:02:19 +00:00
@staticmethod
def isNumerande(exp):
"""Check if the expression can be a numerande (not an operator)
:param exp: an expression
:returns: True if the expression can be a number and false otherwise
"""
return type(exp) == int \
2014-02-28 12:16:57 +00:00
or type(exp) == Fraction
2013-12-08 20:02:19 +00:00
def isOperator(self, exp):
"""Check if the expression is in self.operators
:param exp: an expression
:returns: boolean
"""
return (type(exp) == Operator and str(exp) in self.operators)
2014-02-26 11:48:41 +00:00
2013-12-08 20:38:11 +00:00
class flist(list):
"""Fake list- they are used to stock the main operation of an rendered expression"""
2013-12-08 20:02:19 +00:00
pass
2013-12-08 20:38:11 +00:00
2013-12-08 20:02:19 +00:00
# -----------------------------
# Reglages pour 'vim'
# vim:set autoindent expandtab tabstop=4 shiftwidth=4:
# cursor: 16 del