bit-twiddle 0.0.4 → 0.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 21f2a0957be75960781800875823e68dccce1148
-  data.tar.gz: 1f425d6f4730abd9f318abd6fc183421604707f4
+SHA256:
+  metadata.gz: 25b438e0de17e4ef56155166736b08d0bfc3ba962ae8c85f837e3073ed25e76f
+  data.tar.gz: b6cff494a2d45bdaa06eff5299a64b32f3a3b4ff284f7c5439a40dda29905b32
 SHA512:
-  metadata.gz: cb14a13b0a2d58a0538a7f16609b9782d9a79a7aee9efc4a2a0ae670fac35ac41c2326be5d0c481abe50926dace7094a68472d16f760ce2ac06ed369bb1635ea
-  data.tar.gz: dac2a365b3b19a5acfd4fb30ba932de68b15e8daa42cd522a9db2c828a5b88f2556a408e91ce232c19b54069312596b2271605745f91819113dde3ec8083e6d6
+  metadata.gz: 5097963595ddf9773f481b771958d00315c5a9e15deaa55c1e9290a82398b42b7b4ceccc7c9b6a105b63f30f9fab49b381fcf39ab630dc90343bfaac6cecb058
+  data.tar.gz: 24233d812e555ed06a9c31d6a098a414ebb5e98589b638fede32b981a43adef8f10e213e22167ec1147dd0aa1d6ed5c0f13753cbd218bf7dad2852c270a85760

data/LICENSE

@@ -1,3 +1,3 @@
 The program code in the 'bit-twiddle' repository (currently available at https://github.com/alexdowad/bit-twiddle) has been placed in the public domain by its author. You can do anything you want with it, anything at all. You can copy it, sell it, buy it, lease it, rent it out, put it in pawn, or use it as a down payment on a new truck. You can sing it out in the shower, or on a crowded bus. You can even inscribe it on a silk flag, and plant it on Kilimanjaro's snow-covered slopes. The possibilities are endless!
 
-If you need a specific license, then make a copy of the code, solemnly declare that the copy belongs to you, and license it to yourself under any terms you desire.
+If 'public domain' isn't what you like, then you can use this code under a CC0 (creative commons) license. Still no good? Drop the author a note and we'll see how to fix you up.

data/README.md

@@ -1,6 +1,7 @@
-#Fast bitwise operations for Ruby
+Fast bitwise operations for Ruby
+================================
 
-Ruby has built-in implementations of the "workhorses" of bit manipulation: bitwise AND, OR, NOT, and XOR operations and bit shifts. This library adds more bitwise operations, which may be useful in implementing some algorithms. All the added operations are implemented in optimized C code (so this is MRI-only). All operations on integers are implemented for both `Fixnum`s and `Bignum`s.
+Ruby has built-in implementations of the "workhorses" of bit manipulation: bitwise AND, OR, NOT, and XOR operations and bit shifts. This library adds more bitwise operations, which may be useful in implementing some algorithms. All the added operations are implemented in optimized C code (so this is MRI-only).
 
 Install this goodness with:
 
@@ -22,8 +23,6 @@ require "bit-twiddle/core_ext"
 
 In many cases, `bit-twiddle` operations explicitly work on the low 8, 16, 32, or 64 bits of an integer. (For example, it defines `#bitreverse8`, `#bitreverse16`, `#bitreverse32`, and `#bitreverse64` methods.) If an integer's bit width is larger than the number of bits operated on, the higher-end bits are passed through unchanged.
 
-All methods automatically convert between `Fixnum` and `Bignum` as is most appropriate to represent their result.
-
 ## Examples
 
 ### Population count

data/ext/bit_twiddle/bit_twiddle.c

@@ -1,6 +1,16 @@
+/* Fast C implementation of additional bitwise operations for Ruby
+ * Hand-crafted with ♥ by Alex Dowad, using ONLY the finest 1s and 0s */
+
 #include <ruby.h>
 #include "bt_bignum.h"
 
+#ifndef HAVE_TYPE_ULONG
+typedef unsigned long ulong;
+#endif
+#ifndef HAVE_TYPE_UCHAR
+typedef unsigned char uchar;
+#endif
+
 #define fix_zero LONG2FIX(0L)
 #define BIGNUM_P(x) RB_TYPE_P((x), T_BIGNUM)
 
@@ -21,11 +31,11 @@
 #endif
 
 #if SIZEOF_BDIGIT < 4
-#error "Sorry, Bignum#bswap32 and Bignum#arith_rshift32 will not work if sizeof(BDIGIT) < 4. Please report this error."
+#error "Sorry, Integer#bswap32 and Integer#arith_rshift32 will not work if sizeof(BDIGIT) < 4. Please report this error."
 #elif SIZEOF_BDIGIT > 8
 #error "Sorry, several methods will not work if sizeof(BDIGIT) > 8. Please report this error."
 #elif SIZEOF_LONG > 8
-#error "Sorry, Fixnum#arith_rshift64 will not work if sizeof(long) > 8. Please report this error."
+#error "Sorry, Integer#arith_rshift64 will not work if sizeof(long) > 8. Please report this error."
 #endif
 
 #if HAVE_BSWAP16 == 0
@@ -50,7 +60,7 @@ bnum_greater(VALUE bnum, BDIGIT value)
 }
 
 static long
-value_to_shiftdist(VALUE shiftdist, long bits)
+value_to_shiftdist(VALUE shiftdist, unsigned int bits)
 {
   for (;;) {
     if (FIXNUM_P(shiftdist)) {
@@ -81,12 +91,12 @@ value_to_rotdist(VALUE rotdist, long bits, long mask)
       rdist = FIX2LONG(rotdist) % bits;
       if (rdist < 0)
         rdist += bits;
-      return rdist;
+      return (ulong)rdist;
     } else if (BIGNUM_P(rotdist)) {
       rdist = *RBIGNUM_DIGITS(rotdist) & mask;
       if (RBIGNUM_NEGATIVE_P(rotdist))
         rdist = bits - rdist;
-      return rdist;
+      return (ulong)rdist;
     } else {
       rotdist = rb_to_int(rotdist);
     }
@@ -99,22 +109,22 @@ store_64_into_bnum(VALUE bnum, uint64_t int64)
   BDIGIT *dest = RBIGNUM_DIGITS(bnum);
   size_t  len  = RBIGNUM_LEN(bnum);
 
-  if (SIZEOF_BDIGIT == 8) {
+#if (SIZEOF_BDIGIT == 8)
     *dest = int64;
-  } else {
+#else
     if (len > 1) {
-      *dest     = int64;
-      *(dest+1) = int64 >> 32;
+      *dest     = (uint32_t)int64;
+      *(dest+1) = (uint32_t)(int64 >> 32);
     } else if ((int64 & (0xFFFFFFFFULL << 32)) == 0) {
       /* the high 4 bytes are zero anyways */
-      *dest = int64;
+      *dest = (uint32_t)int64;
     } else {
       rb_big_resize(bnum, 2);
       dest      = RBIGNUM_DIGITS(bnum); /* may have moved */
-      *dest     = int64;
-      *(dest+1) = int64 >> 32;
+      *dest     = (uint32_t)int64;
+      *(dest+1) = (uint32_t)(int64 >> 32);
     }
-  }
+#endif
 }
 
 static uint64_t
@@ -201,24 +211,30 @@ modify_lo64_in_bignum(VALUE bnum, uint64_t lo64)
   return result;
 }
 
-/* Document-method: Fixnum#popcount
- * Document-method: Bignum#popcount
- * Return the number of 1 bits in this integer.
- *
- * If the receiver is negative, raise `RangeError`.
- *
- * @example
- *   7.popcount   # => 3
- *   255.popcount # => 8
- * @return [Fixnum]
- */
+/* Now start defining implementations of actual Ruby methods
+ * First two helper macros: */
+#define def_int_method(name) \
+  static VALUE int_ ## name(VALUE integer) { \
+    if (FIXNUM_P(integer)) \
+      return fnum_ ## name(integer); \
+    else \
+      return bnum_ ## name(integer); \
+  }
+#define def_int_method_with_arg(name) \
+  static VALUE int_ ## name(VALUE integer, VALUE arg) { \
+    if (FIXNUM_P(integer)) \
+      return fnum_ ## name(integer, arg); \
+    else \
+      return bnum_ ## name(integer, arg); \
+  }
+
 static VALUE
 fnum_popcount(VALUE fnum)
 {
   long value = FIX2LONG(fnum);
   if (value < 0)
     rb_raise(rb_eRangeError, "can't take popcount of a negative number");
-  return LONG2FIX(__builtin_popcountl(value));
+  return LONG2FIX(__builtin_popcountl((ulong)value));
 }
 
 static VALUE
@@ -239,16 +255,28 @@ bnum_popcount(VALUE bnum)
   return LONG2FIX(bits);
 }
 
+/* Document-method: Integer#popcount
+ * Return the number of 1 bits in this integer.
+ *
+ * If the receiver is negative, raise `RangeError`.
+ *
+ * @example
+ *   7.popcount   # => 3
+ *   255.popcount # => 8
+ * @return [Integer]
+ */
+def_int_method(popcount);
+
 /* Return the number of 1 bits in all the bytes of this `String`.
  * @example
  *   "abc".popcount # => 10
- * @return [Fixnum]
+ * @return [Integer]
  */
 static VALUE
 str_popcount(VALUE str)
 {
-  char *p     = RSTRING_PTR(str);
-  int  length = RSTRING_LEN(str);
+  uchar *p    = (uchar*)RSTRING_PTR(str);
+  long length = RSTRING_LEN(str);
   long bits   = 0;
 
   /* This could be made faster by processing 4/8 bytes at a time */
@@ -259,18 +287,6 @@ str_popcount(VALUE str)
   return LONG2FIX(bits);
 }
 
