code: def zoom(
      input,
      zoom,
      output=None,
      order=3,
      mode="constant",
      cval=0.0,
      prefilter=True,
      *,
      grid_mode=False,
  ):
      """
      Zoom an array.
  
      The array is zoomed using spline interpolation of the requested order.
  
      Parameters
      ----------
      %(input)s
      zoom : float or sequence
          The zoom factor along the axes. If a float, `zoom` is the same for each
          axis. If a sequence, `zoom` should contain one value for each axis.
      %(output)s
      order : int, optional
          The order of the spline interpolation, default is 3.
          The order has to be in the range 0-5.
      %(mode_interp_constant)s
      %(cval)s
      %(prefilter)s
      grid_mode : bool, optional
          If False, the distance from the pixel centers is zoomed. Otherwise, the
          distance including the full pixel extent is used. For example, a 1d
          signal of length 5 is considered to have length 4 when `grid_mode` is
          False, but length 5 when `grid_mode` is True. See the following
          visual illustration:
  
          .. code-block:: text
  
                  | pixel 1 | pixel 2 | pixel 3 | pixel 4 | pixel 5 |
                       |<-------------------------------------->|
                                          vs.
                  |<----------------------------------------------->|
  
          The starting point of the arrow in the diagram above corresponds to
          coordinate location 0 in each mode.
  
      Returns
      -------
      zoom : ndarray
          The zoomed input.
  
      Notes
      -----
      For complex-valued `input`, this function zooms the real and imaginary
      components independently.
  
      .. versionadded:: 1.6.0
          Complex-valued support added.
  
      Examples
      --------
      >>> from scipy import ndimage, datasets
      >>> import matplotlib.pyplot as plt
  
      >>> fig = plt.figure()
      >>> ax1 = fig.add_subplot(121)  # left side
      >>> ax2 = fig.add_subplot(122)  # right side
      >>> ascent = datasets.ascent()
      >>> result = ndimage.zoom(ascent, 3.0)
      >>> ax1.imshow(ascent, vmin=0, vmax=255)
      >>> ax2.imshow(result, vmin=0, vmax=255)
      >>> plt.show()
  
      >>> print(ascent.shape)
      (512, 512)
  
      >>> print(result.shape)
      (1536, 1536)
      """
      if order < 0 or order > 5:
          raise RuntimeError("spline order not supported")
      input = numpy.asarray(input)
      if input.ndim < 1:
          raise RuntimeError("input and output rank must be > 0")
      zoom = _ni_support._normalize_sequence(zoom, input.ndim)
      output_shape = tuple(
          [int(round(ii * jj)) for ii, jj in zip(input.shape, zoom)]
      )
      complex_output = numpy.iscomplexobj(input)
      output = _ni_support._get_output(
          output,
          input,
          shape=output_shape,
          complex_output=complex_output,
      )
      if complex_output:
          # import under different name to avoid confusion with zoom parameter
          from scipy.ndimage._interpolation import zoom as _zoom
  
          kwargs = dict(order=order, mode=mode, prefilter=prefilter)
          _zoom(
              input.real,
              zoom,
              output=output.real,
              cval=numpy.real(cval),
              **kwargs,
          )
          _zoom(
              input.imag,
              zoom,
              output=output.imag,
              cval=numpy.imag(cval),
              **kwargs,
          )
          return output
      if prefilter and order > 1:
          padded, npad = _prepad_for_spline_filter(input, mode, cval)
          filtered = spline_filter(
              padded, order, output=numpy.float64, mode=mode
          )
      else:
          npad = 0
          filtered = input
      if grid_mode:
          # warn about modes that may have surprising behavior
          suggest_mode = None
          if mode == "constant":
              suggest_mode = "grid-constant"
          elif mode == "wrap":
              suggest_mode = "grid-wrap"
          if suggest_mode is not None:
              warnings.warn(
                  (
                      "It is recommended to use mode = {} instead of {} when "
                      "grid_mode is True."
                  ).format(suggest_mode, mode),
                  stacklevel=2,
              )
      mode = _ni_support._extend_mode_to_code(mode)
  
      zoom_div = numpy.array(output_shape)
      zoom_nominator = numpy.array(input.shape)
      if not grid_mode:
          zoom_div -= 1
          zoom_nominator -= 1
  
      # Zooming to infinite values is unpredictable, so just choose
      # zoom factor 1 instead
      zoom = numpy.divide(
          zoom_nominator,
          zoom_div,
          out=numpy.ones_like(input.shape, dtype=numpy.float64),
          where=zoom_div != 0,
      )
      zoom = numpy.ascontiguousarray(zoom)
      _nd_image.zoom_shift(
          filtered,
          zoom,
          None,
          output,
          order,
          mode,
          cval,
          npad,
          grid_mode,
      )
      return output
  
file_path: scipy/scipy/ndimage/_interpolation.py
imports: import itertools
  import warnings
  import numpy
  from scipy._lib._util import normalize_axis_index
  from scipy import special
  from .None import _ni_support
  from .None import _nd_image
  from ._ni_docstrings import docfiller
label_desc: Use image node_id 8 for calling a global function with example usage: zoom(input, zoom, output, order, mode, cval, prefilter) and returns: output, output