larb 0.1.0 → 1.0.0

data/test/larb/quat2_test.rb

@@ -0,0 +1,161 @@
+# frozen_string_literal: true
+
+require_relative "../test_helper"
+
+class Quat2Test < Test::Unit::TestCase
+  def test_new_identity_by_default
+    q = Larb::Quat2.new
+    assert_equal 1.0, q[3]
+    assert_equal 0.0, q[7]
+  end
+
+  def test_new_with_data
+    data = [0, 0, 0, 1, 0, 0, 0, 0]
+    q = Larb::Quat2.new(data)
+    assert_equal data, q.data
+  end
+
+  def test_identity
+    q = Larb::Quat2.identity
+    assert_equal Larb::Quat.identity, q.real
+  end
+
+  def test_from_rotation_translation
+    rotation = Larb::Quat.from_axis_angle(Larb::Vec3.new(0, 1, 0), Math::PI / 2)
+    translation = Larb::Vec3.new(1, 2, 3)
+    q = Larb::Quat2.from_rotation_translation(rotation, translation)
+    assert q.rotation.near?(rotation)
+    assert q.translation.near?(translation)
+  end
+
+  def test_from_translation
+    translation = Larb::Vec3.new(5, 10, 15)
+    q = Larb::Quat2.from_translation(translation)
+    assert q.translation.near?(translation)
+    assert q.rotation.near?(Larb::Quat.identity)
+  end
+
+  def test_from_rotation
+    rotation = Larb::Quat.from_axis_angle(Larb::Vec3.new(0, 1, 0), Math::PI / 2)
+    q = Larb::Quat2.from_rotation(rotation)
+    assert q.rotation.near?(rotation)
+    assert q.translation.near?(Larb::Vec3.zero)
+  end
+
+  def test_real
+    q = Larb::Quat2.identity
+    assert_instance_of Larb::Quat, q.real
+  end
+
+  def test_dual
+    q = Larb::Quat2.identity
+    assert_instance_of Larb::Quat, q.dual
+  end
+
+  def test_multiply_quat2
+    q1 = Larb::Quat2.from_translation(Larb::Vec3.new(1, 0, 0))
+    q2 = Larb::Quat2.from_translation(Larb::Vec3.new(0, 1, 0))
+    result = q1 * q2
+    assert result.translation.near?(Larb::Vec3.new(1, 1, 0))
+  end
+
+  def test_multiply_vec3
+    q = Larb::Quat2.from_translation(Larb::Vec3.new(10, 0, 0))
+    point = Larb::Vec3.new(0, 0, 0)
+    result = q * point
+    assert result.near?(Larb::Vec3.new(10, 0, 0))
+  end
+
+  def test_add
+    q1 = Larb::Quat2.identity
+    q2 = Larb::Quat2.identity
+    result = q1 + q2
+    assert_equal 2.0, result[3]
+  end
+
+  def test_subtract
+    q1 = Larb::Quat2.identity
+    q2 = Larb::Quat2.identity
+    result = q1 - q2
+    assert_equal 0.0, result[3]
+  end
+
+  def test_dot
+    q = Larb::Quat2.identity
+    assert_equal 1.0, q.dot(q)
+  end
+
+  def test_length
+    q = Larb::Quat2.identity
+    assert_equal 1.0, q.length
+  end
+
+  def test_normalize
+    q = Larb::Quat2.new([0, 0, 0, 2, 0, 0, 0, 0])
+    result = q.normalize
+    assert_in_delta 1.0, result.length, 1e-10
+  end
+
+  def test_conjugate
+    rotation = Larb::Quat.from_axis_angle(Larb::Vec3.new(0, 1, 0), Math::PI / 2)
+    q = Larb::Quat2.from_rotation(rotation)
+    conj = q.conjugate
+    result = q * conj
+    assert result.rotation.near?(Larb::Quat.identity)
+  end
+
+  def test_inverse
+    rotation = Larb::Quat.from_axis_angle(Larb::Vec3.new(0, 1, 0), Math::PI / 4)
+    translation = Larb::Vec3.new(1, 2, 3)
+    q = Larb::Quat2.from_rotation_translation(rotation, translation)
+    inv = q.inverse
+    result = q * inv
+    assert result.rotation.near?(Larb::Quat.identity)
+  end
+
+  def test_translation
+    t = Larb::Vec3.new(5, 10, 15)
+    q = Larb::Quat2.from_translation(t)
+    assert q.translation.near?(t)
+  end
+
+  def test_rotation
+    r = Larb::Quat.from_axis_angle(Larb::Vec3.new(0, 1, 0), Math::PI / 2)
+    q = Larb::Quat2.from_rotation(r)
+    assert q.rotation.near?(r)
+  end
+
+  def test_transform_point
+    rotation = Larb::Quat.from_axis_angle(Larb::Vec3.new(0, 1, 0), Math::PI / 2)
+    translation = Larb::Vec3.new(0, 0, 5)
+    q = Larb::Quat2.from_rotation_translation(rotation, translation)
+    point = Larb::Vec3.new(1, 0, 0)
+    result = q.transform_point(point)
+    assert_in_delta 0.0, result.x, 1e-10
+    assert_in_delta 4.0, result.z, 1e-10
+  end
+
+  def test_lerp
+    q1 = Larb::Quat2.from_translation(Larb::Vec3.new(0, 0, 0))
+    q2 = Larb::Quat2.from_translation(Larb::Vec3.new(10, 0, 0))
+    result = q1.lerp(q2, 0.5)
+    assert_in_delta 5.0, result.translation.x, 1e-6
+  end
+
+  def test_equality
+    q1 = Larb::Quat2.identity
+    q2 = Larb::Quat2.identity
+    assert_equal q1, q2
+  end
+
+  def test_near
+    q1 = Larb::Quat2.identity
+    q2 = Larb::Quat2.new([0, 0, 0, 1.0000001, 0, 0, 0, 0])
+    assert q1.near?(q2)
+  end
+
+  def test_inspect
+    q = Larb::Quat2.identity
+    assert_match(/Quat2/, q.inspect)
+  end
+end

