Data type

class ivy.DefaultDtype(dtype)[source]

Bases: object

__init__(dtype)[source]

class ivy.DefaultFloatDtype(float_dtype)[source]

Bases: object

__init__(float_dtype)[source]

class ivy.DefaultIntDtype(float_dtype)[source]

Bases: object

__init__(float_dtype)[source]

class ivy.DefaultUintDtype(uint_dtype)[source]

Bases: object

__init__(uint_dtype)[source]

ivy.as_ivy_dtype(dtype_in, /)[source]

Convert native data type to string representation.

Parameters: dtype_in (Union[Dtype, str]) – The data type to convert to string.
Return type: Dtype
Returns: ret – data type string ‘float32’

ivy.as_native_dtype(dtype_in, /)[source]

Convert data type string representation to native data type.

Parameters: dtype_in (Union[Dtype, NativeDtype]) – The data type string to convert to native data type.
Return type: NativeDtype
Returns: ret – data type e.g. ivy.float32.

ivy.astype(x, dtype, /, *, copy=True, out=None)[source]

Copies an array to a specified data type irrespective of type-promotion rules.

Casting floating-point NaN and infinity values to integral data types is not specified and is implementation-dependent.

When casting a boolean input array to a numeric data type, a value of True must cast to a numeric value equal to 1, and a value of False must cast to a numeric value equal to 0.

When casting a numeric input array to bool, a value of 0 must cast to False, and a non-zero value must cast to True.

Parameters

x (Union[Array, NativeArray]) – array to cast.
dtype (Union[Dtype, NativeDtype]) – desired data type.
copy (bool) – specifies whether to copy an array when the specified dtype matches (default: True) the data type of the input array x. If True, a newly allocated array must always be returned. If False and the specified dtype matches the data type of the input array, the input array must be returned; otherwise, a newly allocated must be returned. Default: True.
out (Optional[Array]) – optional output array, for writing the result to. It must have a shape (default: None) that the inputs broadcast to.

Return type

Array

Returns

ret – an array having the specified data type. The returned array must have the same shape as x.

Examples

With ivy.Array input:

>>> x = ivy.array([1, 2])
>>> y = ivy.zeros_like(x)
>>> y = ivy.astype(x, ivy.float64)
>>> print(y)
ivy.array([1., 2.])

>>> x = ivy.array([3.141, 2.718, 1.618])
>>> ivy.astype(x, ivy.int32, out=y)
>>> print(y)
ivy.array([3, 2, 1])

>>> x = ivy.array([[-1, -2], [0, 2]])
>>> ivy.astype(x, ivy.float64, out=x)
>>> print(x)
ivy.array([[-1., -2.],  [0.,  2.]])

With ivy.NativeArray input:

>>> x = ivy.native_array([3.141, 2.718, 1.618])
>>> y = ivy.astype(x, ivy.int32)
>>> print(y)
ivy.array([3, 2, 1])

With ivy.Container input:

>>> x = ivy.Container(a=ivy.array([0,2,1]),b=ivy.array([1,0,0]))
>>> print(ivy.astype(x, ivy.bool))
{
    a: ivy.array([False, True, True]),
    b: ivy.array([True, False, False])
}

Using ivy.Array instance method:

>>> x = ivy.array([[-1, -2], [0, 2]])
>>> print(x.astype(ivy.float64))
ivy.array([[-1., -2.],  [0.,  2.]])

Using ivy.Container instance method:

>>> x = ivy.Container(a=ivy.array([False,True,True]),
...                   b=ivy.array([3.14, 2.718, 1.618]))
>>> print(x.astype(ivy.int32))
{
    a: ivy.array([0, 1, 1]),
    b: ivy.array([3, 2, 1])
}

ivy.broadcast_arrays(*arrays)[source]

Broadcasts one or more arrays against one another.

Parameters: arrays (Union[Array, NativeArray]) – an arbitrary number of arrays to-be broadcasted. Each array must have the same shape. Each array must have the same dtype as its corresponding input array.
Return type: List[Array]
Returns: ret – A list containing broadcasted arrays of type ivy.Array

