code: def float_power(
      x1: Union[ivy.Array, float, list, tuple],
      x2: Union[ivy.Array, float, list, tuple],
      /,
      *,
      out: Optional[ivy.Array] = None,
  ) -> ivy.Array:
      """Raise each base in x1 to the positionally-corresponding power in x2. x1
      and x2 must be broadcastable to the same shape. This differs from the power
      function in that integers, float16, and float32 are promoted to floats with
      a minimum precision of float64 so that the result is always inexact.
  
      Parameters
      ----------
      x1
          Array-like with elements to raise in power.
      x2
          Array-like of exponents. If x1.shape != x2.shape,
          they must be broadcastable to a common shape
          (which becomes the shape of the output).
      out
          optional output array, for writing the result to.
  
      Returns
      -------
      ret
          The bases in x1 raised to the exponents in x2.
          This is a scalar if both x1 and x2 are scalars
  
      Examples
      --------
      >>> x1 = ivy.array([1, 2, 3, 4, 5])
      >>> ivy.float_power(x1, 3)
      ivy.array([1.,    8.,   27.,   64.,  125.])
      >>> x1 = ivy.array([1, 2, 3, 4, 5])
      >>> x2 = ivy.array([2, 3, 3, 2, 1])
      >>> ivy.float_power(x1, x2)
      ivy.array([1.,   8.,  27.,  16.,   5.])
      """
      return ivy.current_backend().float_power(x1, x2, out=out)
  
imports: from typing import Optional, Union, Tuple, List, Sequence
  from numbers import Number
  import ivy
  from ivy.func_wrapper import handle_out_argument, to_native_arrays_and_back, handle_nestable, handle_partial_mixed_function, handle_array_like_without_promotion, inputs_to_ivy_arrays, handle_array_function, infer_dtype, handle_device, handle_backend_invalid
  from ivy.utils.exceptions import handle_exceptions
label_desc: Use image node_id 6 for calling a global function with example usage: float_power() and returns: ivy