diff options
| -rwxr-xr-x | numpy/f2py/crackfortran.py | 4 | ||||
| -rw-r--r-- | numpy/f2py/symbolic.py | 449 | ||||
| -rw-r--r-- | numpy/f2py/tests/test_symbolic.py | 67 |
3 files changed, 348 insertions, 172 deletions
diff --git a/numpy/f2py/crackfortran.py b/numpy/f2py/crackfortran.py index 8cb1f73d2..2adca9fba 100755 --- a/numpy/f2py/crackfortran.py +++ b/numpy/f2py/crackfortran.py @@ -2609,8 +2609,8 @@ def analyzevars(block): # not defined in block['vars']. Here we assume # these correspond to Fortran/C intrinsic # functions or that are defined by other - # means. We'll let the compiler to validate - # the definiteness of such symbols. + # means. We'll let the compiler validate the + # definiteness of such symbols. dimension_exprs[d] = solver_and_deps vars[n]['dimension'].append(d) diff --git a/numpy/f2py/symbolic.py b/numpy/f2py/symbolic.py index 56faa309c..0a2c3ba04 100644 --- a/numpy/f2py/symbolic.py +++ b/numpy/f2py/symbolic.py @@ -46,11 +46,14 @@ class Op(Enum): STRING = 20 ARRAY = 30 SYMBOL = 40 + TERNARY = 100 APPLY = 200 INDEXING = 210 CONCAT = 220 TERMS = 1000 FACTORS = 2000 + REF = 3000 + DEREF = 3001 class ArithOp(Enum): @@ -114,10 +117,10 @@ class Expr: """ @staticmethod - def parse(s): + def parse(s, language=Language.C): """Parse a Fortran expression to a Expr. """ - return fromstring(s) + return fromstring(s, language=language) def __init__(self, op, data): assert isinstance(op, Op) @@ -169,6 +172,12 @@ class Expr: assert isinstance(data, tuple) and len(data) == 2 # function is any hashable object assert hash(data[0]) is not None + elif op is Op.TERNARY: + # data is (<cond>, <expr1>, <expr2>) + assert isinstance(data, tuple) and len(data) == 3 + elif op in (Op.REF, Op.DEREF): + # data is Expr instance + assert isinstance(data, Expr) else: raise NotImplementedError( f'unknown op or missing sanity check: {op}') @@ -327,6 +336,21 @@ class Expr: for arg in self.data] r = " // ".join(args) precedence = Precedence.PRODUCT + elif self.op is Op.TERNARY: + cond, expr1, expr2 = [a.tostring(Precedence.TUPLE, + 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}') + elif self.op is Op.REF: + return '&' + self.data.tostring(language=language) + elif self.op is Op.DEREF: + return '*' + self.data.tostring(language=language) else: raise NotImplementedError(f'tostring for op {self.op}') if parent_precedence.value > precedence.value: @@ -561,6 +585,12 @@ class Expr: func = func.substitute(symbols_map) args = tuple(a.substitute(symbols_map) for a in self.data[1:]) return normalize(Expr(self.op, (func,) + args)) + if self.op is Op.TERNARY: + operands = tuple(a.substitute(symbols_map) for a in self.data) + return normalize(Expr(self.op, operands)) + if self.op in (Op.REF, Op.DEREF): + return normalize(Expr(self.op, self.data.substitute(symbols_map))) + raise NotImplementedError(f'substitute method for {self.op}: {self!r}') def traverse(self, visit, *args, **kwargs): @@ -579,7 +609,7 @@ class Expr: if self.op in (Op.INTEGER, Op.REAL, Op.STRING, Op.SYMBOL): return self - elif self.op in (Op.COMPLEX, Op.ARRAY, Op.CONCAT): + elif self.op in (Op.COMPLEX, Op.ARRAY, Op.CONCAT, Op.TERNARY): return normalize(Expr(self.op, tuple( item.traverse(visit, *args, **kwargs) for item in self.data))) @@ -609,6 +639,9 @@ class Expr: indices = tuple(index.traverse(visit, *args, **kwargs) for index in self.data[1:]) return normalize(Expr(self.op, (obj,) + indices)) + elif self.op in (Op.REF, Op.DEREF): + return normalize(Expr(self.op, + self.data.traverse(visit, *args, **kwargs))) raise NotImplementedError(f'traverse method for {self.op}') def contains(self, other): @@ -813,6 +846,13 @@ def normalize(obj): if len(lst) == 1: return lst[0] return Expr(Op.CONCAT, tuple(lst)) + + if obj.op is Op.TERNARY: + cond, expr1, expr2 = map(normalize, obj.data) + if cond.op is Op.INTEGER: + return expr1 if cond.data[0] else expr2 + return Expr(Op.TERNARY, (cond, expr1, expr2)) + return obj @@ -905,6 +945,24 @@ def as_apply(func, *args, **kwargs): dict((k, as_expr(v)) for k, v in kwargs.items()))) +def as_ternary(cond, expr1, expr2): + """Return object as TERNARY expression (cond?expr1:expr2). + """ + return Expr(Op.TERNARY, (cond, expr1, expr2)) + + +def as_ref(expr): + """Return object as referencing expression. + """ + return Expr(Op.REF, expr) + + +def as_deref(expr): + """Return object as dereferencing expression. + """ + return Expr(Op.DEREF, expr) + + def as_terms(obj): """Return expression as TERMS expression. """ @@ -967,7 +1025,8 @@ def as_numer_denom(obj): """ if isinstance(obj, Expr): obj = normalize(obj) - if obj.op in (Op.INTEGER, Op.REAL, Op.COMPLEX, Op.SYMBOL, Op.INDEXING): + if obj.op in (Op.INTEGER, Op.REAL, Op.COMPLEX, Op.SYMBOL, + Op.INDEXING, Op.TERNARY): return obj, as_number(1) elif obj.op is Op.APPLY: if obj.data[0] is ArithOp.DIV and not obj.data[2]: @@ -1017,8 +1076,8 @@ def _counter(): COUNTER = _counter() -def replace_quotes(s): - """Replace quoted substrings of input. +def eliminate_quotes(s): + """Replace quoted substrings of input string. Return a new string and a mapping of replacements. """ @@ -1030,15 +1089,31 @@ def replace_quotes(s): # remove trailing underscore kind = kind[:-1] p = {"'": "SINGLE", '"': "DOUBLE"}[value[0]] - k = f'@__f2py_QUOTES_{p}_{COUNTER.__next__()}@' - d[as_symbol(k)] = as_string(value, kind or 1) + k = f'{kind}@__f2py_QUOTES_{p}_{COUNTER.__next__()}@' + d[k] = value return k - return (re.sub(r'({kind}_|)({single_quoted}|{double_quoted})'.format( + new_s = re.sub(r'({kind}_|)({single_quoted}|{double_quoted})'.format( kind=r'\w[\w\d_]*', single_quoted=r"('([^'\\]|(\\.))*')", double_quoted=r'("([^"\\]|(\\.))*")'), - repl, s), d) + repl, s) + + assert '"' not in new_s + assert "'" not in new_s + + return new_s, d + + +def insert_quotes(s, d): + """Inverse of eliminate_quotes. + """ + for k, v in d.items(): + kind = k[:k.find('@')] + if kind: + kind += '_' + s = s.replace(k, kind + v) + return s def replace_parenthesis(s): @@ -1084,21 +1159,32 @@ def replace_parenthesis(s): return s[:i] + k + r, d -def fromstring(s): - """Create an expression from string. +def _get_parenthesis_kind(s): + assert s.startswith('@__f2py_PARENTHESIS_'), s + return s.split('_')[4] - This is a "lazy" parser, that is, only arithmetic operations are - resolved, non-arithmetic operations are treated as symbols. + +def unreplace_parenthesis(s, d): + """Inverse of replace_parenthesis. """ - # We replace string literal constants that may include parenthesis - # that may confuse the arithmetic expression parser. - s, quotes_map = replace_quotes(s) + for k, v in d.items(): + p = _get_parenthesis_kind(k) + left = dict(ROUND='(', SQUARE='[', CURLY='{', ROUNDDIV='(/')[p] + right = dict(ROUND=')', SQUARE=']', CURLY='}', ROUNDDIV='/)')[p] + s = s.replace(k, left + v + right) + return s - # Apply arithmetic expression parser. - r = _fromstring_worker(s) - # Restore string constants. - return r.substitute(quotes_map) +def fromstring(s, language=Language.C): + """Create an expression from a string. + + This is a "lazy" parser, that is, only arithmetic operations are + resolved, non-arithmetic operations are treated as symbols. + """ + r = _FromStringWorker(language=language).parse(s) + if isinstance(r, Expr): + return r + raise ValueError(f'failed to parse `{s}` to Expr instance: got `{r}`') class _Pair: @@ -1120,151 +1206,210 @@ class _Pair: return f'{type(self).__name__}({self.left}, {self.right})' -def _fromstring_worker(s, dummy=None): - # Internal method used by fromstring to convert a string of - # arithmetic expressions to an expression tree. +class _FromStringWorker: - # Replace subexpression enclosed in parenthesis with dummy symbols - # and recursively parse subexpression into symbol-expression map: - r, raw_symbols_map = replace_parenthesis(s) - r = r.strip() + def __init__(self, language=Language.C): + self.original = None + self.quotes_map = None + self.language = language - symbols_map = dict([(as_symbol(k), _fromstring_worker(v)) - for k, v in raw_symbols_map.items()]) + def finalize_string(self, s): + return insert_quotes(s, self.quotes_map) - if ',' in r: - # comma-separate tuple of expressions - return tuple(_fromstring_worker(r_).substitute(symbols_map) - for r_ in r.split(',')) + def parse(self, inp): + self.original = inp + unquoted, self.quotes_map = eliminate_quotes(inp) + return self.process(unquoted) - m = re.match(r'\A(\w[\w\d_]*)\s*[=](.*)\Z', r) - if m: - # keyword argument - keyname, value = m.groups() - return _Pair(keyname, - _fromstring_worker(value).substitute(symbols_map)) - - operands = re.split(r'((?<!\d[edED])[+-])', r) - if len(operands) > 1: - # Expression is an arithmetic sum - result = _fromstring_worker(operands[0] or '0') - for op, operand in zip(operands[1::2], operands[2::2]): - op = op.strip() - if op == '+': - result += _fromstring_worker(operand) - else: - assert op == '-' - result -= _fromstring_worker(operand) - return result.substitute(symbols_map) - - operands = re.split(r'//', r) - if len(operands) > 1: - # Expression is string concatenate operation - return Expr(Op.CONCAT, - tuple(_fromstring_worker(operand).substitute(symbols_map) - for operand in operands)) - - operands = re.split(r'([*]|/)', r.replace('**', '@__f2py_DOUBLE_STAR@')) - operands = [operand.replace('@__f2py_DOUBLE_STAR@', '**') - for operand in operands] - if len(operands) > 1: - # Expression is an arithmetic product - result = _fromstring_worker(operands[0]) - for op, operand in zip(operands[1::2], operands[2::2]): - op = op.strip() - if op == '*': - result *= _fromstring_worker(operand) + def process(self, s, context='expr'): + """Parse string within the given context. + + The context may define the result in case of ambiguous + expressions. For instance, consider expressions `f(x, y)` and + `(x, y) + (a, b)` where `f` is a function and pair `(x, y)` + denotes complex number. Specifying context as "args" or + "expr", the subexpression `(x, y)` will be parse to an + argument list or to a complex number, respectively. + """ + if isinstance(s, (list, tuple)): + return type(s)(self.process(s_, context) for s_ in s) + + assert isinstance(s, str), (type(s), s) + + # replace subexpressions in parenthesis with f2py @-names + r, raw_symbols_map = replace_parenthesis(s) + r = r.strip() + + def restore(r): + # restores subexpressions marked with f2py @-names + if isinstance(r, (list, tuple)): + return type(r)(map(restore, r)) + return unreplace_parenthesis(r, raw_symbols_map) + + # comma-separated tuple + if ',' in r: + operands = restore(r.split(',')) + if context == 'args': + return tuple(self.process(operands)) + if context == 'expr': + if len(operands) == 2: + # complex number literal + 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: - assert op == '/' - result /= _fromstring_worker(operand) - return result.substitute(symbols_map) - - operands = list(reversed(re.split(r'[*][*]', r))) - if len(operands) > 1: - # Expression is an arithmetic exponentiation - result = _fromstring_worker(operands[0]) - for operand in operands[1:]: - result = _fromstring_worker(operand) ** result - return result - - m = re.match(r'\A({digit_string})({kind}|)\Z'.format( - digit_string=r'\d+', - kind=r'_(\d+|\w[\w\d_]*)'), r) - if m: - # Expression is int-literal-constant - value, _, kind = m.groups() - if kind and kind.isdigit(): - kind = int(kind) - return as_integer(int(value), kind or 4) - - m = re.match(r'\A({significant}({exponent}|)|\d+{exponent})({kind}|)\Z' - .format( - significant=r'[.]\d+|\d+[.]\d*', - exponent=r'[edED][+-]?\d+', - kind=r'_(\d+|\w[\w\d_]*)'), r) - if m: - # Expression is real-literal-constant - value, _, _, kind = m.groups() - if kind and kind.isdigit(): - kind = int(kind) - value = value.lower() - if 'd' in value: - return as_real(float(value.replace('d', 'e')), kind or 8) - return as_real(float(value), kind or 4) - - m = re.match(r'\A(\w[\w\d_]*)_(@__f2py_QUOTES_(\w+)_\d+@)\Z', r) - if m: + oper = as_symbol(self.finalize_string(oper)) + expr1 = self.process(expr1) + expr2 = self.process(expr2) + return as_ternary(oper, expr1, expr2) + + # keyword argument + m = re.match(r'\A(\w[\w\d_]*)\s*[=](.*)\Z', r) + if m: + keyname, value = m.groups() + value = restore(value) + return _Pair(keyname, self.process(value)) + + # addition/subtraction operations + operands = re.split(r'((?<!\d[edED])[+-])', r) + if len(operands) > 1: + result = self.process(restore(operands[0] or '0')) + for op, operand in zip(operands[1::2], operands[2::2]): + operand = self.process(restore(operand)) + op = op.strip() + if op == '+': + result += operand + else: + assert op == '-' + result -= operand + return result + + # string concatenate operation + if self.language is Language.Fortran and '//' in r: + operands = restore(r.split('//')) + return Expr(Op.CONCAT, + tuple(self.process(operands))) + + # multiplication/division operations + operands = re.split(r'(?<=[@\w\d_])\s*([*]|/)', + (r if self.language is Language.C + else r.replace('**', '@__f2py_DOUBLE_STAR@'))) + if len(operands) > 1: + operands = restore(operands) + if self.language is not Language.C: + operands = [operand.replace('@__f2py_DOUBLE_STAR@', '**') + for operand in operands] + # Expression is an arithmetic product + result = self.process(operands[0]) + for op, operand in zip(operands[1::2], operands[2::2]): + operand = self.process(operand) + op = op.strip() + if op == '*': + result *= operand + else: + assert op == '/' + result /= operand + return result + + # referencing/dereferencing + if r.startswith('*') or r.startswith('&'): + op = {'*': Op.DEREF, '&': Op.REF}[r[0]] + operand = self.process(restore(r[1:])) + return Expr(op, operand) + + # exponentiation operations + if self.language is not Language.C and '**' in r: + operands = list(reversed(restore(r.split('**')))) + result = self.process(operands[0]) + for operand in operands[1:]: + operand = self.process(operand) + result = operand ** result + return result + + # int-literal-constant + m = re.match(r'\A({digit_string})({kind}|)\Z'.format( + digit_string=r'\d+', + kind=r'_(\d+|\w[\w\d_]*)'), r) + if m: + value, _, kind = m.groups() + if kind and kind.isdigit(): + kind = int(kind) + return as_integer(int(value), kind or 4) + + # real-literal-constant + m = re.match(r'\A({significant}({exponent}|)|\d+{exponent})({kind}|)\Z' + .format( + significant=r'[.]\d+|\d+[.]\d*', + exponent=r'[edED][+-]?\d+', + kind=r'_(\d+|\w[\w\d_]*)'), r) + if m: + value, _, _, kind = m.groups() + if kind and kind.isdigit(): + kind = int(kind) + value = value.lower() + if 'd' in value: + return as_real(float(value.replace('d', 'e')), kind or 8) + return as_real(float(value), kind or 4) + # string-literal-constant with kind parameter specification - kind, name, _ = m.groups() - return as_string(name, kind) - - m = re.match(r'\A(\w[\w\d+]*)\s*(@__f2py_PARENTHESIS_(\w+)_\d+@)\Z', r) - if m: - # apply or indexing expression - name, args, paren = m.groups() - target = as_symbol(name).substitute(symbols_map) - if args in raw_symbols_map: - args = symbols_map[as_symbol(args)] + if r in self.quotes_map: + kind = r[:r.find('@')] + return as_string(self.quotes_map[r], kind or 1) + + # array constructor or literal complex constant or + # parenthesized expression + if r in raw_symbols_map: + paren = _get_parenthesis_kind(r) + items = self.process(restore(raw_symbols_map[r]), + 'expr' if paren == 'ROUND' else 'args') + if paren == 'ROUND': + if isinstance(items, Expr): + return items + if paren in ['ROUNDDIV', 'SQUARE']: + # Expression is a array constructor + if isinstance(items, Expr): + items = (items,) + return as_array(items) + + # function call/indexing + m = re.match(r'\A(.+)\s*(@__f2py_PARENTHESIS_(ROUND|SQUARE)_\d+@)\Z', + r) + if m: + target, args, paren = m.groups() + target = self.process(restore(target)) + args = self.process(restore(args)[1:-1], 'args') if not isinstance(args, tuple): args = args, if paren == 'ROUND': - # Expression is a function call or a Fortran indexing - # operation kwargs = dict((a.left, a.right) for a in args if isinstance(a, _Pair)) args = tuple(a for a in args if not isinstance(a, _Pair)) + # Warning: this could also be Fortran indexing operation.. return as_apply(target, *args, **kwargs) - if paren == 'SQUARE': - # Expression is a C indexing operation (e.g. used in - # .pyf files) + else: + # Expression is a C/Python indexing operation + # (e.g. used in .pyf files) + assert paren == 'SQUARE' return target[args] - # A non-Fortran/C expression? - assert 0, (s, r) - - m = re.match(r'\A(@__f2py_PARENTHESIS_(\w+)_\d+@)\Z', r) - if m: - # array constructor or literal complex constant - items, paren = m.groups() - if items in raw_symbols_map: - items = symbols_map[as_symbol(items)] - if (paren == 'ROUND' and isinstance(items, - tuple) and len(items) == 2): - # Expression is a literal complex constant - return as_complex(items[0], items[1]) - if paren in ['ROUNDDIV', 'SQUARE']: - # Expression is a array constructor - return as_array(items) - assert 0, (r, items, paren) - m = re.match(r'\A\w[\w\d_]*\Z', r) - if m: - # Fortran standard conforming name - return as_symbol(r) + # Fortran standard conforming identifier + m = re.match(r'\A\w[\w\d_]*\Z', r) + if m: + return as_symbol(r) - m = re.match(r'\A@\w[\w\d_]*@\Z', r) - if m: - # f2py special dummy name + # fall-back to symbol + r = self.finalize_string(restore(r)) + ewarn( + f'fromstring: treating {r!r} as symbol (original={self.original})') return as_symbol(r) - - ewarn(f'fromstring: treating {r!r} as symbol') - return as_symbol(r) diff --git a/numpy/f2py/tests/test_symbolic.py b/numpy/f2py/tests/test_symbolic.py index 27244c995..61f0d4b3a 100644 --- a/numpy/f2py/tests/test_symbolic.py +++ b/numpy/f2py/tests/test_symbolic.py @@ -2,34 +2,35 @@ from numpy.testing import assert_raises from numpy.f2py.symbolic import ( Expr, Op, ArithOp, Language, as_symbol, as_number, as_string, as_array, as_complex, - as_terms, as_factors, fromstring, replace_quotes, as_expr, as_apply, - as_numer_denom + as_terms, as_factors, eliminate_quotes, insert_quotes, + fromstring, as_expr, as_apply, + as_numer_denom, as_ternary, as_ref, as_deref, + normalize ) from . import util class TestSymbolic(util.F2PyTest): - def test_replace_quotes(self): - + def test_eliminate_quotes(self): def worker(s): - r, d = replace_quotes(s) - assert '"' not in r, r - assert "'" not in r, r - # undo replacements: - s1 = r - for k, v in d.items(): - s1 = s1.replace(k.data, v.data[0]) + r, d = eliminate_quotes(s) + s1 = insert_quotes(r, d) assert s1 == s - worker('"1234" // "ABCD"') - worker('"1234" // \'ABCD\'') - worker('"1\\"2\'AB\'34"') - worker("'1\\'2\"AB\"34'") + for kind in ['', 'mykind_']: + worker(kind + '"1234" // "ABCD"') + worker(kind + '"1234" // ' + kind + '"ABCD"') + worker(kind + '"1234" // \'ABCD\'') + worker(kind + '"1234" // ' + kind + '\'ABCD\'') + worker(kind + '"1\\"2\'AB\'34"') + worker('a = ' + kind + "'1\\'2\"AB\"34'") def test_sanity(self): x = as_symbol('x') y = as_symbol('y') + z = as_symbol('z') + assert x.op == Op.SYMBOL assert repr(x) == "Expr(Op.SYMBOL, 'x')" assert x == x @@ -92,9 +93,17 @@ class TestSymbolic(util.F2PyTest): assert w != v assert hash(v) is not None + t = as_ternary(x, y, z) + u = as_ternary(x, z, y) + assert t.op == Op.TERNARY + assert t == t + assert t != u + assert hash(t) is not None + def test_tostring_fortran(self): x = as_symbol('x') y = as_symbol('y') + z = as_symbol('z') n = as_number(123) m = as_number(456) a = as_array((n, m)) @@ -132,10 +141,13 @@ class TestSymbolic(util.F2PyTest): assert str(Expr(Op.APPLY, ('f', (x, y), {}))) == 'f(x, y)' assert str(Expr(Op.INDEXING, ('f', x))) == 'f[x]' + assert str(as_ternary(x, y, z)) == 'merge(y, z, x)' + def test_tostring_c(self): language = Language.C x = as_symbol('x') y = as_symbol('y') + z = as_symbol('z') n = as_number(123) assert Expr(Op.FACTORS, {x: 2}).tostring(language=language) == 'x * x' @@ -153,6 +165,8 @@ class TestSymbolic(util.F2PyTest): assert (x + (x - y) / (x + y) + n).tostring( language=language) == '123 + x + (x - y) / (x + y)' + assert as_ternary(x, y, z).tostring(language=language) == '(x ? y : z)' + def test_operations(self): x = as_symbol('x') y = as_symbol('y') @@ -224,6 +238,9 @@ class TestSymbolic(util.F2PyTest): assert x.substitute({x: y + z}) == y + z assert a.substitute({x: y + z}) == as_array((y + z, y)) + assert as_ternary(x, y, z).substitute( + {x: y + z}) == as_ternary(y + z, y, z) + def test_fromstring(self): x = as_symbol('x') @@ -242,16 +259,20 @@ class TestSymbolic(util.F2PyTest): assert fromstring('x * y') == x * y assert fromstring('x * 2') == x * 2 assert fromstring('x / y') == x / y - assert fromstring('x ** 2') == x ** 2 - assert fromstring('x ** 2 ** 3') == x ** 2 ** 3 + assert fromstring('x ** 2', + language=Language.Python) == x ** 2 + assert fromstring('x ** 2 ** 3', + language=Language.Python) == x ** 2 ** 3 assert fromstring('(x + y) * z') == (x + y) * z assert fromstring('f(x)') == f(x) assert fromstring('f(x,y)') == f(x, y) assert fromstring('f[x]') == f[x] + assert fromstring('f[x][y]') == f[x][y] assert fromstring('"ABC"') == s - assert fromstring('"ABC" // "123" ') == s // t + assert normalize(fromstring('"ABC" // "123" ', + language=Language.Fortran)) == s // t assert fromstring('f("ABC")') == f(s) assert fromstring('MYSTRKIND_"ABC"') == as_string('"ABC"', 'MYSTRKIND') @@ -288,6 +309,16 @@ class TestSymbolic(util.F2PyTest): age=as_number(50), shape=as_array((as_number(34), as_number(23))))) + assert fromstring('x?y:z') == as_ternary(x, y, z) + + assert fromstring('*x') == as_deref(x) + assert fromstring('**x') == as_deref(as_deref(x)) + assert fromstring('&x') == as_ref(x) + 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_deref(x) * as_deref(y) + assert fromstring('*x**y') == as_deref(x) * as_deref(y) + def test_traverse(self): x = as_symbol('x') y = as_symbol('y') |