-/* Document-method: Fixnum#lo_bit
- * Document-method: Bignum#lo_bit
- * Return the index of the lowest 1 bit, where the least-significant bit is index 1.
- * If the receiver is 0, return 0.
- *
- * If the receiver is negative, raise `RangeError`.
- *
- * @example
- *   1.lo_bit   # => 1
- *   128.lo_bit # => 8
- * @return [Fixnum]
- */
 static VALUE
 fnum_lo_bit(VALUE fnum)
 {
@@ -306,18 +322,19 @@ bnum_lo_bit(VALUE bnum)
   return LONG2FIX(bits);
 }
 
-/* Document-method: Fixnum#hi_bit
- * Document-method: Bignum#hi_bit
- * Return the index of the highest 1 bit, where the least-significant bit is index 1.
+/* Document-method: Integer#lo_bit
+ * Return the index of the lowest 1 bit, where the least-significant bit is index 1.
  * If the receiver is 0, return 0.
  *
  * If the receiver is negative, raise `RangeError`.
  *
  * @example
- *   1.hi_bit   # => 1
- *   255.hi_bit # => 8
- * @return [Fixnum]
+ *   1.lo_bit   # => 1
+ *   128.lo_bit # => 8
+ * @return [Integer]
  */
+def_int_method(lo_bit);
+
 static VALUE
 fnum_hi_bit(VALUE fnum)
 {
@@ -333,7 +350,7 @@ static VALUE
 bnum_hi_bit(VALUE bnum)
 {
   BDIGIT *digit = RBIGNUM_DIGITS(bnum) + (RBIGNUM_LEN(bnum)-1);
-  long    bits  = (sizeof(BDIGIT) * 8) * RBIGNUM_LEN(bnum);
+  ulong   bits  = (sizeof(BDIGIT) * 8) * RBIGNUM_LEN(bnum);
 
   if (RBIGNUM_NEGATIVE_P(bnum))
     rb_raise(rb_eRangeError, "can't find highest 1 bit in a negative number");
@@ -347,47 +364,49 @@ bnum_hi_bit(VALUE bnum)
   return LONG2FIX(bits);
 }
 
-/* Document-method: Fixnum#bswap16
- * Document-method: Bignum#bswap16
- * Reverse the least-significant and second least-significant bytes of this integer.
+/* Document-method: Integer#hi_bit
+ * Return the index of the highest 1 bit, where the least-significant bit is index 1.
+ * If the receiver is 0, return 0.
  *
  * If the receiver is negative, raise `RangeError`.
  *
  * @example
- *   0xFF00.bswap16 # => 255
- *   0x00FF.bswap16 # => 65280
+ *   1.hi_bit   # => 1
+ *   255.hi_bit # => 8
  * @return [Integer]
  */
+def_int_method(hi_bit);
+
 static VALUE
 fnum_bswap16(VALUE fnum)
 {
   long value = FIX2LONG(fnum);
   if (value < 0)
     rb_raise(rb_eRangeError, "can't swap bytes in a negative number");
-  return LONG2FIX((value & ~0xFFFF) | __builtin_bswap16(value));
+  return LONG2FIX(((ulong)value & ~0xFFFFUL) | __builtin_bswap16((uint16_t)value));
 }
 
 static VALUE
 bnum_bswap16(VALUE bnum)
 {
   if (RBIGNUM_POSITIVE_P(bnum))
-    return modify_lo16_in_bignum(bnum, __builtin_bswap16(*RBIGNUM_DIGITS(bnum)));
+    return modify_lo16_in_bignum(bnum, __builtin_bswap16((uint16_t)*RBIGNUM_DIGITS(bnum)));
   else
     rb_raise(rb_eRangeError, "can't swap bytes in a negative number");
 }
 
-/* Document-method: Fixnum#bswap32
- * Document-method: Bignum#bswap32
- * Reverse the least-significant 4 bytes of this integer.
+/* Document-method: Integer#bswap16
+ * Reverse the least-significant and second least-significant bytes of this integer.
  *
- * Does not reverse bits within each byte. This can be used to swap endianness
- * of a 32-bit integer. If the receiver is negative, raise `RangeError`.
+ * If the receiver is negative, raise `RangeError`.
  *
  * @example
- *   0xaabbccdd.bswap32.to_s(16) # => "ddccbbaa"
- *
+ *   0xFF00.bswap16 # => 255
+ *   0x00FF.bswap16 # => 65280
  * @return [Integer]
  */
+def_int_method(bswap16);
+
 static VALUE
 fnum_bswap32(VALUE fnum)
 {
@@ -403,7 +422,7 @@ fnum_bswap32(VALUE fnum)
      * That is why we have to use a '2NUM' function, not '2FIX' */
     return ULONG2NUM(__builtin_bswap32(FIX2LONG(fnum)));
   else
-    return LONG2FIX((value & ~0xFFFFFFFFL) | __builtin_bswap32(value));
+    return LONG2FIX(((ulong)value & ~0xFFFFFFFFUL) | __builtin_bswap32((uint32_t)value));
 }
 
 static VALUE
@@ -415,25 +434,26 @@ bnum_bswap32(VALUE bnum)
     rb_raise(rb_eRangeError, "can't swap bytes in a negative number");
 }
 
-/* Document-method: Fixnum#bswap64
- * Document-method: Bignum#bswap64
- * Reverse the least-significant 8 bytes of this integer.
+/* Document-method: Integer#bswap32
+ * Reverse the least-significant 4 bytes of this integer.
  *
  * Does not reverse bits within each byte. This can be used to swap endianness
- * of a 64-bit integer. If the receiver is negative, raise `RangeError`.
+ * of a 32-bit integer. If the receiver is negative, raise `RangeError`.
  *
  * @example
- *   0xaabbccdd.bswap64.to_s(16) # => "ddccbbaa00000000"
+ *   0xaabbccdd.bswap32.to_s(16) # => "ddccbbaa"
  *
  * @return [Integer]
  */
+def_int_method(bswap32);
+
 static VALUE
 fnum_bswap64(VALUE fnum)
 {
   long value = FIX2LONG(fnum);
   if (value < 0)
     rb_raise(rb_eRangeError, "can't swap bytes in a negative number");
-  return ULL2NUM(__builtin_bswap64(value));
+  return ULL2NUM(__builtin_bswap64((uint64_t)value));
 }
 
 static VALUE
@@ -445,6 +465,19 @@ bnum_bswap64(VALUE bnum)
     rb_raise(rb_eRangeError, "can't swap bytes in a negative number");
 }
 
+/* Document-method: Integer#bswap64
+ * Reverse the least-significant 8 bytes of this integer.
+ *
+ * Does not reverse bits within each byte. This can be used to swap endianness
+ * of a 64-bit integer. If the receiver is negative, raise `RangeError`.
+ *
+ * @example
+ *   0xaabbccdd.bswap64.to_s(16) # => "ddccbbaa00000000"
+ *
+ * @return [Integer]
+ */
+def_int_method(bswap64);
+
 #define def_rot_helpers(bits) \
   static inline uint##bits##_t rrot##bits(uint##bits##_t value, VALUE rotdist) { \
     ulong rotd = value_to_rotdist(rotdist, bits, bits-1); \
@@ -460,102 +493,92 @@ def_rot_helpers(16);
 def_rot_helpers(32);
 def_rot_helpers(64);
 
-/* Document-method: Fixnum#rrot8
- * Document-method: Bignum#rrot8
- * Right-rotation ("circular shift") of the low 8 bits in this integer.
- *
- * If the rotate distance is negative, the bit rotation will be to the left
- * instead.
- *
- * @example
- *   0b01110001.rrot8(1).to_s(2) # => "10111000"
- *   0b01110001.rrot8(3).to_s(2) # => "101110"
- *
- * @param rotdist [Integer] Number of bit positions to rotate by
- * @return [Integer]
- */
 static VALUE
 fnum_rrot8(VALUE fnum, VALUE rotdist)
 {
   long value = FIX2LONG(fnum);
-  return LONG2FIX((value & ~0xFFL) | rrot8(value, rotdist));
+  return LONG2FIX(((ulong)value & ~0xFFUL) | rrot8((uint8_t)value, rotdist));
 }
 
 static VALUE
 bnum_rrot8(VALUE bnum, VALUE rotdist)
 {
-  return modify_lo8_in_bignum(bnum, rrot8(*RBIGNUM_DIGITS(bnum), rotdist));
+  return modify_lo8_in_bignum(bnum, rrot8((uint8_t)*RBIGNUM_DIGITS(bnum), rotdist));
 }
 
-/* Document-method: Fixnum#rrot16
- * Document-method: Bignum#rrot16
- * Right-rotation ("circular shift") of the low 16 bits in this integer.
+/* Document-method: Integer#rrot8
+ * Right-rotation ("circular shift") of the low 8 bits in this integer.
  *
  * If the rotate distance is negative, the bit rotation will be to the left
  * instead.
  *
  * @example
- *   0b0111000101110001.rrot16(1).to_s(2) # => "1011100010111000"
- *   0b0111000101110001.rrot16(3).to_s(2) # => "10111000101110"
+ *   0b01110001.rrot8(1).to_s(2) # => "10111000"
+ *   0b01110001.rrot8(3).to_s(2) # => "101110"
  *
  * @param rotdist [Integer] Number of bit positions to rotate by
  * @return [Integer]
  */
