numpy.core.numerictypes
index
/usr/lib/python2.6/dist-packages/numpy/core/numerictypes.py

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
 
    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                                 (kind=i)
     |     integer
     |     signedinteger   (intxx)
     |     byte
     |     short
     |     intc
     |     intp           int0
     |     int_
     |     longlong
     +-> unsignedinteger  (uintxx)              (kind=u)
     |     ubyte
     |     ushort
     |     uintc
     |     uintp          uint0
     |     uint_
     |     ulonglong
     +-> inexact
     |   +-> floating           (floatxx)       (kind=f)
     |   |     single
     |   |     float_  (double)
     |   |     longfloat
     |   \-> complexfloating    (complexxx)     (kind=c)
     |         csingle  (singlecomplex)
     |         complex_ (cfloat, cdouble)
     |         clongfloat (longcomplex)
     +-> flexible
     |     character
     |     str_     (string_)                   (kind=S)
     |     unicode_                             (kind=U)
     |     void                                 (kind=V)
     |
     \-> object_ (not used much)                (kind=O)

 
Modules
       
types

 
Classes
       
dict(object)
_typedict

 
class _typedict(dict)
    # This dictionary allows look up based on any alias for an array data-type
 
 
Method resolution order:
_typedict
dict
object

Methods defined here:
__getitem__(self, obj)

Data descriptors defined here:
__dict__
dictionary for instance variables (if defined)
__weakref__
list of weak references to the object (if defined)

Methods inherited from dict:
__cmp__(...)
x.__cmp__(y) <==> cmp(x,y)
__contains__(...)
D.__contains__(k) -> True if D has a key k, else False
__delitem__(...)
x.__delitem__(y) <==> del x[y]
__eq__(...)
x.__eq__(y) <==> x==y
__ge__(...)
x.__ge__(y) <==> x>=y
__getattribute__(...)
x.__getattribute__('name') <==> x.name
__gt__(...)
x.__gt__(y) <==> x>y
__init__(...)
x.__init__(...) initializes x; see x.__class__.__doc__ for signature
__iter__(...)
x.__iter__() <==> iter(x)
__le__(...)
x.__le__(y) <==> x<=y
__len__(...)
x.__len__() <==> len(x)
__lt__(...)
x.__lt__(y) <==> x<y
__ne__(...)
x.__ne__(y) <==> x!=y
__repr__(...)
x.__repr__() <==> repr(x)
__setitem__(...)
x.__setitem__(i, y) <==> x[i]=y
__sizeof__(...)
D.__sizeof__() -> size of D in memory, in bytes
clear(...)
D.clear() -> None.  Remove all items from D.
copy(...)
D.copy() -> a shallow copy of D
get(...)
D.get(k[,d]) -> D[k] if k in D, else d.  d defaults to None.
has_key(...)
D.has_key(k) -> True if D has a key k, else False
items(...)
D.items() -> list of D's (key, value) pairs, as 2-tuples
iteritems(...)
D.iteritems() -> an iterator over the (key, value) items of D
iterkeys(...)
D.iterkeys() -> an iterator over the keys of D
itervalues(...)
D.itervalues() -> an iterator over the values of D
keys(...)
D.keys() -> list of D's keys
pop(...)
D.pop(k[,d]) -> v, remove specified key and return the corresponding value.
If key is not found, d is returned if given, otherwise KeyError is raised
popitem(...)
D.popitem() -> (k, v), remove and return some (key, value) pair as a
2-tuple; but raise KeyError if D is empty.
setdefault(...)
D.setdefault(k[,d]) -> D.get(k,d), also set D[k]=d if k not in D
update(...)
D.update(E, **F) -> None.  Update D from dict/iterable E and F.
If E has a .keys() method, does:     for k in E: D[k] = E[k]
If E lacks .keys() method, does:     for (k, v) in E: D[k] = v
In either case, this is followed by: for k in F: D[k] = F[k]
values(...)
D.values() -> list of D's values

