def test_dict_of_named_arrays_comparison():
# See https://github.com/inducer/pytato/pull/137
x = pt.make_placeholder("x", (10, 4), float)
dict1 = pt.make_dict_of_named_arrays({"out": 2 * x})
dict2 = pt.make_dict_of_named_arrays({"out": 2 * x})
dict3 = pt.make_dict_of_named_arrays({"not_out": 2 * x})
dict4 = pt.make_dict_of_named_arrays({"out": 3 * x})
assert dict1 == dict2
assert dict1 != dict3
assert dict1 != dict4
def test_slice(ctx_factory, shape):
cl_ctx = ctx_factory()
queue = cl.CommandQueue(cl_ctx)
from numpy.random import default_rng
rng = default_rng()
x_in = rng.random(size=shape)
namespace = pt.Namespace()
x = pt.make_data_wrapper(namespace, x_in)
outputs = {}
ref_outputs = {}
i = 0
for slice_ in generate_test_slices(shape):
outputs[f"out_{i}"] = x[slice_]
ref_outputs[f"out_{i}"] = x_in[slice_]
i += 1
prog = pt.generate_loopy(pt.make_dict_of_named_arrays(outputs),
target=pt.PyOpenCLTarget(queue),
options=lp.Options(return_dict=True))
_, outputs = prog()
for output in outputs:
x_out = outputs[output]
x_ref = ref_outputs[output]
assert (x_out == x_ref).all()
def test_unary_arith(ctx_factory, which):
cl_ctx = ctx_factory()
queue = cl.CommandQueue(cl_ctx)
op = getattr(operator, which)
x_orig = np.array([1, 2, 3, 4, 5])
namespace = pt.Namespace()
exprs = {}
for dtype in ARITH_DTYPES:
exprs[dtype] = op(pt.make_data_wrapper(namespace,
x_orig.astype(dtype)))
prog = pt.generate_loopy(pt.make_dict_of_named_arrays(exprs),
target=pt.PyOpenCLTarget(queue),
options=lp.Options(return_dict=True))
_, outputs = prog()
for dtype in ARITH_DTYPES:
out = outputs[dtype]
out_ref = op(x_orig.astype(dtype))
assert out.dtype == out_ref.dtype
assert np.array_equal(out, out_ref)
def test_scalar_array_binary_arith(ctx_factory, which, reverse):
cl_ctx = ctx_factory()
queue = cl.CommandQueue(cl_ctx)
op = getattr(operator, which)
if reverse:
op = reverse_args(op)
x_orig = 7
y_orig = np.array([1, 2, 3, 4, 5])
for first_dtype in (int, float, complex):
namespace = pt.Namespace()
x_in = first_dtype(x_orig)
exprs = {}
for dtype in ARITH_DTYPES:
y = pt.make_data_wrapper(namespace,
y_orig.astype(dtype),
name=f"y{dtype}")
exprs[dtype] = op(x_in, y)
prog = pt.generate_loopy(pt.make_dict_of_named_arrays(exprs),
target=pt.PyOpenCLTarget(queue),
options=lp.Options(return_dict=True))
_, outputs = prog()
for dtype in exprs:
out = outputs[dtype]
out_ref = op(x_in, y_orig.astype(dtype))
assert out.dtype == out_ref.dtype, (out.dtype, out_ref.dtype)
# In some cases ops are done in float32 in loopy but float64 in numpy.
assert np.allclose(out, out_ref), (out, out_ref)
def test_accessing_dict_of_named_arrays_validation():
x = pt.make_placeholder(name="x", shape=10, dtype=float)
y1y2 = pt.make_dict_of_named_arrays({"y1": 2*x, "y2": 3*x})
assert isinstance(y1y2["y1"], pt.array.NamedArray)
assert y1y2["y1"].shape == (2*x).shape
assert y1y2["y1"].dtype == (2*x).dtype
def test_rec_get_user_nodes():
x1 = pt.make_placeholder("x1", shape=(10, 4), dtype=np.float64)
x2 = pt.make_placeholder("x2", shape=(10, 4), dtype=np.float64)
expr = pt.make_dict_of_named_arrays({"out1": 2 * x1,
"out2": 7 * x1 + 3 * x2})
assert (pt.transform.rec_get_user_nodes(expr, x1)
== frozenset({2 * x1, 7*x1, 7*x1 + 3 * x2, expr}))
assert (pt.transform.rec_get_user_nodes(expr, x2)
== frozenset({3 * x2, 7*x1 + 3 * x2, expr}))
def test_array_array_binary_arith(ctx_factory, which, reverse):
if which == "sub":
pytest.skip("https://github.com/inducer/loopy/issues/131")
cl_ctx = ctx_factory()
queue = cl.CommandQueue(cl_ctx)
op = getattr(operator, which)
if reverse:
op = reverse_args(op)
x_orig = np.array([1, 2, 3, 4, 5])
y_orig = np.array([10, 9, 8, 7, 6])
for first_dtype in ARITH_DTYPES:
namespace = pt.Namespace()
x_in = x_orig.astype(first_dtype)
x = pt.make_data_wrapper(namespace, x_in, name="x")
exprs = {}
for dtype in ARITH_DTYPES:
y = pt.make_data_wrapper(namespace,
y_orig.astype(dtype),
name=f"y{dtype}")
exprs[dtype] = op(x, y)
prog = pt.generate_loopy(pt.make_dict_of_named_arrays(exprs),
target=pt.PyOpenCLTarget(queue),
options=lp.Options(return_dict=True))
_, outputs = prog()
for dtype in ARITH_DTYPES:
out = outputs[dtype]
out_ref = op(x_in, y_orig.astype(dtype))
assert out.dtype == out_ref.dtype, (out.dtype, out_ref.dtype)
# In some cases ops are done in float32 in loopy but float64 in numpy.
assert np.allclose(out, out_ref), (out, out_ref)