larb 1.0.0 → 1.0.1

data/test/larb/quat2_test.rb

@@ -158,4 +158,97 @@ class Quat2Test < Test::Unit::TestCase
     q = Larb::Quat2.identity
     assert_match(/Quat2/, q.inspect)
   end
+
+  def test_matrix_and_point_transform_agree
+    rotation = Larb::Quat.from_axis_angle(Larb::Vec3.forward, Math::PI / 2)
+    q = Larb::Quat2.from_rotation_translation(rotation, Larb::Vec3.new(1, 2, 3))
+    [Larb::Vec3.zero, Larb::Vec3.new(4, -2, 7)].each do |point|
+      actual = (q.to_mat4 * Larb::Vec4.new(*point.to_a, 1)).xyz
+      assert_components q.transform_point(point).to_a, actual
+    end
+    assert_components [1, 2, 3], q.to_mat4.extract_translation
+  end
+
+  def test_lerp_preserves_antipodal_rigid_transforms
+    rotation = Larb::Quat.from_axis_angle(Larb::Vec3.up, 0.7)
+    q = Larb::Quat2.from_rotation_translation(rotation, Larb::Vec3.new(1, 2, 3))
+    [0, 0.5, 1].each do |t|
+      result = (q * 1e200).lerp(q * -1e-200, t)
+      assert_components q.to_a, result
+      assert_components q.transform_point(Larb::Vec3.right).to_a,
+                        result.transform_point(Larb::Vec3.right)
+    end
+  end
+
+  def test_lerp_preserves_real_dual_orthogonality
+    a = Larb::Quat2.identity
+    b = Larb::Quat2.from_rotation_translation(Larb::Quat.new(0, 0, 1, 0), Larb::Vec3.new(0, 0, 2))
+    [0, 0.25, 0.5, 0.75, 1].each do |t|
+      q = a.lerp(b, t)
+      assert q.to_a.all?(&:finite?)
+      assert_in_delta 1.0, q.real.length, 1e-12
+      assert_in_delta 0.0, q.real.dot(q.dual), 1e-12
+      assert_components Larb::Quat2.identity.to_a, q * q.inverse
+    end
+  end
+
+  def test_normalization_removes_parallel_dual_component
+    q = Larb::Quat2.new([0, 0, 0, 2, 4, 6, 8, 10])
+    assert_components [0, 0, 0, 1, 2, 3, 4, 0], q.normalize
+    assert_same q, q.normalize!
+    assert_components [0, 0, 0, 1, 2, 3, 4, 0], q
+    assert_components Larb::Quat2.identity.to_a,
+                      Larb::Quat2.new([0, 0, 0, 1e-200, 0, 0, 0, 1e200]).normalize
+  end
+
+  def test_normalization_and_inverse_across_extreme_magnitudes
+    q = Larb::Quat2.from_translation(Larb::Vec3.new(1, 2, 3))
+    [1e200, 1e-200].each do |magnitude|
+      scaled = q * magnitude
+      assert_equal magnitude, scaled.length
+      assert_components q.to_a, scaled.normalize
+      assert_components Larb::Quat2.identity.to_a, scaled * scaled.inverse
+      assert_same scaled, scaled.normalize!
+      assert_components q.to_a, scaled
+    end
+    assert_components [0.5, 0.5, 0.5, 0.5, 0, 0, 0, 0],
+                      Larb::Quat2.new([Float::MAX] * 4 + [0] * 4).normalize
+  end
+
+  def test_normalization_preserves_subnormal_dual_components
+    magnitude = Float::MIN * Float::EPSILON
+    q = Larb::Quat2.new([magnitude] * 4 + [magnitude, -magnitude] * 2)
+    expected = [0.5] * 4 + [0.5, -0.5] * 2
+    assert_components expected, q.normalize
+    assert_same q, q.normalize!
+    assert_components expected, q
+  end
+
+  def test_inverse_supports_nonorthogonal_dual_quaternions
+    q = Larb::Quat2.new([2, 3, 4, 5, 6, 7, 8, 9])
+    assert_components Larb::Quat2.identity.to_a, q * q.inverse
+    assert_components Larb::Quat2.identity.to_a, q.inverse * q
+  end
+
+  def test_degenerate_dual_quaternions_are_rejected_atomically
+    [[0] * 8, [0, 0, 0, Float::INFINITY, 0, 0, 0, 0],
+     [0, 0, 0, 2, 3, Float::INFINITY, 0, 0]].each do |values|
+      q = Larb::Quat2.new(values)
+      %i[normalize normalize! inverse].each do |method|
+        assert_raise(ArgumentError) { q.public_send(method) }
+        assert_equal values, q.to_a
+      end
+      assert_raise(ArgumentError) { Larb::Quat2.identity.lerp(q, 0.5) }
+    end
+  end
+
+  private
+
+  def assert_components(expected, actual)
+    assert_equal expected.size, actual.to_a.size
+    expected.zip(actual.to_a).each do |wanted, value|
+      assert value.finite?, "expected finite component, got #{value.inspect}"
+      assert_in_delta wanted, value, 1e-10
+    end
+  end
 end

