def test_init(exponent): # Validate that the different init patterns work and do not crash. space = odl.FunctionSpace(odl.IntervalProd(0, 1)) part = odl.uniform_partition_fromintv(space.domain, 10) rn = odl.rn(10, exponent=exponent) odl.DiscreteLp(space, part, rn, exponent=exponent) odl.DiscreteLp(space, part, rn, exponent=exponent, interp='linear') # Normal discretization of unit interval with complex complex_space = odl.FunctionSpace(odl.IntervalProd(0, 1), field=odl.ComplexNumbers()) cn = odl.cn(10, exponent=exponent) odl.DiscreteLp(complex_space, part, cn, exponent=exponent) space = odl.FunctionSpace(odl.IntervalProd([0, 0], [1, 1])) part = odl.uniform_partition_fromintv(space.domain, (10, 10)) rn = odl.rn(100, exponent=exponent) odl.DiscreteLp(space, part, rn, exponent=exponent, interp=['nearest', 'linear']) # Real space should not work with complex with pytest.raises(ValueError): odl.DiscreteLp(space, part, cn) # Complex space should not work with reals with pytest.raises(ValueError): odl.DiscreteLp(complex_space, part, rn) # Wrong size of underlying space rn_wrong_size = odl.rn(20) with pytest.raises(ValueError): odl.DiscreteLp(space, part, rn_wrong_size)
def test_discretelp_init(): """Test initialization and basic properties of DiscreteLp.""" # Real space fspace = odl.FunctionSpace(odl.IntervalProd([0, 0], [1, 1])) part = odl.uniform_partition_fromintv(fspace.domain, (2, 4)) tspace = odl.rn(part.shape) discr = DiscreteLp(fspace, part, tspace) assert discr.fspace == fspace assert discr.tspace == tspace assert discr.partition == part assert discr.interp == 'nearest' assert discr.interp_byaxis == ('nearest', 'nearest') assert discr.exponent == tspace.exponent assert discr.axis_labels == ('$x$', '$y$') assert discr.is_real discr = DiscreteLp(fspace, part, tspace, interp='linear') assert discr.interp == 'linear' assert discr.interp_byaxis == ('linear', 'linear') discr = DiscreteLp(fspace, part, tspace, interp=['nearest', 'linear']) assert discr.interp == ('nearest', 'linear') assert discr.interp_byaxis == ('nearest', 'linear') # Complex space fspace_c = odl.FunctionSpace(odl.IntervalProd([0, 0], [1, 1]), out_dtype=complex) tspace_c = odl.cn(part.shape) discr = DiscreteLp(fspace_c, part, tspace_c) assert discr.is_complex # Make sure repr shows something assert repr(discr) # Error scenarios with pytest.raises(ValueError): DiscreteLp(fspace, part, tspace_c) # mixes real & complex with pytest.raises(ValueError): DiscreteLp(fspace_c, part, tspace) # mixes complex & real part_1d = odl.uniform_partition(0, 1, 2) with pytest.raises(ValueError): DiscreteLp(fspace, part_1d, tspace) # wrong dimensionality part_diffshp = odl.uniform_partition_fromintv(fspace.domain, (3, 4)) with pytest.raises(ValueError): DiscreteLp(fspace, part_diffshp, tspace) # shape mismatch
def test_uniform_partition_fromintv(): intvp = odl.IntervalProd([0, 0], [1, 2]) shape = (4, 10) # All nodes at the boundary part = odl.uniform_partition_fromintv(intvp, shape, nodes_on_bdry=True) assert all_equal(part.min_pt, intvp.min_pt) assert all_equal(part.max_pt, intvp.max_pt) assert all_equal(part.grid.min_pt, intvp.min_pt) assert all_equal(part.grid.max_pt, intvp.max_pt) for cs in part.cell_sizes_vecs: # Check that all cell sizes are equal (except first and last which # are halved) assert np.allclose(np.diff(cs[1:-1]), 0) assert all_almost_equal(cs[0], cs[1] / 2) assert all_almost_equal(cs[-1], cs[-2] / 2) # All nodes not the boundary part = odl.uniform_partition_fromintv(intvp, shape, nodes_on_bdry=False) assert all_equal(part.min_pt, intvp.min_pt) assert all_equal(part.max_pt, intvp.max_pt) for cs in part.cell_sizes_vecs: # Check that all cell sizes are equal assert np.allclose(np.diff(cs), 0) # Only left nodes at the boundary part = odl.uniform_partition_fromintv(intvp, shape, nodes_on_bdry=[[True, False]] * 2) assert all_equal(part.min_pt, intvp.min_pt) assert all_equal(part.max_pt, intvp.max_pt) assert all_equal(part.grid.min_pt, intvp.min_pt) for cs in part.cell_sizes_vecs: # Check that all cell sizes are equal (except first) assert np.allclose(np.diff(cs[1:]), 0) assert all_almost_equal(cs[0], cs[1] / 2) # Only right nodes at the boundary part = odl.uniform_partition_fromintv(intvp, shape, nodes_on_bdry=[[False, True]] * 2) assert all_equal(part.min_pt, intvp.min_pt) assert all_equal(part.max_pt, intvp.max_pt) assert all_equal(part.grid.max_pt, intvp.max_pt) for cs in part.cell_sizes_vecs: # Check that all cell sizes are equal (except last) assert np.allclose(np.diff(cs[:-1]), 0) assert all_almost_equal(cs[-1], cs[-2] / 2)
def test_nearest_interpolation_2d_float(): """Test nearest neighbor interpolation in 2d.""" rect = odl.IntervalProd([0, 0], [1, 1]) part = odl.uniform_partition_fromintv(rect, [4, 2], nodes_on_bdry=False) # Coordinate vectors are: # [0.125, 0.375, 0.625, 0.875], [0.25, 0.75] fspace = odl.FunctionSpace(rect) tspace = odl.rn(part.shape) interp_op = NearestInterpolation(fspace, part, tspace) function = interp_op(np.reshape([0, 1, 2, 3, 4, 5, 6, 7], part.shape)) # Evaluate at single point val = function([0.3, 0.6]) # closest to index (1, 1) -> 3 assert val == 3.0 # Input array, with and without output array pts = np.array([[0.3, 0.6], [1.0, 1.0]]) true_arr = [3, 7] assert all_equal(function(pts.T), true_arr) out = np.empty(2, dtype='float64') function(pts.T, out=out) assert all_equal(out, true_arr) # Input meshgrid, with and without output array mg = sparse_meshgrid([0.3, 1.0], [0.4, 1.0]) # Indices: (1, 3) x (0, 1) true_mg = [[2, 3], [6, 7]] assert all_equal(function(mg), true_mg) out = np.empty((2, 2), dtype='float64') function(mg, out=out) assert all_equal(out, true_mg) assert repr(interp_op) != ''
def test_nearest_interpolation_2d_string(): rect = odl.IntervalProd([0, 0], [1, 1]) part = odl.uniform_partition_fromintv(rect, [4, 2], nodes_on_bdry=False) # Coordinate vectors are: # [0.125, 0.375, 0.625, 0.875], [0.25, 0.75] space = odl.FunctionSet(rect, odl.Strings(1)) dspace = odl.ntuples(part.size, dtype='U1') interp_op = NearestInterpolation(space, part, dspace) values = np.array([c for c in 'mystring']) function = interp_op(values) # Evaluate at single point val = function([0.3, 0.6]) # closest to index (1, 1) -> 3 assert val == 't' # Input array, with and without output array pts = np.array([[0.3, 0.6], [1.0, 1.0]]) true_arr = ['t', 'g'] assert all_equal(function(pts.T), true_arr) out = np.empty(2, dtype='U1') function(pts.T, out=out) assert all_equal(out, true_arr) # Input meshgrid, with and without output array mg = sparse_meshgrid([0.3, 1.0], [0.4, 1.0]) # Indices: (1, 3) x (0, 1) true_mg = [['s', 't'], ['n', 'g']] assert all_equal(function(mg), true_mg) out = np.empty((2, 2), dtype='U1') function(mg, out=out) assert all_equal(out, true_mg)
def test_nearest_interpolation_1d_variants(): """Test nearest neighbor interpolation variants in 1d.""" intv = odl.IntervalProd(0, 1) part = odl.uniform_partition_fromintv(intv, 5, nodes_on_bdry=False) # Coordinate vectors are: # [0.1, 0.3, 0.5, 0.7, 0.9] fspace = odl.FunctionSpace(intv) tspace = odl.rn(part.shape) # 'left' variant interp_op = NearestInterpolation(fspace, part, tspace, variant='left') assert repr(interp_op) != '' function = interp_op([0, 1, 2, 3, 4]) # Testing two midpoints and the extreme values pts = np.array([0.4, 0.8, 0.0, 1.0]) true_arr = [1, 3, 0, 4] assert all_equal(function(pts), true_arr) # 'right' variant interp_op = NearestInterpolation(fspace, part, tspace, variant='right') assert repr(interp_op) != '' function = interp_op([0, 1, 2, 3, 4]) # Testing two midpoints and the extreme values pts = np.array([0.4, 0.8, 0.0, 1.0]) true_arr = [2, 4, 0, 4] assert all_equal(function(pts), true_arr)
def test_nearest_interpolation_1d_complex(fn_impl): intv = odl.IntervalProd(0, 1) part = odl.uniform_partition_fromintv(intv, 5, nodes_on_bdry=False) # Coordinate vectors are: # [0.1, 0.3, 0.5, 0.7, 0.9] space = odl.FunctionSpace(intv, field=odl.ComplexNumbers()) dspace = odl.cn(part.size) interp_op = NearestInterpolation(space, part, dspace) function = interp_op([0 + 1j, 1 + 2j, 2 + 3j, 3 + 4j, 4 + 5j]) # Evaluate at single point val = function(0.35) # closest to index 1 -> 1 + 2j assert val == 1.0 + 2.0j # Input array, with and without output array pts = np.array([0.4, 0.0, 0.65, 0.95]) true_arr = [1 + 2j, 0 + 1j, 3 + 4j, 4 + 5j] assert all_equal(function(pts), true_arr) # Should also work with a (1, N) array pts = pts[None, :] assert all_equal(function(pts), true_arr) out = np.empty(4, dtype='complex128') function(pts, out=out) assert all_equal(out, true_arr) # Input meshgrid, with and without output array # Same as array for 1d mg = sparse_meshgrid([0.4, 0.0, 0.65, 0.95]) true_mg = [1 + 2j, 0 + 1j, 3 + 4j, 4 + 5j] assert all_equal(function(mg), true_mg) function(mg, out=out) assert all_equal(out, true_mg)
def test_nearest_interpolation_2d_string(): """Test nearest neighbor interpolation in 2d with string values.""" rect = odl.IntervalProd([0, 0], [1, 1]) part = odl.uniform_partition_fromintv(rect, [4, 2], nodes_on_bdry=False) # Coordinate vectors are: # [0.125, 0.375, 0.625, 0.875], [0.25, 0.75] fspace = odl.FunctionSpace(rect, out_dtype='U1') tspace = odl.tensor_space(part.shape, dtype='U1') interp_op = NearestInterpolation(fspace, part, tspace) values = np.array([c for c in 'mystring']).reshape(tspace.shape) function = interp_op(values) # Evaluate at single point val = function([0.3, 0.6]) # closest to index (1, 1) -> 3 assert val == 't' # Input array, with and without output array pts = np.array([[0.3, 0.6], [1.0, 1.0]]) true_arr = ['t', 'g'] assert all_equal(function(pts.T), true_arr) out = np.empty(2, dtype='U1') function(pts.T, out=out) assert all_equal(out, true_arr) # Input meshgrid, with and without output array mg = sparse_meshgrid([0.3, 1.0], [0.4, 1.0]) # Indices: (1, 3) x (0, 1) true_mg = [['s', 't'], ['n', 'g']] assert all_equal(function(mg), true_mg) out = np.empty((2, 2), dtype='U1') function(mg, out=out) assert all_equal(out, true_mg) assert repr(interp_op) != ''
def test_nearest_interpolation_1d_variants(): intv = odl.Interval(0, 1) part = odl.uniform_partition_fromintv(intv, 5, nodes_on_bdry=False) # Coordinate vectors are: # [0.1, 0.3, 0.5, 0.7, 0.9] space = odl.FunctionSpace(intv) dspace = odl.Rn(part.size) # 'left' variant interp_op = NearestInterpolation(space, part, dspace, variant='left') function = interp_op([0, 1, 2, 3, 4]) # Testing two midpoints and the extreme values pts = np.array([0.4, 0.8, 0.0, 1.0]) true_arr = [1, 3, 0, 4] assert all_equal(function(pts), true_arr) # 'right' variant interp_op = NearestInterpolation(space, part, dspace, variant='right') function = interp_op([0, 1, 2, 3, 4]) # Testing two midpoints and the extreme values pts = np.array([0.4, 0.8, 0.0, 1.0]) true_arr = [2, 4, 0, 4] assert all_equal(function(pts), true_arr)
def test_collocation_interpolation_identity(): """Check if collocation is left-inverse to interpolation.""" # Interpolation followed by collocation on the same grid should be # the identity rect = odl.IntervalProd([0, 0], [1, 1]) part = odl.uniform_partition_fromintv(rect, [4, 2]) space = odl.FunctionSpace(rect) tspace = odl.rn(part.shape) coll_op = PointCollocation(space, part, tspace) interp_ops = [ NearestInterpolation(space, part, tspace, variant='left'), NearestInterpolation(space, part, tspace, variant='right'), LinearInterpolation(space, part, tspace), PerAxisInterpolation(space, part, tspace, schemes=['linear', 'nearest']) ] values = np.arange(1, 9, dtype='float64').reshape(tspace.shape) for interp_op in interp_ops: ident_values = coll_op(interp_op(values)) assert all_almost_equal(ident_values, values)
def test_nearest_interpolation_2d_string(): rect = odl.Rectangle([0, 0], [1, 1]) part = odl.uniform_partition_fromintv(rect, [4, 2], nodes_on_bdry=False) # Coordinate vectors are: # [0.125, 0.375, 0.625, 0.875], [0.25, 0.75] space = odl.FunctionSet(rect, odl.Strings(1)) dspace = odl.Ntuples(part.size, dtype='U1') interp_op = NearestInterpolation(space, part, dspace) values = np.array([c for c in 'mystring']) function = interp_op(values) # Evaluate at single point val = function([0.3, 0.6]) # closest to index (1, 1) -> 3 assert val == 't' # Input array, with and without output array pts = np.array([[0.3, 0.6], [1.0, 1.0]]) true_arr = ['t', 'g'] assert all_equal(function(pts.T), true_arr) out = np.empty(2, dtype='U1') function(pts.T, out=out) assert all_equal(out, true_arr) # Input meshgrid, with and without output array mg = sparse_meshgrid([0.3, 1.0], [0.4, 1.0]) # Indices: (1, 3) x (0, 1) true_mg = [['s', 't'], ['n', 'g']] assert all_equal(function(mg), true_mg) out = np.empty((2, 2), dtype='U1') function(mg, out=out) assert all_equal(out, true_mg)
def test_nearest_interpolation_2d_float(): rect = odl.IntervalProd([0, 0], [1, 1]) part = odl.uniform_partition_fromintv(rect, [4, 2], nodes_on_bdry=False) # Coordinate vectors are: # [0.125, 0.375, 0.625, 0.875], [0.25, 0.75] space = odl.FunctionSpace(rect) dspace = odl.rn(part.size) interp_op = NearestInterpolation(space, part, dspace) function = interp_op([0, 1, 2, 3, 4, 5, 6, 7]) # Evaluate at single point val = function([0.3, 0.6]) # closest to index (1, 1) -> 3 assert val == 3.0 # Input array, with and without output array pts = np.array([[0.3, 0.6], [1.0, 1.0]]) true_arr = [3, 7] assert all_equal(function(pts.T), true_arr) out = np.empty(2, dtype='float64') function(pts.T, out=out) assert all_equal(out, true_arr) # Input meshgrid, with and without output array mg = sparse_meshgrid([0.3, 1.0], [0.4, 1.0]) # Indices: (1, 3) x (0, 1) true_mg = [[2, 3], [6, 7]] assert all_equal(function(mg), true_mg) out = np.empty((2, 2), dtype='float64') function(mg, out=out) assert all_equal(out, true_mg)
def test_nearest_interpolation_1d_variants(): intv = odl.IntervalProd(0, 1) part = odl.uniform_partition_fromintv(intv, 5, nodes_on_bdry=False) # Coordinate vectors are: # [0.1, 0.3, 0.5, 0.7, 0.9] space = odl.FunctionSpace(intv) dspace = odl.rn(part.size) # 'left' variant interp_op = NearestInterpolation(space, part, dspace, variant='left') function = interp_op([0, 1, 2, 3, 4]) # Testing two midpoints and the extreme values pts = np.array([0.4, 0.8, 0.0, 1.0]) true_arr = [1, 3, 0, 4] assert all_equal(function(pts), true_arr) # 'right' variant interp_op = NearestInterpolation(space, part, dspace, variant='right') function = interp_op([0, 1, 2, 3, 4]) # Testing two midpoints and the extreme values pts = np.array([0.4, 0.8, 0.0, 1.0]) true_arr = [2, 4, 0, 4] assert all_equal(function(pts), true_arr)
def test_nearest_interpolation_1d_complex(odl_tspace_impl): """Test nearest neighbor interpolation in 1d with complex values.""" impl = odl_tspace_impl # TODO: not used! intv = odl.IntervalProd(0, 1) part = odl.uniform_partition_fromintv(intv, 5, nodes_on_bdry=False) # Coordinate vectors are: # [0.1, 0.3, 0.5, 0.7, 0.9] fspace = odl.FunctionSpace(intv, out_dtype=complex) tspace = odl.cn(part.shape) interp_op = NearestInterpolation(fspace, part, tspace) function = interp_op([0 + 1j, 1 + 2j, 2 + 3j, 3 + 4j, 4 + 5j]) # Evaluate at single point val = function(0.35) # closest to index 1 -> 1 + 2j assert val == 1.0 + 2.0j # Input array, with and without output array pts = np.array([0.4, 0.0, 0.65, 0.95]) true_arr = [1 + 2j, 0 + 1j, 3 + 4j, 4 + 5j] assert all_equal(function(pts), true_arr) # Should also work with a (1, N) array pts = pts[None, :] assert all_equal(function(pts), true_arr) out = np.empty(4, dtype='complex128') function(pts, out=out) assert all_equal(out, true_arr) # Input meshgrid, with and without output array # Same as array for 1d mg = sparse_meshgrid([0.4, 0.0, 0.65, 0.95]) true_mg = [1 + 2j, 0 + 1j, 3 + 4j, 4 + 5j] assert all_equal(function(mg), true_mg) function(mg, out=out) assert all_equal(out, true_mg) assert repr(interp_op) != ''
def test_collocation_interpolation_identity(): # Check if interpolation followed by collocation on the same grid # is the identity rect = odl.IntervalProd([0, 0], [1, 1]) part = odl.uniform_partition_fromintv(rect, [4, 2]) space = odl.FunctionSpace(rect) dspace = odl.rn(part.size) coll_op_c = PointCollocation(space, part, dspace, order='C') coll_op_f = PointCollocation(space, part, dspace, order='F') interp_ops_c = [ NearestInterpolation(space, part, dspace, variant='left', order='C'), NearestInterpolation(space, part, dspace, variant='right', order='C'), LinearInterpolation(space, part, dspace, order='C'), PerAxisInterpolation(space, part, dspace, order='C', schemes=['linear', 'nearest'])] interp_ops_f = [ NearestInterpolation(space, part, dspace, variant='left', order='F'), NearestInterpolation(space, part, dspace, variant='right', order='F'), LinearInterpolation(space, part, dspace, order='F'), PerAxisInterpolation(space, part, dspace, order='F', schemes=['linear', 'nearest'])] values = np.arange(1, 9, dtype='float64') for interp_op_c in interp_ops_c: ident_values = coll_op_c(interp_op_c(values)) assert all_almost_equal(ident_values, values) for interp_op_f in interp_ops_f: ident_values = coll_op_f(interp_op_f(values)) assert all_almost_equal(ident_values, values)
def test_uniform_partition_fromintv(): intvp = odl.IntervalProd([0, 0], [1, 2]) nsamp = (4, 10) # All nodes at the boundary part = odl.uniform_partition_fromintv(intvp, nsamp, nodes_on_bdry=True) assert all_equal(part.begin, intvp.begin) assert all_equal(part.end, intvp.end) assert all_equal(part.grid.min_pt, intvp.begin) assert all_equal(part.grid.max_pt, intvp.end) for cs in part.cell_sizes_vecs: # Check that all cell sizes are equal (except first and last which # are halved) assert np.allclose(np.diff(cs[1:-1]), 0) assert all_almost_equal(cs[0], cs[1] / 2) assert all_almost_equal(cs[-1], cs[-2] / 2) # All nodes not the boundary part = odl.uniform_partition_fromintv(intvp, nsamp, nodes_on_bdry=False) assert all_equal(part.begin, intvp.begin) assert all_equal(part.end, intvp.end) for cs in part.cell_sizes_vecs: # Check that all cell sizes are equal assert np.allclose(np.diff(cs), 0) # Only left nodes at the boundary part = odl.uniform_partition_fromintv(intvp, nsamp, nodes_on_bdry=[[True, False]] * 2) assert all_equal(part.begin, intvp.begin) assert all_equal(part.end, intvp.end) assert all_equal(part.grid.min_pt, intvp.begin) for cs in part.cell_sizes_vecs: # Check that all cell sizes are equal (except first) assert np.allclose(np.diff(cs[1:]), 0) assert all_almost_equal(cs[0], cs[1] / 2) # Only right nodes at the boundary part = odl.uniform_partition_fromintv(intvp, nsamp, nodes_on_bdry=[[False, True]] * 2) assert all_equal(part.begin, intvp.begin) assert all_equal(part.end, intvp.end) assert all_equal(part.grid.max_pt, intvp.end) for cs in part.cell_sizes_vecs: # Check that all cell sizes are equal (except last) assert np.allclose(np.diff(cs[:-1]), 0) assert all_almost_equal(cs[-1], cs[-2] / 2)
def test_per_axis_interpolation(): """Test different interpolation schemes per axis.""" rect = odl.IntervalProd([0, 0], [1, 1]) part = odl.uniform_partition_fromintv(rect, [4, 2], nodes_on_bdry=False) # Coordinate vectors are: # [0.125, 0.375, 0.625, 0.875], [0.25, 0.75] fspace = odl.FunctionSpace(rect) tspace = odl.rn(part.shape) schemes = ['linear', 'nearest'] variants = [None, 'right'] interp_op = PerAxisInterpolation(fspace, part, tspace, schemes=schemes, nn_variants=variants) values = np.arange(1, 9, dtype='float64').reshape(part.shape) function = interp_op(values) rvals = values.reshape([4, 2]) # Evaluate at single point val = function([0.3, 0.5]) l1 = (0.3 - 0.125) / (0.375 - 0.125) # 0.5 equally far from both neighbors -> 'right' chooses 0.75 true_val = (1 - l1) * rvals[0, 1] + l1 * rvals[1, 1] assert val == pytest.approx(true_val) # Input array, with and without output array pts = np.array([[0.3, 0.6], [0.1, 0.25], [1.0, 1.0]]) l1 = (0.3 - 0.125) / (0.375 - 0.125) true_val_1 = (1 - l1) * rvals[0, 1] + l1 * rvals[1, 1] l1 = (0.125 - 0.1) / (0.375 - 0.125) true_val_2 = (1 - l1) * rvals[0, 0] # only lower left contributes l1 = (1.0 - 0.875) / (0.875 - 0.625) true_val_3 = (1 - l1) * rvals[3, 1] # lower left only true_arr = [true_val_1, true_val_2, true_val_3] assert all_equal(function(pts.T), true_arr) out = np.empty(3, dtype='float64') function(pts.T, out=out) assert all_equal(out, true_arr) # Input meshgrid, with and without output array mg = sparse_meshgrid([0.3, 1.0], [0.4, 0.85]) # Indices: (1, 3) x (0, 1) lx1 = (0.3 - 0.125) / (0.375 - 0.125) lx2 = (1.0 - 0.875) / (0.875 - 0.625) true_val_11 = (1 - lx1) * rvals[0, 0] + lx1 * rvals[1, 0] true_val_12 = ((1 - lx1) * rvals[0, 1] + lx1 * rvals[1, 1]) true_val_21 = (1 - lx2) * rvals[3, 0] true_val_22 = (1 - lx2) * rvals[3, 1] true_mg = [[true_val_11, true_val_12], [true_val_21, true_val_22]] assert all_equal(function(mg), true_mg) out = np.empty((2, 2), dtype='float64') function(mg, out=out) assert all_equal(out, true_mg) assert repr(interp_op) != ''
def test_per_axis_interpolation(): rect = odl.IntervalProd([0, 0], [1, 1]) part = odl.uniform_partition_fromintv(rect, [4, 2], nodes_on_bdry=False) # Coordinate vectors are: # [0.125, 0.375, 0.625, 0.875], [0.25, 0.75] space = odl.FunctionSpace(rect) dspace = odl.rn(part.size) schemes = ['linear', 'nearest'] variants = [None, 'right'] interp_op = PerAxisInterpolation(space, part, dspace, schemes=schemes, nn_variants=variants) values = np.arange(1, 9, dtype='float64') function = interp_op(values) rvals = values.reshape([4, 2]) # Evaluate at single point val = function([0.3, 0.5]) l1 = (0.3 - 0.125) / (0.375 - 0.125) # 0.5 equally far from both neighbors -> 'right' chooses 0.75 true_val = (1 - l1) * rvals[0, 1] + l1 * rvals[1, 1] assert almost_equal(val, true_val) # Input array, with and without output array pts = np.array([[0.3, 0.6], [0.1, 0.25], [1.0, 1.0]]) l1 = (0.3 - 0.125) / (0.375 - 0.125) true_val_1 = (1 - l1) * rvals[0, 1] + l1 * rvals[1, 1] l1 = (0.125 - 0.1) / (0.375 - 0.125) true_val_2 = (1 - l1) * rvals[0, 0] # only lower left contributes l1 = (1.0 - 0.875) / (0.875 - 0.625) true_val_3 = (1 - l1) * rvals[3, 1] # lower left only true_arr = [true_val_1, true_val_2, true_val_3] assert all_equal(function(pts.T), true_arr) out = np.empty(3, dtype='float64') function(pts.T, out=out) assert all_equal(out, true_arr) # Input meshgrid, with and without output array mg = sparse_meshgrid([0.3, 1.0], [0.4, 0.85]) # Indices: (1, 3) x (0, 1) lx1 = (0.3 - 0.125) / (0.375 - 0.125) lx2 = (1.0 - 0.875) / (0.875 - 0.625) true_val_11 = (1 - lx1) * rvals[0, 0] + lx1 * rvals[1, 0] true_val_12 = ((1 - lx1) * rvals[0, 1] + lx1 * rvals[1, 1]) true_val_21 = (1 - lx2) * rvals[3, 0] true_val_22 = (1 - lx2) * rvals[3, 1] true_mg = [[true_val_11, true_val_12], [true_val_21, true_val_22]] assert all_equal(function(mg), true_mg) out = np.empty((2, 2), dtype='float64') function(mg, out=out) assert all_equal(out, true_mg)
def test_collocation_cuda(): rect = odl.Rectangle([0, 0], [1, 1]) part = odl.uniform_partition_fromintv(rect, [4, 2]) space = odl.FunctionSpace(rect) dspace = odl.CudaRn(part.size) coll_op = PointCollocation(space, part, dspace) interp_op = LinearInterpolation(space, part, dspace) values = np.arange(1, 9, dtype='float64') ident_values = coll_op(interp_op(values)) assert all_almost_equal(ident_values, values)
def test_linear_interpolation_1d(): intv = odl.IntervalProd(0, 1) part = odl.uniform_partition_fromintv(intv, 5, nodes_on_bdry=False) # Coordinate vectors are: # [0.1, 0.3, 0.5, 0.7, 0.9] space = odl.FunctionSpace(intv) dspace = odl.rn(part.size) interp_op = LinearInterpolation(space, part, dspace) function = interp_op([1, 2, 3, 4, 5]) # Evaluate at single point val = function(0.35) true_val = 0.75 * 2 + 0.25 * 3 assert almost_equal(val, true_val) # Input array, with and without output array pts = np.array([0.4, 0.0, 0.65, 0.95]) true_arr = [2.5, 0.5, 3.75, 3.75] assert all_almost_equal(function(pts), true_arr)
def test_init_cuda(exponent): # Normal discretization of unit interval space = odl.FunctionSpace(odl.Interval(0, 1), out_dtype='float32') part = odl.uniform_partition_fromintv(space.domain, 10) rn = odl.CudaRn(10, exponent=exponent) odl.DiscreteLp(space, part, rn, exponent=exponent)
def test_linear_interpolation_2d(): rect = odl.IntervalProd([0, 0], [1, 1]) part = odl.uniform_partition_fromintv(rect, [4, 2], nodes_on_bdry=False) # Coordinate vectors are: # [0.125, 0.375, 0.625, 0.875], [0.25, 0.75] space = odl.FunctionSpace(rect) dspace = odl.rn(part.size) interp_op = LinearInterpolation(space, part, dspace) values = np.arange(1, 9, dtype='float64') function = interp_op(values) rvals = values.reshape([4, 2]) # Evaluate at single point val = function([0.3, 0.6]) l1 = (0.3 - 0.125) / (0.375 - 0.125) l2 = (0.6 - 0.25) / (0.75 - 0.25) true_val = ((1 - l1) * (1 - l2) * rvals[0, 0] + (1 - l1) * l2 * rvals[0, 1] + l1 * (1 - l2) * rvals[1, 0] + l1 * l2 * rvals[1, 1]) assert almost_equal(val, true_val) # Input array, with and without output array pts = np.array([[0.3, 0.6], [0.1, 0.25], [1.0, 1.0]]) l1 = (0.3 - 0.125) / (0.375 - 0.125) l2 = (0.6 - 0.25) / (0.75 - 0.25) true_val_1 = ((1 - l1) * (1 - l2) * rvals[0, 0] + (1 - l1) * l2 * rvals[0, 1] + l1 * (1 - l2) * rvals[1, 0] + l1 * l2 * rvals[1, 1]) l1 = (0.125 - 0.1) / (0.375 - 0.125) # l2 = 0 true_val_2 = (1 - l1) * rvals[0, 0] # only lower left contributes l1 = (1.0 - 0.875) / (0.875 - 0.625) l2 = (1.0 - 0.75) / (0.75 - 0.25) true_val_3 = (1 - l1) * (1 - l2) * rvals[3, 1] # lower left only true_arr = [true_val_1, true_val_2, true_val_3] assert all_equal(function(pts.T), true_arr) out = np.empty(3, dtype='float64') function(pts.T, out=out) assert all_equal(out, true_arr) # Input meshgrid, with and without output array mg = sparse_meshgrid([0.3, 1.0], [0.4, 0.75]) # Indices: (1, 3) x (0, 1) lx1 = (0.3 - 0.125) / (0.375 - 0.125) lx2 = (1.0 - 0.875) / (0.875 - 0.625) ly1 = (0.4 - 0.25) / (0.75 - 0.25) # ly2 = 0 true_val_11 = ((1 - lx1) * (1 - ly1) * rvals[0, 0] + (1 - lx1) * ly1 * rvals[0, 1] + lx1 * (1 - ly1) * rvals[1, 0] + lx1 * ly1 * rvals[1, 1]) true_val_12 = ((1 - lx1) * rvals[0, 1] + lx1 * rvals[1, 1]) # ly2 = 0 true_val_21 = ((1 - lx2) * (1 - ly1) * rvals[3, 0] + (1 - lx2) * ly1 * rvals[3, 1]) # high node 1.0, no upper true_val_22 = (1 - lx2) * rvals[3, 1] # ly2 = 0, no upper for 1.0 true_mg = [[true_val_11, true_val_12], [true_val_21, true_val_22]] assert all_equal(function(mg), true_mg) out = np.empty((2, 2), dtype='float64') function(mg, out=out) assert all_equal(out, true_mg)
def test_linear_interpolation_2d(): """Test linear interpolation in 2d.""" rect = odl.IntervalProd([0, 0], [1, 1]) part = odl.uniform_partition_fromintv(rect, [4, 2], nodes_on_bdry=False) # Coordinate vectors are: # [0.125, 0.375, 0.625, 0.875], [0.25, 0.75] fspace = odl.FunctionSpace(rect) tspace = odl.rn(part.shape) interp_op = LinearInterpolation(fspace, part, tspace) values = np.arange(1, 9, dtype='float64').reshape(part.shape) function = interp_op(values) rvals = values.reshape([4, 2]) # Evaluate at single point val = function([0.3, 0.6]) l1 = (0.3 - 0.125) / (0.375 - 0.125) l2 = (0.6 - 0.25) / (0.75 - 0.25) true_val = ((1 - l1) * (1 - l2) * rvals[0, 0] + (1 - l1) * l2 * rvals[0, 1] + l1 * (1 - l2) * rvals[1, 0] + l1 * l2 * rvals[1, 1]) assert val == pytest.approx(true_val) # Input array, with and without output array pts = np.array([[0.3, 0.6], [0.1, 0.25], [1.0, 1.0]]) l1 = (0.3 - 0.125) / (0.375 - 0.125) l2 = (0.6 - 0.25) / (0.75 - 0.25) true_val_1 = ((1 - l1) * (1 - l2) * rvals[0, 0] + (1 - l1) * l2 * rvals[0, 1] + l1 * (1 - l2) * rvals[1, 0] + l1 * l2 * rvals[1, 1]) l1 = (0.125 - 0.1) / (0.375 - 0.125) # l2 = 0 true_val_2 = (1 - l1) * rvals[0, 0] # only lower left contributes l1 = (1.0 - 0.875) / (0.875 - 0.625) l2 = (1.0 - 0.75) / (0.75 - 0.25) true_val_3 = (1 - l1) * (1 - l2) * rvals[3, 1] # lower left only true_arr = [true_val_1, true_val_2, true_val_3] assert all_equal(function(pts.T), true_arr) out = np.empty(3, dtype='float64') function(pts.T, out=out) assert all_equal(out, true_arr) # Input meshgrid, with and without output array mg = sparse_meshgrid([0.3, 1.0], [0.4, 0.75]) # Indices: (1, 3) x (0, 1) lx1 = (0.3 - 0.125) / (0.375 - 0.125) lx2 = (1.0 - 0.875) / (0.875 - 0.625) ly1 = (0.4 - 0.25) / (0.75 - 0.25) # ly2 = 0 true_val_11 = ((1 - lx1) * (1 - ly1) * rvals[0, 0] + (1 - lx1) * ly1 * rvals[0, 1] + lx1 * (1 - ly1) * rvals[1, 0] + lx1 * ly1 * rvals[1, 1]) true_val_12 = ((1 - lx1) * rvals[0, 1] + lx1 * rvals[1, 1]) # ly2 = 0 true_val_21 = ( (1 - lx2) * (1 - ly1) * rvals[3, 0] + (1 - lx2) * ly1 * rvals[3, 1] ) # high node 1.0, no upper true_val_22 = (1 - lx2) * rvals[3, 1] # ly2 = 0, no upper for 1.0 true_mg = [[true_val_11, true_val_12], [true_val_21, true_val_22]] assert all_equal(function(mg), true_mg) out = np.empty((2, 2), dtype='float64') function(mg, out=out) assert all_equal(out, true_mg) assert repr(interp_op) != ''