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 __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)