Add benchmarks for modules.

bench/mat33_bench.exs

@@ -0,0 +1,79 @@
+alias Graphmath.Mat33
+
+# Test data setup - 3x3 matrices stored as 9-element tuples (row-major)
+mat33_a = {1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0}
+mat33_b = {9.0, 8.0, 7.0, 6.0, 5.0, 4.0, 3.0, 2.0, 1.0}
+mat33_invertible = {1.0, 0.0, 0.0, 0.0, 2.0, 0.0, 0.0, 0.0, 3.0}
+vec2 = {3.0, 4.0}
+vec3 = {3.0, 4.0, 1.0}
+scalar = 2.5
+angle = :math.pi() / 4
+mat33_list = for _ <- 1..10, do: Mat33.identity()
+
+Benchee.run(
+  %{
+    "Baseline" => fn -> {1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0} end,
+
+    # Identity and creation
+    "Mat33.identity/0" => fn -> Mat33.identity() end,
+    "Mat33.zero/0" => fn -> Mat33.zero() end,
+
+    # Basic arithmetic
+    "Mat33.add/2" => fn -> Mat33.add(mat33_a, mat33_b) end,
+    "Mat33.subtract/2" => fn -> Mat33.subtract(mat33_a, mat33_b) end,
+    "Mat33.scale/2" => fn -> Mat33.scale(mat33_a, scalar) end,
+
+    # Matrix multiplication
+    "Mat33.multiply/2" => fn -> Mat33.multiply(mat33_a, mat33_b) end,
+    "Mat33.multiply_transpose/2" => fn -> Mat33.multiply_transpose(mat33_a, mat33_b) end,
+
+    # Inverse
+    "Mat33.inverse/1" => fn -> Mat33.inverse(mat33_invertible) end,
+
+    # Vector transformation
+    "Mat33.apply/2 (vec2)" => fn -> Mat33.apply(mat33_a, vec3) end,
+    "Mat33.apply_transpose/2 (vec2)" => fn -> Mat33.apply_transpose(mat33_a, vec3) end,
+    "Mat33.apply_left/2 (vec2)" => fn -> Mat33.apply_left(vec3,mat33_a) end,
+    "Mat33.apply_left_transpose/2 (vec2)" => fn -> Mat33.apply_left_transpose(vec3,mat33_a) end,
+    "Mat33.transform_point/2" => fn -> Mat33.transform_point(mat33_a, vec2) end,
+    "Mat33.transform_vector/2" => fn -> Mat33.transform_vector(mat33_a, vec2) end,
+
+    # Rotation matrices
+    "Mat33.make_rotate/1" => fn -> Mat33.make_rotate(angle) end,
+
+    # Scale matrices
+    "Mat33.make_scale/1 (uniform)" => fn -> Mat33.make_scale(2.0) end,
+    "Mat33.make_scale/2" => fn -> Mat33.make_scale(1.0, 2.0, 3.0) end,
+
+    # Translation matrices
+    "Mat33.make_translate/2" => fn -> Mat33.make_translate(5.0, 10.0) end,
+
+    # Component access
+    "Mat33.at/3" => fn -> Mat33.at(mat33_a, 1, 1) end,
+    "Mat33.row0/1" => fn -> Mat33.row0(mat33_a) end,
+    "Mat33.row1/1" => fn -> Mat33.row1(mat33_a) end,
+    "Mat33.row2/1" => fn -> Mat33.row2(mat33_a) end,
+    "Mat33.column0/1" => fn -> Mat33.column0(mat33_a) end,
+    "Mat33.column1/1" => fn -> Mat33.column1(mat33_a) end,
+    "Mat33.column2/1" => fn -> Mat33.column2(mat33_a) end,
+    "Mat33.diag/1" => fn -> Mat33.diag(mat33_a) end,
+
+    # Round-trip operations
+    "Mat33 rotate->inverse" => fn ->
+      m = Mat33.make_rotate(angle)
+      Mat33.inverse(m)
+    end,
+
+    # Batch operation (chain multiply 10 matrices)
+    "Mat33 batch multiply (10 matrices)" => fn ->
+      Enum.reduce(mat33_list, Mat33.identity(), &Mat33.multiply/2)
+    end
+  },
+  warmup: 2,
+  time: 5,
+  memory_time: 2,
+  formatters: [
+    Benchee.Formatters.Console,
+    {Benchee.Formatters.Markdown, file: "bench/results/mat33_results.md"}
+  ]
+)

bench/mat44_bench.exs