Examples

With ivy.Array input:

>>> x1 = ivy.array([1, 2, 3])
>>> x2 = ivy.array([4, 5, 6])
>>> y = ivy.broadcast_arrays(x1, x2)
>>> print(y)
[ivy.array([1, 2, 3]), ivy.array([4, 5, 6])]

With ivy.NativeArray inputs:

>>> x1 = ivy.native_array([0.3, 4.3])
>>> x2 = ivy.native_array([3.1, 5])
>>> x3 = ivy.native_array([2, 0])
>>> y = ivy.broadcast_arrays(x1, x2, x3)
[ivy.array([0.3, 4.3]), ivy.array([3.1, 5.]), ivy.array([2, 0])]

With mixed ivy.Array and ivy.NativeArray inputs:

>>> x1 = ivy.array([1, 2])
>>> x2 = ivy.native_array([0.3, 4.3])
>>> y = ivy.broadcast_arrays(x1, x2)
>>> print(y)
[ivy.array([1, 2]), ivy.array([0.3, 4.3])]

With ivy.Container inputs:

>>> x1 = ivy.Container(a=ivy.array([3, 1]), b=ivy.zeros(2))
>>> x2 = ivy.Container(a=ivy.array([4, 5]), b=ivy.array([2, -1]))
>>> y = ivy.broadcast_arrays(x1, x2)
>>> print(y)
[{
    a: ivy.array([3, 1]),
    b: ivy.array([0., 0.])
}, {
    a: ivy.array([4, 5]),
    b: ivy.array([2, -1])
}]

With mixed ivy.Array and ivy.Container inputs:

>>> x1 = ivy.zeros(2)
>>> x2 = ivy.Container(a=ivy.array([4, 5]), b=ivy.array([2, -1]))
>>> y = ivy.broadcast_arrays(x1, x2)
>>> print(y)
[{
    a: ivy.array([0., 0.]),
    b: ivy.array([0., 0.])
}, {
    a: ivy.array([4, 5]),
    b: ivy.array([2, -1])
}]

ivy.broadcast_to(x, /, shape, *, out=None)[source]

Broadcasts an array to a specified shape.

Parameters

x (Union[Array, NativeArray]) – array to broadcast.
shape (Tuple[int, ...]) – array shape. Must be compatible with x (see Broadcasting). If the array is incompatible with the specified shape, the function should raise an exception.
out (Optional[Array]) – optional output array, for writing the result to. It must have a (default: None) shape that the inputs broadcast to.

Return type

Array

Returns

ret – an array having a specified shape. Must have the same data type as x.

Examples

With ivy.Array input:

>>> x = ivy.array([1, 2, 3])
>>> y = ivy.broadcast_to(x, (3, 3))
>>> print(y)
ivy.array([[1, 2, 3],
           [1, 2, 3],
           [1, 2, 3]])

With ivy.NativeArray input:

>>> x = ivy.native_array([0.1 , 0.3])
>>> y = ivy.broadcast_to(x, (3, 2))
>>> print(y)
ivy.array([[0.1, 0.3],
           [0.1, 0.3],
           [0.1, 0.3]])

With ivy.Container input:

>>> x = ivy.Container(a=ivy.array([1, 2, 3]),
...                   b=ivy.array([4, 5, 6]))
>>> y = ivy.broadcast_to(x, (3, 3))
>>> print(y)
{
    a: ivy.array([[1, 2, 3],
                  [1, 2, 3],
                  [1, 2, 3]]),
    b: ivy.array([[4, 5, 6],
                  [4, 5, 6],
                  [4, 5, 6]])
}

ivy.can_cast(from_, to, /)[source]

Determines if one data type can be cast to another data type according to type-promotion rules.

Parameters

from – input data type or array from which to cast.
to (Dtype) – desired data type.

Return type

bool

Returns

