.. _l-onnx-op-scatter-d9-11:

Scatter - 9 vs 11
=================

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_Scatter_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/Scatter9
    +++ b/Scatter11
    @@ -1 +1 @@
    - Given data, updates and indices input tensors of rank r >= 1, write the values provided by updates
    - into the first input, data, along axis dimension of data (by default outer-most one as axis=0) at corresponding indices.
    + This operator is deprecated. Please use ScatterElements, which provides the same functionality.
    + 
    + Scatter takes three inputs data, updates, and indices of the same
    + rank r >= 1 and an optional attribute axis that identifies an axis of data
    + (by default, the outer-most axis, that is axis 0). The output of the operation
    + is produced by creating a copy of the input data, and then updating its value
    + to values specified by updates at specific index positions specified by
    + indices. Its output shape is the same as the shape of data.
    + 
    - For each entry in updates, the target index in data is specified by corresponding entry in indices
    ?                                                        ^^^^ ^^        ^^^^^^ -   -----------------
    + For each entry in updates, the target index in data is obtained by combining
    ?                                                        ^^^^ ^        ^^^
    - for dimension = axis, and index in source for dimension != axis. For instance, in a 2-D tensor case,
    - data[indices[i][j]][j] = updates[i][j] if axis = 0, or data[i][indices[i][j]] = updates[i][j] if axis = 1,
    - where i and j are loop counters from 0 up to the respective size in updates - 1.
    + the corresponding entry in indices with the index of the entry itself: the
    + index-value for dimension = axis is obtained from the value of the corresponding
    + entry in indices and the index-value for dimension != axis is obtained from the
    + index of the entry itself.
    + 
    + For instance, in a 2-D tensor case, the update corresponding to the [i][j] entry
    + is performed as below:
    + 
    +   output[indices[i][j]][j] = updates[i][j] if axis = 0,
    +   output[i][indices[i][j]] = updates[i][j] if axis = 1,
    + 
    + 
    + This operator is the inverse of GatherElements. It is similar to Torch's Scatter operation.
    + 
      Example 1:
    + 
        data = [
            [0.0, 0.0, 0.0],
            [0.0, 0.0, 0.0],
            [0.0, 0.0, 0.0],
        ]
        indices = [
            [1, 0, 2],
            [0, 2, 1],
        ]
        updates = [
            [1.0, 1.1, 1.2],
            [2.0, 2.1, 2.2],
        ]
        output = [
            [2.0, 1.1, 0.0]
            [1.0, 0.0, 2.2]
            [0.0, 2.1, 1.2]
        ]
    + 
      Example 2:
    + 
        data = [[1.0, 2.0, 3.0, 4.0, 5.0]]
        indices = [[1, 3]]
        updates = [[1.1, 2.1]]
        axis = 1
        output = [[1.0, 1.1, 3.0, 2.1, 5.0]]
  
    + 
      ### Attributes
  
      * **axis - INT** (default is '0'):
  
    -   Which axis to scatter on. Negative value means counting dimensions from the back. Accepted range is [-r, r-1]
    +   Which axis to scatter 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 r >= 1 (same rank as input).
    +   Tensor of int32/int64 indices, of r >= 1 (same rank as input). 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.
      - **updates** (heterogeneous) - **T**:
  
        Tensor of rank r >=1 (same rank and shape as indices)
  
      ### Outputs
  
      - **output** (heterogeneous) - **T**:
  
        Tensor of rank r >= 1 (same rank as input).
  
      ### 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) ):
  
        Input and output types can be of any tensor type.
      * **Tind** in ( tensor(int32), tensor(int64) ):
  
        Constrain indices to integer types
    `;

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