Creation#

class ivy.data_classes.array.creation._ArrayWithCreation[source]#

Bases: ABC

_abc_impl = <_abc._abc_data object>#
asarray(*, copy=None, dtype=None, device=None, out=None)[source]#

ivy.Array instance method variant of ivy.asarray. This method simply wraps the function, and so the docstring for ivy.asarray also applies to this method with minimal changes.

Parameters:

  • self (Array) – input data, in any form that can be converted to an array. This includes lists, lists of tuples, tuples, tuples of tuples, tuples of lists and ndarrays.

  • copy (Optional[bool], default: None) – boolean indicating whether or not to copy the input array. If True, the function must always copy. If False, the function must never copy and must raise a ValueError in case a copy would be necessary. If None, the function must reuse existing memory buffer if possible and copy otherwise. Default: None.

  • dtype (Optional[Union[Dtype, NativeDtype]], default: None) – datatype, optional. Datatype is inferred from the input data.

  • device (Optional[Union[Device, NativeDevice]], default: None) – device on which to place the created array. Default: None.

  • out (Optional[Array], default: None) – optional output array, for writing the result to. It must have a shape that the inputs broadcast to.

Return type:

Array

Returns:

ret – An array interpretation of self.

Examples

With list of lists as input:

>>> ivy.asarray([[1,2],[3,4]])
ivy.array([[1, 2],
       [3, 4]])

With tuple of lists as input:

>>> ivy.asarray(([1.4,5.6,5.5],[3.1,9.1,7.5]))
ivy.array([[1.39999998, 5.5999999 , 5.5       ],
       [3.0999999 , 9.10000038, 7.5       ]])

With ndarray as input:

>>> x = ivy.np.ndarray(shape=(2,2), order='C')
>>> x
array([[6.90786433e-310, 6.90786433e-310],
       [6.90786433e-310, 6.90786433e-310]])
>>> ivy.asarray(x)
ivy.array([[6.90786433e-310, 6.90786433e-310],
       [6.90786433e-310, 6.90786433e-310]])
copy_array(*, to_ivy_array=True, out=None)[source]#

ivy.Array instance method variant of ivy.copy_array. This method simply wraps the function, and so the docstring for ivy.copy_array also applies to this method with minimal changes.

Parameters:

  • self (Array) – input array

  • to_ivy_array (bool, default: True) – boolean, if True the returned array will be an ivy.Array object otherwise returns an ivy.NativeArray object (i.e. a torch.tensor, np.array, etc., depending on the backend), defaults to True.

  • out (Optional[Array], default: None) – optional output array, for writing the result to. It must have a shape that the inputs broadcast to.

Return type:

Array

Returns:

ret – a copy of the input array x.

empty_like(*, dtype=None, device=None, out=None)[source]#

ivy.Array instance method variant of ivy.empty_like. This method simply wraps the function, and so the docstring for ivy.empty_like also applies to this method with minimal changes.

Parameters:

  • self (Array) – input array from which to derive the output array shape.

  • dtype (Optional[Union[Dtype, NativeDtype]], default: None) – output array data type. If dtype is None, the output array data type must be inferred from self. Deafult: None.

  • device (Optional[Union[Device, NativeDevice]], default: None) – device on which to place the created array. If device is None, the output array device must be inferred from self. Default: None.

  • out (Optional[Array], default: None) – optional output array, for writing the result to. It must have a shape that the inputs broadcast to.

Return type:

Array

Returns:

ret – an array having the same shape as self and containing uninitialized data.

from_dlpack(*, out=None)[source]#

ivy.Array instance method variant of ivy.from_dlpack. This method simply wraps the function, and so the docstring for ivy.from_dlpack also applies to this method with minimal changes.

Parameters:

  • self (Array) – input array.

  • out (Optional[Array], default: None) – optional output array, for writing the result to. It must have a shape that the inputs broadcast to.

Return type:

Array

Returns:

ret – an array containing the data in self.

full_like(fill_value, *, dtype=None, device=None, out=None)[source]#

ivy.Array instance method variant of ivy.full_like. This method simply wraps the function, and so the docstring for ivy.full_like also applies to this method with minimal changes.

Parameters:

  • self (Array) – input array from which to derive the output array shape.

  • fill_value (float) – Scalar fill value

  • dtype (Optional[Union[Dtype, NativeDtype]], default: None) – output array data type. If dtype is None, the output array data type must be inferred from self. Default: None.

  • device (Optional[Union[Device, NativeDevice]], default: None) – device on which to place the created array. If device is None, the output array device must be inferred from self. Default: None.

  • out (Optional[Array], default: None) – optional output array, for writing the result to. It must have a shape that the inputs broadcast to.

Return type:

Array

Returns:

ret – an array having the same shape as self and where every element is equal to fill_value.

Examples

With int datatype:

>>> x = ivy.array([1,2,3])
>>> fill_value = 0
>>> x.full_like(fill_value)
ivy.array([0, 0, 0])

