Skip to content
Snippets Groups Projects
Select Git revision
  • master default protected
  • rangersbach/c-interfacing
  • fhennig/devel
  • v0.1a4
  • v0.1a3
  • v0.1a2
  • v0.1a1
7 results
Blame Permalink
test_expressions.py 3.30 KiB
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121 






import pytest

from pystencilssfg import SfgException
from pystencilssfg.lang import asvar, SfgVar, AugExpr, cpptype, HeaderFile, CppClass

import sympy as sp

from pystencils import TypedSymbol, DynamicType
from pystencils.types import PsCustomType


def test_asvar():
    #   SfgVar must be returned as-is
    var = SfgVar("p", "uint64")
    assert var is asvar(var)

    #   TypedSymbol is transformed
    ts = TypedSymbol("q", "int32")
    assert asvar(ts) == SfgVar("q", "int32")

    #   Variable AugExprs get lowered to SfgVar
    augexpr = AugExpr("uint16").var("l")
    assert asvar(augexpr) == SfgVar("l", "uint16")

    #   Complex AugExprs cannot be parsed
    cexpr = AugExpr.format("{} + {}", SfgVar("m", "int32"), AugExpr("int32").var("n"))
    with pytest.raises(SfgException):
        _ = asvar(cexpr)

    #   Untyped SymPy symbols won't be parsed
    x = sp.Symbol("x")
    with pytest.raises(ValueError):
        _ = asvar(x)

    #   Dynamically typed TypedSymbols cannot be parsed
    y = TypedSymbol("y", DynamicType.NUMERIC_TYPE)
    with pytest.raises(ValueError):
        _ = asvar(y)


def test_augexpr_format():
    expr = AugExpr.format("std::vector< real_t > {{ 0.1, 0.2, 0.3 }}")
    assert expr.code == "std::vector< real_t > { 0.1, 0.2, 0.3 }"
    assert not expr.depends

    expr = AugExpr("int").var("p")
    assert expr.code == "p"
    assert expr.depends == {SfgVar("p", "int")}

    expr = AugExpr.format(
        "{} + {} / {}",
        AugExpr("int").var("p"),
        AugExpr("int").var("q"),
        AugExpr("uint32").var("r"),
    )

    assert str(expr) == expr.code == "p + q / r"

    assert expr.depends == {
        SfgVar("p", "int"),
        SfgVar("q", "int"),
        SfgVar("r", "uint32"),
    }

    #   Must find TypedSymbols as dependencies
    expr = AugExpr.format(
        "{} + {} / {}",
        AugExpr("int").var("p"),
        TypedSymbol("x", "int32"),
        TypedSymbol("y", "int32"),
    )

    assert expr.code == "p + x / y"
    assert expr.depends == {
        SfgVar("p", "int"),
        SfgVar("x", "int32"),
        SfgVar("y", "int32"),
    }

    #   Can parse constant SymPy expressions
    expr = AugExpr.format("{}", sp.sympify(1))

    assert expr.code == "1"
    assert not expr.depends


def test_augexpr_illegal_format():
    x, y, z = sp.symbols("x, y, z")

    with pytest.raises(ValueError):
        #   Cannot parse SymPy symbols
        _ = AugExpr.format("{}", x)

    with pytest.raises(ValueError):
        #   Cannot parse expressions containing symbols
        _ = AugExpr.format("{} + {}", x + 3, y / (2 * z))


def test_headers():
    pairtype = cpptype("std::tuple< {}, {} >", "<tuple>")

    var = AugExpr(pairtype("double", "int")).var("x")
    assert var.includes == {HeaderFile("tuple", system_header=True)}

    expr = AugExpr().bind("std::get< int >({})", var)
    assert expr.includes == {HeaderFile("tuple", system_header=True)}


def test_cppclass():
    class MyClass(CppClass):
        template = cpptype("mynamespace::MyClass< {T} >", "MyHeader.hpp")

        def ctor(self, arg: AugExpr):
            return self.ctor_bind(arg)

    unbound = MyClass(T="bogus")
    assert unbound.get_dtype() == MyClass.template(T="bogus")

    ctor_expr = unbound.ctor(AugExpr(PsCustomType("bogus")).var("foo"))
    assert str(ctor_expr).strip() == r"mynamespace::MyClass< bogus >{foo}"