arkouda.numpy.dtypes¶

Attributes¶

TYPE_CHECKING

Classes¶

`ARKOUDA_SUPPORTED_BOOLS`	Built-in immutable sequence.
`ARKOUDA_SUPPORTED_DTYPES`	Built-in immutable sequence.
`ARKOUDA_SUPPORTED_FLOATS`	Built-in immutable sequence.
`ARKOUDA_SUPPORTED_INTS`	Built-in immutable sequence.
`ARKOUDA_SUPPORTED_NUMBERS`	Built-in immutable sequence.
`BoolDType`	DType class corresponding to the scalar type and dtype of the same name.
`ByteDType`	DType class corresponding to the scalar type and dtype of the same name.
`BytesDType`	DType class corresponding to the scalar type and dtype of the same name.
`CLongDoubleDType`	DType class corresponding to the scalar type and dtype of the same name.
`Complex128DType`	DType class corresponding to the scalar type and dtype of the same name.
`Complex64DType`	DType class corresponding to the scalar type and dtype of the same name.
`DType`
`DTypeObjects`	Build an immutable unordered collection of unique elements.
`DTypes`	Build an immutable unordered collection of unique elements.
`DateTime64DType`	DType class corresponding to the scalar type and dtype of the same name.
`Enum`	Create a collection of name/value pairs.
`Float16DType`	DType class corresponding to the scalar type and dtype of the same name.
`Float32DType`	DType class corresponding to the scalar type and dtype of the same name.
`Float64DType`	DType class corresponding to the scalar type and dtype of the same name.
`Int16DType`	DType class corresponding to the scalar type and dtype of the same name.
`Int32DType`	DType class corresponding to the scalar type and dtype of the same name.
`Int64DType`	DType class corresponding to the scalar type and dtype of the same name.
`Int8DType`	DType class corresponding to the scalar type and dtype of the same name.
`IntDType`	DType class corresponding to the scalar type and dtype of the same name.
`List`	A generic version of list.
`LongDType`	DType class corresponding to the scalar type and dtype of the same name.
`LongDoubleDType`	DType class corresponding to the scalar type and dtype of the same name.
`LongLongDType`	DType class corresponding to the scalar type and dtype of the same name.
`NUMBER_FORMAT_STRINGS`	dict() -> new empty dictionary
`NumericDTypes`	Build an immutable unordered collection of unique elements.
`ObjectDType`	DType class corresponding to the scalar type and dtype of the same name.
`ScalarDTypes`	Build an immutable unordered collection of unique elements.
`SeriesDTypes`	dict() -> new empty dictionary
`ShortDType`	DType class corresponding to the scalar type and dtype of the same name.
`StrDType`	DType class corresponding to the scalar type and dtype of the same name.
`TimeDelta64DType`	DType class corresponding to the scalar type and dtype of the same name.
`UByteDType`	DType class corresponding to the scalar type and dtype of the same name.
`UInt16DType`	DType class corresponding to the scalar type and dtype of the same name.
`UInt32DType`	DType class corresponding to the scalar type and dtype of the same name.
`UInt64DType`	DType class corresponding to the scalar type and dtype of the same name.
`UInt8DType`	DType class corresponding to the scalar type and dtype of the same name.
`UIntDType`	DType class corresponding to the scalar type and dtype of the same name.
`ULongDType`	DType class corresponding to the scalar type and dtype of the same name.
`ULongLongDType`	DType class corresponding to the scalar type and dtype of the same name.
`UShortDType`	DType class corresponding to the scalar type and dtype of the same name.
`Union`	Union type; Union[X, Y] means either X or Y.
`VoidDType`	DType class corresponding to the scalar type and dtype of the same name.
`all_scalars`	Mixin to prevent iteration, without being compatible with Iterable.
`annotations`
`bigint`	Datatype for representing integers of variable size.
`bitType`	Unsigned signed integer type, 64bit on 64bit systems and 32bit on 32bit
`bool_`	Boolean type (True or False), stored as a byte.
`bool_scalars`	Mixin to prevent iteration, without being compatible with Iterable.
`complex128`	Complex number type composed of two double-precision floating-point
`complex64`	Complex number type composed of two single-precision floating-point
`float16`	Half-precision floating-point number type.
`float32`	Single-precision floating-point number type, compatible with C `float`.
`float64`	Double-precision floating-point number type, compatible with Python
`float_scalars`	Mixin to prevent iteration, without being compatible with Iterable.
`int16`	Signed integer type, compatible with C `short`.
`int32`	Signed integer type, compatible with C `int`.
`int64`	Default signed integer type, 64bit on 64bit systems and 32bit on 32bit
`int8`	Signed integer type, compatible with C `char`.
`intTypes`	Build an immutable unordered collection of unique elements.
`int_scalars`	Mixin to prevent iteration, without being compatible with Iterable.
`numeric_and_bool_scalars`	Mixin to prevent iteration, without being compatible with Iterable.
`numeric_scalars`	Mixin to prevent iteration, without being compatible with Iterable.
`numpy_scalars`	Mixin to prevent iteration, without being compatible with Iterable.
`str_`	A unicode string.
`str_scalars`	Mixin to prevent iteration, without being compatible with Iterable.
`uint16`	Unsigned integer type, compatible with C `unsigned short`.
`uint32`	Unsigned integer type, compatible with C `unsigned int`.
`uint64`	Unsigned signed integer type, 64bit on 64bit systems and 32bit on 32bit
`uint8`	Unsigned integer type, compatible with C `unsigned char`.

Functions¶

`can_cast`(→ bool)	Returns True if cast between data types can occur according to the casting rule.
`cast`(typ, val)	Cast a value to a type.
`dtype`(dtype)	Create a data type object.
`get_byteorder`(→ str)	Get a concrete byteorder (turns '=' into '<' or '>') on the client.
`get_server_byteorder`(→ str)	Get the server's byteorder
`isSupportedBool`(num)	Whether a scalar is an arkouda supported boolean dtype.
`isSupportedDType`(→ bool)	Whether a scalar is an arkouda supported dtype.
`isSupportedFloat`(num)	Whether a scalar is an arkouda supported float dtype.
`isSupportedInt`(num)	Whether a scalar is an arkouda supported integer dtype.
`isSupportedNumber`(num)	Whether a scalar is an arkouda supported numeric dtype.
`resolve_scalar_dtype`(→ str)	Try to infer what dtype arkouda_server should treat val as.
`result_type`(→ Union[np.dtype, type])	Determine the promoted result dtype of inputs, including support for Arkouda's bigint.

Module Contents¶

class arkouda.numpy.dtypes.ARKOUDA_SUPPORTED_BOOLS¶

Built-in immutable sequence.

If no argument is given, the constructor returns an empty tuple. If iterable is specified the tuple is initialized from iterable’s items.

If the argument is a tuple, the return value is the same object.

count(value, /)¶: Return number of occurrences of value.

index(value, start=0, stop=9223372036854775807, /)¶

Return first index of value.

Raises ValueError if the value is not present.

