feat(v4.0.0): Q.COS, bit for bit with v3
Q.COS is v3's q48_cos_approx: on |(Q.REDUCE) x|, the even Taylor series to n = 10. It sets term and sum to 1.0, n to 2 and the sign cell to 0, then jumps into Q.SIN's loop, so it adds no call level. Checked bit for bit against v3's q48_cos_approx (ported into the test) on the same 33 edge angles and 3000 pseudo-random angles as Q.SIN, at 32- and 64-bit cells, optimised and ASan+UBSan (`make test`, `make sanitize`). Mutating the start index, the start sum, the alternation or the sign cell each fails 2500+ cosine checks and no sine checks. Headroom (data under arg / return): Q.COS 3/2. Test results on the amd64 host only. This is a development check, not acceptance (JUSTIFICATION.md section 16). Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
rajames
co-authored by
Claude Opus 5.5
Claude Opus 5.5
parent
1ce705783c
commit
8235078b3b
@@ -147,8 +147,8 @@ IF body1 ELSE body2 THEN → if L1 drop body1 jump L2
|
||||
times, as on the F18. `FOR ... UNEXT` is the same but the body must fit in one instruction word.
|
||||
|
||||
**Register conventions.** `A` and `B` are caller-saved. A word that uses them says so. Words in this
|
||||
document that clobber `A`: `@ ! +! -! 2@ 2! C@ C! UM* * UM/MOD Q.FROM-INT Q.TO-INT Q.* Q./ Q.EXP Q.SQRT Q.LOG Q.SIN SEND RECV`. Words that clobber `B`:
|
||||
`Q./ Q.EXP Q.SQRT Q.LOG Q.SIN SEND RECV`.
|
||||
document that clobber `A`: `@ ! +! -! 2@ 2! C@ C! UM* * UM/MOD Q.FROM-INT Q.TO-INT Q.* Q./ Q.EXP Q.SQRT Q.LOG Q.SIN Q.COS SEND RECV`. Words that clobber `B`:
|
||||
`Q./ Q.EXP Q.SQRT Q.LOG Q.SIN Q.COS SEND RECV`.
|
||||
|
||||
**Return-stack words** (`>R R> R@ 2>R 2R> 2R@ I J UNLOOP` and the loop runtimes) are always IN.
|
||||
|
||||
@@ -664,7 +664,7 @@ word. Per D-10 it occupies two cells on a 64-bit node too. Per D-8, v4 Q values
|
||||
| `D2*C` | CAP | `( lo hi cin -- lo' hi' cout )`: the double shifted left one bit, `cin` entering at the bottom and `cout` the bit leaving the top (both 0 or 1). `a! dup -if L1 drop 1 jump L2 L1: drop 0 L2: push over -if L3 drop 1 jump L4 L3: drop 0 L4: over + + push 2* a + pop pop` — `cin` waits in `A`, and `2hi + m` is `over + +`, so it needs one return entry. Executed on the golden model (2026-10-02). Clobbers `A`. |
|
||||
| `(Q/)` | CAP | Variable, 5 cells: `Q./`'s quotient register, divisor and result sign. Like `BASE` and the hold buffer, it lives in node memory. |
|
||||
| `Q.ABS` `Q.NEG` | CAP | `DABS`, `DNEGATE` — executed on the golden model (2026-10-02) against v3's `q48_abs` and `0 - q`: bit-for-bit at 32-bit cells, including v3's wrap of Q min to itself; at 64-bit cells the low cell is v3's and the high cell is the true sign, per D-10. |
|
||||
| `Q.COS` | CAP | Algorithm ported from `q48_words.c`; the hosted C version is the golden model. |
|
||||
| `Q.COS` | CAP | v3's `q48_cos_approx`: on `xu = |(Q.REDUCE) x|`, `1 - xu^2/2! + xu^4/4! - …` to `n = 10`, run by `Q.SIN`'s loop: `(Q.REDUCE) -if A1 inv 1 + A1: 0 (QT) b! !b 0 over 0 Q.* drop (QT) 1 + b! !b 65536 (QT) 2 + b! !b 65536 (QT) 3 + b! !b 2 (QT) 4 + b! !b -1 (QT) 5 + b! !b jump TRIG` — term and sum start at 1.0, `n` at 2, and the sign cell is 0 so nothing is negated at the end. It jumps into the loop rather than calling it, so it costs no extra return entry. Executed on the golden model (2026-10-03): bit for bit v3's result on angles of every size and sign. Leaves its caller 3 data cells under its argument and 2 return entries. Clobbers `A` and `B`. |
|
||||
| `Q.SIN` | CAP | v3's `q48_sin_approx`: on `r = (Q.REDUCE) x` and `xu = |r|`, `xu - xu^3/3! + xu^5/5! - …` to `n = 11`, each term the last times `xu^2` over `n(n-1)`, stopping once a term is below 10 ulp; negated if `r < 0`. After the reduction every value fits one cell, so the variable `(QT)` holds single cells and the only calls are `(Q.REDUCE)`, `Q.*`, `Q./` and `UM*`. The Taylor loop is written so that `Q.COS` can jump into it. Executed on the golden model (2026-10-03): bit for bit v3's result on angles of every size and sign. Leaves its caller 3 data cells under its argument and 2 return entries. Clobbers `A` and `B`. |
|
||||
| `(Q.REDUCE)` | CAP | `( x -- r )`, v3's `q48_reduce_angle`: the angle reduced to one cell, `-pi <= r <= pi` with `pi = 205887`, `2pi = 411774` — the remainder of `x / 2pi` with the sign of `x`, then one step of `2pi` back into range. `x / 2pi` does not fit a cell, but only the remainder is wanted: `|x| mod 2pi` is two `UM/MOD` steps, the high cell first and its remainder then leading the low cell. `dup (QT) b! !b -if L1 DNEGATE L1: 0 411774 UM/MOD drop 411774 UM/MOD drop (QT) b! @b -if P1 drop inv 1 + jump J1 P1: drop J1: dup -205888 + -if BIG drop dup 205887 + -if OK drop 411774 + ; OK: drop ; BIG: drop -411774 + ;` Executed on the golden model (2026-10-03), bit for bit v3's. Clobbers `A` and `B`. |
|
||||
| `(QT)` | CAP | Variable, 6 cells: `Q.SIN` / `Q.COS`'s sign, `x^2`, term, sum, `n` and subtract flag. |
|
||||
|
||||
@@ -32,8 +32,9 @@
|
||||
* 0 <= q < 2^48, and for 0 with NODE-ERROR below zero (D-12).
|
||||
* Q.LOG is checked bit for bit against v3's q48_log_approx for x > 0, and
|
||||
* for 0 with NODE-ERROR at or below zero.
|
||||
* (Q.REDUCE) and Q.SIN are checked bit for bit against v3's
|
||||
* q48_reduce_angle and q48_sin_approx on angles of every size and sign. Every word is
|
||||
* (Q.REDUCE), Q.SIN and Q.COS are checked bit for bit against v3's
|
||||
* q48_reduce_angle, q48_sin_approx and q48_cos_approx on angles of every
|
||||
* size and sign. Every word is
|
||||
* also probed for how much of the 10- and 9-deep circular stacks (D-2) it
|
||||
* leaves to its caller.
|
||||
*
|
||||
@@ -78,7 +79,7 @@ static v4_cell w_nip, w_swap, w_or, w_negate, w_rot, w_zless, w_zequal,
|
||||
w_slashmod, w_mplus, w_dminus, w_d0equal, w_dequal,
|
||||
w_qfromint, w_qtoint, w_less, w_equal, w_dless, w_2swap, w_2over,
|
||||
w_dmax, w_dmin, w_qgt_doc, w_qgt, w_dltkeep, w_qstar, w_d2starc, w_uqdiv, w_qslash, w_qexp, w_qsqrt, w_qlog,
|
||||
w_qreduce, w_qsin, l_trig;
|
||||
w_qreduce, w_qsin, l_trig, w_qcos;
|
||||
|
||||
#define O(name) v4_asm_op(&as, V4_OP_##name)
|
||||
#define LIT(v) v4_asm_lit(&as, (v4_cell)(v))
|
||||
@@ -1273,6 +1274,27 @@ static void build(void)
|
||||
O(DROP); LIT(-1); O(SEMI);
|
||||
HERE_(sp); O(DROP); LIT(0); O(SEMI);
|
||||
}
|
||||
|
||||
/* : Q.COS ( x -- cos x ) 5.26, v3's q48_cos_approx
|
||||
* On xu = |(Q.REDUCE) x|: 1 - xu^2/2! + xu^4/4! - ... to n = 10, by
|
||||
* Q.SIN's loop: term and sum start at 1.0, n at 2, and the sign cell is
|
||||
* 0 so nothing is negated at the end.
|
||||
* (Q.REDUCE) -if A1 inv 1 + A1: xu
|
||||
* 0 QT b! !b 0 over 0 Q.* drop QT 1 + b! !b x^2
|
||||
* 65536 QT 2 + b! !b 65536 QT 3 + b! !b
|
||||
* 2 QT 4 + b! !b -1 QT 5 + b! !b jump TRIG
|
||||
* Clobbers A and B. */
|
||||
{
|
||||
v4_asm_ref a1;
|
||||
w_qcos = v4_asm_label(&as);
|
||||
CALL(w_qreduce);
|
||||
a1 = FWD(MINUS_IF); O(INV); LIT(1); O(ADD); HERE_(a1);
|
||||
LIT(0); VSET(QT);
|
||||
LIT(0); O(OVER); LIT(0); CALL(w_qstar); O(DROP); VSET(QT + 1);
|
||||
LIT(65536); VSET(QT + 2); LIT(65536); VSET(QT + 3);
|
||||
LIT(2); VSET(QT + 4); LIT(-1); VSET(QT + 5);
|
||||
JUMP_TO(l_trig);
|
||||
}
|
||||
#undef VSET
|
||||
#undef VGET
|
||||
#undef JUMP_TO
|
||||
@@ -1748,6 +1770,24 @@ static uint64_t v3_q48_sin(uint64_t q)
|
||||
return negative ? (uint64_t)0 - result : result;
|
||||
}
|
||||
|
||||
/* v3's q48_cos_approx, verbatim but for the names. */
|
||||
static uint64_t v3_q48_cos(uint64_t q)
|
||||
{
|
||||
int64_t x = v3_q48_reduce((int64_t)q);
|
||||
uint64_t xu = (uint64_t)(x < 0 ? -x : x);
|
||||
uint64_t x2 = v3_q48_mul(xu, xu);
|
||||
uint64_t term = 65536, result = term;
|
||||
int subtract = 1, nn;
|
||||
for (nn = 2; nn <= 10; nn += 2) {
|
||||
term = v3_q48_mul(term, x2);
|
||||
term = v3_q48_div(term, (uint64_t)(nn * (nn - 1)) << 16);
|
||||
result = subtract ? result - term : result + term;
|
||||
subtract = !subtract;
|
||||
if (term < 10) break;
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
/* Stack headroom. Run `word` with `dfill` marked cells under the canary and
|
||||
* `rfill` marked cells under its return address, and report whether the
|
||||
* results, the canary and every marked cell come back intact. The F18 stacks
|
||||
@@ -2468,8 +2508,9 @@ int main(void)
|
||||
}
|
||||
}
|
||||
|
||||
/* (Q.REDUCE) and Q.SIN against v3's q48_reduce_angle and q48_sin_approx,
|
||||
* bit for bit, on angles of every size and sign. */
|
||||
/* (Q.REDUCE), Q.SIN and Q.COS against v3's q48_reduce_angle,
|
||||
* q48_sin_approx and q48_cos_approx, bit for bit, on angles of every size
|
||||
* and sign. */
|
||||
{
|
||||
static const int64_t qa[] = {
|
||||
0, 1, -1, 0x8000, 0x10000, -0x10000, 102943, 102944, -102943, -102944,
|
||||
@@ -2494,6 +2535,8 @@ int main(void)
|
||||
"(Q.REDUCE) [%u] x=%lld", i, (long long)q);
|
||||
qcells(v3_q48_sin((uint64_t)q), &el, &eh);
|
||||
CHECK(call(w_qsin, 2, xl, xh, 0) && left2(el, eh), "Q.SIN [%u] x=%lld", i, (long long)q);
|
||||
qcells(v3_q48_cos((uint64_t)q), &el, &eh);
|
||||
CHECK(call(w_qcos, 2, xl, xh, 0) && left2(el, eh), "Q.COS [%u] x=%lld", i, (long long)q);
|
||||
}
|
||||
}
|
||||
|
||||
@@ -2623,6 +2666,8 @@ int main(void)
|
||||
headroom("(Q.REDUCE)", w_qreduce, 2, qtrig_args, 6, 1, &dh, &rh);
|
||||
headroom("Q.SIN", w_qsin, 2, qtrig_args, 6, 2, &dh, &rh);
|
||||
CHECK(dh >= 2 && rh >= 2, "Q.SIN leaves room");
|
||||
headroom("Q.COS", w_qcos, 2, qtrig_args, 6, 2, &dh, &rh);
|
||||
CHECK(dh >= 2 && rh >= 2, "Q.COS leaves room");
|
||||
headroom("SM/REM", w_smrem, 3, smrem_args, 5, 2, &dh, &rh);
|
||||
CHECK(rh >= 1, "SM/REM leaves room for /MOD's return address");
|
||||
headroom("/MOD", w_slashmod, 2, slashmod_args, 4, 2, &dh, &rh);
|
||||
|
||||
Reference in New Issue
Block a user