carray 1.5.2 → 1.5.7

data/ext/carray.h

@@ -13,6 +13,10 @@
 
 #include "ruby.h"
 
+#ifdef HAVE_RB_ARITHMETIC_SEQUENCE_EXTRACT
+extern VALUE rb_cArithSeq;
+#endif
+
 /* -------------------------------------------------------------------- */
 
 #include "carray_config.h"

data/ext/carray_access.c

@@ -10,35 +10,10 @@
 
 #include "carray.h"
 
-#if RUBY_VERSION_CODE >= 240
-#define RSTRUCT_EMBED_LEN_MAX RSTRUCT_EMBED_LEN_MAX
-enum {
-  RSTRUCT_EMBED_LEN_MAX = 3,
-  RSTRUCT_ENUM_END
-};
-struct RStruct {
-    struct RBasic basic;
-    union {
-        struct {
-            long len;
-            const VALUE *ptr;
-        } heap;
-        const VALUE ary[RSTRUCT_EMBED_LEN_MAX];
-    } as;
-};
-#define RSTRUCT(obj) (R_CAST(RStruct)(obj))
-#endif
-
-#if RUBY_VERSION_CODE >= 190
-#define RANGE_BEG(r) (RSTRUCT(r)->as.ary[0])
-#define RANGE_END(r) (RSTRUCT(r)->as.ary[1])
-#define RANGE_EXCL(r) (RSTRUCT(r)->as.ary[2])
-#else
-static ID id_beg, id_end, id_excl;
-#define RANGE_BEG(r) (rb_ivar_get(r, id_beg))
-#define RANGE_END(r) (rb_ivar_get(r, id_end))
-#define RANGE_EXCL(r) (rb_ivar_get(r, id_excl))
-#endif
+static ID id_begin, id_end, id_excl_end;
+#define RANGE_BEG(r)  (rb_funcall(r, id_begin, 0))
+#define RANGE_END(r)  (rb_funcall(r, id_end, 0))
+#define RANGE_EXCL(r) (rb_funcall(r, id_excl_end, 0))
 
 static ID id_ca, id_to_ca;
 static VALUE sym_star, sym_perc;
