code: def diff(arr, n, axis=0):
      """
      difference of n between self,
      analogous to s-s.shift(n)
  
      Parameters
      ----------
      arr : ndarray
      n : int
          number of periods
      axis : int
          axis to shift on
  
      Returns
      -------
      shifted
  
      """
  
      n = int(n)
      na = np.nan
      dtype = arr.dtype
  
      is_timedelta = False
      if needs_i8_conversion(arr):
          dtype = np.float64
          arr = arr.view("i8")
          na = iNaT
          is_timedelta = True
  
      elif is_bool_dtype(dtype):
          dtype = np.object_
  
      elif is_integer_dtype(dtype):
          dtype = np.float64
  
      dtype = np.dtype(dtype)
      out_arr = np.empty(arr.shape, dtype=dtype)
  
      na_indexer = [slice(None)] * arr.ndim
      na_indexer[axis] = slice(None, n) if n >= 0 else slice(n, None)
      out_arr[tuple(na_indexer)] = na
  
      if arr.ndim == 2 and arr.dtype.name in _diff_special:
          f = _diff_special[arr.dtype.name]
          f(arr, out_arr, n, axis)
      else:
          res_indexer = [slice(None)] * arr.ndim
          res_indexer[axis] = (
              slice(n, None) if n >= 0 else slice(None, n)
          )
          res_indexer = tuple(res_indexer)
  
          lag_indexer = [slice(None)] * arr.ndim
          lag_indexer[axis] = (
              slice(None, -n) if n > 0 else slice(-n, None)
          )
          lag_indexer = tuple(lag_indexer)
  
          # need to make sure that we account for na for datelike/timedelta
          # we don't actually want to subtract these i8 numbers
          if is_timedelta:
              res = arr[res_indexer]
              lag = arr[lag_indexer]
  
              mask = (arr[res_indexer] == na) | (arr[lag_indexer] == na)
              if mask.any():
                  res = res.copy()
                  res[mask] = 0
                  lag = lag.copy()
                  lag[mask] = 0
  
              result = res - lag
              result[mask] = na
              out_arr[res_indexer] = result
          else:
              out_arr[res_indexer] = arr[res_indexer] - arr[lag_indexer]
  
      if is_timedelta:
          from pandas import TimedeltaIndex
  
          out_arr = (
              TimedeltaIndex(out_arr.ravel().astype("int64"))
              .asi8.reshape(out_arr.shape)
              .astype("timedelta64[ns]")
          )
  
      return out_arr
  
imports: from __future__ import division
  from textwrap import dedent
  from warnings import catch_warnings, simplefilter, warn
  import numpy
  from pandas._libs import algos, hashtable, lib
  from pandas._libs.tslib import iNaT
  from pandas.util._decorators import Appender, Substitution, deprecate_kwarg
  from pandas.core.dtypes.cast import construct_1d_object_array_from_listlike, maybe_promote
  from pandas.core.dtypes.common import ensure_float64, ensure_int64, ensure_object, ensure_platform_int, ensure_uint64, is_array_like, is_bool_dtype, is_categorical_dtype, is_complex_dtype, is_datetime64_any_dtype, is_datetime64tz_dtype, is_datetimelike, is_extension_array_dtype, is_float_dtype, is_integer_dtype, is_interval_dtype, is_list_like, is_numeric_dtype, is_object_dtype, is_period_dtype, is_scalar, is_signed_integer_dtype, is_sparse, is_timedelta64_dtype, is_unsigned_integer_dtype, needs_i8_conversion
  from pandas.core.dtypes.generic import ABCIndex, ABCIndexClass, ABCSeries
  from pandas.core.dtypes.missing import isna, na_value_for_dtype
  from pandas.core import common
label_desc: Use image node_id 26 for calling a global function with example usage: diff(arr, n, axis) and returns: out_arr