physpyx 3.1.0__tar.gz → 3.3.0__tar.gz

{physpyx-3.1.0 → physpyx-3.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: physpyx
-Version: 3.1.0
+Version: 3.3.0
 Summary: Provides a way to use python code in LaTeX
 Author: Jérôme Dufour
 Author-email: Jérôme Dufour <jerome.dufour@eduvaud.ch>

{physpyx-3.1.0 → physpyx-3.3.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "physpyx"
-version = "3.1.0"
+version = "3.3.0"
 description = "Provides a way to use python code in LaTeX"
 readme = "README.md"
 requires-python = ">=3.13"

{physpyx-3.1.0 → physpyx-3.3.0}/pyproject.toml.orig

@@ -1,6 +1,6 @@
 [project]
 name = "physpyx"
-version = "3.1.0"
+version = "3.3.0"
 description = "Provides a way to use python code in LaTeX"
 readme = "README.md"
 requires-python = ">=3.13"

{physpyx-3.1.0 → physpyx-3.3.0}/src/physpyx/astronomy.py

@@ -40,6 +40,11 @@ class Orbit:
         else:
             raise ValueError
 
+        if self.a < self.b:
+            raise ValueError(
+                "The semi-major axis should be bigger or equal to the semi-minor axis (a>=b)"
+            )
+
         self.c = self.a * self.e  # linear eccentricity
         self.p = self.a * (1.0 - self.e * self.e)  # semi-latus
         self.T = 2 * np.pi * self.a * np.sqrt(self.a / self.mu)  # period
@@ -69,16 +74,12 @@ class Orbit:
         r = self.p / (1 + self.e * np.cos(self.theta))
         self.x = r * np.array([np.cos(self.theta), np.sin(self.theta)]) + self.v * dt
 
-    def run(
-        self,
-        steps: int,
-        every: int = 1,
-    ) -> Iterator[NDArray]:
+    def run(self, steps: int, every: int = 1) -> Iterator[NDArray]:
         if steps % every:
             raise ValueError(f"{every} is not a divisor {steps} steps")
 
         dt = self.T / steps
-        for i in range(steps + 1):
+        for i in range(steps):
             if i % every == 0:
                 yield self.x
             self.step(dt)
@@ -107,7 +108,7 @@ class Orbit:
         vec_t = self.v / vt
         vec_p = np.array([-vec_t[1], vec_t[0]])
 
-        # compute cetripetal acceleration
+        # compute centripetal acceleration
         a = self.get_acceleration()
         ac = a.dot(vec_p)
 

physpyx-3.3.0/src/physpyx/tikz.py

@@ -0,0 +1,243 @@
+from collections.abc import Generator
+from enum import IntEnum
+from typing import Self
+
+import numpy as np
+
+
+class Coordinate:
+    def __init__(self, x: float, y: float):
+        self.x = x
+        self.y = y
+
+    def norm(self) -> float:
+        return np.sqrt(self.x * self.x + self.y * self.y)
+
+    def __str__(self) -> str:
+        return f"({self.x}, {self.y})"
+
+    def __eq__(self, other: object) -> bool:
+        if not isinstance(other, Coordinate):
+            return False
+        return bool(np.isclose(self.x, other.x) and np.isclose(self.y, other.y))
+
+    def __isub__(self, other: "Coordinate") -> Self:
+        self.x -= other.x
+        self.y -= other.y
+        return self
+
+    def __sub__(self, other: "Coordinate") -> "Coordinate":
+        return Coordinate(self.x - other.x, self.y - other.y)
+
+    def __iadd__(self, other: "Coordinate") -> Self:
+        self.x += other.x
+        self.y += other.y
+        return self
+
+    def __add__(self, other: "Coordinate") -> "Coordinate":
+        return Coordinate(self.x + other.x, self.y + other.y)
+
+    def __mul__(self, number: float) -> "Coordinate":
+        return Coordinate(self.x * number, self.y * number)
+
+    __rmul__ = __mul__
+
+    def __truediv__(self, number: float) -> "Coordinate":
+        return Coordinate(self.x / number, self.y / number)
+
+    def dot(self, other: "Coordinate") -> float:
+        return self.x * other.x + self.y * other.y
+
+    def orientation(self) -> float:
+        a = np.atan2(self.y, self.x) * 180 / np.pi
+        return a + 360 if a < 0 else a
+
+    def rotate(self, angle: float, deg: bool = True) -> "Coordinate":
+        if deg:
+            angle *= np.pi / 180
+        return Coordinate(
+            self.x * np.cos(angle) + self.y * -np.sin(angle),
+            self.x * np.sin(angle) + self.y * np.cos(angle),
+        )
+
+
+class Rectangle:
+    def __init__(self, c1: Coordinate, c2: Coordinate):
+        self.c1 = c1
+        self.c2 = c2
+
+    def __str__(self) -> str:
+        return f"{self.c1} rectangle {self.c2}"
+
+    @property
+    def center(self) -> Coordinate:
+        return 0.5 * self.c1 + 0.5 * self.c2
+
+    @property
+    def north(self) -> Coordinate:
+        return Coordinate(0.5 * self.c1.x + 0.5 * self.c2.x, max(self.c1.y, self.c2.y))
+
+    @property
+    def south(self) -> Coordinate:
+        return Coordinate(0.5 * self.c1.x + 0.5 * self.c2.x, min(self.c1.y, self.c2.y))
+
+    @property
+    def east(self) -> Coordinate:
+        return Coordinate(max(self.c1.x, self.c2.x), 0.5 * self.c1.y + 0.5 * self.c2.y)
+
+    @property
+    def west(self) -> Coordinate:
+        return Coordinate(min(self.c1.x, self.c2.x), 0.5 * self.c1.y + 0.5 * self.c2.y)
+
+    @property
+    def north_east(self) -> Coordinate:
+        return Coordinate(max(self.c1.x, self.c2.x), max(self.c1.y, self.c2.y))
+
+    @property
+    def north_west(self) -> Coordinate:
+        return Coordinate(min(self.c1.x, self.c2.x), max(self.c1.y, self.c2.y))
+
+    @property
+    def south_west(self) -> Coordinate:
+        return Coordinate(min(self.c1.x, self.c2.x), min(self.c1.y, self.c2.y))
+
+    @property
+    def south_east(self) -> Coordinate:
+        return Coordinate(max(self.c1.x, self.c2.x), min(self.c1.y, self.c2.y))
+
+
+class Circle:
+    class LR(IntEnum):
+        LEFT = -1
+        RIGHT = 1
+
+    class IO(IntEnum):
+        OUTER = -1
+        INNER = 1
+
+    class ORIENT(IntEnum):
+        DEFAULT = 0
+        CLOCKWISE = -1
+        COUNTER_CLOCKWISE = 1
+
+    def __init__(self, center: Coordinate, radius: float):
+        self.center = center
+        self.radius = radius
+
+    def __str__(self) -> str:
+        return f"{self.center} circle ({self.radius})"
+
+    def get_point_on_circle(self, angle: float) -> Coordinate:
+        angle *= np.pi / 180
+        return self.center + Coordinate(
+            self.radius * np.cos(angle),
+            self.radius * np.sin(angle),
+        )
+
+    def tangent_points_to_circle(
+        self, circ: "Circle", lr: LR, io: IO
+    ) -> tuple[Coordinate, Coordinate]:
+        D = circ.center - self.center
+        d = D.norm()
+        R = (circ.radius + io * self.radius) / d
+        e1 = D / d
+        e2 = Coordinate(-e1.y, e1.x)
+
+        ab = R * e1 + lr * np.sqrt(1 - R * R) * e2
+        c = -io * self.radius - ab.dot(self.center)
+        return (
+            self.center - ab * (ab.dot(self.center) + c),
+            circ.center - ab * (ab.dot(circ.center) + c),
+        )
+
+    def tangent_points_passing_by(self, P: Coordinate, lr: LR) -> Coordinate:
+        D = P - self.center
+        d = D.norm()
+        e1 = D / d
+        e2 = Coordinate(-e1.y, e1.x)
+        a = self.radius * self.radius / d * e1
+        b = self.radius / d * np.sqrt(d * d - self.radius * self.radius) * e2
+        return self.center + a + lr * b
+
+
+class Pulley(Circle):
+    def to_tex(self) -> Generator[str]:
+        yield rf"\fill[black!30] {self};"
+        yield rf"\draw[black!50, line width={2 * self.radius}] {Circle(self.center, 0.85 * self.radius)};"
+        yield rf"\fill[black!70] {Circle(self.center, 0.25 * self.radius)};"
+        shift = np.random.random() * np.pi / 3
+        for i in range(6):
+            c = self.center + Coordinate(
+                0.6 * self.radius * np.sin(i * np.pi / 3 + shift),
+                0.6 * self.radius * np.cos(i * np.pi / 3 + shift),
+            )
+            yield rf"\fill[black!60]{Circle(c, 0.1 * self.radius)};"
+
+
+class Rope:
+    def __init__(self, start: Coordinate):
+        self.current = start
+        self._path = f"{start}"
+
+    def __str__(self) -> str:
+        return self._path
+
+    def to_pulley(self, pulley: Pulley, lr: Circle.LR) -> None:
+        self.current = pulley.tangent_points_passing_by(self.current, lr)
+        self._path += f" -- {self.current}"
+
+    def _compute_angles(
+        self, a: Coordinate, b: Coordinate, o: Circle.ORIENT
+    ) -> tuple[float, float]:
+        return (self.current - a).orientation(), (b - a).orientation() + o * 360
+
+    def from_pulley(
+        self,
+        pulley: Pulley,
+        to: Coordinate,
+        lr: Circle.LR,
+        orientation: Circle.ORIENT = Circle.ORIENT.DEFAULT,
+    ) -> None:
+        tmp = pulley.tangent_points_passing_by(to, lr)
+        angle_i, angle_o = self._compute_angles(pulley.center, tmp, orientation)
+        self._path += f" arc ({angle_i}:{angle_o}:{pulley.radius}) -- {to}"
+        self.current = to
+
+    def from_pulley_to_pulley(
+        self,
+        P1: Pulley,
+        P2: Pulley,
+        lr: Circle.LR,
+        io: Circle.IO,
+        orientation: Circle.ORIENT = Circle.ORIENT.DEFAULT,
+    ) -> None:
+        t1, t2 = P1.tangent_points_to_circle(P2, lr, io)
+        angle_i, angle_o = self._compute_angles(P1.center, t1, orientation)
+        self._path += f" arc ({angle_i}:{angle_o}:{P1.radius}) -- {t2}"
+        self.current = t2
+
+
+class Angle:
+    def __init__(
+        self,
+        origin: Coordinate,
+        p1: Coordinate,
+        p2: Coordinate,
+        orient: Circle.ORIENT = Circle.ORIENT.COUNTER_CLOCKWISE,
+    ):
+        self.origin = origin
+        self.p1 = p1
+        self.p2 = p2
+        self.alpha1 = (self.p1 - self.origin).orientation()
+        self.alpha2 = (self.p2 - self.origin).orientation()
+        if orient == Circle.ORIENT.CLOCKWISE and self.alpha2 > self.alpha1:
+            self.alpha2 -= 360
+        elif orient == Circle.ORIENT.COUNTER_CLOCKWISE and self.alpha1 > self.alpha2:
+            self.alpha1 -= 360
+        self.alpha = self.alpha2 - self.alpha1
+
+    def angle(self) -> str:
+        return rf"{self.p1} -- {self.origin} -- {self.p2}"
+
+    def arc(self, radius: float) -> str:
+        return rf"([shift={{{self.origin}}}]{self.alpha1}:{radius}) arc ({self.alpha1}:{self.alpha2}:{radius})"