larb 0.1.0 → 1.0.0

data/test/larb/mat2_test.rb

@@ -0,0 +1,144 @@
+# frozen_string_literal: true
+
+require_relative "../test_helper"
+
+class Mat2Test < Test::Unit::TestCase
+  def test_new_identity_by_default
+    m = Larb::Mat2.new
+    assert_equal 1.0, m[0]
+    assert_equal 0.0, m[1]
+    assert_equal 0.0, m[2]
+    assert_equal 1.0, m[3]
+  end
+
+  def test_new_with_data
+    m = Larb::Mat2.new([1, 2, 3, 4])
+    assert_equal [1, 2, 3, 4], m.data
+  end
+
+  def test_identity
+    m = Larb::Mat2.identity
+    assert_equal 1.0, m[0]
+    assert_equal 1.0, m[3]
+  end
+
+  def test_zero
+    m = Larb::Mat2.zero
+    4.times { |i| assert_equal 0.0, m[i] }
+  end
+
+  def test_rotation
+    m = Larb::Mat2.rotation(Math::PI / 2)
+    assert_in_delta 0.0, m[0], 1e-10
+    assert_in_delta 1.0, m[1], 1e-10
+    assert_in_delta(-1.0, m[2], 1e-10)
+    assert_in_delta 0.0, m[3], 1e-10
+  end
+
+  def test_scaling
+    m = Larb::Mat2.scaling(2, 3)
+    assert_equal 2.0, m[0]
+    assert_equal 3.0, m[3]
+  end
+
+  def test_from_vec2
+    v1 = Larb::Vec2.new(1, 2)
+    v2 = Larb::Vec2.new(3, 4)
+    m = Larb::Mat2.from_vec2(v1, v2)
+    assert_equal [1.0, 2.0, 3.0, 4.0], m.data
+  end
+
+  def test_multiply_mat2
+    m1 = Larb::Mat2.rotation(Math::PI / 4)
+    m2 = Larb::Mat2.rotation(Math::PI / 4)
+    result = m1 * m2
+    expected = Larb::Mat2.rotation(Math::PI / 2)
+    assert result.near?(expected)
+  end
+
+  def test_multiply_vec2
+    m = Larb::Mat2.rotation(Math::PI / 2)
+    v = Larb::Vec2.new(1, 0)
+    result = m * v
+    assert_in_delta 0.0, result.x, 1e-10
+    assert_in_delta 1.0, result.y, 1e-10
+  end
+
+  def test_multiply_scalar
+    m = Larb::Mat2.identity
+    result = m * 2
+    assert_equal 2.0, result[0]
+    assert_equal 2.0, result[3]
+  end
+
+  def test_add
+    m1 = Larb::Mat2.identity
+    m2 = Larb::Mat2.identity
+    result = m1 + m2
+    assert_equal 2.0, result[0]
+  end
+
+  def test_subtract
+    m1 = Larb::Mat2.identity
+    m2 = Larb::Mat2.identity
+    result = m1 - m2
+    assert_equal 0.0, result[0]
+  end
+
+  def test_determinant
+    m = Larb::Mat2.identity
+    assert_equal 1.0, m.determinant
+  end
+
+  def test_determinant_scaling
+    m = Larb::Mat2.scaling(2, 3)
+    assert_equal 6.0, m.determinant
+  end
+
+  def test_inverse
+    m = Larb::Mat2.scaling(2, 4)
+    inv = m.inverse
+    result = m * inv
+    assert result.near?(Larb::Mat2.identity)
+  end
+
+  def test_inverse_singular
+    m = Larb::Mat2.zero
+    assert_raise_message("Matrix is not invertible") { m.inverse }
+  end
+
+  def test_transpose
+    m = Larb::Mat2.new([1, 2, 3, 4])
+    result = m.transpose
+    assert_equal [1, 3, 2, 4], result.data
+  end
+
+  def test_adjoint
+    m = Larb::Mat2.new([1, 2, 3, 4])
+    adj = m.adjoint
+    assert_equal 4.0, adj[0]
+    assert_equal(-2.0, adj[1])
+  end
+
+  def test_frobenius_norm
+    m = Larb::Mat2.new([1, 2, 2, 0])
+    assert_equal 3.0, m.frobenius_norm
+  end
+
+  def test_equality
+    m1 = Larb::Mat2.identity
+    m2 = Larb::Mat2.identity
+    assert_equal m1, m2
+  end
+
+  def test_near
+    m1 = Larb::Mat2.identity
+    m2 = Larb::Mat2.new([1.0000001, 0, 0, 1.0000001])
+    assert m1.near?(m2)
+  end
+
+  def test_inspect
+    m = Larb::Mat2.identity
+    assert_match(/Mat2/, m.inspect)
+  end
+end

