ruby-calc 0.1.0

data/ext/calc/calc.c

@@ -0,0 +1,192 @@
+#include "calc.h"
+
+/* Frees memory used to store calculated bernoulli numbers.
+ * 
+ * @return [nil]
+ * @example
+ *  Calc.freebernoulli  #=> nil
+ */
+static VALUE
+calc_freebernoulli(VALUE self)
+{
+    setup_math_error();
+    qfreebern();
+    return Qnil;
+}
+
+/* Frees memory used to store calculated euler numbers.
+ *
+ * @return [nil]
+ * @example
+ *  Calc.freeeuler  #=> nil
+ */
+static VALUE
+calc_freeeuler(VALUE self)
+{
+    setup_math_error();
+    qfreeeuler();
+    return Qnil;
+}
+
+/* Computer mod h * 2^n + r
+ *
+ * hnrmod(v, h, n, r) computes the value:
+ *   v % (h * 2^n + r)
+ * where all parameters are integers and:
+ *   h > 0
+ *   n > 0
+ *   r == -1, 0 or 1
+ * 
+ * This is faster than standard mod.
+ *
+ * @param v [Integer]
+ * @param h [Integer]
+ * @param n [Integer]
+ * @param r [Integer]
+ * @return [Calc::Q]
+ * @example
+ *   Calc.hnrmod(2**177 - 1, 1, 177, -1) #=> Calc::Q(0)
+ *   Calc.hnrmod(10**40, 17, 51, 1)      #=> Calc::Q(33827019788296445)
+ */
+static VALUE
+calc_hnrmod(VALUE self, VALUE v, VALUE h, VALUE n, VALUE r)
+{
+    NUMBER *qv, *qh, *qn, *qr, *qresult;
+    ZVALUE zresult;
+    setup_math_error();
+
+    qv = value_to_number(v, 0);
+    if (qisfrac(qv)) {
+        qfree(qv);
+        rb_raise(e_MathError, "1st arg of hnrmod (v) must be an integer");
+    }
+    qh = value_to_number(h, 0);
+    if (qisfrac(qh) || qisneg(qh) || qiszero(qh)) {
+        qfree(qv);
+        qfree(qh);
+        rb_raise(e_MathError, "2nd arg of hnrmod (h) must be an integer > 0");
+    }
+    qn = value_to_number(n, 0);
+    if (qisfrac(qn) || qisneg(qn) || qiszero(qn)) {
+        qfree(qv);
+        qfree(qh);
+        qfree(qn);
+        rb_raise(e_MathError, "3rd arg of hnrmod (n) must be an integer > 0");
+    }
+    qr = value_to_number(r, 0);
+    if (qisfrac(qr) || !zisabsleone(qr->num)) {
+        qfree(qv);
+        qfree(qh);
+        qfree(qn);
+        qfree(qr);
+        rb_raise(e_MathError, "4th arg of hnrmod (r) must be -1, 0 or 1");
+    }
+    zhnrmod(qv->num, qh->num, qn->num, qr->num, &zresult);
+    qresult = qalloc();
+    qresult->num = zresult;
+    return wrap_number(qresult);
+}
+
+/* Evaluates п (pi) to a specified accuracy
+ *
+ * @param eps [Numeric,Calc::Q] (optional) calculation accuracy
+ * @return [Calc::Q]
+ * @raise [Calc::MathError] if v, h, n or r are non-integer or h or v < 1
+ * @raise [Calc::MathError] if r is not -1, 0 or 1
+ * @example
+ *  Calc.pi          #=> Calc::Q(3.14159265358979323846)
+ *  Calc.pi("1e-40") #=> Calc::Q(3.1415926535897932384626433832795028841972)
+ */
+static VALUE
+calc_pi(int argc, VALUE * argv, VALUE self)
+{
+    NUMBER *qepsilon, *qresult;
+    VALUE epsilon;
+    setup_math_error();
+
+    if (rb_scan_args(argc, argv, "01", &epsilon) == 0) {
+        qresult = qpi(conf->epsilon);
+    }
+    else {
+        qepsilon = value_to_number(epsilon, 1);
+        qresult = qpi(qepsilon);
+        qfree(qepsilon);
+    }
+    return wrap_number(qresult);
+}
+
+/* Returns a new complex (or real) number specified by modulus (radius) and
+ * argument (angle, in radians).
+ *
+ * @param radius [Numeric,Calc::Numeric]
+ * @param angle [Numeric,Calc::Numeric]
+ * @param eps [Numeric] (optional) calculation accuracy
+ * @return [Calc::Numeric]
+ * @example
+ *  Calc.polar(1,2)        #=> Calc::C(-0.416146836547142387+0.9092974268256816954i)
+ *  Calc.polar(1,2,"0.01") #=> Calc::C(-0.42+0.91i)
+ *  Calc.polar(2,0)        #=> Calc::Q(2)
+ */
+static VALUE
+calc_polar(int argc, VALUE * argv, VALUE self)
+{
+    VALUE radius, angle, epsilon, result;
+    NUMBER *qradius, *qangle, *qepsilon;
+    setup_math_error();
+
+    if (rb_scan_args(argc, argv, "21", &radius, &angle, &epsilon) == 3) {
+        qepsilon = value_to_number(epsilon, 1);
+        if (qisneg(qepsilon) || qiszero(qepsilon)) {
+            qfree(qepsilon);
+            rb_raise(e_MathError, "Negative or zero epsilon for polar");
+        }
+    }
+    else {
+        qepsilon = NULL;
+    }
+    qradius = value_to_number(radius, 0);
+    qangle = value_to_number(angle, 0);
+    result = wrap_complex(c_polar(qradius, qangle, qepsilon ? qepsilon : conf->epsilon));
+    if (qepsilon) {
+        qfree(qepsilon);
+    }
+    qfree(qradius);
+    qfree(qangle);
+    return result;
+}
+
+/* Returns the calc version string
+ *
+ * This will return a string specifying the version of calc/libcalc which
+ * ruby-calc was compiled against.
+ *
+ * For the version of ruby-calc itself, use `Calc::VERSION`.
+ *
+ * @example
+ *  Calc.version #=> "2.12.5.0"
+ */
+static VALUE
+calc_version(VALUE self)
+{
+    return rb_str_new_cstr(version());
+}
+
+void
+Init_calc(void)
+{
+    VALUE m;
+    libcalc_call_me_first();
+
+    m = rb_define_module("Calc");
+    rb_define_module_function(m, "config", calc_config, -1);
+    rb_define_module_function(m, "freebernoulli", calc_freebernoulli, 0);
+    rb_define_module_function(m, "freeeuler", calc_freeeuler, 0);
+    rb_define_module_function(m, "hnrmod", calc_hnrmod, 4);
+    rb_define_module_function(m, "pi", calc_pi, -1);
+    rb_define_module_function(m, "polar", calc_polar, -1);
+    rb_define_module_function(m, "version", calc_version, 0);
+    define_calc_math_error(m);
+    define_calc_numeric(m);
+    define_calc_q(m);
+    define_calc_c(m);
+}

