yeptris 0.6.18.2-arm-linux-eabihf

data/vendor/libyeptris/src/yeptris/emit/float/dragon.c

@@ -0,0 +1,405 @@
+/* dragon.c — tier B: exact shortest/fixed output via the interval
+ * method over a fixed-capacity limb vector (TODO.impl/14, clean room).
+ *
+ * v = r/s exactly with r, s, mm, mp integers: value r/s, round-trip
+ * interval ((r - mm)/s, (r + mp)/s). Each digit step advances r, mm,
+ * mp by 10 (s fixed) so the boundaries stay in the remaining-value
+ * space. A position can stop iff truncating (error r/s <= mm/s) or
+ * rounding up (error (s-r)/s <= mp/s) stays inside; when both are
+ * legal the nearer wins, ties to the even digit (reparse is
+ * round-to-nearest-even). When neither is legal, another digit is
+ * required — IEEE-754 guarantees termination by 17 digits (double) /
+ * 9 (float).
+ */
+
+#include <string.h>
+
+#include "emit/float/floatint.h"
+
+/* ---- tiny limb vector: 32-bit limbs, little-endian ---- */
+
+#define LIMBS 44 /* < 1080 binary digits + decimal scaling headroom */
+
+typedef struct {
+    uint32_t d[LIMBS];
+    int n;
+} num;
+
+static void num_zero(num* a) {
+    memset(a, 0, sizeof(*a));
+    a->n = 1;
+}
+
+static void num_set_u64(num* a, uint64_t v) {
+    num_zero(a);
+    a->d[0] = (uint32_t)v;
+    a->d[1] = (uint32_t)(v >> 32);
+    a->n = a->d[1] ? 2 : 1;
+}
+
+static int num_cmp(const num* a, const num* b) {
+    if (a->n != b->n) {
+        return a->n < b->n ? -1 : 1;
+    }
+    for (int i = a->n - 1; i >= 0; i--) {
+        if (a->d[i] != b->d[i]) {
+            return a->d[i] < b->d[i] ? -1 : 1;
+        }
+    }
+    return 0;
+}
+
+static void num_trim(num* a) {
+    while (a->n > 1 && a->d[a->n - 1] == 0) {
+        a->n--;
+    }
+}
+
+static int num_add(num* a, const num* b) {
+    uint64_t carry = 0;
+    int n = a->n > b->n ? a->n : b->n;
+    for (int i = 0; i < n; i++) {
+        uint64_t s = (uint64_t)a->d[i] + (uint64_t)(i < b->n ? b->d[i] : 0) + carry;
+        a->d[i] = (uint32_t)s;
+        carry = s >> 32;
+    }
+    a->n = n;
+    if (carry) {
+        if (a->n >= LIMBS) {
+            return -1;
+        }
+        a->d[a->n++] = (uint32_t)carry;
+    }
+    return 0;
+}
+
+static void num_sub(num* a, const num* b) {
+    int64_t borrow = 0;
+    for (int i = 0; i < a->n; i++) {
+        int64_t s = (int64_t)a->d[i] - (int64_t)(i < b->n ? b->d[i] : 0) - borrow;
+        if (s < 0) {
+            s += ((int64_t)1 << 32);
+            borrow = 1;
+        } else {
+            borrow = 0;
+        }
+        a->d[i] = (uint32_t)s;
+    }
+    num_trim(a);
+}
+
+static int num_shl(num* a, int bits) {
+    for (; bits >= 32; bits -= 32) {
+        for (int i = a->n; i > 0; i--) {
+            a->d[i] = a->d[i - 1];
+        }
+        a->d[0] = 0;
+        a->n++;
+        if (a->n > LIMBS) {
+            return -1;
+        }
+    }
+    if (bits > 0) {
+        uint32_t carry = 0;
+        for (int i = 0; i < a->n; i++) {
+            uint32_t nc = a->d[i] >> (32 - bits);
+            a->d[i] = (a->d[i] << bits) | carry;
+            carry = nc;
+        }
+        if (carry) {
+            if (a->n >= LIMBS) {
+                return -1;
+            }
+            a->d[a->n++] = carry;
+        }
+    }
+    return 0;
+}
+
+static void num_shr(num* a, int bits) {
+    int limbs = bits / 32;
+    int rem = bits % 32;
+    if (limbs >= a->n) {
+        memset(a->d, 0, sizeof(uint32_t) * (size_t)a->n);
+        a->n = 1;
+        return;
+    }
+    for (int i = 0; i + limbs < a->n; i++) {
+        /* rem == 0 would shift by 32 (UB on uint32_t) — the hi limb
+         * is only meaningful when there IS a fractional shift */
+        if (rem == 0) {
+            a->d[i] = a->d[i + limbs];
+            continue;
+        }
+        uint32_t lo = a->d[i + limbs] >> rem;
+        uint32_t hi = (i + limbs + 1 < a->n) ? a->d[i + limbs + 1] << (32 - rem) : 0;
+        a->d[i] = lo | hi;
+    }
+    for (int i = a->n - limbs; i < a->n; i++) {
+        a->d[i] = 0;
+    }
+    a->n -= limbs;
+    num_trim(a);
+}
+
+static int num_mul10(num* a) {
+    uint64_t carry = 0;
+    for (int i = 0; i < a->n; i++) {
+        uint64_t p = (uint64_t)a->d[i] * 10 + carry;
+        a->d[i] = (uint32_t)p;
+        carry = p >> 32;
+    }
+    if (carry) {
+        if (a->n >= LIMBS) {
+            return -1;
+        }
+        a->d[a->n++] = (uint32_t)carry;
+    }
+    return 0;
+}
+
+static int num_is_zero(const num* a) {
+    return a->n == 1 && a->d[0] == 0;
+}
+
+/* Decimal digits of a (a >= 0) into dst[cap]; a == 0 yields "0".
+ * Returns the length, or -1 on overflow of cap. */
+static int num_to_digits(const num* a, char* dst, int cap) {
+    char rev[400];
+    int n = 0;
+    if (num_is_zero(a)) {
+        if (cap < 1) {
+            return -1;
+        }
+        dst[0] = '0';
+        return 1;
+    }
+    num t = *a;
+    while (!num_is_zero(&t)) {
+        uint64_t rem = 0;
+        for (int i = t.n - 1; i >= 0; i--) {
+            uint64_t cur = (rem << 32) | t.d[i];
+            t.d[i] = (uint32_t)(cur / 1000000000u);
+            rem = cur % 1000000000u;
+        }
+        num_trim(&t);
+        for (int k = 0; k < 9; k++) {
+            rev[n++] = (char)('0' + (int)(rem % 10));
+            rem /= 10;
+            if (rem == 0 && num_is_zero(&t)) {
+                break;
+            }
+        }
+        if (n >= (int)sizeof(rev)) {
+            return -1;
+        }
+    }
+    if (n > cap) {
+        return -1;
+    }
+    for (int i = 0; i < n; i++) {
+        dst[i] = rev[n - 1 - i];
+    }
+    return n;
+}
+
+/* ---- exact shortest ---- */
+
+int yep_dragon_shortest(uint64_t m2, int e2, int mb, int pow2_low, int tie_even, yep_dsplit* out) {
+    num r, s, mm, mp;
+    num_set_u64(&r, m2);
+    num_zero(&s);
+    s.d[0] = 1;
+    num_set_u64(&mm, 1);
+    num_set_u64(&mp, 1);
+    if (e2 >= 0) {
+        if (num_shl(&r, e2) != 0 || num_shl(&mm, e2 - 1) != 0) {
+            return -1;
+        }
+        mp = mm;
+    } else {
+        /* v = m2 / 2^-e2 with HALF-ulp boundaries: express with r = 2*m2
+         * over s = 2^(1-e2) so mm = mp = 1 is exactly the half-ulp */
+        if (num_shl(&r, 1) != 0 || num_shl(&s, 1 - e2) != 0) {
+            return -1;
+        }
+    }
+    if (pow2_low) {
+        /* power of two: the lower neighbor is one binade down, so the
+         * lower half-ulp is half the upper — widen by scaling r, s, mp
+         * by 2 (mm untouched halves relative to mp) */
+        if (num_shl(&r, 1) != 0 || num_shl(&s, 1) != 0 || num_shl(&mp, 1) != 0) {
+            return -1;
+        }
+    }
+
+    /* normalize the remaining value into [1/10, 1): v = 0.<digits> x 10^k */
+    int k = 0;
+    {
+        num rmp = r;
+        if (num_add(&rmp, &mp) != 0) {
+            return -1;
+        }
+        while (num_cmp(&rmp, &s) <= 0) {
+            num_mul10(&r);
+            num_mul10(&mm);
+            num_mul10(&mp);
+            rmp = r;
+            if (num_add(&rmp, &mp) != 0) {
+                return -1;
+            }
+            k--;
+        }
+        while (num_cmp(&r, &s) >= 0) {
+            if (num_mul10(&s) != 0) {
+                return -1;
+            }
+            k++;
+        }
+    }
+
+    const int max_digits = (mb >= 52) ? 17 : 9;
+    char digits[24];
+    int n = 0;
+    for (;;) {
+        num_mul10(&r);
+        num_mul10(&mm);
+        num_mul10(&mp);
+        int d = 0;
+        while (num_cmp(&r, &s) >= 0) {
+            num_sub(&r, &s);
+            d++;
+        }
+        digits[n] = (char)('0' + d);
+        n++;
+        /* can truncation stay inside? error r <= mm */
+        num rmm = mm;
+        int eq_down = num_cmp(&r, &rmm) == 0;
+        int can_down = num_cmp(&r, &rmm) < 0 || (tie_even && eq_down);
+        /* can rounding up stay inside? error (s - r) <= mp */
+        num sr = s;
+        num_sub(&sr, &r);
+        int eq_up = num_cmp(&sr, &mp) == 0;
+        int can_up = num_cmp(&sr, &mp) < 0 || (tie_even && eq_up);
+        if (can_down || can_up) {
+            int up;
+            if (can_down && can_up) {
+                num t = r;
+                if (num_add(&t, &r) != 0) {
+                    return -1;
+                }
+                int c = num_cmp(&t, &s);
+                if (c > 0) {
+                    up = 1;
+                } else if (c < 0) {
+                    up = 0;
+                } else {
+                    up = (d % 2) != 0; /* tie to the even digit */
+                }
+            } else {
+                up = can_up;
+            }
+            if (up) {
+                int i = n - 1;
+                for (;;) {
+                    if (digits[i] != '9') {
+                        digits[i]++;
+                        break;
+                    }
+                    digits[i] = '0';
+                    if (i == 0) {
+                        for (int j = n; j > 0; j--) {
+                            digits[j] = digits[j - 1];
+                        }
+                        digits[0] = '1';
+                        n++;
+                        k++;
+                        break;
+                    }
+                    i--;
+                }
+            }
+            break;
+        }
+        if (n >= max_digits) {
+            /* safety net: 17 (9) significant digits always round-trip */
+            break;
+        }
+        if (n >= 23) {
+            return -1;
+        }
+    }
+    memcpy(out->digits, digits, (size_t)n);
+    out->len = n;
+    out->k = k;
+    return 0;
+}
+
+/* ---- exact fixed notation: digits of round_half_even(v x 10^p) ---- */
+
+int yep_dragon_fixed(uint64_t m2, int e2, uint32_t precision, char* buf) {
+    num q;
+    num_set_u64(&q, m2);
+    if (e2 >= 0) {
+        if (num_shl(&q, e2) != 0) {
+            return -1;
+        }
+    }
+    for (uint32_t i = 0; i < precision; i++) {
+        if (num_mul10(&q) != 0) {
+            return -1;
+        }
+    }
+    if (e2 < 0) {
+        /* digits = round_half_even(N / 2^-e2): the remainder against
+         * the exact half decides; ties round to the even quotient */
+        int bits = -e2;
+        num half;
+        num_set_u64(&half, 1);
+        if (num_shl(&half, bits - 1) != 0) {
+            return -1;
+        }
+        num qshift = q;
+        num_shr(&qshift, bits);
+        num back = qshift;
+        if (num_shl(&back, bits) != 0) {
+            return -1;
+        }
+        num rem = q;
+        num_sub(&rem, &back);
+        int cmp = num_cmp(&rem, &half);
+        if (cmp > 0 || (cmp == 0 && (qshift.d[0] & 1))) {
+            num one;
+            num_set_u64(&one, 1);
+            if (num_add(&qshift, &one) != 0) {
+                return -1;
+            }
+        }
+        q = qshift;
+    }
+    char digits[400];
+    int len = num_to_digits(&q, digits, (int)sizeof(digits));
+    if (len < 0) {
+        return -1;
+    }
+    const char* tmp = digits;
+    if (precision == 0) {
+        memcpy(buf, tmp, (size_t)len);
+        return len;
+    }
+    if ((uint32_t)len <= precision) {
+        int pad = (int)precision - len;
+        int o = 0;
+        buf[o++] = '0';
+        buf[o++] = '.';
+        for (int i = 0; i < pad; i++) {
+            buf[o++] = '0';
+        }
+        memcpy(buf + o, tmp, (size_t)len);
+        return o + len;
+    }
+    memcpy(buf, tmp, (size_t)(len - (int)precision));
+    buf[len - (int)precision] = '.';
+    memcpy(buf + len - (int)precision + 1, tmp + (len - (int)precision), (size_t)precision);
+    return len + 1;
+}

