openscad-cpp-evaluator 0.52.0__tar.gz → 0.53.0__tar.gz

{openscad_cpp_evaluator-0.52.0 → openscad_cpp_evaluator-0.53.0}/CLAUDE.md

@@ -577,6 +577,17 @@ grep for `ponytail:`.
   profiled is BOSL2's **argument type-checking**: 25–45%, millions of
   `is_finite`/`is_num`/`is_nan` calls.
 
+- **Degree trigonometry is a direct port of OpenSCAD's `src/utils/degree_trig.cc`**
+  (`sinDegrees`/`cosDegrees`/`tanDegrees` and the inverses, `builtins/function_builtins.cpp`), not
+  `std::sin(x * pi / 180)`. The structure is load-bearing: exact values at 30/45/60, the >45 range
+  computed through the COMPLEMENT function, and OpenSCAD's own literal `M_DEG2RAD` constant rather
+  than `pi / 180.0` (which rounds differently). That is what makes `sin(45) == cos(45)` and
+  `cos(30) == sqrt(3)/2` hold EXACTLY, and the exactness matters to real libraries: BOSL2's
+  `rect(rounding=...)` filters corner intersections with an exact `isect != seg[0]`, so one ULP of
+  drift made a shared vertex compare unequal, kept two corner points instead of one, and killed
+  `rect()` on its own `assert(len(cornerpt)==1, "Cannot find corner point to anchor")`. The
+  inverses also snap to a whole number of degrees when the forward function reproduces the input
+  exactly, so `asin(sin(30))` is `30`. Pinned by `DegreeTrig.*` in `tests/test_function_builtins.cpp`.
 - `include/openscad_cpp_evaluator/value.hpp`, `src/value.cpp` — the `Value` variant (OpenSCAD's
   dynamic value type) and its free-function arithmetic/comparison helpers. See the plan's §1 for
   the type-mapping table and why there's no numpy-equivalent library.
@@ -644,6 +655,16 @@ grep for `ponytail:`.
   accordingly; read its doc comment before touching it, it's the second-trickiest mechanism in this
   codebase after the CSG tree stack), `evalUserModule`/`evalUserFunction`/`evalFunctionLiteral`,
   and `builtinChildren` (children()/children(N), deferred evaluation).
