RPN v2.0.0 — symbolic stack

Evolve the stack value from a plain number into a closed-form symbolic
value (num/den)·√rad·πⁿ:

- Exact fractions, k·√m and rational multiples of π are preserved and
  simplified (8 √ 2 × → 4√2, π 2 ÷ → π/2, √2·√2 → 2, 1/√2 → √2/2).
- Anything outside that form (√2+√3, sin, ln, overflow) falls back to a
  decimal approximation, so a result is never wrongly exact.
- All arithmetic uses overflow-checked int64; π is an exact constant.
- Factorial uses gamma(n+1) for large / non-integer arguments (no more
  unbounded loop).
- Host tests extended to cover the symbolic rules and factorial edges.
- Idempotent release workflow; CHANGELOG; README, landing page and
  roadmap updated.

Author: 1e1

.github/workflows/release.yml

@@ -31,15 +31,21 @@ jobs:
       - name: Stage release asset
         run: cp output/rpn.nwa rpn-${{ github.ref_name }}.nwa
 
-      - name: Create GitHub Release
+      - name: Publish GitHub Release (idempotent)
         env:
           GH_TOKEN: ${{ github.token }}
+          TAG: ${{ github.ref_name }}
         run: |
-          gh release create "${{ github.ref_name }}" \
-            "rpn-${{ github.ref_name }}.nwa#RPN app (${{ github.ref_name }}) — install via my.numworks.com/apps" \
-            --title "RPN ${{ github.ref_name }}" \
-            --notes "RPN calculator for NumWorks.
+          FILE="rpn-${TAG}.nwa"
+          if gh release view "$TAG" >/dev/null 2>&1; then
+            echo "Release $TAG exists — updating asset."
+            gh release upload "$TAG" "$FILE" --clobber
+          else
+            gh release create "$TAG" "${FILE}#RPN app (${TAG}) — install via my.numworks.com/apps" \
+              --title "RPN ${TAG}" \
+              --notes "RPN calculator for NumWorks.
 
-          **Install:** download \`rpn-${{ github.ref_name }}.nwa\` below, then open <https://my.numworks.com/apps>, plug in your calculator and upload the file.
+          **Install:** download \`rpn-${TAG}.nwa\` below, then open <https://my.numworks.com/apps>, plug in your calculator and upload the file.
 
           See the [project page](https://1e1.github.io/numworks-RPN/) for the full key map."
+          fi

CHANGELOG.md

@@ -0,0 +1,28 @@
+# Changelog
+
+All notable changes to this project are documented here. This project follows
+[Semantic Versioning](https://semver.org/).
+
+## v2.0.0 — Symbolic stack
+
+- The stack value is now symbolic: exact results stay in the closed form
+  `(num/den)·√rad·πⁿ`.
+  - `8 √ 2 ×` → `4√2`, `π 2 ÷` → `π/2`, `√2·√2` → `2`, `1/√2` → `√2/2`.
+- Anything outside that closed form (`√2 + √3`, `sin`, `ln`, overflow) falls
+  back to a decimal approximation — a result is never *wrongly* exact.
+- π is an exact constant; `→Dec` (`Ans`) forces the decimal form.
+- Factorial now uses `gamma(n+1)` for large or non-integer arguments instead of
+  an unbounded loop.
+- All arithmetic remains overflow-checked `int64` with a decimal fallback.
+
+## v1.0.0 — First release
+
+- Reverse Polish Notation calculator as a NumWorks external app (`.nwa`).
+- Exact rational arithmetic for `+ − × ÷` and integer powers; IEEE double for
+  transcendental functions.
+- Stack-oriented key map: operator keys act on the stack, RPN-unused keys become
+  stack operations, `Toolbox` opens a stack menu; RAD/DEG angle mode.
+- Pure, host-tested numeric core (`make test`); device build via `nwlink` and
+  `arm-none-eabi`.
+- GitHub Actions for CI, tagged releases and a GitHub Pages site with an
+  interactive N0120 key map.

README.md

@@ -4,16 +4,20 @@ A **Reverse Polish Notation** (RPN) calculator as an external app for the
 [NumWorks](https://www.numworks.com) graphing calculator.
 
 No parentheses, no `=`: you push numbers onto a stack and operators act on it.
-Arithmetic keeps **exact fractions** (`1/3 + 1/6` stays `1/2`), and functions
-fall back to decimal approximations — the familiar NumWorks feel, RPN-style.
+Results stay **symbolic and exact** where they can — fractions (`1/3 + 1/6` →
+`1/2`), radicals (`8 √ 2 ×` → `4√2`), and rational multiples of π (`π 2 ÷` →
+`π/2`) — and fall back to a decimal approximation otherwise. The familiar
+NumWorks feel, RPN-style.
 
 ➡️ **Project page & key map:** <https://1e1.github.io/numworks-RPN/>
 
 > **Scope.** NumWorks external apps run in a sandbox and cannot call the
-> built-in Poincaré engine, so this app ships its own numeric core: exact
-> rational arithmetic for `+ − × ÷` and integer powers, IEEE double for
-> transcendental functions. Full symbolic simplification would require a native
-> build of Epsilon rather than an external app.
+> built-in Poincaré engine, so this app ships its own symbolic core. Values are
+> held in the closed form `(num/den)·√rad·πⁿ`, which keeps exact fractions,
+> `k√m`, and rational multiples of π; anything outside that form (e.g. `√2 + √3`,
+> `sin`, `ln`) collapses to a decimal approximation — so a result is never
+> *wrongly* exact. A full expression-tree CAS with 2D layout would require a
+> native build of Epsilon rather than an external app (see the roadmap).
 
 ## Install
 
@@ -31,12 +35,15 @@ stack. Subtraction and division are `level2 (op) level1`:
 
 ```
 3 EXE 6 ÷        → 1/2          exact fraction
