[WIP] Reconstruction constructor in CoordSys3D

sympy/core/tests/test_args.py

@@ -3870,7 +3870,7 @@ def test_sympy__vector__vector__BaseVector():
     from sympy.vector.vector import BaseVector
     from sympy.vector.coordsysrect import CoordSys3D
     C = CoordSys3D('C')
-    assert _test_args(BaseVector('Ci', 0, C, ' ', ' '))
+    assert _test_args(BaseVector(0, C, ' ', ' '))
 
 
 def test_sympy__vector__vector__VectorAdd():
@@ -4013,7 +4013,7 @@ def test_sympy__vector__scalar__BaseScalar():
     from sympy.vector.scalar import BaseScalar
     from sympy.vector.coordsysrect import CoordSys3D
     C = CoordSys3D('C')
-    assert _test_args(BaseScalar('Cx', 0, C, ' ', ' '))
+    assert _test_args(BaseScalar(0, C, ' ', ' '))
 
 
 def test_sympy__physics__wigner__Wigner3j():

sympy/vector/functions.py

@@ -48,7 +48,7 @@ def express(expr, system, system2=None, variables=False):
     >>> express(B.i, N)
     (cos(q))*N.i + (sin(q))*N.j
     >>> express(N.x, B, variables=True)
-    -sin(q)*B.y + cos(q)*B.x
+    B.x*cos(q) - B.y*sin(q)
     >>> d = N.i.outer(N.i)
     >>> express(d, B, N) == (cos(q))*(B.i|N.i) + (-sin(q))*(B.j|N.i)
     True
@@ -157,9 +157,9 @@ def directional_derivative(field, direction_vector):
     coord_sys = _get_coord_sys_from_expr(field)
     if coord_sys is not None:
         field = express(field, coord_sys, variables=True)
-        out = Vector.dot(direction_vector, coord_sys._i) * diff(field, coord_sys._x)
-        out += Vector.dot(direction_vector, coord_sys._j) * diff(field, coord_sys._y)
-        out += Vector.dot(direction_vector, coord_sys._k) * diff(field, coord_sys._z)
+        out = Vector.dot(direction_vector, coord_sys.i) * diff(field, coord_sys.x)
+        out += Vector.dot(direction_vector, coord_sys.j) * diff(field, coord_sys.y)
+        out += Vector.dot(direction_vector, coord_sys.k) * diff(field, coord_sys.z)
         if out == 0 and isinstance(field, Vector):
             out = Vector.zero
         return out

sympy/vector/operators.py

@@ -140,20 +140,24 @@ def curl(vect, coord_sys=None, doit=True):
     """
 
     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(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)
+        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 * 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)
+        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()
@@ -194,17 +198,20 @@ def divergence(vect, coord_sys=None, doit=True):
     2*R.z
 
     """
-
     coord_sys = _get_coord_sys_from_expr(vect, coord_sys)
+
     if coord_sys is None:
         return S.Zero
     else:
-        vx = _diff_conditional(vect.dot(coord_sys._i), coord_sys._x, coord_sys._h2, coord_sys._h3) \
-             / (coord_sys._h1 * coord_sys._h2 * coord_sys._h3)
-        vy = _diff_conditional(vect.dot(coord_sys._j), coord_sys._y, coord_sys._h3, coord_sys._h1) \
-             / (coord_sys._h1 * coord_sys._h2 * coord_sys._h3)
-        vz = _diff_conditional(vect.dot(coord_sys._k), coord_sys._z, coord_sys._h1, coord_sys._h2) \
-             / (coord_sys._h1 * coord_sys._h2 * coord_sys._h3)
+        i, j, k = coord_sys.base_vectors()
+        x, y, z = coord_sys.base_scalars()
+        h1, h2, h3 = coord_sys.lame_coefficients()
+        vx = _diff_conditional(vect.dot(i), x, h2, h3) \
+             / (h1 * h2 * h3)
+        vy = _diff_conditional(vect.dot(j), y, h3, h1) \
+             / (h1 * h2 * h3)
+        vz = _diff_conditional(vect.dot(k), z, h1, h2) \
+             / (h1 * h2 * h3)
         if doit:
             return (vx + vy + vz).doit()
         return vx + vy + vz