data/test/larb/mat2d_test.rb

@@ -0,0 +1,172 @@
+# frozen_string_literal: true
+
+require_relative "../test_helper"
+
+class Mat2dTest < Test::Unit::TestCase
+  def test_new_identity_by_default
+    m = Larb::Mat2d.new
+    assert_equal 1.0, m[0]
+    assert_equal 0.0, m[1]
+    assert_equal 0.0, m[2]
+    assert_equal 1.0, m[3]
+    assert_equal 0.0, m[4]
+    assert_equal 0.0, m[5]
+  end
+
+  def test_new_with_data
+    data = [1, 2, 3, 4, 5, 6]
+    m = Larb::Mat2d.new(data)
+    assert_equal [1, 2, 3, 4, 5, 6], m.data
+  end
+
+  def test_identity
+    m = Larb::Mat2d.identity
+    assert_equal 1.0, m[0]
+    assert_equal 1.0, m[3]
+  end
+
+  def test_zero
+    m = Larb::Mat2d.zero
+    6.times { |i| assert_equal 0.0, m[i] }
+  end
+
+  def test_translation
+    m = Larb::Mat2d.translation(10, 20)
+    assert_equal 10.0, m[4]
+    assert_equal 20.0, m[5]
+  end
+
+  def test_rotation
+    m = Larb::Mat2d.rotation(Math::PI / 2)
+    assert_in_delta 0.0, m[0], 1e-10
+    assert_in_delta 1.0, m[1], 1e-10
+  end
+
+  def test_scaling
+    m = Larb::Mat2d.scaling(2, 3)
+    assert_equal 2.0, m[0]
+    assert_equal 3.0, m[3]
+  end
+
+  def test_from_rotation_translation_scale
+    m = Larb::Mat2d.from_rotation_translation_scale(
+      0,
+      Larb::Vec2.new(10, 20),
+      Larb::Vec2.new(2, 3)
+    )
+    assert_equal 2.0, m[0]
+    assert_equal 3.0, m[3]
+    assert_equal 10.0, m[4]
+    assert_equal 20.0, m[5]
+  end
+
+  def test_multiply_mat2d
+    m1 = Larb::Mat2d.translation(10, 0)
+    m2 = Larb::Mat2d.translation(5, 0)
+    result = m1 * m2
+    assert_equal 15.0, result[4]
+  end
+
+  def test_multiply_vec2
+    m = Larb::Mat2d.translation(10, 20)
+    v = Larb::Vec2.new(0, 0)
+    result = m * v
+    assert_equal 10.0, result.x
+    assert_equal 20.0, result.y
+  end
+
+  def test_multiply_rotation_translation
+    m = Larb::Mat2d.rotation(Math::PI / 2) * Larb::Mat2d.translation(1, 0)
+    v = Larb::Vec2.new(0, 0)
+    result = m * v
+    assert_in_delta 0.0, result.x, 1e-10
+    assert_in_delta 1.0, result.y, 1e-10
+  end
+
+  def test_determinant
+    m = Larb::Mat2d.identity
+    assert_equal 1.0, m.determinant
+  end
+
+  def test_determinant_scaling
+    m = Larb::Mat2d.scaling(2, 3)
+    assert_equal 6.0, m.determinant
+  end
+
+  def test_inverse
+    m = Larb::Mat2d.translation(10, 20) * Larb::Mat2d.scaling(2, 2)
+    inv = m.inverse
+    result = m * inv
+    assert result.near?(Larb::Mat2d.identity)
+  end
+
+  def test_inverse_singular
+    m = Larb::Mat2d.zero
+    assert_raise_message("Matrix is not invertible") { m.inverse }
+  end
+
+  def test_translate
+    m = Larb::Mat2d.identity
+    result = m.translate(5, 10)
+    assert_equal 5.0, result[4]
+    assert_equal 10.0, result[5]
+  end
+
+  def test_rotate
+    m = Larb::Mat2d.identity
+    result = m.rotate(Math::PI / 2)
+    assert_in_delta 0.0, result[0], 1e-10
+  end
+
+  def test_scale
+    m = Larb::Mat2d.identity
+    result = m.scale(2, 3)
+    assert_equal 2.0, result[0]
+    assert_equal 3.0, result[3]
+  end
+
+  def test_extract_translation
+    m = Larb::Mat2d.translation(10, 20)
+    t = m.extract_translation
+    assert_equal 10.0, t.x
+    assert_equal 20.0, t.y
+  end
+
+  def test_extract_rotation
+    m = Larb::Mat2d.rotation(Math::PI / 4)
+    angle = m.extract_rotation
+    assert_in_delta Math::PI / 4, angle, 1e-10
+  end
+
+  def test_extract_scale
+    m = Larb::Mat2d.scaling(2, 3)
+    s = m.extract_scale
+    assert_in_delta 2.0, s.x, 1e-10
+    assert_in_delta 3.0, s.y, 1e-10
+  end
+
+  def test_to_mat3
+    m = Larb::Mat2d.translation(10, 20)
+    m3 = m.to_mat3
+    assert_instance_of Larb::Mat3, m3
+    assert_equal 10.0, m3[6]
+    assert_equal 20.0, m3[7]
+  end
+
+  def test_equality
+    m1 = Larb::Mat2d.identity
+    m2 = Larb::Mat2d.identity
+    assert_equal m1, m2
+  end
+
+  def test_near
+    m1 = Larb::Mat2d.identity
+    m2 = Larb::Mat2d.new([1.0000001, 0, 0, 1.0000001, 0, 0])
+    assert m1.near?(m2)
+  end
+
+  def test_inspect
+    m = Larb::Mat2d.identity
+    assert_match(/Mat2d/, m.inspect)
+  end
+end

