feat: integrate SimpleCADAPI 2.0.2 CAD workflows

SimpleCADAPI/tools/scene_contract_fixtures/numeric_cases.py

@@ -0,0 +1,128 @@
+"""Numeric profile fixture vector construction."""
+
+from __future__ import annotations
+
+import struct
+
+from simplecadapi.scene import (
+    profile_cross,
+    profile_f32_bits,
+    profile_normalize,
+)
+
+
+def _f64_from_bits(value: str) -> float:
+    return struct.unpack(">d", bytes.fromhex(value))[0]
+
+
+def _f64_bits(value: float) -> str:
+    return struct.pack(">d", value).hex()
+
+
+def build_numeric_vectors() -> list[dict[str, object]]:
+    vectors: list[dict[str, object]] = []
+    for name, input_bits in (
+        ("positive_zero", "0000000000000000"),
+        ("negative_zero", "8000000000000000"),
+        ("smallest_binary64_subnormal", "0000000000000001"),
+        ("negative_smallest_binary64_subnormal", "8000000000000001"),
+        ("binary32_smallest_subnormal", "36a0000000000000"),
+        ("halfway_tie_to_even", "3ff0000010000000"),
+        ("just_above_halfway", "3ff0000010000001"),
+        ("binary32_largest_finite", "47efffffe0000000"),
+    ):
+        expected = profile_f32_bits(_f64_from_bits(input_bits))
+        vectors.append(
+            {
+                "expected_bits": f"{expected:08x}",
+                "input_bits": [input_bits],
+                "name": name,
+                "operation": "f32",
+                "valid": True,
+            }
+        )
+    for name, input_bits in (
+        ("positive_overflow", "7fefffffffffffff"),
+        ("negative_overflow", "ffefffffffffffff"),
+        ("positive_infinity", "7ff0000000000000"),
+        ("quiet_nan", "7ff8000000000000"),
+    ):
+        try:
+            profile_f32_bits(_f64_from_bits(input_bits))
+        except ValueError as exc:
+            error = str(exc)
+        else:
+            raise AssertionError(name)
+        vectors.append(
+            {
+                "error": error,
+                "input_bits": [input_bits],
+                "name": name,
+                "operation": "f32",
+                "valid": False,
+            }
+        )
+
+    cross_inputs = (
+        ("basis_cross", (1.0, 0.0, 0.0), (0.0, 1.0, 0.0)),
+        (
+            "cancellation_cross",
+            (134217729.0, 134217728.0, 0.0),
+            (134217728.0, 134217727.0, 0.0),
+        ),
+    )
+    for name, left, right in cross_inputs:
+        result = profile_cross(left, right)
+        vectors.append(
+            {
+                "expected_bits": [_f64_bits(component) for component in result],
+                "input_bits": [
+                    [_f64_bits(component) for component in left],
+                    [_f64_bits(component) for component in right],
+                ],
+                "name": name,
+                "operation": "cross",
+                "valid": True,
+            }
+        )
+
+    normalize_inputs = (
+        ("normalize_3_4_0", (3.0, 4.0, -0.0)),
+        ("normalize_equal_components", (1.0, 1.0, 1.0)),
+    )
+    for name, value in normalize_inputs:
+        result = profile_normalize(value)
+        vectors.append(
+            {
+                "expected_bits": [
+                    f"{profile_f32_bits(component):08x}" for component in result
+                ],
+                "input_bits": [[_f64_bits(component) for component in value]],
+                "name": name,
+                "operation": "normalize",
+                "valid": True,
+            }
+        )
+    for name, value in (
+        ("normalize_zero", (0.0, 0.0, 0.0)),
+        (
+            "normalize_overflow",
+            (_f64_from_bits("7fefffffffffffff"), 1.0, 0.0),
+        ),
+    ):
+        try:
+            profile_normalize(value)
+        except ValueError as exc:
+            error = str(exc)
+        else:
+            raise AssertionError(name)
+        vectors.append(
+            {
+                "error": error,
+                "input_bits": [[_f64_bits(component) for component in value]],
+                "name": name,
+                "operation": "normalize",
+                "valid": False,
+            }
+        )
+    return vectors