switching to high quality piper tts and added label translations
This commit is contained in:
Matthias Hinrichs
@@ -0,0 +1,464 @@
|
||||
from sympy.testing.pytest import raises
|
||||
from sympy.vector.coordsysrect import CoordSys3D
|
||||
from sympy.vector.scalar import BaseScalar
|
||||
from sympy.core.function import expand
|
||||
from sympy.core.numbers import pi
|
||||
from sympy.core.symbol import symbols
|
||||
from sympy.functions.elementary.hyperbolic import (cosh, sinh)
|
||||
from sympy.functions.elementary.miscellaneous import sqrt
|
||||
from sympy.functions.elementary.trigonometric import (acos, atan2, cos, sin)
|
||||
from sympy.matrices.dense import zeros
|
||||
from sympy.matrices.immutable import ImmutableDenseMatrix as Matrix
|
||||
from sympy.simplify.simplify import simplify
|
||||
from sympy.vector.functions import express
|
||||
from sympy.vector.point import Point
|
||||
from sympy.vector.vector import Vector
|
||||
from sympy.vector.orienters import (AxisOrienter, BodyOrienter,
|
||||
SpaceOrienter, QuaternionOrienter)
|
||||
|
||||
|
||||
x, y, z = symbols('x y z')
|
||||
a, b, c, q = symbols('a b c q')
|
||||
q1, q2, q3, q4 = symbols('q1 q2 q3 q4')
|
||||
|
||||
|
||||
def test_func_args():
|
||||
A = CoordSys3D('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
|
||||
|
||||
|
||||
def test_coordsys3d_equivalence():
|
||||
A = CoordSys3D('A')
|
||||
A1 = CoordSys3D('A')
|
||||
assert A1 == A
|
||||
B = CoordSys3D('B')
|
||||
assert A != B
|
||||
|
||||
|
||||
def test_orienters():
|
||||
A = CoordSys3D('A')
|
||||
axis_orienter = AxisOrienter(a, A.k)
|
||||
body_orienter = BodyOrienter(a, b, c, '123')
|
||||
space_orienter = SpaceOrienter(a, b, c, '123')
|
||||
q_orienter = QuaternionOrienter(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]])
|
||||
|
||||
|
||||
def test_coordinate_vars():
|
||||
"""
|
||||
Tests the coordinate variables functionality with respect to
|
||||
reorientation of coordinate systems.
|
||||
"""
|
||||
A = CoordSys3D('A')
|
||||
# Note that the name given on the lhs is different from A.x._name
|
||||
assert BaseScalar(0, A, 'A_x', r'\mathbf{{x}_{A}}') == A.x
|
||||
assert BaseScalar(1, A, 'A_y', r'\mathbf{{y}_{A}}') == A.y
|
||||
assert BaseScalar(2, A, 'A_z', r'\mathbf{{z}_{A}}') == A.z
|
||||
assert BaseScalar(0, A, 'A_x', r'\mathbf{{x}_{A}}').__hash__() == A.x.__hash__()
|
||||
assert isinstance(A.x, BaseScalar) and \
|
||||
isinstance(A.y, BaseScalar) and \
|
||||
isinstance(A.z, BaseScalar)
|
||||
assert A.x*A.y == A.y*A.x
|
||||
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 expand(express(B.x*B.y*B.z, A, variables=True)) == \
|
||||
expand(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
|
||||
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].equals(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].equals(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].equals(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}
|
||||
|
||||
|
||||
def test_rotation_matrix():
|
||||
N = CoordSys3D('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)]])
|
||||
|
||||
|
||||
def test_vector_with_orientation():
|
||||
"""
|
||||
Tests the effects of orientation of coordinate systems on
|
||||
basic vector operations.
|
||||
"""
|
||||
N = CoordSys3D('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)
|
||||
|
||||
# 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
|
||||
|
||||
|
||||
def test_orient_new_methods():
|
||||
N = CoordSys3D('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')
|
||||
|
||||
|
||||
def test_locatenew_point():
|
||||
"""
|
||||
Tests Point class, and locate_new method in CoordSys3D.
|
||||
"""
|
||||
A = CoordSys3D('A')
|
||||
assert isinstance(A.origin, Point)
|
||||
v = a*A.i + b*A.j + c*A.k
|
||||
C = A.locate_new('C', v)
|
||||
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_create_new():
|
||||
a = CoordSys3D('a')
|
||||
c = a.create_new('c', transformation='spherical')
|
||||
assert c._parent == a
|
||||
assert c.transformation_to_parent() == \
|
||||
(c.r*sin(c.theta)*cos(c.phi), c.r*sin(c.theta)*sin(c.phi), c.r*cos(c.theta))
|
||||
assert c.transformation_from_parent() == \
|
||||
(sqrt(a.x**2 + a.y**2 + a.z**2), acos(a.z/sqrt(a.x**2 + a.y**2 + a.z**2)), atan2(a.y, a.x))
|
||||
|
||||
|
||||
def test_evalf():
|
||||
A = CoordSys3D('A')
|
||||
v = 3*A.i + 4*A.j + a*A.k
|
||||
assert v.n() == v.evalf()
|
||||
assert v.evalf(subs={a:1}) == v.subs(a, 1).evalf()
|
||||
|
||||
|
||||
def test_lame_coefficients():
|
||||
a = CoordSys3D('a', 'spherical')
|
||||
assert a.lame_coefficients() == (1, a.r, sin(a.theta)*a.r)
|
||||
a = CoordSys3D('a')
|
||||
assert a.lame_coefficients() == (1, 1, 1)
|
||||
a = CoordSys3D('a', 'cartesian')
|
||||
assert a.lame_coefficients() == (1, 1, 1)
|
||||
a = CoordSys3D('a', 'cylindrical')
|
||||
assert a.lame_coefficients() == (1, a.r, 1)
|
||||
|
||||
|
||||
def test_transformation_equations():
|
||||
|
||||
x, y, z = symbols('x y z')
|
||||
# Str
|
||||
a = CoordSys3D('a', transformation='spherical',
|
||||
variable_names=["r", "theta", "phi"])
|
||||
r, theta, phi = a.base_scalars()
|
||||
|
||||
assert r == a.r
|
||||
assert theta == a.theta
|
||||
assert phi == a.phi
|
||||
|
||||
raises(AttributeError, lambda: a.x)
|
||||
raises(AttributeError, lambda: a.y)
|
||||
raises(AttributeError, lambda: a.z)
|
||||
|
||||
assert a.transformation_to_parent() == (
|
||||
r*sin(theta)*cos(phi),
|
||||
r*sin(theta)*sin(phi),
|
||||
r*cos(theta)
|
||||
)
|
||||
assert a.lame_coefficients() == (1, r, r*sin(theta))
|
||||
assert a.transformation_from_parent_function()(x, y, z) == (
|
||||
sqrt(x ** 2 + y ** 2 + z ** 2),
|
||||
acos((z) / sqrt(x**2 + y**2 + z**2)),
|
||||
atan2(y, x)
|
||||
)
|
||||
a = CoordSys3D('a', transformation='cylindrical',
|
||||
variable_names=["r", "theta", "z"])
|
||||
r, theta, z = a.base_scalars()
|
||||
assert a.transformation_to_parent() == (
|
||||
r*cos(theta),
|
||||
r*sin(theta),
|
||||
z
|
||||
)
|
||||
assert a.lame_coefficients() == (1, a.r, 1)
|
||||
assert a.transformation_from_parent_function()(x, y, z) == (sqrt(x**2 + y**2),
|
||||
atan2(y, x), z)
|
||||
|
||||
a = CoordSys3D('a', 'cartesian')
|
||||
assert a.transformation_to_parent() == (a.x, a.y, a.z)
|
||||
assert a.lame_coefficients() == (1, 1, 1)
|
||||
assert a.transformation_from_parent_function()(x, y, z) == (x, y, z)
|
||||
|
||||
# Variables and expressions
|
||||
|
||||
# Cartesian with equation tuple:
|
||||
x, y, z = symbols('x y z')
|
||||
a = CoordSys3D('a', ((x, y, z), (x, y, z)))
|
||||
a._calculate_inv_trans_equations()
|
||||
assert a.transformation_to_parent() == (a.x1, a.x2, a.x3)
|
||||
assert a.lame_coefficients() == (1, 1, 1)
|
||||
assert a.transformation_from_parent_function()(x, y, z) == (x, y, z)
|
||||
r, theta, z = symbols("r theta z")
|
||||
|
||||
# Cylindrical with equation tuple:
|
||||
a = CoordSys3D('a', [(r, theta, z), (r*cos(theta), r*sin(theta), z)],
|
||||
variable_names=["r", "theta", "z"])
|
||||
r, theta, z = a.base_scalars()
|
||||
assert a.transformation_to_parent() == (
|
||||
r*cos(theta), r*sin(theta), z
|
||||
)
|
||||
assert a.lame_coefficients() == (
|
||||
sqrt(sin(theta)**2 + cos(theta)**2),
|
||||
sqrt(r**2*sin(theta)**2 + r**2*cos(theta)**2),
|
||||
1
|
||||
) # ==> this should simplify to (1, r, 1), tests are too slow with `simplify`.
|
||||
|
||||
# Definitions with `lambda`:
|
||||
|
||||
# Cartesian with `lambda`
|
||||
a = CoordSys3D('a', lambda x, y, z: (x, y, z))
|
||||
assert a.transformation_to_parent() == (a.x1, a.x2, a.x3)
|
||||
assert a.lame_coefficients() == (1, 1, 1)
|
||||
a._calculate_inv_trans_equations()
|
||||
assert a.transformation_from_parent_function()(x, y, z) == (x, y, z)
|
||||
|
||||
# Spherical with `lambda`
|
||||
a = CoordSys3D('a', lambda r, theta, phi: (r*sin(theta)*cos(phi), r*sin(theta)*sin(phi), r*cos(theta)),
|
||||
variable_names=["r", "theta", "phi"])
|
||||
r, theta, phi = a.base_scalars()
|
||||
assert a.transformation_to_parent() == (
|
||||
r*sin(theta)*cos(phi), r*sin(phi)*sin(theta), r*cos(theta)
|
||||
)
|
||||
assert a.lame_coefficients() == (
|
||||
sqrt(sin(phi)**2*sin(theta)**2 + sin(theta)**2*cos(phi)**2 + cos(theta)**2),
|
||||
sqrt(r**2*sin(phi)**2*cos(theta)**2 + r**2*sin(theta)**2 + r**2*cos(phi)**2*cos(theta)**2),
|
||||
sqrt(r**2*sin(phi)**2*sin(theta)**2 + r**2*sin(theta)**2*cos(phi)**2)
|
||||
) # ==> this should simplify to (1, r, sin(theta)*r), `simplify` is too slow.
|
||||
|
||||
# Cylindrical with `lambda`
|
||||
a = CoordSys3D('a', lambda r, theta, z:
|
||||
(r*cos(theta), r*sin(theta), z),
|
||||
variable_names=["r", "theta", "z"]
|
||||
)
|
||||
r, theta, z = a.base_scalars()
|
||||
assert a.transformation_to_parent() == (r*cos(theta), r*sin(theta), z)
|
||||
assert a.lame_coefficients() == (
|
||||
sqrt(sin(theta)**2 + cos(theta)**2),
|
||||
sqrt(r**2*sin(theta)**2 + r**2*cos(theta)**2),
|
||||
1
|
||||
) # ==> this should simplify to (1, a.x, 1)
|
||||
|
||||
raises(TypeError, lambda: CoordSys3D('a', transformation={
|
||||
x: x*sin(y)*cos(z), y:x*sin(y)*sin(z), z: x*cos(y)}))
|
||||
|
||||
|
||||
def test_check_orthogonality():
|
||||
x, y, z = symbols('x y z')
|
||||
u,v = symbols('u, v')
|
||||
a = CoordSys3D('a', transformation=((x, y, z), (x*sin(y)*cos(z), x*sin(y)*sin(z), x*cos(y))))
|
||||
assert a._check_orthogonality(a._transformation) is True
|
||||
a = CoordSys3D('a', transformation=((x, y, z), (x * cos(y), x * sin(y), z)))
|
||||
assert a._check_orthogonality(a._transformation) is True
|
||||
a = CoordSys3D('a', transformation=((u, v, z), (cosh(u) * cos(v), sinh(u) * sin(v), z)))
|
||||
assert a._check_orthogonality(a._transformation) is True
|
||||
|
||||
raises(ValueError, lambda: CoordSys3D('a', transformation=((x, y, z), (x, x, z))))
|
||||
raises(ValueError, lambda: CoordSys3D('a', transformation=(
|
||||
(x, y, z), (x*sin(y/2)*cos(z), x*sin(y)*sin(z), x*cos(y)))))
|
||||
|
||||
|
||||
def test_rotation_trans_equations():
|
||||
a = CoordSys3D('a')
|
||||
from sympy.core.symbol import symbols
|
||||
q0 = symbols('q0')
|
||||
assert a._rotation_trans_equations(a._parent_rotation_matrix, a.base_scalars()) == (a.x, a.y, a.z)
|
||||
assert a._rotation_trans_equations(a._inverse_rotation_matrix(), a.base_scalars()) == (a.x, a.y, a.z)
|
||||
b = a.orient_new_axis('b', 0, -a.k)
|
||||
assert b._rotation_trans_equations(b._parent_rotation_matrix, b.base_scalars()) == (b.x, b.y, b.z)
|
||||
assert b._rotation_trans_equations(b._inverse_rotation_matrix(), b.base_scalars()) == (b.x, b.y, b.z)
|
||||
c = a.orient_new_axis('c', q0, -a.k)
|
||||
assert c._rotation_trans_equations(c._parent_rotation_matrix, c.base_scalars()) == \
|
||||
(-sin(q0) * c.y + cos(q0) * c.x, sin(q0) * c.x + cos(q0) * c.y, c.z)
|
||||
assert c._rotation_trans_equations(c._inverse_rotation_matrix(), c.base_scalars()) == \
|
||||
(sin(q0) * c.y + cos(q0) * c.x, -sin(q0) * c.x + cos(q0) * c.y, c.z)
|
||||
@@ -0,0 +1,134 @@
|
||||
from sympy.core.numbers import pi
|
||||
from sympy.core.symbol import symbols
|
||||
from sympy.functions.elementary.trigonometric import (cos, sin)
|
||||
from sympy.matrices.immutable import ImmutableDenseMatrix as Matrix
|
||||
from sympy.simplify.simplify import simplify
|
||||
from sympy.vector import (CoordSys3D, Vector, Dyadic,
|
||||
DyadicAdd, DyadicMul, DyadicZero,
|
||||
BaseDyadic, express)
|
||||
|
||||
|
||||
A = CoordSys3D('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) * (A.i|A.j) +\
|
||||
- (A.k|A.i) - b * (A.k|A.j)
|
||||
assert d1 * 0 == Dyadic.zero
|
||||
assert d1 != Dyadic.zero
|
||||
assert d1 * 2 == 2 * (A.i | A.i)
|
||||
assert d1 / 2. == 0.5 * d1
|
||||
|
||||
assert d1.dot(0 * d1) == Vector.zero
|
||||
assert d1 & d2 == Dyadic.zero
|
||||
assert d1.dot(A.i) == A.i == d1 & A.i
|
||||
|
||||
assert d1.cross(Vector.zero) == Dyadic.zero
|
||||
assert d1.cross(A.i) == Dyadic.zero
|
||||
assert d1 ^ A.j == d1.cross(A.j)
|
||||
assert d1.cross(A.k) == - A.i | A.j
|
||||
assert d2.cross(A.i) == - A.j | A.k == d2 ^ A.i
|
||||
|
||||
assert A.i ^ d1 == Dyadic.zero
|
||||
assert A.j.cross(d1) == - A.k | A.i == A.j ^ d1
|
||||
assert Vector.zero.cross(d1) == Dyadic.zero
|
||||
assert A.k ^ d1 == A.j | A.i
|
||||
assert A.i.dot(d1) == A.i & d1 == A.i
|
||||
assert A.j.dot(d1) == Vector.zero
|
||||
assert Vector.zero.dot(d1) == Vector.zero
|
||||
assert A.j & d2 == A.j
|
||||
|
||||
assert d1.dot(d3) == d1 & d3 == A.i | A.j == d3
|
||||
assert d3 & d1 == Dyadic.zero
|
||||
|
||||
q = symbols('q')
|
||||
B = A.orient_new_axis('B', q, A.k)
|
||||
assert express(d1, B) == express(d1, B, B)
|
||||
|
||||
expr1 = ((cos(q)**2) * (B.i | B.i) + (-sin(q) * cos(q)) *
|
||||
(B.i | B.j) + (-sin(q) * cos(q)) * (B.j | B.i) + (sin(q)**2) *
|
||||
(B.j | B.j))
|
||||
assert (express(d1, B) - expr1).simplify() == Dyadic.zero
|
||||
|
||||
expr2 = (cos(q)) * (B.i | A.i) + (-sin(q)) * (B.j | A.i)
|
||||
assert (express(d1, B, A) - expr2).simplify() == Dyadic.zero
|
||||
|
||||
expr3 = (cos(q)) * (A.i | B.i) + (-sin(q)) * (A.i | B.j)
|
||||
assert (express(d1, A, B) - expr3).simplify() == Dyadic.zero
|
||||
|
||||
assert d1.to_matrix(A) == Matrix([[1, 0, 0], [0, 0, 0], [0, 0, 0]])
|
||||
assert d1.to_matrix(A, B) == Matrix([[cos(q), -sin(q), 0],
|
||||
[0, 0, 0],
|
||||
[0, 0, 0]])
|
||||
assert d3.to_matrix(A) == Matrix([[0, 1, 0], [0, 0, 0], [0, 0, 0]])
|
||||
a, b, c, d, e, f = symbols('a, b, c, d, e, f')
|
||||
v1 = a * A.i + b * A.j + c * A.k
|
||||
v2 = d * A.i + e * A.j + f * A.k
|
||||
d4 = v1.outer(v2)
|
||||
assert d4.to_matrix(A) == Matrix([[a * d, a * e, a * f],
|
||||
[b * d, b * e, b * f],
|
||||
[c * d, c * e, c * f]])
|
||||
d5 = v1.outer(v1)
|
||||
C = A.orient_new_axis('C', q, A.i)
|
||||
for expected, actual in zip(C.rotation_matrix(A) * d5.to_matrix(A) * \
|
||||
C.rotation_matrix(A).T, d5.to_matrix(C)):
|
||||
assert (expected - actual).simplify() == 0
|
||||
|
||||
|
||||
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 = CoordSys3D('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_dyadic_srepr():
|
||||
from sympy.printing.repr import srepr
|
||||
N = CoordSys3D('N')
|
||||
|
||||
dy = N.i | N.j
|
||||
res = "BaseDyadic(CoordSys3D(Str('N'), Tuple(ImmutableDenseMatrix([["\
|
||||
"Integer(1), Integer(0), Integer(0)], [Integer(0), Integer(1), "\
|
||||
"Integer(0)], [Integer(0), Integer(0), Integer(1)]]), "\
|
||||
"VectorZero())).i, CoordSys3D(Str('N'), Tuple(ImmutableDenseMatrix("\
|
||||
"[[Integer(1), Integer(0), Integer(0)], [Integer(0), Integer(1), "\
|
||||
"Integer(0)], [Integer(0), Integer(0), Integer(1)]]), VectorZero())).j)"
|
||||
assert srepr(dy) == res
|
||||
@@ -0,0 +1,321 @@
|
||||
from sympy.core.function import Derivative
|
||||
from sympy.vector.vector import Vector
|
||||
from sympy.vector.coordsysrect import CoordSys3D
|
||||
from sympy.simplify import simplify
|
||||
from sympy.core.symbol import symbols
|
||||
from sympy.core import S
|
||||
from sympy.functions.elementary.trigonometric import (cos, sin)
|
||||
from sympy.vector.vector import Dot
|
||||
from sympy.vector.operators import curl, divergence, gradient, Gradient, Divergence, Cross
|
||||
from sympy.vector.deloperator import Del
|
||||
from sympy.vector.functions import (is_conservative, is_solenoidal,
|
||||
scalar_potential, directional_derivative,
|
||||
laplacian, scalar_potential_difference)
|
||||
from sympy.testing.pytest import raises
|
||||
|
||||
C = CoordSys3D('C')
|
||||
i, j, k = C.base_vectors()
|
||||
x, y, z = C.base_scalars()
|
||||
delop = Del()
|
||||
a, b, c, q = symbols('a b c q')
|
||||
|
||||
|
||||
def test_del_operator():
|
||||
# Tests for curl
|
||||
|
||||
assert delop ^ Vector.zero == Vector.zero
|
||||
assert ((delop ^ Vector.zero).doit() == Vector.zero ==
|
||||
curl(Vector.zero))
|
||||
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
|
||||
v = x*y*z * (i + j + k)
|
||||
assert ((delop ^ v).doit() ==
|
||||
(-x*y + x*z)*i + (x*y - y*z)*j + (-x*z + y*z)*k ==
|
||||
curl(v))
|
||||
assert delop ^ v == delop.cross(v)
|
||||
assert (delop.cross(2*x**2*j) ==
|
||||
(Derivative(0, C.y) - Derivative(2*C.x**2, C.z))*C.i +
|
||||
(-Derivative(0, C.x) + Derivative(0, C.z))*C.j +
|
||||
(-Derivative(0, C.y) + Derivative(2*C.x**2, C.x))*C.k)
|
||||
assert (delop.cross(2*x**2*j, doit=True) == 4*x*k ==
|
||||
curl(2*x**2*j))
|
||||
|
||||
#Tests for divergence
|
||||
assert delop & Vector.zero is S.Zero == divergence(Vector.zero)
|
||||
assert (delop & Vector.zero).doit() is S.Zero
|
||||
assert delop.dot(Vector.zero) == delop & Vector.zero
|
||||
assert (delop & i).doit() is S.Zero
|
||||
assert (delop & x**2*i).doit() == 2*x == divergence(x**2*i)
|
||||
assert (delop.dot(v, doit=True) == x*y + y*z + z*x ==
|
||||
divergence(v))
|
||||
assert delop & v == delop.dot(v)
|
||||
assert delop.dot(1/(x*y*z) * (i + j + k), doit=True) == \
|
||||
- 1 / (x*y*z**2) - 1 / (x*y**2*z) - 1 / (x**2*y*z)
|
||||
v = x*i + y*j + z*k
|
||||
assert (delop & v == Derivative(C.x, C.x) +
|
||||
Derivative(C.y, C.y) + Derivative(C.z, C.z))
|
||||
assert delop.dot(v, doit=True) == 3 == divergence(v)
|
||||
assert delop & v == delop.dot(v)
|
||||
assert simplify((delop & v).doit()) == 3
|
||||
|
||||
#Tests for gradient
|
||||
assert (delop.gradient(0, doit=True) == Vector.zero ==
|
||||
gradient(0))
|
||||
assert delop.gradient(0) == delop(0)
|
||||
assert (delop(S.Zero)).doit() == Vector.zero
|
||||
assert (delop(x) == (Derivative(C.x, C.x))*C.i +
|
||||
(Derivative(C.x, C.y))*C.j + (Derivative(C.x, C.z))*C.k)
|
||||
assert (delop(x)).doit() == i == gradient(x)
|
||||
assert (delop(x*y*z) ==
|
||||
(Derivative(C.x*C.y*C.z, C.x))*C.i +
|
||||
(Derivative(C.x*C.y*C.z, C.y))*C.j +
|
||||
(Derivative(C.x*C.y*C.z, C.z))*C.k)
|
||||
assert (delop.gradient(x*y*z, doit=True) ==
|
||||
y*z*i + z*x*j + x*y*k ==
|
||||
gradient(x*y*z))
|
||||
assert delop(x*y*z) == delop.gradient(x*y*z)
|
||||
assert (delop(2*x**2)).doit() == 4*x*i
|
||||
assert ((delop(a*sin(y) / x)).doit() ==
|
||||
-a*sin(y)/x**2 * i + a*cos(y)/x * j)
|
||||
|
||||
#Tests for directional derivative
|
||||
assert (Vector.zero & delop)(a) is S.Zero
|
||||
assert ((Vector.zero & delop)(a)).doit() is S.Zero
|
||||
assert ((v & delop)(Vector.zero)).doit() == Vector.zero
|
||||
assert ((v & delop)(S.Zero)).doit() is S.Zero
|
||||
assert ((i & delop)(x)).doit() == 1
|
||||
assert ((j & delop)(y)).doit() == 1
|
||||
assert ((k & delop)(z)).doit() == 1
|
||||
assert ((i & delop)(x*y*z)).doit() == y*z
|
||||
assert ((v & delop)(x)).doit() == x
|
||||
assert ((v & delop)(x*y*z)).doit() == 3*x*y*z
|
||||
assert (v & delop)(x + y + z) == C.x + C.y + C.z
|
||||
assert ((v & delop)(x + y + z)).doit() == x + y + z
|
||||
assert ((v & delop)(v)).doit() == v
|
||||
assert ((i & delop)(v)).doit() == i
|
||||
assert ((j & delop)(v)).doit() == j
|
||||
assert ((k & delop)(v)).doit() == k
|
||||
assert ((v & delop)(Vector.zero)).doit() == Vector.zero
|
||||
|
||||
# Tests for laplacian on scalar fields
|
||||
assert laplacian(x*y*z) is S.Zero
|
||||
assert laplacian(x**2) == S(2)
|
||||
assert laplacian(x**2*y**2*z**2) == \
|
||||
2*y**2*z**2 + 2*x**2*z**2 + 2*x**2*y**2
|
||||
A = CoordSys3D('A', transformation="spherical", variable_names=["r", "theta", "phi"])
|
||||
B = CoordSys3D('B', transformation='cylindrical', variable_names=["r", "theta", "z"])
|
||||
assert laplacian(A.r + A.theta + A.phi) == 2/A.r + cos(A.theta)/(A.r**2*sin(A.theta))
|
||||
assert laplacian(B.r + B.theta + B.z) == 1/B.r
|
||||
|
||||
# Tests for laplacian on vector fields
|
||||
assert laplacian(x*y*z*(i + j + k)) == Vector.zero
|
||||
assert laplacian(x*y**2*z*(i + j + k)) == \
|
||||
2*x*z*i + 2*x*z*j + 2*x*z*k
|
||||
|
||||
|
||||
def test_product_rules():
|
||||
"""
|
||||
Tests the six product rules defined with respect to the Del
|
||||
operator
|
||||
|
||||
References
|
||||
==========
|
||||
|
||||
.. [1] https://en.wikipedia.org/wiki/Del
|
||||
|
||||
"""
|
||||
|
||||
#Define the scalar and vector functions
|
||||
f = 2*x*y*z
|
||||
g = x*y + y*z + z*x
|
||||
u = x**2*i + 4*j - y**2*z*k
|
||||
v = 4*i + x*y*z*k
|
||||
|
||||
# First product rule
|
||||
lhs = delop(f * g, doit=True)
|
||||
rhs = (f * delop(g) + g * delop(f)).doit()
|
||||
assert simplify(lhs) == simplify(rhs)
|
||||
|
||||
# Second product rule
|
||||
lhs = delop(u & v).doit()
|
||||
rhs = ((u ^ (delop ^ v)) + (v ^ (delop ^ u)) + \
|
||||
((u & delop)(v)) + ((v & delop)(u))).doit()
|
||||
assert simplify(lhs) == simplify(rhs)
|
||||
|
||||
# Third product rule
|
||||
lhs = (delop & (f*v)).doit()
|
||||
rhs = ((f * (delop & v)) + (v & (delop(f)))).doit()
|
||||
assert simplify(lhs) == simplify(rhs)
|
||||
|
||||
# Fourth product rule
|
||||
lhs = (delop & (u ^ v)).doit()
|
||||
rhs = ((v & (delop ^ u)) - (u & (delop ^ v))).doit()
|
||||
assert simplify(lhs) == simplify(rhs)
|
||||
|
||||
# Fifth product rule
|
||||
lhs = (delop ^ (f * v)).doit()
|
||||
rhs = (((delop(f)) ^ v) + (f * (delop ^ v))).doit()
|
||||
assert simplify(lhs) == simplify(rhs)
|
||||
|
||||
# Sixth product rule
|
||||
lhs = (delop ^ (u ^ v)).doit()
|
||||
rhs = (u * (delop & v) - v * (delop & u) +
|
||||
(v & delop)(u) - (u & delop)(v)).doit()
|
||||
assert simplify(lhs) == simplify(rhs)
|
||||
|
||||
|
||||
P = C.orient_new_axis('P', q, C.k) # type: ignore
|
||||
scalar_field = 2*x**2*y*z
|
||||
grad_field = gradient(scalar_field)
|
||||
vector_field = y**2*i + 3*x*j + 5*y*z*k
|
||||
curl_field = curl(vector_field)
|
||||
|
||||
|
||||
def test_conservative():
|
||||
assert is_conservative(Vector.zero) is True
|
||||
assert is_conservative(i) is True
|
||||
assert is_conservative(2 * i + 3 * j + 4 * k) is True
|
||||
assert (is_conservative(y*z*i + x*z*j + x*y*k) is
|
||||
True)
|
||||
assert is_conservative(x * j) is False
|
||||
assert is_conservative(grad_field) is True
|
||||
assert is_conservative(curl_field) is False
|
||||
assert (is_conservative(4*x*y*z*i + 2*x**2*z*j) is
|
||||
False)
|
||||
assert is_conservative(z*P.i + P.x*k) is True
|
||||
|
||||
|
||||
def test_solenoidal():
|
||||
assert is_solenoidal(Vector.zero) is True
|
||||
assert is_solenoidal(i) is True
|
||||
assert is_solenoidal(2 * i + 3 * j + 4 * k) is True
|
||||
assert (is_solenoidal(y*z*i + x*z*j + x*y*k) is
|
||||
True)
|
||||
assert is_solenoidal(y * j) is False
|
||||
assert is_solenoidal(grad_field) is False
|
||||
assert is_solenoidal(curl_field) is True
|
||||
assert is_solenoidal((-2*y + 3)*k) is True
|
||||
assert is_solenoidal(cos(q)*i + sin(q)*j + cos(q)*P.k) is True
|
||||
assert is_solenoidal(z*P.i + P.x*k) is True
|
||||
|
||||
|
||||
def test_directional_derivative():
|
||||
assert directional_derivative(C.x*C.y*C.z, 3*C.i + 4*C.j + C.k) == C.x*C.y + 4*C.x*C.z + 3*C.y*C.z
|
||||
assert directional_derivative(5*C.x**2*C.z, 3*C.i + 4*C.j + C.k) == 5*C.x**2 + 30*C.x*C.z
|
||||
assert directional_derivative(5*C.x**2*C.z, 4*C.j) is S.Zero
|
||||
|
||||
D = CoordSys3D("D", "spherical", variable_names=["r", "theta", "phi"],
|
||||
vector_names=["e_r", "e_theta", "e_phi"])
|
||||
r, theta, phi = D.base_scalars()
|
||||
e_r, e_theta, e_phi = D.base_vectors()
|
||||
assert directional_derivative(r**2*e_r, e_r) == 2*r*e_r
|
||||
assert directional_derivative(5*r**2*phi, 3*e_r + 4*e_theta + e_phi) == 5*r**2 + 30*r*phi
|
||||
|
||||
|
||||
def test_scalar_potential():
|
||||
assert scalar_potential(Vector.zero, C) == 0
|
||||
assert scalar_potential(i, C) == x
|
||||
assert scalar_potential(j, C) == y
|
||||
assert scalar_potential(k, C) == z
|
||||
assert scalar_potential(y*z*i + x*z*j + x*y*k, C) == x*y*z
|
||||
assert scalar_potential(grad_field, C) == scalar_field
|
||||
assert scalar_potential(z*P.i + P.x*k, C) == x*z*cos(q) + y*z*sin(q)
|
||||
assert scalar_potential(z*P.i + P.x*k, P) == P.x*P.z
|
||||
raises(ValueError, lambda: scalar_potential(x*j, C))
|
||||
|
||||
|
||||
def test_scalar_potential_difference():
|
||||
point1 = C.origin.locate_new('P1', 1*i + 2*j + 3*k)
|
||||
point2 = C.origin.locate_new('P2', 4*i + 5*j + 6*k)
|
||||
genericpointC = C.origin.locate_new('RP', x*i + y*j + z*k)
|
||||
genericpointP = P.origin.locate_new('PP', P.x*P.i + P.y*P.j + P.z*P.k)
|
||||
assert scalar_potential_difference(S.Zero, C, point1, point2) == 0
|
||||
assert (scalar_potential_difference(scalar_field, C, C.origin,
|
||||
genericpointC) ==
|
||||
scalar_field)
|
||||
assert (scalar_potential_difference(grad_field, C, C.origin,
|
||||
genericpointC) ==
|
||||
scalar_field)
|
||||
assert scalar_potential_difference(grad_field, C, point1, point2) == 948
|
||||
assert (scalar_potential_difference(y*z*i + x*z*j +
|
||||
x*y*k, C, point1,
|
||||
genericpointC) ==
|
||||
x*y*z - 6)
|
||||
potential_diff_P = (2*P.z*(P.x*sin(q) + P.y*cos(q))*
|
||||
(P.x*cos(q) - P.y*sin(q))**2)
|
||||
assert (scalar_potential_difference(grad_field, P, P.origin,
|
||||
genericpointP).simplify() ==
|
||||
potential_diff_P.simplify())
|
||||
|
||||
|
||||
def test_differential_operators_curvilinear_system():
|
||||
A = CoordSys3D('A', transformation="spherical", variable_names=["r", "theta", "phi"])
|
||||
B = CoordSys3D('B', transformation='cylindrical', variable_names=["r", "theta", "z"])
|
||||
# Test for spherical coordinate system and gradient
|
||||
assert gradient(3*A.r + 4*A.theta) == 3*A.i + 4/A.r*A.j
|
||||
assert gradient(3*A.r*A.phi + 4*A.theta) == 3*A.phi*A.i + 4/A.r*A.j + (3/sin(A.theta))*A.k
|
||||
assert gradient(0*A.r + 0*A.theta+0*A.phi) == Vector.zero
|
||||
assert gradient(A.r*A.theta*A.phi) == A.theta*A.phi*A.i + A.phi*A.j + (A.theta/sin(A.theta))*A.k
|
||||
# Test for spherical coordinate system and divergence
|
||||
assert divergence(A.r * A.i + A.theta * A.j + A.phi * A.k) == \
|
||||
(sin(A.theta)*A.r + cos(A.theta)*A.r*A.theta)/(sin(A.theta)*A.r**2) + 3 + 1/(sin(A.theta)*A.r)
|
||||
assert divergence(3*A.r*A.phi*A.i + A.theta*A.j + A.r*A.theta*A.phi*A.k) == \
|
||||
(sin(A.theta)*A.r + cos(A.theta)*A.r*A.theta)/(sin(A.theta)*A.r**2) + 9*A.phi + A.theta/sin(A.theta)
|
||||
assert divergence(Vector.zero) == 0
|
||||
assert divergence(0*A.i + 0*A.j + 0*A.k) == 0
|
||||
# Test for spherical coordinate system and curl
|
||||
assert curl(A.r*A.i + A.theta*A.j + A.phi*A.k) == \
|
||||
(cos(A.theta)*A.phi/(sin(A.theta)*A.r))*A.i + (-A.phi/A.r)*A.j + A.theta/A.r*A.k
|
||||
assert curl(A.r*A.j + A.phi*A.k) == (cos(A.theta)*A.phi/(sin(A.theta)*A.r))*A.i + (-A.phi/A.r)*A.j + 2*A.k
|
||||
|
||||
# Test for cylindrical coordinate system and gradient
|
||||
assert gradient(0*B.r + 0*B.theta+0*B.z) == Vector.zero
|
||||
assert gradient(B.r*B.theta*B.z) == B.theta*B.z*B.i + B.z*B.j + B.r*B.theta*B.k
|
||||
assert gradient(3*B.r) == 3*B.i
|
||||
assert gradient(2*B.theta) == 2/B.r * B.j
|
||||
assert gradient(4*B.z) == 4*B.k
|
||||
# Test for cylindrical coordinate system and divergence
|
||||
assert divergence(B.r*B.i + B.theta*B.j + B.z*B.k) == 3 + 1/B.r
|
||||
assert divergence(B.r*B.j + B.z*B.k) == 1
|
||||
# Test for cylindrical coordinate system and curl
|
||||
assert curl(B.r*B.j + B.z*B.k) == 2*B.k
|
||||
assert curl(3*B.i + 2/B.r*B.j + 4*B.k) == Vector.zero
|
||||
|
||||
def test_mixed_coordinates():
|
||||
# gradient
|
||||
a = CoordSys3D('a')
|
||||
b = CoordSys3D('b')
|
||||
c = CoordSys3D('c')
|
||||
assert gradient(a.x*b.y) == b.y*a.i + a.x*b.j
|
||||
assert gradient(3*cos(q)*a.x*b.x+a.y*(a.x+(cos(q)+b.x))) ==\
|
||||
(a.y + 3*b.x*cos(q))*a.i + (a.x + b.x + cos(q))*a.j + (3*a.x*cos(q) + a.y)*b.i
|
||||
# Some tests need further work:
|
||||
# assert gradient(a.x*(cos(a.x+b.x))) == (cos(a.x + b.x))*a.i + a.x*Gradient(cos(a.x + b.x))
|
||||
# assert gradient(cos(a.x + b.x)*cos(a.x + b.z)) == Gradient(cos(a.x + b.x)*cos(a.x + b.z))
|
||||
assert gradient(a.x**b.y) == Gradient(a.x**b.y)
|
||||
# assert gradient(cos(a.x+b.y)*a.z) == None
|
||||
assert gradient(cos(a.x*b.y)) == Gradient(cos(a.x*b.y))
|
||||
assert gradient(3*cos(q)*a.x*b.x*a.z*a.y+ b.y*b.z + cos(a.x+a.y)*b.z) == \
|
||||
(3*a.y*a.z*b.x*cos(q) - b.z*sin(a.x + a.y))*a.i + \
|
||||
(3*a.x*a.z*b.x*cos(q) - b.z*sin(a.x + a.y))*a.j + (3*a.x*a.y*b.x*cos(q))*a.k + \
|
||||
(3*a.x*a.y*a.z*cos(q))*b.i + b.z*b.j + (b.y + cos(a.x + a.y))*b.k
|
||||
# divergence
|
||||
assert divergence(a.i*a.x+a.j*a.y+a.z*a.k + b.i*b.x+b.j*b.y+b.z*b.k + c.i*c.x+c.j*c.y+c.z*c.k) == S(9)
|
||||
# assert divergence(3*a.i*a.x*cos(a.x+b.z) + a.j*b.x*c.z) == None
|
||||
assert divergence(3*a.i*a.x*a.z + b.j*b.x*c.z + 3*a.j*a.z*a.y) == \
|
||||
6*a.z + b.x*Dot(b.j, c.k)
|
||||
assert divergence(3*cos(q)*a.x*b.x*b.i*c.x) == \
|
||||
3*a.x*b.x*cos(q)*Dot(b.i, c.i) + 3*a.x*c.x*cos(q) + 3*b.x*c.x*cos(q)*Dot(b.i, a.i)
|
||||
assert divergence(a.x*b.x*c.x*Cross(a.x*a.i, a.y*b.j)) ==\
|
||||
a.x*b.x*c.x*Divergence(Cross(a.x*a.i, a.y*b.j)) + \
|
||||
b.x*c.x*Dot(Cross(a.x*a.i, a.y*b.j), a.i) + \
|
||||
a.x*c.x*Dot(Cross(a.x*a.i, a.y*b.j), b.i) + \
|
||||
a.x*b.x*Dot(Cross(a.x*a.i, a.y*b.j), c.i)
|
||||
assert divergence(a.x*b.x*c.x*(a.x*a.i + b.x*b.i)) == \
|
||||
4*a.x*b.x*c.x +\
|
||||
a.x**2*c.x*Dot(a.i, b.i) +\
|
||||
a.x**2*b.x*Dot(a.i, c.i) +\
|
||||
b.x**2*c.x*Dot(b.i, a.i) +\
|
||||
a.x*b.x**2*Dot(b.i, c.i)
|
||||
@@ -0,0 +1,184 @@
|
||||
from sympy.vector.vector import Vector
|
||||
from sympy.vector.coordsysrect import CoordSys3D
|
||||
from sympy.vector.functions import express, matrix_to_vector, orthogonalize
|
||||
from sympy.core.numbers import Rational
|
||||
from sympy.core.singleton import S
|
||||
from sympy.core.symbol import symbols
|
||||
from sympy.functions.elementary.miscellaneous import sqrt
|
||||
from sympy.functions.elementary.trigonometric import (cos, sin)
|
||||
from sympy.matrices.immutable import ImmutableDenseMatrix as Matrix
|
||||
from sympy.testing.pytest import raises
|
||||
|
||||
N = CoordSys3D('N')
|
||||
q1, q2, q3, q4, q5 = symbols('q1 q2 q3 q4 q5')
|
||||
A = N.orient_new_axis('A', q1, N.k) # type: ignore
|
||||
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(S.Zero, N) is S.Zero
|
||||
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
|
||||
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
|
||||
# Check to make sure UnitVectors get converted properly
|
||||
assert express(N.i, N) == N.i
|
||||
assert express(N.j, N) == N.j
|
||||
assert express(N.k, N) == N.k
|
||||
assert express(N.i, A) == (cos(q1)*A.i - sin(q1)*A.j)
|
||||
assert express(N.j, A) == (sin(q1)*A.i + cos(q1)*A.j)
|
||||
assert express(N.k, A) == A.k
|
||||
assert express(N.i, B) == (cos(q1)*B.i - sin(q1)*cos(q2)*B.j +
|
||||
sin(q1)*sin(q2)*B.k)
|
||||
assert express(N.j, B) == (sin(q1)*B.i + cos(q1)*cos(q2)*B.j -
|
||||
sin(q2)*cos(q1)*B.k)
|
||||
assert express(N.k, B) == (sin(q2)*B.j + cos(q2)*B.k)
|
||||
assert express(N.i, C) == (
|
||||
(cos(q1)*cos(q3) - sin(q1)*sin(q2)*sin(q3))*C.i -
|
||||
sin(q1)*cos(q2)*C.j +
|
||||
(sin(q3)*cos(q1) + sin(q1)*sin(q2)*cos(q3))*C.k)
|
||||
assert express(N.j, C) == (
|
||||
(sin(q1)*cos(q3) + sin(q2)*sin(q3)*cos(q1))*C.i +
|
||||
cos(q1)*cos(q2)*C.j +
|
||||
(sin(q1)*sin(q3) - sin(q2)*cos(q1)*cos(q3))*C.k)
|
||||
assert express(N.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)
|
||||
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(B.i, N) == (cos(q1)*N.i + sin(q1)*N.j)
|
||||
assert express(B.j, N) == (-sin(q1)*cos(q2)*N.i +
|
||||
cos(q1)*cos(q2)*N.j + sin(q2)*N.k)
|
||||
assert express(B.k, N) == (sin(q1)*sin(q2)*N.i -
|
||||
sin(q2)*cos(q1)*N.j + cos(q2)*N.k)
|
||||
assert express(B.i, A) == A.i
|
||||
assert express(B.j, A) == (cos(q2)*A.j + sin(q2)*A.k)
|
||||
assert express(B.k, A) == (-sin(q2)*A.j + cos(q2)*A.k)
|
||||
assert express(B.i, B) == B.i
|
||||
assert express(B.j, B) == B.j
|
||||
assert express(B.k, B) == B.k
|
||||
assert express(B.i, C) == (cos(q3)*C.i + sin(q3)*C.k)
|
||||
assert express(B.j, C) == C.j
|
||||
assert express(B.k, C) == (-sin(q3)*C.i + cos(q3)*C.k)
|
||||
|
||||
assert express(C.i, N) == (
|
||||
(cos(q1)*cos(q3) - sin(q1)*sin(q2)*sin(q3))*N.i +
|
||||
(sin(q1)*cos(q3) + sin(q2)*sin(q3)*cos(q1))*N.j -
|
||||
sin(q3)*cos(q2)*N.k)
|
||||
assert express(C.j, N) == (
|
||||
-sin(q1)*cos(q2)*N.i + cos(q1)*cos(q2)*N.j + sin(q2)*N.k)
|
||||
assert express(C.k, N) == (
|
||||
(sin(q3)*cos(q1) + sin(q1)*sin(q2)*cos(q3))*N.i +
|
||||
(sin(q1)*sin(q3) - sin(q2)*cos(q1)*cos(q3))*N.j +
|
||||
cos(q2)*cos(q3)*N.k)
|
||||
assert express(C.i, A) == (cos(q3)*A.i + sin(q2)*sin(q3)*A.j -
|
||||
sin(q3)*cos(q2)*A.k)
|
||||
assert express(C.j, A) == (cos(q2)*A.j + sin(q2)*A.k)
|
||||
assert express(C.k, A) == (sin(q3)*A.i - sin(q2)*cos(q3)*A.j +
|
||||
cos(q2)*cos(q3)*A.k)
|
||||
assert express(C.i, B) == (cos(q3)*B.i - sin(q3)*B.k)
|
||||
assert express(C.j, B) == B.j
|
||||
assert express(C.k, B) == (sin(q3)*B.i + cos(q3)*B.k)
|
||||
assert express(C.i, C) == C.i
|
||||
assert express(C.j, C) == C.j
|
||||
assert express(C.k, C) == C.k == (C.k)
|
||||
|
||||
# Check to make sure Vectors get converted back to UnitVectors
|
||||
assert N.i == express((cos(q1)*A.i - sin(q1)*A.j), N).simplify()
|
||||
assert N.j == express((sin(q1)*A.i + cos(q1)*A.j), N).simplify()
|
||||
assert N.i == express((cos(q1)*B.i - sin(q1)*cos(q2)*B.j +
|
||||
sin(q1)*sin(q2)*B.k), N).simplify()
|
||||
assert N.j == express((sin(q1)*B.i + cos(q1)*cos(q2)*B.j -
|
||||
sin(q2)*cos(q1)*B.k), N).simplify()
|
||||
assert N.k == express((sin(q2)*B.j + cos(q2)*B.k), N).simplify()
|
||||
|
||||
|
||||
assert A.i == express((cos(q1)*N.i + sin(q1)*N.j), A).simplify()
|
||||
assert A.j == express((-sin(q1)*N.i + cos(q1)*N.j), A).simplify()
|
||||
|
||||
assert A.j == express((cos(q2)*B.j - sin(q2)*B.k), A).simplify()
|
||||
assert A.k == express((sin(q2)*B.j + cos(q2)*B.k), A).simplify()
|
||||
|
||||
assert A.i == express((cos(q3)*C.i + sin(q3)*C.k), A).simplify()
|
||||
assert A.j == express((sin(q2)*sin(q3)*C.i + cos(q2)*C.j -
|
||||
sin(q2)*cos(q3)*C.k), A).simplify()
|
||||
|
||||
assert A.k == express((-sin(q3)*cos(q2)*C.i + sin(q2)*C.j +
|
||||
cos(q2)*cos(q3)*C.k), A).simplify()
|
||||
assert B.i == express((cos(q1)*N.i + sin(q1)*N.j), B).simplify()
|
||||
assert B.j == express((-sin(q1)*cos(q2)*N.i +
|
||||
cos(q1)*cos(q2)*N.j + sin(q2)*N.k), B).simplify()
|
||||
|
||||
assert B.k == express((sin(q1)*sin(q2)*N.i -
|
||||
sin(q2)*cos(q1)*N.j + cos(q2)*N.k), B).simplify()
|
||||
|
||||
assert B.j == express((cos(q2)*A.j + sin(q2)*A.k), B).simplify()
|
||||
assert B.k == express((-sin(q2)*A.j + cos(q2)*A.k), B).simplify()
|
||||
assert B.i == express((cos(q3)*C.i + sin(q3)*C.k), B).simplify()
|
||||
assert B.k == express((-sin(q3)*C.i + cos(q3)*C.k), B).simplify()
|
||||
assert C.i == express((cos(q3)*A.i + sin(q2)*sin(q3)*A.j -
|
||||
sin(q3)*cos(q2)*A.k), C).simplify()
|
||||
assert C.j == express((cos(q2)*A.j + sin(q2)*A.k), C).simplify()
|
||||
assert C.k == express((sin(q3)*A.i - sin(q2)*cos(q3)*A.j +
|
||||
cos(q2)*cos(q3)*A.k), C).simplify()
|
||||
assert C.i == express((cos(q3)*B.i - sin(q3)*B.k), C).simplify()
|
||||
assert C.k == express((sin(q3)*B.i + cos(q3)*B.k), C).simplify()
|
||||
|
||||
|
||||
def test_matrix_to_vector():
|
||||
m = Matrix([[1], [2], [3]])
|
||||
assert matrix_to_vector(m, C) == C.i + 2*C.j + 3*C.k
|
||||
m = Matrix([[0], [0], [0]])
|
||||
assert matrix_to_vector(m, N) == matrix_to_vector(m, C) == \
|
||||
Vector.zero
|
||||
m = Matrix([[q1], [q2], [q3]])
|
||||
assert matrix_to_vector(m, N) == q1*N.i + q2*N.j + q3*N.k
|
||||
|
||||
|
||||
def test_orthogonalize():
|
||||
C = CoordSys3D('C')
|
||||
a, b = symbols('a b', integer=True)
|
||||
i, j, k = C.base_vectors()
|
||||
v1 = i + 2*j
|
||||
v2 = 2*i + 3*j
|
||||
v3 = 3*i + 5*j
|
||||
v4 = 3*i + j
|
||||
v5 = 2*i + 2*j
|
||||
v6 = a*i + b*j
|
||||
v7 = 4*a*i + 4*b*j
|
||||
assert orthogonalize(v1, v2) == [C.i + 2*C.j, C.i*Rational(2, 5) + -C.j/5]
|
||||
# from wikipedia
|
||||
assert orthogonalize(v4, v5, orthonormal=True) == \
|
||||
[(3*sqrt(10))*C.i/10 + (sqrt(10))*C.j/10, (-sqrt(10))*C.i/10 + (3*sqrt(10))*C.j/10]
|
||||
raises(ValueError, lambda: orthogonalize(v1, v2, v3))
|
||||
raises(ValueError, lambda: orthogonalize(v6, v7))
|
||||
@@ -0,0 +1,90 @@
|
||||
from sympy.core.relational import Eq
|
||||
from sympy.core.singleton import S
|
||||
from sympy.abc import x, y, z, s, t
|
||||
from sympy.sets import FiniteSet, EmptySet
|
||||
from sympy.geometry import Point
|
||||
from sympy.vector import ImplicitRegion
|
||||
from sympy.testing.pytest import raises
|
||||
|
||||
|
||||
def test_ImplicitRegion():
|
||||
ellipse = ImplicitRegion((x, y), (x**2/4 + y**2/16 - 1))
|
||||
assert ellipse.equation == x**2/4 + y**2/16 - 1
|
||||
assert ellipse.variables == (x, y)
|
||||
assert ellipse.degree == 2
|
||||
r = ImplicitRegion((x, y, z), Eq(x**4 + y**2 - x*y, 6))
|
||||
assert r.equation == x**4 + y**2 - x*y - 6
|
||||
assert r.variables == (x, y, z)
|
||||
assert r.degree == 4
|
||||
|
||||
|
||||
def test_regular_point():
|
||||
r1 = ImplicitRegion((x,), x**2 - 16)
|
||||
assert r1.regular_point() == (-4,)
|
||||
c1 = ImplicitRegion((x, y), x**2 + y**2 - 4)
|
||||
assert c1.regular_point() == (0, -2)
|
||||
c2 = ImplicitRegion((x, y), (x - S(5)/2)**2 + y**2 - (S(1)/4)**2)
|
||||
assert c2.regular_point() == (S(5)/2, -S(1)/4)
|
||||
c3 = ImplicitRegion((x, y), (y - 5)**2 - 16*(x - 5))
|
||||
assert c3.regular_point() == (5, 5)
|
||||
r2 = ImplicitRegion((x, y), x**2 - 4*x*y - 3*y**2 + 4*x + 8*y - 5)
|
||||
assert r2.regular_point() == (S(4)/7, S(9)/7)
|
||||
r3 = ImplicitRegion((x, y), x**2 - 2*x*y + 3*y**2 - 2*x - 5*y + 3/2)
|
||||
raises(ValueError, lambda: r3.regular_point())
|
||||
|
||||
|
||||
def test_singular_points_and_multiplicty():
|
||||
r1 = ImplicitRegion((x, y, z), Eq(x + y + z, 0))
|
||||
assert r1.singular_points() == EmptySet
|
||||
r2 = ImplicitRegion((x, y, z), x*y*z + y**4 -x**2*z**2)
|
||||
assert r2.singular_points() == FiniteSet((0, 0, z), (x, 0, 0))
|
||||
assert r2.multiplicity((0, 0, 0)) == 3
|
||||
assert r2.multiplicity((0, 0, 6)) == 2
|
||||
r3 = ImplicitRegion((x, y, z), z**2 - x**2 - y**2)
|
||||
assert r3.singular_points() == FiniteSet((0, 0, 0))
|
||||
assert r3.multiplicity((0, 0, 0)) == 2
|
||||
r4 = ImplicitRegion((x, y), x**2 + y**2 - 2*x)
|
||||
assert r4.singular_points() == EmptySet
|
||||
assert r4.multiplicity(Point(1, 3)) == 0
|
||||
|
||||
|
||||
def test_rational_parametrization():
|
||||
p = ImplicitRegion((x,), x - 2)
|
||||
assert p.rational_parametrization() == (x - 2,)
|
||||
|
||||
line = ImplicitRegion((x, y), Eq(y, 3*x + 2))
|
||||
assert line.rational_parametrization() == (x, 3*x + 2)
|
||||
|
||||
circle1 = ImplicitRegion((x, y), (x-2)**2 + (y+3)**2 - 4)
|
||||
assert circle1.rational_parametrization(parameters=t) == (4*t/(t**2 + 1) + 2, 4*t**2/(t**2 + 1) - 5)
|
||||
circle2 = ImplicitRegion((x, y), (x - S.Half)**2 + y**2 - (S(1)/2)**2)
|
||||
|
||||
assert circle2.rational_parametrization(parameters=t) == (t/(t**2 + 1) + S(1)/2, t**2/(t**2 + 1) - S(1)/2)
|
||||
circle3 = ImplicitRegion((x, y), Eq(x**2 + y**2, 2*x))
|
||||
assert circle3.rational_parametrization(parameters=(t,)) == (2*t/(t**2 + 1) + 1, 2*t**2/(t**2 + 1) - 1)
|
||||
|
||||
parabola = ImplicitRegion((x, y), (y - 3)**2 - 4*(x + 6))
|
||||
assert parabola.rational_parametrization(t) == (-6 + 4/t**2, 3 + 4/t)
|
||||
|
||||
rect_hyperbola = ImplicitRegion((x, y), x*y - 1)
|
||||
assert rect_hyperbola.rational_parametrization(t) == (-1 + (t + 1)/t, t)
|
||||
|
||||
cubic_curve = ImplicitRegion((x, y), x**3 + x**2 - y**2)
|
||||
assert cubic_curve.rational_parametrization(parameters=(t)) == (t**2 - 1, t*(t**2 - 1))
|
||||
cuspidal = ImplicitRegion((x, y), (x**3 - y**2))
|
||||
assert cuspidal.rational_parametrization(t) == (t**2, t**3)
|
||||
|
||||
I = ImplicitRegion((x, y), x**3 + x**2 - y**2)
|
||||
assert I.rational_parametrization(t) == (t**2 - 1, t*(t**2 - 1))
|
||||
|
||||
sphere = ImplicitRegion((x, y, z), Eq(x**2 + y**2 + z**2, 2*x))
|
||||
assert sphere.rational_parametrization(parameters=(s, t)) == (2/(s**2 + t**2 + 1), 2*t/(s**2 + t**2 + 1), 2*s/(s**2 + t**2 + 1))
|
||||
|
||||
conic = ImplicitRegion((x, y), Eq(x**2 + 4*x*y + 3*y**2 + x - y + 10, 0))
|
||||
assert conic.rational_parametrization(t) == (
|
||||
S(17)/2 + 4/(3*t**2 + 4*t + 1), 4*t/(3*t**2 + 4*t + 1) - S(11)/2)
|
||||
|
||||
r1 = ImplicitRegion((x, y), y**2 - x**3 + x)
|
||||
raises(NotImplementedError, lambda: r1.rational_parametrization())
|
||||
r2 = ImplicitRegion((x, y), y**2 - x**3 - x**2 + 1)
|
||||
raises(NotImplementedError, lambda: r2.rational_parametrization())
|
||||
@@ -0,0 +1,106 @@
|
||||
from sympy.core.numbers import pi
|
||||
from sympy.core.singleton import S
|
||||
from sympy.functions.elementary.miscellaneous import sqrt
|
||||
from sympy.functions.elementary.trigonometric import (cos, sin)
|
||||
from sympy.testing.pytest import raises
|
||||
from sympy.vector.coordsysrect import CoordSys3D
|
||||
from sympy.vector.integrals import ParametricIntegral, vector_integrate
|
||||
from sympy.vector.parametricregion import ParametricRegion
|
||||
from sympy.vector.implicitregion import ImplicitRegion
|
||||
from sympy.abc import x, y, z, u, v, r, t, theta, phi
|
||||
from sympy.geometry import Point, Segment, Curve, Circle, Polygon, Plane
|
||||
|
||||
C = CoordSys3D('C')
|
||||
|
||||
def test_parametric_lineintegrals():
|
||||
halfcircle = ParametricRegion((4*cos(theta), 4*sin(theta)), (theta, -pi/2, pi/2))
|
||||
assert ParametricIntegral(C.x*C.y**4, halfcircle) == S(8192)/5
|
||||
|
||||
curve = ParametricRegion((t, t**2, t**3), (t, 0, 1))
|
||||
field1 = 8*C.x**2*C.y*C.z*C.i + 5*C.z*C.j - 4*C.x*C.y*C.k
|
||||
assert ParametricIntegral(field1, curve) == 1
|
||||
line = ParametricRegion((4*t - 1, 2 - 2*t, t), (t, 0, 1))
|
||||
assert ParametricIntegral(C.x*C.z*C.i - C.y*C.z*C.k, line) == 3
|
||||
|
||||
assert ParametricIntegral(4*C.x**3, ParametricRegion((1, t), (t, 0, 2))) == 8
|
||||
|
||||
helix = ParametricRegion((cos(t), sin(t), 3*t), (t, 0, 4*pi))
|
||||
assert ParametricIntegral(C.x*C.y*C.z, helix) == -3*sqrt(10)*pi
|
||||
|
||||
field2 = C.y*C.i + C.z*C.j + C.z*C.k
|
||||
assert ParametricIntegral(field2, ParametricRegion((cos(t), sin(t), t**2), (t, 0, pi))) == -5*pi/2 + pi**4/2
|
||||
|
||||
def test_parametric_surfaceintegrals():
|
||||
|
||||
semisphere = ParametricRegion((2*sin(phi)*cos(theta), 2*sin(phi)*sin(theta), 2*cos(phi)),\
|
||||
(theta, 0, 2*pi), (phi, 0, pi/2))
|
||||
assert ParametricIntegral(C.z, semisphere) == 8*pi
|
||||
|
||||
cylinder = ParametricRegion((sqrt(3)*cos(theta), sqrt(3)*sin(theta), z), (z, 0, 6), (theta, 0, 2*pi))
|
||||
assert ParametricIntegral(C.y, cylinder) == 0
|
||||
|
||||
cone = ParametricRegion((v*cos(u), v*sin(u), v), (u, 0, 2*pi), (v, 0, 1))
|
||||
assert ParametricIntegral(C.x*C.i + C.y*C.j + C.z**4*C.k, cone) == pi/3
|
||||
|
||||
triangle1 = ParametricRegion((x, y), (x, 0, 2), (y, 0, 10 - 5*x))
|
||||
triangle2 = ParametricRegion((x, y), (y, 0, 10 - 5*x), (x, 0, 2))
|
||||
assert ParametricIntegral(-15.6*C.y*C.k, triangle1) == ParametricIntegral(-15.6*C.y*C.k, triangle2)
|
||||
assert ParametricIntegral(C.z, triangle1) == 10*C.z
|
||||
|
||||
def test_parametric_volumeintegrals():
|
||||
|
||||
cube = ParametricRegion((x, y, z), (x, 0, 1), (y, 0, 1), (z, 0, 1))
|
||||
assert ParametricIntegral(1, cube) == 1
|
||||
|
||||
solidsphere1 = ParametricRegion((r*sin(phi)*cos(theta), r*sin(phi)*sin(theta), r*cos(phi)),\
|
||||
(r, 0, 2), (theta, 0, 2*pi), (phi, 0, pi))
|
||||
solidsphere2 = ParametricRegion((r*sin(phi)*cos(theta), r*sin(phi)*sin(theta), r*cos(phi)),\
|
||||
(r, 0, 2), (phi, 0, pi), (theta, 0, 2*pi))
|
||||
assert ParametricIntegral(C.x**2 + C.y**2, solidsphere1) == -256*pi/15
|
||||
assert ParametricIntegral(C.x**2 + C.y**2, solidsphere2) == 256*pi/15
|
||||
|
||||
region_under_plane1 = ParametricRegion((x, y, z), (x, 0, 3), (y, 0, -2*x/3 + 2),\
|
||||
(z, 0, 6 - 2*x - 3*y))
|
||||
region_under_plane2 = ParametricRegion((x, y, z), (x, 0, 3), (z, 0, 6 - 2*x - 3*y),\
|
||||
(y, 0, -2*x/3 + 2))
|
||||
|
||||
assert ParametricIntegral(C.x*C.i + C.j - 100*C.k, region_under_plane1) == \
|
||||
ParametricIntegral(C.x*C.i + C.j - 100*C.k, region_under_plane2)
|
||||
assert ParametricIntegral(2*C.x, region_under_plane2) == -9
|
||||
|
||||
def test_vector_integrate():
|
||||
halfdisc = ParametricRegion((r*cos(theta), r* sin(theta)), (r, -2, 2), (theta, 0, pi))
|
||||
assert vector_integrate(C.x**2, halfdisc) == 4*pi
|
||||
assert vector_integrate(C.x, ParametricRegion((t, t**2), (t, 2, 3))) == -17*sqrt(17)/12 + 37*sqrt(37)/12
|
||||
|
||||
assert vector_integrate(C.y**3*C.z, (C.x, 0, 3), (C.y, -1, 4)) == 765*C.z/4
|
||||
|
||||
s1 = Segment(Point(0, 0), Point(0, 1))
|
||||
assert vector_integrate(-15*C.y, s1) == S(-15)/2
|
||||
s2 = Segment(Point(4, 3, 9), Point(1, 1, 7))
|
||||
assert vector_integrate(C.y*C.i, s2) == -6
|
||||
|
||||
curve = Curve((sin(t), cos(t)), (t, 0, 2))
|
||||
assert vector_integrate(5*C.z, curve) == 10*C.z
|
||||
|
||||
c1 = Circle(Point(2, 3), 6)
|
||||
assert vector_integrate(C.x*C.y, c1) == 72*pi
|
||||
c2 = Circle(Point(0, 0), Point(1, 1), Point(1, 0))
|
||||
assert vector_integrate(1, c2) == c2.circumference
|
||||
|
||||
triangle = Polygon((0, 0), (1, 0), (1, 1))
|
||||
assert vector_integrate(C.x*C.i - 14*C.y*C.j, triangle) == 0
|
||||
p1, p2, p3, p4 = [(0, 0), (1, 0), (5, 1), (0, 1)]
|
||||
poly = Polygon(p1, p2, p3, p4)
|
||||
assert vector_integrate(-23*C.z, poly) == -161*C.z - 23*sqrt(17)*C.z
|
||||
|
||||
point = Point(2, 3)
|
||||
assert vector_integrate(C.i*C.y, point) == ParametricIntegral(C.y*C.i, ParametricRegion((2, 3)))
|
||||
|
||||
c3 = ImplicitRegion((x, y), x**2 + y**2 - 4)
|
||||
assert vector_integrate(45, c3) == 180*pi
|
||||
c4 = ImplicitRegion((x, y), (x - 3)**2 + (y - 4)**2 - 9)
|
||||
assert vector_integrate(1, c4) == 6*pi
|
||||
|
||||
pl = Plane(Point(1, 1, 1), Point(2, 3, 4), Point(2, 2, 2))
|
||||
raises(ValueError, lambda: vector_integrate(C.x*C.z*C.i + C.k, pl))
|
||||
@@ -0,0 +1,43 @@
|
||||
from sympy.vector import CoordSys3D, Gradient, Divergence, Curl, VectorZero, Laplacian
|
||||
from sympy.printing.repr import srepr
|
||||
|
||||
R = CoordSys3D('R')
|
||||
s1 = R.x*R.y*R.z # type: ignore
|
||||
s2 = R.x + 3*R.y**2 # type: ignore
|
||||
s3 = R.x**2 + R.y**2 + R.z**2 # type: ignore
|
||||
v1 = R.x*R.i + R.z*R.z*R.j # type: ignore
|
||||
v2 = R.x*R.i + R.y*R.j + R.z*R.k # type: ignore
|
||||
v3 = R.x**2*R.i + R.y**2*R.j + R.z**2*R.k # type: ignore
|
||||
|
||||
|
||||
def test_Gradient():
|
||||
assert Gradient(s1) == Gradient(R.x*R.y*R.z)
|
||||
assert Gradient(s2) == Gradient(R.x + 3*R.y**2)
|
||||
assert Gradient(s1).doit() == R.y*R.z*R.i + R.x*R.z*R.j + R.x*R.y*R.k
|
||||
assert Gradient(s2).doit() == R.i + 6*R.y*R.j
|
||||
|
||||
|
||||
def test_Divergence():
|
||||
assert Divergence(v1) == Divergence(R.x*R.i + R.z*R.z*R.j)
|
||||
assert Divergence(v2) == Divergence(R.x*R.i + R.y*R.j + R.z*R.k)
|
||||
assert Divergence(v1).doit() == 1
|
||||
assert Divergence(v2).doit() == 3
|
||||
# issue 22384
|
||||
Rc = CoordSys3D('R', transformation='cylindrical')
|
||||
assert Divergence(Rc.i).doit() == 1/Rc.r
|
||||
|
||||
|
||||
def test_Curl():
|
||||
assert Curl(v1) == Curl(R.x*R.i + R.z*R.z*R.j)
|
||||
assert Curl(v2) == Curl(R.x*R.i + R.y*R.j + R.z*R.k)
|
||||
assert Curl(v1).doit() == (-2*R.z)*R.i
|
||||
assert Curl(v2).doit() == VectorZero()
|
||||
|
||||
|
||||
def test_Laplacian():
|
||||
assert Laplacian(s3) == Laplacian(R.x**2 + R.y**2 + R.z**2)
|
||||
assert Laplacian(v3) == Laplacian(R.x**2*R.i + R.y**2*R.j + R.z**2*R.k)
|
||||
assert Laplacian(s3).doit() == 6
|
||||
assert Laplacian(v3).doit() == 2*R.i + 2*R.j + 2*R.k
|
||||
assert srepr(Laplacian(s3)) == \
|
||||
'Laplacian(Add(Pow(R.x, Integer(2)), Pow(R.y, Integer(2)), Pow(R.z, Integer(2))))'
|
||||
@@ -0,0 +1,97 @@
|
||||
from sympy.core.numbers import pi
|
||||
from sympy.functions.elementary.trigonometric import (cos, sin)
|
||||
from sympy.vector.coordsysrect import CoordSys3D
|
||||
from sympy.vector.parametricregion import ParametricRegion, parametric_region_list
|
||||
from sympy.geometry import Point, Segment, Curve, Ellipse, Line, Parabola, Polygon
|
||||
from sympy.testing.pytest import raises
|
||||
from sympy.abc import a, b, r, t, x, y, z, theta, phi
|
||||
|
||||
|
||||
C = CoordSys3D('C')
|
||||
|
||||
def test_ParametricRegion():
|
||||
|
||||
point = ParametricRegion((3, 4))
|
||||
assert point.definition == (3, 4)
|
||||
assert point.parameters == ()
|
||||
assert point.limits == {}
|
||||
assert point.dimensions == 0
|
||||
|
||||
# line x = y
|
||||
line_xy = ParametricRegion((y, y), (y, 1, 5))
|
||||
assert line_xy .definition == (y, y)
|
||||
assert line_xy.parameters == (y,)
|
||||
assert line_xy.dimensions == 1
|
||||
|
||||
# line y = z
|
||||
line_yz = ParametricRegion((x,t,t), x, (t, 1, 2))
|
||||
assert line_yz.definition == (x,t,t)
|
||||
assert line_yz.parameters == (x, t)
|
||||
assert line_yz.limits == {t: (1, 2)}
|
||||
assert line_yz.dimensions == 1
|
||||
|
||||
p1 = ParametricRegion((9*a, -16*b), (a, 0, 2), (b, -1, 5))
|
||||
assert p1.definition == (9*a, -16*b)
|
||||
assert p1.parameters == (a, b)
|
||||
assert p1.limits == {a: (0, 2), b: (-1, 5)}
|
||||
assert p1.dimensions == 2
|
||||
|
||||
p2 = ParametricRegion((t, t**3), t)
|
||||
assert p2.parameters == (t,)
|
||||
assert p2.limits == {}
|
||||
assert p2.dimensions == 0
|
||||
|
||||
circle = ParametricRegion((r*cos(theta), r*sin(theta)), r, (theta, 0, 2*pi))
|
||||
assert circle.definition == (r*cos(theta), r*sin(theta))
|
||||
assert circle.dimensions == 1
|
||||
|
||||
halfdisc = ParametricRegion((r*cos(theta), r*sin(theta)), (r, -2, 2), (theta, 0, pi))
|
||||
assert halfdisc.definition == (r*cos(theta), r*sin(theta))
|
||||
assert halfdisc.parameters == (r, theta)
|
||||
assert halfdisc.limits == {r: (-2, 2), theta: (0, pi)}
|
||||
assert halfdisc.dimensions == 2
|
||||
|
||||
ellipse = ParametricRegion((a*cos(t), b*sin(t)), (t, 0, 8))
|
||||
assert ellipse.parameters == (t,)
|
||||
assert ellipse.limits == {t: (0, 8)}
|
||||
assert ellipse.dimensions == 1
|
||||
|
||||
cylinder = ParametricRegion((r*cos(theta), r*sin(theta), z), (r, 0, 1), (theta, 0, 2*pi), (z, 0, 4))
|
||||
assert cylinder.parameters == (r, theta, z)
|
||||
assert cylinder.dimensions == 3
|
||||
|
||||
sphere = ParametricRegion((r*sin(phi)*cos(theta),r*sin(phi)*sin(theta), r*cos(phi)),
|
||||
r, (theta, 0, 2*pi), (phi, 0, pi))
|
||||
assert sphere.definition == (r*sin(phi)*cos(theta),r*sin(phi)*sin(theta), r*cos(phi))
|
||||
assert sphere.parameters == (r, theta, phi)
|
||||
assert sphere.dimensions == 2
|
||||
|
||||
raises(ValueError, lambda: ParametricRegion((a*t**2, 2*a*t), (a, -2)))
|
||||
raises(ValueError, lambda: ParametricRegion((a, b), (a**2, sin(b)), (a, 2, 4, 6)))
|
||||
|
||||
|
||||
def test_parametric_region_list():
|
||||
|
||||
point = Point(-5, 12)
|
||||
assert parametric_region_list(point) == [ParametricRegion((-5, 12))]
|
||||
|
||||
e = Ellipse(Point(2, 8), 2, 6)
|
||||
assert parametric_region_list(e, t) == [ParametricRegion((2*cos(t) + 2, 6*sin(t) + 8), (t, 0, 2*pi))]
|
||||
|
||||
c = Curve((t, t**3), (t, 5, 3))
|
||||
assert parametric_region_list(c) == [ParametricRegion((t, t**3), (t, 5, 3))]
|
||||
|
||||
s = Segment(Point(2, 11, -6), Point(0, 2, 5))
|
||||
assert parametric_region_list(s, t) == [ParametricRegion((2 - 2*t, 11 - 9*t, 11*t - 6), (t, 0, 1))]
|
||||
s1 = Segment(Point(0, 0), (1, 0))
|
||||
assert parametric_region_list(s1, t) == [ParametricRegion((t, 0), (t, 0, 1))]
|
||||
s2 = Segment(Point(1, 2, 3), Point(1, 2, 5))
|
||||
assert parametric_region_list(s2, t) == [ParametricRegion((1, 2, 2*t + 3), (t, 0, 1))]
|
||||
s3 = Segment(Point(12, 56), Point(12, 56))
|
||||
assert parametric_region_list(s3) == [ParametricRegion((12, 56))]
|
||||
|
||||
poly = Polygon((1,3), (-3, 8), (2, 4))
|
||||
assert parametric_region_list(poly, t) == [ParametricRegion((1 - 4*t, 5*t + 3), (t, 0, 1)), ParametricRegion((5*t - 3, 8 - 4*t), (t, 0, 1)), ParametricRegion((2 - t, 4 - t), (t, 0, 1))]
|
||||
|
||||
p1 = Parabola(Point(0, 0), Line(Point(5, 8), Point(7,8)))
|
||||
raises(ValueError, lambda: parametric_region_list(p1))
|
||||
@@ -0,0 +1,221 @@
|
||||
# -*- coding: utf-8 -*-
|
||||
from sympy.core.function import Function
|
||||
from sympy.integrals.integrals import Integral
|
||||
from sympy.printing.latex import latex
|
||||
from sympy.printing.pretty import pretty as xpretty
|
||||
from sympy.vector import CoordSys3D, Del, Vector, express
|
||||
from sympy.abc import a, b, c
|
||||
from sympy.testing.pytest import XFAIL
|
||||
|
||||
|
||||
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 = CoordSys3D('N')
|
||||
C = N.orient_new_axis('C', a, N.k) # type: ignore
|
||||
v = []
|
||||
d = []
|
||||
v.append(Vector.zero)
|
||||
v.append(N.i) # type: ignore
|
||||
v.append(-N.i) # type: ignore
|
||||
v.append(N.i + N.j) # type: ignore
|
||||
v.append(a*N.i) # type: ignore
|
||||
v.append(a*N.i - b*N.j) # type: ignore
|
||||
v.append((a**2 + N.x)*N.i + N.k) # type: ignore
|
||||
v.append((a**2 + b)*N.i + 3*(C.y - c)*N.k) # type: ignore
|
||||
f = Function('f')
|
||||
v.append(N.j - (Integral(f(b)) - C.x**2)*N.k) # type: ignore
|
||||
upretty_v_8 = """\
|
||||
⎛ 2 ⌠ ⎞ \n\
|
||||
j_N + ⎜x_C - ⎮ f(b) db⎟ k_N\n\
|
||||
⎝ ⌡ ⎠ \
|
||||
"""
|
||||
pretty_v_8 = """\
|
||||
j_N + / / \\\n\
|
||||
| 2 | |\n\
|
||||
|x_C - | f(b) db|\n\
|
||||
| | |\n\
|
||||
\\ / / \
|
||||
"""
|
||||
|
||||
v.append(N.i + C.k) # type: ignore
|
||||
v.append(express(N.i, C)) # type: ignore
|
||||
v.append((a**2 + b)*N.i + (Integral(f(b)))*N.k) # type: ignore
|
||||
upretty_v_11 = """\
|
||||
⎛ 2 ⎞ ⎛⌠ ⎞ \n\
|
||||
⎝a + b⎠ i_N + ⎜⎮ f(b) db⎟ k_N\n\
|
||||
⎝⌡ ⎠ \
|
||||
"""
|
||||
pretty_v_11 = """\
|
||||
/ 2 \\ + / / \\\n\
|
||||
\\a + b/ i_N| | |\n\
|
||||
| | f(b) db|\n\
|
||||
| | |\n\
|
||||
\\/ / \
|
||||
"""
|
||||
|
||||
for x in v:
|
||||
d.append(x | N.k) # type: ignore
|
||||
s = 3*N.x**2*C.y # type: ignore
|
||||
upretty_s = """\
|
||||
2\n\
|
||||
3⋅y_C⋅x_N \
|
||||
"""
|
||||
pretty_s = """\
|
||||
2\n\
|
||||
3*y_C*x_N \
|
||||
"""
|
||||
|
||||
# This is the pretty form for ((a**2 + b)*N.i + 3*(C.y - c)*N.k) | N.k
|
||||
upretty_d_7 = """\
|
||||
⎛ 2 ⎞ \n\
|
||||
⎝a + b⎠ (i_N|k_N) + (3⋅y_C - 3⋅c) (k_N|k_N)\
|
||||
"""
|
||||
pretty_d_7 = """\
|
||||
/ 2 \\ (i_N|k_N) + (3*y_C - 3*c) (k_N|k_N)\n\
|
||||
\\a + b/ \
|
||||
"""
|
||||
|
||||
|
||||
def test_str_printing():
|
||||
assert str(v[0]) == '0'
|
||||
assert str(v[1]) == 'N.i'
|
||||
assert str(v[2]) == '(-1)*N.i'
|
||||
assert str(v[3]) == 'N.i + N.j'
|
||||
assert str(v[8]) == 'N.j + (C.x**2 - Integral(f(b), b))*N.k'
|
||||
assert str(v[9]) == 'C.k + N.i'
|
||||
assert str(s) == '3*C.y*N.x**2'
|
||||
assert str(d[0]) == '0'
|
||||
assert str(d[1]) == '(N.i|N.k)'
|
||||
assert str(d[4]) == 'a*(N.i|N.k)'
|
||||
assert str(d[5]) == 'a*(N.i|N.k) + (-b)*(N.j|N.k)'
|
||||
assert str(d[8]) == ('(N.j|N.k) + (C.x**2 - ' +
|
||||
'Integral(f(b), b))*(N.k|N.k)')
|
||||
|
||||
|
||||
@XFAIL
|
||||
def test_pretty_printing_ascii():
|
||||
assert pretty(v[0]) == '0'
|
||||
assert pretty(v[1]) == 'i_N'
|
||||
assert pretty(v[5]) == '(a) i_N + (-b) j_N'
|
||||
assert pretty(v[8]) == pretty_v_8
|
||||
assert pretty(v[2]) == '(-1) i_N'
|
||||
assert pretty(v[11]) == pretty_v_11
|
||||
assert pretty(s) == pretty_s
|
||||
assert pretty(d[0]) == '(0|0)'
|
||||
assert pretty(d[5]) == '(a) (i_N|k_N) + (-b) (j_N|k_N)'
|
||||
assert pretty(d[7]) == pretty_d_7
|
||||
assert pretty(d[10]) == '(cos(a)) (i_C|k_N) + (-sin(a)) (j_C|k_N)'
|
||||
|
||||
|
||||
def test_pretty_print_unicode_v():
|
||||
assert upretty(v[0]) == '0'
|
||||
assert upretty(v[1]) == 'i_N'
|
||||
assert upretty(v[5]) == '(a) i_N + (-b) j_N'
|
||||
# Make sure the printing works in other objects
|
||||
assert upretty(v[5].args) == '((a) i_N, (-b) j_N)'
|
||||
assert upretty(v[8]) == upretty_v_8
|
||||
assert upretty(v[2]) == '(-1) i_N'
|
||||
assert upretty(v[11]) == upretty_v_11
|
||||
assert upretty(s) == upretty_s
|
||||
assert upretty(d[0]) == '(0|0)'
|
||||
assert upretty(d[5]) == '(a) (i_N|k_N) + (-b) (j_N|k_N)'
|
||||
assert upretty(d[7]) == upretty_d_7
|
||||
assert upretty(d[10]) == '(cos(a)) (i_C|k_N) + (-sin(a)) (j_C|k_N)'
|
||||
|
||||
|
||||
def test_latex_printing():
|
||||
assert latex(v[0]) == '\\mathbf{\\hat{0}}'
|
||||
assert latex(v[1]) == '\\mathbf{\\hat{i}_{N}}'
|
||||
assert latex(v[2]) == '- \\mathbf{\\hat{i}_{N}}'
|
||||
assert latex(v[5]) == ('\\left(a\\right)\\mathbf{\\hat{i}_{N}} + ' +
|
||||
'\\left(- b\\right)\\mathbf{\\hat{j}_{N}}')
|
||||
assert latex(v[6]) == ('\\left(\\mathbf{{x}_{N}} + a^{2}\\right)\\mathbf{\\hat{i}_' +
|
||||
'{N}} + \\mathbf{\\hat{k}_{N}}')
|
||||
assert latex(v[8]) == ('\\mathbf{\\hat{j}_{N}} + \\left(\\mathbf{{x}_' +
|
||||
'{C}}^{2} - \\int f{\\left(b \\right)}\\,' +
|
||||
' db\\right)\\mathbf{\\hat{k}_{N}}')
|
||||
assert latex(s) == '3 \\mathbf{{y}_{C}} \\mathbf{{x}_{N}}^{2}'
|
||||
assert latex(d[0]) == '(\\mathbf{\\hat{0}}|\\mathbf{\\hat{0}})'
|
||||
assert latex(d[4]) == ('\\left(a\\right)\\left(\\mathbf{\\hat{i}_{N}}{\\middle|}' +
|
||||
'\\mathbf{\\hat{k}_{N}}\\right)')
|
||||
assert latex(d[9]) == ('\\left(\\mathbf{\\hat{k}_{C}}{\\middle|}' +
|
||||
'\\mathbf{\\hat{k}_{N}}\\right) + \\left(' +
|
||||
'\\mathbf{\\hat{i}_{N}}{\\middle|}\\mathbf{' +
|
||||
'\\hat{k}_{N}}\\right)')
|
||||
assert latex(d[11]) == ('\\left(a^{2} + b\\right)\\left(\\mathbf{\\hat{i}_{N}}' +
|
||||
'{\\middle|}\\mathbf{\\hat{k}_{N}}\\right) + ' +
|
||||
'\\left(\\int f{\\left(b \\right)}\\, db\\right)\\left(' +
|
||||
'\\mathbf{\\hat{k}_{N}}{\\middle|}\\mathbf{' +
|
||||
'\\hat{k}_{N}}\\right)')
|
||||
|
||||
def test_issue_23058():
|
||||
from sympy import symbols, sin, cos, pi, UnevaluatedExpr
|
||||
|
||||
delop = Del()
|
||||
CC_ = CoordSys3D("C")
|
||||
y = CC_.y
|
||||
xhat = CC_.i
|
||||
|
||||
t = symbols("t")
|
||||
ten = symbols("10", positive=True)
|
||||
eps, mu = 4*pi*ten**(-11), ten**(-5)
|
||||
|
||||
Bx = 2 * ten**(-4) * cos(ten**5 * t) * sin(ten**(-3) * y)
|
||||
vecB = Bx * xhat
|
||||
vecE = (1/eps) * Integral(delop.cross(vecB/mu).doit(), t)
|
||||
vecE = vecE.doit()
|
||||
|
||||
vecB_str = """\
|
||||
⎛ ⎛y_C⎞ ⎛ 5 ⎞⎞ \n\
|
||||
⎜2⋅sin⎜───⎟⋅cos⎝10 ⋅t⎠⎟ i_C\n\
|
||||
⎜ ⎜ 3⎟ ⎟ \n\
|
||||
⎜ ⎝10 ⎠ ⎟ \n\
|
||||
⎜─────────────────────⎟ \n\
|
||||
⎜ 4 ⎟ \n\
|
||||
⎝ 10 ⎠ \
|
||||
"""
|
||||
vecE_str = """\
|
||||
⎛ 4 ⎛ 5 ⎞ ⎛y_C⎞ ⎞ \n\
|
||||
⎜-10 ⋅sin⎝10 ⋅t⎠⋅cos⎜───⎟ ⎟ k_C\n\
|
||||
⎜ ⎜ 3⎟ ⎟ \n\
|
||||
⎜ ⎝10 ⎠ ⎟ \n\
|
||||
⎜─────────────────────────⎟ \n\
|
||||
⎝ 2⋅π ⎠ \
|
||||
"""
|
||||
|
||||
assert upretty(vecB) == vecB_str
|
||||
assert upretty(vecE) == vecE_str
|
||||
|
||||
ten = UnevaluatedExpr(10)
|
||||
eps, mu = 4*pi*ten**(-11), ten**(-5)
|
||||
|
||||
Bx = 2 * ten**(-4) * cos(ten**5 * t) * sin(ten**(-3) * y)
|
||||
vecB = Bx * xhat
|
||||
|
||||
vecB_str = """\
|
||||
⎛ -4 ⎛ 5⎞ ⎛ -3⎞⎞ \n\
|
||||
⎝2⋅10 ⋅cos⎝t⋅10 ⎠⋅sin⎝y_C⋅10 ⎠⎠ i_C \
|
||||
"""
|
||||
assert upretty(vecB) == vecB_str
|
||||
|
||||
def test_custom_names():
|
||||
A = CoordSys3D('A', vector_names=['x', 'y', 'z'],
|
||||
variable_names=['i', 'j', 'k'])
|
||||
assert A.i.__str__() == 'A.i'
|
||||
assert A.x.__str__() == 'A.x'
|
||||
assert A.i._pretty_form == 'i_A'
|
||||
assert A.x._pretty_form == 'x_A'
|
||||
assert A.i._latex_form == r'\mathbf{{i}_{A}}'
|
||||
assert A.x._latex_form == r"\mathbf{\hat{x}_{A}}"
|
||||
@@ -0,0 +1,342 @@
|
||||
from sympy.core import Rational, S, Add, Mul, I
|
||||
from sympy.simplify import simplify, trigsimp
|
||||
from sympy.core.function import (Derivative, Function, diff)
|
||||
from sympy.core.numbers import pi
|
||||
from sympy.core.symbol import symbols
|
||||
from sympy.functions.elementary.miscellaneous import sqrt
|
||||
from sympy.functions.elementary.trigonometric import (cos, sin)
|
||||
from sympy.integrals.integrals import Integral
|
||||
from sympy.matrices.immutable import ImmutableDenseMatrix as Matrix
|
||||
from sympy.vector.vector import Vector, BaseVector, VectorAdd, \
|
||||
VectorMul, VectorZero
|
||||
from sympy.vector.coordsysrect import CoordSys3D
|
||||
from sympy.vector.vector import Cross, Dot, cross
|
||||
from sympy.testing.pytest import raises
|
||||
from sympy.vector.kind import VectorKind
|
||||
from sympy.core.kind import NumberKind
|
||||
from sympy.testing.pytest import XFAIL
|
||||
|
||||
|
||||
C = CoordSys3D('C')
|
||||
|
||||
i, j, k = C.base_vectors()
|
||||
a, b, c = symbols('a b c')
|
||||
|
||||
|
||||
def test_cross():
|
||||
v1 = C.x * i + C.z * C.z * j
|
||||
v2 = C.x * i + C.y * j + C.z * k
|
||||
assert Cross(v1, v2) == Cross(C.x*C.i + C.z**2*C.j, C.x*C.i + C.y*C.j + C.z*C.k)
|
||||
assert Cross(v1, v2).doit() == C.z**3*C.i + (-C.x*C.z)*C.j + (C.x*C.y - C.x*C.z**2)*C.k
|
||||
assert cross(v1, v2) == C.z**3*C.i + (-C.x*C.z)*C.j + (C.x*C.y - C.x*C.z**2)*C.k
|
||||
assert Cross(v1, v2) == -Cross(v2, v1)
|
||||
# XXX: Cannot use Cross here. See XFAIL test below:
|
||||
assert cross(v1, v2) + cross(v2, v1) == Vector.zero
|
||||
|
||||
|
||||
@XFAIL
|
||||
def test_cross_xfail():
|
||||
v1 = C.x * i + C.z * C.z * j
|
||||
v2 = C.x * i + C.y * j + C.z * k
|
||||
assert Cross(v1, v2) + Cross(v2, v1) == Vector.zero
|
||||
|
||||
|
||||
def test_dot():
|
||||
v1 = C.x * i + C.z * C.z * j
|
||||
v2 = C.x * i + C.y * j + C.z * k
|
||||
assert Dot(v1, v2) == Dot(C.x*C.i + C.z**2*C.j, C.x*C.i + C.y*C.j + C.z*C.k)
|
||||
assert Dot(v1, v2).doit() == C.x**2 + C.y*C.z**2
|
||||
assert Dot(v2, v1).doit() == C.x**2 + C.y*C.z**2
|
||||
assert Dot(v1, v2) == Dot(v2, v1)
|
||||
|
||||
|
||||
def test_vector_sympy():
|
||||
"""
|
||||
Test whether the Vector framework confirms to the hashing
|
||||
and equality testing properties of SymPy.
|
||||
"""
|
||||
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_kind():
|
||||
assert C.i.kind is VectorKind(NumberKind)
|
||||
assert C.j.kind is VectorKind(NumberKind)
|
||||
assert C.k.kind is VectorKind(NumberKind)
|
||||
|
||||
assert C.x.kind is NumberKind
|
||||
assert C.y.kind is NumberKind
|
||||
assert C.z.kind is NumberKind
|
||||
|
||||
assert Mul._kind_dispatcher(NumberKind, VectorKind(NumberKind)) is VectorKind(NumberKind)
|
||||
assert Mul(2, C.i).kind is VectorKind(NumberKind)
|
||||
|
||||
v1 = C.x * i + C.z * C.z * j
|
||||
v2 = C.x * i + C.y * j + C.z * k
|
||||
assert v1.kind is VectorKind(NumberKind)
|
||||
assert v2.kind is VectorKind(NumberKind)
|
||||
|
||||
assert (v1 + v2).kind is VectorKind(NumberKind)
|
||||
assert Add(v1, v2).kind is VectorKind(NumberKind)
|
||||
assert Cross(v1, v2).doit().kind is VectorKind(NumberKind)
|
||||
assert VectorAdd(v1, v2).kind is VectorKind(NumberKind)
|
||||
assert VectorMul(2, v1).kind is VectorKind(NumberKind)
|
||||
assert VectorZero().kind is VectorKind(NumberKind)
|
||||
|
||||
assert v1.projection(v2).kind is VectorKind(NumberKind)
|
||||
assert v2.projection(v1).kind is VectorKind(NumberKind)
|
||||
|
||||
|
||||
def test_vectoradd():
|
||||
assert isinstance(Add(C.i, C.j), VectorAdd)
|
||||
v1 = C.x * i + C.z * C.z * j
|
||||
v2 = C.x * i + C.y * j + C.z * k
|
||||
assert isinstance(Add(v1, v2), VectorAdd)
|
||||
|
||||
# https://github.com/sympy/sympy/issues/26121
|
||||
|
||||
E = Matrix([C.i, C.j, C.k]).T
|
||||
a = Matrix([1, 2, 3])
|
||||
av = E*a
|
||||
|
||||
assert av[0].kind == VectorKind()
|
||||
assert isinstance(av[0], VectorAdd)
|
||||
|
||||
|
||||
def test_vector():
|
||||
assert isinstance(i, BaseVector)
|
||||
assert i != j
|
||||
assert j != k
|
||||
assert k != i
|
||||
assert i - i == Vector.zero
|
||||
assert i + Vector.zero == i
|
||||
assert i - Vector.zero == i
|
||||
assert Vector.zero != 0
|
||||
assert -Vector.zero == Vector.zero
|
||||
|
||||
v1 = a*i + b*j + c*k
|
||||
v2 = a**2*i + b**2*j + c**2*k
|
||||
v3 = v1 + v2
|
||||
v4 = 2 * v1
|
||||
v5 = a * i
|
||||
|
||||
assert isinstance(v1, VectorAdd)
|
||||
assert v1 - v1 == Vector.zero
|
||||
assert v1 + Vector.zero == v1
|
||||
assert v1.dot(i) == a
|
||||
assert v1.dot(j) == b
|
||||
assert v1.dot(k) == c
|
||||
assert i.dot(v2) == a**2
|
||||
assert j.dot(v2) == b**2
|
||||
assert k.dot(v2) == c**2
|
||||
assert v3.dot(i) == a**2 + a
|
||||
assert v3.dot(j) == b**2 + b
|
||||
assert v3.dot(k) == c**2 + c
|
||||
|
||||
assert v1 + v2 == v2 + v1
|
||||
assert v1 - v2 == -1 * (v2 - v1)
|
||||
assert a * v1 == v1 * a
|
||||
|
||||
assert isinstance(v5, VectorMul)
|
||||
assert v5.base_vector == i
|
||||
assert v5.measure_number == a
|
||||
assert isinstance(v4, Vector)
|
||||
assert isinstance(v4, VectorAdd)
|
||||
assert isinstance(v4, Vector)
|
||||
assert isinstance(Vector.zero, VectorZero)
|
||||
assert isinstance(Vector.zero, Vector)
|
||||
assert isinstance(v1 * 0, VectorZero)
|
||||
|
||||
assert v1.to_matrix(C) == Matrix([[a], [b], [c]])
|
||||
|
||||
assert i.components == {i: 1}
|
||||
assert v5.components == {i: a}
|
||||
assert v1.components == {i: a, j: b, k: c}
|
||||
|
||||
assert VectorAdd(v1, Vector.zero) == v1
|
||||
assert VectorMul(a, v1) == v1*a
|
||||
assert VectorMul(1, i) == i
|
||||
assert VectorAdd(v1, Vector.zero) == v1
|
||||
assert VectorMul(0, Vector.zero) == Vector.zero
|
||||
raises(TypeError, lambda: v1.outer(1))
|
||||
raises(TypeError, lambda: v1.dot(1))
|
||||
|
||||
|
||||
def test_vector_magnitude_normalize():
|
||||
assert Vector.zero.magnitude() == 0
|
||||
assert Vector.zero.normalize() == Vector.zero
|
||||
|
||||
assert i.magnitude() == 1
|
||||
assert j.magnitude() == 1
|
||||
assert k.magnitude() == 1
|
||||
assert i.normalize() == i
|
||||
assert j.normalize() == j
|
||||
assert k.normalize() == k
|
||||
|
||||
v1 = a * i
|
||||
assert v1.normalize() == (a/sqrt(a**2))*i
|
||||
assert v1.magnitude() == sqrt(a**2)
|
||||
|
||||
v2 = a*i + b*j + c*k
|
||||
assert v2.magnitude() == sqrt(a**2 + b**2 + c**2)
|
||||
assert v2.normalize() == v2 / v2.magnitude()
|
||||
|
||||
v3 = i + j
|
||||
assert v3.normalize() == (sqrt(2)/2)*C.i + (sqrt(2)/2)*C.j
|
||||
|
||||
|
||||
def test_vector_simplify():
|
||||
A, s, k, m = symbols('A, s, k, m')
|
||||
|
||||
test1 = (1 / a + 1 / b) * i
|
||||
assert (test1 & i) != (a + b) / (a * b)
|
||||
test1 = simplify(test1)
|
||||
assert (test1 & i) == (a + b) / (a * b)
|
||||
assert test1.simplify() == simplify(test1)
|
||||
|
||||
test2 = (A**2 * s**4 / (4 * pi * k * m**3)) * i
|
||||
test2 = simplify(test2)
|
||||
assert (test2 & i) == (A**2 * s**4 / (4 * pi * k * m**3))
|
||||
|
||||
test3 = ((4 + 4 * a - 2 * (2 + 2 * a)) / (2 + 2 * a)) * i
|
||||
test3 = simplify(test3)
|
||||
assert (test3 & i) == 0
|
||||
|
||||
test4 = ((-4 * a * b**2 - 2 * b**3 - 2 * a**2 * b) / (a + b)**2) * i
|
||||
test4 = simplify(test4)
|
||||
assert (test4 & i) == -2 * b
|
||||
|
||||
v = (sin(a)+cos(a))**2*i - j
|
||||
assert trigsimp(v) == (2*sin(a + pi/4)**2)*i + (-1)*j
|
||||
assert trigsimp(v) == v.trigsimp()
|
||||
|
||||
assert simplify(Vector.zero) == Vector.zero
|
||||
|
||||
|
||||
def test_vector_equals():
|
||||
assert (2*i).equals(j) is False
|
||||
assert i.equals(i) is True
|
||||
|
||||
# https://github.com/sympy/sympy/issues/25915
|
||||
A = (sqrt(2) + sqrt(6)) / sqrt(sqrt(3) + 2)
|
||||
assert (A*i).equals(2*i) is True
|
||||
assert (A*i).equals(3*i) is False
|
||||
|
||||
# Test comparing vectors in different coordinate systems
|
||||
D = C.orient_new_axis('D', pi/2, C.k)
|
||||
assert (D.i).equals(C.j) is True
|
||||
assert (D.i).equals(C.i) is False
|
||||
|
||||
|
||||
def test_vector_conjugate():
|
||||
# https://github.com/sympy/sympy/issues/27094
|
||||
assert (I*i + (1 + I)*j + 2*k).conjugate() == -I*i + (1 - I)*j + 2*k
|
||||
|
||||
|
||||
def test_vector_dot():
|
||||
assert i.dot(Vector.zero) == 0
|
||||
assert Vector.zero.dot(i) == 0
|
||||
assert i & Vector.zero == 0
|
||||
|
||||
assert i.dot(i) == 1
|
||||
assert i.dot(j) == 0
|
||||
assert i.dot(k) == 0
|
||||
assert i & i == 1
|
||||
assert i & j == 0
|
||||
assert i & k == 0
|
||||
|
||||
assert j.dot(i) == 0
|
||||
assert j.dot(j) == 1
|
||||
assert j.dot(k) == 0
|
||||
assert j & i == 0
|
||||
assert j & j == 1
|
||||
assert j & k == 0
|
||||
|
||||
assert k.dot(i) == 0
|
||||
assert k.dot(j) == 0
|
||||
assert k.dot(k) == 1
|
||||
assert k & i == 0
|
||||
assert k & j == 0
|
||||
assert k & k == 1
|
||||
|
||||
raises(TypeError, lambda: k.dot(1))
|
||||
|
||||
|
||||
def test_vector_cross():
|
||||
assert i.cross(Vector.zero) == Vector.zero
|
||||
assert Vector.zero.cross(i) == Vector.zero
|
||||
|
||||
assert i.cross(i) == Vector.zero
|
||||
assert i.cross(j) == k
|
||||
assert i.cross(k) == -j
|
||||
assert i ^ i == Vector.zero
|
||||
assert i ^ j == k
|
||||
assert i ^ k == -j
|
||||
|
||||
assert j.cross(i) == -k
|
||||
assert j.cross(j) == Vector.zero
|
||||
assert j.cross(k) == i
|
||||
assert j ^ i == -k
|
||||
assert j ^ j == Vector.zero
|
||||
assert j ^ k == i
|
||||
|
||||
assert k.cross(i) == j
|
||||
assert k.cross(j) == -i
|
||||
assert k.cross(k) == Vector.zero
|
||||
assert k ^ i == j
|
||||
assert k ^ j == -i
|
||||
assert k ^ k == Vector.zero
|
||||
|
||||
assert k.cross(1) == Cross(k, 1)
|
||||
|
||||
|
||||
def test_projection():
|
||||
v1 = i + j + k
|
||||
v2 = 3*i + 4*j
|
||||
v3 = 0*i + 0*j
|
||||
assert v1.projection(v1) == i + j + k
|
||||
assert v1.projection(v2) == Rational(7, 3)*C.i + Rational(7, 3)*C.j + Rational(7, 3)*C.k
|
||||
assert v1.projection(v1, scalar=True) == S.One
|
||||
assert v1.projection(v2, scalar=True) == Rational(7, 3)
|
||||
assert v3.projection(v1) == Vector.zero
|
||||
assert v3.projection(v1, scalar=True) == S.Zero
|
||||
|
||||
|
||||
def test_vector_diff_integrate():
|
||||
f = Function('f')
|
||||
v = f(a)*C.i + a**2*C.j - C.k
|
||||
assert Derivative(v, a) == Derivative((f(a))*C.i +
|
||||
a**2*C.j + (-1)*C.k, a)
|
||||
assert (diff(v, a) == v.diff(a) == Derivative(v, a).doit() ==
|
||||
(Derivative(f(a), a))*C.i + 2*a*C.j)
|
||||
assert (Integral(v, a) == (Integral(f(a), a))*C.i +
|
||||
(Integral(a**2, a))*C.j + (Integral(-1, a))*C.k)
|
||||
|
||||
|
||||
def test_vector_args():
|
||||
raises(ValueError, lambda: BaseVector(3, C))
|
||||
raises(TypeError, lambda: BaseVector(0, Vector.zero))
|
||||
|
||||
|
||||
def test_srepr():
|
||||
from sympy.printing.repr import srepr
|
||||
res = "CoordSys3D(Str('C'), Tuple(ImmutableDenseMatrix([[Integer(1), "\
|
||||
"Integer(0), Integer(0)], [Integer(0), Integer(1), Integer(0)], "\
|
||||
"[Integer(0), Integer(0), Integer(1)]]), VectorZero())).i"
|
||||
assert srepr(C.i) == res
|
||||
|
||||
|
||||
def test_scalar():
|
||||
from sympy.vector import CoordSys3D
|
||||
C = CoordSys3D('C')
|
||||
v1 = 3*C.i + 4*C.j + 5*C.k
|
||||
v2 = 3*C.i - 4*C.j + 5*C.k
|
||||
assert v1.is_Vector is True
|
||||
assert v1.is_scalar is False
|
||||
assert (v1.dot(v2)).is_scalar is True
|
||||
assert (v1.cross(v2)).is_scalar is False
|
||||
Reference in New Issue
Block a user