snow-math 1.6.1 → 1.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 59c66cdb4331e39915f31821b06050210de0101b
-  data.tar.gz: 38339703c8a3dc316120129c559b5d5fe096c1a9
+  metadata.gz: 07dcfa849094229689bdbf469119e52479b5034e
+  data.tar.gz: 51702b6e75a2b89f77c257a79ca5e1b9162a763a
 SHA512:
-  metadata.gz: 848fb1b812af454cb1775db23d1cdd59f071c8f4f8dfbce4eb2315e760445a55ad6f02bb74443d25c6de9a521fdae2db837ca0087e2a6f8314211783ccb8b274
-  data.tar.gz: 3236a1958069e2d11086fcc688e30c13c8b141a2b034f24a085b0f1142a2f72bc1c680b00760b129a209d364ad54282f1812ff841a2091ccd17c2aa512862ac9
+  metadata.gz: 6a625c25c0d0c193dc9cd1d76f921c6ac8e59d94da5da176418656afa924c6f7d2a9dfc8054c091736faa934a37354e5893fa1296c8bfb6905ad0b3f1ffdd562
+  data.tar.gz: a1f15c58795706985615239610c1a673ab009a41a12df9061c3bfac81b4af5f5c00cb03c74e0eba84236b230e9dd0beef48e3bc94ecd6d8d9fe286eea7ca892f

data/ext/snow-math/maths.c

@@ -1,2 +1,10 @@
 #include "maths_local.h"
 #define __SNOW__MATHS_C__
+
+s_float_t S_FLOAT_EPSILON = s_float_lit(
+                            #ifdef USE_FLOAT
+                            1.0e-6
+                            #else
+                            1.0e-9
+                            #endif
+                            );

data/ext/snow-math/maths_local.h

@@ -69,7 +69,7 @@ typedef s_float_t quat_t[4];
  *
  * It should be stressed that this is absolutely not an accurate epsilon.
  */
-#define S_FLOAT_EPSILON s_float_lit(1.0e-9)
+extern s_float_t S_FLOAT_EPSILON;
 
 #define S_DEG2RAD s_float_lit(0.01745329)
 #define S_RAD2DEG s_float_lit(57.2957795)

data/ext/snow-math/snow-math.c

@@ -87,6 +87,37 @@ static VALUE sm_mathtype_array_length(VALUE sm_self)
   return rb_ivar_get(sm_self, kRB_IVAR_MATHARRAY_LENGTH);
 }
 
+
+
+/*
+ * Freezes the array and its elements.
+ *
+ * call-seq: freeze -> self
+ */
+static VALUE sm_mathtype_array_freeze(VALUE sm_self)
+{
+  VALUE sm_cache;
+  VALUE sm_cached_entry;
+  long length;
+  long index;
+
+  if (OBJ_FROZEN(sm_self)) {
+    return sm_self;
+  }
+
+  sm_cache = rb_ivar_get(sm_self, kRB_IVAR_MATHARRAY_CACHE);
+  length = RARRAY_LEN(sm_cache);
+
+  for (index = 0; index < length; ++index) {
+    sm_cached_entry = rb_ary_entry(sm_cache, index);
+    if (RTEST(sm_cached_entry)) {
+      rb_funcall2(sm_cached_entry, kRB_NAME_FREEZE, 0, 0);
+    }
+  }
+
+  return rb_call_super(0, 0);
+}
+
 #endif
 
 
@@ -188,37 +219,6 @@ static VALUE sm_vec2_array_new(VALUE sm_self, VALUE sm_length_or_copy)
 
 
 