data/test/larb/quat_test.rb

@@ -221,4 +221,64 @@ class QuatTest < Test::Unit::TestCase
     q = Larb::Quat.new(1, 2, 3, 4)
     assert_equal q.inspect, q.to_s
   end
+
+  def test_interpolation_preserves_antipodal_rotations
+    q = Larb::Quat.from_axis_angle(Larb::Vec3.up, 0.7)
+    %i[lerp slerp].each do |method|
+      [0, 0.5, 1].each do |t|
+        result = (q * 1e200).public_send(method, q * -1e-200, t)
+        assert_components q.to_a, result
+        assert_in_delta 1.0, result.length, 1e-12
+      end
+      assert_raise(ArgumentError) { q.public_send(method, Larb::Quat.new(0, 0, 0, 0), 0.5) }
+      assert_raise(ArgumentError) { q.public_send(method, q, Float::NAN) }
+    end
+  end
+
+  def test_normalization_and_inverse_across_extreme_magnitudes
+    [1e200, 1e-200, Float::MAX, Float::MIN].each do |magnitude|
+      q = Larb::Quat.new(magnitude, 0, 0, 0)
+      assert_equal magnitude, q.length
+      assert_components [1, 0, 0, 0], q.normalize
+      assert_components [0, 0, 0, 1], q * q.inverse
+      assert_same q, q.normalize!
+      assert_components [1, 0, 0, 0], q
+    end
+    assert_components [0.5, 0.5, 0.5, 0.5], Larb::Quat.new(*[Float::MAX] * 4).normalize
+  end
+
+  def test_degenerate_quaternions_cannot_be_normalized_or_inverted
+    [0, Float::INFINITY, Float::NAN].each do |value|
+      q = Larb::Quat.new(value, 0, 0, 0)
+      %i[normalize normalize! inverse to_axis_angle].each do |method|
+        assert_raise(ArgumentError) { q.public_send(method) }
+      end
+      assert_equal [0.0, 0.0, 0.0], q.to_a.drop(1)
+      value.is_a?(Float) && value.nan? ? assert(q.x.nan?) : assert_equal(value, q.x)
+    end
+  end
+
+  def test_small_axis_angles_round_trip
+    [1e-3, 1e-12, 1e-200].each do |angle|
+      q = Larb::Quat.from_axis_angle(Larb::Vec3.up, angle)
+      axis, actual_angle = q.to_axis_angle
+      assert_components [0, 1, 0], axis
+      assert actual_angle.finite?
+      assert_in_delta angle, actual_angle, angle * 1e-12
+      assert_components q.to_a, Larb::Quat.from_axis_angle(axis, actual_angle)
+    end
+    axis, angle = Larb::Quat.identity.to_axis_angle
+    assert_components [1, 0, 0], axis
+    assert_equal 0.0, angle
+  end
+
+  private
+
+  def assert_components(expected, actual)
+    assert_equal expected.size, actual.to_a.size
+    expected.zip(actual.to_a).each do |wanted, value|
+      assert value.finite?, "expected finite component, got #{value.inspect}"
+      assert_in_delta wanted, value, 1e-10
+    end
+  end
 end

