voroskoi/pathfinder.zig - Change GGCMPNJA4ZJ7M4MV2KL6FIVB3WY5S3K7MOFIQIJMKUSQRQT33RDQC

Fix building with latest zig

Created by voroskoi on March 13, 2024

GGCMPNJA4ZJ7M4MV2KL6FIVB3WY5S3K7MOFIQIJMKUSQRQT33RDQC

Dependencies

In channels

main

Change contents

File deletion: pathfinder_test.zig
BF:BFD[4.15] → [5.0:43]
BF:BFD[5.43] → [5.44:44]
B:BD[5.44] → [5.45:123]
```
test {
    _ = @import("grid_test.zig");
    _ = @import("graph_test.zig");
}
```

Replacement in src/pathfinder.zig at line 1 [4.50]

B:BD[4.50] → [5.150:223]

usingnamespace @import("grid.zig");
usingnamespace @import("graph.zig");

[4.50]

[5.223]

pub const Grid = @import("grid.zig");
pub const Graph = @import("graph.zig");

Insertion in src/pathfinder.zig at line 7 [4.50]

[4.171]


test {
    _ = @import("grid_test.zig");
    _ = @import("graph_test.zig");
}

Replacement in src/grid_test.zig at line 5 [4.210]

B:BD[2.48] → [2.48:259]

    const absx = try std.math.absInt(@intCast(isize, a[0]) - @intCast(isize, b[0]));
    const absy = try std.math.absInt(@intCast(isize, a[1]) - @intCast(isize, b[1]));
    return @intCast(usize, absx + absy);

[2.48]

[2.259]

    const absx = @abs(@as(isize, @intCast(a[0])) - @as(isize, @intCast(b[0])));
    const absy = @abs(@as(isize, @intCast(a[1])) - @as(isize, @intCast(b[1])));
    return @as(usize, @intCast(absx + absy));

Replacement in src/grid_test.zig at line 11 [4.210]

∅:D[2.286] → [6.0:69]

B:BD[7.40] → [6.0:69]

    var grid = PF.Grid(usize, 100, 100).init(std.testing.allocator);

[2.286]

[6.69]

    var grid = PF.Grid.Grid(usize, 100, 100).init(std.testing.allocator);

Replacement in src/grid_test.zig at line 14 [4.210]

B:BD[6.147] → [6.147:214]

    var ret = try grid.dijkstra(.{ 0, 0 }, .{ 99, 99 }, PF.D2.HV);

[6.147]

[7.202]

    var ret = try grid.dijkstra(.{ 0, 0 }, .{ 99, 99 }, PF.Grid.D2.HV);

Replacement in src/grid_test.zig at line 27 [4.210]

∅:D[2.311] → [6.511:580]

B:BD[8.122] → [6.511:580]

    var grid = PF.Grid(isize, 100, 100).init(std.testing.allocator);

[2.311]

[6.580]

    var grid = PF.Grid.Grid(isize, 100, 100).init(std.testing.allocator);

Replacement in src/grid_test.zig at line 30 [4.210]

B:BD[6.658] → [6.658:733]

    const ret = try grid.dijkstra(.{ 0, 0 }, .{ 99, 99 }, PF.D2.diagonal);

[6.658]

[7.506]

    const ret = try grid.dijkstra(.{ 0, 0 }, .{ 99, 99 }, PF.Grid.D2.diagonal);

Replacement in src/grid_test.zig at line 35 [4.210]

∅:D[2.336] → [6.734:801]

B:BD[8.357] → [6.734:801]

    var grid = PF.Grid(f64, 100, 100).init(std.testing.allocator);

[2.336]

[6.801]

    var grid = PF.Grid.Grid(f64, 100, 100).init(std.testing.allocator);

Replacement in src/grid_test.zig at line 38 [4.210]

B:BD[6.879] → [6.879:949]

    const ret = try grid.dijkstra(.{ 0, 0 }, .{ 99, 99 }, PF.D2.all);

[6.879]

[7.645]

    const ret = try grid.dijkstra(.{ 0, 0 }, .{ 99, 99 }, PF.Grid.D2.all);

