Fix a bug in dependencies. Implement support for relational operations.

Author: pearu

numpy/f2py/crackfortran.py

@@ -2701,11 +2701,6 @@ def analyzevars(block):
                                     'required' if is_required else 'optional')
                             if v_attr:
                                 vars[v]['attrspec'] = v_attr
-                    else:
-                        # n is output or hidden argument, hence it
-                        # will depend on all variables in d
-                        n_deps.extend(coeffs_and_deps)
-
                     if coeffs_and_deps is not None:
                         # extend v dependencies with ones specified in attrspec
                         for v, (solver, deps) in coeffs_and_deps.items():
@@ -2716,6 +2711,8 @@ def analyzevars(block):
                                     v_deps.extend(aa[7:-1].split(','))
                             if v_deps:
                                 vars[v]['depend'] = list(set(v_deps))
+                            if n not in v_deps:
+                                n_deps.append(v)
             elif isstring(vars[n]):
                 if 'charselector' in vars[n]:
                     if '*' in vars[n]['charselector']:

numpy/f2py/symbolic.py

@@ -15,7 +15,6 @@
 #
 # TODO: support logical constants (Op.BOOLEAN)
 # TODO: support logical operators (.AND., ...)
-# TODO: support relational operators (<, >, ..., .LT., ...)
 # TODO: support defined operators (.MYOP., ...)
 #
 __all__ = ['Expr']
@@ -50,12 +49,43 @@ class Op(Enum):
     APPLY = 200
     INDEXING = 210
     CONCAT = 220
+    RELATIONAL = 300
     TERMS = 1000
     FACTORS = 2000
     REF = 3000
     DEREF = 3001
 
 
