ruby-calc 0.1.0

data/ext/calc/convert.c

@@ -0,0 +1,193 @@
+#include "calc.h"
+
+/* attempt to convert a bignum a long then to Calc::Q using itoq().
+ * NUM2LONG will raise a RangeError if arg doesn't fit in a long */
+static VALUE
+bignum_to_calc_q_via_long(VALUE arg)
+{
+    return wrap_number(itoq(NUM2LONG(arg)));
+}
+
+/* handles exceptions during via_long.  convert the arg to a string, then
+ * Calc::Q using str2q() */
+static VALUE
+bignum_to_calc_q_via_string(VALUE arg, VALUE e)
+{
+    VALUE string;
+
+    if (!rb_obj_is_kind_of(e, rb_eRangeError)) {
+        /* something other than RangeError; re-raise it */
+        rb_exc_raise(e);
+    }
+    string = rb_funcall(arg, rb_intern("to_s"), 0);
+    return wrap_number(str2q(StringValueCStr(string)));
+}
+
+/* convert a Bignum to Calc::Q
+ * first tries to convert via a long; if that raises an exception, convert via
+ * a string */
+static VALUE
+bignum_to_calc_q(VALUE arg)
+{
+    return rb_rescue(&bignum_to_calc_q_via_long, arg, &bignum_to_calc_q_via_string, arg);
+}
+
+/* convert a ruby Rational to a NUMBER*.  Since the denominator/numerator of
+ * the rational number could be too big for long, they are converted to NUMBER*
+ * first.
+ */
+static NUMBER *
+rational_to_number(VALUE arg)
+{
+    NUMBER *qresult, *qnum, *qden;
+
+    qnum = value_to_number(rb_funcall(arg, rb_intern("numerator"), 0), 0);
+    qden = value_to_number(rb_funcall(arg, rb_intern("denominator"), 0), 0);
+    qresult = qqdiv(qnum, qden);
+    qfree(qnum);
+    qfree(qden);
+    return qresult;
+}
+
+/* converts a ruby value into a NUMBER*.  Allowed types:
+ *  - Fixnum
+ *  - Bignum
+ *  - Calc::Q
+ *  - Rational
+ *  - String (using libcalc str2q)
+ *  - Float (will be converted to a Rational first)
+ *
+ * the caller is responsible for freeing the returned number.  storing it in
+ * a Calc::Q is sufficient for the ruby GC to get it.
+ */
+NUMBER *
+value_to_number(VALUE arg, int string_allowed)
+{
+    NUMBER *qresult;
+    VALUE num, tmp;
+
+    if (TYPE(arg) == T_FIXNUM) {
+        qresult = itoq(NUM2LONG(arg));
+    }
+    else if (TYPE(arg) == T_BIGNUM) {
+        num = bignum_to_calc_q(arg);
+        qresult = qlink((NUMBER *) DATA_PTR(num));
+    }
+    else if (CALC_Q_P(arg)) {
+        qresult = qlink((NUMBER *) DATA_PTR(arg));
+    }
+    else if (TYPE(arg) == T_RATIONAL) {
+        qresult = rational_to_number(arg);
+    }
+    else if (TYPE(arg) == T_FLOAT) {
+        tmp = rb_funcall(arg, rb_intern("to_r"), 0);
+        qresult = rational_to_number(tmp);
+    }
+    else if (string_allowed && TYPE(arg) == T_STRING) {
+        qresult = str2q(StringValueCStr(arg));
+        /* libcalc str2q allows a 0 denominator */
+        if (ziszero(qresult->den)) {
+            qfree(qresult);
+            rb_raise(rb_eZeroDivError, "division by zero");
+        }
+    }
+    else {
+        rb_raise(rb_eArgError, "%" PRIsVALUE " (%" PRIsVALUE ") can't be converted to Calc::Q",
+                 arg, rb_obj_class(arg));
+    }
+    return qresult;
+}
+
+/* convert a ruby value into a COMPLEX*.  Allowed types:
+ * - Complex
+ * - Any type allowed by value_to_number (except string).
+ *
+ * libcalc doesn't provide any way to convert a string to a complex number.
+ *
+ * caller is responseible for freeing the returned complex.  storing it in
+ * a Calc::C is sufficient for the ruby GC to get it.
+ */
+COMPLEX *
+value_to_complex(VALUE arg)
+{
+    COMPLEX *cresult;
+    VALUE real, imag;
+
+    if (CALC_C_P(arg)) {
+        cresult = clink((COMPLEX *) DATA_PTR(arg));
+    }
+    else if (TYPE(arg) == T_COMPLEX) {
+        real = rb_funcall(arg, rb_intern("real"), 0);
+        imag = rb_funcall(arg, rb_intern("imag"), 0);
+        cresult = qqtoc(value_to_number(real, 0), value_to_number(imag, 0));
+    }
+    else if (CALC_Q_P(arg)) {
+        cresult = qqtoc(DATA_PTR(arg), &_qzero_);
+    }
+    else if (FIXNUM_P(arg) || TYPE(arg) == T_BIGNUM || TYPE(arg) == T_RATIONAL
+             || TYPE(arg) == T_FLOAT) {
+        cresult = qqtoc(value_to_number(arg, 0), &_qzero_);
+    }
+    else {
+        rb_raise(rb_eArgError, "%" PRIsVALUE " (%" PRIsVALUE ") can't be converted to Calc::C",
+                 arg, rb_obj_class(arg));
+    }
+
+    return cresult;
+}
+
+/* get a long out of a ruby VALUE.  if it is fractional, or too big to be
+ * represented, raises an error */
+long
+value_to_long(VALUE v)
+{
+    long l;
+    NUMBER *q;
+
+    if (FIXNUM_P(v)) {
+        return FIX2LONG(v);
+    }
+    q = value_to_number(v, 0);
+    if (qisfrac(q)) {
+        qfree(q);
+        rb_raise(rb_eTypeError, "Fraction (%" PRIsVALUE ") can't be converted to long", v);
+    }
+    if (zgtmaxlong(q->num)) {
+        qfree(q);
+        rb_raise(rb_eTypeError, "%" PRIsVALUE " is too large to convert to long", v);
+    }
+    l = qtoi(q);
+    qfree(q);
+    return l;
+}
+
+/* wrap a COMPLEX* into a ruby VALUE of class Calc::C (if there is a non-zero
+ * imaginary part) or Calc::Q (otherwise).
+ */
+VALUE
+wrap_complex(COMPLEX * c)
+{
+    VALUE result;
+
+    if (cisreal(c)) {
+        result = cq_new();
+        DATA_PTR(result) = qlink(c->real);
+        comfree(c);
+    }
+    else {
+        result = cc_new();
+        DATA_PTR(result) = c;
+    }
+    return result;
+}
+
+/* wrap a NUMBER* into a ruby VALUE of class Calc::Q. */
+VALUE
+wrap_number(NUMBER * n)
+{
+    VALUE result;
+
+    result = cq_new();
+    DATA_PTR(result) = n;
+    return result;
+}