Data and other attributes inherited from dict:
__hash__ = None
__new__ = <built-in method __new__ of type object at 0x81a1e0>
T.__new__(S, ...) -> a new object with type S, a subtype of T
fromkeys = <built-in method fromkeys of type object at 0x2293d40>
dict.fromkeys(S[,v]) -> New dict with keys from S and values equal to v.
v defaults to None.

 
Functions
       
_add_aliases()
_add_array_type(typename, bits)
_add_integer_aliases()
_add_types()
_construct_char_code_lookup()
_construct_lookups()
_evalname(name)
_find_common_coerce(a, b)
# Keep incrementing until a common type both can be coerced to
#  is found.  Otherwise, return None
_python_type(t)
returns the type corresponding to a certain Python type
_set_array_types()
_set_up_aliases()
# Rework the Python names (so that float and complex and int are consistent
#                            with Python usage)
bitname(obj)
Return a bit-width name for a given type object
english_capitalize(s)
Apply English case rules to convert the first character of an ASCII
string to upper case.
 
This is an internal utility function to replace calls to str.capitalize()
such that we can avoid changing behavior with changing locales.
 
Parameters
----------
s : str
 
Returns
-------
capitalized : str
 
Examples
--------
>>> from numpy.core.numerictypes import english_capitalize
>>> english_capitalize('int8')
'Int8'
>>> english_capitalize('Int8')
'Int8'
>>> english_capitalize('')
''
english_lower(s)
Apply English case rules to convert ASCII strings to all lower case.
 
This is an internal utility function to replace calls to str.lower() such
that we can avoid changing behavior with changing locales. In particular,
Turkish has distinct dotted and dotless variants of the Latin letter "I" in
both lowercase and uppercase. Thus, "I".lower() != "i" in a "tr" locale.
 
Parameters
----------
s : str
 
Returns
-------
lowered : str
 
Examples
--------
>>> from numpy.core.numerictypes import english_lower
>>> english_lower('ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789_')
'abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyz0123456789_'
>>> english_lower('')
''
english_upper(s)
Apply English case rules to convert ASCII strings to all upper case.
 
This is an internal utility function to replace calls to str.upper() such
that we can avoid changing behavior with changing locales. In particular,
Turkish has distinct dotted and dotless variants of the Latin letter "I" in
both lowercase and uppercase. Thus, "i".upper() != "I" in a "tr" locale.
 
Parameters
----------
s : str
 
Returns
-------
uppered : str
 
Examples
--------
>>> from numpy.core.numerictypes import english_upper
>>> english_upper('ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789_')
'ABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_'
>>> english_upper('')
''

 
Data
        LOWER_TABLE = '\x00\x01\x02\x03\x04\x05\x06\x07\x08\t\n\x0b\x0c\r\x0e\x0f\x10\x11\x12\x13\x14\x15\x16\x17\x18\x19\x1a\x1b\x1c\x1d\x1e\x1f !"#$%&\'()*+,-./...\xcf\xd0\xd1\xd2\xd3\xd4\xd5\xd6\xd7\xd8\xd9\xda\xdb\xdc\xdd\xde\xdf\xe0\xe1\xe2\xe3\xe4\xe5\xe6\xe7\xe8\xe9\xea\xeb\xec\xed\xee\xef\xf0\xf1\xf2\xf3\xf4\xf5\xf6\xf7\xf8\xf9\xfa\xfb\xfc\xfd\xfe\xff'
