def test_locatenew_point():
"""
Tests Point class, and locate_new method in CoordSysCartesian.
"""
A = CoordSysCartesian('A')
assert isinstance(A.origin, Point)
v = a * A.i + b * A.j + c * A.k
C = A.locate_new('C', v)
pytest.raises(TypeError, lambda: C.origin.position_wrt(1))
assert C.origin.position_wrt(A) == \
C.position_wrt(A) == \
C.origin.position_wrt(A.origin) == v
assert A.origin.position_wrt(C) == \
A.position_wrt(C) == \
A.origin.position_wrt(C.origin) == -v
assert A.origin.express_coordinates(C) == (-a, -b, -c)
p = A.origin.locate_new('p', -v)
assert p.express_coordinates(A) == (-a, -b, -c)
assert p.position_wrt(C.origin) == p.position_wrt(C) == \
-2 * v
p1 = p.locate_new('p1', 2 * v)
assert p1.position_wrt(C.origin) == Vector.zero
assert p1.express_coordinates(C) == (0, 0, 0)
p2 = p.locate_new('p2', A.i)
assert p1.position_wrt(p2) == 2 * v - A.i
assert p2.express_coordinates(C) == (-2 * a + 1, -2 * b, -2 * c)
def test_orienters():
A = CoordSysCartesian('A')
axis_orienter = AxisOrienter(a, A.k)
B = body_orienter = BodyOrienter(a, b, c, '123')
assert (B.angle1, B.angle2, B.angle3) == (a, b, c)
assert B.rot_order == '123'
B = BodyOrienter(a, b, c, Symbol('123'))
assert B.rot_order == '123'
space_orienter = SpaceOrienter(a, b, c, '123')
Q = q_orienter = QuaternionOrienter(q1, q2, q3, q4)
assert (Q.q0, Q.q1, Q.q2, Q.q3) == (q1, q2, q3, q4)
assert axis_orienter.rotation_matrix(A) == Matrix([[+cos(a),
sin(a), 0],
[-sin(a),
cos(a), 0], [0, 0, 1]])
assert body_orienter.rotation_matrix() == Matrix(
[[
cos(b) * cos(c),
sin(a) * sin(b) * cos(c) + sin(c) * cos(a),
sin(a) * sin(c) - sin(b) * cos(a) * cos(c)
],
[
-sin(c) * cos(b), -sin(a) * sin(b) * sin(c) + cos(a) * cos(c),
sin(a) * cos(c) + sin(b) * sin(c) * cos(a)
], [sin(b), -sin(a) * cos(b),
cos(a) * cos(b)]])
assert space_orienter.rotation_matrix() == Matrix(
[[cos(b) * cos(c), sin(c) * cos(b), -sin(b)],
[
sin(a) * sin(b) * cos(c) - sin(c) * cos(a),
sin(a) * sin(b) * sin(c) + cos(a) * cos(c),
sin(a) * cos(b)
],
[
sin(a) * sin(c) + sin(b) * cos(a) * cos(c),
-sin(a) * cos(c) + sin(b) * sin(c) * cos(a),
cos(a) * cos(b)
]])
assert q_orienter.rotation_matrix() == Matrix(
[[
q1**2 + q2**2 - q3**2 - q4**2, 2 * q1 * q4 + 2 * q2 * q3,
-2 * q1 * q3 + 2 * q2 * q4
],
[
-2 * q1 * q4 + 2 * q2 * q3, q1**2 - q2**2 + q3**2 - q4**2,
2 * q1 * q2 + 2 * q3 * q4
],
[
2 * q1 * q3 + 2 * q2 * q4, -2 * q1 * q2 + 2 * q3 * q4,
q1**2 - q2**2 - q3**2 + q4**2
]])
B = CoordSysCartesian('T')
pytest.raises(ValueError, lambda: A.orient_new_axis('A', a, B.i))
pytest.raises(TypeError, lambda: BodyOrienter(a, b, c, '12'))
pytest.raises(TypeError, lambda: BodyOrienter(a, b, c, '111'))
def test_custom_names():
A = CoordSysCartesian('A', vector_names=['x', 'y', 'z'],
variable_names=['i', 'j', 'k'])
assert str(A.i) == 'x'
assert str(A.x) == 'i'
assert A.i._pretty_form == 'A_x'
assert A.x._pretty_form == 'A_i'
assert A.i._latex_form == r'\mathbf{\hat{x}_{A}}'
assert A.x._latex_form == r'\mathbf{{i}_{A}}'
def test_rotation_matrix():
N = CoordSysCartesian('N')
A = N.orient_new_axis('A', q1, N.k)
B = A.orient_new_axis('B', q2, A.i)
C = B.orient_new_axis('C', q3, B.j)
D = N.orient_new_axis('D', q4, N.j)
E = N.orient_new_space('E', q1, q2, q3, '123')
F = N.orient_new_quaternion('F', q1, q2, q3, q4)
G = N.orient_new_body('G', q1, q2, q3, '123')
assert N.rotation_matrix(C) == Matrix([
[- sin(q1) * sin(q2) * sin(q3) + cos(q1) * cos(q3), - sin(q1) *
cos(q2), sin(q1) * sin(q2) * cos(q3) + sin(q3) * cos(q1)],
[sin(q1) * cos(q3) + sin(q2) * sin(q3) * cos(q1),
cos(q1) * cos(q2), sin(q1) * sin(q3) - sin(q2) * cos(q1) *
cos(q3)], [- sin(q3) * cos(q2), sin(q2), cos(q2) * cos(q3)]])
test_mat = D.rotation_matrix(C) - Matrix(
[[cos(q1) * cos(q3) * cos(q4) - sin(q3) * (- sin(q4) * cos(q2) +
sin(q1) * sin(q2) * cos(q4)), - sin(q2) * sin(q4) - sin(q1) *
cos(q2) * cos(q4), sin(q3) * cos(q1) * cos(q4) + cos(q3) *
(- sin(q4) * cos(q2) + sin(q1) * sin(q2) * cos(q4))],
[sin(q1) * cos(q3) + sin(q2) * sin(q3) * cos(q1), cos(q1) *
cos(q2), sin(q1) * sin(q3) - sin(q2) * cos(q1) * cos(q3)],
[sin(q4) * cos(q1) * cos(q3) - sin(q3) * (cos(q2) * cos(q4) +
sin(q1) * sin(q2) *
sin(q4)), sin(q2) *
cos(q4) - sin(q1) * sin(q4) * cos(q2), sin(q3) *
sin(q4) * cos(q1) + cos(q3) * (cos(q2) * cos(q4) +
sin(q1) * sin(q2) * sin(q4))]])
assert test_mat.expand() == zeros(3, 3)
assert E.rotation_matrix(N) == Matrix(
[[cos(q2)*cos(q3), sin(q3)*cos(q2), -sin(q2)],
[sin(q1)*sin(q2)*cos(q3) - sin(q3)*cos(q1),
sin(q1)*sin(q2)*sin(q3) + cos(q1)*cos(q3), sin(q1)*cos(q2)],
[sin(q1)*sin(q3) + sin(q2)*cos(q1)*cos(q3), -
sin(q1)*cos(q3) + sin(q2)*sin(q3)*cos(q1), cos(q1)*cos(q2)]])
assert F.rotation_matrix(N) == Matrix([[
q1**2 + q2**2 - q3**2 - q4**2,
2*q1*q4 + 2*q2*q3, -2*q1*q3 + 2*q2*q4], [ -2*q1*q4 + 2*q2*q3,
q1**2 - q2**2 + q3**2 - q4**2, 2*q1*q2 + 2*q3*q4],
[2*q1*q3 + 2*q2*q4,
-2*q1*q2 + 2*q3*q4,
q1**2 - q2**2 - q3**2 + q4**2]])
assert G.rotation_matrix(N) == Matrix([[
cos(q2)*cos(q3), sin(q1)*sin(q2)*cos(q3) + sin(q3)*cos(q1),
sin(q1)*sin(q3) - sin(q2)*cos(q1)*cos(q3)], [
-sin(q3)*cos(q2), -sin(q1)*sin(q2)*sin(q3) + cos(q1)*cos(q3),
sin(q1)*cos(q3) + sin(q2)*sin(q3)*cos(q1)], [
sin(q2), -sin(q1)*cos(q2), cos(q1)*cos(q2)]])
pytest.raises(TypeError, lambda: G.rotation_matrix(a))
def test_orient_new_methods():
N = CoordSysCartesian('N')
orienter1 = AxisOrienter(q4, N.j)
orienter2 = SpaceOrienter(q1, q2, q3, '123')
orienter3 = QuaternionOrienter(q1, q2, q3, q4)
orienter4 = BodyOrienter(q1, q2, q3, '123')
D = N.orient_new('D', (orienter1, ))
E = N.orient_new('E', (orienter2, ))
F = N.orient_new('F', (orienter3, ))
G = N.orient_new('G', (orienter4, ))
assert D == N.orient_new_axis('D', q4, N.j)
assert E == N.orient_new_space('E', q1, q2, q3, '123')
assert F == N.orient_new_quaternion('F', q1, q2, q3, q4)
assert G == N.orient_new_body('G', q1, q2, q3, '123')
pytest.raises(TypeError, lambda: AxisOrienter(q4, 1))
def test_dyadic_simplify():
x, y, z, k, n, m, w, f, s, A = symbols('x, y, z, k, n, m, w, f, s, A')
N = CoordSysCartesian('N')
dy = N.i | N.i
test1 = (1 / x + 1 / y) * dy
assert (N.i & test1 & N.i) != (x + y) / (x * y)
test1 = test1.simplify()
assert test1.simplify() == simplify(test1)
assert (N.i & test1 & N.i) == (x + y) / (x * y)
test2 = (A**2 * s**4 / (4 * pi * k * m**3)) * dy
test2 = test2.simplify()
assert (N.i & test2 & N.i) == (A**2 * s**4 / (4 * pi * k * m**3))
test3 = ((4 + 4 * x - 2 * (2 + 2 * x)) / (2 + 2 * x)) * dy
test3 = test3.simplify()
assert (N.i & test3 & N.i) == 0
test4 = ((-4 * x * y**2 - 2 * y**3 - 2 * x**2 * y) / (x + y)**2) * dy
test4 = test4.simplify()
assert (N.i & test4 & N.i) == -2 * y
def test_func_args():
A = CoordSysCartesian('A')
assert A.x.func(*A.x.args) == A.x
expr = 3*A.x + 4*A.y
assert expr.func(*expr.args) == expr
assert A.i.func(*A.i.args) == A.i
v = A.x*A.i + A.y*A.j + A.z*A.k
assert v.func(*v.args) == v
assert A.origin.func(*A.origin.args) == A.origin
pytest.raises(TypeError, lambda: CoordSysCartesian('B', parent=A,
location=Point('a')))
pytest.raises(TypeError, lambda: CoordSysCartesian('A',
rotation_matrix=a))
pytest.raises(TypeError, lambda: CoordSysCartesian('B', parent=a))
pytest.raises(ValueError, lambda: CoordSysCartesian('A', vector_names=(1,)))
pytest.raises(TypeError, lambda: CoordSysCartesian('A', vector_names=('a', 'b', 1)))
from diofant import (sin, cos, symbols, pi, ImmutableMatrix as Matrix,
simplify)
from diofant.vector import (CoordSysCartesian, Vector, Dyadic, DyadicAdd,
DyadicMul, DyadicZero, BaseDyadic, express)
A = CoordSysCartesian('A')
def test_dyadic():
a, b = symbols('a, b')
assert Dyadic.zero != 0
assert isinstance(Dyadic.zero, DyadicZero)
assert BaseDyadic(A.i, A.j) != BaseDyadic(A.j, A.i)
assert (BaseDyadic(Vector.zero, A.i) == BaseDyadic(A.i, Vector.zero) ==
Dyadic.zero)
d1 = A.i | A.i
d2 = A.j | A.j
d3 = A.i | A.j
assert isinstance(d1, BaseDyadic)
d_mul = a * d1
assert isinstance(d_mul, DyadicMul)
assert d_mul.base_dyadic == d1
assert d_mul.measure_number == a
assert isinstance(a * d1 + b * d3, DyadicAdd)
assert d1 == A.i.outer(A.i)
assert d3 == A.i.outer(A.j)
v1 = a * A.i - A.k
v2 = A.i + b * A.j
assert v1 | v2 == v1.outer(v2) == (a * (A.i | A.i) + (a * b) *
def test_coordsyscartesian_equivalence():
A = CoordSysCartesian('A')
A1 = CoordSysCartesian('A')
assert A1 == A
B = CoordSysCartesian('B')
assert A != B
def test_evalf():
A = CoordSysCartesian('A')
v = 3 * A.i + 4 * A.j + a * A.k
assert v.evalf(subs={a: 1}) == v.subs({a: 1}).evalf()
def test_vector():
# Tests the effects of orientation of coordinate systems on
# basic vector operations.
N = CoordSysCartesian('N')
A = N.orient_new_axis('A', q1, N.k)
B = A.orient_new_axis('B', q2, A.i)
C = B.orient_new_axis('C', q3, B.j)
# Test to_matrix
v1 = a * N.i + b * N.j + c * N.k
assert v1.to_matrix(A) == Matrix([[a * cos(q1) + b * sin(q1)],
[-a * sin(q1) + b * cos(q1)], [c]])
# Test dot
assert N.i.dot(A.i) == cos(q1)
assert N.i.dot(A.j) == -sin(q1)
assert N.i.dot(A.k) == 0
assert N.j.dot(A.i) == sin(q1)
assert N.j.dot(A.j) == cos(q1)
assert N.j.dot(A.k) == 0
assert N.k.dot(A.i) == 0
assert N.k.dot(A.j) == 0
assert N.k.dot(A.k) == 1
assert N.i.dot(A.i + A.j) == -sin(q1) + cos(q1) == \
(A.i + A.j).dot(N.i)
assert A.i.dot(C.i) == cos(q3)
assert A.i.dot(C.j) == 0
assert A.i.dot(C.k) == sin(q3)
assert A.j.dot(C.i) == sin(q2) * sin(q3)
assert A.j.dot(C.j) == cos(q2)
assert A.j.dot(C.k) == -sin(q2) * cos(q3)
assert A.k.dot(C.i) == -cos(q2) * sin(q3)
assert A.k.dot(C.j) == sin(q2)
assert A.k.dot(C.k) == cos(q2) * cos(q3)
pytest.raises(TypeError, lambda: N.i.dot(A.x))
# Test cross
assert N.i.cross(A.i) == sin(q1) * A.k
assert N.i.cross(A.j) == cos(q1) * A.k
assert N.i.cross(A.k) == -sin(q1) * A.i - cos(q1) * A.j
assert N.j.cross(A.i) == -cos(q1) * A.k
assert N.j.cross(A.j) == sin(q1) * A.k
assert N.j.cross(A.k) == cos(q1) * A.i - sin(q1) * A.j
assert N.k.cross(A.i) == A.j
assert N.k.cross(A.j) == -A.i
assert N.k.cross(A.k) == Vector.zero
assert N.i.cross(A.i) == sin(q1) * A.k
assert N.i.cross(A.j) == cos(q1) * A.k
assert N.i.cross(A.i + A.j) == sin(q1) * A.k + cos(q1) * A.k
assert (A.i + A.j).cross(N.i) == (-sin(q1) - cos(q1)) * N.k
assert A.i.cross(C.i) == sin(q3) * C.j
assert A.i.cross(C.j) == -sin(q3) * C.i + cos(q3) * C.k
assert A.i.cross(C.k) == -cos(q3) * C.j
assert C.i.cross(A.i) == (-sin(q3)*cos(q2))*A.j + \
(-sin(q2)*sin(q3))*A.k
assert C.j.cross(A.i) == (sin(q2)) * A.j + (-cos(q2)) * A.k
assert express(C.k.cross(A.i), C).trigsimp() == cos(q3) * C.j
pytest.raises(TypeError, lambda: N.i.cross(A.x))
def test_coordinate_vars():
# Tests the coordinate variables functionality with respect to
# reorientation of coordinate systems.
A = CoordSysCartesian('A')
# Note that the name given on the lhs is different from A.x._name
assert BaseScalar('A.x', 0, A, 'A_x', r'\mathbf{{x}_{A}}') == A.x
assert BaseScalar('A.y', 1, A, 'A_y', r'\mathbf{{y}_{A}}') == A.y
assert BaseScalar('A.z', 2, A, 'A_z', r'\mathbf{{z}_{A}}') == A.z
assert hash(BaseScalar('A.x', 0, A, 'A_x',
r'\mathbf{{x}_{A}}')) == hash(A.x)
assert all(isinstance(_, BaseScalar) for _ in (A.x, A.y, A.z))
assert A.x * A.y == A.y * A.x
pytest.raises(TypeError, lambda: BaseScalar('Ax', 0, 1, ' ', ' '))
pytest.raises(ValueError, lambda: BaseScalar('Ax', 5, A, ' ', ' '))
assert A.scalar_map(A) == {A.x: A.x, A.y: A.y, A.z: A.z}
assert A.x.system == A
assert A.x.diff(A.x) == 1
B = A.orient_new_axis('B', q, A.k)
assert B.scalar_map(A) == {
B.z: A.z,
B.y: -A.x * sin(q) + A.y * cos(q),
B.x: A.x * cos(q) + A.y * sin(q)
}
assert A.scalar_map(B) == {
A.x: B.x * cos(q) - B.y * sin(q),
A.y: B.x * sin(q) + B.y * cos(q),
A.z: B.z
}
assert express(B.x, A, variables=True) == A.x * cos(q) + A.y * sin(q)
assert express(B.y, A, variables=True) == -A.x * sin(q) + A.y * cos(q)
assert express(B.z, A, variables=True) == A.z
assert express(B.x*B.y*B.z, A, variables=True) == \
A.z*(-A.x*sin(q) + A.y*cos(q))*(A.x*cos(q) + A.y*sin(q))
assert express(B.x*B.i + B.y*B.j + B.z*B.k, A) == \
(B.x*cos(q) - B.y*sin(q))*A.i + (B.x*sin(q) +
B.y*cos(q))*A.j + B.z*A.k
assert simplify(express(B.x*B.i + B.y*B.j + B.z*B.k, A,
variables=True)) == \
A.x*A.i + A.y*A.j + A.z*A.k
assert express(A.x*A.i + A.y*A.j + A.z*A.k, B) == \
(A.x*cos(q) + A.y*sin(q))*B.i + \
(-A.x*sin(q) + A.y*cos(q))*B.j + A.z*B.k
assert simplify(express(A.x*A.i + A.y*A.j + A.z*A.k, B,
variables=True)) == \
B.x*B.i + B.y*B.j + B.z*B.k
pytest.raises(TypeError, lambda: express(A.x, 1))
pytest.raises(ValueError, lambda: express(A.i, B, A))
pytest.raises(TypeError, lambda: express(A.i | A.j, B, 1))
pytest.raises(ValueError, lambda: express(1, B, 1))
N = B.orient_new_axis('N', -q, B.k)
assert N.scalar_map(A) == \
{N.x: A.x, N.z: A.z, N.y: A.y}
C = A.orient_new_axis('C', q, A.i + A.j + A.k)
mapping = A.scalar_map(C)
assert mapping[A.x] == (C.x * (2 * cos(q) + 1) / 3 + C.y *
(-2 * sin(q + pi / 6) + 1) / 3 + C.z *
(-2 * cos(q + pi / 3) + 1) / 3)
assert mapping[A.y] == (C.x * (-2 * cos(q + pi / 3) + 1) / 3 + C.y *
(2 * cos(q) + 1) / 3 + C.z *
(-2 * sin(q + pi / 6) + 1) / 3)
assert mapping[A.z] == (C.x * (-2 * sin(q + pi / 6) + 1) / 3 + C.y *
(-2 * cos(q + pi / 3) + 1) / 3 + C.z *
(2 * cos(q) + 1) / 3)
D = A.locate_new('D', a * A.i + b * A.j + c * A.k)
assert D.scalar_map(A) == {D.z: A.z - c, D.x: A.x - a, D.y: A.y - b}
E = A.orient_new_axis('E', a, A.k, a * A.i + b * A.j + c * A.k)
assert A.scalar_map(E) == {
A.z: E.z + c,
A.x: E.x * cos(a) - E.y * sin(a) + a,
A.y: E.x * sin(a) + E.y * cos(a) + b
}
assert E.scalar_map(A) == {
E.x: (A.x - a) * cos(a) + (A.y - b) * sin(a),
E.y: (-A.x + a) * sin(a) + (A.y - b) * cos(a),
E.z: A.z - c
}
F = A.locate_new('F', Vector.zero)
assert A.scalar_map(F) == {A.z: F.z, A.x: F.x, A.y: F.y}
from diofant import ImmutableMatrix as Matrix
from diofant import Integer, cos, sin, symbols
from diofant.vector import CoordSysCartesian, Vector, express, matrix_to_vector
__all__ = ()
N = CoordSysCartesian('N')
q1, q2, q3, q4, q5 = symbols('q1:6')
A = N.orient_new_axis('A', q1, N.k)
B = A.orient_new_axis('B', q2, A.i)
C = B.orient_new_axis('C', q3, B.j)
def test_express():
assert express(Vector.zero, N) == Vector.zero
assert express(Integer(0), N) == Integer(0)
assert express(A.i, C) == cos(q3)*C.i + sin(q3)*C.k
assert express(A.j, C) == sin(q2)*sin(q3)*C.i + cos(q2)*C.j - \
sin(q2)*cos(q3)*C.k
assert express(A.k, C) == -sin(q3)*cos(q2)*C.i + sin(q2)*C.j + \
cos(q2)*cos(q3)*C.k
assert express(A.i, N) == cos(q1)*N.i + sin(q1)*N.j
assert express(A.j, N) == -sin(q1)*N.i + cos(q1)*N.j
assert express(A.k, N) == N.k
assert express(A.i, A) == A.i
assert express(A.j, A) == A.j
assert express(A.k, A) == A.k
assert express(A.i, B) == B.i
assert express(A.j, B) == cos(q2)*B.j - sin(q2)*B.k
assert express(A.k, B) == sin(q2)*B.j + cos(q2)*B.k
import pytest
from diofant import Add, Derivative, Function
from diofant import ImmutableMatrix as Matrix
from diofant import (Integral, Mul, Pow, cos, diff, pi, simplify, sin, sqrt,
symbols, trigsimp)
from diofant.abc import a, b, c
from diofant.vector import (BaseVector, CoordSysCartesian, Vector, VectorAdd,
VectorMul, VectorZero)
__all__ = ()
C = CoordSysCartesian('C')
i, j, k = C.base_vectors()
def test_vector_diofant():
"""
Test whether the Vector framework confirms to the hashing
and equality testing properties of Diofant.
"""
v1 = 3 * j
assert v1 == j * 3
assert v1.components == {j: 3}
v2 = 3 * i + 4 * j + 5 * k
v3 = 2 * i + 4 * j + i + 4 * k + k
assert v3 == v2
assert v3.__hash__() == v2.__hash__()
def test_vector():
def pretty(expr):
"""ASCII pretty-printing"""
return xpretty(expr, use_unicode=False, wrap_line=False)
def upretty(expr):
"""Unicode pretty-printing"""
return xpretty(expr, use_unicode=True, wrap_line=False)
# Initialize the basic and tedious vector/dyadic expressions
# needed for testing.
# Some of the pretty forms shown denote how the expressions just
# above them should look with pretty printing.
N = CoordSysCartesian('N')
C = N.orient_new_axis('C', a, N.k)
v = []
d = []
v.append(Vector.zero)
v.append(N.i)
v.append(-N.i)
v.append(N.i + N.j)
v.append(a * N.i)
v.append(a * N.i - b * N.j)
v.append((a**2 + N.x) * N.i + N.k)
v.append((a**2 + b) * N.i + 3 * (C.y - c) * N.k)
f = Function('f')
v.append(N.j - (Integral(f(b)) - C.x**2) * N.k)
upretty_v_8 = \
"""\
def pretty(expr):
"""ASCII pretty-printing"""
return xpretty(expr, use_unicode=False, wrap_line=False)
def upretty(expr):
"""Unicode pretty-printing"""
return xpretty(expr, use_unicode=True, wrap_line=False)
# Initialize the basic and tedious vector/dyadic expressions
# needed for testing.
# Some of the pretty forms shown denote how the expressions just
# above them should look with pretty printing.
N = CoordSysCartesian('N')
C = N.orient_new_axis('C', a, N.k)
v = []
d = []
v.append(Vector.zero)
v.append(N.i)
v.append(-N.i)
v.append(N.i + N.j)
v.append(a*N.i)
v.append(a*N.i - b*N.j)
v.append((a**2 + N.x)*N.i + N.k)
v.append((a**2 + b)*N.i + 3*(C.y - c)*N.k)
f = Function('f')
v.append(N.j - (Integral(f(b)) - C.x**2)*N.k)
upretty_v_8 = \
"""\
import pytest
from diofant import Derivative, Integer, cos, simplify, sin
from diofant.abc import a, q
from diofant.vector import (CoordSysCartesian, Del, Vector, curl, divergence,
gradient, is_conservative, is_solenoidal,
scalar_potential, scalar_potential_difference)
__all__ = ()
C = CoordSysCartesian('C')
i, j, k = C.base_vectors()
x, y, z = C.base_scalars()
delop = C.delop
def test_del_operator():
pytest.raises(TypeError, lambda: Del(Integer(1)))
# Tests for curl
assert (delop ^ Vector.zero ==
(Derivative(0, C.y) - Derivative(0, C.z))*C.i +
(-Derivative(0, C.x) + Derivative(0, C.z))*C.j +
(Derivative(0, C.x) - Derivative(0, C.y))*C.k)
assert ((delop ^ Vector.zero).doit() == Vector.zero ==
curl(Vector.zero, C))
assert delop.cross(Vector.zero) == delop ^ Vector.zero
assert (delop ^ i).doit() == Vector.zero
assert delop.cross(2*y**2*j, doit=True) == Vector.zero
assert delop.cross(2*y**2*j) == delop ^ 2*y**2*j
