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)