@@ -249,15 +256,17 @@ def gradient(scalar_field, coord_sys=None, doit=True):
         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
+        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 * 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
+            return (vx * i + vy * j + vz * k).doit()
+        return vx * i + vy * j + vz * k
 
 
 def _diff_conditional(expr, base_scalar, coeff_1, coeff_2):

sympy/vector/scalar.py

@@ -1,11 +1,11 @@
-from sympy.core import Expr, Symbol, S
+from sympy.core import AtomicExpr, Symbol, S
 from sympy.core.sympify import _sympify
 from sympy.core.compatibility import range
 from sympy.printing.pretty.stringpict import prettyForm
 from sympy.printing.precedence import PRECEDENCE
 
 
-class BaseScalar(Expr):
+class BaseScalar(AtomicExpr):
     """
     A coordinate symbol/base scalar.
 
@@ -15,27 +15,27 @@ class BaseScalar(Expr):
 
     """
 
-    def __new__(cls, name, index, system, pretty_str, latex_str):
+    def __new__(cls, index, system, pretty_str=None, latex_str=None):
         from sympy.vector.coordsysrect import CoordSys3D
-        if isinstance(name, Symbol):
-            name = name.name
-        if isinstance(pretty_str, Symbol):
+        if pretty_str is None:
+            pretty_str = "x{0}".format(index)
+        elif isinstance(pretty_str, Symbol):
             pretty_str = pretty_str.name
-        if isinstance(latex_str, Symbol):
+        if latex_str is None:
+            latex_str = "x_{0}".format(index)
+        elif isinstance(latex_str, Symbol):
             latex_str = latex_str.name
 
         index = _sympify(index)
         system = _sympify(system)
-        obj = super(BaseScalar, cls).__new__(cls, Symbol(name), index, system,
-                                             Symbol(pretty_str),
-                                             Symbol(latex_str))
+        obj = super(BaseScalar, cls).__new__(cls, index, system)
         if not isinstance(system, CoordSys3D):
             raise TypeError("system should be a CoordSys3D")
         if index not in range(0, 3):
             raise ValueError("Invalid index specified.")
         # The _id is used for equating purposes, and for hashing
         obj._id = (index, system)
-        obj._name = obj.name = name
+        obj._name = obj.name = system._name + '.' + system._variable_names[index]
         obj._pretty_form = u'' + pretty_str
         obj._latex_form = latex_str
         obj._system = system

sympy/vector/tests/test_coordsysrect.py