With float datatype:

>>> fill_value = 0.000123
>>> x = ivy.array(ivy.ones(5))
>>> y = x.full_like(fill_value)
>>> print(y)
ivy.array([0.000123, 0.000123, 0.000123, 0.000123, 0.000123])

With ivy.Array input:

>>> x = ivy.array([1, 2, 3, 4, 5, 6])
>>> fill_value = 1
>>> y = x.full_like(fill_value)
>>> print(y)
ivy.array([1, 1, 1, 1, 1, 1])
linspace(stop, /, num, *, axis=None, endpoint=True, dtype=None, device=None, out=None)[source]#
Return type:

Array

logspace(stop, /, num, *, base=10.0, axis=0, endpoint=True, dtype=None, device=None, out=None)[source]#

ivy.Array instance method variant of ivy.logspace. This method simply wraps the function, and so the docstring for ivy.logspace also applies to this method with minimal changes.

Parameters:

  • self (Array) – First value in the range in log space. base ** start is the starting value in the sequence. Can be an array or a float.

  • stop (Union[Array, NativeArray, float]) – Last value in the range in log space. base ** stop is the final value in the sequence. Can be an array or a float.

  • num (int) – Number of values to generate.

  • base (float, default: 10.0) – The base of the log space. Default is 10.0

  • axis (int, default: 0) – Axis along which the operation is performed. Relevant only if start or stop are array-like. Default is 0.

  • endpoint (bool, default: True) – If True, stop is the last sample. Otherwise, it is not included. Default is True.

  • dtype (Optional[Union[Dtype, NativeDtype]], default: None) – The data type of the output tensor. If None, the dtype of on_value is used or if that is None, the dtype of off_value is used, or if that is None, defaults to float32. Default is None.

  • device (Optional[Union[Device, NativeDevice]], default: None) – device on which to create the array ‘cuda:0’, ‘cuda:1’, ‘cpu’ etc. Default is None.

  • out (Optional[Array], default: None) – optional output array, for writing the result to. It must have a shape that the inputs broadcast to. Default is None.

Return type:

Array

Returns:

  • ret – Tensor of evenly-spaced values in log space.

  • 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 float input:

