# nlcpy.dot

nlcpy.dot(a, b, out=None)[ソース]

Computes a dot product of two arrays.

• 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 `nlcpy.matmul()` or `a @ b` is preferred.

• If either a or b is 0-D (scalar), it is equivalent to multiply and using `nlcpy.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])`

Parameters
aarray_like

Input arrays or scalars.

barray_like

Input arrays or scalars.

outndarray, optional

Output argument. This must have the exact kind that would be returned if it was not used. In particular, out.dtype must be the dtype that would be returned for dot(a,b).

Returns
outputndarray

Returns the dot product of a and b. If a and b are both scalars or both 1-D arrays then this function returns the result as a 0-dimention array.

Examples

```>>> import nlcpy as vp
>>> vp.dot(3, 4)
array(12)
```

Neither argument is complex-conjugated:

```>>> vp.dot([2j, 3j], [2j, 3j])
array(-13.+0.j)
```

For 2-D arrays it is the matrix product:

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