def cross(self, vect):
"""
Represents the cross product between this operator and a given
vector - equal to the curl of the vector field.
Parameters
==========
vect : Vector
The vector whose curl is to be calculated.
Examples
========
>>> from sympy.vector import CoordSysCartesian
>>> C = CoordSysCartesian('C')
>>> v = C.x*C.y*C.z * (C.i + C.j + C.k)
>>> C.delop ^ v
(-C.x*C.y + C.x*C.z)*C.i + (C.x*C.y - C.y*C.z)*C.j + (-C.x*C.z + C.y*C.z)*C.k
>>> C.delop.cross(C.i)
0
"""
vectx = express(vect.dot(self._i), self.system)
vecty = express(vect.dot(self._j), self.system)
vectz = express(vect.dot(self._k), self.system)
outvec = Vector.zero
outvec += (diff(vectz, self._y) - diff(vecty, self._z)) * self._i
outvec += (diff(vectx, self._z) - diff(vectz, self._x)) * self._j
outvec += (diff(vecty, self._x) - diff(vectx, self._y)) * self._k
return outvec
def cross(self, vect):
"""
Represents the cross product between this operator and a given
vector - equal to the curl of the vector field.
Parameters
==========
vect : Vector
The vector whose curl is to be calculated.
Examples
========
>>> from sympy.vector import CoordSysCartesian
>>> C = CoordSysCartesian('C')
>>> v = C.x*C.y*C.z * (C.i + C.j + C.k)
>>> C.delop ^ v
(-C.x*C.y + C.x*C.z)*C.i + (C.x*C.y - C.y*C.z)*C.j + (-C.x*C.z + C.y*C.z)*C.k
>>> C.delop.cross(C.i)
0
"""
vectx = express(vect.dot(self._i), self.system)
vecty = express(vect.dot(self._j), self.system)
vectz = express(vect.dot(self._k), self.system)
outvec = Vector.zero
outvec += (diff(vectz, self._y) - diff(vecty, self._z)) * self._i
outvec += (diff(vectx, self._z) - diff(vectz, self._x)) * self._j
outvec += (diff(vecty, self._x) - diff(vectx, self._y)) * self._k
return outvec
def curl(vect, coord_sys=None, doit=True):
"""
Returns the curl of a vector field computed wrt the base scalars
of the given coordinate system.
Parameters
==========
vect : Vector
The vector operand
coord_sys : CoordSys3D
The coordinate system to calculate the gradient in.
Deprecated since version 1.1
doit : bool
If True, the result is returned after calling .doit() on
each component. Else, the returned expression contains
Derivative instances
Examples
========
>>> from sympy.vector import CoordSys3D, curl
>>> R = CoordSys3D('R')
>>> v1 = R.y*R.z*R.i + R.x*R.z*R.j + R.x*R.y*R.k
>>> curl(v1)
0
>>> v2 = R.x*R.y*R.z*R.i
>>> curl(v2)
R.x*R.y*R.j + (-R.x*R.z)*R.k
"""
coord_sys = _get_coord_sys_from_expr(vect, coord_sys)
if coord_sys is None:
return Vector.zero
else:
i, j, k = coord_sys.base_vectors()
x, y, z = coord_sys.base_scalars()
h1, h2, h3 = coord_sys.lame_coefficients()
from sympy.vector.functions import express
vectx = express(vect.dot(i), coord_sys, variables=True)
vecty = express(vect.dot(j), coord_sys, variables=True)
vectz = express(vect.dot(k), coord_sys, variables=True)
outvec = Vector.zero
outvec += (Derivative(vectz * h3, y) -
Derivative(vecty * h2, z)) * i / (h2 * h3)
outvec += (Derivative(vectx * h1, z) -
Derivative(vectz * h3, x)) * j / (h1 * h3)
outvec += (Derivative(vecty * h2, x) -
Derivative(vectx * h1, y)) * k / (h2 * h1)
if doit:
return outvec.doit()
return outvec
def curl(vect, coord_sys=None, doit=True):
"""
Returns the curl of a vector field computed wrt the base scalars
of the given coordinate system.
Parameters
==========
vect : Vector
The vector operand
coord_sys : CoordSysCartesian
The coordinate system to calculate the gradient in.
Deprecated since version 1.1
doit : bool
If True, the result is returned after calling .doit() on
each component. Else, the returned expression contains
Derivative instances
Examples
========
>>> from sympy.vector import CoordSysCartesian, curl
>>> R = CoordSysCartesian('R')
>>> v1 = R.y*R.z*R.i + R.x*R.z*R.j + R.x*R.y*R.k
>>> curl(v1)
0
>>> v2 = R.x*R.y*R.z*R.i
>>> curl(v2)
R.x*R.y*R.j + (-R.x*R.z)*R.k
"""
coord_sys = _get_coord_sys_from_expr(vect, coord_sys)
if coord_sys is None:
return Vector.zero
else:
from sympy.vector.functions import express
vectx = express(vect.dot(coord_sys._i), coord_sys, variables=True)
vecty = express(vect.dot(coord_sys._j), coord_sys, variables=True)
vectz = express(vect.dot(coord_sys._k), coord_sys, variables=True)
outvec = Vector.zero
outvec += (Derivative(vectz * coord_sys._h3, coord_sys._y) -
Derivative(vecty * coord_sys._h2, coord_sys._z)
) * coord_sys._i / (coord_sys._h2 * coord_sys._h3)
outvec += (Derivative(vectx * coord_sys._h1, coord_sys._z) -
Derivative(vectz * coord_sys._h3, coord_sys._x)
) * coord_sys._j / (coord_sys._h1 * coord_sys._h3)
outvec += (Derivative(vecty * coord_sys._h2, coord_sys._x) -
Derivative(vectx * coord_sys._h1, coord_sys._y)
) * coord_sys._k / (coord_sys._h2 * coord_sys._h1)
if doit:
return outvec.doit()
return outvec
def curl(vect, coord_sys=None, doit=True):
"""
Returns the curl of a vector field computed wrt the base scalars
of the given coordinate system.
Parameters
==========
vect : Vector
The vector operand
coord_sys : CoordSys3D
The coordinate system to calculate the gradient in.
Deprecated since version 1.1
doit : bool
If True, the result is returned after calling .doit() on
each component. Else, the returned expression contains
Derivative instances
Examples
========
>>> from sympy.vector import CoordSys3D, curl
>>> R = CoordSys3D('R')
>>> v1 = R.y*R.z*R.i + R.x*R.z*R.j + R.x*R.y*R.k
>>> curl(v1)
0
>>> v2 = R.x*R.y*R.z*R.i
>>> curl(v2)
R.x*R.y*R.j + (-R.x*R.z)*R.k
"""
coord_sys = _get_coord_sys_from_expr(vect, coord_sys)
if coord_sys is None:
return Vector.zero
else:
from sympy.vector.functions import express
vectx = express(vect.dot(coord_sys._i), coord_sys, variables=True)
vecty = express(vect.dot(coord_sys._j), coord_sys, variables=True)
vectz = express(vect.dot(coord_sys._k), coord_sys, variables=True)
outvec = Vector.zero
outvec += (Derivative(vectz * coord_sys._h3, coord_sys._y) -
Derivative(vecty * coord_sys._h2, coord_sys._z)) * coord_sys._i / (coord_sys._h2 * coord_sys._h3)
outvec += (Derivative(vectx * coord_sys._h1, coord_sys._z) -
Derivative(vectz * coord_sys._h3, coord_sys._x)) * coord_sys._j / (coord_sys._h1 * coord_sys._h3)
outvec += (Derivative(vecty * coord_sys._h2, coord_sys._x) -
Derivative(vectx * coord_sys._h1, coord_sys._y)) * coord_sys._k / (coord_sys._h2 * coord_sys._h1)
if doit:
return outvec.doit()
return outvec
def test_coordinate_vars():
"""
Tests the coordinate variables functionality with respect to
reorientation of coordinate systems.
"""
A = CoordSysCartesian('A')
assert BaseScalar('Ax', 0, A, ' ', ' ') == A.x
assert BaseScalar('Ay', 1, A, ' ', ' ') == A.y
assert BaseScalar('Az', 2, A, ' ', ' ') == A.z
assert BaseScalar('Ax', 0, A, ' ', ' ').__hash__() == A.x.__hash__()
assert isinstance(A.x, BaseScalar) and \
isinstance(A.y, BaseScalar) and \
isinstance(A.z, BaseScalar)
assert A.scalar_map(A) == {A.x: A.x, A.y: A.y, A.z: A.z}
assert A.x.system == A
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
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] == 2*C.x*cos(q)/3 + C.x/3 - \
2*C.y*sin(q + pi/6)/3 + C.y/3 - 2*C.z*cos(q + pi/3)/3 + C.z/3
assert mapping[A.y] == -2*C.x*cos(q + pi/3)/3 + \
C.x/3 + 2*C.y*cos(q)/3 + C.y/3 - 2*C.z*sin(q + pi/6)/3 + C.z/3
assert mapping[A.z] == -2*C.x*sin(q + pi/6)/3 + C.x/3 - \
2*C.y*cos(q + pi/3)/3 + C.y/3 + 2*C.z*cos(q)/3 + C.z/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 __call__(self, scalar_field):
"""
Represents the gradient of the given scalar field.
Parameters
==========
scalar_field : SymPy expression
The scalar field to calculate the gradient of.
Examples
========
>>> from sympy.vector import CoordSysCartesian
>>> C = CoordSysCartesian('C')
>>> C.delop(C.x*C.y*C.z)
C.y*C.z*C.i + C.x*C.z*C.j + C.x*C.y*C.k
"""
scalar_field = express(scalar_field, self.system, variables=True)
vx = diff(scalar_field, self._x)
vy = diff(scalar_field, self._y)
vz = diff(scalar_field, self._z)
return vx * self._i + vy * self._j + vz * self._k
def __call__(self, scalar_field):
"""
Represents the gradient of the given scalar field.
Parameters
==========
scalar_field : SymPy expression
The scalar field to calculate the gradient of.
Examples
========
>>> from sympy.vector import CoordSysCartesian
>>> C = CoordSysCartesian('C')
>>> C.delop(C.x*C.y*C.z)
C.y*C.z*C.i + C.x*C.z*C.j + C.x*C.y*C.k
"""
scalar_field = express(scalar_field, self.system,
variables = True)
vx = diff(scalar_field, self._x)
vy = diff(scalar_field, self._y)
vz = diff(scalar_field, self._z)
return vx*self._i + vy*self._j + vz*self._k
def express_coordinates(self, coordinate_system):
"""
Returns the Cartesian/rectangular coordinates of this point
wrt the origin of the given CoordSysCartesian instance.
Parameters
==========
coordinate_system : CoordSysCartesian
The coordinate system to express the coordinates of this
Point in.
Examples
========
>>> from sympy.vector import Point, CoordSysCartesian
>>> N = CoordSysCartesian('N')
>>> p1 = N.origin.locate_new('p1', 10 * N.i)
>>> p2 = p1.locate_new('p2', 5 * N.j)
>>> p2.express_coordinates(N)
(10, 5, 0)
"""
#Determine the position vector
pos_vect = self.position_wrt(coordinate_system.origin)
#Express it in the given coordinate system
pos_vect = trigsimp(
express(pos_vect, coordinate_system, variables=True))
coords = []
for vect in coordinate_system.base_vectors():
coords.append(pos_vect.dot(vect))
return tuple(coords)
def express_coordinates(self, coordinate_system):
"""
Returns the Cartesian/rectangular coordinates of this point
wrt the origin of the given CoordSysCartesian instance.
Parameters
==========
coordinate_system : CoordSysCartesian
The coordinate system to express the coordinates of this
Point in.
Examples
========
>>> from sympy.vector import Point, CoordSysCartesian
>>> N = CoordSysCartesian('N')
>>> p1 = N.origin.locate_new('p1', 10 * N.i)
>>> p2 = p1.locate_new('p2', 5 * N.j)
>>> p2.express_coordinates(N)
(10, 5, 0)
"""
#Determine the position vector
pos_vect = self.position_wrt(coordinate_system.origin)
#Express it in the given coordinate system
pos_vect = trigsimp(express(pos_vect, coordinate_system,
variables = True))
coords = []
for vect in coordinate_system.base_vectors():
coords.append(pos_vect.dot(vect))
return tuple(coords)
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)
# 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 directional_derivative(field):
field = express(field, other.system, variables=True)
out = self.dot(other._i) * df(field, other._x)
out += self.dot(other._j) * df(field, other._y)
out += self.dot(other._k) * df(field, other._z)
if out == 0 and isinstance(field, Vector):
out = Vector.zero
return out
def directional_derivative(field):
field = express(field, other.system, variables = True)
out = self.dot(other._i) * df(field, other._x)
out += self.dot(other._j) * df(field, other._y)
out += self.dot(other._k) * df(field, other._z)
if out == 0 and isinstance(field, Vector):
out = Vector.zero
return out
def cross(self, vect, doit=False):
"""
Represents the cross product between this operator and a given
vector - equal to the curl of the vector field.
Parameters
==========
vect : Vector
The vector whose curl is to be calculated.
doit : bool
If True, the result is returned after calling .doit() on
each component. Else, the returned expression contains
Derivative instances
Examples
========
>>> from sympy.vector import CoordSysCartesian
>>> C = CoordSysCartesian('C')
>>> v = C.x*C.y*C.z * (C.i + C.j + C.k)
>>> C.delop.cross(v, doit = True)
(-C.x*C.y + C.x*C.z)*C.i + (C.x*C.y - C.y*C.z)*C.j +
(-C.x*C.z + C.y*C.z)*C.k
>>> (C.delop ^ C.i).doit()
0
"""
vectx = express(vect.dot(self._i), self.system, variables=True)
vecty = express(vect.dot(self._j), self.system, variables=True)
vectz = express(vect.dot(self._k), self.system, variables=True)
outvec = Vector.zero
outvec += (Derivative(vectz * self._h3, self._y) - Derivative(
vecty * self._h2, self._z)) * self._i / (self._h2 * self._h3)
outvec += (Derivative(vectx * self._h1, self._z) - Derivative(
vectz * self._h3, self._x)) * self._j / (self._h1 * self._h3)
outvec += (Derivative(vecty * self._h2, self._x) - Derivative(
vectx * self._h1, self._y)) * self._k / (self._h2 * self._h1)
if doit:
return outvec.doit()
return outvec
def cross(self, vect, doit=False):
"""
Represents the cross product between this operator and a given
vector - equal to the curl of the vector field.
Parameters
==========
vect : Vector
The vector whose curl is to be calculated.
doit : bool
If True, the result is returned after calling .doit() on
each component. Else, the returned expression contains
Derivative instances
Examples
========
>>> from sympy.vector import CoordSysCartesian
>>> C = CoordSysCartesian('C')
>>> v = C.x*C.y*C.z * (C.i + C.j + C.k)
>>> C.delop.cross(v, doit = True)
(-C.x*C.y + C.x*C.z)*C.i + (C.x*C.y - C.y*C.z)*C.j +
(-C.x*C.z + C.y*C.z)*C.k
>>> (C.delop ^ C.i).doit()
0
"""
vectx = express(vect.dot(self._i), self.system, variables=True)
vecty = express(vect.dot(self._j), self.system, variables=True)
vectz = express(vect.dot(self._k), self.system, variables=True)
outvec = Vector.zero
outvec += (Derivative(vectz, self._y) -
Derivative(vecty, self._z)) * self._i
outvec += (Derivative(vectx, self._z) -
Derivative(vectz, self._x)) * self._j
outvec += (Derivative(vecty, self._x) -
Derivative(vectx, self._y)) * self._k
if doit:
return outvec.doit()
return outvec
def _diff_conditional(expr, base_scalar, coeff_1, coeff_2):
"""
First re-expresses expr in the system that base_scalar belongs to.
If base_scalar appears in the re-expressed form, differentiates
it wrt base_scalar.
Else, returns S(0)
"""
from sympy.vector.functions import express
new_expr = express(expr, base_scalar.system, variables=True)
if base_scalar in new_expr.atoms(BaseScalar):
return Derivative(coeff_1 * coeff_2 * new_expr, base_scalar)
return S(0)
def _diff_conditional(expr, base_scalar):
"""
First re-expresses expr in the system that base_scalar belongs to.
If base_scalar appears in the re-expressed form, differentiates
it wrt base_scalar.
Else, returns S(0)
"""
new_expr = express(expr, base_scalar.system, variables=True)
if base_scalar in new_expr.atoms():
return Derivative(new_expr, base_scalar)
return S(0)
def _diff_conditional(expr, base_scalar, coeff_1, coeff_2):
"""
First re-expresses expr in the system that base_scalar belongs to.
If base_scalar appears in the re-expressed form, differentiates
it wrt base_scalar.
Else, returns S(0)
"""
from sympy.vector.functions import express
new_expr = express(expr, base_scalar.system, variables=True)
if base_scalar in new_expr.atoms(BaseScalar):
return Derivative(coeff_1 * coeff_2 * new_expr, base_scalar)
return S(0)
def _diff_conditional(expr, base_scalar):
"""
First re-expresses expr in the system that base_scalar belongs to.
If base_scalar appears in the re-expressed form, differentiates
it wrt base_scalar.
Else, returns S(0)
"""
new_expr = express(expr, base_scalar.system, variables = True)
if base_scalar in new_expr.atoms(BaseScalar):
return Derivative(new_expr, base_scalar)
return S(0)
def gradient(scalar_field, coord_sys=None, doit=True):
"""
Returns the vector gradient of a scalar field computed wrt the
base scalars of the given coordinate system.
Parameters
==========
scalar_field : SymPy Expr
The scalar field to compute the gradient of
coord_sys : CoordSys3D
The coordinate system to calculate the gradient in
Deprecated since version 1.1
doit : bool
If True, the result is returned after calling .doit() on
each component. Else, the returned expression contains
Derivative instances
Examples
========
>>> from sympy.vector import CoordSys3D, gradient
>>> R = CoordSys3D('R')
>>> s1 = R.x*R.y*R.z
>>> gradient(s1)
R.y*R.z*R.i + R.x*R.z*R.j + R.x*R.y*R.k
>>> s2 = 5*R.x**2*R.z
>>> gradient(s2)
10*R.x*R.z*R.i + 5*R.x**2*R.k
"""
coord_sys = _get_coord_sys_from_expr(scalar_field, coord_sys)
if coord_sys is None:
return Vector.zero
else:
from sympy.vector.functions import express
h1, h2, h3 = coord_sys.lame_coefficients()
i, j, k = coord_sys.base_vectors()
x, y, z = coord_sys.base_scalars()
scalar_field = express(scalar_field, coord_sys, variables=True)
vx = Derivative(scalar_field, x) / h1
vy = Derivative(scalar_field, y) / h2
vz = Derivative(scalar_field, z) / h3
if doit:
return (vx * i + vy * j + vz * k).doit()
return vx * i + vy * j + vz * k
def test_coordinate_vars():
"""
Tests the coordinate variables functionality with respect to
reorientation of coordinate systems.
"""
assert BaseScalar('Ax', 0, A) == A.x
assert BaseScalar('Ay', 1, A) == A.y
assert BaseScalar('Az', 2, A) == A.z
assert BaseScalar('Ax', 0, A).__hash__() == A.x.__hash__()
assert isinstance(A.x, BaseScalar) and \
isinstance(A.y, BaseScalar) and \
isinstance(A.z, BaseScalar)
assert A.scalar_map(A) == {A.x: A.x, A.y: A.y, A.z: A.z}
assert A.x.system == A
B = A.orient_new('B', 'Axis', [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
N = B.orient_new('N', 'Axis', [-q, B.k])
assert N.scalar_map(A) == \
{N.x: A.x, N.z: A.z, N.y: A.y}
C = A.orient_new('C', 'Axis', [q, A.i + A.j + A.k])
mapping = A.scalar_map(C)
assert mapping[A.x] == 2*C.x*cos(q)/3 + C.x/3 - \
2*C.y*sin(q + pi/6)/3 + C.y/3 - 2*C.z*cos(q + pi/3)/3 + C.z/3
assert mapping[A.y] == -2*C.x*cos(q + pi/3)/3 + \
C.x/3 + 2*C.y*cos(q)/3 + C.y/3 - 2*C.z*sin(q + pi/6)/3 + C.z/3
assert mapping[A.z] == -2*C.x*sin(q + pi/6)/3 + C.x/3 - \
2*C.y*cos(q + pi/3)/3 + C.y/3 + 2*C.z*cos(q)/3 + C.z/3
def directional_derivative(field):
from sympy.vector.operators import _get_coord_sys_from_expr
coord_sys = _get_coord_sys_from_expr(field)
if coord_sys is not None:
field = express(field, coord_sys, variables=True)
out = self.dot(coord_sys._i) * df(field, coord_sys._x)
out += self.dot(coord_sys._j) * df(field, coord_sys._y)
out += self.dot(coord_sys._k) * df(field, coord_sys._z)
if out == 0 and isinstance(field, Vector):
out = Vector.zero
return out
elif isinstance(field, Vector) :
return Vector.zero
else:
return S(0)
def directional_derivative(field):
from sympy.vector.operators import _get_coord_sys_from_expr
coord_sys = _get_coord_sys_from_expr(field)
if coord_sys is not None:
field = express(field, coord_sys, variables=True)
out = self.dot(coord_sys._i) * df(field, coord_sys._x)
out += self.dot(coord_sys._j) * df(field, coord_sys._y)
out += self.dot(coord_sys._k) * df(field, coord_sys._z)
if out == 0 and isinstance(field, Vector):
out = Vector.zero
return out
elif isinstance(field, Vector):
return Vector.zero
else:
return S(0)
def gradient(scalar_field, coord_sys=None, doit=True):
"""
Returns the vector gradient of a scalar field computed wrt the
base scalars of the given coordinate system.
Parameters
==========
scalar_field : SymPy Expr
The scalar field to compute the gradient of
coord_sys : CoordSys3D
The coordinate system to calculate the gradient in
Deprecated since version 1.1
doit : bool
If True, the result is returned after calling .doit() on
each component. Else, the returned expression contains
Derivative instances
Examples
========
>>> from sympy.vector import CoordSys3D, gradient
>>> R = CoordSys3D('R')
>>> s1 = R.x*R.y*R.z
>>> gradient(s1)
R.y*R.z*R.i + R.x*R.z*R.j + R.x*R.y*R.k
>>> s2 = 5*R.x**2*R.z
>>> gradient(s2)
10*R.x*R.z*R.i + 5*R.x**2*R.k
"""
coord_sys = _get_coord_sys_from_expr(scalar_field, coord_sys)
if coord_sys is None:
return Vector.zero
else:
from sympy.vector.functions import express
scalar_field = express(scalar_field, coord_sys,
variables=True)
vx = Derivative(scalar_field, coord_sys._x) / coord_sys._h1
vy = Derivative(scalar_field, coord_sys._y) / coord_sys._h2
vz = Derivative(scalar_field, coord_sys._z) / coord_sys._h3
if doit:
return (vx * coord_sys._i + vy * coord_sys._j + vz * coord_sys._k).doit()
return vx * coord_sys._i + vy * coord_sys._j + vz * coord_sys._k
def _orient_axis(amounts, rot_order, parent):
"""
Helper method for orientation using Axis method.
"""
if not rot_order == '':
raise TypeError('Axis orientation takes no' + 'rotation order')
if not (isinstance(amounts, (list, tuple)) and (len(amounts) == 2)):
raise TypeError('Amounts should be of length 2')
theta = amounts[0]
axis = amounts[1]
axis = express(axis, parent).normalize()
axis = axis.to_matrix(parent)
parent_orient = ((eye(3) - axis * axis.T) * cos(theta) +
Matrix([[0, -axis[2], axis[1]], [axis[2], 0, -axis[0]],
[-axis[1], axis[0], 0]]) * sin(theta) +
axis * axis.T)
return parent_orient
def _orient_axis(amounts, rot_order, parent):
"""
Helper method for orientation using Axis method.
"""
if not rot_order == "":
raise TypeError("Axis orientation takes no" + "rotation order")
if not (isinstance(amounts, (list, tuple)) and (len(amounts) == 2)):
raise TypeError("Amounts should be of length 2")
theta = amounts[0]
axis = amounts[1]
axis = express(axis, parent).normalize()
axis = axis.to_matrix(parent)
parent_orient = (
(eye(3) - axis * axis.T) * cos(theta)
+ Matrix([[0, -axis[2], axis[1]], [axis[2], 0, -axis[0]], [-axis[1], axis[0], 0]]) * sin(theta)
+ axis * axis.T
)
return parent_orient
def gradient(self, scalar_field, doit=False):
"""
Returns the gradient of the given scalar field, as a
Vector instance.
Parameters
==========
scalar_field : SymPy expression
The scalar field to calculate the gradient of.
doit : bool
If True, the result is returned after calling .doit() on
each component. Else, the returned expression contains
Derivative instances
Examples
========
>>> from sympy.vector import CoordSysCartesian
>>> C = CoordSysCartesian('C')
>>> C.delop.gradient(9)
(Derivative(9, C.x))*C.i + (Derivative(9, C.y))*C.j +
(Derivative(9, C.z))*C.k
>>> C.delop(C.x*C.y*C.z).doit()
C.y*C.z*C.i + C.x*C.z*C.j + C.x*C.y*C.k
"""
scalar_field = express(scalar_field, self.system,
variables=True)
vx = Derivative(scalar_field, self._x)
vy = Derivative(scalar_field, self._y)
vz = Derivative(scalar_field, self._z)
if doit:
return (vx * self._i + vy * self._j + vz * self._k).doit()
return vx * self._i + vy * self._j + vz * self._k
def test_coordinate_vars():
"""
Tests the coordinate variables functionality with respect to
reorientation of coordinate systems.
"""
A = CoordSysCartesian("A")
assert BaseScalar("Ax", 0, A, " ", " ") == A.x
assert BaseScalar("Ay", 1, A, " ", " ") == A.y
assert BaseScalar("Az", 2, A, " ", " ") == A.z
assert BaseScalar("Ax", 0, A, " ", " ").__hash__() == A.x.__hash__()
assert isinstance(A.x, BaseScalar) and isinstance(A.y, BaseScalar) and isinstance(A.z, BaseScalar)
assert A.scalar_map(A) == {A.x: A.x, A.y: A.y, A.z: A.z}
assert A.x.system == A
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
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]
== 2 * C.x * cos(q) / 3
+ C.x / 3
- 2 * C.y * sin(q + pi / 6) / 3
+ C.y / 3
- 2 * C.z * cos(q + pi / 3) / 3
+ C.z / 3
)
assert (
mapping[A.y]
== -2 * C.x * cos(q + pi / 3) / 3
+ C.x / 3
+ 2 * C.y * cos(q) / 3
+ C.y / 3
- 2 * C.z * sin(q + pi / 6) / 3
+ C.z / 3
)
assert (
mapping[A.z]
== -2 * C.x * sin(q + pi / 6) / 3
+ C.x / 3
- 2 * C.y * cos(q + pi / 3) / 3
+ C.y / 3
+ 2 * C.z * cos(q) / 3
+ C.z / 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_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_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_express():
assert express(Vector.zero, N) == Vector.zero
assert express(S(0), N) == S(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
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_coordinate_vars():
"""
Tests the coordinate variables functionality with respect to
reorientation of coordinate systems.
"""
A = CoordSysCartesian('A')
assert BaseScalar('Ax', 0, A, ' ', ' ') == A.x
assert BaseScalar('Ay', 1, A, ' ', ' ') == A.y
assert BaseScalar('Az', 2, A, ' ', ' ') == A.z
assert BaseScalar('Ax', 0, A, ' ', ' ').__hash__() == A.x.__hash__()
assert isinstance(A.x, BaseScalar) and \
isinstance(A.y, BaseScalar) and \
isinstance(A.z, BaseScalar)
assert A.scalar_map(A) == {A.x: A.x, A.y: A.y, A.z: A.z}
assert A.x.system == A
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
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] == 2*C.x*cos(q)/3 + C.x/3 - \
2*C.y*sin(q + pi/6)/3 + C.y/3 - 2*C.z*cos(q + pi/3)/3 + C.z/3
assert mapping[A.y] == -2*C.x*cos(q + pi/3)/3 + \
C.x/3 + 2*C.y*cos(q)/3 + C.y/3 - 2*C.z*sin(q + pi/6)/3 + C.z/3
assert mapping[A.z] == -2*C.x*sin(q + pi/6)/3 + C.x/3 - \
2*C.y*cos(q + pi/3)/3 + C.y/3 + 2*C.z*cos(q)/3 + C.z/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 dot(self, other):
"""
Returns the dot product of this Vector, either with another
Vector, or a Dyadic, or a Del operator.
If 'other' is a Vector, returns the dot product scalar (Sympy
expression).
If 'other' is a Dyadic, the dot product is returned as a Vector.
If 'other' is an instance of Del, returns the directional
derivate operator as a Python function. If this function is
applied to a scalar expression, it returns the directional
derivative of the scalar field wrt this Vector.
Parameters
==========
other: Vector/Dyadic/Del
The Vector or Dyadic we are dotting with, or a Del operator .
Examples
========
>>> from sympy.vector import CoordSysCartesian
>>> C = CoordSysCartesian('C')
>>> C.i.dot(C.j)
0
>>> C.i & C.i
1
>>> v = 3*C.i + 4*C.j + 5*C.k
>>> v.dot(C.k)
5
>>> (C.i & C.delop)(C.x*C.y*C.z)
C.y*C.z
>>> d = C.i.outer(C.i)
>>> C.i.dot(d)
C.i
"""
from sympy.vector.functions import express
#Check special cases
if isinstance(other, Dyadic):
if isinstance(self, VectorZero):
return Vector.zero
outvec = Vector.zero
for k, v in other.components.items():
vect_dot = k.args[0].dot(self)
outvec += vect_dot * v * k.args[1]
return outvec
from sympy.vector.deloperator import Del
if not isinstance(other, Vector) and not isinstance(other, Del):
raise TypeError(str(other) + " is not a vector, dyadic or " +
"del operator")
#Check if the other is a del operator
if isinstance(other, Del):
def directional_derivative(field):
field = express(field, other.system, variables = True)
out = self.dot(other._i) * df(field, other._x)
out += self.dot(other._j) * df(field, other._y)
out += self.dot(other._k) * df(field, other._z)
if out == 0 and isinstance(field, Vector):
out = Vector.zero
return out
return directional_derivative
if isinstance(self, VectorZero) or isinstance(other, VectorZero):
return S(0)
v1 = express(self, other._sys)
v2 = express(other, other._sys)
dotproduct = S(0)
for x in other._sys.base_vectors():
dotproduct += (v1.components.get(x, 0) *
v2.components.get(x, 0))
return dotproduct
def dot(self, other):
"""
Returns the dot product of this Vector, either with another
Vector, or a Dyadic, or a Del operator.
If 'other' is a Vector, returns the dot product scalar (Sympy
expression).
If 'other' is a Dyadic, the dot product is returned as a Vector.
If 'other' is an instance of Del, returns the directional
derivate operator as a Python function. If this function is
applied to a scalar expression, it returns the directional
derivative of the scalar field wrt this Vector.
Parameters
==========
other: Vector/Dyadic/Del
The Vector or Dyadic we are dotting with, or a Del operator .
Examples
========
>>> from sympy.vector import CoordSysCartesian
>>> C = CoordSysCartesian('C')
>>> C.i.dot(C.j)
0
>>> C.i & C.i
1
>>> v = 3*C.i + 4*C.j + 5*C.k
>>> v.dot(C.k)
5
>>> (C.i & C.delop)(C.x*C.y*C.z)
C.y*C.z
>>> d = C.i.outer(C.i)
>>> C.i.dot(d)
C.i
"""
from sympy.vector.functions import express
#Check special cases
if isinstance(other, Dyadic):
if isinstance(self, VectorZero):
return Vector.zero
outvec = Vector.zero
for k, v in other.components.items():
vect_dot = k.args[0].dot(self)
outvec += vect_dot * v * k.args[1]
return outvec
from sympy.vector.deloperator import Del
if not isinstance(other, Vector) and not isinstance(other, Del):
raise TypeError(
str(other) + " is not a vector, dyadic or " + "del operator")
#Check if the other is a del operator
if isinstance(other, Del):
def directional_derivative(field):
field = express(field, other.system, variables=True)
out = self.dot(other._i) * df(field, other._x)
out += self.dot(other._j) * df(field, other._y)
out += self.dot(other._k) * df(field, other._z)
if out == 0 and isinstance(field, Vector):
out = Vector.zero
return out
return directional_derivative
if isinstance(self, VectorZero) or isinstance(other, VectorZero):
return S(0)
v1 = express(self, other._sys)
v2 = express(other, other._sys)
dotproduct = S(0)
for x in other._sys.base_vectors():
dotproduct += (v1.components.get(x, 0) * v2.components.get(x, 0))
return dotproduct
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('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 BaseScalar('A.x', 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_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_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_vector():
"""
Tests the effects of orientation of coordinate systems on
basic vector operations.
"""
N = CoordSysCartesian('N')
A = N.orient_new('A', 'Axis', [q1, N.k])
B = A.orient_new('B', 'Axis', [q2, A.i])
C = B.orient_new('C', 'Axis', [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 curl(vect, coord_sys=None, doit=True):
"""
Returns the curl of a vector field computed wrt the base scalars
of the given coordinate system.
Parameters
==========
vect : Vector
The vector operand
coord_sys : CoordSys3D
The coordinate system to calculate the gradient in.
Deprecated since version 1.1
doit : bool
If True, the result is returned after calling .doit() on
each component. Else, the returned expression contains
Derivative instances
Examples
========
>>> from sympy.vector import CoordSys3D, curl
>>> R = CoordSys3D('R')
>>> v1 = R.y*R.z*R.i + R.x*R.z*R.j + R.x*R.y*R.k
>>> curl(v1)
0
>>> v2 = R.x*R.y*R.z*R.i
>>> curl(v2)
R.x*R.y*R.j + (-R.x*R.z)*R.k
"""
coord_sys = _get_coord_sys_from_expr(vect, coord_sys)
if len(coord_sys) == 0:
return Vector.zero
elif len(coord_sys) == 1:
coord_sys = coord_sys.pop()
i, j, k = coord_sys.base_vectors()
x, y, z = coord_sys.base_scalars()
h1, h2, h3 = coord_sys.lame_coefficients()
vectx = vect.dot(i)
vecty = vect.dot(j)
vectz = vect.dot(k)
outvec = Vector.zero
outvec += (Derivative(vectz * h3, y) -
Derivative(vecty * h2, z)) * i / (h2 * h3)
outvec += (Derivative(vectx * h1, z) -
Derivative(vectz * h3, x)) * j / (h1 * h3)
outvec += (Derivative(vecty * h2, x) -
Derivative(vectx * h1, y)) * k / (h2 * h1)
if doit:
return outvec.doit()
return outvec
else:
# TODO: use some of the vector calculus properties for this:
coord_sys = coord_sys.pop() # get one random coord_sys
i, j, k = coord_sys.base_vectors()
x, y, z = coord_sys.base_scalars()
h1, h2, h3 = coord_sys.lame_coefficients()
from .functions import express
vectx = express(vect.dot(i), coord_sys, variables=True)
vecty = express(vect.dot(j), coord_sys, variables=True)
vectz = express(vect.dot(k), coord_sys, variables=True)
# This is a repetition of previous code, it will be removed as soon as
# we have some better algorithm to deal with this case:
outvec = Vector.zero
outvec += (Derivative(vectz * h3, y) -
Derivative(vecty * h2, z)) * i / (h2 * h3)
outvec += (Derivative(vectx * h1, z) -
Derivative(vectz * h3, x)) * j / (h1 * h3)
outvec += (Derivative(vecty * h2, x) -
Derivative(vectx * h1, y)) * k / (h2 * h1)
if doit:
return outvec.doit()
return outvec