-/*
- * Freezes the array and its elements.
- *
- * call-seq: freeze -> self
- */
-static VALUE sm_vec2_array_freeze(VALUE sm_self)
-{
-  VALUE sm_cache;
-  VALUE sm_cached_entry;
-  long length;
-  long index;
-
-  if (OBJ_FROZEN(sm_self)) {
-    return sm_self;
-  }
-
-  sm_cache = rb_ivar_get(sm_self, kRB_IVAR_MATHARRAY_CACHE);
-  length = RARRAY_LEN(sm_cache);
-
-  for (index = 0; index < length; ++index) {
-    sm_cached_entry = rb_ary_entry(sm_cache, index);
-    if (RTEST(sm_cached_entry) && !OBJ_FROZEN(sm_cached_entry)) {
-      rb_funcall2(sm_cached_entry, kRB_NAME_FREEZE, 0, 0);
-    }
-  }
-
-  return rb_call_super(0, 0);
-}
-
-
-
 /*
  * Resizes the array to new_length and returns self.
  *
@@ -418,37 +418,6 @@ static VALUE sm_vec3_array_new(VALUE sm_self, VALUE sm_length_or_copy)
 
 
 
-/*
- * Freezes the array and its elements.
- *
- * call-seq: freeze -> self
- */
-static VALUE sm_vec3_array_freeze(VALUE sm_self)
-{
-  VALUE sm_cache;
-  VALUE sm_cached_entry;
-  long length;
-  long index;
-
-  if (OBJ_FROZEN(sm_self)) {
-    return sm_self;
-  }
-
-  sm_cache = rb_ivar_get(sm_self, kRB_IVAR_MATHARRAY_CACHE);
-  length = RARRAY_LEN(sm_cache);
-
-  for (index = 0; index < length; ++index) {
-    sm_cached_entry = rb_ary_entry(sm_cache, index);
-    if (RTEST(sm_cached_entry)) {
-      rb_funcall2(sm_cached_entry, kRB_NAME_FREEZE, 0, 0);
-    }
-  }
-
-  return rb_call_super(0, 0);
-}
-
-
-
 /*
  * Resizes the array to new_length and returns self.
  *
@@ -647,37 +616,6 @@ static VALUE sm_vec4_array_new(VALUE sm_self, VALUE sm_length_or_copy)
 
 
 
-/*
- * Freezes the array and its elements.
- *
- * call-seq: freeze -> self
- */
-static VALUE sm_vec4_array_freeze(VALUE sm_self)
-{
-  VALUE sm_cache;
-  VALUE sm_cached_entry;
-  long length;
-  long index;
-
-  if (OBJ_FROZEN(sm_self)) {
-    return sm_self;
-  }
-
-  sm_cache = rb_ivar_get(sm_self, kRB_IVAR_MATHARRAY_CACHE);
-  length = RARRAY_LEN(sm_cache);
-
-  for (index = 0; index < length; ++index) {
-    sm_cached_entry = rb_ary_entry(sm_cache, index);
-    if (RTEST(sm_cached_entry)) {
-      rb_funcall2(sm_cached_entry, kRB_NAME_FREEZE, 0, 0);
-    }
-  }
-
-  return rb_call_super(0, 0);
-}
-
-
-
 /*
  * Resizes the array to new_length and returns self.
  *
@@ -876,37 +814,6 @@ static VALUE sm_quat_array_new(VALUE sm_self, VALUE sm_length_or_copy)
 
 
 
-/*
- * Freezes the array and its elements.
- *
- * call-seq: freeze -> self
- */
-static VALUE sm_quat_array_freeze(VALUE sm_self)
-{
-  VALUE sm_cache;
-  VALUE sm_cached_entry;
-  long length;
-  long index;
-
-  if (OBJ_FROZEN(sm_self)) {
-    return sm_self;
-  }
-
-  sm_cache = rb_ivar_get(sm_self, kRB_IVAR_MATHARRAY_CACHE);
-  length = RARRAY_LEN(sm_cache);
-
-  for (index = 0; index < length; ++index) {
-    sm_cached_entry = rb_ary_entry(sm_cache, index);
-    if (RTEST(sm_cached_entry)) {
-      rb_funcall2(sm_cached_entry, kRB_NAME_FREEZE, 0, 0);
-    }
-  }
-
-  return rb_call_super(0, 0);
-}
-
-
-
 /*
  * Resizes the array to new_length and returns self.
  *
@@ -1105,37 +1012,6 @@ static VALUE sm_mat3_array_new(VALUE sm_self, VALUE sm_length_or_copy)
 
 
 
-/*
- * Freezes the array and its elements.
- *
- * call-seq: freeze -> self
- */
-static VALUE sm_mat3_array_freeze(VALUE sm_self)
-{
-  VALUE sm_cache;
-  VALUE sm_cached_entry;
-  long length;
-  long index;
-
-  if (OBJ_FROZEN(sm_self)) {
-    return sm_self;
-  }
-
-  sm_cache = rb_ivar_get(sm_self, kRB_IVAR_MATHARRAY_CACHE);
-  length = RARRAY_LEN(sm_cache);
-
-  for (index = 0; index < length; ++index) {
-    sm_cached_entry = rb_ary_entry(sm_cache, index);
-    if (RTEST(sm_cached_entry)) {
-      rb_funcall2(sm_cached_entry, kRB_NAME_FREEZE, 0, 0);
-    }
-  }
-
-  return rb_call_super(0, 0);
-}
-
-
-
 /*
  * Resizes the array to new_length and returns self.
  *
@@ -1340,37 +1216,6 @@ static VALUE sm_mat4_array_new(VALUE sm_self, VALUE sm_length_or_copy)
 
 
 
-/*
- * Freezes the array and its elements.
- *
- * call-seq: freeze -> self
- */
-static VALUE sm_mat4_array_freeze(VALUE sm_self)
-{
-  VALUE sm_cache;
-  VALUE sm_cached_entry;
-  long length;
-  long index;
-
-  if (OBJ_FROZEN(sm_self)) {
-    return sm_self;
-  }
-
-  sm_cache = rb_ivar_get(sm_self, kRB_IVAR_MATHARRAY_CACHE);
-  length = RARRAY_LEN(sm_cache);
-
-  for (index = 0; index < length; ++index) {
-    sm_cached_entry = rb_ary_entry(sm_cache, index);
-    if (RTEST(sm_cached_entry)) {
-      rb_funcall2(sm_cached_entry, kRB_NAME_FREEZE, 0, 0);
-    }
-  }
-
-  return rb_call_super(0, 0);
-}
-
-
-
 /*
  * Resizes the array to new_length and returns self.
  *
@@ -1576,7 +1421,7 @@ static VALUE sm_vec2_fetch (VALUE sm_self, VALUE sm_index)
     rb_raise(rb_eRangeError,
       "Index %d is out of bounds, must be from 0 through %d", index, max_index - 1);
   }
-  return rb_float_new(self[0][NUM2INT(sm_index)]);
+  return DBL2NUM(self[0][NUM2INT(sm_index)]);
 }
 
 
@@ -1596,7 +1441,7 @@ static VALUE sm_vec2_store (VALUE sm_self, VALUE sm_index, VALUE sm_value)
     rb_raise(rb_eRangeError,
       "Index %d is out of bounds, must be from 0 through %d", index, max_index - 1);
   }
-  self[0][index] = (s_float_t)rb_num2dbl(sm_value);
+  self[0][index] = (s_float_t)NUM2DBL(sm_value);
   return sm_value;
 }
 
@@ -2058,7 +1903,7 @@ static VALUE sm_vec2_dot_product(VALUE sm_self, VALUE sm_other)
       rb_obj_classname(sm_other));
     return Qnil;
   }
-  return rb_float_new(
+  return DBL2NUM(
     vec2_dot_product(
       *sm_unwrap_vec2(sm_self, NULL),
       *sm_unwrap_vec2(sm_other, NULL)));
@@ -2124,8 +1969,8 @@ static VALUE sm_vec2_init(int argc, VALUE *argv, VALUE sm_self)
     if (0) {
       case 2:
       if (!SM_RB_IS_A(argv[0], rb_cArray)) {
-        self[0][0] = (s_float_t)rb_num2dbl(argv[0]);
-        self[0][1] = (s_float_t)rb_num2dbl(argv[1]);
+        self[0][0] = (s_float_t)NUM2DBL(argv[0]);
+        self[0][1] = (s_float_t)NUM2DBL(argv[1]);
         break;
       }
       arr_index = NUM2SIZET(argv[1]);
@@ -2136,7 +1981,7 @@ static VALUE sm_vec2_init(int argc, VALUE *argv, VALUE sm_self)
     const size_t arr_end = arr_index + 2;
     s_float_t *vec_elem = *self;
     for (; arr_index < arr_end; ++arr_index, ++vec_elem) {
-      *vec_elem = (s_float_t)rb_num2dbl(rb_ary_entry(arrdata, (long)arr_index));
+      *vec_elem = (s_float_t)NUM2DBL(rb_ary_entry(arrdata, (long)arr_index));
     }
     break;
   }
@@ -2181,7 +2026,7 @@ static VALUE sm_vec2_to_s(VALUE self)
  */
 static VALUE sm_vec2_magnitude_squared(VALUE sm_self)
 {
-  return rb_float_new(vec2_length_squared(*sm_unwrap_vec2(sm_self, NULL)));
+  return DBL2NUM(vec2_length_squared(*sm_unwrap_vec2(sm_self, NULL)));
 }
 
 
@@ -2194,7 +2039,7 @@ static VALUE sm_vec2_magnitude_squared(VALUE sm_self)
  */
 static VALUE sm_vec2_magnitude(VALUE sm_self)
 {
-  return rb_float_new(vec2_length(*sm_unwrap_vec2(sm_self, NULL)));
+  return DBL2NUM(vec2_length(*sm_unwrap_vec2(sm_self, NULL)));
 }
 
 
@@ -2213,7 +2058,7 @@ static VALUE sm_vec2_scale(int argc, VALUE *argv, VALUE sm_self)
   vec2_t *self = sm_unwrap_vec2(sm_self, NULL);
 
   rb_scan_args(argc, argv, "11", &sm_scalar, &sm_out);
