.. _l-onnx-op-gather-d1-13:

Gather - 1 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_Gather_3"></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/Gather1
    +++ b/Gather13
    @@ -1 +1 @@
      Given data tensor of rank r >= 1, and indices tensor of rank q, gather
      entries of the axis dimension of data (by default outer-most one as axis=0) indexed by indices, and concatenates
      them in an output tensor of rank q + (r - 1).
    - Example 1:
  
    + If axis = 0, let k = indices[i_{0}, ..., i_{q-1}]
    + then output[i_{0}, ..., i_{q-1}, j_{0}, ..., j_{r-2}] = input[k , j_{0}, ..., j_{r-2}]:
    -   data = [
    -       [1.0, 1.2],
    -       [2.3, 3.4],
    -       [4.5, 5.7],
    -   ]
    -   indices = [
    -       [0, 1],
    -       [1, 2],
    -   ]
    -   output = [
    -       [
    -           [1.0, 1.2],
    -           [2.3, 3.4],
    -       ],
    -       [
    -           [2.3, 3.4],
    -           [4.5, 5.7],
    -       ],
    -   ]
  
    - Example 2:
  
    -   data = [
    ? --
    + data = [
    +     [1.0, 1.2],
    +     [2.3, 3.4],
    +     [4.5, 5.7],
    + ]
    + indices = [
    +     [0, 1],
    +     [1, 2],
    + ]
    + output = [
    +     [
    +         [1.0, 1.2],
    +         [2.3, 3.4],
    +     ],
    +     [
    +         [2.3, 3.4],
    +         [4.5, 5.7],
    +     ],
    + ]
    + 
    + 
    + If axis = 1, let k = indices[i_{0}, ..., i_{q-1}]
    + then output[j_{0}, i_{0}, ..., i_{q-1}, j_{1}, ..., j_{r-2}] = input[j_{0}, k, j_{1}, ..., j_{r-2}]:
    + 
    + 
    + data = [
    -       [1.0, 1.2, 1.9],
    ? --
    +     [1.0, 1.2, 1.9],
    -       [2.3, 3.4, 3.9],
    ? --
    +     [2.3, 3.4, 3.9],
    -       [4.5, 5.7, 5.9],
    ? --
    +     [4.5, 5.7, 5.9],
    -   ]
    + ]
    -   indices = [
    ? --
    + indices = [
    -       [0, 2],
    ? --
    +     [0, 2],
    -   ]
    + ]
    -   axis = 1,
    ? --
    + axis = 1,
    -   output = [
    ? --
    + output = [
    -       [[1.0, 1.9]],
    +         [[1.0, 1.9]],
    ? ++
    -       [[2.3, 3.9]],
    +         [[2.3, 3.9]],
    ? ++
    -       [[4.5, 5.9]],
    +         [[4.5, 5.9]],
    ? ++
    -   ]
    + ]
  
  
      ### Attributes
  
      * **axis - INT** (default is '0'):
  
    -   Which axis to gather on. Negative value means counting dimensions from the back. Accepted range is [-r, r-1]
    +   Which axis to gather on. Negative value means counting dimensions from the back. Accepted range is [-r, r-1] where r = rank(data).
    ?                                                                                                               ++++++++++++++++++++++
  
      ### Inputs
  
      - **data** (heterogeneous) - **T**:
  
        Tensor of rank r >= 1.
      - **indices** (heterogeneous) - **Tind**:
  
    -   Tensor of int32/int64 indices, of any rank q. All index values are expected to be within bounds. It is an error if any of the index values are out of bounds.
    +   Tensor of int32/int64 indices, of any rank q. All index values are expected to be within bounds [-s, s-1] along axis of size s. It is an error if any of the index values are out of bounds.
    ?                                                                                                  +++++++++++++++++++++++++++++++
  
      ### Outputs
  
      - **output** (heterogeneous) - **T**:
  
        Tensor of rank q + (r - 1).
  
      ### 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 any tensor type.
      * **Tind** in ( tensor(int32), tensor(int64) ):
  
        Constrain indices to integer types
    `;

    document.addEventListener('DOMContentLoaded', function () {
    var targetElement = document.getElementById('div_Gather_3');
    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>