def __repr__(self):
"""Return ``repr(self)``."""
posargs = [array_str(self.array)]
optargs = [('exponent', self.exponent, 2.0)]
inner_str = signature_string(posargs, optargs, sep=',\n',
mod=['!s', ':.4'])
return '{}(\n{}\n)'.format(self.__class__.__name__, indent(inner_str))
def __repr__(self):
"""Return ``repr(self)``."""
if all(scm == self.schemes[0] for scm in self.schemes):
schemes = self.schemes[0]
else:
schemes = self.schemes
posargs = [self.range, self.grid, self.domain, schemes]
nn_relevant = [x for x in self.nn_variants if x is not None]
if not nn_relevant:
# No NN axes, ignore nn_variants
optargs = []
else:
# Use single string if all are equal, one per axis otherwise
first_relevant = nn_relevant[0]
if all(var == first_relevant for var in nn_relevant):
variants = first_relevant
else:
variants = self.nn_variants
optargs = [('nn_variants', variants, 'left')]
inner_str = signature_string(posargs,
optargs,
sep=[',\n', ', ', ',\n'],
mod=['!r', ''])
return '{}(\n{}\n)'.format(self.__class__.__name__, indent(inner_str))
def __repr__(self):
"""Return ``repr(self)``."""
posargs = [self.range, self.grid, self.domain]
inner_str = signature_string(posargs, [],
sep=[',\n', ', ', ',\n'],
mod=['!r', ''])
return '{}(\n{}\n)'.format(self.__class__.__name__, indent(inner_str))
def __repr__(self):
"""Return ``repr(self)``."""
posargs = [self.motion_partition, self.det_partition]
optargs = [('det_radius', self.det_radius, -1)]
if not np.allclose(self.axis, self._default_config['axis']):
optargs.append(['axis', array_str(self.axis), ''])
if self._orig_to_det_init_arg is not None:
optargs.append([
'orig_to_det_init',
array_str(self._orig_to_det_init_arg), ''
])
if self._det_axes_init_arg is not None:
optargs.append([
'det_axes_init',
tuple(array_str(a) for a in self._det_axes_init_arg), None
])
if not np.array_equal(self.translation, (0, 0, 0)):
optargs.append(['translation', array_str(self.translation), ''])
sig_str = signature_string(posargs, optargs, sep=',\n')
return '{}(\n{}\n)'.format(self.__class__.__name__, indent(sig_str))
def __repr__(self):
"""Return ``repr(self)``."""
maxsize_full_print = 2 * np.get_printoptions()['edgeitems']
self_str = array_str(self, nprint=maxsize_full_print)
if self.ndim == 1 and self.size <= maxsize_full_print:
return '{!r}.element({})'.format(self.space, self_str)
else:
return '{!r}.element(\n{}\n)'.format(self.space, indent(self_str))
def __repr__(self):
"""Return ``repr(self)``."""
posargs = [self.displacement]
optargs = [
('templ_space', self.domain, self.displacement.space[0]),
('interp', self.interp, 'linear'),
]
inner_str = signature_string(posargs, optargs, mod='!r', sep=',\n')
return '{}(\n{}\n)'.format(self.__class__.__name__, indent(inner_str))
def __repr__(self):
"""Return ``repr(self)``."""
posargs = [self.template]
optargs = [
('domain', self.domain, self.template.space.tangent_bundle),
('interp', self.interp, 'linear'),
]
inner_str = signature_string(posargs, optargs, mod='!r', sep=',\n')
return '{}(\n{}\n)'.format(self.__class__.__name__, indent(inner_str))
def __repr__(self):
"""Return ``repr(self)``."""
posargs = [self.domain]
optargs = [('range', self.range, self.domain**self.domain.ndim),
('pad_mode', self.pad_mode, 'constant'),
('pad_const', self.pad_const, 0)]
inner_str = signature_string(posargs,
optargs,
sep=[',\n', ', ', ',\n'],
mod=['!r', ''])
return '{}(\n{}\n)'.format(self.__class__.__name__, indent(inner_str))
def __repr__(self):
"""Return ``repr(self)``."""
posargs = [self.domain]
optargs = [('axis', self.axis, None),
('range', self.range, self.domain),
('method', self.method, 'forward'),
('pad_mode', self.pad_mode, 'constant'),
('pad_const', self.pad_const, 0)]
inner_str = signature_string(posargs,
optargs,
sep=',\n',
mod=['!r', ''])
return '{}(\n{}\n)'.format(self.__class__.__name__, indent(inner_str))
def __repr__(self):
"""Return ``repr(self)``."""
if self.matrix_issparse:
posargs = ['<{} sparse matrix, format {}, {} nonzero entries>'
''.format(self.matrix.shape, self.matrix.format,
self.matrix.nnz)]
else:
posargs = [array_str(self.matrix, nprint=10)]
optargs = [('exponent', self.exponent, 2.0)]
inner_str = signature_string(posargs, optargs, sep=',\n',
mod=['!s', ''])
return '{}(\n{}\n)'.format(self.__class__.__name__, indent(inner_str))
def __repr__(self):
"""Return ``repr(self)``."""
if self.is_uniform:
ctor = 'uniform_grid'
posargs = [self.min_pt, self.max_pt, self.shape]
posmod = [array_str, array_str, '']
with npy_printoptions(precision=4):
inner_str = signature_string(posargs, [], mod=[posmod, ''])
return '{}({})'.format(ctor, inner_str)
else:
ctor = self.__class__.__name__
posargs = self.coord_vectors
posmod = array_str
inner_str = signature_string(posargs, [], sep=[',\n', ', ', ', '],
mod=[posmod, ''])
return '{}(\n{}\n)'.format(ctor, indent(inner_str))
def __str__(self):
"""Return ``str(self)``."""
dom_ran_str = '\n-->\n'.join([repr(self.domain), repr(self.range)])
return '{}:\n{}'.format(self.__class__.__name__, indent(dom_ran_str))
def __repr__(self):
"""Return ``repr(self)``."""
posargs = [self.partition]
optargs = [('center', array_str(self.center), None)]
inner_str = signature_string(posargs, optargs, sep=',\n')
return '{}(\n{}\n)'.format(self.__class__.__name__, indent(inner_str))
def __repr__(self):
"""Return ``repr(self)``."""
posargs = [self.left, self.right]
inner_str = signature_string(posargs, [], sep=',\n')
return '{}(\n{}\n)'.format(self.__class__.__name__, indent(inner_str))
