feat: add more examples

Author: guidoschmidt

src/examples/algorithms/dynamic-programming.zig

@@ -0,0 +1,81 @@
+// Source: https://qsantos.fr/2024/01/04/dynamic-programming-is-not-black-magic/
+const std = @import("std");
+const time = std.time;
+
+const Timer = time.Timer;
+
+var gpa = std.heap.GeneralPurposeAllocator(.{}){};
+const allocator = gpa.allocator();
+
+var cache = std.AutoHashMap(u128, u128).init(allocator);
+
+
+fn fibonacciRecursiveMemoized(comptime T: type, n: T) T {
+    if (n == 0) {
+        cache.put(0, 0) catch unreachable;
+        return 0;
+    }
+    if (n == 1) {
+        cache.put(1, 1) catch unreachable;
+        return 1;
+    }
+    const n_2 = cache.get(n - 2) orelse fibonacciRecursiveMemoized(T, n - 2);
+    const n_1 = cache.get(n - 1) orelse fibonacciRecursiveMemoized(T, n - 1);
+    if (!cache.contains(n - 2)) cache.put(n - 2, n_2) catch unreachable;
+    if (!cache.contains(n - 1)) cache.put(n - 1, n_1) catch unreachable;
+    return n_2 + n_1;
+}
+
+fn fibonacciRecursive(comptime T: type, n: T) T {
+    if (n == 0) return 0;
+    if (n == 1) return 1;
+    return fibonacciRecursive(T, n - 2) + fibonacciRecursive(T, n - 1);
+}
+
+fn fibonacciDynamicProgramming(comptime T: type, n: T) T {
+    if (n == 0) return 0;
+    var previous_previous: T = 0;
+    var previous: T = 1;
+    for (0..@intCast(n - 1)) |_| {
+        const current = previous_previous + previous;
+        previous_previous = previous;
+        previous = current;
+    }
+    return previous;
+}
+
+pub fn main() !void {
+    const input_values = [_]u32{ 1, 2, 3, 8, 12, 30, 40, 42, 43, 44 };
+
+    for (input_values) |input| {
+        std.debug.print("\n\n>>> Input \x1B[33m{d}\x1B[0m → fibonacci", .{ input });
+
+        var timer = Timer.start() catch {
+            unreachable;
+        };
+        const result_dp = fibonacciDynamicProgramming(u128, input);
+        var elapsed: f64 = @floatFromInt(timer.read()) ;
+        var dur: u64 = @intFromFloat(elapsed / time.ns_per_ms);
+        std.debug.print("\n\x1B[31mDynamic Programming:\n{d: >4} [{d} ms]", .{ result_dp, dur });
+
+        
+        timer = Timer.start() catch {
+            unreachable;
+        };
+        const result_recur_memo = fibonacciRecursiveMemoized(u128, input);
+        elapsed = @floatFromInt(timer.read()) ;
+        dur = @intFromFloat(elapsed / time.ns_per_ms);
+        std.debug.print("\n\x1B[32mRecursive (Memoized):\n{d: >4} [{d} ms]", .{ result_recur_memo, dur });
+
+        
+        timer = Timer.start() catch {
+            unreachable;
+        };
+        const result_recur = fibonacciRecursive(u128, input);
+        elapsed = @floatFromInt(timer.read()) ;
+        dur = @intFromFloat(elapsed / time.ns_per_ms);
+        std.debug.print("\n\x1B[34mRecursive:\n{d: >4} [{d} ms]", .{ result_recur, dur });
+
+        std.debug.print("\x1B[0m", .{});
+    }
+}

src/examples/comp-partial.zig

@@ -0,0 +1,42 @@
+/// Sources:
+/// https://zig.news/kristoff/easy-interfaces-with-zig-0100-2hc5
+/// https://www.youtube.com/watch?v=AHc4x1uXBQE
+/// https://ziggit.dev/t/polymorphism-with-zig-0-10-0/463/10
+
+const std = @import("std");
+
+const Shape = union(enum) {
+    circle: Circle,
+    rectangle: Rectangle,
+
+    pub fn area(self: *Shape) f32 {
+        switch(self.*) {
+            inline else => |*kind| kind.area(),
+        }
+    }
+};
+
+const Circle = struct {
+    radius: f32 = 1,
+
+    pub fn area(self: Circle) f32 {
+        return 2.0 * std.math.pi * self.radius;
+    } 
+};
+
+const Rectangle = struct {
+    width: f32 = 1,
+    height: f32 = 1,
+
+    pub fn area(self: Rectangle) f32 {
+        return self.width * self.height;
+    }
+};
+
+pub fn main() !void {
+    const circ = Circle{ .radius = 12 };
+    std.debug.print("\nCircle area: {d:.3}", .{ circ.area() });
+
+    const rect = Rectangle{ .width = 4, .height = 3 };
+    std.debug.print("\nRectangle area: {d:.3}", .{ rect.area() });
+}