data/test/larb/vec2_test.rb

@@ -3,6 +3,29 @@
 require_relative "../test_helper"
 
 class Vec2Test < Test::Unit::TestCase
+  def test_index_assignment_bounds_and_negative_indices
+    v = Larb::Vec2.new(1, 2)
+    v[-2] = 3
+    v[-1] = 4
+    assert_equal [3.0, 4.0], v.to_a
+    [-3, 2, 100].each { |index| assert_raise(IndexError) { v[index] = 99 } }
+    assert_equal [3.0, 4.0], v.to_a
+  end
+
+  def test_clamp_length_validates_limits_and_handles_extreme_magnitudes
+    [Larb::Vec2, Larb::Vec3].each do |klass|
+      v = klass.new(1e200, 0)
+      [-1, Float::NAN, Float::INFINITY].each do |limit|
+        assert_raise(ArgumentError) { v.clamp_length(limit) }
+      end
+      assert_equal klass.new(2, 0), v.clamp_length(2)
+      assert_equal klass.zero, v.clamp_length(0)
+      assert_equal klass.zero, klass.zero.clamp_length(0)
+      tiny = klass.new(1e-200, 0)
+      assert_equal klass.new(1e-201, 0), tiny.clamp_length(1e-201)
+    end
+  end
+
   def test_new_with_default_values
     v = Larb::Vec2.new
     assert_equal 0.0, v.x

data/test/larb/vec3_test.rb

@@ -3,6 +3,69 @@
 require_relative "../test_helper"
 
 class Vec3Test < Test::Unit::TestCase
+  def assert_finite_vector(expected, actual)
+    actual.to_a.zip(expected).each do |value, target|
+      assert_predicate value, :finite?
+      assert_in_delta target, value, 1e-10
+    end
+  end
+
+  def test_slerp_equal_opposite_and_nonunit_endpoints
+    a = Larb::Vec3.new(2, 0, 0)
+    [0, 0.5, 1].each { |t| assert_finite_vector a.to_a, a.slerp(a, t) }
+    b = Larb::Vec3.new(0, 4, 0)
+    assert_equal a, a.slerp(b, 0)
+    assert_equal b, a.slerp(b, 1)
+    assert_finite_vector [3 / Math.sqrt(2), 3 / Math.sqrt(2), 0], a.slerp(b, 0.5)
+    same_direction = Larb::Vec3.new(4, 0, 0)
+    assert_finite_vector [3, 0, 0], a.slerp(same_direction, 0.5)
+
+    [Larb::Vec3.right, Larb::Vec3.up, Larb::Vec3.new(1, 2, 3).normalize].each do |v|
+      middle = v.slerp(-v, 0.5)
+      assert middle.to_a.all?(&:finite?)
+      assert_in_delta 1, middle.length, 1e-10
+      assert_in_delta 0, middle.dot(v), 1e-10
+      assert_equal(-v, v.slerp(-v, 1))
+      assert_equal middle, v.slerp(-v, 0.5)
+    end
+    close = Larb::Vec3.new(1, 1e-8, 0).normalize
+    assert_finite_vector [1, 5e-9, 0], Larb::Vec3.right.slerp(close, 0.5)
+  end
+
+  def test_direction_operations_reject_zero_vectors
+    v = Larb::Vec3.right
+    assert_raise(ArgumentError) { v.project(Larb::Vec3.zero) }
+    assert_raise(ArgumentError) { v.reject(Larb::Vec3.zero) }
+    assert_raise(ArgumentError) { v.angle_between(Larb::Vec3.zero) }
+    assert_raise(ArgumentError) { Larb::Vec3.zero.angle_between(v) }
+    assert_raise(ArgumentError) { v.slerp(Larb::Vec3.zero, 0.5) }
+    assert_raise(ArgumentError) { Larb::Vec3.zero.slerp(v, 0.5) }
+    assert_raise(ArgumentError) { v.slerp(v, Float::NAN) }
+  end
+
+  def test_slerp_near_antipodes_preserves_interpolated_length
+    a = Larb::Vec3.new(1, 2, 3).normalize
+    tangent = a.cross(Larb::Vec3.right).normalize
+    [1e-8, 1e-10, 1e-11, 1e-13].each do |offset|
+      b = (-a + tangent * offset).normalize
+      [0.25, 0.5, 0.75].each do |t|
+        result = (a * 2).slerp(b * 4, t)
+        assert result.to_a.all?(&:finite?)
+        assert_in_delta 2 + 2 * t, result.length, 1e-12
+      end
+    end
+  end
+
+  def test_projection_and_angle_handle_extreme_direction_magnitudes
+    [1e200, 1e-200].each do |magnitude|
+      v = Larb::Vec3.new(3, 4, 5)
+      direction = Larb::Vec3.new(magnitude, 0, 0)
+      assert_finite_vector [3, 0, 0], v.project(direction)
+      assert_finite_vector [0, 4, 5], v.reject(direction)
+      assert_in_delta Math::PI / 2, direction.angle_between(Larb::Vec3.up * magnitude), 1e-10
+    end
+  end
+
   def test_new_with_default_values
     v = Larb::Vec3.new
     assert_equal 0.0, v.x

