forgekernel 0.9.1__tar.gz → 0.9.4__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: forgekernel
-Version: 0.9.1
+Version: 0.9.4
 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.4}/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.4"

{forgekernel-0.9.1 → forgekernel-0.9.4}/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.4}/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.4}/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.4}/src/forgekernel/quadric.py

@@ -93,6 +93,35 @@ class Cyl:
         return lathe(profile, deflection, float(self.cx), float(self.cy))
 
 
+def _xy_inside_footprint(solid: Solid, px, py) -> bool:
+    """Exact: is (px, py) inside the solid's xy footprint?
+
+    The footprint boundary is the xy projection of the lateral (non-horizontal)
+    faces. Ray parity along +x with the half-open upward-crossing rule — all
+    rational, no tolerance. Needed because "the bore does not CROSS a lateral
+    wall" does not distinguish a bore strictly inside from one entirely
+    outside: neither crosses anything."""
+    segs = set()
+    for p in solid.polys:
+        n = p.plane.n
+        if n[0] == 0 and n[1] == 0:
+            continue                           # horizontal face: no footprint edge
+        m = len(p.verts)
+        for i in range(m):
+            a, b = p.verts[i], p.verts[(i + 1) % m]
+            if a[0] == b[0] and a[1] == b[1]:
+                continue                       # vertical edge: projects to a point
+            key = ((a[0], a[1]), (b[0], b[1]))
+            segs.add(key if key[0] <= key[1] else (key[1], key[0]))
+    inside = False
+    for (x1, y1), (x2, y2) in segs:
+        if (y1 > py) != (y2 > py):
+            xc = x1 + (py - y1) * (x2 - x1) / (y2 - y1)
+            if px < xc:
+                inside = not inside
+    return inside
+
+
 def _dist2_point_seg(px, py, ax, ay, bx, by) -> Fraction:
     """Exact squared distance from point to segment (all rational)."""
     dx, dy = bx - ax, by - ay
@@ -140,6 +169,12 @@ class DrilledSolid:
                     raise ValueError(
                         "bore crosses a lateral wall — general quadric "
                         "booleans arrive at K2.1")
+        # The wall check above proves the bore straddles no wall; it does NOT
+        # say which side it is on. Without this, a bore placed entirely outside
+        # the footprint is recorded as a phantom hole and its volume silently
+        # subtracted from a solid it never touches.
+        if not _xy_inside_footprint(self.base, c.cx, c.cy):
+            raise ValueError("bore misses the solid in xy (nothing to drill)")
         for o in self.bores:
             if o.cx == c.cx and o.cy == c.cy:
                 continue                       # coaxial stack (counterbore)
