def test_fspace_lincomb_vec_tens(a, b, out_shape):
"""Check linear combination in function spaces."""
if out_shape == ():
return
intv = odl.IntervalProd([0, 0], [1, 1])
fspace = FunctionSpace(intv, out_dtype=(float, out_shape))
points = _points(fspace.domain, 4)
ndim = len(out_shape)
if ndim == 1:
f_elem1 = fspace.element(func_vec_nd_oop)
f_elem2 = fspace.element(func_vec_nd_other)
true_result = (a * func_vec_nd_ref(points) +
b * func_vec_nd_other(points))
elif ndim == 2:
f_elem1 = fspace.element(func_tens_oop)
f_elem2 = fspace.element(func_tens_other)
true_result = a * func_tens_ref(points) + b * func_tens_other(points)
else:
assert False
out_func = fspace.element()
fspace.lincomb(a, f_elem1, b, f_elem2, out_func)
assert all_equal(out_func(points), true_result)
out_arr = np.empty(out_shape + (4, ))
out_func(points, out=out_arr)
assert all_equal(out_arr, true_result)
def test_fspace_lincomb_scalar(a, b):
"""Check linear combination in function spaces.
Note: Special cases and more alignment options are tested later in the
special methods like ``__add__``.
"""
intv = odl.IntervalProd([0, 0], [1, 1])
fspace = FunctionSpace(intv)
points = _points(fspace.domain, 4)
true_result = a * func_nd_oop(points) + b * func_nd_bcast_ref(points)
# Non-vectorized evaluation, checking with `out` array and without.
f_elem1_novec = fspace.element(func_nd_oop, vectorized=False)
f_elem2_novec = fspace.element(func_nd_bcast_oop, vectorized=False)
out_novec = fspace.element(vectorized=False)
fspace.lincomb(a, f_elem1_novec, b, f_elem2_novec, out_novec)
assert all_equal(out_novec(points), true_result)
out_arr = np.empty(4)
out_novec(points, out=out_arr)
assert all_equal(out_arr, true_result)
# Vectorized evaluation with definition from out-of-place (oop),
# in-place (ip) and dual-use (dual) versions of Python functions.
# Checking evaluation with `out` array and without.
# out-of-place
f_elem1_oop = fspace.element(func_nd_oop)
f_elem2_oop = fspace.element(func_nd_bcast_oop)
out_oop = fspace.element()
fspace.lincomb(a, f_elem1_oop, b, f_elem2_oop, out_oop)
assert all_equal(out_oop(points), true_result)
out_arr = np.empty(4)
out_oop(points, out=out_arr)
assert all_equal(out_arr, true_result)
# in-place
f_elem1_ip = fspace.element(func_nd_ip)
f_elem2_ip = fspace.element(func_nd_bcast_ip)
out_ip = fspace.element()
fspace.lincomb(a, f_elem1_ip, b, f_elem2_ip, out_ip)
assert all_equal(out_ip(points), true_result)
out_arr = np.empty(4)
out_ip(points, out=out_arr)
assert all_equal(out_arr, true_result)
# dual
f_elem1_dual = fspace.element(func_nd_dual)
f_elem2_dual = fspace.element(func_nd_bcast_dual)
out_dual = fspace.element()
fspace.lincomb(a, f_elem1_dual, b, f_elem2_dual, out_dual)
assert all_equal(out_dual(points), true_result)
out_arr = np.empty(4)
out_dual(points, out=out_arr)
assert all_equal(out_arr, true_result)
# Check mixing vectorized and non-vectorized functions
out = fspace.element()
fspace.lincomb(a, f_elem1_oop, b, f_elem2_novec, out)
assert all_equal(out(points), true_result)
out_arr = np.empty(4)
out(points, out=out_arr)
assert all_equal(out_arr, true_result)
# Alignment options
# out = a * out + b * f2, out = f1.copy() -> same as before
out = f_elem1_oop.copy()
fspace.lincomb(a, out, b, f_elem2_oop, out)
true_result_aligned = true_result
assert all_equal(out(points), true_result_aligned)
# out = a * f1 + b * out, out = f2.copy() -> same as before
out = f_elem2_oop.copy()
fspace.lincomb(a, f_elem1_oop, b, out, out)
true_result_aligned = true_result
assert all_equal(out(points), true_result_aligned)
# out = a * out + b * out
out = f_elem1_oop.copy()
fspace.lincomb(a, out, b, out, out)
true_result_aligned = (a + b) * f_elem1_oop(points)
assert all_equal(out(points), true_result_aligned)
# out = a * f1 + b * f1
out = fspace.element()
fspace.lincomb(a, f_elem1_oop, b, f_elem1_oop, out)
true_result_aligned = (a + b) * f_elem1_oop(points)
assert all_equal(out(points), true_result_aligned)
def test_fspace_lincomb(a, b):
rect, points, mg = _standard_setup_2d()
point = points.T[0]
fspace = FunctionSpace(rect)
# Note: Special cases and alignment are tested later in the magic methods
# Not vectorized
true_novec = a * func_2d_novec(point) + b * other_func_2d_novec(point)
f_novec = fspace.element(func_2d_novec, vectorized=False)
g_novec = fspace.element(other_func_2d_novec, vectorized=False)
out_novec = fspace.element(vectorized=False)
fspace.lincomb(a, f_novec, b, g_novec, out_novec)
assert almost_equal(out_novec(point), true_novec)
# Vectorized
true_arr = (a * func_2d_vec_oop(points) +
b * other_func_2d_vec_oop(points))
true_mg = (a * func_2d_vec_oop(mg) + b * other_func_2d_vec_oop(mg))
# Out-of-place
f_vec_oop = fspace.element(func_2d_vec_oop, vectorized=True)
g_vec_oop = fspace.element(other_func_2d_vec_oop, vectorized=True)
out_vec = fspace.element()
fspace.lincomb(a, f_vec_oop, b, g_vec_oop, out_vec)
assert all_equal(out_vec(points), true_arr)
assert all_equal(out_vec(mg), true_mg)
assert almost_equal(out_vec(point), true_novec)
out_arr = np.empty((5,), dtype=float)
out_mg = np.empty((2, 3), dtype=float)
out_vec(points, out=out_arr)
out_vec(mg, out=out_mg)
assert all_equal(out_arr, true_arr)
assert all_equal(out_mg, true_mg)
# In-place
f_vec_ip = fspace.element(func_2d_vec_ip, vectorized=True)
g_vec_ip = fspace.element(other_func_2d_vec_ip, vectorized=True)
out_vec = fspace.element()
fspace.lincomb(a, f_vec_ip, b, g_vec_ip, out_vec)
assert all_equal(out_vec(points), true_arr)
assert all_equal(out_vec(mg), true_mg)
assert almost_equal(out_vec(point), true_novec)
out_arr = np.empty((5,), dtype=float)
out_mg = np.empty((2, 3), dtype=float)
out_vec(points, out=out_arr)
out_vec(mg, out=out_mg)
assert all_equal(out_arr, true_arr)
assert all_equal(out_mg, true_mg)
# Dual use
f_vec_dual = fspace.element(func_2d_vec_dual, vectorized=True)
g_vec_dual = fspace.element(other_func_2d_vec_dual, vectorized=True)
out_vec = fspace.element()
fspace.lincomb(a, f_vec_dual, b, g_vec_dual, out_vec)
assert all_equal(out_vec(points), true_arr)
assert all_equal(out_vec(mg), true_mg)
assert almost_equal(out_vec(point), true_novec)
out_arr = np.empty((5,), dtype=float)
out_mg = np.empty((2, 3), dtype=float)
out_vec(points, out=out_arr)
out_vec(mg, out=out_mg)
assert all_equal(out_arr, true_arr)
assert all_equal(out_mg, true_mg)
# Mix of vectorized and non-vectorized -> manual vectorization
fspace.lincomb(a, f_vec_dual, b, g_novec, out_vec)
assert all_equal(out_vec(points), true_arr)
assert all_equal(out_vec(mg), true_mg)
def test_fspace_lincomb(a, b):
rect, points, mg = _standard_setup_2d()
point = points.T[0]
fspace = FunctionSpace(rect)
# Note: Special cases and alignment are tested later in the magic methods
# Not vectorized
true_novec = a * func_2d_novec(point) + b * other_func_2d_novec(point)
f_novec = fspace.element(func_2d_novec, vectorized=False)
g_novec = fspace.element(other_func_2d_novec, vectorized=False)
out_novec = fspace.element(vectorized=False)
fspace.lincomb(a, f_novec, b, g_novec, out_novec)
assert almost_equal(out_novec(point), true_novec)
# Vectorized
true_arr = (a * func_2d_vec_oop(points) +
b * other_func_2d_vec_oop(points))
true_mg = (a * func_2d_vec_oop(mg) + b * other_func_2d_vec_oop(mg))
# Out-of-place
f_vec_oop = fspace.element(func_2d_vec_oop, vectorized=True)
g_vec_oop = fspace.element(other_func_2d_vec_oop, vectorized=True)
out_vec = fspace.element()
fspace.lincomb(a, f_vec_oop, b, g_vec_oop, out_vec)
assert all_equal(out_vec(points), true_arr)
assert all_equal(out_vec(mg), true_mg)
assert almost_equal(out_vec(point), true_novec)
out_arr = np.empty((5, ), dtype=float)
out_mg = np.empty((2, 3), dtype=float)
out_vec(points, out=out_arr)
out_vec(mg, out=out_mg)
assert all_equal(out_arr, true_arr)
assert all_equal(out_mg, true_mg)
# In-place
f_vec_ip = fspace.element(func_2d_vec_ip, vectorized=True)
g_vec_ip = fspace.element(other_func_2d_vec_ip, vectorized=True)
out_vec = fspace.element()
fspace.lincomb(a, f_vec_ip, b, g_vec_ip, out_vec)
assert all_equal(out_vec(points), true_arr)
assert all_equal(out_vec(mg), true_mg)
assert almost_equal(out_vec(point), true_novec)
out_arr = np.empty((5, ), dtype=float)
out_mg = np.empty((2, 3), dtype=float)
out_vec(points, out=out_arr)
out_vec(mg, out=out_mg)
assert all_equal(out_arr, true_arr)
assert all_equal(out_mg, true_mg)
# Dual use
f_vec_dual = fspace.element(func_2d_vec_dual, vectorized=True)
g_vec_dual = fspace.element(other_func_2d_vec_dual, vectorized=True)
out_vec = fspace.element()
fspace.lincomb(a, f_vec_dual, b, g_vec_dual, out_vec)
assert all_equal(out_vec(points), true_arr)
assert all_equal(out_vec(mg), true_mg)
assert almost_equal(out_vec(point), true_novec)
out_arr = np.empty((5, ), dtype=float)
out_mg = np.empty((2, 3), dtype=float)
out_vec(points, out=out_arr)
out_vec(mg, out=out_mg)
assert all_equal(out_arr, true_arr)
assert all_equal(out_mg, true_mg)
# Mix of vectorized and non-vectorized -> manual vectorization
fspace.lincomb(a, f_vec_dual, b, g_novec, out_vec)
assert all_equal(out_vec(points), true_arr)
assert all_equal(out_vec(mg), true_mg)