+def_int_method_with_arg(rrot8);
+
 static VALUE
 fnum_rrot16(VALUE fnum, VALUE rotdist)
 {
   long value = FIX2LONG(fnum);
-  return LONG2FIX((value & ~0xFFFFL) | rrot16(value, rotdist));
+  return LONG2FIX(((ulong)value & ~0xFFFFUL) | rrot16((uint16_t)value, rotdist));
 }
 
 static VALUE
 bnum_rrot16(VALUE bnum, VALUE rotdist)
 {
-  return modify_lo16_in_bignum(bnum, rrot16(*RBIGNUM_DIGITS(bnum), rotdist));
+  return modify_lo16_in_bignum(bnum, rrot16((uint16_t)*RBIGNUM_DIGITS(bnum), rotdist));
 }
 
-/* Document-method: Fixnum#rrot32
- * Document-method: Bignum#rrot32
- * Right-rotation ("circular shift") of the low 32 bits in this integer.
+/* Document-method: Integer#rrot16
+ * Right-rotation ("circular shift") of the low 16 bits in this integer.
  *
  * If the rotate distance is negative, the bit rotation will be to the left
  * instead.
  *
  * @example
- *   0xaabbccdd.rrot32(4).to_s(16) # => "daabbccd"
+ *   0b0111000101110001.rrot16(1).to_s(2) # => "1011100010111000"
+ *   0b0111000101110001.rrot16(3).to_s(2) # => "10111000101110"
  *
  * @param rotdist [Integer] Number of bit positions to rotate by
  * @return [Integer]
  */
+def_int_method_with_arg(rrot16);
+
 static VALUE
 fnum_rrot32(VALUE fnum, VALUE rotdist)
 {
   long     value  = FIX2LONG(fnum);
   if (SIZEOF_LONG == 8)
-    return LONG2FIX((value & ~0xFFFFFFFFL) | rrot32(value, rotdist));
+    return LONG2FIX(((ulong)value & ~0xFFFFFFFFUL) | rrot32((uint32_t)value, rotdist));
   else
-    return ULONG2NUM(rrot32(value, rotdist));
+    return ULONG2NUM(rrot32((uint32_t)value, rotdist));
 }
 
 static VALUE
 bnum_rrot32(VALUE bnum, VALUE rotdist)
 {
-  return modify_lo32_in_bignum(bnum, rrot32(*RBIGNUM_DIGITS(bnum), rotdist));
+  return modify_lo32_in_bignum(bnum, rrot32((uint32_t)*RBIGNUM_DIGITS(bnum), rotdist));
 }
 
-/* Document-method: Fixnum#rrot64
- * Document-method: Bignum#rrot64
- * Right-rotation ("circular shift") of the low 64 bits in this integer.
+/* Document-method: Integer#rrot32
+ * Right-rotation ("circular shift") of the low 32 bits in this integer.
  *
  * If the rotate distance is negative, the bit rotation will be to the left
  * instead.
  *
  * @example
- *   0x11223344aabbccdd.rrot64(4).to_s(16) # => "d11223344aabbccd"
+ *   0xaabbccdd.rrot32(4).to_s(16) # => "daabbccd"
  *
  * @param rotdist [Integer] Number of bit positions to rotate by
  * @return [Integer]
  */
+def_int_method_with_arg(rrot32);
+
 static VALUE
 fnum_rrot64(VALUE fnum, VALUE rotdist)
 {
@@ -568,99 +591,103 @@ bnum_rrot64(VALUE bnum, VALUE rotdist)
   return modify_lo64_in_bignum(bnum, rrot64(load_64_from_bignum(bnum), rotdist));
 }
 
-/* Document-method: Fixnum#lrot8
- * Document-method: Bignum#lrot8
- * Left-rotation ("circular shift") of the low 8 bits in this integer.
+/* Document-method: Integer#rrot64
+ * Right-rotation ("circular shift") of the low 64 bits in this integer.
  *
- * If the rotate distance is negative, the bit rotation will be to the right
+ * If the rotate distance is negative, the bit rotation will be to the left
  * instead.
  *
  * @example
- *   0b01110001.lrot8(1).to_s(2) # => "11100010"
- *   0b01110001.lrot8(3).to_s(2) # => "10001011"
+ *   0x11223344aabbccdd.rrot64(4).to_s(16) # => "d11223344aabbccd"
  *
  * @param rotdist [Integer] Number of bit positions to rotate by
  * @return [Integer]
  */
+def_int_method_with_arg(rrot64);
+
 static VALUE
 fnum_lrot8(VALUE fnum, VALUE rotdist)
 {
   long value = FIX2LONG(fnum);
-  return LONG2FIX((value & ~0xFFL) | lrot8(value, rotdist));
+  return LONG2FIX(((ulong)value & ~0xFFUL) | lrot8((uint8_t)value, rotdist));
 }
 
 static VALUE
 bnum_lrot8(VALUE bnum, VALUE rotdist)
 {
-  return modify_lo8_in_bignum(bnum, lrot8(*RBIGNUM_DIGITS(bnum), rotdist));
+  return modify_lo8_in_bignum(bnum, lrot8((uint8_t)*RBIGNUM_DIGITS(bnum), rotdist));
 }
 
-/* Document-method: Fixnum#lrot16
- * Document-method: Bignum#lrot16
- * Left-rotation ("circular shift") of the low 16 bits in this integer.
+/* Document-method: Integer#lrot8
+ * Left-rotation ("circular shift") of the low 8 bits in this integer.
  *
  * If the rotate distance is negative, the bit rotation will be to the right
  * instead.
  *
  * @example
- *   0b0111000101110001.lrot16(1).to_s(2) # => "1110001011100010"
- *   0b0111000101110001.lrot16(3).to_s(2) # => "1000101110001011"
+ *   0b01110001.lrot8(1).to_s(2) # => "11100010"
+ *   0b01110001.lrot8(3).to_s(2) # => "10001011"
  *
  * @param rotdist [Integer] Number of bit positions to rotate by
  * @return [Integer]
  */
+def_int_method_with_arg(lrot8);
+
 static VALUE
 fnum_lrot16(VALUE fnum, VALUE rotdist)
 {
   long value = FIX2LONG(fnum);
-  return LONG2FIX((value & ~0xFFFFL) | lrot16(value, rotdist));
+  return LONG2FIX(((ulong)value & ~0xFFFFUL) | lrot16((uint16_t)value, rotdist));
 }
 
 static VALUE
 bnum_lrot16(VALUE bnum, VALUE rotdist)
 {
-  return modify_lo16_in_bignum(bnum, lrot16(*RBIGNUM_DIGITS(bnum), rotdist));
+  return modify_lo16_in_bignum(bnum, lrot16((uint16_t)*RBIGNUM_DIGITS(bnum), rotdist));
 }
 
-/* Document-method: Fixnum#lrot32
- * Document-method: Bignum#lrot32
- * Left-rotation ("circular shift") of the low 32 bits in this integer.
+/* Document-method: Integer#lrot16
+ * Left-rotation ("circular shift") of the low 16 bits in this integer.
  *
  * If the rotate distance is negative, the bit rotation will be to the right
  * instead.
  *
  * @example
- *   0xaabbccdd.lrot32(4).to_s(16) # => "abbccdda"
+ *   0b0111000101110001.lrot16(1).to_s(2) # => "1110001011100010"
+ *   0b0111000101110001.lrot16(3).to_s(2) # => "1000101110001011"
  *
  * @param rotdist [Integer] Number of bit positions to rotate by
  * @return [Integer]
  */
+def_int_method_with_arg(lrot16);
+
 static VALUE
 fnum_lrot32(VALUE fnum, VALUE rotdist)
 {
   long value = FIX2LONG(fnum);
-  return LONG2FIX((value & ~0xFFFFFFFFL) | lrot32(value, rotdist));
+  return LONG2FIX(((ulong)value & ~0xFFFFFFFFUL) | lrot32((uint32_t)value, rotdist));
 }
 
 static VALUE
 bnum_lrot32(VALUE bnum, VALUE rotdist)
 {
-  return modify_lo32_in_bignum(bnum, lrot32(*RBIGNUM_DIGITS(bnum), rotdist));
+  return modify_lo32_in_bignum(bnum, lrot32((uint32_t)*RBIGNUM_DIGITS(bnum), rotdist));
 }
 
-/* Document-method: Fixnum#lrot64
- * Document-method: Bignum#lrot64
- * Left-rotation ("circular shift") of the low 64 bits in this integer.
+/* Document-method: Integer#lrot32
+ * Left-rotation ("circular shift") of the low 32 bits in this integer.
  *
  * If the rotate distance is negative, the bit rotation will be to the right
  * instead.
  *
  * @example
- *   0x11223344aabbccdd.lrot64(4).to_s(16) # => "1223344aabbccdd1"
+ *   0xaabbccdd.lrot32(4).to_s(16) # => "abbccdda"
  *
  * @param rotdist [Integer] Number of bit positions to rotate by
  * @return [Integer]
  */
+def_int_method_with_arg(lrot32);
+
 static VALUE
 fnum_lrot64(VALUE fnum, VALUE rotdist)
 {
@@ -673,6 +700,20 @@ bnum_lrot64(VALUE bnum, VALUE rotdist)
   return modify_lo64_in_bignum(bnum, lrot64(load_64_from_bignum(bnum), rotdist));
 }
 
+/* Document-method: Integer#lrot64
+ * Left-rotation ("circular shift") of the low 64 bits in this integer.
+ *
+ * If the rotate distance is negative, the bit rotation will be to the right
+ * instead.
+ *
+ * @example
+ *   0x11223344aabbccdd.lrot64(4).to_s(16) # => "1223344aabbccdd1"
+ *
+ * @param rotdist [Integer] Number of bit positions to rotate by
+ * @return [Integer]
+ */
+def_int_method_with_arg(lrot64);
+
 #define def_shift_helpers(bits) \
   static uint##bits##_t lshift##bits(uint##bits##_t value, VALUE shiftdist) { \
     long sdist = value_to_shiftdist(shiftdist, bits); \
