0
@@ -423,7 +423,7 @@ namespace rubinius {
0
     NMP;
0
     int shift = bits->n2i();
0
     if(shift < 0) {
0
-      return right_shift(state, bits);
0
+      return right_shift(state, Object::i2n(-bits->n2i()));
0
     }
0
     mp_int *a = MP(this);
0
 
0
@@ -436,7 +436,7 @@ namespace rubinius {
0
     NMP;
0
     int shift = bits->n2i();
0
     if(shift < 0) {
0
-      return left_shift(state, bits);
0
+      return left_shift(state, Object::i2n(-bits->n2i()));
0
     }
0
 
0
     mp_int * a = MP(this);
0
@@ -528,56 +528,142 @@ namespace rubinius {
0
     return Float::coerce(state, this)->compare(state, b);
0
   }
0
 
0
-  OBJECT Bignum::gt(STATE, INTEGER b) {
0
-    if(kind_of<Fixnum>(b)) {
0
-      b = Bignum::create(state, b->n2i());
0
+  OBJECT Bignum::gt(STATE, FIXNUM b) {
0
+    native_int bi = b->n2i();
0
+
0
+    mp_int* a = MP(this);
0
+    if(bi < 0) {
0
+      mp_int n;
0
+      mp_init(&n);
0
+      mp_copy(a, &n);
0
+      mp_neg(&n, &n);
0
+
0
+      if(mp_cmp_d(&n, -bi) == MP_LT) {
0
+        return Qtrue;
0
+      }
0
+      return Qfalse;
0
+    } else {
0
+      if(mp_cmp_d(a, bi) == MP_GT) {
0
+        return Qtrue;
0
+      }
0
+      return Qfalse;
0
     }
0
+  }
0
 
0
+  OBJECT Bignum::gt(STATE, Bignum* b) {
0
     if(mp_cmp(MP(this), MP(b)) == MP_GT) {
0
       return Qtrue;
0
     }
0
     return Qfalse;
0
   }
0
 
0
-  OBJECT Bignum::ge(STATE, INTEGER b) {
0
-    int r;
0
+  OBJECT Bignum::gt(STATE, Float* b) {
0
+    return Float::coerce(state, this)->gt(state, b);
0
+  }
0
+
0
+  OBJECT Bignum::ge(STATE, FIXNUM b) {
0
+    native_int bi = b->n2i();
0
 
0
-    if(kind_of<Fixnum>(b)) {
0
-      b = Bignum::create(state, b->n2i());
0
+    mp_int* a = MP(this);
0
+    if(bi < 0) {
0
+      mp_int n;
0
+      mp_init(&n);
0
+      mp_copy(a, &n);
0
+      mp_neg(&n, &n);
0
+      int r = mp_cmp_d(&n, -bi);
0
+      if(r == MP_EQ || r == MP_LT) {
0
+        return Qtrue;
0
+      }
0
+      return Qfalse;
0
+    } else {
0
+      int r = mp_cmp_d(a, bi);
0
+      if(r == MP_EQ || r == MP_GT) {
0
+        return Qtrue;
0
+      }
0
+      return Qfalse;
0
     }
0
+  }
0
+
0
+  OBJECT Bignum::ge(STATE, Float* b) {
0
+    return Float::coerce(state, this)->ge(state, b);
0
+  }
0
 
0
-    r = mp_cmp(MP(this), MP(b));
0
+  OBJECT Bignum::ge(STATE, Bignum* b) {
0
+    int r = mp_cmp(MP(this), MP(b));
0
     if(r == MP_GT || r == MP_EQ) {
0
       return Qtrue;
0
     }
0
     return Qfalse;
0
   }
0
 
0
-  OBJECT Bignum::lt(STATE, INTEGER b) {
0
-    if(kind_of<Fixnum>(b)) {
0
-      b = Bignum::create(state, b->n2i());
0
+  OBJECT Bignum::lt(STATE, FIXNUM b) {
0
+    native_int bi = b->n2i();
0
+
0
+    mp_int* a = MP(this);
0
+    if(bi < 0) {
0
+      mp_int n;
0
+      mp_init(&n);
0
+      mp_copy(a, &n);
0
+      mp_neg(&n, &n);
0
+
0
+      if(mp_cmp_d(&n, -bi) == MP_GT) {
0
+        return Qtrue;
0
+      }
0
+      return Qfalse;
0
+    } else {
0
+      if(mp_cmp_d(a, bi) == MP_LT) {
0
+        return Qtrue;
0
+      }
0
+      return Qfalse;
0
     }
0
+  }
0
 
0
+  OBJECT Bignum::lt(STATE, Bignum* b) {
0
     if(mp_cmp(MP(this), MP(b)) == MP_LT) {
0
       return Qtrue;
0
     }
0
     return Qfalse;
0
   }
0
 
0
-  OBJECT Bignum::le(STATE, INTEGER b) {
0
-    int r;
0
+  OBJECT Bignum::lt(STATE, Float* b) {
0
+    return Float::coerce(state, this)->lt(state, b);
0
+  }
0
+
0
+  OBJECT Bignum::le(STATE, FIXNUM b) {
0
+    native_int bi = b->n2i();
0
 
0
-    if(kind_of<Fixnum>(b)) {
0
-      b = Bignum::create(state, b->n2i());
0
+    mp_int* a = MP(this);
0
+    if(bi < 0) {
0
+      mp_int n;
0
+      mp_init(&n);
0
+      mp_copy(a, &n);
0
+      mp_neg(&n, &n);
0
+      int r = mp_cmp_d(&n, -bi);
0
+      if(r == MP_EQ || r == MP_GT) {
0
+        return Qtrue;
0
+      }
0
+      return Qfalse;
0
+    } else {
0
+      int r = mp_cmp_d(a, bi);
0
+      if(r == MP_EQ || r == MP_LT) {
0
+        return Qtrue;
0
+      }
0
+      return Qfalse;
0
     }
0
+  }
0
 
0
-    r = mp_cmp(MP(this), MP(b));
0
+  OBJECT Bignum::le(STATE, Bignum* b) {
0
+    int r = mp_cmp(MP(this), MP(b));
0
     if(r == MP_LT || r == MP_EQ) {
0
       return Qtrue;
0
     }
0
     return Qfalse;
0
   }
0
 
0
+  OBJECT Bignum::le(STATE, Float* b) {
0
+    return Float::coerce(state, this)->le(state, b);
0
+  }
0
+
0
   int Bignum::to_int(STATE) {
0
     if(MP(this)->sign == MP_NEG) {
0
       return -mp_get_int(MP(this));

0
@@ -108,10 +108,33 @@ namespace rubinius {
0
     // Ruby.primitive :bignum_right_shift
0
     INTEGER right_shift(STATE, INTEGER bits);
0
 
0
-    OBJECT gt(STATE, INTEGER b);
0
-    OBJECT ge(STATE, INTEGER b);
0
-    OBJECT lt(STATE, INTEGER b);
0
-    OBJECT le(STATE, INTEGER b);
0
+    // Ruby.primitive! :bignum_gt
0
+    OBJECT gt(STATE, FIXNUM b);
0
+    // Ruby.primitive! :bignum_gt
0
+    OBJECT gt(STATE, Bignum* b);
0
+    // Ruby.primitive! :bignum_gt
0
+    OBJECT gt(STATE, Float* b);
0
+
0
+    // Ruby.primitive! :bignum_ge
0
+    OBJECT ge(STATE, FIXNUM b);
0
+    // Ruby.primitive! :bignum_ge
0
+    OBJECT ge(STATE, Bignum* b);
0
+    // Ruby.primitive! :bignum_ge
0
+    OBJECT ge(STATE, Float* b);
0
+
0
+    // Ruby.primitive! :bignum_lt
0
+    OBJECT lt(STATE, FIXNUM b);
0
+    // Ruby.primitive! :bignum_lt
0
+    OBJECT lt(STATE, Bignum* b);
0
+    // Ruby.primitive! :bignum_lt
0
+    OBJECT lt(STATE, Float* b);
0
+
0
+    // Ruby.primitive! :bignum_le
0
+    OBJECT le(STATE, FIXNUM b);
0
+    // Ruby.primitive! :bignum_le
0
+    OBJECT le(STATE, Bignum* b);
0
+    // Ruby.primitive! :bignum_le
0
+    OBJECT le(STATE, Float* b);
0
 
0
     int    to_int(STATE);
0
     int    to_i(STATE);

0
@@ -232,6 +232,9 @@ class TestBignum : public CxxTest::TestSuite {
0
     INTEGER shifted = b1->left_shift(state, Object::i2n(3));
0
     check_bignum(shifted, "17179869176");
0
 
0
+    shifted = b1->left_shift(state, Object::i2n(-3));
0
+    check_bignum(shifted, "268435455");
0
+
0
     Bignum* nbn1 = Bignum::create(state, (native_int)-2147483647);
0
     shifted = nbn1->left_shift(state, Object::i2n(3));
0
     check_bignum(shifted, "-17179869176");
0
@@ -241,6 +244,9 @@ class TestBignum : public CxxTest::TestSuite {
0
     INTEGER shifted = b1->right_shift(state, Object::i2n(3));
0
     check_bignum(shifted, "268435455");
0
 
0
+    shifted = b1->right_shift(state, Object::i2n(-3));
0
+    check_bignum(shifted, "17179869176");
0
+
0
     shifted = b1->right_shift(state, Object::i2n(1048576));
0
     check_bignum(shifted, "0");
0
 
0
@@ -359,6 +365,14 @@ class TestBignum : public CxxTest::TestSuite {
0
     TS_ASSERT_EQUALS(b2->gt(state, b1), Qfalse);
0
     TS_ASSERT_EQUALS(b1->gt(state, b1), Qfalse);
0
     TS_ASSERT_EQUALS(b1->gt(state, two), Qtrue);
0
+
0
+    TS_ASSERT_EQUALS(Bignum::create(state, -3)->gt(state, Object::i2n(-3)), Qfalse);
0
+    TS_ASSERT_EQUALS(Bignum::create(state, -3)->gt(state, Object::i2n(-2)), Qfalse);
0
+    TS_ASSERT_EQUALS(Bignum::create(state, -3)->gt(state, Object::i2n(-4)), Qtrue);
0
+
0
+    TS_ASSERT_EQUALS(Bignum::create(state, -3)->gt(state, Float::create(state, -3.0)), Qfalse);
0
+    TS_ASSERT_EQUALS(Bignum::create(state, -3)->gt(state, Float::create(state, -2.9)), Qfalse);
0
+    TS_ASSERT_EQUALS(Bignum::create(state, -3)->gt(state, Float::create(state, -3.1)), Qtrue);
0
   }
0
 
0
   void test_ge() {
0
@@ -366,6 +380,14 @@ class TestBignum : public CxxTest::TestSuite {
0
     TS_ASSERT_EQUALS(b2->ge(state, b1), Qfalse);
0
     TS_ASSERT_EQUALS(b1->ge(state, b1), Qtrue);
0
     TS_ASSERT_EQUALS(b1->ge(state, two), Qtrue);
0
+
0
+    TS_ASSERT_EQUALS(Bignum::create(state, -3)->ge(state, Object::i2n(-3)), Qtrue);
0
+    TS_ASSERT_EQUALS(Bignum::create(state, -3)->ge(state, Object::i2n(-2)), Qfalse);
0
+    TS_ASSERT_EQUALS(Bignum::create(state, -3)->ge(state, Object::i2n(-4)), Qtrue);
0
+
0
+    TS_ASSERT_EQUALS(Bignum::create(state, -3)->ge(state, Float::create(state, -3.0)), Qtrue);
0
+    TS_ASSERT_EQUALS(Bignum::create(state, -3)->ge(state, Float::create(state, -2.9)), Qfalse);
0
+    TS_ASSERT_EQUALS(Bignum::create(state, -3)->ge(state, Float::create(state, -3.1)), Qtrue);
0
   }
0
 
0
   void test_lt() {
0
@@ -373,6 +395,14 @@ class TestBignum : public CxxTest::TestSuite {
0
     TS_ASSERT_EQUALS(b2->lt(state, b1), Qtrue);
0
     TS_ASSERT_EQUALS(b1->lt(state, b1), Qfalse);
0
     TS_ASSERT_EQUALS(b1->lt(state, two), Qfalse);
0
+
0
+    TS_ASSERT_EQUALS(Bignum::create(state, -3)->lt(state, Object::i2n(-3)), Qfalse);
0
+    TS_ASSERT_EQUALS(Bignum::create(state, -3)->lt(state, Object::i2n(-2)), Qtrue);
0
+    TS_ASSERT_EQUALS(Bignum::create(state, -3)->lt(state, Object::i2n(-4)), Qfalse);
0
+
0
+    TS_ASSERT_EQUALS(Bignum::create(state, -3)->lt(state, Float::create(state, -3.0)), Qfalse);
0
+    TS_ASSERT_EQUALS(Bignum::create(state, -3)->lt(state, Float::create(state, -2.9)), Qtrue);
0
+    TS_ASSERT_EQUALS(Bignum::create(state, -3)->lt(state, Float::create(state, -3.1)), Qfalse);
0
   }
0
 
0
   void test_le() {
0
@@ -380,6 +410,14 @@ class TestBignum : public CxxTest::TestSuite {
0
     TS_ASSERT_EQUALS(b2->le(state, b1), Qtrue);
0
     TS_ASSERT_EQUALS(b1->le(state, b1), Qtrue);
0
     TS_ASSERT_EQUALS(b1->le(state, two), Qfalse);
0
+
0
+    TS_ASSERT_EQUALS(Bignum::create(state, -3)->le(state, Object::i2n(-3)), Qtrue);
0
+    TS_ASSERT_EQUALS(Bignum::create(state, -3)->le(state, Object::i2n(-2)), Qtrue);
0
+    TS_ASSERT_EQUALS(Bignum::create(state, -3)->le(state, Object::i2n(-4)), Qfalse);
0
+
0
+    TS_ASSERT_EQUALS(Bignum::create(state, -3)->le(state, Float::create(state, -3.0)), Qtrue);
0
+    TS_ASSERT_EQUALS(Bignum::create(state, -3)->le(state, Float::create(state, -2.9)), Qtrue);
0
+    TS_ASSERT_EQUALS(Bignum::create(state, -3)->le(state, Float::create(state, -3.1)), Qfalse);
0
   }
0
 
0
   void test_from_double() {