-  scalar = rb_num2dbl(sm_scalar);
+  scalar = NUM2DBL(sm_scalar);
 
   if (SM_IS_A(sm_out, vec2) || SM_IS_A(sm_out, vec3) || SM_IS_A(sm_out, vec4) || SM_IS_A(sm_out, quat)) {
     rb_check_frozen(sm_out);
@@ -2244,7 +2089,7 @@ static VALUE sm_vec2_divide(int argc, VALUE *argv, VALUE sm_self)
   vec2_t *self = sm_unwrap_vec2(sm_self, NULL);
 
   rb_scan_args(argc, argv, "11", &sm_scalar, &sm_out);
-  scalar = rb_num2dbl(sm_scalar);
+  scalar = NUM2DBL(sm_scalar);
 
   if (SM_IS_A(sm_out, vec2) || SM_IS_A(sm_out, vec3) || SM_IS_A(sm_out, vec4) || SM_IS_A(sm_out, quat)) {
     rb_check_frozen(sm_out);
@@ -2329,7 +2174,7 @@ static VALUE sm_vec3_fetch (VALUE sm_self, VALUE sm_index)
     rb_raise(rb_eRangeError,
       "Index %d is out of bounds, must be from 0 through %d", index, max_index - 1);
   }
-  return rb_float_new(self[0][NUM2INT(sm_index)]);
+  return DBL2NUM(self[0][NUM2INT(sm_index)]);
 }
 
 
@@ -2349,7 +2194,7 @@ static VALUE sm_vec3_store (VALUE sm_self, VALUE sm_index, VALUE sm_value)
     rb_raise(rb_eRangeError,
       "Index %d is out of bounds, must be from 0 through %d", index, max_index - 1);
   }
-  self[0][index] = (s_float_t)rb_num2dbl(sm_value);
+  self[0][index] = (s_float_t)NUM2DBL(sm_value);
   return sm_value;
 }
 
@@ -2858,7 +2703,7 @@ static VALUE sm_vec3_dot_product(VALUE sm_self, VALUE sm_other)
       rb_obj_classname(sm_other));
     return Qnil;
   }
-  return rb_float_new(
+  return DBL2NUM(
     vec3_dot_product(
       *sm_unwrap_vec3(sm_self, NULL),
       *sm_unwrap_vec3(sm_other, NULL)));
@@ -2936,7 +2781,7 @@ static VALUE sm_vec3_init(int argc, VALUE *argv, VALUE sm_self)
       const size_t arr_end = arr_index + 3;
       s_float_t *vec_elem = *self;
       for (; arr_index < arr_end; ++arr_index, ++vec_elem) {
-        *vec_elem = (s_float_t)rb_num2dbl(rb_ary_entry(arrdata, (long)arr_index));
+        *vec_elem = (s_float_t)NUM2DBL(rb_ary_entry(arrdata, (long)arr_index));
       }
       break;
     }
@@ -2947,9 +2792,9 @@ static VALUE sm_vec3_init(int argc, VALUE *argv, VALUE sm_self)
 
   /* X, Y, Z */
   case 3: {
-    self[0][0] = (s_float_t)rb_num2dbl(argv[0]);
-    self[0][1] = (s_float_t)rb_num2dbl(argv[1]);
-    self[0][2] = (s_float_t)rb_num2dbl(argv[2]);
+    self[0][0] = (s_float_t)NUM2DBL(argv[0]);
+    self[0][1] = (s_float_t)NUM2DBL(argv[1]);
+    self[0][2] = (s_float_t)NUM2DBL(argv[2]);
     break;
   }
 
@@ -2993,7 +2838,7 @@ static VALUE sm_vec3_to_s(VALUE self)
  */
 static VALUE sm_vec3_magnitude_squared(VALUE sm_self)
 {
-  return rb_float_new(vec3_length_squared(*sm_unwrap_vec3(sm_self, NULL)));
+  return DBL2NUM(vec3_length_squared(*sm_unwrap_vec3(sm_self, NULL)));
 }
 
 
@@ -3006,7 +2851,7 @@ static VALUE sm_vec3_magnitude_squared(VALUE sm_self)
  */
 static VALUE sm_vec3_magnitude(VALUE sm_self)
 {
-  return rb_float_new(vec3_length(*sm_unwrap_vec3(sm_self, NULL)));
+  return DBL2NUM(vec3_length(*sm_unwrap_vec3(sm_self, NULL)));
 }
 
 
@@ -3025,7 +2870,7 @@ static VALUE sm_vec3_scale(int argc, VALUE *argv, VALUE sm_self)
   vec3_t *self = sm_unwrap_vec3(sm_self, NULL);
 
   rb_scan_args(argc, argv, "11", &sm_scalar, &sm_out);
-  scalar = rb_num2dbl(sm_scalar);
+  scalar = NUM2DBL(sm_scalar);
 
   if (SM_IS_A(sm_out, vec3) || SM_IS_A(sm_out, vec4) || SM_IS_A(sm_out, quat)) {
     rb_check_frozen(sm_out);
@@ -3056,7 +2901,7 @@ static VALUE sm_vec3_divide(int argc, VALUE *argv, VALUE sm_self)
   vec3_t *self = sm_unwrap_vec3(sm_self, NULL);
 
   rb_scan_args(argc, argv, "11", &sm_scalar, &sm_out);
-  scalar = rb_num2dbl(sm_scalar);
+  scalar = NUM2DBL(sm_scalar);
 
   if (SM_IS_A(sm_out, vec3) || SM_IS_A(sm_out, vec4) || SM_IS_A(sm_out, quat)) {
     rb_check_frozen(sm_out);
@@ -3140,7 +2985,7 @@ static VALUE sm_vec4_fetch (VALUE sm_self, VALUE sm_index)
     rb_raise(rb_eRangeError,
       "Index %d is out of bounds, must be from 0 through %d", index, max_index - 1);
   }
-  return rb_float_new(self[0][NUM2INT(sm_index)]);
+  return DBL2NUM(self[0][NUM2INT(sm_index)]);
 }
 
 
@@ -3160,7 +3005,7 @@ static VALUE sm_vec4_store (VALUE sm_self, VALUE sm_index, VALUE sm_value)
     rb_raise(rb_eRangeError,
       "Index %d is out of bounds, must be from 0 through %d", index, max_index - 1);
   }
-  self[0][index] = (s_float_t)rb_num2dbl(sm_value);
+  self[0][index] = (s_float_t)NUM2DBL(sm_value);
   return sm_value;
 }
 
@@ -3618,7 +3463,7 @@ static VALUE sm_vec4_dot_product(VALUE sm_self, VALUE sm_other)
       rb_obj_classname(sm_other));
     return Qnil;
   }
-  return rb_float_new(
+  return DBL2NUM(
     vec4_dot_product(
       *sm_unwrap_vec4(sm_self, NULL),
       *sm_unwrap_vec4(sm_other, NULL)));
@@ -3702,7 +3547,7 @@ static VALUE sm_vec4_init(int argc, VALUE *argv, VALUE sm_self)
       const size_t arr_end = arr_index + 4;
       s_float_t *vec_elem = *self;
       for (; arr_index < arr_end; ++arr_index, ++vec_elem) {
-        *vec_elem = (s_float_t)rb_num2dbl(rb_ary_entry(arrdata, (long)arr_index));
+        *vec_elem = (s_float_t)NUM2DBL(rb_ary_entry(arrdata, (long)arr_index));
       }
       break;
     }
