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

Gemm - 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_Gemm_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/Gemm9
    +++ b/Gemm11
    @@ -1 +1 @@
      General Matrix multiplication:
      https://en.wikipedia.org/wiki/Basic_Linear_Algebra_Subprograms#Level_3
  
      A' = transpose(A) if transA else A
  
      B' = transpose(B) if transB else B
  
      Compute Y = alpha * A' * B' + beta * C, where input tensor A has shape (M, K) or (K, M),
      input tensor B has shape (K, N) or (N, K), input tensor C is broadcastable to shape (M, N),
      and output tensor Y has shape (M, N). A will be transposed before doing the
      computation if attribute transA is non-zero, same for B and transB.
      This operator supports **unidirectional broadcasting** (tensor C should be unidirectional broadcastable to tensor A * B); for more details please check [Broadcasting in ONNX](https://github.com/onnx/onnx/blob/main/docs/Broadcasting.md).
    + This operator has **optional** inputs/outputs. See [ONNX IR](https://github.com/onnx/onnx/blob/main/docs/IR.md) for more details about the representation of optional arguments. An empty string may be used in the place of an actual argument's name to indicate a missing argument. Trailing optional arguments (those not followed by an argument that is present) may also be simply omitted.
  
      ### Attributes
  
      * **alpha - FLOAT** (default is '1.0'):
  
        Scalar multiplier for the product of input tensors A * B.
  
      * **beta - FLOAT** (default is '1.0'):
  
        Scalar multiplier for input tensor C.
  
      * **transA - INT** (default is '0'):
  
        Whether A should be transposed
  
      * **transB - INT** (default is '0'):
  
        Whether B should be transposed
  
      ### Inputs
  
    + Between 2 and 3 inputs.
    + 
      - **A** (heterogeneous) - **T**:
  
        Input tensor A. The shape of A should be (M, K) if transA is 0, or (K, M) if transA is non-zero.
      - **B** (heterogeneous) - **T**:
  
        Input tensor B. The shape of B should be (K, N) if transB is 0, or (N, K) if transB is non-zero.
    - - **C** (heterogeneous) - **T**:
    + - **C** (optional, heterogeneous) - **T**:
    ?          ++++++++++
  
    -   Input tensor C. The shape of C should be unidirectional broadcastable to (M, N).
    +   Optional input tensor C. If not specified, the computation is done as if C is a scalar 0. The shape of C should be unidirectional broadcastable to (M, N).
  
      ### Outputs
  
      - **Y** (heterogeneous) - **T**:
  
        Output tensor of shape (M, N).
  
      ### Type Constraints
  
      * **T** in ( tensor(double), tensor(float), tensor(float16), tensor(int32), tensor(int64), tensor(uint32), tensor(uint64) ):
  
        Constrain input and output types to float/int tensors.
    `;

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