class arkouda.numpy.dtypes.ARKOUDA_SUPPORTED_DTYPES¶

Built-in immutable sequence.

If no argument is given, the constructor returns an empty tuple. If iterable is specified the tuple is initialized from iterable’s items.

If the argument is a tuple, the return value is the same object.

count(value, /)¶: Return number of occurrences of value.

index(value, start=0, stop=9223372036854775807, /)¶

Return first index of value.

Raises ValueError if the value is not present.

class arkouda.numpy.dtypes.ARKOUDA_SUPPORTED_FLOATS¶

Built-in immutable sequence.

If no argument is given, the constructor returns an empty tuple. If iterable is specified the tuple is initialized from iterable’s items.

If the argument is a tuple, the return value is the same object.

count(value, /)¶: Return number of occurrences of value.

index(value, start=0, stop=9223372036854775807, /)¶

Return first index of value.

Raises ValueError if the value is not present.

class arkouda.numpy.dtypes.ARKOUDA_SUPPORTED_INTS¶

Built-in immutable sequence.

If no argument is given, the constructor returns an empty tuple. If iterable is specified the tuple is initialized from iterable’s items.

If the argument is a tuple, the return value is the same object.

count(value, /)¶: Return number of occurrences of value.

index(value, start=0, stop=9223372036854775807, /)¶

Return first index of value.

Raises ValueError if the value is not present.

class arkouda.numpy.dtypes.ARKOUDA_SUPPORTED_NUMBERS¶

Built-in immutable sequence.

If no argument is given, the constructor returns an empty tuple. If iterable is specified the tuple is initialized from iterable’s items.

If the argument is a tuple, the return value is the same object.

count(value, /)¶: Return number of occurrences of value.

index(value, start=0, stop=9223372036854775807, /)¶

Return first index of value.

Raises ValueError if the value is not present.

class arkouda.numpy.dtypes.BoolDType¶

Bases: numpy.dtype

DType class corresponding to the scalar type and dtype of the same name.

Please see numpy.dtype for the typical way to create dtype instances and arrays.dtypes for additional information.

class arkouda.numpy.dtypes.ByteDType¶

Bases: numpy.dtypes._IntegerAbstractDType

DType class corresponding to the scalar type and dtype of the same name.

Please see numpy.dtype for the typical way to create dtype instances and arrays.dtypes for additional information.

class arkouda.numpy.dtypes.BytesDType¶

Bases: numpy.dtype

DType class corresponding to the scalar type and dtype of the same name.

Please see numpy.dtype for the typical way to create dtype instances and arrays.dtypes for additional information.

class arkouda.numpy.dtypes.CLongDoubleDType¶

Bases: numpy.dtypes._ComplexAbstractDType

DType class corresponding to the scalar type and dtype of the same name.

Please see numpy.dtype for the typical way to create dtype instances and arrays.dtypes for additional information.

class arkouda.numpy.dtypes.Complex128DType¶

Bases: numpy.dtypes._ComplexAbstractDType

DType class corresponding to the scalar type and dtype of the same name.

Please see numpy.dtype for the typical way to create dtype instances and arrays.dtypes for additional information.

class arkouda.numpy.dtypes.Complex64DType¶

Bases: numpy.dtypes._ComplexAbstractDType

DType class corresponding to the scalar type and dtype of the same name.

Please see numpy.dtype for the typical way to create dtype instances and arrays.dtypes for additional information.

class arkouda.numpy.dtypes.DType[source]¶

BIGINT(*args, **kwargs)¶

BOOL(*args, **kwargs)¶

COMPLEX128(*args, **kwargs)¶

COMPLEX64(*args, **kwargs)¶

FLOAT(*args, **kwargs)¶

FLOAT32(*args, **kwargs)¶

FLOAT64(*args, **kwargs)¶

INT(*args, **kwargs)¶

INT16(*args, **kwargs)¶

INT32(*args, **kwargs)¶

INT64(*args, **kwargs)¶

INT8(*args, **kwargs)¶

STR(*args, **kwargs)¶

UINT(*args, **kwargs)¶

UINT16(*args, **kwargs)¶

UINT32(*args, **kwargs)¶

UINT64(*args, **kwargs)¶

UINT8(*args, **kwargs)¶

name(*args, **kwargs)¶: The name of the Enum member.

value(*args, **kwargs)¶: The value of the Enum member.

class arkouda.numpy.dtypes.DTypeObjects¶

Build an immutable unordered collection of unique elements.

copy()¶: Return a shallow copy of a set.

difference(*others)¶: Return a new set with elements in the set that are not in the others.

intersection(*others)¶: Return a new set with elements common to the set and all others.

isdisjoint(other, /)¶: Return True if two sets have a null intersection.

issubset(other, /)¶: Report whether another set contains this set.

issuperset(other, /)¶: Report whether this set contains another set.

symmetric_difference(other, /)¶: Return a new set with elements in either the set or other but not both.

union(*others)¶: Return a new set with elements from the set and all others.

class arkouda.numpy.dtypes.DTypes¶

Build an immutable unordered collection of unique elements.

copy()¶: Return a shallow copy of a set.

difference(*others)¶: Return a new set with elements in the set that are not in the others.

intersection(*others)¶: Return a new set with elements common to the set and all others.

isdisjoint(other, /)¶: Return True if two sets have a null intersection.

issubset(other, /)¶: Report whether another set contains this set.

issuperset(other, /)¶: Report whether this set contains another set.

symmetric_difference(other, /)¶: Return a new set with elements in either the set or other but not both.

union(*others)¶: Return a new set with elements from the set and all others.

class arkouda.numpy.dtypes.DateTime64DType¶

Bases: numpy.dtype

DType class corresponding to the scalar type and dtype of the same name.

Please see numpy.dtype for the typical way to create dtype instances and arrays.dtypes for additional information.

class arkouda.numpy.dtypes.Enum[source]¶

Create a collection of name/value pairs.

Example enumeration:

>>> class Color(Enum):
...     RED = 1
...     BLUE = 2
...     GREEN = 3

Access them by:

attribute access:
```
>>> Color.RED
<Color.RED: 1>
```
value lookup:
```
>>> Color(1)
<Color.RED: 1>
```
name lookup:
```
>>> Color['RED']
<Color.RED: 1>
```

Enumerations can be iterated over, and know how many members they have:

>>> len(Color)
3

>>> list(Color)
[<Color.RED: 1>, <Color.BLUE: 2>, <Color.GREEN: 3>]

Methods can be added to enumerations, and members can have their own attributes – see the documentation for details.

class arkouda.numpy.dtypes.Float16DType¶

Bases: numpy.dtypes._FloatAbstractDType

DType class corresponding to the scalar type and dtype of the same name.

Please see numpy.dtype for the typical way to create dtype instances and arrays.dtypes for additional information.

class arkouda.numpy.dtypes.Float32DType¶

Bases: numpy.dtypes._FloatAbstractDType

DType class corresponding to the scalar type and dtype of the same name.