@@ -3713,11 +3558,11 @@ static VALUE sm_vec4_init(int argc, VALUE *argv, VALUE sm_self)
 
   /* W */
   case 4: {
-    self[0][3] = (s_float_t)rb_num2dbl(argv[3]);
+    self[0][3] = (s_float_t)NUM2DBL(argv[3]);
     case 3: /* X, Y, Z */
-    self[0][0] = (s_float_t)rb_num2dbl(argv[0]);
-    self[0][1] = (s_float_t)rb_num2dbl(argv[1]);
-    self[0][2] = (s_float_t)rb_num2dbl(argv[2]);
+    self[0][0] = (s_float_t)NUM2DBL(argv[0]);
+    self[0][1] = (s_float_t)NUM2DBL(argv[1]);
+    self[0][2] = (s_float_t)NUM2DBL(argv[2]);
     break;
   }
 
@@ -3761,7 +3606,7 @@ static VALUE sm_vec4_to_s(VALUE self)
  */
 static VALUE sm_vec4_magnitude_squared(VALUE sm_self)
 {
-  return rb_float_new(vec4_length_squared(*sm_unwrap_vec4(sm_self, NULL)));
+  return DBL2NUM(vec4_length_squared(*sm_unwrap_vec4(sm_self, NULL)));
 }
 
 
@@ -3774,7 +3619,7 @@ static VALUE sm_vec4_magnitude_squared(VALUE sm_self)
  */
 static VALUE sm_vec4_magnitude(VALUE sm_self)
 {
-  return rb_float_new(vec4_length(*sm_unwrap_vec4(sm_self, NULL)));
+  return DBL2NUM(vec4_length(*sm_unwrap_vec4(sm_self, NULL)));
 }
 
 
@@ -3794,7 +3639,7 @@ static VALUE sm_vec4_scale(int argc, VALUE *argv, VALUE sm_self)
   vec4_t *self = sm_unwrap_vec4(sm_self, NULL);
 
   rb_scan_args(argc, argv, "11", &sm_scalar, &sm_out);
-  scalar = rb_num2dbl(sm_scalar);
+  scalar = NUM2DBL(sm_scalar);
 
   if ((SM_IS_A(sm_out, vec4) || SM_IS_A(sm_out, quat))) {
     rb_check_frozen(sm_out);
@@ -3826,7 +3671,7 @@ static VALUE sm_vec4_divide(int argc, VALUE *argv, VALUE sm_self)
   vec4_t *self = sm_unwrap_vec4(sm_self, NULL);
 
   rb_scan_args(argc, argv, "11", &sm_scalar, &sm_out);
-  scalar = rb_num2dbl(sm_scalar);
+  scalar = NUM2DBL(sm_scalar);
 
   if ((SM_IS_A(sm_out, vec4) || SM_IS_A(sm_out, quat))) {
     rb_check_frozen(sm_out);
@@ -3909,7 +3754,7 @@ static VALUE sm_quat_fetch (VALUE sm_self, VALUE sm_index)
     rb_raise(rb_eRangeError,
       "Index %d is out of bounds, must be from 0 through %d", index, max_index - 1);
   }
-  return rb_float_new(self[0][NUM2INT(sm_index)]);
+  return DBL2NUM(self[0][NUM2INT(sm_index)]);
 }
 
 
@@ -3929,7 +3774,7 @@ static VALUE sm_quat_store (VALUE sm_self, VALUE sm_index, VALUE sm_value)
     rb_raise(rb_eRangeError,
       "Index %d is out of bounds, must be from 0 through %d", index, max_index - 1);
   }
-  self[0][index] = (s_float_t)rb_num2dbl(sm_value);
+  self[0][index] = (s_float_t)NUM2DBL(sm_value);
   return sm_value;
 }
 
@@ -4192,7 +4037,7 @@ static VALUE sm_quat_init(int argc, VALUE *argv, VALUE sm_self)
       const size_t arr_end = arr_index + 3;
       s_float_t *vec_elem = *self;
       for (; arr_index < arr_end; ++arr_index, ++vec_elem) {
-        *vec_elem = (s_float_t)rb_num2dbl(rb_ary_entry(arrdata, (long)arr_index));
+        *vec_elem = (s_float_t)NUM2DBL(rb_ary_entry(arrdata, (long)arr_index));
       }
       break;
     }
@@ -4203,11 +4048,11 @@ static VALUE sm_quat_init(int argc, VALUE *argv, VALUE sm_self)
 
   /* W */
   case 4: {
-    self[0][3] = (s_float_t)rb_num2dbl(argv[3]);
+    self[0][3] = (s_float_t)NUM2DBL(argv[3]);
     case 3: /* X, Y, Z */
-    self[0][0] = (s_float_t)rb_num2dbl(argv[0]);
-    self[0][1] = (s_float_t)rb_num2dbl(argv[1]);
-    self[0][2] = (s_float_t)rb_num2dbl(argv[2]);
+    self[0][0] = (s_float_t)NUM2DBL(argv[0]);
+    self[0][1] = (s_float_t)NUM2DBL(argv[1]);
+    self[0][2] = (s_float_t)NUM2DBL(argv[2]);
     break;
   }
 
@@ -4265,7 +4110,7 @@ static VALUE sm_quat_angle_axis(int argc, VALUE *argv, VALUE self)
     return Qnil;
   }
 
-  angle = (s_float_t)rb_num2dbl(sm_angle);
+  angle = (s_float_t)NUM2DBL(sm_angle);
   axis = sm_unwrap_vec3(sm_axis, NULL);
 
   if (SM_IS_A(sm_out, quat) || SM_IS_A(sm_out, vec4)) {
@@ -4317,7 +4162,7 @@ static VALUE sm_quat_slerp(int argc, VALUE *argv, VALUE sm_self)
   s_float_t alpha;
 
   rb_scan_args(argc, argv, "21", &sm_destination, &sm_alpha, &sm_out);
-  alpha = rb_num2dbl(sm_alpha);
+  alpha = NUM2DBL(sm_alpha);
 
   if (!SM_IS_A(sm_destination, vec4) && !SM_IS_A(sm_destination, quat)) {
     rb_raise(rb_eTypeError,
@@ -4389,7 +4234,7 @@ static VALUE sm_mat4_fetch (VALUE sm_self, VALUE sm_index)
     rb_raise(rb_eRangeError,
       "Index %d is out of bounds, must be from 0 through %d", index, max_index - 1);
   }
-  return rb_float_new(self[0][NUM2INT(sm_index)]);
+  return DBL2NUM(self[0][NUM2INT(sm_index)]);
 }
 
 
@@ -4409,7 +4254,7 @@ static VALUE sm_mat4_store (VALUE sm_self, VALUE sm_index, VALUE sm_value)
     rb_raise(rb_eRangeError,
       "Index %d is out of bounds, must be from 0 through %d", index, max_index - 1);
   }
-  self[0][index] = (s_float_t)rb_num2dbl(sm_value);
+  self[0][index] = (s_float_t)NUM2DBL(sm_value);
   return sm_value;
 }
 
