larb 1.0.0 → 1.0.1

data/ext/larb/vec4.c

@@ -20,11 +20,6 @@ static const rb_data_type_t vec4_type = {
 
 static VALUE cVec4 = Qnil;
 
-static double value_to_double(VALUE value) {
-  VALUE coerced = rb_funcall(value, rb_intern("to_f"), 0);
-  return NUM2DBL(coerced);
-}
-
 static Vec4Data *vec4_get(VALUE obj) {
   Vec4Data *data = NULL;
   TypedData_Get_Struct(obj, Vec4Data, &vec4_type, data);
@@ -51,18 +46,20 @@ VALUE vec4_alloc(VALUE klass) {
 }
 
 VALUE vec4_initialize(int argc, VALUE *argv, VALUE self) {
+  rb_check_frozen(self);
   VALUE vx = Qnil;
   VALUE vy = Qnil;
   VALUE vz = Qnil;
   VALUE vw = Qnil;
-  Vec4Data *data = vec4_get(self);
-
   rb_scan_args(argc, argv, "04", &vx, &vy, &vz, &vw);
-  data->x = NIL_P(vx) ? 0.0 : value_to_double(vx);
-  data->y = NIL_P(vy) ? 0.0 : value_to_double(vy);
-  data->z = NIL_P(vz) ? 0.0 : value_to_double(vz);
-  data->w = NIL_P(vw) ? 1.0 : value_to_double(vw);
-
+  Vec4Data value = {
+      argc > 0 ? NUM2DBL(vx) : 0.0,
+      argc > 1 ? NUM2DBL(vy) : 0.0,
+      argc > 2 ? NUM2DBL(vz) : 0.0,
+      argc > 3 ? NUM2DBL(vw) : 1.0
+  };
+  rb_check_frozen(self);
+  *vec4_get(self) = value;
   return self;
 }
 
@@ -73,8 +70,8 @@ static VALUE vec4_class_bracket(int argc, VALUE *argv, VALUE klass) {
   VALUE vw = Qnil;
 
   rb_scan_args(argc, argv, "31", &vx, &vy, &vz, &vw);
-  return vec4_build(klass, value_to_double(vx), value_to_double(vy),
-                    value_to_double(vz), NIL_P(vw) ? 1.0 : value_to_double(vw));
+  return vec4_build(klass, NUM2DBL(vx), NUM2DBL(vy),
+                    NUM2DBL(vz), argc < 4 ? 1.0 : NUM2DBL(vw));
 }
 
 static VALUE vec4_class_zero(VALUE klass) {
@@ -91,8 +88,11 @@ static VALUE vec4_get_x(VALUE self) {
 }
 
 static VALUE vec4_set_x(VALUE self, VALUE value) {
+  rb_check_frozen(self);
   Vec4Data *data = vec4_get(self);
-  data->x = value_to_double(value);
+  double component = NUM2DBL(value);
+  rb_check_frozen(self);
+  data->x = component;
   return value;
 }
 
@@ -102,8 +102,11 @@ static VALUE vec4_get_y(VALUE self) {
 }
 
 static VALUE vec4_set_y(VALUE self, VALUE value) {
+  rb_check_frozen(self);
   Vec4Data *data = vec4_get(self);
-  data->y = value_to_double(value);
+  double component = NUM2DBL(value);
+  rb_check_frozen(self);
+  data->y = component;
   return value;
 }
 
@@ -113,8 +116,11 @@ static VALUE vec4_get_z(VALUE self) {
 }
 
 static VALUE vec4_set_z(VALUE self, VALUE value) {
+  rb_check_frozen(self);
   Vec4Data *data = vec4_get(self);
-  data->z = value_to_double(value);
+  double component = NUM2DBL(value);
+  rb_check_frozen(self);
+  data->z = component;
   return value;
 }
 
@@ -124,8 +130,11 @@ static VALUE vec4_get_w(VALUE self) {
 }
 
 static VALUE vec4_set_w(VALUE self, VALUE value) {
+  rb_check_frozen(self);
   Vec4Data *data = vec4_get(self);
-  data->w = value_to_double(value);
+  double component = NUM2DBL(value);
+  rb_check_frozen(self);
+  data->w = component;
   return value;
 }
 
@@ -145,14 +154,14 @@ VALUE vec4_sub(VALUE self, VALUE other) {
 
 VALUE vec4_mul(VALUE self, VALUE scalar) {
   Vec4Data *a = vec4_get(self);
-  double s = value_to_double(scalar);
+  double s = NUM2DBL(scalar);
   return vec4_build(rb_obj_class(self), a->x * s, a->y * s, a->z * s,
                     a->w * s);
 }
 
 VALUE vec4_div(VALUE self, VALUE scalar) {
   Vec4Data *a = vec4_get(self);
-  double s = value_to_double(scalar);
+  double s = NUM2DBL(scalar);
   return vec4_build(rb_obj_class(self), a->x / s, a->y / s, a->z / s,
                     a->w / s);
 }
@@ -170,7 +179,7 @@ VALUE vec4_dot(VALUE self, VALUE other) {
 
 VALUE vec4_length(VALUE self) {
   Vec4Data *a = vec4_get(self);
-  return DBL2NUM(sqrt(a->x * a->x + a->y * a->y + a->z * a->z + a->w * a->w));
+  return DBL2NUM(hypot(hypot(hypot(a->x, a->y), a->z), a->w));
 }
 
 VALUE vec4_length_squared(VALUE self) {
@@ -180,18 +189,20 @@ VALUE vec4_length_squared(VALUE self) {
 
 VALUE vec4_normalize(VALUE self) {
   Vec4Data *a = vec4_get(self);
-  double len = sqrt(a->x * a->x + a->y * a->y + a->z * a->z + a->w * a->w);
-  return vec4_build(rb_obj_class(self), a->x / len, a->y / len, a->z / len,
-                    a->w / len);
+  double values[] = {a->x, a->y, a->z, a->w};
+  larb_normalize(values, 4);
+  return vec4_build(rb_obj_class(self), values[0], values[1], values[2], values[3]);
 }
 
 VALUE vec4_normalize_bang(VALUE self) {
+  rb_check_frozen(self);
   Vec4Data *a = vec4_get(self);
-  double len = sqrt(a->x * a->x + a->y * a->y + a->z * a->z + a->w * a->w);
-  a->x /= len;
-  a->y /= len;
-  a->z /= len;
-  a->w /= len;
+  double values[] = {a->x, a->y, a->z, a->w};
+  larb_normalize(values, 4);
+  a->x = values[0];
+  a->y = values[1];
+  a->z = values[2];
+  a->w = values[3];
   return self;
 }
 
@@ -199,9 +210,8 @@ VALUE vec4_perspective_divide(VALUE self) {
   Vec4Data *a = vec4_get(self);
   VALUE vec3_class = rb_const_get(mLarb, rb_intern("Vec3"));
 
-  if (a->w == 0.0 || a->w == 1.0) {
-    return rb_funcall(vec3_class, rb_intern("new"), 3, DBL2NUM(a->x),
-                      DBL2NUM(a->y), DBL2NUM(a->z));
+  if (!isfinite(a->w) || a->w == 0.0) {
+    rb_raise(rb_eArgError, "w must be finite and nonzero for perspective division");
   }
 
   return rb_funcall(vec3_class, rb_intern("new"), 3, DBL2NUM(a->x / a->w),
@@ -259,7 +269,10 @@ VALUE vec4_near(int argc, VALUE *argv, VALUE self) {
   rb_scan_args(argc, argv, "11", &other, &epsilon);
   Vec4Data *a = vec4_get(self);
   Vec4Data *b = vec4_get(other);
-  double eps = NIL_P(epsilon) ? 1e-6 : value_to_double(epsilon);
+  double eps = argc < 2 ? 1e-6 : NUM2DBL(epsilon);
+  if (!isfinite(eps) || eps <= 0.0) {
+    rb_raise(rb_eArgError, "epsilon must be finite and positive");
+  }
 
   if (fabs(a->x - b->x) < eps && fabs(a->y - b->y) < eps &&
       fabs(a->z - b->z) < eps && fabs(a->w - b->w) < eps) {
@@ -271,7 +284,7 @@ VALUE vec4_near(int argc, VALUE *argv, VALUE self) {
 VALUE vec4_lerp(VALUE self, VALUE other, VALUE t) {
   Vec4Data *a = vec4_get(self);
   Vec4Data *b = vec4_get(other);
-  double s = value_to_double(t);
+  double s = NUM2DBL(t);
   return vec4_build(rb_obj_class(self), a->x + (b->x - a->x) * s,
                     a->y + (b->y - a->y) * s,
                     a->z + (b->z - a->z) * s,
@@ -296,11 +309,19 @@ VALUE vec4_inspect(VALUE self) {
   return str;
 }
 
+static VALUE vec4_initialize_copy(VALUE self, VALUE other) {
+  if (self == other) return self;
+  rb_obj_init_copy(self, other);
+  *vec4_get(self) = *vec4_get(other);
+  return self;
+}
+
 void Init_vec4(VALUE module) {
   cVec4 = rb_define_class_under(module, "Vec4", rb_cObject);
 
   rb_define_alloc_func(cVec4, vec4_alloc);
   rb_define_method(cVec4, "initialize", vec4_initialize, -1);
+  rb_define_method(cVec4, "initialize_copy", vec4_initialize_copy, 1);
 
   rb_define_singleton_method(cVec4, "[]", vec4_class_bracket, -1);
   rb_define_singleton_method(cVec4, "zero", vec4_class_zero, 0);

data/lib/larb/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Larb
-  VERSION = "1.0.0"
+  VERSION = "1.0.1"
 end

data/test/larb/color_test.rb

@@ -3,6 +3,27 @@
 require_relative "../test_helper"
 
 class ColorTest < Test::Unit::TestCase
+  def test_bytes_clamp_before_integer_conversion
+    [1e8, 1e300, Float::INFINITY].each do |large|
+      assert_equal [255, 0, 128, 255], Larb::Color.new(large, -large, 0.5, 1).to_bytes
+      assert_equal "#ff0080ff", Larb::Color.new(large, -large, 0.5, 1).to_hex
+    end
+    4.times do |i|
+      values = [0, 0, 0, 1]
+      values[i] = Float::NAN
+      assert_raise(ArgumentError) { Larb::Color.new(*values).to_bytes }
+    end
+  end
+
+  def test_from_hex_validates_the_entire_string
+    ["#gg0000", "#ff0000zz", "#ff0000ffjunk", "f#f0000", "", "#fff",
+     "#ffff", " ff0000", "#ff0000\n", "ff0000\0", "＃ff0000"].each do |hex|
+      assert_raise(ArgumentError, hex.inspect) { Larb::Color.from_hex(hex) }
+    end
+    assert_raise(TypeError) { Larb::Color.from_hex(nil) }
+    assert_equal [255, 128, 0, 170], Larb::Color.from_hex("#FF8000aA").to_bytes
+  end
+
   def test_new_with_default_values
     c = Larb::Color.new
     assert_equal 0.0, c.r

data/test/larb/mat2d_test.rb

@@ -169,4 +169,29 @@ class Mat2dTest < Test::Unit::TestCase
     m = Larb::Mat2d.identity
     assert_match(/Mat2d/, m.inspect)
   end
+
+  def test_decomposition_round_trips_signed_scales
+    [-1, 1].repeated_permutation(2) do |signs|
+      [0, Math::PI / 2, 1.2].each do |angle|
+        matrix = Larb::Mat2d.from_rotation_translation_scale(
+          angle, Larb::Vec2.new(1, 2), Larb::Vec2.new(signs[0] * 2, signs[1] * 3)
+        )
+        scale = matrix.extract_scale
+        assert_equal signs.inject(:*) < 0, scale.x < 0
+        rebuilt = Larb::Mat2d.from_rotation_translation_scale(
+          matrix.extract_rotation, matrix.extract_translation, scale
+        )
+        assert rebuilt.to_a.all?(&:finite?)
+        matrix.to_a.zip(rebuilt.to_a).each { |a, b| assert_in_delta a, b, 1e-9 }
+      end
+    end
+  end
+
+  def test_decomposition_rejects_shear_zero_scale_and_nonfinite_values
+    [Larb::Mat2d.new([1, 0, 0.5, 1, 0, 0]), Larb::Mat2d.scaling(0, 1),
+     Larb::Mat2d.scaling(Float::NAN, 1)].each do |matrix|
+      assert_raise(ArgumentError) { matrix.extract_scale }
+      assert_raise(ArgumentError) { matrix.extract_rotation }
+    end
+  end
 end

data/test/larb/mat4_test.rb

@@ -267,4 +267,81 @@ class Mat4Test < Test::Unit::TestCase
     m = Larb::Mat4.identity
     assert_match(/Mat4/, m.inspect)
   end
+
+  def test_trs_applies_scale_rotation_then_translation
+    matrix = Larb::Mat4.trs(
+      Larb::Vec3.new(1, 2, 3),
+      Larb::Quat.from_axis_angle(Larb::Vec3.back, Math::PI / 2),
+      Larb::Vec3.new(2, 3, 4)
+    )
+    assert_finite_close [1, 2, 3], matrix.extract_translation.to_a
+    assert_finite_close [-2, 4, 7, 1], (matrix * Larb::Vec4.new(1, 1, 1, 1)).to_a
+  end
+
+  def test_decomposition_round_trips_signed_scales
+    rotations = [Larb::Quat.identity] + [Larb::Vec3.right, Larb::Vec3.up, Larb::Vec3.forward].map do |axis|
+      Larb::Quat.from_axis_angle(axis, Math::PI)
+    end
+    rotations << Larb::Quat.from_axis_angle(Larb::Vec3.new(1, 2, 3), 1.2)
+    [-1, 1].repeated_permutation(3) do |signs|
+      rotations.each do |rotation|
+        scale = Larb::Vec3.new(signs[0] * 2, signs[1] * 3, signs[2] * 4)
+        matrix = Larb::Mat4.trs(Larb::Vec3.new(1, 2, 3), rotation, scale)
+        extracted_rotation = matrix.extract_rotation
+        extracted_scale = matrix.extract_scale
+        assert extracted_rotation.to_a.all?(&:finite?)
+        assert_in_delta 1.0, extracted_rotation.length, 1e-12
+        assert_equal signs.inject(:*) < 0, extracted_scale.x < 0
+        rebuilt = Larb::Mat4.trs(matrix.extract_translation, extracted_rotation, extracted_scale)
+        assert_finite_close matrix.to_a, rebuilt.to_a
+      end
+    end
+  end
+
+  def test_decomposition_handles_extreme_scales
+    [1e-200, 1e200].each do |magnitude|
+      matrix = Larb::Mat4.scaling(-magnitude, magnitude, magnitude)
+      scale = matrix.extract_scale
+      assert_finite_close [-1, 1, 1], scale.to_a.map { |value| value / magnitude }
+      assert_finite_close [0, 0, 0, 1], matrix.extract_rotation.to_a
+    end
+  end
+
+  def test_decomposition_rejects_unsupported_matrices
+    shear = Larb::Mat4.identity
+    shear[4] = 0.5
+    nonfinite = Larb::Mat4.identity
+    nonfinite[0] = Float::NAN
+    matrices = [shear, nonfinite, Larb::Mat4.scaling(0, 1, 1),
+                Larb::Mat4.perspective(Math::PI / 4, 1, 0.1, 100)]
+    matrices.each do |matrix|
+      assert_raise(ArgumentError) { matrix.extract_rotation }
+      assert_raise(ArgumentError) { matrix.extract_scale }
+    end
+  end
+
+  def test_look_at_rejects_degenerate_directions
+    origin = Larb::Vec3.zero
+    assert_raise(ArgumentError) { Larb::Mat4.look_at(origin, origin, Larb::Vec3.up) }
+    assert_raise(ArgumentError) { Larb::Mat4.look_at(origin, Larb::Vec3.forward, origin) }
+    assert_raise(ArgumentError) { Larb::Mat4.look_at(origin, Larb::Vec3.forward, Larb::Vec3.forward) }
+    assert_raise(ArgumentError) do
+      Larb::Mat4.look_at(origin, Larb::Vec3.new(Float::NAN, 0, 1), Larb::Vec3.up)
+    end
+  end
+
+  def test_look_at_normalizes_extreme_directions
+    [1e-200, 1e200].each do |magnitude|
+      matrix = Larb::Mat4.look_at(Larb::Vec3.zero, Larb::Vec3.new(0, 0, -magnitude),
+                                 Larb::Vec3.new(0, magnitude, 0))
+      assert_finite_close Larb::Mat4.identity.to_a, matrix.to_a
+    end
+  end
+
+  private
+
+  def assert_finite_close(expected, actual)
+    assert actual.all?(&:finite?), actual.inspect
+    expected.zip(actual).each { |a, b| assert_in_delta a, b, 1e-9 }
+  end
 end

data/test/larb/matrix_test.rb

@@ -0,0 +1,135 @@
+# frozen_string_literal: true
+
+require_relative "../test_helper"
+
+class MatrixTest < Test::Unit::TestCase
+  MATRIX_CLASSES = [Larb::Mat2, Larb::Mat2d, Larb::Mat3, Larb::Mat4].freeze
+
+  def test_array_sizes_and_component_types
+    MATRIX_CLASSES.each do |klass|
+      size = klass.identity.to_a.size
+      [[], Array.new(size - 1, 0), Array.new(size + 1, 0)].each do |values|
+        assert_raise(ArgumentError) { klass.new(values) }
+      end
+      [nil, "1", Object.new].each do |value|
+        assert_raise(TypeError) { klass.new(value) }
+        values = klass.identity.to_a
+        values[-1] = value
+        assert_raise(TypeError) { klass.new(values) }
+      end
+    end
+  end
+
+  def test_numeric_scalar_multiplication_and_invalid_operands
+    MATRIX_CLASSES.each do |klass|
+      matrix = klass.identity
+      assert_equal matrix.to_a.map { |value| value * 2 }, (matrix * 2).to_a
+      [nil, "2", Object.new, []].each do |other|
+        assert_raise(TypeError) { matrix * other }
+      end
+    end
+  end
+
+  def test_near_rejects_nonfinite_components_and_invalid_epsilon
+    MATRIX_CLASSES.each do |klass|
+      matrix = klass.identity
+      [Float::NAN, Float::INFINITY, -Float::INFINITY].each do |value|
+        other = klass.identity
+        other[0] = value
+        assert_false matrix.near?(other)
+        assert_false other.near?(other)
+      end
+      [0, -1, Float::NAN, Float::INFINITY, -Float::INFINITY].each do |epsilon|
+        assert_raise(ArgumentError) { matrix.near?(matrix, epsilon) }
+      end
+      assert_raise(TypeError) { matrix.near?(matrix, nil) }
+    end
+  end
+
+  def test_inverse_does_not_depend_on_absolute_scale
+    MATRIX_CLASSES.each do |klass|
+      [1e-200, 1e-6, 1e200].each do |magnitude|
+        matrix = klass.identity * magnitude
+        inverse = matrix.inverse
+        assert inverse.to_a.all?(&:finite?)
+        assert_finite_close klass.identity.to_a, (matrix * inverse).to_a
+        assert_finite_close klass.identity.to_a, (inverse * matrix).to_a
+      end
+    end
+  end
+
+  def test_inverse_uses_pivot_swaps_and_handles_different_axis_scales
+    matrices = [
+      Larb::Mat2.new([0, 2, 3, 4]),
+      Larb::Mat2d.new([0, 2, 3, 4, 5, 6]),
+      Larb::Mat3.new([0, 1, 0, 1, 2, 0, 0, 0, 3]),
+      Larb::Mat4.new([0, 1, 0, 1, 1, 2, 1, 0, 2, 0, 3, 1, 1, 0, 0, 4]),
+      Larb::Mat2.scaling(1e-200, 1e200),
+      Larb::Mat2d.scaling(1e-200, 1e200),
+      Larb::Mat3.scaling(1e-200, 1e200),
+      Larb::Mat4.scaling(1e-200, 1e200, 1),
+      Larb::Mat2d.translation(1e200, 0),
+      Larb::Mat4.translation(1e200, 0, 0)
+    ]
+    matrices.each do |matrix|
+      inverse = matrix.inverse
+      assert inverse.to_a.all?(&:finite?)
+      assert_finite_close matrix.class.identity.to_a, (matrix * inverse).to_a
+      assert_finite_close matrix.class.identity.to_a, (inverse * matrix).to_a
+    end
+  end
+
+  def test_inverse_rejects_rank_deficient_and_nonfinite_matrices
+    MATRIX_CLASSES.each do |klass|
+      assert_raise(RuntimeError) { klass.new(Array.new(klass.identity.to_a.size, 1)).inverse }
+      [Float::NAN, Float::INFINITY].each do |value|
+        matrix = klass.identity
+        matrix[0] = value
+        assert_raise(RuntimeError) { matrix.inverse }
+      end
+    end
+    assert_raise(RuntimeError) { Larb::Mat3.new([1, 2, 3, 4, 5, 6, 5, 7, 9]).inverse }
+    assert_raise(RuntimeError) do
+      Larb::Mat4.new([1, 2, 3, 4, 5, 6, 7, 8, 6, 8, 10, 12, 0, 1, 0, 1]).inverse
+    end
+  end
+
+  def test_inverse_preserves_small_components_in_rows_and_columns
+    cases = [
+      [[1e200, 1e-200, 1e200, -1e-200], [5e-201, 5e-201, 5e199, -5e199]],
+      [[1e200, 1e200, 1e-200, -1e-200], [5e-201, 5e199, 5e-201, -5e199]]
+    ]
+    MATRIX_CLASSES.each do |klass|
+      size = klass == Larb::Mat2d ? 2 : Math.sqrt(klass.identity.to_a.size).to_i
+      indices = [0, 1, size, size + 1]
+      cases.each do |values, expected|
+        matrix = klass.identity
+        indices.zip(values).each { |index, value| matrix[index] = value }
+        inverse = matrix.inverse.to_a
+        assert inverse.all?(&:finite?)
+        indices.zip(expected).each do |index, value|
+          assert_in_delta 1.0, inverse[index] / value, 1e-12
+        end
+      end
+    end
+  end
+
+  def test_frobenius_norm_handles_extreme_magnitudes
+    [Larb::Mat2, Larb::Mat2d, Larb::Mat3].each do |klass|
+      [1e-200, 1e200].each do |magnitude|
+        values = klass.zero.to_a
+        values[0] = magnitude
+        norm = klass.new(values).frobenius_norm
+        assert norm.finite?
+        assert_in_delta 1.0, norm / magnitude, 1e-12
+      end
+    end
+  end
+
+  private
+
+  def assert_finite_close(expected, actual)
+    assert actual.all?(&:finite?), actual.inspect
+    expected.zip(actual).each { |a, b| assert_in_delta a, b, 1e-9 }
+  end
+end

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