Please see numpy.dtype for the typical way to create dtype instances and arrays.dtypes for additional information.

class arkouda.numpy.dtypes.Float64DType¶

Bases: numpy.dtypes._FloatAbstractDType

DType class corresponding to the scalar type and dtype of the same name.

Please see numpy.dtype for the typical way to create dtype instances and arrays.dtypes for additional information.

class arkouda.numpy.dtypes.Int16DType¶

Bases: numpy.dtypes._IntegerAbstractDType

DType class corresponding to the scalar type and dtype of the same name.

Please see numpy.dtype for the typical way to create dtype instances and arrays.dtypes for additional information.

class arkouda.numpy.dtypes.Int32DType¶

Bases: numpy.dtypes._IntegerAbstractDType

DType class corresponding to the scalar type and dtype of the same name.

Please see numpy.dtype for the typical way to create dtype instances and arrays.dtypes for additional information.

class arkouda.numpy.dtypes.Int64DType¶

Bases: numpy.dtypes._IntegerAbstractDType

DType class corresponding to the scalar type and dtype of the same name.

Please see numpy.dtype for the typical way to create dtype instances and arrays.dtypes for additional information.

class arkouda.numpy.dtypes.Int8DType¶

Bases: numpy.dtypes._IntegerAbstractDType

DType class corresponding to the scalar type and dtype of the same name.

Please see numpy.dtype for the typical way to create dtype instances and arrays.dtypes for additional information.

class arkouda.numpy.dtypes.IntDType¶

Bases: numpy.dtypes._IntegerAbstractDType

DType class corresponding to the scalar type and dtype of the same name.

Please see numpy.dtype for the typical way to create dtype instances and arrays.dtypes for additional information.

class arkouda.numpy.dtypes.List¶

Bases: _NotIterable

A generic version of list.

append(object, /)¶: Append object to the end of the list.

clear(/)¶: Remove all items from list.

copy(/)¶: Return a shallow copy of the list.

copy_with(params)¶

count(value, /)¶: Return number of occurrences of value.

extend(iterable, /)¶: Extend list by appending elements from the iterable.

index(value, start=0, stop=9223372036854775807, /)¶

Return first index of value.

Raises ValueError if the value is not present.

insert(index, object, /)¶: Insert object before index.

pop(index=-1, /)¶

Remove and return item at index (default last).

Raises IndexError if list is empty or index is out of range.

remove(value, /)¶

Remove first occurrence of value.

Raises ValueError if the value is not present.

reverse(/)¶: Reverse IN PLACE.

sort(/, *, key=None, reverse=False)¶

Sort the list in ascending order and return None.

The sort is in-place (i.e. the list itself is modified) and stable (i.e. the order of two equal elements is maintained).

If a key function is given, apply it once to each list item and sort them, ascending or descending, according to their function values.

The reverse flag can be set to sort in descending order.

class arkouda.numpy.dtypes.LongDType¶

Bases: numpy.dtypes._IntegerAbstractDType

DType class corresponding to the scalar type and dtype of the same name.

Please see numpy.dtype for the typical way to create dtype instances and arrays.dtypes for additional information.

class arkouda.numpy.dtypes.LongDoubleDType¶

Bases: numpy.dtypes._FloatAbstractDType

DType class corresponding to the scalar type and dtype of the same name.

Please see numpy.dtype for the typical way to create dtype instances and arrays.dtypes for additional information.

class arkouda.numpy.dtypes.LongLongDType¶

Bases: numpy.dtypes._IntegerAbstractDType

DType class corresponding to the scalar type and dtype of the same name.

Please see numpy.dtype for the typical way to create dtype instances and arrays.dtypes for additional information.

class arkouda.numpy.dtypes.NUMBER_FORMAT_STRINGS¶

dict() -> new empty dictionary dict(mapping) -> new dictionary initialized from a mapping object’s

(key, value) pairs

dict(iterable) -> new dictionary initialized as if via:: d = {} for k, v in iterable:

d[k] = v
dict(**kwargs) -> new dictionary initialized with the name=value pairs: in the keyword argument list. For example: dict(one=1, two=2)

clear()¶: Remove all items from the dict.

copy()¶: Return a shallow copy of the dict.

fromkeys(iterable, value=None, /)¶: Create a new dictionary with keys from iterable and values set to value.

get(key, default=None, /)¶: Return the value for key if key is in the dictionary, else default.

items()¶: Return a set-like object providing a view on the dict’s items.

keys()¶: Return a set-like object providing a view on the dict’s keys.

pop(*args, **kwargs)¶

D.pop(k[,d]) -> v, remove specified key and return the corresponding value.

If the key is not found, return the default if given; otherwise, raise a KeyError.

popitem()¶

Remove and return a (key, value) pair as a 2-tuple.

Pairs are returned in LIFO (last-in, first-out) order. Raises KeyError if the dict is empty.

setdefault(key, default=None, /)¶

Insert key with a value of default if key is not in the dictionary.

Return the value for key if key is in the dictionary, else default.

update(*args, **kwargs)¶: D.update([E, ]**F) -> None. Update D from mapping/iterable E and F. If E is present and has a .keys() method, then does: for k in E.keys(): D[k] = E[k] If E is present and lacks a .keys() method, then 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()¶: Return an object providing a view on the dict’s values.

class arkouda.numpy.dtypes.NumericDTypes¶

Build an immutable unordered collection of unique elements.

copy()¶: Return a shallow copy of a set.

difference(*others)¶: Return a new set with elements in the set that are not in the others.

intersection(*others)¶: Return a new set with elements common to the set and all others.

isdisjoint(other, /)¶: Return True if two sets have a null intersection.

issubset(other, /)¶: Report whether another set contains this set.

issuperset(other, /)¶: Report whether this set contains another set.

symmetric_difference(other, /)¶: Return a new set with elements in either the set or other but not both.

union(*others)¶: Return a new set with elements from the set and all others.

class arkouda.numpy.dtypes.ObjectDType¶

Bases: numpy.dtype

DType class corresponding to the scalar type and dtype of the same name.

Please see numpy.dtype for the typical way to create dtype instances and arrays.dtypes for additional information.

class arkouda.numpy.dtypes.ScalarDTypes¶

Build an immutable unordered collection of unique elements.

copy()¶: Return a shallow copy of a set.

difference(*others)¶: Return a new set with elements in the set that are not in the others.

intersection(*others)¶: Return a new set with elements common to the set and all others.

isdisjoint(other, /)¶: Return True if two sets have a null intersection.

issubset(other, /)¶: Report whether another set contains this set.

issuperset(other, /)¶: Report whether this set contains another set.

symmetric_difference(other, /)¶: Return a new set with elements in either the set or other but not both.

union(*others)¶: Return a new set with elements from the set and all others.

class arkouda.numpy.dtypes.SeriesDTypes¶

dict() -> new empty dictionary dict(mapping) -> new dictionary initialized from a mapping object’s

(key, value) pairs

dict(iterable) -> new dictionary initialized as if via:: d = {} for k, v in iterable:

