forgekernel 0.9.1__tar.gz → 0.9.2__tar.gz

{forgekernel-0.9.1/src/forgekernel.egg-info → forgekernel-0.9.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: forgekernel
-Version: 0.9.1
+Version: 0.9.2
 Summary: Exact-arithmetic B-rep CAD kernel
 Author-email: Dan Willis <danielcwillis@gmail.com>
 Maintainer-email: Dan Willis <danielcwillis@gmail.com>

{forgekernel-0.9.1 → forgekernel-0.9.2}/src/forgekernel/__init__.py

@@ -4,4 +4,4 @@ Exact rational arithmetic for every topological decision; approximation
 only with tracked error bounds. See README for the three-oracle chain.
 """
 
-__version__ = "0.9.1"
+__version__ = "0.9.2"

{forgekernel-0.9.1 → forgekernel-0.9.2}/src/forgekernel/brep.py

@@ -188,25 +188,21 @@ class Solid:
         moment) and closure requires the SIGNED interval coverage on every
         line to cancel exactly. Zero everywhere == closed surface."""
         from collections import defaultdict
-        from math import gcd as _gcd
 
         def canon_dir(d: Vec) -> Vec | None:
-            den = 1
+            # Canonical (scale- and sign-invariant) representative of a
+            # direction: divide through by the first nonzero component so any
+            # scalar multiple ±λ·d maps to the same tuple. Works whether the
+            # components are rational (ℚ) or quadratic surds (ℚ[√d]) — an
+            # exactly-rotated solid carries √d edge directions.
+            lead = None
             for v in d:
-                den = den * v.denominator // _gcd(den, v.denominator)
-            ints = [int(v * den) for v in d]
-            g = 0
-            for v in ints:
-                g = _gcd(g, abs(v))
-            if g == 0:
-                return None
-            ints = [v // g for v in ints]
-            for v in ints:
                 if v != 0:
-                    if v < 0:
-                        ints = [-w for w in ints]
+                    lead = v
                     break
-            return (F(ints[0]), F(ints[1]), F(ints[2]))
+            if lead is None:
+                return None
+            return tuple(v / lead for v in d)
 
         lines: dict = defaultdict(list)
         for p in self.polys:
@@ -298,24 +294,16 @@ def _ear_clip(loop: list[tuple]) -> list[tuple]:
 
 
 def _canon_dir(d: Vec):
-    from math import gcd as _g
-
-    den = 1
+    # Scale- and sign-invariant direction key: divide by the first nonzero
+    # component. Rational (ℚ) or quadratic-surd (ℚ[√d], from exact rotation).
+    lead = None
     for v in d:
-        den = den * v.denominator // _g(den, v.denominator)
-    ints = [int(v * den) for v in d]
-    g = 0
-    for v in ints:
-        g = _g(g, abs(v))
-    if g == 0:
-        return None
-    ints = [v // g for v in ints]
-    for v in ints:
         if v != 0:
-            if v < 0:
-                ints = [-w for w in ints]
+            lead = v
             break
-    return (F(ints[0]), F(ints[1]), F(ints[2]))
+    if lead is None:
+        return None
+    return tuple(v / lead for v in d)
 
 
 def logical_edges(solid: Solid) -> list[dict]:

{forgekernel-0.9.1 → forgekernel-0.9.2}/src/forgekernel/exact.py

@@ -87,24 +87,17 @@ class Plane:
         return Plane(neg(self.n), -self.d)
 
     def canonical(self) -> tuple:
-        """Hashable canonical form: normal scaled to coprime integers with a
-        sign convention — coplanarity comparisons become tuple equality."""
-        nums = [self.n[0], self.n[1], self.n[2], self.d]
-        den = 1
-        for v in nums:
-            den = den * v.denominator // gcd(den, v.denominator)
-        ints = [int(v * den) for v in nums]
-        g = 0
-        for v in ints:
-            g = gcd(g, abs(v))
-        if g:
-            ints = [v // g for v in ints]
-        for v in ints[:3]:
+        """Hashable canonical form: (normal, d) divided through by the normal's
+        first nonzero component, so any scalar multiple ±λ·(n, d) maps to the
+        same tuple — coplanarity becomes tuple equality. Works over ℚ and over
+        ℚ[√d] (an exactly-rotated solid carries surd face normals)."""
+        nums = (self.n[0], self.n[1], self.n[2], self.d)
+        lead = None
+        for v in nums[:3]:
             if v != 0:
-                if v < 0:
-                    ints = [-w for w in ints]
+                lead = v
                 break
-        return tuple(ints)
+        return tuple(v / lead for v in nums)
 
     def coplanar_key(self) -> tuple:
         """Canonical form ignoring orientation (for adjacency grouping)."""

{forgekernel-0.9.1 → forgekernel-0.9.2}/src/forgekernel/kernel.py

@@ -51,6 +51,69 @@ def rotate_quarter(s: Solid, axis: str, quarters: int) -> Solid:
     return s.rotated_quarter(axis, quarters)
 
 
+def _cos_sin_deg(deg):
+    """Exact (cos, sin) of an angle in degrees, in ℚ[√d] — or None if the angle
+    needs a larger field. Covers the multiples of 30° and 45° (so circular
+    patterns of 3/4/6/8/12 and the diagonal sketch-plane rotations are exact)."""
+    from forgekernel.surd import SurdVal
+
+    from fractions import Fraction
+
+    d = int(deg) % 360
+    if deg != int(deg):
+        return None
+    if d % 90 == 0:
+        return [(F(1), F(0)), (F(0), F(1)), (F(-1), F(0)), (F(0), F(-1))][d // 90]
+    h = Fraction(1, 2)
+    r3, r2 = SurdVal(0, h, 3), SurdVal(0, h, 2)      # √3/2, √2/2
+    table = {30: (r3, h), 60: (h, r3), 120: (-h, r3), 150: (-r3, h),
+             210: (-r3, -h), 240: (-h, -r3), 300: (h, -r3), 330: (r3, -h),
+             45: (r2, r2), 135: (-r2, r2), 225: (-r2, -r2), 315: (r2, -r2)}
+    return table.get(d)
+
+
+def _rotation_matrix(axis, deg):
+    """Exact Rodrigues rotation matrix (list of 3 rows) about ``axis`` by
+    ``deg``, over ℚ[√d]. Raises ValueError if the angle is not representable."""
+    from forgekernel.surd import SurdVal, sqrt_rational
+
+    cs = _cos_sin_deg(deg)
+    if cs is None:
+        raise ValueError(
+            f"rotation by {deg}° is not exactly representable in ℚ[√d] "
+            "(only multiples of 30° and 45°)")
+    c, s = cs
+    ax, ay, az = F(axis[0]), F(axis[1]), F(axis[2])
+    n2 = ax * ax + ay * ay + az * az                 # |axis|², rational
+    if n2 == 0:
+        raise ValueError("zero rotation axis")
+    one = SurdVal(1, 0, 1)
+    s_over_n = (s if isinstance(s, SurdVal) else SurdVal(s)) / sqrt_rational(n2)
+    k2c = (one - (c if isinstance(c, SurdVal) else SurdVal(c))) / n2
+    k = [[F(0), -az, ay], [az, F(0), -ax], [-ay, ax, F(0)]]          # [axis]×
+    k2 = [[sum(k[i][t] * k[t][j] for t in range(3)) for j in range(3)]
+          for i in range(3)]
+    return [[(F(1) if i == j else F(0)) + s_over_n * k[i][j] + k2c * k2[i][j]
+             for j in range(3)] for i in range(3)]
+
+
+def rotate(s: Solid, axis, deg) -> Solid:
+    """Exact rotation of a planar solid about an arbitrary axis by an angle in
+    ℚ[√d] (multiples of 30°/45°). Rigid motion — volume is preserved exactly and
+    the result is a Solid with exact ℚ[√d] coordinates. Raises ValueError for
+    angles a larger field would be needed for (the seam turns that into an
+    honest refusal)."""
+    r = _rotation_matrix(axis, deg)
+
+    def fn(v):
+        x, y, z = v
+        return (r[0][0] * x + r[0][1] * y + r[0][2] * z,
+                r[1][0] * x + r[1][1] * y + r[1][2] * z,
+                r[2][0] * x + r[2][1] * y + r[2][2] * z)
+
+    return s.mapped(fn)
+
+
 def chamfer(s: Solid, distance) -> Solid:
     """Exact chamfer on all convex rational-normal edges, with industrial
     corner-triangle vertex truncation (oracle-matched semantics)."""

{forgekernel-0.9.1 → forgekernel-0.9.2}/src/forgekernel/surd.py

@@ -76,6 +76,9 @@ class SurdVal:
         o = self._co(o)
         return SurdVal(self.a - o.a, self.b - o.b, self._radical(o))
 
+    def __rsub__(self, o) -> "SurdVal":     # o − self, for rational/int on the left
+        return self._co(o) - self
+
     def __mul__(self, o) -> "SurdVal":
         o = self._co(o)
         if self.b == 0 or o.b == 0:
@@ -89,12 +92,63 @@ class SurdVal:
 
     __rmul__ = __mul__
 
+    def __neg__(self) -> "SurdVal":
+        return SurdVal(-self.a, -self.b, self.d)
+
+    def __truediv__(self, o) -> "SurdVal":
+        if isinstance(o, (int, Fraction)):
+            r = F(o)
+            return SurdVal(self.a / r, self.b / r, self.d)
+        o = self._co(o)
+        if o.b == 0:                             # divide by a rational
+            return SurdVal(self.a / o.a, self.b / o.a, self.d)
+        # divide by (c+e√d) via the conjugate: ·(c−e√d)/(c²−e²d)
+        denom = o.a * o.a - o.b * o.b * o.d      # rational, nonzero
+        num = self * SurdVal(o.a, -o.b, o.d)
+        return SurdVal(num.a / denom, num.b / denom, num.d)
+
+    def __rtruediv__(self, o) -> "SurdVal":
+        return self._co(o) / self
+
+    def _sign(self) -> int:
+        """Exact sign of a + b√d (d ≥ 1, √d > 0) — decides comparisons."""
+        if self.b == 0:
+            return (self.a > 0) - (self.a < 0)
+        if self.a == 0:
+            return (self.b > 0) - (self.b < 0)
+        sa = (self.a > 0) - (self.a < 0)
+        sb = (self.b > 0) - (self.b < 0)
+        if sa == sb:                             # both terms same sign
+            return sa
+        # opposite signs: compare magnitudes a² vs b²·d (squaring is monotone)
+        da, db = self.a * self.a, self.b * self.b * self.d
+        if da == db:
+            return 0
+        return sa if da > db else sb
+
+    def __lt__(self, o) -> bool:
+        return (self - self._co(o))._sign() < 0
+
+    def __le__(self, o) -> bool:
+        return (self - self._co(o))._sign() <= 0
+
+    def __gt__(self, o) -> bool:
+        return (self - self._co(o))._sign() > 0
+
+    def __ge__(self, o) -> bool:
+        return (self - self._co(o))._sign() >= 0
+
     def __eq__(self, o: object) -> bool:
         o = self._co(o)
         if self.b == 0 and o.b == 0:
             return self.a == o.a
         return self.a == o.a and self.b == o.b and self.d == o.d
 
+    def __hash__(self) -> int:
+        if self.b == 0:                          # a pure rational hashes as itself
+            return hash(self.a)
+        return hash((self.a, self.b, self.d))
+
     def __float__(self) -> float:
         return float(self.a) + float(self.b) * math.sqrt(self.d)
 

{forgekernel-0.9.1 → forgekernel-0.9.2/src/forgekernel.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: forgekernel
-Version: 0.9.1
+Version: 0.9.2
 Summary: Exact-arithmetic B-rep CAD kernel
 Author-email: Dan Willis <danielcwillis@gmail.com>
 Maintainer-email: Dan Willis <danielcwillis@gmail.com>

{forgekernel-0.9.1 → forgekernel-0.9.2}/src/forgekernel.egg-info/SOURCES.txt

@@ -39,5 +39,6 @@ tests/test_k7_bsolid.py
 tests/test_k7_stepexport.py
 tests/test_k7_trim.py
 tests/test_k7_trimflux.py
+tests/test_rotate.py
 tests/test_rust_oracle.py
 tests/test_scaffold.py

forgekernel-0.9.2/tests/test_rotate.py

@@ -0,0 +1,87 @@
+"""Exact rotation over ℚ[√d] — the K2.2 circular-pattern / diagonal-sketch-plane
+enabler. Rotation is a rigid motion, so volume is preserved EXACTLY (rational),
+and representable angles (multiples of 30°/45°) keep coordinates exact."""
+
+from __future__ import annotations
+
+import math
+
+import pytest
+
+from forgekernel import kernel as fk
+from forgekernel.surd import SurdVal, sqrt_rational
+
+
+def test_rotation_preserves_volume_exactly() -> None:
+    b = fk.box(10, 4, 3)
+    for axis, deg in [((0, 0, 1), 60), ((0, 0, 1), 45), ((1, 0, 0), 30),
+                      ((1, 1, 1), 120)]:
+        r = fk.rotate(b, axis, deg)
+        assert r.volume() == 120           # exact rational, not a float
+
+
+def test_six_sixty_degree_rotations_are_the_identity() -> None:
+    b = fk.box(7, 5, 2)
+    acc = b
+    for _ in range(6):
+        acc = fk.rotate(acc, (0, 0, 1), 60)
+    orig = {tuple(float(c) for c in v) for p in b.polys for v in p.verts}
+    back = {tuple(float(c) for c in v) for p in acc.polys for v in p.verts}
+    assert orig == back                    # 6·60° = 360° back to start, exactly
+
+
+def test_diagonal_120_is_a_rational_axis_permutation() -> None:
+    p = fk.rotate(fk.box(3, 5, 7), (1, 1, 1), 120)
+    # 120° about the body diagonal cyclically permutes the axes — the surds
+    # cancel, leaving purely rational coordinates.
+    assert all(not isinstance(c, SurdVal) or c.b == 0
+               for poly in p.polys for v in poly.verts for c in v)
+    assert p.volume() == 105
+
+
+def test_unrepresentable_angle_is_refused() -> None:
+    with pytest.raises(ValueError):
+        fk.rotate(fk.box(2, 2, 2), (0, 0, 1), 37)
+
+
+def test_boolean_union_of_rotated_copies_is_watertight_and_exact() -> None:
+    # the circular-pattern path: union disjoint rotated copies (surd coords)
+    seed = fk.translate(fk.box(5, 2, 3), 10, -1, 0)
+    out = seed
+    for i in range(1, 6):
+        out = fk.boolean("union", out, fk.rotate(seed, (0, 0, 1), 60 * i))
+    assert out.volume() == 6 * 5 * 2 * 3   # disjoint -> exact sum, no leaks
+    assert out.watertight_violations() == []
+
+
+def test_overlapping_boolean_mixes_rational_and_surd_coords() -> None:
+    # the case disjoint patterns miss: an axis-aligned (ℚ) body booleaned with
+    # an OVERLAPPING rotated (ℚ[√3]) body — BSP clipping makes mixed-type
+    # polygons, so Fraction−SurdVal must resolve (needs SurdVal.__rsub__).
+    from fractions import Fraction as F
+
+    a = fk.box(2, 2, 2)
+    b = fk.rotate(fk.translate(fk.box(2, 2, 2), F(1, 2), F(1, 2), 0), (0, 0, 1), 30)
+    vu = float(fk.boolean("union", a, b).volume())
+    vi = float(fk.boolean("intersect", a, b).volume())
+    vc = float(fk.boolean("cut", a, b).volume())
+    assert vi > 0                                   # they genuinely overlap
+    assert abs(vu + vi - 16) < 1e-9                 # |A∪B| + |A∩B| = |A| + |B|
+    assert abs(vc - (8 - vi)) < 1e-9                # |A∖B| = |A| − |A∩B|
+    for op in ("union", "cut", "intersect"):
+        assert fk.boolean(op, a, b).watertight_violations() == []
+
+
+def test_surd_is_an_ordered_field() -> None:
+    import random
+    random.seed(0)
+    for _ in range(2000):
+        d = random.choice([2, 3, 5, 6])
+        from fractions import Fraction as F
+        x = SurdVal(F(random.randint(-9, 9), random.randint(1, 4)),
+                    F(random.randint(-9, 9), random.randint(1, 4)), d)
+        y = SurdVal(F(random.randint(-9, 9), random.randint(1, 4)),
+                    F(random.randint(-9, 9), random.randint(1, 4)), d)
+        if abs(float(x) - float(y)) > 1e-9:
+            assert (x < y) == (float(x) < float(y))
+        assert (x / y) * y == x if float(y) != 0 else True