integer.c: Implement Integer#digits

Author: mrkn

numeric.c

@@ -4475,6 +4475,111 @@ rb_int_bit_length(VALUE num)
     return Qnil;
 }
 
+/*
+ *  Document-method: Integer#digits(base=10)
+ *  call-seq:
+ *     int.digits       -> [int]
+ *     int.digits(base) -> [int]
+ *
+ *  Returns the array including the digits extracted by place-value notation
+ *  with radix +base+ of +int+.
+ *
+ *  +base+ should be greater than or equal to 2.
+ *
+ *     12345.digits      #=> [5, 4, 3, 2, 1]
+ *     12345.digits(7)   #=> [4, 6, 6, 0, 5]
+ *     -12345.digits(7)  #=> [4, 6, 6, 0, 5]
+ *     12345.digits(100) #=> [45, 23, 1]
+ *
+ */
+
+static VALUE
+rb_fix_digits(VALUE fix, long base)
+{
+    VALUE digits;
+    long x = FIX2LONG(fix);
+
+    if (base < 2)
+        rb_raise(rb_eArgError, "invalid radix %ld", base);
+
+    if (x == 0) {
+        return rb_ary_new_from_args(1, INT2FIX(0));
+    }
+    else if (x < 0)
+        x = -x;
+
+    digits = rb_ary_new();
+    while (x > 0) {
+        long q = x % base;
+        rb_ary_push(digits, LONG2NUM(q));
+        x /= base;
+    }
+
+    return digits;
+}
+
+static VALUE
+rb_int_digits_bigbase(VALUE num, VALUE base)
+{
+    VALUE digits;
+
+    if (RB_TYPE_P(base, T_BIGNUM)) {
+        base = rb_big_norm(base);
+    }
+
+    if (FIXNUM_P(base) && FIX2LONG(base) < 2)
+        rb_raise(rb_eArgError, "invalid radix %ld", FIX2LONG(base));
+    else if (RB_TYPE_P(base, T_BIGNUM) && BIGNUM_NEGATIVE_P(base))
+        rb_raise(rb_eArgError, "negative radix");
+
+    if (FIXNUM_P(base) && FIXNUM_P(num))
+        return rb_fix_digits(num, FIX2LONG(base));
+
+    if (FIXNUM_P(num)) {
+        long x = FIX2LONG(num);
+        if (x < 0) x = -x;
+        return rb_ary_new_from_args(1, LONG2FIX(x));
+    }
+
+    digits = rb_ary_new();
+    while (!FIXNUM_P(num) || FIX2LONG(num) > 0) {
+        VALUE rq = int_divmod(num, base);
+
+        rb_ary_push(digits, RARRAY_AREF(rq, 1));
+
+        num = RARRAY_AREF(rq, 0);
+    }
+
+    return digits;
+}
+
+static VALUE
+rb_int_digits(int argc, VALUE *argv, VALUE num)
+{
+    long base;
+
+    if (rb_check_arity(argc, 0, 1)) {
+        if (!RB_INTEGER_TYPE_P(argv[0]))
+            rb_raise(rb_eTypeError, "wrong argument type %s (expected Integer)",
+                     rb_obj_classname(argv[0]));
+        if (RB_TYPE_P(argv[0], T_BIGNUM))
+            return rb_int_digits_bigbase(num, argv[0]);
+
+        base = FIX2LONG(argv[0]);
+        if (base < 2)
+            rb_raise(rb_eArgError, "invalid radix %ld", base);
+    }
+    else
+        base = 10;
+
+    if (FIXNUM_P(num))
+        return rb_fix_digits(num, base);
+    else if (RB_TYPE_P(num, T_BIGNUM))
+        return rb_int_digits_bigbase(num, LONG2FIX(base));
+
+    return Qnil;
+}
+
 /*
  *  Document-method: Integer#upto
  *  call-seq:
@@ -4956,6 +5061,7 @@ Init_Numeric(void)
 
     rb_define_method(rb_cInteger, "size", int_size, 0);
     rb_define_method(rb_cInteger, "bit_length", rb_int_bit_length, 0);
+    rb_define_method(rb_cInteger, "digits", rb_int_digits, -1);
 
     rb_cFixnum = rb_cInteger;
     rb_define_const(rb_cObject, "Fixnum", rb_cInteger);

test/ruby/test_bignum.rb

@@ -737,5 +737,20 @@ def obj.coerce(other)
     end
     assert_equal(T1024 ^ 10, T1024 ^ obj)
   end
+
+  def test_digits
+    assert_equal([90, 78, 56, 34, 12], 1234567890.to_bignum.digits(100))
+    assert_equal([7215, 2413, 6242], T1024P.digits(10_000).first(3))
+    assert_equal([11], 11.digits(T1024P))
+    assert_equal([11], -11.digits(T1024P))
+    assert_equal([T1024P - 1, 1], (T1024P + T1024P - 1).digits(T1024P))
+    assert_raise(ArgumentError) { T1024P.to_bignum.digits(0) }
+    assert_raise(ArgumentError) { T1024P.to_bignum.digits(-1) }
+    assert_raise(ArgumentError) { T1024P.to_bignum.digits(0.to_bignum) }
+    assert_raise(ArgumentError) { T1024P.to_bignum.digits(1.to_bignum) }
+    assert_raise(ArgumentError) { T1024P.to_bignum.digits(-T1024P) }
+    assert_raise(ArgumentError) { 10.digits(0.to_bignum) }
+    assert_raise(ArgumentError) { 10.digits(1.to_bignum) }
+  end
 end
 end

test/ruby/test_integer.rb

@@ -331,4 +331,19 @@ def test_bit_length
       assert_equal(i+1, (n+1).bit_length, "#{n+1}.bit_length")
     }
   end
+
+  def test_digits
+    assert_equal([0], 0.digits)
+    assert_equal([1], 1.digits)
+    assert_equal([1], -1.digits)
+    assert_equal([0, 9, 8, 7, 6, 5, 4, 3, 2, 1], 1234567890.digits)
+    assert_equal([0, 9, 8, 7, 6, 5, 4, 3, 2, 1], -1234567890.digits)
+    assert_equal([90, 78, 56, 34, 12], 1234567890.digits(100))
+    assert_equal([90, 78, 56, 34, 12], -1234567890.digits(100))
+    assert_equal([10, 5, 6, 8, 0, 10, 8, 6, 1], 1234567890.digits(13))
+    assert_equal([10, 5, 6, 8, 0, 10, 8, 6, 1], -1234567890.digits(13))
+    assert_raise(ArgumentError) { 10.digits(0) }
+    assert_raise(ArgumentError) { 10.digits(1) }
+    assert_raise(TypeError) { 10.digits("a") }
+  end
 end