d[k] = v
dict(**kwargs) -> new dictionary initialized with the name=value pairs: in the keyword argument list. For example: dict(one=1, two=2)

clear()¶: Remove all items from the dict.

copy()¶: Return a shallow copy of the dict.

fromkeys(iterable, value=None, /)¶: Create a new dictionary with keys from iterable and values set to value.

get(key, default=None, /)¶: Return the value for key if key is in the dictionary, else default.

items()¶: Return a set-like object providing a view on the dict’s items.

keys()¶: Return a set-like object providing a view on the dict’s keys.

pop(*args, **kwargs)¶

D.pop(k[,d]) -> v, remove specified key and return the corresponding value.

If the key is not found, return the default if given; otherwise, raise a KeyError.

popitem()¶

Remove and return a (key, value) pair as a 2-tuple.

Pairs are returned in LIFO (last-in, first-out) order. Raises KeyError if the dict is empty.

setdefault(key, default=None, /)¶

Insert key with a value of default if key is not in the dictionary.

Return the value for key if key is in the dictionary, else default.

update(*args, **kwargs)¶: D.update([E, ]**F) -> None. Update D from mapping/iterable E and F. If E is present and has a .keys() method, then does: for k in E.keys(): D[k] = E[k] If E is present and lacks a .keys() method, then 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()¶: Return an object providing a view on the dict’s values.

class arkouda.numpy.dtypes.ShortDType¶

Bases: numpy.dtypes._IntegerAbstractDType

DType class corresponding to the scalar type and dtype of the same name.

Please see numpy.dtype for the typical way to create dtype instances and arrays.dtypes for additional information.

class arkouda.numpy.dtypes.StrDType¶

Bases: numpy.dtype

DType class corresponding to the scalar type and dtype of the same name.

Please see numpy.dtype for the typical way to create dtype instances and arrays.dtypes for additional information.

arkouda.numpy.dtypes.TYPE_CHECKING: int¶

class arkouda.numpy.dtypes.TimeDelta64DType¶

Bases: numpy.dtype

DType class corresponding to the scalar type and dtype of the same name.

Please see numpy.dtype for the typical way to create dtype instances and arrays.dtypes for additional information.

class arkouda.numpy.dtypes.UByteDType¶

Bases: numpy.dtypes._IntegerAbstractDType

DType class corresponding to the scalar type and dtype of the same name.

Please see numpy.dtype for the typical way to create dtype instances and arrays.dtypes for additional information.

class arkouda.numpy.dtypes.UInt16DType¶

Bases: numpy.dtypes._IntegerAbstractDType

DType class corresponding to the scalar type and dtype of the same name.

Please see numpy.dtype for the typical way to create dtype instances and arrays.dtypes for additional information.

class arkouda.numpy.dtypes.UInt32DType¶

Bases: numpy.dtypes._IntegerAbstractDType

DType class corresponding to the scalar type and dtype of the same name.

Please see numpy.dtype for the typical way to create dtype instances and arrays.dtypes for additional information.

class arkouda.numpy.dtypes.UInt64DType¶

Bases: numpy.dtypes._IntegerAbstractDType

DType class corresponding to the scalar type and dtype of the same name.

Please see numpy.dtype for the typical way to create dtype instances and arrays.dtypes for additional information.

class arkouda.numpy.dtypes.UInt8DType¶

Bases: numpy.dtypes._IntegerAbstractDType

DType class corresponding to the scalar type and dtype of the same name.

Please see numpy.dtype for the typical way to create dtype instances and arrays.dtypes for additional information.

class arkouda.numpy.dtypes.UIntDType¶

Bases: numpy.dtypes._IntegerAbstractDType

DType class corresponding to the scalar type and dtype of the same name.

Please see numpy.dtype for the typical way to create dtype instances and arrays.dtypes for additional information.

class arkouda.numpy.dtypes.ULongDType¶

Bases: numpy.dtypes._IntegerAbstractDType

DType class corresponding to the scalar type and dtype of the same name.

Please see numpy.dtype for the typical way to create dtype instances and arrays.dtypes for additional information.

class arkouda.numpy.dtypes.ULongLongDType¶

Bases: numpy.dtypes._IntegerAbstractDType

DType class corresponding to the scalar type and dtype of the same name.

Please see numpy.dtype for the typical way to create dtype instances and arrays.dtypes for additional information.

class arkouda.numpy.dtypes.UShortDType¶

Bases: numpy.dtypes._IntegerAbstractDType

DType class corresponding to the scalar type and dtype of the same name.

Please see numpy.dtype for the typical way to create dtype instances and arrays.dtypes for additional information.

class arkouda.numpy.dtypes.Union[source]¶

Bases: _Final

Union type; Union[X, Y] means either X or Y.

On Python 3.10 and higher, the | operator can also be used to denote unions; X | Y means the same thing to the type checker as Union[X, Y].

To define a union, use e.g. Union[int, str]. Details: - The arguments must be types and there must be at least one. - None as an argument is a special case and is replaced by

type(None).

Unions of unions are flattened, e.g.:

assert Union[Union[int, str], float] == Union[int, str, float]

Unions of a single argument vanish, e.g.:

assert Union[int] == int  # The constructor actually returns int

Redundant arguments are skipped, e.g.:

assert Union[int, str, int] == Union[int, str]

When comparing unions, the argument order is ignored, e.g.:
```
assert Union[int, str] == Union[str, int]
```
You cannot subclass or instantiate a union.
You can use Optional[X] as a shorthand for Union[X, None].

class arkouda.numpy.dtypes.VoidDType¶

Bases: numpy.dtype

DType class corresponding to the scalar type and dtype of the same name.

Please see numpy.dtype for the typical way to create dtype instances and arrays.dtypes for additional information.

class arkouda.numpy.dtypes.all_scalars¶

Bases: _NotIterable

Mixin to prevent iteration, without being compatible with Iterable.

That is, we could do:

def __iter__(self): raise TypeError()

But this would make users of this mixin duck type-compatible with collections.abc.Iterable - isinstance(foo, Iterable) would be True.

Luckily, we can instead prevent iteration by setting __iter__ to None, which is treated specially.

copy_with(params)¶

class arkouda.numpy.dtypes.annotations¶

compiler_flag(*args, **kwargs)¶

int([x]) -> integer int(x, base=10) -> integer

Convert a number or string to an integer, or return 0 if no arguments are given. If x is a number, return x.__int__(). For floating-point numbers, this truncates towards zero.

If x is not a number or if base is given, then x must be a string, bytes, or bytearray instance representing an integer literal in the given base. The literal can be preceded by ‘+’ or ‘-’ and be surrounded by whitespace. The base defaults to 10. Valid bases are 0 and 2-36. Base 0 means to interpret the base from the string as an integer literal. >>> int(‘0b100’, base=0) 4

getMandatoryRelease()¶

Return release in which this feature will become mandatory.

This is a 5-tuple, of the same form as sys.version_info, or, if the feature was dropped, or the release date is undetermined, is None.