@@ -614,17 +589,17 @@ rb_ca_scan_index (int ca_ndim, ca_size_t *ca_dim, ca_size_t ca_elements,
         info->ndim = ca_ndim;
       }
       else if ( rb_obj_is_kind_of(arg, rb_cRange) ) { /* ca[--,i..j,--] */
-        ca_size_t first, last, excl, count, step;
+        ca_size_t start, last, excl, count, step;
         volatile VALUE iv_beg, iv_end, iv_excl;
         iv_beg  = RANGE_BEG(arg);
         iv_end  = RANGE_END(arg);
         iv_excl = RANGE_EXCL(arg);
         index_type[i] = CA_IDX_BLOCK; /* convert to block */
         if ( NIL_P(iv_beg) ) {
-          first = 0;                    
+          start = 0;                    
         }
         else {
-          first = NUM2SIZE(iv_beg);          
+          start = NUM2SIZE(iv_beg);          
         }
         if ( NIL_P(iv_end) ) {
           last  = -1;
@@ -635,20 +610,20 @@ rb_ca_scan_index (int ca_ndim, ca_size_t *ca_dim, ca_size_t ca_elements,
         excl  = RTEST(iv_excl);
 
         if ( info->range_check ) {
-          CA_CHECK_INDEX_AT(first, ca_dim[i], i);
+          CA_CHECK_INDEX_AT(start, ca_dim[i], i);
         }
 
         if ( last < 0 ) { /* don't use CA_CHECK_INDEX for excl */
           last += ca_dim[i];
         }
-        if ( excl && ( first == last ) ) {
-          index[i].block.start = first;
+        if ( excl && ( start == last ) ) {
+          index[i].block.start = start;
           index[i].block.count = 0;
           index[i].block.step  = 1;
         }
         else {
           if ( excl ) {
-            last += ( (last>=first) ? -1 : 1 );
+            last += ( (last>=start) ? -1 : 1 );
           }
           if ( info->range_check ) {
             if ( last < 0 || last >= ca_dim[i] ) {
@@ -657,11 +632,71 @@ rb_ca_scan_index (int ca_ndim, ca_size_t *ca_dim, ca_size_t ca_elements,
                        (ca_size_t) last, (ca_size_t) (ca_dim[i]-1), i);
             }
           }
-          index[i].block.start = first;
-          index[i].block.count = count = llabs(last - first) + 1;
-          index[i].block.step  = step  = ( last >= first ) ? 1 : -1;
+          index[i].block.start = start;
+          index[i].block.count = count = llabs(last - start) + 1;
+          index[i].block.step  = step  = ( last >= start ) ? 1 : -1;
         }
       }
+#ifdef HAVE_RB_ARITHMETIC_SEQUENCE_EXTRACT
+      else if ( rb_obj_is_kind_of(arg, rb_cArithSeq) ) { /* ca[--,ArithSeq,--]*/
+        ca_size_t start, last, excl, count, step, bound;
+        volatile VALUE iv_beg, iv_end, iv_excl;
+        rb_arithmetic_sequence_components_t x;
+        rb_arithmetic_sequence_extract(arg, &x);
+        iv_beg  = x.begin;
+        iv_end  = x.end;
+        iv_excl = x.exclude_end;
+        step    = NUM2SIZE(x.step);
+        if ( NIL_P(iv_beg) ) {
+          start = 0;                    
+        }
+        else {
+          start = NUM2SIZE(iv_beg);          
+        }
+        if ( NIL_P(iv_end) ) {
+          last  = -1;
+        }
+        else {
+          last  = NUM2SIZE(iv_end);          
+        }
+        excl  = RTEST(iv_excl);
+        if ( step == 0 ) {
+          rb_raise(rb_eRuntimeError, 
+                   "step in index equals to 0 in block reference");
+        }
+        index_type[i] = CA_IDX_BLOCK;
+        CA_CHECK_INDEX_AT(start, ca_dim[i], i);
+        if ( last < 0 ) {
+          last += ca_dim[i];
+        }
+        if ( excl && ( start == last ) ) {
+          index[i].block.start = start;
+          index[i].block.count = 0;
+          index[i].block.step  = 1;
+        }
+        else {
+          if ( excl ) {
+            last += ( (last>=start) ? -1 : 1 );
+          }
+          if ( last < 0 || last >= ca_dim[i] ) {
+            rb_raise(rb_eIndexError,
+                     "index %lld is out of range (0..%lld) at %i-dim",
+                     (ca_size_t) last, (ca_size_t) (ca_dim[i]-1), i);
+          }
+          if ( (last - start) * step < 0 ) {
+            count = 1;
+          }
+          else {
+            count = llabs(last - start)/llabs(step) + 1;
+          }
+          bound = start + (count - 1)*step;
+          CA_CHECK_INDEX_AT(bound, ca_dim[i], i);
+          index[i].block.start = start;
+          index[i].block.count = count;
+          index[i].block.step  = step;
+        }
+      }
+#endif
       else if ( TYPE(arg) == T_ARRAY ) { /* ca[--,[array],--] */
         if ( RARRAY_LEN(arg) == 1 ) {
           VALUE arg0 = rb_ary_entry(arg, 0);
@@ -1914,12 +1949,9 @@ void
 Init_carray_access ()
 {
 
-#if RUBY_VERSION_CODE >= 190
-#else
-  id_beg   = rb_intern("begin");
-  id_end   = rb_intern("end");
-  id_excl  = rb_intern("excl");
-#endif
+  id_begin    = rb_intern("begin");
+  id_end      = rb_intern("end");
+  id_excl_end = rb_intern("exclude_end?");
 
   id_ca    = rb_intern("ca");
   id_to_ca = rb_intern("to_ca");

data/ext/carray_attribute.c

@@ -17,7 +17,7 @@
 (Attribute) 
 Returns the object type (e.g. CA_OBJ_ARRAY, CA_OBJ_BLOCK, ...).
 Since the object type can be known from the class of the object,
-this attribute method is rarely used.
+this attribute methods is rarely used.
 */
 
 VALUE
@@ -711,6 +711,20 @@ rb_ca_data_type_import (VALUE self, VALUE data_type)
   return Qnil;
 }
 
+static VALUE
+rb_ca_set_data_class (VALUE self, VALUE klass)
+{
+  if ( RTEST(rb_ca_is_fixlen_type(self)) &&
+       rb_obj_is_data_class(klass) ) {
+    rb_ivar_set(self, rb_intern("member"), rb_hash_new());
+    return rb_ivar_set(self, id_data_class, klass);
+  }
+  else {
+    rb_raise(rb_eTypeError, "invalid data_class or self is not fixlen array.");
+  }
+  return Qnil;
+}
+
 /* ------------------------------------------------------------------- */
 
 CArray *
@@ -824,6 +838,7 @@ Init_carray_attribute ()
   rb_define_method(rb_cCArray, "parent", rb_ca_parent, 0);
 
   rb_define_method(rb_cCArray, "data_class", rb_ca_data_class, 0);
+  rb_define_method(rb_cCArray, "data_class=", rb_ca_set_data_class, 1);
 
   rb_define_method(rb_cCArray, "scalar?", rb_ca_is_scalar, 0);
 

data/ext/carray_cast.c

@@ -66,7 +66,7 @@ OBJ2DBL (VALUE val)
     else if ( ! strncasecmp("-infinity", str, 9) ) {
       return -1.0/0.0;
     }
-    return NUM2DBL(rb_Float(val));
+    return rb_cstr_to_dbl(str, 0);
   }
   default:
     return NUM2DBL(rb_Float(val));

data/ext/carray_conversion.c

@@ -342,6 +342,8 @@ rb_ca_format (int argc, VALUE *argv, VALUE self)
 
 #include <time.h>
 
+#ifdef HAVE_STRPTIME
+
 /* @overload str_strptime (fmt)
 
 (Conversion) 
@@ -404,7 +406,9 @@ rb_ca_strptime (VALUE self, VALUE rfmt)
   return obj;
 }
 
-/* @overload time_strptime (fmt)
+#endif
+
+/* @overload time_strftime (fmt)
 
 (Conversion) 
 Creates object type array consist of strings
@@ -498,7 +502,10 @@ Init_carray_conversion ()
 
   rb_define_method(rb_cCArray, "str_format", rb_ca_format, -1); 
 
+#ifdef HAVE_STRPTIME
   rb_define_method(rb_cCArray, "str_strptime", rb_ca_strptime, 1);
+#endif
+  
   rb_define_method(rb_cCArray, "time_strftime", rb_ca_strftime, 1);
 
   rb_define_method(rb_cCArray, "test_ca_to_cptr", rb_test_ca_to_cptr, 0);

data/ext/carray_core.c

@@ -1186,7 +1186,7 @@ rb_ca_data_class_encode (VALUE self, VALUE obj)
 VALUE
 rb_ca_members (VALUE self)
 {
-  VALUE data_class = rb_ca_data_class(self);
+  volatile VALUE data_class = rb_ca_data_class(self);
   if ( NIL_P(data_class) ) {
     rb_raise(rb_eRuntimeError, "carray doesn't have data class");
   }
@@ -1198,9 +1198,9 @@ rb_ca_members (VALUE self)
 VALUE
 rb_ca_field_as_member (VALUE self, VALUE sym)
 {
-  VALUE data_class = rb_ca_data_class(self);
-  VALUE member;
-  VALUE obj;
+  volatile VALUE data_class = rb_ca_data_class(self);
+  volatile VALUE member;
+  volatile VALUE obj;
 
   if ( NIL_P(data_class) ) {
     rb_raise(rb_eRuntimeError, "carray doesn't have data class");
@@ -1214,23 +1214,29 @@ rb_ca_field_as_member (VALUE self, VALUE sym)
              "for data_class array");
   }
 
-  if ( TYPE(sym) == T_SYMBOL ) {
-    sym = rb_funcall(sym, rb_intern("to_s"), 0);
-  }
-  else if ( rb_obj_is_kind_of(sym, rb_cInteger) ) {
-    VALUE member_names = rb_const_get(data_class, rb_intern("MEMBERS"));
-    sym = rb_ary_entry(member_names, NUM2SIZE(sym));
+  if ( rb_obj_is_kind_of(sym, rb_cInteger) ) {
+      volatile VALUE member_names = rb_const_get(data_class, rb_intern("MEMBERS"));
+      sym = rb_ary_entry(member_names, NUM2SIZE(sym));
+      obj = rb_hash_aref(member, sym);
+    }
+  else {
+    obj = rb_hash_aref(member, sym);
+    if ( NIL_P(obj) ) {
+      sym = rb_funcall(sym, rb_intern("to_s"), 0);
+      obj = rb_hash_aref(member, sym);      
+    }
   }
 
-  obj = rb_hash_aref(member, sym);
-
   if ( rb_obj_is_carray(obj) ) {
     return obj;
   }
   else {
-    VALUE MEMBER_TABLE = rb_const_get(data_class, rb_intern("MEMBER_TABLE"));
-    VALUE info = rb_hash_aref(MEMBER_TABLE, sym);
+    volatile VALUE MEMBER_TABLE = rb_const_get(data_class, rb_intern("MEMBER_TABLE"));
+    volatile VALUE info = rb_hash_aref(MEMBER_TABLE, sym);
     if ( NIL_P(info) ) {
+      if ( TYPE(sym) != T_STRING ) {
+        sym = rb_funcall(sym, rb_intern("to_s"), 0);
+      }
       rb_raise(rb_eRuntimeError,
                "can't find data_member named <%s>", StringValuePtr(sym));
     }
@@ -1249,7 +1255,7 @@ rb_ca_field_as_member (VALUE self, VALUE sym)
 VALUE
 rb_ca_fields (VALUE self)
 {
-  VALUE data_class = rb_ca_data_class(self);
+  volatile VALUE data_class = rb_ca_data_class(self);
   volatile VALUE member_names, list;
   int i;
   if ( NIL_P(data_class) ) {
@@ -1272,7 +1278,7 @@ Returns an array of data class members (fields) with names specified
 VALUE
 rb_ca_fields_at (int argc, VALUE *argv, VALUE self)
 {
-  VALUE data_class = rb_ca_data_class(self);
+  volatile VALUE data_class = rb_ca_data_class(self);
   volatile VALUE member_names, list;
   int i;
   if ( NIL_P(data_class) ) {

data/ext/carray_generate.c

@@ -62,15 +62,15 @@ Returns the 1d index array for non-zero elements of self
 VALUE
 rb_ca_where (VALUE self)
 {
-  volatile VALUE bool, obj;
+  volatile VALUE bool0, obj;
   CArray *ca, *co;
   boolean8_t *p, *m;
   ca_size_t *q;
   ca_size_t i, count;
 
-  bool = ( ! rb_ca_is_boolean_type(self) ) ? rb_ca_to_boolean(self) : self;
+  bool0 = ( ! rb_ca_is_boolean_type(self) ) ? rb_ca_to_boolean(self) : self;
 
-  Data_Get_Struct(bool, CArray, ca);
+  Data_Get_Struct(bool0, CArray, ca);
 
   ca_attach(ca);
 

data/ext/carray_mask.c

@@ -757,7 +757,12 @@ rb_ca_is_masked (VALUE self)
 
   Data_Get_Struct(self, CArray, ca);
 
-  co = carray_new(CA_BOOLEAN, ca->ndim, ca->dim, ca->bytes, NULL);
+  if ( ca_is_scalar(ca) ) {
+    co = cscalar_new(CA_BOOLEAN, ca->bytes, NULL);        
+  }
+  else {
+    co = carray_new(CA_BOOLEAN, ca->ndim, ca->dim, ca->bytes, NULL);    
+  }
 
   ca_update_mask(ca);
   if ( ! ca->mask ) {
@@ -798,7 +803,12 @@ rb_ca_is_not_masked (VALUE self)
 
   Data_Get_Struct(self, CArray, ca);
 
-  co = carray_new(CA_BOOLEAN, ca->ndim, ca->dim, ca->bytes, NULL);
+  if ( ca_is_scalar(ca) ) {
+    co = cscalar_new(CA_BOOLEAN, ca->bytes, NULL);        
+  }
+  else {
+    co = carray_new(CA_BOOLEAN, ca->ndim, ca->dim, ca->bytes, NULL);    
+  }
 
   ca_update_mask(ca);
   if ( ! ca->mask ) {

data/ext/carray_math.rb

@@ -155,6 +155,10 @@ monfunc("exp", "exp",
       FLOAT_TYPES => "(#2) = exp(#1);",
       CMPLX_TYPES => HAVE_COMPLEX ? "(#2) = cexp(#1);" : nil,
       OBJ_TYPES   => '(#2) = rb_funcall((#1), rb_intern("exp"), 0);')
+monfunc("exp2", "exp2",
+      FLOAT_TYPES => "(#2) = exp2(#1);",
+      CMPLX_TYPES => HAVE_COMPLEX ? "(#2) = cpow(2, (#1));" : nil,
+      OBJ_TYPES   => '(#2) = rb_funcall((#1), rb_intern("exp2"), 0);')
 monfunc("exp10", "exp10",
       FLOAT_TYPES => "(#2) = pow(10, (#1));",
       CMPLX_TYPES => HAVE_COMPLEX ? "(#2) = cpow(10, (#1));" : nil,
@@ -166,6 +170,12 @@ monfunc("log", "log",
 monfunc("log10", "log10",
       FLOAT_TYPES => "(#2) = log10(#1);",
       OBJ_TYPES   => '(#2) = rb_funcall((#1), rb_intern("log10"), 0);')
+monfunc("log2", "log2",
+      FLOAT_TYPES => "(#2) = log2(#1);",
+      OBJ_TYPES   => '(#2) = rb_funcall((#1), rb_intern("log2"), 0);')
+monfunc("logb", "logb",
+      FLOAT_TYPES => "(#2) = logb(#1);",
+      OBJ_TYPES   => '(#2) = rb_funcall((#1), rb_intern("logb"), 0);')
 monfunc("sin", "sin",
       FLOAT_TYPES => "(#2) = sin(#1);",
       CMPLX_TYPES => HAVE_COMPLEX ? "(#2) = csin(#1);" : nil,
@@ -217,12 +227,14 @@ monfunc("atanh", "atanh",
 
 
 binop("pmax", "pmax",
-      ALL_TYPES =>"(#3) = (#1) > (#2) ? (#1) : (#2);",
+      INT_TYPES =>"(#3) = (#1) > (#2) ? (#1) : (#2);",
+      FLOAT_TYPES =>"(#3) = fmax(#1, #2);",
       CMPLX_TYPES => nil,
       OBJ_TYPES =>'(#3) = rb_funcall(rb_assoc_new((#1),(#2)), rb_intern("max"), 0);')
 
 binop("pmin", "pmin",
-      ALL_TYPES =>"(#3) = (#1) < (#2) ? (#1) : (#2);",
+      INT_TYPES =>"(#3) = (#1) < (#2) ? (#1) : (#2);",
+      FLOAT_TYPES =>"(#3) = fmin(#1, #2);",
       CMPLX_TYPES => nil,
       OBJ_TYPES =>'(#3) = rb_funcall(rb_assoc_new((#1),(#2)), rb_intern("min"), 0);')
 
@@ -258,6 +270,12 @@ binop("rcp_mul", "rcp_mul",
 
 binop("%", "mod",
       INT_TYPES => "if ((#2)==0) {ca_zerodiv();}; (#3) = (#1) % (#2);",
+      FLOAT_TYPES => "(#3) = fmod(#1, #2);",
+      OBJ_TYPES => '(#3) = rb_funcall((#1), id_percent, 1, (#2));')
+
+binop("reminder", "reminder",
+      INT_TYPES => "if ((#2)==0) {ca_zerodiv();}; (#3) = (#1) % (#2);",
+      FLOAT_TYPES => "(#3) = remainder(#1, #2);",
       OBJ_TYPES => '(#3) = rb_funcall((#1), id_percent, 1, (#2));')
 
 binop("&", "bit_and_i",

data/ext/carray_numeric.c

@@ -11,11 +11,6 @@
 #include "ruby.h"
 #include "carray.h"
 
-#if RUBY_VERSION_CODE >= 240
-# define rb_cFixnum rb_cInteger
-# define rb_cBignum rb_cInteger
-#endif
-
 VALUE CA_NAN, CA_INF;
 
 static ID id___or__;
@@ -24,24 +19,18 @@ static ID id___xor__;
 static ID id___rshift__;
 static ID id___lshift__;
 
-VALUE
-rb_num_nan (VALUE self)
-{
-  return CA_NAN;
-}
-
-VALUE
-rb_num_inf (VALUE self)
-{
-  return CA_INF;
-}
+static ID id_bit_or;
+static ID id_bit_and;
+static ID id_bit_xor;
+static ID id_lshift;
+static ID id_rshift;
 
 static VALUE
 rb_hack_or(VALUE x, VALUE y)
 {
   if ( rb_obj_is_carray(y) ) {
     if ( rb_ca_is_boolean_type(y) ) {
-      return rb_funcall(y, rb_intern("bit_or"), 1, x);
+      return rb_funcall(y, id_bit_or, 1, x);
     }
     else {
 #if RUBY_VERSION_CODE >= 190
@@ -61,7 +50,7 @@ rb_hack_and (VALUE x, VALUE y)
 {
   if ( rb_obj_is_carray(y) ) {
     if ( rb_ca_is_boolean_type(y) ) {
-      return rb_funcall(y, rb_intern("bit_and"), 1, x);
+      return rb_funcall(y, id_bit_and, 1, x);
     }
     else {
 #if RUBY_VERSION_CODE >= 190
@@ -81,7 +70,7 @@ rb_hack_xor (VALUE x, VALUE y)
 {
   if ( rb_obj_is_carray(y) ) {
     if ( rb_ca_is_boolean_type(y) ) {
-      return rb_funcall(y, rb_intern("bit_xor"), 1, x);
+      return rb_funcall(y, id_bit_xor, 1, x);
     }
     else {
 #if RUBY_VERSION_CODE >= 190
@@ -101,7 +90,7 @@ rb_hack_lshift (VALUE x, VALUE y)
 {
   if ( rb_obj_is_carray(y) ) {
 #if RUBY_VERSION_CODE >= 190
-      return rb_num_coerce_bin(x, y, rb_intern("<<"));
+      return rb_num_coerce_bin(x, y, id_lshift);
 #else
       return rb_num_coerce_bin(x, y);
 #endif
@@ -116,7 +105,7 @@ rb_hack_rshift (VALUE x, VALUE y)
 {
   if ( rb_obj_is_carray(y) ) {
 #if RUBY_VERSION_CODE >= 190
-      return rb_num_coerce_bin(x, y, rb_intern(">>"));
+      return rb_num_coerce_bin(x, y, id_rshift);
 #else
       return rb_num_coerce_bin(x, y);
 #endif
@@ -126,12 +115,6 @@ rb_hack_rshift (VALUE x, VALUE y)
   }
 }
 
-static VALUE
-rb_hack_star (VALUE x, VALUE y)
-{
-  return rb_funcall(y, rb_intern("*"), 1, x);
-}
-
 /* ------------------------------------------------------------------- */
 
 #ifdef HAVE_COMPLEX_H
@@ -197,35 +180,51 @@ Init_carray_numeric ()
 {
   /* hack Fixnum and Bignum's "|", "&", "^", "<<", ">>" */
 
-  id___or__ = rb_intern("__or__");
-  id___and__ = rb_intern("__and__");
-  id___xor__ = rb_intern("__xor__");
+  id___or__     = rb_intern("__or__");
+  id___and__    = rb_intern("__and__");
+  id___xor__    = rb_intern("__xor__");
   id___rshift__ = rb_intern("__rshift__");
   id___lshift__ = rb_intern("__lshift__");
 
+  id_bit_or     = rb_intern("bit_or");
+  id_bit_and    = rb_intern("bit_and");
+  id_bit_xor    = rb_intern("bit_xor");
+  id_lshift     = rb_intern("<<");
+  id_rshift     = rb_intern(">>");
+
   CA_NAN = rb_float_new(0.0/0.0);
   CA_INF = rb_float_new(1.0/0.0);
   rb_define_const(rb_cObject, "CA_NAN", CA_NAN);
   rb_define_const(rb_cObject, "CA_INF", CA_INF);
-  rb_define_global_function("nan", rb_num_nan, 0);
-  rb_define_global_function("inf", rb_num_inf, 0);
 
   rb_define_alias(rb_cTrueClass, "__or__", "|");
   rb_define_alias(rb_cTrueClass, "__and__", "&");
   rb_define_alias(rb_cTrueClass, "__xor__", "^");
 
+  rb_define_method(rb_cTrueClass, "|", rb_hack_or, 1);
+  rb_define_method(rb_cTrueClass, "&", rb_hack_and, 1);
+  rb_define_method(rb_cTrueClass, "^", rb_hack_xor, 1);
+
   rb_define_alias(rb_cFalseClass, "__or__", "|");
   rb_define_alias(rb_cFalseClass, "__and__", "&");
   rb_define_alias(rb_cFalseClass, "__xor__", "^");
 
-#if RUBY_VERSION_CODE >= 240
+  rb_define_method(rb_cFalseClass, "|", rb_hack_or, 1);
+  rb_define_method(rb_cFalseClass, "&", rb_hack_and, 1);
+  rb_define_method(rb_cFalseClass, "^", rb_hack_xor, 1);
 
+#if RUBY_VERSION_CODE >= 240
   rb_define_alias(rb_cInteger, "__or__", "|");
   rb_define_alias(rb_cInteger, "__and__", "&");
   rb_define_alias(rb_cInteger, "__xor__", "^");
   rb_define_alias(rb_cInteger, "__lshift__", "<<");
   rb_define_alias(rb_cInteger, "__rshift__", ">>");
 
+  rb_define_method(rb_cInteger, "|", rb_hack_or, 1);
+  rb_define_method(rb_cInteger, "&", rb_hack_and, 1);
+  rb_define_method(rb_cInteger, "^", rb_hack_xor, 1);
+  rb_define_method(rb_cInteger, "<<", rb_hack_lshift, 1);
+  rb_define_method(rb_cInteger, ">>", rb_hack_rshift, 1);
 #else
   rb_define_alias(rb_cFixnum, "__or__", "|");
   rb_define_alias(rb_cFixnum, "__and__", "&");
@@ -238,25 +237,7 @@ Init_carray_numeric ()
   rb_define_alias(rb_cBignum, "__xor__", "^");
   rb_define_alias(rb_cBignum, "__lshift__", "<<");
   rb_define_alias(rb_cBignum, "__rshift__", ">>");
-#endif
 
-  rb_define_method(rb_cTrueClass, "|", rb_hack_or, 1);
-  rb_define_method(rb_cTrueClass, "&", rb_hack_and, 1);
-  rb_define_method(rb_cTrueClass, "^", rb_hack_xor, 1);
-  rb_define_method(rb_cTrueClass, "*", rb_hack_star, 1);
-
-  rb_define_method(rb_cFalseClass, "|", rb_hack_or, 1);
-  rb_define_method(rb_cFalseClass, "&", rb_hack_and, 1);
-  rb_define_method(rb_cFalseClass, "^", rb_hack_xor, 1);
-  rb_define_method(rb_cFalseClass, "*", rb_hack_star, 1);
-
-#if RUBY_VERSION_CODE >= 240
-  rb_define_method(rb_cInteger, "|", rb_hack_or, 1);
-  rb_define_method(rb_cInteger, "&", rb_hack_and, 1);
-  rb_define_method(rb_cInteger, "^", rb_hack_xor, 1);
-  rb_define_method(rb_cInteger, "<<", rb_hack_lshift, 1);
-  rb_define_method(rb_cInteger, ">>", rb_hack_rshift, 1);
-#else
   rb_define_method(rb_cFixnum, "|", rb_hack_or, 1);
   rb_define_method(rb_cFixnum, "&", rb_hack_and, 1);
   rb_define_method(rb_cFixnum, "^", rb_hack_xor, 1);