larb 0.1.0 → 1.0.1

data/test/larb/native_value_test.rb

@@ -0,0 +1,157 @@
+# frozen_string_literal: true
+
+require_relative "../test_helper"
+
+class NativeValueTest < Test::Unit::TestCase
+  TYPES = [Larb::Vec2, Larb::Vec3, Larb::Vec4, Larb::Mat2, Larb::Mat2d,
+           Larb::Mat3, Larb::Mat4, Larb::Quat, Larb::Quat2, Larb::Color].freeze
+  ARRAY_TYPES = [Larb::Mat2, Larb::Mat2d, Larb::Mat3, Larb::Mat4, Larb::Quat2].freeze
+
+  def arguments(klass, values)
+    ARRAY_TYPES.include?(klass) ? [values] : values
+  end
+
+  def sample(klass)
+    klass.new(*arguments(klass, (1..klass.new.to_a.length).to_a))
+  end
+
+  def setters(value)
+    %i[x= y= z= w= r= g= b= a=].select { |method| value.respond_to?(method) }
+  end
+
+  def coercion(&block)
+    Object.new.tap { |object| object.define_singleton_method(:to_f, &block) }
+  end
+
+  def test_copies_preserve_components_and_have_independent_storage
+    TYPES.each do |klass|
+      original = sample(klass)
+      [original.dup, original.clone, original.freeze.clone(freeze: false)].each do |copy|
+        assert_equal original.to_a, copy.to_a, klass.name
+        copy.send(:initialize)
+        assert_equal (1..original.to_a.length).to_a, original.to_a
+      end
+      assert_predicate original.clone, :frozen?
+      subclass = Class.new(klass)
+      assert_instance_of subclass, subclass.new.dup
+      assert_raise(TypeError) { klass.new.send(:initialize_copy, Object.new) }
+    end
+  end
+
+  def test_frozen_values_reject_every_mutator
+    TYPES.each do |klass|
+      value = sample(klass).freeze
+      before = value.to_a
+      setters(value).each { |method| assert_raise(FrozenError) { value.public_send(method, 99) } }
+      assert_raise(FrozenError) { value[0] = 99 } if value.respond_to?(:[]=)
+      assert_raise(FrozenError) { value.normalize! } if value.respond_to?(:normalize!)
+      assert_raise(FrozenError) { value.send(:initialize) }
+      assert_raise(FrozenError) { value.send(:initialize_copy, sample(klass)) }
+      assert_equal before, value.to_a
+    end
+  end
+
+  def test_setters_recheck_freeze_after_numeric_conversion
+    TYPES.each do |klass|
+      setters(sample(klass)).each do |method|
+        value = sample(klass)
+        before = value.to_a
+        number = coercion { value.freeze; 99.0 }
+        assert_raise(FrozenError) { value.public_send(method, number) }
+        assert_equal before, value.to_a
+      end
+      next unless sample(klass).respond_to?(:[]=)
+
+      value = sample(klass)
+      before = value.to_a
+      number = coercion { value.freeze; 99.0 }
+      assert_raise(FrozenError) { value[0] = number }
+      assert_equal before, value.to_a
+
+      value = sample(klass)
+      index = Object.new
+      index.define_singleton_method(:to_int) { value.freeze; 0 }
+      assert_raise(FrozenError) { value[index] = 99 }
+      assert_equal before, value.to_a
+    end
+  end
+
+  def test_reinitialization_is_atomic_when_conversion_freezes_or_fails
+    TYPES.each do |klass|
+      value = sample(klass)
+      before = value.to_a
+      input = Array.new(before.length, 99)
+      input[-1] = coercion { value.freeze; 99.0 }
+      assert_raise(FrozenError) { value.send(:initialize, *arguments(klass, input)) }
+      assert_equal before, value.to_a
+
+      value = sample(klass)
+      input[-1] = Object.new
+      assert_raise(TypeError) { value.send(:initialize, *arguments(klass, input)) }
+      assert_equal before, value.to_a
+    end
+  end
+
+  def test_numeric_inputs_reject_strings_and_nil
+    TYPES.each do |klass|
+      [nil, "not a number"].each do |invalid|
+        input = sample(klass).to_a
+        input[0] = invalid
+        assert_raise(TypeError) { klass.new(*arguments(klass, input)) }
+        assert_raise(TypeError) { sample(klass) * invalid }
+        setters(sample(klass)).each do |method|
+          assert_raise(TypeError) { sample(klass).public_send(method, invalid) }
+        end
+      end
+    end
+  end
+
+  def test_array_constructors_require_exact_component_counts
+    ARRAY_TYPES.each do |klass|
+      count = klass.new.to_a.length
+      [0, count - 1, count + 1].each do |length|
+        assert_raise(ArgumentError) { klass.new(Array.new(length, 0)) }
+      end
+      assert_raise(TypeError) { klass.new(nil) }
+    end
+  end
+
+  def test_near_rejects_nan_components_and_invalid_tolerances
+    TYPES.each do |klass|
+      good = sample(klass)
+      values = good.to_a
+      values.each_index do |i|
+        bad_values = values.dup
+        bad_values[i] = Float::NAN
+        bad = klass.new(*arguments(klass, bad_values))
+        assert_false good.near?(bad), klass.name
+        assert_false bad.near?(good), klass.name
+      end
+      [0, -1, Float::NAN, Float::INFINITY].each do |epsilon|
+        assert_raise(ArgumentError) { good.near?(good, epsilon) }
+      end
+      assert_raise(TypeError) { good.near?(good, nil) }
+    end
+  end
+
+  def test_vector_lengths_and_normalization_across_magnitudes
+    [Larb::Vec2, Larb::Vec3, Larb::Vec4].each do |klass|
+      count = klass.zero.to_a.length
+      [1e200, 1e-200, Float::MAX, Float::MIN * Float::EPSILON].each do |magnitude|
+        value = klass.new(magnitude, *Array.new(count - 1, 0))
+        assert_equal magnitude, value.length
+        assert_equal magnitude, value.distance(klass.zero) if value.respond_to?(:distance)
+        assert_equal [1.0, *Array.new(count - 1, 0.0)], value.normalize.to_a
+        value.normalize!
+        assert_equal [1.0, *Array.new(count - 1, 0.0)], value.to_a
+      end
+      value = klass.new(*Array.new(count, Float::MAX)).normalize
+      value.to_a.each { |v| assert_in_delta 1.0 / Math.sqrt(count), v, 1e-15 }
+      [0.0, Float::INFINITY, Float::NAN].each do |invalid|
+        value = klass.new(invalid, *Array.new(count - 1, 0))
+        assert_raise(ArgumentError) { value.normalize }
+        assert_raise(ArgumentError) { value.normalize! }
+      end
+    end
+  end
+end

data/test/larb/quat2_test.rb

@@ -0,0 +1,254 @@
+# 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
+
+  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

@@ -0,0 +1,284 @@
+# 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
+
+  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