DEBUG: isolate Windows free-threaded special-value failures

Temporary branch: build only cp313 (GIL) + cp313t (free-threaded) on Windows
and run ci_debug/ft_repro.py under each to diff [GIL] vs [FT] output.
Not for merge.

Author: SwayamInSync

.github/workflows/debug_win_ft.yml

@@ -0,0 +1,65 @@
+# TEMPORARY debug workflow (branch debug/win-ft-isolation).
+#
+# Isolates the Windows free-threaded (cp313t) special-value failures seen on
+# PR #108's CI: build ONLY cp313 (GIL) and cp313t (free-threaded) on Windows and
+# run ci_debug/ft_repro.py under each, so we can diff the [GIL] vs [FT] output
+# and see exactly which quad operation diverges. Not for merge.
+name: Debug Windows FT
+
+on:
+  push:
+    branches:
+      - "debug/win-ft-isolation"
+  workflow_dispatch:
+
+jobs:
+  debug_windows_ft:
+    name: Debug Windows FT (cp313 vs cp313t)
+    runs-on: windows-latest
+    strategy:
+      matrix:
+        architecture: [x64]
+
+    steps:
+      - uses: actions/checkout@v6
+
+      - name: Setup MSVC
+        uses: ilammy/msvc-dev-cmd@v1
+        with:
+          arch: ${{ matrix.architecture }}
+
+      - name: Set up Python
+        uses: actions/setup-python@v6
+        with:
+          python-version: ">=3.11.0"
+          architecture: ${{ matrix.architecture }}
+
+      - name: Install CMake
+        uses: lukka/get-cmake@latest
+
+      - name: Install build dependencies
+        shell: bash -l {0}
+        run: |
+          pip install -U pip
+          pip install cibuildwheel==3.1.4 ninja meson meson-python numpy delvewheel pytest
+
+      - name: Build wheels and run FT probe (cp313, cp313t)
+        env:
+          # Only the two interpreters we need to compare -> much faster than the
+          # full matrix.
+          CIBW_BUILD: "cp313-* cp313t-*"
+          CIBW_ENABLE: cpython-prerelease cpython-freethreading
+          CIBW_ARCHS_WINDOWS: ${{ matrix.architecture == 'x86' && 'x86' || 'AMD64' }}
+          CIBW_BUILD_VERBOSITY: "3"
+          DISTUTILS_USE_SDK: "1"
+          MSSdk: "1"
+          CIBW_REPAIR_WHEEL_COMMAND: 'delvewheel repair -w {dest_dir} {wheel} --add-path C:\sleef\bin'
+          # Replace the usual pytest run with the targeted diagnostic. It prints
+          # the actual values and always exits 0, so BOTH wheels' output lands in
+          # the log for a direct [GIL] vs [FT] comparison.
+          CIBW_TEST_COMMAND_WINDOWS: pip install numpy && pip install --no-deps {wheel} && python {project}/ci_debug/ft_repro.py
+          CIBW_TEST_EXTRAS: test
+        shell: pwsh
+        run: |
+          python -m cibuildwheel --output-dir wheelhouse
+          if (-not (Test-Path wheelhouse/*.whl)) { throw "Wheel was not created" }

ci_debug/ft_repro.py

@@ -0,0 +1,86 @@
+"""Windows free-threaded isolation probe for numpy-quaddtype.
+
+Prints the ACTUAL computed values for the operations that fail on the Windows
+cp313t (free-threaded) wheel but pass on cp313 (GIL) and on Linux/macOS. Run the
+SAME script under both interpreters and diff the ``[GIL]`` vs ``[FT]`` blocks to
+see exactly what diverges.
+
+This is a diagnostic, not a gate: it never raises to the shell (always exits 0),
+so both wheels' output is captured in the CI log.
+"""
+import sys
+
+import numpy as np
+import numpy_quaddtype as nq
+from numpy_quaddtype import QuadPrecision as Q
+
+
+def gil_enabled():
+    f = getattr(sys, "_is_gil_enabled", None)
+    return bool(f()) if f is not None else True
+
+
+def fval(x):
+    try:
+        return float(x)
+    except Exception as e:  # noqa: BLE001
+        return "<err %s>" % type(e).__name__
+
+
+def bits(q):
+    try:
+        return q.__reduce__()[1][0].hex()
+    except Exception:  # noqa: BLE001
+        return "?"
+
+
+def run(label, fn):
+    try:
+        print("  %-46s -> %s" % (label, fn()))
+    except Exception as e:  # noqa: BLE001
+        print("  %-46s -> ERROR %s: %s" % (label, type(e).__name__, e))
+
+
+TAG = "FT" if not gil_enabled() else "GIL"
+
+print("\n########## quaddtype win-ft probe [%s] ##########" % TAG)
+print("python    : %s  gil_enabled=%s" % (sys.version.split()[0], gil_enabled()))
+print("numpy     : %s" % np.__version__)
+print("quaddtype : %s" % getattr(nq, "__version__", "?"))
+run("is_longdouble_128", nq.is_longdouble_128)
+
+print("[%s] string -> quad (special values + a couple normals):" % TAG)
+for s in ["inf", "-inf", "nan", "-nan", "Infinity", "1.5", "0.1"]:
+    run("Q(%r)" % s, lambda s=s: "float=%s bits=%s" % (fval(Q(s)), bits(Q(s))))
+
+print("[%s] float() cast of constructed specials:" % TAG)
+run("float(Q('inf'))", lambda: fval(Q("inf")))
+run("np.isinf(float(Q('inf')))", lambda: np.isinf(fval(Q("inf"))))
+run("np.isnan(float(Q('nan')))", lambda: np.isnan(fval(Q("nan"))))
+
+print("[%s] frexp (quad mantissa/exp  vs  numpy float64):" % TAG)
+for v in ["0.1", "0.9", "1.5", "inf", "nan"]:
+    def _fx(v=v):
+        q = Q(v)
+        qm, qe = np.frexp(q)
+        fm, fe = np.frexp(np.float64(fval(q)))
+        return "quad=(%s, %s)  np=(%s, %s)" % (fval(qm), qe, fm, fe)
+    run("frexp(Q(%s))" % v, _fx)
+
+print("[%s] ldexp overflow (expect inf):" % TAG)
+for base, e in [("1.5", 16384), ("2.0", 20000)]:
+    run("ldexp(Q(%s), %d)" % (base, e),
+        lambda base=base, e=e: fval(np.ldexp(Q(base), e)))
+
+print("[%s] modf:" % TAG)
+run("modf(Q('-0.001'))",
+    lambda: tuple(fval(x) for x in np.modf(Q("-0.001"))))
+
+print("[%s] matmul special (Windows uses the naive kernel; QBLAS disabled):" % TAG)
+def _mm():
+    A = np.array([[Q("inf"), Q("1")], [Q("2"), Q("3")]])
+    Im = np.array([[Q("1"), Q("0")], [Q("0"), Q("1")]])
+    return fval(np.matmul(A, Im)[0, 0])
+run("matmul(inf-matrix, I)[0,0]", _mm)
+
+print("########## end probe [%s] ##########\n" % TAG)