voroskoi/pathfinder.zig - Change F2AZDZWZABPDWUH4TPLK4N5NMSRYKFDKP3GURGUVNYH4R6W2JSCAC

Grid: add support for various types

Created by voroskoi on April 10, 2022

F2AZDZWZABPDWUH4TPLK4N5NMSRYKFDKP3GURGUVNYH4R6W2JSCAC

Dependencies

[2] IUN32JQJ57DGPVQYWTQNGYXEIMBBWYEXGSGTW3IUZMRIWHEJ7HYAC

In channels

main

Change contents

File addition: zig-cache (d--x------)
[2.15]
Replacement in src/grid_test.zig at line 4 [2.210]
B:BD[2.279] → [2.279:334]
```
test "Grid" {
    var t = try std.time.Timer.start();
```
[2.279]
[2.334]
```
test "Grid usize" {
```

Insertion in src/grid_test.zig at line 7 [2.210]

[2.491]

    try std.testing.expectEqual(@as(usize, 366), ret);
}

Replacement in src/grid_test.zig at line 10 [2.210]

B:BD[2.492] → [2.492:551]

    std.debug.print("time: {d}us\n", .{t.read() / 1_000});

[2.492]

[2.551]

test "Grid isize" {
    var d = try Grid(isize, 100, 100).ParseGridFromCSV("grid-test.txt", ",");
    const ret = try d.dijkstra(std.testing.allocator, .{ 0, 0 }, .{ 99, 99 });
    try std.testing.expectEqual(@as(isize, 366), ret);
}

Replacement in src/grid_test.zig at line 16 [2.210]

B:BD[2.552] → [2.552:607]

    try std.testing.expectEqual(@as(usize, 366), ret);

[2.552]

[2.607]

test "Grid float" {
    var d = try Grid(f64, 100, 100).ParseGridFromCSV("grid-test.txt", ",");
    const ret = try d.dijkstra(std.testing.allocator, .{ 0, 0 }, .{ 99, 99 });
    try std.testing.expectEqual(@as(f64, 366), ret);

Insertion in src/grid.zig at line 8 [2.643]

[2.848]


        const QueueType = struct {
            state: [2]usize,
            cost: T,
        };

Replacement in src/grid.zig at line 26 [2.643]

B:BD[2.1329] → [2.1329:1473]

                    // TODO: use proper parse function for each type
                    ret[row][col] = try std.fmt.parseUnsigned(T, item, 0);

[2.1329]

[2.1473]

                    switch (@typeInfo(T)) {
                        .Int => |item_type| {
                            if (item_type.signedness == .unsigned) {
                                ret[row][col] = try std.fmt.parseUnsigned(T, item, 0);
                            } else {
                                ret[row][col] = try std.fmt.parseInt(T, item, 0);
                            }
                        },
                        .Float => ret[row][col] = try std.fmt.parseFloat(T, item),
                        else => @compileError("unsupported type: " ++ @typeName(T)),
                    }

Deletion in src/grid.zig at line 45 [2.643]

B:BD[2.1589] → [2.1589:1689]

        const QueueType = struct {
            state: [2]usize,
            cost: usize,
        };

Replacement in src/grid.zig at line 56 [2.643]

B:BD[2.2002] → [2.2002:2212]

        pub fn dijkstra(self: @This(), allocator: std.mem.Allocator, start: [2]usize, end: [2]usize) !usize {
            var CostGrid = [_][GRID_COLS]usize{[_]usize{~@as(usize, 0)} ** GRID_COLS} ** GRID_ROWS;

[2.2002]

[2.2212]

        pub fn dijkstra(self: @This(), allocator: std.mem.Allocator, start: [2]usize, end: [2]usize) !T {
            var CostGrid = switch (@typeInfo(T)) {
                .Int => [_][GRID_COLS]T{[_]T{std.math.maxInt(T)} ** GRID_COLS} ** GRID_ROWS,
                .Float => [_][GRID_COLS]T{[_]T{std.math.floatMax(T)} ** GRID_COLS} ** GRID_ROWS,
                else => @compileError("unsupported type: " ++ @typeName(T)),
            };

Replacement in src/grid.zig at line 92 [2.643]

B:BD[2.3304] → [2.3304:3398]

                    const cost = CostGrid[curr.state[0]][curr.state[1]] +| self.grid[dr][dc];

[2.3304]

[2.3398]

                    const cost = CostGrid[curr.state[0]][curr.state[1]] + self.grid[dr][dc];