src/examples/datastructures/interfaces.zig

@@ -0,0 +1,27 @@
+const std = @import("std");
+const f = @import("shared").functional;
+
+fn addX(comptime T: type, comptime x: T, v: T) T {
+    return v + x;
+}
+
+fn subX(comptime T: type, comptime x: T, v: T) T {
+    return v - x;
+}
+
+fn mulX(comptime T: type, comptime x: T, v: T) T {
+    return v * x;
+}
+
+pub fn main() !void {
+    const combined = f.comp(u32, .{
+        f.partial(u32, addX, 5),
+        f.partial(u32, mulX, 10),
+        f.partial(u32, subX, 3),
+        f.partial(u32, mulX, 2),
+    });
+    std.debug.print("\nFunction Composition", .{});
+    for (1..10) |i| {
+        std.debug.print("\n((({d} + 5) * 10) - 3) * 2: {d}", .{ i, combined(@intCast(i)) });
+    }
+}

src/examples/functional/composition.zig

@@ -0,0 +1,36 @@
+const std = @import("std");
+const f = @import("shared").functional;
+
+fn addX(comptime T: type, comptime x: T, v: T) T {
+    return v + x;
+}
+
+fn multX(comptime T: type, comptime x: T, v: T) T {
+    return v * x;
+}
+
+fn multXAddY(comptime T: type, comptime x: T, comptime y: T, v: T) T {
+    return (x * v) + y;
+}
+
+pub fn main() !void {
+    std.debug.print("Partial Function Application", .{});
+
+    std.debug.print("\nCreate an add8 function:", .{});
+    const add8 = f.partial(u8, addX, 8);
+    for (0..3) |i| {
+        std.debug.print("\n {d} + 8 = {d}", .{ i, add8(@intCast(i)) });
+    }
+
+    std.debug.print("\nCreate a multiply with 5 function:", .{});
+    const mult5 = f.partial(u8, multX, 5);
+    for (1..6) |i| {
+        std.debug.print("\n {d} x 5 = {d}", .{ i, mult5(@intCast(i)) });
+    }
+
+    std.debug.print("\nCreate a function which calculates 5 * x + 2:", .{});
+    const mult2add5 = f.partial2(u8, multXAddY, 2, 5);
+    for (0..10) |i| {
+        std.debug.print("\n 2 * {d} + 5 = {d}", .{ i, mult2add5(@intCast(i)) });
+    }
+}

src/examples/functional/partial.zig

@@ -0,0 +1,48 @@
+const std = @import("std");
+
+var gpa = std.heap.GeneralPurposeAllocator(.{}){};
+const allocator = gpa.allocator();
+
+const OscArgument = packed struct {
+    tag_type: u8 = 'i',
+    value: i32 = undefined,
+
+    pub fn format(
+        self: OscArgument,
+        writer: *std.Io.Writer,
+    ) std.Io.Writer.Error!void {
+        try writer.print("\nOSC Argument:\n - {c} - {d}", .{
+            self.tag_type,
+            self.value,
+        });
+    }
+};
+
+pub fn main() !void {
+    const buffer: []u8 = try allocator.alloc(u8, 100);
+    var stream = std.io.fixedBufferStream(buffer);
+    var writer = stream.writer();
+    try writer.writeInt(i32, 1337, .big);
+    try writer.writeInt(i32, 128, .big);
+    try writer.writeStruct(OscArgument{
+        .tag_type = 'i',
+        .value = 1337,
+    });
+
+    const written = stream.getWritten();
+    std.debug.print("Buffer Written:\n > {any}", .{written});
+
+    var out_stream = std.io.fixedBufferStream(written);
+    var reader = out_stream.reader();
+
+    var out = try reader.readInt(i32, .big);
+    std.debug.print("\n\nRead Integer:\n > {any}", .{out_stream.buffer});
+    std.debug.print("\n > {d}", .{out});
+
+    out = try reader.readInt(i32, .big);
+    std.debug.print("\n\nRead Integer:\n > {any}", .{out_stream.buffer});
+    std.debug.print("\n > {d}", .{out});
+
+    const out_struct = try reader.readStruct(OscArgument);
+    std.debug.print("\n{f}", .{out_struct});
+}