UPPER_TABLE = '\x00\x01\x02\x03\x04\x05\x06\x07\x08\t\n\x0b\x0c\r\x0e\x0f\x10\x11\x12\x13\x14\x15\x16\x17\x18\x19\x1a\x1b\x1c\x1d\x1e\x1f !"#$%&\'()*+,-./...\xcf\xd0\xd1\xd2\xd3\xd4\xd5\xd6\xd7\xd8\xd9\xda\xdb\xdc\xdd\xde\xdf\xe0\xe1\xe2\xe3\xe4\xe5\xe6\xe7\xe8\xe9\xea\xeb\xec\xed\xee\xef\xf0\xf1\xf2\xf3\xf4\xf5\xf6\xf7\xf8\xf9\xfa\xfb\xfc\xfd\xfe\xff'
__all__ = ['sctypeDict', 'sctypeNA', 'typeDict', 'typeNA', 'sctypes', 'ScalarType', 'obj2sctype', 'cast', 'nbytes', 'sctype2char', 'maximum_sctype', 'issctype', 'typecodes', 'find_common_type', 'complex_', 'clongfloat', 'uintp', 'intc', 'int32', 'unsignedinteger', ...]
__file__ = '/usr/lib/python2.6/dist-packages/numpy/core/numerictypes.pyc'
__len_test_types = 17
__name__ = 'numpy.core.numerictypes'
__package__ = 'numpy.core'
__test_types = 'bBhHiIlLqQfdgFDGO'
_alignment = {<type 'numpy.int64'>: 8, <type 'numpy.int16'>: ...e 'numpy.complex128'>: 8, <type 'numpy.void'>: 1}
_all_chars = ['\x00', '\x01', '\x02', '\x03', '\x04', '\x05', '\x06', '\x07', '\x08', '\t', '\n', '\x0b', '\x0c', '\r', '\x0e', '\x0f', '\x10', '\x11', '\x12', '\x13', ...]
_ascii_lower = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', ...]
_ascii_upper = ['A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', ...]
_kind_list = ['b', 'u', 'i', 'f', 'c', 'S', 'U', 'V', 'O']
_maxvals = {<type 'numpy.int64'>: 9223372036854775807L, <ty...py.complex128'>: None, <type 'numpy.void'>: None}
_minvals = {<type 'numpy.int64'>: -9223372036854775808L, <t...py.complex128'>: None, <type 'numpy.void'>: None}
_python_types = {<type 'float'>: 'float_', <type 'int'>: 'int_', <type 'str'>: 'string_', <type 'unicode'>: 'unicode_', <type 'bool'>: 'bool_', <type 'buffer'>: 'void', <type 'complex'>: 'complex_'}
_sctype2char_dict = {<type 'numpy.bool_'>: '?', <type 'numpy.int8'>: 'b', <type 'numpy.int16'>: 'h', <type 'numpy.int32'>: 'i', <type 'numpy.int64'>: 'l', <type 'numpy.int64'>: 'q', <type 'numpy.uint8'>: 'B', <type 'numpy.uint16'>: 'H', <type 'numpy.uint32'>: 'I', <type 'numpy.uint64'>: 'L', ...}
_typestr = {<type 'numpy.int64'>: 'i8', <type 'numpy.int16'...py.complex128'>: 'c16', <type 'numpy.void'>: 'V'}
allTypes = {'bool8': <type 'numpy.bool_'>, 'bool_': <type 'numpy.bool_'>, 'byte': <type 'numpy.int8'>, 'cdouble': <type 'numpy.complex128'>, 'cfloat': <type 'numpy.complex128'>, 'character': <type 'numpy.character'>, 'clongdouble': <type 'numpy.complex256'>, 'clongfloat': <type 'numpy.complex256'>, 'complex128': <type 'numpy.complex128'>, 'complex256': <type 'numpy.complex256'>, ...}
genericTypeRank = ['bool', 'int8', 'uint8', 'int16', 'uint16', 'int32', 'uint32', 'int64', 'uint64', 'int128', 'uint128', 'float16', 'float32', 'float64', 'float80', 'float96', 'float128', 'float256', 'complex32', 'complex64', ...]
typeinfo = {'BOOL': ('?', 0, 8, 1, 1, 0, <type 'numpy.bool_'>), 'BYTE': ('b', 1, 8, 1, 127, -128, <type 'numpy.int8'>), 'CDOUBLE': ('D', 15, 128, 8, <type 'numpy.complex128'>), 'CFLOAT': ('F', 14, 64, 4, <type 'numpy.complex64'>), 'CLONGDOUBLE': ('G', 16, 256, 16, <type 'numpy.complex256'>), 'Character': <type 'numpy.character'>, 'ComplexFloating': <type 'numpy.complexfloating'>, 'DOUBLE': ('d', 12, 64, 8, <type 'numpy.float64'>), 'FLOAT': ('f', 11, 32, 4, <type 'numpy.float32'>), 'Flexible': <type 'numpy.flexible'>, ...}
val = 'V'