.. _l-onnx-op-slice-d11-13:

Slice - 11 vs 13
================

Next section compares an older to a newer version of the same operator 
after both definition are converted into markdown text.
Green means an addition to the newer version, red means a deletion.
Anything else is unchanged.

.. raw:: html


    <div id="div_Slice_2"></div>
    <link rel="stylesheet" type="text/css" href="../_static/diff2html.min.css" />
    <script type="text/javascript" src="../_static/diff2html-ui-slim.min.js"></script>
    <script>
    const diffString = `
    --- a/Slice11
    +++ b/Slice13
    @@ -1 +1 @@
      Produces a slice of the input tensor along multiple axes. Similar to numpy:
    - https://numpy.org/doc/stable/reference/routines.indexing.html
    + https://numpy.org/doc/stable/user/basics.indexing.html?highlight=slice#slicing-and-striding
    + 
    - Slices uses starts, ends, axes and steps inputs to specify the start and end
    ?      -                                              ^  ------------   --   ^
    + Slice uses the starts, ends, axes and steps inputs to select a sub-tensor
    ?           ++++                                         ^^      +++++  ^^^
    + of its input data tensor.
    + 
    + An effective starts[i], ends[i], and steps[i] must be computed for each i
    + in [0, ... r-1] where r = rank(input) as follows:
    + 
    - dimension and step for each axis in the list of axes, it uses this information to
    - slice the input data tensor. If a negative value is passed for any of the
    - start or end indices, it represents number of elements before the end of that
    - dimension. If the value passed to start or end is larger than the n (the
    - number of elements in this dimension), it represents n. For slicing to the
    - end of a dimension with unknown size, it is recommended to pass in INT_MAX
    - when slicing forward and 'INT_MIN' when slicing backward.
    - If a negative value is passed for step, it represents slicing backward.
    - However step value cannot be 0.
    - If axes are omitted, they are set to [0, ..., ndim-1].
    ?                                               ^^^^
    + If axes are omitted, they are set to [0, ..., r-1].
    ?                                               ^
      If steps are omitted, they are set to [1, ..., 1] of length len(starts)
    + 
    + The effective values are initialized as start[i] = 0, ends[i] = dims[i] where
    + dims are the dimensions of input and steps[i] = 1.
    + 
    + All negative elements of axes are made non-negative by adding r to them, where
    + r =rank(input).
    + 
    + All negative values in starts[i] and ends[i] have dims[axes[i]] added to them,
    + where dims are the dimensions of input. Then start[axes[i]] is the adjusted
    + starts[i] is clamped into the range [0, dims[axes[i]]] for positive stepping
    + and [0, dims[axes[i]]-1] for negative stepping.
    + 
    + The clamping for the adjusted ends[i] depends on the sign of steps[i] and must
    + accommodate copying 0 through dims[axes[i]] elements, so for positive stepping
    + ends[axes[i]] is clamped to [0, dims[axes[i]]], while for negative stepping it
    + is clamped to [-1, dims[axes[i]]-1].
    + 
    + Finally, steps[axes[i]] = steps[i].
    + 
    + For slicing to the end of a dimension with unknown size, it is recommended to pass
    + in INT_MAX when slicing forward and 'INT_MIN' when slicing backward.
    + 
      Example 1:
    + 
    + 
    -   data = [
    ? --
    + data = [
    -       [1, 2, 3, 4],
    ? --
    +     [1, 2, 3, 4],
    -       [5, 6, 7, 8],
    ? --
    +     [5, 6, 7, 8],
    -   ]
    + ]
    -   axes = [0, 1]
    ? --
    + axes = [0, 1]
    -   starts = [1, 0]
    ? --
    + starts = [1, 0]
    -   ends = [2, 3]
    ? --
    + ends = [2, 3]
    -   steps = [1, 2]
    ? --
    + steps = [1, 2]
    -   result = [
    ? --
    + result = [
    -       [5, 7],
    ? --
    +     [5, 7],
    -   ]
    + ]
    + 
    + 
      Example 2:
    + 
    + 
    -   data = [
    ? --
    + data = [
    -       [1, 2, 3, 4],
    ? --
    +     [1, 2, 3, 4],
    -       [5, 6, 7, 8],
    ? --
    +     [5, 6, 7, 8],
    -   ]
    + ]
    -   starts = [0, 1]
    ? --
    + starts = [0, 1]
    -   ends = [-1, 1000]
    ? --
    + ends = [-1, 1000]
    -   result = [
    ? --
    + result = [
    -       [2, 3, 4],
    ? --
    +     [2, 3, 4],
    -   ]
    + ]
    + 
  
      ### Inputs
  
      Between 3 and 5 inputs.
  
      - **data** (heterogeneous) - **T**:
  
        Tensor of data to extract slices from.
      - **starts** (heterogeneous) - **Tind**:
  
        1-D tensor of starting indices of corresponding axis in axes
      - **ends** (heterogeneous) - **Tind**:
  
        1-D tensor of ending indices (exclusive) of corresponding axis in axes
      - **axes** (optional, heterogeneous) - **Tind**:
  
    -   1-D tensor of axes that starts and ends apply to. Negative value means counting dimensions from the back. Accepted range is [-r, r-1] where r = rank(data).
    +   1-D tensor of axes that starts and ends apply to. Negative value means counting dimensions from the back. Accepted range is [-r, r-1] where r = rank(data). Behavior is undefined if an axis is repeated.
    ?                                                                                                                                                              ++++++++++++++++++++++++++++++++++++++++++++++
      - **steps** (optional, heterogeneous) - **Tind**:
  
    -   1-D tensor of slice step of corresponding axis in axes. Negative value means slicing backward. 'steps' cannot be 0. Defaults to 1.
    +   1-D tensor of slice step of corresponding axis in axes. Negative value means slicing backward. 'steps' cannot be 0. Defaults to 1s.
    ?                                                                                                                                    +
  
      ### Outputs
  
      - **output** (heterogeneous) - **T**:
  
        Sliced data tensor.
  
      ### Type Constraints
  
    - * **T** in ( tensor(bool), tensor(complex128), tensor(complex64), tensor(double), tensor(float), tensor(float16), tensor(int16), tensor(int32), tensor(int64), tensor(int8), tensor(string), tensor(uint16), tensor(uint32), tensor(uint64), tensor(uint8) ):
    + * **T** in ( tensor(bfloat16), tensor(bool), tensor(complex128), tensor(complex64), tensor(double), tensor(float), tensor(float16), tensor(int16), tensor(int32), tensor(int64), tensor(int8), tensor(string), tensor(uint16), tensor(uint32), tensor(uint64), tensor(uint8) ):
    ?             ++++++++++++++++++
  
        Constrain input and output types to all tensor types.
      * **Tind** in ( tensor(int32), tensor(int64) ):
  
        Constrain indices to integer types
    `;

    document.addEventListener('DOMContentLoaded', function () {
    var targetElement = document.getElementById('div_Slice_2');
    var configuration = {
        drawFileList: true,
        fileListToggle: false,
        fileListStartVisible: false,
        fileContentToggle: false,
        matching: 'lines',
        outputFormat: 'line-by-line',
        synchronisedScroll: true,
        highlight: true,
        renderNothingWhenEmpty: false,
    };
    var diff2htmlUi = new Diff2HtmlUI(targetElement, diffString, configuration);
    diff2htmlUi.draw();
    diff2htmlUi.highlightCode();
    });
    </script>