def __repr__(self):
"""Return ``repr(self)``."""
if self.is_real:
ctor = 'rn'
elif self.is_complex:
ctor = 'cn'
else:
ctor = 'fn'
posargs = [self.size]
default_dtype_str = dtype_repr(self.default_dtype(self.field))
optargs = [('dtype', dtype_repr(self.dtype), default_dtype_str),
('impl', self.impl, 'numpy')]
inner_str = signature_string(posargs, optargs)
weight_str = self.weighting.repr_part
if weight_str:
inner_str += ', ' + weight_str
return '{}({})'.format(ctor, inner_str)
def __repr__(self):
"""s.__repr__() <==> repr(s)."""
if self.is_rn:
class_name = 'CudaFn'
elif self.is_cn:
class_name = 'CudaCn'
else:
class_name = self.__class__.__name__
inner_str = '{}'.format(self.size)
if self.dtype != self.default_dtype(self.field):
inner_str += ', {}'.format(dtype_repr(self.dtype))
weight_str = self.weighting.repr_part
if weight_str:
inner_str += ', ' + weight_str
return '{}({})'.format(class_name, inner_str)
def __repr__(self):
"""s.__repr__() <==> repr(s)."""
if self.is_rn:
class_name = 'CudaFn'
elif self.is_cn:
class_name = 'CudaCn'
else:
class_name = self.__class__.__name__
inner_str = '{}'.format(self.size)
if self.dtype != self.default_dtype(self.field):
inner_str += ', {}'.format(dtype_repr(self.dtype))
weight_str = self.weighting.repr_part
if weight_str:
inner_str += ', ' + weight_str
return '{}({})'.format(class_name, inner_str)
def __str__(self):
"""Return ``str(self)``."""
inner_str = '{}'.format(self.domain)
dtype_str = dtype_repr(self.out_dtype)
if self.field == RealNumbers():
if self.out_dtype == np.dtype('float64'):
pass
else:
inner_str += ', out_dtype={}'.format(dtype_str)
elif self.field == ComplexNumbers():
if self.out_dtype == np.dtype('complex128'):
inner_str += ', field={!r}'.format(self.field)
else:
inner_str += ', out_dtype={}'.format(dtype_str)
else: # different field, name explicitly
inner_str += ', field={!r}'.format(self.field)
inner_str += ', out_dtype={}'.format(dtype_str)
return '{}({})'.format(self.__class__.__name__, inner_str)
def __str__(self):
"""Return ``str(self)``."""
return '{}({}, {})'.format(self.__class__.__name__, self.size,
dtype_repr(self.dtype))
def __repr__(self):
"""Return ``repr(self)``."""
return '{}({}, {})'.format(self.__class__.__name__, self.size,
dtype_repr(self.dtype))
def __repr__(self):
"""``s.__repr__() <==> repr(s)``."""
return '{}({}, {})'.format(self.__class__.__name__, self.size,
dtype_repr(self.dtype))
def __repr__(self):
"""Return ``repr(self).``"""
# Check if the factory repr can be used
if (uniform_partition_fromintv(
self.uspace.domain, self.shape,
nodes_on_bdry=False) == self.partition):
use_uniform = True
nodes_on_bdry = False
elif (uniform_partition_fromintv(
self.uspace.domain, self.shape,
nodes_on_bdry=True) == self.partition):
use_uniform = True
nodes_on_bdry = True
else:
use_uniform = False
if use_uniform:
if isinstance(self.dspace, Fn):
impl = 'numpy'
default_dtype = np.float64
elif isinstance(self.dspace, CudaFn):
impl = 'cuda'
default_dtype = np.float32
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 self.dtype != default_dtype:
arg_fstr += ', dtype={dtype}'
if not all(s == 'nearest' for s in self.interp):
arg_fstr += ', interp={interp!r}'
if impl != 'numpy':
arg_fstr += ', impl={impl!r}'
if self.order != 'C':
arg_fstr += ', order={order!r}'
if nodes_on_bdry:
arg_fstr += ', nodes_on_bdry={nodes_on_bdry!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,
dtype=dtype_repr(self.dtype),
interp=self.interp,
impl=impl,
order=self.order,
nodes_on_bdry=nodes_on_bdry)
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.partition, self.dspace, interp=self.interp,
ex=self.exponent, order=self.order)
return '{}({})'.format(self.__class__.__name__, arg_str)
