def __init__(self, size, dtype):
"""Initialize a new instance.
Parameters
----------
size : `int`
The number of dimensions of the space
dtype : `object`
The data type of the storage array. Can be provided in any
way the `numpy.dtype` function understands, most notably
as built-in type, as one of NumPy's internal datatype
objects or as string.
Only scalar data types (numbers) are allowed.
"""
NtuplesBase.__init__(self, size, dtype)
if not is_scalar_dtype(self.dtype):
raise TypeError('{!r} is not a scalar data type.'.format(dtype))
if is_real_dtype(self.dtype):
field = RealNumbers()
self._real_dtype = self.dtype
self._is_real = True
else:
field = ComplexNumbers()
self._real_dtype = _TYPE_MAP_C2R[self.dtype]
self._is_real = False
self._is_floating = is_floating_dtype(self.dtype)
LinearSpace.__init__(self, field)
def __init__(self, dim, isotropic=True):
LinearSpace.__init__(self, ComplexNumbers())
self.dim = dim
self.isotropic = isotropic
self.__size = 1 + dim
if isotropic:
self.__size += 1
elif dim == 2:
self.__size += 3
else:
self.__size += 6
def __init__(self, shape, dtype):
"""Initialize a new instance.
Parameters
----------
shape : nonnegative int or sequence of nonnegative ints
Number of entries of type ``dtype`` per axis in this space. A
single integer results in a space with rank 1, i.e., 1 axis.
dtype :
Data type of elements in this space. Can be provided
in any way the `numpy.dtype` constructor understands, e.g.
as built-in type or as a string.
For a data type with a ``dtype.shape``, these extra dimensions
are added *to the left* of ``shape``.
"""
# Handle shape and dtype, taking care also of dtypes with shape
try:
shape, shape_in = tuple(safe_int_conv(s) for s in shape), shape
except TypeError:
shape, shape_in = (safe_int_conv(shape), ), shape
if any(s < 0 for s in shape):
raise ValueError('`shape` must have only nonnegative entries, got '
'{}'.format(shape_in))
dtype = np.dtype(dtype)
# We choose this order in contrast to Numpy, since we usually want
# to represent discretizations of vector- or tensor-valued functions,
# i.e., if dtype.shape == (3,) we expect f[0] to have shape `shape`.
self.__shape = dtype.shape + shape
self.__dtype = dtype.base
if is_real_dtype(self.dtype):
# real includes non-floating-point like integers
field = RealNumbers()
self.__real_dtype = self.dtype
self.__real_space = self
self.__complex_dtype = TYPE_MAP_R2C.get(self.dtype, None)
self.__complex_space = None # Set in first call of astype
elif is_complex_floating_dtype(self.dtype):
field = ComplexNumbers()
self.__real_dtype = TYPE_MAP_C2R[self.dtype]
self.__real_space = None # Set in first call of astype
self.__complex_dtype = self.dtype
self.__complex_space = self
else:
field = None
LinearSpace.__init__(self, field)
def __init__(self, dom, field=RealNumbers()):
"""Initialize a new instance.
Parameters
----------
dom : `Set`
The domain of the functions.
field : `RealNumbers` or `ComplexNumbers`
The range of the functions.
"""
if not isinstance(dom, Set):
raise TypeError("domain {!r} not a Set instance.".format(dom))
if not (isinstance(field, (RealNumbers, ComplexNumbers))):
raise TypeError("field {!r} not a RealNumbers or " "ComplexNumbers instance.".format(field))
FunctionSet.__init__(self, dom, field)
LinearSpace.__init__(self, field)
def __init__(self, domain, field=RealNumbers()):
"""Initialize a new instance.
Parameters
----------
domain : `Set`
The domain of the functions
field : `Field`, optional
The range of the functions.
"""
if not isinstance(domain, Set):
raise TypeError('domain {!r} not a Set instance.'.format(domain))
if not isinstance(field, Field):
raise TypeError('field {!r} not a `Field` instance.'
''.format(field))
FunctionSet.__init__(self, domain, field)
LinearSpace.__init__(self, field)
def __init__(self, angles=None, detector=None, orientations=None, ortho=None):
LinearSpace.__init__(self, ComplexNumbers())
from .atomFuncs import theta_to_vec, perp
c = context()
if angles is not None:
angles = _getcoord_vectors(angles)
self.orientations = theta_to_vec(angles)
self.ortho = perp(angles)
elif orientations is not None and ortho is not None:
self.orientations = orientations
self.ortho = ortho
else:
raise ValueError
dim = self.orientations.shape[-1]
self.orientations = c.cast(self.orientations.reshape(-1, dim))
self.ortho = tuple(c.cast(o.reshape(-1, dim)) for o in self.ortho)
self.detector = _getcoord_vectors(detector)
self.detector = [c.cast(g.reshape(-1)) for g in self.detector]
self.shape = [self.orientations.shape[0], ] + \
[g.size for g in self.detector]
def __init__(self, size, dtype):
"""Initialize a new instance.
Parameters
----------
size : `int`
The number of dimensions of the space
dtype : `object`
The data type of the storage array. Can be provided in any
way the `numpy.dtype` function understands, most notably
as built-in type, as one of NumPy's internal datatype
objects or as string.
Only scalar data types (numbers) are allowed.
"""
NtuplesBase.__init__(self, size, dtype)
if not is_scalar_dtype(self.dtype):
raise TypeError('{!r} is not a scalar data type'.format(dtype))
if is_real_dtype(self.dtype):
field = RealNumbers()
self._is_real = True
self._real_dtype = self.dtype
self._real_space = self
self._complex_dtype = _TYPE_MAP_R2C.get(self.dtype, None)
self._complex_space = None # Set in first call of astype
else:
field = ComplexNumbers()
self._is_real = False
self._real_dtype = _TYPE_MAP_C2R[self.dtype]
self._real_space = None # Set in first call of astype
self._complex_dtype = self.dtype
self._complex_space = self
self._is_floating = is_floating_dtype(self.dtype)
LinearSpace.__init__(self, field)
def __init__(self, domain, field=None, out_dtype=None):
"""Initialize a new instance.
Parameters
----------
domain : `Set`
The domain of the functions
field : `Field`, optional
The range of the functions, usually the `RealNumbers` or
`ComplexNumbers`. If not given, the field is either inferred
from ``out_dtype``, or, if the latter is also `None`, set
to ``RealNumbers()``.
out_dtype : optional
Data type of the return value of a function in this space.
Can be given in any way `numpy.dtype` understands, e.g. as
string ('float64') or data type (`float`).
By default, 'float64' is used for real and 'complex128'
for complex spaces.
"""
if not isinstance(domain, Set):
raise TypeError('`domain` {!r} not a Set instance'.format(domain))
if field is not None and not isinstance(field, Field):
raise TypeError('`field` {!r} not a `Field` instance'
''.format(field))
# Data type: check if consistent with field, take default for None
dtype, dtype_in = np.dtype(out_dtype), out_dtype
# Default for both None
if field is None and out_dtype is None:
field = RealNumbers()
out_dtype = np.dtype('float64')
# field None, dtype given -> infer field
elif field is None:
if is_real_dtype(dtype):
field = RealNumbers()
elif is_complex_floating_dtype(dtype):
field = ComplexNumbers()
else:
raise ValueError('{} is not a scalar data type'
''.format(dtype_in))
# field given -> infer dtype if not given, else check consistency
elif field == RealNumbers():
if out_dtype is None:
out_dtype = np.dtype('float64')
elif not is_real_dtype(dtype):
raise ValueError('{} is not a real data type'
''.format(dtype_in))
elif field == ComplexNumbers():
if out_dtype is None:
out_dtype = np.dtype('complex128')
elif not is_complex_floating_dtype(dtype):
raise ValueError('{} is not a complex data type'
''.format(dtype_in))
# Else: keep out_dtype=None, which results in lazy dtype determination
LinearSpace.__init__(self, field)
FunctionSet.__init__(self, domain, field, out_dtype)
# Init cache attributes for real / complex variants
if self.field == RealNumbers():
self._real_out_dtype = self.out_dtype
self._real_space = self
self._complex_out_dtype = _TYPE_MAP_R2C.get(self.out_dtype,
np.dtype(object))
self._complex_space = None
elif self.field == ComplexNumbers():
self._real_out_dtype = _TYPE_MAP_C2R[self.out_dtype]
self._real_space = None
self._complex_out_dtype = self.out_dtype
self._complex_space = self
else:
self._real_out_dtype = None
self._real_space = None
self._complex_out_dtype = None
self._complex_space = None