data/ext/calc/extconf.rb

@@ -0,0 +1,29 @@
+require "mkmf"
+
+unless find_header("calc/cmath.h")
+  abort "calc/cmath.h is missing, please install calc development headers"
+end
+
+if RUBY_PLATFORM =~ /darwin/
+  # on macosx, detection of libcustcalc doesn't work.  just assume it is
+  # required.
+  $libs = append_library($libs, "custcalc")
+  unless have_library("calc", "libcalc_call_me_first")
+    abort "can't find libcalc, please install calc"
+  end
+  # on macosx, i can't get the linker to use our version of math_error().
+  # this macro uses an alternative error hander based on setjmp/longjmp.
+  $defs << "-DJUMP_ON_MATH_ERROR"
+else
+  # try libcalc by itself first - this will work if libcustcalc wasn't made,
+  # but will fail if it was
+  unless have_library("calc", "libcalc_call_me_first")
+    puts "trying again with -lcustcalc"
+    $libs = append_library($libs, "custcalc")
+    unless have_library("calc", "libcalc_call_me_first")
+      abort "can't find libcalc, please install calc"
+    end
+  end
+end
+
+create_makefile("calc/calc")

data/ext/calc/math_error.c

@@ -0,0 +1,72 @@
+#include <stdarg.h>
+#include "calc.h"
+
+/* Document-class: Calc::MathError
+ *
+ * Exceptions of this class are raised whenever a libcalc function encounters
+ * an error.
+ */
+VALUE e_MathError;
+
+#ifdef JUMP_ON_MATH_ERROR
+
+/* this is an alternative error handler used on systems when we can't tell
+ * the linker to use our version of math_error.  uses setjmp to tell libcalc's
+ * default math_error to return here instead of exiting.  a ruby exception
+ * is raised if the longjmp is made.
+ *
+ * the downside of this is that each c function which calls libcalc methods
+ * that /could/ call math_error needs to call this first.  apart from the small
+ * performance hit, this is extra unwanted code in many functions.  if I
+ * could find a way to tell the macosx linker to replace math_error() like
+ * it works on Linux, this method would not be necessary.
+ *
+ * unfortunately it is not possible to call this once (say, during definition
+ * of Calc::MathError) and except later C functions to be able to jump into it.
+ * crossing the ruby/C boundary like that causes crashes or hangs.
+ *
+ * on other systems, this function name is #defined to nothing.
+ */
+
+void
+setup_math_error(void)
+{
+    int error;
+    VALUE mesg;
+
+    if ((error = setjmp(calc_matherr_jmpbuf)) != 0) {
+        mesg = rb_str_new2(calc_err_msg);
+        reinitialize();
+        rb_exc_raise(rb_exc_new3(e_MathError, mesg));
+    }
+    calc_use_matherr_jmpbuf = 1;
+}
+
+#else
+
+/* provide our own version of math_error which raises a ruby exception
+ * instead of exiting.
+ *
+ * ideally this would call rb_raise, but you can't just pass a varargs list to
+ * another function (see http://c-faq.com/varargs/handoff.html).
+ * so this just does what rb_raise does internally.
+ */
+void
+math_error(char *fmt, ...)
+{
+    va_list args;
+    VALUE mesg;
+
+    va_start(args, fmt);
+    mesg = rb_vsprintf(fmt, args);
+    va_end(args);
+    rb_exc_raise(rb_exc_new3(e_MathError, mesg));
+}
+
+#endif                          /* JUMP_ON_MATH_ERROR */
+
+void
+define_calc_math_error(VALUE m)
+{
+    e_MathError = rb_define_class_under(m, "MathError", rb_eStandardError);
+}

