123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642 |
- """
- numerictypes: Define the numeric type objects
- This module is designed so "from numerictypes import \\*" is safe.
- Exported symbols include:
- Dictionary with all registered number types (including aliases):
- typeDict
- Type objects (not all will be available, depends on platform):
- see variable sctypes for which ones you have
- Bit-width names
- int8 int16 int32 int64 int128
- uint8 uint16 uint32 uint64 uint128
- float16 float32 float64 float96 float128 float256
- complex32 complex64 complex128 complex192 complex256 complex512
- datetime64 timedelta64
- c-based names
- bool_
- object_
- void, str_, unicode_
- byte, ubyte,
- short, ushort
- intc, uintc,
- intp, uintp,
- int_, uint,
- longlong, ulonglong,
- single, csingle,
- float_, complex_,
- longfloat, clongfloat,
- As part of the type-hierarchy: xx -- is bit-width
- generic
- +-> bool_ (kind=b)
- +-> number
- | +-> integer
- | | +-> signedinteger (intxx) (kind=i)
- | | | byte
- | | | short
- | | | intc
- | | | intp int0
- | | | int_
- | | | longlong
- | | \\-> unsignedinteger (uintxx) (kind=u)
- | | ubyte
- | | ushort
- | | uintc
- | | uintp uint0
- | | uint_
- | | ulonglong
- | +-> inexact
- | +-> floating (floatxx) (kind=f)
- | | half
- | | single
- | | float_ (double)
- | | longfloat
- | \\-> complexfloating (complexxx) (kind=c)
- | csingle (singlecomplex)
- | complex_ (cfloat, cdouble)
- | clongfloat (longcomplex)
- +-> flexible
- | +-> character
- | | str_ (string_, bytes_) (kind=S) [Python 2]
- | | unicode_ (kind=U) [Python 2]
- | |
- | | bytes_ (string_) (kind=S) [Python 3]
- | | str_ (unicode_) (kind=U) [Python 3]
- | |
- | \\-> void (kind=V)
- \\-> object_ (not used much) (kind=O)
- """
- import types as _types
- import numbers
- import warnings
- from numpy.core.multiarray import (
- typeinfo, ndarray, array, empty, dtype, datetime_data,
- datetime_as_string, busday_offset, busday_count, is_busday,
- busdaycalendar
- )
- from numpy.core.overrides import set_module
- # we add more at the bottom
- __all__ = ['sctypeDict', 'sctypeNA', 'typeDict', 'typeNA', 'sctypes',
- 'ScalarType', 'obj2sctype', 'cast', 'nbytes', 'sctype2char',
- 'maximum_sctype', 'issctype', 'typecodes', 'find_common_type',
- 'issubdtype', 'datetime_data', 'datetime_as_string',
- 'busday_offset', 'busday_count', 'is_busday', 'busdaycalendar',
- ]
- # we don't need all these imports, but we need to keep them for compatibility
- # for users using np.core.numerictypes.UPPER_TABLE
- from ._string_helpers import (
- english_lower, english_upper, english_capitalize, LOWER_TABLE, UPPER_TABLE
- )
- from ._type_aliases import (
- sctypeDict,
- sctypeNA,
- allTypes,
- bitname,
- sctypes,
- _concrete_types,
- _concrete_typeinfo,
- _bits_of,
- )
- from ._dtype import _kind_name
- # we don't export these for import *, but we do want them accessible
- # as numerictypes.bool, etc.
- from builtins import bool, int, float, complex, object, str, bytes
- from numpy.compat import long, unicode
- # We use this later
- generic = allTypes['generic']
- genericTypeRank = ['bool', 'int8', 'uint8', 'int16', 'uint16',
- 'int32', 'uint32', 'int64', 'uint64', 'int128',
- 'uint128', 'float16',
- 'float32', 'float64', 'float80', 'float96', 'float128',
- 'float256',
- 'complex32', 'complex64', 'complex128', 'complex160',
- 'complex192', 'complex256', 'complex512', 'object']
- @set_module('numpy')
- def maximum_sctype(t):
- """
- Return the scalar type of highest precision of the same kind as the input.
- Parameters
- ----------
- t : dtype or dtype specifier
- The input data type. This can be a `dtype` object or an object that
- is convertible to a `dtype`.
- Returns
- -------
- out : dtype
- The highest precision data type of the same kind (`dtype.kind`) as `t`.
- See Also
- --------
- obj2sctype, mintypecode, sctype2char
- dtype
- Examples
- --------
- >>> np.maximum_sctype(int)
- <class 'numpy.int64'>
- >>> np.maximum_sctype(np.uint8)
- <class 'numpy.uint64'>
- >>> np.maximum_sctype(complex)
- <class 'numpy.complex256'> # may vary
- >>> np.maximum_sctype(str)
- <class 'numpy.str_'>
- >>> np.maximum_sctype('i2')
- <class 'numpy.int64'>
- >>> np.maximum_sctype('f4')
- <class 'numpy.float128'> # may vary
- """
- g = obj2sctype(t)
- if g is None:
- return t
- t = g
- base = _kind_name(dtype(t))
- if base in sctypes:
- return sctypes[base][-1]
- else:
- return t
- @set_module('numpy')
- def issctype(rep):
- """
- Determines whether the given object represents a scalar data-type.
- Parameters
- ----------
- rep : any
- If `rep` is an instance of a scalar dtype, True is returned. If not,
- False is returned.
- Returns
- -------
- out : bool
- Boolean result of check whether `rep` is a scalar dtype.
- See Also
- --------
- issubsctype, issubdtype, obj2sctype, sctype2char
- Examples
- --------
- >>> np.issctype(np.int32)
- True
- >>> np.issctype(list)
- False
- >>> np.issctype(1.1)
- False
- Strings are also a scalar type:
- >>> np.issctype(np.dtype('str'))
- True
- """
- if not isinstance(rep, (type, dtype)):
- return False
- try:
- res = obj2sctype(rep)
- if res and res != object_:
- return True
- return False
- except Exception:
- return False
- @set_module('numpy')
- def obj2sctype(rep, default=None):
- """
- Return the scalar dtype or NumPy equivalent of Python type of an object.
- Parameters
- ----------
- rep : any
- The object of which the type is returned.
- default : any, optional
- If given, this is returned for objects whose types can not be
- determined. If not given, None is returned for those objects.
- Returns
- -------
- dtype : dtype or Python type
- The data type of `rep`.
- See Also
- --------
- sctype2char, issctype, issubsctype, issubdtype, maximum_sctype
- Examples
- --------
- >>> np.obj2sctype(np.int32)
- <class 'numpy.int32'>
- >>> np.obj2sctype(np.array([1., 2.]))
- <class 'numpy.float64'>
- >>> np.obj2sctype(np.array([1.j]))
- <class 'numpy.complex128'>
- >>> np.obj2sctype(dict)
- <class 'numpy.object_'>
- >>> np.obj2sctype('string')
- >>> np.obj2sctype(1, default=list)
- <class 'list'>
- """
- # prevent abstract classes being upcast
- if isinstance(rep, type) and issubclass(rep, generic):
- return rep
- # extract dtype from arrays
- if isinstance(rep, ndarray):
- return rep.dtype.type
- # fall back on dtype to convert
- try:
- res = dtype(rep)
- except Exception:
- return default
- else:
- return res.type
- @set_module('numpy')
- def issubclass_(arg1, arg2):
- """
- Determine if a class is a subclass of a second class.
- `issubclass_` is equivalent to the Python built-in ``issubclass``,
- except that it returns False instead of raising a TypeError if one
- of the arguments is not a class.
- Parameters
- ----------
- arg1 : class
- Input class. True is returned if `arg1` is a subclass of `arg2`.
- arg2 : class or tuple of classes.
- Input class. If a tuple of classes, True is returned if `arg1` is a
- subclass of any of the tuple elements.
- Returns
- -------
- out : bool
- Whether `arg1` is a subclass of `arg2` or not.
- See Also
- --------
- issubsctype, issubdtype, issctype
- Examples
- --------
- >>> np.issubclass_(np.int32, int)
- False
- >>> np.issubclass_(np.int32, float)
- False
- >>> np.issubclass_(np.float64, float)
- True
- """
- try:
- return issubclass(arg1, arg2)
- except TypeError:
- return False
- @set_module('numpy')
- def issubsctype(arg1, arg2):
- """
- Determine if the first argument is a subclass of the second argument.
- Parameters
- ----------
- arg1, arg2 : dtype or dtype specifier
- Data-types.
- Returns
- -------
- out : bool
- The result.
- See Also
- --------
- issctype, issubdtype, obj2sctype
- Examples
- --------
- >>> np.issubsctype('S8', str)
- False
- >>> np.issubsctype(np.array([1]), int)
- True
- >>> np.issubsctype(np.array([1]), float)
- False
- """
- return issubclass(obj2sctype(arg1), obj2sctype(arg2))
- @set_module('numpy')
- def issubdtype(arg1, arg2):
- """
- Returns True if first argument is a typecode lower/equal in type hierarchy.
- Parameters
- ----------
- arg1, arg2 : dtype_like
- dtype or string representing a typecode.
- Returns
- -------
- out : bool
- See Also
- --------
- issubsctype, issubclass_
- numpy.core.numerictypes : Overview of numpy type hierarchy.
- Examples
- --------
- >>> np.issubdtype('S1', np.string_)
- True
- >>> np.issubdtype(np.float64, np.float32)
- False
- """
- if not issubclass_(arg1, generic):
- arg1 = dtype(arg1).type
- if not issubclass_(arg2, generic):
- arg2 = dtype(arg2).type
- return issubclass(arg1, arg2)
- # This dictionary allows look up based on any alias for an array data-type
- class _typedict(dict):
- """
- Base object for a dictionary for look-up with any alias for an array dtype.
- Instances of `_typedict` can not be used as dictionaries directly,
- first they have to be populated.
- """
- def __getitem__(self, obj):
- return dict.__getitem__(self, obj2sctype(obj))
- nbytes = _typedict()
- _alignment = _typedict()
- _maxvals = _typedict()
- _minvals = _typedict()
- def _construct_lookups():
- for name, info in _concrete_typeinfo.items():
- obj = info.type
- nbytes[obj] = info.bits // 8
- _alignment[obj] = info.alignment
- if len(info) > 5:
- _maxvals[obj] = info.max
- _minvals[obj] = info.min
- else:
- _maxvals[obj] = None
- _minvals[obj] = None
- _construct_lookups()
- @set_module('numpy')
- def sctype2char(sctype):
- """
- Return the string representation of a scalar dtype.
- Parameters
- ----------
- sctype : scalar dtype or object
- If a scalar dtype, the corresponding string character is
- returned. If an object, `sctype2char` tries to infer its scalar type
- and then return the corresponding string character.
- Returns
- -------
- typechar : str
- The string character corresponding to the scalar type.
- Raises
- ------
- ValueError
- If `sctype` is an object for which the type can not be inferred.
- See Also
- --------
- obj2sctype, issctype, issubsctype, mintypecode
- Examples
- --------
- >>> for sctype in [np.int32, np.double, np.complex_, np.string_, np.ndarray]:
- ... print(np.sctype2char(sctype))
- l # may vary
- d
- D
- S
- O
- >>> x = np.array([1., 2-1.j])
- >>> np.sctype2char(x)
- 'D'
- >>> np.sctype2char(list)
- 'O'
- """
- sctype = obj2sctype(sctype)
- if sctype is None:
- raise ValueError("unrecognized type")
- if sctype not in _concrete_types:
- # for compatibility
- raise KeyError(sctype)
- return dtype(sctype).char
- # Create dictionary of casting functions that wrap sequences
- # indexed by type or type character
- cast = _typedict()
- for key in _concrete_types:
- cast[key] = lambda x, k=key: array(x, copy=False).astype(k)
- try:
- ScalarType = [_types.IntType, _types.FloatType, _types.ComplexType,
- _types.LongType, _types.BooleanType,
- _types.StringType, _types.UnicodeType, _types.BufferType]
- except AttributeError:
- # Py3K
- ScalarType = [int, float, complex, int, bool, bytes, str, memoryview]
- ScalarType.extend(_concrete_types)
- ScalarType = tuple(ScalarType)
- # Now add the types we've determined to this module
- for key in allTypes:
- globals()[key] = allTypes[key]
- __all__.append(key)
- del key
- typecodes = {'Character':'c',
- 'Integer':'bhilqp',
- 'UnsignedInteger':'BHILQP',
- 'Float':'efdg',
- 'Complex':'FDG',
- 'AllInteger':'bBhHiIlLqQpP',
- 'AllFloat':'efdgFDG',
- 'Datetime': 'Mm',
- 'All':'?bhilqpBHILQPefdgFDGSUVOMm'}
- # backwards compatibility --- deprecated name
- typeDict = sctypeDict
- typeNA = sctypeNA
- # b -> boolean
- # u -> unsigned integer
- # i -> signed integer
- # f -> floating point
- # c -> complex
- # M -> datetime
- # m -> timedelta
- # S -> string
- # U -> Unicode string
- # V -> record
- # O -> Python object
- _kind_list = ['b', 'u', 'i', 'f', 'c', 'S', 'U', 'V', 'O', 'M', 'm']
- __test_types = '?'+typecodes['AllInteger'][:-2]+typecodes['AllFloat']+'O'
- __len_test_types = len(__test_types)
- # Keep incrementing until a common type both can be coerced to
- # is found. Otherwise, return None
- def _find_common_coerce(a, b):
- if a > b:
- return a
- try:
- thisind = __test_types.index(a.char)
- except ValueError:
- return None
- return _can_coerce_all([a, b], start=thisind)
- # Find a data-type that all data-types in a list can be coerced to
- def _can_coerce_all(dtypelist, start=0):
- N = len(dtypelist)
- if N == 0:
- return None
- if N == 1:
- return dtypelist[0]
- thisind = start
- while thisind < __len_test_types:
- newdtype = dtype(__test_types[thisind])
- numcoerce = len([x for x in dtypelist if newdtype >= x])
- if numcoerce == N:
- return newdtype
- thisind += 1
- return None
- def _register_types():
- numbers.Integral.register(integer)
- numbers.Complex.register(inexact)
- numbers.Real.register(floating)
- numbers.Number.register(number)
- _register_types()
- @set_module('numpy')
- def find_common_type(array_types, scalar_types):
- """
- Determine common type following standard coercion rules.
- Parameters
- ----------
- array_types : sequence
- A list of dtypes or dtype convertible objects representing arrays.
- scalar_types : sequence
- A list of dtypes or dtype convertible objects representing scalars.
- Returns
- -------
- datatype : dtype
- The common data type, which is the maximum of `array_types` ignoring
- `scalar_types`, unless the maximum of `scalar_types` is of a
- different kind (`dtype.kind`). If the kind is not understood, then
- None is returned.
- See Also
- --------
- dtype, common_type, can_cast, mintypecode
- Examples
- --------
- >>> np.find_common_type([], [np.int64, np.float32, complex])
- dtype('complex128')
- >>> np.find_common_type([np.int64, np.float32], [])
- dtype('float64')
- The standard casting rules ensure that a scalar cannot up-cast an
- array unless the scalar is of a fundamentally different kind of data
- (i.e. under a different hierarchy in the data type hierarchy) then
- the array:
- >>> np.find_common_type([np.float32], [np.int64, np.float64])
- dtype('float32')
- Complex is of a different type, so it up-casts the float in the
- `array_types` argument:
- >>> np.find_common_type([np.float32], [complex])
- dtype('complex128')
- Type specifier strings are convertible to dtypes and can therefore
- be used instead of dtypes:
- >>> np.find_common_type(['f4', 'f4', 'i4'], ['c8'])
- dtype('complex128')
- """
- array_types = [dtype(x) for x in array_types]
- scalar_types = [dtype(x) for x in scalar_types]
- maxa = _can_coerce_all(array_types)
- maxsc = _can_coerce_all(scalar_types)
- if maxa is None:
- return maxsc
- if maxsc is None:
- return maxa
- try:
- index_a = _kind_list.index(maxa.kind)
- index_sc = _kind_list.index(maxsc.kind)
- except ValueError:
- return None
- if index_sc > index_a:
- return _find_common_coerce(maxsc, maxa)
- else:
- return maxa
|