@@ -711,21 +752,6 @@ def_shift_helpers(16);
 def_shift_helpers(32);
 def_shift_helpers(64);
 
-/* Document-method: Fixnum#lshift8
- * Document-method: Bignum#lshift8
- * Left-shift of the low 8 bits in this integer.
- *
- * If the shift distance is negative, a right shift will be performed instead.
- * The vacated bit positions will be filled with 0 bits. If shift distance is
- * more than 7 or less than -7, the low 8 bits will all be zeroed.
- *
- * @example
- *   0x11223344.lshift8(1).to_s(16) # => "11223388"
- *   0x11223344.lshift8(2).to_s(16) # => "11223310"
- *
- * @param shiftdist [Integer] Number of bit positions to shift by
- * @return [Integer]
- */
 static VALUE
 fnum_lshift8(VALUE fnum, VALUE shiftdist)
 {
@@ -733,7 +759,7 @@ fnum_lshift8(VALUE fnum, VALUE shiftdist)
   if (shiftdist == fix_zero)
     return fnum;
   else
-    return LONG2FIX((value & ~0xFFL) | lshift8(value, shiftdist));
+    return LONG2FIX(((ulong)value & ~0xFFUL) | lshift8((uint8_t)value, shiftdist));
 }
 
 static VALUE
@@ -742,24 +768,25 @@ bnum_lshift8(VALUE bnum, VALUE shiftdist)
   if (shiftdist == fix_zero)
     return bnum;
   else
-    return modify_lo8_in_bignum(bnum, lshift8(*RBIGNUM_DIGITS(bnum), shiftdist));
+    return modify_lo8_in_bignum(bnum, lshift8((uint8_t)*RBIGNUM_DIGITS(bnum), shiftdist));
 }
 
-/* Document-method: Fixnum#lshift16
- * Document-method: Bignum#lshift16
- * Left-shift of the low 16 bits in this integer.
+/* Document-method: Integer#lshift8
+ * Left-shift of the low 8 bits in this integer.
  *
  * If the shift distance is negative, a right shift will be performed instead.
  * The vacated bit positions will be filled with 0 bits. If shift distance is
- * more than 15 or less than -15, the low 16 bits will all be zeroed.
+ * more than 7 or less than -7, the low 8 bits will all be zeroed.
  *
  * @example
- *   0x11223344.lshift16(1).to_s(16) # => "11226688"
- *   0x11223344.lshift16(2).to_s(16) # => "1122cd10"
+ *   0x11223344.lshift8(1).to_s(16) # => "11223388"
+ *   0x11223344.lshift8(2).to_s(16) # => "11223310"
  *
  * @param shiftdist [Integer] Number of bit positions to shift by
  * @return [Integer]
  */
+def_int_method_with_arg(lshift8);
+
 static VALUE
 fnum_lshift16(VALUE fnum, VALUE shiftdist)
 {
@@ -767,7 +794,7 @@ fnum_lshift16(VALUE fnum, VALUE shiftdist)
   if (shiftdist == fix_zero)
     return fnum;
   else
-    return LONG2FIX((value & ~0xFFFFL) | lshift16(value, shiftdist));
+    return LONG2FIX(((ulong)value & ~0xFFFFUL) | lshift16((uint16_t)value, shiftdist));
 }
 
 static VALUE
@@ -776,24 +803,25 @@ bnum_lshift16(VALUE bnum, VALUE shiftdist)
   if (shiftdist == fix_zero)
     return bnum;
   else
-    return modify_lo16_in_bignum(bnum, lshift16(*RBIGNUM_DIGITS(bnum), shiftdist));
+    return modify_lo16_in_bignum(bnum, lshift16((uint16_t)*RBIGNUM_DIGITS(bnum), shiftdist));
 }
 
-/* Document-method: Fixnum#lshift32
- * Document-method: Bignum#lshift32
- * Left-shift of the low 32 bits in this integer.
+/* Document-method: Integer#lshift16
+ * Left-shift of the low 16 bits in this integer.
  *
  * If the shift distance is negative, a right shift will be performed instead.
  * The vacated bit positions will be filled with 0 bits. If shift distance is
- * more than 31 or less than -31, the low 32 bits will all be zeroed.
+ * more than 15 or less than -15, the low 16 bits will all be zeroed.
  *
  * @example
- *   0x11223344.lshift32(1).to_s(16) # => "22446688"
- *   0x11223344.lshift32(2).to_s(16) # => "4488cd10"
+ *   0x11223344.lshift16(1).to_s(16) # => "11226688"
+ *   0x11223344.lshift16(2).to_s(16) # => "1122cd10"
  *
  * @param shiftdist [Integer] Number of bit positions to shift by
  * @return [Integer]
  */
+def_int_method_with_arg(lshift16);
+
 static VALUE
 fnum_lshift32(VALUE fnum, VALUE shiftdist)
 {
@@ -801,7 +829,7 @@ fnum_lshift32(VALUE fnum, VALUE shiftdist)
   if (shiftdist == fix_zero)
     return fnum;
   else
-    return LONG2FIX((value & ~0xFFFFFFFFL) | lshift32(value, shiftdist));
+    return LONG2FIX(((ulong)value & ~0xFFFFFFFFUL) | lshift32((uint32_t)value, shiftdist));
 }
 
 static VALUE
@@ -810,24 +838,25 @@ bnum_lshift32(VALUE bnum, VALUE shiftdist)
   if (shiftdist == fix_zero)
     return bnum;
   else
-    return modify_lo32_in_bignum(bnum, lshift32(*RBIGNUM_DIGITS(bnum), shiftdist));
+    return modify_lo32_in_bignum(bnum, lshift32((uint32_t)*RBIGNUM_DIGITS(bnum), shiftdist));
 }
 
-/* Document-method: Fixnum#lshift64
- * Document-method: Bignum#lshift64
- * Left-shift of the low 64 bits in this integer.
+/* Document-method: Integer#lshift32
+ * Left-shift of the low 32 bits in this integer.
  *
  * If the shift distance is negative, a right shift will be performed instead.
  * The vacated bit positions will be filled with 0 bits. If shift distance is
- * more than 63 or less than -63, the low 64 bits will all be zeroed.
+ * more than 31 or less than -31, the low 32 bits will all be zeroed.
  *
  * @example
- *   0x1122334411223344.lshift64(1).to_s(16) # => "2244668822446688"
- *   0x1122334411223344.lshift64(2).to_s(16) # => "4488cd104488cd10"
+ *   0x11223344.lshift32(1).to_s(16) # => "22446688"
+ *   0x11223344.lshift32(2).to_s(16) # => "4488cd10"
  *
  * @param shiftdist [Integer] Number of bit positions to shift by
  * @return [Integer]
  */
+def_int_method_with_arg(lshift32);
+
 static VALUE
 fnum_lshift64(VALUE fnum, VALUE shiftdist)
 {
@@ -852,21 +881,22 @@ bnum_lshift64(VALUE bnum, VALUE shiftdist)
     return modify_lo64_in_bignum(bnum, lshift64(load_64_from_bignum(bnum), shiftdist));
 }
 
-/* Document-method: Fixnum#rshift8
- * Document-method: Bignum#rshift8
- * Right-shift of the low 8 bits in this integer.
+/* Document-method: Integer#lshift64
+ * Left-shift of the low 64 bits in this integer.
  *
- * If the shift distance is negative, a left shift will be performed instead.
+ * If the shift distance is negative, a right shift will be performed instead.
  * The vacated bit positions will be filled with 0 bits. If shift distance is
- * more than 7 or less than -7, the low 8 bits will all be zeroed.
+ * more than 63 or less than -63, the low 64 bits will all be zeroed.
  *
  * @example
- *   0x11223344.rshift8(1).to_s(16) # => "11223322"
- *   0x11223344.rshift8(2).to_s(16) # => "11223311"
+ *   0x1122334411223344.lshift64(1).to_s(16) # => "2244668822446688"
+ *   0x1122334411223344.lshift64(2).to_s(16) # => "4488cd104488cd10"
  *
  * @param shiftdist [Integer] Number of bit positions to shift by
  * @return [Integer]
  */
+def_int_method_with_arg(lshift64);
+
 static VALUE
 fnum_rshift8(VALUE fnum, VALUE shiftdist)
 {
@@ -874,7 +904,7 @@ fnum_rshift8(VALUE fnum, VALUE shiftdist)
   if (shiftdist == fix_zero)
     return fnum;
   else
-    return LONG2FIX((value & ~0xFFL) | rshift8(value, shiftdist));
+    return LONG2FIX(((ulong)value & ~0xFFUL) | rshift8((uint8_t)value, shiftdist));
 }
 
 static VALUE
@@ -883,24 +913,25 @@ bnum_rshift8(VALUE bnum, VALUE shiftdist)
   if (shiftdist == fix_zero)
     return bnum;
   else
-    return modify_lo8_in_bignum(bnum, rshift8(*RBIGNUM_DIGITS(bnum), shiftdist));
+    return modify_lo8_in_bignum(bnum, rshift8((uint8_t)*RBIGNUM_DIGITS(bnum), shiftdist));
 }
 
