def test_dspace_type_cuda(): # Plain function set -> Ntuples-like fset = odl.FunctionSet(odl.Interval(0, 1), odl.Strings(2)) assert dspace_type(fset, 'cuda') == odl.CudaNtuples assert dspace_type(fset, 'cuda', np.int) == odl.CudaNtuples # Real space rspc = odl.FunctionSpace(odl.Interval(0, 1), field=odl.RealNumbers()) assert dspace_type(rspc, 'cuda') == odl.CudaRn assert dspace_type(rspc, 'cuda', np.float32) == odl.CudaRn assert dspace_type(rspc, 'cuda', np.int) == odl.CudaFn with pytest.raises(TypeError): dspace_type(rspc, 'cuda', np.complex) with pytest.raises(TypeError): dspace_type(rspc, 'cuda', np.dtype('<U2')) # Complex space (not implemented) cspc = odl.FunctionSpace(odl.Interval(0, 1), field=odl.ComplexNumbers()) with pytest.raises(NotImplementedError): dspace_type(cspc, 'cuda') with pytest.raises(NotImplementedError): dspace_type(cspc, 'cuda', np.complex64) with pytest.raises(TypeError): dspace_type(cspc, 'cuda', np.float) with pytest.raises(TypeError): assert dspace_type(cspc, 'cuda', np.int)
def test_dspace_type_numpy(): # Plain function set -> Ntuples-like fset = odl.FunctionSet(odl.Interval(0, 1), odl.Strings(2)) assert dspace_type(fset, 'numpy') == odl.Ntuples assert dspace_type(fset, 'numpy', np.int) == odl.Ntuples # Real space rspc = odl.FunctionSpace(odl.Interval(0, 1), field=odl.RealNumbers()) assert dspace_type(rspc, 'numpy') == odl.Rn assert dspace_type(rspc, 'numpy', np.float32) == odl.Rn assert dspace_type(rspc, 'numpy', np.int) == odl.Fn with pytest.raises(TypeError): dspace_type(rspc, 'numpy', np.complex) with pytest.raises(TypeError): dspace_type(rspc, 'numpy', np.dtype('<U2')) # Complex space cspc = odl.FunctionSpace(odl.Interval(0, 1), field=odl.ComplexNumbers()) assert dspace_type(cspc, 'numpy') == odl.Cn assert dspace_type(cspc, 'numpy', np.complex64) == odl.Cn with pytest.raises(TypeError): dspace_type(cspc, 'numpy', np.float) with pytest.raises(TypeError): assert dspace_type(cspc, 'numpy', np.int) with pytest.raises(TypeError): dspace_type(cspc, 'numpy', np.dtype('<U2'))
def uniform_discr_fromspace(fspace, nsamples, exponent=2.0, interp='nearest', impl='numpy', **kwargs): """Discretize an Lp function space by uniform sampling. Parameters ---------- fspace : `FunctionSpace` Continuous function space. Its domain must be an `IntervalProd` instance. nsamples : `int` or `tuple` of `int` Number of samples per axis. For dimension >= 2, a tuple is required. exponent : positive `float`, optional The parameter :math:`p` in :math:`L^p`. If the exponent is not equal to the default 2.0, the space has no inner product. interp : `str`, optional Interpolation type to be used for discretization. 'nearest' : use nearest-neighbor interpolation (default) 'linear' : use linear interpolation (not implemented) impl : {'numpy', 'cuda'} Implementation of the data storage arrays kwargs : {'order', 'dtype', 'weighting'} 'order' : {'C', 'F'} (Default: 'C') Axis ordering in the data storage 'dtype' : dtype Data type for the discretized space Default for 'numpy': 'float64' / 'complex128' Default for 'cuda': 'float32' / TODO 'weighting' : {'simple', 'consistent'} Weighting of the discretized space functions. 'simple': weight is a constant (cell volume) 'consistent': weight is a matrix depending on the interpolation type Returns ------- discr : `DiscreteLp` The uniformly discretized function space Examples -------- >>> from odl import Interval, FunctionSpace >>> I = Interval(0, 1) >>> X = FunctionSpace(I) >>> uniform_discr_fromspace(X, 10) uniform_discr([0.0], [1.0], [10]) See also -------- uniform_discr """ if not isinstance(fspace, FunctionSpace): raise TypeError('space {!r} is not a `FunctionSpace` instance.' ''.format(fspace)) if not isinstance(fspace.domain, IntervalProd): raise TypeError('domain {!r} of the function space is not an ' '`IntervalProd` instance.'.format(fspace.domain)) if impl == 'cuda' and not CUDA_AVAILABLE: raise ValueError('CUDA not available.') dtype = kwargs.pop('dtype', None) ds_type = dspace_type(fspace, impl, dtype) grid = uniform_sampling(fspace.domain, nsamples, as_midp=True) weighting = kwargs.pop('weighting', 'simple') weighting_ = weighting.lower() if weighting_ not in ('simple', 'consistent'): raise ValueError('weighting {!r} not understood.'.format(weighting)) if weighting_ == 'simple': csize = grid.stride idcs = np.where(csize == 0) csize[idcs] = fspace.domain.size[idcs] weight = np.prod(csize) else: # weighting_ == 'consistent' # TODO: implement raise NotImplementedError if dtype is not None: dspace = ds_type(grid.ntotal, dtype=dtype, weight=weight, exponent=exponent) else: dspace = ds_type(grid.ntotal, weight=weight, exponent=exponent) order = kwargs.pop('order', 'C') return DiscreteLp(fspace, grid, dspace, exponent=exponent, interp=interp, order=order)
def uniform_discr_frompartition(partition, exponent=2.0, interp='nearest', impl='numpy', **kwargs): """Discretize an Lp function space given a uniform partition. Parameters ---------- partition : `RectPartition` Regular (uniform) partition to be used for discretization exponent : positive `float`, optional The parameter ``p`` in ``L^p``. If the exponent is not equal to the default 2.0, the space has no inner product. interp : `str` or `sequence` of `str`, optional Interpolation type to be used for discretization. A sequence is interpreted as interpolation scheme per axis. 'nearest' : use nearest-neighbor interpolation 'linear' : use linear interpolation impl : {'numpy', 'cuda'}, optional Implementation of the data storage arrays Other Parameters ---------------- order : {'C', 'F'}, optional Axis ordering in the data storage. Default: 'C' dtype : dtype Data type for the discretized space Default for 'numpy': 'float64' / 'complex128' Default for 'cuda': 'float32' weighting : {'const', 'none'}, optional Weighting of the discretized space functions. 'const' : weight is a constant, the cell volume (default) 'none' : no weighting Returns ------- discr : `DiscreteLp` The uniformly discretized function space Examples -------- >>> from odl import uniform_partition >>> part = uniform_partition(0, 1, 10) >>> uniform_discr_frompartition(part) uniform_discr(0.0, 1.0, 10) See also -------- uniform_discr : implicit uniform Lp discretization uniform_discr_fromspace : uniform Lp discretization from an existing function space odl.discr.partition.uniform_partition : partition of the function domain """ if not isinstance(partition, RectPartition): raise TypeError('partition {!r} is not a RectPartition instance.' ''.format(partition)) if not partition.is_regular: raise ValueError('partition is not regular.') impl, impl_in = str(impl).lower(), impl if impl == 'numpy': dtype = np.dtype(kwargs.pop('dtype', 'float64')) elif impl == 'cuda': if not CUDA_AVAILABLE: raise ValueError('CUDA not available.') dtype = np.dtype(kwargs.pop('dtype', 'float32')) else: raise ValueError("implementation '{}' not understood.".format(impl_in)) fspace = FunctionSpace(partition.set, out_dtype=dtype) ds_type = dspace_type(fspace, impl, dtype) order = kwargs.pop('order', 'C') weighting = kwargs.pop('weighting', 'const') weighting, weighting_in = str(weighting).lower(), weighting if weighting == 'none' or float(exponent) == float('inf'): weight = None elif weighting == 'const': weight = partition.cell_volume else: raise ValueError("weighting '{}' not understood.".format(weighting_in)) if dtype is not None: dspace = ds_type(partition.size, dtype=dtype, weight=weight, exponent=exponent) else: dspace = ds_type(partition.size, weight=weight, exponent=exponent) return DiscreteLp(fspace, partition, dspace, exponent, interp, order=order)
def test_dspace_type_cuda(): # Plain function set -> Ntuples-like fset = odl.FunctionSet(odl.Interval(0, 1), odl.Strings(2)) assert dspace_type(fset, 'cuda') == odl.CudaNtuples assert dspace_type(fset, 'cuda', np.int) == odl.CudaNtuples # Real space rspc = odl.FunctionSpace(odl.Interval(0, 1), field=odl.RealNumbers()) assert dspace_type(rspc, 'cuda') == odl.CudaFn assert dspace_type(rspc, 'cuda', np.float64) == odl.CudaFn assert dspace_type(rspc, 'cuda', np.int) == odl.CudaFn with pytest.raises(TypeError): dspace_type(rspc, 'cuda', np.complex) with pytest.raises(TypeError): dspace_type(rspc, 'cuda', np.dtype('<U2')) # Complex space (not implemented) cspc = odl.FunctionSpace(odl.Interval(0, 1), field=odl.ComplexNumbers()) with pytest.raises(NotImplementedError): dspace_type(cspc, 'cuda') with pytest.raises(NotImplementedError): dspace_type(cspc, 'cuda', np.complex64) with pytest.raises(TypeError): dspace_type(cspc, 'cuda', np.float) with pytest.raises(TypeError): assert dspace_type(cspc, 'cuda', np.int)
def test_dspace_type_numpy(): # Plain function set -> Ntuples-like fset = odl.FunctionSet(odl.Interval(0, 1), odl.Strings(2)) assert dspace_type(fset, 'numpy') == odl.Ntuples, None assert dspace_type(fset, 'numpy', np.int) == odl.Ntuples # Real space rspc = odl.FunctionSpace(odl.Interval(0, 1), field=odl.RealNumbers()) assert dspace_type(rspc, 'numpy') == odl.Fn assert dspace_type(rspc, 'numpy', np.float32) == odl.Fn assert dspace_type(rspc, 'numpy', np.int) == odl.Fn with pytest.raises(TypeError): dspace_type(rspc, 'numpy', np.complex) with pytest.raises(TypeError): dspace_type(rspc, 'numpy', np.dtype('<U2')) # Complex space cspc = odl.FunctionSpace(odl.Interval(0, 1), field=odl.ComplexNumbers()) assert dspace_type(cspc, 'numpy') == odl.Fn assert dspace_type(cspc, 'numpy', np.complex64) == odl.Fn with pytest.raises(TypeError): dspace_type(cspc, 'numpy', np.float) with pytest.raises(TypeError): assert dspace_type(cspc, 'numpy', np.int) with pytest.raises(TypeError): dspace_type(cspc, 'numpy', np.dtype('<U2'))