getOptionalRelease()¶

Return first release in which this feature was recognized.

This is a 5-tuple, of the same form as sys.version_info.

mandatory(*args, **kwargs)¶: The type of the None singleton.

optional(*args, **kwargs)¶

Built-in immutable sequence.

If no argument is given, the constructor returns an empty tuple. If iterable is specified the tuple is initialized from iterable’s items.

If the argument is a tuple, the return value is the same object.

class arkouda.numpy.dtypes.bigint[source]¶

Datatype for representing integers of variable size.

May be used for integers that exceed 64 bits.

itemsize(*args, **kwargs)¶

int([x]) -> integer int(x, base=10) -> integer

Convert a number or string to an integer, or return 0 if no arguments are given. If x is a number, return x.__int__(). For floating-point numbers, this truncates towards zero.

name(*args, **kwargs)¶

str(object=’’) -> str str(bytes_or_buffer[, encoding[, errors]]) -> str

Create a new string object from the given object. If encoding or errors is specified, then the object must expose a data buffer that will be decoded using the given encoding and error handler. Otherwise, returns the result of object.__str__() (if defined) or repr(object). encoding defaults to ‘utf-8’. errors defaults to ‘strict’.

ndim(*args, **kwargs)¶

int([x]) -> integer int(x, base=10) -> integer

Convert a number or string to an integer, or return 0 if no arguments are given. If x is a number, return x.__int__(). For floating-point numbers, this truncates towards zero.

shape(*args, **kwargs)¶

Built-in immutable sequence.

If no argument is given, the constructor returns an empty tuple. If iterable is specified the tuple is initialized from iterable’s items.

If the argument is a tuple, the return value is the same object.

type(x)[source]¶

class arkouda.numpy.dtypes.bitType¶

Bases: numpy.unsignedinteger

Unsigned signed integer type, 64bit on 64bit systems and 32bit on 32bit

systems.

Character code:: 'L'
Canonical name:: numpy.uint
Alias on this platform (Linux x86_64):: numpy.uint64: 64-bit unsigned integer (0 to 18_446_744_073_709_551_615).
Alias on this platform (Linux x86_64):: numpy.uintp: Unsigned integer large enough to fit pointer, compatible with C uintptr_t.

bit_count(/)¶

uint64.bit_count() -> int

Computes the number of 1-bits in the absolute value of the input. Analogous to the builtin int.bit_count or popcount in C++.
>>> np.uint64(127).bit_count()
7

class arkouda.numpy.dtypes.bool_¶

Bases: numpy.generic

Boolean type (True or False), stored as a byte.

Warning

The bool type is not a subclass of the int_ type (the bool is not even a number type). This is different than Python’s default implementation of bool as a sub-class of int.

Character code:

'?'

class arkouda.numpy.dtypes.bool_scalars¶

Bases: _NotIterable

Mixin to prevent iteration, without being compatible with Iterable.

That is, we could do:

def __iter__(self): raise TypeError()

But this would make users of this mixin duck type-compatible with collections.abc.Iterable - isinstance(foo, Iterable) would be True.

Luckily, we can instead prevent iteration by setting __iter__ to None, which is treated specially.

copy_with(params)¶

arkouda.numpy.dtypes.can_cast(from_, to) → bool[source]¶

Returns True if cast between data types can occur according to the casting rule.

Parameters:

from (dtype, dtype specifier, NumPy scalar, or pdarray) – Data type, NumPy scalar, or array to cast from.
to (dtype or dtype specifier) – Data type to cast to.

Returns:

True if cast can occur according to the casting rule.

Return type:

bool

arkouda.numpy.dtypes.cast(typ, val)[source]¶

Cast a value to a type.

This returns the value unchanged. To the type checker this signals that the return value has the designated type, but at runtime we intentionally don’t check anything (we want this to be as fast as possible).

class arkouda.numpy.dtypes.complex128¶

Bases: numpy.complexfloating

Complex number type composed of two double-precision floating-point

numbers, compatible with Python complex.

Character code:: 'D'
Canonical name:: numpy.cdouble
Alias on this platform (Linux x86_64):: numpy.complex128: Complex number type composed of 2 64-bit-precision floating-point numbers.

class arkouda.numpy.dtypes.complex64¶

Bases: numpy.complexfloating

Complex number type composed of two single-precision floating-point

numbers.

Character code:: 'F'
Canonical name:: numpy.csingle
Alias on this platform (Linux x86_64):: numpy.complex64: Complex number type composed of 2 32-bit-precision floating-point numbers.

arkouda.numpy.dtypes.dtype(dtype)[source]¶

Create a data type object.

Parameters:: dtype (object) – Object to be converted to a data type object.
Return type:: type

class arkouda.numpy.dtypes.float16¶

Bases: numpy.floating

Half-precision floating-point number type.

Character code:

'e'

Canonical name:

numpy.half

Alias on this platform (Linux x86_64):

numpy.float16: 16-bit-precision floating-point number type: sign bit, 5 bits exponent, 10 bits mantissa.

as_integer_ratio(/)¶

half.as_integer_ratio() -> (int, int)

Return a pair of integers, whose ratio is exactly equal to the original floating point number, and with a positive denominator. Raise OverflowError on infinities and a ValueError on NaNs.
>>> np.half(10.0).as_integer_ratio()
(10, 1)
>>> np.half(0.0).as_integer_ratio()
(0, 1)
>>> np.half(-.25).as_integer_ratio()
(-1, 4)

is_integer(/)¶

half.is_integer() -> bool

Return True if the floating point number is finite with integral value, and False otherwise.

Added in version 1.22.
>>> np.half(-2.0).is_integer()
True
>>> np.half(3.2).is_integer()
False

class arkouda.numpy.dtypes.float32¶

Bases: numpy.floating

Single-precision floating-point number type, compatible with C float.

Character code:

'f'

Canonical name:

numpy.single

Alias on this platform (Linux x86_64):

numpy.float32: 32-bit-precision floating-point number type: sign bit, 8 bits exponent, 23 bits mantissa.

as_integer_ratio(/)¶

single.as_integer_ratio() -> (int, int)

Return a pair of integers, whose ratio is exactly equal to the original floating point number, and with a positive denominator. Raise OverflowError on infinities and a ValueError on NaNs.
>>> np.single(10.0).as_integer_ratio()
(10, 1)
>>> np.single(0.0).as_integer_ratio()
(0, 1)
>>> np.single(-.25).as_integer_ratio()
(-1, 4)

is_integer(/)¶

single.is_integer() -> bool

Return True if the floating point number is finite with integral value, and False otherwise.

Added in version 1.22.
>>> np.single(-2.0).is_integer()
True
>>> np.single(3.2).is_integer()
False

class arkouda.numpy.dtypes.float64¶

Bases: numpy.floating

Double-precision floating-point number type, compatible with Python

float and C double.