-2 EXE √          → 1.414214     approximation
+2 EXE √          → √2           exact radical
+8 EXE √ 2 ×      → 4√2          simplified
+π EXE 2 ÷        → π/2          rational multiple of π
 5 EXE 4 EXE −    → 1            (5 − 4)
-π EXE 2 ×        → 6.283185
 5 !              → 120          exact factorial
 ```
 
+Press `Ans` (→Dec) to force the decimal approximation of the top level.
+
 If you enter operands in the wrong order, press **( = SWAP** to exchange the top
 two levels.
 

docs/ROADMAP.md

@@ -1,8 +1,10 @@
-# Roadmap — v2: symbolic stack with Poincaré-style presentation
+# Roadmap — symbolic stack with Poincaré-style presentation
 
-v1.0.0 is a numeric RPN calculator: the stack holds *numbers* (exact rationals
-or doubles) and every operator computes eagerly. v2 changes the nature of the
-stack.
+> **Status.** v1.0.0 held plain numbers (exact rationals or doubles). **v2.0.0
+> ships the first symbolic layer**: values now live in the closed form
+> `(num/den)·√rad·πⁿ`, so `8 √ 2 ×` gives `4√2`, `π 2 ÷` gives `π/2`, and
+> `√2·√2` gives `2` — exact where possible, decimal otherwise. The steps below
+> describe what remains to reach a *full* expression-tree CAS with 2D layout.
 
 ## Vision
 

docs/index.html

@@ -123,9 +123,9 @@ <h3>Stack, not lines</h3>
         <p>Push numbers and let operators act on them. Fast, keystroke-efficient, and ideal for long chained calculations.</p>
       </div>
       <div class="card">
-        <span class="emoji">½</span>
-        <h3>Exact fractions</h3>
-        <p><code>1/3 + 1/6</code> stays <code>1/2</code>. Arithmetic and integer powers keep exact rationals; functions give decimals.</p>
+        <span class="emoji">√</span>
+        <h3>Exact &amp; symbolic</h3>
+        <p>Fractions, radicals and multiples of π stay exact — <code>1/2</code>, <code>4√2</code>, <code>π/2</code> — with a decimal fallback when they can't.</p>
       </div>
       <div class="card">
         <span class="emoji">⌨️</span>
@@ -137,11 +137,11 @@ <h3>Familiar keys</h3>
 
   <section>
     <h2>See it in action</h2>
-    <pre>3 <b>EXE</b> 6 ÷        <span class="out">→ 1/2</span>        exact fraction
-2 <b>EXE</b> √          <span class="out">→ 1.414214</span>   approximation
-5 <b>EXE</b> 4 <b>EXE</b> −    <span class="out">→ 1</span>          (5 − 4)
-π <b>EXE</b> 2 ×        <span class="out">→ 6.283185</span>
-5 !              <span class="out">→ 120</span>        exact factorial</pre>
+    <pre>3 <b>EXE</b> 6 ÷        <span class="out">→ 1/2</span>     exact fraction
+2 <b>EXE</b> √          <span class="out">→ √2</span>      exact radical
+8 <b>EXE</b> √ 2 ×      <span class="out">→ 4√2</span>     simplified
+π <b>EXE</b> 2 ÷        <span class="out">→ π/2</span>     rational multiple of π
+5 !              <span class="out">→ 120</span>     exact factorial</pre>
     <p class="note">Subtraction and division are <em>level 2 (op) level 1</em>. Entered the operands in the wrong order? Press <kbd>(</kbd> to <strong>SWAP</strong> the top two.</p>
   </section>
 

src/main.cpp

@@ -24,6 +24,9 @@ const uint32_t eadk_api_level
 using EADK::Keyboard::Event;
 
 int main(int argc, char* argv[]) {
+  (void)argc;
+  (void)argv;
+
   Engine engine;
   View view;
 

src/rpn.cpp

@@ -11,12 +11,8 @@ constexpr double kE = 2.71828182845904523536;
 double toRadians(double x) { return x * kPi / 180.0; }
 double toDegrees(double x) { return x * 180.0 / kPi; }
 
-double factorialDouble(double x) {
-  // Only defined here for non-negative integers; caller validates.
-  double result = 1.0;
-  for (int i = 2; i <= (int)(x + 0.5); i++) result *= i;
-  return result;
-}
+// Largest n whose factorial fits exactly in int64 (20! < 2^63 <= 21!).
+constexpr int64_t kMaxExactFactorial = 20;
 }  // namespace
 
 void Engine::toggleAngleMode() {
@@ -126,7 +122,7 @@ void Engine::execute(Command command) {
       if (!m_input.isEmpty()) {
         Value v = Value::parse(m_input.text());
         m_input.clear();
-        if (v.isExact()) level = (int)v.numerator();
+        if (v.isInteger()) level = (int)v.integerValue();
       }
       if (!m_stack.pick(level)) setStatus("Bad level");
       break;
@@ -206,23 +202,23 @@ void Engine::execute(Command command) {
       if (!ensureOperands(1)) break;
       Value a = m_stack.pop();
       double x = a.toDouble();
-      if (a.isExact() && a.denominator() == 1 && a.numerator() >= 0 &&
-          a.numerator() <= 20) {
+      if (x < 0.0) {
+        m_stack.push(Value::undefined());
+        setStatus("Factorial needs n>=0");
+      } else if (a.isInteger() && a.integerValue() <= kMaxExactFactorial) {
         int64_t r = 1;
-        for (int64_t i = 2; i <= a.numerator(); i++) r *= i;
+        for (int64_t i = 2; i <= a.integerValue(); i++) r *= i;
         m_stack.push(Value::integer(r));
-      } else if (x >= 0.0) {
-        m_stack.push(Value::real(factorialDouble(x)));
       } else {
-        m_stack.push(Value::undefined());
-        setStatus("Factorial needs n>=0");
+        // Larger or non-integer arguments: n! = gamma(n+1) as a double.
+        m_stack.push(Value::real(tgamma(x + 1.0)));
       }
       break;
     }
 
     case Command::PushPi:
       commitInput();
-      m_stack.push(Value::real(kPi));
+      m_stack.push(Value::pi());
       break;
     case Command::PushE:
       commitInput();