larb 1.0.0 → 1.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2b1d77ff0ad9a72005f26e788711b7a6de60fecf47f9e7232009bc2f27c797ec
-  data.tar.gz: 409a982d4e663ea572852deead61d9bd94f87aead91276322c03bbfb3d79b906
+  metadata.gz: e661682c31f5246004965e4c9883a15fae7aae30fccb2e9a56a6e0b5e28f7ad1
+  data.tar.gz: b4095f395b19e7c38d10659c7ae05169972c329087be2fa4481c97b456872b62
 SHA512:
-  metadata.gz: 4ce1d13c4eff9c79b54d49619182e61f56a7a00cd7e1b37119e168d3491e114e3ecbd76c26428d9e57a39acc4c7ed8e21472d302d46da01fe34dce8e8a5b1689
-  data.tar.gz: 82ca7ec6c30c6ac3080ed5ef7070afefddcbdc2455a1bc36045673d1492d4c9b34f3a1fc94310edca0cbf6f4bee544c65d22ae8b6bf23b9b1f142ae9a6d80950
+  metadata.gz: c9a4f13ebd8ef25af8cea483059080e89dd955633006955458b65afda317dc23c5fe34875436a83353f2ca8a8e60f98cc2aa707d65a407eff4c01958b39186e0
+  data.tar.gz: 1f41fd169747e148a30a18b665ff41e259dd69ce303911d68c6058cb94dbce4d2034bf83d383c730fc216038c0c7a70399263f6444ed7d2e7eb159d1109cf548

data/CHANGELOG.md

@@ -2,10 +2,18 @@
 
 ## Unreleased
 
+## 1.0.1 - 2026-09-09
+
+- Preserve native components in `dup`/`clone` and enforce `freeze` on all mutations.
+- Correct indexed Vec2 assignment, transform composition, quaternion interpolation, dual quaternion normalization/inversion, and reflection decomposition.
+- Stabilize lengths, normalization, matrix inversion, and small axis-angle rotations; prevent NaN values from passing approximate comparisons.
+- Validate constructor inputs, multiplication operands, tolerances, degenerate directions, length limits, perspective division, and hexadecimal colors.
+- Clamp color components before integer conversion and preserve IEEE floating-point behavior in native builds.
+
 ## 1.0.0 - 2026-01-10
 
 - Reimplemented in C for better performance.
 
 ## 0.1.0 - 2026-01-02
 
-- Initial release.
+- Initial release.

data/README.md