Replacement in src/grid_test.zig at line 43 [4.210]

B:BD[2.358] → [2.358:427]

    var grid = PF.Grid(usize, 100, 100).init(std.testing.allocator);

[2.358]

[2.427]

    var grid = PF.Grid.Grid(usize, 100, 100).init(std.testing.allocator);

Replacement in src/grid_test.zig at line 46 [4.210]

B:BD[2.505] → [2.505:583]

    const ret = try grid.astar(.{ 0, 0 }, .{ 99, 99 }, PF.D2.all, manhattan);

[2.505]

[2.583]

    const ret = try grid.astar(.{ 0, 0 }, .{ 99, 99 }, PF.Grid.D2.all, manhattan);

Deletion in src/grid.zig at line 20 [4.643]

B:BD[9.337] → [9.337:405]

/// `dir` is an array of arrays defining the valid neighbour moves.

Deletion in src/grid.zig at line 23 [4.643]
B:BD[6.1404] → [6.1404:1458]
```
        // directions: [][]isize = arrayToSlice(.HV),
```

Replacement in src/grid.zig at line 99 [4.643]

B:BD[4.2662] → [4.2662:2748]

            while (queue.count() > 0) {
                const curr = queue.remove();

[4.2453]

[9.753]

            while (queue.removeOrNull()) |curr| {

Replacement in src/grid.zig at line 104 [4.643]

∅:D[7.1816] → [4.2896:2971]

∅:D[6.2244] → [4.2896:2971]

B:BD[4.2896] → [4.2896:2971]

                    const diffrow = @intCast(isize, curr.state[0]) + d[0];

[6.2244]

[4.2971]

                    const diffrow = @as(isize, @intCast(curr.state[0])) + d[0];

Replacement in src/grid.zig at line 106 [4.643]

B:BD[4.3042] → [4.3042:3099]

                    const dr = @intCast(usize, diffrow);

[4.3042]

[4.3099]

                    const dr = @as(usize, @intCast(diffrow));

Replacement in src/grid.zig at line 108 [4.643]

B:BD[4.3100] → [4.3100:3175]

                    const diffcol = @intCast(isize, curr.state[1]) + d[1];

[4.3100]

[4.3175]

                    const diffcol = @as(isize, @intCast(curr.state[1])) + d[1];

Replacement in src/grid.zig at line 110 [4.643]

B:BD[4.3246] → [4.3246:3303]

                    const dc = @intCast(usize, diffcol);

[4.3246]

[4.3303]

                    const dc = @as(usize, @intCast(diffcol));

Replacement in src/grid.zig at line 136 [4.643]

B:BD[2.1337] → [2.1337:1423]

            while (queue.count() > 0) {
                const curr = queue.remove();

[2.1337]

[2.1423]

            while (queue.removeOrNull()) |curr| {

Replacement in src/grid.zig at line 141 [4.643]

B:BD[2.1565] → [2.1565:1640]

                    const diffrow = @intCast(isize, curr.state[0]) + d[0];

[2.1565]

[2.1640]

                    const diffrow = @as(isize, @intCast(curr.state[0])) + d[0];

Replacement in src/grid.zig at line 143 [4.643]

B:BD[2.1711] → [2.1711:1768]

                    const dr = @intCast(usize, diffrow);

[2.1711]

[2.1768]

                    const dr = @as(usize, @intCast(diffrow));

Replacement in src/grid.zig at line 145 [4.643]

B:BD[2.1769] → [2.1769:1844]

                    const diffcol = @intCast(isize, curr.state[1]) + d[1];

[2.1769]

[2.1844]

                    const diffcol = @as(isize, @intCast(curr.state[1])) + d[1];

Replacement in src/grid.zig at line 147 [4.643]

B:BD[2.1915] → [2.1915:1972]

                    const dc = @intCast(usize, diffcol);

[2.1915]

[2.1972]

                    const dc = @as(usize, @intCast(diffcol));

Replacement in src/graph.zig at line 58 [4.33557]

B:BD[4.35267] → [4.35267:35343]

                var nb = try curr.state.neighborFn(self.arena.allocator());

[4.35267]

[4.35343]

                const nb = try curr.state.neighborFn(self.arena.allocator());

Replacement in src/benchmark.zig at line 5 [3.38]

B:BD[3.154] → [3.154:365]

    const absx = try std.math.absInt(@intCast(isize, a[0]) - @intCast(isize, b[0]));
    const absy = try std.math.absInt(@intCast(isize, a[1]) - @intCast(isize, b[1]));
    return @intCast(usize, absx + absy);

[3.154]

[3.365]

    const absx = @abs(@as(isize, @intCast(a[0])) - @as(isize, @intCast(b[0])));
    const absy = @abs(@as(isize, @intCast(a[1])) - @as(isize, @intCast(b[1])));
    return absx + absy;

Replacement in src/benchmark.zig at line 11 [3.38]

B:BD[3.414] → [3.414:657]

    const powx = try std.math.powi(isize, @intCast(isize, a[0]) - @intCast(isize, b[0]), 2);
    const powy = try std.math.powi(isize, @intCast(isize, a[1]) - @intCast(isize, b[1]), 2);
    return std.math.sqrt(@intToFloat(f32, powx + powy));

[3.414]

[3.657]

    const powx = try std.math.powi(isize, @as(isize, @intCast(a[0])) - @as(isize, @intCast(b[0])), 2);
    const powy = try std.math.powi(isize, @as(isize, @intCast(a[1])) - @as(isize, @intCast(b[1])), 2);
    return @sqrt(@as(f32, @floatFromInt(powx + powy)));

Replacement in src/benchmark.zig at line 17 [3.38]

B:BD[3.691] → [3.691:760]

    var grid = PF.Grid(usize, 100, 100).init(std.testing.allocator);

[3.691]

[3.760]

    var grid = PF.Grid.Grid(usize, 100, 100).init(std.testing.allocator);

Replacement in src/benchmark.zig at line 21 [3.38]

B:BD[3.878] → [3.878:940]

    _ = try grid.dijkstra(.{ 0, 0 }, .{ 99, 99 }, PF.D2.all);

[3.878]

[3.940]

    _ = try grid.dijkstra(.{ 0, 0 }, .{ 99, 99 }, PF.Grid.D2.all);

Replacement in src/benchmark.zig at line 23 [3.38]

B:BD[3.967] → [3.967:1049]

    std.debug.print("\nGrid.dijkstra():\t{d}ms\n", .{time / std.time.ns_per_ms});

[3.967]

[3.1049]

    std.debug.print("Grid.dijkstra():\t{d}ms\n", .{time / std.time.ns_per_ms});

Replacement in src/benchmark.zig at line 26 [3.38]

B:BD[3.1052] → [3.1052:1149]

test "Bench Grid.astar()" {
    var grid = PF.Grid(usize, 100, 100).init(std.testing.allocator);

[3.1052]

[3.1149]

test "Bench Grid.astar() - manhattan" {
    var grid = PF.Grid.Grid(usize, 100, 100).init(std.testing.allocator);

Replacement in src/benchmark.zig at line 31 [3.38]

B:BD[3.1267] → [3.1267:1345]

    const res = try grid.astar(.{ 0, 0 }, .{ 99, 99 }, PF.D2.all, manhattan);

[3.1267]

[3.1345]

    const res = try grid.astar(.{ 0, 0 }, .{ 99, 99 }, PF.Grid.D2.all, manhattan);

Replacement in src/benchmark.zig at line 34 [3.38]

B:BD[3.1427] → [3.1427:1506]

    std.debug.print("\nGrid.astar():\t{d}ms\n", .{time / std.time.ns_per_ms});

[3.1427]

[3.1506]

    std.debug.print("Grid.astar() - manhattan:\t{d}ms\n", .{time / std.time.ns_per_ms});

Replacement in src/benchmark.zig at line 37 [3.38]

B:BD[3.1509] → [3.1509:1604]

test "Bench Grid.astar()" {
    var grid = PF.Grid(f32, 100, 100).init(std.testing.allocator);

[3.1509]

[3.1604]

test "Bench Grid.astar() - euclidean" {
    var grid = PF.Grid.Grid(f32, 100, 100).init(std.testing.allocator);

Replacement in src/benchmark.zig at line 42 [3.38]

B:BD[3.1722] → [3.1722:1800]

    const res = try grid.astar(.{ 0, 0 }, .{ 99, 99 }, PF.D2.all, euclidean);

[3.1722]

[3.1800]

    const res = try grid.astar(.{ 0, 0 }, .{ 99, 99 }, PF.Grid.D2.all, euclidean);

Replacement in src/benchmark.zig at line 45 [3.38]

B:BD[3.1880] → [3.1880:1959]

    std.debug.print("\nGrid.astar():\t{d}ms\n", .{time / std.time.ns_per_ms});

[3.1880]

[3.1959]

    std.debug.print("Grid.astar() - euclidean:\t{d}ms\n", .{time / std.time.ns_per_ms});

Replacement in src/aoc2021-day23_test.zig at line 14 [4.23757]

B:BD[4.24005] → [4.24005:24078]

const hallway_length = 7;
const siderooms = 4;
const sideroom_depth = 2;

[4.24005]

[4.24078]

const HALLWAY_LENGTH = 7;
const SIDEROOMS = 4;
const SIDEROOM_DEPTH = 2;

Replacement in src/aoc2021-day23_test.zig at line 21 [4.23757]

B:BD[4.24124] → [4.24124:24241]

    hallway: [hallway_length]?Amphipod = .{null} ** hallway_length,
    rooms: [siderooms][sideroom_depth]?Amphipod,

[4.24124]

[4.24241]

    hallway: [HALLWAY_LENGTH]?Amphipod = .{null} ** HALLWAY_LENGTH,
    rooms: [SIDEROOMS][SIDEROOM_DEPTH]?Amphipod,

Replacement in src/aoc2021-day23_test.zig at line 34 [4.23757]
B:BD[4.24573] → [4.24573:24613]
```
        for (self.hallway) |amp, idx| {
```
[4.24573]
[4.24613]
```
        for (self.hallway, 0..) |amp, idx| {
```

Replacement in src/aoc2021-day23_test.zig at line 55 [4.23757]

B:BD[4.25227] → [4.25227:25302]

        for (self.rooms) |room, rid| {
            for (room) |amp, aid| {

[4.25227]

[4.25302]

        for (self.rooms, 0..) |room, rid| {
            for (room, 0..) |amp, aid| {

Replacement in src/aoc2021-day23_test.zig at line 71 [4.23757]
B:BD[4.25737] → [4.25737:25781]
```
        std.debug.assert(room < siderooms);
```
[4.25737]
[4.25781]
```
        std.debug.assert(room < SIDEROOMS);
```

Replacement in src/aoc2021-day23_test.zig at line 73 [4.23757]

B:BD[4.25820] → [4.25820:26011]

            // https://github.com/ziglang/zig/issues/6059
            if (amp == null) {
                return false;
            } else if (amp != @intToEnum(Amphipod, room)) return false;

[4.25820]

[4.26011]

            if (amp == null or amp != @as(Amphipod, @enumFromInt(room))) return false;

Replacement in src/aoc2021-day23_test.zig at line 80 [4.23757]
B:BD[4.26133] → [4.26133:26177]
```
        std.debug.assert(room < siderooms);
```
[4.26133]
[4.26177]
```
        std.debug.assert(room < SIDEROOMS);
```

Replacement in src/aoc2021-day23_test.zig at line 84 [4.23757]

B:BD[4.26273] → [4.26273:26333]

            } else if (amp != @intToEnum(Amphipod, room)) {

[4.26273]

[4.26333]

            } else if (amp != @as(Amphipod, @enumFromInt(room))) {

Replacement in src/aoc2021-day23_test.zig at line 89 [4.23757]

B:BD[4.26387] → [4.26387:26436]

        std.debug.assert(ret <= sideroom_depth);

[4.26387]

[4.26436]

        std.debug.assert(ret <= SIDEROOM_DEPTH);

Replacement in src/aoc2021-day23_test.zig at line 93 [4.23757]
B:BD[4.26512] → [4.26512:26548]
```
        for (self.rooms) |_, idx| {
```
[4.26512]
[4.26548]
```
        for (self.rooms, 0..) |_, idx| {
```

Replacement in src/aoc2021-day23_test.zig at line 99 [4.23757]

B:BD[4.26713] → [4.26713:26815]

            for (self.hallway) |amp, hwidx| {
                if (amp == @intToEnum(Amphipod, idx)) {

[4.26713]

[4.26815]

            for (self.hallway, 0..) |amp, hwidx| {
                if (amp == @as(Amphipod, @enumFromInt(idx))) {

Replacement in src/aoc2021-day23_test.zig at line 105 [4.23757]

B:BD[4.26961] → [4.26961:27065]

                    ret.cost = (std.math.powi(usize, 10, @enumToInt(amp.?)) catch unreachable) * steps;

[4.26961]

[4.27065]

                    ret.cost = (std.math.powi(usize, 10, @intFromEnum(amp.?)) catch unreachable) * steps;

Replacement in src/aoc2021-day23_test.zig at line 115 [4.23757]

B:BD[4.27281] → [4.27281:27326]

            for (self.rooms) |other, oidx| {

[4.27281]

[4.27326]

            for (self.rooms, 0..) |other, oidx| {

Replacement in src/aoc2021-day23_test.zig at line 124 [4.23757]

B:BD[4.27574] → [4.27574:27634]

                    if (amp == @intToEnum(Amphipod, idx)) {

[4.27574]

[4.27634]

                    if (amp == @as(Amphipod, @enumFromInt(idx))) {

Replacement in src/aoc2021-day23_test.zig at line 139 [4.23757]

B:BD[4.28423] → [4.28423:28531]

                        ret.cost = (std.math.powi(usize, 10, @enumToInt(amp.?)) catch unreachable) * steps;

[4.28423]

[4.28531]

                        ret.cost = (std.math.powi(usize, 10, @intFromEnum(amp.?)) catch unreachable) * steps;

Replacement in src/aoc2021-day23_test.zig at line 195 [4.23757]
B:BD[4.30410] → [4.30410:30449]
```
        for (self.rooms) |room, idx| {
```
[4.30410]
[4.30449]
```
        for (self.rooms, 0..) |room, idx| {
```
Replacement in src/aoc2021-day23_test.zig at line 197 [4.23757]
B:BD[4.30518] → [4.30518:30554]
```
            for (room) |amp, pos| {
```
[4.30518]
[4.30554]
```
            for (room, 0..) |amp, pos| {
```

Replacement in src/aoc2021-day23_test.zig at line 202 [4.23757]

B:BD[4.30724] → [4.30724:30780]

                if (amp == @intToEnum(Amphipod, idx)) {

[4.30724]

[4.30780]

                if (amp == @as(Amphipod, @enumFromInt(idx))) {

Replacement in src/aoc2021-day23_test.zig at line 205 [4.23757]

B:BD[4.30828] → [4.30828:31049]

                    var next: PathType = @intCast(PathType, pos) + 1;
                    while (next < sideroom_depth) : (next += 1) {
                        if (room[next] != @intToEnum(Amphipod, idx)) tainted = true;

[4.30828]

[4.31049]

                    var next: PathType = @as(PathType, @intCast(pos)) + 1;
                    while (next < SIDEROOM_DEPTH) : (next += 1) {
                        if (room[next] != @as(Amphipod, @enumFromInt(idx))) tainted = true;

Replacement in src/aoc2021-day23_test.zig at line 212 [4.23757]

B:BD[4.31131] → [4.31131:31180]

                for (self.hallway) |hw, hwidx| {

[4.31131]

[4.31180]

                for (self.hallway, 0..) |hw, hwidx| {

Replacement in src/aoc2021-day23_test.zig at line 219 [4.23757]

B:BD[4.31515] → [4.31515:31606]

                        st.cost = steps * try std.math.powi(usize, 10, @enumToInt(amp.?));

[4.31515]

[4.31606]

                        st.cost = steps * try std.math.powi(usize, 10, @intFromEnum(amp.?));

Replacement in src/aoc2021-day23_test.zig at line 246 [4.23757]
B:BD[4.32255] → [4.32255:32287]
```
            for (l) |ch, idx| {
```
[4.32255]
[4.32287]
```
            for (l, 0..) |ch, idx| {
```

Replacement in src/aoc2021-day23_test.zig at line 256 [4.23757]

B:BD[4.32713] → [4.32713:32792]

                    ret.rooms[counter % siderooms][counter / siderooms] = amp;

[4.32713]

[4.32792]

                    ret.rooms[counter % SIDEROOMS][counter / SIDEROOMS] = amp;

Replacement in src/aoc2021-day23_test.zig at line 267 [4.23757]
B:BD[5.1416] → [5.1416:1462]
```
const StateQueue = PF.Graph(State).QueueType;
```
[5.1416]
[4.32937]
```
const StateQueue = PF.Graph.Graph(State).QueueType;
```

Replacement in src/aoc2021-day23_test.zig at line 287 [4.23757]

B:BD[4.33326] → [5.1463:1524]

    var graph = PF.Graph(State).init(std.testing.allocator);

[4.33326]

[5.1524]

    var graph = PF.Graph.Graph(State).init(std.testing.allocator);

Deletion in build.zig at line 2 [4.35623]

B:BD[4.35652] → [4.35652:35886]


pub fn build(b: *std.build.Builder) void {
    // Standard release options allow the person running `zig build` to select
    // between Debug, ReleaseSafe, ReleaseFast, and ReleaseSmall.
    const mode = b.standardReleaseOptions();

Replacement in build.zig at line 3 [4.35623]

B:BD[4.35887] → [5.1600:1676]

∅:D[5.1676] → [4.35957:36005]

B:BD[4.35957] → [4.35957:36005]

B:BD[4.36005] → [5.1677:1738]

∅:D[5.1738] → [4.36060:36095]

B:BD[4.36060] → [4.36060:36095]

    const lib = b.addStaticLibrary("pathfinder.zig", "src/pathfinder.zig");
    lib.setBuildMode(mode);
    lib.install();
    const main_tests = b.addTest("src/pathfinder_test.zig");
    main_tests.setBuildMode(mode);

[4.35887]

[4.36095]

pub fn build(b: *std.Build) void {
    const optmization = b.standardOptimizeOption(.{});
    const target = b.standardTargetOptions(.{});

Replacement in build.zig at line 7 [4.35623]

B:BD[4.36096] → [4.36096:36197]

    const test_step = b.step("test", "Run library tests");
    test_step.dependOn(&main_tests.step);

[4.36096]

[3.1962]

    const lib = b.addStaticLibrary(.{
        .name = "pathfinder",
        .root_source_file = .{ .path = "src/pathfinder.zig" },
        .optimize = optmization,
        .target = target,
    });
    b.installArtifact(lib);

Replacement in build.zig at line 15 [4.35623]

B:BD[3.1963] → [3.1963:2043]

    const bench = b.addTest("src/benchmark.zig");
    bench.setBuildMode(mode);

[3.1963]

[3.2043]

    const main_tests = b.addTest(.{
        .name = "test",
        .root_source_file = .{ .path = "src/pathfinder.zig" },
        .optimize = optmization,
        .target = target,
    });
    const test_cmd = b.addRunArtifact(main_tests);
    const test_step = b.step("test", "Run tests");
    test_step.dependOn(&test_cmd.step);

Replacement in build.zig at line 25 [4.35623]

B:BD[3.2044] → [3.2044:2148]

    const bench_step = b.step("bench", "Run library benchmarks");
    bench_step.dependOn(&bench.step);

[3.2044]

[4.36197]

    const benchmark = b.addTest(.{
        .name = "benchmark",
        .root_source_file = .{ .path = "src/benchmark.zig" },
        .optimize = optmization,
    });
    const bench_cmd = b.addRunArtifact(benchmark);
    const bench_step = b.step("bench", "Run benchmarks");
    bench_step.dependOn(&bench_cmd.step);