@@ -0,0 +1,74 @@
+alias Graphmath.Mat44
+
+# Test data setup - 4x4 matrices stored as 16-element tuples (row-major)
+mat44_a = {1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0}
+mat44_b = {16.0, 15.0, 14.0, 13.0, 12.0, 11.0, 10.0, 9.0, 8.0, 7.0, 6.0, 5.0, 4.0, 3.0, 2.0, 1.0}
+vec3 = {3.0, 4.0, 5.0}
+vec4 = {3.0, 4.0, 5.0, 1.0}
+scalar = 2.5
+angle = :math.pi() / 4
+mat44_list = for _ <- 1..10, do: Mat44.identity()
+
+Benchee.run(
+  %{
+    # Identity and creation
+    "Mat44.identity/0" => fn -> Mat44.identity() end,
+    "Mat44.zero/0" => fn -> Mat44.zero() end,
+
+    # Basic arithmetic
+    "Mat44.add/2" => fn -> Mat44.add(mat44_a, mat44_b) end,
+    "Mat44.subtract/2" => fn -> Mat44.subtract(mat44_a, mat44_b) end,
+    "Mat44.scale/2" => fn -> Mat44.scale(mat44_a, scalar) end,
+
+    # Matrix multiplication
+    "Mat44.multiply/2" => fn -> Mat44.multiply(mat44_a, mat44_b) end,
+    "Mat44.multiply_transpose/2" => fn -> Mat44.multiply_transpose(mat44_a, mat44_b) end,
+
+    # Vector transformation
+    "Mat44.apply/2 (vec3)" => fn -> Mat44.apply(mat44_a, vec4) end,
+    "Mat44.apply_transpose/2 (vec3)" => fn -> Mat44.apply_transpose(mat44_a, vec4) end,
+    "Mat44.apply_left/2 (vec3)" => fn -> Mat44.apply_left(vec4, mat44_a) end,
+    "Mat44.apply_left_transpose/2 (vec3)" => fn -> Mat44.apply_left_transpose(vec4, mat44_a) end,
+    "Mat44.transform_point/2" => fn -> Mat44.transform_point(mat44_a, vec3) end,
+    "Mat44.transform_vector/2" => fn -> Mat44.transform_vector(mat44_a, vec3) end,
+
+    # Rotation matrices
+    "Mat44.make_rotate_x/1" => fn -> Mat44.make_rotate_x(angle) end,
+    "Mat44.make_rotate_y/1" => fn -> Mat44.make_rotate_y(angle) end,
+    "Mat44.make_rotate_z/1" => fn -> Mat44.make_rotate_z(angle) end,
+
+    # Scale matrices
+    "Mat44.make_scale/1 (uniform)" => fn -> Mat44.make_scale(2.0) end,
+    "Mat44.make_scale/4" => fn -> Mat44.make_scale(2.0, 3.0, 4.0, 5.0) end,
+
+    # Translation matrices
+    "Mat44.make_translate/3" => fn -> Mat44.make_translate(5.0, 10.0, 15.0) end,
+
+    # Component access
+    "Mat44.row0/1" => fn -> Mat44.row0(mat44_a) end,
+    "Mat44.row1/1" => fn -> Mat44.row1(mat44_a) end,
+    "Mat44.row2/1" => fn -> Mat44.row2(mat44_a) end,
+    "Mat44.row3/1" => fn -> Mat44.row3(mat44_a) end,
+    "Mat44.column0/1" => fn -> Mat44.column0(mat44_a) end,
+    "Mat44.column1/1" => fn -> Mat44.column1(mat44_a) end,
+    "Mat44.column2/1" => fn -> Mat44.column2(mat44_a) end,
+    "Mat44.column3/1" => fn -> Mat44.column3(mat44_a) end,
+    "Mat44.diag/1" => fn -> Mat44.diag(mat44_a) end,
+    "Mat44.at/3" => fn -> Mat44.at(mat44_a, 2, 2) end,
+
+    # Extract submatrices
+    "Mat44.round/2" => fn -> Mat44.round(mat44_a, 3) end,
+
+    # Batch operation (chain multiply 10 matrices)
+    "Mat44 batch multiply (10 matrices)" => fn ->
+      Enum.reduce(mat44_list, Mat44.identity(), &Mat44.multiply/2)
+    end
+  },
+  warmup: 2,
+  time: 5,
+  memory_time: 2,
+  formatters: [
+    Benchee.Formatters.Console,
+    {Benchee.Formatters.Markdown, file: "bench/results/mat44_results.md"}
+  ]
+)

bench/quatern_bench.exs

