code: def arange(
      start: Number,
      /,
      stop: Optional[Number] = None,
      step: Number = 1,
      *,
      dtype: Optional[Union[ivy.Dtype, ivy.NativeDtype]] = None,
      device: Optional[Union[ivy.Device, ivy.NativeDevice]] = None,
      out: Optional[ivy.Array] = None,
  ) -> ivy.Array:
      """Return evenly spaced values within a given interval, with the spacing
      being specified.
  
      Values are generated within the half-open interval [start, stop) (in other words,
      the interval including start but excluding stop). For integer arguments the function
      is equivalent to the Python built-in range function, but returns an array in the
      chosen ml_framework rather than a list.
  
      See :math:`linspace` for a certain number of evenly spaced values in an interval.
  
      Parameters
      ----------
      start
          if stop is specified, the start of interval (inclusive); otherwise, the end of
          the interval (exclusive). If stop is not specified, the default starting value
          is 0.
      stop
          the end of the interval. Default: ``None``.
      step
          the distance between two adjacent elements (out[i+1] - out[i]). Must not be 0;
          may be negative, this results in an empty array if stop >= start. Default: 1.
      dtype
          output array data type. If dtype is None, the output array data type must be
          inferred from start, stop and step. If those are all integers, the output array
          dtype must be the default integer dtype; if one or more have type float, then
          the output array dtype must be the default floating-point data type. Default:
          None.
      device
          device on which to place the created array. Default: ``None``.
      out
          optional output array, for writing the result to. It must have a shape that the
          inputs broadcast to.
  
      Returns
      -------
      ret
          a one-dimensional array containing evenly spaced values. The length of the
          output array must be ceil((stop-start)/step) if stop - start and step have the
          same sign, and length 0 otherwise.
  
  
      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/array_api.arange.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 :class:`ivy.Container`
      instances in place of any of the arguments.
  
      Examples
      --------
      >>> stop = 5
      >>> x = ivy.arange(stop)
      >>> print(x)
      ivy.array([0, 1, 2, 3, 4])
  
      >>> start = 1
      >>> stop = 5
      >>> x = ivy.arange(start, stop)
      >>> print(x)
      ivy.array([1, 2, 3, 4])
  
      >>> start = 1
      >>> stop = 10
      >>> step = 2
      >>> x = ivy.arange(start, stop, step)
      >>> print(x)
      ivy.array([1, 3, 5, 7, 9])
  
      >>> start = 1
      >>> stop = 10
      >>> step = 2
      >>> dtype = "float64"
      >>> device = "cpu"
      >>> x = ivy.arange(start, stop, step, dtype=dtype, device=device)
      >>> print(x, x.dtype, x.device)
      ivy.array([1., 3., 5., 7., 9.]) float64 cpu
      """
      return current_backend().arange(
          start, stop, step, dtype=dtype, device=device, out=out
      )
  
imports: from __future__ import annotations
  import functools
  from numbers import Number
  from typing import Union, Tuple, Optional, List, Sequence, Callable, Protocol, TypeVar, Iterable
  import numpy
  import ivy
  from ivy import to_ivy
  from ivy.utils.exceptions import handle_exceptions
  from ivy.utils.backend import current_backend
  from ivy.func_wrapper import handle_array_function, infer_dtype, handle_out_argument, outputs_to_ivy_arrays, inputs_to_native_arrays, inputs_to_native_shapes, to_native_arrays_and_back, handle_nestable, handle_array_like_without_promotion, handle_device, handle_backend_invalid, temp_asarray_wrapper
label_desc: Use image node_id 10 for calling a global function with example usage: arange(stop, step) and returns: current_backend