ret – True if the cast can occur according to type-promotion rules; otherwise, False.
This function conforms to the `Array API Standard
<https (//data-apis.org/array-api/latest/>`_. This docstring is an extension of the)
`docstring <https (//data-apis.org/array-api/latest/API_specification/generated/signatures.data_type_functions.can_cast.html>`_ )
in the standard.
Both the description and the type hints above assumes an array input for simplicity,
but this function is nestable, and therefore also accepts ivy.Container
instances in place of any of the arguments.

Examples

With ivy.Dtype input:

>>> print(ivy.can_cast(ivy.uint8, ivy.int32))
True

>>> print(ivy.can_cast(ivy.float64, 'int64'))
False

With ivy.Array input:

>>> x = ivy.array([1., 2., 3.])
>>> print(ivy.can_cast(x, ivy.float64))
True

With ivy.NativeArray input:

>>> x = ivy.native_array([[-1, -1, -1],
...                       [1, 1, 1]],
...                       dtype='int16')
>>> print(ivy.can_cast(x, 'uint8'))
False

With ivy.Container input:

>>> x = ivy.Container(a=ivy.array([0., 1., 2.]),
...                   b=ivy.array([3, 4, 5]))
>>> print(ivy.can_cast(x, 'int64'))
{
    a: false,
    b: true
}

ivy.check_float(x)[source]

Helper function to check if the input is a float or a float-like object.

Parameters: x (Any) – Input to check.
Return type: bool
Returns: ret – “True” if the input is a float or a float-like object, otherwise “False”.

ivy.closest_valid_dtype(type, /)[source]

Determines the closest valid datatype to the datatype passed as input.

Parameters: type (Optional[Union[Dtype, str]]) – The data type for which to check the closest valid type for.
Return type: Union[Dtype, str]
Returns: ret – The closest valid data type as a native ivy.Dtype

Examples

With ivy.Dtype input: >>> xType = ivy.float16 >>> yType = ivy.closest_valid_dtype(xType) >>> print(yType) float16

With ivy.NativeDtype inputs: >>> xType = ivy.native_uint16 >>> yType = ivy.closest_valid_dtype(xType) >>> print(yType) <dtype:’uint16’>

With str input: >>> xType = ‘int32’ >>> yType = ivy.closest_valid_dtype(xType) >>> print(yType) int32

ivy.default_dtype(*, dtype=None, item=None, as_native=None)[source]

Parameters

dtype (Optional[Union[Dtype, str]]) – The dtype to be returned. (default: None)
item (Optional[Union[Array, NativeArray]]) – Number or array for inferring the dtype. (default: None)
as_native (Optional[bool]) – Whether to return the dtype as native dtype. (default: None)

Return type

Union[Dtype, NativeDtype, str]

Returns

Return dtype as native or ivy dtype if provided, else
if item is given, return its dtype, otherwise return the
global default dtype.

ivy.default_float_dtype(*, input=None, float_dtype=None, as_native=None)[source]

Parameters

input (Optional[Union[Array, NativeArray]]) – Number or array for inferring the float dtype. (default: None)
float_dtype (Optional[Union[FloatDtype, NativeDtype]]) – The float dtype to be returned. (default: None)
as_native (Optional[bool]) – Whether to return the float dtype as native dtype. (default: None)

Return type

Union[Dtype, str, NativeDtype]

Returns

Return float_dtype as native or ivy dtype if provided, else
if input is given, return its float dtype, otherwise return the
global default float dtype.

Examples

>>> ivy.default_float_dtype()
'float32'

>>> ivy.set_default_float_dtype(ivy.FloatDtype("float64"))
>>> ivy.default_float_dtype()
'float64'

>>> ivy.default_float_dtype(float_dtype=ivy.FloatDtype("float16"))
'float16'

>>> ivy.default_float_dtype(input=4294.967346)
'float32'

>>> x = ivy.array([9.8,8.9], dtype="float16")
>>> ivy.default_float_dtype(input=x)
'float16'

ivy.default_int_dtype(*, input=None, int_dtype=None, as_native=None)[source]

Parameters

