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)