data/test/larb/quat_test.rb

@@ -0,0 +1,224 @@
+# frozen_string_literal: true
+
+require_relative "../test_helper"
+
+class QuatTest < Test::Unit::TestCase
+  def test_new_with_default_values
+    q = Larb::Quat.new
+    assert_equal 0.0, q.x
+    assert_equal 0.0, q.y
+    assert_equal 0.0, q.z
+    assert_equal 1.0, q.w
+  end
+
+  def test_new_with_given_values
+    q = Larb::Quat.new(1, 2, 3, 4)
+    assert_equal 1.0, q.x
+    assert_equal 2.0, q.y
+    assert_equal 3.0, q.z
+    assert_equal 4.0, q.w
+  end
+
+  def test_bracket_syntax
+    q = Larb::Quat[1, 2, 3, 4]
+    assert_equal 1.0, q.x
+    assert_equal 2.0, q.y
+    assert_equal 3.0, q.z
+    assert_equal 4.0, q.w
+  end
+
+  def test_identity
+    q = Larb::Quat.identity
+    assert_equal 0.0, q.x
+    assert_equal 0.0, q.y
+    assert_equal 0.0, q.z
+    assert_equal 1.0, q.w
+  end
+
+  def test_from_axis_angle
+    q = Larb::Quat.from_axis_angle(Larb::Vec3.new(0, 1, 0), Math::PI / 2)
+    assert_in_delta 1.0, q.length, 1e-10
+    assert_in_delta Math.sin(Math::PI / 4), q.y, 1e-10
+    assert_in_delta Math.cos(Math::PI / 4), q.w, 1e-10
+  end
+
+  def test_from_euler
+    q = Larb::Quat.from_euler(0, Math::PI / 2, 0)
+    assert_in_delta 1.0, q.length, 1e-10
+  end
+
+  def test_multiply_quaternions
+    q1 = Larb::Quat.from_axis_angle(Larb::Vec3.new(0, 1, 0), Math::PI / 4)
+    q2 = Larb::Quat.from_axis_angle(Larb::Vec3.new(0, 1, 0), Math::PI / 4)
+    result = q1 * q2
+    expected = Larb::Quat.from_axis_angle(Larb::Vec3.new(0, 1, 0), Math::PI / 2)
+    assert result.near?(expected)
+  end
+
+  def test_multiply_rotates_vector
+    q = Larb::Quat.from_axis_angle(Larb::Vec3.new(0, 1, 0), Math::PI / 2)
+    v = Larb::Vec3.new(1, 0, 0)
+    result = q * v
+    assert_in_delta 0.0, result.x, 1e-10
+    assert_in_delta(-1.0, result.z, 1e-10)
+  end
+
+  def test_multiply_by_scalar
+    q = Larb::Quat.new(1, 2, 3, 4)
+    result = q * 2
+    assert_equal 2.0, result.x
+    assert_equal 4.0, result.y
+    assert_equal 6.0, result.z
+    assert_equal 8.0, result.w
+  end
+
+  def test_add
+    q1 = Larb::Quat.new(1, 2, 3, 4)
+    q2 = Larb::Quat.new(5, 6, 7, 8)
+    result = q1 + q2
+    assert_equal 6.0, result.x
+    assert_equal 8.0, result.y
+    assert_equal 10.0, result.z
+    assert_equal 12.0, result.w
+  end
+
+  def test_subtract
+    q1 = Larb::Quat.new(5, 6, 7, 8)
+    q2 = Larb::Quat.new(1, 2, 3, 4)
+    result = q1 - q2
+    assert_equal 4.0, result.x
+    assert_equal 4.0, result.y
+    assert_equal 4.0, result.z
+    assert_equal 4.0, result.w
+  end
+
+  def test_negate
+    q = Larb::Quat.new(1, 2, 3, 4)
+    result = -q
+    assert_equal(-1.0, result.x)
+    assert_equal(-2.0, result.y)
+    assert_equal(-3.0, result.z)
+    assert_equal(-4.0, result.w)
+  end
+
+  def test_dot
+    q1 = Larb::Quat.new(1, 2, 3, 4)
+    q2 = Larb::Quat.new(5, 6, 7, 8)
+    assert_equal 70.0, q1.dot(q2)
+  end
+
+  def test_length
+    q = Larb::Quat.new(1, 2, 2, 0)
+    assert_equal 3.0, q.length
+  end
+
+  def test_length_squared
+    q = Larb::Quat.new(1, 2, 2, 0)
+    assert_equal 9.0, q.length_squared
+  end
+
+  def test_normalize
+    q = Larb::Quat.new(1, 2, 2, 0)
+    result = q.normalize
+    assert_in_delta 1.0, result.length, 1e-10
+  end
+
+  def test_normalize!
+    q = Larb::Quat.new(1, 2, 2, 0)
+    q.normalize!
+    assert_in_delta 1.0, q.length, 1e-10
+  end
+
+  def test_conjugate
+    q = Larb::Quat.new(1, 2, 3, 4)
+    result = q.conjugate
+    assert_equal(-1.0, result.x)
+    assert_equal(-2.0, result.y)
+    assert_equal(-3.0, result.z)
+    assert_equal 4.0, result.w
+  end
+
+  def test_inverse
+    q = Larb::Quat.from_axis_angle(Larb::Vec3.new(0, 1, 0), Math::PI / 4)
+    inv = q.inverse
+    result = q * inv
+    assert result.near?(Larb::Quat.identity)
+  end
+
+  def test_lerp
+    q1 = Larb::Quat.identity
+    q2 = Larb::Quat.from_axis_angle(Larb::Vec3.new(0, 1, 0), Math::PI / 2)
+    result = q1.lerp(q2, 0.5)
+    assert_in_delta 1.0, result.length, 1e-10
+  end
+
+  def test_slerp
+    q1 = Larb::Quat.identity
+    q2 = Larb::Quat.from_axis_angle(Larb::Vec3.new(0, 1, 0), Math::PI / 2)
+    result = q1.slerp(q2, 0.5)
+    expected = Larb::Quat.from_axis_angle(Larb::Vec3.new(0, 1, 0), Math::PI / 4)
+    assert result.near?(expected, 1e-6)
+  end
+
+  def test_to_axis_angle
+    q = Larb::Quat.from_axis_angle(Larb::Vec3.new(0, 1, 0), Math::PI / 2)
+    axis, angle = q.to_axis_angle
+    assert_in_delta Math::PI / 2, angle, 1e-10
+    assert_in_delta 1.0, axis.y, 1e-10
+  end
+
+  def test_to_euler
+    q = Larb::Quat.from_euler(0.1, 0.2, 0.3)
+    euler = q.to_euler
+    assert_in_delta 0.1, euler.x, 1e-6
+    assert_in_delta 0.2, euler.y, 1e-6
+    assert_in_delta 0.3, euler.z, 1e-6
+  end
+
+  def test_to_mat4
+    q = Larb::Quat.from_axis_angle(Larb::Vec3.new(0, 1, 0), Math::PI / 2)
+    m = q.to_mat4
+    assert_instance_of Larb::Mat4, m
+  end
+
+  def test_to_a
+    q = Larb::Quat.new(1, 2, 3, 4)
+    assert_equal [1.0, 2.0, 3.0, 4.0], q.to_a
+  end
+
+  def test_index_access
+    q = Larb::Quat.new(1, 2, 3, 4)
+    assert_equal 1.0, q[0]
+    assert_equal 2.0, q[1]
+    assert_equal 3.0, q[2]
+    assert_equal 4.0, q[3]
+  end
+
+  def test_equality
+    q1 = Larb::Quat.new(1, 2, 3, 4)
+    q2 = Larb::Quat.new(1, 2, 3, 4)
+    assert_equal q1, q2
+  end
+
+  def test_inequality
+    q1 = Larb::Quat.new(1, 2, 3, 4)
+    q2 = Larb::Quat.new(1, 2, 3, 5)
+    assert_not_equal q1, q2
+  end
+
+  def test_near
+    q1 = Larb::Quat.new(1.0, 2.0, 3.0, 4.0)
+    q2 = Larb::Quat.new(1.0000001, 2.0000001, 3.0000001, 4.0000001)
+    assert q1.near?(q2)
+  end
+
+  def test_inspect
+    q = Larb::Quat.new(1, 2, 3, 4)
+    assert_equal "Quat[1.0, 2.0, 3.0, 4.0]", q.inspect
+  end
+
+  def test_to_s
+    q = Larb::Quat.new(1, 2, 3, 4)
+    assert_equal q.inspect, q.to_s
+  end
+end

