sollya 0.1.0

data/ext/sollya_rb.c

@@ -0,0 +1,3423 @@
+/* Copyright (C) 2024 Théotime Bollengier <theotime.bollengier@ensta-bretagne.fr>
+ *
+ * This file is part of Sollya.rb. <https://gitlab.ensta-bretagne.fr/bollenth/sollya.rb>
+ *
+ * Sollya.rb is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published
+ * by the Free Software Foundation, either version 3 of the License,
+ * or (at your option) any later version.
+ *
+ * Sollya.rb is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ * See the GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with Sollya.rb. If not, see <https://www.gnu.org/licenses/>. 
+ */
+
+#include "ruby/internal/intern/array.h"
+#include <ruby.h>
+#include <sollya.h>
+
+extern void Init_mpfr(void);
+extern void mpfrrb_bignum_to_mpz(VALUE, mpz_ptr);
+extern void mpfrrb_rational_to_mpq(VALUE, mpq_ptr);
+extern mpfr_ptr mpfrrb_rb2ref_ext(VALUE);
+extern VALUE c_MPFR;
+extern VALUE mpfrrb_alloc(VALUE klass);
+
+static VALUE m_Sollya;
+static VALUE c_SolObject;
+static VALUE c_SolString;
+static VALUE c_SolSpecial;
+static VALUE c_SolRange;
+static VALUE c_SolList;
+static VALUE c_SolStructure;
+static VALUE c_SolProcedure;
+static VALUE c_SolExternalProcedure;
+static VALUE c_SolExternalData;
+static VALUE c_SolFunction;
+static VALUE c_UnaryOp;
+static VALUE c_BinaryOp;
+static VALUE c_Abs;
+static VALUE c_Acos;
+static VALUE c_Acosh;
+static VALUE c_Add;
+static VALUE c_Asin;
+static VALUE c_Asinh;
+static VALUE c_Atan;
+static VALUE c_Atanh;
+static VALUE c_Ceil;
+static VALUE c_Constant;
+static VALUE c_Cos;
+static VALUE c_Cosh;
+static VALUE c_Div;
+static VALUE c_Double;
+static VALUE c_DoubleDouble;
+static VALUE c_DoubleExtended;
+static VALUE c_Erf;
+static VALUE c_Erfc;
+static VALUE c_Exp;
+static VALUE c_Expm1;
+static VALUE c_Floor;
+static VALUE c_Freevariable;
+static VALUE c_Halfprecision;
+static VALUE c_Libraryconstant;
+static VALUE c_Libraryfunction;
+static VALUE c_Log;
+static VALUE c_Log10;
+static VALUE c_Log1p;
+static VALUE c_Log2;
+static VALUE c_Mul;
+static VALUE c_Nearestint;
+static VALUE c_Neg;
+static VALUE c_Pi;
+static VALUE c_Pow;
+static VALUE c_Procedurefunction;
+static VALUE c_Quad;
+static VALUE c_Sin;
+static VALUE c_Single;
+static VALUE c_Sinh;
+static VALUE c_Sqrt;
+static VALUE c_Sub;
+static VALUE c_Tan;
+static VALUE c_Tanh;
+static VALUE c_Tripledouble;
+
+static VALUE sollyarb_cst_ON;
+static VALUE sollyarb_cst_OFF;
+static VALUE sollyarb_cst_DYADIC;
+static VALUE sollyarb_cst_POWERS;
+static VALUE sollyarb_cst_BINARY;
+static VALUE sollyarb_cst_HEXADECIMAL;
+static VALUE sollyarb_cst_FILE;
+static VALUE sollyarb_cst_POSTSCRIPT;
+static VALUE sollyarb_cst_POSTSCRIPTFILE;
+static VALUE sollyarb_cst_PERTURB;
+static VALUE sollyarb_cst_ROUND_DOWN;
+static VALUE sollyarb_cst_ROUND_UP;
+static VALUE sollyarb_cst_ROUND_TOWARDS_ZERO;
+static VALUE sollyarb_cst_ROUND_TO_NEAREST;
+static VALUE sollyarb_cst_HONORCOEFFPREC;
+static VALUE sollyarb_cst_TRUE;
+static VALUE sollyarb_cst_FALSE;
+static VALUE sollyarb_cst_VOID;
+static VALUE sollyarb_cst_DEFAULT;
+static VALUE sollyarb_cst_DECIMAL;
+static VALUE sollyarb_cst_ABSOLUTE;
+static VALUE sollyarb_cst_RELATIVE;
+static VALUE sollyarb_cst_FIXED;
+static VALUE sollyarb_cst_FLOATING;
+static VALUE sollyarb_cst_ERROR;
+static VALUE sollyarb_cst_DOUBLE;
+static VALUE sollyarb_cst_SINGLE;
+static VALUE sollyarb_cst_QUAD;
+static VALUE sollyarb_cst_HALFPRECISION;
+static VALUE sollyarb_cst_DOUBLEEXTENDED;
+static VALUE sollyarb_cst_DOUBLE_DOUBLE;
+static VALUE sollyarb_cst_TRIPLE_DOUBLE;
+static VALUE sollyarb_cst_PI;
+
+static ID id_to_sollya;
+static ID id_to_mpfr;
+static ID id_to_s;
+static ID id_end_elliptic;
+static ID id_prec;
+
+static ID id_on;
+static ID id_off;
+static ID id_dyadic;
+static ID id_powers;
+static ID id_binary;
+static ID id_hexadecimal;
+static ID id_file;
+static ID id_postscript;
+static ID id_postscriptfile;
+static ID id_perturb;
+static ID id_RD;
+static ID id_round_down;
+static ID id_RU;
+static ID id_round_up;
+static ID id_RZ;
+static ID id_round_towards_zero;
+static ID id_RN;
+static ID id_round_to_nearest;
+static ID id_honorcoeffprec;
+static ID id_true;
+static ID id_false;
+static ID id_void;
+static ID id_default;
+static ID id_decimal;
+static ID id_absolute;
+static ID id_relative;
+static ID id_fixed;
+static ID id_floating;
+static ID id_error;
+static ID id_D;
+static ID id_double;
+static ID id_SG;
+static ID id_single;
+static ID id_QD;
+static ID id_quad;
+static ID id_HP;
+static ID id_halfprecision;
+static ID id_DE;
+static ID id_doubleextended;
+static ID id_DD;
+static ID id_doubledouble;
+static ID id_TD;
+static ID id_tripledouble;
+
+
+// static inline VALUE sollyarb_obj2sollya(VALUE obj) {
+// 	return rb_funcallv(obj, id_to_sollya, 0, NULL);
+// }
+
+
+static void sollyarb_object_free(void *p)
+{
+	sollya_obj_t obj = (sollya_obj_t)p;
+	if (obj) {
+		sollya_lib_clear_obj(obj);
+	}
+}
+
+
+const rb_data_type_t sollyarb_object_type = {
+	.wrap_struct_name = "Sollya::Object",
+	.function = {
+		.dmark = NULL,
+		.dfree = sollyarb_object_free,
+		.dsize = NULL,
+	},
+	.parent = NULL,
+	.data = NULL,
+	.flags = RUBY_TYPED_FREE_IMMEDIATELY
+};
+
+
+static VALUE sollyarb_object_alloc(VALUE klass)
+{
+	sollya_obj_t obj = NULL;
+	return TypedData_Wrap_Struct(klass, &sollyarb_object_type, obj);
+}
+
+
+static inline VALUE sollyarb_ref2rb(sollya_obj_t obj, VALUE klass)
+{
+	return TypedData_Wrap_Struct(klass, &sollyarb_object_type, obj);
+}
+
+
+static inline sollya_obj_t sollyarb_object_rb2ref(VALUE obj) {
+	sollya_obj_t p;
+	TypedData_Get_Struct(obj, __sollya_internal_type_object_base, &sollyarb_object_type, p);
+	return p;
+}
+
+
+static VALUE sollyarb_object_print(VALUE self)
+{
+	sollya_obj_t sol = sollyarb_object_rb2ref(self);
+	sollya_lib_autoprint(sol, NULL);
+	return Qnil;
+}
+
+
+static VALUE sollyarb_object_to_s(VALUE self)
+{
+	char buf[64];
+	sollya_obj_t sol = sollyarb_object_rb2ref(self);
+	int s = sollya_lib_snprintf(buf, sizeof(buf), "%b", sol);
+	if (s < (int)sizeof(buf)) {
+		return rb_str_new(buf, s);
+	}
+	char *strp = malloc(s+1);
+	if (!strp) return Qnil;
+	s = sollya_lib_snprintf(strp, s+1, "%b", sol);
+	VALUE rbstr = rb_str_new(strp, s);
+	free(strp);
+	return rbstr;
+}
+
+
+static VALUE sollyarb_object_to_sollya(VALUE self)
+{
+	return self;
+}
+
+
+static VALUE sollyarb_float_to_sollya(VALUE self)
+{
+	return sollyarb_ref2rb(sollya_lib_constant_from_double(NUM2DBL(self)), c_SolFunction);
+}
+
+
+static VALUE sollyarb_integer_to_sollya(VALUE self)
+{
+	if (RB_FIXNUM_P(self)) {
+		return sollyarb_ref2rb(sollya_lib_constant_from_int64(NUM2LL(self)), c_SolFunction);
+	}
+	mpz_t mpz;
+	mpz_init(mpz);
+	mpfrrb_bignum_to_mpz(self, mpz);
+	VALUE r = sollyarb_ref2rb(sollya_lib_constant_from_mpz(mpz), c_SolFunction);
+	mpz_clear(mpz);
+	return r;
+}
+
+
+static VALUE sollyarb_rational_to_sollya(VALUE self)
+{
+	mpq_t mpq;
+	mpq_init(mpq);
+	mpfrrb_rational_to_mpq(self, mpq);
+	VALUE r = sollyarb_ref2rb(sollya_lib_constant_from_mpq(mpq), c_SolFunction);
+	mpq_clear(mpq);
+	return r;
+}
+
+
+static VALUE sollyarb_MPFR_to_sollya(VALUE self)
+{
+	return sollyarb_ref2rb(sollya_lib_constant(mpfrrb_rb2ref_ext(self)), c_SolFunction);
+}
+
+
+static VALUE sollyarb_string_to_sollya(VALUE self)
+{
+	char *str = rb_string_value_cstr(&self);
+	VALUE r = sollyarb_ref2rb(sollya_lib_string(str), c_SolString);
+	RB_GC_GUARD(self);
+	return r;
+}
+
+
+static VALUE sollyarb_true_to_sollya(VALUE self)
+{
+	return sollyarb_cst_TRUE;
+}
+
+
+static VALUE sollyarb_false_to_sollya(VALUE self)
+{
+	return sollyarb_cst_FALSE;
+}
+
+
+static VALUE sollyarb_symbol_to_sollya(VALUE self)
+{
+	ID id = rb_sym2id(self);
+	if (id == id_on) {
+		return sollyarb_cst_ON;
+	} else if (id == id_off) {
+		return sollyarb_cst_OFF;
+	} else if (id == id_dyadic) {
+		return sollyarb_cst_DYADIC;
+	} else if (id == id_powers) {
+		return sollyarb_cst_POWERS;
+	} else if (id == id_binary) {
+		return sollyarb_cst_BINARY;
+	} else if (id == id_hexadecimal) {
+		return sollyarb_cst_HEXADECIMAL;
+	} else if (id == id_file) {
+		return sollyarb_cst_FILE;
+	} else if (id == id_postscript) {
+		return sollyarb_cst_POSTSCRIPT;
+	} else if (id == id_postscriptfile) {
+		return sollyarb_cst_POSTSCRIPTFILE;
+	} else if (id == id_perturb) {
+		return sollyarb_cst_PERTURB;
+	} else if (id == id_RD || id == id_round_down) {
+		return sollyarb_cst_ROUND_DOWN;
+	} else if (id == id_RU || id == id_round_up) {
+		return sollyarb_cst_ROUND_UP;
+	} else if (id == id_RZ || id == id_round_towards_zero) {
+		return sollyarb_cst_ROUND_TOWARDS_ZERO;
+	} else if (id == id_RN || id == id_round_to_nearest) {
+		return sollyarb_cst_ROUND_TO_NEAREST;
+	} else if (id == id_honorcoeffprec) {
+		return sollyarb_cst_HONORCOEFFPREC;
+	} else if (id == id_true) {
+		return sollyarb_cst_TRUE;
+	} else if (id == id_false) {
+		return sollyarb_cst_FALSE;
+	} else if (id == id_void) {
+		return sollyarb_cst_VOID;
+	} else if (id == id_default) {
+		return sollyarb_cst_DEFAULT;
+	} else if (id == id_decimal) {
+		return sollyarb_cst_DECIMAL;
+	} else if (id == id_absolute) {
+		return sollyarb_cst_ABSOLUTE;
+	} else if (id == id_relative) {
+		return sollyarb_cst_RELATIVE;
+	} else if (id == id_fixed) {
+		return sollyarb_cst_FIXED;
+	} else if (id == id_floating) {
+		return sollyarb_cst_FLOATING;
+	} else if (id == id_error) {
+		return sollyarb_cst_ERROR;
+	} else if (id == id_D || id == id_double) {
+		return sollyarb_cst_DOUBLE;
+	} else if (id == id_SG || id == id_single) {
+		return sollyarb_cst_SINGLE;
+	} else if (id == id_QD || id == id_quad) {
+		return sollyarb_cst_QUAD;
+	} else if (id == id_HP || id == id_halfprecision) {
+		return sollyarb_cst_HALFPRECISION;
+	} else if (id == id_DE || id == id_doubleextended) {
+		return sollyarb_cst_DOUBLEEXTENDED;
+	} else if (id == id_DD || id == id_doubledouble) {
+		return sollyarb_cst_DOUBLE_DOUBLE;
+	} else if (id == id_TD || id == id_tripledouble) {
+		return sollyarb_cst_TRIPLE_DOUBLE;
+	} else {
+		rb_raise(rb_eArgError, "cannot convert symbol %" PRIsVALUE " into a Sollya object", self);
+	}
+}
+
+
+static VALUE sollyarb_autowrap_object(sollya_obj_t obj)
+{
+	VALUE r = Qnil;
+
+	if (sollya_lib_obj_is_function(obj)) {
+		sollya_base_function_t base_func;
+  		if (!sollya_lib_get_head_function(&base_func, obj)) {
+			r = sollyarb_ref2rb(obj, c_SolFunction);
+		} else {
+			switch (base_func) {
+				case SOLLYA_BASE_FUNC_ABS:               r = sollyarb_ref2rb(obj, c_Abs); break;
+				case SOLLYA_BASE_FUNC_ACOS:              r = sollyarb_ref2rb(obj, c_Acos); break;
+				case SOLLYA_BASE_FUNC_ACOSH:             r = sollyarb_ref2rb(obj, c_Acosh); break;
+				case SOLLYA_BASE_FUNC_ADD:               r = sollyarb_ref2rb(obj, c_Add); break;
+				case SOLLYA_BASE_FUNC_ASIN:              r = sollyarb_ref2rb(obj, c_Asin); break;
+				case SOLLYA_BASE_FUNC_ASINH:             r = sollyarb_ref2rb(obj, c_Asinh); break;
+				case SOLLYA_BASE_FUNC_ATAN:              r = sollyarb_ref2rb(obj, c_Atan); break;
+				case SOLLYA_BASE_FUNC_ATANH:             r = sollyarb_ref2rb(obj, c_Atanh); break;
+				case SOLLYA_BASE_FUNC_CEIL:              r = sollyarb_ref2rb(obj, c_Ceil); break;
+				case SOLLYA_BASE_FUNC_CONSTANT:          r = sollyarb_ref2rb(obj, c_Constant); break;
+				case SOLLYA_BASE_FUNC_COS:               r = sollyarb_ref2rb(obj, c_Cos); break;
+				case SOLLYA_BASE_FUNC_COSH:              r = sollyarb_ref2rb(obj, c_Cosh); break;
+				case SOLLYA_BASE_FUNC_DIV:               r = sollyarb_ref2rb(obj, c_Div); break;
+				case SOLLYA_BASE_FUNC_DOUBLE:            r = sollyarb_ref2rb(obj, c_Double); break;
+				case SOLLYA_BASE_FUNC_DOUBLEDOUBLE:      r = sollyarb_ref2rb(obj, c_DoubleDouble); break;
+				case SOLLYA_BASE_FUNC_DOUBLEEXTENDED:    r = sollyarb_ref2rb(obj, c_DoubleExtended); break;
+				case SOLLYA_BASE_FUNC_ERF:               r = sollyarb_ref2rb(obj, c_Erf); break;
+				case SOLLYA_BASE_FUNC_ERFC:              r = sollyarb_ref2rb(obj, c_Erfc); break;
+				case SOLLYA_BASE_FUNC_EXP:               r = sollyarb_ref2rb(obj, c_Exp); break;
+				case SOLLYA_BASE_FUNC_EXP_M1:            r = sollyarb_ref2rb(obj, c_Expm1); break;
+				case SOLLYA_BASE_FUNC_FLOOR:             r = sollyarb_ref2rb(obj, c_Floor); break;
+				case SOLLYA_BASE_FUNC_FREE_VARIABLE:     r = sollyarb_ref2rb(obj, c_Freevariable); break;
+				case SOLLYA_BASE_FUNC_HALFPRECISION:     r = sollyarb_ref2rb(obj, c_Halfprecision); break;
+				case SOLLYA_BASE_FUNC_LIBRARYCONSTANT:   r = sollyarb_ref2rb(obj, c_Libraryconstant); break;
+				case SOLLYA_BASE_FUNC_LIBRARYFUNCTION:   r = sollyarb_ref2rb(obj, c_Libraryfunction); break;
+				case SOLLYA_BASE_FUNC_LOG:               r = sollyarb_ref2rb(obj, c_Log); break;
+				case SOLLYA_BASE_FUNC_LOG_10:            r = sollyarb_ref2rb(obj, c_Log10); break;
+				case SOLLYA_BASE_FUNC_LOG_1P:            r = sollyarb_ref2rb(obj, c_Log1p); break;
+				case SOLLYA_BASE_FUNC_LOG_2:             r = sollyarb_ref2rb(obj, c_Log2); break;
+				case SOLLYA_BASE_FUNC_MUL:               r = sollyarb_ref2rb(obj, c_Mul); break;
+				case SOLLYA_BASE_FUNC_NEARESTINT:        r = sollyarb_ref2rb(obj, c_Nearestint); break;
+				case SOLLYA_BASE_FUNC_NEG:               r = sollyarb_ref2rb(obj, c_Neg); break;
+				case SOLLYA_BASE_FUNC_PI:                r = sollyarb_ref2rb(obj, c_Pi); break;
+				case SOLLYA_BASE_FUNC_POW:               r = sollyarb_ref2rb(obj, c_Pow); break;
+				case SOLLYA_BASE_FUNC_PROCEDUREFUNCTION: r = sollyarb_ref2rb(obj, c_Procedurefunction); break;
+				case SOLLYA_BASE_FUNC_QUAD:              r = sollyarb_ref2rb(obj, c_Quad); break;
+				case SOLLYA_BASE_FUNC_SIN:               r = sollyarb_ref2rb(obj, c_Sin); break;
+				case SOLLYA_BASE_FUNC_SINGLE:            r = sollyarb_ref2rb(obj, c_Single); break;
+				case SOLLYA_BASE_FUNC_SINH:              r = sollyarb_ref2rb(obj, c_Sinh); break;
+				case SOLLYA_BASE_FUNC_SQRT:              r = sollyarb_ref2rb(obj, c_Sqrt); break;
+				case SOLLYA_BASE_FUNC_SUB:               r = sollyarb_ref2rb(obj, c_Sub); break;
+				case SOLLYA_BASE_FUNC_TAN:               r = sollyarb_ref2rb(obj, c_Tan); break;
+				case SOLLYA_BASE_FUNC_TANH:              r = sollyarb_ref2rb(obj, c_Tanh); break;
+				case SOLLYA_BASE_FUNC_TRIPLEDOUBLE:      r = sollyarb_ref2rb(obj, c_Tripledouble); break;
+				default:                                 r = sollyarb_ref2rb(obj, c_SolFunction);
+			}
+		}
+	} else if (sollya_lib_obj_is_list(obj)) {
+		r = sollyarb_ref2rb(obj, c_SolList);
+	} else if (sollya_lib_obj_is_end_elliptic_list(obj)) {
+		r = sollyarb_ref2rb(obj, c_SolList);
+	} else if (sollya_lib_obj_is_range(obj)) {
+		r = sollyarb_ref2rb(obj, c_SolRange);
+	} else if (sollya_lib_obj_is_string(obj)) {
+		r = sollyarb_ref2rb(obj, c_SolString);
+	} else if (sollya_lib_obj_is_error(obj)) {
+		r = sollyarb_cst_ERROR;
+		sollya_lib_clear_obj(obj);
+	} else if (sollya_lib_obj_is_structure(obj)) {
+		r = sollyarb_ref2rb(obj, c_SolStructure);
+	} else if (sollya_lib_obj_is_procedure(obj)) {
+		r = sollyarb_ref2rb(obj, c_SolProcedure);
+	} else if (sollya_lib_obj_is_externalprocedure(obj)) {
+		r = sollyarb_ref2rb(obj, c_SolExternalProcedure);
+	} else if (sollya_lib_obj_is_externaldata(obj)) {
+		r = sollyarb_ref2rb(obj, c_SolExternalData);
+	} else if (sollya_lib_is_on(obj)) {
+		r = sollyarb_cst_ON;
+		sollya_lib_clear_obj(obj);
+	} else if (sollya_lib_is_off(obj)) {
+		r = sollyarb_cst_OFF;
+		sollya_lib_clear_obj(obj);
+	} else if (sollya_lib_is_dyadic(obj)) {
+		r = sollyarb_cst_DYADIC;
+		sollya_lib_clear_obj(obj);
+	} else if (sollya_lib_is_powers(obj)) {
+		r = sollyarb_cst_POWERS;
+		sollya_lib_clear_obj(obj);
+	} else if (sollya_lib_is_binary(obj)) {
+		r = sollyarb_cst_BINARY;
+		sollya_lib_clear_obj(obj);
+	} else if (sollya_lib_is_hexadecimal(obj)) {
+		r = sollyarb_cst_HEXADECIMAL;
+		sollya_lib_clear_obj(obj);
+	} else if (sollya_lib_is_file(obj)) {
+		r = sollyarb_cst_FILE;
+		sollya_lib_clear_obj(obj);
+	} else if (sollya_lib_is_postscript(obj)) {
+		r = sollyarb_cst_POSTSCRIPT;
+		sollya_lib_clear_obj(obj);
+	} else if (sollya_lib_is_postscriptfile(obj)) {
+		r = sollyarb_cst_POSTSCRIPTFILE;
+		sollya_lib_clear_obj(obj);
+	} else if (sollya_lib_is_perturb(obj)) {
+		r = sollyarb_cst_PERTURB;
+		sollya_lib_clear_obj(obj);
+	} else if (sollya_lib_is_round_down(obj)) {
+		r = sollyarb_cst_ROUND_DOWN;
+		sollya_lib_clear_obj(obj);
+	} else if (sollya_lib_is_round_up(obj)) {
+		r = sollyarb_cst_ROUND_UP;
+		sollya_lib_clear_obj(obj);
+	} else if (sollya_lib_is_round_towards_zero(obj)) {
+		r = sollyarb_cst_ROUND_TOWARDS_ZERO;
+		sollya_lib_clear_obj(obj);
+	} else if (sollya_lib_is_round_to_nearest(obj)) {
+		r = sollyarb_cst_ROUND_TO_NEAREST;
+		sollya_lib_clear_obj(obj);
+	} else if (sollya_lib_is_honorcoeffprec(obj)) {
+		r = sollyarb_cst_HONORCOEFFPREC;
+		sollya_lib_clear_obj(obj);
+	} else if (sollya_lib_is_true(obj)) {
+		r = sollyarb_cst_TRUE;
+		sollya_lib_clear_obj(obj);
+	} else if (sollya_lib_is_false(obj)) {
+		r = sollyarb_cst_FALSE;
+		sollya_lib_clear_obj(obj);
+	} else if (sollya_lib_is_void(obj)) {
+		r = sollyarb_cst_VOID;
+		sollya_lib_clear_obj(obj);
+	} else if (sollya_lib_is_default(obj)) {
+		r = sollyarb_cst_DEFAULT;
+		sollya_lib_clear_obj(obj);
+	} else if (sollya_lib_is_decimal(obj)) {
+		r = sollyarb_cst_DECIMAL;
+		sollya_lib_clear_obj(obj);
+	} else if (sollya_lib_is_absolute(obj)) {
+		r = sollyarb_cst_ABSOLUTE;
+		sollya_lib_clear_obj(obj);
+	} else if (sollya_lib_is_relative(obj)) {
+		r = sollyarb_cst_RELATIVE;
+		sollya_lib_clear_obj(obj);
+	} else if (sollya_lib_is_fixed(obj)) {
+		r = sollyarb_cst_FIXED;
+		sollya_lib_clear_obj(obj);
+	} else if (sollya_lib_is_floating(obj)) {
+		r = sollyarb_cst_FLOATING;
+		sollya_lib_clear_obj(obj);
+	} else if (sollya_lib_is_double_obj(obj)) {
+		r = sollyarb_cst_DOUBLE;
+		sollya_lib_clear_obj(obj);
+	} else if (sollya_lib_is_single_obj(obj)) {
+		r = sollyarb_cst_SINGLE;
+		sollya_lib_clear_obj(obj);
+	} else if (sollya_lib_is_quad_obj(obj)) {
+		r = sollyarb_cst_QUAD;
+		sollya_lib_clear_obj(obj);
+	} else if (sollya_lib_is_halfprecision_obj(obj)) {
+		r = sollyarb_cst_HALFPRECISION;
+		sollya_lib_clear_obj(obj);
+	} else if (sollya_lib_is_doubleextended_obj(obj)) {
+		r = sollyarb_cst_DOUBLEEXTENDED;
+		sollya_lib_clear_obj(obj);
+	} else if (sollya_lib_is_double_double_obj(obj)) {
+		r = sollyarb_cst_DOUBLE_DOUBLE;
+		sollya_lib_clear_obj(obj);
+	} else if (sollya_lib_is_triple_double_obj(obj)) {
+		r = sollyarb_cst_TRIPLE_DOUBLE;
+		sollya_lib_clear_obj(obj);
+	} else if (sollya_lib_is_pi(obj)) {
+		r = sollyarb_cst_PI;
+		sollya_lib_clear_obj(obj);
+	} else {
+		r = sollyarb_ref2rb(obj, c_SolObject);
+	}
+	return r;
+		r = sollyarb_cst_ERROR;
+}
+
+static VALUE sollyarb_range_to_sollya(VALUE self)
+{
+	VALUE beg = Qnil, end = Qnil;
+	int exclp;
+	rb_range_values(self, &beg, &end, &exclp);
+#if 0
+	beg = rb_funcallv(beg, id_to_mpfr, 0, NULL);
+	end = rb_funcallv(end, id_to_mpfr, 0, NULL);
+	mpfr_ptr mpbeg = mpfrrb_rb2ref_ext(beg);
+	mpfr_ptr mpend = mpfrrb_rb2ref_ext(end);
+	return sollyarb_ref2rb(sollya_lib_range_from_bounds(mpbeg, mpend), c_SolRange);
+#else
+	beg = rb_funcallv(beg, id_to_sollya, 0, NULL);
+	end = rb_funcallv(end, id_to_sollya, 0, NULL);
+	return sollyarb_ref2rb(sollya_lib_range(sollyarb_object_rb2ref(beg), sollyarb_object_rb2ref(end)), c_SolRange);
+#endif
+}
+
+
+static VALUE sollyarb_array_to_sollya(VALUE self)
+{
+	long i;
+	long l = rb_array_len(self);
+	sollya_obj_t *carr = malloc(l*sizeof(sollya_obj_t));
+	for (i = 0; i < l; i++) {
+		VALUE elem = rb_ary_entry(self, i);
+		elem = rb_funcallv(elem, id_to_sollya, 0, NULL);
+		carr[i] = sollyarb_object_rb2ref(elem);
+	}
+	sollya_obj_t r = sollya_lib_list(carr, l);
+	free(carr);
+	return sollyarb_ref2rb(r, c_SolList);
+}
+
+
+static VALUE sollyarb_object_inspect(VALUE self)
+{
+	return rb_sprintf("#<%s %" PRIsVALUE ">", rb_obj_classname(self), rb_funcallv(self, id_to_s, 0, NULL));
+}
+
+
+#define SOLLYARB_ARGV(i) sollyarb_object_rb2ref(rb_funcallv(argv[i], id_to_sollya, 0, NULL))
+#define SOLLYARB_TO_SOLLYA(arg) sollyarb_object_rb2ref(rb_funcallv(arg, id_to_sollya, 0, NULL))
+
+#define SOLLYARB_FUNC_VA_1(func) \
+	(void)self; \
+	switch (argc) { \
+		case  1: func(SOLLYARB_ARGV(0), NULL); break; \
+		case  2: func(SOLLYARB_ARGV(0), SOLLYARB_ARGV(1), NULL); break; \
+		case  3: func(SOLLYARB_ARGV(0), SOLLYARB_ARGV(1), SOLLYARB_ARGV(2), NULL); break; \
+		case  4: func(SOLLYARB_ARGV(0), SOLLYARB_ARGV(1), SOLLYARB_ARGV(2), SOLLYARB_ARGV(3), NULL); break; \
+		case  5: func(SOLLYARB_ARGV(0), SOLLYARB_ARGV(1), SOLLYARB_ARGV(2), SOLLYARB_ARGV(3), SOLLYARB_ARGV(4), NULL); break; \
+		case  6: func(SOLLYARB_ARGV(0), SOLLYARB_ARGV(1), SOLLYARB_ARGV(2), SOLLYARB_ARGV(3), SOLLYARB_ARGV(4), SOLLYARB_ARGV(5), NULL); break; \
+		case  7: func(SOLLYARB_ARGV(0), SOLLYARB_ARGV(1), SOLLYARB_ARGV(2), SOLLYARB_ARGV(3), SOLLYARB_ARGV(4), SOLLYARB_ARGV(5), SOLLYARB_ARGV(6), NULL); break; \
+		case  8: func(SOLLYARB_ARGV(0), SOLLYARB_ARGV(1), SOLLYARB_ARGV(2), SOLLYARB_ARGV(3), SOLLYARB_ARGV(4), SOLLYARB_ARGV(5), SOLLYARB_ARGV(6), SOLLYARB_ARGV(7), NULL); break; \
+		case  9: func(SOLLYARB_ARGV(0), SOLLYARB_ARGV(1), SOLLYARB_ARGV(2), SOLLYARB_ARGV(3), SOLLYARB_ARGV(4), SOLLYARB_ARGV(5), SOLLYARB_ARGV(6), SOLLYARB_ARGV(7), SOLLYARB_ARGV(8), NULL); break; \
+		case 10: func(SOLLYARB_ARGV(0), SOLLYARB_ARGV(1), SOLLYARB_ARGV(2), SOLLYARB_ARGV(3), SOLLYARB_ARGV(4), SOLLYARB_ARGV(5), SOLLYARB_ARGV(6), SOLLYARB_ARGV(7), SOLLYARB_ARGV(8), SOLLYARB_ARGV(9), NULL); break; \
+		case 11: func(SOLLYARB_ARGV(0), SOLLYARB_ARGV(1), SOLLYARB_ARGV(2), SOLLYARB_ARGV(3), SOLLYARB_ARGV(4), SOLLYARB_ARGV(5), SOLLYARB_ARGV(6), SOLLYARB_ARGV(7), SOLLYARB_ARGV(8), SOLLYARB_ARGV(9), SOLLYARB_ARGV(10), NULL); break; \
+		case 12: func(SOLLYARB_ARGV(0), SOLLYARB_ARGV(1), SOLLYARB_ARGV(2), SOLLYARB_ARGV(3), SOLLYARB_ARGV(4), SOLLYARB_ARGV(5), SOLLYARB_ARGV(6), SOLLYARB_ARGV(7), SOLLYARB_ARGV(8), SOLLYARB_ARGV(9), SOLLYARB_ARGV(10), SOLLYARB_ARGV(11), NULL); break; \
+		case 13: func(SOLLYARB_ARGV(0), SOLLYARB_ARGV(1), SOLLYARB_ARGV(2), SOLLYARB_ARGV(3), SOLLYARB_ARGV(4), SOLLYARB_ARGV(5), SOLLYARB_ARGV(6), SOLLYARB_ARGV(7), SOLLYARB_ARGV(8), SOLLYARB_ARGV(9), SOLLYARB_ARGV(10), SOLLYARB_ARGV(11), SOLLYARB_ARGV(12), NULL); break; \
+		case 14: func(SOLLYARB_ARGV(0), SOLLYARB_ARGV(1), SOLLYARB_ARGV(2), SOLLYARB_ARGV(3), SOLLYARB_ARGV(4), SOLLYARB_ARGV(5), SOLLYARB_ARGV(6), SOLLYARB_ARGV(7), SOLLYARB_ARGV(8), SOLLYARB_ARGV(9), SOLLYARB_ARGV(10), SOLLYARB_ARGV(11), SOLLYARB_ARGV(12), SOLLYARB_ARGV(13), NULL); break; \
+		case 15: func(SOLLYARB_ARGV(0), SOLLYARB_ARGV(1), SOLLYARB_ARGV(2), SOLLYARB_ARGV(3), SOLLYARB_ARGV(4), SOLLYARB_ARGV(5), SOLLYARB_ARGV(6), SOLLYARB_ARGV(7), SOLLYARB_ARGV(8), SOLLYARB_ARGV(9), SOLLYARB_ARGV(10), SOLLYARB_ARGV(11), SOLLYARB_ARGV(12), SOLLYARB_ARGV(13), SOLLYARB_ARGV(14), NULL); break; \
+		case 16: func(SOLLYARB_ARGV(0), SOLLYARB_ARGV(1), SOLLYARB_ARGV(2), SOLLYARB_ARGV(3), SOLLYARB_ARGV(4), SOLLYARB_ARGV(5), SOLLYARB_ARGV(6), SOLLYARB_ARGV(7), SOLLYARB_ARGV(8), SOLLYARB_ARGV(9), SOLLYARB_ARGV(10), SOLLYARB_ARGV(11), SOLLYARB_ARGV(12), SOLLYARB_ARGV(13), SOLLYARB_ARGV(14), SOLLYARB_ARGV(15), NULL); break; \
+		default: rb_raise(rb_eArgError, "expecting 1 to 16 arguments, got %d", argc); \
+	} \
+	return Qnil
+
+#define SOLLYARB_FUNC_VA_2(func) \
+	(void)self; \
+	switch (argc) { \
+		case  2: func(SOLLYARB_ARGV(0), SOLLYARB_ARGV(1), NULL); break; \
+		case  3: func(SOLLYARB_ARGV(0), SOLLYARB_ARGV(1), SOLLYARB_ARGV(2), NULL); break; \
+		case  4: func(SOLLYARB_ARGV(0), SOLLYARB_ARGV(1), SOLLYARB_ARGV(2), SOLLYARB_ARGV(3), NULL); break; \
+		case  5: func(SOLLYARB_ARGV(0), SOLLYARB_ARGV(1), SOLLYARB_ARGV(2), SOLLYARB_ARGV(3), SOLLYARB_ARGV(4), NULL); break; \
+		case  6: func(SOLLYARB_ARGV(0), SOLLYARB_ARGV(1), SOLLYARB_ARGV(2), SOLLYARB_ARGV(3), SOLLYARB_ARGV(4), SOLLYARB_ARGV(5), NULL); break; \
+		case  7: func(SOLLYARB_ARGV(0), SOLLYARB_ARGV(1), SOLLYARB_ARGV(2), SOLLYARB_ARGV(3), SOLLYARB_ARGV(4), SOLLYARB_ARGV(5), SOLLYARB_ARGV(6), NULL); break; \
+		case  8: func(SOLLYARB_ARGV(0), SOLLYARB_ARGV(1), SOLLYARB_ARGV(2), SOLLYARB_ARGV(3), SOLLYARB_ARGV(4), SOLLYARB_ARGV(5), SOLLYARB_ARGV(6), SOLLYARB_ARGV(7), NULL); break; \
+		case  9: func(SOLLYARB_ARGV(0), SOLLYARB_ARGV(1), SOLLYARB_ARGV(2), SOLLYARB_ARGV(3), SOLLYARB_ARGV(4), SOLLYARB_ARGV(5), SOLLYARB_ARGV(6), SOLLYARB_ARGV(7), SOLLYARB_ARGV(8), NULL); break; \
+		case 10: func(SOLLYARB_ARGV(0), SOLLYARB_ARGV(1), SOLLYARB_ARGV(2), SOLLYARB_ARGV(3), SOLLYARB_ARGV(4), SOLLYARB_ARGV(5), SOLLYARB_ARGV(6), SOLLYARB_ARGV(7), SOLLYARB_ARGV(8), SOLLYARB_ARGV(9), NULL); break; \
+		case 11: func(SOLLYARB_ARGV(0), SOLLYARB_ARGV(1), SOLLYARB_ARGV(2), SOLLYARB_ARGV(3), SOLLYARB_ARGV(4), SOLLYARB_ARGV(5), SOLLYARB_ARGV(6), SOLLYARB_ARGV(7), SOLLYARB_ARGV(8), SOLLYARB_ARGV(9), SOLLYARB_ARGV(10), NULL); break; \
+		case 12: func(SOLLYARB_ARGV(0), SOLLYARB_ARGV(1), SOLLYARB_ARGV(2), SOLLYARB_ARGV(3), SOLLYARB_ARGV(4), SOLLYARB_ARGV(5), SOLLYARB_ARGV(6), SOLLYARB_ARGV(7), SOLLYARB_ARGV(8), SOLLYARB_ARGV(9), SOLLYARB_ARGV(10), SOLLYARB_ARGV(11), NULL); break; \
+		case 13: func(SOLLYARB_ARGV(0), SOLLYARB_ARGV(1), SOLLYARB_ARGV(2), SOLLYARB_ARGV(3), SOLLYARB_ARGV(4), SOLLYARB_ARGV(5), SOLLYARB_ARGV(6), SOLLYARB_ARGV(7), SOLLYARB_ARGV(8), SOLLYARB_ARGV(9), SOLLYARB_ARGV(10), SOLLYARB_ARGV(11), SOLLYARB_ARGV(12), NULL); break; \
+		case 14: func(SOLLYARB_ARGV(0), SOLLYARB_ARGV(1), SOLLYARB_ARGV(2), SOLLYARB_ARGV(3), SOLLYARB_ARGV(4), SOLLYARB_ARGV(5), SOLLYARB_ARGV(6), SOLLYARB_ARGV(7), SOLLYARB_ARGV(8), SOLLYARB_ARGV(9), SOLLYARB_ARGV(10), SOLLYARB_ARGV(11), SOLLYARB_ARGV(12), SOLLYARB_ARGV(13), NULL); break; \
+		case 15: func(SOLLYARB_ARGV(0), SOLLYARB_ARGV(1), SOLLYARB_ARGV(2), SOLLYARB_ARGV(3), SOLLYARB_ARGV(4), SOLLYARB_ARGV(5), SOLLYARB_ARGV(6), SOLLYARB_ARGV(7), SOLLYARB_ARGV(8), SOLLYARB_ARGV(9), SOLLYARB_ARGV(10), SOLLYARB_ARGV(11), SOLLYARB_ARGV(12), SOLLYARB_ARGV(13), SOLLYARB_ARGV(14), NULL); break; \
+		case 16: func(SOLLYARB_ARGV(0), SOLLYARB_ARGV(1), SOLLYARB_ARGV(2), SOLLYARB_ARGV(3), SOLLYARB_ARGV(4), SOLLYARB_ARGV(5), SOLLYARB_ARGV(6), SOLLYARB_ARGV(7), SOLLYARB_ARGV(8), SOLLYARB_ARGV(9), SOLLYARB_ARGV(10), SOLLYARB_ARGV(11), SOLLYARB_ARGV(12), SOLLYARB_ARGV(13), SOLLYARB_ARGV(14), SOLLYARB_ARGV(15), NULL); break; \
+		default: rb_raise(rb_eArgError, "expecting 2 to 16 arguments, got %d", argc); \
+	} \
+	return Qnil
+
+#define SOLLYARB_FUNC_VA_3(func) \
+	(void)self; \
+	switch (argc) { \
+		case  3: func(SOLLYARB_ARGV(0), SOLLYARB_ARGV(1), SOLLYARB_ARGV(2), NULL); break; \
+		case  4: func(SOLLYARB_ARGV(0), SOLLYARB_ARGV(1), SOLLYARB_ARGV(2), SOLLYARB_ARGV(3), NULL); break; \
+		case  5: func(SOLLYARB_ARGV(0), SOLLYARB_ARGV(1), SOLLYARB_ARGV(2), SOLLYARB_ARGV(3), SOLLYARB_ARGV(4), NULL); break; \
+		case  6: func(SOLLYARB_ARGV(0), SOLLYARB_ARGV(1), SOLLYARB_ARGV(2), SOLLYARB_ARGV(3), SOLLYARB_ARGV(4), SOLLYARB_ARGV(5), NULL); break; \
+		case  7: func(SOLLYARB_ARGV(0), SOLLYARB_ARGV(1), SOLLYARB_ARGV(2), SOLLYARB_ARGV(3), SOLLYARB_ARGV(4), SOLLYARB_ARGV(5), SOLLYARB_ARGV(6), NULL); break; \
+		case  8: func(SOLLYARB_ARGV(0), SOLLYARB_ARGV(1), SOLLYARB_ARGV(2), SOLLYARB_ARGV(3), SOLLYARB_ARGV(4), SOLLYARB_ARGV(5), SOLLYARB_ARGV(6), SOLLYARB_ARGV(7), NULL); break; \
+		case  9: func(SOLLYARB_ARGV(0), SOLLYARB_ARGV(1), SOLLYARB_ARGV(2), SOLLYARB_ARGV(3), SOLLYARB_ARGV(4), SOLLYARB_ARGV(5), SOLLYARB_ARGV(6), SOLLYARB_ARGV(7), SOLLYARB_ARGV(8), NULL); break; \
+		case 10: func(SOLLYARB_ARGV(0), SOLLYARB_ARGV(1), SOLLYARB_ARGV(2), SOLLYARB_ARGV(3), SOLLYARB_ARGV(4), SOLLYARB_ARGV(5), SOLLYARB_ARGV(6), SOLLYARB_ARGV(7), SOLLYARB_ARGV(8), SOLLYARB_ARGV(9), NULL); break; \
+		case 11: func(SOLLYARB_ARGV(0), SOLLYARB_ARGV(1), SOLLYARB_ARGV(2), SOLLYARB_ARGV(3), SOLLYARB_ARGV(4), SOLLYARB_ARGV(5), SOLLYARB_ARGV(6), SOLLYARB_ARGV(7), SOLLYARB_ARGV(8), SOLLYARB_ARGV(9), SOLLYARB_ARGV(10), NULL); break; \
+		case 12: func(SOLLYARB_ARGV(0), SOLLYARB_ARGV(1), SOLLYARB_ARGV(2), SOLLYARB_ARGV(3), SOLLYARB_ARGV(4), SOLLYARB_ARGV(5), SOLLYARB_ARGV(6), SOLLYARB_ARGV(7), SOLLYARB_ARGV(8), SOLLYARB_ARGV(9), SOLLYARB_ARGV(10), SOLLYARB_ARGV(11), NULL); break; \
+		case 13: func(SOLLYARB_ARGV(0), SOLLYARB_ARGV(1), SOLLYARB_ARGV(2), SOLLYARB_ARGV(3), SOLLYARB_ARGV(4), SOLLYARB_ARGV(5), SOLLYARB_ARGV(6), SOLLYARB_ARGV(7), SOLLYARB_ARGV(8), SOLLYARB_ARGV(9), SOLLYARB_ARGV(10), SOLLYARB_ARGV(11), SOLLYARB_ARGV(12), NULL); break; \
+		case 14: func(SOLLYARB_ARGV(0), SOLLYARB_ARGV(1), SOLLYARB_ARGV(2), SOLLYARB_ARGV(3), SOLLYARB_ARGV(4), SOLLYARB_ARGV(5), SOLLYARB_ARGV(6), SOLLYARB_ARGV(7), SOLLYARB_ARGV(8), SOLLYARB_ARGV(9), SOLLYARB_ARGV(10), SOLLYARB_ARGV(11), SOLLYARB_ARGV(12), SOLLYARB_ARGV(13), NULL); break; \
+		case 15: func(SOLLYARB_ARGV(0), SOLLYARB_ARGV(1), SOLLYARB_ARGV(2), SOLLYARB_ARGV(3), SOLLYARB_ARGV(4), SOLLYARB_ARGV(5), SOLLYARB_ARGV(6), SOLLYARB_ARGV(7), SOLLYARB_ARGV(8), SOLLYARB_ARGV(9), SOLLYARB_ARGV(10), SOLLYARB_ARGV(11), SOLLYARB_ARGV(12), SOLLYARB_ARGV(13), SOLLYARB_ARGV(14), NULL); break; \
+		case 16: func(SOLLYARB_ARGV(0), SOLLYARB_ARGV(1), SOLLYARB_ARGV(2), SOLLYARB_ARGV(3), SOLLYARB_ARGV(4), SOLLYARB_ARGV(5), SOLLYARB_ARGV(6), SOLLYARB_ARGV(7), SOLLYARB_ARGV(8), SOLLYARB_ARGV(9), SOLLYARB_ARGV(10), SOLLYARB_ARGV(11), SOLLYARB_ARGV(12), SOLLYARB_ARGV(13), SOLLYARB_ARGV(14), SOLLYARB_ARGV(15), NULL); break; \
+		default: rb_raise(rb_eArgError, "expecting 3 to 16 arguments, got %d", argc); \
+	} \
+	return Qnil
+
+#define SOLLYARB_FUNC_VA_4(func) \
+	(void)self; \
+	switch (argc) { \
+		case  4: func(SOLLYARB_ARGV(0), SOLLYARB_ARGV(1), SOLLYARB_ARGV(2), SOLLYARB_ARGV(3), NULL); break; \
+		case  5: func(SOLLYARB_ARGV(0), SOLLYARB_ARGV(1), SOLLYARB_ARGV(2), SOLLYARB_ARGV(3), SOLLYARB_ARGV(4), NULL); break; \
+		case  6: func(SOLLYARB_ARGV(0), SOLLYARB_ARGV(1), SOLLYARB_ARGV(2), SOLLYARB_ARGV(3), SOLLYARB_ARGV(4), SOLLYARB_ARGV(5), NULL); break; \
+		case  7: func(SOLLYARB_ARGV(0), SOLLYARB_ARGV(1), SOLLYARB_ARGV(2), SOLLYARB_ARGV(3), SOLLYARB_ARGV(4), SOLLYARB_ARGV(5), SOLLYARB_ARGV(6), NULL); break; \
+		case  8: func(SOLLYARB_ARGV(0), SOLLYARB_ARGV(1), SOLLYARB_ARGV(2), SOLLYARB_ARGV(3), SOLLYARB_ARGV(4), SOLLYARB_ARGV(5), SOLLYARB_ARGV(6), SOLLYARB_ARGV(7), NULL); break; \
+		case  9: func(SOLLYARB_ARGV(0), SOLLYARB_ARGV(1), SOLLYARB_ARGV(2), SOLLYARB_ARGV(3), SOLLYARB_ARGV(4), SOLLYARB_ARGV(5), SOLLYARB_ARGV(6), SOLLYARB_ARGV(7), SOLLYARB_ARGV(8), NULL); break; \
+		case 10: func(SOLLYARB_ARGV(0), SOLLYARB_ARGV(1), SOLLYARB_ARGV(2), SOLLYARB_ARGV(3), SOLLYARB_ARGV(4), SOLLYARB_ARGV(5), SOLLYARB_ARGV(6), SOLLYARB_ARGV(7), SOLLYARB_ARGV(8), SOLLYARB_ARGV(9), NULL); break; \
+		case 11: func(SOLLYARB_ARGV(0), SOLLYARB_ARGV(1), SOLLYARB_ARGV(2), SOLLYARB_ARGV(3), SOLLYARB_ARGV(4), SOLLYARB_ARGV(5), SOLLYARB_ARGV(6), SOLLYARB_ARGV(7), SOLLYARB_ARGV(8), SOLLYARB_ARGV(9), SOLLYARB_ARGV(10), NULL); break; \
+		case 12: func(SOLLYARB_ARGV(0), SOLLYARB_ARGV(1), SOLLYARB_ARGV(2), SOLLYARB_ARGV(3), SOLLYARB_ARGV(4), SOLLYARB_ARGV(5), SOLLYARB_ARGV(6), SOLLYARB_ARGV(7), SOLLYARB_ARGV(8), SOLLYARB_ARGV(9), SOLLYARB_ARGV(10), SOLLYARB_ARGV(11), NULL); break; \
+		case 13: func(SOLLYARB_ARGV(0), SOLLYARB_ARGV(1), SOLLYARB_ARGV(2), SOLLYARB_ARGV(3), SOLLYARB_ARGV(4), SOLLYARB_ARGV(5), SOLLYARB_ARGV(6), SOLLYARB_ARGV(7), SOLLYARB_ARGV(8), SOLLYARB_ARGV(9), SOLLYARB_ARGV(10), SOLLYARB_ARGV(11), SOLLYARB_ARGV(12), NULL); break; \
+		case 14: func(SOLLYARB_ARGV(0), SOLLYARB_ARGV(1), SOLLYARB_ARGV(2), SOLLYARB_ARGV(3), SOLLYARB_ARGV(4), SOLLYARB_ARGV(5), SOLLYARB_ARGV(6), SOLLYARB_ARGV(7), SOLLYARB_ARGV(8), SOLLYARB_ARGV(9), SOLLYARB_ARGV(10), SOLLYARB_ARGV(11), SOLLYARB_ARGV(12), SOLLYARB_ARGV(13), NULL); break; \
+		case 15: func(SOLLYARB_ARGV(0), SOLLYARB_ARGV(1), SOLLYARB_ARGV(2), SOLLYARB_ARGV(3), SOLLYARB_ARGV(4), SOLLYARB_ARGV(5), SOLLYARB_ARGV(6), SOLLYARB_ARGV(7), SOLLYARB_ARGV(8), SOLLYARB_ARGV(9), SOLLYARB_ARGV(10), SOLLYARB_ARGV(11), SOLLYARB_ARGV(12), SOLLYARB_ARGV(13), SOLLYARB_ARGV(14), NULL); break; \
+		case 16: func(SOLLYARB_ARGV(0), SOLLYARB_ARGV(1), SOLLYARB_ARGV(2), SOLLYARB_ARGV(3), SOLLYARB_ARGV(4), SOLLYARB_ARGV(5), SOLLYARB_ARGV(6), SOLLYARB_ARGV(7), SOLLYARB_ARGV(8), SOLLYARB_ARGV(9), SOLLYARB_ARGV(10), SOLLYARB_ARGV(11), SOLLYARB_ARGV(12), SOLLYARB_ARGV(13), SOLLYARB_ARGV(14), SOLLYARB_ARGV(15), NULL); break; \
+		default: rb_raise(rb_eArgError, "expecting 4 to 16 arguments, got %d", argc); \
+	} \
+	return Qnil
+
+#define SOLLYARB_FUNC_VA_5(func) \
+	(void)self; \
+	switch (argc) { \
+		case  5: func(SOLLYARB_ARGV(0), SOLLYARB_ARGV(1), SOLLYARB_ARGV(2), SOLLYARB_ARGV(3), SOLLYARB_ARGV(4), NULL); break; \
+		case  6: func(SOLLYARB_ARGV(0), SOLLYARB_ARGV(1), SOLLYARB_ARGV(2), SOLLYARB_ARGV(3), SOLLYARB_ARGV(4), SOLLYARB_ARGV(5), NULL); break; \
+		case  7: func(SOLLYARB_ARGV(0), SOLLYARB_ARGV(1), SOLLYARB_ARGV(2), SOLLYARB_ARGV(3), SOLLYARB_ARGV(4), SOLLYARB_ARGV(5), SOLLYARB_ARGV(6), NULL); break; \
+		case  8: func(SOLLYARB_ARGV(0), SOLLYARB_ARGV(1), SOLLYARB_ARGV(2), SOLLYARB_ARGV(3), SOLLYARB_ARGV(4), SOLLYARB_ARGV(5), SOLLYARB_ARGV(6), SOLLYARB_ARGV(7), NULL); break; \
+		case  9: func(SOLLYARB_ARGV(0), SOLLYARB_ARGV(1), SOLLYARB_ARGV(2), SOLLYARB_ARGV(3), SOLLYARB_ARGV(4), SOLLYARB_ARGV(5), SOLLYARB_ARGV(6), SOLLYARB_ARGV(7), SOLLYARB_ARGV(8), NULL); break; \
+		case 10: func(SOLLYARB_ARGV(0), SOLLYARB_ARGV(1), SOLLYARB_ARGV(2), SOLLYARB_ARGV(3), SOLLYARB_ARGV(4), SOLLYARB_ARGV(5), SOLLYARB_ARGV(6), SOLLYARB_ARGV(7), SOLLYARB_ARGV(8), SOLLYARB_ARGV(9), NULL); break; \
+		case 11: func(SOLLYARB_ARGV(0), SOLLYARB_ARGV(1), SOLLYARB_ARGV(2), SOLLYARB_ARGV(3), SOLLYARB_ARGV(4), SOLLYARB_ARGV(5), SOLLYARB_ARGV(6), SOLLYARB_ARGV(7), SOLLYARB_ARGV(8), SOLLYARB_ARGV(9), SOLLYARB_ARGV(10), NULL); break; \
+		case 12: func(SOLLYARB_ARGV(0), SOLLYARB_ARGV(1), SOLLYARB_ARGV(2), SOLLYARB_ARGV(3), SOLLYARB_ARGV(4), SOLLYARB_ARGV(5), SOLLYARB_ARGV(6), SOLLYARB_ARGV(7), SOLLYARB_ARGV(8), SOLLYARB_ARGV(9), SOLLYARB_ARGV(10), SOLLYARB_ARGV(11), NULL); break; \
+		case 13: func(SOLLYARB_ARGV(0), SOLLYARB_ARGV(1), SOLLYARB_ARGV(2), SOLLYARB_ARGV(3), SOLLYARB_ARGV(4), SOLLYARB_ARGV(5), SOLLYARB_ARGV(6), SOLLYARB_ARGV(7), SOLLYARB_ARGV(8), SOLLYARB_ARGV(9), SOLLYARB_ARGV(10), SOLLYARB_ARGV(11), SOLLYARB_ARGV(12), NULL); break; \
+		case 14: func(SOLLYARB_ARGV(0), SOLLYARB_ARGV(1), SOLLYARB_ARGV(2), SOLLYARB_ARGV(3), SOLLYARB_ARGV(4), SOLLYARB_ARGV(5), SOLLYARB_ARGV(6), SOLLYARB_ARGV(7), SOLLYARB_ARGV(8), SOLLYARB_ARGV(9), SOLLYARB_ARGV(10), SOLLYARB_ARGV(11), SOLLYARB_ARGV(12), SOLLYARB_ARGV(13), NULL); break; \
+		case 15: func(SOLLYARB_ARGV(0), SOLLYARB_ARGV(1), SOLLYARB_ARGV(2), SOLLYARB_ARGV(3), SOLLYARB_ARGV(4), SOLLYARB_ARGV(5), SOLLYARB_ARGV(6), SOLLYARB_ARGV(7), SOLLYARB_ARGV(8), SOLLYARB_ARGV(9), SOLLYARB_ARGV(10), SOLLYARB_ARGV(11), SOLLYARB_ARGV(12), SOLLYARB_ARGV(13), SOLLYARB_ARGV(14), NULL); break; \
+		case 16: func(SOLLYARB_ARGV(0), SOLLYARB_ARGV(1), SOLLYARB_ARGV(2), SOLLYARB_ARGV(3), SOLLYARB_ARGV(4), SOLLYARB_ARGV(5), SOLLYARB_ARGV(6), SOLLYARB_ARGV(7), SOLLYARB_ARGV(8), SOLLYARB_ARGV(9), SOLLYARB_ARGV(10), SOLLYARB_ARGV(11), SOLLYARB_ARGV(12), SOLLYARB_ARGV(13), SOLLYARB_ARGV(14), SOLLYARB_ARGV(15), NULL); break; \
+		default: rb_raise(rb_eArgError, "expecting 5 to 16 arguments, got %d", argc); \
+	} \
+	return Qnil
+
+
+#define SOLLYARB_PROC_VA_1(func) \
+	(void)self; \
+	sollya_obj_t r; \
+	switch (argc) { \
+		case  1: r = func(SOLLYARB_ARGV(0), NULL); break; \
+		case  2: r = func(SOLLYARB_ARGV(0), SOLLYARB_ARGV(1), NULL); break; \
+		case  3: r = func(SOLLYARB_ARGV(0), SOLLYARB_ARGV(1), SOLLYARB_ARGV(2), NULL); break; \
+		case  4: r = func(SOLLYARB_ARGV(0), SOLLYARB_ARGV(1), SOLLYARB_ARGV(2), SOLLYARB_ARGV(3), NULL); break; \
+		case  5: r = func(SOLLYARB_ARGV(0), SOLLYARB_ARGV(1), SOLLYARB_ARGV(2), SOLLYARB_ARGV(3), SOLLYARB_ARGV(4), NULL); break; \
+		case  6: r = func(SOLLYARB_ARGV(0), SOLLYARB_ARGV(1), SOLLYARB_ARGV(2), SOLLYARB_ARGV(3), SOLLYARB_ARGV(4), SOLLYARB_ARGV(5), NULL); break; \
+		case  7: r = func(SOLLYARB_ARGV(0), SOLLYARB_ARGV(1), SOLLYARB_ARGV(2), SOLLYARB_ARGV(3), SOLLYARB_ARGV(4), SOLLYARB_ARGV(5), SOLLYARB_ARGV(6), NULL); break; \
+		case  8: r = func(SOLLYARB_ARGV(0), SOLLYARB_ARGV(1), SOLLYARB_ARGV(2), SOLLYARB_ARGV(3), SOLLYARB_ARGV(4), SOLLYARB_ARGV(5), SOLLYARB_ARGV(6), SOLLYARB_ARGV(7), NULL); break; \
+		case  9: r = func(SOLLYARB_ARGV(0), SOLLYARB_ARGV(1), SOLLYARB_ARGV(2), SOLLYARB_ARGV(3), SOLLYARB_ARGV(4), SOLLYARB_ARGV(5), SOLLYARB_ARGV(6), SOLLYARB_ARGV(7), SOLLYARB_ARGV(8), NULL); break; \
+		case 10: r = func(SOLLYARB_ARGV(0), SOLLYARB_ARGV(1), SOLLYARB_ARGV(2), SOLLYARB_ARGV(3), SOLLYARB_ARGV(4), SOLLYARB_ARGV(5), SOLLYARB_ARGV(6), SOLLYARB_ARGV(7), SOLLYARB_ARGV(8), SOLLYARB_ARGV(9), NULL); break; \
+		case 11: r = func(SOLLYARB_ARGV(0), SOLLYARB_ARGV(1), SOLLYARB_ARGV(2), SOLLYARB_ARGV(3), SOLLYARB_ARGV(4), SOLLYARB_ARGV(5), SOLLYARB_ARGV(6), SOLLYARB_ARGV(7), SOLLYARB_ARGV(8), SOLLYARB_ARGV(9), SOLLYARB_ARGV(10), NULL); break; \
+		case 12: r = func(SOLLYARB_ARGV(0), SOLLYARB_ARGV(1), SOLLYARB_ARGV(2), SOLLYARB_ARGV(3), SOLLYARB_ARGV(4), SOLLYARB_ARGV(5), SOLLYARB_ARGV(6), SOLLYARB_ARGV(7), SOLLYARB_ARGV(8), SOLLYARB_ARGV(9), SOLLYARB_ARGV(10), SOLLYARB_ARGV(11), NULL); break; \
+		case 13: r = func(SOLLYARB_ARGV(0), SOLLYARB_ARGV(1), SOLLYARB_ARGV(2), SOLLYARB_ARGV(3), SOLLYARB_ARGV(4), SOLLYARB_ARGV(5), SOLLYARB_ARGV(6), SOLLYARB_ARGV(7), SOLLYARB_ARGV(8), SOLLYARB_ARGV(9), SOLLYARB_ARGV(10), SOLLYARB_ARGV(11), SOLLYARB_ARGV(12), NULL); break; \
+		case 14: r = func(SOLLYARB_ARGV(0), SOLLYARB_ARGV(1), SOLLYARB_ARGV(2), SOLLYARB_ARGV(3), SOLLYARB_ARGV(4), SOLLYARB_ARGV(5), SOLLYARB_ARGV(6), SOLLYARB_ARGV(7), SOLLYARB_ARGV(8), SOLLYARB_ARGV(9), SOLLYARB_ARGV(10), SOLLYARB_ARGV(11), SOLLYARB_ARGV(12), SOLLYARB_ARGV(13), NULL); break; \
+		case 15: r = func(SOLLYARB_ARGV(0), SOLLYARB_ARGV(1), SOLLYARB_ARGV(2), SOLLYARB_ARGV(3), SOLLYARB_ARGV(4), SOLLYARB_ARGV(5), SOLLYARB_ARGV(6), SOLLYARB_ARGV(7), SOLLYARB_ARGV(8), SOLLYARB_ARGV(9), SOLLYARB_ARGV(10), SOLLYARB_ARGV(11), SOLLYARB_ARGV(12), SOLLYARB_ARGV(13), SOLLYARB_ARGV(14), NULL); break; \
+		case 16: r = func(SOLLYARB_ARGV(0), SOLLYARB_ARGV(1), SOLLYARB_ARGV(2), SOLLYARB_ARGV(3), SOLLYARB_ARGV(4), SOLLYARB_ARGV(5), SOLLYARB_ARGV(6), SOLLYARB_ARGV(7), SOLLYARB_ARGV(8), SOLLYARB_ARGV(9), SOLLYARB_ARGV(10), SOLLYARB_ARGV(11), SOLLYARB_ARGV(12), SOLLYARB_ARGV(13), SOLLYARB_ARGV(14), SOLLYARB_ARGV(15), NULL); break; \
+		default: rb_raise(rb_eArgError, "expecting 1 to 16 arguments, got %d", argc); \
+	} \
+	return sollyarb_autowrap_object(r)
+
+#define SOLLYARB_PROC_VA_2(func) \
+	(void)self; \
+	sollya_obj_t r; \
+	switch (argc) { \
+		case  2: r = func(SOLLYARB_ARGV(0), SOLLYARB_ARGV(1), NULL); break; \
+		case  3: r = func(SOLLYARB_ARGV(0), SOLLYARB_ARGV(1), SOLLYARB_ARGV(2), NULL); break; \
+		case  4: r = func(SOLLYARB_ARGV(0), SOLLYARB_ARGV(1), SOLLYARB_ARGV(2), SOLLYARB_ARGV(3), NULL); break; \
+		case  5: r = func(SOLLYARB_ARGV(0), SOLLYARB_ARGV(1), SOLLYARB_ARGV(2), SOLLYARB_ARGV(3), SOLLYARB_ARGV(4), NULL); break; \
+		case  6: r = func(SOLLYARB_ARGV(0), SOLLYARB_ARGV(1), SOLLYARB_ARGV(2), SOLLYARB_ARGV(3), SOLLYARB_ARGV(4), SOLLYARB_ARGV(5), NULL); break; \
+		case  7: r = func(SOLLYARB_ARGV(0), SOLLYARB_ARGV(1), SOLLYARB_ARGV(2), SOLLYARB_ARGV(3), SOLLYARB_ARGV(4), SOLLYARB_ARGV(5), SOLLYARB_ARGV(6), NULL); break; \
+		case  8: r = func(SOLLYARB_ARGV(0), SOLLYARB_ARGV(1), SOLLYARB_ARGV(2), SOLLYARB_ARGV(3), SOLLYARB_ARGV(4), SOLLYARB_ARGV(5), SOLLYARB_ARGV(6), SOLLYARB_ARGV(7), NULL); break; \
+		case  9: r = func(SOLLYARB_ARGV(0), SOLLYARB_ARGV(1), SOLLYARB_ARGV(2), SOLLYARB_ARGV(3), SOLLYARB_ARGV(4), SOLLYARB_ARGV(5), SOLLYARB_ARGV(6), SOLLYARB_ARGV(7), SOLLYARB_ARGV(8), NULL); break; \
+		case 10: r = func(SOLLYARB_ARGV(0), SOLLYARB_ARGV(1), SOLLYARB_ARGV(2), SOLLYARB_ARGV(3), SOLLYARB_ARGV(4), SOLLYARB_ARGV(5), SOLLYARB_ARGV(6), SOLLYARB_ARGV(7), SOLLYARB_ARGV(8), SOLLYARB_ARGV(9), NULL); break; \
+		case 11: r = func(SOLLYARB_ARGV(0), SOLLYARB_ARGV(1), SOLLYARB_ARGV(2), SOLLYARB_ARGV(3), SOLLYARB_ARGV(4), SOLLYARB_ARGV(5), SOLLYARB_ARGV(6), SOLLYARB_ARGV(7), SOLLYARB_ARGV(8), SOLLYARB_ARGV(9), SOLLYARB_ARGV(10), NULL); break; \
+		case 12: r = func(SOLLYARB_ARGV(0), SOLLYARB_ARGV(1), SOLLYARB_ARGV(2), SOLLYARB_ARGV(3), SOLLYARB_ARGV(4), SOLLYARB_ARGV(5), SOLLYARB_ARGV(6), SOLLYARB_ARGV(7), SOLLYARB_ARGV(8), SOLLYARB_ARGV(9), SOLLYARB_ARGV(10), SOLLYARB_ARGV(11), NULL); break; \
+		case 13: r = func(SOLLYARB_ARGV(0), SOLLYARB_ARGV(1), SOLLYARB_ARGV(2), SOLLYARB_ARGV(3), SOLLYARB_ARGV(4), SOLLYARB_ARGV(5), SOLLYARB_ARGV(6), SOLLYARB_ARGV(7), SOLLYARB_ARGV(8), SOLLYARB_ARGV(9), SOLLYARB_ARGV(10), SOLLYARB_ARGV(11), SOLLYARB_ARGV(12), NULL); break; \
+		case 14: r = func(SOLLYARB_ARGV(0), SOLLYARB_ARGV(1), SOLLYARB_ARGV(2), SOLLYARB_ARGV(3), SOLLYARB_ARGV(4), SOLLYARB_ARGV(5), SOLLYARB_ARGV(6), SOLLYARB_ARGV(7), SOLLYARB_ARGV(8), SOLLYARB_ARGV(9), SOLLYARB_ARGV(10), SOLLYARB_ARGV(11), SOLLYARB_ARGV(12), SOLLYARB_ARGV(13), NULL); break; \
+		case 15: r = func(SOLLYARB_ARGV(0), SOLLYARB_ARGV(1), SOLLYARB_ARGV(2), SOLLYARB_ARGV(3), SOLLYARB_ARGV(4), SOLLYARB_ARGV(5), SOLLYARB_ARGV(6), SOLLYARB_ARGV(7), SOLLYARB_ARGV(8), SOLLYARB_ARGV(9), SOLLYARB_ARGV(10), SOLLYARB_ARGV(11), SOLLYARB_ARGV(12), SOLLYARB_ARGV(13), SOLLYARB_ARGV(14), NULL); break; \
+		case 16: r = func(SOLLYARB_ARGV(0), SOLLYARB_ARGV(1), SOLLYARB_ARGV(2), SOLLYARB_ARGV(3), SOLLYARB_ARGV(4), SOLLYARB_ARGV(5), SOLLYARB_ARGV(6), SOLLYARB_ARGV(7), SOLLYARB_ARGV(8), SOLLYARB_ARGV(9), SOLLYARB_ARGV(10), SOLLYARB_ARGV(11), SOLLYARB_ARGV(12), SOLLYARB_ARGV(13), SOLLYARB_ARGV(14), SOLLYARB_ARGV(15), NULL); break; \
+		default: rb_raise(rb_eArgError, "expecting 2 to 16 arguments, got %d", argc); \
+	} \
+	return sollyarb_autowrap_object(r)
+
+#define SOLLYARB_PROC_VA_3(func) \
+	(void)self; \
+	sollya_obj_t r; \
+	switch (argc) { \
+		case  3: r = func(SOLLYARB_ARGV(0), SOLLYARB_ARGV(1), SOLLYARB_ARGV(2), NULL); break; \
+		case  4: r = func(SOLLYARB_ARGV(0), SOLLYARB_ARGV(1), SOLLYARB_ARGV(2), SOLLYARB_ARGV(3), NULL); break; \
+		case  5: r = func(SOLLYARB_ARGV(0), SOLLYARB_ARGV(1), SOLLYARB_ARGV(2), SOLLYARB_ARGV(3), SOLLYARB_ARGV(4), NULL); break; \
+		case  6: r = func(SOLLYARB_ARGV(0), SOLLYARB_ARGV(1), SOLLYARB_ARGV(2), SOLLYARB_ARGV(3), SOLLYARB_ARGV(4), SOLLYARB_ARGV(5), NULL); break; \
+		case  7: r = func(SOLLYARB_ARGV(0), SOLLYARB_ARGV(1), SOLLYARB_ARGV(2), SOLLYARB_ARGV(3), SOLLYARB_ARGV(4), SOLLYARB_ARGV(5), SOLLYARB_ARGV(6), NULL); break; \
+		case  8: r = func(SOLLYARB_ARGV(0), SOLLYARB_ARGV(1), SOLLYARB_ARGV(2), SOLLYARB_ARGV(3), SOLLYARB_ARGV(4), SOLLYARB_ARGV(5), SOLLYARB_ARGV(6), SOLLYARB_ARGV(7), NULL); break; \
+		case  9: r = func(SOLLYARB_ARGV(0), SOLLYARB_ARGV(1), SOLLYARB_ARGV(2), SOLLYARB_ARGV(3), SOLLYARB_ARGV(4), SOLLYARB_ARGV(5), SOLLYARB_ARGV(6), SOLLYARB_ARGV(7), SOLLYARB_ARGV(8), NULL); break; \
+		case 10: r = func(SOLLYARB_ARGV(0), SOLLYARB_ARGV(1), SOLLYARB_ARGV(2), SOLLYARB_ARGV(3), SOLLYARB_ARGV(4), SOLLYARB_ARGV(5), SOLLYARB_ARGV(6), SOLLYARB_ARGV(7), SOLLYARB_ARGV(8), SOLLYARB_ARGV(9), NULL); break; \
+		case 11: r = func(SOLLYARB_ARGV(0), SOLLYARB_ARGV(1), SOLLYARB_ARGV(2), SOLLYARB_ARGV(3), SOLLYARB_ARGV(4), SOLLYARB_ARGV(5), SOLLYARB_ARGV(6), SOLLYARB_ARGV(7), SOLLYARB_ARGV(8), SOLLYARB_ARGV(9), SOLLYARB_ARGV(10), NULL); break; \
+		case 12: r = func(SOLLYARB_ARGV(0), SOLLYARB_ARGV(1), SOLLYARB_ARGV(2), SOLLYARB_ARGV(3), SOLLYARB_ARGV(4), SOLLYARB_ARGV(5), SOLLYARB_ARGV(6), SOLLYARB_ARGV(7), SOLLYARB_ARGV(8), SOLLYARB_ARGV(9), SOLLYARB_ARGV(10), SOLLYARB_ARGV(11), NULL); break; \
+		case 13: r = func(SOLLYARB_ARGV(0), SOLLYARB_ARGV(1), SOLLYARB_ARGV(2), SOLLYARB_ARGV(3), SOLLYARB_ARGV(4), SOLLYARB_ARGV(5), SOLLYARB_ARGV(6), SOLLYARB_ARGV(7), SOLLYARB_ARGV(8), SOLLYARB_ARGV(9), SOLLYARB_ARGV(10), SOLLYARB_ARGV(11), SOLLYARB_ARGV(12), NULL); break; \
+		case 14: r = func(SOLLYARB_ARGV(0), SOLLYARB_ARGV(1), SOLLYARB_ARGV(2), SOLLYARB_ARGV(3), SOLLYARB_ARGV(4), SOLLYARB_ARGV(5), SOLLYARB_ARGV(6), SOLLYARB_ARGV(7), SOLLYARB_ARGV(8), SOLLYARB_ARGV(9), SOLLYARB_ARGV(10), SOLLYARB_ARGV(11), SOLLYARB_ARGV(12), SOLLYARB_ARGV(13), NULL); break; \
+		case 15: r = func(SOLLYARB_ARGV(0), SOLLYARB_ARGV(1), SOLLYARB_ARGV(2), SOLLYARB_ARGV(3), SOLLYARB_ARGV(4), SOLLYARB_ARGV(5), SOLLYARB_ARGV(6), SOLLYARB_ARGV(7), SOLLYARB_ARGV(8), SOLLYARB_ARGV(9), SOLLYARB_ARGV(10), SOLLYARB_ARGV(11), SOLLYARB_ARGV(12), SOLLYARB_ARGV(13), SOLLYARB_ARGV(14), NULL); break; \
+		case 16: r = func(SOLLYARB_ARGV(0), SOLLYARB_ARGV(1), SOLLYARB_ARGV(2), SOLLYARB_ARGV(3), SOLLYARB_ARGV(4), SOLLYARB_ARGV(5), SOLLYARB_ARGV(6), SOLLYARB_ARGV(7), SOLLYARB_ARGV(8), SOLLYARB_ARGV(9), SOLLYARB_ARGV(10), SOLLYARB_ARGV(11), SOLLYARB_ARGV(12), SOLLYARB_ARGV(13), SOLLYARB_ARGV(14), SOLLYARB_ARGV(15), NULL); break; \
+		default: rb_raise(rb_eArgError, "expecting 3 to 16 arguments, got %d", argc); \
+	} \
+	return sollyarb_autowrap_object(r)
+
+#define SOLLYARB_PROC_VA_4(func) \
+	(void)self; \
+	sollya_obj_t r; \
+	switch (argc) { \
+		case  4: r = func(SOLLYARB_ARGV(0), SOLLYARB_ARGV(1), SOLLYARB_ARGV(2), SOLLYARB_ARGV(3), NULL); break; \
+		case  5: r = func(SOLLYARB_ARGV(0), SOLLYARB_ARGV(1), SOLLYARB_ARGV(2), SOLLYARB_ARGV(3), SOLLYARB_ARGV(4), NULL); break; \
+		case  6: r = func(SOLLYARB_ARGV(0), SOLLYARB_ARGV(1), SOLLYARB_ARGV(2), SOLLYARB_ARGV(3), SOLLYARB_ARGV(4), SOLLYARB_ARGV(5), NULL); break; \
+		case  7: r = func(SOLLYARB_ARGV(0), SOLLYARB_ARGV(1), SOLLYARB_ARGV(2), SOLLYARB_ARGV(3), SOLLYARB_ARGV(4), SOLLYARB_ARGV(5), SOLLYARB_ARGV(6), NULL); break; \
+		case  8: r = func(SOLLYARB_ARGV(0), SOLLYARB_ARGV(1), SOLLYARB_ARGV(2), SOLLYARB_ARGV(3), SOLLYARB_ARGV(4), SOLLYARB_ARGV(5), SOLLYARB_ARGV(6), SOLLYARB_ARGV(7), NULL); break; \
+		case  9: r = func(SOLLYARB_ARGV(0), SOLLYARB_ARGV(1), SOLLYARB_ARGV(2), SOLLYARB_ARGV(3), SOLLYARB_ARGV(4), SOLLYARB_ARGV(5), SOLLYARB_ARGV(6), SOLLYARB_ARGV(7), SOLLYARB_ARGV(8), NULL); break; \
+		case 10: r = func(SOLLYARB_ARGV(0), SOLLYARB_ARGV(1), SOLLYARB_ARGV(2), SOLLYARB_ARGV(3), SOLLYARB_ARGV(4), SOLLYARB_ARGV(5), SOLLYARB_ARGV(6), SOLLYARB_ARGV(7), SOLLYARB_ARGV(8), SOLLYARB_ARGV(9), NULL); break; \
+		case 11: r = func(SOLLYARB_ARGV(0), SOLLYARB_ARGV(1), SOLLYARB_ARGV(2), SOLLYARB_ARGV(3), SOLLYARB_ARGV(4), SOLLYARB_ARGV(5), SOLLYARB_ARGV(6), SOLLYARB_ARGV(7), SOLLYARB_ARGV(8), SOLLYARB_ARGV(9), SOLLYARB_ARGV(10), NULL); break; \
+		case 12: r = func(SOLLYARB_ARGV(0), SOLLYARB_ARGV(1), SOLLYARB_ARGV(2), SOLLYARB_ARGV(3), SOLLYARB_ARGV(4), SOLLYARB_ARGV(5), SOLLYARB_ARGV(6), SOLLYARB_ARGV(7), SOLLYARB_ARGV(8), SOLLYARB_ARGV(9), SOLLYARB_ARGV(10), SOLLYARB_ARGV(11), NULL); break; \
+		case 13: r = func(SOLLYARB_ARGV(0), SOLLYARB_ARGV(1), SOLLYARB_ARGV(2), SOLLYARB_ARGV(3), SOLLYARB_ARGV(4), SOLLYARB_ARGV(5), SOLLYARB_ARGV(6), SOLLYARB_ARGV(7), SOLLYARB_ARGV(8), SOLLYARB_ARGV(9), SOLLYARB_ARGV(10), SOLLYARB_ARGV(11), SOLLYARB_ARGV(12), NULL); break; \
+		case 14: r = func(SOLLYARB_ARGV(0), SOLLYARB_ARGV(1), SOLLYARB_ARGV(2), SOLLYARB_ARGV(3), SOLLYARB_ARGV(4), SOLLYARB_ARGV(5), SOLLYARB_ARGV(6), SOLLYARB_ARGV(7), SOLLYARB_ARGV(8), SOLLYARB_ARGV(9), SOLLYARB_ARGV(10), SOLLYARB_ARGV(11), SOLLYARB_ARGV(12), SOLLYARB_ARGV(13), NULL); break; \
+		case 15: r = func(SOLLYARB_ARGV(0), SOLLYARB_ARGV(1), SOLLYARB_ARGV(2), SOLLYARB_ARGV(3), SOLLYARB_ARGV(4), SOLLYARB_ARGV(5), SOLLYARB_ARGV(6), SOLLYARB_ARGV(7), SOLLYARB_ARGV(8), SOLLYARB_ARGV(9), SOLLYARB_ARGV(10), SOLLYARB_ARGV(11), SOLLYARB_ARGV(12), SOLLYARB_ARGV(13), SOLLYARB_ARGV(14), NULL); break; \
+		case 16: r = func(SOLLYARB_ARGV(0), SOLLYARB_ARGV(1), SOLLYARB_ARGV(2), SOLLYARB_ARGV(3), SOLLYARB_ARGV(4), SOLLYARB_ARGV(5), SOLLYARB_ARGV(6), SOLLYARB_ARGV(7), SOLLYARB_ARGV(8), SOLLYARB_ARGV(9), SOLLYARB_ARGV(10), SOLLYARB_ARGV(11), SOLLYARB_ARGV(12), SOLLYARB_ARGV(13), SOLLYARB_ARGV(14), SOLLYARB_ARGV(15), NULL); break; \
+		default: rb_raise(rb_eArgError, "expecting 4 to 16 arguments, got %d", argc); \
+	} \
+	return sollyarb_autowrap_object(r)
+
+#define SOLLYARB_PROC_VA_5(func) \
+	(void)self; \
+	sollya_obj_t r; \
+	switch (argc) { \
+		case  5: r = func(SOLLYARB_ARGV(0), SOLLYARB_ARGV(1), SOLLYARB_ARGV(2), SOLLYARB_ARGV(3), SOLLYARB_ARGV(4), NULL); break; \
+		case  6: r = func(SOLLYARB_ARGV(0), SOLLYARB_ARGV(1), SOLLYARB_ARGV(2), SOLLYARB_ARGV(3), SOLLYARB_ARGV(4), SOLLYARB_ARGV(5), NULL); break; \
+		case  7: r = func(SOLLYARB_ARGV(0), SOLLYARB_ARGV(1), SOLLYARB_ARGV(2), SOLLYARB_ARGV(3), SOLLYARB_ARGV(4), SOLLYARB_ARGV(5), SOLLYARB_ARGV(6), NULL); break; \
+		case  8: r = func(SOLLYARB_ARGV(0), SOLLYARB_ARGV(1), SOLLYARB_ARGV(2), SOLLYARB_ARGV(3), SOLLYARB_ARGV(4), SOLLYARB_ARGV(5), SOLLYARB_ARGV(6), SOLLYARB_ARGV(7), NULL); break; \
+		case  9: r = func(SOLLYARB_ARGV(0), SOLLYARB_ARGV(1), SOLLYARB_ARGV(2), SOLLYARB_ARGV(3), SOLLYARB_ARGV(4), SOLLYARB_ARGV(5), SOLLYARB_ARGV(6), SOLLYARB_ARGV(7), SOLLYARB_ARGV(8), NULL); break; \
+		case 10: r = func(SOLLYARB_ARGV(0), SOLLYARB_ARGV(1), SOLLYARB_ARGV(2), SOLLYARB_ARGV(3), SOLLYARB_ARGV(4), SOLLYARB_ARGV(5), SOLLYARB_ARGV(6), SOLLYARB_ARGV(7), SOLLYARB_ARGV(8), SOLLYARB_ARGV(9), NULL); break; \
+		case 11: r = func(SOLLYARB_ARGV(0), SOLLYARB_ARGV(1), SOLLYARB_ARGV(2), SOLLYARB_ARGV(3), SOLLYARB_ARGV(4), SOLLYARB_ARGV(5), SOLLYARB_ARGV(6), SOLLYARB_ARGV(7), SOLLYARB_ARGV(8), SOLLYARB_ARGV(9), SOLLYARB_ARGV(10), NULL); break; \
+		case 12: r = func(SOLLYARB_ARGV(0), SOLLYARB_ARGV(1), SOLLYARB_ARGV(2), SOLLYARB_ARGV(3), SOLLYARB_ARGV(4), SOLLYARB_ARGV(5), SOLLYARB_ARGV(6), SOLLYARB_ARGV(7), SOLLYARB_ARGV(8), SOLLYARB_ARGV(9), SOLLYARB_ARGV(10), SOLLYARB_ARGV(11), NULL); break; \
+		case 13: r = func(SOLLYARB_ARGV(0), SOLLYARB_ARGV(1), SOLLYARB_ARGV(2), SOLLYARB_ARGV(3), SOLLYARB_ARGV(4), SOLLYARB_ARGV(5), SOLLYARB_ARGV(6), SOLLYARB_ARGV(7), SOLLYARB_ARGV(8), SOLLYARB_ARGV(9), SOLLYARB_ARGV(10), SOLLYARB_ARGV(11), SOLLYARB_ARGV(12), NULL); break; \
+		case 14: r = func(SOLLYARB_ARGV(0), SOLLYARB_ARGV(1), SOLLYARB_ARGV(2), SOLLYARB_ARGV(3), SOLLYARB_ARGV(4), SOLLYARB_ARGV(5), SOLLYARB_ARGV(6), SOLLYARB_ARGV(7), SOLLYARB_ARGV(8), SOLLYARB_ARGV(9), SOLLYARB_ARGV(10), SOLLYARB_ARGV(11), SOLLYARB_ARGV(12), SOLLYARB_ARGV(13), NULL); break; \
+		case 15: r = func(SOLLYARB_ARGV(0), SOLLYARB_ARGV(1), SOLLYARB_ARGV(2), SOLLYARB_ARGV(3), SOLLYARB_ARGV(4), SOLLYARB_ARGV(5), SOLLYARB_ARGV(6), SOLLYARB_ARGV(7), SOLLYARB_ARGV(8), SOLLYARB_ARGV(9), SOLLYARB_ARGV(10), SOLLYARB_ARGV(11), SOLLYARB_ARGV(12), SOLLYARB_ARGV(13), SOLLYARB_ARGV(14), NULL); break; \
+		case 16: r = func(SOLLYARB_ARGV(0), SOLLYARB_ARGV(1), SOLLYARB_ARGV(2), SOLLYARB_ARGV(3), SOLLYARB_ARGV(4), SOLLYARB_ARGV(5), SOLLYARB_ARGV(6), SOLLYARB_ARGV(7), SOLLYARB_ARGV(8), SOLLYARB_ARGV(9), SOLLYARB_ARGV(10), SOLLYARB_ARGV(11), SOLLYARB_ARGV(12), SOLLYARB_ARGV(13), SOLLYARB_ARGV(14), SOLLYARB_ARGV(15), NULL); break; \
+		default: rb_raise(rb_eArgError, "expecting 5 to 16 arguments, got %d", argc); \
+	} \
+	return sollyarb_autowrap_object(r)
+
+
+
+static VALUE sollyarb_list(int argc, VALUE *argv, VALUE self)
+{
+	VALUE splat;
+	VALUE kw;
+	const ID kwkeys[1] = {id_end_elliptic};
+	VALUE kwvalues[1] = {Qundef};
+	int is_end_elliptic = 0;
+	rb_scan_args(argc, argv, "*:", &splat, &kw);
+	if (!NIL_P(kw)) {
+		rb_get_kwargs(kw, kwkeys, 0, 1, kwvalues);
+		if (kwvalues[0] != Qundef) {
+			if (RB_TEST(kwvalues[0])) {
+				is_end_elliptic = 1;
+			}
+		}
+	}
+
+	long i;
+	long l = rb_array_len(splat);
+	sollya_obj_t *carr = malloc(l*sizeof(sollya_obj_t));
+	sollya_obj_t r;
+	for (i = 0; i < l; i++) {
+		carr[i] = SOLLYARB_TO_SOLLYA(rb_ary_entry(splat, i));
+	}
+	if (is_end_elliptic) {
+		r = sollya_lib_end_elliptic_list(carr, l);
+	} else {
+		r = sollya_lib_list(carr, l);
+	}
+	free(carr);
+	return sollyarb_autowrap_object(r);
+}
+
+
+static VALUE sollyarb_list_is_end_elliptic(VALUE self)
+{
+	sollya_obj_t l = sollyarb_object_rb2ref(self);
+	if (sollya_lib_obj_is_end_elliptic_list(l))
+		return Qtrue;
+	if (sollya_lib_obj_is_list(l))
+		return Qfalse;
+	return Qfalse;
+}
+
+
+/* @return [MPFR]
+ */
+static VALUE sollyarb_range_lower_bound(VALUE self)
+{
+	sollya_obj_t rng = sollyarb_object_rb2ref(self);
+	mp_prec_t prec = 0;
+	if (!sollya_lib_get_prec_of_range(&prec, rng)) {
+		sollya_obj_t p = sollya_lib_get_prec();
+		sollya_lib_get_constant_as_int64(&prec, p);
+		sollya_lib_clear_obj(p);
+	}
+	if (!prec) {
+		return Qnil;
+	}
+	VALUE mprb = mpfrrb_alloc(c_MPFR);
+	mpfr_ptr mp = mpfrrb_rb2ref_ext(mprb);
+	mpfr_init2(mp, prec);
+
+	mpfr_t dummy;
+	mpfr_init2(dummy, 32);
+	if (!sollya_lib_get_bounds_from_range(mp, dummy, rng)) {
+		mpfr_clear(dummy);
+		return Qnil;
+	}
+	return mprb;
+}
+
+
+/* @return [MPFR]
+ */
+static VALUE sollyarb_range_upper_bound(VALUE self)
+{
+	sollya_obj_t rng = sollyarb_object_rb2ref(self);
+	mp_prec_t prec = 0;
+	if (!sollya_lib_get_prec_of_range(&prec, rng)) {
+		sollya_obj_t p = sollya_lib_get_prec();
+		sollya_lib_get_constant_as_int64(&prec, p);
+		sollya_lib_clear_obj(p);
+	}
+	if (!prec) {
+		return Qnil;
+	}
+	VALUE mprb = mpfrrb_alloc(c_MPFR);
+	mpfr_ptr mp = mpfrrb_rb2ref_ext(mprb);
+	mpfr_init2(mp, prec);
+
+	mpfr_t dummy;
+	mpfr_init2(dummy, 32);
+	if (!sollya_lib_get_bounds_from_range(dummy, mp, rng)) {
+		mpfr_clear(dummy);
+		return Qnil;
+	}
+	return mprb;
+}
+
+
+/* @return [Sollya::Range]
+ */
+static VALUE sollyarb_range(VALUE self, VALUE inf, VALUE sup)
+{
+	return sollyarb_autowrap_object(sollya_lib_range(SOLLYARB_TO_SOLLYA(inf), SOLLYARB_TO_SOLLYA(sup)));
+}
+
+
+/* @param str [String]
+ * @return [Sollya::Object]
+ */
+static VALUE sollyarb_parse(VALUE self, VALUE str)
+{
+	(void)self;
+	str = rb_funcallv(str, id_to_s, 0, NULL);
+	const char *cstr = rb_string_value_cstr(&str);
+	sollya_obj_t sr = sollya_lib_parse_string(cstr);
+	RB_GC_GUARD(str);
+	return sollyarb_autowrap_object(sr);
+}
+
+
+/* Returns the precision of the floating-point format used in numerical computations.
+ * Many commands try to adapt their working precision in order to have approximately _𝑛_ correct bits in output,
+ * where _𝑛_ is the value of `prec`.
+ * @return [Integer]
+ */
+static VALUE sollyarb_get_prec(VALUE self)
+{
+	sollya_obj_t p = sollya_lib_get_prec();
+	int64_t i;
+	int r = sollya_lib_get_constant_as_int64(&i, p);
+	sollya_lib_clear_obj(p);
+	if (!r) {
+		rb_raise(rb_eRuntimeError, "Cannot get prec as integer");
+	}
+	return LL2NUM(i);
+}
+
+
+/* Set the precision of the floating-point format used in numerical computations.
+ * That is, the number of bits of the significand of floating-point numbers.
+ * @param prec [Integer]
+ * @return [Integer]
+ */
+static VALUE sollyarb_set_prec(VALUE self, VALUE prec)
+{
+	sollya_obj_t p = sollya_lib_constant_from_int(NUM2INT(prec));
+	sollya_lib_set_prec(p);
+	sollya_lib_clear_obj(p);
+	return prec;
+}
+
+
+/* Returns the number of points chosen by Sollya in certain commands.
+ * Its value represents the number of points used in numerical algorithms
+ * of Sollya (namely {dirtyinfnorm}, {dirtyintegral}, {dirtyfindzeros} and {plot}).
+ * @return [Integer]
+ * @see points=
+ */
+static VALUE sollyarb_get_points(VALUE self)
+{
+	sollya_obj_t p = sollya_lib_get_points();
+	int64_t i;
+	int r = sollya_lib_get_constant_as_int64(&i, p);
+	sollya_lib_clear_obj(p);
+	if (!r) {
+		rb_raise(rb_eRuntimeError, "Cannot get points as integer");
+	}
+	return LL2NUM(i);
+}
+
+
+/* Set the number of points chosen by Sollya in certain commands.
+ * @param [Integer]
+ * @return [Integer]
+ * @see points
+ */
+static VALUE sollyarb_set_points(VALUE self, VALUE points)
+{
+	sollya_obj_t p = sollya_lib_constant_from_int(NUM2INT(points));
+	sollya_lib_set_points(p);
+	sollya_lib_clear_obj(p);
+	return points;
+}
+
+
+/* Returns the maximal width allowed for intervals involved in safe algorithms of Sollya.
+ * These are {infnorm}, {checkinfnorm}, {accurateinfnorm}, {integral}, {findzeros} and {supnorm}.
+ * More precisely, _diam_ is relative to the width of the input interval of the command.
+ * For instance, suppose that diam=1e-5: if infnorm is called on interval [0, 1], the maximal width of an interval
+ * will be 1e-5. But if it is called on interval [0, 1e-3], the maximal width will be 1e-8.
+ * @return [MPFR,Float] the maximal relative width of the intervals used
+ * @see diam=
+ */
+static VALUE sollyarb_get_diam(VALUE self)
+{
+	sollya_obj_t c = sollya_lib_get_diam();
+	mp_prec_t prec = 0;
+	if (!sollya_lib_get_prec_of_constant(&prec, c)) {
+		sollya_obj_t p = sollya_lib_get_prec();
+		sollya_lib_get_constant_as_int64(&prec, p);
+		sollya_lib_clear_obj(p);
+	}
+	if (!prec) return Qnil;
+	if (prec <= 53) {
+		double d;
+		if (sollya_lib_get_constant_as_double(&d, c))
+			return DBL2NUM(d);
+	}
+	VALUE mprb = mpfrrb_alloc(c_MPFR);
+	mpfr_ptr mp = mpfrrb_rb2ref_ext(mprb);
+	mpfr_init2(mp, prec);
+	if (!sollya_lib_get_constant(mp, c)) {
+		return Qnil;
+	}
+	return mprb;
+}
+
+
+/* Sets the maximal width allowed for intervals involved in safe algorithms of Sollya.
+ * These are {infnorm}, {checkinfnorm}, {accurateinfnorm}, {integral}, {findzeros} and {supnorm}.
+ * More precisely, _diam_ is relative to the width of the input interval of the command.
+ * For instance, suppose that diam=1e-5: if infnorm is called on interval [0, 1], the maximal width of an interval
+ * will be 1e-5. But if it is called on interval [0, 1e-3], the maximal width will be 1e-8.
+ * @param width [MPFR] the maximal relative width of the intervals used
+ * @return [MPFR,Float]
+ * @see diam
+ */
+static VALUE sollyarb_set_diam(VALUE self, VALUE width)
+{
+	width = rb_funcallv(width, id_to_sollya, 0, NULL);
+	sollya_obj_t w = sollyarb_object_rb2ref(width);
+	sollya_lib_set_diam(w);
+	return width;
+}
+
+
+/* Gets the global variable specifying number notation.
+ * @see display=
+ * @return [Symbol] `:decimal`, `:dyadic`, `:powers`, `:binary` or `:hexadecimal`
+ */
+static VALUE sollyarb_get_display(VALUE self)
+{
+	sollya_obj_t c = sollya_lib_get_display();
+	if (sollya_lib_is_decimal(c)) {
+		sollya_lib_clear_obj(c);
+		return ID2SYM(id_decimal);
+	} else if (sollya_lib_is_binary(c)) {
+		sollya_lib_clear_obj(c);
+		return ID2SYM(id_binary);
+	} else if (sollya_lib_is_dyadic(c)) {
+		sollya_lib_clear_obj(c);
+		return ID2SYM(id_dyadic);
+	} else if (sollya_lib_is_powers(c)) {
+		sollya_lib_clear_obj(c);
+		return ID2SYM(id_powers);
+	} else if (sollya_lib_is_hexadecimal(c)) {
+		sollya_lib_clear_obj(c);
+		return ID2SYM(id_hexadecimal);
+	}
+	return sollyarb_autowrap_object(c);
+}
+
+
+/* Gets the global variable specifying number notation.
+ * An assignment `display = notation_value`, where notation value is one of `:decimal`, `:dyadic`, `:powers`,
+ * `:binary` or `:hexadecimal`, activates the corresponding notation for output of values in print, write
+ * or at the Sollya prompt.
+ *
+ * - If the global notation variable display is `:decimal`, all numbers will be output in scientific decimal notation.
+ * - If the global notation variable display is `:dyadic`, all numbers will be output as dyadic numbers with Gappa notation.
+ * - If the global notation variable display is `:powers`, all numbers will be output as dyadic numbers with a notation
+ *   compatible with Maple and PARI/GP.
+ * - If the global notation variable display is `:binary`, all numbers will be output in binary notation.
+ * - If the global notation variable display is `:hexadecimal`, all numbers will be output in C99/ IEEE754-2008 notation.
+ *
+ * All output notations can be parsed back by Sollya, inducing no error if the input and
+ * output precisions are the same (see {prec}).
+ * @param display_notation [Symbol] `:decimal`, `:dyadic`, `:powers`, `:binary` or `:hexadecimal`
+ */
+static VALUE sollyarb_set_display(VALUE self, VALUE notation_value)
+{
+	notation_value = rb_funcallv(notation_value, id_to_sollya, 0, NULL);
+	sollya_obj_t nv = sollyarb_object_rb2ref(notation_value);
+	sollya_lib_set_display(nv);
+	return notation_value;
+}
+
+
+
+/* Returns the verbosity level.
+ * At level 0, commands do not display anything on standard output.
+ * Default level is 1. It displays important information such as warnings when roundings happen.
+ * @return [Integer]
+ * @see verbosity=
+ */
+static VALUE sollyarb_get_verbosity(VALUE self)
+{
+	sollya_obj_t p = sollya_lib_get_verbosity();
+	int64_t i;
+	if (!sollya_lib_get_constant_as_int64(&i, p)) return Qnil;
+	sollya_lib_clear_obj(p);
+	return LL2NUM(i);
+}
+
+
+/* Set the amount of information displayed by commands.
+ * At level 0, commands do not display anything on standard output.
+ * Note that very critical information may however be displayed on standard error.
+ * Default level is 1. It displays important information such as warnings when roundings happen.
+ * For higher levels more information is displayed depending on the command.
+ * @param n [Integer] level of verbosity
+ * @return [Integer]
+ * @see verbosity
+ * @see roundingwarnings
+ * @see suppressmessage
+ */
+static VALUE sollyarb_set_verbosity(VALUE self, VALUE n)
+{
+	sollya_obj_t p = sollya_lib_constant_from_int(NUM2INT(n));
+	sollya_lib_set_verbosity(p);
+	sollya_lib_clear_obj(p);
+	return n;
+}
+
+
+/* Returns whether or not a warning is displayed when roundings occur.
+ * When it is `true`, warnings are emitted in appropriate verbosity modes (see {verbosity}) when roundings occur.
+ * When it is `false`, these warnings are suppressed.
+ *
+ * This mode depends on a verbosity of at least 1. See {verbosity} for more details.
+ *
+ * Default is `true` when the standard input is a terminal and `false` when Sollya input is read from a file.
+ * @see roundingwarnings=
+ * @return [Boolean]
+ */
+static VALUE sollyarb_get_roundingwarnings(VALUE self)
+{
+	sollya_obj_t w = sollya_lib_get_roundingwarnings();
+	if (sollya_lib_is_on(w)) {
+		sollya_lib_clear_obj(w);
+		return Qtrue;
+	} else if (sollya_lib_is_off(w)) {
+		sollya_lib_clear_obj(w);
+		return Qfalse;
+	}
+	return sollyarb_autowrap_object(w);
+}
+
+
+/* Sets whether or not a warning is displayed when roundings occur.
+ * When set to `true`, warnings are emitted in appropriate verbosity modes (see {verbosity}) when roundings occur.
+ * When set to `false`, these warnings are suppressed.
+ * @param v [Boolean]
+ * @return [Boolean]
+ * @see roundingwarnings
+ */
+static VALUE sollyarb_set_roundingwarnings(VALUE self, VALUE v)
+{
+	sollya_obj_t w = (v != sollyarb_cst_OFF && v != sollyarb_cst_FALSE && (v == sollyarb_cst_ON || RB_TEST(v))) ? sollyarb_object_rb2ref(sollyarb_cst_ON) : sollyarb_object_rb2ref(sollyarb_cst_OFF);
+	sollya_lib_set_roundingwarnings(w);
+	return v;
+}
+
+
+/* Returns the value of the automatic simplification state variable.
+ * @see autosimplify=
+ * @return [Boolean]
+ */
+static VALUE sollyarb_get_autosimplify(VALUE self)
+{
+	sollya_obj_t w = sollya_lib_get_autosimplify();
+	if (sollya_lib_is_on(w)) {
+		sollya_lib_clear_obj(w);
+		return Qtrue;
+	} else if (sollya_lib_is_off(w)) {
+		sollya_lib_clear_obj(w);
+		return Qfalse;
+	}
+	return sollyarb_autowrap_object(w);
+}
+
+
+/* Activates or deactivates automatic simplification.
+ * That is, the automatic safe simplification of expressions of functions generated
+ * by the evaluation of commands or in argument of other commands.
+ *
+ * Sollya commands like {remez}, {taylor} or {rationalapprox} sometimes produce expressions that
+ * can be simplified. Constant subexpressions can be evaluated to dyadic floating-point numbers,
+ * monomials with coefficients 0 can be eliminated. Further, expressions indicated by the user perform
+ * better in many commands when simplified before being passed in argument to a command. When
+ * the automatic simplification of expressions is activated, Sollya automatically performs a safe (not
+ * value changing) simplification process on such expressions.
+ *
+ * The automatic generation of subexpressions can be annoying, in particular if it takes too much
+ * time for not enough benefit. Further the user might want to inspect the structure of the expression
+ * tree returned by a command. In this case, the automatic simplification should be deactivated.
+ * @param v [Boolean]
+ * @return [Boolean]
+ * @see autosimplify
+ */
+static VALUE sollyarb_set_autosimplify(VALUE self, VALUE v)
+{
+	sollya_obj_t w = (v != sollyarb_cst_OFF && v != sollyarb_cst_FALSE && (v == sollyarb_cst_ON || RB_TEST(v))) ? sollyarb_object_rb2ref(sollyarb_cst_ON) : sollyarb_object_rb2ref(sollyarb_cst_OFF);
+	sollya_lib_set_autosimplify(w);
+	return v;
+}
+
+
+/* Returns the value of the state variable controlling output with full parenthesising.
+ * @see fullparentheses=
+ * @return [Boolean]
+ */
+static VALUE sollyarb_get_fullparentheses(VALUE self)
+{
+	sollya_obj_t w = sollya_lib_get_fullparentheses();
+	if (sollya_lib_is_on(w)) {
+		sollya_lib_clear_obj(w);
+		return Qtrue;
+	} else if (sollya_lib_is_off(w)) {
+		sollya_lib_clear_obj(w);
+		return Qfalse;
+	}
+	return sollyarb_autowrap_object(w);
+}
+
+
+/* Activates or deactivates the output of expressions with full parenthesising.
+ * In full parenthesising mode, Sollya commands like {print}, {write} and the implicit command when an expression
+ * is given at the prompt will output expressions with parenthesising at all places where it is necessary
+ * for expressions containing infix operators to be parsed back with the same result. Otherwise
+ * parentheses around associative operators are omitted.
+ * @param v [Boolean]
+ * @return [Boolean]
+ * @see fullparentheses
+ */
+static VALUE sollyarb_set_fullparentheses(VALUE self, VALUE v)
+{
+	sollya_obj_t w = (v != sollyarb_cst_OFF && v != sollyarb_cst_FALSE && (v == sollyarb_cst_ON || RB_TEST(v))) ? sollyarb_object_rb2ref(sollyarb_cst_ON) : sollyarb_object_rb2ref(sollyarb_cst_OFF);
+	sollya_lib_set_fullparentheses(w);
+	return v;
+}
+
+
+/* Returns whether message numbers are displayed in messages.
+ * @see showmessagenumbers=
+ * @return [Boolean]
+ */
+static VALUE sollyarb_get_showmessagenumbers(VALUE self)
+{
+	sollya_obj_t w = sollya_lib_get_showmessagenumbers();
+	if (sollya_lib_is_on(w)) {
+		sollya_lib_clear_obj(w);
+		return Qtrue;
+	} else if (sollya_lib_is_off(w)) {
+		sollya_lib_clear_obj(w);
+		return Qfalse;
+	}
+	return sollyarb_autowrap_object(w);
+}
+
+
+/* Activates or deactivates the displaying of numbers for warning and information
+ * messages. Every Sollya warning or information message (that is not fatal to the tool's execution)
+ * has a message number. By default, these numbers are not displayed when a message is output.
+ * When message number displaying is activated, the message numbers are displayed together with
+ * the message. This allows the user to recover the number of a particular message in order to
+ * suppress resp. unsuppress the displaying of this particular message (see suppressmessage and
+ * unsuppressmessage).
+ * 
+ * The user should be aware of the fact that message number display activation resp. deactivation
+ * through showmessagenumbers does not affect message displaying in general. For instance, even
+ * with message number displaying activated, messages with only displayed when general verbosity
+ * and rounding warning mode are set accordingly.
+ * @param v [Boolean]
+ * @return [Boolean]
+ * @see showmessagenumbers
+ */
+static VALUE sollyarb_set_showmessagenumbers(VALUE self, VALUE v)
+{
+	sollya_obj_t w = (v != sollyarb_cst_OFF && v != sollyarb_cst_FALSE && (v == sollyarb_cst_ON || RB_TEST(v))) ? sollyarb_object_rb2ref(sollyarb_cst_ON) : sollyarb_object_rb2ref(sollyarb_cst_OFF);
+	sollya_lib_set_showmessagenumbers(w);
+	return v;
+}
+
+
+/* Returns the the way intervals are displayed.
+ * @return [Boolean]
+ * @see midpointmode=
+ */
+static VALUE sollyarb_get_midpointmode(VALUE self)
+{
+	sollya_obj_t w = sollya_lib_get_midpointmode();
+	if (sollya_lib_is_on(w)) {
+		sollya_lib_clear_obj(w);
+		return Qtrue;
+	} else if (sollya_lib_is_off(w)) {
+		sollya_lib_clear_obj(w);
+		return Qfalse;
+	}
+	return sollyarb_autowrap_object(w);
+}
+
+/* Enables or disables midpoint mode.
+ * When not activated, intervals are displayed as usual (in the form [𝑎; 𝑏]).
+ * When it is on, and if _𝑎_ and _𝑏_ have the same first significant digits, the interval
+ * in displayed in a way that lets one immediately see the common digits of the two bounds.
+ *
+ * This mode is supported only with {display} set to `:decimal`.
+ * In other modes of {display}, midpointmode value is simply ignored.
+ * @param v [Boolean]
+ * @return [Boolean]
+ * @see midpointmode
+ */
+static VALUE sollyarb_set_midpointmode(VALUE self, VALUE v)
+{
+	sollya_obj_t w = (v != sollyarb_cst_OFF && v != sollyarb_cst_FALSE && (v == sollyarb_cst_ON || RB_TEST(v))) ? sollyarb_object_rb2ref(sollyarb_cst_ON) : sollyarb_object_rb2ref(sollyarb_cst_OFF);
+	sollya_lib_set_midpointmode(w);
+	return v;
+}
+
+
+/* Without arguments, returns the global variable controlling the canonical form printing;
+ * with an expression argument, brings all polynomial subexpressions to canonical form.
+ *
+ * @overload canonical
+ *  @return [Boolean] canonical form printing
+ *  @see canonical=
+ *
+ * The command canonical rewrites the expression representing the function `expr` in a way such
+ * that all polynomial subexpressions (or the whole expression itself, if it is a polynomial) are written
+ * in canonical form, i.e. as a sum of monomials in the canonical base. The canonical base is the
+ * base of the integer powers of the global free variable. The command canonical does not endanger
+ * the safety of computations even in Sollya's floating-point environment: the function returned is
+ * mathematically equal to the function function.
+ * @overload canonical(expr)
+ *  @param expr [Function] the expression to be rewritten in canonical form
+ *  @return [Function]
+ */
+static VALUE sollyarb_get_canonical(int argc, VALUE *argv, VALUE self)
+{
+	if (argc == 0) {
+		sollya_obj_t w = sollya_lib_get_canonical();
+		if (sollya_lib_is_on(w)) {
+			sollya_lib_clear_obj(w);
+			return Qtrue;
+		} else if (sollya_lib_is_off(w)) {
+			sollya_lib_clear_obj(w);
+			return Qfalse;
+		}
+		return sollyarb_autowrap_object(w);
+	} else if (argc == 1) {
+		argv[0] = rb_funcallv(argv[0], id_to_sollya, 0, NULL);
+		sollya_obj_t r = sollya_lib_canonical(sollyarb_object_rb2ref(argv[0]));
+		return sollyarb_autowrap_object(r);
+	} else {
+		rb_raise(rb_eArgError, "wrong number of arguments (given %d, expected 0..1)", argc);
+	}
+}
+
+/* Enables or disables canonical form printing.
+ * Canonical form printing is the automatic printing of polynomial expressions in canonical form, i.e. as
+ * a sum of monomials in the canonical base. If automatic printing in canonical form is deactivated,
+ * automatic printing yields to displaying polynomial subexpressions in Horner form.
+ * @param v [Boolean]
+ * @return [Boolean]
+ * @see canonical
+ */
+static VALUE sollyarb_set_canonical(VALUE self, VALUE v)
+{
+	sollya_obj_t w = (v != sollyarb_cst_OFF && v != sollyarb_cst_FALSE && (v == sollyarb_cst_ON || RB_TEST(v))) ? sollyarb_object_rb2ref(sollyarb_cst_ON) : sollyarb_object_rb2ref(sollyarb_cst_OFF);
+	sollya_lib_set_canonical(w);
+	return v;
+}
+
+
+/* Returns if rational arithmetic is used or not.
+ * @return [Boolean]
+ * @see rationalmode=
+ */
+static VALUE sollyarb_get_rationalmode(VALUE self)
+{
+	sollya_obj_t w = sollya_lib_get_rationalmode();
+	if (sollya_lib_is_on(w)) {
+		sollya_lib_clear_obj(w);
+		return Qtrue;
+	} else if (sollya_lib_is_off(w)) {
+		sollya_lib_clear_obj(w);
+		return Qfalse;
+	}
+	return sollyarb_autowrap_object(w);
+}
+
+/* Sets whether rational arithmetic should be used or not.
+ * _rationalmode_ is a global variable. When its value is off, which is the default, Sollya will
+ * not use rational arithmetic to simplify expressions. All computations, including the evaluation
+ * of constant expressions given on the Sollya prompt, will be performed using floating-point and
+ * interval arithmetic. Constant expressions will be approximated by floating-point numbers, which
+ * are in most cases faithful roundings of the expressions, when shown at the prompt.
+ * 
+ * When it is on, Sollya will use rational arithmetic
+ * when simplifying expressions. Constant expressions, given at the Sollya prompt, will be simplified
+ * to rational numbers and displayed as such when they are in the set of the rational numbers. Other-
+ * wise, floating-point and interval arithmetic will be used to compute a floating-point approximation,
+ * which is in most cases a faithful rounding of the constant expression.
+ * 
+ * When a decimal value is parsed, the behavior of Sollya is different depending on the value of
+ * the global variable rationalmode. If it is off, the value gets rounded as a floating-point at
+ * precision prec. But if rationalmode is set to on, the decimal value is interpreted exactly and
+ * converted as a rational number of the form 𝑀/10𝑁 where 𝑀 and 𝑁 are integers. Accordingly, when
+ * rationalmode is set to on and display is set to decimal, all floating-point values are displayed
+ * exactly: indeed, any floating-point number with radix 2 has a finite decimal expansion. Therefore,
+ * any rational number of the form 𝑀/(2^P · 5^Q ) gets displayed as an exact decimal value (while other
+ * fractions get displayed as fractions).
+ * 
+ * @param v [Boolean]
+ * @return [Boolean]
+ * @see rationalmode
+ */
+static VALUE sollyarb_set_rationalmode(VALUE self, VALUE v)
+{
+	sollya_obj_t w = (v != sollyarb_cst_OFF && v != sollyarb_cst_FALSE && (v == sollyarb_cst_ON || RB_TEST(v))) ? sollyarb_object_rb2ref(sollyarb_cst_ON) : sollyarb_object_rb2ref(sollyarb_cst_OFF);
+	sollya_lib_set_rationalmode(w);
+	return v;
+}
+
+
+/* Returns whether timing measures are performed in Sollya.
+ * @return [Boolean]
+ * @see timing=
+ */
+static VALUE sollyarb_get_timing(VALUE self)
+{
+	sollya_obj_t w = sollya_lib_get_timing();
+	if (sollya_lib_is_on(w)) {
+		sollya_lib_clear_obj(w);
+		return Qtrue;
+	} else if (sollya_lib_is_off(w)) {
+		sollya_lib_clear_obj(w);
+		return Qfalse;
+	}
+	return sollyarb_autowrap_object(w);
+}
+
+/* Sets whether timing measures a re performed in Sollya.
+ *
+ * When set to `true`, the time spent in each command is measured
+ * and displayed (for {verbosity} levels higher than 1).
+ * 
+ * @param v [Boolean]
+ * @return [Boolean]
+ * @see timing
+ */
+static VALUE sollyarb_set_timing(VALUE self, VALUE v)
+{
+	sollya_obj_t w = (v != sollyarb_cst_OFF && v != sollyarb_cst_FALSE && (v == sollyarb_cst_ON || RB_TEST(v))) ? sollyarb_object_rb2ref(sollyarb_cst_ON) : sollyarb_object_rb2ref(sollyarb_cst_OFF);
+	sollya_lib_set_timing(w);
+	return v;
+}
+
+
+/* Returns the number of recursion steps when applying Taylor's rule.
+ * @return [Integer]
+ * @see taylorrecursions=
+ */
+static VALUE sollyarb_get_taylorrecursions(VALUE self)
+{
+	sollya_obj_t p = sollya_lib_get_taylorrecursions();
+	int64_t i;
+	int r = sollya_lib_get_constant_as_int64(&i, p);
+	sollya_lib_clear_obj(p);
+	if (!r) {
+		rb_raise(rb_eRuntimeError, "Cannot get taylorrecursions as integer");
+	}
+	return LL2NUM(i);
+}
+
+
+/* Set the number of recursion steps when applying Taylor's rule.
+ * This rule is applied by the interval evaluator present in the
+ * core of Sollya (and particularly visible in commands like infnorm).
+ * 
+ * To improve the quality of an interval evaluation of a function _𝑓_ , in particular when there are
+ * problems of decorrelation), the evaluator of Sollya uses Taylor's rule:
+ * 𝑓([𝑎, 𝑏]) ⊆ 𝑓(𝑚) + [𝑎 - 𝑚, 𝑏 − 𝑚] · 𝑓'([𝑎, 𝑏])
+ * where 𝑚 = (𝑎+𝑏)/2
+ * This rule can be applied recursively. The number of step in this recursion process is controlled by taylorrecursions.
+ * 
+ * Setting taylorrecursions to 0 makes Sollya use this rule only once; setting it to 1 makes Sollya
+ * use the rule twice, and so on. In particular: the rule is always applied at least once.
+ * @param n [Integer] the number of recursions
+ * @return [Integer]
+ * @see taylorrecursions
+ */
+static VALUE sollyarb_set_taylorrecursions(VALUE self, VALUE n)
+{
+	sollya_obj_t p = sollya_lib_constant_from_int(NUM2INT(n));
+	sollya_lib_set_taylorrecursions(p);
+	sollya_lib_clear_obj(p);
+	return n;
+}
+
+
+/* Returns the number of recursion steps when applying L'Hopital's rule.
+ * @return [Integer]
+ * @see hopitalrecursions=
+ */
+static VALUE sollyarb_get_hopitalrecursions(VALUE self)
+{
+	sollya_obj_t p = sollya_lib_get_hopitalrecursions();
+	int64_t i;
+	int r = sollya_lib_get_constant_as_int64(&i, p);
+	sollya_lib_clear_obj(p);
+	if (!r) {
+		rb_raise(rb_eRuntimeError, "Cannot get hopitalrecursions as integer");
+	}
+	return LL2NUM(i);
+}
+
+
+/* Set the number of steps of recursion that are tried when applying L'Hopital's rule.
+ * This rule is applied by the interval evaluator present in
+ * the core of Sollya (and particularly visible in commands like infnorm).
+ *
+ * If an expression of the form _𝑓/𝑔_ has to be evaluated by interval arithmetic on an interval _𝐼_ and if _𝑓_
+ * and _𝑔_ have a common zero in _𝐼_, a direct evaluation leads to NaN. Sollya implements a safe heuristic
+ * to avoid this, based on L'Hopital's rule: in such a case, it can be shown that _(𝑓/𝑔)(𝐼) ⊆ (𝑓'/𝑔')(𝐼)_.
+ * Since the same problem may exist for _𝑓''/𝑔'_, the rule is applied recursively. The number of step in
+ * this recursion process is controlled by _hopitalrecursions_.
+ * 
+ * Setting hopitalrecursions to 0 makes Sollya use this rule only once; setting it to 1 makes Sollya
+ * use the rule twice, and so on. In particular: the rule is always applied at least once, if necessary.
+ * @param n [Integer] the number of recursions
+ * @return [Integer]
+ * @see hopitalrecursions
+ */
+static VALUE sollyarb_set_hopitalrecursions(VALUE self, VALUE n)
+{
+	sollya_obj_t p = sollya_lib_constant_from_int(NUM2INT(n));
+	sollya_lib_set_hopitalrecursions(p);
+	sollya_lib_clear_obj(p);
+	return n;
+}
+
+
+/* @return [String]
+ */
+static VALUE sollyarb_get_free_variable_name(VALUE self)
+{
+	char *s = sollya_lib_get_free_variable_name();
+	VALUE r = rb_str_new_cstr(s);
+	sollya_lib_free(s);
+	return r;
+}
+
+
+static VALUE sollyarb_set_free_variable_name(VALUE self, VALUE name)
+{
+	sollya_lib_name_free_variable(rb_string_value_cstr(&name));
+	return name;
+}
+
+
+
+/* Plots one or several functions.
+ *
+ * This command plots one or several functions `f1`, ... ,`fn` on an interval `range`. Functions can be either
+ * given as parameters of plot or as a list `f_list` which elements are functions. The functions are drawn
+ * on the same plot with different colors.
+ * 
+ * If `f_list` contains an element that is not a function (or a constant), an error occurs.
+ * 
+ * Plot relies on the value of global variable {points}. Let _𝑛_ be the value of this variable. The algorithm
+ * is the following: each function is evaluated at _𝑛_ evenly distributed points in `range`. At each point, the
+ * computed value is a faithful rounding of the exact value with a sufficiently high precision. Each
+ * point is finally plotted. This should avoid numerical artefacts such as critical cancellations.
+ * 
+ * The plot can be saved either as a data file or as a postscript file.
+ * 
+ * If you use argument `:file` with a string `name`, Sollya will save a data file called `name.dat` and
+ * a gnuplot directives file called `name.p`. Invoking gnuplot on `name.p` will plot the data stored in
+ * `name.dat`.
+ * 
+ * If you use argument `:postscript` with a string `name`, Sollya will save a postscript file called
+ * `name.eps` representing your plot.
+ * 
+ * If you use argument `:postscriptfile` with a string `name`, Sollya will produce the corresponding
+ * `name.dat`, `name.p` and `name.eps`.
+ * 
+ * By default, this command uses _gnuplot_ to produce the final plot. If Sollya is run while the
+ * environment variable `SOLLYA_GNUPLOT` is set, the content of that variable is used as the gnuplot
+ * binary. If your terminal is not graphic (typically if you use Sollya through ssh without -X) gnuplot
+ * should be able to detect that and produce an ASCII-art version on the standard output. If it is
+ * not the case, you can either store the plot in a postscript file to view it locally, or use {asciiplot}
+ * command.
+ * 
+ * If every function is constant, plot will not plot them but just display their value.
+ * 
+ * If the interval is reduced to a single point, plot will just display the value of the functions at this
+ * point.
+ *
+ * @return [nil]
+ * @overload plot(f1, ..., fn, range)
+ *  @param f1 [Function] functions to be plotted.
+ *  @param range [Range] the interval where the functions have to be plotted.
+ * @overload plot(f1, ..., fn, range, mode, name)
+ *  @param f1 [Function] functions to be plotted.
+ *  @param range [Range] the interval where the functions have to be plotted.
+ *  @param mode [Symbol] `:file`, `:postscript` or `:postscriptfile`
+ *  @param name [String] name of a file
+ * @overload plot(f_list, range)
+ *  @param f_list [List<Function>] a list of functions to be plotted.
+ *  @param range [Range] the interval where the functions have to be plotted.
+ * @overload plot(f_list, range, mode, name)
+ *  @param f_list [List<Function>] a list of functions to be plotted.
+ *  @param range [Range] the interval where the functions have to be plotted.
+ *  @param mode [Symbol] `:file`, `:postscript` or `:postscriptfile`
+ *  @param name [String] name of a file
+ */
+static VALUE sollyarb_plot(int argc, VALUE *argv, VALUE self)
+{
+	SOLLYARB_FUNC_VA_2(sollya_lib_plot);
+}
+
+
+/* Plots a function in a range using ASCII characters.
+ *
+ * Plots the function `func` in range `range` using ASCII characters. On systems that
+ * provide the necessary `TIOCGWINSZ ioctl`, Sollya determines the size of the terminal for the plot
+ * size if connected to a terminal. If it is not connected to a terminal or if the test is not possible,
+ * the plot is of fixed size 77 × 25 characters.
+ *
+ * The function is evaluated on a number of points equal
+ * to the number of columns available. Its value is rounded to the next integer in the range of lines
+ * available. A letter _x_ is written at this place. If zero is in the hull of the image domain of the
+ * function, an x-axis is displayed. If zero is in range, a y-axis is displayed. If the function is constant
+ * or if the range is reduced to one point, the function is evaluated to a constant and the constant is
+ * displayed instead of a plot.
+ *
+ * @param func [Function]
+ * @param range [Range]
+ * @return [nil]
+ */
+static VALUE sollyarb_asciiplot(VALUE self, VALUE func, VALUE range)
+{
+	sollya_lib_asciiplot(SOLLYARB_TO_SOLLYA(func), SOLLYARB_TO_SOLLYA(range));
+	return Qnil;
+}
+
+
+/* Prints a constant value as a hexadecimal double precision number.
+ *
+ * Prints a constant value as a hexadecimal number on 16 hexadecimal digits. The hexadecimal
+ * number represents the integer equivalent to the 64 bit memory representation of the constant
+ * considered as a double precision number.
+ *
+ * If the constant value does not hold on a double precision number, it is first rounded to the nearest
+ * double precision number before displayed. A warning is displayed in this case.
+ * @return [nil]
+ */
+static VALUE sollyarb_printdouble(VALUE self, VALUE constant)
+{
+	sollya_lib_printdouble(SOLLYARB_TO_SOLLYA(constant));
+	return Qnil;
+}
+
+
+/* Prints a constant value as a hexadecimal single precision number.
+ *
+ * Prints a constant value as a hexadecimal number on 8 hexadecimal digits. The hexadecimal number
+ * represents the integer equivalent to the 32 bit memory representation of the constant considered
+ * as a single precision number.
+ *
+ * If the constant value does not hold on a single precision number, it is first rounded to the nearest
+ * single precision number before it is displayed. A warning is displayed in this case.
+ * @return [nil]
+ */
+static VALUE sollyarb_printsingle(VALUE self, VALUE constant)
+{
+	sollya_lib_printsingle(SOLLYARB_TO_SOLLYA(constant));
+	return Qnil;
+}
+
+
+/* Prints a polynomial in Horner form with its coefficients written as a expansions of double precision numbers.
+ *
+ * The command printexpansion prints the polynomial `polynomial` in Horner form writing its coefficients 
+ * as expansions of double precision numbers. The double precision numbers themselves are
+ * displayed in hexadecimal memory notation (see {printdouble}).
+ * 
+ * If some of the coefficients of the polynomial `polynomial` are not floating-point constants but constant
+ * expressions, they are evaluated to floating-point constants using the global precision {prec}. If a
+ * rounding occurs in this evaluation, a warning is displayed.
+ * 
+ * If the exponent range of double precision is not sufficient to display all the mantissa bits of a
+ * coefficient, the coefficient is displayed rounded and a warning is displayed.
+ * 
+ * If the argument `polynomial` does not represent a polynomial, nothing but a warning or a newline is displayed.
+ * Constants can be displayed using printexpansion since they are polynomials of degree 0.
+ * 
+ * @param polynomial [Function]
+ * @return [nil]
+ */
+static VALUE sollyarb_printexpansion(VALUE self, VALUE polynomial)
+{
+	sollya_lib_printexpansion(SOLLYARB_TO_SOLLYA(polynomial));
+	return Qnil;
+}
+
+
+/* Plots the error of an external code with regard to a function
+ *
+ * The command _externalplot_ plots the error of an external function evaluation code sequence
+ * implemented in the object file named `filename` with regard to the function `function`. If `mode`
+ * evaluates to `:absolute`, the difference of both functions is considered as an error function; if `mode`
+ * evaluates to `:relative`, the difference is divided by the function `function`. The resulting error function
+ * is plotted on all floating-point numbers with `precision` significant mantissa bits in the range `range`.
+ * 
+ * If the sixth argument of the command externalplot is given and evaluates to `:perturb`, each of
+ * the floating-point numbers the function is evaluated at gets perturbed by a random value that is
+ * uniformly distributed in ±1 ulp around the original precision bit floating-point variable.
+ * 
+ * If a sixth and seventh argument, respectively a seventh and eighth argument in the presence of
+ * `perturb` as a sixth argument, are given that evaluate to a variable of type `:file`, `:postscript`, `:postscriptfile`
+ * respectively to a character sequence of type string, externalplot will plot (additionally) to a file
+ * in the same way as the command plot does. See {plot} for details.
+ * 
+ * The external function evaluation code given in the object file name `filename` is supposed to define
+ * a function name f as follows (here in C syntax): `void f(mpfr_t rop, mpfr_t op)`. This function
+ * is supposed to evaluate op with an accuracy corresponding to the precision of rop and assign this
+ * value to rop.
+ *
+ * Example:
+ * ```ruby
+ * system 'gcc -fPIC -c externalplotexample.c'
+ * system 'gcc -shared -o externalplotexample externalplotexample.o -lgmp -lmpfr'
+ * Sollya.externalplot('./externalplotexample', :relative, Sollya.parse 'exp(x)', -0.5 .. 0.5, 12, :perturb)
+ * ```
+ * @return [nil]
+ * @overload externalplot(filename, mode, function, range, precision, perturb = nil, plot_mode = nil, res_filename = nil)
+ *  @param filename [String]
+ *  @param mode [Symbol] `:absolute` or `:relative`
+ *  @param function [Function]
+ *  @param range [Range]
+ *  @param precision [Integer]
+ *  @param perturb [Symbol,nil] `:perturb`
+ *  @param plot_mode [Symbol,nil] `:file`, `:postscript` or `:postscriptfile` 
+ *  @param res_filename [String]
+ */
+static VALUE sollyarb_externalplot(int argc, VALUE *argv, VALUE self)
+{
+	SOLLYARB_FUNC_VA_5(sollya_lib_externalplot);
+}
+
+
+/* Executes the content of a file
+ *
+ * Opens the file indicated by filename, and executes the sequence of commands it contains.
+ * This command is evaluated at execution time: this way you can modify the file filename (for
+ * instance using bashexecute) and execute it just after.
+ *
+ * If filename contains a command _execute_, it will be executed recursively.
+ *
+ * If filename contains a call to _restart_, it will be neglected.
+ *
+ * If filename contains a call to _quit_, the commands following quit in filename will be neglected.
+ * @param filename [String]
+ * @return [nil]
+ */
+static VALUE sollyarb_execute(VALUE self, VALUE filename)
+{
+	sollya_lib_execute(SOLLYARB_TO_SOLLYA(filename));
+	return Qnil;
+}
+
+
+/* Prints an expression as an MathML-Content-Tree.
+ *
+ * Prints the functional expression expr as a tree of MathML Content Definition Markups.
+ *
+ * @param expr [Function] a functional expression
+ * @param expr [Function] represents a functional expression
+ * @return [nil]
+ */
+static VALUE sollyarb_printxml(VALUE self, VALUE expr)
+{
+	sollya_lib_printxml(SOLLYARB_TO_SOLLYA(expr));
+	return Qnil;
+}
+
+
+/* Prints an expression as an MathML-Content-Tree.
+ *
+ * Prints the functional expression expr as a tree of MathML Content Definition Markups.
+ *
+ * The MathML tree is not output on the standard output but in the file `filename` that get newly created or overwritten.
+ *
+ * @param expr [Function] a functional expression
+ * @param filename [String]
+ * @return [nil]
+ */
+static VALUE sollyarb_printxml_newfile(VALUE self, VALUE expr, VALUE filename)
+{
+	sollya_lib_printxml_newfile(SOLLYARB_TO_SOLLYA(expr), SOLLYARB_TO_SOLLYA(filename));
+	return Qnil;
+}
+
+
+/* Prints an expression as an MathML-Content-Tree.
+ *
+ * Prints the functional expression expr as a tree of MathML Content Definition Markups.
+ *
+ * The MathML tree is not output on the standard output but will be appended to the file `filename`.
+ *
+ * @param expr [Function] a functional expression
+ * @param filename [String]
+ * @return [nil]
+ */
+static VALUE sollyarb_printxml_appendfile(VALUE self, VALUE expr, VALUE filename)
+{
+	sollya_lib_printxml_appendfile(SOLLYARB_TO_SOLLYA(expr), SOLLYARB_TO_SOLLYA(filename));
+	return Qnil;
+}
+
+
+/* Searches for hard-to-round cases of a function.
+ *
+ * The _worstcase_ command is deprecated. It searches for hard-to-round cases of a function. The
+ * command {searchgal} has a comparable functionality.
+
+ * @return [nil]
+ * @overload worstcase(function, preimage_precision, preimage_exponent_range, image_precision, error_bound, filename = nil)
+ *  @param function [Function] the function to be considered
+ *  @param preimage_precision [Integer] the precision of the preimages
+ *  @param preimage_exponent_range [Range] the exponents in the preimage format
+ *  @param image_precision [Integer] the precision of the format the images are to be rounded to
+ *  @param error_bound [Constant] the upper bound for the search w.r.t. the relative rounding error
+ *  @param filename [String]
+ */
+static VALUE sollyarb_worstcase(int argc, VALUE *argv, VALUE self)
+{
+	SOLLYARB_FUNC_VA_5(sollya_lib_worstcase);
+}
+
+
+/* Print a list of Sollya objects on the standard output.
+ * @return [nil]
+ * @overload autoprint(obj, ...)
+ *  @param obj [#to_sollya]
+ */
+static VALUE sollyarb_autoprint(int argc, VALUE *argv, VALUE self)
+{
+	SOLLYARB_FUNC_VA_1(sollya_lib_autoprint);
+}
+
+
+/* Suppresses the displaying of messages with a certain number
+ *
+ * The _suppressmessage_ command allows particular warning and information messages to be suppressed 
+ * from message output, while maintaining global verbosity levels (see verbosity) high. Every
+ * Sollya warning or information message (that is not fatal to the tool’s execution) has a message
+ * number. When these message numbers msg num 1 thru msg num n are given to suppressmessage,
+ * the corresponding message are no longer displayed. The {unsuppressmessage} command
+ * reverts this suppression from output for a particular message.
+ * 
+ * Instead of giving suppressmessage several message numbers msg num 1 thru msg num n or
+ * calling suppressmessage several times, it is possible to give a whole list msg list of message
+ * numbers to suppressmessage.
+ * 
+ * The user should be aware that suppressmessage presents sticky behavior for the warning and
+ * information messages suppressed from output. This means that even if subsequent calls to suppressmessage
+ * occur, a message suppressed by a call to suppressmessage stays suppressed until
+ * it is unsuppressed using {unsuppressmessage} or the tool is restarted. This behavior distinguishes
+ * message suppression from other global states of the Sollya tool. The user may use {getsuppressedmessages}
+ * to obtain a list of currently suppressed messages.
+ * 
+ * When suppressmessage is used on message numbers that do not exist in the current version of
+ * the tool, a warning is displayed. The call has no other effect though.
+ *
+ * @return [nil]
+ * @overload supressmessage(msg_num_1, ..., msg_num_n)
+ *  @param msg_num_1 [Integer]
+ */
+static VALUE sollyarb_suppressmessage(int argc, VALUE *argv, VALUE self)
+{
+	SOLLYARB_FUNC_VA_1(sollya_lib_suppressmessage);
+}
+
+
+/* Unsuppresses the displaying of messages with a certain number
+ *
+ * The unsuppressmessage command allows particular warning and information messages that have
+ * been suppressed from message output to be unsuppressed, i.e. activated for display again. Every
+ * Sollya warning or information message (that is not fatal to the tool’s execution) has a message
+ * number. When these message numbers `msg_num_1` thru `msg_num_n` are given to unsuppressmessage,
+ * the corresponding message are displayed again, as they are by default at according verbosity
+ * levels. Actually, the unsuppressmessage command just reverts the effects of the suppressmessage command.
+ * 
+ * Instead of giving unsuppressmessage several message numbers `msg_num_1` thru `msg_num_n` or
+ * calling unsuppressmessage several times, it is possible to give a whole list `msg_list` of message
+ * numbers to unsuppressmessage.
+ * 
+ * The user should be aware that unsuppressmessage presents sticky behavior for the warning and
+ * information messages suppressed from output. In fact, unsuppressmessage just unsuppresses the
+ * warning or information messages given in argument. All other suppressed messages stay suppressed
+ * until they get unsuppressed by subsequent calls to unsuppressmessage or the Sollya tool is
+ * restarted. This behavior distinguishes message suppression from other global states of the Sollya
+ * tool. The user may use getsuppressedmessages to obtain a list of currently suppressed messages.
+ * In particular, in order to unsuppressed all currently suppressed warning or information messages,
+ * the user may feed the output of getsuppressedmessages (a list) into unsuppressmessage.
+ * 
+ * The user should also note that unsuppressing warning or information messages with unsuppressmessage
+ * just reverts the effects of the suppressmessage command but that other conditions
+ * exist that affect the actual displaying of a message, such as global verbosity (see verbosity) and
+ * modes like rounding warnings (see roundingwarnings). A message will not just get displayed
+ * because it was unsuppressed with unsuppressmessage.
+ * 
+ * When unsuppressmessage is used on message numbers that do not exist in the current version
+ * of the tool, a warning is displayed. The call has no other effect though.
+ *
+ * @return [nil]
+ * @overload unsupressmessage(msg_num_1, ..., msg_num_n)
+ *  @param msg_num_1 [Integer]
+ * @overload unsupressmessage(msg_list)
+ *  @param msg_list [List<Integer>]
+ */
+static VALUE sollyarb_unsuppressmessage(int argc, VALUE *argv, VALUE self)
+{
+	SOLLYARB_FUNC_VA_1(sollya_lib_unsuppressmessage);
+}
+
+
+/* Implements a constant in arbitrary precision
+ *
+ * The command _implementconstant_ implements the constant expression `expr` in arbitrary precision.
+ * More precisely, it generates the source code (written in C, and using MPFR) of a C function
+ * const_something with the following signature:
+ * `void const_something (mpfr_ptr y, mp_prec_t prec)`
+ * Let us denote by 𝑐 the exact mathematical value of the constant defined by the expression `expr`.
+ * When called with arguments 𝑦 and prec (where the variable 𝑦 is supposed to be already initialized),
+ * the function mpfr_const_something sets the precision of 𝑦 to a suitable precision and stores in it
+ * an approximate value of 𝑐 such that
+ * |𝑦 − 𝑐| ≤ |𝑐| 21−prec .
+ * 
+ * When no filename `filename` is given or if `:default` is given as `filename`, the source code produced by
+ * implementconstant is printed on standard output. Otherwise, when `filename` is given as a string
+ * of characters, the source code is output to a file named `filename`. If that file cannot be opened
+ * and/or written to, implementconstant fails and has no other effect.
+ * 121• When `functionname` is given as an argument to implementconstant and `functionname` evaluates
+ * to a string of characters, the default name for the C function const_something is replaced by
+ * `functionname`. When `:default` is given as `functionname`, the default name is used nevertheless, as
+ * if no `functionname` argument were given. When choosing a character sequence for `functionname`,
+ * the user should keep attention to the fact that `functionname` must be a valid C identifier in order
+ * to enable error-free compilation of the produced code.
+ * 
+ * If `expr` refers to a constant defined with libraryconstant, the produced code uses the external
+ * code implementing this constant. The user should keep in mind that it is up to them to make sure
+ * the symbol for that external code can get resolved when the newly generated code is to be loaded.
+ * 
+ * If a subexpression of `expr` evaluates to 0, implementconstant will most likely fail with an error
+ * message.
+ * 
+ * implementconstant is unable to implement constant expressions `expr` that contain procedurebased
+ * functions, i.e. functions created from Sollya procedures using the function construct. If
+ * `expr` contains such a procedure-based function, implementconstant prints a warning and fails
+ * silently. The reason for this lack of functionality is that the produced C source code, which is
+ * supposed to be compiled, would have to call back to the Sollya interpreter in order to evaluate
+ * the procedure-based function.
+ * 
+ * Similarly, implementconstant is currently unable to implement constant expressions `expr` that
+ * contain library-based functions, i.e. functions dynamically bound to Sollya using the library
+ * construct. If `expr` contains such a library-based function, implementconstant prints a warning
+ * and fails silently. Support for this feature is in principle feasible from a technical standpoint and
+ * might be added in a future release of Sollya.
+ * 
+ * Currently, non-differentiable functions such as {double}, {doubledouble}, {tripledouble}, {single},
+ * {halfprecision}, {quad}, {doubleextended}, {floor}, {ceil}, {nearestint} are not supported by implementconstant.
+ * If implementconstant encounters one of them, a warning message is displayed
+ * and no code is produced. However, if {autosimplify} equals `true`, it is possible that Sollya silently
+ * simplifies subexpressions of `expr` containing such functions and that implementconstant successfully
+ * produces code for evaluating `expr`.
+ * 
+ * While it produces an MPFR-based C source code for `expr`, implementconstant takes architectural
+ * and system-dependent parameters into account. For example, it checks whether literal constants
+ * figuring in `expr` can be represented on a C long int type or if they must be stored in a different
+ * manner not to affect their accuracy. These tests, performed by Sollya during execution of implementconstant,
+ * depend themselves on the architecture Sollya is running on. Users should keep
+ * this matter in mind, especially when trying to compile source code on one machine whilst it has
+ * been produced on another.
+ *
+ * @return [nil]
+ * @overload implementconstant(expr, filename = nil, functionname = nil)
+ *  @param expr [Function]
+ *  @param filename [String, nil]
+ *  @param functionname [String, nil]
+ */
+static VALUE sollyarb_implementconstant(int argc, VALUE *argv, VALUE self)
+{
+	SOLLYARB_FUNC_VA_1(sollya_lib_implementconstant);
+}
+
+
+/* Computes a good polynomial approximation with fixed-point or floating-point coefficients
+ *
+ * _fpminimax_ uses a heuristic (but practically efficient) method to find a good polynomial approximation 
+ * of a function `f` on an interval `range`. It implements the method published in the article:
+ * _Efficient polynomial 𝐿∞ -approximations, Nicolas Brisebarre and Sylvain Chevillard, Proceedings of the 18th IEEE Symposium on Computer Arithmetic (ARITH 18), pp. 169-176_.
+ *
+ * The basic usage of this command is `fpminimax(f, n, formats, range)`. It computes a polynomial
+ * approximation of `𝑓` with degree at most `𝑛` on the interval `range`. `formats` is a list of integers or
+ * format types (such as `:double`, `:doubledouble`, etc.). The polynomial returned by the command
+ * has its coefficients that fit the formats indications. For instance, if formats[0] is 35, the coefficient
+ * of degree 0 of the polynomial will fit a floating-point format of 35 bits. If formats[1] is `:double`, the
+ * coefficient of degree 1 will be representable by a floating-point number with a precision of 53 bits
+ * (which is not necessarily an IEEE 754 double precision number. See the remark below), etc.
+ *
+ * The second argument may be either an integer, a list of integers or a list of functions. An integer
+ * indicates the degree of the desired polynomial approximation. A list of integers indicates the list of
+ * desired monomials. For instance, the list `[0, 2, 4, 6]` indicates that the polynomial must be even
+ * and of degree at most 6. Giving an integer 𝑛 as second argument is equivalent as giving [0, 1, ..., 𝑛].
+ * Finally, a list of function _𝑔𝑘_ indicates that the desired approximation must be a linear combination of the _𝑔𝑘_.
+ * The list of formats is interpreted with respect to the list of monomials. For instance, if the list of
+ * monomials is [0, 2, 4, 6] and the list of formats is [161, 107, 53, 24], the coefficients of degree 0
+ * is searched as a floating-point number with precision 161, the coefficient of degree 2 is searched as
+ * a number of precision 107, and so on.
+ *
+ * The floating-point coefficients considered by fpminimax do not have an exponent range. In
+ * particular, in the format list, `:double` is an exact synonym for 53. Currently, fpminimax only
+ * ensures that the corresponding coefficient has at most 53 bits of mantissa. It does not imply that
+ * it is an IEEE-754 double.
+ * 
+ * By default, the list of formats is interpreted as a list of floating-point formats. This may be changed
+ * by passing `:fixed` for `indic2`.
+ * For example: `fpminimax(𝑓 , 2, [25, 18, 30], (0..10, :fixed)`. In this case, _fpminimax_ will search
+ * for a polynomial of degree 2 with a constant coefficient of the form `𝑚/2^25` where _𝑚_ is an integer. In
+ * other words, it is a fixed-point number with 25 bits after the point.
+ *
+ * For more documentation on fpminimax, see the official [Sollya documentation](https://www.sollya.org/sollya-8.0/help.php?name=fpminimax).
+ *
+ * @return [Function] polynomial approximation
+ * @overload fpminimax(f, n | monomials, formats, range | lst, opterror = :relative, coefformat = :floating, indic3 = nil, p | lcoeffs = nil)
+ *  @param f [Function] the function to be approximated
+ *  @param n [Integer] the degree of the polynomial that must approximate _f_
+ *  @param monomials [List<Integer,Function>] a list of integers or a list of function. It indicates the basis for the approximation of _f_
+ *  @param formats [List<Integer,Constant>] a list indicating the formats that the coefficients of the polynomial must have
+ *  @param range [Range] the interval where the function must be approximated
+ *  @param lst [List] list of interpolation points used by the method
+ *  @param opterror [Symbol, nil] the error to be optimized, `:absolute` or `:relative`
+ *  @param coefformat [Symbol, nil] formats of the coefficients, `:fixed` or `:floating`
+ *  @param indic2 [Symbol, nil] `:absolute` or `:relative`
+ *  @param p [Function, nil] the minimax polynomial to be considered for solving the problem.
+ *  @param lcoeffs [List, nil] a list containing the coefficients of the minimax polynomial to be considered for solving the problem.
+ * @see supnorm
+ */
+static VALUE sollyarb_fpminimax(int argc, VALUE *argv, VALUE self)
+{
+	SOLLYARB_PROC_VA_4(sollya_lib_fpminimax);
+}
+
+
+/* Computes an interval bounding the supremum norm of an approximation error (absolute or relative) between a given polynomial
+ * and a function.
+ *
+ * `supnorm(p, f, I, errorType, accuracy)` tries to compute an interval bound r=[l,u] for the supremum norm of
+ * the error function epsilon_absolute=p-f (when errorType evaluates to `:absolute`) or
+ * epsilon_relative=p/f-1 (when errorType evaluates to `:relative`), over the interval I, such that
+ * `sup{|epsilon(x)|, x in I} C r` and `0 < |u/l-1| < accuracy`.
+ * If supnorm succeeds in computing a suitable interval _r_, which it returns, that interval is guaranteed to
+ * contain the supremum norm value and to satisfy the required quality. Otherwise, supnorm evaluates to error,
+ * displaying a corresponding error message.
+ * These failure cases are rare and basically happen only for functions which are too complicated.
+ *
+ * Roughly speaking, supnorm is based on {taylorform} to obtain a higher degree polynomial approximation for _f_.
+ * This process is coupled with an a posteriori validation of a potential supremum norm upper bound.
+ * The validation is based on showing a certain polynomial the problem gets reduced to does not vanish.
+ * In cases when this process alone does not succeed, for instance because taylorform is unable to compute a sufficiently
+ * good approximation to f, supnorm falls back to bisecting the working interval until safe supremum norm bounds
+ * can be computed with the required accuracy or until the width of the subintervals becomes less than {diam} times
+ * the original interval I, in which case supnorm fails.
+ *
+ * The algorithm used for supnorm is quite complex, which makes it impossible to explain it here in further detail.
+ * Please find a complete description in the following article:
+ * _Sylvain Chevillard, John Harrison, Mioara Joldes, Christoph Lauter, Efficient and accurate computation of upper bounds of approximation errors, Journal of Theoretical Computer Science (TCS), 2010, LIP Research Report number RR LIP2010-2_,
+ * <http://prunel.ccsd.cnrs.fr/ensl-00445343/fr/>
+ *
+ * In practical cases, supnorm should be able to automatically handle removable discontinuities that relative errors might have.
+ * This means that usually, if f vanishes at a point x0 in the interval considered,
+ * the approximation polynomial p is designed such that it also vanishes at the same point with a multiplicity large enough.
+ * Hence, although f vanishes, epsilon_relative=p/f-1 may be defined by continuous extension at such points x0,
+ * called removable discontinuities.
+ *
+ * For more documentation on fpminimax, see the official [Sollya documentation](https://www.sollya.org/sollya-8.0/help.php?name=supnorm).
+ * 
+ * @param polynom [Function] a polynomial
+ * @param func [Function] a function
+ * @param itvl [Range] an interval
+ * @param etype [Symbol] the type of error to be considered: `:absolute` or `:relative`
+ * @param accuracy [Numeric] a constant that controls the relative tightness of the interval returned.
+ * @return [Range]
+ */
+static VALUE sollyarb_supnorm(VALUE self, VALUE polynom, VALUE func, VALUE itvl, VALUE etype, VALUE accuracy)
+{
+	sollya_obj_t r = sollya_lib_supnorm(
+		SOLLYARB_TO_SOLLYA(polynom),
+		SOLLYARB_TO_SOLLYA(func),
+		SOLLYARB_TO_SOLLYA(itvl),
+		SOLLYARB_TO_SOLLYA(etype),
+		SOLLYARB_TO_SOLLYA(accuracy));
+	return sollyarb_autowrap_object(r);
+}
+
+
+static VALUE sollyarb_infnorm(int argc, VALUE *argv, VALUE self)
+{
+	SOLLYARB_PROC_VA_2(sollya_lib_infnorm);
+}
+
+static VALUE sollyarb_dirtyinfnorm(VALUE self, VALUE func, VALUE range)
+{
+	return sollyarb_autowrap_object(sollya_lib_dirtyinfnorm(SOLLYARB_TO_SOLLYA(func), SOLLYARB_TO_SOLLYA(range)));
+}
+
+static VALUE sollyarb_remez(int argc, VALUE *argv, VALUE self)
+{
+	SOLLYARB_PROC_VA_3(sollya_lib_remez);
+}
+
+static VALUE sollyarb_taylorform(int argc, VALUE *argv, VALUE self)
+{
+	SOLLYARB_PROC_VA_3(sollya_lib_taylorform);
+}
+
+
+/* Universal name for the mathematical free variable.
+ * Sollya manipulates mathematical functions of a single variable.
+ * @return [Function]
+ */
+static VALUE sollyarb_free_variable(VALUE self)
+{
+	(void)self;
+	return sollyarb_autowrap_object(sollya_lib_free_variable());
+}
+
+
+static VALUE sollyarb_object_and(VALUE self, VALUE other)
+{
+	return sollyarb_autowrap_object(sollya_lib_and(sollyarb_object_rb2ref(self), SOLLYARB_TO_SOLLYA(other)));
+}
+
+
+static VALUE sollyarb_object_or(VALUE self, VALUE other)
+{
+	return sollyarb_autowrap_object(sollya_lib_or(sollyarb_object_rb2ref(self), SOLLYARB_TO_SOLLYA(other)));
+}
+
+
+static VALUE sollyarb_object_negate(VALUE self)
+{
+	return sollyarb_autowrap_object(sollya_lib_negate(sollyarb_object_rb2ref(self)));
+}
+
+
+static VALUE sollyarb_object_in(VALUE self, VALUE range)
+{
+	return sollyarb_autowrap_object(sollya_lib_negate(sollyarb_object_rb2ref(self)));
+}
+
+
+static VALUE sollyarb_object_add(VALUE self, VALUE other)
+{
+	return sollyarb_autowrap_object(sollya_lib_add(sollyarb_object_rb2ref(self), SOLLYARB_TO_SOLLYA(other)));
+}
+
+
+static VALUE sollyarb_object_sub(VALUE self, VALUE other)
+{
+	return sollyarb_autowrap_object(sollya_lib_sub(sollyarb_object_rb2ref(self), SOLLYARB_TO_SOLLYA(other)));
+}
+
+
+static VALUE sollyarb_object_mul(VALUE self, VALUE other)
+{
+	return sollyarb_autowrap_object(sollya_lib_mul(sollyarb_object_rb2ref(self), SOLLYARB_TO_SOLLYA(other)));
+}
+
+
+static VALUE sollyarb_object_div(VALUE self, VALUE other)
+{
+	return sollyarb_autowrap_object(sollya_lib_div(sollyarb_object_rb2ref(self), SOLLYARB_TO_SOLLYA(other)));
+}
+
+
+static VALUE sollyarb_object_pow(VALUE self, VALUE other)
+{
+	return sollyarb_autowrap_object(sollya_lib_pow(sollyarb_object_rb2ref(self), SOLLYARB_TO_SOLLYA(other)));
+}
+
+
+static VALUE sollyarb_object_neg(VALUE self)
+{
+	return sollyarb_autowrap_object(sollya_lib_neg(sollyarb_object_rb2ref(self)));
+}
+
+
+/* @return [Sollya::Object]
+ */
+static VALUE sollyarb_range_inf(VALUE self)
+{
+	return sollyarb_autowrap_object(sollya_lib_inf(sollyarb_object_rb2ref(self)));
+}
+
+
+/* @return [Sollya::Object]
+ */
+static VALUE sollyarb_range_sup(VALUE self)
+{
+	return sollyarb_autowrap_object(sollya_lib_sup(sollyarb_object_rb2ref(self)));
+}
+
+
+static VALUE sollyarb_object_concat(VALUE self, VALUE other)
+{
+	return sollyarb_autowrap_object(sollya_lib_concat(sollyarb_object_rb2ref(self), SOLLYARB_TO_SOLLYA(other)));
+}
+
+
+static VALUE sollyarb_list_append(VALUE self, VALUE other)
+{
+	return sollyarb_autowrap_object(sollya_lib_append(sollyarb_object_rb2ref(self), SOLLYARB_TO_SOLLYA(other)));
+}
+
+
+static VALUE sollyarb_list_prepend(VALUE self, VALUE other)
+{
+	return sollyarb_autowrap_object(sollya_lib_prepend(SOLLYARB_TO_SOLLYA(other), sollyarb_object_rb2ref(self)));
+}
+
+
+static VALUE sollyarb_exp(VALUE self, VALUE v) {
+	return sollyarb_autowrap_object(sollya_lib_exp(SOLLYARB_TO_SOLLYA(v)));
+}
+
+static VALUE sollyarb_log(VALUE self, VALUE v) {
+	return sollyarb_autowrap_object(sollya_lib_log(SOLLYARB_TO_SOLLYA(v)));
+}
+
+static VALUE sollyarb_log2(VALUE self, VALUE v) {
+	return sollyarb_autowrap_object(sollya_lib_log2(SOLLYARB_TO_SOLLYA(v)));
+}
+
+static VALUE sollyarb_log10(VALUE self, VALUE v) {
+	return sollyarb_autowrap_object(sollya_lib_log10(SOLLYARB_TO_SOLLYA(v)));
+}
+
+static VALUE sollyarb_sqrt(VALUE self, VALUE v) {
+	return sollyarb_autowrap_object(sollya_lib_sqrt(SOLLYARB_TO_SOLLYA(v)));
+}
+
+static VALUE sollyarb_sin(VALUE self, VALUE v) {
+	return sollyarb_autowrap_object(sollya_lib_sin(SOLLYARB_TO_SOLLYA(v)));
+}
+
+static VALUE sollyarb_cos(VALUE self, VALUE v) {
+	return sollyarb_autowrap_object(sollya_lib_cos(SOLLYARB_TO_SOLLYA(v)));
+}
+
+static VALUE sollyarb_tan(VALUE self, VALUE v) {
+	return sollyarb_autowrap_object(sollya_lib_tan(SOLLYARB_TO_SOLLYA(v)));
+}
+
+static VALUE sollyarb_asin(VALUE self, VALUE v) {
+	return sollyarb_autowrap_object(sollya_lib_asin(SOLLYARB_TO_SOLLYA(v)));
+}
+
+static VALUE sollyarb_acos(VALUE self, VALUE v) {
+	return sollyarb_autowrap_object(sollya_lib_acos(SOLLYARB_TO_SOLLYA(v)));
+}
+
+static VALUE sollyarb_atan(VALUE self, VALUE v) {
+	return sollyarb_autowrap_object(sollya_lib_atan(SOLLYARB_TO_SOLLYA(v)));
+}
+
+static VALUE sollyarb_sinh(VALUE self, VALUE v) {
+	return sollyarb_autowrap_object(sollya_lib_sinh(SOLLYARB_TO_SOLLYA(v)));
+}
+
+static VALUE sollyarb_cosh(VALUE self, VALUE v) {
+	return sollyarb_autowrap_object(sollya_lib_cosh(SOLLYARB_TO_SOLLYA(v)));
+}
+
+static VALUE sollyarb_tanh(VALUE self, VALUE v) {
+	return sollyarb_autowrap_object(sollya_lib_tanh(SOLLYARB_TO_SOLLYA(v)));
+}
+
+static VALUE sollyarb_asinh(VALUE self, VALUE v) {
+	return sollyarb_autowrap_object(sollya_lib_asinh(SOLLYARB_TO_SOLLYA(v)));
+}
+
+static VALUE sollyarb_acosh(VALUE self, VALUE v) {
+	return sollyarb_autowrap_object(sollya_lib_acosh(SOLLYARB_TO_SOLLYA(v)));
+}
+
+static VALUE sollyarb_atanh(VALUE self, VALUE v) {
+	return sollyarb_autowrap_object(sollya_lib_atanh(SOLLYARB_TO_SOLLYA(v)));
+}
+
+static VALUE sollyarb_abs(VALUE self, VALUE v) {
+	return sollyarb_autowrap_object(sollya_lib_abs(SOLLYARB_TO_SOLLYA(v)));
+}
+
+static VALUE sollyarb_erf(VALUE self, VALUE v) {
+	return sollyarb_autowrap_object(sollya_lib_erf(SOLLYARB_TO_SOLLYA(v)));
+}
+
+static VALUE sollyarb_erfc(VALUE self, VALUE v) {
+	return sollyarb_autowrap_object(sollya_lib_erfc(SOLLYARB_TO_SOLLYA(v)));
+}
+
+static VALUE sollyarb_log1p(VALUE self, VALUE v) {
+	return sollyarb_autowrap_object(sollya_lib_log1p(SOLLYARB_TO_SOLLYA(v)));
+}
+
+static VALUE sollyarb_expm1(VALUE self, VALUE v) {
+	return sollyarb_autowrap_object(sollya_lib_expm1(SOLLYARB_TO_SOLLYA(v)));
+}
+
+static VALUE sollyarb_double(VALUE self, VALUE v) {
+	return sollyarb_autowrap_object(sollya_lib_double(SOLLYARB_TO_SOLLYA(v)));
+}
+
+static VALUE sollyarb_single(VALUE self, VALUE v) {
+	return sollyarb_autowrap_object(sollya_lib_single(SOLLYARB_TO_SOLLYA(v)));
+}
+
+static VALUE sollyarb_quad(VALUE self, VALUE v) {
+	return sollyarb_autowrap_object(sollya_lib_quad(SOLLYARB_TO_SOLLYA(v)));
+}
+
+static VALUE sollyarb_halfprecision(VALUE self, VALUE v) {
+	return sollyarb_autowrap_object(sollya_lib_halfprecision(SOLLYARB_TO_SOLLYA(v)));
+}
+
+static VALUE sollyarb_double_double(VALUE self, VALUE v) {
+	return sollyarb_autowrap_object(sollya_lib_double_double(SOLLYARB_TO_SOLLYA(v)));
+}
+
+static VALUE sollyarb_triple_double(VALUE self, VALUE v) {
+	return sollyarb_autowrap_object(sollya_lib_triple_double(SOLLYARB_TO_SOLLYA(v)));
+}
+
+static VALUE sollyarb_doubleextended(VALUE self, VALUE v) {
+	return sollyarb_autowrap_object(sollya_lib_doubleextended(SOLLYARB_TO_SOLLYA(v)));
+}
+
+static VALUE sollyarb_ceil(VALUE self, VALUE v) {
+	return sollyarb_autowrap_object(sollya_lib_ceil(SOLLYARB_TO_SOLLYA(v)));
+}
+
+static VALUE sollyarb_floor(VALUE self, VALUE v) {
+	return sollyarb_autowrap_object(sollya_lib_floor(SOLLYARB_TO_SOLLYA(v)));
+}
+
+static VALUE sollyarb_nearestint(VALUE self, VALUE v) {
+	return sollyarb_autowrap_object(sollya_lib_nearestint(SOLLYARB_TO_SOLLYA(v)));
+}
+
+
+static VALUE sollyarb_function_abs(VALUE self) {
+	return sollyarb_autowrap_object(sollya_lib_abs(sollyarb_object_rb2ref(self)));
+}
+
+static VALUE sollyarb_function_ceil(VALUE self) {
+	return sollyarb_autowrap_object(sollya_lib_ceil(sollyarb_object_rb2ref(self)));
+}
+
+static VALUE sollyarb_function_floor(VALUE self) {
+	return sollyarb_autowrap_object(sollya_lib_floor(sollyarb_object_rb2ref(self)));
+}
+
+static VALUE sollyarb_function_nearestint(VALUE self) {
+	return sollyarb_autowrap_object(sollya_lib_nearestint(sollyarb_object_rb2ref(self)));
+}
+
+static VALUE sollyarb_apply(int argc, VALUE *argv, VALUE self) {
+	SOLLYARB_PROC_VA_1(sollya_lib_apply);
+}
+
+/* Computes an interpolation polynomial.
+ * @return [Function]
+ */
+static VALUE sollyarb_interpolate(int argc, VALUE *argv, VALUE self) {
+	SOLLYARB_PROC_VA_2(sollya_lib_interpolate);
+}
+
+static VALUE sollyarb_getbacktrace(VALUE self) {
+	return sollyarb_autowrap_object(sollya_lib_getbacktrace());
+}
+
+
+static VALUE sollyarb_function_numerator(VALUE self) {
+	return sollyarb_autowrap_object(sollya_lib_numerator(sollyarb_object_rb2ref(self)));
+}
+
+static VALUE sollyarb_function_denominator(VALUE self) {
+	return sollyarb_autowrap_object(sollya_lib_denominator(sollyarb_object_rb2ref(self)));
+}
+
+/* @overload apply_at(x, prec: prec)
+ *  @param x [MPFR, Float] point at which to evaluate the function
+ *  @param prec [Integer] precision
+ *  @return [MPFR]
+ * @overload apply_at(x)
+ *  @param x [Sollya::Object]
+ *  @return [Sollya::Object]
+ */
+static VALUE sollyarb_function_apply_at(int argc, VALUE *argv, VALUE self) {
+	VALUE v;
+	VALUE kw;
+	const ID kwkeys[1] = {id_prec};
+	VALUE kwvalues[1] = {Qundef};
+	mpfr_prec_t prec = -1;
+	rb_scan_args(argc, argv, "1:", &v, &kw);
+	if (!NIL_P(kw)) {
+		rb_get_kwargs(kw, kwkeys, 0, 1, kwvalues);
+		if (kwvalues[0] != Qundef) {
+			prec = NUM2LL(kwvalues[0]);
+		}
+	}
+	if (prec <= 0) {
+		sollya_obj_t p = sollya_lib_get_prec();
+		sollya_lib_get_constant_as_int64(&prec, p);
+		sollya_lib_clear_obj(p);
+	}
+
+	if (RB_FLOAT_TYPE_P(v)) {
+		mpfr_t mp;
+		mpfr_init2(mp, 53);
+		mpfr_set_d(mp, NUM2DBL(v), MPFR_RNDN);
+
+		VALUE rbres = mpfrrb_alloc(c_MPFR);
+		mpfr_ptr mpr = mpfrrb_rb2ref_ext(rbres);
+		mpfr_init2(mpr, prec);
+
+		sollya_lib_evaluate_function_at_point(mpr, sollyarb_object_rb2ref(self), mp, NULL);
+
+		mpfr_clear(mp);
+		return rbres;
+	} else if (rb_obj_is_kind_of(v, c_MPFR)) {
+		mpfr_ptr mp = mpfrrb_rb2ref_ext(v);
+
+		VALUE rbres = mpfrrb_alloc(c_MPFR);
+		mpfr_ptr mpr = mpfrrb_rb2ref_ext(rbres);
+		mpfr_init2(mpr, prec);
+
+		sollya_lib_evaluate_function_at_point(mpr, sollyarb_object_rb2ref(self), mp, NULL);
+
+		return rbres;
+	} else {
+		return sollyarb_autowrap_object(sollya_lib_apply(sollyarb_object_rb2ref(self), SOLLYARB_TO_SOLLYA(v), NULL));
+	}
+}
+
+static VALUE sollyarb_approx(VALUE self, VALUE v) {
+	return sollyarb_autowrap_object(sollya_lib_approx(SOLLYARB_TO_SOLLYA(v)));
+}
+
+/* Returns the middle of _self_.
+ * If the middle is not exactly representable at the current precision, the value is returned as an unevaluated expression.
+ * @return [Sollya::Object]
+ */
+static VALUE sollyarb_range_mid(VALUE self) {
+	return sollyarb_autowrap_object(sollya_lib_mid(sollyarb_object_rb2ref(self)));
+}
+
+/* Differentiation operator.
+ * Returns the symbolic derivative of the function _self_ by the global free variable.
+ * If _self_ represents a function symbol that is externally bound to some code by library, the
+ * derivative is performed as a symbolic annotation to the returned expression tree.
+ * @return [Function]
+ */
+static VALUE sollyarb_function_diff(VALUE self) {
+	return sollyarb_autowrap_object(sollya_lib_diff(sollyarb_object_rb2ref(self)));
+}
+
+/* Brings all polynomial subexpressions of _self_ to Horner form.
+ * 
+ * This method rewrites the expression representing the function _self_ in a way such that
+ * all polynomial subexpressions (or the whole expression itself, if it is a polynomial) are written in
+ * Horner form. The command horner does not endanger the safety of computations even in Sollya's
+ * floating-point environment: the function returned is mathematically equal to _self_.
+ * @return [Function]
+ */
+static VALUE sollyarb_function_horner(VALUE self) {
+	return sollyarb_autowrap_object(sollya_lib_horner(sollyarb_object_rb2ref(self)));
+}
+
+/* Expands polynomial subexpressiosns.
+ * Expands all polynomial subexpressions in function _self_ as far as possible.
+ * Factors of sums are multiplied out, power operators with constant positive integer exponents are
+ * replaced by multiplications.
+ * @return [Function]
+ */
+static VALUE sollyarb_function_expand(VALUE self) {
+	return sollyarb_autowrap_object(sollya_lib_expand(sollyarb_object_rb2ref(self)));
+}
+
+/* Simplifies an expression representing a function.
+ * It does not endanger the safety of computations even in Sollya's
+ * floating-point environment: the function returned is mathematically equal to _self_.
+ * Remark that the simplification provided by simplify is not perfect: they may exist simpler equivalent
+ * expressions for expressions returned by simplify.
+ * @return [Function]
+ */
+static VALUE sollyarb_function_simplify(VALUE self) {
+	return sollyarb_autowrap_object(sollya_lib_simplify(sollyarb_object_rb2ref(self)));
+}
+
+/* Simplifies constant subexpressions of _self_
+ * Those constant subexpressions are evaluated using floating-point arithmetic with the global precision {prec}.
+ * @return [Function]
+ */
+static VALUE sollyarb_function_dirtysimplify(VALUE self)
+{
+	return sollyarb_autowrap_object(sollya_lib_dirtysimplify(sollyarb_object_rb2ref(self)));
+}
+
+/* Returns the degree of the polynomial _self_.
+ * @return [Integer, nil]
+ */
+static VALUE sollyarb_function_degree(VALUE self) {
+	sollya_obj_t d = sollya_lib_degree(sollyarb_object_rb2ref(self));
+	int r;
+	int s = sollya_lib_get_constant_as_int(&r, d);
+	sollya_lib_clear_obj(d);
+	if (!s || r < 0) return Qnil;
+	return INT2NUM(r);
+}
+
+/* Return the Taylor expansion of _self_ in a point.
+ * @param degree [Integer] degree of the expansion to be delivered
+ * @param point [Constant] point in wich the function is to be developed
+ * @return [Function]
+ */
+static VALUE sollyarb_function_taylor(VALUE self, VALUE degree, VALUE point)
+{
+	return sollyarb_autowrap_object(sollya_lib_taylor(sollyarb_object_rb2ref(self), SOLLYARB_TO_SOLLYA(degree), SOLLYARB_TO_SOLLYA(point)));
+}
+
+/* Returns the coefficient of dgree `n` of a polynomial.
+ * Returns 0 if _self_ is not a polynomial.
+ * @param n [Integer] coefficient degree
+ * @return [Sollya::Constant]
+ */
+static VALUE sollyarb_function_coeff(VALUE self, VALUE n) {
+	int i = NUM2INT(n);
+	sollya_obj_t j = sollya_lib_constant_from_int(i);
+	sollya_obj_t r = sollya_lib_coeff(sollyarb_object_rb2ref(self), j); 
+	sollya_lib_clear_obj(j);
+	return sollyarb_autowrap_object(r);
+}
+
+/* Computes an interval bounding the integral of a function on an interval.
+ *
+ * Returns an interval 𝐽 such that the exact value of the integral of _self_ on I lies in 𝐽.
+ *
+ * This command is safe but very inefficient. Use {dirtyintegral} if you just want an approximate
+ * value.
+ * 
+ * The result of this command depends on the global variable {diam}. The method used is the following:
+ * I is cut into intervals of length not greater then 𝛿 · |𝐼| where 𝛿 is the value of global variable {diam}.
+ * On each small interval J, an evaluation of _self_f by interval is performed. The result is multiplied by
+ * the length of J. Finally all values are summed.
+ * @param itvl [Sollya::Range]
+ * @return [Sollya::Range] an interval bounding the integral
+ */
+static VALUE sollyarb_function_integral(VALUE self, VALUE itvl)
+{
+	return sollyarb_autowrap_object(sollya_lib_integral(sollyarb_object_rb2ref(self), SOLLYARB_TO_SOLLYA(itvl)));
+}
+
+/* Computes a numerical approximation of the integral of _self_ on an interval.
+ *
+ * The interval must be bound. If the interval contains one of -Inf or +Inf, the result
+ * is NaN, even if the integral has a meaning.
+ * 
+ * The result of this command depends on the global variables {prec} and {points}. The method used
+ * is the trapezium rule applied at _𝑛_ evenly distributed points in the interval, where _𝑛_ is the value of
+ * global variable {points}.
+ * 
+ * This command computes a numerical approximation of the exact value of the integral. It should
+ * not be used if safety is critical. In this case, use command integral instead.
+ * 
+ * Warning: this command is currently known to be unsatisfactory. If you really need to compute
+ * integrals, think of using another tool.
+ *
+ * @param itvl [Sollya::Range]
+ * @return [Sollya::Constant]
+ */
+static VALUE sollyarb_function_dirtyintegral(VALUE self, VALUE itvl)
+{
+	return sollyarb_autowrap_object(sollya_lib_dirtyintegral(sollyarb_object_rb2ref(self), SOLLYARB_TO_SOLLYA(itvl)));
+}
+
+/* Computes the number of roots of a polynomial in a given range.
+ *
+ * Rigorously computes the number of roots of polynomial _self_ in the interval `itvl`. The
+ * technique used is Sturm's algorithm. The value returned is not just a numerical estimation of the
+ * number of roots of _self_ in `itvl`: it is the exact number of roots.
+ * 
+ * The method {findzeros} computes safe enclosures of all the zeros of a function, without forgetting
+ * any, but it is not guaranteed to separate them all in distinct intervals. _numberroots_ is more
+ * accurate since it guarantees the exact number of roots. However, it does not compute them. It
+ * may be used, for instance, to certify that {findzeros} did not put two distinct roots in the same
+ * interval.
+ * 
+ * Multiple roots are counted only once.
+ * 
+ * The interval `itvl` must be bounded. The algorithm cannot handle unbounded intervals. Moreover,
+ * the interval is considered as a closed interval: if one (or both) of the endpoints of `itvl` are roots of _self_,
+ * they are counted.
+ * 
+ * _self_ can be any expression, but if Sollya fails to prove that it is a polynomial an error
+ * is produced. Also, please note that if the coefficients of _self_ or the endpoints of `itvl` are not exactly
+ * representable, they are first numerically evaluated, before the algorithm is used. In that case, the
+ * counted number of roots corresponds to the rounded polynomial on the rounded interval and not
+ * to the exact parameters given by the user. A warning is displayed to inform the user.
+ *
+ * @param itvl [Sollya::Range]
+ * @return [Integer, nil]
+ */
+static VALUE sollyarb_function_numberroots(VALUE self, VALUE itvl)
+{
+	sollya_obj_t r = sollya_lib_numberroots(sollyarb_object_rb2ref(self), SOLLYARB_TO_SOLLYA(itvl));
+	int64_t i;
+	int s = sollya_lib_get_constant_as_int64(&i, r);
+	sollya_lib_clear_obj(r);
+	if (!s) return Qnil;
+	return LL2NUM(i);
+}
+
+/* Returns a list of intervals containing all zeros of _self_ on an interval.
+ *
+ * Returns a list of intervals 𝐼1, ..., 𝐼𝑛 such that, for every zero 𝑧 of _self_ , there exists
+ * some 𝑘 such that 𝑧 ∈ 𝐼𝑘 .
+ * 
+ * The list may contain intervals 𝐼𝑘 that do not contain any zero of _self_. An interval Ik may contain
+ * many zeros of _self_.
+ * 
+ * This command is meant for cases when safety is critical. If you want to be sure not to forget
+ * any zero, use findzeros. However, if you just want to know numerical values for the zeros of _self_,
+ * dirtyfindzeros should be quite satisfactory and a lot faster.
+ * 
+ * If 𝛿 denotes the value of global variable diam, the algorithm ensures that for each 𝑘, |𝐼𝑘| ≤ 𝛿·|𝐼|.
+ * 
+ * The algorithm used is basically a bisection algorithm. It is the same algorithm that the one used
+ * for infnorm. See the help page of this command for more details. In short, the behavior of the
+ * algorithm depends on global variables prec, diam, taylorrecursions and hopitalrecursions.
+ *
+ * @param itvl [Sollya::Range]
+ * @return [Sollya::List<Sollya::Range>]
+ * @see dirtyfindzeros
+ */
+static VALUE sollyarb_function_findzeros(VALUE self, VALUE itvl)
+{
+	return sollyarb_autowrap_object(sollya_lib_findzeros(sollyarb_object_rb2ref(self), SOLLYARB_TO_SOLLYA(itvl)));
+}
+
+/* Returns a list of numerical values listing the zeros of _self_ on an interval.
+ * @param itvl [Sollya::Range]
+ * @return [Sollya::List<Sollya::Range>]
+ * @see findzeros
+ */
+static VALUE sollyarb_function_dirtyfindzeros(VALUE self, VALUE itvl)
+{
+	return sollyarb_autowrap_object(sollya_lib_dirtyfindzeros(sollyarb_object_rb2ref(self), SOLLYARB_TO_SOLLYA(itvl)));
+}
+
+static VALUE sollyarb_function_chebyshevform(VALUE self, VALUE n, VALUE itvl)
+{
+	return sollyarb_autowrap_object(sollya_lib_chebyshevform(sollyarb_object_rb2ref(self), SOLLYARB_TO_SOLLYA(n), SOLLYARB_TO_SOLLYA(itvl)));
+}
+
+/* Computes the first 𝑛 derivatives of _self_ at a point or over an interval.
+ * @param n [Integer] the order or differentiation
+ * @param itvl [Constant, Range] point or interval over which _self_ is differentiated
+ * @return [List<Function>]
+ */
+static VALUE sollyarb_function_autodiff(VALUE self, VALUE n, VALUE itvl)
+{
+	return sollyarb_autowrap_object(sollya_lib_autodiff(sollyarb_object_rb2ref(self), SOLLYARB_TO_SOLLYA(n), SOLLYARB_TO_SOLLYA(itvl)));
+}
+
+/* Evaluates _self_ at a constant point or in a range
+ * @param x [Constant, Range, Function] point or interval over which _self_ is evaluated
+ * @return [Constant, Range, Function]
+ */
+static VALUE sollyarb_function_evaluate(VALUE self, VALUE x)
+{
+	return sollyarb_autowrap_object(sollya_lib_evaluate(sollyarb_object_rb2ref(self), SOLLYARB_TO_SOLLYA(x)));
+}
+
+/* Replace the occurrences of the free variable in _self_.
+ * @param g [Function, Constant]
+ * @return [Function, Constant]
+ */
+static VALUE sollyarb_function_substitute(VALUE self, VALUE g)
+{
+	return sollyarb_autowrap_object(sollya_lib_substitute(sollyarb_object_rb2ref(self), SOLLYARB_TO_SOLLYA(g)));
+}
+
+
+
+
+
+
+
+
+
+#if 0
+static int sollyarb_msg_callback(sollya_msg_t msg, void *data)
+{
+	(void)data;
+	int msg_id = sollya_lib_get_msg_id(msg);
+	char *txt = sollya_lib_msg_to_text(msg);
+//	fprintf(stderr, "\e[31;1m[Sollya]\e[0;91m %s\e[0m\n", txt);
+	fprintf(stderr, "\e[91m[Sollya, %d] %s\e[0m\n", msg_id, txt);
+//	rb_warning("\e[91m[Sollya, %d] %s\e[0m\n", msg_id, txt);
+//	rb_warn("\e[91m[Sollya, %d] %s\e[0m\n", msg_id, txt);
+	sollya_lib_free(txt);
+	return 0;
+}
+#endif
+
+
+static VALUE sollyarb_help_str(VALUE self, VALUE topic_str)
+{
+	(void)self;
+	Check_Type(topic_str, T_STRING);
+	char *tstr = rb_string_value_cstr(&topic_str);
+	const char *h = sollya_lib_get_help_text(tstr);
+	if (!h) {
+		return Qnil;
+	}
+	return rb_str_new_cstr(h);
+}
+
+
+static VALUE sollyarb_help(VALUE self, VALUE topic_str)
+{
+	(void)self;
+	Check_Type(topic_str, T_STRING);
+	char *tstr = rb_string_value_cstr(&topic_str);
+	const char *h = sollya_lib_get_help_text(tstr);
+	if (!h) {
+		printf("No Sollya help found for topic %s\n", tstr);
+		return Qfalse;
+	}
+	puts(h);
+	return Qtrue;
+}
+
+
+static VALUE sollyarb_object_cmp_equal(VALUE self, VALUE other)
+{
+	sollya_obj_t y = SOLLYARB_TO_SOLLYA(other);
+	sollya_obj_t x = sollyarb_object_rb2ref(self);
+	sollya_obj_t r = sollya_lib_cmp_equal(x, y);
+	VALUE b;
+	if (sollya_lib_is_true(r)) {
+		b = Qtrue;
+	} else if (sollya_lib_is_false(r)) {
+		b = Qfalse;
+	} else {
+		b = Qnil;
+	}
+	sollya_lib_clear_obj(r);
+	return b;
+}
+
+
+static VALUE sollyarb_object_cmp_not_equal(VALUE self, VALUE other)
+{
+	sollya_obj_t y = SOLLYARB_TO_SOLLYA(other);
+	sollya_obj_t x = sollyarb_object_rb2ref(self);
+	sollya_obj_t r = sollya_lib_cmp_not_equal(x, y);
+	VALUE b;
+	if (sollya_lib_is_true(r)) {
+		b = Qtrue;
+	} else if (sollya_lib_is_false(r)) {
+		b = Qfalse;
+	} else {
+		b = Qnil;
+	}
+	sollya_lib_clear_obj(r);
+	return b;
+}
+
+
+static VALUE sollyarb_object_cmp_less(VALUE self, VALUE other)
+{
+	sollya_obj_t y = SOLLYARB_TO_SOLLYA(other);
+	sollya_obj_t x = sollyarb_object_rb2ref(self);
+	sollya_obj_t r = sollya_lib_cmp_less(x, y);
+	VALUE b;
+	if (sollya_lib_is_true(r)) {
+		b = Qtrue;
+	} else if (sollya_lib_is_false(r)) {
+		b = Qfalse;
+	} else {
+		b = Qnil;
+	}
+	sollya_lib_clear_obj(r);
+	if (RB_NIL_P(b)) {
+		rb_raise(rb_eArgError, "comparison of %s with %s failed", rb_obj_classname(self), rb_obj_classname(other));
+	}
+	return b;
+}
+
+
+static VALUE sollyarb_object_cmp_greater(VALUE self, VALUE other)
+{
+	sollya_obj_t y = SOLLYARB_TO_SOLLYA(other);
+	sollya_obj_t x = sollyarb_object_rb2ref(self);
+	sollya_obj_t r = sollya_lib_cmp_greater(x, y);
+	VALUE b;
+	if (sollya_lib_is_true(r)) {
+		b = Qtrue;
+	} else if (sollya_lib_is_false(r)) {
+		b = Qfalse;
+	} else {
+		b = Qnil;
+	}
+	sollya_lib_clear_obj(r);
+	if (RB_NIL_P(b)) {
+		rb_raise(rb_eArgError, "comparison of %s with %s failed", rb_obj_classname(self), rb_obj_classname(other));
+	}
+	return b;
+}
+
+
+static VALUE sollyarb_object_cmp_less_equal(VALUE self, VALUE other)
+{
+	sollya_obj_t y = SOLLYARB_TO_SOLLYA(other);
+	sollya_obj_t x = sollyarb_object_rb2ref(self);
+	sollya_obj_t r = sollya_lib_cmp_less_equal(x, y);
+	VALUE b;
+	if (sollya_lib_is_true(r)) {
+		b = Qtrue;
+	} else if (sollya_lib_is_false(r)) {
+		b = Qfalse;
+	} else {
+		b = Qnil;
+	}
+	sollya_lib_clear_obj(r);
+	if (RB_NIL_P(b)) {
+		rb_raise(rb_eArgError, "comparison of %s with %s failed", rb_obj_classname(self), rb_obj_classname(other));
+	}
+	return b;
+}
+
+
+static VALUE sollyarb_object_cmp_greater_equal(VALUE self, VALUE other)
+{
+	sollya_obj_t y = SOLLYARB_TO_SOLLYA(other);
+	sollya_obj_t x = sollyarb_object_rb2ref(self);
+	sollya_obj_t r = sollya_lib_cmp_greater_equal(x, y);
+	VALUE b;
+	if (sollya_lib_is_true(r)) {
+		b = Qtrue;
+	} else if (sollya_lib_is_false(r)) {
+		b = Qfalse;
+	} else {
+		b = Qnil;
+	}
+	sollya_lib_clear_obj(r);
+	if (RB_NIL_P(b)) {
+		rb_raise(rb_eArgError, "comparison of %s with %s failed", rb_obj_classname(self), rb_obj_classname(other));
+	}
+	return b;
+}
+
+
+static VALUE sollyarb_object_coerce(VALUE self, VALUE num)
+{
+	return rb_ary_new_from_args(2, rb_funcallv(num, id_to_sollya, 0, NULL), self);
+}
+
+
+/* @return [Integer, nil]
+ */
+static VALUE sollyarb_function_arity(VALUE self)
+{
+	int arity = 0;
+	if (!sollya_lib_get_function_arity(&arity, sollyarb_object_rb2ref(self)) || arity < 1) {
+		return Qnil;
+	}
+	return INT2NUM(arity);
+}
+
+
+static VALUE sollyarb_unaryop_get_child(VALUE self)
+{
+	sollya_obj_t c;
+	if (!sollya_lib_get_nth_subfunction(&c, sollyarb_object_rb2ref(self), 1)) {
+		return Qnil;
+	}
+	return sollyarb_autowrap_object(c);
+}
+
+static VALUE sollyarb_binaryop_get_lhs(VALUE self)
+{
+	sollya_obj_t c;
+	if (!sollya_lib_get_nth_subfunction(&c, sollyarb_object_rb2ref(self), 1)) {
+		return Qnil;
+	}
+	return sollyarb_autowrap_object(c);
+}
+
+static VALUE sollyarb_binaryop_get_rhs(VALUE self)
+{
+	sollya_obj_t c;
+	if (!sollya_lib_get_nth_subfunction(&c, sollyarb_object_rb2ref(self), 2)) {
+		return Qnil;
+	}
+	return sollyarb_autowrap_object(c);
+}
+
+static VALUE sollyarb_function_get_nth_child(VALUE self, VALUE n)
+{
+	int m = NUM2INT(n);
+	sollya_obj_t c;
+	if (!sollya_lib_get_nth_subfunction(&c, sollyarb_object_rb2ref(self), m - 1)) {
+		return Qnil;
+	}
+	if (rb_class_of(self) == c_Freevariable) {
+		return Qnil;
+	}
+	return sollyarb_autowrap_object(c);
+}
+
+static VALUE sollyarb_function_get_children(VALUE self)
+{
+	sollya_obj_t func = sollyarb_object_rb2ref(self);
+	int arity = 1;
+	sollya_lib_get_function_arity(&arity, func);
+	VALUE ar = rb_ary_new_capa(arity);
+	if (rb_class_of(self) == c_Freevariable) {
+		return ar;
+	}
+	sollya_obj_t c;
+	int m = 1;
+	while (sollya_lib_get_nth_subfunction(&c, func, m++)) {
+		rb_ary_push(ar, sollyarb_autowrap_object(c));
+	}
+	return ar;
+}
+
+
+/* @return [MPFR]
+ */
+static VALUE sollyarb_constant_to_mpfr(VALUE self)
+{
+	sollya_obj_t cst = sollyarb_object_rb2ref(self);
+	mp_prec_t prec = 0;
+	if (!sollya_lib_get_prec_of_constant(&prec, cst)) {
+		sollya_obj_t p = sollya_lib_get_prec();
+		sollya_lib_get_constant_as_int64(&prec, p);
+		sollya_lib_clear_obj(p);
+	}
+	if (!prec) return Qnil;
+	VALUE mprb = mpfrrb_alloc(c_MPFR);
+	mpfr_ptr mp = mpfrrb_rb2ref_ext(mprb);
+	mpfr_init2(mp, prec);
+	if (!sollya_lib_get_constant(mp, cst)) {
+		return Qnil;
+	}
+	return mprb;
+}
+
+
+/* @return [Float]
+ */
+static VALUE sollyarb_constant_to_f(VALUE self)
+{
+	sollya_obj_t cst = sollyarb_object_rb2ref(self);
+	double d;
+	if (!sollya_lib_get_constant_as_double(&d, cst))
+		return Qnil;
+	return DBL2NUM(d);
+}
+
+
+void Init_sollya(void)
+{
+	Init_mpfr();
+
+	id_to_sollya = rb_intern("to_sollya");
+	id_to_mpfr   = rb_intern("to_mpfr");
+	id_to_s      = rb_intern("to_s");
+	id_end_elliptic = rb_intern("end_elliptic");
+	id_prec         = rb_intern("prec");
+	id_on                  = rb_intern("on");
+	id_off                 = rb_intern("off");
+	id_dyadic              = rb_intern("dyadic");
+	id_powers              = rb_intern("powers");
+	id_binary              = rb_intern("binary");
+	id_hexadecimal         = rb_intern("hexadecimal");
+	id_file                = rb_intern("file");
+	id_postscript          = rb_intern("postscript");
+	id_postscriptfile      = rb_intern("postscriptfile");
+	id_perturb             = rb_intern("perturb");
+	id_RD                  = rb_intern("RD");
+	id_round_down          = rb_intern("round_down");
+	id_RU                  = rb_intern("RU");
+	id_round_up            = rb_intern("round_up");
+	id_RZ                  = rb_intern("RZ");
+	id_round_towards_zero  = rb_intern("round_towards_zero");
+	id_RN                  = rb_intern("RN");
+	id_round_to_nearest    = rb_intern("round_to_nearest");
+	id_honorcoeffprec      = rb_intern("honorcoeffprec");
+	id_true                = rb_intern("true");
+	id_false               = rb_intern("false");
+	id_void                = rb_intern("void");
+	id_default             = rb_intern("default");
+	id_decimal             = rb_intern("decimal");
+	id_absolute            = rb_intern("absolute");
+	id_relative            = rb_intern("relative");
+	id_fixed               = rb_intern("fixed");
+	id_floating            = rb_intern("floating");
+	id_error               = rb_intern("error");
+	id_D                   = rb_intern("D");
+	id_double              = rb_intern("double");
+	id_SG                  = rb_intern("SG");
+	id_single              = rb_intern("single");
+	id_QD                  = rb_intern("QD");
+	id_quad                = rb_intern("quad");
+	id_HP                  = rb_intern("HP");
+	id_halfprecision       = rb_intern("halfprecision");
+	id_DE                  = rb_intern("DE");
+	id_doubleextended      = rb_intern("doubleextended");
+	id_DD                  = rb_intern("DD");
+	id_doubledouble        = rb_intern("doubledouble");
+	id_TD                  = rb_intern("TD");
+	id_tripledouble        = rb_intern("tripledouble");
+
+
+	m_Sollya = rb_define_module("Sollya");
+
+	rb_define_module_function(m_Sollya, "parse",     sollyarb_parse,    1);
+	rb_define_module_function(m_Sollya, "help_str",  sollyarb_help_str, 1);
+	rb_define_module_function(m_Sollya, "help",      sollyarb_help,     1);
+
+	/* Global variable getters and setters */
+	rb_define_module_function(m_Sollya, "prec",                sollyarb_get_prec,               0);
+	rb_define_module_function(m_Sollya, "prec=",               sollyarb_set_prec,               1);
+	rb_define_module_function(m_Sollya, "points",              sollyarb_get_points,             0);
+	rb_define_module_function(m_Sollya, "points=",             sollyarb_set_points,             1);
+	rb_define_module_function(m_Sollya, "diam",                sollyarb_get_diam,               0);
+	rb_define_module_function(m_Sollya, "diam=",               sollyarb_set_diam,               1);
+	rb_define_module_function(m_Sollya, "display",             sollyarb_get_display,            0);
+	rb_define_module_function(m_Sollya, "display=",            sollyarb_set_display,            1);
+	rb_define_module_function(m_Sollya, "verbosity",           sollyarb_get_verbosity,          0);
+	rb_define_module_function(m_Sollya, "verbosity=",          sollyarb_set_verbosity,          1);
+	rb_define_module_function(m_Sollya, "roundingwarnings",    sollyarb_get_roundingwarnings,   0);
+	rb_define_module_function(m_Sollya, "roundingwarnings=",   sollyarb_set_roundingwarnings,   1);
+	rb_define_module_function(m_Sollya, "autosimplify",        sollyarb_get_autosimplify,       0);
+	rb_define_module_function(m_Sollya, "autosimplify=",       sollyarb_set_autosimplify,       1);
+	rb_define_module_function(m_Sollya, "fullparentheses",     sollyarb_get_fullparentheses,    0);
+	rb_define_module_function(m_Sollya, "fullparentheses=",    sollyarb_set_fullparentheses,    1);
+	rb_define_module_function(m_Sollya, "showmessagenumbers",  sollyarb_get_showmessagenumbers, 0);
+	rb_define_module_function(m_Sollya, "showmessagenumbers=", sollyarb_set_showmessagenumbers, 1);
+	rb_define_module_function(m_Sollya, "midpointmode",        sollyarb_get_midpointmode,       0);
+	rb_define_module_function(m_Sollya, "midpointmode=",       sollyarb_set_midpointmode,       1);
+	rb_define_module_function(m_Sollya, "canonical",           sollyarb_get_canonical,         -1);
+	rb_define_module_function(m_Sollya, "canonical=",          sollyarb_set_canonical,          1);
+	rb_define_module_function(m_Sollya, "rationalmode",        sollyarb_get_rationalmode,       0);
+	rb_define_module_function(m_Sollya, "rationalmode=",       sollyarb_set_rationalmode,       1);
+	rb_define_module_function(m_Sollya, "timing",              sollyarb_get_timing,             0);
+	rb_define_module_function(m_Sollya, "timing=",             sollyarb_set_timing,             1);
+	rb_define_module_function(m_Sollya, "taylorrecursions",    sollyarb_get_taylorrecursions,   0);
+	rb_define_module_function(m_Sollya, "taylorrecursions=",   sollyarb_set_taylorrecursions,   1);
+	rb_define_module_function(m_Sollya, "hopitalrecursions",   sollyarb_get_hopitalrecursions,  0);
+	rb_define_module_function(m_Sollya, "hopitalrecursions=",  sollyarb_set_hopitalrecursions,  1);
+	rb_define_module_function(m_Sollya, "free_variable_name",  sollyarb_get_free_variable_name, 0);
+	rb_define_module_function(m_Sollya, "free_variable_name=", sollyarb_set_free_variable_name, 1);
+
+	/* Functions corresponding to Sollya commands */
+	rb_define_module_function(m_Sollya, "plot",                sollyarb_plot,               -1);
+	rb_define_module_function(m_Sollya, "asciiplot",           sollyarb_asciiplot,           2);
+	rb_define_module_function(m_Sollya, "printdouble",         sollyarb_printdouble,         1);
+	rb_define_module_function(m_Sollya, "printsingle",         sollyarb_printsingle,         1);
+	rb_define_module_function(m_Sollya, "printprintexpansion", sollyarb_printexpansion,      1);
+	rb_define_module_function(m_Sollya, "externalplot",        sollyarb_externalplot,       -1);
+	rb_define_module_function(m_Sollya, "execute",             sollyarb_execute,             1);
+	rb_define_module_function(m_Sollya, "printxml",            sollyarb_printxml,            1);
+	rb_define_module_function(m_Sollya, "printxml_newfile",    sollyarb_printxml_newfile,    2);
+	rb_define_module_function(m_Sollya, "printxml_appendfile", sollyarb_printxml_appendfile, 2);
+	rb_define_module_function(m_Sollya, "worstcase",           sollyarb_worstcase,          -1);
+	rb_define_module_function(m_Sollya, "autoprint",           sollyarb_autoprint,          -1);
+	rb_define_module_function(m_Sollya, "suppressmessage",     sollyarb_suppressmessage,    -1);
+	rb_define_module_function(m_Sollya, "unsuppressmessage",   sollyarb_unsuppressmessage,  -1);
+	rb_define_module_function(m_Sollya, "implementconstant",   sollyarb_implementconstant,  -1);
+
+	/* Functions corresponding to Sollya built-in procedures */
+	rb_define_module_function(m_Sollya, "range",          sollyarb_range,          2);
+	rb_define_module_function(m_Sollya, "list",           sollyarb_list,          -1);
+	rb_define_module_function(m_Sollya, "fpminimax",      sollyarb_fpminimax,     -1);
+	rb_define_module_function(m_Sollya, "supnorm",        sollyarb_supnorm,        5);
+	rb_define_module_function(m_Sollya, "free_variable",  sollyarb_free_variable,  0);
+	rb_define_module_function(m_Sollya, "x",              sollyarb_free_variable,  0);
+	rb_define_module_function(m_Sollya, "exp",            sollyarb_exp,            1);
+	rb_define_module_function(m_Sollya, "log",            sollyarb_log,            1);
+	rb_define_module_function(m_Sollya, "log2",           sollyarb_log2,           1);
+	rb_define_module_function(m_Sollya, "log10",          sollyarb_log10,          1);
+	rb_define_module_function(m_Sollya, "sqrt",           sollyarb_sqrt,           1);
+	rb_define_module_function(m_Sollya, "sin",            sollyarb_sin,            1);
+	rb_define_module_function(m_Sollya, "cos",            sollyarb_cos,            1);
+	rb_define_module_function(m_Sollya, "tan",            sollyarb_tan,            1);
+	rb_define_module_function(m_Sollya, "asin",           sollyarb_asin,           1);
+	rb_define_module_function(m_Sollya, "acos",           sollyarb_acos,           1);
+	rb_define_module_function(m_Sollya, "atan",           sollyarb_atan,           1);
+	rb_define_module_function(m_Sollya, "sinh",           sollyarb_sinh,           1);
+	rb_define_module_function(m_Sollya, "cosh",           sollyarb_cosh,           1);
+	rb_define_module_function(m_Sollya, "tanh",           sollyarb_tanh,           1);
+	rb_define_module_function(m_Sollya, "asinh",          sollyarb_asinh,          1);
+	rb_define_module_function(m_Sollya, "acosh",          sollyarb_acosh,          1);
+	rb_define_module_function(m_Sollya, "atanh",          sollyarb_atanh,          1);
+	rb_define_module_function(m_Sollya, "abs",            sollyarb_abs,            1);
+	rb_define_module_function(m_Sollya, "erf",            sollyarb_erf,            1);
+	rb_define_module_function(m_Sollya, "erfc",           sollyarb_erfc,           1);
+	rb_define_module_function(m_Sollya, "log1p",          sollyarb_log1p,          1);
+	rb_define_module_function(m_Sollya, "expm1",          sollyarb_expm1,          1);
+	rb_define_module_function(m_Sollya, "double",         sollyarb_double,         1);
+	rb_define_module_function(m_Sollya, "single",         sollyarb_single,         1);
+	rb_define_module_function(m_Sollya, "quad",           sollyarb_quad,           1);
+	rb_define_module_function(m_Sollya, "halfprecision",  sollyarb_halfprecision,  1);
+	rb_define_module_function(m_Sollya, "double_double",  sollyarb_double_double,  1);
+	rb_define_module_function(m_Sollya, "triple_double",  sollyarb_triple_double,  1);
+	rb_define_module_function(m_Sollya, "doubleextended", sollyarb_doubleextended, 1);
+	rb_define_module_function(m_Sollya, "ceil",           sollyarb_ceil,           1);
+	rb_define_module_function(m_Sollya, "floor",          sollyarb_floor,          1);
+	rb_define_module_function(m_Sollya, "nearestint",     sollyarb_nearestint,     1);
+	rb_define_module_function(m_Sollya, "apply",          sollyarb_apply,         -1);
+	rb_define_module_function(m_Sollya, "approx",         sollyarb_approx,         1);
+	rb_define_module_function(m_Sollya, "infnorm",        sollyarb_infnorm,       -1);
+	rb_define_module_function(m_Sollya, "dirtyinfnorm",   sollyarb_dirtyinfnorm,   2);
+	rb_define_module_function(m_Sollya, "remez",          sollyarb_remez,         -1);
+	rb_define_module_function(m_Sollya, "taylorform",     sollyarb_taylorform,    -1);
+	rb_define_module_function(m_Sollya, "interpolate",    sollyarb_interpolate,   -1);
+	rb_define_module_function(m_Sollya, "getbacktrace",   sollyarb_getbacktrace,   0);
+//	rb_define_module_function(m_Sollya, "", sollyarb_, 1);
+//	rb_define_module_function(m_Sollya, "", sollyarb_, 1);
+
+//  sollya_obj_t sollya_lib_annotatefunction(sollya_obj_t, sollya_obj_t, sollya_obj_t, sollya_obj_t, ...);
+//  sollya_obj_t sollya_lib_min(sollya_obj_t, ...);
+//  sollya_obj_t sollya_lib_max(sollya_obj_t, ...);
+//  sollya_obj_t sollya_lib_composepolynomials(sollya_obj_t, sollya_obj_t);
+//  sollya_obj_t sollya_lib_bezout(sollya_obj_t, sollya_obj_t);
+//  sollya_obj_t sollya_lib_subpoly(sollya_obj_t, sollya_obj_t);
+//  sollya_obj_t sollya_lib_roundcoefficients(sollya_obj_t, sollya_obj_t);
+//  sollya_obj_t sollya_lib_rationalapprox(sollya_obj_t, sollya_obj_t);
+//  sollya_obj_t sollya_lib_round(sollya_obj_t, sollya_obj_t, sollya_obj_t);
+//  sollya_obj_t sollya_lib_parse(sollya_obj_t);
+//  sollya_obj_t sollya_lib_readxml(sollya_obj_t);
+//  sollya_obj_t sollya_lib_gcd(sollya_obj_t, sollya_obj_t);
+//  sollya_obj_t sollya_lib_euclidian_div(sollya_obj_t, sollya_obj_t);
+//  sollya_obj_t sollya_lib_euclidian_mod(sollya_obj_t, sollya_obj_t);
+//  sollya_obj_t sollya_lib_implementpoly(sollya_obj_t, sollya_obj_t, sollya_obj_t, sollya_obj_t, sollya_obj_t, sollya_obj_t, ...);
+//  sollya_obj_t sollya_lib_checkinfnorm(sollya_obj_t, sollya_obj_t, sollya_obj_t);
+//  sollya_obj_t sollya_lib_searchgal(sollya_obj_t, sollya_obj_t, sollya_obj_t, sollya_obj_t, sollya_obj_t, sollya_obj_t);
+//  sollya_obj_t sollya_lib_guessdegree(sollya_obj_t, sollya_obj_t, sollya_obj_t, ...);
+//  sollya_obj_t sollya_lib_head(sollya_obj_t);
+//  sollya_obj_t sollya_lib_roundcorrectly(sollya_obj_t);
+//  sollya_obj_t sollya_lib_revert(sollya_obj_t);
+//  sollya_obj_t sollya_lib_sort(sollya_obj_t);
+//  sollya_obj_t sollya_lib_mantissa(sollya_obj_t);
+//  sollya_obj_t sollya_lib_exponent(sollya_obj_t);
+//  sollya_obj_t sollya_lib_precision(sollya_obj_t);
+//  sollya_obj_t sollya_lib_tail(sollya_obj_t);
+//  sollya_obj_t sollya_lib_length(sollya_obj_t);
+//  sollya_obj_t sollya_lib_objectname(sollya_obj_t);
+
+
+	c_SolObject = rb_define_class_under(m_Sollya, "Object", rb_cObject);
+	rb_define_alloc_func(c_SolObject, sollyarb_object_alloc);
+	rb_undef_method(rb_class_of(c_SolObject), "allocate");
+	rb_undef_method(rb_class_of(c_SolObject), "new");
+
+	c_SolString   = rb_define_class_under(m_Sollya, "String",   c_SolObject);
+	c_SolRange    = rb_define_class_under(m_Sollya, "Range",    c_SolObject);
+	c_SolList     = rb_define_class_under(m_Sollya, "List",     c_SolObject);
+	c_SolStructure         = rb_define_class_under(m_Sollya, "Structure",         c_SolObject);
+	c_SolProcedure         = rb_define_class_under(m_Sollya, "Procedure",         c_SolObject);
+	c_SolExternalProcedure = rb_define_class_under(m_Sollya, "ExternalProcedure", c_SolObject);
+	c_SolExternalData      = rb_define_class_under(m_Sollya, "ExternalData",      c_SolObject);
+	c_SolSpecial           = rb_define_class_under(m_Sollya, "Special",           c_SolObject);
+	c_SolFunction          = rb_define_class_under(m_Sollya, "Function",          c_SolObject);
+	c_UnaryOp              = rb_define_class_under(m_Sollya, "UnaryOp",           c_SolFunction);
+	c_BinaryOp             = rb_define_class_under(m_Sollya, "BinaryOp",          c_SolFunction);
+	c_Constant             = rb_define_class_under(m_Sollya, "Constant",          c_SolFunction);
+	c_Abs                  = rb_define_class_under(m_Sollya, "Abs",               c_UnaryOp);
+	c_Acos                 = rb_define_class_under(m_Sollya, "Acos",              c_UnaryOp);
+	c_Acosh                = rb_define_class_under(m_Sollya, "Acosh",             c_UnaryOp);
+	c_Add                  = rb_define_class_under(m_Sollya, "Add",               c_BinaryOp);
+	c_Asin                 = rb_define_class_under(m_Sollya, "Asin",              c_UnaryOp);
+	c_Asinh                = rb_define_class_under(m_Sollya, "Asinh",             c_UnaryOp);
+	c_Atan                 = rb_define_class_under(m_Sollya, "Atan",              c_UnaryOp);
+	c_Atanh                = rb_define_class_under(m_Sollya, "Atanh",             c_UnaryOp);
+	c_Ceil                 = rb_define_class_under(m_Sollya, "Ceil",              c_UnaryOp);
+	c_Cos                  = rb_define_class_under(m_Sollya, "Cos",               c_UnaryOp);
+	c_Cosh                 = rb_define_class_under(m_Sollya, "Cosh",              c_UnaryOp);
+	c_Div                  = rb_define_class_under(m_Sollya, "Div",               c_BinaryOp);
+	c_Double               = rb_define_class_under(m_Sollya, "Double",            c_UnaryOp);
+	c_DoubleDouble         = rb_define_class_under(m_Sollya, "DoubleDouble",      c_UnaryOp);
+	c_DoubleExtended       = rb_define_class_under(m_Sollya, "DoubleExtended",    c_UnaryOp);
+	c_Erf                  = rb_define_class_under(m_Sollya, "Erf",               c_UnaryOp);
+	c_Erfc                 = rb_define_class_under(m_Sollya, "Erfc",              c_UnaryOp);
+	c_Exp                  = rb_define_class_under(m_Sollya, "Exp",               c_UnaryOp);
+	c_Expm1                = rb_define_class_under(m_Sollya, "Expm1",             c_UnaryOp);
+	c_Floor                = rb_define_class_under(m_Sollya, "Floor",             c_UnaryOp);
+	c_Freevariable         = rb_define_class_under(m_Sollya, "FreeVariable",      c_SolFunction);
+	c_Halfprecision        = rb_define_class_under(m_Sollya, "HalfPrecision",     c_UnaryOp);
+	c_Libraryconstant      = rb_define_class_under(m_Sollya, "LibraryConstant",   c_Constant);
+	c_Libraryfunction      = rb_define_class_under(m_Sollya, "LibraryFunction",   c_SolFunction);
+	c_Log                  = rb_define_class_under(m_Sollya, "Log",               c_UnaryOp);
+	c_Log10                = rb_define_class_under(m_Sollya, "Log10",             c_UnaryOp);
+	c_Log1p                = rb_define_class_under(m_Sollya, "Log1p",             c_UnaryOp);
+	c_Log2                 = rb_define_class_under(m_Sollya, "Log2",              c_UnaryOp);
+	c_Mul                  = rb_define_class_under(m_Sollya, "Mul",               c_BinaryOp);
+	c_Nearestint           = rb_define_class_under(m_Sollya, "NearestInt",        c_UnaryOp);
+	c_Neg                  = rb_define_class_under(m_Sollya, "Neg",               c_UnaryOp);
+	c_Pi                   = rb_define_class_under(m_Sollya, "Pi",                c_Constant);
+	c_Pow                  = rb_define_class_under(m_Sollya, "Pow",               c_BinaryOp);
+	c_Procedurefunction    = rb_define_class_under(m_Sollya, "ProcedureFunction", c_SolFunction);
+	c_Quad                 = rb_define_class_under(m_Sollya, "Quad",              c_UnaryOp);
+	c_Sin                  = rb_define_class_under(m_Sollya, "Sin",               c_UnaryOp);
+	c_Single               = rb_define_class_under(m_Sollya, "Single",            c_UnaryOp);
+	c_Sinh                 = rb_define_class_under(m_Sollya, "Sinh",              c_UnaryOp);
+	c_Sqrt                 = rb_define_class_under(m_Sollya, "Sqrt",              c_UnaryOp);
+	c_Sub                  = rb_define_class_under(m_Sollya, "Sub",               c_BinaryOp);
+	c_Tan                  = rb_define_class_under(m_Sollya, "Tan",               c_UnaryOp);
+	c_Tanh                 = rb_define_class_under(m_Sollya, "Tanh",              c_UnaryOp);
+	c_Tripledouble         = rb_define_class_under(m_Sollya, "TripleDouble",      c_UnaryOp);
+
+
+	rb_define_method(c_SolObject, "to_sollya", sollyarb_object_to_sollya,         0);
+	rb_define_method(c_SolObject, "print",     sollyarb_object_print,             0);
+	rb_define_method(c_SolObject, "to_s",      sollyarb_object_to_s,              0);
+	rb_define_method(c_SolObject, "inspect",   sollyarb_object_inspect,           0);
+	rb_define_method(c_SolObject, "==",        sollyarb_object_cmp_equal,         1);
+	rb_define_method(c_SolObject, "!=",        sollyarb_object_cmp_not_equal,     1);
+	rb_define_method(c_SolObject, "&",         sollyarb_object_and,               1);
+	rb_define_method(c_SolObject, "|",         sollyarb_object_or,                1);
+	rb_define_method(c_SolObject, "~",         sollyarb_object_negate,            0);
+	rb_define_method(c_SolObject, "concat",    sollyarb_object_concat,            1);
+
+	rb_define_method(c_SolFunction, "<",             sollyarb_object_cmp_less,          1);
+	rb_define_method(c_SolFunction, ">",             sollyarb_object_cmp_greater,       1);
+	rb_define_method(c_SolFunction, "<=",            sollyarb_object_cmp_less_equal,    1);
+	rb_define_method(c_SolFunction, ">=",            sollyarb_object_cmp_greater_equal, 1);
+	rb_define_method(c_SolFunction, "+",             sollyarb_object_add,               1);
+	rb_define_method(c_SolFunction, "-",             sollyarb_object_sub,               1);
+	rb_define_method(c_SolFunction, "*",             sollyarb_object_mul,               1);
+	rb_define_method(c_SolFunction, "/",             sollyarb_object_div,               1);
+	rb_define_method(c_SolFunction, "**",            sollyarb_object_pow,               1);
+	rb_define_method(c_SolFunction, "-@",            sollyarb_object_neg,               0);
+	rb_define_method(c_SolFunction, "coerce",        sollyarb_object_coerce,            1);
+	rb_define_method(c_SolFunction, "in",            sollyarb_object_in,                1);
+	rb_define_method(c_SolFunction, "abs",           sollyarb_function_abs,             0);
+	rb_define_method(c_SolFunction, "ceil",          sollyarb_function_ceil,            0);
+	rb_define_method(c_SolFunction, "floor",         sollyarb_function_floor,           0);
+	rb_define_method(c_SolFunction, "nearestint",    sollyarb_function_nearestint,      0);
+	rb_define_method(c_SolFunction, "apply_at",      sollyarb_function_apply_at,       -1);
+	rb_define_method(c_SolFunction, "diff",          sollyarb_function_diff,            0);
+	rb_define_method(c_SolFunction, "horner",        sollyarb_function_horner,          0);
+	rb_define_method(c_SolFunction, "expand",        sollyarb_function_expand,          0);
+	rb_define_method(c_SolFunction, "simplify",      sollyarb_function_simplify,        0);
+	rb_define_method(c_SolFunction, "dirtysimplify", sollyarb_function_dirtysimplify,   0);
+	rb_define_method(c_SolFunction, "degree",        sollyarb_function_degree,          0);
+	rb_define_method(c_SolFunction, "taylor",        sollyarb_function_taylor,          2);
+	rb_define_method(c_SolFunction, "coeff",         sollyarb_function_coeff,           1);
+	rb_define_method(c_SolFunction, "integral",      sollyarb_function_integral,        1);
+	rb_define_method(c_SolFunction, "dirtyintegral", sollyarb_function_dirtyintegral,   1);
+	rb_define_method(c_SolFunction, "numberroots",   sollyarb_function_numberroots,     1);
+	rb_define_method(c_SolFunction, "findzeros",     sollyarb_function_findzeros,       1);
+	rb_define_method(c_SolFunction, "dirtyfindzeros",sollyarb_function_dirtyfindzeros,  1);
+	rb_define_method(c_SolFunction, "chebyshevform", sollyarb_function_chebyshevform,   2);
+	rb_define_method(c_SolFunction, "autodiff",      sollyarb_function_autodiff,        2);
+	rb_define_method(c_SolFunction, "evaluate",      sollyarb_function_evaluate,        1);
+	rb_define_method(c_SolFunction, "substitute",    sollyarb_function_substitute,      1);
+	rb_define_method(c_SolFunction, "numerator",     sollyarb_function_numerator,       0);
+	rb_define_method(c_SolFunction, "denominator",   sollyarb_function_denominator,     0);
+	rb_define_method(c_SolFunction, "arity",         sollyarb_function_arity,           0);
+
+	rb_define_method(c_UnaryOp,     "child",      sollyarb_unaryop_get_child,      0);
+	rb_define_method(c_BinaryOp,    "lhs",        sollyarb_binaryop_get_lhs,       0);
+	rb_define_method(c_BinaryOp,    "rhs",        sollyarb_binaryop_get_rhs,       0);
+	rb_define_method(c_SolFunction, "nth_child",  sollyarb_function_get_nth_child, 1);
+	rb_define_method(c_SolFunction, "children",   sollyarb_function_get_children,  0);
+
+	rb_define_method(c_SolList,   "end_elliptic?", sollyarb_list_is_end_elliptic, 0);
+	rb_define_method(c_SolList,   "append",        sollyarb_list_append,          1);
+	rb_define_method(c_SolList,   "prepend",       sollyarb_list_prepend,         1);
+
+	rb_define_method(c_SolRange,  "lower_bound",  sollyarb_range_lower_bound, 0);
+	rb_define_method(c_SolRange,  "upper_bound",  sollyarb_range_upper_bound, 0);
+	rb_define_method(c_SolRange,  "inf",          sollyarb_range_inf,         0);
+	rb_define_method(c_SolRange,  "sup",          sollyarb_range_sup,         0);
+	rb_define_method(c_SolRange,  "mid",          sollyarb_range_mid,         0);
+
+	rb_define_method(c_Constant,  "to_mpfr",      sollyarb_constant_to_mpfr,  0);
+	rb_define_method(c_Constant,  "to_f",         sollyarb_constant_to_f,     0);
+
+	rb_define_method(rb_cFloat,     "to_sollya", sollyarb_float_to_sollya,    0);
+	rb_define_method(rb_cInteger,   "to_sollya", sollyarb_integer_to_sollya,  0);
+	rb_define_method(rb_cRational,  "to_sollya", sollyarb_rational_to_sollya, 0);
+	rb_define_method(c_MPFR,        "to_sollya", sollyarb_MPFR_to_sollya,     0);
+	rb_define_method(rb_cString,    "to_sollya", sollyarb_string_to_sollya,   0);
+	rb_define_method(rb_cTrueClass, "to_sollya", sollyarb_true_to_sollya,     0);
+	rb_define_method(rb_cFalseClass,"to_sollya", sollyarb_false_to_sollya,    0);
+	rb_define_method(rb_cRange,     "to_sollya", sollyarb_range_to_sollya,    0);
+	rb_define_method(rb_cSymbol,    "to_sollya", sollyarb_symbol_to_sollya,   0);
+	rb_define_method(rb_cArray,     "to_sollya", sollyarb_array_to_sollya,    0);
+
+
+	sollya_lib_init();
+//	sollya_lib_install_msg_callback(sollyarb_msg_callback, NULL);
+
+	sollyarb_cst_ON                 = sollyarb_ref2rb(sollya_lib_on(),                 c_SolSpecial);
+	sollyarb_cst_OFF                = sollyarb_ref2rb(sollya_lib_off(),                c_SolSpecial);
+	sollyarb_cst_DYADIC             = sollyarb_ref2rb(sollya_lib_dyadic(),             c_SolSpecial);
+	sollyarb_cst_POWERS             = sollyarb_ref2rb(sollya_lib_powers(),             c_SolSpecial);
+	sollyarb_cst_BINARY             = sollyarb_ref2rb(sollya_lib_binary(),             c_SolSpecial);
+	sollyarb_cst_HEXADECIMAL        = sollyarb_ref2rb(sollya_lib_hexadecimal(),        c_SolSpecial);
+	sollyarb_cst_FILE               = sollyarb_ref2rb(sollya_lib_file(),               c_SolSpecial);
+	sollyarb_cst_POSTSCRIPT         = sollyarb_ref2rb(sollya_lib_postscript(),         c_SolSpecial);
+	sollyarb_cst_POSTSCRIPTFILE     = sollyarb_ref2rb(sollya_lib_postscriptfile(),     c_SolSpecial);
+	sollyarb_cst_PERTURB            = sollyarb_ref2rb(sollya_lib_perturb(),            c_SolSpecial);
+	sollyarb_cst_ROUND_DOWN         = sollyarb_ref2rb(sollya_lib_round_down(),         c_SolSpecial);
+	sollyarb_cst_ROUND_UP           = sollyarb_ref2rb(sollya_lib_round_up(),           c_SolSpecial);
+	sollyarb_cst_ROUND_TOWARDS_ZERO = sollyarb_ref2rb(sollya_lib_round_towards_zero(), c_SolSpecial);
+	sollyarb_cst_ROUND_TO_NEAREST   = sollyarb_ref2rb(sollya_lib_round_to_nearest(),   c_SolSpecial);
+	sollyarb_cst_HONORCOEFFPREC     = sollyarb_ref2rb(sollya_lib_honorcoeffprec(),     c_SolSpecial);
+	sollyarb_cst_TRUE               = sollyarb_ref2rb(sollya_lib_true(),               c_SolSpecial);
+	sollyarb_cst_FALSE              = sollyarb_ref2rb(sollya_lib_false(),              c_SolSpecial);
+	sollyarb_cst_VOID               = sollyarb_ref2rb(sollya_lib_void(),               c_SolSpecial);
+	sollyarb_cst_DEFAULT            = sollyarb_ref2rb(sollya_lib_default(),            c_SolSpecial);
+	sollyarb_cst_DECIMAL            = sollyarb_ref2rb(sollya_lib_decimal(),            c_SolSpecial);
+	sollyarb_cst_ABSOLUTE           = sollyarb_ref2rb(sollya_lib_absolute(),           c_SolSpecial);
+	sollyarb_cst_RELATIVE           = sollyarb_ref2rb(sollya_lib_relative(),           c_SolSpecial);
+	sollyarb_cst_FIXED              = sollyarb_ref2rb(sollya_lib_fixed(),              c_SolSpecial);
+	sollyarb_cst_FLOATING           = sollyarb_ref2rb(sollya_lib_floating(),           c_SolSpecial);
+	sollyarb_cst_ERROR              = sollyarb_ref2rb(sollya_lib_error(),              c_SolSpecial);
+	sollyarb_cst_DOUBLE             = sollyarb_ref2rb(sollya_lib_double_obj(),         c_SolSpecial);
+	sollyarb_cst_SINGLE             = sollyarb_ref2rb(sollya_lib_single_obj(),         c_SolSpecial);
+	sollyarb_cst_QUAD               = sollyarb_ref2rb(sollya_lib_quad_obj(),           c_SolSpecial);
+	sollyarb_cst_HALFPRECISION      = sollyarb_ref2rb(sollya_lib_halfprecision_obj(),  c_SolSpecial);
+	sollyarb_cst_DOUBLEEXTENDED     = sollyarb_ref2rb(sollya_lib_doubleextended_obj(), c_SolSpecial);
+	sollyarb_cst_DOUBLE_DOUBLE      = sollyarb_ref2rb(sollya_lib_double_double_obj(),  c_SolSpecial);
+	sollyarb_cst_TRIPLE_DOUBLE      = sollyarb_ref2rb(sollya_lib_triple_double_obj(),  c_SolSpecial);
+	sollyarb_cst_PI                 = sollyarb_ref2rb(sollya_lib_pi(),                 c_Constant);
+
+	rb_define_const(m_Sollya, "ON",                 sollyarb_cst_ON);
+	rb_define_const(m_Sollya, "OFF",                sollyarb_cst_OFF);
+	rb_define_const(m_Sollya, "DYADIC",             sollyarb_cst_DYADIC);
+	rb_define_const(m_Sollya, "POWERS",             sollyarb_cst_POWERS);
+	rb_define_const(m_Sollya, "BINARY",             sollyarb_cst_BINARY);
+	rb_define_const(m_Sollya, "HEXADECIMAL",        sollyarb_cst_HEXADECIMAL);
+	rb_define_const(m_Sollya, "FILE",               sollyarb_cst_FILE);
+	rb_define_const(m_Sollya, "POSTSCRIPT",         sollyarb_cst_POSTSCRIPT);
+	rb_define_const(m_Sollya, "POSTSCRIPTFILE",     sollyarb_cst_POSTSCRIPTFILE);
+	rb_define_const(m_Sollya, "PERTURB",            sollyarb_cst_PERTURB);
+	rb_define_const(m_Sollya, "ROUND_DOWN",         sollyarb_cst_ROUND_DOWN);
+	rb_define_const(m_Sollya, "ROUND_UP",           sollyarb_cst_ROUND_UP);
+	rb_define_const(m_Sollya, "ROUND_TOWARDS_ZERO", sollyarb_cst_ROUND_TOWARDS_ZERO);
+	rb_define_const(m_Sollya, "ROUND_TO_NEAREST",   sollyarb_cst_ROUND_TO_NEAREST);
+	rb_define_const(m_Sollya, "HONORCOEFFPREC",     sollyarb_cst_HONORCOEFFPREC);
+	rb_define_const(m_Sollya, "TRUE",               sollyarb_cst_TRUE);
+	rb_define_const(m_Sollya, "FALSE",              sollyarb_cst_FALSE);
+	rb_define_const(m_Sollya, "VOID",               sollyarb_cst_VOID);
+	rb_define_const(m_Sollya, "DEFAULT",            sollyarb_cst_DEFAULT);
+	rb_define_const(m_Sollya, "DECIMAL",            sollyarb_cst_DECIMAL);
+	rb_define_const(m_Sollya, "ABSOLUTE",           sollyarb_cst_ABSOLUTE);
+	rb_define_const(m_Sollya, "RELATIVE",           sollyarb_cst_RELATIVE);
+	rb_define_const(m_Sollya, "FIXED",              sollyarb_cst_FIXED);
+	rb_define_const(m_Sollya, "FLOATING",           sollyarb_cst_FLOATING);
+	rb_define_const(m_Sollya, "ERROR",              sollyarb_cst_ERROR);
+	rb_define_const(m_Sollya, "DOUBLE",             sollyarb_cst_DOUBLE);
+	rb_define_const(m_Sollya, "SINGLE",             sollyarb_cst_SINGLE);
+	rb_define_const(m_Sollya, "QUAD",               sollyarb_cst_QUAD);
+	rb_define_const(m_Sollya, "HALFPRECISION",      sollyarb_cst_HALFPRECISION);
+	rb_define_const(m_Sollya, "DOUBLEEXTENDED",     sollyarb_cst_DOUBLEEXTENDED);
+	rb_define_const(m_Sollya, "DOUBLE_DOUBLE",      sollyarb_cst_DOUBLE_DOUBLE);
+	rb_define_const(m_Sollya, "TRIPLE_DOUBLE",      sollyarb_cst_TRIPLE_DOUBLE);
+	rb_define_const(m_Sollya, "PI",                 sollyarb_cst_PI);
+}
+
+// sollya_lib_close();
+