@pkmn/engine 0.1.0-dev.c5fe6d07 → 0.1.0-dev.d1b39ff0

package/src/lib/common/rational.zig

@@ -43,8 +43,7 @@ pub fn Rational(comptime T: type) type {
         /// Update the rational by multiplying its numerator by p and its denominator by q.
         /// Both p and q must be >= 1, and if computable at comptime must have no common factors.
         pub fn update(r: *Self, p: anytype, q: anytype) Error!void {
-            // FIXME
-            // std.debug.print("({d}/{d}) * ", .{p, q});
+            // std.debug.print("({d}/{d}) * ", .{ p, q }); // DEBUG
             assert(p >= 1);
             assert(q >= 1);
 
@@ -185,16 +184,16 @@ pub fn Rational(comptime T: type) type {
             try writer.print("{d}/{d}", .{ self.p, self.q });
         }
 
-        inline fn multiplication(r: *Self, p: anytype, q: anytype) !void {
+        fn multiplication(r: *Self, p: anytype, q: anytype) !void {
             r.p = try std.math.mul(T, r.p, p);
             r.q = try std.math.mul(T, r.q, q);
         }
 
-        inline fn addition(r: *Self, p: anytype, q: anytype) !void {
+        fn addition(r: *Self, p: anytype, q: anytype) !void {
             // (a/b) + (c/d) = (ad+bc)/(bd)
-            var d = try std.math.mul(T, r.q, q);
-            var n1 = try std.math.mul(T, r.p, q);
-            var n2 = try std.math.mul(T, r.q, p);
+            const d = try std.math.mul(T, r.q, q);
+            const n1 = try std.math.mul(T, r.p, q);
+            const n2 = try std.math.mul(T, r.q, p);
 
             r.p = try std.math.add(T, n1, n2);
             r.q = d;
@@ -202,23 +201,88 @@ pub fn Rational(comptime T: type) type {
     };
 }
 
-// https://en.wikipedia.org/wiki/Euclidean_algorithm
-inline fn gcd(p: anytype, q: anytype) @TypeOf(p, q) {
+// https://lemire.me/blog/greatest-common-divisor-the-extended-euclidean-algorithm-and-speed/
+fn gcd(p: anytype, q: anytype) @TypeOf(p, q) {
     assert(p >= 1);
     assert(q >= 1);
 
-    var a = p;
-    var b = q;
-    var c: @TypeOf(p, q) = undefined;
+    // convert comptime_int to a sized integer within this function so that @ctz will work
+    const T = switch (@TypeOf(p, q)) {
+        comptime_int => std.math.IntFittingRange(@min(p, q), @max(p, q)),
+        else => |U| U,
+    };
+
+    switch (@typeInfo(T)) {
+        .Int => {
+            var u: T = undefined;
+            var v: T = undefined;
+            if (p < q) {
+                u = q;
+                v = p;
+            } else {
+                u = p;
+                v = q;
+            }
+            assert(v <= u);
+            u %= v;
+            if (u == 0) return v;
+
+            const zu = @ctz(u);
+            const zv = @ctz(v);
+            const shift = @min(zu, zv);
+            u >>= @intCast(zu);
+            v >>= @intCast(zv);
+
+            while (true) {
+                const diff = u -% v;
+                if (u > v) {
+                    u = v;
+                    v = diff;
+                } else {
+                    v -= u;
+                }
+                if (diff != 0) v >>= @intCast(@ctz(diff));
+                if (v == 0) break;
+            }
+
+            const result = u << @intCast(shift);
+            assert(result > 0);
+            return result;
+        },
+        else => {
+            var a = p;
+            var b = q;
+            var c: T = undefined;
+
+            while (b != 0) {
+                c = b;
+                b = @mod(a, b);
+                a = c;
+            }
+
+            assert(a > 0);
+            return a;
+        },
+    }
+}
+
+test gcd {
+    const seed = if (@hasDecl(std.testing, "random_seed")) std.testing.random_seed else 0x12345678;
+    var prng = std.Random.DefaultPrng.init(seed);
+    var random = prng.random();
+
+    for (0..1000) |_| {
+        const a = random.int(u32);
+        const b = random.int(u32);
+        if (a == 0 or b == 0) continue;
 
-    while (b != 0) {
-        c = b;
-        b = @mod(a, b);
-        a = c;
+        try expectEqual(
+            gcd(a, b),
+            @as(u32, @intFromFloat(gcd(@as(f64, @floatFromInt(a)), @as(f64, @floatFromInt(b))))),
+        );
     }
 
-    assert(a > 0);
-    return a;
+    try expectEqual(gcd(300_000, @as(u32, 2_300_000)), 100_000); // NB: @ctz requires an @intCast
 }
 
 fn doTurn(r: anytype) !void {
@@ -234,6 +298,8 @@ test Rational {
         var r: Rational(t) = .{};
 
         var c: t = 128;
+        _ = &c;
+
         try r.update(c, 256);
         try doTurn(&r);
 
@@ -275,7 +341,7 @@ pub const BigRational = struct {
     /// Create a new BigRational wrapper.  A small amount of memory will be allocated on
     /// initialization. Not default initialized to 1 - you must explicitly `reset` first.
     pub fn init(alloc: std.mem.Allocator) !BigRational {
-        return BigRational{ .val = try std.math.big.Rational.init(alloc) };
+        return .{ .val = try std.math.big.Rational.init(alloc) };
     }
 
     /// Frees all memory associated with a rational.
@@ -320,6 +386,8 @@ test BigRational {
     try r.reset();
 
     var c: u8 = 128;
+    _ = &c;
+
     try r.update(c, 256);
     try doTurn(&r);
 
@@ -351,3 +419,36 @@ test BigRational {
     try s.setRatio(71, 78);
     try expect((try s.order(r.val)) == .eq);
 }
+
+test "minimum" {
+    // TODO: ziglang/zig#21069
+    if (builtin.mode == .ReleaseFast or builtin.mode == .ReleaseSmall) {
+        return error.SkipZigTest;
+    }
+    var r = try BigRational.init(std.testing.allocator);
+    defer r.deinit();
+    var s = try std.math.big.Rational.init(std.testing.allocator);
+    defer s.deinit();
+
+    try r.reset();
+
+    try r.update(1, 2); // Speed Tie
+    for (0..2) |_| {
+        try r.update(1, 2); // Confusion
+        try r.update(1, 2); // Infatuation
+        try r.update(3, 4); // Paralysis
+        // Population Bomb
+        for (0..10) |_| {
+            try r.update(9, 10); // Accuracy
+            try r.update(1, 15); // Damage roll
+            try r.update(1, 24); // Critical Hit
+            try r.update(9, 10); // King's Rock non-proc
+        }
+    }
+
+    const ZEROS = std.math.pow(u310, 10, 31);
+    const n = 36472996377170786403;
+    const d: u310 = 146267071761884981524886149560653378220687632500762654519853056 * ZEROS;
+    try s.setRatio(n, d);
+    try expect((try s.order(r.val)) == .eq);
+}

package/src/lib/common/rng.zig

@@ -1,6 +1,6 @@
 const std = @import("std");
 
-const options = @import("./options.zig");
+const options = @import("options.zig");
 
 const assert = std.debug.assert;
 const expectEqual = std.testing.expectEqual;
@@ -25,6 +25,11 @@ pub fn PRNG(comptime gen: comptime_int) type {
         pub fn next(self: *Self) Output(gen) {
             return self.src.next();
         }
+
+        pub fn advance(self: *Self, n: usize) void {
+            if (!options.advance) return;
+            for (0..n) |_| self.src.advance();
+        }
     };
 }
 
@@ -61,11 +66,15 @@ pub const PSRNG = extern struct {
             (@as(u64, self.range(u16, 0, 0x10000)) << 16) |
             (@as(u64, self.range(u16, 0, 0x10000)));
     }
+
+    pub fn Bound(comptime T: type) type {
+        return std.math.IntFittingRange(0, std.math.maxInt(T) + 1);
+    }
 };
 
 test PSRNG {
-    var psrng = PSRNG{ .src = .{ .seed = 0x0001000200030004 } };
-    try expectEqual(@as(u8, 121), psrng.range(u8, 0, 256));
+    var psrng: PSRNG = .{ .src = .{ .seed = 0x0001000200030004 } };
+    try expectEqual(121, psrng.range(u8, 0, 256));
     try expectEqual(false, psrng.chance(u8, 128, 256)); // 226 < 128
 }
 
@@ -79,7 +88,7 @@ pub const Gen12 = extern struct {
         assert(@sizeOf(Gen12) == 10);
     }
 
-    pub fn percent(p: u8) u8 {
+    pub fn percent(comptime p: comptime_int) u8 {
         return @intCast((@as(u16, p) * 0xFF) / 100);
     }
 
@@ -89,18 +98,22 @@ pub const Gen12 = extern struct {
         self.index = (self.index + 1) % 9;
         return val;
     }
+
+    pub fn advance(self: *Gen12) void {
+        _ = self.next();
+    }
 };
 
 test Gen12 {
     const expected = [_]u8{ 6, 11, 16, 21, 26, 31, 36, 41, 46, 31, 56, 81 };
-    var rng = Gen12{ .seed = .{ 1, 2, 3, 4, 5, 6, 7, 8, 9 } };
+    var rng: Gen12 = .{ .seed = .{ 1, 2, 3, 4, 5, 6, 7, 8, 9 } };
     for (expected) |e| {
         try expectEqual(e, rng.next());
     }
 
-    try expectEqual(@as(u8, 16), Gen12.percent(6) + 1);
-    try expectEqual(@as(u8, 16), Gen12.percent(7) - 1);
-    try expectEqual(@as(u8, 128), Gen12.percent(50) + 1);
+    try expectEqual(16, Gen12.percent(6) + 1);
+    try expectEqual(16, Gen12.percent(7) - 1);
+    try expectEqual(128, Gen12.percent(50) + 1);
 }
 
 // https://pkmn.cc/pokeemerald/src/random.c
@@ -129,7 +142,7 @@ test Gen34 {
         .{ 0x80000000, 5, 0x0E425287 }, .{ 0x80000000, 10, 0x6F2CF4B2 },
     };
     for (data) |d| {
-        var rng = Gen34{ .seed = d[0] };
+        var rng: Gen34 = .{ .seed = d[0] };
         for (0..d[1]) |_| _ = rng.next();
         try expectEqual(d[2], rng.seed);
     }
@@ -161,7 +174,7 @@ test Gen56 {
         .{ 0x8000000000000000, 10, 0xE7795501267F125A },
     };
     for (data) |d| {
-        var rng = Gen56{ .seed = d[0] };
+        var rng: Gen56 = .{ .seed = d[0] };
         for (0..d[1]) |_| _ = rng.next();
         try expectEqual(d[2], rng.seed);
     }
@@ -188,7 +201,7 @@ pub fn FixedRNG(comptime gen: comptime_int, comptime len: usize) type {
             for (0..n) |_| _ = self.next();
         }
 
-        pub fn range(self: *Self, comptime T: type, from: T, to: Bound(T)) T {
+        pub fn range(self: *Self, comptime T: type, from: T, to: PSRNG.Bound(T)) T {
             assert(showdown);
             return @intCast(@as(u64, self.next()) * (to - from) / divisor + from);
         }
@@ -197,7 +210,7 @@ pub fn FixedRNG(comptime gen: comptime_int, comptime len: usize) type {
             self: *Self,
             comptime T: type,
             numerator: T,
-            denominator: Bound(T),
+            denominator: PSRNG.Bound(T),
         ) bool {
             assert(showdown);
             assert(denominator > 0);
@@ -213,7 +226,7 @@ pub fn FixedRNG(comptime gen: comptime_int, comptime len: usize) type {
 test FixedRNG {
     const Type = if (showdown) u32 else u8;
     const expected = [_]Type{ 42, 255, 0 };
-    var rng = FixedRNG(1, expected.len){ .rolls = expected };
+    var rng: FixedRNG(1, expected.len) = .{ .rolls = expected };
     for (expected) |e| {
         try expectEqual(e, rng.next());
     }
@@ -228,7 +241,3 @@ fn Output(comptime gen: comptime_int) type {
         else => unreachable,
     };
 }
-
-fn Bound(comptime T: type) type {
-    return std.math.IntFittingRange(0, std.math.maxInt(T) + 1);
-}