physpyx 3.0.0__tar.gz → 3.2.0__tar.gz

{physpyx-3.0.0 → physpyx-3.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: physpyx
-Version: 3.0.0
+Version: 3.2.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.0.0 → physpyx-3.2.0}/pyproject.toml

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

{physpyx-3.0.0 → physpyx-3.2.0}/pyproject.toml.orig

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

{physpyx-3.0.0 → physpyx-3.2.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,11 +74,7 @@ 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")
 

{physpyx-3.0.0 → physpyx-3.2.0}/src/physpyx/qty.py

@@ -1,7 +1,10 @@
 import re
 import sys
+from collections.abc import Iterable
 from logging import getLogger
+from typing import cast
 
+from numpy import array
 from pint._typing import Scalar
 from pint.facets.context import Context
 
@@ -56,7 +59,7 @@ class Qty(PTManager):
 
     def __call__(
         self,
-        value: Scalar | list[Scalar] | str,
+        value: Scalar | Iterable[Scalar | SiunitxQuantity] | str,
         unit: str | None = None,
         to: str | None = None,
         fmt: str = "g",
@@ -90,6 +93,22 @@ class Qty(PTManager):
             if unit is not None:
                 logger.warning("Units are ignored when instanciating a constant")
             value, unit, fmt = self._constants(value, fmt)
+        elif isinstance(value, Iterable):
+            if all(isinstance(item, SiunitxQuantity) for item in value):
+                value = cast(Iterable[SiunitxQuantity], value)
+                dim = {v.dimensionality for v in value}
+                if len(dim) != 1:
+                    raise ValueError(
+                        f"Can't create a vector with different dimensionality ({dim})"
+                    )
+
+                if unit == None:
+                    unit = ""
+                if self._ureg.Unit(unit).dimensionality != dim.pop():
+                    raise ValueError("Need to set unit with correct dimensionality")
+                value = array([v.fmtex(to=unit).m for v in value])
+            else:
+                value = array(value)
 
         q = self._ureg.Quantity(
             value,

{physpyx-3.0.0 → physpyx-3.2.0}/src/physpyx/quantity.py

@@ -1,8 +1,8 @@
-from collections.abc import Generator, Iterator
+from collections.abc import Generator, Iterable, Iterator
 from logging import getLogger
 from typing import ClassVar, Self, TypedDict, cast
 
-from numpy import cross, linalg, ndarray
+from numpy import cross, linalg
 from pint._typing import Magnitude, UnitLike
 from pint.registry import Quantity
 
@@ -82,8 +82,8 @@ class SiunitxQuantity(Quantity):
             return alt
 
     def __iter__(self) -> Iterator["SiunitxQuantity"]:
-        # NOTE: this is used to set formatting options in tuple expansions:
-        # rx, ry = qty([3, 2], "kilometer", fmt=".1e")
+        # NOTE: this is used to set formatting options in tuple expansions rx,
+        # ry = qty([3, 2], "kilometer", fmt=".1e")
         for val in super().__iter__():
             val._fmt = self._fmt
             val._base = self._base
@@ -99,33 +99,35 @@ class SiunitxQuantity(Quantity):
         elif self._preferred:
             quantity = self._REGISTRY.to_preferred_units(self)
         if self._compact:
+            if isinstance(self.m, Iterable):
+                raise ValueError("'compact=True' for vectors has an undefined behavior")
             quantity = cast(SiunitxQuantity, self.to_compact())
 
         quantity._fmt = self._fmt
         return (
             quantity._format_array()
-            if isinstance(quantity.m, ndarray)
+            if isinstance(quantity.m, Iterable)
             else quantity._format_scalar()
         )
 
+    def _format_magnitude(self, m: float) -> str:
+        out = f"{m:{self._fmt}}"
+        if out.startswith("1e"):
+            return out[1:]
+        elif out.startswith("-1e"):
+            return "-" + out[2:]
+        return out
+
     def _format_array(self) -> str:
         if self.m.ndim != 1:
             raise NotImplementedError
         out = r"\begin{pmatrix}"
         if isinstance(self.m[0], complex):
             out += "\\\\".join(
-                [
-                    rf"\complexnum{{{v:{self._fmt}}}}" if abs(v) > 1e-16 else r"\num{0}"
-                    for v in self.m
-                ]
+                rf"\complexnum{{{self._format_magnitude(m)}}}" for m in self.m
             )
         else:
-            out += "\\\\".join(
-                [
-                    rf"\num{{{v:{self._fmt}}}}" if abs(v) > 1e-16 else r"\num{0}"
-                    for v in self.m
-                ]
-            )
+            out += "\\\\".join(rf"\num{{{self._format_magnitude(m)}}}" for m in self.m)
 
         out += r"\end{pmatrix}"
         if ustr := self._format_unit():
@@ -133,9 +135,7 @@ class SiunitxQuantity(Quantity):
         return out
 
     def _format_scalar(self) -> str:
-        out = f"{self.m:{self._fmt}}"
-        if out.startswith("1e"):
-            out = out[1:]
+        out = self._format_magnitude(self.m)
         if ustr := self._format_unit():
             if isinstance(self.m, complex):
                 return rf"\complexqty{{{out}}}{{{ustr}}}"
@@ -157,6 +157,21 @@ class SiunitxQuantity(Quantity):
         # "PlainQuantity[Unknown]"'
         return cast(SiunitxQuantity, super().__add__(other))
 
+    def __truediv__(self, other: object) -> "SiunitxQuantity":
+        # NOTE: to fix typing warning 'Cannot access attribute "???" for class
+        # "PlainQuantity[Unknown]"'
+        return cast(SiunitxQuantity, super().__truediv__(other))
+
+    def __mul__(self, other: object) -> "SiunitxQuantity":
+        # NOTE: to fix typing warning 'Cannot access attribute "???" for class
+        # "PlainQuantity[Unknown]"'
+        return cast(SiunitxQuantity, super().__mul__(other))
+
+    def __rmul__(self, other: object) -> "SiunitxQuantity":
+        # NOTE: to fix typing warning 'Cannot access attribute "???" for class
+        # "PlainQuantity[Unknown]"'
+        return cast(SiunitxQuantity, super().__rmul__(other))
+
     def _format_unit(self) -> str:
         num = ""
         den = ""

physpyx-3.2.0/src/physpyx/tikz.py

@@ -0,0 +1,196 @@
+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 orientation(self) -> float:
+        return np.atan2(self.y, self.x) * 180 / np.pi
+
+    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 __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 __add__(self, other: "Coordinate") -> "Coordinate":
+        return Coordinate(self.x + other.x, self.y + other.y)
+
+    def dot(self, other: "Coordinate") -> float:
+        return self.x * other.x + self.y * other.y
+
+    def __str__(self) -> str:
+        return f"({self.x}, {self.y})"
+
+
+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 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