data/ext/calc/numeric.c

@@ -0,0 +1,623 @@
+#include <calc.h>
+
+/* Document-class: Calc::Numeric
+ *
+ * Parent class to the libraries numeric classes (Calc::Q and Calc::C)
+ */
+VALUE cNumeric;
+
+/* similar to trans_function, but for ln and log; the rational versions (qln,
+ * qlog) return wrong results for self < 0, so call the complex version in that
+ * case.
+ * ref: f_ln() and f_log() in calc's func.c
+ */
+static VALUE
+log_function(int argc, VALUE * argv, VALUE self, NUMBER * (fq) (NUMBER *, NUMBER *),
+             COMPLEX * (*fc) (COMPLEX *, NUMBER *))
+{
+    VALUE epsilon, result;
+    NUMBER *qepsilon, *qself;
+    COMPLEX *cself;
+    setup_math_error();
+
+    if (rb_scan_args(argc, argv, "01", &epsilon) == 0) {
+        qepsilon = NULL;
+    }
+    else {
+        qepsilon = value_to_number(epsilon, 1);
+    }
+    if (CALC_Q_P(self)) {
+        qself = DATA_PTR(self);
+        if (!qisneg(qself) && !qiszero(qself)) {
+            result = cq_new();
+            DATA_PTR(result) = (*fq) (qself, qepsilon ? qepsilon : conf->epsilon);
+        }
+        else {
+            cself = comalloc();
+            qfree(cself->real);
+            cself->real = qlink(qself);
+            result = wrap_complex((*fc) (cself, qepsilon ? qepsilon : conf->epsilon));
+            comfree(cself);
+        }
+    }
+    else if (CALC_C_P(self)) {
+        cself = DATA_PTR(self);
+        result = wrap_complex((*fc) (cself, qepsilon ? qepsilon : conf->epsilon));
+    }
+    else {
+        rb_raise(e_MathError, "log_function called with invalid receiver");
+    }
+    if (qepsilon) {
+        qfree(qepsilon);
+    }
+    return result;
+}
+
+static VALUE
+shift(VALUE self, VALUE other, BOOL rightshift)
+{
+    NUMBER *qother;
+    long n;
+    setup_math_error();
+
+    qother = value_to_number(other, 0);
+    if (qisfrac(qother)) {
+        qfree(qother);
+        rb_raise(rb_eArgError, "shift by non-integer");
+    }
+    if (zge31b(qother->num)) {
+        qfree(qother);
+        rb_raise(rb_eArgError, "shift by too many bits");
+    }
+    n = qtoi(qother);
+    qfree(qother);
+    if (rightshift) {
+        n = -n;
+    }
+    if (CALC_Q_P(self)) {
+        return wrap_number(qshift(DATA_PTR(self), n));
+    }
+    return wrap_complex(c_shift(DATA_PTR(self), n));
+}
+
+
+NUMBER *
+sign_of_int(int r)
+{
+    return (r > 0) ? qlink(&_qone_) : (r < 0) ? qlink(&_qnegone_) : qlink(&_qzero_);
+}
+
+/* Left shift an integer by a given number of bits.  This multiplies the number
+ * by the appropriate power of 2.
+ *
+ * @param n [Integer] number of bits to shift
+ * @return [Calc::C,Calc::Q]
+ * @raise [Calc::MathError] if self is a non-integer
+ * @raise [ArgumentError] if abs(n) is >= 2^31
+ * @example:
+ *  Calc::Q(2) << 3    #=> Calc::Q(16)
+ *  Calc::C(2, 3) << 3 #=> Calc::C(16+24i)
+ */
+static VALUE
+cn_shift_left(VALUE self, VALUE other)
+{
+    return shift(self, other, FALSE);
+}
+
+/* Right shift an integer by a given number of bits.  This multiplies the
+ * number by the appropriate power of 2.  Low bits are truncated.
+ *
+ * @param n [Integer] number of bits to shift
+ * @return [Calc::C,Calc::Q]
+ * @raise [Calc::MathError] if self is a non-integer
+ * @raise [ArgumentError] if abs(n) is >= 2^31
+ * @example:
+ *  Calc::Q(8) >> 2     #=> Calc::Q(2)
+ *  Calc::C(8, 12) >> 2 #=> Calc::C(2+3i)
+ */
+static VALUE
+cn_shift_right(VALUE self, VALUE other)
+{
+    return shift(self, other, TRUE);
+}
+
+/* Compare 2 values.
+ *
+ * If x and y are both real, returns -1, 0 or 1 according as x < y, x == y or
+ * x > y.
+ *
+ * If one or both of x and y are complex, returns a complex number composed
+ * of the real and imaginary parts being compared individually as above.
+ *
+ * @param y [Numeric] value to compare self to
+ * @example
+ *  Calc::Q(3).cmp(4)     #=> Calc::Q(-1)
+ *  Calc::Q(3).cmp(4+4i)  #=> Calc::C(-1-1i)
+ *  Calc::C(3i).cmp(3+3i) #=> Calc::Q(-1)
+ */
+static VALUE
+cn_cmp(VALUE self, VALUE other)
+{
+    VALUE result;
+    NUMBER *qself, *qother;
+    COMPLEX *cself, *cother, *cresult;
+    int r, i;
+    setup_math_error();
+
+    if (CALC_Q_P(self)) {
+        qself = DATA_PTR(self);
+        if (CALC_C_P(other) || TYPE(other) == T_COMPLEX) {
+            cother = value_to_complex(other);
+            r = qrel(qself, cother->real);
+            i = qrel(&_qzero_, cother->imag);
+            comfree(cother);
+        }
+        else {
+            qother = value_to_number(other, 0);
+            r = qrel(qself, qother);
+            i = 0;
+            qfree(qother);
+        }
+    }
+    else if (CALC_C_P(self)) {
+        cself = DATA_PTR(self);
+        if (CALC_C_P(other) || TYPE(other) == T_COMPLEX) {
+            cother = value_to_complex(other);
+            r = qrel(cself->real, cother->real);
+            i = qrel(cself->imag, cother->imag);
+        }
+        else {
+            qother = value_to_number(other, 0);
+            r = qrel(cself->real, qother);
+            i = qrel(cself->imag, &_qzero_);
+            qfree(qother);
+        }
+    }
+    else {
+        rb_raise(rb_eTypeError, "receiver must be Calc::Q or Calc::C");
+    }
+    if (i == 0) {
+        result = cq_new();
+        DATA_PTR(result) = sign_of_int(r);
+    }
+    else {
+        result = cc_new();
+        cresult = comalloc();
+        qfree(cresult->real);
+        cresult->real = sign_of_int(r);
+        qfree(cresult->imag);
+        cresult->imag = sign_of_int(i);
+        DATA_PTR(result) = cresult;
+    }
+    return result;
+}
+
+/* combinatorial number
+ *
+ * Returns the number of combinations in which `other` things may be chosen
+ * from `self` items ignoring order.
+ *
+ * @param other [Integer]
+ * @return [Calc::Q,Calc::C]
+ * @raise [MathError] if `other` is too large or not a positive integer
+ * @example
+ *  Calc::Q(5).comb(3)     #=> Calc::Q(10)
+ *  Calc::Q(60).comb(30)   #=> Calc::Q(118264581564861424)
+ *  Calc::Q("5.1").comb(5) #=> Calc::Q(1.24780425)
+ *  Calc::C(8,9).comb(3)   #=> Calc::C(-227.5+97.5i)
+ */
+static VALUE
+cn_comb(VALUE self, VALUE other)
+{
+    VALUE result;
+    NUMBER *qother, *qresult, *qdiv, *qtmp;
+    COMPLEX *cresult, *ctmp1, *ctmp2;
+    long n;
+    setup_math_error();
+
+    qother = value_to_number(other, 0);
+    if (qisfrac(qother)) {
+        qfree(qother);
+        rb_raise(e_MathError, "non-integer argument to comb");
+    }
+    if (qisneg(qother)) {
+        qfree(qother);
+        result = cq_new();
+        DATA_PTR(result) = qlink(&_qzero_);
+        return result;
+    }
+    else if (qiszero(qother)) {
+        qfree(qother);
+        result = cq_new();
+        DATA_PTR(result) = qlink(&_qone_);
+        return result;
+    }
+    else if (qisone(qother)) {
+        qfree(qother);
+        return self;
+    }
+    else if (CALC_Q_P(self)) {
+        qresult = qcomb(DATA_PTR(self), qother);
+        qfree(qother);
+        if (qresult == NULL) {
+            rb_raise(e_MathError, "argument too large for comb");
+        }
+        result = cq_new();
+        DATA_PTR(result) = qresult;
+        return result;
+    }
+    /* if here, self is a Calc::C and qother is integer > 1.  algorithm based
+     * on calc's func.c, but only for COMPLEX*. */
+    if (zge24b(qother->num)) {
+        qfree(qother);
+        rb_raise(e_MathError, "argument too large for comb");
+    }
+    n = qtoi(qother);
+    cresult = clink((COMPLEX *) DATA_PTR(self));
+    ctmp1 = c_addq((COMPLEX *) DATA_PTR(self), &_qnegone_);
+    qdiv = qlink(&_qtwo_);
+    n--;
+    for (;;) {
+        ctmp2 = c_mul(cresult, ctmp1);
+        comfree(cresult);
+        cresult = c_divq(ctmp2, qdiv);
+        comfree(ctmp2);
+        if (--n == 0 || ciszero(cresult)) {
+            comfree(ctmp1);
+            qfree(qdiv);
+            result = cc_new();
+            DATA_PTR(result) = cresult;
+            return result;
+        }
+        ctmp2 = c_addq(ctmp1, &_qnegone_);
+        comfree(ctmp1);
+        ctmp1 = ctmp2;
+        qtmp = qinc(qdiv);
+        qfree(qdiv);
+        qdiv = qtmp;
+    }
+}
+
+/* floor of logarithm to specified integer base
+ *
+ * x.ilog(b) returns the greatest integer for which b^n <= abs(x)
+ *
+ * @param base [Integer]
+ * @return [Calc::Q]
+ * @raise [Calc::MathError] if x is zero, b is non-integer or b is <= 1
+ * @example
+ *  Calc::Q(2).ilog(3) #=> Calc::Q(0)
+ *  Calc::Q(8).ilog(3) #=> Calc::Q(1)
+ *  Calc::Q(9).ilog(3) #=> Calc::Q(2)
+ */
+static VALUE
+cn_ilog(VALUE self, VALUE base)
+{
+    VALUE result;
+    NUMBER *qbase, *qresult;
+    setup_math_error();
+
+    qbase = value_to_number(base, 0);
+    if (qisfrac(qbase) || qiszero(qbase) || qisunit(qbase) || qisneg(qbase)) {
+        qfree(qbase);
+        rb_raise(e_MathError, "base must be an integer > 1");
+    }
+    if (CALC_Q_P(self)) {
+        qresult = qilog(DATA_PTR(self), qbase->num);
+    }
+    else if (CALC_C_P(self)) {
+        qresult = c_ilog(DATA_PTR(self), qbase->num);
+    }
+    else {
+        rb_raise(rb_eTypeError, "cn_ilog called with invalid receiver");
+    }
+    qfree(qbase);
+    if (!qresult) {
+        rb_raise(e_MathError, "invalid argument for ilog");
+    }
+    result = cq_new();
+    DATA_PTR(result) = qresult;
+    return result;
+}
+
+/* Natural logarithm
+ *
+ * Note that this is like using ruby's Math.log.
+ *
+ * @param eps [Numeric,Calc::Q] (optional) calculation accuracy
+ * @return [Calc::Q,Calc::C]
+ * @raise [Calc::MathError] if self is zero
+ * @example
+ *  Calc::Q(10).ln    #=> Calc::Q(2.30258509299404568402)
+ *  Calc::Q(-10).ln   #=> Calc::C(2.30258509299404568402+3.14159265358979323846i)
+ *  Calc::C(0, 10).ln #=> Calc::C(2.30258509299404568402+1.57079632679489661923i)
+ */
+static VALUE
+cn_ln(int argc, VALUE * argv, VALUE self)
+{
+    return log_function(argc, argv, self, &qln, &c_ln);
+}
+
+/* Base 10 logarithm
+ *
+ * Note that this is like using ruby's Math.log10.
+ *
+ * @param eps [Numeric,Calc::Q] (optional) calculation accuracy
+ * @return [Calc::Q,Calc::C]
+ * @raise [Calc::MathError] if self is zero
+ * @example
+ *  Calc::Q(-1).log     #=> Calc::C(~1.36437635384184134748i)
+ *  Calc::Q(10).log     #=> Calc::Q(1)
+ *  Calc::Q(100).log    #=> Calc::Q(2)
+ *  Calc::Q("1e10").log #=> Calc::Q(10)
+ *  Calc::C(0, 10).log  #=> Calc::C(1+~0.68218817692092067374i)
+ */
+static VALUE
+cn_log(int argc, VALUE * argv, VALUE self)
+{
+    return log_function(argc, argv, self, &qlog, &c_log);
+}
+
+/* Compute integer quotient of a value by a real number (integer division)
+ *
+ * If y is zero, returns zero.
+ *
+ * @param y [Numeric]
+ * @param rnd [Integer] rounding flags, default Calc.config(:quo)
+ * @return [Calc::Q,Calc::C]
+ * @example
+ *  Calc::Q(11,5) #=> Calc::Q(2)
+ */
+static VALUE
+cn_quo(int argc, VALUE * argv, VALUE self)
+{
+    VALUE y, rnd;
+    NUMBER *qy, *qresult;
+    COMPLEX *cself, *cresult;
+    long r;
+    setup_math_error();
+
+    if (rb_scan_args(argc, argv, "11", &y, &rnd) == 2) {
+        r = value_to_long(rnd);
+    }
+    else {
+        r = conf->quo;
+    }
+    qy = value_to_number(y, 1);
+    if (qiszero(qy)) {
+        qfree(qy);
+        rb_raise(rb_eZeroDivError, "division by zero in quo");
+    }
+    if (CALC_Q_P(self)) {
+        qresult = qquo(DATA_PTR(self), qy, r);
+        qfree(qy);
+        return wrap_number(qresult);
+    }
+    cself = DATA_PTR(self);
+    cresult = comalloc();
+    qfree(cresult->real);
+    qfree(cresult->imag);
+    cresult->real = qquo(cself->real, qy, r);
+    cresult->imag = qquo(cself->imag, qy, r);
+    qfree(qy);
+    return wrap_complex(cresult);
+}
+
+/* Root of a number
+ *
+ * x.root(n) returns the nth root of x.  x can be real or complex, n must be
+ * a positive integer.
+ *
+ * If the nth root of x is a multiple of eps, it will be returned exactly.
+ * Otherwise the returned value will be a multiple of eps close to the real
+ * nth root of x.
+ *
+ * @param n [Integer]
+ * @param eps [Numeric] optional epsilon, default Calc.config(:epsilon)
+ * @return [Calc::Q,Calc::C]
+ * @raise [Calc::MathError] if n is not a positive integer
+ * @example
+ *  Calc::Q(7).root(4)    #=> Calc::Q(1.62657656169778574321)
+ *  Calc::Q(-7).root(4)   #=> Calc::C(1.15016331689560300254+1.15016331689560300254i)
+ *  Calc::C(7, 7).root(4) #=> Calc::C(1.73971135785495811228+0.34605010474820910752i)
+ */
+static VALUE
+cn_root(int argc, VALUE * argv, VALUE self)
+{
+    VALUE n, epsilon, result;
+    NUMBER *qn, *qepsilon, *qself;
+    COMPLEX ctmp;
+    setup_math_error();
+
+    if (rb_scan_args(argc, argv, "11", &n, &epsilon) > 1) {
+        qepsilon = value_to_number(epsilon, 1);
+        if (qiszero(qepsilon)) {
+            qfree(qepsilon);
+            rb_raise(e_MathError, "zero epsilon for root");
+        }
+    }
+    else {
+        qepsilon = qlink(conf->epsilon);
+    }
+    qn = value_to_number(n, 0);
+    if (qisneg(qn) || qiszero(qn) || qisfrac(qn)) {
+        qfree(qepsilon);
+        qfree(qn);
+        rb_raise(e_MathError, "non-positive integer root");
+    }
+    if (CALC_Q_P(self)) {
+        qself = DATA_PTR(self);
+        if (!qisneg(qself)) {
+            result = wrap_number(qroot(qself, qn, qepsilon));
+        }
+        else {
+            ctmp.real = qself;
+            ctmp.imag = &_qzero_;
+            ctmp.links = 1;
+            result = wrap_complex(c_root(&ctmp, qn, qepsilon));
+        }
+    }
+    else {
+        result = wrap_complex(c_root(DATA_PTR(self), qn, qepsilon));
+    }
+    qfree(qepsilon);
+    qfree(qn);
+    return result;
+}
+
+/* Scale a number by a power of 2
+ *
+ * x.scale(n) returns the value of 2**n * x.
+ *
+ * Unlike the << and >> operators, this function works on fractional x.
+ *
+ * @param n [Integer]
+ * @return [Calc::C,Calc::Q]
+ * @raise [ArgumentError] if n isn't an integer < 2^31
+ * @example
+ *  Calc::Q(3).scale(2)    #=> Calc::Q(12)
+ *  Calc::Q(3).scale(-2)   #=> Calc::Q(0.75)
+ *  Calc::C(3, 3).scale(2) #=> Calc::C(12+12i)
+ */
+static VALUE
+cn_scale(VALUE self, VALUE other)
+{
+    NUMBER *qother;
+    long n;
+    setup_math_error();
+
+    qother = value_to_number(other, 0);
+    if (qisfrac(qother)) {
+        qfree(qother);
+        rb_raise(rb_eArgError, "scale by non-integer");
+    }
+    if (zge31b(qother->num)) {
+        qfree(qother);
+        rb_raise(rb_eArgError, "scale factor must be < 2^31");
+    }
+    n = qtoi(qother);
+    qfree(qother);
+    if (CALC_Q_P(self)) {
+        return wrap_number(qscale(DATA_PTR(self), n));
+    }
+    else {
+        return wrap_complex(c_scale(DATA_PTR(self), n));
+    }
+}
+
+/* Indicates sign of a real or complex number
+ *
+ * For real x, x.sgn returns
+ *   -1 if x < 0
+ *    0 if x == 0
+ *    1 if x > 0
+ *
+ * For complex x, x.sgn returns Calc::C(x.re.sgn, x.im.sgn)
+ *
+ * @return [Calc::C,Calc::Q]
+ * @example
+ *  Calc::Q(9).sgn     #=> Calc::Q(1)
+ *  Calc::Q(0).sgn     #=> Calc::Q(0)
+ *  Calc::Q(-9).sgn    #=> Calc::Q(-1)
+ *  Calc::C(1, -1).sgn #=> Calc::C(1-1i)
+ */
+static VALUE
+cn_sgn(VALUE self)
+{
+    COMPLEX *cself, *cresult;
+    setup_math_error();
+
+    if (CALC_Q_P(self)) {
+        return wrap_number(qsign(DATA_PTR(self)));
+    }
+    cself = DATA_PTR(self);
+    cresult = comalloc();
+    qfree(cresult->real);
+    qfree(cresult->imag);
+    cresult->real = qsign(cself->real);
+    cresult->imag = qsign(cself->imag);
+    return wrap_complex(cresult);
+}
+
+/* Square root
+ *
+ * Calculates the square root of self (rational or complex).  If eps
+ * is provided, it specifies the accuracy/error of the calculation, otherwise
+ * config("epsilon") is used.
+ * If z is provided, it controls the sign and rounding if required, otherwise
+ * config("sqrt") is used.
+ * Type "help sqrt" in calc for a full explanation of z.
+ *
+ * @param eps [Numeric,Calc::Q] (optional) calculation accuracy
+ * @param z [Integer] (optional) sign and rounding flags
+ * @example
+ *  Calc::Q(4).sqrt     #=> Calc::Q(2)
+ *  Calc::Q(5).sqrt     #=> Calc::Q(2.23606797749978969641)
+ *  Calc::C(0,8).sqrt   #=> Calc::C(2+2i)
+ */
+static VALUE
+cn_sqrt(int argc, VALUE * argv, VALUE self)
+{
+    VALUE result, epsilon, z;
+    NUMBER *qtmp, *qepsilon;
+    COMPLEX *cresult;
+    long R;
+    int n;
+    setup_math_error();
+
+    n = rb_scan_args(argc, argv, "02", &epsilon, &z);
+    if (n >= 1) {
+        qepsilon = value_to_number(epsilon, 1);
+    }
+    else {
+        qepsilon = conf->epsilon;
+    }
+    if (n == 2) {
+        R = FIX2LONG(z);
+    }
+    else {
+        R = conf->sqrt;
+    }
+    if (CALC_Q_P(self) && !qisneg((NUMBER *) DATA_PTR(self))) {
+        /* non-negative rational */
+        result = cq_new();
+        DATA_PTR(result) = qsqrt(DATA_PTR(self), qepsilon, R);
+    }
+    else {
+        if (CALC_Q_P(self)) {
+            /* negative rational */
+            qtmp = qneg(DATA_PTR(self));
+            cresult = comalloc();
+            qfree(cresult->imag);
+            cresult->imag = qsqrt(qtmp, qepsilon, R);
+            qfree(qtmp);
+        }
+        else {
+            /* complex */
+            cresult = c_sqrt(DATA_PTR(self), qepsilon, R);
+        }
+        result = wrap_complex(cresult);
+    }
+    if (n >= 1) {
+        qfree(qepsilon);
+    }
+    return result;
+}
+
+void
+define_calc_numeric(VALUE m)
+{
+    cNumeric = rb_define_class_under(m, "Numeric", rb_cData);
+    rb_define_method(cNumeric, "<<", cn_shift_left, 1);
+    rb_define_method(cNumeric, ">>", cn_shift_right, 1);
+    rb_define_method(cNumeric, "cmp", cn_cmp, 1);
+    rb_define_method(cNumeric, "comb", cn_comb, 1);
+    rb_define_method(cNumeric, "ilog", cn_ilog, 1);
+    rb_define_method(cNumeric, "ln", cn_ln, -1);
+    rb_define_method(cNumeric, "log", cn_log, -1);
+    rb_define_method(cNumeric, "quo", cn_quo, -1);
+    rb_define_method(cNumeric, "root", cn_root, -1);
+    rb_define_method(cNumeric, "scale", cn_scale, 1);
+    rb_define_method(cNumeric, "sgn", cn_sgn, 0);
+    rb_define_method(cNumeric, "sqrt", cn_sqrt, -1);
+}