@@ -616,17 +651,23 @@ class AxisStack:
 
 class RevolveSolid:
     """A closed line-segment profile in the (r, z) half-plane revolved
-    360 degrees about the z axis. Green gives exact metrics:
-    V = pi * contour_integral(r^2 dz), each edge contributing
-    (z2-z1)(r1^2 + r1 r2 + r2^2)/3."""
+    360 degrees about a z-parallel axis through ``(cx, cy)``. Green gives
+    exact metrics: V = pi * contour_integral(r^2 dz), each edge contributing
+    (z2-z1)(r1^2 + r1 r2 + r2^2)/3. The profile need not touch r = 0 — an
+    annular loop is a tube (a bored cylinder), still exact."""
 
-    def __init__(self, loop_rz: list) -> None:
+    def __init__(self, loop_rz: list, cx=0, cy=0) -> None:
         self.loop = [(F(r), F(z)) for r, z in loop_rz]
+        self.cx, self.cy = F(cx), F(cy)
         if any(r < 0 for r, _ in self.loop):
             raise ValueError("revolve profile must stay at r >= 0")
         if self._v3() < 0:
             self.loop = list(reversed(self.loop))
 
+    def translated(self, x, y, z) -> "RevolveSolid":
+        return RevolveSolid([(r, zz + F(z)) for r, zz in self.loop],
+                            self.cx + F(x), self.cy + F(y))
+
     def _edges(self):
         n = len(self.loop)
         for i in range(n):
@@ -648,18 +689,53 @@ class RevolveSolid:
             num += dz * (z1 * (3 * r1 * r1 + 2 * r1 * r2 + r2 * r2)
                          + z2 * (r1 * r1 + 2 * r1 * r2 + 3 * r2 * r2)) / 12
         v3 = self._v3()
-        return (0.0, 0.0, float(num / v3 * 3) if v3 else 0.0)
+        return (float(self.cx), float(self.cy),
+                float(num / v3 * 3) if v3 else 0.0)
 
     def bbox(self):
         rmax = max(r for r, _ in self.loop)
         zs = [z for _, z in self.loop]
-        return ((-float(rmax), -float(rmax), float(min(zs))),
-                (float(rmax), float(rmax), float(max(zs))))
+        cx, cy = float(self.cx), float(self.cy)
+        return ((cx - float(rmax), cy - float(rmax), float(min(zs))),
+                (cx + float(rmax), cy + float(rmax), float(max(zs))))
 
     def tessellate(self, deflection: float = 0.2) -> dict:
         from forgekernel.tess import lathe
 
-        return lathe([(float(r), float(z)) for r, z in self.loop], deflection)
+        return lathe([(float(r), float(z)) for r, z in self.loop], deflection,
+                     float(self.cx), float(self.cy))
+
+
+def bore_cyl(cyl: "Cyl", bore: "Cyl") -> object:
+    """Cut a COAXIAL bore out of a z-cylinder, exactly.
+
+    A cylinder minus a coaxial cylindrical bore is still a solid of
+    revolution, so the result is a ``RevolveSolid`` whose (r, z) profile is
+    the cylinder's rectangle minus the bore's — exact in ℚ, with the volume
+    following in ℚ[π] from Green's theorem. Returns ``cyl`` unchanged when
+    the bore misses it in z. Raises ValueError for the cases that are not a
+    single revolved region (a bore floating strictly inside — a closed
+    cavity — or one that consumes the whole cylinder)."""
+    if bore.cx != cyl.cx or bore.cy != cyl.cy:
+        raise ValueError("bore is not coaxial with the cylinder — K2.3")
+    if bore.r >= cyl.r:
+        raise ValueError("bore is not narrower than the cylinder — K2.3")
+    z0, z1 = cyl.z0, cyl.z1
+    b0, b1 = max(bore.z0, z0), min(bore.z1, z1)
+    if b1 <= b0:
+        return cyl                              # bore misses in z: unchanged
+    R, rb = cyl.r, bore.r
+    if b0 <= z0 and b1 >= z1:                   # through bore -> annulus
+        loop = [(rb, z0), (R, z0), (R, z1), (rb, z1)]
+    elif b0 <= z0:                              # blind from the bottom
+        loop = [(rb, z0), (R, z0), (R, z1), (0, z1), (0, b1), (rb, b1)]
+    elif b1 >= z1:                              # blind from the top
+        loop = [(0, z0), (R, z0), (R, z1), (rb, z1), (rb, b0), (0, b0)]
+    else:
+        raise ValueError(
+            "bore floats strictly inside the cylinder (a closed cavity) — "
+            "general quadric booleans arrive at K2.3")
+    return RevolveSolid(loop, cyl.cx, cyl.cy)
 
 
 def _member_volume(m):
@@ -696,6 +772,59 @@ class DisjointUnion:
             _classify_pair(m, other)
         return DisjointUnion(self.members + [other])
 
+    def tessellate(self, deflection: float = 0.2) -> dict:
+        """Display mesh = the members' meshes merged. Valid as one mesh
+        because the members are disjoint (at most tangent), so the shells
+        never interpenetrate."""
+        verts: list = []
+        tris: list = []
+        for m in self.members:
+            if not hasattr(m, "tessellate"):    # bare Sphere/Cone: via a stack
+                m = AxisStack(m.cx, m.cy, [m])
+            try:
+                sub = m.tessellate(deflection)
+            except TypeError:                   # planar Solid: meshes exactly
+                sub = m.tessellate()
+            off = len(verts)
+            verts.extend(sub["vertices"])
+            tris.extend([a + off, b + off, c + off] for a, b, c in sub["triangles"])
+        return {"vertices": verts, "triangles": tris}
+
+    @classmethod
+    def _unchecked(cls, members: list) -> "DisjointUnion":
+        """Build without re-running the pairwise predicates — for members
+        derived from an already-validated union by an operation that can only
+        SHRINK them (see ``cut``)."""
+        u = cls.__new__(cls)
+        u.members = list(members)
+        return u
+
+    def cut(self, tool) -> "DisjointUnion":
+        """Subtract ``tool`` from every member: (A ∪ B) ∖ C = (A∖C) ∪ (B∖C).
+        Members that the tool misses come back unchanged. Disjointness is
+        preserved because cutting only shrinks a member — (A∖C) ∩ (B∖C) ⊆
+        A ∩ B, already proven measure-zero — so the result needs no
+        re-validation (and its members may now be other exact types)."""
+        from forgekernel.brep import Solid
+
+        out = []
+        for m in self.members:
+            if isinstance(m, Cyl) and isinstance(tool, Cyl):
+                out.append(bore_cyl(m, tool))
+            elif isinstance(m, (Solid, DrilledSolid)) and isinstance(tool, Cyl):
+                base = DrilledSolid(m, []) if isinstance(m, Solid) else m
+                try:
+                    out.append(base.cut(tool))
+                except ValueError as exc:
+                    if "misses the solid in" not in str(exc):
+                        raise                   # a real precondition violation
+                    out.append(m)               # tool misses this member (z or xy)
+            else:
+                raise ValueError(
+                    f"cut of {type(m).__name__} by {type(tool).__name__} in a "
+                    "disjoint union arrives at K2.3")
+        return DisjointUnion._unchecked(out)
+
     def volume(self) -> "PiVal":
         total = PiVal(0, 0)
         for m in self.members:
@@ -748,10 +877,12 @@ def _classify_pair(a, b) -> None:
         if za[1] <= zb[0] or zb[1] <= za[0]:
             return                            # disjoint in z
         d2 = (a.cx - b.cx) ** 2 + (a.cy - b.cy) ** 2
-        outer = (a.r + b.r) ** 2
-        inner = (a.r - b.r) ** 2
-        if d2 >= outer or d2 <= inner:
-            return                            # externally/internally clear
+        if d2 >= (a.r + b.r) ** 2:
+            return                            # externally clear (or tangent)
+        # NOTE: d2 <= (ra−rb)² is CONTAINMENT, not separation — these are solid
+        # cylinders, not tubes, so a nested one overlaps with positive measure
+        # (identical cylinders land here too, at d2 = 0). Treating it as clear
+        # silently doubled the volume; it must refuse.
         raise ValueError(
             "overlapping cylinders — general quadric booleans arrive at K2.3")
     # sphere / planar Solid
@@ -761,11 +892,20 @@ def _classify_pair(a, b) -> None:
     if isinstance(b, Sphere) and isinstance(a, Solid):
         _sphere_solid(b, a)
         return
+    # z-cylinder / planar Solid (a mounting boss standing on a face)
+    if isinstance(a, Cyl) and isinstance(b, Solid):
+        _cyl_solid(a, b)
+        return
+    if isinstance(b, Cyl) and isinstance(a, Solid):
+        _cyl_solid(b, a)
+        return
     # sphere / sphere
     if isinstance(a, Sphere) and isinstance(b, Sphere):
         d2 = (a.cx - b.cx) ** 2 + (a.cy - b.cy) ** 2 + (a.cz - b.cz) ** 2
-        if d2 >= (a.r + b.r) ** 2 or d2 <= (a.r - b.r) ** 2:
-            return
+        if d2 >= (a.r + b.r) ** 2:
+            return                            # externally clear (or tangent)
+        # containment (d2 ≤ (ra−rb)²) is an overlap, not a separation — see the
+        # cylinder note above; SphereOverlap already rejects it as "nesting".
         raise ValueError(
             "overlapping spheres — general quadric booleans arrive at K2.3")
     raise ValueError(
@@ -773,6 +913,28 @@ def _classify_pair(a, b) -> None:
         "at K2.3")
 
 
+def _require_convex(solid: "Solid", what: str) -> None:
+    """Raise unless every vertex is on the inward side of every face plane.
+
+    The separating-plane predicates below are sound ONLY for a convex solid: a
+    convex body is the intersection of its face half-spaces, so "outside one
+    face plane" implies "outside the solid". For a non-convex solid that
+    implication fails — a bore sitting inside an L-bracket's arm is outside the
+    plane of the other arm's face — and accepting it would silently double-count
+    the overlap. Exact (rational comparisons); refuses rather than guesses."""
+    planes, verts = {}, set()
+    for p in solid.polys:
+        planes.setdefault(p.plane.canonical(), (p.plane.n, p.plane.d))
+        verts.update(p.verts)
+    for n, dpl in planes.values():
+        for v in verts:
+            if dot(n, v) - dpl > 0:
+                raise ValueError(
+                    f"{what} against a non-convex solid — the separating-plane "
+                    "test is not sound there; general quadric booleans arrive "
+                    "at K2.3")
+
+
 def _sphere_solid(s: "Sphere", solid: "Solid") -> None:
     """Disjoint/tangent iff the sphere center lies on the far side of (or
     exactly on) some face plane by at least the radius — exact, sqrt-free:
