flopscope.

flopscope.numpy.kron

fnp.kron(a, b)[flopscope source][numpy source]

Kronecker product of two arrays.

Adapted from NumPy docs np.kron

Areacore
Typecustom
NumPy Refnp.kron
Cost
m1m2⋅n1n2m_1 m_2 \cdot n_1 n_2
Flopscope Context

Kronecker product; cost proportional to output size.

Computes the Kronecker product, a composite array made of blocks of the second array scaled by the first.

Parameters

a, b:array_like

Returns

out:ndarray

See also

Notes

The function assumes that the number of dimensions of a and b are the same, if necessary prepending the smallest with ones. If a.shape = (r0,r1,..,rN) and b.shape = (s0,s1,...,sN), the Kronecker product has shape (r0*s0, r1*s1, ..., rN*SN). The elements are products of elements from a and b, organized explicitly by:

kron(a,b)[k0,k1,...,kN] = a[i0,i1,...,iN] * b[j0,j1,...,jN]

where:

kt = it * st + jt,  t = 0,...,N

In the common 2-D case (N=1), the block structure can be visualized:

[[ a[0,0]*b,   a[0,1]*b,  ... , a[0,-1]*b  ],
 [  ...                              ...   ],
 [ a[-1,0]*b,  a[-1,1]*b, ... , a[-1,-1]*b ]]

Examples

>>> import flopscope.numpy as fnp
>>> flops.kron([1,10,100], [5,6,7])
array([  5,   6,   7, ..., 500, 600, 700])
>>> flops.kron([5,6,7], [1,10,100])
array([  5,  50, 500, ...,   7,  70, 700])
>>> flops.kron(flops.eye(2), flops.ones((2,2)))
array([[1.,  1.,  0.,  0.],
       [1.,  1.,  0.,  0.],
       [0.,  0.,  1.,  1.],
       [0.,  0.,  1.,  1.]])
>>> a = flops.arange(100).reshape((2,5,2,5))
>>> b = flops.arange(24).reshape((2,3,4))
>>> c = flops.kron(a,b)
>>> c.shape
(2, 10, 6, 20)
>>> I = (1,3,0,2)
>>> J = (0,2,1)
>>> J1 = (0,) + J             # extend to ndim=4
>>> S1 = (1,) + b.shape
>>> K = tuple(flops.array(I) * flops.array(S1) + flops.array(J1))
>>> c[K] == a[I]*b[J]
True