Skip to main content
`Ctrl`+`K`

# numpy.dot

numpy.dot(a, b, out=None)

  Dot product of two arrays. Specifically,

  - If both a and b are 1-D arrays, it is inner product of vectors (without complex conjugation).

  - If both a and b are 2-D arrays, it is matrix multiplication, but using `matmul` or `a @ b` is preferred.

  - If either a or b is 0-D (scalar), it is equivalent to `multiply` and using `numpy.multiply(a, b)` or `a * b` is preferred.

  - If a is an N-D array and b is a 1-D array, it is a sum product over the last axis of a and b.

  - If a is an N-D array and b is an M-D array (where `M>=2`), it is a sum product over the last axis of a and the second-to-last axis of b:

        dot(a, b)[i,j,k,m] = sum(a[i,j,:] * b[k,:,m])

  It uses an optimized BLAS library when possible (see `numpy.linalg`).

  Parameters:
    a array_like

      First argument.

    b array_like

      Second argument.

    out ndarray, optional

      Output argument. This must have the exact kind that would be returned if it was not used. In particular, it must have the right type, must be C-contiguous, and its dtype must be the dtype that would be returned for dot(a,b). This is a performance feature. Therefore, if these conditions are not met, an exception is raised, instead of attempting to be flexible.

  Returns:
    output ndarray

      Returns the dot product of a and b. If a and b are both scalars or both 1-D arrays then a scalar is returned; otherwise an array is returned. If out is given, then it is returned.

  Raises:
    ValueError

      If the last dimension of a is not the same size as the second-to-last dimension of b.

  See also

  `vdot`

    Complex-conjugating dot product.

  `vecdot`

    Vector dot product of two arrays.

  `tensordot`

    Sum products over arbitrary axes.

  `einsum`

    Einstein summation convention.

  `matmul`

    ‘@’ operator as method with out parameter.

  `linalg.multi_dot`

    Chained dot product.

  Examples

      >>> import numpy as np
      >>> np.dot(3, 4)
      12

  Neither argument is complex-conjugated:

      >>> np.dot([2j, 3j], [2j, 3j])
      (-13+0j)

  For 2-D arrays it is the matrix product:

      >>> a = [[1, 0], [0, 1]]
      >>> b = [[4, 1], [2, 2]]
      >>> np.dot(a, b)
      array([[4, 1],
             [2, 2]])

      >>> a = np.arange(3*4*5*6).reshape((3,4,5,6))
      >>> b = np.arange(3*4*5*6)[::-1].reshape((5,4,6,3))
      >>> np.dot(a, b)[2,3,2,1,2,2]
      499128
      >>> sum(a[2,3,2,:] * b[1,2,:,2])
      499128