@@ -780,6 +942,7 @@ def _sphere_solid(s: "Sphere", solid: "Solid") -> None:
     g² ≥ r²·(n·n) (both sides squared, exact). Convex-solid sufficient
     condition; a sphere separated from a convex solid is separated by one
     of its face planes."""
+    _require_convex(solid, "sphere")
     c = (s.cx, s.cy, s.cz)
     seen = set()
     for p in solid.polys:
@@ -795,6 +958,35 @@ def _sphere_solid(s: "Sphere", solid: "Solid") -> None:
         "sphere overlaps the solid — general quadric booleans arrive at K2.3")
 
 
+def _cyl_solid(c: "Cyl", solid: "Solid") -> None:
+    """Disjoint/tangent iff some face plane of the solid separates the
+    z-cylinder — exact and sqrt-free. For outward plane n·x = d, the
+    cylinder's minimum of n·x is
+
+        n_x·cx + n_y·cy + min(n_z·z0, n_z·z1) − r·√(n_x² + n_y²),
+
+    so the cylinder is clear of that plane iff A ≥ r·√(n_x²+n_y²) where
+    A = n_x·cx + n_y·cy + min(n_z·z0, n_z·z1) − d. Both sides are squared
+    (A ≥ 0 and A² ≥ r²·(n_x²+n_y²)) to stay in ℚ. A mounting boss standing
+    ON a face gives A = 0 exactly — tangent, measure-zero, admitted.
+    Sufficient for a convex solid (separating-plane argument); for a
+    non-convex one it is conservative, so it refuses rather than guesses."""
+    _require_convex(solid, "cylinder")
+    seen = set()
+    for p in solid.polys:
+        key = p.plane.canonical()
+        if key in seen:
+            continue
+        seen.add(key)
+        n, dpl = p.plane.n, p.plane.d
+        a = (n[0] * c.cx + n[1] * c.cy
+             + min(n[2] * c.z0, n[2] * c.z1) - dpl)
+        if a >= 0 and a * a >= c.r * c.r * (n[0] * n[0] + n[1] * n[1]):
+            return                            # separated by this face plane
+    raise ValueError(
+        "cylinder overlaps the solid — general quadric booleans arrive at K2.3")
+
+
 class RoundedBox:
     """An axis-aligned box with ALL edges and corners filleted radius r —
     the Minkowski sum of the inner core box (a-2r)x(b-2r)x(c-2r) with a

