1import pytest
2
3from diofant import ImmutableMatrix as Matrix
4from diofant import cos, pi, simplify, sin, symbols
5from diofant.vector import (BaseDyadic, CoordSysCartesian, Dyadic, DyadicAdd,
6                            DyadicMul, DyadicZero, Vector, express)
7
8
9__all__ = ()
10
11A = CoordSysCartesian('A')
12
13
14def test_dyadic():
15    a, b = symbols('a, b')
16    assert Dyadic.zero != 0
17    assert isinstance(Dyadic.zero, DyadicZero)
18    assert BaseDyadic(A.i, A.j) != BaseDyadic(A.j, A.i)
19    assert (BaseDyadic(Vector.zero, A.i) ==
20            BaseDyadic(A.i, Vector.zero) == Dyadic.zero)
21    pytest.raises(TypeError, lambda: BaseDyadic(A.i, a))
22    pytest.raises(TypeError, lambda: BaseDyadic(a, A.j))
23
24    d1 = A.i | A.i
25    d2 = A.j | A.j
26    d3 = A.i | A.j
27
28    assert isinstance(d1, BaseDyadic)
29    d_mul = a*d1
30    assert isinstance(d_mul, DyadicMul)
31    assert d_mul.base_dyadic == d1
32    assert d_mul.measure_number == a
33    assert isinstance(a*d1 + b*d3, DyadicAdd)
34    assert d1 == A.i.outer(A.i)
35    assert d3 == A.i.outer(A.j)
36    v1 = a*A.i - A.k
37    v2 = A.i + b*A.j
38    assert v1 | v2 == v1.outer(v2) == (a * (A.i | A.i) + (a*b) * (A.i | A.j)
39                                       - (A.k | A.i) - b * (A.k | A.j))
40    pytest.raises(TypeError, lambda: A.i.outer(A.x))
41
42    assert d1 * 0 == Dyadic.zero
43    assert d1 != Dyadic.zero
44    assert d1 * 2 == 2 * (A.i | A.i)
45    assert d1 / 2. == 0.5 * d1
46    pytest.raises(TypeError, lambda: d1/d2)
47
48    assert d1.dot(0 * d1) == Vector.zero
49    assert d1 & d2 == Dyadic.zero
50    assert d1.dot(A.i) == A.i == d1 & A.i
51    pytest.raises(TypeError, lambda: d1.dot(a))
52
53    assert d1.cross(Vector.zero) == Dyadic.zero
54    assert d1.cross(A.i) == Dyadic.zero
55    assert d1 ^ A.j == d1.cross(A.j)
56    assert d1.cross(A.k) == - A.i | A.j
57    assert d2.cross(A.i) == - A.j | A.k == d2 ^ A.i
58    pytest.raises(TypeError, lambda: d1.cross(a))
59
60    assert A.i ^ d1 == Dyadic.zero
61    assert A.j.cross(d1) == - A.k | A.i == A.j ^ d1
62    assert Vector.zero.cross(d1) == Dyadic.zero
63    assert A.k ^ d1 == A.j | A.i
64    assert A.i.dot(d1) == A.i & d1 == A.i
65    assert A.j.dot(d1) == Vector.zero
66    assert Vector.zero.dot(d1) == Vector.zero
67    assert A.j & d2 == A.j
68
69    assert d1.dot(d3) == d1 & d3 == A.i | A.j == d3
70    assert d3 & d1 == Dyadic.zero
71
72    q = symbols('q')
73    B = A.orient_new_axis('B', q, A.k)
74    assert express(d1, B) == express(d1, B, B)
75    assert express(d1, B) == ((cos(q)**2) * (B.i | B.i) + (-sin(q) * cos(q)) *
76                              (B.i | B.j) + (-sin(q) * cos(q)) * (B.j | B.i) + (sin(q)**2) *
77                              (B.j | B.j))
78    assert express(d1, B, A) == (cos(q)) * (B.i | A.i) + (-sin(q)) * (B.j | A.i)
79    assert express(d1, A, B) == (cos(q)) * (A.i | B.i) + (-sin(q)) * (A.i | B.j)
80    assert d1.to_matrix(A) == Matrix([[1, 0, 0], [0, 0, 0], [0, 0, 0]])
81    assert d1.to_matrix(A, B) == Matrix([[cos(q), -sin(q), 0],
82                                         [0, 0, 0],
83                                         [0, 0, 0]])
84    assert d3.to_matrix(A) == Matrix([[0, 1, 0], [0, 0, 0], [0, 0, 0]])
85    a, b, c, d, e, f = symbols('a, b, c, d, e, f')
86    v1 = a * A.i + b * A.j + c * A.k
87    v2 = d * A.i + e * A.j + f * A.k
88    d4 = v1.outer(v2)
89    assert d4.to_matrix(A) == Matrix([[a * d, a * e, a * f],
90                                      [b * d, b * e, b * f],
91                                      [c * d, c * e, c * f]])
92    d5 = v1.outer(v1)
93    C = A.orient_new_axis('C', q, A.i)
94    for expected, actual in zip(C.rotation_matrix(A) * d5.to_matrix(A) *
95                                C.rotation_matrix(A).T, d5.to_matrix(C)):
96        assert (expected - actual).simplify() == 0
97
98
99def test_dyadic_simplify():
100    x, y, k, m, s, A = symbols('x, y, k, m, s, A')
101    N = CoordSysCartesian('N')
102
103    dy = N.i | N.i
104    test1 = (1 / x + 1 / y) * dy
105    assert (N.i & test1 & N.i) != (x + y) / (x * y)
106    test1 = test1.simplify()
107    assert test1.simplify() == simplify(test1)
108    assert (N.i & test1 & N.i) == (x + y) / (x * y)
109
110    test2 = (A**2 * s**4 / (4 * pi * k * m**3)) * dy
111    test2 = test2.simplify()
112    assert (N.i & test2 & N.i) == (A**2 * s**4 / (4 * pi * k * m**3))
113
114    test3 = ((4 + 4 * x - 2 * (2 + 2 * x)) / (2 + 2 * x)) * dy
115    test3 = test3.simplify()
116    assert (N.i & test3 & N.i) == 0
117
118    test4 = ((-4 * x * y**2 - 2 * y**3 - 2 * x**2 * y) / (x + y)**2) * dy
119    test4 = test4.simplify()
120    assert (N.i & test4 & N.i) == -2 * y
121