Fixed formating, created patch file.

exercises/109_vectors.zig

@@ -10,16 +10,16 @@
 // These are known as "single instruction, multiple data" (SIMD)
 // instructions. SIMD instructions can make code significantly
 // more performant.
-// 
+//
 // To see why, imagine we have a program in which we take the
 // square root of four (changing) f32 floats.
-// 
+//
 // A simple compiler would take the program and produce machine code
 // which calculates each square root sequentially. Most registers on
 // modern CPUs have 64 bits, so we could imagine that each float moves
 // into a 64-bit register, and the following happens four times:
 //
-//            32 bits   32 bits 
+//            32 bits   32 bits
 //          +-------------------+
 // register |    0    |    x    |
 //          +-------------------+
@@ -35,7 +35,7 @@
 // Notice that half of the register contains blank data to which
 // nothing happened. What a waste! What if we were able to use
 // that space instead? This is the idea at the core of SIMD.
-// 
+//
 // Most modern CPUs contain specialized registers with at least 128 bits
 // for performing SIMD instructions. On a machine with 128-bit SIMD
 // registers, a smart compiler would probably NOT issue four sqrt
@@ -50,11 +50,11 @@
 //           +---------------------------------------+
 // register  |   4.0   |   9.0   |  25.0   |  49.0   |
 //           +---------------------------------------+
-//          
+//
 //                              |
 //                  [SIMD SQRT instruction]
 //                              V
-//          
+//
 //           +---------------------------------------+
 // register  |   2.0   |   3.0   |   5.0   |   7.0   |
 //           +---------------------------------------+
@@ -74,26 +74,26 @@
 // SIMD instructions, whenever possible.
 //
 // Defining vectors in Zig is straightforwards. No library import is needed.
-const v1 = @Vector(3, i32) {  1,  10, 100};
+const v1 = @Vector(3, i32){ 1, 10, 100 };
-const v2 = @Vector(3, f32) {2.0, 3.0, 5.0}; 
+const v2 = @Vector(3, f32){ 2.0, 3.0, 5.0 };
 
 // Vectors support the same builtin operators as their underlying base types.
 const v3 = v1 + v1; // {   2,  20,  200};
 const v4 = v2 * v2; // { 4.0, 9.0, 25.0};
 
 // Intrinsics that apply to base types usually extend to vectors.
-const v5 : @Vector(3, f32) = @floatFromInt(v3); // { 2.0,  20.0,  200.0}
+const v5: @Vector(3, f32) = @floatFromInt(v3); // { 2.0,  20.0,  200.0}
-const v6 = v4 - v5;                             // { 2.0, -11.0, -175.0}
+const v6 = v4 - v5; // { 2.0, -11.0, -175.0}
-const v7 = @abs(v6);                            // { 2.0,  11.0,  175.0}
+const v7 = @abs(v6); // { 2.0,  11.0,  175.0}
 
 // We can make constant vectors, and reduce vectors.
-const v8 : @Vector(4, u8) = @splat(2); // { 2, 2, 2, 2}
+const v8: @Vector(4, u8) = @splat(2); // { 2, 2, 2, 2}
-const v8_sum = @reduce(.Add, v8);      // 8
+const v8_sum = @reduce(.Add, v8); // 8
-const v8_min = @reduce(.Min, v8);      // 2
+const v8_min = @reduce(.Min, v8); // 2
 
 // Fixed-length arrays can be automatically assigned to vectors (and vice-versa).
-const single_digit_primes = [4] i8 {2, 3, 5, 7};
+const single_digit_primes = [4]i8{ 2, 3, 5, 7 };
-const prime_vector : @Vector(4, i8) = single_digit_primes;
+const prime_vector: @Vector(4, i8) = single_digit_primes;
 
 // Now let's use vectors to simplify and optimize some code!
 //
@@ -103,8 +103,8 @@ const prime_vector : @Vector(4, i8) = single_digit_primes;
 //
 // Ewa wrote the following function to figure this out.
 
-fn calcMaxPairwiseDiffOld( list1 : [4] f32, list2 : [4] f32) f32 {
+fn calcMaxPairwiseDiffOld(list1: [4]f32, list2: [4]f32) f32 {
-    var max_diff : f32 = 0;
+    var max_diff: f32 = 0;
     for (list1, list2) |n1, n2| {
         const abs_diff = @abs(n1 - n2);
         if (abs_diff > max_diff) {
@@ -120,7 +120,7 @@ fn calcMaxPairwiseDiffOld( list1 : [4] f32, list2 : [4] f32) f32 {
 // Help Ewa finish the vector version! The examples above should help.
 
 const Vec4 = @Vector(4, f32);
-fn calcMaxPairwiseDiffNew( a : Vec4, b : Vec4) f32 {
+fn calcMaxPairwiseDiffNew(a: Vec4, b: Vec4) f32 {
     const abs_diff_vec = ???;
     const max_diff = @reduce(???, abs_diff_vec);
     return max_diff;
@@ -138,8 +138,8 @@ const std = @import("std");
 const print = std.debug.print;
 
 pub fn main() void {
-    const l1 = [4] f32 { 3.141, 2.718, 0.577, 1.000};
+    const l1 = [4]f32{ 3.141, 2.718, 0.577, 1.000 };
-    const l2 = [4] f32 { 3.154, 2.707, 0.591, 0.993};
+    const l2 = [4]f32{ 3.154, 2.707, 0.591, 0.993 };
     const mpd_old = calcMaxPairwiseDiffOld(l1, l2);
     const mpd_new = calcMaxPairwiseDiffNew(l1, l2);
     print("Max difference (old fn): {d: >5.3}\n", .{mpd_old});

patches/patches/109_vectors.patch

@@ -1,12 +1,12 @@
---- exercises/109_vectors.zig	2024-11-03 11:17:00.928652000 +1000
+--- exercises/109_vectors.zig	2024-11-07 14:57:09.673383618 +0100
-+++ answers/109_vectors.zig	2024-11-07 13:11:23.838667200 +1000
++++ answers/109_vectors.zig	2024-11-07 14:22:59.069150138 +0100
 @@ -121,8 +121,8 @@
  
  const Vec4 = @Vector(4, f32);
- fn calcMaxPairwiseDiffNew( a : Vec4, b : Vec4) f32 {
+ fn calcMaxPairwiseDiffNew(a: Vec4, b: Vec4) f32 {
 -    const abs_diff_vec = ???;
 -    const max_diff = @reduce(???, abs_diff_vec);
-+    const abs_diff_vec = @abs( a - b );
++    const abs_diff_vec = @abs(a - b);
 +    const max_diff = @reduce(.Max, abs_diff_vec);
      return max_diff;
  }