data/vendor/libyeptris/src/yeptris/emit/float/floatint.h

@@ -0,0 +1,231 @@
+/* floatint.h — internal float-printing declarations (TODO.impl/14).
+ *
+ * CLEAN-ROOM IMPLEMENTATION: no third-party code is vendored (licensing
+ * decision 2026-09-01). What follows implements the published interval
+ * method for shortest round-trip decimal output (the Dragon4/Steele-
+ * White family, described in the literature) entirely from the math:
+ * find the shortest decimal that lies strictly inside the rounding
+ * interval (v - w_low, v + w_high) of the binary value.
+ *
+ * Two tiers, one algorithm:
+ *   - tier A (print.c): the same digit loop over exact 128-bit
+ *     integers — covers every value whose scaled representation fits
+ *     (doubles with E in [-32, 75], floats with E in [-32, 104]);
+ *   - tier B (dragon.c): the same loop over a fixed-capacity limb
+ *     vector — exact for everything else (extreme exponents), and the
+ *     correctness oracle for tier A in tests.
+ */
+
+#ifndef YEP_FLOATINT_H
+#define YEP_FLOATINT_H
+
+#include <stdint.h>
+
+#include "emit/float/api.h"
+
+/* YEP_FLOAT_FORCE_LIMBS: test hook — exercises the portable lo/hi
+ * tier on hosts that also have __int128 (the limbs math is otherwise
+ * only compiled on 32-bit targets). */
+#if defined(__SIZEOF_INT128__) && !defined(YEP_FLOAT_FORCE_LIMBS) && !defined(YEP_FLOAT_FORCE_LIMBS)
+typedef unsigned __int128 yep_u128;
+#define YEP_MUL64(a, b) ((yep_u128)(uint64_t)(a) * (uint64_t)(b))
+#elif defined(_MSC_VER) && (defined(_M_X64) || defined(_M_ARM64))
+#include <intrin.h>
+/* MSVC has no __int128: the lo/hi pair behind the SAME helper surface
+ * (print.c's interval loop rides only these — no operator arithmetic
+ * anywhere, so both branches share one source shape). */
+typedef struct {
+    uint64_t lo, hi;
+} yep_u128;
+#define YEP_MUL64(a, b) yep_u128_mul64(a, b)
+#else
+/* Any compiler without __int128 (32-bit GCC/Clang, MSVC x86-32): the
+ * same lo/hi pair; multiplication via 32-bit limbs (below). */
+typedef struct {
+    uint64_t lo, hi;
+} yep_u128;
+#define YEP_MUL64(a, b) yep_u128_mul64(a, b)
+#endif
+
+static inline yep_u128 yep_u128_of(uint64_t v) {
+#if defined(__SIZEOF_INT128__) && !defined(YEP_FLOAT_FORCE_LIMBS)
+    return (yep_u128)v;
+#else
+    yep_u128 r = {v, 0};
+    return r;
+#endif
+}
+
+static inline yep_u128 yep_u128_max(void) {
+#if defined(__SIZEOF_INT128__) && !defined(YEP_FLOAT_FORCE_LIMBS)
+    return ~(yep_u128)0;
+#else
+    yep_u128 r = {~(uint64_t)0, ~(uint64_t)0};
+    return r;
+#endif
+}
+
+static inline yep_u128 yep_u128_add(yep_u128 a, yep_u128 b) {
+#if defined(__SIZEOF_INT128__) && !defined(YEP_FLOAT_FORCE_LIMBS)
+    return a + b;
+#else
+    yep_u128 r;
+    r.lo = a.lo + b.lo;
+    r.hi = a.hi + b.hi + (r.lo < a.lo ? 1u : 0u);
+    return r;
+#endif
+}
+
+static inline yep_u128 yep_u128_sub(yep_u128 a, yep_u128 b) {
+#if defined(__SIZEOF_INT128__) && !defined(YEP_FLOAT_FORCE_LIMBS)
+    return a - b;
+#else
+    yep_u128 r;
+    r.lo = a.lo - b.lo;
+    r.hi = a.hi - b.hi - (a.lo < b.lo ? 1u : 0u);
+    return r;
+#endif
+}
+
+/* n < 128 */
+static inline yep_u128 yep_u128_shl(yep_u128 a, unsigned n) {
+#if defined(__SIZEOF_INT128__) && !defined(YEP_FLOAT_FORCE_LIMBS)
+    return a << n;
+#else
+    yep_u128 r = {0, 0};
+    if (n == 0) {
+        return a;
+    }
+    if (n < 64) {
+        r.hi = (a.hi << n) | (a.lo >> (64 - n));
+        r.lo = a.lo << n;
+    } else {
+        r.hi = a.lo << (n - 64);
+    }
+    return r;
+#endif
+}
+
+/* n < 128 */
+static inline yep_u128 yep_u128_shr(yep_u128 a, unsigned n) {
+#if defined(__SIZEOF_INT128__) && !defined(YEP_FLOAT_FORCE_LIMBS)
+    return a >> n;
+#else
+    yep_u128 r = {0, 0};
+    if (n == 0) {
+        return a;
+    }
+    if (n < 64) {
+        r.lo = (a.lo >> n) | (a.hi << (64 - n));
+        r.hi = a.hi >> n;
+    } else {
+        r.lo = a.hi >> (n - 64);
+    }
+    return r;
+#endif
+}
+
+static inline int yep_u128_cmp(yep_u128 a, yep_u128 b) {
+#if defined(__SIZEOF_INT128__) && !defined(YEP_FLOAT_FORCE_LIMBS)
+    return a < b ? -1 : (a > b ? 1 : 0);
+#else
+    if (a.hi != b.hi) {
+        return a.hi < b.hi ? -1 : 1;
+    }
+    if (a.lo != b.lo) {
+        return a.lo < b.lo ? -1 : 1;
+    }
+    return 0;
+#endif
+}
+
+#if defined(_MSC_VER) && defined(_M_X64)
+static inline yep_u128 yep_u128_mul64(uint64_t a, uint64_t b) {
+    yep_u128 r;
+    r.lo = _umul128(a, b, &r.hi);
+    return r;
+}
+#elif defined(_MSC_VER) && defined(_M_ARM64)
+static inline yep_u128 yep_u128_mul64(uint64_t a, uint64_t b) {
+    yep_u128 r;
+    r.hi = __umulh(a, b);
+    r.lo = a * b;
+    return r;
+}
+#elif !defined(__SIZEOF_INT128__) || defined(YEP_FLOAT_FORCE_LIMBS)
+/* portable: 32-bit limbs, exact (the struct tier only) */
+static inline yep_u128 yep_u128_mul64(uint64_t a, uint64_t b) {
+    uint64_t a0 = (uint32_t)a, a1 = a >> 32;
+    uint64_t b0 = (uint32_t)b, b1 = b >> 32;
+    uint64_t ll = a0 * b0;
+    uint64_t lh = a0 * b1;
+    uint64_t hl = a1 * b0;
+    uint64_t mid = (ll >> 32) + (uint32_t)lh + (uint32_t)hl;
+    yep_u128 r;
+    r.lo = (mid << 32) | (uint32_t)ll;
+    r.hi = (a1 * b1) + (lh >> 32) + (hl >> 32) + (mid >> 32);
+    return r;
+}
+#endif
+
+/* x * 10 stays in range */
+static inline int yep_u128_fits10(yep_u128 x) {
+#if defined(__SIZEOF_INT128__) && !defined(YEP_FLOAT_FORCE_LIMBS)
+    return x <= (~(yep_u128)0) / 10;
+#else
+    /* exact: x*10 = (hi*10 << 64) + lo*10 — overflow iff hi*10
+     * escapes 64 bits or the lo-carry wraps the sum */
+    yep_u128 hp = YEP_MUL64(x.hi, 10u);
+    if (hp.hi != 0) {
+        return 0;
+    }
+    yep_u128 lp = YEP_MUL64(x.lo, 10u);
+    return hp.lo + lp.hi >= hp.lo;
+#endif
+}
+
+/* m small (< 2^32); caller guarantees no overflow (fits10 guarded) */
+static inline yep_u128 yep_u128_mul_small(yep_u128 a, uint32_t m) {
+#if defined(__SIZEOF_INT128__) && !defined(YEP_FLOAT_FORCE_LIMBS)
+    return a * m;
+#else
+    yep_u128 r;
+    yep_u128 lp = YEP_MUL64(a.lo, m);
+    r.lo = lp.lo;
+    r.hi = a.hi * m + lp.hi;
+    return r;
+#endif
+}
+
+/* The shortest-roundtrip result both tiers produce. digits[] is the
+ * rounded digit sequence (no leading zero, trailing zeros kept only
+ * when significant), len its length; k is the decimal exponent so the
+ * value is 0.<digits> * 10^k (i.e. in [10^(k-1), 10^k)). */
+typedef struct {
+    char digits[24];
+    int len;
+    int k;
+} yep_dsplit;
+
+/* Tier B (dragon.c): exact shortest for any finite double/float bits.
+ * m2/e2 is the (unified) significand/exponent: v = m2 * 2^e2 with
+ * 2^mb <= m2 < 2^(mb+1) for normals, m2 < 2^mb for subnormals. */
+int yep_dragon_shortest(uint64_t m2, int e2, int mb, int pow2_low, int tie_even, yep_dsplit* out);
+
+/* Tier B exact fixed notation: digits of round_half_even(v * 10^p). */
+int yep_dragon_fixed(uint64_t m2, int e2, uint32_t precision, char* buf);
+
+/* Tier A (print.c): u128 fast tier; returns 0 when the value is out
+ * of the exact-128 range and tier B must be used. */
+int yep_u128_shortest(uint64_t m2, int e2, int mb, int pow2_low, int tie_even, yep_dsplit* out);
+
+/* tie_even: whether a decimal landing exactly on a round-trip boundary
+ * may be accepted — reparse ties to the even float, which is v only
+ * when v's significand is even (callers pass m2 % 2 == 0). */
+
+/* Shared rendering of a digit split into the canonical YAML form:
+ * plain notation for 10^-4 <= |v| < 10^16, else d.dddde[+-]XX with a
+ * leading "1.0e+20"-style fraction so the value re-parses as float. */
+int yep_float_render(const yep_dsplit* ds, int negative, char* buf);
+
+#endif /* YEP_FLOATINT_H */