Character code:: 'd'
Canonical name:: numpy.double
Alias on this platform (Linux x86_64):: numpy.float64: 64-bit precision floating-point number type: sign bit, 11 bits exponent, 52 bits mantissa.

as_integer_ratio(/)¶

double.as_integer_ratio() -> (int, int)

Return a pair of integers, whose ratio is exactly equal to the original floating point number, and with a positive denominator. Raise OverflowError on infinities and a ValueError on NaNs.
>>> np.double(10.0).as_integer_ratio()
(10, 1)
>>> np.double(0.0).as_integer_ratio()
(0, 1)
>>> np.double(-.25).as_integer_ratio()
(-1, 4)

fromhex(string, /)¶

Create a floating-point number from a hexadecimal string.

>>> float.fromhex('0x1.ffffp10')
2047.984375
>>> float.fromhex('-0x1p-1074')
-5e-324

hex(/)¶

Return a hexadecimal representation of a floating-point number.

>>> (-0.1).hex()
'-0x1.999999999999ap-4'
>>> 3.14159.hex()
'0x1.921f9f01b866ep+1'

is_integer(/)¶

double.is_integer() -> bool

Return True if the floating point number is finite with integral value, and False otherwise.

Added in version 1.22.
>>> np.double(-2.0).is_integer()
True
>>> np.double(3.2).is_integer()
False

class arkouda.numpy.dtypes.float_scalars¶

Bases: _NotIterable

Mixin to prevent iteration, without being compatible with Iterable.

That is, we could do:

def __iter__(self): raise TypeError()

But this would make users of this mixin duck type-compatible with collections.abc.Iterable - isinstance(foo, Iterable) would be True.

Luckily, we can instead prevent iteration by setting __iter__ to None, which is treated specially.

copy_with(params)¶

arkouda.numpy.dtypes.get_byteorder(dt: np.dtype) → str[source]¶

Get a concrete byteorder (turns ‘=’ into ‘<’ or ‘>’) on the client.

Parameters:: dt (np.dtype) – The numpy dtype to determine the byteorder of.
Returns:: Returns “<” for little endian and “>” for big endian.
Return type:: str
Raises:: ValueError – Returned if sys.byteorder is not “little” or “big”

Examples

>>> import arkouda as ak
>>> ak.get_byteorder(ak.dtype(ak.int64))
'<'

arkouda.numpy.dtypes.get_server_byteorder() → str[source]¶

Get the server’s byteorder

Returns:: Returns “little” for little endian and “big” for big endian.
Return type:: str
Raises:: ValueError – Raised if Server byteorder is not ‘little’ or ‘big’

Examples

>>> import arkouda as ak
>>> ak.get_server_byteorder()
'little'

class arkouda.numpy.dtypes.int16¶

Bases: numpy.signedinteger

Signed integer type, compatible with C short.

Character code:

'h'

Canonical name:

numpy.short

Alias on this platform (Linux x86_64):

numpy.int16: 16-bit signed integer (-32_768 to 32_767).

bit_count(/)¶

int16.bit_count() -> int

Computes the number of 1-bits in the absolute value of the input. Analogous to the builtin int.bit_count or popcount in C++.
>>> np.int16(127).bit_count()
7
>>> np.int16(-127).bit_count()
7

class arkouda.numpy.dtypes.int32¶

Bases: numpy.signedinteger

Signed integer type, compatible with C int.

Character code:

'i'

Canonical name:

numpy.intc

Alias on this platform (Linux x86_64):

numpy.int32: 32-bit signed integer (-2_147_483_648 to 2_147_483_647).

bit_count(/)¶

int32.bit_count() -> int

Computes the number of 1-bits in the absolute value of the input. Analogous to the builtin int.bit_count or popcount in C++.
>>> np.int32(127).bit_count()
7
>>> np.int32(-127).bit_count()
7

class arkouda.numpy.dtypes.int64¶

Bases: numpy.signedinteger

Default signed integer type, 64bit on 64bit systems and 32bit on 32bit

systems.

Character code:: 'l'
Canonical name:: numpy.int_
Alias on this platform (Linux x86_64):: numpy.int64: 64-bit signed integer (-9_223_372_036_854_775_808 to 9_223_372_036_854_775_807).
Alias on this platform (Linux x86_64):: numpy.intp: Signed integer large enough to fit pointer, compatible with C intptr_t.

bit_count(/)¶

int64.bit_count() -> int

Computes the number of 1-bits in the absolute value of the input. Analogous to the builtin int.bit_count or popcount in C++.
>>> np.int64(127).bit_count()
7
>>> np.int64(-127).bit_count()
7

class arkouda.numpy.dtypes.int8¶

Bases: numpy.signedinteger

Signed integer type, compatible with C char.

Character code:

'b'

Canonical name:

numpy.byte

Alias on this platform (Linux x86_64):

numpy.int8: 8-bit signed integer (-128 to 127).

bit_count(/)¶

int8.bit_count() -> int

Computes the number of 1-bits in the absolute value of the input. Analogous to the builtin int.bit_count or popcount in C++.
>>> np.int8(127).bit_count()
7
>>> np.int8(-127).bit_count()
7

class arkouda.numpy.dtypes.intTypes¶

Build an immutable unordered collection of unique elements.

copy()¶: Return a shallow copy of a set.

difference(*others)¶: Return a new set with elements in the set that are not in the others.

intersection(*others)¶: Return a new set with elements common to the set and all others.

isdisjoint(other, /)¶: Return True if two sets have a null intersection.

issubset(other, /)¶: Report whether another set contains this set.

issuperset(other, /)¶: Report whether this set contains another set.

symmetric_difference(other, /)¶: Return a new set with elements in either the set or other but not both.

union(*others)¶: Return a new set with elements from the set and all others.

class arkouda.numpy.dtypes.int_scalars¶

Bases: _NotIterable

Mixin to prevent iteration, without being compatible with Iterable.

That is, we could do:

def __iter__(self): raise TypeError()

But this would make users of this mixin duck type-compatible with collections.abc.Iterable - isinstance(foo, Iterable) would be True.

Luckily, we can instead prevent iteration by setting __iter__ to None, which is treated specially.

copy_with(params)¶

arkouda.numpy.dtypes.isSupportedBool(num)[source]¶

Whether a scalar is an arkouda supported boolean dtype.

Parameters:: num (object) – A scalar.
Returns:: True if scalar is an instance of an arkouda supported boolean dtype, else False.
Return type:: bool

Examples

>>> import arkouda as ak
>>> ak.isSupportedBool("True")
False
>>> ak.isSupportedBool(True)
True

arkouda.numpy.dtypes.isSupportedDType(scalar: object) → bool[source]¶

Whether a scalar is an arkouda supported dtype.

Parameters:: scalar (object)
Returns:: True if scalar is an instance of an arkouda supported dtype, else False.
Return type:: bool

Examples

>>> import arkouda as ak
>>> ak.isSupportedDType(ak.int64(64))
True
>>> ak.isSupportedDType(np.complex128(1+2j))
False

arkouda.numpy.dtypes.isSupportedFloat(num)[source]¶