>>> x = ivy.array([1, 2])
>>> y = ivy.array([4, 5])
>>> x.logspace(y, 4)
ivy.array([[1.e+01, 1.e+02],
           [1.e+02, 1.e+03],
           [1.e+03, 1.e+04],
           [1.e+04, 1.e+05])

>>> x.logspace(y, 4, axis = 1)
ivy.array([[[1.e+01, 1.e+02, 1.e+03, 1.e+04],
           [1.e+02, 1.e+03, 1.e+04, 1.e+05]]])

>>> x = ivy.array([1, 2])
>>> y = ivy.array([4])      # Broadcasting example
>>> x.logspace(y, 4)
ivy.array([[10., 100.]
           [100., 464.15888336]
           [1000., 2154.43469003]
           [10000., 10000.]])
meshgrid(*arrays, sparse=False, indexing='xy')[source]#

ivy.Array instance method variant of ivy.meshgrid. This method simply wraps the function, and so the docstring for ivy.meshgrid also applies to this method with minimal changes.

Parameters:

  • self (Array) – one-dimensional input array.

  • arrays (Union[Array, NativeArray]) – an arbitrary number of one-dimensional arrays representing grid coordinates. Each array should have the same numeric data type.

  • sparse (bool, default: False) – if True, a sparse grid is returned in order to conserve memory. Default: False.

  • indexing (str, default: 'xy') – Cartesian 'xy' or matrix 'ij' indexing of output. If provided zero or one one-dimensional vector(s) (i.e., the zero- and one-dimensional cases, respectively), the indexing keyword has no effect and should be ignored. Default: 'xy'.

Return type:

List[Array]

Returns:

ret – list of N arrays, where N is the number of provided one-dimensional input arrays. Each returned array must have rank N. For N one-dimensional arrays having lengths Ni = len(xi).

native_array(*, dtype=None, device=None)[source]#

ivy.Array instance method variant of ivy.native_array. This method simply wraps the function, and so the docstring for ivy.native_array also applies to this method with minimal changes.

Parameters:

  • self (Array) – input array.

  • dtype (Optional[Union[Dtype, NativeDtype]], default: None) – datatype, optional. Datatype is inferred from the input data.

  • device (Optional[Union[Device, NativeDevice]], default: None) – device on which to place the created array. Default: None.

Return type:

NativeArray

Returns:

ret – A native array interpretation of self.

one_hot(depth, /, *, on_value=None, off_value=None, axis=None, dtype=None, device=None, out=None)[source]#

ivy.Array instance method variant of ivy.one_hot. This method simply wraps the function, and so the docstring for ivy.one_hot also applies to this method with minimal changes.

Parameters:

  • self (Array) – input array containing the indices for which the ones should be scattered

  • depth (int) – Scalar defining the depth of the one-hot dimension.

  • on_value (Optional[Number], default: None) – Value to fill in output when indices[j] == i. Default 1.

  • off_value (Optional[Number], default: None) – Value to fill in output when indices[j] != i. Default 0.

  • axis (Optional[int], default: None) – The axis to scatter on. The default is -1 which is the last axis.

  • dtype (Optional[Union[Dtype, NativeDtype]], default: None) – The data type of the output array. If None, the data type of the on_value is used, or if that is None, the data type of the off_value is used. Default float32.

  • device (Optional[Union[Device, NativeDevice]], default: None) – device on which to create the array ‘cuda:0’, ‘cuda:1’, ‘cpu’ etc. Same as x if None.

  • out (Optional[Array], default: None) – optional output array, for writing the result to. It must have a shape that the inputs broadcast to.

Return type:

Array

Returns:

ret – Tensor of zeros with the same shape and type as a, unless dtype provided which overrides.

Examples

With ivy.Array inputs:

>>> x = ivy.array([3, 1])
>>> y = 5
>>> z = x.one_hot(5)
>>> print(z)
ivy.array([[0., 0., 0., 1., 0.],
...    [0., 1., 0., 0., 0.]])

>>> x = ivy.array([0])
>>> y = 5
>>> ivy.one_hot(x, y)
ivy.array([[1., 0., 0., 0., 0.]])

>>> x = ivy.array([0])
>>> y = 5
>>> ivy.one_hot(x, 5, out=z)
ivy.array([[1., 0., 0., 0., 0.]])
>>> print(z)
ivy.array([[1., 0., 0., 0., 0.]])
ones_like(*, dtype=None, device=None, out=None)[source]#

ivy.Array instance method variant of ivy.ones_like. This method simply wraps the function, and so the docstring for ivy.ones_like also applies to this method with minimal changes.

Parameters:

  • self (Array) – input array from which to derive the output array shape.

  • dtype (Optional[Union[Dtype, NativeDtype]], default: None) – output array data type. If dtype is None, the output array data type must be inferred from self. Default None.

  • device (Optional[Union[Device, NativeDevice]], default: None) – device on which to place the created array. If device is None, the output array device must be inferred from self. Default: None.

  • out (Optional[Array], default: None) – optional output array, for writing the result to. It must have a shape that the inputs broadcast to.

Return type:

Array

Returns:

ret – an array having the same shape as self and filled with ones.

tril(*, k=0, out=None)[source]#

ivy.Array instance method variant of ivy.tril. This method simply wraps the function, and so the docstring for ivy.tril also applies to this method with minimal changes.

Parameters:

  • self (Array) – input array having shape (…, M, N) and whose innermost two dimensions form MxN matrices.

  • k (int, default: 0) – diagonal above which to zero elements. If k = 0, the diagonal is the main diagonal. If k < 0, the diagonal is below the main diagonal. If k > 0, the diagonal is above the main diagonal. Default: 0.

  • out (Optional[Array], default: None) – optional output array, for writing the result to. It must have a shape that the inputs broadcast to.

Return type:

Array

Returns:

ret – an array containing the lower triangular part(s). The returned array must have the same shape and data type as self. All elements above the specified diagonal k must be zeroed. The returned array should be allocated on the same device as self.

triu(*, k=0, out=None)[source]#

ivy.Array instance method variant of ivy.triu. This method simply wraps the function, and so the docstring for ivy.triu also applies to this method with minimal changes.

Parameters:

  • self (Array) – input array having shape (…, M, N) and whose innermost two dimensions form MxN matrices. *,

  • k (int, default: 0) – diagonal below which to zero elements. If k = 0, the diagonal is the main diagonal. If k < 0, the diagonal is below the main diagonal. If k > 0, the diagonal is above the main diagonal. Default: 0.

  • out (Optional[Array], default: None) – optional output array, for writing the result to. It must have a shape that the inputs broadcast to.

Return type:

Array

Returns:

ret – an array containing the upper triangular part(s). The returned array must have the same shape and data type as self. All elements below the specified diagonal k must be zeroed. The returned array should be allocated on the same device as self.

zeros_like(*, dtype=None, device=None, out=None)[source]#

ivy.Array instance method variant of ivy.zeros_like. This method simply wraps the function, and so the docstring for ivy.zeros_like also applies to this method with minimal changes.

Parameters:

  • self (Array) – input array from which to derive the output array shape.

  • dtype (Optional[Union[Dtype, NativeDtype]], default: None) – output array data type. If dtype is None, the output array data type must be inferred from self. Default: None.

  • device (Optional[Union[Device, NativeDevice]], default: None) – device on which to place the created array. If device is None, the output array device must be inferred from self. Default: None.

  • out (Optional[Array], default: None) – optional output array, for writing the result to. It must have a shape that the inputs broadcast to.

Return type:

Array

Returns:

ret – an array having the same shape as self and filled with zeros.