@@ -5005,9 +4850,9 @@ static VALUE sm_mat4_translate(int argc, VALUE *argv, VALUE sm_self)
   }
 
   case 3: {
-    xyz[0] = rb_num2dbl(argv[0]);
-    xyz[1] = rb_num2dbl(argv[1]);
-    xyz[2] = rb_num2dbl(argv[2]);
+    xyz[0] = NUM2DBL(argv[0]);
+    xyz[1] = NUM2DBL(argv[1]);
+    xyz[2] = NUM2DBL(argv[2]);
 
     SM_LABEL(get_output):
     if (RTEST(sm_out)) {
@@ -5057,9 +4902,9 @@ static VALUE sm_mat4_translation(int argc, VALUE *argv, VALUE sm_self)
   }
 
   case 3: {
-    xyz[0] = rb_num2dbl(argv[0]);
-    xyz[1] = rb_num2dbl(argv[1]);
-    xyz[2] = rb_num2dbl(argv[2]);
+    xyz[0] = NUM2DBL(argv[0]);
+    xyz[1] = NUM2DBL(argv[1]);
+    xyz[2] = NUM2DBL(argv[2]);
 
     SM_LABEL(get_output):
     if (RTEST(sm_out)) {
@@ -5158,7 +5003,7 @@ static VALUE sm_mat4_init(int argc, VALUE *argv, VALUE sm_self)
       const size_t arr_end = arr_index + 16;
       s_float_t *mat_elem = *self;
       for (; arr_index < arr_end; ++arr_index, ++mat_elem) {
-        *mat_elem = rb_num2dbl(rb_ary_entry(arrdata, (long)arr_index));
+        *mat_elem = NUM2DBL(rb_ary_entry(arrdata, (long)arr_index));
       }
       break;
     }
@@ -5189,7 +5034,7 @@ static VALUE sm_mat4_init(int argc, VALUE *argv, VALUE sm_self)
     s_float_t *mat_elem = *self;
     VALUE *argv_p = argv;
     for (; argc; --argc, ++argv_p, ++mat_elem) {
-      *mat_elem = (s_float_t)rb_num2dbl(*argv_p);
+      *mat_elem = (s_float_t)NUM2DBL(*argv_p);
     }
     break;
   }
@@ -5257,7 +5102,7 @@ static VALUE sm_mat4_angle_axis(int argc, VALUE *argv, VALUE self)
     return Qnil;
   }
 
-  angle = (s_float_t)rb_num2dbl(sm_angle);
+  angle = (s_float_t)NUM2DBL(sm_angle);
   axis = sm_unwrap_vec3(sm_axis, NULL);
 
   if (SM_IS_A(sm_out, mat4)) {
@@ -5711,12 +5556,12 @@ static VALUE sm_mat4_frustum(int argc, VALUE *argv, VALUE self)
 
   rb_scan_args(argc, argv, "61", &sm_left, &sm_right, &sm_bottom, &sm_top, &sm_z_near, &sm_z_far, &sm_out);
 
-  left = (s_float_t)rb_num2dbl(sm_left);
-  right = (s_float_t)rb_num2dbl(sm_right);
-  bottom = (s_float_t)rb_num2dbl(sm_bottom);
-  top = (s_float_t)rb_num2dbl(sm_top);
-  z_near = (s_float_t)rb_num2dbl(sm_z_near);
-  z_far = (s_float_t)rb_num2dbl(sm_z_far);
+  left = (s_float_t)NUM2DBL(sm_left);
+  right = (s_float_t)NUM2DBL(sm_right);
+  bottom = (s_float_t)NUM2DBL(sm_bottom);
+  top = (s_float_t)NUM2DBL(sm_top);
+  z_near = (s_float_t)NUM2DBL(sm_z_near);
+  z_far = (s_float_t)NUM2DBL(sm_z_far);
 
   if (SM_IS_A(sm_out, mat4)) {
     rb_check_frozen(sm_out);
@@ -5758,12 +5603,12 @@ static VALUE sm_mat4_orthographic(int argc, VALUE *argv, VALUE self)
 
   rb_scan_args(argc, argv, "61", &sm_left, &sm_right, &sm_bottom, &sm_top, &sm_z_near, &sm_z_far, &sm_out);
 
-  left = (s_float_t)rb_num2dbl(sm_left);
-  right = (s_float_t)rb_num2dbl(sm_right);
-  bottom = (s_float_t)rb_num2dbl(sm_bottom);
-  top = (s_float_t)rb_num2dbl(sm_top);
-  z_near = (s_float_t)rb_num2dbl(sm_z_near);
-  z_far = (s_float_t)rb_num2dbl(sm_z_far);
+  left = (s_float_t)NUM2DBL(sm_left);
+  right = (s_float_t)NUM2DBL(sm_right);
+  bottom = (s_float_t)NUM2DBL(sm_bottom);
+  top = (s_float_t)NUM2DBL(sm_top);
+  z_near = (s_float_t)NUM2DBL(sm_z_near);
+  z_far = (s_float_t)NUM2DBL(sm_z_far);
 
   if (SM_IS_A(sm_out, mat4)) {
     rb_check_frozen(sm_out);
@@ -5801,10 +5646,10 @@ static VALUE sm_mat4_perspective(int argc, VALUE *argv, VALUE self)
 
   rb_scan_args(argc, argv, "41", &sm_fov_y, &sm_aspect, &sm_z_near, &sm_z_far, &sm_out);
 
-  fov_y = (s_float_t)rb_num2dbl(sm_fov_y);
-  aspect = (s_float_t)rb_num2dbl(sm_aspect);
-  z_near = (s_float_t)rb_num2dbl(sm_z_near);
-  z_far = (s_float_t)rb_num2dbl(sm_z_far);
+  fov_y = (s_float_t)NUM2DBL(sm_fov_y);
+  aspect = (s_float_t)NUM2DBL(sm_aspect);
+  z_near = (s_float_t)NUM2DBL(sm_z_near);
+  z_far = (s_float_t)NUM2DBL(sm_z_far);
 
   if (SM_IS_A(sm_out, mat4)) {
     rb_check_frozen(sm_out);
@@ -5875,9 +5720,9 @@ static VALUE sm_mat4_scale(int argc, VALUE *argv, VALUE sm_self)
   mat4_t *self = sm_unwrap_mat4(sm_self, NULL);
 
   rb_scan_args(argc, argv, "31", &sm_x, &sm_y, &sm_z, &sm_out);
-  x = rb_num2dbl(sm_x);
-  y = rb_num2dbl(sm_y);
-  z = rb_num2dbl(sm_z);
+  x = NUM2DBL(sm_x);
+  y = NUM2DBL(sm_y);
+  z = NUM2DBL(sm_z);
 
   if (SM_IS_A(sm_out, mat4)) {
     rb_check_frozen(sm_out);
@@ -5957,7 +5802,7 @@ static VALUE sm_mat3_fetch (VALUE sm_self, VALUE sm_index)
     rb_raise(rb_eRangeError,
       "Index %d is out of bounds, must be from 0 through %d", index, max_index - 1);
   }
-  return rb_float_new(self[0][NUM2INT(sm_index)]);
+  return DBL2NUM(self[0][NUM2INT(sm_index)]);
 }
 
 
@@ -5977,7 +5822,7 @@ static VALUE sm_mat3_store (VALUE sm_self, VALUE sm_index, VALUE sm_value)
     rb_raise(rb_eRangeError,
       "Index %d is out of bounds, must be from 0 through %d", index, max_index - 1);
   }
-  self[0][index] = (s_float_t)rb_num2dbl(sm_value);
+  self[0][index] = (s_float_t)NUM2DBL(sm_value);
   return sm_value;
 }
 
@@ -6502,7 +6347,7 @@ static VALUE sm_mat3_init(int argc, VALUE *argv, VALUE sm_self)
       const size_t arr_end = arr_index + 9;
       s_float_t *mat_elem = *self;
       for (; arr_index < arr_end; ++arr_index, ++mat_elem) {
-        *mat_elem = rb_num2dbl(rb_ary_entry(arrdata, (long)arr_index));
+        *mat_elem = NUM2DBL(rb_ary_entry(arrdata, (long)arr_index));
       }
       break;
     }