-/* Document-method: Fixnum#rshift16
- * Document-method: Bignum#rshift16
- * Right-shift of the low 16 bits in this integer.
+/* Document-method: Integer#rshift8
+ * Right-shift of the low 8 bits in this integer.
  *
  * If the shift distance is negative, a left shift will be performed instead.
  * The vacated bit positions will be filled with 0 bits. If shift distance is
- * more than 15 or less than -15, the low 16 bits will all be zeroed.
+ * more than 7 or less than -7, the low 8 bits will all be zeroed.
  *
  * @example
- *   0x11223344.rshift16(1).to_s(16) # => "112219a2"
- *   0x11223344.rshift16(2).to_s(16) # => "11220cd1"
+ *   0x11223344.rshift8(1).to_s(16) # => "11223322"
+ *   0x11223344.rshift8(2).to_s(16) # => "11223311"
  *
  * @param shiftdist [Integer] Number of bit positions to shift by
  * @return [Integer]
  */
+def_int_method_with_arg(rshift8);
+
 static VALUE
 fnum_rshift16(VALUE fnum, VALUE shiftdist)
 {
@@ -908,7 +939,7 @@ fnum_rshift16(VALUE fnum, VALUE shiftdist)
   if (shiftdist == fix_zero)
     return fnum;
   else
-    return LONG2FIX((value & ~0xFFFFL) | rshift16(value, shiftdist));
+    return LONG2FIX(((ulong)value & ~0xFFFFUL) | rshift16((uint16_t)value, shiftdist));
 }
 
 static VALUE
@@ -917,24 +948,25 @@ bnum_rshift16(VALUE bnum, VALUE shiftdist)
   if (shiftdist == fix_zero)
     return bnum;
   else
-    return modify_lo16_in_bignum(bnum, rshift16(*RBIGNUM_DIGITS(bnum), shiftdist));
+    return modify_lo16_in_bignum(bnum, rshift16((uint16_t)*RBIGNUM_DIGITS(bnum), shiftdist));
 }
 
-/* Document-method: Fixnum#rshift32
- * Document-method: Bignum#rshift32
- * Right-shift of the low 32 bits in this integer.
+/* Document-method: Integer#rshift16
+ * Right-shift of the low 16 bits in this integer.
  *
  * If the shift distance is negative, a left shift will be performed instead.
  * The vacated bit positions will be filled with 0 bits. If shift distance is
- * more than 31 or less than -31, the low 32 bits will all be zeroed.
+ * more than 15 or less than -15, the low 16 bits will all be zeroed.
  *
  * @example
- *   0x11223344.rshift32(1).to_s(16) # => "89119a2"
- *   0x11223344.rshift32(2).to_s(16) # => "4488cd1"
+ *   0x11223344.rshift16(1).to_s(16) # => "112219a2"
+ *   0x11223344.rshift16(2).to_s(16) # => "11220cd1"
  *
  * @param shiftdist [Integer] Number of bit positions to shift by
  * @return [Integer]
  */
+def_int_method_with_arg(rshift16);
+
 static VALUE
 fnum_rshift32(VALUE fnum, VALUE shiftdist)
 {
@@ -942,7 +974,7 @@ fnum_rshift32(VALUE fnum, VALUE shiftdist)
   if (shiftdist == fix_zero)
     return fnum;
   else
-    return LONG2FIX((value & ~0xFFFFFFFFL) | rshift32(value, shiftdist));
+    return LONG2FIX(((ulong)value & ~0xFFFFFFFFUL) | rshift32((uint32_t)value, shiftdist));
 }
 
 static VALUE
@@ -954,21 +986,22 @@ bnum_rshift32(VALUE bnum, VALUE shiftdist)
     return modify_lo32_in_bignum(bnum, rshift32(*RBIGNUM_DIGITS(bnum), shiftdist));
 }
 
-/* Document-method: Fixnum#rshift64
- * Document-method: Bignum#rshift64
- * Right-shift of the low 64 bits in this integer.
+/* Document-method: Integer#rshift32
+ * Right-shift of the low 32 bits in this integer.
  *
  * If the shift distance is negative, a left shift will be performed instead.
  * The vacated bit positions will be filled with 0 bits. If shift distance is
- * more than 63 or less than -63, the low 64 bits will all be zeroed.
+ * more than 31 or less than -31, the low 32 bits will all be zeroed.
  *
  * @example
- *   0x1122334411223344.rshift64(1).to_s(16) # => "89119a2089119a2"
- *   0x1122334411223344.rshift64(2).to_s(16) # => "4488cd104488cd1"
+ *   0x11223344.rshift32(1).to_s(16) # => "89119a2"
+ *   0x11223344.rshift32(2).to_s(16) # => "4488cd1"
  *
  * @param shiftdist [Integer] Number of bit positions to shift by
  * @return [Integer]
  */
+def_int_method_with_arg(rshift32);
+
 static VALUE
 fnum_rshift64(VALUE fnum, VALUE shiftdist)
 {
@@ -993,21 +1026,22 @@ bnum_rshift64(VALUE bnum, VALUE shiftdist)
     return modify_lo64_in_bignum(bnum, rshift64(load_64_from_bignum(bnum), shiftdist));
 }
 
-/* Document-method: Fixnum#arith_rshift8
- * Document-method: Bignum#arith_rshift8
- * Arithmetic right-shift of the low 8 bits in this integer.
+/* Document-method: Integer#rshift64
+ * Right-shift of the low 64 bits in this integer.
  *
- * If bit 8 is a 1, the vacated bit positions will be filled with 1s. Otherwise,
- * they will be filled with 0s. Or, if the shift distance is negative, a left shift
- * will be performed instead, and the vacated bit positions will be filled with 0s.
+ * If the shift distance is negative, a left shift will be performed instead.
+ * The vacated bit positions will be filled with 0 bits. If shift distance is
+ * more than 63 or less than -63, the low 64 bits will all be zeroed.
  *
  * @example
- *   0xaabbccdd.arith_rshift8(1).to_s(16) # => "aabbccee"
- *   0xaabbccdd.arith_rshift8(2).to_s(16) # => "aabbccf7"
+ *   0x1122334411223344.rshift64(1).to_s(16) # => "89119a2089119a2"
+ *   0x1122334411223344.rshift64(2).to_s(16) # => "4488cd104488cd1"
  *
  * @param shiftdist [Integer] Number of bit positions to shift by
  * @return [Integer]
  */
+def_int_method_with_arg(rshift64);
+
 static VALUE
 fnum_arith_rshift8(VALUE fnum, VALUE shiftdist)
 {
@@ -1015,7 +1049,7 @@ fnum_arith_rshift8(VALUE fnum, VALUE shiftdist)
   if (shiftdist == fix_zero)
     return fnum;
   else
-    return LONG2FIX((value & ~0xFFUL) | arith_rshift8(value, shiftdist));
+    return LONG2FIX(((ulong)value & ~0xFFUL) | arith_rshift8((uint8_t)value, shiftdist));
 }
 
 static VALUE
@@ -1024,24 +1058,25 @@ bnum_arith_rshift8(VALUE bnum, VALUE shiftdist)
   if (shiftdist == fix_zero)
     return bnum;
   else
-    return modify_lo8_in_bignum(bnum, arith_rshift8(*RBIGNUM_DIGITS(bnum), shiftdist));
+    return modify_lo8_in_bignum(bnum, arith_rshift8((uint8_t)*RBIGNUM_DIGITS(bnum), shiftdist));
 }
 
-/* Document-method: Fixnum#arith_rshift16
- * Document-method: Bignum#arith_rshift16
- * Arithmetic right-shift of the low 16 bits in this integer.
+/* Document-method: Integer#arith_rshift8
+ * Arithmetic right-shift of the low 8 bits in this integer.
  *
- * If bit 16 is a 1, the vacated bit positions will be filled with 1s. Otherwise,
+ * If bit 8 is a 1, the vacated bit positions will be filled with 1s. Otherwise,
  * they will be filled with 0s. Or, if the shift distance is negative, a left shift
  * will be performed instead, and the vacated bit positions will be filled with 0s.
  *
  * @example
- *   0xaabbccdd.arith_rshift16(1).to_s(16) # => "aabbe66e"
- *   0xaabbccdd.arith_rshift16(2).to_s(16) # => "aabbf337"
+ *   0xaabbccdd.arith_rshift8(1).to_s(16) # => "aabbccee"
+ *   0xaabbccdd.arith_rshift8(2).to_s(16) # => "aabbccf7"
  *
  * @param shiftdist [Integer] Number of bit positions to shift by
  * @return [Integer]
  */
+def_int_method_with_arg(arith_rshift8);
+
 static VALUE
 fnum_arith_rshift16(VALUE fnum, VALUE shiftdist)
 {
@@ -1049,7 +1084,7 @@ fnum_arith_rshift16(VALUE fnum, VALUE shiftdist)
   if (shiftdist == fix_zero)
     return fnum;
   else
-    return LONG2FIX((value & ~0xFFFFUL) | arith_rshift16(value, shiftdist));
+    return LONG2FIX(((ulong)value & ~0xFFFFUL) | arith_rshift16((uint16_t)value, shiftdist));
 }
 
 static VALUE
@@ -1058,24 +1093,25 @@ bnum_arith_rshift16(VALUE bnum, VALUE shiftdist)
   if (shiftdist == fix_zero)
     return bnum;
   else
-    return modify_lo16_in_bignum(bnum, arith_rshift16(*RBIGNUM_DIGITS(bnum), shiftdist));
+    return modify_lo16_in_bignum(bnum, arith_rshift16((uint16_t)*RBIGNUM_DIGITS(bnum), shiftdist));
 }
 
