Make physics.mechanics.wrapping_geometry public

doc/src/modules/physics/mechanics/api/index.rst

@@ -12,3 +12,4 @@ Mechanics API Reference
    linearize.rst
    expr_manip.rst
    printing.rst
+   wrapping_geometry.rst

doc/src/modules/physics/mechanics/api/wrapping_geometry.rst

@@ -0,0 +1,6 @@
+==============================
+Wrapping Geometry (Docstrings)
+==============================
+
+.. automodule:: sympy.physics.mechanics.wrapping_geometry
+   :members:

sympy/physics/mechanics/_pathway.py

@@ -16,7 +16,7 @@
 
 from sympy.core.backend import S
 from sympy.physics.mechanics import Force, Point
-from sympy.physics.mechanics._geometry import GeometryBase
+from sympy.physics.mechanics.wrapping_geometry import GeometryBase
 from sympy.physics.vector import dynamicsymbols
 
 if TYPE_CHECKING:
@@ -300,13 +300,13 @@ class WrappingPathway(PathwayBase):
     >>> from sympy.physics.mechanics._pathway import WrappingPathway
 
     To construct a wrapping pathway, a geometry object, which the pathway can
-    wrap, is required. Similar to above, the ``_geometry.py`` module is also
-    experimental so geometry classes needed to be imported directly from the
-    ``sympy.physics.mechanics._geometry.py`` module. Let's create a wrapping
-    pathway that wraps around a cylinder. To do this we need to import the
-    ``Cylinder`` class.
+    wrap, is required. Similar to above, the ``wrapping_geometry.py`` module is
+    also experimental so geometry classes needed to be imported directly from
+    the ``sympy.physics.mechanics.wrapping_geometry.py`` module. Let's create a
+    wrapping pathway that wraps around a cylinder. To do this we need to import
+    the ``Cylinder`` class.
 
-    >>> from sympy.physics.mechanics._geometry import Cylinder
+    >>> from sympy.physics.mechanics.wrapping_geometry import Cylinder
 
     To construct a wrapping pathway, like other pathways, a pair of points must
     be passed, followed by an instance of a geometry class as a keyword
@@ -419,7 +419,7 @@ def compute_loads(self, force: ExprType) -> list[LoadBase]:
 
         >>> from sympy import Symbol
         >>> from sympy.physics.mechanics import Point, ReferenceFrame
-        >>> from sympy.physics.mechanics._geometry import Cylinder
+        >>> from sympy.physics.mechanics.wrapping_geometry import Cylinder
         >>> N = ReferenceFrame('N')
         >>> r = Symbol('r', positive=True)
         >>> pO = Point('pO')

sympy/physics/mechanics/tests/test_pathway.py

@@ -21,7 +21,8 @@
     ReferenceFrame,
     dynamicsymbols,
 )
-from sympy.physics.mechanics._geometry import Cylinder, GeometryBase, Sphere
+from sympy.physics.mechanics.wrapping_geometry import (Cylinder, GeometryBase,
+                                                       Sphere)
 from sympy.physics.mechanics._pathway import (
     LinearPathway,
     PathwayBase,

sympy/physics/mechanics/tests/test_geometry.py → sympy/physics/mechanics/tests/test_wrapping_geometry.py

@@ -1,4 +1,4 @@
-"""Tests for the ``sympy.physics.mechanics._geometry.py`` module."""
+"""Tests for the ``sympy.physics.mechanics.wrapping_geometry.py`` module."""
 
 from __future__ import annotations
 
@@ -20,7 +20,7 @@
 )
 from sympy.core.relational import Eq
 from sympy.physics.mechanics import Point, ReferenceFrame, dynamicsymbols
-from sympy.physics.mechanics._geometry import Cylinder, Sphere
+from sympy.physics.mechanics.wrapping_geometry import Cylinder, Sphere
 from sympy.simplify.simplify import simplify
 
 if TYPE_CHECKING:
@@ -52,7 +52,7 @@ def test_valid_constructor() -> None:
         assert sphere.point == pO
 
     @staticmethod
-    @pytest.mark.parametrize('position', [S.Zero, Integer(2) * r * N.x])
+    @pytest.mark.parametrize('position', [S.Zero, Integer(2)*r*N.x])
     def test_geodesic_length_point_not_on_surface_invalid(position: Vector) -> None:
         r = Symbol('r', positive=True)
         pO = Point('pO')
@@ -71,19 +71,20 @@ def test_geodesic_length_point_not_on_surface_invalid(position: Vector) -> None:
     @pytest.mark.parametrize(
         'position_1, position_2, expected',
         [
-            (r * N.x, r * N.x, S.Zero),
-            (r * N.x, r * N.y, S.Half * pi * r),
-            (r * N.x, r * -N.x, pi * r),
-            (r * -N.x, r * N.x, pi * r),
-            (r * N.x, r * sqrt(2) * S.Half * (N.x + N.y), Rational(1, 4) * pi * r),
+            (r*N.x, r*N.x, S.Zero),
+            (r*N.x, r*N.y, S.Half*pi*r),
+            (r*N.x, r*-N.x, pi*r),
+            (r*-N.x, r*N.x, pi*r),
+            (r*N.x, r*sqrt(2)*S.Half*(N.x + N.y), Rational(1, 4)*pi*r),
             (
-                r * sqrt(2) * S.Half * (N.x + N.y),
-                r * sqrt(3) * Rational(1, 3) * (N.x + N.y + N.z),
-                r * acos(sqrt(6) * Rational(1, 3)),
+                r*sqrt(2)*S.Half*(N.x + N.y),
+                r*sqrt(3)*Rational(1, 3)*(N.x + N.y + N.z),
+                r*acos(sqrt(6)*Rational(1, 3)),
             ),
         ]
     )
