numpy_pad.ipynb

{
 "metadata": {
  "name": "numpy_pad"
 },
 "nbformat": 3,
 "nbformat_minor": 0,
 "worksheets": [
  {
   "cells": [
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "\"\"\"\n",
      "The arraypad module contains a group of functions to pad values onto the edges\n",
      "of an n-dimensional array.\n",
      "\"\"\"\n",
      "\n",
      "import numpy as np\n",
      "\n",
      "__all__ = ['pad']\n",
      "\n",
      "\n",
      "################################################################################\n",
      "# Private utility functions.\n",
      "\n",
      "\n",
      "def _create_vector(vector, pad_tuple, before_val, after_val):\n",
      "    '''\n",
      "    Private function which creates the padded vector.\n",
      "\n",
      "    Parameters\n",
      "    ----------\n",
      "    vector : ndarray of rank 1, length N + pad_tuple[0] + pad_tuple[1]\n",
      "        Input vector including blank padded values.  `N` is the lenth of the\n",
      "        original vector.\n",
      "    pad_tuple : tuple\n",
      "        This tuple represents the (before, after) width of the padding along\n",
      "        this particular iaxis.\n",
      "    before_val : scalar or ndarray of rank 1, length pad_tuple[0]\n",
      "        This is the value(s) that will pad the beginning of `vector`.\n",
      "    after_val : scalar or ndarray of rank 1, length pad_tuple[1]\n",
      "        This is the value(s) that will pad the end of the `vector`.\n",
      "\n",
      "    Returns\n",
      "    -------\n",
      "    _create_vector : ndarray\n",
      "        Vector with before_val and after_val replacing the blank pad values.\n",
      "    '''\n",
      "    vector[:pad_tuple[0]] = before_val\n",
      "    if pad_tuple[1] > 0:\n",
      "        vector[-pad_tuple[1]:] = after_val\n",
      "    return vector\n",
      "\n",
      "\n",
      "def _normalize_shape(narray, shape):\n",
      "    '''\n",
      "    Private function which does some checks and normalizes the possibly\n",
      "    much simpler representations of 'pad_width', 'stat_length',\n",
      "    'constant_values', 'end_values'.\n",
      "\n",
      "    Parameters\n",
      "    ----------\n",
      "    narray : ndarray\n",
      "        Input ndarray\n",
      "    shape : {sequence, int}, optional\n",
      "        The width of padding (pad_width) or the number of elements on the\n",
      "        edge of the narray used for statistics (stat_length).\n",
      "        ((before_1, after_1), ... (before_N, after_N)) unique number of\n",
      "        elements for each axis where `N` is rank of `narray`.\n",
      "        ((before, after),) yields same before and after constants for each\n",
      "        axis.\n",
      "        (constant,) or int is a shortcut for before = after = constant for\n",
      "        all axes.\n",
      "\n",
      "    Returns\n",
      "    -------\n",
      "    _normalize_shape : tuple of tuples\n",
      "        int                               => ((int, int), (int, int), ...)\n",
      "        [[int1, int2], [int3, int4], ...] => ((int1, int2), (int3, int4), ...)\n",
      "        ((int1, int2), (int3, int4), ...) => no change\n",
      "        [[int1, int2], ]                  => ((int1, int2), (int1, int2), ...]\n",
      "        ((int1, int2), )                  => ((int1, int2), (int1, int2), ...)\n",
      "        [[int ,     ), )                  => ((int, int), (int, int), ...)\n",
      "        ((int ,     ), )                  => ((int, int), (int, int), ...)\n",
      "    '''\n",
      "    normshp = None\n",
      "    shapelen = len(np.shape(narray))\n",
      "    if (isinstance(shape, int)):\n",
      "        normshp = ((shape, shape), ) * shapelen\n",
      "    elif (isinstance(shape, (tuple, list))\n",
      "            and isinstance(shape[0], (tuple, list))\n",
      "            and len(shape) == shapelen):\n",
      "        normshp = shape\n",
      "        for i in normshp:\n",
      "            if len(i) != 2:\n",
      "                fmt = \"Unable to create correctly shaped tuple from %s\"\n",
      "                raise ValueError(fmt % (normshp,))\n",
      "    elif (isinstance(shape, (tuple, list))\n",
      "            and isinstance(shape[0], (int, float, long))\n",
      "            and len(shape) == 1):\n",
      "        normshp = ((shape[0], shape[0]), ) * shapelen\n",
      "    elif (isinstance(shape, (tuple, list))\n",
      "            and isinstance(shape[0], (int, float, long))\n",
      "            and len(shape) == 2):\n",
      "        normshp = (shape, ) * shapelen\n",
      "    if normshp == None:\n",
      "        fmt = \"Unable to create correctly shaped tuple from %s\"\n",
      "        raise ValueError(fmt % (shape,))\n",
      "    return normshp\n",
      "\n",
      "\n",
      "def _validate_lengths(narray, number_elements):\n",
      "    '''\n",
      "    Private function which does some checks and reformats pad_width and\n",
      "    stat_length using _normalize_shape.\n",
      "\n",
      "    Parameters\n",
      "    ----------\n",
      "    narray : ndarray\n",
      "        Input ndarray\n",
      "    number_elements : {sequence, int}, optional\n",
      "        The width of padding (pad_width) or the number of elements on the edge\n",
      "        of the narray used for statistics (stat_length).\n",
      "        ((before_1, after_1), ... (before_N, after_N)) unique number of\n",
      "        elements for each axis.\n",
      "        ((before, after),) yields same before and after constants for each\n",
      "        axis.\n",
      "        (constant,) or int is a shortcut for before = after = constant for all\n",
      "        axes.\n",
      "\n",
      "    Returns\n",
      "    -------\n",
      "    _validate_lengths : tuple of tuples\n",
      "        int                               => ((int, int), (int, int), ...)\n",
      "        [[int1, int2], [int3, int4], ...] => ((int1, int2), (int3, int4), ...)\n",
      "        ((int1, int2), (int3, int4), ...) => no change\n",
      "        [[int1, int2], ]                  => ((int1, int2), (int1, int2), ...]\n",
      "        ((int1, int2), )                  => ((int1, int2), (int1, int2), ...)\n",
      "        [[int ,     ), )                  => ((int, int), (int, int), ...)\n",
      "        ((int ,     ), )                  => ((int, int), (int, int), ...)\n",
      "    '''\n",
      "    shapelen = len(np.shape(narray))\n",
      "    normshp = _normalize_shape(narray, number_elements)\n",
      "    for i in normshp:\n",
      "        if i[0] < 0 or i[1] < 0:\n",
      "            fmt =\"%s cannot contain negative values.\"\n",
      "            raise ValueError(fmt % (number_elements,))\n",
      "    return normshp\n",
      "\n",
      "\n",
      "def _create_stat_vectors(vector, pad_tuple, iaxis, kwargs):\n",
      "    '''\n",
      "    Returns the portion of the vector required for any statistic.\n",
      "\n",
      "    Parameters\n",
      "    ----------\n",
      "    vector : ndarray\n",
      "        Input vector that already includes empty padded values.\n",
      "    pad_tuple : tuple\n",
      "        This tuple represents the (before, after) width of the padding\n",
      "        along this particular iaxis.\n",
      "    iaxis : int\n",
      "        The axis currently being looped across.\n",
      "    kwargs : keyword arguments\n",
      "        Keyword arguments.  Only 'stat_length' is used.  'stat_length'\n",
      "        defaults to the entire vector if not supplied.\n",
      "\n",
      "    Return\n",
      "    ------\n",
      "    _create_stat_vectors : ndarray\n",
      "        The values from the original vector that will be used to calculate\n",
      "        the statistic.\n",
      "    '''\n",
      "\n",
      "    # Can't have 0 represent the end if a slice... a[1:0] doesnt' work\n",
      "    pt1 = -pad_tuple[1]\n",
      "    if pt1 == 0:\n",
      "        pt1 = None\n",
      "\n",
      "    # Default is the entire vector from the original array.\n",
      "    sbvec = vector[pad_tuple[0]:pt1]\n",
      "    savec = vector[pad_tuple[0]:pt1]\n",
      "\n",
      "    if kwargs['stat_length']:\n",
      "        stat_length = kwargs['stat_length'][iaxis]\n",
      "        sl0 = min(stat_length[0], len(sbvec))\n",
      "        sl1 = min(stat_length[1], len(savec))\n",
      "        sbvec = np.arange(0)\n",
      "        savec = np.arange(0)\n",
      "        if pad_tuple[0] > 0:\n",
      "            sbvec = vector[pad_tuple[0]:pad_tuple[0] + sl0]\n",
      "        if pad_tuple[1] > 0:\n",
      "            savec = vector[-pad_tuple[1] - sl1:pt1]\n",
      "    return (sbvec, savec)\n",
      "\n",
      "\n",
      "def _maximum(vector, pad_tuple, iaxis, kwargs):\n",
      "    '''\n",
      "    Private function to calculate the before/after vectors for pad_maximum.\n",
      "\n",
      "    Parameters\n",
      "    ----------\n",
      "    vector : ndarray\n",
      "        Input vector that already includes empty padded values.\n",
      "    pad_tuple : tuple\n",
      "        This tuple represents the (before, after) width of the padding\n",
      "        along this particular iaxis.\n",
      "    iaxis : int\n",
      "        The axis currently being looped across.\n",
      "    kwargs : keyword arguments\n",
      "        Keyword arguments.  Only 'stat_length' is used.  'stat_length'\n",
      "        defaults to the entire vector if not supplied.\n",
      "\n",
      "    Return\n",
      "    ------\n",
      "    _maximum : ndarray\n",
      "        Padded vector\n",
      "    '''\n",
      "    sbvec, savec = _create_stat_vectors(vector, pad_tuple, iaxis, kwargs)\n",
      "    return _create_vector(vector, pad_tuple, max(sbvec), max(savec))\n",
      "\n",
      "\n",
      "def _minimum(vector, pad_tuple, iaxis, kwargs):\n",
      "    '''\n",
      "    Private function to calculate the before/after vectors for pad_minimum.\n",
      "\n",
      "    Parameters\n",
      "    ----------\n",
      "    vector : ndarray\n",
      "        Input vector that already includes empty padded values.\n",
      "    pad_tuple : tuple\n",
      "        This tuple represents the (before, after) width of the padding\n",
      "        along this particular iaxis.\n",
      "    iaxis : int\n",
      "        The axis currently being looped across.\n",
      "    kwargs : keyword arguments\n",
      "        Keyword arguments.  Only 'stat_length' is used.  'stat_length'\n",
      "        defaults to the entire vector if not supplied.\n",
      "\n",
      "    Return\n",
      "    ------\n",
      "    _minimum : ndarray\n",
      "        Padded vector\n",
      "    '''\n",
      "    sbvec, savec = _create_stat_vectors(vector, pad_tuple, iaxis, kwargs)\n",
      "    return _create_vector(vector, pad_tuple, min(sbvec), min(savec))\n",
      "\n",
      "\n",
      "def _median(vector, pad_tuple, iaxis, kwargs):\n",
      "    '''\n",
      "    Private function to calculate the before/after vectors for pad_median.\n",
      "\n",
      "    Parameters\n",
      "    ----------\n",
      "    vector : ndarray\n",
      "        Input vector that already includes empty padded values.\n",
      "    pad_tuple : tuple\n",
      "        This tuple represents the (before, after) width of the padding\n",
      "        along this particular iaxis.\n",
      "    iaxis : int\n",
      "        The axis currently being looped across.\n",
      "    kwargs : keyword arguments\n",
      "        Keyword arguments.  Only 'stat_length' is used.  'stat_length'\n",
      "        defaults to the entire vector if not supplied.\n",
      "\n",
      "    Return\n",
      "    ------\n",
      "    _median : ndarray\n",
      "        Padded vector\n",
      "    '''\n",
      "    sbvec, savec = _create_stat_vectors(vector, pad_tuple, iaxis, kwargs)\n",
      "    return _create_vector(vector, pad_tuple, np.median(sbvec),\n",
      "                          np.median(savec))\n",
      "\n",
      "\n",
      "def _mean(vector, pad_tuple, iaxis, kwargs):\n",
      "    '''\n",
      "    Private function to calculate the before/after vectors for pad_mean.\n",
      "\n",
      "    Parameters\n",
      "    ----------\n",
      "    vector : ndarray\n",
      "        Input vector that already includes empty padded values.\n",
      "    pad_tuple : tuple\n",
      "        This tuple represents the (before, after) width of the padding\n",
      "        along this particular iaxis.\n",
      "    iaxis : int\n",
      "        The axis currently being looped across.\n",
      "    kwargs : keyword arguments\n",
      "        Keyword arguments.  Only 'stat_length' is used.  'stat_length'\n",
      "        defaults to the entire vector if not supplied.\n",
      "\n",
      "    Return\n",
      "    ------\n",
      "    _mean : ndarray\n",
      "        Padded vector\n",
      "    '''\n",
      "    sbvec, savec = _create_stat_vectors(vector, pad_tuple, iaxis, kwargs)\n",
      "    return _create_vector(vector, pad_tuple, np.average(sbvec),\n",
      "                          np.average(savec))\n",
      "\n",
      "\n",
      "def _constant(vector, pad_tuple, iaxis, kwargs):\n",
      "    '''\n",
      "    Private function to calculate the before/after vectors for\n",
      "    pad_constant.\n",
      "\n",
      "    Parameters\n",
      "    ----------\n",
      "    vector : ndarray\n",
      "        Input vector that already includes empty padded values.\n",
      "    pad_tuple : tuple\n",
      "        This tuple represents the (before, after) width of the padding\n",
      "        along this particular iaxis.\n",
      "    iaxis : int\n",
      "        The axis currently being looped across.\n",
      "    kwargs : keyword arguments\n",
      "        Keyword arguments.  Need 'constant_values' keyword argument.\n",
      "\n",
      "    Return\n",
      "    ------\n",
      "    _constant : ndarray\n",
      "        Padded vector\n",
      "    '''\n",
      "    nconstant = kwargs['constant_values'][iaxis]\n",
      "    return _create_vector(vector, pad_tuple, nconstant[0], nconstant[1])\n",
      "\n",
      "\n",
      "def _linear_ramp(vector, pad_tuple, iaxis, kwargs):\n",
      "    '''\n",
      "    Private function to calculate the before/after vectors for\n",
      "    pad_linear_ramp.\n",
      "\n",
      "    Parameters\n",
      "    ----------\n",
      "    vector : ndarray\n",
      "        Input vector that already includes empty padded values.\n",
      "    pad_tuple : tuple\n",
      "        This tuple represents the (before, after) width of the padding\n",
      "        along this particular iaxis.\n",
      "    iaxis : int\n",
      "        The axis currently being looped across.  Not used in _linear_ramp.\n",
      "    kwargs : keyword arguments\n",
      "        Keyword arguments. Not used in _linear_ramp.\n",
      "\n",
      "    Return\n",
      "    ------\n",
      "    _linear_ramp : ndarray\n",
      "        Padded vector\n",
      "    '''\n",
      "    end_values = kwargs['end_values'][iaxis]\n",
      "    before_delta = ((vector[pad_tuple[0]] - end_values[0])\n",
      "                    / float(pad_tuple[0]))\n",
      "    after_delta = ((vector[-pad_tuple[1] - 1] - end_values[1])\n",
      "                   / float(pad_tuple[1]))\n",
      "\n",
      "    before_vector = np.ones((pad_tuple[0], )) * end_values[0]\n",
      "    before_vector = before_vector.astype(vector.dtype)\n",
      "    for i in range(len(before_vector)):\n",
      "        before_vector[i] = before_vector[i] + i * before_delta\n",
      "\n",
      "    after_vector = np.ones((pad_tuple[1], )) * end_values[1]\n",
      "    after_vector = after_vector.astype(vector.dtype)\n",
      "    for i in range(len(after_vector)):\n",
      "        after_vector[i] = after_vector[i] + i * after_delta\n",
      "    after_vector = after_vector[::-1]\n",
      "\n",
      "    return _create_vector(vector, pad_tuple, before_vector, after_vector)\n",
      "\n",
      "\n",
      "def _reflect(vector, pad_tuple, iaxis, kwargs):\n",
      "    '''\n",
      "    Private function to calculate the before/after vectors for pad_reflect.\n",
      "\n",
      "    Parameters\n",
      "    ----------\n",
      "    vector : ndarray\n",
      "        Input vector that already includes empty padded values.\n",
      "    pad_tuple : tuple\n",
      "        This tuple represents the (before, after) width of the padding\n",
      "        along this particular iaxis.\n",
      "    iaxis : int\n",
      "        The axis currently being looped across.  Not used in _reflect.\n",
      "    kwargs : keyword arguments\n",
      "        Keyword arguments. Not used in _reflect.\n",
      "\n",
      "    Return\n",
      "    ------\n",
      "    _reflect : ndarray\n",
      "        Padded vector\n",
      "    '''\n",
      "    # Can't have pad_tuple[1] be used in the slice if == to 0.\n",
      "    if pad_tuple[1] == 0:\n",
      "        after_vector = vector[pad_tuple[0]:None]\n",
      "    else:\n",
      "        after_vector = vector[pad_tuple[0]:-pad_tuple[1]]\n",
      "\n",
      "    reverse = after_vector[::-1]\n",
      "\n",
      "    before_vector = np.resize(\n",
      "                        np.concatenate(\n",
      "                        (after_vector[1:-1], reverse)), pad_tuple[0])[::-1]\n",
      "    after_vector = np.resize(\n",
      "                       np.concatenate(\n",
      "                       (reverse[1:-1], after_vector)), pad_tuple[1])\n",
      "\n",
      "    if kwargs['reflect_type'] == 'even':\n",
      "        pass\n",
      "    elif kwargs['reflect_type'] == 'odd':\n",
      "        before_vector = 2 * vector[pad_tuple[0]] - before_vector\n",
      "        after_vector = 2 * vector[-pad_tuple[-1] - 1] - after_vector\n",
      "    else:\n",
      "        raise ValueError(\"The keyword '%s' cannot have the value '%s'.\"\n",
      "                          % ('reflect_type', kwargs['reflect_type']))\n",
      "    return _create_vector(vector, pad_tuple, before_vector, after_vector)\n",
      "\n",
      "\n",
      "def _symmetric(vector, pad_tuple, iaxis, kwargs):\n",
      "    '''\n",
      "    Private function to calculate the before/after vectors for\n",
      "    pad_symmetric.\n",
      "\n",
      "    Parameters\n",
      "    ----------\n",
      "    vector : ndarray\n",
      "        Input vector that already includes empty padded values.\n",
      "    pad_tuple : tuple\n",
      "        This tuple represents the (before, after) width of the padding\n",
      "        along this particular iaxis.\n",
      "    iaxis : int\n",
      "        The axis currently being looped across.  Not used in _symmetric.\n",
      "    kwargs : keyword arguments\n",
      "        Keyword arguments. Not used in _symmetric.\n",
      "\n",
      "    Return\n",
      "    ------\n",
      "    _symmetric : ndarray\n",
      "        Padded vector\n",
      "    '''\n",
      "    if pad_tuple[1] == 0:\n",
      "        after_vector = vector[pad_tuple[0]:None]\n",
      "    else:\n",
      "        after_vector = vector[pad_tuple[0]:-pad_tuple[1]]\n",
      "\n",
      "    before_vector = np.resize( np.concatenate( (after_vector,\n",
      "        after_vector[::-1])), pad_tuple[0])[::-1]\n",
      "    after_vector = np.resize( np.concatenate( (after_vector[::-1],\n",
      "        after_vector)), pad_tuple[1])\n",
      "\n",
      "    if kwargs['reflect_type'] == 'even':\n",
      "        pass\n",
      "    elif kwargs['reflect_type'] == 'odd':\n",
      "        before_vector = 2 * vector[pad_tuple[0]] - before_vector\n",
      "        after_vector = 2 * vector[-pad_tuple[1] - 1] - after_vector\n",
      "    else:\n",
      "        raise ValueError(\"The keyword '%s' cannot have the value '%s'.\"\n",
      "                          % ('reflect_type', kwargs['reflect_type']))\n",
      "    return _create_vector(vector, pad_tuple, before_vector, after_vector)\n",
      "\n",
      "\n",
      "def _wrap(vector, pad_tuple, iaxis, kwargs):\n",
      "    '''\n",
      "    Private function to calculate the before/after vectors for pad_wrap.\n",
      "\n",
      "    Parameters\n",
      "    ----------\n",
      "    vector : ndarray\n",
      "        Input vector that already includes empty padded values.\n",
      "    pad_tuple : tuple\n",
      "        This tuple represents the (before, after) width of the padding\n",
      "        along this particular iaxis.\n",
      "    iaxis : int\n",
      "        The axis currently being looped across.  Not used in _wrap.\n",
      "    kwargs : keyword arguments\n",
      "        Keyword arguments. Not used in _wrap.\n",
      "\n",
      "    Return\n",
      "    ------\n",
      "    _wrap : ndarray\n",
      "        Padded vector\n",
      "    '''\n",
      "    if pad_tuple[1] == 0:\n",
      "        after_vector = vector[pad_tuple[0]:None]\n",
      "    else:\n",
      "        after_vector = vector[pad_tuple[0]:-pad_tuple[1]]\n",
      "\n",
      "    before_vector = np.resize(after_vector[::-1], pad_tuple[0])[::-1]\n",
      "    after_vector = np.resize(after_vector, pad_tuple[1])\n",
      "\n",
      "    return _create_vector(vector, pad_tuple, before_vector, after_vector)\n",
      "\n",
      "\n",
      "def _edge(vector, pad_tuple, iaxis, kwargs):\n",
      "    '''\n",
      "    Private function to calculate the before/after vectors for pad_edge.\n",
      "\n",
      "    Parameters\n",
      "    ----------\n",
      "    vector : ndarray\n",
      "        Input vector that already includes empty padded values.\n",
      "    pad_tuple : tuple\n",
      "        This tuple represents the (before, after) width of the padding\n",
      "        along this particular iaxis.\n",
      "    iaxis : int\n",
      "        The axis currently being looped across.  Not used in _edge.\n",
      "    kwargs : keyword arguments\n",
      "        Keyword arguments. Not used in _edge.\n",
      "\n",
      "    Return\n",
      "    ------\n",
      "    _edge : ndarray\n",
      "        Padded vector\n",
      "    '''\n",
      "    return _create_vector(vector, pad_tuple, vector[pad_tuple[0]],\n",
      "                          vector[-pad_tuple[1] - 1])\n",
      "\n",
      "\n",
      "################################################################################\n",
      "# Public functions\n",
      "\n",
      "\n",
      "def pad(array, pad_width, mode=None, **kwargs):\n",
      "    \"\"\"\n",
      "    Pads an array.\n",
      "\n",
      "    Parameters\n",
      "    ----------\n",
      "    array : array_like of rank N\n",
      "        Input array\n",
      "    pad_width : {sequence, int}\n",
      "        Number of values padded to the edges of each axis.\n",
      "        ((before_1, after_1), ... (before_N, after_N)) unique pad widths\n",
      "        for each axis.\n",
      "        ((before, after),) yields same before and after pad for each axis.\n",
      "        (pad,) or int is a shortcut for before = after = pad width for all\n",
      "        axes.\n",
      "    mode : {str, function}\n",
      "        One of the following string values or a user supplied function.\n",
      "\n",
      "        'constant'      Pads with a constant value.\n",
      "        'edge'          Pads with the edge values of array.\n",
      "        'linear_ramp'   Pads with the linear ramp between end_value and the\n",
      "                        array edge value.\n",
      "        'maximum'       Pads with the maximum value of all or part of the\n",
      "                        vector along each axis.\n",
      "        'mean'          Pads with the mean value of all or part of the\n",
      "                        vector along each axis.\n",
      "        'median'        Pads with the median value of all or part of the\n",
      "                        vector along each axis.\n",
      "        'minimum'       Pads with the minimum value of all or part of the\n",
      "                        vector along each axis.\n",
      "        'reflect'       Pads with the reflection of the vector mirrored on\n",
      "                        the first and last values of the vector along each\n",
      "                        axis.\n",
      "        'symmetric'     Pads with the reflection of the vector mirrored\n",
      "                        along the edge of the array.\n",
      "        'wrap'          Pads with the wrap of the vector along the axis.\n",
      "                        The first values are used to pad the end and the\n",
      "                        end values are used to pad the beginning.\n",
      "        <function>      Padding function, see Notes.\n",
      "    stat_length : {sequence, int}, optional\n",
      "        Used in 'maximum', 'mean', 'median', and 'minimum'.  Number of\n",
      "        values at edge of each axis used to calculate the statistic value.\n",
      "\n",
      "        ((before_1, after_1), ... (before_N, after_N)) unique statistic\n",
      "        lengths for each axis.\n",
      "\n",
      "        ((before, after),) yields same before and after statistic lengths\n",
      "        for each axis.\n",
      "\n",
      "        (stat_length,) or int is a shortcut for before = after = statistic\n",
      "        length for all axes.\n",
      "\n",
      "        Default is ``None``, to use the entire axis.\n",
      "    constant_values : {sequence, int}, optional\n",
      "        Used in 'constant'.  The values to set the padded values for each\n",
      "        axis.\n",
      "\n",
      "        ((before_1, after_1), ... (before_N, after_N)) unique pad constants\n",
      "        for each axis.\n",
      "\n",
      "        ((before, after),) yields same before and after constants for each\n",
      "        axis.\n",
      "\n",
      "        (constant,) or int is a shortcut for before = after = constant for\n",
      "        all axes.\n",
      "\n",
      "        Default is 0.\n",
      "    end_values : {sequence, int}, optional\n",
      "        Used in 'linear_ramp'.  The values used for the ending value of the\n",
      "        linear_ramp and that will form the edge of the padded array.\n",
      "\n",
      "        ((before_1, after_1), ... (before_N, after_N)) unique end values\n",
      "        for each axis.\n",
      "\n",
      "        ((before, after),) yields same before and after end values for each\n",
      "        axis.\n",
      "\n",
      "        (constant,) or int is a shortcut for before = after = end value for\n",
      "        all axes.\n",
      "\n",
      "        Default is 0.\n",
      "    reflect_type : str {'even', 'odd'}, optional\n",
      "        Used in 'reflect', and 'symmetric'.  The 'even' style is the\n",
      "        default with an unaltered reflection around the edge value.  For\n",
      "        the 'odd' style, the extented part of the array is created by\n",
      "        subtracting the reflected values from two times the edge value.\n",
      "\n",
      "    Returns\n",
      "    -------\n",
      "    pad : ndarray\n",
      "        Padded array of rank equal to `array` with shape increased\n",
      "        according to `pad_width`.\n",
      "\n",
      "    Notes\n",
      "    -----\n",
      "    .. versionadded:: 1.7.0\n",
      "\n",
      "    For an array with rank greater than 1, some of the padding of later\n",
      "    axes is calculated from padding of previous axes.  This is easiest to\n",
      "    think about with a rank 2 array where the corners of the padded array\n",
      "    are calculated by using padded values from the first axis.\n",
      "\n",
      "    The padding function, if used, should return a rank 1 array equal in\n",
      "    length to the vector argument with padded values replaced. It has the\n",
      "    following signature:\n",
      "\n",
      "        padding_func(vector, iaxis_pad_width, iaxis, **kwargs)\n",
      "\n",
      "    where\n",
      "\n",
      "        vector: ndarray\n",
      "            A rank 1 array already padded with zeros.  Padded values are\n",
      "            vector[:pad_tuple[0]] and vector[-pad_tuple[1]:].\n",
      "        iaxis_pad_width: tuple\n",
      "            A 2-tuple of ints, iaxis_pad_width[0] represents the number of\n",
      "            values padded at the beginning of vector where\n",
      "            iaxis_pad_width[1] represents the number of values padded at\n",
      "            the end of vector.\n",
      "        iaxis : int\n",
      "            The axis currently being calculated.\n",
      "        kwargs : misc\n",
      "            Any keyword arguments the function requires.\n",
      "\n",
      "    Examples\n",
      "    --------\n",
      "    >>> a = [1, 2, 3, 4, 5]\n",
      "    >>> np.lib.pad(a, (2,3), 'constant', constant_values=(4,6))\n",
      "    array([4, 4, 1, 2, 3, 4, 5, 6, 6, 6])\n",
      "\n",
      "    >>> np.lib.pad(a, (2,3), 'edge')\n",
      "    array([1, 1, 1, 2, 3, 4, 5, 5, 5, 5])\n",
      "\n",
      "    >>> np.lib.pad(a, (2,3), 'linear_ramp', end_values=(5,-4))\n",
      "    array([ 5,  3,  1,  2,  3,  4,  5,  2, -1, -4])\n",
      "\n",
      "    >>> np.lib.pad(a, (2,), 'maximum')\n",
      "    array([5, 5, 1, 2, 3, 4, 5, 5, 5])\n",
      "\n",
      "    >>> np.lib.pad(a, (2,), 'mean')\n",
      "    array([3, 3, 1, 2, 3, 4, 5, 3, 3])\n",
      "\n",
      "    >>> np.lib.pad(a, (2,), 'median')\n",
      "    array([3, 3, 1, 2, 3, 4, 5, 3, 3])\n",
      "\n",
      "    >>> a = [[1,2], [3,4]]\n",
      "    >>> np.lib.pad(a, ((3, 2), (2, 3)), 'minimum')\n",
      "    array([[1, 1, 1, 2, 1, 1, 1],\n",
      "           [1, 1, 1, 2, 1, 1, 1],\n",
      "           [1, 1, 1, 2, 1, 1, 1],\n",
      "           [1, 1, 1, 2, 1, 1, 1],\n",
      "           [3, 3, 3, 4, 3, 3, 3],\n",
      "           [1, 1, 1, 2, 1, 1, 1],\n",
      "           [1, 1, 1, 2, 1, 1, 1]])\n",
      "\n",
      "    >>> a = [1, 2, 3, 4, 5]\n",
      "    >>> np.lib.pad(a, (2,3), 'reflect')\n",
      "    array([3, 2, 1, 2, 3, 4, 5, 4, 3, 2])\n",
      "\n",
      "    >>> np.lib.pad(a, (2,3), 'reflect', reflect_type='odd')\n",
      "    array([-1,  0,  1,  2,  3,  4,  5,  6,  7,  8])\n",
      "\n",
      "    >>> np.lib.pad(a, (2,3), 'symmetric')\n",
      "    array([2, 1, 1, 2, 3, 4, 5, 5, 4, 3])\n",
      "\n",
      "    >>> np.lib.pad(a, (2,3), 'symmetric', reflect_type='odd')\n",
      "    array([0, 1, 1, 2, 3, 4, 5, 5, 6, 7])\n",
      "\n",
      "    >>> np.lib.pad(a, (2,3), 'wrap')\n",
      "    array([4, 5, 1, 2, 3, 4, 5, 1, 2, 3])\n",
      "\n",
      "    >>> def padwithtens(vector, pad_width, iaxis, kwargs):\n",
      "    ...     vector[:pad_width[0]] = 10\n",
      "    ...     vector[-pad_width[1]:] = 10\n",
      "    ...     return vector\n",
      "\n",
      "    >>> a = np.arange(6)\n",
      "    >>> a = a.reshape((2,3))\n",
      "\n",
      "    >>> np.lib.pad(a, 2, padwithtens)\n",
      "    array([[10, 10, 10, 10, 10, 10, 10],\n",
      "           [10, 10, 10, 10, 10, 10, 10],\n",
      "           [10, 10,  0,  1,  2, 10, 10],\n",
      "           [10, 10,  3,  4,  5, 10, 10],\n",
      "           [10, 10, 10, 10, 10, 10, 10],\n",
      "           [10, 10, 10, 10, 10, 10, 10]])\n",
      "    \"\"\"\n",
      "\n",
      "\n",
      "    narray = np.array(array)\n",
      "    pad_width = _validate_lengths(narray, pad_width)\n",
      "\n",
      "    modefunc = {\n",
      "           'constant': _constant,\n",
      "           'edge': _edge,\n",
      "           'linear_ramp': _linear_ramp,\n",
      "           'maximum': _maximum,\n",
      "           'mean': _mean,\n",
      "           'median': _median,\n",
      "           'minimum': _minimum,\n",
      "           'reflect': _reflect,\n",
      "           'symmetric': _symmetric,\n",
      "           'wrap': _wrap,\n",
      "           }\n",
      "\n",
      "    allowedkwargs = {\n",
      "           'constant': ['constant_values'],\n",
      "           'edge': [],\n",
      "           'linear_ramp': ['end_values'],\n",
      "           'maximum': ['stat_length'],\n",
      "           'mean': ['stat_length'],\n",
      "           'median': ['stat_length'],\n",
      "           'minimum': ['stat_length'],\n",
      "           'reflect': ['reflect_type'],\n",
      "           'symmetric': ['reflect_type'],\n",
      "           'wrap': [],\n",
      "            }\n",
      "\n",
      "    kwdefaults = {\n",
      "            'stat_length': None,\n",
      "            'constant_values': 0,\n",
      "            'end_values': 0,\n",
      "            'reflect_type': 'even',\n",
      "            }\n",
      "\n",
      "    if isinstance(mode, str):\n",
      "        function = modefunc[mode]\n",
      "\n",
      "        # Make sure have allowed kwargs appropriate for mode\n",
      "        for key in kwargs:\n",
      "            if key not in allowedkwargs[mode]:\n",
      "                raise ValueError('%s keyword not in allowed keywords %s' %\n",
      "                                  (key, allowedkwargs[mode]))\n",
      "\n",
      "        # Set kwarg defaults\n",
      "        for kw in allowedkwargs[mode]:\n",
      "            kwargs.setdefault(kw, kwdefaults[kw])\n",
      "\n",
      "        # Need to only normalize particular keywords.\n",
      "        for i in kwargs:\n",
      "            if i == 'stat_length' and kwargs[i]:\n",
      "                kwargs[i] = _validate_lengths(narray, kwargs[i])\n",
      "            if i in ['end_values', 'constant_values']:\n",
      "                kwargs[i] = _normalize_shape(narray, kwargs[i])\n",
      "    elif mode == None:\n",
      "        raise ValueError('Keyword \"mode\" must be a function or one of %s.' %\n",
      "                          (modefunc.keys(),))\n",
      "    else:\n",
      "        # User supplied function, I hope\n",
      "        function = mode\n",
      "\n",
      "    # Create a new padded array\n",
      "    rank = range(len(narray.shape))\n",
      "    total_dim_increase = [np.sum(pad_width[i]) for i in rank]\n",
      "    offset_slices = [slice(pad_width[i][0],\n",
      "                           pad_width[i][0] + narray.shape[i])\n",
      "                     for i in rank]\n",
      "    new_shape = np.array(narray.shape) + total_dim_increase\n",
      "    newmat = np.zeros(new_shape).astype(narray.dtype)\n",
      "\n",
      "    # Insert the original array into the padded array\n",
      "    newmat[offset_slices] = narray\n",
      "\n",
      "    # This is the core of pad ...\n",
      "    for iaxis in rank:\n",
      "        np.apply_along_axis(function,\n",
      "                            iaxis,\n",
      "                            newmat,\n",
      "                            pad_width[iaxis],\n",
      "                            iaxis,\n",
      "                            kwargs)\n",
      "    return newmat\n"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    }
   ],
   "metadata": {}
  }
 ]
}