-/* Document-method: Fixnum#arith_rshift32
- * Document-method: Bignum#arith_rshift32
- * Arithmetic right-shift of the low 32 bits in this integer.
+/* Document-method: Integer#arith_rshift16
+ * Arithmetic right-shift of the low 16 bits in this integer.
  *
- * If bit 32 is a 1, the vacated bit positions will be filled with 1s. Otherwise,
+ * If bit 16 is a 1, the vacated bit positions will be filled with 1s. Otherwise,
  * they will be filled with 0s. Or, if the shift distance is negative, a left shift
  * will be performed instead, and the vacated bit positions will be filled with 0s.
  *
  * @example
- *   0xaabbccddaabbccdd.arith_rshift32(1).to_s(16) # => "d55de66e"
- *   0xaabbccddaabbccdd.arith_rshift32(2).to_s(16) # => "eaaef337"
+ *   0xaabbccdd.arith_rshift16(1).to_s(16) # => "aabbe66e"
+ *   0xaabbccdd.arith_rshift16(2).to_s(16) # => "aabbf337"
  *
  * @param shiftdist [Integer] Number of bit positions to shift by
  * @return [Integer]
  */
+def_int_method_with_arg(arith_rshift16);
+
 static VALUE
 fnum_arith_rshift32(VALUE fnum, VALUE shiftdist)
 {
@@ -1083,7 +1119,7 @@ fnum_arith_rshift32(VALUE fnum, VALUE shiftdist)
   if (shiftdist == fix_zero)
     return fnum;
   else
-    return LONG2FIX((value & ~0xFFFFFFFFUL) | arith_rshift32(value, shiftdist));
+    return LONG2FIX(((ulong)value & ~0xFFFFFFFFUL) | arith_rshift32((uint32_t)value, shiftdist));
 }
 
 static VALUE
@@ -1095,28 +1131,29 @@ bnum_arith_rshift32(VALUE bnum, VALUE shiftdist)
     return modify_lo32_in_bignum(bnum, arith_rshift32(*RBIGNUM_DIGITS(bnum), shiftdist));
 }
 
-/* Document-method: Fixnum#arith_rshift64
- * Document-method: Bignum#arith_rshift64
- * Arithmetic right-shift of the low 64 bits in this integer.
+/* Document-method: Integer#arith_rshift32
+ * Arithmetic right-shift of the low 32 bits in this integer.
  *
- * If bit 64 is a 1, the vacated bit positions will be filled with 1s. Otherwise,
+ * If bit 32 is a 1, the vacated bit positions will be filled with 1s. Otherwise,
  * they will be filled with 0s. Or, if the shift distance is negative, a left shift
  * will be performed instead, and the vacated bit positions will be filled with 0s.
  *
  * @example
- *   0xaabbccddaabbccdd.arith_rshift64(1).to_s(16) # => "d55de66ed55de66e"
- *   0xaabbccddaabbccdd.arith_rshift64(2).to_s(16) # => "eaaef3376aaef337"
+ *   0xaabbccddaabbccdd.arith_rshift32(1).to_s(16) # => "d55de66e"
+ *   0xaabbccddaabbccdd.arith_rshift32(2).to_s(16) # => "eaaef337"
  *
  * @param shiftdist [Integer] Number of bit positions to shift by
  * @return [Integer]
  */
+def_int_method_with_arg(arith_rshift32);
+
 static VALUE
 fnum_arith_rshift64(VALUE fnum, VALUE shiftdist)
 {
   if (shiftdist == fix_zero)
     return fnum;
   else
-    return ULONG2NUM(arith_rshift64(FIX2LONG(fnum), shiftdist));
+    return ULONG2NUM(arith_rshift64((uint64_t)FIX2LONG(fnum), shiftdist));
 }
 
 static VALUE
@@ -1128,6 +1165,22 @@ bnum_arith_rshift64(VALUE bnum, VALUE shiftdist)
     return modify_lo64_in_bignum(bnum, arith_rshift64(load_64_from_bignum(bnum), shiftdist));
 }
 
+/* Document-method: Integer#arith_rshift64
+ * Arithmetic right-shift of the low 64 bits in this integer.
+ *
+ * If bit 64 is a 1, the vacated bit positions will be filled with 1s. Otherwise,
+ * they will be filled with 0s. Or, if the shift distance is negative, a left shift
+ * will be performed instead, and the vacated bit positions will be filled with 0s.
+ *
+ * @example
+ *   0xaabbccddaabbccdd.arith_rshift64(1).to_s(16) # => "d55de66ed55de66e"
+ *   0xaabbccddaabbccdd.arith_rshift64(2).to_s(16) # => "eaaef3376aaef337"
+ *
+ * @param shiftdist [Integer] Number of bit positions to shift by
+ * @return [Integer]
+ */
+def_int_method_with_arg(arith_rshift64);
+
 static const uint8_t bitreverse_table[] =
 {
   0x00, 0x80, 0x40, 0xC0, 0x20, 0xA0, 0x60, 0xE0, 0x10, 0x90, 0x50, 0xD0, 0x30, 0xB0, 0x70, 0xF0,
@@ -1154,7 +1207,7 @@ static inline uint8_t reverse8(uint8_t value)
     /* 64-bit CPU
      * Thanks to the Bit Twiddling Hacks page:
      * http://graphics.stanford.edu/~seander/bithacks.html */
-    return (value * 0x0202020202UL & 0x010884422010UL) % 1023;
+    return (uint8_t)((value * 0x0202020202UL & 0x010884422010UL) % 1023);
   else
     /* 32-bit CPU */
     return bitreverse_table[value];
@@ -1162,37 +1215,26 @@ static inline uint8_t reverse8(uint8_t value)
 
 static inline uint16_t reverse16(uint16_t value)
 {
-  return (bitreverse_table[value & 0xFF] << 8) | bitreverse_table[value >> 8];
+  return (uint16_t)(bitreverse_table[value & 0xFF] << 8) | bitreverse_table[value >> 8];
 }
 
 static inline uint32_t reverse32(uint32_t value)
 {
-  return ((uint32_t)reverse16(value) << 16) | reverse16(value >> 16);
+  return ((uint32_t)reverse16((uint16_t)value) << 16) | reverse16(value >> 16);
 }
 
 static inline uint64_t reverse64(uint64_t value)
 {
-  return ((uint64_t)reverse32(value) << 32) | reverse32(value >> 32);
+  return ((uint64_t)reverse32((uint32_t)value) << 32) | reverse32(value >> 32);
 }
 
-/* Document-method: Fixnum#bitreverse8
- * Document-method: Bignum#bitreverse8
- * Reverse the low 8 bits in this integer.
- *
- * If the receiver is negative, raise `RangeError`.
- *
- * @example
- *   0b01101011.bitreverse8.to_s(2) # => "11010110"
- *
- * @return [Integer]
- */
 static VALUE
 fnum_bitreverse8(VALUE fnum)
 {
   long value = FIX2LONG(fnum);
   if (value < 0)
     rb_raise(rb_eRangeError, "can't reverse bits in a negative number");
-  return LONG2FIX((value & ~0xFFL) | reverse8(value));
+  return LONG2FIX((value & ~0xFFL) | reverse8((uint8_t)value));
 }
 
 static VALUE
@@ -1200,27 +1242,28 @@ bnum_bitreverse8(VALUE bnum)
 {
   if (RBIGNUM_NEGATIVE_P(bnum))
     rb_raise(rb_eRangeError, "can't reverse bits in a negative number");
-  return modify_lo8_in_bignum(bnum, reverse8(*RBIGNUM_DIGITS(bnum)));
+  return modify_lo8_in_bignum(bnum, reverse8((uint8_t)*RBIGNUM_DIGITS(bnum)));
 }
 
-/* Document-method: Fixnum#bitreverse16
- * Document-method: Bignum#bitreverse16
- * Reverse the low 16 bits in this integer.
+/* Document-method: Integer#bitreverse8
+ * Reverse the low 8 bits in this integer.
  *
  * If the receiver is negative, raise `RangeError`.
  *
  * @example
- *   0b0110101100001011.bitreverse16.to_s(2) # => "1101000011010110"
+ *   0b01101011.bitreverse8.to_s(2) # => "11010110"
  *
  * @return [Integer]
  */
+def_int_method(bitreverse8);
+
 static VALUE
 fnum_bitreverse16(VALUE fnum)
 {
   long value = FIX2LONG(fnum);
   if (value < 0)
     rb_raise(rb_eRangeError, "can't reverse bits in a negative number");
-  return LONG2FIX((value & ~0xFFFFL) | reverse16(value));
+  return LONG2FIX((value & ~0xFFFFL) | reverse16((uint16_t)value));
 }
 
 static VALUE
@@ -1228,25 +1271,26 @@ bnum_bitreverse16(VALUE bnum)
 {
   if (RBIGNUM_NEGATIVE_P(bnum))
     rb_raise(rb_eRangeError, "can't reverse bits in a negative number");
-  return modify_lo16_in_bignum(bnum, reverse16(*RBIGNUM_DIGITS(bnum)));
+  return modify_lo16_in_bignum(bnum, reverse16((uint16_t)*RBIGNUM_DIGITS(bnum)));
 }
 
-/* Document-method: Fixnum#bitreverse32
- * Document-method: Bignum#bitreverse32
- * Reverse the low 32 bits in this integer.
+/* Document-method: Integer#bitreverse16
+ * Reverse the low 16 bits in this integer.
  *
  * If the receiver is negative, raise `RangeError`.
  *
  * @example
- *   0x12341234.bitreverse32.to_s(16) # => "2c482c48"
+ *   0b0110101100001011.bitreverse16.to_s(2) # => "1101000011010110"
  *
  * @return [Integer]
  */
+def_int_method(bitreverse16);
+
 static VALUE
 fnum_bitreverse32(VALUE fnum)
 {
   long     value = FIX2LONG(fnum);
-  uint32_t lo32  = value;
+  uint32_t lo32  = (uint32_t)value;
   if (value < 0)
     rb_raise(rb_eRangeError, "can't reverse bits in a negative number");
   else if (SIZEOF_LONG == 4)
@@ -1263,24 +1307,25 @@ bnum_bitreverse32(VALUE bnum)
   return modify_lo32_in_bignum(bnum, reverse32(*RBIGNUM_DIGITS(bnum)));
 }
 
-/* Document-method: Fixnum#bitreverse64
- * Document-method: Bignum#bitreverse64
- * Reverse the low 64 bits in this integer.
+/* Document-method: Integer#bitreverse32
+ * Reverse the low 32 bits in this integer.
  *
  * If the receiver is negative, raise `RangeError`.
  *
  * @example
- *   0xabcd1234abcd1234.bitreverse64.to_s(16) # => "2c48b3d52c48b3d5"
+ *   0x12341234.bitreverse32.to_s(16) # => "2c482c48"
  *
  * @return [Integer]
  */
+def_int_method(bitreverse32);
+
 static VALUE
 fnum_bitreverse64(VALUE fnum)
 {
   long value = FIX2LONG(fnum);
   if (value < 0)
     rb_raise(rb_eRangeError, "can't reverse bits in a negative number");
-  return ULL2NUM(reverse64(value));
+  return ULL2NUM(reverse64((uint64_t)value));
 }
 
 static VALUE
@@ -1291,80 +1336,78 @@ bnum_bitreverse64(VALUE bnum)
   return modify_lo64_in_bignum(bnum, reverse64(load_64_from_bignum(bnum)));
 }
 