@@ -75,10 +75,10 @@ def test_coordinate_vars():
     """
     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 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)
@@ -299,84 +299,74 @@ def test_evalf():
     assert v.evalf(subs={a:1}) == v.subs(a, 1).evalf()
 
 
-def test_lame_coefficients():
-    a = CoordSys3D('a')
-    a._set_lame_coefficient_mapping('spherical')
-    assert a.lame_coefficients() == (1, a.x, sin(a.y)*a.x)
-    a = CoordSys3D('a')
-    assert a.lame_coefficients() == (1, 1, 1)
-    a = CoordSys3D('a')
-    a._set_lame_coefficient_mapping('cartesian')
-    assert a.lame_coefficients() == (1, 1, 1)
-    a = CoordSys3D('a')
-    a._set_lame_coefficient_mapping('cylindrical')
-    assert a.lame_coefficients() == (1, a.y, 1)
-
-
 def test_transformation_equations():
-    from sympy import symbols
+
     x, y, z = symbols('x y z')
-    a = CoordSys3D('a')
+    #r, theta, phi = symbols("r theta phi")
     # Str
-    a._connect_to_standard_cartesian('spherical')
-    assert a._transformation_equations() == (a.x * sin(a.y) * cos(a.z),
-                          a.x * sin(a.y) * sin(a.z),
-                          a.x * cos(a.y))
-    assert a.lame_coefficients() == (1, a.x, a.x * sin(a.y))
-    assert a._inverse_transformation_equations() == (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))
-    a._connect_to_standard_cartesian('cylindrical')
-    assert a._transformation_equations() == (a.x * cos(a.y), a.x * sin(a.y), a.z)
-    assert a.lame_coefficients() == (1, a.y, 1)
-    assert a._inverse_transformation_equations() == (sqrt(a.x**2 + a.y**2),
-                            atan2(a.y, a.x), a.z)
-    a._connect_to_standard_cartesian('cartesian')
-    assert a._transformation_equations() == (a.x, a.y, a.z)
+    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.theta, 1)
+    assert a.transformation_from_parent_function()(x, y, z) == (sqrt(x**2 + y**2),
+                            atan2(y, x), z)
+    a = CoordSys3D('a', transformation='cartesian')
+    assert a.transformation_to_parent() == (a.x, a.y, a.z)
     assert a.lame_coefficients() == (1, 1, 1)
-    assert a._inverse_transformation_equations() == (a.x, a.y, a.z)
+    assert a.transformation_from_parent_function()(x, y, z) == (x, y, z)
     # Variables and expressions
-    a._connect_to_standard_cartesian(((x, y, z), (x, y, z)))
-    assert a._transformation_equations() == (a.x, a.y, a.z)
+    x, y, z = symbols('x y z')
+    a = CoordSys3D('a', transformation=((x, y, z), (x, y, z)))
+    a._calculate_inv_trans_equations()
+    assert a.transformation_to_parent() == (a.x, a.y, a.z)
     assert a.lame_coefficients() == (1, 1, 1)
-    assert a._inverse_transformation_equations() == (a.x, a.y, a.z)
-    a._connect_to_standard_cartesian(((x, y, z), ((x * cos(y), x * sin(y), z))), inverse=False)
-    assert a._transformation_equations() == (a.x * cos(a.y), a.x * sin(a.y), a.z)
+    assert a.transformation_from_parent_function()(x, y, z) == (x, y, z)
+    a = CoordSys3D('a', transformation=(((x*cos(y), x*sin(y), z)), (x, y, z)))
+    assert a.transformation_to_parent() == (a.x * cos(a.y), a.x * sin(a.y), a.z)
     assert simplify(a.lame_coefficients()) == (1, sqrt(a.x**2), 1)
-    a._connect_to_standard_cartesian(((x, y, z), (x * sin(y) * cos(z), x * sin(y) * sin(z), x * cos(y))), inverse=False)
-    assert a._transformation_equations() == (a.x * sin(a.y) * cos(a.z),
-                          a.x * sin(a.y) * sin(a.z),
-                          a.x * cos(a.y))
-    assert simplify(a.lame_coefficients()) == (1, sqrt(a.x**2), sqrt(sin(a.y)**2*a.x**2))
-    # Equations
-    a._connect_to_standard_cartesian((a.x*sin(a.y)*cos(a.z), a.x*sin(a.y)*sin(a.z), a.x*cos(a.y)), inverse=False)
-    assert a._transformation_equations() == (a.x * sin(a.y) * cos(a.z),
-                          a.x * sin(a.y) * sin(a.z),
-                          a.x * cos(a.y))
-    assert simplify(a.lame_coefficients()) == (1, sqrt(a.x**2), sqrt(sin(a.y)**2*a.x**2))
-    a._connect_to_standard_cartesian((a.x, a.y, a.z))
-    assert a._transformation_equations() == (a.x, a.y, a.z)
-    assert simplify(a.lame_coefficients()) == (1, 1, 1)
-    assert a._inverse_transformation_equations() == (a.x, a.y, a.z)
-    a._connect_to_standard_cartesian((a.x * cos(a.y), a.x * sin(a.y), a.z), inverse=False)
-    assert a._transformation_equations() == (a.x * cos(a.y), a.x * sin(a.y), a.z)
-    assert simplify(a.lame_coefficients()) == (1, sqrt(a.x**2), 1)
-
-    raises(ValueError, lambda: a._connect_to_standard_cartesian((x, y, z)))
 
 
 def test_check_orthogonality():
-    a = CoordSys3D('a')
-    a._connect_to_standard_cartesian((a.x*sin(a.y)*cos(a.z), a.x*sin(a.y)*sin(a.z), a.x*cos(a.y)), inverse=False)
-    assert a._check_orthogonality() is True
-    a._connect_to_standard_cartesian((a.x * cos(a.y), a.x * sin(a.y), a.z))
-    assert a._check_orthogonality() is True
-    a._connect_to_standard_cartesian((cosh(a.x)*cos(a.y), sinh(a.x)*sin(a.y), a.z), inverse=False)
-    assert a._check_orthogonality() is True
+    x, y, z = symbols('x y z')
+    u,v = symbols('u, v')
+    a = CoordSys3D('a', transformation=((x*sin(y)*cos(z), x*sin(y)*sin(z), x*cos(y)), (x, y, z)))
+    assert a._check_orthogonality(a._transformation) is True
+    a = CoordSys3D('a', transformation=((x * cos(y), x * sin(y), z), (x, y, z)))
+    assert a._check_orthogonality(a._transformation) is True
+    a = CoordSys3D('a', transformation=((cosh(u) * cos(v), sinh(u) * sin(v), z), (u, v, z)))
+    assert a._check_orthogonality(a._transformation) is True
 
-    raises(ValueError, lambda: a._connect_to_standard_cartesian((a.x, a.x, a.z)))
-    raises(ValueError, lambda: a._connect_to_standard_cartesian(
-        (a.x*sin(a.y / 2)*cos(a.z), a.x*sin(a.y)*sin(a.z), a.x*cos(a.y)), inverse=False))
+    raises(ValueError, lambda: CoordSys3D('a', transformation=((x, x, z), (x, y, z))))
+    raises(ValueError, lambda: CoordSys3D('a', transformation=(
+        (x*sin(y/2)*cos(z), x*sin(y)*sin(z), x*cos(y)), (x, y, z))))
 
 
 def test_coordsys3d():
@@ -389,27 +379,30 @@ def test_rotation_trans_equations():
     a = CoordSys3D('a')
     from sympy import symbols
     q0 = symbols('q0')
-    assert a._rotation_trans_equations(a._parent_rotation_matrix) == (a.x, a.y, a.z)
-    assert a._rotation_trans_equations(a._inverse_rotation_matrix()) == (a.x, a.y, a.z)
+    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.x, b.y, b.z)
-    assert b._rotation_trans_equations(b._inverse_rotation_matrix()) == (b.x, b.y, b.z)
+    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) == \
+    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()) == \
+    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)
 
+
 def test_translation_trans_equations():
     from sympy import symbols
-    q0 = symbols('q0')
     a = CoordSys3D('a')
-    assert a._translation_trans_equations() == (a.x, a.y, a.z)
+    assert a._translation_trans_equations(a, a._origin, a.base_scalars()) == (a.x, a.y, a.z)
     b = a.locate_new('b', None)
-    assert b._translation_trans_equations() == (b.x, b.y, b.z)
-    assert b._translation_trans_equations(inverse=True) == (b.x, b.y, b.z)
+    assert b._translation_trans_equations(a, b._origin, b.base_scalars()) == (b.x, b.y, b.z)
+    assert b._translation_trans_equations(a, b._origin, b.base_scalars(), inverse=True) == (b.x, b.y, b.z)
     c = a.locate_new('c', (a.i + a.j + a.k))
-    assert c._translation_trans_equations() == (c.x + 1, c.y + 1, c.z + 1)
+    assert c._translation_trans_equations(a, c._origin, c.base_scalars()) ==\
+           (c.x + 1, c.y + 1, c.z + 1)
     d = a.locate_new('d', (a.i + a.j + Vector.zero))
-    assert d._translation_trans_equations() == (d.x + 1, d.y + 1, d.z)
-    assert d._translation_trans_equations(inverse=True) == (d.x - 1, d.y - 1, d.z)
+    assert d._translation_trans_equations(a, d._origin, d.base_scalars()) ==\
+           (d.x + 1, d.y + 1, d.z)
+    assert d._translation_trans_equations(a, d._origin, d.base_scalars(), inverse=True) ==\
+           (d.x - 1, d.y - 1, d.z)