data/ext/calc/calc.h

@@ -0,0 +1,71 @@
+#ifndef CALC_H
+#define CALC_H 1
+
+#include "ruby.h"
+
+/* cannot include calc/calc.h, which contains some things we need, because it
+ * includes calc/value.h which defines VALUE, a name already used by ruby.
+ * copying things we need here for now. */
+extern void libcalc_call_me_first(void);
+extern void reinitialize(void);
+extern char *version(void);
+
+#include <calc/cmath.h>
+#include <calc/config.h>
+#include <calc/lib_calc.h>
+
+/* config.c */
+extern VALUE calc_config(int argc, VALUE * argv, VALUE klass);
+extern long value_to_mode(VALUE v);
+
+/* convert.c */
+extern NUMBER *value_to_number(VALUE arg, int string_allowed);
+extern COMPLEX *value_to_complex(VALUE arg);
+extern long value_to_long(VALUE n);
+extern VALUE wrap_complex(COMPLEX * c);
+extern VALUE wrap_number(NUMBER * n);
+
+/* math_error.c */
+extern VALUE e_MathError;       /* Calc::MathError class (exception) */
+extern void define_calc_math_error();
+
+#ifdef JUMP_ON_MATH_ERROR
+extern void setup_math_error();
+#else
+#define setup_math_error() ((void)0)
+#endif
+
+/* numeric.c */
+extern VALUE cNumeric;          /* Calc::Numeric module */
+extern void define_calc_numeric(VALUE m);
+
+/* q.c (rational numbers) */
+extern const rb_data_type_t calc_q_type;
+extern VALUE cQ;                /* Calc::Q class */
+
+extern VALUE cq_alloc(VALUE klass);
+extern void define_calc_q(VALUE m);
+
+/* c.c (complex numbers) */
+extern const rb_data_type_t calc_c_type;
+extern VALUE cC;                /* Calc::C class */
+
+extern VALUE cc_alloc(VALUE klass);
+extern void define_calc_c(VALUE m);
+
+/*** macros ***/
+
+/* initialize new ruby values */
+#define cq_new() cq_alloc(cQ)
+#define cc_new() cc_alloc(cC)
+
+/* test ruby values match our TypedData classes */
+#define CALC_Q_P(v) (rb_typeddata_is_kind_of((v), &calc_q_type))
+#define CALC_C_P(v) (rb_typeddata_is_kind_of((v), &calc_c_type))
+
+/* ruby before 2.1 doesn't have RARRAY_AREF */
+#ifndef RARRAY_AREF
+#define RARRAY_AREF(a, i) (RARRAY_PTR(a)[i])
+#endif
+
+#endif                          /* CALC_H */