data/test/larb/vec2_test.rb

@@ -0,0 +1,251 @@
+# frozen_string_literal: true
+
+require_relative "../test_helper"
+
+class Vec2Test < Test::Unit::TestCase
+  def test_new_with_default_values
+    v = Larb::Vec2.new
+    assert_equal 0.0, v.x
+    assert_equal 0.0, v.y
+  end
+
+  def test_new_with_given_values
+    v = Larb::Vec2.new(3, 4)
+    assert_equal 3.0, v.x
+    assert_equal 4.0, v.y
+  end
+
+  def test_bracket_syntax
+    v = Larb::Vec2[1, 2]
+    assert_equal 1.0, v.x
+    assert_equal 2.0, v.y
+  end
+
+  def test_zero
+    v = Larb::Vec2.zero
+    assert_equal 0.0, v.x
+    assert_equal 0.0, v.y
+  end
+
+  def test_one
+    v = Larb::Vec2.one
+    assert_equal 1.0, v.x
+    assert_equal 1.0, v.y
+  end
+
+  def test_add
+    v1 = Larb::Vec2.new(1, 2)
+    v2 = Larb::Vec2.new(3, 4)
+    result = v1 + v2
+    assert_equal 4.0, result.x
+    assert_equal 6.0, result.y
+  end
+
+  def test_subtract
+    v1 = Larb::Vec2.new(5, 7)
+    v2 = Larb::Vec2.new(2, 3)
+    result = v1 - v2
+    assert_equal 3.0, result.x
+    assert_equal 4.0, result.y
+  end
+
+  def test_multiply_by_scalar
+    v = Larb::Vec2.new(2, 3)
+    result = v * 2
+    assert_equal 4.0, result.x
+    assert_equal 6.0, result.y
+  end
+
+  def test_divide_by_scalar
+    v = Larb::Vec2.new(6, 8)
+    result = v / 2
+    assert_equal 3.0, result.x
+    assert_equal 4.0, result.y
+  end
+
+  def test_negate
+    v = Larb::Vec2.new(1, -2)
+    result = -v
+    assert_equal(-1.0, result.x)
+    assert_equal 2.0, result.y
+  end
+
+  def test_dot
+    v1 = Larb::Vec2.new(1, 2)
+    v2 = Larb::Vec2.new(3, 4)
+    assert_equal 11.0, v1.dot(v2)
+  end
+
+  def test_length
+    v = Larb::Vec2.new(3, 4)
+    assert_equal 5.0, v.length
+  end
+
+  def test_length_squared
+    v = Larb::Vec2.new(3, 4)
+    assert_equal 25.0, v.length_squared
+  end
+
+  def test_normalize
+    v = Larb::Vec2.new(3, 4)
+    result = v.normalize
+    assert_in_delta 0.6, result.x, 1e-10
+    assert_in_delta 0.8, result.y, 1e-10
+  end
+
+  def test_normalize!
+    v = Larb::Vec2.new(3, 4)
+    v.normalize!
+    assert_in_delta 0.6, v.x, 1e-10
+    assert_in_delta 0.8, v.y, 1e-10
+  end
+
+  def test_lerp
+    v1 = Larb::Vec2.new(0, 0)
+    v2 = Larb::Vec2.new(10, 20)
+    result = v1.lerp(v2, 0.5)
+    assert_equal 5.0, result.x
+    assert_equal 10.0, result.y
+  end
+
+  def test_to_a
+    v = Larb::Vec2.new(1, 2)
+    assert_equal [1.0, 2.0], v.to_a
+  end
+
+  def test_index_access
+    v = Larb::Vec2.new(1, 2)
+    assert_equal 1.0, v[0]
+    assert_equal 2.0, v[1]
+  end
+
+  def test_index_assignment
+    v = Larb::Vec2.new(0, 0)
+    v[0] = 5
+    v[1] = 6
+    assert_equal 5, v.x
+    assert_equal 6, v.y
+  end
+
+  def test_equality
+    v1 = Larb::Vec2.new(1, 2)
+    v2 = Larb::Vec2.new(1, 2)
+    assert_equal v1, v2
+  end
+
+  def test_inequality
+    v1 = Larb::Vec2.new(1, 2)
+    v2 = Larb::Vec2.new(1, 3)
+    assert_not_equal v1, v2
+  end
+
+  def test_not_equal_to_array
+    v = Larb::Vec2.new(1, 2)
+    assert_not_equal v, [1, 2]
+  end
+
+  def test_near_true
+    v1 = Larb::Vec2.new(1.0, 2.0)
+    v2 = Larb::Vec2.new(1.0000001, 2.0000001)
+    assert v1.near?(v2)
+  end
+
+  def test_near_false
+    v1 = Larb::Vec2.new(1.0, 2.0)
+    v2 = Larb::Vec2.new(1.1, 2.1)
+    assert_false v1.near?(v2)
+  end
+
+  def test_angle
+    v = Larb::Vec2.new(1, 0)
+    assert_equal 0.0, v.angle
+  end
+
+  def test_angle_up
+    v = Larb::Vec2.new(0, 1)
+    assert_in_delta Math::PI / 2, v.angle, 1e-10
+  end
+
+  def test_angle_to
+    v1 = Larb::Vec2.new(0, 0)
+    v2 = Larb::Vec2.new(1, 0)
+    assert_equal 0.0, v1.angle_to(v2)
+  end
+
+  def test_rotate
+    v = Larb::Vec2.new(1, 0)
+    result = v.rotate(Math::PI / 2)
+    assert_in_delta 0.0, result.x, 1e-10
+    assert_in_delta 1.0, result.y, 1e-10
+  end
+
+  def test_distance
+    v1 = Larb::Vec2.new(0, 0)
+    v2 = Larb::Vec2.new(3, 4)
+    assert_equal 5.0, v1.distance(v2)
+  end
+
+  def test_distance_squared
+    v1 = Larb::Vec2.new(0, 0)
+    v2 = Larb::Vec2.new(3, 4)
+    assert_equal 25.0, v1.distance_squared(v2)
+  end
+
+  def test_cross
+    v1 = Larb::Vec2.new(1, 0)
+    v2 = Larb::Vec2.new(0, 1)
+    assert_equal 1.0, v1.cross(v2)
+  end
+
+  def test_perpendicular
+    v = Larb::Vec2.new(1, 0)
+    result = v.perpendicular
+    assert_equal 0.0, result.x
+    assert_equal 1.0, result.y
+  end
+
+  def test_reflect
+    v = Larb::Vec2.new(1, -1).normalize
+    normal = Larb::Vec2.new(0, 1)
+    result = v.reflect(normal)
+    assert_in_delta v.x, result.x, 1e-10
+    assert_in_delta(-v.y, result.y, 1e-10)
+  end
+
+  def test_clamp_length
+    v = Larb::Vec2.new(3, 4)
+    result = v.clamp_length(2.5)
+    assert_in_delta 2.5, result.length, 1e-10
+  end
+
+  def test_clamp_length_under_limit
+    v = Larb::Vec2.new(1, 1)
+    result = v.clamp_length(10)
+    assert_equal v, result
+  end
+
+  def test_to_vec3
+    v = Larb::Vec2.new(1, 2)
+    result = v.to_vec3
+    assert_instance_of Larb::Vec3, result
+    assert_equal 1.0, result.x
+    assert_equal 2.0, result.y
+    assert_equal 0.0, result.z
+  end
+
+  def test_to_vec3_with_custom_z
+    v = Larb::Vec2.new(1, 2)
+    result = v.to_vec3(5)
+    assert_equal 5.0, result.z
+  end
+
+  def test_inspect
+    v = Larb::Vec2.new(1, 2)
+    assert_equal "Vec2[1.0, 2.0]", v.inspect
+  end
+
+  def test_to_s
+    v = Larb::Vec2.new(1, 2)
+    assert_equal v.inspect, v.to_s
+  end
+end