+  **A function literal declared in a MODULE body captures that body's bindings**, its own
+  parameters included, and keeps them when it escapes (passed to another module and called there).
+  The interpreter gets this for free — it captures `ctx.let_` wholesale. The VM snapshots only the
+  names it can resolve, and inside a module body it can resolve NONE: module parameters are bound
+  natively into `ctx.let_` rather than slot-addressed, and a module chunk compiles with no
+  enclosing level. So such a literal used to be frozen as a captureless constant whose free names
+  resolved against whatever ctx CALLED it — silently `undef`, which is how BOSL2's
+  `attachable(override=function(anchor) ...)` broke. `ClosureSite::captureDefiningLet` (set
+  whenever the literal's body still contains `Op::LoadFree`) makes `Op::MakeClosure` root the
+  captured trail at the DEFINING `ctx.let_`. Pinned by `EscapingClosure.*` under both engines.
   **`children(..., separate=true)`** is a BelfrySCAD extension handled *before* any of that, by
   `expandChildStatements`: a block is read with each separating forward replaced by one synthetic
   `children(k)` statement per child it selects (`makeChildrenIndexCall`, owned by

{openscad_cpp_evaluator-0.52.0 → openscad_cpp_evaluator-0.53.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: openscad_cpp_evaluator
-Version: 0.52.0
+Version: 0.53.0
 Summary: C++ OpenSCAD evaluator with Python bindings
 Author: NeuSCAD Contributors
 License-Expression: MIT

{openscad_cpp_evaluator-0.52.0 → openscad_cpp_evaluator-0.53.0}/include/openscad_cpp_evaluator/bytecode.hpp

@@ -845,6 +845,21 @@ struct CompiledChunk {
     struct ClosureSite {
         const oscad::FunctionLiteral* node = nullptr;
         std::vector<UpvalueRef> captures;
+        // True when the literal's body still contains Op::LoadFree -- a name
+        // the compiler could not resolve to a slot or an upvalue. Such a
+        // closure is NOT self-contained: LoadFree resolves against whatever
+        // ctx is current when the closure is CALLED, so if it escapes the
+        // scope that defined it, those names silently resolve to the
+        // caller's bindings (or to undef).
+        //
+        // That is exactly what happens to a function literal declared in a
+        // MODULE body: module parameters are bound natively into ctx.let_
+        // rather than slot-addressed, and a module chunk is compiled with no
+        // enclosing level, so the compiler can resolve none of them. With
+        // this set, Op::MakeClosure roots the captured trail at the DEFINING
+        // ctx.let_ -- which is what the interpreter has always done
+        // unconditionally (see the FunctionLiteral case in expr_eval.cpp).
+        bool captureDefiningLet = false;
     };
 
     // One echo() expression form's own argument names, in source order --

{openscad_cpp_evaluator-0.52.0 → openscad_cpp_evaluator-0.53.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "scikit_build_core.build"
 
 [project]
 name = "openscad_cpp_evaluator"
-version = "0.52.0"
+version = "0.53.0"
 description = "C++ OpenSCAD evaluator with Python bindings"
 readme = "README.md"
 requires-python = ">=3.12"

{openscad_cpp_evaluator-0.52.0 → openscad_cpp_evaluator-0.53.0}/src/builtins/function_builtins.cpp

@@ -55,28 +55,141 @@ Value numList(const std::vector<double>& xs) {
     return listOf(std::move(items));
 }
 
-double degrees(double rad) { return rad * 180.0 / std::numbers::pi; }
-double radians(double deg) { return deg * std::numbers::pi / 180.0; }
-
-// At exact multiples of 90 degrees, sin/cos/tan use exact table values
-// instead of sin/cos/tan(radians(x)), which accumulate floating-point
-// noise (cos(90) -> 6.12e-17 etc) -- matches real OpenSCAD's degree-based
-// trig. Mirrors _deg_trig.
-constexpr std::array<double, 4> kSin90 = {0.0, 1.0, 0.0, -1.0};
-constexpr std::array<double, 4> kCos90 = {1.0, 0.0, -1.0, 0.0};
-const std::array<double, 4> kTan90 = {0.0, std::numeric_limits<double>::infinity(), 0.0,
-                                       -std::numeric_limits<double>::infinity()};
-
-double degTrig(double x, const std::array<double, 4>& table, double (*fallback)(double)) {
-    if (std::isnan(x) || std::isinf(x)) return std::numeric_limits<double>::quiet_NaN();
-    const double n = x / 90.0;
-    const double rn = std::round(n);
-    if (rn == n) {
-        int idx = static_cast<int>(rn) % 4;
-        if (idx < 0) idx += 4;
-        return table[static_cast<size_t>(idx)];
+// Degree trigonometry, a direct port of real OpenSCAD's
+// src/utils/degree_trig.cc. Not `std::sin(x * pi / 180)`: that is off by an
+// ULP from OpenSCAD for most angles, and OpenSCAD's own extra structure --
+// exact values at 30/45/60, and computing the >45 range through the
+// COMPLEMENT function -- is what makes identities like sin(45) == cos(45)
+// and cos(30) == sqrt(3)/2 hold EXACTLY there.
+//
+// That exactness is load-bearing for real libraries, not cosmetic. BOSL2's
+// rect(rounding=...) builds a corner arc and then filters intersections
+// with `isect != seg[0]`, an exact float comparison. One ULP of drift makes
+// the shared vertex of two adjacent segments compare unequal, the filter
+// keeps two corner points instead of one, and rect() dies on its own
+// `assert(len(cornerpt)==1, "Cannot find corner point to anchor")`.
+//
+// The constants are OpenSCAD's own literals, deliberately -- M_DEG2RAD as a
+// single pre-rounded double is not bitwise identical to `pi / 180.0`.
+constexpr double kSqrt3 = 1.73205080756887719318;    // sqrt(3)
+constexpr double kSqrt3_4 = 0.86602540378443859659;  // sqrt(3/4) == sqrt(3)/2
+constexpr double kSqrt1_3 = 0.57735026918962573106;  // sqrt(1/3) == sqrt(3)/3
+constexpr double kSqrt1_2 = 0.70710678118654752440;  // sqrt(1/2)
+constexpr double kRad2Deg = 57.2957795130823208767;  // 180/PI
+constexpr double kDeg2Rad = 0.017453292519943295769; // PI/180
+
+// Assumes a 26+26=52-bit mantissa; beyond it, reduction loses all accuracy
+// and OpenSCAD returns NaN rather than a meaningless answer.
+constexpr double kTrigHugeVal = (1L << 26) * 360.0 * (1L << 26);
+
+double degrees(double rad) { return rad * kRad2Deg; }
+double radians(double deg) { return deg * kDeg2Rad; }
+
+double sinDegrees(double x) {
+    // Positive tests, so Inf/NaN fall through to the domain check.
+    if (x < 360.0 && x >= 0.0) {
+        // already reduced
+    } else if (x < kTrigHugeVal && x > -kTrigHugeVal) {
+        x -= 360.0 * std::floor(x / 360.0);
+    } else {
+        return std::numeric_limits<double>::quiet_NaN();
+    }
+    bool oppose = x >= 180.0;
+    if (oppose) x -= 180.0;
+    if (x > 90.0) x = 180.0 - x;
+    if (x < 45.0) {
+        x = (x == 30.0) ? 0.5 : std::sin(radians(x));
+    } else if (x == 45.0) {
+        x = kSqrt1_2;
+    } else if (x == 60.0) {
+        x = kSqrt3_4;
+    } else { // Inf/NaN would fall here
+        x = std::cos(radians(90.0 - x));
+    }
+    return oppose ? -x : x;
+}
+
+double cosDegrees(double x) {
+    if (x < 360.0 && x >= 0.0) {
+        // already reduced
+    } else if (x < kTrigHugeVal && x > -kTrigHugeVal) {
+        x -= 360.0 * std::floor(x / 360.0);
+    } else {
+        return std::numeric_limits<double>::quiet_NaN();
+    }
+    bool oppose = x >= 180.0;
+    if (oppose) x -= 180.0;
+    if (x > 90.0) {
+        x = 180.0 - x;
+        oppose = !oppose;
+    }
+    if (x > 45.0) {
+        x = (x == 60.0) ? 0.5 : std::sin(radians(90.0 - x));
+    } else if (x == 45.0) {
+        x = kSqrt1_2;
+    } else if (x == 30.0) {
+        x = kSqrt3_4;
+    } else { // Inf/NaN would fall here
+        x = std::cos(radians(x));
+    }
+    return oppose ? -x : x;
+}
+
+double tanDegrees(double x) {
+    const double cycles = std::floor(x / 180.0);
+    if (x < 180.0 && x >= 0.0) {
+        // already reduced
+    } else if (x < kTrigHugeVal && x > -kTrigHugeVal) {
+        x -= 180.0 * cycles;
+    } else {
+        return std::numeric_limits<double>::quiet_NaN();
+    }
+    const bool evenCycle = std::fmod(cycles, 2.0) == 0.0;
+    bool oppose = x > 90.0;
+    if (oppose) x = 180.0 - x;
+    if (x == 0.0) {
+        x = evenCycle ? 0.0 : -0.0;
+    } else if (x == 30.0) {
+        x = kSqrt1_3;
+    } else if (x == 45.0) {
+        x = 1.0;
+    } else if (x == 60.0) {
+        x = kSqrt3;
+    } else if (x == 90.0) {
+        x = evenCycle ? std::numeric_limits<double>::infinity()
+                      : -std::numeric_limits<double>::infinity();
+    } else {
+        x = std::tan(radians(x));
     }
-    return fallback(radians(x));
+    return oppose ? -x : x;
+}
+
+// The inverses snap to a whole number of degrees whenever the forward
+// function reproduces the input exactly, so asin(sin(30)) is 30 and not
+// 29.999999999999996.
+double asinDegrees(double x) {
+    const double degs = degrees(std::asin(x));
+    const double whole = std::round(degs);
+    return sinDegrees(whole) == x ? whole : degs;
+}
+
+double acosDegrees(double x) {
+    const double degs = degrees(std::acos(x));
+    const double whole = std::round(degs);
+    return cosDegrees(whole) == x ? whole : degs;
+}
+
+double atanDegrees(double x) {
+    const double degs = degrees(std::atan(x));
+    const double whole = std::round(degs);
+    return tanDegrees(whole) == x ? whole : degs;
+}
+
+// atan2 snaps on a tolerance rather than a round-trip: OpenSCAD's own rule.
+double atan2Degrees(double y, double x) {
+    const double degs = degrees(std::atan2(y, x));
+    const double whole = std::round(degs);
+    return std::fabs(degs - whole) < 3.0E-14 ? whole : degs;
 }
 
 // UTF-8 encode/decode for chr()/ord() -- OpenSCAD strings are unicode text,
@@ -1183,20 +1296,21 @@ Value evalBuiltinFunction(Evaluator& ev, const std::string& name, const CallArgs
             return Value{x < 0 ? std::numeric_limits<double>::quiet_NaN() : std::log10(x)};
         }
         case BuiltinFnId::Exp: return Value{std::exp(toDoubleLenient(getArg(args, 0, "x", Value{})))};
-        case BuiltinFnId::Sin: return Value{degTrig(toDoubleLenient(getArg(args, 0, "x", Value{})), kSin90, &std::sin)};
-        case BuiltinFnId::Cos: return Value{degTrig(toDoubleLenient(getArg(args, 0, "x", Value{})), kCos90, &std::cos)};
-        case BuiltinFnId::Tan: return Value{degTrig(toDoubleLenient(getArg(args, 0, "x", Value{})), kTan90, &std::tan)};
+        case BuiltinFnId::Sin: return Value{sinDegrees(toDoubleLenient(getArg(args, 0, "x", Value{})))};
+        case BuiltinFnId::Cos: return Value{cosDegrees(toDoubleLenient(getArg(args, 0, "x", Value{})))};
+        case BuiltinFnId::Tan: return Value{tanDegrees(toDoubleLenient(getArg(args, 0, "x", Value{})))};
         case BuiltinFnId::Asin: {
             const double x = toDoubleLenient(getArg(args, 0, "x", Value{}));
-            return Value{std::fabs(x) > 1 ? std::numeric_limits<double>::quiet_NaN() : degrees(std::asin(x))};
+            return Value{std::fabs(x) > 1 ? std::numeric_limits<double>::quiet_NaN() : asinDegrees(x)};
         }
         case BuiltinFnId::Acos: {
             const double x = toDoubleLenient(getArg(args, 0, "x", Value{}));
-            return Value{std::fabs(x) > 1 ? std::numeric_limits<double>::quiet_NaN() : degrees(std::acos(x))};
+            return Value{std::fabs(x) > 1 ? std::numeric_limits<double>::quiet_NaN() : acosDegrees(x)};
         }
-        case BuiltinFnId::Atan: return Value{degrees(std::atan(toDoubleLenient(getArg(args, 0, "x", Value{}))))};
+        case BuiltinFnId::Atan: return Value{atanDegrees(toDoubleLenient(getArg(args, 0, "x", Value{})))};
         case BuiltinFnId::Atan2:
-            return Value{degrees(std::atan2(toDoubleLenient(getArg(args, 0, "y", Value{})), toDoubleLenient(getArg(args, 1, "x", Value{}))))};
+            return Value{atan2Degrees(toDoubleLenient(getArg(args, 0, "y", Value{})),
+                                       toDoubleLenient(getArg(args, 1, "x", Value{})))};
         case BuiltinFnId::Max: return builtinMinMax(args, true);
         case BuiltinFnId::Min: return builtinMinMax(args, false);
         case BuiltinFnId::Pow: return builtinPow(toDoubleLenient(getArg(args, 0, "x", Value{})), toDoubleLenient(getArg(args, 1, "y", Value{})));

{openscad_cpp_evaluator-0.52.0 → openscad_cpp_evaluator-0.53.0}/src/bytecode_compiler.cpp

@@ -447,10 +447,12 @@ public:
                 // `ctx.let_`, which callCtxFor roots at this exact closure's
                 // own capturedLet snapshot whenever it's invoked -- the same
                 // snapshot `effectiveCaptures` describes below.
-                if (effectiveCaptures.empty() || !containsLoadFree(literalChunk)) {
+                // Must be read BEFORE literalChunk is moved from below.
+                const bool needsDefiningLet = containsLoadFree(literalChunk);
+                if (effectiveCaptures.empty() || !needsDefiningLet) {
                     chunk_.nestedLiterals.emplace_back(&n, std::move(literalChunk));
                 }
-                if (effectiveCaptures.empty()) {
+                if (effectiveCaptures.empty() && !needsDefiningLet) {
                     // Closes over nothing at all, even transitively -- a
                     // single frozen constant works for every invocation, no
                     // per-call snapshot needed.
@@ -461,7 +463,8 @@ public:
                 }
                 // Escaping-closure support (Op::MakeClosure, bytecode.hpp).
                 int siteIdx = static_cast<int>(chunk_.closureSites.size());
-                chunk_.closureSites.push_back(CompiledChunk::ClosureSite{&n, std::move(effectiveCaptures)});
+                chunk_.closureSites.push_back(
+                    CompiledChunk::ClosureSite{&n, std::move(effectiveCaptures), needsDefiningLet});
                 out.push_back({Op::MakeClosure, siteIdx, 0, nullptr});
                 return;
             }

{openscad_cpp_evaluator-0.52.0 → openscad_cpp_evaluator-0.53.0}/src/bytecode_vm.cpp

@@ -599,7 +599,15 @@ Value driveVm(Evaluator& ev, size_t floor) {
                 }
                 case Op::MakeClosure: {
                     const CompiledChunk::ClosureSite& site = f.chunk->closureSites[static_cast<size_t>(ins.a)];
-                    auto capturedTrail = TrailView<Value>::makeRoot();
+                    // A child of the DEFINING ctx.let_ when the body still
+                    // has unresolved names (see ClosureSite::
+                    // captureDefiningLet), so they resolve where the closure
+                    // was written rather than wherever it is later called.
+                    // openChild, not ctx.let_ itself: the explicit captures
+                    // below are layered on top and must not leak back into
+                    // the defining scope.
+                    auto capturedTrail = site.captureDefiningLet ? ctx.let_->openChild(/*isolate=*/false)
+                                                                  : TrailView<Value>::makeRoot();
                     std::vector<const std::string*> selfNames;
                     for (const auto& cap : site.captures) {
                         if (cap.isSelfReference) {

{openscad_cpp_evaluator-0.52.0 → openscad_cpp_evaluator-0.53.0}/tests/test_control_flow.cpp

@@ -348,6 +348,84 @@ TEST(OperatorBlockScope, BlockAssignmentCannotFeedBackIntoArgumentsInterpreted)
 TEST(OperatorBlockScope, UserModuleChildBlockIsItsOwnScopeCompiled) { checkUserModuleChildBlockIsItsOwnScope(true); }
 TEST(OperatorBlockScope, UserModuleChildBlockIsItsOwnScopeInterpreted) { checkUserModuleChildBlockIsItsOwnScope(false); }
 
+// A function literal declared in a MODULE body captures that body's
+// bindings, including the module's own parameters, and keeps them when it
+// escapes -- passed to another module and called there.
+//
+// The interpreter always did this (it captures ctx.let_ wholesale). The VM
+// tries to snapshot only the names it can resolve, and inside a module body
+// it can resolve none: module parameters are bound natively into ctx.let_
+// rather than slot-addressed, and a module chunk compiles with no enclosing
+// level. So the literal was frozen as a captureless constant and its free
+// names resolved against whatever ctx CALLED it -- silently undef.
+//
+// Verified against real OpenSCAD 2026.02.01: every case below echoes 20.
+
+namespace {
+
+void checkEscapingClosureKeepsItsDefiningScope(bool useVm, const std::string& body) {
+    ScopedVm vm(useVm);
+    std::vector<std::string> echoed;
+    runScript(body, [&](const std::string& msg) { echoed.push_back(msg); });
+    EXPECT_EQ(echoed, (std::vector<std::string>{"ECHO: r = 20"})) << "in: " << body;
+}
+
+} // namespace
+
+TEST(EscapingClosure, CapturesModuleParameterCompiled) {
+    checkEscapingClosureKeepsItsDefiningScope(true,
+        "module callee(fn) { echo(r = fn(2)); }\n"
+        "module caller(s=100) { f = function (x) s / 8 * x; callee(f); }\n"
+        "caller(80);\n");
+}
+TEST(EscapingClosure, CapturesModuleParameterInterpreted) {
+    checkEscapingClosureKeepsItsDefiningScope(false,
+        "module callee(fn) { echo(r = fn(2)); }\n"
+        "module caller(s=100) { f = function (x) s / 8 * x; callee(f); }\n"
+        "caller(80);\n");
+}
+
+// BOSL2's attachable(override=...) shape: the closure travels inside a list.
+TEST(EscapingClosure, SurvivesInsideAListCompiled) {
+    checkEscapingClosureKeepsItsDefiningScope(true,
+        "module callee(spec) { echo(r = spec[0](2)); }\n"
+        "module caller(s=100) { f = function (x) s / 8 * x; callee([f]); }\n"
+        "caller(80);\n");
+}
+TEST(EscapingClosure, SurvivesInsideAListInterpreted) {
+    checkEscapingClosureKeepsItsDefiningScope(false,
+        "module callee(spec) { echo(r = spec[0](2)); }\n"
+        "module caller(s=100) { f = function (x) s / 8 * x; callee([f]); }\n"
+        "caller(80);\n");
+}
+
+// The callee has its OWN `s`. The closure must still see the one it was
+// written next to -- this is what proves it captures rather than merely
+// resolving late.
+TEST(EscapingClosure, IsNotCapturedByTheCallersOwnBindingCompiled) {
+    checkEscapingClosureKeepsItsDefiningScope(true,
+        "module callee(fn, s=999) { echo(r = fn(2)); }\n"
+        "module caller(s=100) { f = function (x) s / 8 * x; callee(f); }\n"
+        "caller(80);\n");
+}
+TEST(EscapingClosure, IsNotCapturedByTheCallersOwnBindingInterpreted) {
+    checkEscapingClosureKeepsItsDefiningScope(false,
+        "module callee(fn, s=999) { echo(r = fn(2)); }\n"
+        "module caller(s=100) { f = function (x) s / 8 * x; callee(f); }\n"
+        "caller(80);\n");
+}
+
+// A literal closing over nothing keeps the cheap frozen-constant path.
+TEST(EscapingClosure, CapturelessLiteralStillWorksCompiled) {
+    ScopedVm vm(true);
+    std::vector<std::string> echoed;
+    runScript("module callee(fn) { echo(r = fn(4)); }\n"
+              "module caller() { callee(function (x) x * 5); }\n"
+              "caller();\n",
+              [&](const std::string& msg) { echoed.push_back(msg); });
+    EXPECT_EQ(echoed, (std::vector<std::string>{"ECHO: r = 20"}));
+}
+
 // -- let (statement + expression forms) --------------------------------
 
 TEST(LetStatement, BindsVisibleInsideBlockOnly) {

{openscad_cpp_evaluator-0.52.0 → openscad_cpp_evaluator-0.53.0}/tests/test_function_builtins.cpp

@@ -897,3 +897,71 @@ TEST(LinearSolve, AnExplicitlyUndefRightHandSideCountsAsAbsent) {
     EXPECT_TRUE(isUndef(evalSrc("linear_solve([[2,1],[1,3]], undef).x", ev)));
     EXPECT_TRUE(builtinWarnings("linear_solve([[2,1],[1,3]], undef)").empty());
 }
+
+
+// -- degree trig is bit-exact, not merely close ---------------------------
+//
+// A direct port of real OpenSCAD's src/utils/degree_trig.cc, and these
+// identities are the reason. `std::sin(x * pi / 180)` gets them wrong by an
+// ULP, and that is enough to break real libraries: BOSL2's
+// rect(rounding=...) filters corner intersections with an exact `!=`
+// comparison, so one ULP of drift makes it find two corner points instead
+// of one and die on its own "Cannot find corner point to anchor" assert.
+//
+// Every expectation below was read off OpenSCAD 2026.02.01.
+
+TEST(DegreeTrig, SinAndCosAgreeExactlyAt45) {
+    Evaluator ev;
+    EXPECT_EQ(asNum(evalSrc("sin(45) - cos(45)", ev)), 0.0);
+}
+
+TEST(DegreeTrig, ExactAtThirtyAndSixty) {
+    Evaluator ev;
+    EXPECT_EQ(asNum(evalSrc("sin(30)", ev)), 0.5);
+    EXPECT_EQ(asNum(evalSrc("cos(60)", ev)), 0.5);
+    // cos(30) == sqrt(3)/2 exactly, and sin(60) likewise.
+    EXPECT_EQ(asNum(evalSrc("cos(30) - sqrt(3)/2", ev)), 0.0);
+    EXPECT_EQ(asNum(evalSrc("sin(60) - sqrt(3)/2", ev)), 0.0);
+}
+
+TEST(DegreeTrig, ScalingKeepsTheIdentity) {
+    // The exact form the BOSL2 failure took: polar_to_xy(10, 45).
+    Evaluator ev;
+    EXPECT_EQ(asNum(evalSrc("10*cos(45) - 10*sin(45)", ev)), 0.0);
+}
+
+TEST(DegreeTrig, ExactAtMultiplesOfNinety) {
+    Evaluator ev;
+    EXPECT_EQ(asNum(evalSrc("sin(90)", ev)), 1.0);
+    EXPECT_EQ(asNum(evalSrc("cos(90)", ev)), 0.0);
+    EXPECT_EQ(asNum(evalSrc("sin(180)", ev)), 0.0);
+    EXPECT_EQ(asNum(evalSrc("cos(180)", ev)), -1.0);
+    EXPECT_EQ(asNum(evalSrc("sin(-90)", ev)), -1.0);
+}
+
+TEST(DegreeTrig, TanExactValues) {
+    Evaluator ev;
+    EXPECT_EQ(asNum(evalSrc("tan(45)", ev)), 1.0);
+    EXPECT_EQ(asNum(evalSrc("tan(0)", ev)), 0.0);
+    EXPECT_TRUE(std::isinf(asNum(evalSrc("tan(90)", ev))));
+}
+
+TEST(DegreeTrig, InversesSnapToWholeDegrees) {
+    // asin/acos/atan return a whole number of degrees whenever the forward
+    // function reproduces the input exactly -- so this is 30, not
+    // 29.999999999999996.
+    Evaluator ev;
+    EXPECT_EQ(asNum(evalSrc("asin(sin(30))", ev)), 30.0);
+    EXPECT_EQ(asNum(evalSrc("acos(cos(60))", ev)), 60.0);
+    EXPECT_EQ(asNum(evalSrc("atan(tan(45))", ev)), 45.0);
+    EXPECT_EQ(asNum(evalSrc("atan2(1, 1)", ev)), 45.0);
+    EXPECT_EQ(asNum(evalSrc("atan2(1, 0)", ev)), 90.0);
+}
+
+TEST(DegreeTrig, HugeAnglesAreNaNNotMeaningless) {
+    // Beyond a 52-bit mantissa's reduction range OpenSCAD returns NaN
+    // rather than a meaningless answer; matched deliberately.
+    Evaluator ev;
+    EXPECT_TRUE(std::isnan(asNum(evalSrc("sin(1e30)", ev))));
+    EXPECT_TRUE(std::isnan(asNum(evalSrc("cos(1e30)", ev))));
+}