def test_KroneckerProduct_expand():
X = MatrixSymbol('X', n, n)
Y = MatrixSymbol('Y', n, n)
assert KroneckerProduct(X + Y, Y + Z).expand(kroneckerproduct=True) == \
KroneckerProduct(X, Y) + KroneckerProduct(X, Z) + \
KroneckerProduct(Y, Y) + KroneckerProduct(Y, Z)
def test_KroneckerProduct_explicit():
X = MatrixSymbol("X", 2, 2)
Y = MatrixSymbol("Y", 2, 2)
kp = KroneckerProduct(X, Y)
assert kp.shape == (4, 4)
assert kp.as_explicit() == Matrix([
[
X[0, 0] * Y[0, 0],
X[0, 0] * Y[0, 1],
X[0, 1] * Y[0, 0],
X[0, 1] * Y[0, 1],
],
[
X[0, 0] * Y[1, 0],
X[0, 0] * Y[1, 1],
X[0, 1] * Y[1, 0],
X[0, 1] * Y[1, 1],
],
[
X[1, 0] * Y[0, 0],
X[1, 0] * Y[0, 1],
X[1, 1] * Y[0, 0],
X[1, 1] * Y[0, 1],
],
[
X[1, 0] * Y[1, 0],
X[1, 0] * Y[1, 1],
X[1, 1] * Y[1, 0],
X[1, 1] * Y[1, 1],
],
])
def test_KroneckerProduct_explicit():
X = MatrixSymbol('X', 2, 2)
Y = MatrixSymbol('Y', 2, 2)
kp = KroneckerProduct(X, Y)
assert kp.shape == (4, 4)
assert kp.as_explicit() == Matrix(
[
[X[0, 0]*Y[0, 0], X[0, 0]*Y[0, 1], X[0, 1]*Y[0, 0], X[0, 1]*Y[0, 1]],
[X[0, 0]*Y[1, 0], X[0, 0]*Y[1, 1], X[0, 1]*Y[1, 0], X[0, 1]*Y[1, 1]],
[X[1, 0]*Y[0, 0], X[1, 0]*Y[0, 1], X[1, 1]*Y[0, 0], X[1, 1]*Y[0, 1]],
[X[1, 0]*Y[1, 0], X[1, 0]*Y[1, 1], X[1, 1]*Y[1, 0], X[1, 1]*Y[1, 1]]
]
)
def test_KroneckerProduct_combine_pow():
X = MatrixSymbol('X', n, n)
Y = MatrixSymbol('Y', n, n)
assert combine_kronecker(KroneckerProduct(
X, Y)**x) == KroneckerProduct(X**x, Y**x)
assert combine_kronecker(x * KroneckerProduct(X, Y)
** 2) == x * KroneckerProduct(X**2, Y**2)
assert combine_kronecker(
x * (KroneckerProduct(X, Y)**2) * KroneckerProduct(A, B)) == x * KroneckerProduct(X**2 * A, Y**2 * B)
# cannot simplify because of non-square arguments to kronecker product:
assert combine_kronecker(KroneckerProduct(A, B.T) ** m) == KroneckerProduct(A, B.T) ** m
def test_KroneckerProduct_entry():
A = MatrixSymbol('A', n, m)
B = MatrixSymbol('B', o, p)
assert KroneckerProduct(A, B)._entry(
i, j) == A[Mod(floor(i / o), n),
Mod(floor(j / p), m)] * B[Mod(i, o), Mod(j, p)]
def test_KroneckerProduct_combine_pow():
X = MatrixSymbol('X', n, n)
Y = MatrixSymbol('Y', n, n)
assert combine_kronecker(KroneckerProduct(
X, Y)**x) == KroneckerProduct(X**x, Y**x)
assert combine_kronecker(x * KroneckerProduct(X, Y)
** 2) == x * KroneckerProduct(X**2, Y**2)
assert combine_kronecker(
x * (KroneckerProduct(X, Y)**2) * KroneckerProduct(A, B)) == x * KroneckerProduct(X**2 * A, Y**2 * B)
def test_NumPyPrinter():
from sympy.core.function import Lambda
from sympy.matrices.expressions.adjoint import Adjoint
from sympy.matrices.expressions.diagonal import (DiagMatrix,
DiagonalMatrix,
DiagonalOf)
from sympy.matrices.expressions.funcmatrix import FunctionMatrix
from sympy.matrices.expressions.hadamard import HadamardProduct
from sympy.matrices.expressions.kronecker import KroneckerProduct
from sympy.matrices.expressions.special import (OneMatrix, ZeroMatrix)
from sympy.abc import a, b
p = NumPyPrinter()
assert p.doprint(sign(x)) == 'numpy.sign(x)'
A = MatrixSymbol("A", 2, 2)
B = MatrixSymbol("B", 2, 2)
C = MatrixSymbol("C", 1, 5)
D = MatrixSymbol("D", 3, 4)
assert p.doprint(A**(-1)) == "numpy.linalg.inv(A)"
assert p.doprint(A**5) == "numpy.linalg.matrix_power(A, 5)"
assert p.doprint(Identity(3)) == "numpy.eye(3)"
u = MatrixSymbol('x', 2, 1)
v = MatrixSymbol('y', 2, 1)
assert p.doprint(MatrixSolve(A, u)) == 'numpy.linalg.solve(A, x)'
assert p.doprint(MatrixSolve(A, u) + v) == 'numpy.linalg.solve(A, x) + y'
assert p.doprint(ZeroMatrix(2, 3)) == "numpy.zeros((2, 3))"
assert p.doprint(OneMatrix(2, 3)) == "numpy.ones((2, 3))"
assert p.doprint(FunctionMatrix(4, 5, Lambda((a, b), a + b))) == \
"numpy.fromfunction(lambda a, b: a + b, (4, 5))"
assert p.doprint(HadamardProduct(A, B)) == "numpy.multiply(A, B)"
assert p.doprint(KroneckerProduct(A, B)) == "numpy.kron(A, B)"
assert p.doprint(Adjoint(A)) == "numpy.conjugate(numpy.transpose(A))"
assert p.doprint(DiagonalOf(A)) == "numpy.reshape(numpy.diag(A), (-1, 1))"
assert p.doprint(DiagMatrix(C)) == "numpy.diagflat(C)"
assert p.doprint(DiagonalMatrix(D)) == "numpy.multiply(D, numpy.eye(3, 4))"
# Workaround for numpy negative integer power errors
assert p.doprint(x**-1) == 'x**(-1.0)'
assert p.doprint(x**-2) == 'x**(-2.0)'
expr = Pow(2, -1, evaluate=False)
assert p.doprint(expr) == "2**(-1.0)"
assert p.doprint(S.Exp1) == 'numpy.e'
assert p.doprint(S.Pi) == 'numpy.pi'
assert p.doprint(S.EulerGamma) == 'numpy.euler_gamma'
assert p.doprint(S.NaN) == 'numpy.nan'
assert p.doprint(S.Infinity) == 'numpy.PINF'
assert p.doprint(S.NegativeInfinity) == 'numpy.NINF'
def test_KroneckerProduct_is_associative():
assert kronecker_product(A, kronecker_product(B, C)) == kronecker_product(
kronecker_product(A, B), C)
assert kronecker_product(A, kronecker_product(B, C)) == KroneckerProduct(
A, B, C)
def test_tensor_product_transpose():
assert KroneckerProduct(I*A, B).transpose() == \
I*KroneckerProduct(A.transpose(), B.transpose())
assert KroneckerProduct(mat1, mat2).transpose() == \
kronecker_product(mat1.transpose(), mat2.transpose())
def test_tensor_product_conjugate():
assert KroneckerProduct(I*A, B).conjugate() == \
-I*KroneckerProduct(A.conjugate(), B.conjugate())
assert KroneckerProduct(mat1, mat2).conjugate() == \
kronecker_product(mat1.conjugate(), mat2.conjugate())
def test_tensor_product_adjoint():
assert KroneckerProduct(I*A, B).adjoint() == \
-I*KroneckerProduct(A.adjoint(), B.adjoint())
assert KroneckerProduct(mat1, mat2).adjoint() == \
kronecker_product(mat1.adjoint(), mat2.adjoint())
def test_KroneckerProduct_identity():
assert KroneckerProduct(Identity(m), Identity(n)) == Identity(m * n)
assert KroneckerProduct(eye(2), eye(3)) == eye(6)
def test_KroneckerProduct():
assert isinstance(KroneckerProduct(A, B), KroneckerProduct)
assert KroneckerProduct(A, B).subs(A, C) == KroneckerProduct(C, B)
assert KroneckerProduct(A, C).shape == (n * m, m * k)
assert (KroneckerProduct(A, C) + KroneckerProduct(-A, C)).is_ZeroMatrix
assert (KroneckerProduct(W, Z) * KroneckerProduct(W.I, Z.I)).is_Identity
def test_KroneckerProduct_extracts_commutative_part():
assert kronecker_product(x * A, 2 * B) == x * \
2 * KroneckerProduct(A, B)
def test_KroneckerProduct_isnt_commutative():
assert KroneckerProduct(A, B) != KroneckerProduct(B, A)
assert KroneckerProduct(A, B).is_commutative is False