-    def test_geodesic_length(position_1: Vector, position_2: Vector, expected: ExprType) -> None:
+    def test_geodesic_length(position_1: Vector, position_2: Vector,
+                             expected: ExprType) -> None:
         r = Symbol('r', positive=True)
         pO = Point('pO')
         sphere = Sphere(r, pO)
@@ -209,14 +210,14 @@ def test_valid_constructor() -> None:
         'position, expected',
         [
             (S.Zero, False),
-            (r * N.y, True),
-            (r * N.z, True),
-            (r * (N.y + N.z).normalize(), True),
-            (Integer(2) * r * N.y, False),
-            (r * (N.x + N.y), True),
-            (r * (Integer(2) * N.x + N.y), True),
-            (Integer(2) * N.x + r * (Integer(2) * N.y + N.z).normalize(), True),
-            (r * (cos(q) * N.y + sin(q) * N.z), True)
+            (r*N.y, True),
+            (r*N.z, True),
+            (r*(N.y + N.z).normalize(), True),
+            (Integer(2)*r*N.y, False),
+            (r*(N.x + N.y), True),
+            (r*(Integer(2)*N.x + N.y), True),
+            (Integer(2)*N.x + r*(Integer(2)*N.y + N.z).normalize(), True),
+            (r*(cos(q)*N.y + sin(q)*N.z), True)
         ]
     )
     def test_point_is_on_surface(position: Vector, expected: bool) -> None:
@@ -227,10 +228,10 @@ def test_point_is_on_surface(position: Vector, expected: bool) -> None:
         p1 = Point('p1')
         p1.set_pos(pO, position)
 
-        assert cylinder._point_is_on_surface(p1) is expected
+        assert cylinder.point_on_surface(p1) is expected
 
     @staticmethod
-    @pytest.mark.parametrize('position', [S.Zero, Integer(2) * r * N.y])
+    @pytest.mark.parametrize('position', [S.Zero, Integer(2)*r*N.y])
     def test_geodesic_length_point_not_on_surface_invalid(position: Vector) -> None:
         r = Symbol('r', positive=True)
         pO = Point('pO')
@@ -249,19 +250,19 @@ def test_geodesic_length_point_not_on_surface_invalid(position: Vector) -> None:
     @pytest.mark.parametrize(
         'axis, position_1, position_2, expected',
         [
-            (N.x, r * N.y, r * N.y, S.Zero),
-            (N.x, r * N.y, N.x + r * N.y, S.One),
-            (N.x, r * N.y, -x * N.x + r * N.y, sqrt(x**2)),
-            (-N.x, r * N.y, x * N.x + r * N.y, sqrt(x**2)),
-            (N.x, r * N.y, r * N.z, S.Half * pi * sqrt(r**2)),
-            (-N.x, r * N.y, r * N.z, Integer(3) * S.Half * pi * sqrt(r**2)),
-            (N.x, r * N.z, r * N.y, Integer(3) * S.Half * pi * sqrt(r**2)),
-            (-N.x, r * N.z, r * N.y, S.Half * pi * sqrt(r**2)),
-            (N.x, r * N.y, r * (cos(q) * N.y + sin(q) * N.z), sqrt(r**2 * q**2)),
+            (N.x, r*N.y, r*N.y, S.Zero),
+            (N.x, r*N.y, N.x + r*N.y, S.One),
+            (N.x, r*N.y, -x*N.x + r*N.y, sqrt(x**2)),
+            (-N.x, r*N.y, x*N.x + r*N.y, sqrt(x**2)),
+            (N.x, r*N.y, r*N.z, S.Half*pi*sqrt(r**2)),
+            (-N.x, r*N.y, r*N.z, Integer(3)*S.Half*pi*sqrt(r**2)),
+            (N.x, r*N.z, r*N.y, Integer(3)*S.Half*pi*sqrt(r**2)),
+            (-N.x, r*N.z, r*N.y, S.Half*pi*sqrt(r**2)),
+            (N.x, r*N.y, r*(cos(q)*N.y + sin(q)*N.z), sqrt(r**2*q**2)),
             (
-                -N.x, r * N.y,
-                r * (cos(q) * N.y + sin(q) * N.z),
-                sqrt(r**2 * (Integer(2) * pi - q)**2),
+                -N.x, r*N.y,
+                r*(cos(q)*N.y + sin(q)*N.z),
+                sqrt(r**2*(Integer(2)*pi - q)**2),
             ),
         ]
     )