data/ext/calc/config.c

@@ -0,0 +1,239 @@
+#include "calc.h"
+
+/* "mode" conversions.  this is based on code in config.c */
+
+typedef struct {
+    const char *name;
+    long type;
+} nametype2;
+
+static nametype2 modes[] = {
+    {"fraction", MODE_FRAC},
+    {"frac", MODE_FRAC},
+    {"integer", MODE_INT},
+    {"int", MODE_INT},
+    {"real", MODE_REAL},
+    {"float", MODE_REAL},
+    {"default", MODE_INITIAL},  /* MODE_REAL */
+    {"scientific", MODE_EXP},
+    {"sci", MODE_EXP},
+    {"exp", MODE_EXP},
+    {"hexadecimal", MODE_HEX},
+    {"hex", MODE_HEX},
+    {"octal", MODE_OCTAL},
+    {"oct", MODE_OCTAL},
+    {"binary", MODE_BINARY},
+    {"bin", MODE_BINARY},
+    {"off", MODE2_OFF},
+    {NULL, 0}
+};
+
+/* config types we support - a subset of "configs[]" in calc's config.c */
+
+static nametype2 configs[] = {
+    {"mode", CONFIG_MODE},
+    {"display", CONFIG_DISPLAY},
+    {"epsilon", CONFIG_EPSILON},
+    {"quomod", CONFIG_QUOMOD},
+    {"quo", CONFIG_QUO},
+    {"mod", CONFIG_MOD},
+    {"sqrt", CONFIG_SQRT},
+    {"appr", CONFIG_APPR},
+    {"cfappr", CONFIG_CFAPPR},
+    {"cfsim", CONFIG_CFSIM},
+    {"round", CONFIG_ROUND},
+    {NULL, 0}
+};
+
+static long
+lookup_long(nametype2 * set, const char *name)
+{
+    nametype2 *cp;
+
+    for (cp = set; cp->name; cp++) {
+        if (strcmp(cp->name, name) == 0)
+            return cp->type;
+    }
+    return -1;
+}
+
+static const char *
+lookup_name(nametype2 * set, long val)
+{
+    nametype2 *cp;
+
+    for (cp = set; cp->name; cp++) {
+        if (val == cp->type)
+            return cp->name;
+    }
+    return NULL;
+}
+
+/* given a String or Symbol, returns the index into a nameset
+ * or -1 if not found */
+static long
+value_to_nametype_long(VALUE v, nametype2 * set)
+{
+    VALUE tmp;
+    char *str;
+
+    if (TYPE(v) == T_STRING) {
+        str = StringValueCStr(v);
+    }
+    else if (TYPE(v) == T_SYMBOL) {
+        tmp = rb_funcall(v, rb_intern("to_s"), 0);
+        str = StringValueCStr(tmp);
+    }
+    else {
+        rb_raise(rb_eArgError, "expected String or Symbol");
+    }
+    return lookup_long(set, str);
+}
+
+/* convert value to a libcalc mode flag.  value may be a string or a symbol.
+ * raises an exception if the mode in invalid. */
+long
+value_to_mode(VALUE v)
+{
+    long n;
+
+    n = value_to_nametype_long(v, modes);
+    if (n < 0) {
+        rb_raise(rb_eArgError, "invalid output mode");
+    }
+    return n;
+}
+
+static VALUE
+mode_to_string(long n)
+{
+    const char *p;
+
+    p = lookup_name(modes, n);
+    if (p == NULL) {
+        rb_raise(e_MathError, "invalid output mode: %ld", n);
+    }
+    return rb_str_new2(p);
+}
+
+/* convert a string or symbol to the libcalc CALC_* enum
+ * returns -1 if the name is invalid/unsupported in ruby-calc */
+static long
+value_to_config(VALUE v)
+{
+    return value_to_nametype_long(v, configs);
+}
+
+static LEN
+value_to_len(VALUE v, const char *name)
+{
+    NUMBER *q;
+    LEN len = 0;
+
+    q = value_to_number(v, 1);
+    if (!qisint(q)) {
+        qfree(q);
+        rb_raise(e_MathError, "Non-integer value for %s", name);
+    }
+    if (zge31b(q->num)) {
+        qfree(q);
+        rb_raise(e_MathError, "Integer too big for %s", name);
+    }
+    len = (LEN) ztoi(q->num);
+    qfree(q);
+    if (len < 0)
+        rb_raise(e_MathError, "Negative value for %s", name);
+    return len;
+}
+
+/* Unfortunately in this function we can't use the libcalc method setconfig()
+ * or config_value() - because it is defined in value.h which is
+ * incompatible with the ruby C API (they both define a type called VALUE).
+ *
+ * some of its code is duplicated here.
+ */
+
+/* Gets or sets a libcalc configuration type.
+ */
+VALUE
+calc_config(int argc, VALUE * argv, VALUE klass)
+{
+    VALUE name, new_value, old_value;
+    int args;
+    setup_math_error();
+
+    args = rb_scan_args(argc, argv, "11", &name, &new_value);
+
+    switch (value_to_config(name)) {
+
+    case CONFIG_DISPLAY:
+        old_value = INT2FIX(conf->outdigits);
+        if (args == 2)
+            math_setdigits(FIX2INT(new_value));
+        break;
+
+    case CONFIG_MODE:
+        old_value = mode_to_string(conf->outmode);
+        if (args == 2)
+            math_setmode((int) value_to_mode(new_value));
+        break;
+
+    case CONFIG_EPSILON:
+        old_value = wrap_number(qlink(conf->epsilon));
+        if (args == 2)
+            setepsilon(value_to_number(new_value, 1));
+        break;
+
+    case CONFIG_QUOMOD:
+        old_value = INT2FIX(conf->quomod);
+        if (args == 2)
+            conf->quomod = value_to_len(new_value, "quomod");
+        break;
+
+    case CONFIG_QUO:
+        old_value = INT2FIX(conf->quo);
+        if (args == 2)
+            conf->quo = value_to_len(new_value, "quo");
+        break;
+
+    case CONFIG_MOD:
+        old_value = INT2FIX(conf->mod);
+        if (args == 2)
+            conf->mod = value_to_len(new_value, "mod");
+        break;
+
+    case CONFIG_SQRT:
+        old_value = INT2FIX(conf->sqrt);
+        if (args == 2)
+            conf->sqrt = value_to_len(new_value, "sqrt");
+        break;
+
+    case CONFIG_APPR:
+        old_value = INT2FIX(conf->appr);
+        if (args == 2)
+            conf->appr = value_to_len(new_value, "appr");
+        break;
+
+    case CONFIG_CFAPPR:
+        old_value = INT2FIX(conf->cfappr);
+        if (args == 2)
+            conf->cfappr = value_to_len(new_value, "cfappr");
+        break;
+
+    case CONFIG_CFSIM:
+        old_value = INT2FIX(conf->cfsim);
+        if (args == 2)
+            conf->cfsim = value_to_len(new_value, "cfsim");
+        break;
+
+    case CONFIG_ROUND:
+        old_value = INT2FIX(conf->round);
+        if (args == 2)
+            conf->round = value_to_len(new_value, "round");
+        break;
+
+    default:
+        rb_raise(rb_eArgError, "Invalid or unsupported config parameter");
+    }
+    return old_value;
+}