@@ -0,0 +1,100 @@
+alias Graphmath.Quatern
+alias Graphmath.Mat33
+
+# Test data setup - quaternions stored as {w, x, y, z}
+quat_a = Quatern.from_axis_angle(:math.pi() / 4, {0.0, 1.0, 0.0})
+quat_b = Quatern.from_axis_angle(:math.pi() / 3, {1.0, 0.0, 0.0})
+quat_identity = Quatern.identity()
+vec3 = {3.0, 4.0, 5.0}
+scalar = 2.5
+angle = :math.pi() / 4
+axis = {0.0, 1.0, 0.0}
+quat_list = for _ <- 1..10, do: Quatern.identity()
+
+Benchee.run(
+  %{
+    # Baseline
+    "Baseline" => fn -> {1.0, 0.0, 0.0, 0.0} end,
+
+    # Identity and creation
+    "Quatern.zero/0" => fn -> Quatern.zero() end,
+    "Quatern.identity/0" => fn -> Quatern.identity() end,
+    "Quatern.from_axis_angle/2" => fn -> Quatern.from_axis_angle(angle, axis) end,
+    "Quatern.random/0" => fn -> Quatern.random() end,
+
+    # Basic arithmetic
+    "Quatern.add/2" => fn -> Quatern.add(quat_a, quat_b) end,
+    "Quatern.subtract/2" => fn -> Quatern.subtract(quat_a, quat_b) end,
+    "Quatern.scale/2" => fn -> Quatern.scale(quat_a, scalar) end,
+
+    # Quaternion multiplication (Hamilton product)
+    "Quatern.multiply/2" => fn -> Quatern.multiply(quat_a, quat_b) end,
+
+    # Conjugate and inverse
+    "Quatern.conjugate/1" => fn -> Quatern.conjugate(quat_a) end,
+    "Quatern.inverse/1" => fn -> Quatern.inverse(quat_a) end,
+
+    # Length operations
+    "Quatern.norm/1" => fn -> Quatern.norm(quat_a) end,
+    "Quatern.normalize/1" => fn -> Quatern.normalize(quat_a) end,
+    "Quatern.normalize_strict/1" => fn -> Quatern.normalize_strict(quat_a) end,
+
+    # Vector rotation
+    "Quatern.transform_vector/2" => fn -> Quatern.transform_vector(quat_a, vec3) end,
+
+    # Interpolation
+    "Quatern.slerp/3" => fn -> Quatern.slerp(quat_a, quat_b, 0.5) end,
+
+    # Dot product
+    "Quatern.dot/2" => fn -> Quatern.dot(quat_a, quat_b) end,
+
+    # Comparison
+    "Quatern.equal/2" => fn -> Quatern.equal(quat_a, quat_b) end,
+    "Quatern.equal/3 (epsilon)" => fn -> Quatern.equal(quat_a, quat_b, 0.001) end,
+    "Quatern.equal_elements/2" => fn -> Quatern.equal_elements(quat_a, quat_b) end,
+    "Quatern.equal_elements/3 (epsilon)" => fn -> Quatern.equal_elements(quat_a, quat_b, 0.001) end,
+
+    # Conversion
+    "Quatern.to_rotation_matrix_33/1" => fn -> Quatern.to_rotation_matrix_33(quat_a) end,
+    "Quatern.to_rotation_matrix_44/1" => fn -> Quatern.to_rotation_matrix_44(quat_a) end,
+    "Quatern.from_rotation_matrix/1" => fn ->
+      mat = Mat33.make_rotate(angle)
+      Quatern.from_rotation_matrix(mat)
+    end,
+    "Quatern.from_axis_angle/1" => fn -> Quatern.from_axis_angle( 0.0, {1,0,0}) end,
+    "Quatern.from_list/1" => fn -> Quatern.from_list([1,2,3,0]) end,
+
+    # Pitch/yaw/roll extraction
+    "Quatern.get_pitch/1" => fn -> Quatern.get_pitch(quat_a) end,
+    "Quatern.get_yaw/1" => fn -> Quatern.get_yaw(quat_a) end,
+    "Quatern.get_roll/1" => fn -> Quatern.get_roll(quat_a) end,
+
+    # Complex operations
+    "Quatern.integrate" => fn -> Quatern.integrate({1.0, 0.0, 0.0, 0.0}, {0.0, :math.pi(), 0.0}, 1.0) end,
+    "Quatern rotate->inverse->transform" => fn ->
+      q = Quatern.from_axis_angle(angle, {0.0, 1.0, 0.0})
+      q_inv = Quatern.inverse(q)
+      rotated = Quatern.transform_vector(q, vec3)
+      Quatern.transform_vector(q_inv, rotated)
+    end,
+
+    # Batch operation (chain multiply 10 quaternions)
+    "Quatern batch multiply (10 quaternions)" => fn ->
+      Enum.reduce(quat_list, Quatern.identity(), &Quatern.multiply/2)
+    end,
+
+    # Slerp chain (useful for animation)
+    "Quatern slerp chain (10 steps)" => fn ->
+      for t <- 0..9 do
+        Quatern.slerp(quat_a, quat_b, t / 9.0)
+      end
+    end
+  },
+  warmup: 2,
+  time: 5,
+  memory_time: 2,
+  formatters: [
+    Benchee.Formatters.Console,
+    {Benchee.Formatters.Markdown, file: "bench/results/quatern_results.md"}
+  ]
+)

