def __repr__(self):
"""Return ``repr(self).``"""
# Check if the factory repr can be used
if (uniform_sampling(self.uspace.domain, self.shape,
as_midp=True) == self.grid):
if isinstance(self.dspace, Fn):
impl = 'numpy'
elif isinstance(self.dspace, CudaFn):
impl = 'cuda'
else: # This should never happen
raise RuntimeError('unable to determine data space impl.')
arg_fstr = '{}, {}, {}'
if self.exponent != 2.0:
arg_fstr += ', exponent={exponent}'
if not isinstance(self.field, RealNumbers):
arg_fstr += ', field={field!r}'
if self.interp != 'nearest':
arg_fstr += ', interp={interp!r}'
if impl != 'numpy':
arg_fstr += ', impl={impl!r}'
if self.order != 'C':
arg_fstr += ', order={order!r}'
if self.ndim == 1:
min_str = '{!r}'.format(self.uspace.domain.min()[0])
max_str = '{!r}'.format(self.uspace.domain.max()[0])
shape_str = '{!r}'.format(self.shape[0])
else:
min_str = '{!r}'.format(list(self.uspace.domain.min()))
max_str = '{!r}'.format(list(self.uspace.domain.max()))
shape_str = '{!r}'.format(list(self.shape))
arg_str = arg_fstr.format(
min_str, max_str, shape_str,
exponent=self.exponent,
field=self.field,
interp=self.interp,
impl=impl,
order=self.order)
return 'uniform_discr({})'.format(arg_str)
else:
arg_fstr = '''
{!r},
{!r},
{!r}
'''
if self.exponent != 2.0:
arg_fstr += ', exponent={ex}'
if self.interp != 'nearest':
arg_fstr += ', interp={interp!r}'
if self.order != 'C':
arg_fstr += ', order={order!r}'
arg_str = arg_fstr.format(
self.uspace, self.grid, self.dspace, interp=self.interp,
order=self.order, ex=self.exponent)
return '{}({})'.format(self.__class__.__name__, arg_str)
def __repr__(self):
"""``lp.__repr__() <==> repr(lp).``"""
# Check if the factory repr can be used
if (uniform_sampling(self.uspace.domain, self.grid.shape,
as_midp=True) == self.grid):
if isinstance(self.dspace, Fn):
impl = 'numpy'
elif isinstance(self.dspace, CudaFn):
impl = 'cuda'
else: # This should never happen
raise RuntimeError('unable to determine data space impl.')
arg_fstr = '{!r}, {!r}'
if self.exponent != 2.0:
arg_fstr += ', exponent={ex}'
if self.interp != 'nearest':
arg_fstr += ', interp={interp!r}'
if impl != 'numpy':
arg_fstr += ', impl={impl!r}'
if self.order != 'C':
arg_fstr += ', order={order!r}'
arg_str = arg_fstr.format(
self.uspace, self.grid.shape, interp=self.interp,
impl=impl, order=self.order)
return 'uniform_discr({})'.format(arg_str)
else:
arg_fstr = '''
{!r},
{!r},
{!r}
'''
if self.exponent != 2.0:
arg_fstr += ', exponent={ex}'
if self.interp != 'nearest':
arg_fstr += ', interp={interp!r}'
if self.order != 'C':
arg_fstr += ', order={order!r}'
arg_str = arg_fstr.format(
self.uspace, self.grid, self.dspace, interp=self.interp,
order=self.order, ex=self.exponent)
return '{}({})'.format(self.__class__.__name__, arg_str)
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)