+class RelOp(Enum):
+    """
+    Used in Op.RELATIONAL expression to specify the function part.
+    """
+    EQ = 1
+    NE = 2
+    LT = 3
+    LE = 4
+    GT = 5
+    GE = 6
+
+    @classmethod
+    def fromstring(cls, s, language=Language.C):
+        if language is Language.Fortran:
+            return {'.eq.': RelOp.EQ, '.ne.': RelOp.NE,
+                    '.lt.': RelOp.LT, '.le.': RelOp.LE,
+                    '.gt.': RelOp.GT, '.ge.': RelOp.GE}[s.lower()]
+        return {'==': RelOp.EQ, '!=': RelOp.NE, '<': RelOp.LT,
+                '<=': RelOp.LE, '>': RelOp.GT, '>=': RelOp.GE}[s]
+
+    def tostring(self, language=Language.C):
+        if language is Language.Fortran:
+            return {RelOp.EQ: '.eq.', RelOp.NE: '.ne.',
+                    RelOp.LT: '.lt.', RelOp.LE: '.le.',
+                    RelOp.GT: '.gt.', RelOp.GE: '.ge.'}[self]
+        return {RelOp.EQ: '==', RelOp.NE: '!=',
+                RelOp.LT: '<', RelOp.LE: '<=',
+                RelOp.GT: '>', RelOp.GE: '>='}[self]
+
+
 class ArithOp(Enum):
     """
     Used in Op.APPLY expression to specify the function part.
@@ -77,12 +107,19 @@ class Precedence(Enum):
     """
     Used as Expr.tostring precedence argument.
     """
-    NONE = 0
-    TUPLE = 1
-    SUM = 2
+    ATOM = 0
+    POWER = 1
+    UNARY = 2
     PRODUCT = 3
-    POWER = 4
-    ATOM = 5
+    SUM = 4
+    LT = 6
+    EQ = 7
+    LAND = 11
+    LOR = 12
+    TERNARY = 13
+    ASSIGN = 14
+    TUPLE = 15
+    NONE = 100
 
 
 integer_types = (int,)
@@ -178,6 +215,9 @@ def __init__(self, op, data):
         elif op in (Op.REF, Op.DEREF):
             # data is Expr instance
             assert isinstance(data, Expr)
+        elif op is Op.RELATIONAL:
+            # data is (<relop>, <left>, <right>)
+            assert isinstance(data, tuple) and len(data) == 3
         else:
             raise NotImplementedError(
                 f'unknown op or missing sanity check: {op}')
@@ -341,19 +381,32 @@ def tostring(self, parent_precedence=Precedence.NONE,
                                              language=language)
                                   for a in self.data]
             if language is Language.C:
-                return f'({cond} ? {expr1} : {expr2})'
-            if language is Language.Python:
-                return f'({expr1} if {cond} else {expr2})'
-            if language is Language.Fortran:
-                return f'merge({expr1}, {expr2}, {cond})'
-            raise NotImplementedError(f'tostring for {self.op} and {language}')
+                r = f'({cond} ? {expr1} : {expr2})'
+            elif language is Language.Python:
+                r = f'({expr1} if {cond} else {expr2})'
+            elif language is Language.Fortran:
+                r = f'merge({expr1}, {expr2}, {cond})'
+            else:
+                raise NotImplementedError(
+                    f'tostring for {self.op} and {language}')
+            precedence = Precedence.ATOM
         elif self.op is Op.REF:
-            return '&' + self.data.tostring(language=language)
+            r = '&' + self.data.tostring(Precedence.UNARY, language=language)
+            precedence = Precedence.UNARY
         elif self.op is Op.DEREF:
-            return '*' + self.data.tostring(language=language)
+            r = '*' + self.data.tostring(Precedence.UNARY, language=language)
+            precedence = Precedence.UNARY
+        elif self.op is Op.RELATIONAL:
+            rop, left, right = self.data
+            precedence = (Precedence.EQ if rop in (RelOp.EQ, RelOp.NE)
+                          else Precedence.LT)
+            left = left.tostring(precedence, language=language)
+            right = right.tostring(precedence, language=language)
+            rop = rop.tostring(language=language)
+            r = f'{left} {rop} {right}'
         else:
             raise NotImplementedError(f'tostring for op {self.op}')
-        if parent_precedence.value > precedence.value:
+        if parent_precedence.value < precedence.value:
             # If parent precedence is higher than operand precedence,
             # operand will be enclosed in parenthesis.
             return '(' + r + ')'
@@ -590,7 +643,11 @@ def substitute(self, symbols_map):
             return normalize(Expr(self.op, operands))
         if self.op in (Op.REF, Op.DEREF):
             return normalize(Expr(self.op, self.data.substitute(symbols_map)))
-
+        if self.op is Op.RELATIONAL:
+            rop, left, right = self.data
+            left = left.substitute(symbols_map)
+            right = right.substitute(symbols_map)
+            return normalize(Expr(self.op, (rop, left, right)))
         raise NotImplementedError(f'substitute method for {self.op}: {self!r}')
 
     def traverse(self, visit, *args, **kwargs):
@@ -642,6 +699,11 @@ def traverse(self, visit, *args, **kwargs):
         elif self.op in (Op.REF, Op.DEREF):
             return normalize(Expr(self.op,
                                   self.data.traverse(visit, *args, **kwargs)))
+        elif self.op is Op.RELATIONAL:
+            rop, left, right = self.data
+            left = left.traverse(visit, *args, **kwargs)
+            right = right.traverse(visit, *args, **kwargs)
+            return normalize(Expr(self.op, (rop, left, right)))
         raise NotImplementedError(f'traverse method for {self.op}')
 
     def contains(self, other):
@@ -963,6 +1025,30 @@ def as_deref(expr):
     return Expr(Op.DEREF, expr)
 
 
+def as_eq(left, right):
+    return Expr(Op.RELATIONAL, (RelOp.EQ, left, right))
+
+
+def as_ne(left, right):
+    return Expr(Op.RELATIONAL, (RelOp.NE, left, right))
+
+
+def as_lt(left, right):
+    return Expr(Op.RELATIONAL, (RelOp.LT, left, right))
+
+
+def as_le(left, right):
+    return Expr(Op.RELATIONAL, (RelOp.LE, left, right))
+
+
+def as_gt(left, right):
+    return Expr(Op.RELATIONAL, (RelOp.GT, left, right))
+
+
+def as_ge(left, right):
+    return Expr(Op.RELATIONAL, (RelOp.GE, left, right))
+
+
 def as_terms(obj):
     """Return expression as TERMS expression.
     """
@@ -1257,23 +1343,32 @@ def restore(r):
                     return as_complex(*self.process(operands))
             raise NotImplementedError(
                 f'parsing comma-separated list (context={context}): {r}')
-            return tuple(self.process(restore(r.split(',')), context))
 
         # ternary operation
         m = re.match(r'\A([^?]+)[?]([^:]+)[:](.+)\Z', r)
         if m:
             assert context == 'expr', context
             oper, expr1, expr2 = restore(m.groups())
-            if 0:
-                # TODO: enable this when support for boolean
-                # expressions is fully implemented
-                oper = self.process(oper)
-            else:
-                oper = as_symbol(self.finalize_string(oper))
+            oper = self.process(oper)
             expr1 = self.process(expr1)
             expr2 = self.process(expr2)
             return as_ternary(oper, expr1, expr2)
 
+        # relational expression
+        if self.language is Language.Fortran:
+            m = re.match(
+                r'\A(.+)\s*[.](eq|ne|lt|le|gt|ge)[.]\s*(.+)\Z', r, re.I)
+        else:
+            m = re.match(
+                r'\A(.+)\s*([=][=]|[!][=]|[<][=]|[<]|[>][=]|[>])\s*(.+)\Z', r)
+        if m:
+            left, rop, right = m.groups()
+            if self.language is Language.Fortran:
+                rop = '.' + rop + '.'
+            left, right = self.process(restore((left, right)))
+            rop = RelOp.fromstring(rop, language=self.language)
+            return Expr(Op.RELATIONAL, (rop, left, right))
+
         # keyword argument
         m = re.match(r'\A(\w[\w\d_]*)\s*[=](.*)\Z', r)
         if m:

numpy/f2py/tests/test_symbolic.py

@@ -5,7 +5,7 @@
     as_terms, as_factors, eliminate_quotes, insert_quotes,
     fromstring, as_expr, as_apply,
     as_numer_denom, as_ternary, as_ref, as_deref,
-    normalize
+    normalize, as_eq, as_ne, as_lt, as_gt, as_le, as_ge
     )
 from . import util
 
@@ -100,6 +100,13 @@ def test_sanity(self):
         assert t != u
         assert hash(t) is not None
 
+        e = as_eq(x, y)
+        f = as_lt(x, y)
+        assert e.op == Op.RELATIONAL
+        assert e == e
+        assert e != f
+        assert hash(e) is not None
+
     def test_tostring_fortran(self):
         x = as_symbol('x')
         y = as_symbol('y')
@@ -142,6 +149,12 @@ def test_tostring_fortran(self):
         assert str(Expr(Op.INDEXING, ('f', x))) == 'f[x]'
 
         assert str(as_ternary(x, y, z)) == 'merge(y, z, x)'
+        assert str(as_eq(x, y)) == 'x .eq. y'
+        assert str(as_ne(x, y)) == 'x .ne. y'
+        assert str(as_lt(x, y)) == 'x .lt. y'
+        assert str(as_le(x, y)) == 'x .le. y'
+        assert str(as_gt(x, y)) == 'x .gt. y'
+        assert str(as_ge(x, y)) == 'x .ge. y'
 
     def test_tostring_c(self):
         language = Language.C
@@ -166,6 +179,12 @@ def test_tostring_c(self):
             language=language) == '123 + x + (x - y) / (x + y)'
 
         assert as_ternary(x, y, z).tostring(language=language) == '(x ? y : z)'
+        assert as_eq(x, y).tostring(language=language) == 'x == y'
+        assert as_ne(x, y).tostring(language=language) == 'x != y'
+        assert as_lt(x, y).tostring(language=language) == 'x < y'
+        assert as_le(x, y).tostring(language=language) == 'x <= y'
+        assert as_gt(x, y).tostring(language=language) == 'x > y'
+        assert as_ge(x, y).tostring(language=language) == 'x >= y'
 
     def test_operations(self):
         x = as_symbol('x')
@@ -240,6 +259,8 @@ def test_substitute(self):
 
         assert as_ternary(x, y, z).substitute(
             {x: y + z}) == as_ternary(y + z, y, z)
+        assert as_eq(x, y).substitute(
+            {x: y + z}) == as_eq(y + z, y)
 
     def test_fromstring(self):
 
@@ -319,6 +340,20 @@ def test_fromstring(self):
         assert fromstring('*x * *y') == as_deref(x) * as_deref(y)
         assert fromstring('*x**y') == as_deref(x) * as_deref(y)
 
+        assert fromstring('x == y') == as_eq(x, y)
+        assert fromstring('x != y') == as_ne(x, y)
+        assert fromstring('x < y') == as_lt(x, y)
+        assert fromstring('x > y') == as_gt(x, y)
+        assert fromstring('x <= y') == as_le(x, y)
+        assert fromstring('x >= y') == as_ge(x, y)
+
+        assert fromstring('x .eq. y', language=Language.Fortran) == as_eq(x, y)
+        assert fromstring('x .ne. y', language=Language.Fortran) == as_ne(x, y)
+        assert fromstring('x .lt. y', language=Language.Fortran) == as_lt(x, y)
+        assert fromstring('x .gt. y', language=Language.Fortran) == as_gt(x, y)
+        assert fromstring('x .le. y', language=Language.Fortran) == as_le(x, y)
+        assert fromstring('x .ge. y', language=Language.Fortran) == as_ge(x, y)
+
     def test_traverse(self):
         x = as_symbol('x')
         y = as_symbol('y')
@@ -340,6 +375,7 @@ def replace_visit(s, r=z):
         assert (x + y + z).traverse(replace_visit) == (2 * z + y)
         assert (x + f(y, x - z)).traverse(
             replace_visit) == (z + f(y, as_number(0)))
+        assert as_eq(x, y).traverse(replace_visit) == as_eq(z, y)
 
         # Use traverse to collect symbols, method 1
         function_symbols = set()