Whether a scalar is an arkouda supported float dtype.

Parameters:: num (object) – A scalar.
Returns:: True if scalar is an instance of an arkouda supported float dtype, else False.
Return type:: bool

Examples

>>> import arkouda as ak
>>> ak.isSupportedFloat(56)
False
>>> ak.isSupportedFloat(56.7)
True

arkouda.numpy.dtypes.isSupportedInt(num)[source]¶

Whether a scalar is an arkouda supported integer dtype.

Parameters:: num (object) – A scalar.
Returns:: True if scalar is an instance of an arkouda supported integer dtype, else False.
Return type:: bool

Examples

>>> import arkouda as ak
>>> ak.isSupportedInt(79)
True
>>> ak.isSupportedInt(54.9)
False

arkouda.numpy.dtypes.isSupportedNumber(num)[source]¶

Whether a scalar is an arkouda supported numeric dtype.

Parameters:: num (object) – A scalar.
Returns:: True if scalar is an instance of an arkouda supported numeric dtype, else False.
Return type:: bool

Examples

>>> import arkouda as ak
>>> ak.isSupportedNumber(45.9)
True
>>> ak.isSupportedNumber("string")
False

class arkouda.numpy.dtypes.numeric_and_bool_scalars¶

Bases: _NotIterable

Mixin to prevent iteration, without being compatible with Iterable.

That is, we could do:

def __iter__(self): raise TypeError()

But this would make users of this mixin duck type-compatible with collections.abc.Iterable - isinstance(foo, Iterable) would be True.

Luckily, we can instead prevent iteration by setting __iter__ to None, which is treated specially.

copy_with(params)¶

class arkouda.numpy.dtypes.numeric_scalars¶

Bases: _NotIterable

Mixin to prevent iteration, without being compatible with Iterable.

That is, we could do:

def __iter__(self): raise TypeError()

But this would make users of this mixin duck type-compatible with collections.abc.Iterable - isinstance(foo, Iterable) would be True.

Luckily, we can instead prevent iteration by setting __iter__ to None, which is treated specially.

copy_with(params)¶

class arkouda.numpy.dtypes.numpy_scalars¶

Bases: _NotIterable

Mixin to prevent iteration, without being compatible with Iterable.

That is, we could do:

def __iter__(self): raise TypeError()

But this would make users of this mixin duck type-compatible with collections.abc.Iterable - isinstance(foo, Iterable) would be True.

Luckily, we can instead prevent iteration by setting __iter__ to None, which is treated specially.

copy_with(params)¶

arkouda.numpy.dtypes.resolve_scalar_dtype(val: object) → str[source]¶

Try to infer what dtype arkouda_server should treat val as.

Parameters:: val (object) – The object to determine the dtype of.
Returns:: The dtype name, if it can be resolved, otherwise the type (as str).
Return type:: str

Examples

>>> import arkouda as ak
>>> ak.resolve_scalar_dtype(1)
'int64'
>>> ak.resolve_scalar_dtype(2.0)
'float64'

arkouda.numpy.dtypes.result_type(*args: pdarray | np.dtype | type) → np.dtype | type[source]¶

Determine the promoted result dtype of inputs, including support for Arkouda’s bigint.

Determine the result dtype that would be returned by a NumPy-like operation on the provided input arguments, accounting for Arkouda’s extended types such as ak.bigint.

This function mimics numpy.result_type, with support for Arkouda types.

Parameters:: *args (Union[pdarray, np.dtype, type]) – One or more input objects. These can be NumPy arrays, dtypes, Python scalar types, or Arkouda pdarrays.
Returns:: The dtype (or equivalent Arkouda type) that results from applying type promotion rules to the inputs.
Return type:: Union[np.dtype, type]

Notes

This function is meant to be a drop-in replacement for numpy.result_type but includes logic to support Arkouda’s bigint type.

class arkouda.numpy.dtypes.str_¶

A unicode string.

This type strips trailing null codepoints.
>>> s = np.str_("abc\x00")
>>> s
'abc'
Unlike the builtin str, this supports the python:bufferobjects, exposing its contents as UCS4:
>>> m = memoryview(np.str_("abc"))
>>> m.format
'3w'
>>> m.tobytes()
b'a\x00\x00\x00b\x00\x00\x00c\x00\x00\x00'
Character code:

'U'

T(*args, **kwargs)¶: Scalar attribute identical to the corresponding array attribute.

Please see ndarray.T.

all(*args, **kwargs)¶: Scalar method identical to the corresponding array attribute.

Please see ndarray.all.

any(*args, **kwargs)¶: Scalar method identical to the corresponding array attribute.

Please see ndarray.any.

argmax(*args, **kwargs)¶: Scalar method identical to the corresponding array attribute.

Please see ndarray.argmax.

argmin(*args, **kwargs)¶: Scalar method identical to the corresponding array attribute.

Please see ndarray.argmin.

argsort(*args, **kwargs)¶: Scalar method identical to the corresponding array attribute.

Please see ndarray.argsort.

astype(*args, **kwargs)¶: Scalar method identical to the corresponding array attribute.

Please see ndarray.astype.

base(*args, **kwargs)¶: Scalar attribute identical to the corresponding array attribute.

Please see ndarray.base.

byteswap(*args, **kwargs)¶: Scalar method identical to the corresponding array attribute.

Please see ndarray.byteswap.

choose(*args, **kwargs)¶: Scalar method identical to the corresponding array attribute.

Please see ndarray.choose.

clip(*args, **kwargs)¶: Scalar method identical to the corresponding array attribute.

Please see ndarray.clip.

compress(*args, **kwargs)¶: Scalar method identical to the corresponding array attribute.

Please see ndarray.compress.

conj(*args, **kwargs)¶

conjugate(*args, **kwargs)¶: Scalar method identical to the corresponding array attribute.

Please see ndarray.conjugate.

copy(*args, **kwargs)¶: Scalar method identical to the corresponding array attribute.

Please see ndarray.copy.

cumprod(*args, **kwargs)¶: Scalar method identical to the corresponding array attribute.

Please see ndarray.cumprod.

cumsum(*args, **kwargs)¶: Scalar method identical to the corresponding array attribute.

Please see ndarray.cumsum.

data(*args, **kwargs)¶: Pointer to start of data.

device(*args, **kwargs)¶

diagonal(*args, **kwargs)¶: Scalar method identical to the corresponding array attribute.

Please see ndarray.diagonal.

dtype(*args, **kwargs)¶: Get array data-descriptor.

dump(*args, **kwargs)¶: Scalar method identical to the corresponding array attribute.

Please see ndarray.dump.

dumps(*args, **kwargs)¶: Scalar method identical to the corresponding array attribute.

Please see ndarray.dumps.

fill(*args, **kwargs)¶: Scalar method identical to the corresponding array attribute.

Please see ndarray.fill.

flags(*args, **kwargs)¶: The integer value of flags.

flat(*args, **kwargs)¶: A 1-D view of the scalar.

