simplify bignum generic types

Author: 9il

source/mir/bignum/decimal.d

@@ -12,7 +12,7 @@ import std.traits: isSomeChar;
 public import mir.bignum.low_level_view: DecimalExponentKey;
 import mir.bignum.low_level_view: ceilLog10Exp2;
 
-private enum expBufferLength = 2 + ceilLog10Exp2(size_t.sizeof * 8);
+private enum expBufferLength = 2 + ceilLog10Exp2(ulong.sizeof * 8);
 private static immutable C[9] zerosImpl(C) = "0.00000.0";
 
 /++
@@ -21,7 +21,7 @@ Params:
     maxSize64 = count of 64bit words in coefficient
 +/
 @serdeScoped @serdeProxy!(const(char)[])
-struct Decimal(size_t maxSize64)
+struct Decimal(uint maxSize64)
     if (maxSize64 && maxSize64 <= ushort.max)
 {
     import mir.format: NumericSpec;
@@ -30,7 +30,7 @@ struct Decimal(size_t maxSize64)
     import std.traits: isMutable, isFloatingPoint;
 
     ///
-    sizediff_t exponent;
+    long exponent;
     ///
     BigInt!maxSize64 coefficient;
 
@@ -108,7 +108,7 @@ struct Decimal(size_t maxSize64)
     }
 
     ///