@@ -6533,7 +6378,7 @@ static VALUE sm_mat3_init(int argc, VALUE *argv, VALUE sm_self)
     s_float_t *mat_elem = *self;
     VALUE *argv_p = argv;
     for (; argc; --argc, ++argv_p, ++mat_elem) {
-      *mat_elem = (s_float_t)rb_num2dbl(*argv_p);
+      *mat_elem = (s_float_t)NUM2DBL(*argv_p);
     }
     break;
   }
@@ -6598,7 +6443,7 @@ static VALUE sm_mat3_angle_axis(int argc, VALUE *argv, VALUE self)
     return Qnil;
   }
 
-  angle = (s_float_t)rb_num2dbl(sm_angle);
+  angle = (s_float_t)NUM2DBL(sm_angle);
   axis = sm_unwrap_vec3(sm_axis, NULL);
 
   if (SM_IS_A(sm_out, mat3)) {
@@ -6844,9 +6689,9 @@ static VALUE sm_mat3_scale(int argc, VALUE *argv, VALUE sm_self)
   mat3_t *self = sm_unwrap_mat3(sm_self, NULL);
 
   rb_scan_args(argc, argv, "31", &sm_x, &sm_y, &sm_z, &sm_out);
-  x = rb_num2dbl(sm_x);
-  y = rb_num2dbl(sm_y);
-  z = rb_num2dbl(sm_z);
+  x = NUM2DBL(sm_x);
+  y = NUM2DBL(sm_y);
+  z = NUM2DBL(sm_z);
 
   if (SM_IS_A(sm_out, mat3)) {
     rb_check_frozen(sm_out);
@@ -6900,6 +6745,65 @@ static VALUE sm_get_address(VALUE sm_self)
 
 
 
+/*
+  call-seq:
+    float_epsilon -> Float
+
+  Gets the float epsilon for snow-math types. By default, this is 1e-9 for
+  double-precision floats and 1e-6 for single-precision floats.
+ */
+static VALUE sm_get_float_epsilon(VALUE sm_self)
+{
+  return DBL2NUM(S_FLOAT_EPSILON);
+}
+
+
+
+/*
+  call-seq:
+    float_epsilon = value -> value
+
+  Sets the float epsilon for snow-math types. If snow-math is compiled to use
+  single-precision floats, changing the epsilon for floats may cause the
+  assigned value to lose precision itself in the cast, resulting in a subtly
+  different epsilon than intended, as Ruby uses double-precision floats, which
+  may lead you to think you're setting the epsilon to one value when it's
+  another similar by not equal value.
+
+  Just be aware of what you're doing and the type of float you've compiled
+  snow-math to use.
+ */
+static VALUE sm_set_float_epsilon(VALUE sm_self, VALUE sm_value)
+{
+  switch (TYPE(sm_value)) {
+  case T_FLOAT:
+  case T_FIXNUM:
+  case T_BIGNUM:
+  case T_RATIONAL:
+  case T_COMPLEX: {
+    S_FLOAT_EPSILON = (s_float_t)NUM2DBL(sm_value);
+    break;
+  }
+  default: {
+    VALUE sm_value_s = rb_any_to_s(sm_value);
+    if (0) {
+      case T_STRING:
+      sm_value_s = sm_value;
+    }
+    S_FLOAT_EPSILON =
+      #ifdef USE_FLOAT
+      strtof(StringValueCStr(sm_value_s), NULL)
+      #else
+      strtod(StringValueCStr(sm_value_s), NULL)
+      #endif
+      ;
+  break;
+  }
+  } /* switch (TYPE(sm_value)) */
+  return sm_value;
+}
+
+
 void Init_bindings()
 {
   ID kRB_CONST_SIZE, kRB_CONST_LENGTH, kRB_CONST_FLOAT_SIZE, kRB_CONST_TYPE,
@@ -6909,10 +6813,6 @@ void Init_bindings()
   kRB_IVAR_MATHARRAY_LENGTH = rb_intern("__length");
   kRB_IVAR_MATHARRAY_CACHE  = rb_intern("__cache");
   kRB_IVAR_MATHARRAY_SOURCE = rb_intern("__source");
-  kRB_CONST_SIZE            = rb_intern("SIZE");
-  kRB_CONST_LENGTH          = rb_intern("LENGTH");
-  kRB_CONST_FLOAT_SIZE      = rb_intern("SNOW_MATH_FLOAT_SIZE");
-  kRB_CONST_TYPE            = rb_intern("TYPE");
   kRB_SIZE_METHOD           = rb_intern("size");
   kRB_BYTESIZE_METHOD       = rb_intern("bytesize");
 
@@ -6929,19 +6829,25 @@ void Init_bindings()
   s_sm_mat3_klass   = rb_define_class_under(s_sm_snowmath_mod, "Mat3", rb_cData);
   s_sm_mat4_klass   = rb_define_class_under(s_sm_snowmath_mod, "Mat4", rb_cData);
 
-  rb_const_set(s_sm_snowmath_mod, kRB_CONST_FLOAT_SIZE, INT2FIX(sizeof(s_float_t)));
-  rb_const_set(s_sm_vec2_klass, kRB_CONST_SIZE, INT2FIX(sizeof(vec2_t)));
-  rb_const_set(s_sm_vec3_klass, kRB_CONST_SIZE, INT2FIX(sizeof(vec3_t)));
-  rb_const_set(s_sm_vec4_klass, kRB_CONST_SIZE, INT2FIX(sizeof(vec4_t)));
-  rb_const_set(s_sm_quat_klass, kRB_CONST_SIZE, INT2FIX(sizeof(quat_t)));
-  rb_const_set(s_sm_mat3_klass, kRB_CONST_SIZE, INT2FIX(sizeof(mat3_t)));
-  rb_const_set(s_sm_mat4_klass, kRB_CONST_SIZE, INT2FIX(sizeof(mat4_t)));
-  rb_const_set(s_sm_vec2_klass, kRB_CONST_LENGTH, INT2FIX(sizeof(vec2_t) / sizeof(s_float_t)));
-  rb_const_set(s_sm_vec3_klass, kRB_CONST_LENGTH, INT2FIX(sizeof(vec3_t) / sizeof(s_float_t)));
-  rb_const_set(s_sm_vec4_klass, kRB_CONST_LENGTH, INT2FIX(sizeof(vec4_t) / sizeof(s_float_t)));
-  rb_const_set(s_sm_quat_klass, kRB_CONST_LENGTH, INT2FIX(sizeof(quat_t) / sizeof(s_float_t)));
-  rb_const_set(s_sm_mat3_klass, kRB_CONST_LENGTH, INT2FIX(sizeof(mat3_t) / sizeof(s_float_t)));
-  rb_const_set(s_sm_mat4_klass, kRB_CONST_LENGTH, INT2FIX(sizeof(mat4_t) / sizeof(s_float_t)));
+  rb_define_const(s_sm_snowmath_mod, "SNOW_MATH_FLOAT_SIZE", INT2FIX(sizeof(s_float_t)));
+  rb_define_const(s_sm_snowmath_mod, "SNOW_MATH_DEFAULT_FLOAT_EPSILON", DBL2NUM(S_FLOAT_EPSILON));
+  rb_define_const(s_sm_snowmath_mod, "DEGREES_TO_RADIANS", DBL2NUM(S_DEG2RAD));
+  rb_define_const(s_sm_snowmath_mod, "RADIANS_TO_DEGREES", DBL2NUM(S_RAD2DEG));
+  rb_define_const(s_sm_vec2_klass, "SIZE",    INT2FIX(sizeof(vec2_t)));
+  rb_define_const(s_sm_vec3_klass, "SIZE",    INT2FIX(sizeof(vec3_t)));
+  rb_define_const(s_sm_vec4_klass, "SIZE",    INT2FIX(sizeof(vec4_t)));
+  rb_define_const(s_sm_quat_klass, "SIZE",    INT2FIX(sizeof(quat_t)));
+  rb_define_const(s_sm_mat3_klass, "SIZE",    INT2FIX(sizeof(mat3_t)));
+  rb_define_const(s_sm_mat4_klass, "SIZE",    INT2FIX(sizeof(mat4_t)));
+  rb_define_const(s_sm_vec2_klass, "LENGTH",  INT2FIX(sizeof(vec2_t) / sizeof(s_float_t)));
+  rb_define_const(s_sm_vec3_klass, "LENGTH",  INT2FIX(sizeof(vec3_t) / sizeof(s_float_t)));
+  rb_define_const(s_sm_vec4_klass, "LENGTH",  INT2FIX(sizeof(vec4_t) / sizeof(s_float_t)));
+  rb_define_const(s_sm_quat_klass, "LENGTH",  INT2FIX(sizeof(quat_t) / sizeof(s_float_t)));
+  rb_define_const(s_sm_mat3_klass, "LENGTH",  INT2FIX(sizeof(mat3_t) / sizeof(s_float_t)));
+  rb_define_const(s_sm_mat4_klass, "LENGTH",  INT2FIX(sizeof(mat4_t) / sizeof(s_float_t)));
+
+  rb_define_singleton_method(s_sm_snowmath_mod, "float_epsilon=", sm_set_float_epsilon, 1);
+  rb_define_singleton_method(s_sm_snowmath_mod, "float_epsilon", sm_get_float_epsilon, 0);
 
   rb_define_singleton_method(s_sm_vec2_klass, "new", sm_vec2_new, -1);
   rb_define_method(s_sm_vec2_klass, "initialize", sm_vec2_init, -1);
@@ -7126,9 +7032,9 @@ void Init_bindings()
   #if BUILD_ARRAY_TYPE
 
   s_sm_vec2_array_klass = rb_define_class_under(s_sm_snowmath_mod, "Vec2Array", rb_cData);
-  rb_const_set(s_sm_vec2_array_klass, kRB_CONST_TYPE, s_sm_vec2_klass);
+  rb_define_const(s_sm_vec2_array_klass, "TYPE", s_sm_vec2_klass);
   rb_define_singleton_method(s_sm_vec2_array_klass, "new", sm_vec2_array_new, 1);
-  rb_define_method(s_sm_vec2_array_klass, "freeze", sm_vec2_array_freeze, 0);
+  rb_define_method(s_sm_vec2_array_klass, "freeze", sm_mathtype_array_freeze, 0);
   rb_define_method(s_sm_vec2_array_klass, "fetch", sm_vec2_array_fetch, 1);
   rb_define_method(s_sm_vec2_array_klass, "store", sm_vec2_array_store, 2);
   rb_define_method(s_sm_vec2_array_klass, "resize!", sm_vec2_array_resize, 1);
@@ -7138,9 +7044,9 @@ void Init_bindings()
   rb_alias(s_sm_vec2_array_klass, kRB_BYTESIZE_METHOD, kRB_SIZE_METHOD);
 
   s_sm_vec3_array_klass = rb_define_class_under(s_sm_snowmath_mod, "Vec3Array", rb_cData);
-  rb_const_set(s_sm_vec3_array_klass, kRB_CONST_TYPE, s_sm_vec3_klass);
+  rb_define_const(s_sm_vec3_array_klass, "TYPE", s_sm_vec3_klass);
   rb_define_singleton_method(s_sm_vec3_array_klass, "new", sm_vec3_array_new, 1);
-  rb_define_method(s_sm_vec3_array_klass, "freeze", sm_vec3_array_freeze, 0);
+  rb_define_method(s_sm_vec3_array_klass, "freeze", sm_mathtype_array_freeze, 0);
   rb_define_method(s_sm_vec3_array_klass, "fetch", sm_vec3_array_fetch, 1);
   rb_define_method(s_sm_vec3_array_klass, "store", sm_vec3_array_store, 2);
   rb_define_method(s_sm_vec3_array_klass, "resize!", sm_vec3_array_resize, 1);
@@ -7150,9 +7056,9 @@ void Init_bindings()
   rb_alias(s_sm_vec3_array_klass, kRB_BYTESIZE_METHOD, kRB_SIZE_METHOD);
 
   s_sm_vec4_array_klass = rb_define_class_under(s_sm_snowmath_mod, "Vec4Array", rb_cData);
-  rb_const_set(s_sm_vec4_array_klass, kRB_CONST_TYPE, s_sm_vec4_klass);
+  rb_define_const(s_sm_vec4_array_klass, "TYPE", s_sm_vec4_klass);
   rb_define_singleton_method(s_sm_vec4_array_klass, "new", sm_vec4_array_new, 1);
-  rb_define_method(s_sm_vec4_array_klass, "freeze", sm_vec4_array_freeze, 0);
+  rb_define_method(s_sm_vec4_array_klass, "freeze", sm_mathtype_array_freeze, 0);
   rb_define_method(s_sm_vec4_array_klass, "fetch", sm_vec4_array_fetch, 1);
   rb_define_method(s_sm_vec4_array_klass, "store", sm_vec4_array_store, 2);
   rb_define_method(s_sm_vec4_array_klass, "resize!", sm_vec4_array_resize, 1);
@@ -7162,9 +7068,9 @@ void Init_bindings()
   rb_alias(s_sm_vec4_array_klass, kRB_BYTESIZE_METHOD, kRB_SIZE_METHOD);
 
   s_sm_quat_array_klass = rb_define_class_under(s_sm_snowmath_mod, "QuatArray", rb_cData);
-  rb_const_set(s_sm_quat_array_klass, kRB_CONST_TYPE, s_sm_quat_klass);
+  rb_define_const(s_sm_quat_array_klass, "TYPE", s_sm_quat_klass);
   rb_define_singleton_method(s_sm_quat_array_klass, "new", sm_quat_array_new, 1);
-  rb_define_method(s_sm_quat_array_klass, "freeze", sm_quat_array_freeze, 0);
+  rb_define_method(s_sm_quat_array_klass, "freeze", sm_mathtype_array_freeze, 0);
   rb_define_method(s_sm_quat_array_klass, "fetch", sm_quat_array_fetch, 1);
   rb_define_method(s_sm_quat_array_klass, "store", sm_quat_array_store, 2);
   rb_define_method(s_sm_quat_array_klass, "resize!", sm_quat_array_resize, 1);
@@ -7174,9 +7080,9 @@ void Init_bindings()
   rb_alias(s_sm_quat_array_klass, kRB_BYTESIZE_METHOD, kRB_SIZE_METHOD);
 
   s_sm_mat3_array_klass = rb_define_class_under(s_sm_snowmath_mod, "Mat3Array", rb_cData);
-  rb_const_set(s_sm_mat3_array_klass, kRB_CONST_TYPE, s_sm_mat3_klass);
+  rb_define_const(s_sm_mat3_array_klass, "TYPE", s_sm_mat3_klass);
   rb_define_singleton_method(s_sm_mat3_array_klass, "new", sm_mat3_array_new, 1);
-  rb_define_method(s_sm_mat3_array_klass, "freeze", sm_mat3_array_freeze, 0);
+  rb_define_method(s_sm_mat3_array_klass, "freeze", sm_mathtype_array_freeze, 0);
   rb_define_method(s_sm_mat3_array_klass, "fetch", sm_mat3_array_fetch, 1);
   rb_define_method(s_sm_mat3_array_klass, "store", sm_mat3_array_store, 2);
   rb_define_method(s_sm_mat3_array_klass, "resize!", sm_mat3_array_resize, 1);
@@ -7186,9 +7092,9 @@ void Init_bindings()
   rb_alias(s_sm_mat3_array_klass, kRB_BYTESIZE_METHOD, kRB_SIZE_METHOD);
 
   s_sm_mat4_array_klass = rb_define_class_under(s_sm_snowmath_mod, "Mat4Array", rb_cData);
-  rb_const_set(s_sm_mat4_array_klass, kRB_CONST_TYPE, s_sm_mat4_klass);
+  rb_define_const(s_sm_mat4_array_klass, "TYPE", s_sm_mat4_klass);
   rb_define_singleton_method(s_sm_mat4_array_klass, "new", sm_mat4_array_new, 1);
-  rb_define_method(s_sm_mat4_array_klass, "freeze", sm_mat4_array_freeze, 0);
+  rb_define_method(s_sm_mat4_array_klass, "freeze", sm_mathtype_array_freeze, 0);
   rb_define_method(s_sm_mat4_array_klass, "fetch", sm_mat4_array_fetch, 1);
   rb_define_method(s_sm_mat4_array_klass, "store", sm_mat4_array_store, 2);
   rb_define_method(s_sm_mat4_array_klass, "resize!", sm_mat4_array_resize, 1);

data/lib/snow-math/mat3.rb

@@ -136,6 +136,47 @@ class Snow::Mat3
     scale x, y, z, self
   end
 
+  #
+  # Returns the pitch (X-axis rotation) of this matrix in degrees. This assumes
+  # the matrix is orthogonal.
+  #
+  def pitch
+    tx = self[6]
+    tz = self[8]
+    Math::atan2(
+      self[7],
+      Math::sqrt(tx * tx + tz * tz)) * ::Snow::RADIANS_TO_DEGREES
+  end
+
+  #
+  # Returns the yaw (Y-axis rotation) of this matrix in degrees. This assumes
+  # the matrix is orthogonal.
+  #
+  def yaw
+    -Math::atan2(self[6], self[8]) * ::Snow::RADIANS_TO_DEGREES
+  end
+
+  #
+  # Returns the roll (Z-axis rotation) of this matrix in degrees. This assumes
+  # the matrix is orthogonal.
+  #
+  def roll
+    Math::atan2(self[1], self[4]) * ::Snow::RADIANS_TO_DEGREES
+  end
+
+  #
+  # call-seq:
+  #   orthogonal? -> true or false
+  #
+  # Returns whether self is an orthogonal matrix (its columns and rows are all
+  # unit vectors). Note that this allocates a new matrix. You probably don't
+  # want to call it often.
+  #
+  def orthogonal?
+    temp = self.transpose
+    multiply_mat3(temp, temp) == IDENTITY
+  end
+
 
   alias_method :*, :multiply
   alias_method :**, :scale

data/lib/snow-math/mat4.rb

@@ -162,6 +162,46 @@ class Snow::Mat4
     inverse_general self
   end
 
+  #
+  # Returns the pitch (X-axis rotation) of this matrix in degrees. This assumes
+  # the matrix is orthogonal.
+  #
+  def pitch
+    tx = self[8]
+    tz = self[10]
+    Math::atan2(
+      self[9],
+      Math::sqrt(tx * tx + tz * tz)) * ::Snow::RADIANS_TO_DEGREES
+  end
+
+  #
+  # Returns the yaw (Y-axis rotation) of this matrix in degrees. This assumes
+  # the matrix is orthogonal.
+  #
+  def yaw
+    -Math::atan2(self[8], self[10]) * ::Snow::RADIANS_TO_DEGREES
+  end
+
+  #
+  # Returns the roll (Z-axis rotation) of this matrix in degrees. This assumes
+  # the matrix is orthogonal.
+  #
+  def roll
+    Math::atan2(self[1], self[5]) * ::Snow::RADIANS_TO_DEGREES
+  end
+
+  #
+  # call-seq:
+  #   orthogonal? -> true or false
+  #
+  # Returns whether self is an orthogonal matrix (its columns and rows are all
+  # unit vectors). Note that this allocates a new matrix.
+  #
+  def orthogonal?
+    temp = self.transpose
+    multiply_mat4(temp, temp) == IDENTITY
+  end
+
 
   alias_method :*, :multiply
   alias_method :**, :scale

data/lib/snow-math/version.rb

@@ -7,6 +7,6 @@ module Snow
   #
   # snow-math bindings version string.
   #
-  SNOW_MATH_VERSION = '1.6.1'
+  SNOW_MATH_VERSION = '1.7.0'
 
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: snow-math
 version: !ruby/object:Gem::Version
-  version: 1.6.1
+  version: 1.7.0
 platform: ruby
 authors:
 - Noel Raymond Cower
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-07-28 00:00:00.000000000 Z
+date: 2013-07-29 00:00:00.000000000 Z
 dependencies: []
 description: Math types built on the SnowPalm math code
 email: ncower@gmail.com