input (Optional[Union[Array, NativeArray]]) – Number or array for inferring the int dtype. (default: None)
int_dtype (Optional[Union[IntDtype, NativeDtype]]) – The int dtype to be returned. (default: None)
as_native (Optional[bool]) – Whether to return the int dtype as native dtype. (default: None)

Return type

Union[IntDtype, NativeDtype]

Returns

Return int_dtype as native or ivy dtype if provided, else
if input is given, return its int dtype, otherwise return the
global default int dtype.

Examples

>>> ivy.set_default_int_dtype(ivy.intDtype("int16"))
>>> ivy.default_int_dtype()
'int16'

>>> ivy.default_int_dtype(input=4294967346)
'int64'

>>> ivy.default_int_dtype(int_dtype=ivy.intDtype("int8"))
'int8'

>>> x = ivy.array([9,8], dtype="int32")
>>> ivy.default_int_dtype(input=x)
'int32'

ivy.default_uint_dtype(*, input=None, uint_dtype=None, as_native=None)[source]

Parameters

input (Optional[Union[Array, NativeArray]]) – Number or array for inferring the uint dtype. (default: None)
uint_dtype (Optional[Union[UintDtype, NativeDtype]]) – The uint dtype to be returned. (default: None)
as_native (Optional[bool]) – Whether to return the uint dtype as native dtype. (default: None)

Return type

Union[UintDtype, NativeDtype]

Returns

Return uint_dtype as native or ivy dtype if provided, else
if input is given, return its uint dtype, otherwise return the
global default uint dtype.

Examples

>>> ivy.set_default_uint_dtype(ivy.UintDtype("uint16"))
>>> ivy.default_uint_dtype()
'uint16'

>>> ivy.default_uint_dtype(input=4294967346)
'uint64'

>>> ivy.default_uint_dtype(uint_dtype=ivy.UintDtype("uint8"))
'uint8'

>>> x = ivy.array([9,8], dtype="uint32")
>>> ivy.default_uint_dtype(input=x)
'uint32'

ivy.dtype(x, *, as_native=False)[source]

Get the data type for input array x.

Parameters

x (Union[Array, NativeArray]) – Tensor for which to get the data type.
as_native (bool) – Whether or not to return the dtype in string format. Default is False. (default: False)

Return type

Union[Dtype, NativeDtype]

Returns

ret – Data type of the array.

Examples

With ivy.Array inputs:

>>> x1 = ivy.array([1.0, 2.0, 3.5, 4.5, 5, 6])
>>> y = ivy.dtype(x1)
>>> print(y)
float32

With ivy.NativeArray inputs:

>>> x1 = ivy.native_array([1, 0, 1, -1, 0])
>>> y = ivy.dtype(x1)
>>> print(y)
int32

With ivy.Container inputs:

>>> x = ivy.Container(a=ivy.native_array([1.0, 2.0, -1.0, 4.0, 1.0]),
...                   b=ivy.native_array([1, 0, 0, 0, 1]))
>>> y = ivy.dtype(x.a)
>>> print(y)
float32

ivy.dtype_bits(dtype_in, /)[source]

Get the number of bits used for representing the input data type.

Parameters: dtype_in (Union[Dtype, NativeDtype, str]) – The data type to determine the number of bits for.
Return type: int
Returns: ret – The number of bits used to represent the data type.

Examples

With ivy.Dtype inputs:

>>> x = ivy.dtype_bits(ivy.float32)
>>> print(x)
32

>>> x = ivy.dtype_bits('int64')
>>> print(x)
64

With ivy.NativeDtype inputs:

>>> x = ivy.dtype_bits(ivy.native_bool)
>>> print(x)
1

ivy.finfo(type, /)[source]

Machine limits for floating-point data types.

Parameters

type (Union[Dtype, str, Array, NativeArray]) – the kind of floating-point data-type about which to get information.

Return type

None

Returns

ret – an object having the followng attributes:

bits: int

number of bits occupied by the floating-point data type.
eps: float