data/test/larb/mat3_test.rb

@@ -0,0 +1,147 @@
+# frozen_string_literal: true
+
+require_relative "../test_helper"
+
+class Mat3Test < Test::Unit::TestCase
+  def test_new_identity_by_default
+    m = Larb::Mat3.new
+    assert_equal 1.0, m[0]
+    assert_equal 1.0, m[4]
+    assert_equal 1.0, m[8]
+  end
+
+  def test_new_with_data
+    data = Array.new(9) { |i| i.to_f }
+    m = Larb::Mat3.new(data)
+    assert_equal data, m.data
+  end
+
+  def test_identity
+    m = Larb::Mat3.identity
+    assert_equal 1.0, m[0]
+    assert_equal 1.0, m[4]
+    assert_equal 1.0, m[8]
+  end
+
+  def test_zero
+    m = Larb::Mat3.zero
+    9.times { |i| assert_equal 0.0, m[i] }
+  end
+
+  def test_from_mat4
+    m4 = Larb::Mat4.identity
+    m3 = Larb::Mat3.from_mat4(m4)
+    assert_equal 1.0, m3[0]
+    assert_equal 1.0, m3[4]
+    assert_equal 1.0, m3[8]
+  end
+
+  def test_from_quaternion
+    q = Larb::Quat.from_axis_angle(Larb::Vec3.new(0, 0, 1), Math::PI / 2)
+    m = Larb::Mat3.from_quaternion(q)
+    assert_in_delta 0.0, m[0], 1e-10
+    assert_in_delta 1.0, m[1], 1e-10
+  end
+
+  def test_translation
+    m = Larb::Mat3.translation(5, 10)
+    assert_equal 5.0, m[6]
+    assert_equal 10.0, m[7]
+  end
+
+  def test_rotation
+    m = Larb::Mat3.rotation(Math::PI / 2)
+    assert_in_delta 0.0, m[0], 1e-10
+    assert_in_delta 1.0, m[1], 1e-10
+  end
+
+  def test_scaling
+    m = Larb::Mat3.scaling(2, 3)
+    assert_equal 2.0, m[0]
+    assert_equal 3.0, m[4]
+  end
+
+  def test_multiply_mat3
+    m1 = Larb::Mat3.identity
+    m2 = Larb::Mat3.translation(1, 2)
+    result = m1 * m2
+    assert_equal 1.0, result[6]
+    assert_equal 2.0, result[7]
+  end
+
+  def test_multiply_vec3
+    m = Larb::Mat3.scaling(2, 3)
+    v = Larb::Vec3.new(1, 1, 1)
+    result = m * v
+    assert_equal 2.0, result.x
+    assert_equal 3.0, result.y
+  end
+
+  def test_determinant
+    m = Larb::Mat3.identity
+    assert_equal 1.0, m.determinant
+  end
+
+  def test_determinant_scaling
+    m = Larb::Mat3.scaling(2, 3)
+    assert_equal 6.0, m.determinant
+  end
+
+  def test_inverse
+    m = Larb::Mat3.scaling(2, 4)
+    inv = m.inverse
+    result = m * inv
+    assert result.near?(Larb::Mat3.identity)
+  end
+
+  def test_inverse_singular
+    m = Larb::Mat3.zero
+    assert_raise_message("Matrix is not invertible") { m.inverse }
+  end
+
+  def test_transpose
+    data = Array.new(9) { |i| i.to_f }
+    m = Larb::Mat3.new(data)
+    result = m.transpose
+    assert_equal 3.0, result[1]
+    assert_equal 1.0, result[3]
+  end
+
+  def test_translate
+    m = Larb::Mat3.identity
+    result = m.translate(5, 10)
+    assert_equal 5.0, result[6]
+    assert_equal 10.0, result[7]
+  end
+
+  def test_rotate
+    m = Larb::Mat3.identity
+    result = m.rotate(Math::PI / 2)
+    assert_in_delta 0.0, result[0], 1e-10
+  end
+
+  def test_scale
+    m = Larb::Mat3.identity
+    result = m.scale(2, 3)
+    assert_equal 2.0, result[0]
+    assert_equal 3.0, result[4]
+  end
+
+  def test_equality
+    m1 = Larb::Mat3.identity
+    m2 = Larb::Mat3.identity
+    assert_equal m1, m2
+  end
+
+  def test_near
+    m1 = Larb::Mat3.identity
+    m2 = Larb::Mat3.identity
+    m2[0] = 1.0000001
+    assert m1.near?(m2)
+  end
+
+  def test_inspect
+    m = Larb::Mat3.identity
+    assert_match(/Mat3/, m.inspect)
+  end
+end

