def test_inverse():
n, m, l = symbols("n m l", integer=True)
A = MatrixSymbol("A", n, m)
C = MatrixSymbol("C", n, n)
D = MatrixSymbol("D", n, n)
E = MatrixSymbol("E", m, n)
raises(ShapeError, lambda: Inverse(A))
assert Inverse(Inverse(C)) == C
assert Inverse(C) * C == Identity(C.rows)
assert Inverse(eye(3)) == eye(3)
assert Inverse(S(3)) == S(1) / 3
assert Inverse(Identity(n)) == Identity(n)
# Simplifies Muls if possible (i.e. submatrices are square)
assert Inverse(C * D) == D.I * C.I
# But still works when not possible
assert Inverse(A * E).is_Inverse
# We play nice with traditional explicit matrices
assert Inverse(Matrix([[1, 2], [3, 4]])) == Matrix([[1, 2], [3, 4]]).inv()
def _represent_ZGate(self, basis, **options):
"""
Represents the (I)QFT In the Z Basis
"""
nqubits = options.get('nqubits', 0)
if nqubits == 0:
raise QuantumError(
'The number of qubits must be given as nqubits.')
if nqubits < self.min_qubits:
raise QuantumError(
'The number of qubits %r is too small for the gate.' % nqubits
)
size = self.size
omega = self.omega
#Make a matrix that has the basic Fourier Transform Matrix
arrayFT = [[omega**(
i*j % size)/sqrt(size) for i in range(size)] for j in range(size)]
matrixFT = Matrix(arrayFT)
#Embed the FT Matrix in a higher space, if necessary
if self.label[0] != 0:
matrixFT = matrix_tensor_product(eye(2**self.label[0]), matrixFT)
if self.min_qubits < nqubits:
matrixFT = matrix_tensor_product(
matrixFT, eye(2**(nqubits - self.min_qubits)))
return matrixFT
def test_inverse():
n, m, l = symbols('n m l', integer=True)
A = MatrixSymbol('A', n, m)
B = MatrixSymbol('B', m, l)
C = MatrixSymbol('C', n, n)
D = MatrixSymbol('D', n, n)
E = MatrixSymbol('E', m, n)
raises(ShapeError, "Inverse(A)")
assert Inverse(Inverse(C)) == C
assert Inverse(C)*C == Identity(C.n)
assert Inverse(eye(3)) == eye(3)
assert Inverse(S(3)) == S(1)/3
assert Inverse(Identity(n)) == Identity(n)
# Simplifies Muls if possible (i.e. submatrices are square)
assert Inverse(C*D) == D.I*C.I
# But still works when not possible
assert Inverse(A*E).is_Inverse
# We play nice with traditional explicit matrices
assert Inverse(Matrix([[1,2],[3,4]])) == Matrix([[1,2],[3,4]]).inv()
def test(As,Bs,Cs,Ds,Us,sI_A,Js,Ys,B0,C0,C,Psi,Lamda):
D1=BlockMatrix([[Us.inv()*Psi,zeros(Us.rows,1)],[-Lamda,eye(Lamda.rows)]]).as_mutable()
D2=BlockMatrix([[sI_A,B0],[-C,Js]]).as_mutable()
D3=BlockMatrix([[As,Bs],[-Cs,Ds]]).as_mutable()
D4=BlockMatrix([[C0,-Ys],[zeros(Ys.cols,C0.cols),eye(Ys.cols)]]).as_mutable()
return expand(simplify(D1*D2))==expand(D3*D4)
def test_inverse():
raises(ShapeError, lambda: Inverse(A))
raises(ShapeError, lambda: Inverse(A*B))
assert Inverse(C).args == (C, S(-1))
assert Inverse(C).shape == (n, n)
assert Inverse(A*E).shape == (n, n)
assert Inverse(E*A).shape == (m, m)
assert Inverse(C).inverse() == C
assert isinstance(Inverse(Inverse(C)), Inverse)
assert Inverse(*Inverse(E*A).args) == Inverse(E*A)
assert C.inverse().inverse() == C
assert C.inverse()*C == Identity(C.rows)
assert Identity(n).inverse() == Identity(n)
assert (3*Identity(n)).inverse() == Identity(n)/3
# Simplifies Muls if possible (i.e. submatrices are square)
assert (C*D).inverse() == D.I*C.I
# But still works when not possible
assert isinstance((A*E).inverse(), Inverse)
assert Inverse(C*D).doit(inv_expand=False) == Inverse(C*D)
assert Inverse(eye(3)).doit() == eye(3)
assert Inverse(eye(3)).doit(deep=False) == eye(3)
def test(B0,Ts,E,A,B,C,U,V,Rc,Rs,Ss,p,m,rt):
D1=BlockDiagMatrix(B0,eye(p)).as_mutable()
D2=BlockMatrix([[Ts,U],[-V,zeros(p,m)]]).as_mutable()
D3=BlockMatrix([[s*E-A,B],[-C,zeros(C.rows,B.cols)]]).as_mutable()
D4Block11=simplify((Ss*Rs.inv())).as_mutable()
D4=BlockDiagMatrix(D4Block11,eye(m)).as_mutable()
return simplify(D1*D2)==simplify(D3*D4)
def test(B0,Ts,E,E0,A0,A,B,C,U,V,Rc,Rs,Qs,Ss,p,m,rt,n):
D1=BlockMatrix([[zeros(n,rt+p)],[eye(rt +p)]]).as_mutable()
D2=BlockMatrix([[Ts,U],[-V,zeros(p,m)]]).as_mutable()
D3=BlockMatrix([[s*E-A,B],[-C,zeros(C.rows,B.cols)]]).as_mutable()
D4Block1=simplify((-Ss*(Qs.inv()))).as_mutable()
D4Block1=D4Block1.col_join(eye(rt))
D4=BlockDiagMatrix(D4Block1,eye(m)).as_mutable()
return simplify(D1*D2) == simplify(D3*D4)
def test(rE, r, p, m, PE, PA, PC, As, Bs, Cs, Ds, E, A, B, C, D):
D1Block2 = simplify(PC * s * (PE - s * PA).inv())
D1Block3 = BlockMatrix([[Bs], [Ds]]).as_mutable()
D1Block4 = BlockMatrix([[zeros(r, p)], [eye(p)]]).as_mutable()
D1 = BlockMatrix([[eye(r + p), D1Block2, D1Block3, D1Block4]]).as_mutable()
D2 = BlockMatrix(2, 2, [s * E - A, B, -C, D]).as_mutable()
D3 = BlockMatrix(2, 2, [As, Bs, -Cs, Ds]).as_mutable()
D4 = BlockMatrix(
[[eye(r), zeros(r, rE + 2 * p), zeros(r, m)], [zeros(m, r), zeros(m, rE + 2 * p), eye(m)]]
).as_mutable()
return simplify(D1 * D2) == simplify(D3 * D4)
def make_collision(choice):
model_switcher = {
# Relax 2nd moments for hydro, SOI
'hydro': (eye(q) - S_Relax) * temp_populations
+ S_Relax * hardcoded_cm_eq
+ (eye(q) - S_Relax / 2) * hardcoded_F_cm,
# Relax 1st moments for ADE, SOI without force
'ade': None # TODO: write the collision for advection-diffusion equation
}
# Get the function from switcher dictionary
cm_after_collision = model_switcher.get(choice, lambda: "Invalid argument")
print_as_vector(cm_after_collision, print_symbol=pop_in_str)
def test_det():
assert isinstance(Determinant(A), Determinant)
assert not isinstance(Determinant(A), MatrixExpr)
raises(ShapeError, lambda: Determinant(C))
print det(eye(3))
assert det(eye(3)) == 1
assert det(Matrix(3, 3, [1, 3, 2, 4, 1, 3, 2, 5, 2])) == 17
A / det(A) # Make sure this is possible
raises(TypeError, lambda: Determinant(S.One))
assert Determinant(A).arg is A
def test_transpose():
Sq = MatrixSymbol('Sq', n, n)
assert Transpose(A).shape == (m, n)
assert Transpose(A*B).shape == (l, n)
assert Transpose(Transpose(A)) == A
assert Transpose(eye(3)) == eye(3)
assert Transpose(S(5)) == S(5)
assert Transpose(Matrix([[1, 2], [3, 4]])) == Matrix([[1, 3], [2, 4]])
assert Transpose(Trace(Sq)) == Trace(Sq)
def test_transpose():
n, m, l = symbols('n m l', integer=True)
A = MatrixSymbol('A', n, m)
B = MatrixSymbol('B', m, l)
assert Transpose(A).shape == (m,n)
assert Transpose(A*B).shape == (l,n)
assert Transpose(Transpose(A)) == A
assert Transpose(eye(3)) == eye(3)
assert Transpose(S(5)) == S(5)
assert Transpose(Matrix([[1,2],[3,4]])) == Matrix([[1,3],[2,4]])
def test_sparse_solve():
from sympy.matrices import SparseMatrix
A = SparseMatrix(((25, 15, -5), (15, 18, 0), (-5, 0, 11)))
assert A.cholesky() == Matrix([
[ 5, 0, 0],
[ 3, 3, 0],
[-1, 1, 3]])
assert A.cholesky() * A.cholesky().T == Matrix([
[25, 15, -5],
[15, 18, 0],
[-5, 0, 11]])
A = SparseMatrix(((25, 15, -5), (15, 18, 0), (-5, 0, 11)))
L, D = A.LDLdecomposition()
assert 15*L == Matrix([
[15, 0, 0],
[ 9, 15, 0],
[-3, 5, 15]])
assert D == Matrix([
[25, 0, 0],
[ 0, 9, 0],
[ 0, 0, 9]])
assert L * D * L.T == A
A = SparseMatrix(((3, 0, 2), (0, 0, 1), (1, 2, 0)))
assert A.inv() * A == SparseMatrix(eye(3))
A = SparseMatrix([
[ 2, -1, 0],
[-1, 2, -1],
[ 0, 0, 2]])
ans = SparseMatrix([
[S(2)/3, S(1)/3, S(1)/6],
[S(1)/3, S(2)/3, S(1)/3],
[ 0, 0, S(1)/2]])
assert A.inv(method='CH') == ans
assert A.inv(method='LDL') == ans
assert A * ans == SparseMatrix(eye(3))
s = A.solve(A[:, 0], 'LDL')
assert A*s == A[:, 0]
s = A.solve(A[:, 0], 'CH')
assert A*s == A[:, 0]
A = A.col_join(A)
s = A.solve_least_squares(A[:, 0], 'CH')
assert A*s == A[:, 0]
s = A.solve_least_squares(A[:, 0], 'LDL')
assert A*s == A[:, 0]
def sigma(k):
s = zeros(3)
e = eye(3)
for i in range(3):
for j in range(3):
s[i, j] = (im if i == k else e)[i,j]
return s
def _syzygies(self):
"""Compute syzygies. See [SCA, algorithm 2.5.4]."""
# NOTE if self.gens is a standard basis, this can be done more
# efficiently using Schreyer's theorem
from sympy.matrices import eye
# First bullet point
k = len(self.gens)
r = self.rank
im = eye(k)
Rkr = self.ring.free_module(r + k)
newgens = []
for j, f in enumerate(self.gens):
m = [0]*(r + k)
for i, v in enumerate(f):
m[i] = f[i]
for i in range(k):
m[r + i] = im[j, i]
newgens.append(Rkr.convert(m))
# Note: we need *descending* order on module index, and TOP=False to
# get an eliminetaion order
F = Rkr.submodule(*newgens, order='ilex', TOP=False)
# Second bullet point: standard basis of F
G = F._groebner_vec()
# Third bullet point: G0 = G intersect the new k components
G0 = [x[r:] for x in G if all(y == self.ring.convert(0)
for y in x[:r])]
# Fourth and fifth bullet points: we are done
return G0
def demo_corr_bound(n):
def corr(i, j):
if i == j:
return 1
else:
return rho
Rho = Matrix(n, n, corr)
print "what's the bound of rho to make below a correlation matrix?\n"
pprint(Rho)
print "\ncan be viewed as the sum of 2 matrices Rho = A + B:\n"
A = (1-rho)*eye(n)
B = rho*ones(n,n)
pprint(A)
pprint(B)
print "\nthe eigen value and its dimention of first matrix A is:"
pprint(A.eigenvects())
print "\nas for the seconde matrix B\n"\
"it's product of any vector v:"
v = IndexedBase('v')
vec = Matrix(n, 1, lambda i, j: v[i+1])
pprint(vec)
pprint(B*vec)
print "\nin order for it's to equal to a linear transform of v\n"\
"we can see its eigen values, vectors and dimentions are:"
pprint(B.eigenvects())
print "\nfor any eigen vector of B v, we have Rho*v :\n"
pprint(Rho*vec)
print "\nwhich means v is also an eigen vector of Rho,\n"\
"the eigen values, vectors and dimentions of Rho are:\n"
pprint(Rho.eigenvects())
print "\nsince have no negative eigen values <=> positive semidefinite:\n"\
"the boundaries for rho are: [1/(%d-1),1]" %n
def test_singular_values():
x = Symbol('x', real=True)
A = EigenOnlyMatrix([[0, 1*I], [2, 0]])
# if singular values can be sorted, they should be in decreasing order
assert A.singular_values() == [2, 1]
A = eye(3)
A[1, 1] = x
A[2, 2] = 5
vals = A.singular_values()
# since Abs(x) cannot be sorted, test set equality
assert set(vals) == set([5, 1, Abs(x)])
A = EigenOnlyMatrix([[sin(x), cos(x)], [-cos(x), sin(x)]])
vals = [sv.trigsimp() for sv in A.singular_values()]
assert vals == [S(1), S(1)]
A = EigenOnlyMatrix([
[2, 4],
[1, 3],
[0, 0],
[0, 0]
])
assert A.singular_values() == \
[sqrt(sqrt(221) + 15), sqrt(15 - sqrt(221))]
assert A.T.singular_values() == \
[sqrt(sqrt(221) + 15), sqrt(15 - sqrt(221)), 0, 0]
def cartan_matrix(self):
"""
Returns the Cartan matrix for A_n.
The Cartan matrix matrix for a Lie algebra is
generated by assigning an ordering to the simple
roots, (alpha[1], ...., alpha[l]). Then the ijth
entry of the Cartan matrix is (<alpha[i],alpha[j]>).
Examples
========
>>> from sympy.liealgebras.cartan_type import CartanType
>>> c = CartanType('A4')
>>> c.cartan_matrix()
Matrix([
[ 2, -1, 0, 0],
[-1, 2, -1, 0],
[ 0, -1, 2, -1],
[ 0, 0, -1, 2]])
"""
n = self.n
m = 2 * eye(n)
i = 1
while i < n-1:
m[i, i+1] = -1
m[i, i-1] = -1
i += 1
m[0,1] = -1
m[n-1, n-2] = -1
return m
def test_Trace():
assert isinstance(Trace(A), Trace)
assert not isinstance(Trace(A), MatrixExpr)
raises(ShapeError, lambda: Trace(C))
assert trace(eye(3)) == 3
assert trace(Matrix(3, 3, [1, 2, 3, 4, 5, 6, 7, 8, 9])) == 15
assert adjoint(Trace(A)) == trace(Adjoint(A))
assert conjugate(Trace(A)) == trace(Adjoint(A))
assert transpose(Trace(A)) == Trace(A)
A / Trace(A) # Make sure this is possible
# Some easy simplifications
assert trace(Identity(5)) == 5
assert trace(ZeroMatrix(5, 5)) == 0
assert trace(OneMatrix(1, 1)) == 1
assert trace(OneMatrix(2, 2)) == 2
assert trace(OneMatrix(n, n)) == n
assert trace(2*A*B) == 2*Trace(A*B)
assert trace(A.T) == trace(A)
i, j = symbols('i j')
F = FunctionMatrix(3, 3, Lambda((i, j), i + j))
assert trace(F) == (0 + 0) + (1 + 1) + (2 + 2)
raises(TypeError, lambda: Trace(S.One))
assert Trace(A).arg is A
assert str(trace(A)) == str(Trace(A).doit())
assert Trace(A).is_commutative is True
def prde_no_cancel_b_large(b, Q, n, DE):
"""
Parametric Poly Risch Differential Equation - No cancellation: deg(b) large enough.
Given a derivation D on k[t], n in ZZ, and b, q1, ..., qm in k[t] with
b != 0 and either D == d/dt or deg(b) > max(0, deg(D) - 1), returns
h1, ..., hr in k[r] and a matrix A with coefficients in Const(k) such that
if c1, ..., cm in Const(k) and q in k[t] satisfy deg(q) <= n and
Dq + b*Q == Sum(ci*qi, (i, 1, m)), then q = Sum(dj*hj, (j, 1, r)), where
d1, ..., dr in Const(k) and A*Matrix([[c1, ..., cm, d1, ..., dr]]).T == 0.
"""
db = b.degree(DE.t)
m = len(Q)
H = [Poly(0, DE.t)]*m
for N in xrange(n, -1, -1): # [n, ..., 0]
for i in range(m):
si = Q[i].nth(N + db)/b.LC()
sitn = Poly(si*DE.t**N, DE.t)
H[i] = H[i] + sitn
Q[i] = Q[i] - derivation(sitn, DE) - b*sitn
if all(qi.is_zero for qi in Q):
dc = -1
M = zeros(0, 2)
else:
dc = max([qi.degree(t) for qi in Q])
M = Matrix(dc + 1, m, lambda i, j: Q[j].nth(i))
A, u = constant_system(M, zeros(dc + 1, 1), DE)
c = eye(m)
A = A.row_join(zeros(A.rows, m)).col_join(c.row_join(-c))
return (H, A)
def test_trace():
n, m, l = symbols("n m l", integer=True)
A = MatrixSymbol("A", n, n)
B = MatrixSymbol("B", n, n)
assert isinstance(Trace(A), Trace)
assert not isinstance(Trace(A), MatrixExpr)
raises(ShapeError, lambda: Trace(MatrixSymbol("B", 3, 4)))
assert Trace(eye(3)) == 3
assert Trace(Matrix(3, 3, [1, 2, 3, 4, 5, 6, 7, 8, 9])) == 15
A / Trace(A) # Make sure this is possible
# Some easy simplifications
assert Trace(Identity(5)) == 5
assert Trace(ZeroMatrix(5, 5)) == 0
assert Trace(2 * A * B) == 2 * Trace(A * B)
assert Trace(A.T) == Trace(A)
i, j = symbols("i,j")
F = FunctionMatrix(3, 3, Lambda((i, j), i + j))
assert Trace(F).doit() == (0 + 0) + (1 + 1) + (2 + 2)
raises(TypeError, lambda: Trace(S.One))
assert Trace(A).arg is A
def test_adjoint():
Sq = MatrixSymbol('Sq', n, n)
assert Adjoint(A).shape == (m, n)
assert Adjoint(A*B).shape == (l, n)
assert Adjoint(Adjoint(A)) == A
assert Adjoint(eye(3)) == eye(3)
assert Adjoint(S(5)) == S(5)
assert Adjoint(Matrix([[1, 2], [3, 4]])) == Matrix([[1, 3], [2, 4]])
assert Adjoint(Trace(Sq)) == conjugate(Trace(Sq))
assert Trace(Adjoint(Sq)) == conjugate(Trace(Sq))
assert Adjoint(Sq)[0, 1] == conjugate(Sq[1, 0])
def test_transpose():
n, m, l = symbols("n m l", integer=True)
A = MatrixSymbol("A", n, m)
B = MatrixSymbol("B", m, l)
Sq = MatrixSymbol("Sq", n, n)
assert Transpose(A).shape == (m, n)
assert Transpose(A * B).shape == (l, n)
assert Transpose(Transpose(A)) == A
assert Transpose(eye(3)) == eye(3)
assert Transpose(S(5)) == S(5)
assert Transpose(Matrix([[1, 2], [3, 4]])) == Matrix([[1, 3], [2, 4]])
assert Transpose(Trace(Sq)) == Trace(Sq)
def _represent_default_basis(self, **options):
if not self.N or self.N == oo:
raise NotImplementedError("Cannot represent infinite dimensional" + " identity operator as a matrix")
format = options.get("format", "sympy")
if format != "sympy":
raise NotImplementedError("Representation in format " + "%s not implemented." % format)
return eye(self.N)
def rmat_k2d(d):
d = normalize(d)
if d == k:
rot = eye(3)
elif d == -k:
rot = diag(1,-1,-1)
else:
rot = rquat2rmat(rquat(acos(dot(k, d)), cross(k, d)))
return rot
def test_is_zero():
assert PropertiesOnlyMatrix(0, 0, []).is_zero
assert PropertiesOnlyMatrix([[0, 0], [0, 0]]).is_zero
assert PropertiesOnlyMatrix(zeros(3, 4)).is_zero
assert not PropertiesOnlyMatrix(eye(3)).is_zero
assert PropertiesOnlyMatrix([[x, 0], [0, 0]]).is_zero == None
assert PropertiesOnlyMatrix([[x, 1], [0, 0]]).is_zero == False
a = Symbol('a', nonzero=True)
assert PropertiesOnlyMatrix([[a, 0], [0, 0]]).is_zero == False
def enlarge_single_opt_sympy(self, opt, qubit, number_of_qubits):
"""Enlarge single operator to n qubits.
It is exponential in the number of qubits.
Args:
opt (object): the single-qubit opt.
qubit (int): the qubit to apply it on counts from 0 and order
is q_{n-1} ... otimes q_1 otimes q_0.
number_of_qubits (int): the number of qubits in the system.
Returns:
Matrix: the enlarged matrix that operates on all qubits in the system.
"""
temp_1 = eye(2**(number_of_qubits-qubit-1))
temp_2 = eye(2**(qubit))
enlarge_opt = TensorProduct(temp_1, TensorProduct(opt, temp_2))
return enlarge_opt
def test_containers():
assert julia_code([1, 2, 3, [4, 5, [6, 7]], 8, [9, 10], 11]) == \
"Any[1, 2, 3, Any[4, 5, Any[6, 7]], 8, Any[9, 10], 11]"
assert julia_code((1, 2, (3, 4))) == "(1, 2, (3, 4))"
assert julia_code([1]) == "Any[1]"
assert julia_code((1,)) == "(1,)"
assert julia_code(Tuple(*[1, 2, 3])) == "(1, 2, 3)"
assert julia_code((1, x*y, (3, x**2))) == "(1, x.*y, (3, x.^2))"
# scalar, matrix, empty matrix and empty list
assert julia_code((1, eye(3), Matrix(0, 0, []), [])) == "(1, [1 0 0;\n0 1 0;\n0 0 1], zeros(0, 0), Any[])"
def test_containers():
assert mcode([1, 2, 3, [4, 5, [6, 7]], 8, [9, 10], 11]) == \
"{1, 2, 3, {4, 5, {6, 7}}, 8, {9, 10}, 11}"
assert mcode((1, 2, (3, 4))) == "{1, 2, {3, 4}}"
assert mcode([1]) == "{1}"
assert mcode((1,)) == "{1}"
assert mcode(Tuple(*[1, 2, 3])) == "{1, 2, 3}"
assert mcode((1, x*y, (3, x**2))) == "{1, x.*y, {3, x.^2}}"
# scalar, matrix, empty matrix and empty list
assert mcode((1, eye(3), Matrix(0, 0, []), [])) == "{1, [1 0 0;\n0 1 0;\n0 0 1], [], {}}"
def matrix_eye(n, **options):
"""Get the version of eye and tensor_product for a given format."""
format = options.get('format', 'sympy')
if format == 'sympy':
return eye(n)
elif format == 'numpy':
return _numpy_eye(n)
elif format == 'scipy.sparse':
return _scipy_sparse_eye(n)
raise NotImplementedError('Invalid format: %r' % format)
def g(x):
W = eye(2, real=True)
W[1, 0] = 1
return W * x
def test_matrix_symbol_MM():
X = MatrixSymbol('X', 3, 3)
Y = eye(3) + X
assert Y[1, 1] == 1 + X[1, 1]
def f(x, n):
h = symbols("h", real=True, positive=True)
return n - (eye(2, real=True) * h) * x
def test_inverse_laplace_transform():
from sympy import sinh, cosh, besselj, besseli, simplify, factor_terms,\
DiracDelta
ILT = inverse_laplace_transform
a, b, c, = symbols('a b c', positive=True)
t = symbols('t')
def simp_hyp(expr):
return factor_terms(expand_mul(expr)).rewrite(sin)
assert ILT(1, s, t) == DiracDelta(t)
assert ILT(1 / s, s, t) == Heaviside(t)
assert ILT(a / (a + s), s, t) == a * exp(-a * t) * Heaviside(t)
assert ILT(s / (a + s), s,
t) == -a * exp(-a * t) * Heaviside(t) + DiracDelta(t)
assert ILT((a + s)**(-2), s, t) == t * exp(-a * t) * Heaviside(t)
assert ILT((a + s)**(-5), s, t) == t**4 * exp(-a * t) * Heaviside(t) / 24
assert ILT(a / (a**2 + s**2), s, t) == sin(a * t) * Heaviside(t)
assert ILT(s / (s**2 + a**2), s, t) == cos(a * t) * Heaviside(t)
assert ILT(b / (b**2 + (a + s)**2), s,
t) == exp(-a * t) * sin(b * t) * Heaviside(t)
assert ILT(b*s/(b**2 + (a + s)**2), s, t) +\
(a*sin(b*t) - b*cos(b*t))*exp(-a*t)*Heaviside(t) == 0
assert ILT(exp(-a * s) / s, s, t) == Heaviside(-a + t)
assert ILT(exp(-a * s) / (b + s), s,
t) == exp(b * (a - t)) * Heaviside(-a + t)
assert ILT((b + s)/(a**2 + (b + s)**2), s, t) == \
exp(-b*t)*cos(a*t)*Heaviside(t)
assert ILT(exp(-a*s)/s**b, s, t) == \
(-a + t)**(b - 1)*Heaviside(-a + t)/gamma(b)
assert ILT(exp(-a*s)/sqrt(s**2 + 1), s, t) == \
Heaviside(-a + t)*besselj(0, a - t)
assert ILT(1 / (s * sqrt(s + 1)), s, t) == Heaviside(t) * erf(sqrt(t))
assert ILT(1 / (s**2 * (s**2 + 1)), s, t) == (t - sin(t)) * Heaviside(t)
assert ILT(s**2 / (s**2 + 1), s,
t) == -sin(t) * Heaviside(t) + DiracDelta(t)
assert ILT(1 - 1 / (s**2 + 1), s,
t) == -sin(t) * Heaviside(t) + DiracDelta(t)
assert ILT(1 / s**2, s, t) == t * Heaviside(t)
assert ILT(1 / s**5, s, t) == t**4 * Heaviside(t) / 24
assert simp_hyp(ILT(a / (s**2 - a**2), s, t)) == sinh(a * t) * Heaviside(t)
assert simp_hyp(ILT(s / (s**2 - a**2), s, t)) == cosh(a * t) * Heaviside(t)
# TODO sinh/cosh shifted come out a mess. also delayed trig is a mess
# TODO should this simplify further?
assert ILT(exp(-a*s)/s**b, s, t) == \
(t - a)**(b - 1)*Heaviside(t - a)/gamma(b)
assert ILT(exp(-a*s)/sqrt(1 + s**2), s, t) == \
Heaviside(t - a)*besselj(0, a - t) # note: besselj(0, x) is even
# XXX ILT turns these branch factor into trig functions ...
assert simplify(ILT(a**b*(s + sqrt(s**2 - a**2))**(-b)/sqrt(s**2 - a**2),
s, t).rewrite(exp)) == \
Heaviside(t)*besseli(b, a*t)
assert ILT(a**b*(s + sqrt(s**2 + a**2))**(-b)/sqrt(s**2 + a**2),
s, t).rewrite(exp) == \
Heaviside(t)*besselj(b, a*t)
assert ILT(1 / (s * sqrt(s + 1)), s, t) == Heaviside(t) * erf(sqrt(t))
# TODO can we make erf(t) work?
assert ILT(1 / (s**2 * (s**2 + 1)), s, t) == (t - sin(t)) * Heaviside(t)
assert ILT( (s * eye(2) - Matrix([[1, 0], [0, 2]])).inv(), s, t) ==\
Matrix([[exp(t)*Heaviside(t), 0], [0, exp(2*t)*Heaviside(t)]])
def test_applyfunc():
m0 = OperationsOnlyMatrix(eye(3))
assert m0.applyfunc(lambda x: 2*x) == eye(3)*2
assert m0.applyfunc(lambda x: 0) == zeros(3)
assert m0.applyfunc(lambda x: 1) == ones(3)
def test_gauss_jordan_solve():
# Square, full rank, unique solution
A = Matrix([[1, 2, 3], [4, 5, 6], [7, 8, 10]])
b = Matrix([3, 6, 9])
sol, params = A.gauss_jordan_solve(b)
assert sol == Matrix([[-1], [2], [0]])
assert params == Matrix(0, 1, [])
# Square, full rank, unique solution, B has more columns than rows
A = eye(3)
B = Matrix([[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]])
sol, params = A.gauss_jordan_solve(B)
assert sol == B
assert params == Matrix(0, 4, [])
# Square, reduced rank, parametrized solution
A = Matrix([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
b = Matrix([3, 6, 9])
sol, params, freevar = A.gauss_jordan_solve(b, freevar=True)
w = {}
for s in sol.atoms(Symbol):
# Extract dummy symbols used in the solution.
w[s.name] = s
assert sol == Matrix([[w['tau0'] - 1], [-2 * w['tau0'] + 2], [w['tau0']]])
assert params == Matrix([[w['tau0']]])
assert freevar == [2]
# Square, reduced rank, parametrized solution, B has two columns
A = Matrix([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
B = Matrix([[3, 4], [6, 8], [9, 12]])
sol, params, freevar = A.gauss_jordan_solve(B, freevar=True)
w = {}
for s in sol.atoms(Symbol):
# Extract dummy symbols used in the solution.
w[s.name] = s
assert sol == Matrix([
[w['tau0'] - 1, w['tau1'] - Rational(4, 3)],
[-2 * w['tau0'] + 2, -2 * w['tau1'] + Rational(8, 3)],
[w['tau0'], w['tau1']],
])
assert params == Matrix([[w['tau0'], w['tau1']]])
assert freevar == [2]
# Square, reduced rank, parametrized solution
A = Matrix([[1, 2, 3], [2, 4, 6], [3, 6, 9]])
b = Matrix([0, 0, 0])
sol, params = A.gauss_jordan_solve(b)
w = {}
for s in sol.atoms(Symbol):
w[s.name] = s
assert sol == Matrix([[-2 * w['tau0'] - 3 * w['tau1']], [w['tau0']],
[w['tau1']]])
assert params == Matrix([[w['tau0']], [w['tau1']]])
# Square, reduced rank, parametrized solution
A = Matrix([[0, 0, 0], [0, 0, 0], [0, 0, 0]])
b = Matrix([0, 0, 0])
sol, params = A.gauss_jordan_solve(b)
w = {}
for s in sol.atoms(Symbol):
w[s.name] = s
assert sol == Matrix([[w['tau0']], [w['tau1']], [w['tau2']]])
assert params == Matrix([[w['tau0']], [w['tau1']], [w['tau2']]])
# Square, reduced rank, no solution
A = Matrix([[1, 2, 3], [2, 4, 6], [3, 6, 9]])
b = Matrix([0, 0, 1])
raises(ValueError, lambda: A.gauss_jordan_solve(b))
# Rectangular, tall, full rank, unique solution
A = Matrix([[1, 5, 3], [2, 1, 6], [1, 7, 9], [1, 4, 3]])
b = Matrix([0, 0, 1, 0])
sol, params = A.gauss_jordan_solve(b)
assert sol == Matrix([[Rational(-1, 2)], [0], [Rational(1, 6)]])
assert params == Matrix(0, 1, [])
# Rectangular, tall, full rank, unique solution, B has less columns than rows
A = Matrix([[1, 5, 3], [2, 1, 6], [1, 7, 9], [1, 4, 3]])
B = Matrix([[0, 0], [0, 0], [1, 2], [0, 0]])
sol, params = A.gauss_jordan_solve(B)
assert sol == Matrix([[Rational(-1, 2), Rational(-2, 2)], [0, 0],
[Rational(1, 6), Rational(2, 6)]])
assert params == Matrix(0, 2, [])
# Rectangular, tall, full rank, no solution
A = Matrix([[1, 5, 3], [2, 1, 6], [1, 7, 9], [1, 4, 3]])
b = Matrix([0, 0, 0, 1])
raises(ValueError, lambda: A.gauss_jordan_solve(b))
# Rectangular, tall, full rank, no solution, B has two columns (2nd has no solution)
A = Matrix([[1, 5, 3], [2, 1, 6], [1, 7, 9], [1, 4, 3]])
B = Matrix([[0, 0], [0, 0], [1, 0], [0, 1]])
raises(ValueError, lambda: A.gauss_jordan_solve(B))
# Rectangular, tall, full rank, no solution, B has two columns (1st has no solution)
A = Matrix([[1, 5, 3], [2, 1, 6], [1, 7, 9], [1, 4, 3]])
B = Matrix([[0, 0], [0, 0], [0, 1], [1, 0]])
raises(ValueError, lambda: A.gauss_jordan_solve(B))
# Rectangular, tall, reduced rank, parametrized solution
A = Matrix([[1, 5, 3], [2, 10, 6], [3, 15, 9], [1, 4, 3]])
b = Matrix([0, 0, 0, 1])
sol, params = A.gauss_jordan_solve(b)
w = {}
for s in sol.atoms(Symbol):
w[s.name] = s
assert sol == Matrix([[-3 * w['tau0'] + 5], [-1], [w['tau0']]])
assert params == Matrix([[w['tau0']]])
# Rectangular, tall, reduced rank, no solution
A = Matrix([[1, 5, 3], [2, 10, 6], [3, 15, 9], [1, 4, 3]])
b = Matrix([0, 0, 1, 1])
raises(ValueError, lambda: A.gauss_jordan_solve(b))
# Rectangular, wide, full rank, parametrized solution
A = Matrix([[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 1, 12]])
b = Matrix([1, 1, 1])
sol, params = A.gauss_jordan_solve(b)
w = {}
for s in sol.atoms(Symbol):
w[s.name] = s
assert sol == Matrix([[2 * w['tau0'] - 1], [-3 * w['tau0'] + 1], [0],
[w['tau0']]])
assert params == Matrix([[w['tau0']]])
# Rectangular, wide, reduced rank, parametrized solution
A = Matrix([[1, 2, 3, 4], [5, 6, 7, 8], [2, 4, 6, 8]])
b = Matrix([0, 1, 0])
sol, params = A.gauss_jordan_solve(b)
w = {}
for s in sol.atoms(Symbol):
w[s.name] = s
assert sol == Matrix([[w['tau0'] + 2 * w['tau1'] + S.Half],
[-2 * w['tau0'] - 3 * w['tau1'] - Rational(1, 4)],
[w['tau0']], [w['tau1']]])
assert params == Matrix([[w['tau0']], [w['tau1']]])
# watch out for clashing symbols
x0, x1, x2, _x0 = symbols('_tau0 _tau1 _tau2 tau1')
M = Matrix([[0, 1, 0, 0, 0, 0], [0, 0, 0, 1, 0, _x0]])
A = M[:, :-1]
b = M[:, -1:]
sol, params = A.gauss_jordan_solve(b)
assert params == Matrix(3, 1, [x0, x1, x2])
assert sol == Matrix(5, 1, [x0, 0, x1, _x0, x2])
# Rectangular, wide, reduced rank, no solution
A = Matrix([[1, 2, 3, 4], [5, 6, 7, 8], [2, 4, 6, 8]])
b = Matrix([1, 1, 1])
raises(ValueError, lambda: A.gauss_jordan_solve(b))
# Test for immutable matrix
A = ImmutableMatrix([[1, 0], [0, 1]])
B = ImmutableMatrix([1, 2])
sol, params = A.gauss_jordan_solve(B)
assert sol == ImmutableMatrix([1, 2])
assert params == ImmutableMatrix(0, 1, [])
assert sol.__class__ == ImmutableDenseMatrix
assert params.__class__ == ImmutableDenseMatrix
# Test placement of free variables
A = Matrix([[1, 0, 0, 0], [0, 0, 0, 1]])
b = Matrix([1, 1])
sol, params = A.gauss_jordan_solve(b)
w = {}
for s in sol.atoms(Symbol):
w[s.name] = s
assert sol == Matrix([[1], [w['tau0']], [w['tau1']], [1]])
assert params == Matrix([[w['tau0']], [w['tau1']]])
def translate(x, y):
"""Return the matrix to translate a 2-D point by x and y."""
rv = eye(3)
rv[2, 0] = x
rv[2, 1] = y
return rv
Here we test the extent to which they cooperate
"""
from sympy import symbols
from sympy.matrices import (Matrix, MatrixSymbol, eye, Identity,
ImmutableMatrix)
from sympy.core.compatibility import range
from sympy.matrices.expressions import MatrixExpr, MatAdd
from sympy.matrices.matrices import classof
from sympy.utilities.pytest import raises
SM = MatrixSymbol('X', 3, 3)
SV = MatrixSymbol('v', 3, 1)
MM = Matrix([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
IM = ImmutableMatrix([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
meye = eye(3)
imeye = ImmutableMatrix(eye(3))
ideye = Identity(3)
a, b, c = symbols('a,b,c')
def test_IM_MM():
assert isinstance(MM + IM, ImmutableMatrix)
assert isinstance(IM + MM, ImmutableMatrix)
assert isinstance(2 * IM + MM, ImmutableMatrix)
assert MM.equals(IM)
def test_ME_MM():
assert isinstance(Identity(3) + MM, MatrixExpr)
assert isinstance(SM + MM, MatAdd)
def test_matadd_of_matrices():
assert MatAdd(eye(2), 4 * eye(2),
eye(2)).doit() == ImmutableMatrix(6 * eye(2))
def test_QR_trivial():
# Rank deficient matrices
A = Matrix([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
Q, R = A.QRdecomposition()
assert Q.T * Q == eye(Q.cols)
assert R.is_upper
assert A == Q * R
A = Matrix([[1, 1, 1], [2, 2, 2], [3, 3, 3], [4, 4, 4]])
Q, R = A.QRdecomposition()
assert Q.T * Q == eye(Q.cols)
assert R.is_upper
assert A == Q * R
A = Matrix([[1, 1, 1], [2, 2, 2], [3, 3, 3], [4, 4, 4]]).T
Q, R = A.QRdecomposition()
assert Q.T * Q == eye(Q.cols)
assert R.is_upper
assert A == Q * R
# Zero rank matrices
A = Matrix([[0, 0, 0]])
Q, R = A.QRdecomposition()
assert Q.T * Q == eye(Q.cols)
assert R.is_upper
assert A == Q * R
A = Matrix([[0, 0, 0]]).T
Q, R = A.QRdecomposition()
assert Q.T * Q == eye(Q.cols)
assert R.is_upper
assert A == Q * R
A = Matrix([[0, 0, 0], [0, 0, 0]])
Q, R = A.QRdecomposition()
assert Q.T * Q == eye(Q.cols)
assert R.is_upper
assert A == Q * R
A = Matrix([[0, 0, 0], [0, 0, 0]]).T
Q, R = A.QRdecomposition()
assert Q.T * Q == eye(Q.cols)
assert R.is_upper
assert A == Q * R
# Rank deficient matrices with zero norm from beginning columns
A = Matrix([[0, 0, 0], [1, 2, 3]]).T
Q, R = A.QRdecomposition()
assert Q.T * Q == eye(Q.cols)
assert R.is_upper
assert A == Q * R
A = Matrix([[0, 0, 0, 0], [1, 2, 3, 4], [0, 0, 0, 0]]).T
Q, R = A.QRdecomposition()
assert Q.T * Q == eye(Q.cols)
assert R.is_upper
assert A == Q * R
A = Matrix([[0, 0, 0, 0], [1, 2, 3, 4], [0, 0, 0, 0], [2, 4, 6, 8]]).T
Q, R = A.QRdecomposition()
assert Q.T * Q == eye(Q.cols)
assert R.is_upper
assert A == Q * R
A = Matrix([[0, 0, 0], [0, 0, 0], [0, 0, 0], [1, 2, 3]]).T
Q, R = A.QRdecomposition()
assert Q.T * Q == eye(Q.cols)
assert R.is_upper
assert A == Q * R
def Theorm2(G, k):
row = G.rows
col = G.cols
alpha = col // k
n = row // alpha
d = alpha + k - 1
fail_node = random.randint(1, n)
Z = Functional_regenerating_code_test.generate_Z(alpha, d)
access_nodes = set()
while len(access_nodes) < d:
access_nodes.add(random.randint(1, n))
if fail_node in access_nodes:
access_nodes.remove(fail_node)
access_nodes = list(access_nodes)
b = []
b1 = Functional_regenerating_code_test.generate_b_row_vector(alpha)
# access_matrix = b1* G[access_nodes[0] * alpha: (access_nodes[0] + 1) * alpha, :]
b.append(b1)
for i in range(1, d):
bi = Functional_regenerating_code_test.generate_b_row_vector(alpha)
b.append(bi)
# access_matrix = Matrix([access_matrix,
# bi * G[(access_nodes[i] - 1) * alpha: access_nodes[i] * alpha,
# :]])
original_H = eye(row)
H_sub = b[0] * original_H[access_nodes[0] * alpha:(access_nodes[0] + 1) *
alpha, :]
for i in range(1, d):
H_sub = Matrix([
H_sub, b[i] * original_H[(access_nodes[i] - 1) *
alpha:access_nodes[i] * alpha, :]
])
H = Z * H_sub
tempH = Matrix([
original_H[0:(fail_node - 1) * alpha, :],
original_H[fail_node * alpha:, :]
])
H = Matrix([tempH, H])
# print("H", H)
fail = 1
for p in combinations(list(range(n)), k):
# print(p)
temp_matrix = H[(p[0] - 1) * alpha:p[0] * alpha, :]
for i in range(1, k):
temp_matrix = Matrix(
[temp_matrix, H[(p[i] - 1) * alpha:alpha * p[i], :]])
# print("temp matrix", temp_matrix, temp_matrix.rows, temp_matrix.cols)
rank = temp_matrix.rank()
if rank != k * alpha:
break
fail = 0
if fail == 0:
return 0
else:
return 1
def matrix_form(self, weylelt):
"""
This method takes input from the user in the form of products of the
generating reflections, and returns the matrix corresponding to the
element of the Weyl group. Since each element of the Weyl group is
a reflection of some type, there is a corresponding matrix representation.
This method uses the standard representation for all the generating
reflections.
Example
=======
>>> from sympy.liealgebras.weyl_group import WeylGroup
>>> f = WeylGroup("F4")
>>> f.matrix_form('r2*r3')
Matrix([
[1, 0, 0, 0],
[0, 1, 0, 0],
[0, 0, 0, -1],
[0, 0, 1, 0]])
"""
elts = list(weylelt)
reflections = elts[1::3]
n = self.cartan_type.rank()
if self.cartan_type.series == 'A':
matrixform = eye(n+1)
for elt in reflections:
a = int(elt)
mat = eye(n+1)
mat[a-1, a-1] = 0
mat[a-1, a] = 1
mat[a, a-1] = 1
mat[a, a] = 0
matrixform *= mat
return matrixform
if self.cartan_type.series == 'D':
matrixform = eye(n)
for elt in reflections:
a = int(elt)
mat = eye(n)
if a < n:
mat[a-1, a-1] = 0
mat[a-1, a] = 1
mat[a, a-1] = 1
mat[a, a] = 0
matrixform *= mat
else:
mat[n-2, n-1] = -1
mat[n-2, n-2] = 0
mat[n-1, n-2] = -1
mat[n-1, n-1] = 0
matrixform *= mat
return matrixform
if self.cartan_type.series == 'G':
matrixform = eye(3)
for elt in reflections:
a = int(elt)
if a == 1:
gen1 = Matrix([[1, 0, 0], [0, 0, 1], [0, 1, 0]])
matrixform *= gen1
else:
gen2 = Matrix([[Rational(2, 3), Rational(2, 3), -Rational(1, 3)],
[Rational(2, 3), Rational(-1, 3), Rational(2, 3)], [Rational(-1, 3),
Rational(2, 3), Rational(2, 3)]])
matrixform *= gen2
return matrixform
if self.cartan_type.series == 'F':
matrixform = eye(4)
for elt in reflections:
a = int(elt)
if a == 1:
mat = Matrix([[1, 0, 0, 0], [0, 0, 1, 0], [0, 1, 0, 0], [0, 0, 0, 1]])
matrixform *= mat
elif a == 2:
mat = Matrix([[1, 0, 0, 0], [0, 1, 0, 0], [0, 0, 0, 1], [0, 0, 1, 0]])
matrixform *= mat
elif a == 3:
mat = Matrix([[1, 0, 0, 0], [0, 1, 0, 0], [0, 0, 1, 0], [0, 0, 0, -1]])
matrixform *= mat
else:
mat = Matrix([[Rational(1, 2), Rational(1, 2), Rational(1, 2), Rational(1, 2)],
[Rational(1, 2), Rational(1, 2), Rational(-1, 2), Rational(-1, 2)],
[Rational(1, 2), Rational(-1, 2), Rational(1, 2), Rational(-1, 2)],
[Rational(1, 2), Rational(-1, 2), Rational(-1, 2), Rational(1, 2)]])
matrixform *= mat
return matrixform
if self.cartan_type.series == 'E':
matrixform = eye(8)
for elt in reflections:
a = int(elt)
if a == 1:
mat = Matrix([[Rational(3, 4), Rational(1, 4), Rational(1, 4), Rational(1, 4),
Rational(1, 4), Rational(1, 4), Rational(1, 4), Rational(-1, 4)],
[Rational(1, 4), Rational(3, 4), Rational(-1, 4), Rational(-1, 4),
Rational(-1, 4), Rational(-1, 4), Rational(1, 4), Rational(-1, 4)],
[Rational(1, 4), Rational(-1, 4), Rational(3, 4), Rational(-1, 4),
Rational(-1, 4), Rational(-1, 4), Rational(-1, 4), Rational(1, 4)],
[Rational(1, 4), Rational(-1, 4), Rational(-1, 4), Rational(3, 4),
Rational(-1, 4), Rational(-1, 4), Rational(-1, 4), Rational(1, 4)],
[Rational(1, 4), Rational(-1, 4), Rational(-1, 4), Rational(-1, 4),
Rational(3, 4), Rational(-1, 4), Rational(-1, 4), Rational(1, 4)],
[Rational(1, 4), Rational(-1, 4), Rational(-1, 4), Rational(-1, 4),
Rational(-1, 4), Rational(3, 4), Rational(-1, 4), Rational(1, 4)],
[Rational(1, 4), Rational(-1, 4), Rational(-1, 4), Rational(-1, 4),
Rational(-1, 4), Rational(-1, 4), Rational(-3, 4), Rational(1, 4)],
[Rational(1, 4), Rational(-1, 4), Rational(-1, 4), Rational(-1, 4),
Rational(-1, 4), Rational(-1, 4), Rational(-1, 4), Rational(3, 4)]])
matrixform *= mat
elif a == 2:
mat = eye(8)
mat[0, 0] = 0
mat[0, 1] = -1
mat[1, 0] = -1
mat[1, 1] = 0
matrixform *= mat
else:
mat = eye(8)
mat[a-3, a-3] = 0
mat[a-3, a-2] = 1
mat[a-2, a-3] = 1
mat[a-2, a-2] = 0
matrixform *= mat
return matrixform
if self.cartan_type.series == 'B' or self.cartan_type.series == 'C':
matrixform = eye(n)
for elt in reflections:
a = int(elt)
mat = eye(n)
if a == 1:
mat[0, 0] = -1
matrixform *= mat
else:
mat[a - 2, a - 2] = 0
mat[a-2, a-1] = 1
mat[a - 1, a - 2] = 1
mat[a -1, a - 1] = 0
matrixform *= mat
return matrixform
init_printing(use_unicode=True)
# %%
C = symbols("C", real="True")
sigma_s, sigma_x, sigma_nu = \
symbols(r"\sigma_s \sigma_x \sigma_{\nu}", real=True)
s = Matrix(2, 1, symbols('s_p s_s'), real=True)
mux = Matrix(2, 1, symbols(r'\mu_{x_i} \mu_{x_e}'), real=True)
dmux = Matrix(2, 1, symbols(r'd\mu_{x_i} d\mu_{x_e}'), real=True)
munu = Matrix(2, 1, symbols(r'\mu_{\nu_i} \mu_{\nu_e}'), real=True)
dmunu = Matrix(2, 1, symbols(r'd\mu_{\nu_i} d\mu_{\nu_e}'), real=True)
Sigma_s = eye(2, real=True) * sigma_s
Sigma_x = eye(2, real=True) * sigma_x
Sigma_nu = eye(2, real=True) * sigma_nu
def g(x):
W = eye(2, real=True)
W[1, 0] = 1
return W * x
def f(x, n):
h = symbols("h", real=True, positive=True)
return n - (eye(2, real=True) * h) * x
def grad(f, args, g=None, output_type=None):
"""Return the vector field gradient of a function f(x).
Examples:
=========
>>> from tensor_analysis.tensor_fields import grad
>>> from sympy import symbols, sin
>>> from tensor_analysis.arraypy import Arraypy
>>> x1, x2, x3 = symbols('x1 x2 x3')
f it's a function the differential of that is calculated:
>>> f=x1**2*x2 + sin(x2*x3 - x2)
args it's a list of symbol arguments of function of f.
It can be in list, array of arraypy or contravariant tensor:
>>> args=[x1,x2,x3]
g - optional parameter, metric tensor, which can be a matrix "Matrix",
array of arraypy or covariant tensor:
>>> g=Arraypy([2,3,1])
>>> g_t=g.to_tensor((-1,-1))
>>> g_t[1,1]=2
>>> g_t[1,2]=1
>>> g_t[1,3]=0
>>> g_t[2,1]=1
>>> g_t[2,2]=3
>>> g_t[2,3]=0
>>> g_t[3,1]=0
>>> g_t[3,2]=0
>>> g_t[3,3]=1
output _ type it is an optional parameter accepting symbol value of
'l', 'a' or 't' and indicative on the type of result of calculations:
- 'l' it is a result as a list(list);
- 'a' it is a result as an unidimensional array of arraypy;
- 't' it is a result as an unidimensional covariant tensor.
Gradient:
>>> gr=grad(f,args,g_t,'a')
>>> print(gr)
-x1**2/5 + 6*x1*x2/5 - (x3 - 1)*cos(x2*x3 - x2)/5 2*x1**2/5 - 2*x1*x2/5 + \
2*(x3 - 1)*cos(x2*x3 - x2)/5 x2*cos(x2*x3 - x2)
"""
# Handling of a vector of arguments
check_vector_of_arguments(args)
# The definition of the start index
if isinstance(args, list):
idx_args = 0
else:
idx_args = args.start_index[0]
# Handling of the metric tensor
# 1. if g is not NULL
if g is not None:
if output_type is None:
output_type = 't'
check_metric_tensor(g)
# The definition of the start index
if isinstance(g, Matrix):
idx_st = 0
else:
idx_st = g.start_index[0]
# The start index is the same
if isinstance(g, type(args)) and idx_st != idx_args:
raise ValueError(
"The start index of the metric tensor and vector of arguments \
must be equal")
if isinstance(g, (TensorArray, Arraypy)):
g = g.to_matrix()
# 2.if g is NULL
else:
# g - the identity matrix
g = eye(len(args))
idx_st = 0
# Creating the output array in accordance with start indexes
n = len(args)
array = Arraypy([1, n, idx_st])
indices = range(idx_st, idx_st + n)
# Calculating
g_inv = g.inv()
if isinstance(args, (TensorArray, Arraypy)):
args = args.to_list()
for i in indices:
for j in indices:
array[i] += (g_inv[i - idx_st, j - idx_st] *
diff(f, args[j - idx_st]))
# Handling of an output array
if output_type == 't' or output_type == Symbol('t'):
gradient = Arraypy.to_tensor(array, 1)
elif output_type == 'a' or output_type == Symbol('a'):
gradient = array
elif output_type == 'l' or output_type == Symbol('l') or output_type is \
None:
gradient = Arraypy.to_list(array)
else:
raise TypeError(
"The third argument must be 't' - tensor,'a' - Arraypy, \
'l' - list")
# Output
return gradient
def test_equality():
a, b, c = Identity(3), eye(3), ImmutableMatrix(eye(3))
for x in [a, b, c]:
for y in [a, b, c]:
assert x.equals(y)
def test_matadd_sympify():
assert isinstance(MatAdd(eye(1), eye(1)).args[0], Basic)
def test_sparse_zeros_sparse_eye():
assert SparseMatrix.eye(3) == eye(3, cls=SparseMatrix)
assert len(SparseMatrix.eye(3)._smat) == 3
assert SparseMatrix.zeros(3) == zeros(3, cls=SparseMatrix)
assert len(SparseMatrix.zeros(3)._smat) == 0
def test_matmul_sympify():
assert isinstance(MatMul(eye(1), eye(1)).args[0], Basic)
def diverg(X, args, g=None):
"""Return the divergence of a vector field X. Compute divergence of vector
field consisting of N elements.
Examples:
=========
>>> from tensor_analysis.tensor_fields import diverg
>>> from sympy import symbols, cos
>>> from sympy.matrices import Matrix
>>> x1, x2, x3 = symbols('x1 x2 x3')
X is a vector field, args it's a list of symbol arguments of the vector
field X. It's can be in list, array of arraypy or contravariant tensor:
>>> X = [x1*x2**3,x2-cos(x3),x3**3-x1]
>>> arg = [x1, x2, x3]
g - optional parameter, metric tensor, which can be a matrix "Matrix",
array of arraypy or covariant tensor:
>>> g = Matrix([[2,1,0],[1,3,0],[0,0,1]])
>>> dv = diverg(X,arg,g)
>>> print(dv)
x2**3 + 3*x3**2 + 1
"""
# Handling of a vector of arguments
check_vector_of_arguments(args)
if isinstance(args, list):
idx_args = 0
else:
idx_args = args.start_index[0]
# Handling of the first vector field
check_the_vector_field(X)
if isinstance(X, (TensorArray, Arraypy)):
idx_X = X.start_index[0]
else:
idx_X = 0
if idx_args != idx_X:
raise ValueError(
"The start index of vector field and vector of arguments must be \
equal")
# Handling of the metric tensor
if g is not None:
if isinstance(g, (TensorArray, Arraypy)):
g = g.to_matrix()
else:
g = eye(len(args))
# Calculation
sq = sqrt(abs(det(g)))
diver = 0
for k in range(len(args)):
diver += simplify(1 / sq *
sum([diff(X[k + idx_X] * sq, args[k + idx_X])]))
# Output
return diver
def element_order(self, weylelt):
"""
This method returns the order of a given Weyl group element, which should
be specified by the user in the form of products of the generating
reflections, i.e. of the form r1*r2 etc.
For types A-F, this method current works by taking the matrix form of
the specified element, and then finding what power of the matrix is the
identity. It then returns this power.
Example
========
>>> from sympy.liealgebras.weyl_group import WeylGroup
>>> b = WeylGroup("B4")
>>> b.element_order('r1*r4*r2')
4
"""
n = self.cartan_type.rank()
if self.cartan_type.series == "A":
a = self.matrix_form(weylelt)
order = 1
while a != eye(n+1):
a *= self.matrix_form(weylelt)
order += 1
return order
if self.cartan_type.series == "D":
a = self.matrix_form(weylelt)
order = 1
while a != eye(n):
a *= self.matrix_form(weylelt)
order += 1
return order
if self.cartan_type.series == "E":
a = self.matrix_form(weylelt)
order = 1
while a != eye(8):
a *= self.matrix_form(weylelt)
order += 1
return order
if self.cartan_type.series == "G":
elts = list(weylelt)
reflections = elts[1::3]
m = self.delete_doubles(reflections)
while self.delete_doubles(m) != m:
m = self.delete_doubles(m)
reflections = m
if len(reflections) % 2 == 1:
return 2
elif len(reflections) == 0:
return 1
else:
if len(reflections) == 1:
return 2
else:
m = len(reflections) / 2
lcm = (6 * m)/ igcd(m, 6)
order = lcm / m
return order
if self.cartan_type.series == 'F':
a = self.matrix_form(weylelt)
order = 1
while a != eye(4):
a *= self.matrix_form(weylelt)
order += 1
return order
if self.cartan_type.series == "B" or self.cartan_type.series == "C":
a = self.matrix_form(weylelt)
order = 1
while a != eye(n):
a *= self.matrix_form(weylelt)
order += 1
return order
def run_circuit(self, circuit):
"""Run a circuit and return the results.
Args:
circuit (dict): JSON that describes the circuit
Returns:
dict: A dictionary of results which looks something like::
{'data': {'unitary': array([[sqrt(2)/2, sqrt(2)/2, 0, 0],
[0, 0, sqrt(2)/2, -sqrt(2)/2],
[0, 0, sqrt(2)/2, sqrt(2)/2],
[sqrt(2)/2, -sqrt(2)/2, 0, 0]], dtype=object)
},
'status': 'DONE'}
Raises:
SimulatorError: if unsupported operations passed
"""
ccircuit = circuit['compiled_circuit']
self._number_of_qubits = ccircuit['header']['number_of_qubits']
result = {}
result['data'] = {}
self._unitary_state = eye(2**self._number_of_qubits)
for operation in ccircuit['operations']:
if 'conditional' in operation:
raise SimulatorError(
'conditional operations not supported in unitary simulator'
)
if operation['name'] == 'measure' or operation['name'] == 'reset':
raise SimulatorError('operation {} not supported by '
'sympy unitary simulator.'.format(
operation['name']))
if operation['name'] in ['U', 'u1', 'u2', 'u3']:
if 'params' in operation:
params = operation['params']
else:
params = None
qubit = operation['qubits'][0]
gate = SympyUnitarySimulator.compute_ugate_matrix_wrap(params)
self._add_unitary_single(gate, qubit)
elif operation['name'] in ['id']:
logger.info(
'Identity gate is ignored by sympy-based unitary simulator.'
)
elif operation['name'] in ['barrier']:
logger.info(
'Barrier is ignored by sympy-based unitary simulator.')
elif operation['name'] in ['CX', 'cx']:
qubit0 = operation['qubits'][0]
qubit1 = operation['qubits'][1]
gate = Matrix([[1, 0, 0, 0], [0, 0, 0, 1], [0, 0, 1, 0],
[0, 1, 0, 0]])
self._add_unitary_two(gate, qubit0, qubit1)
else:
result['status'] = 'ERROR'
return result
result['data']['unitary'] = np.array(self._unitary_state)
result['status'] = 'DONE'
result['name'] = circuit['name']
return result
def _pinv_solve(M, B, arbitrary_matrix=None):
"""Solve ``Ax = B`` using the Moore-Penrose pseudoinverse.
There may be zero, one, or infinite solutions. If one solution
exists, it will be returned. If infinite solutions exist, one will
be returned based on the value of arbitrary_matrix. If no solutions
exist, the least-squares solution is returned.
Parameters
==========
B : Matrix
The right hand side of the equation to be solved for. Must have
the same number of rows as matrix A.
arbitrary_matrix : Matrix
If the system is underdetermined (e.g. A has more columns than
rows), infinite solutions are possible, in terms of an arbitrary
matrix. This parameter may be set to a specific matrix to use
for that purpose; if so, it must be the same shape as x, with as
many rows as matrix A has columns, and as many columns as matrix
B. If left as None, an appropriate matrix containing dummy
symbols in the form of ``wn_m`` will be used, with n and m being
row and column position of each symbol.
Returns
=======
x : Matrix
The matrix that will satisfy ``Ax = B``. Will have as many rows as
matrix A has columns, and as many columns as matrix B.
Examples
========
>>> from sympy import Matrix
>>> A = Matrix([[1, 2, 3], [4, 5, 6]])
>>> B = Matrix([7, 8])
>>> A.pinv_solve(B)
Matrix([
[ _w0_0/6 - _w1_0/3 + _w2_0/6 - 55/18],
[-_w0_0/3 + 2*_w1_0/3 - _w2_0/3 + 1/9],
[ _w0_0/6 - _w1_0/3 + _w2_0/6 + 59/18]])
>>> A.pinv_solve(B, arbitrary_matrix=Matrix([0, 0, 0]))
Matrix([
[-55/18],
[ 1/9],
[ 59/18]])
See Also
========
sympy.matrices.dense.DenseMatrix.lower_triangular_solve
sympy.matrices.dense.DenseMatrix.upper_triangular_solve
gauss_jordan_solve
cholesky_solve
diagonal_solve
LDLsolve
LUsolve
QRsolve
pinv
Notes
=====
This may return either exact solutions or least squares solutions.
To determine which, check ``A * A.pinv() * B == B``. It will be
True if exact solutions exist, and False if only a least-squares
solution exists. Be aware that the left hand side of that equation
may need to be simplified to correctly compare to the right hand
side.
References
==========
.. [1] https://en.wikipedia.org/wiki/Moore-Penrose_pseudoinverse#Obtaining_all_solutions_of_a_linear_system
"""
from sympy.matrices import eye
A = M
A_pinv = M.pinv()
if arbitrary_matrix is None:
rows, cols = A.cols, B.cols
w = symbols('w:{}_:{}'.format(rows, cols), cls=Dummy)
arbitrary_matrix = M.__class__(cols, rows, w).T
return A_pinv.multiply(B) + (eye(A.cols) -
A_pinv.multiply(A)).multiply(arbitrary_matrix)