feat: add benchmark test for fused/vectorized sin+cos

Signed-off-by: Michael Pollind <mpollind@gmail.com>

Author: pollend

build.zig

@@ -35,6 +35,7 @@ pub fn build(b: *std.Build) void {
                 },
             }),
         });
+        b.installArtifact(bench);
         const bench_step = b.step("bench", "run benchmark");
         const bench_cmd = b.addRunArtifact(bench);
         bench_step.dependOn(&bench_cmd.step);

src/bench.zig

@@ -2,18 +2,6 @@ const std = @import("std");
 const zbench = @import("zbench");
 const zla = @import("zla");
 
-fn bubbleSort(nums: []i32) void {
-    var i: usize = nums.len - 1;
-    while (i > 0) : (i -= 1) {
-        var j: usize = 0;
-        while (j < i) : (j += 1) {
-            if (nums[j] > nums[j + 1]) {
-                std.mem.swap(i32, &nums[j], &nums[j + 1]);
-            }
-        }
-    }
-}
-
 fn benchmark_multiply(comptime size: usize) type {
     return struct {
         const Matrix512 = zla.Mat(f32, size, size);
@@ -39,9 +27,47 @@ fn benchmark_multiply(comptime size: usize) type {
     };
 }
 
-fn myBenchmark(_: std.mem.Allocator) void {
-    var numbers = [_]i32{ 4, 1, 3, 1, 5, 2 };
-    _ = bubbleSort(&numbers);
+fn bench_sin_cos_fused(comptime size: usize) type {
+    return struct {
+        angles: @Vector(size, f32),
+
+        fn init() @This() {
+            var val: [size]f32 = undefined;
+            for (0..size) |k| {
+                val[k] = @as(f32, @floatFromInt(k)) * 0.01;
+            }
+            return .{ .angles = val };
+        }
+
+        pub fn run(self: @This(), _: std.mem.Allocator) void {
+           std.mem.doNotOptimizeAway(@call(.never_inline, zla.vec.sin_cos, .{self.angles}));
+        }
+    };
+}
+
+fn benchmark_sin_cos_system(comptime size: usize) type {
+    return struct {
+        angles: [size]f32,
+
+        fn init() @This() {
+            var val: [size]f32 = undefined;
+            for (0..size) |k| {
+                val[k] = @as(f32, @floatFromInt(k)) * 0.01;
+            }
+            return .{ .angles = val };
+        }
+
+        pub fn run(self: @This(), _: std.mem.Allocator) void {
+            var sin_val: [size]f32 = undefined;
+            var cos_val: [size]f32 = undefined;
+            for(self.angles, 0..) |angle, i| {
+                sin_val[i] = std.math.sin(angle);
+                cos_val[i] = std.math.cos(angle);
+            }
+            std.mem.doNotOptimizeAway(sin_val);
+            std.mem.doNotOptimizeAway(cos_val);
+        }
+    };
 }
 
 pub fn main() !void {
@@ -57,6 +83,12 @@ pub fn main() !void {
     try bench.addParam("Multiple 512x512 matrix multiplication", &benchmark_multiply(512).init(), .{
         .iterations = 256,
     });
+    try bench.addParam("Sin/Cos", &benchmark_sin_cos_system(256).init(), .{
+        .iterations = 256,
+    });
+    try bench.addParam("Sin/Cos vectorized", &bench_sin_cos_fused(256).init(), .{
+        .iterations = 256,
+    });
 
     try writer.writeAll("\n");
     try bench.run(writer);

src/quat.zig

@@ -114,15 +114,22 @@ pub fn from_eular_angles(inAngles: anytype) @Vector(4, std.meta.Child(@TypeOf(in
     const cz = res.cos_out[2];
     const sz = res.sin_out[2];
 
-    return .{ cz * sx * cy - sz * cx * sy, cz * cx * sy + sz * sx * cy, sz * cx * cy - cz * sx * sy, cz * cx * cy + sz * sx * sy };
+    return .{ cz * sx * cy - sz * cx * sy, 
+              cz * cx * sy + sz * sx * cy, 
+              sz * cx * cy - cz * sx * sy, 
+              cz * cx * cy + sz * sx * sy };
 }
 
-//pub fn from_rotation_angle(axis: anytype, angle: std.meta.Child(@TypeOf(axis))) @Vector(4, std.meta.Child(@TypeOf(axis))) {
-//    //if (meta.array_vector_length(@TypeOf(axis)) != 3) @compileError("vector must have three elements for from_rotation_angle() to be defined");
-//    //const half_angle = angle * 0.5;
-//    //const norm_axis = vector.normalize(axis);
-//    //return .{ norm_axis[0] * s, norm_axis[1] * s, norm_axis[2] * s, c };
-//}
+pub fn from_rotation_angle(axis: anytype, angle: std.meta.Child(@TypeOf(axis))) @Vector(4, std.meta.Child(@TypeOf(axis))) {
+    const in_axis = map_to_vector(axis); 
+    if (meta.array_vector_length(@TypeOf(axis)) != 3) @compileError("vector must have three elements for from_rotation_angle() to be defined");
+    std.debug.assert(vector.is_normalized_default(in_axis));
+    return .{ 
+        in_axis[0] * std.math.sin(angle * 0.5), 
+        in_axis[1] * std.math.sin(angle * 0.5), 
+        in_axis[2] * std.math.sin(angle * 0.5), 
+        std.math.cos(angle * 0.5) };
+}
 
 
 pub fn to_eular_angles(q: anytype) @Vector(3, std.meta.Child(@TypeOf(q))) {

src/vector.zig

@@ -340,6 +340,10 @@ pub fn is_close(a: anytype, b: @TypeOf(a), max_distance_sqr: Float(@bitSizeOf(st
     return norm_sqr(inner_a - inner_b) <= max_distance_sqr;
 }
 
+pub fn is_normalized_default(a: anytype) bool {
+    return is_normalized(a, 1.0e-6);
+}
+
 pub fn is_normalized(a: anytype, tolerance: Float(@bitSizeOf(std.meta.Child(@TypeOf(a))))) bool {
     return norm_sqr(a - 1.0) <= tolerance;
 }