{forgekernel-0.9.1 → forgekernel-0.9.4}/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.4/src/forgekernel.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: forgekernel
-Version: 0.9.1
+Version: 0.9.4
 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.4}/src/forgekernel.egg-info/SOURCES.txt

@@ -27,6 +27,7 @@ src/forgekernel.egg-info/SOURCES.txt
 src/forgekernel.egg-info/dependency_links.txt
 src/forgekernel.egg-info/requires.txt
 src/forgekernel.egg-info/top_level.txt
+tests/test_boss.py
 tests/test_hlr.py
 tests/test_k1_exact.py
 tests/test_k37_loft.py
@@ -39,5 +40,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.4/tests/test_boss.py

@@ -0,0 +1,134 @@
+"""Bosses and bored cylinders — a z-cylinder standing on a planar face
+(tangent, measure-zero) and coaxial bores through solids of revolution.
+
+A cylinder minus a coaxial bore is still a solid of revolution, so the result
+stays an exact ℚ[π] object rather than degrading to a mesh.
+"""
+
+from __future__ import annotations
+
+import math
+from collections import defaultdict
+
+import pytest
+
+from forgekernel.brep import Solid
+from forgekernel.quadric import Cyl, DisjointUnion, RevolveSolid, bore_cyl
+
+
+def _nonmanifold(mesh):
+    ec = defaultdict(int)
+    for a, b, c in mesh["triangles"]:
+        for e in ((a, b), (b, c), (c, a)):
+            ec[tuple(sorted(e))] += 1
+    return sum(1 for n in ec.values() if n != 2)
+
+
+def test_boss_standing_on_a_plate_is_a_tangent_union() -> None:
+    # the cylinder's base sits EXACTLY on the plate's top face: contact is
+    # measure-zero, so the union volume is exactly the sum.
+    plate = Solid.box(30, 30, 3)
+    boss = Cyl(15, 15, 4, 3, 9)
+    u = DisjointUnion([plate, boss])
+    assert float(u.volume()) == pytest.approx(30 * 30 * 3 + math.pi * 16 * 6)
+
+
+def test_boss_sunk_into_the_plate_is_refused() -> None:
+    plate = Solid.box(30, 30, 3)
+    with pytest.raises(ValueError, match="overlaps the solid"):
+        DisjointUnion([plate, Cyl(15, 15, 4, 2, 9)])     # base below the top face
+
+
+def test_cylinder_beside_the_plate_is_separated_by_a_side_face() -> None:
+    plate = Solid.box(10, 10, 10)
+    DisjointUnion([plate, Cyl(20, 5, 3, 0, 10)])         # clear in x: no raise
+
+
+def test_non_convex_solids_refuse_rather_than_double_count() -> None:
+    """SOUNDNESS: the separating-plane test only holds for a convex solid.
+
+    In an L-prism, a bore buried in one arm lies outside the plane of the
+    OTHER arm's face — so a plane-only test would call it disjoint and silently
+    add its volume twice. Both predicates must refuse instead."""
+    from forgekernel import kernel as fk
+    from forgekernel.quadric import Sphere
+
+    ell = fk.prism([(0, 0), (10, 0), (10, 4), (4, 4), (4, 10), (0, 10)], 5)
+    for buried in (Cyl(2, 7, 1, 1, 4), Sphere(2, 7, 2, 1)):
+        with pytest.raises(ValueError, match="non-convex"):
+            DisjointUnion([ell, buried])
+
+
+def test_a_bore_outside_the_footprint_is_not_a_phantom_hole() -> None:
+    """SOUNDNESS: "the bore crosses no lateral wall" does not mean "the bore is
+    inside" — a bore entirely OUTSIDE the footprint crosses nothing either. It
+    used to be recorded as a hole, silently deleting volume from a solid the
+    tool never touched (a Ø4 tool 40 mm away removed 125.66 mm³ from a box)."""
+    from forgekernel.quadric import DrilledSolid
+
+    box = Solid.box(10, 10, 10)
+    with pytest.raises(ValueError, match="misses the solid in xy"):
+        DrilledSolid(box, []).cut(Cyl(50, 50, 2, 0, 10))
+    inside = DrilledSolid(box, []).cut(Cyl(5, 5, 2, 0, 10))     # a real hole
+    assert float(inside.volume()) == pytest.approx(1000 - math.pi * 4 * 10)
+
+
+def test_cut_leaves_members_the_tool_misses_untouched() -> None:
+    # a post standing 50 mm clear of a plate; boring the POST must not shrink
+    # the plate (the tool never enters it in xy).
+    plate, post = Solid.box(100, 100, 10), Cyl(150, 50, 8, 0, 20)
+    out = DisjointUnion([plate, post]).cut(Cyl(150, 50, 4, 0, 20))
+    assert float(out.volume()) == pytest.approx(100000 + (64 - 16) * 20 * math.pi)
+
+
+def test_coaxial_bore_of_a_cylinder_is_an_exact_revolve() -> None:
+    cyl = Cyl(0, 0, 10, 0, 2)
+    washer = bore_cyl(cyl, Cyl(0, 0, 4, 0, 2))           # through bore: annulus
+    assert isinstance(washer, RevolveSolid)
+    assert float(washer.volume()) == pytest.approx(math.pi * (100 - 16) * 2)
+    mesh = washer.tessellate(0.05)
+    assert _nonmanifold(mesh) == 0                       # watertight tube
+
+    blind = bore_cyl(Cyl(0, 0, 4, 3, 9), Cyl(0, 0, 1, 4, 9))   # blind from top
+    assert float(blind.volume()) == pytest.approx(math.pi * 16 * 6 - math.pi * 1 * 5)
+
+    up = bore_cyl(Cyl(0, 0, 4, 0, 6), Cyl(0, 0, 1, -5, 2))     # blind from below
+    assert float(up.volume()) == pytest.approx(math.pi * 16 * 6 - math.pi * 1 * 2)
+
+
+def test_bore_that_misses_in_z_leaves_the_cylinder_unchanged() -> None:
+    cyl = Cyl(0, 0, 4, 0, 6)
+    assert bore_cyl(cyl, Cyl(0, 0, 1, 10, 12)) is cyl
+
+
+def test_non_representable_bores_refuse() -> None:
+    cyl = Cyl(0, 0, 4, 0, 6)
+    with pytest.raises(ValueError, match="not coaxial"):
+        bore_cyl(cyl, Cyl(1, 0, 1, 0, 6))
+    with pytest.raises(ValueError, match="not narrower"):
+        bore_cyl(cyl, Cyl(0, 0, 4, 0, 6))
+    with pytest.raises(ValueError, match="closed cavity"):
+        bore_cyl(cyl, Cyl(0, 0, 1, 2, 4))                # floats strictly inside
+
+
+def test_cut_distributes_over_a_disjoint_union() -> None:
+    # the boss + pilot: (plate ∪ boss) ∖ pilot, pilot blind in the boss only
+    plate = Solid.box(30, 30, 3)
+    u = DisjointUnion([plate, Cyl(15, 15, 4, 3, 9)])
+    out = u.cut(Cyl(15, 15, 1, 4, 9))
+    expect = 30 * 30 * 3 + math.pi * 16 * 6 - math.pi * 1 * 5
+    assert float(out.volume()) == pytest.approx(expect)
+    # the plate member is untouched (the tool misses it in z)
+    assert any(isinstance(m, Solid) for m in out.members)
+    assert _nonmanifold(out.tessellate(0.05)) == 0
+
+
+def test_revolve_solid_can_sit_off_axis() -> None:
+    loop = [(0, 0), (2, 0), (2, 5), (0, 5)]              # a plain cylinder r=2
+    at_origin, moved = RevolveSolid(loop), RevolveSolid(loop, 7, -3)
+    assert float(at_origin.volume()) == float(moved.volume())
+    assert moved.centroid_f()[0] == pytest.approx(7.0)
+    assert moved.centroid_f()[1] == pytest.approx(-3.0)
+    lo, hi = moved.bbox()
+    assert (lo[0], hi[0]) == pytest.approx((5.0, 9.0))
+    assert (lo[1], hi[1]) == pytest.approx((-5.0, -1.0))