flatten(*args, **kwargs)¶: Scalar method identical to the corresponding array attribute.

Please see ndarray.flatten.

getfield(*args, **kwargs)¶: Scalar method identical to the corresponding array attribute.

Please see ndarray.getfield.

imag(*args, **kwargs)¶: The imaginary part of the scalar.

item(*args, **kwargs)¶: Scalar method identical to the corresponding array attribute.

Please see ndarray.item.

itemset(*args, **kwargs)¶

itemsize(*args, **kwargs)¶: The length of one element in bytes.

max(*args, **kwargs)¶: Scalar method identical to the corresponding array attribute.

Please see ndarray.max.

mean(*args, **kwargs)¶: Scalar method identical to the corresponding array attribute.

Please see ndarray.mean.

min(*args, **kwargs)¶: Scalar method identical to the corresponding array attribute.

Please see ndarray.min.

nbytes(*args, **kwargs)¶

ndim(*args, **kwargs)¶: The number of array dimensions.

newbyteorder(*args, **kwargs)¶

nonzero(*args, **kwargs)¶: Scalar method identical to the corresponding array attribute.

Please see ndarray.nonzero.

prod(*args, **kwargs)¶: Scalar method identical to the corresponding array attribute.

Please see ndarray.prod.

ptp(*args, **kwargs)¶

put(*args, **kwargs)¶: Scalar method identical to the corresponding array attribute.

Please see ndarray.put.

ravel(*args, **kwargs)¶: Scalar method identical to the corresponding array attribute.

Please see ndarray.ravel.

real(*args, **kwargs)¶: The real part of the scalar.

repeat(*args, **kwargs)¶: Scalar method identical to the corresponding array attribute.

Please see ndarray.repeat.

reshape(*args, **kwargs)¶: Scalar method identical to the corresponding array attribute.

Please see ndarray.reshape.

resize(*args, **kwargs)¶: Scalar method identical to the corresponding array attribute.

Please see ndarray.resize.

round(*args, **kwargs)¶: Scalar method identical to the corresponding array attribute.

Please see ndarray.round.

searchsorted(*args, **kwargs)¶: Scalar method identical to the corresponding array attribute.

Please see ndarray.searchsorted.

setfield(*args, **kwargs)¶: Scalar method identical to the corresponding array attribute.

Please see ndarray.setfield.

setflags(*args, **kwargs)¶: Scalar method identical to the corresponding array attribute.

Please see ndarray.setflags.

shape(*args, **kwargs)¶: Tuple of array dimensions.

size(*args, **kwargs)¶: The number of elements in the gentype.

sort(*args, **kwargs)¶: Scalar method identical to the corresponding array attribute.

Please see ndarray.sort.

squeeze(*args, **kwargs)¶: Scalar method identical to the corresponding array attribute.

Please see ndarray.squeeze.

std(*args, **kwargs)¶: Scalar method identical to the corresponding array attribute.

Please see ndarray.std.

strides(*args, **kwargs)¶: Tuple of bytes steps in each dimension.

sum(*args, **kwargs)¶: Scalar method identical to the corresponding array attribute.

Please see ndarray.sum.

swapaxes(*args, **kwargs)¶: Scalar method identical to the corresponding array attribute.

Please see ndarray.swapaxes.

take(*args, **kwargs)¶: Scalar method identical to the corresponding array attribute.

Please see ndarray.take.

to_device(*args, **kwargs)¶

tobytes(*args, **kwargs)¶

tofile(*args, **kwargs)¶: Scalar method identical to the corresponding array attribute.

Please see ndarray.tofile.

tolist(*args, **kwargs)¶: Scalar method identical to the corresponding array attribute.

Please see ndarray.tolist.

tostring(*args, **kwargs)¶: Scalar method identical to the corresponding array attribute.

Please see ndarray.tostring.

trace(*args, **kwargs)¶: Scalar method identical to the corresponding array attribute.

Please see ndarray.trace.

transpose(*args, **kwargs)¶: Scalar method identical to the corresponding array attribute.

Please see ndarray.transpose.

var(*args, **kwargs)¶: Scalar method identical to the corresponding array attribute.

Please see ndarray.var.

view(*args, **kwargs)¶: Scalar method identical to the corresponding array attribute.

Please see ndarray.view.

class arkouda.numpy.dtypes.str_scalars¶

Bases: _NotIterable

Mixin to prevent iteration, without being compatible with Iterable.

That is, we could do:

def __iter__(self): raise TypeError()

But this would make users of this mixin duck type-compatible with collections.abc.Iterable - isinstance(foo, Iterable) would be True.

Luckily, we can instead prevent iteration by setting __iter__ to None, which is treated specially.

copy_with(params)¶

class arkouda.numpy.dtypes.uint16¶

Bases: numpy.unsignedinteger

Unsigned integer type, compatible with C unsigned short.

Character code:

'H'

Canonical name:

numpy.ushort

Alias on this platform (Linux x86_64):

numpy.uint16: 16-bit unsigned integer (0 to 65_535).

bit_count(/)¶

uint16.bit_count() -> int

Computes the number of 1-bits in the absolute value of the input. Analogous to the builtin int.bit_count or popcount in C++.
>>> np.uint16(127).bit_count()
7

class arkouda.numpy.dtypes.uint32¶

Bases: numpy.unsignedinteger

Unsigned integer type, compatible with C unsigned int.

Character code:

'I'

Canonical name:

numpy.uintc

Alias on this platform (Linux x86_64):

numpy.uint32: 32-bit unsigned integer (0 to 4_294_967_295).

bit_count(/)¶

uint32.bit_count() -> int

Computes the number of 1-bits in the absolute value of the input. Analogous to the builtin int.bit_count or popcount in C++.
>>> np.uint32(127).bit_count()
7

class arkouda.numpy.dtypes.uint64¶

Bases: numpy.unsignedinteger

Unsigned signed integer type, 64bit on 64bit systems and 32bit on 32bit

systems.

Character code:: 'L'
Canonical name:: numpy.uint
Alias on this platform (Linux x86_64):: numpy.uint64: 64-bit unsigned integer (0 to 18_446_744_073_709_551_615).
Alias on this platform (Linux x86_64):: numpy.uintp: Unsigned integer large enough to fit pointer, compatible with C uintptr_t.

bit_count(/)¶

uint64.bit_count() -> int

Computes the number of 1-bits in the absolute value of the input. Analogous to the builtin int.bit_count or popcount in C++.
>>> np.uint64(127).bit_count()
7

class arkouda.numpy.dtypes.uint8¶

Bases: numpy.unsignedinteger

Unsigned integer type, compatible with C unsigned char.

Character code:

'B'

Canonical name:

numpy.ubyte

Alias on this platform (Linux x86_64):

numpy.uint8: 8-bit unsigned integer (0 to 255).

bit_count(/)¶

uint8.bit_count() -> int

Computes the number of 1-bits in the absolute value of the input. Analogous to the builtin int.bit_count or popcount in C++.
>>> np.uint8(127).bit_count()
7