larb 0.1.0 → 1.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1ca6912c8989e8917738c9965540ee392fce8e3c5bcfb95960b1e36d39a84b56
-  data.tar.gz: c38e9ab279c3e9ede439d90ff7e9153a523e189e7f5bf18867811c0356b21866
+  metadata.gz: e661682c31f5246004965e4c9883a15fae7aae30fccb2e9a56a6e0b5e28f7ad1
+  data.tar.gz: b4095f395b19e7c38d10659c7ae05169972c329087be2fa4481c97b456872b62
 SHA512:
-  metadata.gz: f3499157dd5c279ba8afac41e9d245742cfd7d6a31bdf83e683ee42d9c448e6b67666b1c28b15becf18640393486658e2825e44b10ded335a37a5eb37858c722
-  data.tar.gz: 381dce0add3519b5b0c2661a443d34aa2cc14dfcbb1225c5b507c744b2fa9cd31d89e7fdfac5a776abf6b924e28aeb08afa66ade9e87b19d7268f0946988b7a9
+  metadata.gz: c9a4f13ebd8ef25af8cea483059080e89dd955633006955458b65afda317dc23c5fe34875436a83353f2ca8a8e60f98cc2aa707d65a407eff4c01958b39186e0
+  data.tar.gz: 1f41fd169747e148a30a18b665ff41e259dd69ce303911d68c6058cb94dbce4d2034bf83d383c730fc216038c0c7a70399263f6444ed7d2e7eb159d1109cf548

data/CHANGELOG.md

@@ -2,6 +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

@@ -1,4 +1,4 @@
-# Larb
+# Larb [![Gem Version](https://badge.fury.io/rb/larb.svg)](https://badge.fury.io/rb/larb) [![CI](https://github.com/ydah/larb/actions/workflows/ci.yml/badge.svg)](https://github.com/ydah/larb/actions/workflows/ci.yml)
 
 Linear algebra library for 2D/3D graphics in Ruby.
 
