def __repr__(self): """Return ``repr(self)``.""" weight_str = self.weighting.repr_part if self.size == 0: posargs = [] optargs = [('field', self.field, None)] oneline = True elif self.is_power_space: posargs = [self.spaces[0], self.size] optargs = [] oneline = True else: posargs = self.spaces optargs = [] argstr = ', '.join(repr(s) for s in self.spaces) oneline = (len(argstr + weight_str) <= 40 and '\n' not in argstr + weight_str) if oneline: inner_str = signature_string(posargs, optargs, sep=', ', mod='!r') if weight_str: inner_str = ', '.join([inner_str, weight_str]) return '{}({})'.format(self.__class__.__name__, inner_str) else: inner_str = signature_string(posargs, optargs, sep=',\n', mod='!r') if weight_str: inner_str = ',\n'.join([inner_str, weight_str]) return '{}(\n{}\n)'.format(self.__class__.__name__, indent_rows(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', self.axis.tolist(), None]) if self._orig_to_det_init_arg is not None: optargs.append([ 'orig_to_det_init', self._orig_to_det_init_arg.tolist(), None ]) if self._det_axes_init_arg is not None: optargs.append([ 'det_axes_init', tuple(a.tolist() for a in self._det_axes_init_arg), None ]) if not np.array_equal(self.translation, (0, 0, 0)): optargs.append(['translation', self.translation.tolist(), None]) sig_str = signature_string(posargs, optargs, sep=',\n') return '{}(\n{}\n)'.format(self.__class__.__name__, indent_rows(sig_str))
def __repr__(self): """Return ``repr(self)``.""" # Matrix printing itself in an executable way (for dense matrix) if self.matrix_issparse: # Don't convert to dense, can take forever matrix_str = repr(self.matrix) else: matrix_str = np.array2string(self.matrix, separator=', ') posargs = [matrix_str] # Optional arguments with defaults, inferred from the matrix optargs = [] # domain optargs.append( ('domain', self.domain, fn(self.matrix.shape[1], self.matrix.dtype))) # range optargs.append( ('range', self.range, fn(self.matrix.shape[0], self.matrix.dtype))) inner_str = signature_string(posargs, optargs, sep=[', ', ', ', ',\n'], mod=[['!s'], ['!r', '!r']]) return '{}(\n{}\n)'.format(self.__class__.__name__, indent_rows(inner_str))
def __repr__(self): """Return ``repr(self)``.""" posargs = [self.partition] optargs = [('center', self.center.tolist(), None)] inner_str = signature_string(posargs, optargs, sep=',\n') return '{}(\n{}\n)'.format(self.__class__.__name__, indent_rows(inner_str))
def __repr__(self): """Return ``repr(self)``.""" bdry_fracs = np.vstack(self.boundary_cell_fractions) default_bdry_fracs = np.all(np.isclose(bdry_fracs, 0.5) | np.isclose(bdry_fracs, 1.0)) # Get default shifts of min_pt and max_pt from corresponding # grid points csizes_l = np.fromiter((s[0] for s in self.cell_sizes_vecs), dtype=float) csizes_r = np.fromiter((s[-1] for s in self.cell_sizes_vecs), dtype=float) shift_l = ((bdry_fracs[:, 0].astype(float).squeeze() - 0.5) * csizes_l) shift_r = ((bdry_fracs[:, 1].astype(float).squeeze() - 0.5) * csizes_r) if self.is_uniform and default_bdry_fracs: constructor = 'uniform_partition' if self.ndim == 1: posargs = [self.min_pt[0], self.max_pt[0], self.shape[0]] else: posargs = [list(self.min_pt), list(self.max_pt), self.shape] optargs = [('nodes_on_bdry', self.nodes_on_bdry, False)] sig_str = signature_string(posargs, optargs) return '{}({})'.format(constructor, sig_str) else: constructor = 'nonuniform_partition' posargs = [list(v) for v in self.coord_vectors] optargs = [] # Defaults with and without nodes_on_bdry option nodes_def_min_pt = self.grid.min_pt - shift_l nodes_def_max_pt = self.grid.max_pt + shift_r def_min_pt = self.grid.min_pt - 0.5 * csizes_l def_max_pt = self.grid.max_pt + 0.5 * csizes_r # Since min/max_pt and nodes_on_bdry are mutex, we need a # couple of cases here if (np.allclose(self.min_pt, nodes_def_min_pt) and np.allclose(self.max_pt, nodes_def_max_pt)): # Append nodes_on_bdry to list of optional args optargs.append(('nodes_on_bdry', self.nodes_on_bdry, False)) else: # Append min/max_pt to list of optional args if not # default (need check here because array comparison is # ambiguous) if not np.allclose(self.min_pt, def_min_pt): p = self.min_pt[0] if self.ndim == 1 else list(self.min_pt) optargs.append((('min_pt', p, None))) if not np.allclose(self.max_pt, def_max_pt): p = self.max_pt[0] if self.ndim == 1 else list(self.max_pt) optargs.append((('max_pt', p, None))) sig_str = signature_string(posargs, optargs, sep=[',\n', ', ', ',\n']) return '{}(\n{}\n)'.format(constructor, indent_rows(sig_str))
def __repr__(self): """Return ``repr(self)``.""" bdry_fracs = np.vstack(self.boundary_cell_fractions) default_bdry_fracs = np.all( np.isclose(bdry_fracs, 0.5) | np.isclose(bdry_fracs, 1.0)) # Get default shifts of min_pt and max_pt from corresponding # grid points csizes_l = np.fromiter((s[0] for s in self.cell_sizes_vecs), dtype=float) csizes_r = np.fromiter((s[-1] for s in self.cell_sizes_vecs), dtype=float) shift_l = ((bdry_fracs[:, 0].astype(float).squeeze() - 0.5) * csizes_l) shift_r = ((bdry_fracs[:, 1].astype(float).squeeze() - 0.5) * csizes_r) if self.is_uniform and default_bdry_fracs: constructor = 'uniform_partition' if self.ndim == 1: posargs = [self.min_pt[0], self.max_pt[0], self.shape[0]] else: posargs = [list(self.min_pt), list(self.max_pt), self.shape] optargs = [('nodes_on_bdry', self.nodes_on_bdry, False)] sig_str = signature_string(posargs, optargs) return '{}({})'.format(constructor, sig_str) else: constructor = 'nonuniform_partition' posargs = [list(v) for v in self.coord_vectors] optargs = [] # Defaults with and without nodes_on_bdry option nodes_def_min_pt = self.grid.min_pt - shift_l nodes_def_max_pt = self.grid.max_pt + shift_r def_min_pt = self.grid.min_pt - 0.5 * csizes_l def_max_pt = self.grid.max_pt + 0.5 * csizes_r # Since min/max_pt and nodes_on_bdry are mutex, we need a # couple of cases here if (np.allclose(self.min_pt, nodes_def_min_pt) and np.allclose(self.max_pt, nodes_def_max_pt)): # Append nodes_on_bdry to list of optional args optargs.append(('nodes_on_bdry', self.nodes_on_bdry, False)) else: # Append min/max_pt to list of optional args if not # default (need check here because array comparison is # ambiguous) if not np.allclose(self.min_pt, def_min_pt): p = self.min_pt[0] if self.ndim == 1 else list(self.min_pt) optargs.append((('min_pt', p, None))) if not np.allclose(self.max_pt, def_max_pt): p = self.max_pt[0] if self.ndim == 1 else list(self.max_pt) optargs.append((('max_pt', p, None))) sig_str = signature_string(posargs, optargs, sep=[',\n', ', ', ',\n']) return '{}(\n{}\n)'.format(constructor, indent_rows(sig_str))
def __repr__(self): """Return ``repr(self)``.""" posargs = [self.array] optargs = [('exponent', self.exponent, 2.0), ('dist_using_inner', self.dist_using_inner, False)] inner_str = signature_string(posargs, optargs, sep=[', ', ', ', ',\n'], mod=['!r', '']) return '{}(\n{}\n)'.format(self.__class__.__name__, indent_rows(inner_str))
def __repr__(self): """Return ``repr(self)``.""" if self.is_uniform: constructor = 'uniform_grid' posargs = [list(self.min_pt), list(self.max_pt), self.shape] inner_str = signature_string(posargs, []) return '{}({})'.format(constructor, inner_str) else: constructor = self.__class__.__name__ posargs = [array1d_repr(v) for v in self.coord_vectors] inner_str = signature_string(posargs, [], sep=[',\n', ', ', ', '], mod=['!s', '']) return '{}(\n{}\n)'.format(constructor, indent_rows(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_rows(inner_str))
def __repr__(self): """Return ``repr(self)``.""" posargs = [self.partition, self.axis] inner_str = signature_string(posargs, [], sep=[',\n', ', ', ', ']) return '{}({})'.format(self.__class__.__name__, indent_rows(inner_str))