-    ref opAssign(size_t rhsMaxSize64)(auto ref scope const Decimal!rhsMaxSize64 rhs) return
+    ref opAssign(uint rhsMaxSize64)(auto ref scope const Decimal!rhsMaxSize64 rhs) return
         if (rhsMaxSize64 < maxSize64)
     {
         this.exponent = rhs.exponent;
@@ -737,7 +737,7 @@ struct Decimal(size_t maxSize64)
 
         C[1] sign = coefficient.sign ? "-" : "+";
         bool addSign = coefficient.sign || spec.plus;
-        sizediff_t s = this.exponent + coefficientLength;
+        long s = this.exponent + coefficientLength;
 
         alias zeros = zerosImpl!C;
 
@@ -840,7 +840,7 @@ struct Decimal(size_t maxSize64)
 
         assert(coefficientLength);
 
-        sizediff_t exponent = s - 1;
+        long exponent = s - 1;
 
         if (coefficientLength > 1)
         {
@@ -854,7 +854,7 @@ struct Decimal(size_t maxSize64)
 
         import mir.format_impl: printSignedToTail;
 
-        static if (sizediff_t.sizeof == 8)
+        static if (exponent.sizeof == 8)
             enum N = 21;
         else
             enum N = 11;
@@ -1081,7 +1081,7 @@ unittest
 
 deprecated("use decimal.fromStringImpl insteade")
 @trusted @nogc pure nothrow
-bool parseDecimal(size_t maxSize64, C)(scope const(C)[] str, ref Decimal!maxSize64 decimal, out DecimalExponentKey key)
+bool parseDecimal(uint maxSize64, C)(scope const(C)[] str, ref Decimal!maxSize64 decimal, out DecimalExponentKey key)
     if (isSomeChar!C)
 {
     return decimal.fromStringImpl(str, key);

source/mir/bignum/fixed.d

@@ -334,7 +334,7 @@ struct UInt(size_t size)
     }
 
     /// ditto
-    bool opOpAssign(string op, size_t rsize)(UInt!rsize rhs, bool overflow = false)
+    bool opOpAssign(string op, uint rsize)(UInt!rsize rhs, bool overflow = false)
         @safe pure nothrow @nogc scope
         if ((op == "+" || op == "-") && rsize < size)
     {

source/mir/bignum/fp.d

@@ -8,7 +8,7 @@ import std.traits;
 import mir.bitop;
 import mir.utility;
 
-package enum half(size_t hs) = (){
+package enum half(uint hs) = (){
     import mir.bignum.fixed: UInt;
     UInt!hs ret; ret.signBit = true; return ret;
 }();
@@ -21,8 +21,8 @@ Params:
 
 Note: the implementation doesn't support NaN and Infinity values.
 +/
-struct Fp(size_t coefficientSize, Exp = sizediff_t)
-    if ((is(Exp == int) || is(Exp == long)) && coefficientSize % (size_t.sizeof * 8) == 0 && coefficientSize >= (size_t.sizeof * 8))
+struct Fp(uint coefficientSize, Exp = long)
+    if ((is(Exp == int) || is(Exp == long)) && coefficientSize % (uint.sizeof * 8) == 0 && coefficientSize >= (uint.sizeof * 8))
 {
     import mir.bignum.fixed: UInt;
 
@@ -161,7 +161,7 @@ struct Fp(size_t coefficientSize, Exp = sizediff_t)
 
     /++
     +/
-    this(size_t size)(UInt!size integer, bool normalizedInteger = false)
+    this(uint size)(UInt!size integer, bool normalizedInteger = false)
         nothrow
     {
         import mir.bignum.fixed: UInt;
@@ -313,7 +313,7 @@ struct Fp(size_t coefficientSize, Exp = sizediff_t)
         Fp a = this;
         alias b = rhs;
         auto exponent = a.exponent - b.exponent;
-        a.exponent = b.exponent = -coefficientSize;
+        a.exponent = b.exponent = -Exp(coefficientSize);
         auto ret = Fp(cast(real) a / cast(real) b);
         ret.exponent += exponent;
         return ret;
@@ -460,7 +460,7 @@ struct Fp(size_t coefficientSize, Exp = sizediff_t)
 }
 
 ///
-Fp!(coefficientizeA + coefficientizeB) extendedMul(size_t coefficientizeA, size_t coefficientizeB)(Fp!coefficientizeA a, Fp!coefficientizeB b)
+Fp!(coefficientizeA + coefficientizeB) extendedMul(uint coefficientizeA, size_t coefficientizeB)(Fp!coefficientizeA a, Fp!coefficientizeB b)
     @safe pure nothrow @nogc
 {
     import mir.bignum.fixed: extendedMul;
@@ -480,11 +480,11 @@ template fp_log2(T)
     if (__traits(isFloating, T))
 {
     ///
-    T fp_log2(size_t coefficientSize, Exp = sizediff_t)(Fp!(coefficientSize, Exp) x)
+    T fp_log2(uint coefficientSize, Exp = long)(Fp!(coefficientSize, Exp) x)
     {
         import mir.math.common: log2;
         auto exponent = x.exponent + coefficientSize;
-        x.exponent = -coefficientSize;
+        x.exponent = -Exp(coefficientSize);
         return log2(cast(T)x) + exponent;
     }
 }
@@ -506,7 +506,7 @@ template fp_log(T)
     if (__traits(isFloating, T))
 {
     ///
-    T fp_log(size_t coefficientSize, Exp = sizediff_t)(Fp!(coefficientSize, Exp) x)
+    T fp_log(uint coefficientSize, Exp = long)(Fp!(coefficientSize, Exp) x)
     {
         import mir.math.constant: LN2;
         return T(LN2) * fp_log2!T(x);

source/mir/bignum/integer.d

@@ -15,7 +15,7 @@ Params:
     maxSize64 = count of 64bit words in coefficient
 +/
 @serdeScoped @serdeProxy!(const(char)[])
-struct BigInt(size_t maxSize64)
+struct BigInt(uint maxSize64)
     if (maxSize64 && maxSize64 <= ushort.max)
 {
     import mir.bignum.low_level_view;
@@ -29,13 +29,13 @@ struct BigInt(size_t maxSize64)
     size_t[ulong.sizeof / size_t.sizeof * maxSize64] data = void;
 
     ///
-    this(size_t size)(UInt!size fixedInt)
+    this(uint size)(UInt!size fixedInt)
     {
         this(fixedInt.data);
     }
 
     ///
-    this(size_t N)(size_t[N] data)
+    this(uint N)(size_t[N] data)
         if (N <= this.data.length)
     {
         sign = false;
@@ -115,7 +115,7 @@ struct BigInt(size_t maxSize64)
     }
 
     ///
-    ref opAssign(size_t rhsMaxSize64)(auto ref scope const BigInt!rhsMaxSize64 rhs) return
+    ref opAssign(uint rhsMaxSize64)(auto ref scope const BigInt!rhsMaxSize64 rhs) return
         if (rhsMaxSize64 < maxSize64)
     {
         this.sign = rhs.sign;

source/mir/bignum/internal/ryu/generic_128.d

@@ -142,44 +142,44 @@ else
 
 enum baseDiv5 = UInt!128([0x3333333333333333, 0x3333333333333333]);
 
-uint divRem5(size_t size)(ref UInt!size value)
+uint divRem5(uint size)(ref UInt!size value)
 {
     auto q = div5(value);
     auto r = cast(uint)(value - q * 5);
     value = q;
     return r;
 }
 
-uint divRem10(size_t size)(ref UInt!size value)
+uint divRem10(uint size)(ref UInt!size value)
 {
     auto q = div10(value);
     auto r = cast(uint)(value - q * 10);
     value = q;
     return r;
 }
 
-uint rem5(size_t size)(UInt!size value)
+uint rem5(uint size)(UInt!size value)
 {
     return divRem5(value);
 }
 
-uint rem10(size_t size)(UInt!size value)
+uint rem10(uint size)(UInt!size value)
 {
     return divRem10(value);
 }
 
-UInt!size div5(size_t size)(UInt!size value)
+UInt!size div5(uint size)(UInt!size value)
 {
     return extendedMulHigh(value, fiveReciprocal.toSize!size) >> 2;
 }
 
-UInt!size div10(size_t size)(UInt!size value)
+UInt!size div10(uint size)(UInt!size value)
 {
     return extendedMulHigh(value, fiveReciprocal.toSize!size) >> 3;
 }
 
 // Returns true if value is divisible by 5^p.
-bool multipleOfPowerOf5(size_t size)(UInt!size value, const uint p)
+bool multipleOfPowerOf5(uint size)(UInt!size value, const uint p)
 {
     enum fiveReciprocal = .fiveReciprocal.toSize!size;
     enum baseDiv5 = .baseDiv5.toSize!size;
@@ -206,7 +206,7 @@ version(mir_bignum_test) unittest
 }
 
 // Returns true if value is divisible by 2^p.
-bool multipleOfPowerOf2(size_t size)(const UInt!size value, const uint p)
+bool multipleOfPowerOf2(uint size)(const UInt!size value, const uint p)
 {
     version(LDC) pragma(inline, true);
     return (value & ((UInt!size(1) << p) - 1)) == 0;
@@ -224,7 +224,7 @@ version(mir_bignum_test) unittest
     assert(multipleOfPowerOf2(UInt!128(8), 4) == false);
 }
 
-UInt!size mulShift(size_t size)(const UInt!size m, const UInt!256 mul, const uint j)
+UInt!size mulShift(uint size)(const UInt!size m, const UInt!256 mul, const uint j)
 {
     version(LDC) pragma(inline, true);
     assert(j > 128);

source/mir/bignum/low_level_view.d

@@ -2460,7 +2460,7 @@ enum DecimalExponentKey
 
 /++
 +/
-struct DecimalView(W, WordEndian endian = TargetEndian, Exp = sizediff_t)
+struct DecimalView(W, WordEndian endian = TargetEndian, Exp = long)
     if (isUnsigned!W)
 {
     ///

source/mir/math/numeric.d

@@ -523,7 +523,7 @@ Returns: `(count + start - 1)! / (start - 1)!`
 Complexity: O(count)
 +/
 auto factorial
-    (size_t coefficientSize = 128, Exp = sizediff_t)
+    (uint coefficientSize = 128, Exp = long)
     (ulong count, ulong start = 1)
     if (coefficientSize % (size_t.sizeof * 8) == 0 && coefficientSize >= (size_t.sizeof * 8))
     in (start)
@@ -592,7 +592,7 @@ Returns: n choose k
 Complexity: O(min(k, n - k))
 +/
 auto binomialCoefficient
-    (size_t coefficientSize = 128, Exp = sizediff_t)
+    (uint coefficientSize = 128, Exp = long)
     (ulong n, uint k)
     if (coefficientSize % (size_t.sizeof * 8) == 0 && coefficientSize >= (size_t.sizeof * 8))
     in (k <= n)