-/* Add all `bit-twiddle` methods directly to `Fixnum` and `Bignum`. */
-static VALUE
-bt_add_core_extensions(VALUE self)
+/* Document-method: Integer#bitreverse64
+ * Reverse the low 64 bits in this integer.
+ *
+ * If the receiver is negative, raise `RangeError`.
+ *
+ * @example
+ *   0xabcd1234abcd1234.bitreverse64.to_s(16) # => "2c48b3d52c48b3d5"
+ *
+ * @return [Integer]
+ */
+def_int_method(bitreverse64);
+
+/* Document-class: Integer
+ * Ruby's good old Integer.
+ *
+ * `require "bit-twiddle/core_ext"` before trying to use any of the below methods.
+ */
+/* Document-class: String
+ * Ruby's good old String.
+ *
+ * `require "bit-twiddle/core_ext"` before trying to use any of the below methods.
+ */
+
+/* Add all `bit-twiddle` methods directly to `Integer`. */
+static void init_core_extensions()
 {
-  rb_define_method(rb_cFixnum, "popcount", fnum_popcount, 0);
-  rb_define_method(rb_cBignum, "popcount", bnum_popcount, 0);
+  rb_define_method(rb_cInteger, "popcount", int_popcount, 0);
   rb_define_method(rb_cString, "popcount", str_popcount,  0);
 
-  rb_define_method(rb_cFixnum, "lo_bit",   fnum_lo_bit, 0);
-  rb_define_method(rb_cBignum, "lo_bit",   bnum_lo_bit, 0);
-  rb_define_method(rb_cFixnum, "hi_bit",   fnum_hi_bit, 0);
-  rb_define_method(rb_cBignum, "hi_bit",   bnum_hi_bit, 0);
-
-  rb_define_method(rb_cFixnum, "bswap16",  fnum_bswap16, 0);
-  rb_define_method(rb_cBignum, "bswap16",  bnum_bswap16, 0);
-  rb_define_method(rb_cFixnum, "bswap32",  fnum_bswap32, 0);
-  rb_define_method(rb_cBignum, "bswap32",  bnum_bswap32, 0);
-  rb_define_method(rb_cFixnum, "bswap64",  fnum_bswap64, 0);
-  rb_define_method(rb_cBignum, "bswap64",  bnum_bswap64, 0);
-
-  rb_define_method(rb_cFixnum, "rrot8",    fnum_rrot8,  1);
-  rb_define_method(rb_cBignum, "rrot8",    bnum_rrot8,  1);
-  rb_define_method(rb_cFixnum, "rrot16",   fnum_rrot16, 1);
-  rb_define_method(rb_cBignum, "rrot16",   bnum_rrot16, 1);
-  rb_define_method(rb_cFixnum, "rrot32",   fnum_rrot32, 1);
-  rb_define_method(rb_cBignum, "rrot32",   bnum_rrot32, 1);
-  rb_define_method(rb_cFixnum, "rrot64",   fnum_rrot64, 1);
-  rb_define_method(rb_cBignum, "rrot64",   bnum_rrot64, 1);
-
-  rb_define_method(rb_cFixnum, "lrot8",    fnum_lrot8,  1);
-  rb_define_method(rb_cBignum, "lrot8",    bnum_lrot8,  1);
-  rb_define_method(rb_cFixnum, "lrot16",   fnum_lrot16, 1);
-  rb_define_method(rb_cBignum, "lrot16",   bnum_lrot16, 1);
-  rb_define_method(rb_cFixnum, "lrot32",   fnum_lrot32, 1);
-  rb_define_method(rb_cBignum, "lrot32",   bnum_lrot32, 1);
-  rb_define_method(rb_cFixnum, "lrot64",   fnum_lrot64, 1);
-  rb_define_method(rb_cBignum, "lrot64",   bnum_lrot64, 1);
-
-  rb_define_method(rb_cFixnum, "lshift8",   fnum_lshift8,  1);
-  rb_define_method(rb_cBignum, "lshift8",   bnum_lshift8,  1);
-  rb_define_method(rb_cFixnum, "lshift16",  fnum_lshift16, 1);
-  rb_define_method(rb_cBignum, "lshift16",  bnum_lshift16, 1);
-  rb_define_method(rb_cFixnum, "lshift32",  fnum_lshift32, 1);
-  rb_define_method(rb_cBignum, "lshift32",  bnum_lshift32, 1);
-  rb_define_method(rb_cFixnum, "lshift64",  fnum_lshift64, 1);
-  rb_define_method(rb_cBignum, "lshift64",  bnum_lshift64, 1);
-
-  rb_define_method(rb_cFixnum, "rshift8",   fnum_rshift8,  1);
-  rb_define_method(rb_cBignum, "rshift8",   bnum_rshift8,  1);
-  rb_define_method(rb_cFixnum, "rshift16",  fnum_rshift16, 1);
-  rb_define_method(rb_cBignum, "rshift16",  bnum_rshift16, 1);
-  rb_define_method(rb_cFixnum, "rshift32",  fnum_rshift32, 1);
-  rb_define_method(rb_cBignum, "rshift32",  bnum_rshift32, 1);
-  rb_define_method(rb_cFixnum, "rshift64",  fnum_rshift64, 1);
-  rb_define_method(rb_cBignum, "rshift64",  bnum_rshift64, 1);
-
-  rb_define_method(rb_cFixnum, "arith_rshift8",  fnum_arith_rshift8,  1);
-  rb_define_method(rb_cBignum, "arith_rshift8",  bnum_arith_rshift8,  1);
-  rb_define_method(rb_cFixnum, "arith_rshift16", fnum_arith_rshift16, 1);
-  rb_define_method(rb_cBignum, "arith_rshift16", bnum_arith_rshift16, 1);
-  rb_define_method(rb_cFixnum, "arith_rshift32", fnum_arith_rshift32, 1);
-  rb_define_method(rb_cBignum, "arith_rshift32", bnum_arith_rshift32, 1);
-  rb_define_method(rb_cFixnum, "arith_rshift64", fnum_arith_rshift64, 1);
-  rb_define_method(rb_cBignum, "arith_rshift64", bnum_arith_rshift64, 1);
-
-  rb_define_method(rb_cFixnum, "bitreverse8",  fnum_bitreverse8,  0);
-  rb_define_method(rb_cBignum, "bitreverse8",  bnum_bitreverse8,  0);
-  rb_define_method(rb_cFixnum, "bitreverse16", fnum_bitreverse16, 0);
-  rb_define_method(rb_cBignum, "bitreverse16", bnum_bitreverse16, 0);
-  rb_define_method(rb_cFixnum, "bitreverse32", fnum_bitreverse32, 0);
-  rb_define_method(rb_cBignum, "bitreverse32", bnum_bitreverse32, 0);
-  rb_define_method(rb_cFixnum, "bitreverse64", fnum_bitreverse64, 0);
-  rb_define_method(rb_cBignum, "bitreverse64", bnum_bitreverse64, 0);
+  rb_define_method(rb_cInteger, "lo_bit",   int_lo_bit, 0);
+  rb_define_method(rb_cInteger, "hi_bit",   int_hi_bit, 0);
+
+  rb_define_method(rb_cInteger, "bswap16",  int_bswap16, 0);
+  rb_define_method(rb_cInteger, "bswap32",  int_bswap32, 0);
+  rb_define_method(rb_cInteger, "bswap64",  int_bswap64, 0);
+
+  rb_define_method(rb_cInteger, "rrot8",    int_rrot8,  1);
+  rb_define_method(rb_cInteger, "rrot16",   int_rrot16, 1);
+  rb_define_method(rb_cInteger, "rrot32",   int_rrot32, 1);
+  rb_define_method(rb_cInteger, "rrot64",   int_rrot64, 1);
+
+  rb_define_method(rb_cInteger, "lrot8",    int_lrot8,  1);
+  rb_define_method(rb_cInteger, "lrot16",   int_lrot16, 1);
+  rb_define_method(rb_cInteger, "lrot32",   int_lrot32, 1);
+  rb_define_method(rb_cInteger, "lrot64",   int_lrot64, 1);
+
+  rb_define_method(rb_cInteger, "lshift8",   int_lshift8,  1);
+  rb_define_method(rb_cInteger, "lshift16",  int_lshift16, 1);
+  rb_define_method(rb_cInteger, "lshift32",  int_lshift32, 1);
+  rb_define_method(rb_cInteger, "lshift64",  int_lshift64, 1);
+
+  rb_define_method(rb_cInteger, "rshift8",   int_rshift8,  1);
+  rb_define_method(rb_cInteger, "rshift16",  int_rshift16, 1);
+  rb_define_method(rb_cInteger, "rshift32",  int_rshift32, 1);
+  rb_define_method(rb_cInteger, "rshift64",  int_rshift64, 1);
 
+  rb_define_method(rb_cInteger, "arith_rshift8",  int_arith_rshift8,  1);
+  rb_define_method(rb_cInteger, "arith_rshift16", int_arith_rshift16, 1);
+  rb_define_method(rb_cInteger, "arith_rshift32", int_arith_rshift32, 1);
+  rb_define_method(rb_cInteger, "arith_rshift64", int_arith_rshift64, 1);
+
+  rb_define_method(rb_cInteger, "bitreverse8",  int_bitreverse8,  0);
+  rb_define_method(rb_cInteger, "bitreverse16", int_bitreverse16, 0);
+  rb_define_method(rb_cInteger, "bitreverse32", int_bitreverse32, 0);
+  rb_define_method(rb_cInteger, "bitreverse64", int_bitreverse64, 0);
+}
+
+static VALUE
+bt_add_core_extensions(VALUE self)
+{
+  /* this is so Yardoc can find method definitions */
+  init_core_extensions();
   return Qnil;
 }
 