data/test/larb/mat4_test.rb

@@ -0,0 +1,270 @@
+# frozen_string_literal: true
+
+require_relative "../test_helper"
+
+class Mat4Test < Test::Unit::TestCase
+  def test_new_identity_by_default
+    m = Larb::Mat4.new
+    assert_equal 1.0, m[0]
+    assert_equal 1.0, m[5]
+    assert_equal 1.0, m[10]
+    assert_equal 1.0, m[15]
+    assert_equal 0.0, m[1]
+    assert_equal 0.0, m[4]
+  end
+
+  def test_new_with_data
+    data = Array.new(16) { |i| i.to_f }
+    m = Larb::Mat4.new(data)
+    assert_equal data, m.data
+  end
+
+  def test_identity
+    m = Larb::Mat4.identity
+    assert_equal 1.0, m[0]
+    assert_equal 1.0, m[5]
+    assert_equal 1.0, m[10]
+    assert_equal 1.0, m[15]
+  end
+
+  def test_zero
+    m = Larb::Mat4.zero
+    16.times { |i| assert_equal 0.0, m[i] }
+  end
+
+  def test_translation
+    m = Larb::Mat4.translation(1, 2, 3)
+    assert_equal 1.0, m[12]
+    assert_equal 2.0, m[13]
+    assert_equal 3.0, m[14]
+    assert_equal 1.0, m[0]
+    assert_equal 1.0, m[5]
+    assert_equal 1.0, m[10]
+    assert_equal 1.0, m[15]
+  end
+
+  def test_scaling
+    m = Larb::Mat4.scaling(2, 3, 4)
+    assert_equal 2.0, m[0]
+    assert_equal 3.0, m[5]
+    assert_equal 4.0, m[10]
+    assert_equal 1.0, m[15]
+  end
+
+  def test_rotation_x
+    m = Larb::Mat4.rotation_x(Math::PI / 2)
+    assert_equal 1.0, m[0]
+    assert_in_delta 0.0, m[5], 1e-10
+    assert_in_delta 1.0, m[6], 1e-10
+    assert_in_delta(-1.0, m[9], 1e-10)
+    assert_in_delta 0.0, m[10], 1e-10
+  end
+
+  def test_rotation_y
+    m = Larb::Mat4.rotation_y(Math::PI / 2)
+    assert_in_delta 0.0, m[0], 1e-10
+    assert_in_delta(-1.0, m[2], 1e-10)
+    assert_equal 1.0, m[5]
+    assert_in_delta 1.0, m[8], 1e-10
+    assert_in_delta 0.0, m[10], 1e-10
+  end
+
+  def test_rotation_z
+    m = Larb::Mat4.rotation_z(Math::PI / 2)
+    assert_in_delta 0.0, m[0], 1e-10
+    assert_in_delta 1.0, m[1], 1e-10
+    assert_in_delta(-1.0, m[4], 1e-10)
+    assert_in_delta 0.0, m[5], 1e-10
+    assert_equal 1.0, m[10]
+  end
+
+  def test_rotation
+    m = Larb::Mat4.rotation(Larb::Vec3.new(0, 1, 0), Math::PI / 2)
+    assert_in_delta 0.0, m[0], 1e-10
+    assert_in_delta 1.0, m[8], 1e-10
+  end
+
+  def test_look_at
+    eye = Larb::Vec3.new(0, 0, 5)
+    target = Larb::Vec3.new(0, 0, 0)
+    up = Larb::Vec3.new(0, 1, 0)
+    m = Larb::Mat4.look_at(eye, target, up)
+    assert_instance_of Larb::Mat4, m
+    assert_in_delta(-5.0, m[14], 1e-10)
+  end
+
+  def test_perspective
+    m = Larb::Mat4.perspective(Math::PI / 4, 16.0 / 9.0, 0.1, 100.0)
+    assert_instance_of Larb::Mat4, m
+    assert_equal(-1.0, m[11])
+  end
+
+  def test_orthographic
+    m = Larb::Mat4.orthographic(-1, 1, -1, 1, 0.1, 100)
+    assert_instance_of Larb::Mat4, m
+    assert_equal 1.0, m[0]
+    assert_equal 1.0, m[5]
+  end
+
+  def test_index_access
+    m = Larb::Mat4.identity
+    assert_equal 1.0, m[0]
+    assert_equal 0.0, m[1]
+  end
+
+  def test_index_assignment
+    m = Larb::Mat4.identity
+    m[0] = 5.0
+    assert_equal 5.0, m[0]
+  end
+
+  def test_multiply_mat4
+    m1 = Larb::Mat4.translation(1, 0, 0)
+    m2 = Larb::Mat4.translation(0, 1, 0)
+    result = m1 * m2
+    assert_equal 1.0, result[12]
+    assert_equal 1.0, result[13]
+  end
+
+  def test_multiply_identity
+    m = Larb::Mat4.translation(1, 2, 3)
+    result = Larb::Mat4.identity * m
+    assert_equal m.data, result.data
+  end
+
+  def test_multiply_vec4
+    m = Larb::Mat4.translation(1, 2, 3)
+    v = Larb::Vec4.new(0, 0, 0, 1)
+    result = m * v
+    assert_equal 1.0, result.x
+    assert_equal 2.0, result.y
+    assert_equal 3.0, result.z
+    assert_equal 1.0, result.w
+  end
+
+  def test_multiply_vec3
+    m = Larb::Mat4.translation(1, 2, 3)
+    v = Larb::Vec3.new(0, 0, 0)
+    result = m * v
+    assert_equal 1.0, result.x
+    assert_equal 2.0, result.y
+    assert_equal 3.0, result.z
+  end
+
+  def test_transpose
+    data = Array.new(16) { |i| i.to_f }
+    m = Larb::Mat4.new(data)
+    result = m.transpose
+    assert_equal 4.0, result[1]
+    assert_equal 1.0, result[4]
+    assert_equal 8.0, result[2]
+    assert_equal 2.0, result[8]
+  end
+
+  def test_inverse
+    m = Larb::Mat4.translation(1, 2, 3)
+    inv = m.inverse
+    result = m * inv
+    assert_in_delta 1.0, result[0], 1e-10
+    assert_in_delta 1.0, result[5], 1e-10
+    assert_in_delta 1.0, result[10], 1e-10
+    assert_in_delta 1.0, result[15], 1e-10
+    assert_in_delta 0.0, result[12], 1e-10
+    assert_in_delta 0.0, result[13], 1e-10
+    assert_in_delta 0.0, result[14], 1e-10
+  end
+
+  def test_inverse_singular
+    m = Larb::Mat4.zero
+    assert_raise_message("Matrix is not invertible") { m.inverse }
+  end
+
+  def test_to_a
+    m = Larb::Mat4.identity
+    arr = m.to_a
+    assert_equal m.data, arr
+    arr[0] = 999
+    assert_equal 1.0, m.data[0]
+  end
+
+  def test_determinant
+    m = Larb::Mat4.identity
+    assert_equal 1.0, m.determinant
+  end
+
+  def test_determinant_zero
+    m = Larb::Mat4.zero
+    assert_equal 0.0, m.determinant
+  end
+
+  def test_determinant_scaling
+    m = Larb::Mat4.scaling(2, 3, 4)
+    assert_equal 24.0, m.determinant
+  end
+
+  def test_add
+    m1 = Larb::Mat4.identity
+    m2 = Larb::Mat4.identity
+    result = m1 + m2
+    assert_equal 2.0, result[0]
+    assert_equal 2.0, result[5]
+  end
+
+  def test_subtract
+    m1 = Larb::Mat4.identity
+    m2 = Larb::Mat4.identity
+    result = m1 - m2
+    assert_equal 0.0, result[0]
+    assert_equal 0.0, result[5]
+  end
+
+  def test_equality
+    m1 = Larb::Mat4.identity
+    m2 = Larb::Mat4.identity
+    assert_equal m1, m2
+  end
+
+  def test_inequality
+    m1 = Larb::Mat4.identity
+    m2 = Larb::Mat4.translation(1, 0, 0)
+    assert_not_equal m1, m2
+  end
+
+  def test_near
+    m1 = Larb::Mat4.identity
+    m2 = Larb::Mat4.identity
+    m2[0] = 1.0000001
+    assert m1.near?(m2)
+  end
+
+  def test_extract_translation
+    m = Larb::Mat4.translation(1, 2, 3)
+    result = m.extract_translation
+    assert_equal Larb::Vec3.new(1, 2, 3), result
+  end
+
+  def test_extract_scale
+    m = Larb::Mat4.scaling(2, 3, 4)
+    result = m.extract_scale
+    assert_in_delta 2.0, result.x, 1e-10
+    assert_in_delta 3.0, result.y, 1e-10
+    assert_in_delta 4.0, result.z, 1e-10
+  end
+
+  def test_frustum
+    m = Larb::Mat4.frustum(-1, 1, -1, 1, 0.1, 100)
+    assert_instance_of Larb::Mat4, m
+  end
+
+  def test_from_quaternion
+    q = Larb::Quat.from_axis_angle(Larb::Vec3.new(0, 1, 0), Math::PI / 2)
+    m = Larb::Mat4.from_quaternion(q)
+    assert_instance_of Larb::Mat4, m
+    assert_in_delta 0.0, m[0], 1e-10
+  end
+
+  def test_inspect
+    m = Larb::Mat4.identity
+    assert_match(/Mat4/, m.inspect)
+  end
+end