difference between 1.0 and the next smallest representable floating-point number larger than 1.0 according to the IEEE-754 standard.
max: float

largest representable number.
min: float

smallest representable number.
smallest_normal: float

smallest positive floating-point number with full precision.

This function conforms to the Array API Standard. This docstring is an extension of the docstring in the standard.

Examples

With ivy.Dtype input:

>>> ivy.finfo(ivy.float32)
finfo(resolution=1e-06, min=-3.4028235e+38, max=3.4028235e+38, dtype=float32)

With str input:

>>> ivy.finfo('float32')
finfo(resolution=1e-06, min=-3.4028235e+38, max=3.4028235e+38, dtype=float32)

With ivy.Array input:

>>> x = ivy.array([1.3,2.1,3.4], dtype=ivy.float64)
>>> ivy.finfo(x)
finfo(resolution=1e-15, min=-1.7976931348623157e+308, /
max=1.7976931348623157e+308, dtype=float64)

With ivy.NativeArray input:

>>> x = ivy.native_array([0.7,8.4,3.14], dtype=ivy.float16)
>>> ivy.finfo(x)
finfo(resolution=0.001, min=-6.55040e+04, max=6.55040e+04, dtype=float16)

With ivy.Container input:

>>> c = ivy.Container(x=ivy.array([-9.5,1.8,-8.9], dtype=ivy.float16), /
                      y=ivy.array([7.6,8.1,1.6], dtype=ivy.float64))
>>> ivy.finfo(c)
{
    x: finfo(resolution=0.001, min=-6.55040e+04, max=6.55040e+04, dtype=float16),
    y: finfo(resolution=1e-15, min=-1.7976931348623157e+308, /
       max=1.7976931348623157e+308, dtype=float64)
}

Using ivy.Array instance method:

>>> x = ivy.array([0.7,8.4,3.14], dtype=ivy.float32)
>>> x.finfo()
finfo(resolution=1e-06, min=-3.4028235e+38, max=3.4028235e+38, dtype=float32)

Using ivy.Container instance method:

>>> c = ivy.Container(x=ivy.array([1.2,3.5,8.], dtype=ivy.float64), /
                      y=ivy.array([1.3,2.1,3.4], dtype=ivy.float16))
>>> c.finfo()
{
    x: finfo(resolution=1e-15, min=-1.7976931348623157e+308, /
             max=1.7976931348623157e+308, dtype=float64)
    y: finfo(resolution=0.001, min=-6.55040e+04, max=6.55040e+04, dtype=float16),
}

ivy.function_supported_dtypes(fn, recurse=True)[source]

Returns the supported data types of the current backend’s function.

Parameters

fn (Callable) – The function to check for the supported dtype attribute
recurse (bool) – Whether to recurse into used ivy functions. Default is True. (default: True)

Return type

Tuple

Returns

ret – The supported data types of the function

Examples

>>> print(ivy.function_supported_dtypes(ivy.acosh))
('bool', 'float64', 'int64', 'uint8', 'int8', 'float32', 'int32', 'int16',     'bfloat16')

ivy.function_unsupported_dtypes(fn, recurse=True)[source]

Returns the unsupported data types of the current backend’s function.

Parameters

fn (Callable) – The function to check for the unsupported dtype attribute
recurse (bool) – Whether to recurse into used ivy functions. Default is True. (default: True)

Return type

Tuple

Returns

ret – The unsupported data types of the function

Examples

>>> ivy.set_backend('torch')
>>> print(ivy.function_unsupported_dtypes(ivy.acosh))
('float16','uint16','uint32','uint64')

ivy.iinfo(type, /)[source]

Machine limits for integer data types.

Parameters

type (Union[Dtype, str, Array, NativeArray]) – the kind of integer data-type about which to get information.

Return type

None

Returns

ret – a class with that encapsules the following attributes:

bits: int

number of bits occupied by the type.
max: int

largest representable number.
min: int

smallest representable number.

This function conforms to the Array API Standard. This docstring is an extension of the docstring in the standard.

Examples

With ivy.Dtype input:

>>> ivy.iinfo(ivy.int32)
iinfo(min=-2147483648, max=2147483647, dtype=int32)

With str input:

>>> ivy.iinfo('int32')
iinfo(min=-2147483648, max=2147483647, dtype=int32)

With ivy.Array input:

>>> x = ivy.array([13,21,34], dtype=ivy.int8)
>>> ivy.iinfo(x)
iinfo(min=-128, max=127, dtype=int8)

With ivy.NativeArray input:

>>> x = ivy.native_array([7,84,314], dtype=ivy.int64)
>>> ivy.iinfo(x)
iinfo(min=-9223372036854775808, max=9223372036854775807, dtype=int64)

With ivy.Container input:

>>> c = ivy.Container(x=ivy.array([0,1800,89], dtype=ivy.uint16),
...                   y=ivy.array([76,81,16], dtype=ivy.uint32))
>>> ivy.iinfo(c)
{
    x: iinfo(min=0, max=65535, dtype=uint16),
    y: iinfo(min=0, max=4294967295, dtype=uint32)
}

ivy.infer_default_dtype(dtype, as_native=False)[source]

Summary.

Parameters

dtype (Union[Dtype, NativeDtype, str]) –
as_native (bool) – (Default value = False) (default: False)

Return type

Union[Dtype, NativeDtype]

Returns

Return the default data type for the “kind” (integer or floating-point) of dtype

Examples

>>> ivy.set_default_int_dtype("int32")
>>> ivy.infer_default_dtype("int8")
'int8'

>>> ivy.set_default_float_dtype("float64")
>>> ivy.infer_default_dtype("float32")
'float64'

>>> ivy.set_default_uint_dtype("uint32")
>>> x = ivy.array([0], dtype="uint64")
>>> ivy.infer_default_dtype(x.dtype)
'uint32'

ivy.invalid_dtype(dtype_in, /)[source]

Determines whether the provided data type is not support by the current framework.

Parameters: dtype_in (Optional[Union[Dtype, NativeDtype, str]]) – The data type for which to check for backend non-support
Return type: bool
Returns: ret – Boolean, whether the data-type string is un-supported.

Examples

>>> print(ivy.invalid_dtype(None))
False

>>> print(ivy.invalid_dtype("uint64"))
False

>>> print(ivy.invalid_dtype(ivy.float64))
False

>>> print(ivy.invalid_dtype(ivy.native_uint8))
False

ivy.is_bool_dtype(dtype_in, /)[source]

Determine whether the input data type is a bool data type.

Parameters

dtype_in (Union[Dtype, str, Array, NativeArray, Number]) – input data type to test.

Return type

bool

Returns

ret – “True” if the input data type is a bool, otherwise “False”.
Both the description and the type hints above assumes an array input for
simplicity but this function is *nestable, and therefore also accepts*
ivy.Container instances in place of any of the arguments.

ivy.is_float_dtype(dtype_in, /)[source]

Determine whether the input data type is a float dtype.

Parameters: dtype_in (Union[Dtype, str, Array, NativeArray, Number]) – The array or data type to check
Return type: bool
Returns: ret – Whether or not the array or data type is of a floating point dtype

Examples

>>> x = ivy.is_float_dtype(ivy.float32)
>>> print(x)
True

>>> arr = ivy.array([1.2, 3.2, 4.3], dtype=ivy.float32)
>>> print(ivy.is_float_dtype(arr))
True

ivy.is_int_dtype(dtype_in, /)[source]

Determine whether the input data type is an int data type.

Parameters

dtype_in (Union[Dtype, str, Array, NativeArray, Number]) – input data type to test.

Return type

bool

Returns

ret – “True” if the input data type is an integer, otherwise “False”.
Both the description and the type hints above assumes an array input for
simplicity but this function is *nestable, and therefore also accepts*
ivy.Container instances in place of any of the arguments.

Examples

With ivy.Dtype input:

>>> x = ivy.is_int_dtype(ivy.float64)
>>> print(x)
False