{forgekernel-0.9.1 → forgekernel-0.9.4}/tests/test_k1_exact.py

@@ -270,11 +270,26 @@ def test_disjoint_in_z_passes_despite_close_axes() -> None:
     assert u.volume() == PiVal(0, 1000)
 
 
-def test_internally_tangent_cylinders_exact() -> None:
+def test_internally_tangent_cylinders_are_an_overlap_not_a_union() -> None:
+    """INTERNAL tangency of two SOLID cylinders is containment, not disjointness.
+
+    r=10 at the origin and r=4 at (6,0): d² = 36 = (10−4)², so they touch at
+    (10,0) — but the small cylinder lies wholly INSIDE the big one (its farthest
+    point is 6+4 = 10 = the big radius) and their z-ranges coincide. The union is
+    therefore just the big cylinder, 800π — NOT 928π. An earlier version of this
+    test asserted 928π, and that is what let ``_classify_pair`` admit nested
+    cylinders into a DisjointUnion and silently double-count the overlap. Only
+    EXTERNAL separation (d² ≥ (ra+rb)²) certifies disjointness.
+    """
+    import pytest
+
     from forgekernel.quadric import Cyl, DisjointUnion, PiVal
 
-    # r=10 and r=4, centers 6 apart: d^2 = 36 = (10-4)^2 internally tangent
-    u = DisjointUnion([Cyl.make(10, 8), Cyl.make(4, 8).translated(6, 0, 0)])
+    with pytest.raises(ValueError, match="overlapping cylinders"):
+        DisjointUnion([Cyl.make(10, 8), Cyl.make(4, 8).translated(6, 0, 0)])
+
+    # externally tangent (d² = (ra+rb)²) IS measure-zero contact: exact sum
+    u = DisjointUnion([Cyl.make(10, 8), Cyl.make(4, 8).translated(14, 0, 0)])
     assert u.volume() == PiVal(0, (100 + 16) * 8)
 
 

forgekernel-0.9.4/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