@@ -58,6 +58,55 @@ custom = Larb::Color.new(0.5, 0.3, 0.8, 1.0)
 hex_color = Larb::Color.from_hex("#ff8800")
 ```
 
+### Value and input behavior
+
+All types support independent `dup`/`clone` copies and respect `freeze`, including
+setters, indexed assignment, `normalize!`, and reinitialization. Failed numeric
+conversion during reinitialization leaves the components unchanged.
+
+Numeric arguments use Ruby's native numeric conversion. Strings and explicit
+`nil` are rejected with `TypeError`; omitted optional arguments retain their
+defaults. Array constructors require exactly 4 (`Mat2`), 6 (`Mat2d`), 9 (`Mat3`),
+16 (`Mat4`), or 8 (`Quat2`) components. Unsupported multiplication operands raise
+`TypeError`; all matrix types support numeric scalar multiplication.
+
+`near?` uses an absolute tolerance (default `1e-6`) that must be finite and
+positive. NaN components never compare near another value. Normalization uses
+scaled components to handle very large and very small finite values; zero-length
+or non-finite inputs raise `ArgumentError`. `length_squared` can still overflow
+or underflow when the squared result is outside the range of a Float.
+
+Direction operations (`Vec3#project`, `reject`, `angle_between`, and `slerp`)
+reject a zero or non-finite direction with `ArgumentError`. `Vec3#slerp`
+interpolates direction along an arc and length linearly; its endpoint lengths
+and interpolation parameter must be finite. Opposite directions use a
+deterministic perpendicular direction to select an arc. `clamp_length` requires
+a finite, nonnegative limit. Degenerate `Mat4.look_at` and `Quat.look_rotation`
+inputs also raise `ArgumentError`.
+
+`Quat#lerp`, `Quat#slerp`, and `Quat2#lerp` choose the shorter rotation path,
+including between `q` and `-q`. Dual quaternion normalization enforces both unit
+real length and real/dual orthogonality. Quaternion rotation factories and
+matrix/point conversion APIs expect unit rotations; normalize manually
+constructed quaternions before using them as rotations.
+
+`Mat4.trs` composes `translation * rotation * scale`. `Mat4` and `Mat2d`
+scale/rotation extraction support finite affine transforms with nonzero scales
+and no shear (normalized-column dot tolerance `1e-6`). Reflections are assigned
+to the X scale, so the extracted values reconstruct the original transform;
+the original individual scale signs are not uniquely recoverable. Unsupported
+decompositions raise `ArgumentError`. Matrix inversion uses scaled pivoting;
+singular, numerically singular, non-finite, or non-finitely representable inverse
+results raise `RuntimeError`.
+
+`Vec4#perspective_divide` requires finite, nonzero `w` and raises `ArgumentError`
+otherwise. Use `xyz` to read a direction vector's three spatial components.
+
+`Color.from_hex` accepts 6 or 8 hexadecimal digits, optionally prefixed with one
+`#`; malformed strings raise `ArgumentError`. `to_bytes` and `to_hex` clamp
+components to `[0, 1]` before rounding: infinities saturate to the corresponding
+endpoint and NaN raises `ArgumentError`.
+
 ## Development
 
 ```bash

data/ext/larb/color.c

@@ -22,11 +22,6 @@ static VALUE cColor = Qnil;
 static VALUE cVec3 = Qnil;
 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 ColorData *color_get(VALUE obj) {
   ColorData *data = NULL;
   TypedData_Get_Struct(obj, ColorData, &color_type, data);
@@ -53,14 +48,9 @@ static double clamp_double(double value, double min, double max) {
   return value;
 }
 
-static int clamp_int(int value, int min, int max) {
-  if (value < min) {
-    return min;
-  }
-  if (value > max) {
-    return max;
-  }
-  return value;
+static int color_byte(double value) {
+  if (isnan(value)) rb_raise(rb_eArgError, "Cannot convert NaN to a color byte");
+  return (int)lround(clamp_double(value, 0.0, 1.0) * 255.0);
 }
 
 static VALUE color_get_r(VALUE self) {
@@ -69,8 +59,11 @@ static VALUE color_get_r(VALUE self) {
 }
 
 static VALUE color_set_r(VALUE self, VALUE value) {
+  rb_check_frozen(self);
   ColorData *data = color_get(self);
-  data->r = value_to_double(value);
+  double component = NUM2DBL(value);
+  rb_check_frozen(self);
+  data->r = component;
   return value;
 }
 
@@ -80,8 +73,11 @@ static VALUE color_get_g(VALUE self) {
 }
 
 static VALUE color_set_g(VALUE self, VALUE value) {
+  rb_check_frozen(self);
   ColorData *data = color_get(self);
-  data->g = value_to_double(value);
+  double component = NUM2DBL(value);
+  rb_check_frozen(self);
+  data->g = component;
   return value;
 }
 
@@ -91,8 +87,11 @@ static VALUE color_get_b(VALUE self) {
 }
 
 static VALUE color_set_b(VALUE self, VALUE value) {
+  rb_check_frozen(self);
   ColorData *data = color_get(self);
-  data->b = value_to_double(value);
+  double component = NUM2DBL(value);
+  rb_check_frozen(self);
+  data->b = component;
   return value;
 }
 
@@ -102,8 +101,11 @@ static VALUE color_get_a(VALUE self) {
 }
 
 static VALUE color_set_a(VALUE self, VALUE value) {
+  rb_check_frozen(self);
   ColorData *data = color_get(self);
-  data->a = value_to_double(value);
+  double component = NUM2DBL(value);
+  rb_check_frozen(self);
+  data->a = component;
   return value;
 }
 
@@ -117,18 +119,20 @@ VALUE color_alloc(VALUE klass) {
 }
 
 VALUE color_initialize(int argc, VALUE *argv, VALUE self) {
+  rb_check_frozen(self);
   VALUE vr = Qnil;
   VALUE vg = Qnil;
   VALUE vb = Qnil;
   VALUE va = Qnil;
-  ColorData *data = color_get(self);
-
   rb_scan_args(argc, argv, "04", &vr, &vg, &vb, &va);
-  data->r = NIL_P(vr) ? 0.0 : value_to_double(vr);
-  data->g = NIL_P(vg) ? 0.0 : value_to_double(vg);
-  data->b = NIL_P(vb) ? 0.0 : value_to_double(vb);
-  data->a = NIL_P(va) ? 1.0 : value_to_double(va);
-
+  ColorData value = {
+      argc > 0 ? NUM2DBL(vr) : 0.0,
+      argc > 1 ? NUM2DBL(vg) : 0.0,
+      argc > 2 ? NUM2DBL(vb) : 0.0,
+      argc > 3 ? NUM2DBL(va) : 1.0
+  };
+  rb_check_frozen(self);
+  *color_get(self) = value;
   return self;
 }
 
@@ -139,18 +143,18 @@ static VALUE color_class_bracket(int argc, VALUE *argv, VALUE klass) {
   VALUE va = Qnil;
 
   rb_scan_args(argc, argv, "31", &vr, &vg, &vb, &va);
-  return color_build(klass, value_to_double(vr), value_to_double(vg),
-                     value_to_double(vb), NIL_P(va) ? 1.0 : value_to_double(va));
+  return color_build(klass, NUM2DBL(vr), NUM2DBL(vg),
+                     NUM2DBL(vb), argc < 4 ? 1.0 : NUM2DBL(va));
 }
 
 static VALUE color_class_rgb(VALUE klass, VALUE r, VALUE g, VALUE b) {
-  return color_build(klass, value_to_double(r), value_to_double(g),
-                     value_to_double(b), 1.0);
+  return color_build(klass, NUM2DBL(r), NUM2DBL(g),
+                     NUM2DBL(b), 1.0);
 }
 
 static VALUE color_class_rgba(VALUE klass, VALUE r, VALUE g, VALUE b, VALUE a) {
-  return color_build(klass, value_to_double(r), value_to_double(g),
-                     value_to_double(b), value_to_double(a));
+  return color_build(klass, NUM2DBL(r), NUM2DBL(g),
+                     NUM2DBL(b), NUM2DBL(a));
 }
 
 static VALUE color_class_from_bytes(int argc, VALUE *argv, VALUE klass) {
@@ -160,41 +164,37 @@ static VALUE color_class_from_bytes(int argc, VALUE *argv, VALUE klass) {
   VALUE va = Qnil;
 
   rb_scan_args(argc, argv, "31", &vr, &vg, &vb, &va);
-  double r = value_to_double(vr) / 255.0;
-  double g = value_to_double(vg) / 255.0;
-  double b = value_to_double(vb) / 255.0;
-  double a = NIL_P(va) ? 1.0 : value_to_double(va) / 255.0;
+  double r = NUM2DBL(vr) / 255.0;
+  double g = NUM2DBL(vg) / 255.0;
+  double b = NUM2DBL(vb) / 255.0;
+  double a = argc < 4 ? 1.0 : NUM2DBL(va) / 255.0;
   return color_build(klass, r, g, b, a);
 }
 
 static VALUE color_class_from_hex(VALUE klass, VALUE hex_value) {
-  VALUE hex = rb_funcall(hex_value, rb_intern("to_s"), 0);
-  VALUE cleaned = rb_funcall(hex, rb_intern("delete"), 1, rb_str_new_cstr("#"));
-  VALUE len_val = rb_funcall(cleaned, rb_intern("length"), 0);
-  long len = NUM2LONG(len_val);
-
-  VALUE r_str = rb_funcall(cleaned, rb_intern("[]"), 2, INT2NUM(0), INT2NUM(2));
-  VALUE g_str = rb_funcall(cleaned, rb_intern("[]"), 2, INT2NUM(2), INT2NUM(2));
-  VALUE b_str = rb_funcall(cleaned, rb_intern("[]"), 2, INT2NUM(4), INT2NUM(2));
-  double r = value_to_double(rb_funcall(r_str, rb_intern("to_i"), 1,
-                                        INT2NUM(16))) /
-             255.0;
-  double g = value_to_double(rb_funcall(g_str, rb_intern("to_i"), 1,
-                                        INT2NUM(16))) /
-             255.0;
-  double b = value_to_double(rb_funcall(b_str, rb_intern("to_i"), 1,
-                                        INT2NUM(16))) /
-             255.0;
-  double a = 1.0;
-  if (len > 6) {
-    VALUE a_str =
-        rb_funcall(cleaned, rb_intern("[]"), 2, INT2NUM(6), INT2NUM(2));
-    a = value_to_double(
-            rb_funcall(a_str, rb_intern("to_i"), 1, INT2NUM(16))) /
-        255.0;
+  StringValue(hex_value);
+  const char *hex = RSTRING_PTR(hex_value);
+  long len = RSTRING_LEN(hex_value);
+  if (len > 0 && hex[0] == '#') {
+    hex++;
+    len--;
   }
-
-  return color_build(klass, r, g, b, a);
+  if (len != 6 && len != 8) {
+    rb_raise(rb_eArgError, "Expected 6 or 8 hexadecimal digits with an optional leading #");
+  }
+  unsigned int rgba = 0;
+  for (long i = 0; i < len; i++) {
+    unsigned int digit;
+    if (hex[i] >= '0' && hex[i] <= '9') digit = hex[i] - '0';
+    else if (hex[i] >= 'a' && hex[i] <= 'f') digit = hex[i] - 'a' + 10;
+    else if (hex[i] >= 'A' && hex[i] <= 'F') digit = hex[i] - 'A' + 10;
+    else rb_raise(rb_eArgError, "Invalid hexadecimal digit");
+    rgba = (rgba << 4) | digit;
+  }
+  if (len == 6) rgba = (rgba << 8) | 255;
+  return color_build(klass, ((rgba >> 24) & 255) / 255.0,
+                     ((rgba >> 16) & 255) / 255.0, ((rgba >> 8) & 255) / 255.0,
+                     (rgba & 255) / 255.0);
 }
 
 static VALUE color_class_black(VALUE klass) {
@@ -234,10 +234,10 @@ static VALUE color_class_transparent(VALUE klass) {
 }
 
 VALUE color_class_from_vec4(VALUE klass, VALUE vec4) {
-  double r = value_to_double(rb_funcall(vec4, rb_intern("x"), 0));
-  double g = value_to_double(rb_funcall(vec4, rb_intern("y"), 0));
-  double b = value_to_double(rb_funcall(vec4, rb_intern("z"), 0));
-  double a = value_to_double(rb_funcall(vec4, rb_intern("w"), 0));
+  double r = NUM2DBL(rb_funcall(vec4, rb_intern("x"), 0));
+  double g = NUM2DBL(rb_funcall(vec4, rb_intern("y"), 0));
+  double b = NUM2DBL(rb_funcall(vec4, rb_intern("z"), 0));
+  double a = NUM2DBL(rb_funcall(vec4, rb_intern("w"), 0));
   return color_build(klass, r, g, b, a);
 }
 
@@ -245,10 +245,10 @@ VALUE color_class_from_vec3(int argc, VALUE *argv, VALUE klass) {
   VALUE vec3 = Qnil;
   VALUE alpha = Qnil;
   rb_scan_args(argc, argv, "11", &vec3, &alpha);
-  double r = value_to_double(rb_funcall(vec3, rb_intern("x"), 0));
-  double g = value_to_double(rb_funcall(vec3, rb_intern("y"), 0));
-  double b = value_to_double(rb_funcall(vec3, rb_intern("z"), 0));
-  double a = NIL_P(alpha) ? 1.0 : value_to_double(alpha);
+  double r = NUM2DBL(rb_funcall(vec3, rb_intern("x"), 0));
+  double g = NUM2DBL(rb_funcall(vec3, rb_intern("y"), 0));
+  double b = NUM2DBL(rb_funcall(vec3, rb_intern("z"), 0));
+  double a = argc < 2 ? 1.0 : NUM2DBL(alpha);
   return color_build(klass, r, g, b, a);
 }
 
@@ -274,17 +274,17 @@ VALUE color_mul(VALUE self, VALUE scalar) {
                        a->b * b->b, a->a * b->a);
   }
   if (rb_obj_is_kind_of(scalar, rb_cNumeric)) {
-    double s = value_to_double(scalar);
+    double s = NUM2DBL(scalar);
     return color_build(rb_obj_class(self), a->r * s, a->g * s, a->b * s,
                        a->a * s);
   }
-  return Qnil;
+  rb_raise(rb_eTypeError, "Expected a Color or numeric scalar");
 }
 
 VALUE color_lerp(VALUE self, VALUE other, VALUE t) {
   ColorData *a = color_get(self);
   ColorData *b = color_get(other);
-  double s = value_to_double(t);
+  double s = NUM2DBL(t);
   return color_build(rb_obj_class(self), a->r + (b->r - a->r) * s,
                      a->g + (b->g - a->g) * s, a->b + (b->b - a->b) * s,
                      a->a + (b->a - a->a) * s);
@@ -300,16 +300,8 @@ VALUE color_clamp(VALUE self) {
 
 VALUE color_to_bytes(VALUE self) {
   ColorData *a = color_get(self);
-  int r = (int)lround(a->r * 255.0);
-  int g = (int)lround(a->g * 255.0);
-  int b = (int)lround(a->b * 255.0);
-  int alpha = (int)lround(a->a * 255.0);
-  VALUE ary = rb_ary_new_capa(4);
-  rb_ary_push(ary, INT2NUM(clamp_int(r, 0, 255)));
-  rb_ary_push(ary, INT2NUM(clamp_int(g, 0, 255)));
-  rb_ary_push(ary, INT2NUM(clamp_int(b, 0, 255)));
-  rb_ary_push(ary, INT2NUM(clamp_int(alpha, 0, 255)));
-  return ary;
+  return rb_ary_new_from_args(4, INT2NUM(color_byte(a->r)), INT2NUM(color_byte(a->g)),
+                              INT2NUM(color_byte(a->b)), INT2NUM(color_byte(a->a)));
 }
 
 VALUE color_to_hex(VALUE self) {
@@ -367,7 +359,10 @@ VALUE color_near(int argc, VALUE *argv, VALUE self) {
   rb_scan_args(argc, argv, "11", &other, &epsilon);
   ColorData *a = color_get(self);
   ColorData *b = color_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->r - b->r) < eps && fabs(a->g - b->g) < eps &&
       fabs(a->b - b->b) < eps && fabs(a->a - b->a) < eps) {
@@ -394,6 +389,13 @@ VALUE color_inspect(VALUE self) {
   return str;
 }
 
+static VALUE color_initialize_copy(VALUE self, VALUE other) {
+  if (self == other) return self;
+  rb_obj_init_copy(self, other);
+  *color_get(self) = *color_get(other);
+  return self;
+}
+
 void Init_color(VALUE module) {
   cColor = rb_define_class_under(module, "Color", rb_cObject);
   cVec3 = rb_const_get(mLarb, rb_intern("Vec3"));
@@ -401,6 +403,7 @@ void Init_color(VALUE module) {
 
   rb_define_alloc_func(cColor, color_alloc);
   rb_define_method(cColor, "initialize", color_initialize, -1);
+  rb_define_method(cColor, "initialize_copy", color_initialize_copy, 1);
 
   rb_define_singleton_method(cColor, "[]", color_class_bracket, -1);
   rb_define_singleton_method(cColor, "rgb", color_class_rgb, 3);

data/ext/larb/extconf.rb

@@ -6,6 +6,6 @@ require "mkmf"
 have_library("m", "sin")
 
 # 最適化フラグ
-$CFLAGS << " -O3 -march=native -ffast-math -funroll-loops"
+$CFLAGS << " -O3 -march=native -funroll-loops"
 
 create_makefile("larb/larb")

data/ext/larb/larb.h

@@ -2,7 +2,30 @@
 #define LARB_H
 
 #include <ruby.h>
+#include <math.h>
 
 extern VALUE mLarb;
 
+static inline void larb_normalize(double *values, size_t count) {
+  double scale = 0.0;
+  for (size_t i = 0; i < count; i++) {
+    if (!isfinite(values[i])) {
+      rb_raise(rb_eArgError, "Cannot normalize non-finite components");
+    }
+    scale = fmax(scale, fabs(values[i]));
+  }
+  if (scale == 0.0) {
+    rb_raise(rb_eArgError, "Cannot normalize a zero-length value");
+  }
+  double sum = 0.0;
+  for (size_t i = 0; i < count; i++) {
+    values[i] /= scale;
+    sum += values[i] * values[i];
+  }
+  double length = sqrt(sum);
+  for (size_t i = 0; i < count; i++) {
+    values[i] /= length;
+  }
+}
+
 #endif

data/ext/larb/mat2.c

@@ -1,4 +1,5 @@
 #include "mat2.h"
+#include "matrix_utils.h"
 
 #include <math.h>
 
@@ -21,11 +22,6 @@ static const rb_data_type_t mat2_type = {
 static VALUE cMat2 = Qnil;
 static VALUE cVec2 = Qnil;
 
-static double value_to_double(VALUE value) {
-  VALUE coerced = rb_funcall(value, rb_intern("to_f"), 0);
-  return NUM2DBL(coerced);
-}
-
 static Mat2Data *mat2_get(VALUE obj) {
   Mat2Data *data = NULL;
   TypedData_Get_Struct(obj, Mat2Data, &mat2_type, data);
@@ -53,28 +49,31 @@ VALUE mat2_alloc(VALUE klass) {
 }
 
 VALUE mat2_initialize(int argc, VALUE *argv, VALUE self) {
+  rb_check_frozen(self);
   VALUE data_arg = Qnil;
-  Mat2Data *data = mat2_get(self);
-
+  Mat2Data values = {{1.0, 0.0, 0.0, 1.0}};
   rb_scan_args(argc, argv, "01", &data_arg);
-  if (NIL_P(data_arg)) {
-    data->data[0] = 1.0;
-    data->data[1] = 0.0;
-    data->data[2] = 0.0;
-    data->data[3] = 1.0;
-    return self;
+  if (argc != 0) {
+    VALUE ary = rb_check_array_type(data_arg);
+    if (NIL_P(ary)) {
+      rb_raise(rb_eTypeError, "expected Array");
+    }
+    if (RARRAY_LEN(ary) != 4) {
+      rb_raise(rb_eArgError, "expected 4 elements");
+    }
+    for (int i = 0; i < 4; i++) {
+      values.data[i] = NUM2DBL(rb_ary_entry(ary, i));
+    }
   }
+  rb_check_frozen(self);
+  *mat2_get(self) = values;
+  return self;
+}
 
-  VALUE ary = rb_check_array_type(data_arg);
-  if (NIL_P(ary)) {
-    rb_raise(rb_eTypeError, "expected Array");
-  }
-
-  data->data[0] = value_to_double(rb_ary_entry(ary, 0));
-  data->data[1] = value_to_double(rb_ary_entry(ary, 1));
-  data->data[2] = value_to_double(rb_ary_entry(ary, 2));
-  data->data[3] = value_to_double(rb_ary_entry(ary, 3));
-
+static VALUE mat2_initialize_copy(VALUE self, VALUE other) {
+  if (self == other) return self;
+  rb_obj_init_copy(self, other);
+  *mat2_get(self) = *mat2_get(other);
   return self;
 }
 
@@ -87,21 +86,21 @@ static VALUE mat2_class_zero(VALUE klass) {
 }
 
 static VALUE mat2_class_rotation(VALUE klass, VALUE radians) {
-  double r = value_to_double(radians);
+  double r = NUM2DBL(radians);
   double c = cos(r);
   double s = sin(r);
   return mat2_build(klass, c, s, -s, c);
 }
 
 static VALUE mat2_class_scaling(VALUE klass, VALUE x, VALUE y) {
-  return mat2_build(klass, value_to_double(x), 0.0, 0.0, value_to_double(y));
+  return mat2_build(klass, NUM2DBL(x), 0.0, 0.0, NUM2DBL(y));
 }
 
 static VALUE mat2_class_from_vec2(VALUE klass, VALUE v1, VALUE v2) {
-  double x1 = value_to_double(rb_funcall(v1, rb_intern("x"), 0));
-  double y1 = value_to_double(rb_funcall(v1, rb_intern("y"), 0));
-  double x2 = value_to_double(rb_funcall(v2, rb_intern("x"), 0));
-  double y2 = value_to_double(rb_funcall(v2, rb_intern("y"), 0));
+  double x1 = NUM2DBL(rb_funcall(v1, rb_intern("x"), 0));
+  double y1 = NUM2DBL(rb_funcall(v1, rb_intern("y"), 0));
+  double x2 = NUM2DBL(rb_funcall(v2, rb_intern("x"), 0));
+  double y2 = NUM2DBL(rb_funcall(v2, rb_intern("y"), 0));
   return mat2_build(klass, x1, y1, x2, y2);
 }
 
@@ -115,12 +114,15 @@ VALUE mat2_aref(VALUE self, VALUE index) {
 }
 
 VALUE mat2_aset(VALUE self, VALUE index, VALUE value) {
+  rb_check_frozen(self);
   Mat2Data *data = mat2_get(self);
   long idx = NUM2LONG(index);
   if (idx < 0 || idx > 3) {
     rb_raise(rb_eIndexError, "index %ld out of range", idx);
   }
-  data->data[idx] = value_to_double(value);
+  double component = NUM2DBL(value);
+  rb_check_frozen(self);
+  data->data[idx] = component;
   return value;
 }
 
@@ -137,8 +139,8 @@ VALUE mat2_mul(VALUE self, VALUE other) {
   }
 
   if (rb_obj_is_kind_of(other, cVec2)) {
-    double x = value_to_double(rb_funcall(other, rb_intern("x"), 0));
-    double y = value_to_double(rb_funcall(other, rb_intern("y"), 0));
+    double x = NUM2DBL(rb_funcall(other, rb_intern("x"), 0));
+    double y = NUM2DBL(rb_funcall(other, rb_intern("y"), 0));
     VALUE vec2_class = rb_const_get(mLarb, rb_intern("Vec2"));
     return rb_funcall(vec2_class, rb_intern("new"), 2,
                       DBL2NUM(a->data[0] * x + a->data[2] * y),
@@ -146,12 +148,12 @@ VALUE mat2_mul(VALUE self, VALUE other) {
   }
 
   if (rb_obj_is_kind_of(other, rb_cNumeric)) {
-    double s = value_to_double(other);
+    double s = NUM2DBL(other);
     return mat2_build(rb_obj_class(self), a->data[0] * s, a->data[1] * s,
                       a->data[2] * s, a->data[3] * s);
   }
 
-  return Qnil;
+  rb_raise(rb_eTypeError, "unsupported operand for Mat2 multiplication");
 }
 
 VALUE mat2_add(VALUE self, VALUE other) {
@@ -176,15 +178,10 @@ VALUE mat2_determinant(VALUE self) {
 }
 
 VALUE mat2_inverse(VALUE self) {
-  Mat2Data *a = mat2_get(self);
-  double det = a->data[0] * a->data[3] - a->data[2] * a->data[1];
-  if (fabs(det) < 1e-10) {
-    rb_raise(rb_eRuntimeError, "Matrix is not invertible");
-  }
-  double inv_det = 1.0 / det;
-  return mat2_build(rb_obj_class(self), a->data[3] * inv_det,
-                    -a->data[1] * inv_det, -a->data[2] * inv_det,
-                    a->data[0] * inv_det);
+  double inverse[4];
+  larb_matrix_inverse(mat2_get(self)->data, inverse, 2);
+  return mat2_build(rb_obj_class(self), inverse[0], inverse[1], inverse[2],
+                    inverse[3]);
 }
 
 VALUE mat2_transpose(VALUE self) {
@@ -201,9 +198,11 @@ VALUE mat2_adjoint(VALUE self) {
 
 VALUE mat2_frobenius_norm(VALUE self) {
   Mat2Data *a = mat2_get(self);
-  double sum = a->data[0] * a->data[0] + a->data[1] * a->data[1] +
-               a->data[2] * a->data[2] + a->data[3] * a->data[3];
-  return DBL2NUM(sqrt(sum));
+  double norm = 0.0;
+  for (int i = 0; i < 4; i++) {
+    norm = hypot(norm, a->data[i]);
+  }
+  return DBL2NUM(norm);
 }
 
 VALUE mat2_to_a(VALUE self) {
@@ -239,7 +238,10 @@ VALUE mat2_near(int argc, VALUE *argv, VALUE self) {
   rb_scan_args(argc, argv, "11", &other, &epsilon);
   Mat2Data *a = mat2_get(self);
   Mat2Data *b = mat2_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->data[0] - b->data[0]) < eps &&
       fabs(a->data[1] - b->data[1]) < eps &&
@@ -274,6 +276,7 @@ void Init_mat2(VALUE module) {
 
   rb_define_alloc_func(cMat2, mat2_alloc);
   rb_define_method(cMat2, "initialize", mat2_initialize, -1);
+  rb_define_method(cMat2, "initialize_copy", mat2_initialize_copy, 1);
 
   rb_define_singleton_method(cMat2, "identity", mat2_class_identity, 0);
   rb_define_singleton_method(cMat2, "zero", mat2_class_zero, 0);