With ivy.Array input: >>> x = ivy.array([1., 2., 3.]) >>> x.dtype float32

>>> print(ivy.is_int_dtype(x))
False

With ivy.NativeArray input: >>> x = ivy.native_array([[-1, -1, -1], [1, 1, 1]], dtype=ivy.int16) >>> print(ivy.is_int_dtype(x)) True

With Number input: >>> x = 1 >>> print(ivy.is_int_dtype(x)) True

With ivy.Container input: >>> x = ivy.Container(a=ivy.array([0., 1., 2.]),b=ivy.array([3, 4, 5])) >>> x.a.dtype float32 >>> x.b.dtype int32

>>> print(ivy.is_int_dtype(x))
{
    a: false,
    b: true
}

ivy.is_uint_dtype(dtype_in, /)[source]

Determine whether the input data type is a uint dtype.

Parameters: dtype_in (Union[Dtype, str, Array, NativeArray, Number]) – The array or data type to check
Return type: bool
Returns: ret – Whether or not the array or data type is of a uint dtype

Examples

>>> ivy.is_uint_dtype(ivy.UintDtype("uint16"))
True

>>> ivy.is_uint_dtype(ivy.Dtype("uint8"))
True

>>> ivy.is_uint_dtype(ivy.IntDtype("int64"))
False

ivy.promote_types(type1, type2, /, *, array_api_promotion=False)[source]

Promotes the datatypes type1 and type2, returning the data type they promote to

Parameters

type1 (Union[Dtype, NativeDtype]) – the first of the two types to promote
type2 (Union[Dtype, NativeDtype]) – the second of the two types to promote
array_api_promotion (bool) – whether to only use the array api promotion rules (default: False)

Return type

Dtype

Returns

ret – The type that both input types promote to

ivy.promote_types_of_inputs(x1, x2, /, *, array_api_promotion=False)[source]

Promotes the dtype of the given native array inputs to a common dtype based on type promotion rules. While passing float or integer values or any other non-array input to this function, it should be noted that the return will be an array-like object. Therefore, outputs from this function should be used as inputs only for those functions that expect an array-like or tensor-like objects, otherwise it might give unexpected results.

Return type: Tuple[NativeArray, NativeArray]

ivy.result_type(*arrays_and_dtypes)[source]

Returns the dtype that results from applying the type promotion rules (see type-promotion) to the arguments.

Note

If provided mixed dtypes (e.g., integer and floating-point), the returned dtype will be implementation-specific.

Parameters: arrays_and_dtypes (Union[Array, NativeArray, Dtype]) – an arbitrary number of input arrays and/or dtypes.
Return type: Dtype
Returns: ret – the dtype resulting from an operation involving the input arrays and dtypes.

This function conforms to the Array API Standard. This docstring is an extension of the docstring in the standard.

Examples

With ivy.Array input:

>>> x = ivy.array([3, 4, 5])
>>> y = ivy.array([3., 4., 5.])
>>> print(ivy.result_type(x, y))
float64

With ivy.NativeArray input:

>>> x = ivy.native_array([3., 4, 7.5])
>>> y = ivy.native_array([3, 4, 7])
>>> print(ivy.result_type(x, y))
float64

With ivy.Dtype input:

>>> print(ivy.result_type(ivy.uint8, ivy.uint64))
uint64

With ivy.Container input:

>>> x = ivy.Container(a = ivy.array([3, 4, 5]))
>>> print(x.a.dtype)
int32

>>> print(ivy.result_type(x, ivy.float64))
{
    a: float64
}

ivy.set_default_dtype(dtype, /)[source]

Sets the datatype dtype as default data type.

Parameters: dtype (Union[Dtype, NativeDtype, str]) – the data_type to set as default data type

Examples

With ivy.Dtype input: >>> ivy.set_default_dtype(ivy.bool) >>> ivy.default_dtype_stack [‘bool’] >>> ivy.unset_default_dtype()

>>> ivy.set_default_dtype("float64")
>>> ivy.default_dtype_stack
['float64']
>>> ivy.unset_default_dtype()