bench/vec2_bench.exs

@@ -0,0 +1,74 @@
+alias Graphmath.Vec2
+
+# Test data setup
+vec2_a = {1.5, 2.5}
+vec2_b = {3.0, 4.0}
+vec2_list = for _ <- 1..100, do: {Enum.random(1..1000) / 1.0, Enum.random(1..1000) / 1.0}
+scalar = 2.5
+angle = :math.pi() / 4
+
+Benchee.run(
+  %{
+    # Invocation reference
+    "Baseline/0" => fn -> {1,2} end,
+
+    # Creation
+    "Vec2.create/0" => fn -> Vec2.create() end,
+    "Vec2.create/2" => fn -> Vec2.create(1.5, 2.5) end,
+
+    # Basic arithmetic
+    "Vec2.add/2" => fn -> Vec2.add(vec2_a, vec2_b) end,
+    "Vec2.subtract/2" => fn -> Vec2.subtract(vec2_a, vec2_b) end,
+    "Vec2.multiply/2" => fn -> Vec2.multiply(vec2_a, vec2_b) end,
+    "Vec2.scale/2" => fn -> Vec2.scale(vec2_a, scalar) end,
+
+    # Products
+    "Vec2.dot/2" => fn -> Vec2.dot(vec2_a, vec2_b) end,
+    "Vec2.perp_prod/2" => fn -> Vec2.perp_prod(vec2_a, vec2_b) end,
+
+    # Length operations
+    "Vec2.length/1" => fn -> Vec2.length(vec2_a) end,
+    "Vec2.length_squared/1" => fn -> Vec2.length_squared(vec2_a) end,
+    "Vec2.length_manhattan/1" => fn -> Vec2.length_manhattan(vec2_a) end,
+    "Vec2.normalize/1" => fn -> Vec2.normalize(vec2_a) end,
+    "Vec2.p_norm/2" => fn -> Vec2.p_norm(vec2_a, 1) end,
+
+    # Distance operations
+    "Vec2.chebyshev_distance/2" => fn -> Vec2.chebyshev_distance(vec2_a, vec2_b) end,
+    "Vec2.minkowski_distance/2" => fn -> Vec2.minkowski_distance(vec2_a, vec2_b, 2) end,
+
+    # Interpolation
+    "Vec2.lerp/3" => fn -> Vec2.lerp(vec2_a, vec2_b, 0.5) end,
+
+    # Rotation
+    "Vec2.rotate/2" => fn -> Vec2.rotate(vec2_a, angle) end,
+
+    # Comparison
+    "Vec2.equal/2" => fn -> Vec2.equal(vec2_a, vec2_b) end,
+    "Vec2.equal/3 (epsilon)" => fn -> Vec2.equal(vec2_a, vec2_b, 0.001) end,
+    "Vec2.near/3" => fn -> Vec2.near(vec2_a, vec2_b, 0.001) end,
+
+    # Projection/Reflection
+    "Vec2.project/2" => fn -> Vec2.project(vec2_a, vec2_b) end,
+
+    # Perpendicular
+    "Vec2.perp/1" => fn -> Vec2.perp(vec2_a) end,
+
+    # Random generation
+    "Vec2.random_circle/0" => fn -> Vec2.random_circle() end,
+    "Vec2.random_disc/0" => fn -> Vec2.random_disc() end,
+    "Vec2.random_box/0" => fn -> Vec2.random_box() end,
+
+    # Batch operation (sum of list)
+    "Vec2 batch add (100 vectors)" => fn ->
+      Enum.reduce(vec2_list, {0.0, 0.0}, &Vec2.add/2)
+    end
+  },
+  warmup: 2,
+  time: 5,
+  memory_time: 2,
+  formatters: [
+    Benchee.Formatters.Console,
+    {Benchee.Formatters.Markdown, file: "bench/results/vec2_results.md"}
+  ]
+)