not very good render especially with negativ numbers... but can work

pymath/generic.py

@@ -75,6 +75,37 @@ def flatten_list(a, result=None):
 
     return result
 
+def first_elem(ll):
+    """Get the first element in imbricates lists
+    # TODO: Fonction pourrie mais j'ai pas le temps de faire mieux! |mar. janv. 28 22:32:22 CET 2014
+
+    :param list: list of lists of lists...
+    :returns: the first element
+
+    >>> first_elem(1)
+    1
+    >>> first_elem([1,2])
+    1
+    >>> first_elem([["abc"]])
+    'a'
+    >>> first_elem("abc")
+    'a'
+    >>> first_elem([[[1,2],[3,4]], [5,6]])
+    1
+    >>> first_elem([[["ab",2],[3,4]], [5,6]])
+    'a'
+
+    """
+    if hasattr(ll, '__contains__'):
+        if len(ll) == 1 and type(ll) == str:
+            return ll[0]
+        else:
+            return first_elem(ll[0])
+    else:
+        return ll
+
+
+
 def expand_list(list_list):
     """Expand list of list
 
@@ -189,6 +220,7 @@ if __name__ == '__main__':
     import doctest
     doctest.testmod()
 
+
 # -----------------------------
 # Reglages pour 'vim'
 # vim:set autoindent expandtab tabstop=4 shiftwidth=4:

pymath/random_expression.py

@@ -111,12 +111,12 @@ def desc_rdExp(rdExp):
 
 
 if __name__ == '__main__':
-    form = "{a}*-14 / (2*{b}) : -23 / 4"
-    cond = ["{a} + {b} in [1, 2, 3, 4, 5]", "{a} not in [0,1]", "{b} not in [0,1]"]
-    rdExp1 = RdExpression(form, cond)
-    desc_rdExp(rdExp1)
-    rdExp2 = RdExpression(form)
-    desc_rdExp(rdExp2)
+    #form = "{a}*-14 / (2*{b}) : -23 / 4"
+    #cond = ["{a} + {b} in [1, 2, 3, 4, 5]", "{a} not in [0,1]", "{b} not in [0,1]"]
+    #rdExp1 = RdExpression(form, cond)
+    #desc_rdExp(rdExp1)
+    #rdExp2 = RdExpression(form)
+    #desc_rdExp(rdExp2)
     #form = "{a+a/10}x + {a} + 2*{b}"
     #cond = ["{a} + {b} in [1, 2, 3, 4, 5]", "{a} not in [0,1]", "{b} not in [0,1]"]
     #rdExp3 = RdExpression(form)

pymath/render.py

@@ -7,7 +7,7 @@ from .formal import FormalExp
 
 class Render(object):
     """A class which aims to create render functions from three dictionnaries:
-        - op_infix: dict of caracters
+        - op_infix: dict of caracters or two argument functions
         - 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.
@@ -57,7 +57,11 @@ class Render(object):
                     op1 = [self.other["("] ,  op1 , self.other[")"]]
 
                 if token in self.op_infix:
-                    res = flist([op1 , self.op_infix[token] ,  op2])
+                    if type(self.op_infix[token]) == str:
+                        res = flist([op1 , self.op_infix[token] ,  op2])
+                    else:
+                        res = flist([self.op_infix[token](op1, op2)])
+
 
                 elif token in self.op_postfix:
                     res = flist([self.op_postfix[token](op1, op2)])
@@ -73,6 +77,7 @@ class Render(object):
             
         # Manip pour gerer les cas de listes imbriquées dans d'autres listes
         infix_tokens = operandeStack.pop()
+
         if type(infix_tokens) == list or type(infix_tokens) == flist:
             infix_tokens = flatten_list(infix_tokens)
         elif self.isNumerande(infix_tokens):