data/test/larb/vec4_test.rb

@@ -78,7 +78,14 @@ class Vec4Test < Test::Unit::TestCase
 
   def test_perspective_divide_w_is_0
     v = Larb::Vec4.new(1, 2, 3, 0)
-    assert_equal Larb::Vec3.new(1, 2, 3), v.perspective_divide
+    assert_raise(ArgumentError) { v.perspective_divide }
+    assert_equal Larb::Vec3.new(1, 2, 3), v.xyz
+  end
+
+  def test_perspective_divide_rejects_nonfinite_w
+    [Float::NAN, Float::INFINITY].each do |w|
+      assert_raise(ArgumentError) { Larb::Vec4.new(1, 2, 3, w).perspective_divide }
+    end
   end
 
   def test_xyz

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: larb
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 1.0.1
 platform: ruby
 authors:
 - Yudai Takada
@@ -48,6 +48,7 @@ files:
 - ext/larb/mat3.h
 - ext/larb/mat4.c
 - ext/larb/mat4.h
+- ext/larb/matrix_utils.h
 - ext/larb/quat.c
 - ext/larb/quat.h
 - ext/larb/quat2.c
@@ -65,18 +66,20 @@ files:
 - test/larb/mat2d_test.rb
 - test/larb/mat3_test.rb
 - test/larb/mat4_test.rb
+- test/larb/matrix_test.rb
+- test/larb/native_value_test.rb
 - test/larb/quat2_test.rb
 - test/larb/quat_test.rb
 - test/larb/vec2_test.rb
 - test/larb/vec3_test.rb
 - test/larb/vec4_test.rb
 - test/test_helper.rb
-homepage: https://github.com/ydah/larb
+homepage: https://github.com/rbgfx/larb
 licenses:
 - MIT
 metadata:
-  source_code_uri: https://github.com/ydah/larb
-  changelog_uri: https://github.com/ydah/larb/blob/main/CHANGELOG.md
+  source_code_uri: https://github.com/rbgfx/larb
+  changelog_uri: https://github.com/rbgfx/larb/blob/main/CHANGELOG.md
 rdoc_options: []
 require_paths:
 - lib
@@ -91,7 +94,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 4.0.3
+rubygems_version: 4.0.19
 specification_version: 4
 summary: Linear algebra library for 2D/3D graphics in Ruby
 test_files: []