With ivy.NativeDtype input: >>> ivy.set_default_dtype(ivy.native_uint64) >>> ivy.default_dtype_stack [‘uint64’]

ivy.set_default_float_dtype(float_dtype, /)[source]

Summary.

Parameters: float_dtype (Union[Dtype, str]) –

ivy.set_default_int_dtype(int_dtype, /)[source]

Sets the ‘int_dtype’ as the default data type.

Parameters: int_dtype (Union[Dtype, str]) – The integer data type to be set as the default.

Examples

With :class: ivy.Dtype input: >>> ivy.set_default_int_dtype(ivy.intDtype(“int64”)) >>> ivy.default_int_dtype() ‘int64’

>>> ivy.set_default_int_dtype(ivy.intDtype("int32"))
>>> ivy.default_int_dtype()
'int32'

ivy.set_default_uint_dtype(uint_dtype, /)[source]

Set the uint dtype to be default.

Parameters: uint_dtype (Union[Dtype, str]) – The uint dtype to be set as default.

Examples

>>> ivy.set_default_uint_dtype(ivy.UintDtype("uint8"))
>>> ivy.default_uint_dtype()
'uint8'

>>> ivy.set_default_uint_dtype(ivy.UintDtype("uint64"))
>>> ivy.default_uint_dtype()
'uint64'

ivy.type_promote_arrays(x1, x2, /)[source]

Type promote the input arrays, returning new arrays with the shared correct data type

Parameters

x1 (Union[Array, NativeArray]) – the first of the two arrays to type promote
x2 (Union[Array, NativeArray]) – the second of the two arrays to type promote

Return type

Tuple

Returns

ret1, ret2 – The input arrays after type promotion

ivy.unset_default_dtype()[source]

Reset the current default dtype to the previous state.

Examples

>>> ivy.set_default_dtype(ivy.int32)
>>> ivy.set_default_dtype(ivy.bool)
>>> ivy.default_dtype_stack
['int32', 'bool']

>>> ivy.unset_default_dtype()
>>> ivy.default_dtype_stack
['int32']

>>> ivy.unset_default_dtype()
>>> ivy.default_dtype_stack
[]

ivy.unset_default_float_dtype()[source]

Reset the current default float dtype to the previous state.

Examples

>>> ivy.set_default_float_dtype(ivy.float32)
>>> ivy.set_default_float_dtype(ivy.float64)
>>> ivy.default_float_dtype_stack
['float32','float64']
>>> ivy.unset_default_float_dtype()
>>> ivy.default_float_dtype_stack
['float32']

ivy.unset_default_int_dtype()[source]

Reset the current default int dtype to the previous state.

Parameters: None –

Examples

>>> ivy.set_default_int_dtype(ivy.intDtype("int16"))
>>> ivy.default_int_dtype()
'int16'

>>> ivy.unset_default_int_dtype()
>>> ivy.default_int_dtype()
'int32'

ivy.unset_default_uint_dtype()[source]

Reset the current default uint dtype to the previous state.

Examples

>>> ivy.set_default_uint_dtype(ivy.UintDtype("uint8"))
>>> ivy.default_uint_dtype()
'uint8'

>>> ivy.unset_default_uint_dtype()
>>> ivy.default_uint_dtype()
'uint32'

ivy.valid_dtype(dtype_in, /)[source]

Determines whether the provided data type is supported by the current framework.

Parameters: dtype_in (Optional[Union[Dtype, NativeDtype, str]]) – The data type for which to check for backend support
Return type: bool
Returns: ret – Boolean, whether or not the data-type string is supported.

Examples

>>> print(ivy.valid_dtype(None))
True

>>> print(ivy.valid_dtype(ivy.float64))
True

>>> print(ivy.valid_dtype('bool'))
True

>>> print(ivy.valid_dtype(ivy.native_float16))
True

This should have hopefully given you an overview of the data type submodule,If you have any questions, please feel free to reach out on our discord in the data type channel or in the data type forum!