@@ -58,6 +58,68 @@ 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
+# Install dependencies
+bundle install
+
+# Compile native extension
+bundle exec rake compile
+
+# Run tests
+bundle exec rake test
+```
+
 ## License
 
 The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/ext/larb/color.c

@@ -0,0 +1,449 @@
+#include "color.h"
+
+#include <math.h>
+
+static void color_free(void *ptr) {
+  xfree(ptr);
+}
+
+static size_t color_memsize(const void *ptr) {
+  return sizeof(ColorData);
+}
+
+static const rb_data_type_t color_type = {
+    "Color",
+    {0, color_free, color_memsize},
+    0,
+    0,
+    RUBY_TYPED_FREE_IMMEDIATELY,
+};
+
+static VALUE cColor = Qnil;
+static VALUE cVec3 = Qnil;
+static VALUE cVec4 = Qnil;
+
+static ColorData *color_get(VALUE obj) {
+  ColorData *data = NULL;
+  TypedData_Get_Struct(obj, ColorData, &color_type, data);
+  return data;
+}
+
+static VALUE color_build(VALUE klass, double r, double g, double b, double a) {
+  VALUE obj = color_alloc(klass);
+  ColorData *data = color_get(obj);
+  data->r = r;
+  data->g = g;
+  data->b = b;
+  data->a = a;
+  return obj;
+}
+
+static double clamp_double(double value, double min, double 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) {
+  ColorData *data = color_get(self);
+  return DBL2NUM(data->r);
+}
+
+static VALUE color_set_r(VALUE self, VALUE value) {
+  rb_check_frozen(self);
+  ColorData *data = color_get(self);
+  double component = NUM2DBL(value);
+  rb_check_frozen(self);
+  data->r = component;
+  return value;
+}
+
+static VALUE color_get_g(VALUE self) {
+  ColorData *data = color_get(self);
+  return DBL2NUM(data->g);
+}
+
+static VALUE color_set_g(VALUE self, VALUE value) {
+  rb_check_frozen(self);
+  ColorData *data = color_get(self);
+  double component = NUM2DBL(value);
+  rb_check_frozen(self);
+  data->g = component;
+  return value;
+}
+
+static VALUE color_get_b(VALUE self) {
+  ColorData *data = color_get(self);
+  return DBL2NUM(data->b);
+}
+
+static VALUE color_set_b(VALUE self, VALUE value) {
+  rb_check_frozen(self);
+  ColorData *data = color_get(self);
+  double component = NUM2DBL(value);
+  rb_check_frozen(self);
+  data->b = component;
+  return value;
+}
+
+static VALUE color_get_a(VALUE self) {
+  ColorData *data = color_get(self);
+  return DBL2NUM(data->a);
+}
+
+static VALUE color_set_a(VALUE self, VALUE value) {
+  rb_check_frozen(self);
+  ColorData *data = color_get(self);
+  double component = NUM2DBL(value);
+  rb_check_frozen(self);
+  data->a = component;
+  return value;
+}
+
+VALUE color_alloc(VALUE klass) {
+  ColorData *data = ALLOC(ColorData);
+  data->r = 0.0;
+  data->g = 0.0;
+  data->b = 0.0;
+  data->a = 1.0;
+  return TypedData_Wrap_Struct(klass, &color_type, data);
+}
+
+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;
+  rb_scan_args(argc, argv, "04", &vr, &vg, &vb, &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;
+}
+
+static VALUE color_class_bracket(int argc, VALUE *argv, VALUE klass) {
+  VALUE vr = Qnil;
+  VALUE vg = Qnil;
+  VALUE vb = Qnil;
+  VALUE va = Qnil;
+
+  rb_scan_args(argc, argv, "31", &vr, &vg, &vb, &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, 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, NUM2DBL(r), NUM2DBL(g),
+                     NUM2DBL(b), NUM2DBL(a));
+}
+
+static VALUE color_class_from_bytes(int argc, VALUE *argv, VALUE klass) {
+  VALUE vr = Qnil;
+  VALUE vg = Qnil;
+  VALUE vb = Qnil;
+  VALUE va = Qnil;
+
+  rb_scan_args(argc, argv, "31", &vr, &vg, &vb, &va);
+  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) {
+  StringValue(hex_value);
+  const char *hex = RSTRING_PTR(hex_value);
+  long len = RSTRING_LEN(hex_value);
+  if (len > 0 && hex[0] == '#') {
+    hex++;
+    len--;
+  }
+  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) {
+  return color_build(klass, 0.0, 0.0, 0.0, 1.0);
+}
+
+static VALUE color_class_white(VALUE klass) {
+  return color_build(klass, 1.0, 1.0, 1.0, 1.0);
+}
+
+static VALUE color_class_red(VALUE klass) {
+  return color_build(klass, 1.0, 0.0, 0.0, 1.0);
+}
+
+static VALUE color_class_green(VALUE klass) {
+  return color_build(klass, 0.0, 1.0, 0.0, 1.0);
+}
+
+static VALUE color_class_blue(VALUE klass) {
+  return color_build(klass, 0.0, 0.0, 1.0, 1.0);
+}
+
+static VALUE color_class_yellow(VALUE klass) {
+  return color_build(klass, 1.0, 1.0, 0.0, 1.0);
+}
+
+static VALUE color_class_cyan(VALUE klass) {
+  return color_build(klass, 0.0, 1.0, 1.0, 1.0);
+}
+
+static VALUE color_class_magenta(VALUE klass) {
+  return color_build(klass, 1.0, 0.0, 1.0, 1.0);
+}
+
+static VALUE color_class_transparent(VALUE klass) {
+  return color_build(klass, 0.0, 0.0, 0.0, 0.0);
+}
+
+VALUE color_class_from_vec4(VALUE klass, VALUE vec4) {
+  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);
+}
+
+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 = 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);
+}
+
+VALUE color_add(VALUE self, VALUE other) {
+  ColorData *a = color_get(self);
+  ColorData *b = color_get(other);
+  return color_build(rb_obj_class(self), a->r + b->r, a->g + b->g, a->b + b->b,
+                     a->a + b->a);
+}
+
+VALUE color_sub(VALUE self, VALUE other) {
+  ColorData *a = color_get(self);
+  ColorData *b = color_get(other);
+  return color_build(rb_obj_class(self), a->r - b->r, a->g - b->g, a->b - b->b,
+                     a->a - b->a);
+}
+
+VALUE color_mul(VALUE self, VALUE scalar) {
+  ColorData *a = color_get(self);
+  if (rb_obj_is_kind_of(scalar, cColor)) {
+    ColorData *b = color_get(scalar);
+    return color_build(rb_obj_class(self), a->r * b->r, a->g * b->g,
+                       a->b * b->b, a->a * b->a);
+  }
+  if (rb_obj_is_kind_of(scalar, rb_cNumeric)) {
+    double s = NUM2DBL(scalar);
+    return color_build(rb_obj_class(self), a->r * s, a->g * s, a->b * s,
+                       a->a * s);
+  }
+  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 = 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);
+}
+
+VALUE color_clamp(VALUE self) {
+  ColorData *a = color_get(self);
+  return color_build(rb_obj_class(self), clamp_double(a->r, 0.0, 1.0),
+                     clamp_double(a->g, 0.0, 1.0),
+                     clamp_double(a->b, 0.0, 1.0),
+                     clamp_double(a->a, 0.0, 1.0));
+}
+
+VALUE color_to_bytes(VALUE self) {
+  ColorData *a = color_get(self);
+  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) {
+  VALUE bytes = color_to_bytes(self);
+  VALUE r = rb_ary_entry(bytes, 0);
+  VALUE g = rb_ary_entry(bytes, 1);
+  VALUE b = rb_ary_entry(bytes, 2);
+  VALUE a = rb_ary_entry(bytes, 3);
+  return rb_funcall(rb_mKernel, rb_intern("format"), 5,
+                    rb_str_new_cstr("#%02x%02x%02x%02x"), r, g, b, a);
+}
+
+VALUE color_to_vec3(VALUE self) {
+  ColorData *a = color_get(self);
+  return rb_funcall(cVec3, rb_intern("new"), 3, DBL2NUM(a->r), DBL2NUM(a->g),
+                    DBL2NUM(a->b));
+}
+
+VALUE color_to_vec4(VALUE self) {
+  ColorData *a = color_get(self);
+  return rb_funcall(cVec4, rb_intern("new"), 4, DBL2NUM(a->r), DBL2NUM(a->g),
+                    DBL2NUM(a->b), DBL2NUM(a->a));
+}
+
+VALUE color_to_a(VALUE self) {
+  ColorData *a = color_get(self);
+  VALUE ary = rb_ary_new_capa(4);
+  rb_ary_push(ary, DBL2NUM(a->r));
+  rb_ary_push(ary, DBL2NUM(a->g));
+  rb_ary_push(ary, DBL2NUM(a->b));
+  rb_ary_push(ary, DBL2NUM(a->a));
+  return ary;
+}
+
+VALUE color_aref(VALUE self, VALUE index) {
+  VALUE ary = color_to_a(self);
+  return rb_ary_entry(ary, NUM2LONG(index));
+}
+
+VALUE color_equal(VALUE self, VALUE other) {
+  if (!rb_obj_is_kind_of(other, cColor)) {
+    return Qfalse;
+  }
+  ColorData *a = color_get(self);
+  ColorData *b = color_get(other);
+  return (a->r == b->r && a->g == b->g && a->b == b->b && a->a == b->a)
+             ? Qtrue
+             : Qfalse;
+}
+
+VALUE color_near(int argc, VALUE *argv, VALUE self) {
+  VALUE other = Qnil;
+  VALUE epsilon = Qnil;
+
+  rb_scan_args(argc, argv, "11", &other, &epsilon);
+  ColorData *a = color_get(self);
+  ColorData *b = color_get(other);
+  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) {
+    return Qtrue;
+  }
+  return Qfalse;
+}
+
+VALUE color_inspect(VALUE self) {
+  ColorData *a = color_get(self);
+  VALUE sr = rb_funcall(DBL2NUM(a->r), rb_intern("to_s"), 0);
+  VALUE sg = rb_funcall(DBL2NUM(a->g), rb_intern("to_s"), 0);
+  VALUE sb = rb_funcall(DBL2NUM(a->b), rb_intern("to_s"), 0);
+  VALUE sa = rb_funcall(DBL2NUM(a->a), rb_intern("to_s"), 0);
+  VALUE str = rb_str_new_cstr("Color[");
+  rb_str_concat(str, sr);
+  rb_str_cat_cstr(str, ", ");
+  rb_str_concat(str, sg);
+  rb_str_cat_cstr(str, ", ");
+  rb_str_concat(str, sb);
+  rb_str_cat_cstr(str, ", ");
+  rb_str_concat(str, sa);
+  rb_str_cat_cstr(str, "]");
+  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"));
+  cVec4 = rb_const_get(mLarb, rb_intern("Vec4"));
+
+  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);
+  rb_define_singleton_method(cColor, "rgba", color_class_rgba, 4);
+  rb_define_singleton_method(cColor, "from_bytes", color_class_from_bytes, -1);
+  rb_define_singleton_method(cColor, "from_hex", color_class_from_hex, 1);
+  rb_define_singleton_method(cColor, "black", color_class_black, 0);
+  rb_define_singleton_method(cColor, "white", color_class_white, 0);
+  rb_define_singleton_method(cColor, "red", color_class_red, 0);
+  rb_define_singleton_method(cColor, "green", color_class_green, 0);
+  rb_define_singleton_method(cColor, "blue", color_class_blue, 0);
+  rb_define_singleton_method(cColor, "yellow", color_class_yellow, 0);
+  rb_define_singleton_method(cColor, "cyan", color_class_cyan, 0);
+  rb_define_singleton_method(cColor, "magenta", color_class_magenta, 0);
+  rb_define_singleton_method(cColor, "transparent", color_class_transparent, 0);
+  rb_define_singleton_method(cColor, "from_vec4", color_class_from_vec4, 1);
+  rb_define_singleton_method(cColor, "from_vec3", color_class_from_vec3, -1);
+
+  rb_define_method(cColor, "r", color_get_r, 0);
+  rb_define_method(cColor, "r=", color_set_r, 1);
+  rb_define_method(cColor, "g", color_get_g, 0);
+  rb_define_method(cColor, "g=", color_set_g, 1);
+  rb_define_method(cColor, "b", color_get_b, 0);
+  rb_define_method(cColor, "b=", color_set_b, 1);
+  rb_define_method(cColor, "a", color_get_a, 0);
+  rb_define_method(cColor, "a=", color_set_a, 1);
+
+  rb_define_method(cColor, "+", color_add, 1);
+  rb_define_method(cColor, "-", color_sub, 1);
+  rb_define_method(cColor, "*", color_mul, 1);
+  rb_define_method(cColor, "lerp", color_lerp, 2);
+  rb_define_method(cColor, "clamp", color_clamp, 0);
+  rb_define_method(cColor, "to_bytes", color_to_bytes, 0);
+  rb_define_method(cColor, "to_hex", color_to_hex, 0);
+  rb_define_method(cColor, "to_vec3", color_to_vec3, 0);
+  rb_define_method(cColor, "to_vec4", color_to_vec4, 0);
+  rb_define_method(cColor, "to_a", color_to_a, 0);
+  rb_define_method(cColor, "[]", color_aref, 1);
+  rb_define_method(cColor, "==", color_equal, 1);
+  rb_define_method(cColor, "near?", color_near, -1);
+  rb_define_method(cColor, "inspect", color_inspect, 0);
+  rb_define_alias(cColor, "to_s", "inspect");
+}

data/ext/larb/color.h

@@ -0,0 +1,35 @@
+#ifndef COLOR_H
+#define COLOR_H
+
+#include "larb.h"
+
+typedef struct {
+  double r;
+  double g;
+  double b;
+  double a;
+} ColorData;
+
+void Init_color(VALUE module);
+VALUE color_alloc(VALUE klass);
+VALUE color_initialize(int argc, VALUE *argv, VALUE self);
+
+VALUE color_class_from_vec4(VALUE klass, VALUE vec4);
+VALUE color_class_from_vec3(int argc, VALUE *argv, VALUE klass);
+
+VALUE color_add(VALUE self, VALUE other);
+VALUE color_sub(VALUE self, VALUE other);
+VALUE color_mul(VALUE self, VALUE scalar);
+VALUE color_lerp(VALUE self, VALUE other, VALUE t);
+VALUE color_clamp(VALUE self);
+VALUE color_to_bytes(VALUE self);
+VALUE color_to_hex(VALUE self);
+VALUE color_to_vec3(VALUE self);
+VALUE color_to_vec4(VALUE self);
+VALUE color_to_a(VALUE self);
+VALUE color_aref(VALUE self, VALUE index);
+VALUE color_equal(VALUE self, VALUE other);
+VALUE color_near(int argc, VALUE *argv, VALUE self);
+VALUE color_inspect(VALUE self);
+
+#endif

data/ext/larb/extconf.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+require "mkmf"
+
+# mathライブラリの確認
+have_library("m", "sin")
+
+# 最適化フラグ
+$CFLAGS << " -O3 -march=native -funroll-loops"
+
+create_makefile("larb/larb")

data/ext/larb/larb.c

@@ -0,0 +1,27 @@
+#include "larb.h"
+#include "vec2.h"
+#include "vec3.h"
+#include "vec4.h"
+#include "mat2.h"
+#include "mat3.h"
+#include "mat4.h"
+#include "quat.h"
+#include "mat2d.h"
+#include "color.h"
+#include "quat2.h"
+
+VALUE mLarb = Qnil;
+
+void Init_larb(void) {
+  mLarb = rb_define_module("Larb");
+  Init_vec2(mLarb);
+  Init_vec3(mLarb);
+  Init_vec4(mLarb);
+  Init_mat2(mLarb);
+  Init_mat3(mLarb);
+  Init_quat(mLarb);
+  Init_mat4(mLarb);
+  Init_mat2d(mLarb);
+  Init_color(mLarb);
+  Init_quat2(mLarb);
+}

data/ext/larb/larb.h

@@ -0,0 +1,31 @@
+#ifndef LARB_H
+#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