code: def rolling_window(array, length, mutable=False):
      """
      Restride an array of shape
  
          (X_0, ... X_N)
  
      into an array of shape
  
          (length, X_0 - length + 1, ... X_N)
  
      where each slice at index i along the first axis is equivalent to
  
          result[i] = array[length * i:length * (i + 1)]
  
      Parameters
      ----------
      array : np.ndarray
          The base array.
      length : int
          Length of the synthetic first axis to generate.
      mutable : bool, optional
          Return a mutable array? The returned array shares the same memory as
          the input array. This means that writes into the returned array affect
          ``array``. The returned array also uses strides to map the same values
          to multiple indices. Writes to a single index may appear to change many
          values in the returned array.
  
      Returns
      -------
      out : np.ndarray
  
      Example
      -------
      >>> from numpy import arange
      >>> a = arange(25).reshape(5, 5)
      >>> a
      array([[ 0,  1,  2,  3,  4],
             [ 5,  6,  7,  8,  9],
             [10, 11, 12, 13, 14],
             [15, 16, 17, 18, 19],
             [20, 21, 22, 23, 24]])
  
      >>> rolling_window(a, 2)
      array([[[ 0,  1,  2,  3,  4],
              [ 5,  6,  7,  8,  9]],
      <BLANKLINE>
             [[ 5,  6,  7,  8,  9],
              [10, 11, 12, 13, 14]],
      <BLANKLINE>
             [[10, 11, 12, 13, 14],
              [15, 16, 17, 18, 19]],
      <BLANKLINE>
             [[15, 16, 17, 18, 19],
              [20, 21, 22, 23, 24]]])
      """
      if not length:
          raise ValueError("Can't have 0-length window")
  
      orig_shape = array.shape
      if not orig_shape:
          raise IndexError("Can't restride a scalar.")
      elif orig_shape[0] < length:
          raise IndexError(
              "Can't restride array of shape {shape} with"
              " a window length of {len}".format(
                  shape=orig_shape,
                  len=length,
              )
          )
  
      num_windows = orig_shape[0] - length + 1
      new_shape = (num_windows, length) + orig_shape[1:]
  
      new_strides = (array.strides[0],) + array.strides
  
      out = as_strided(array, new_shape, new_strides)
      out.setflags(write=mutable)
      return out
  
imports: from datetime import datetime
  from functools import wraps
  from os import makedirs, environ
  from os.path import expanduser, join, getmtime, isdir
  import errno
  import warnings
  import numpy
  from numpy.lib.stride_tricks import as_strided
  import pandas
  from pandas.tseries.offsets import BDay
  from .deprecate import deprecated
label_desc: Use image node_id 17 for calling a global function with example usage: rolling_window(array, length, mutable) and returns: out