@@ -1421,21 +1464,6 @@ def_wrapper(bitreverse16);
 def_wrapper(bitreverse32);
 def_wrapper(bitreverse64);
 
-/* Document-class: Fixnum
- * Ruby's good old Fixnum.
- *
- * `require "bit-twiddle/core_ext"` before trying to use any of the below methods.
- */
-/* Document-class: Bignum
- * Ruby's good old Bignum.
- *
- * `require "bit-twiddle/core_ext"` before trying to use any of the below methods.
- */
-/* Document-class: String
- * Ruby's good old String.
- *
- * `require "bit-twiddle/core_ext"` before trying to use any of the below methods.
- */
 void Init_bit_twiddle(void)
 {
   VALUE rb_mBitTwiddle = rb_define_module("BitTwiddle");
@@ -1450,7 +1478,7 @@ void Init_bit_twiddle(void)
    * If `int` is negative, raise `RangeError`.
    *
    * @param int [Integer] The integer to operate on
-   * @return [Fixnum]
+   * @return [Integer]
    */
   rb_define_singleton_method(rb_mBitTwiddle, "popcount", bt_popcount, 1);
   /* Return the index of the lowest 1 bit, where the least-significant bit is index 1.
@@ -1462,7 +1490,7 @@ void Init_bit_twiddle(void)
    * If `int` is negative, raise `RangeError`.
    *
    * @param int [Integer] The integer to operate on
-   * @return [Fixnum]
+   * @return [Integer]
    */
   rb_define_singleton_method(rb_mBitTwiddle, "lo_bit",   bt_lo_bit,   1);
   /* Return the index of the highest 1 bit, where the least-significant bit is index 1.
@@ -1474,7 +1502,7 @@ void Init_bit_twiddle(void)
    * If `int` is negative, raise `RangeError`.
    *
    * @param int [Integer] The integer to operate on
-   * @return [Fixnum]
+   * @return [Integer]
    */
   rb_define_singleton_method(rb_mBitTwiddle, "hi_bit",   bt_hi_bit,   1);
   /* Reverse the least-significant and second least-significant bytes of `int`.
@@ -1848,79 +1876,4 @@ void Init_bit_twiddle(void)
    * @return [Integer]
    */
   rb_define_singleton_method(rb_mBitTwiddle, "bitreverse64", bt_bitreverse64, 1);
-
-#if 0
-  /* The following definitions are executed only on BitTwiddle.add_core_extensions
-   * This is a hack for Yardoc -- so Yardoc can find them: */
-
-   rb_define_method(rb_cFixnum, "popcount", fnum_popcount, 0);
-   rb_define_method(rb_cBignum, "popcount", bnum_popcount, 0);
-   rb_define_method(rb_cString, "popcount", str_popcount,  0);
-
-   rb_define_method(rb_cFixnum, "lo_bit",   fnum_lo_bit, 0);
-   rb_define_method(rb_cBignum, "lo_bit",   bnum_lo_bit, 0);
-   rb_define_method(rb_cFixnum, "hi_bit",   fnum_hi_bit, 0);
-   rb_define_method(rb_cBignum, "hi_bit",   bnum_hi_bit, 0);
-
-   rb_define_method(rb_cFixnum, "bswap16", fnum_bswap16, 0);
-   rb_define_method(rb_cBignum, "bswap16", bnum_bswap16, 0);
-   rb_define_method(rb_cFixnum, "bswap32", fnum_bswap32, 0);
-   rb_define_method(rb_cBignum, "bswap32", bnum_bswap32, 0);
-   rb_define_method(rb_cFixnum, "bswap64", fnum_bswap64, 0);
-   rb_define_method(rb_cBignum, "bswap64", bnum_bswap64, 0);
-
-   rb_define_method(rb_cFixnum, "rrot8",  fnum_rrot8,  1);
-   rb_define_method(rb_cBignum, "rrot8",  bnum_rrot8,  1);
-   rb_define_method(rb_cFixnum, "rrot16", fnum_rrot16, 1);
-   rb_define_method(rb_cBignum, "rrot16", bnum_rrot16, 1);
-   rb_define_method(rb_cFixnum, "rrot32", fnum_rrot32, 1);
-   rb_define_method(rb_cBignum, "rrot32", bnum_rrot32, 1);
-   rb_define_method(rb_cFixnum, "rrot64", fnum_rrot64, 1);
-   rb_define_method(rb_cBignum, "rrot64", bnum_rrot64, 1);
-
-   rb_define_method(rb_cFixnum, "lrot8",  fnum_lrot8,  1);
-   rb_define_method(rb_cBignum, "lrot8",  bnum_lrot8,  1);
-   rb_define_method(rb_cFixnum, "lrot16", fnum_lrot16, 1);
-   rb_define_method(rb_cBignum, "lrot16", bnum_lrot16, 1);
-   rb_define_method(rb_cFixnum, "lrot32", fnum_lrot32, 1);
-   rb_define_method(rb_cBignum, "lrot32", bnum_lrot32, 1);
-   rb_define_method(rb_cFixnum, "lrot64", fnum_lrot64, 1);
-   rb_define_method(rb_cBignum, "lrot64", bnum_lrot64, 1);
-
-   rb_define_method(rb_cFixnum, "lshift8",   fnum_lshift8,  1);
-   rb_define_method(rb_cBignum, "lshift8",   bnum_lshift8,  1);
-   rb_define_method(rb_cFixnum, "lshift16",  fnum_lshift16, 1);
-   rb_define_method(rb_cBignum, "lshift16",  bnum_lshift16, 1);
-   rb_define_method(rb_cFixnum, "lshift32",  fnum_lshift32, 1);
-   rb_define_method(rb_cBignum, "lshift32",  bnum_lshift32, 1);
-   rb_define_method(rb_cFixnum, "lshift64",  fnum_lshift64, 1);
-   rb_define_method(rb_cBignum, "lshift64",  bnum_lshift64, 1);
-
-   rb_define_method(rb_cFixnum, "rshift8",   fnum_rshift8,  1);
-   rb_define_method(rb_cBignum, "rshift8",   bnum_rshift8,  1);
-   rb_define_method(rb_cFixnum, "rshift16",  fnum_rshift16, 1);
-   rb_define_method(rb_cBignum, "rshift16",  bnum_rshift16, 1);
-   rb_define_method(rb_cFixnum, "rshift32",  fnum_rshift32, 1);
-   rb_define_method(rb_cBignum, "rshift32",  bnum_rshift32, 1);
-   rb_define_method(rb_cFixnum, "rshift64",  fnum_rshift64, 1);
-   rb_define_method(rb_cBignum, "rshift64",  bnum_rshift64, 1);
-
-   rb_define_method(rb_cFixnum, "arith_rshift8",  fnum_arith_rshift8,  1);
-   rb_define_method(rb_cBignum, "arith_rshift8",  bnum_arith_rshift8,  1);
-   rb_define_method(rb_cFixnum, "arith_rshift16", fnum_arith_rshift16, 1);
-   rb_define_method(rb_cBignum, "arith_rshift16", bnum_arith_rshift16, 1);
-   rb_define_method(rb_cFixnum, "arith_rshift32", fnum_arith_rshift32, 1);
-   rb_define_method(rb_cBignum, "arith_rshift32", bnum_arith_rshift32, 1);
-   rb_define_method(rb_cFixnum, "arith_rshift64", fnum_arith_rshift64, 1);
-   rb_define_method(rb_cBignum, "arith_rshift64", bnum_arith_rshift64, 1);
-
-   rb_define_method(rb_cFixnum, "bitreverse8",  fnum_bitreverse8,  0);
-   rb_define_method(rb_cBignum, "bitreverse8",  bnum_bitreverse8,  0);
-   rb_define_method(rb_cFixnum, "bitreverse16", fnum_bitreverse16, 0);
-   rb_define_method(rb_cBignum, "bitreverse16", bnum_bitreverse16, 0);
-   rb_define_method(rb_cFixnum, "bitreverse32", fnum_bitreverse32, 0);
-   rb_define_method(rb_cBignum, "bitreverse32", bnum_bitreverse32, 0);
-   rb_define_method(rb_cFixnum, "bitreverse64", fnum_bitreverse64, 0);
-   rb_define_method(rb_cBignum, "bitreverse64", bnum_bitreverse64, 0);
-#endif
 }