numo-gsl 0.1.0

data/ext/numo/gsl/stats/tmpl/stats_spearman.c

@@ -0,0 +1,46 @@
+static void
+iter_<%=c_func%>(na_loop_t *const lp)
+{
+    size_t   n;
+    char    *p1, *p2, *p3;
+    ssize_t  s1, s2;
+    double  *opt = (double*)(lp->opt_ptr);
+
+    INIT_COUNTER(lp, n);
+    INIT_PTR(lp, 0, p1, s1);
+    INIT_PTR(lp, 1, p2, s2);
+    p3 = lp->args[2].ptr + lp->args[2].iter[0].pos;
+
+    *(double*)p3 = <%=func_name%>((double*)p1,s1/sizeof(double),
+                                 (double*)p2,s2/sizeof(double),n,opt);
+}
+
+/*
+  <%=desc%>
+  @overload <%=name%>(<%=method_args%>, axis:nil, keepdims:false)
+  <% desc_param.each do |x|%>
+  <%=x%><% end %>
+  @param [Numeric,Array,Range] axis (keyword) Axes along which the operation is performed.
+  @param [TrueClass] keepdims (keyword) If true, the reduced axes are left in th*/
+static VALUE
+<%=c_func%>(int argc, VALUE *argv, VALUE mod)
+{
+    VALUE reduce, v, buf = 0;
+    narray_t *na;
+    double *opt;
+    ndfunc_arg_in_t ain[3] = {{cDF,0},{cDF,0},{sym_reduce,0}};
+    ndfunc_arg_out_t aout[1] = {{cDF,0}};
+    ndfunc_t ndf = { iter_<%=c_func%>, STRIDE_LOOP_NIP|NDF_FLAT_REDUCE|NDF_EXTRACT,
+                     3, 1, ain, aout };
+
+    if (argc<2) {
+        rb_raise(rb_eArgError,"wrong number of argument (%d for >=2)",argc);
+    }
+
+    GetNArray(argv[0],na);
+    opt = ALLOCV_N(double,buf,na->size*2); // todo: get loop size
+    reduce = nary_reduce_dimension(argc-2, argv+2, 2, argv, &ndf, 0);
+    v = na_ndloop3(&ndf, opt, 3, argv[0], argv[1], reduce);
+    ALLOCV_END(buf);
+    return v;
+}

data/ext/numo/gsl/sys/const_def.rb

@@ -0,0 +1,21 @@
+[["GSL_MODE_DEFAULT", nil],
+ ["GSL_PREC_APPROX", nil],
+ ["GSL_PREC_DOUBLE", nil],
+ ["GSL_PREC_SINGLE", nil],
+ ["M_1_PI", "The reciprocal of pi, 1/\\pi "],
+ ["M_2_PI", "Twice the reciprocal of pi, 2/\\pi "],
+ ["M_2_SQRTPI", "Two divided by the square root of pi, 2/\\sqrt\\pi "],
+ ["M_E", "The base of exponentials, e "],
+ ["M_EULER", "Euler's constant, \\gamma "],
+ ["M_LN10", "The natural logarithm of ten, \\ln(10) "],
+ ["M_LN2", "The natural logarithm of two, \\ln(2) "],
+ ["M_LNPI", "The natural logarithm of pi, \\ln(\\pi) "],
+ ["M_LOG10E", "The base-10 logarithm of e, $\\log_{10}(e)$ \\log_10 (e) "],
+ ["M_LOG2E", "The base-2 logarithm of e, \\log_2 (e) "],
+ ["M_PI", "The constant pi, \\pi "],
+ ["M_PI_2", "Pi divided by two, \\pi/2 "],
+ ["M_PI_4", "Pi divided by four, \\pi/4 "],
+ ["M_SQRT1_2", "The square root of one-half, $\\sqrt{1/2}$ \\sqrt@{1/2@} "],
+ ["M_SQRT2", "The square root of two, \\sqrt 2 "],
+ ["M_SQRT3", "The square root of three, \\sqrt 3 "],
+ ["M_SQRTPI", "The square root of pi, \\sqrt\\pi "]]

data/ext/numo/gsl/sys/depend

@@ -0,0 +1,17 @@
+COGEN=ruby erbpp_sys.rb
+GENSRC=gsl_sys.c
+GENDEPS=erbpp_sys.rb *_def.rb ../gen/*.rb ../gen/tmpl/*.c
+
+src : $(GENSRC)
+
+$(GENSRC) : $(GENDEPS)
+	$(COGEN) > $@
+
+doc : $(GENSRC)
+	yard doc $(GENSRC)
+
+clean: cleansrc cleandoc
+cleansrc:
+	-$(Q)$(RM) $(GENSRC)
+cleandoc:
+	-$(Q)$(RM_RF) doc .yardoc

data/ext/numo/gsl/sys/enum_def.rb

@@ -0,0 +1,75 @@
+[["GSL_EIGEN_SORT_VAL_ASC", 0, ""],
+ ["GSL_EIGEN_SORT_VAL_DESC", 1, ""],
+ ["GSL_EIGEN_SORT_ABS_ASC", 2, ""],
+ ["GSL_EIGEN_SORT_ABS_DESC", 3, ""],
+ ["GSL_SUCCESS", 0, ""],
+ ["GSL_FAILURE", -1, ""],
+ ["GSL_CONTINUE", -2, "iteration has not converged"],
+ ["GSL_EDOM", 1, "input domain error, e.g sqrt(-1)"],
+ ["GSL_ERANGE", 2, "output range error, e.g. exp(1e100)"],
+ ["GSL_EFAULT", 3, "invalid pointer"],
+ ["GSL_EINVAL", 4, "invalid argument supplied by user"],
+ ["GSL_EFAILED", 5, "generic failure"],
+ ["GSL_EFACTOR", 6, "factorization failed"],
+ ["GSL_ESANITY", 7, "sanity check failed - shouldn't happen"],
+ ["GSL_ENOMEM", 8, "malloc failed"],
+ ["GSL_EBADFUNC", 9, "problem with user-supplied function"],
+ ["GSL_ERUNAWAY", 10, "iterative process is out of control"],
+ ["GSL_EMAXITER", 11, "exceeded max number of iterations"],
+ ["GSL_EZERODIV", 12, "tried to divide by zero"],
+ ["GSL_EBADTOL", 13, "user specified an invalid tolerance"],
+ ["GSL_ETOL", 14, "failed to reach the specified tolerance"],
+ ["GSL_EUNDRFLW", 15, "underflow"],
+ ["GSL_EOVRFLW", 16, "overflow"],
+ ["GSL_ELOSS", 17, "loss of accuracy"],
+ ["GSL_EROUND", 18, "failed because of roundoff error"],
+ ["GSL_EBADLEN", 19, "matrix, vector lengths are not conformant"],
+ ["GSL_ENOTSQR", 20, "matrix not square"],
+ ["GSL_ESING", 21, "apparent singularity detected"],
+ ["GSL_EDIVERGE", 22, "integral or series is divergent"],
+ ["GSL_EUNSUP", 23, "requested feature is not supported by the hardware"],
+ ["GSL_EUNIMPL", 24, "requested feature not (yet) implemented"],
+ ["GSL_ECACHE", 25, "cache limit exceeded"],
+ ["GSL_ETABLE", 26, "table limit exceeded"],
+ ["GSL_ENOPROG", 27, "iteration is not making progress towards solution"],
+ ["GSL_ENOPROGJ", 28, "jacobian evaluations are not improving the solution"],
+ ["GSL_ETOLF", 29, "cannot reach the specified tolerance in F"],
+ ["GSL_ETOLX", 30, "cannot reach the specified tolerance in X"],
+ ["GSL_ETOLG", 31, "cannot reach the specified tolerance in gradient"],
+ ["GSL_EOF", 32, "end of file"],
+ ["GSL_MESSAGE_MASK_A", 1, ""],
+ ["GSL_MESSAGE_MASK_B", 2, ""],
+ ["GSL_MESSAGE_MASK_C", 4, ""],
+ ["GSL_MESSAGE_MASK_D", 8, ""],
+ ["GSL_MESSAGE_MASK_E", 16, ""],
+ ["GSL_MESSAGE_MASK_F", 32, ""],
+ ["GSL_MESSAGE_MASK_G", 64, ""],
+ ["GSL_MESSAGE_MASK_H", 128, ""],
+ ["GSL_IEEE_TYPE_NAN", 1, ""],
+ ["GSL_IEEE_TYPE_INF", 2, ""],
+ ["GSL_IEEE_TYPE_NORMAL", 3, ""],
+ ["GSL_IEEE_TYPE_DENORMAL", 4, ""],
+ ["GSL_IEEE_TYPE_ZERO", 5, ""],
+ ["GSL_IEEE_SINGLE_PRECISION", 1, ""],
+ ["GSL_IEEE_DOUBLE_PRECISION", 2, ""],
+ ["GSL_IEEE_EXTENDED_PRECISION", 3, ""],
+ ["GSL_IEEE_ROUND_TO_NEAREST", 1, ""],
+ ["GSL_IEEE_ROUND_DOWN", 2, ""],
+ ["GSL_IEEE_ROUND_UP", 3, ""],
+ ["GSL_IEEE_ROUND_TO_ZERO", 4, ""],
+ ["GSL_IEEE_MASK_INVALID", 1, ""],
+ ["GSL_IEEE_MASK_DENORMALIZED", 2, ""],
+ ["GSL_IEEE_MASK_DIVISION_BY_ZERO", 4, ""],
+ ["GSL_IEEE_MASK_OVERFLOW", 8, ""],
+ ["GSL_IEEE_MASK_UNDERFLOW", 16, ""],
+ ["GSL_IEEE_MASK_ALL", 31, ""],
+ ["GSL_IEEE_TRAP_INEXACT", 32, ""],
+ ["GSL_INTEG_GAUSS15", 1, "15 point Gauss-Kronrod rule"],
+ ["GSL_INTEG_GAUSS21", 2, "21 point Gauss-Kronrod rule"],
+ ["GSL_INTEG_GAUSS31", 3, "31 point Gauss-Kronrod rule"],
+ ["GSL_INTEG_GAUSS41", 4, "41 point Gauss-Kronrod rule"],
+ ["GSL_INTEG_GAUSS51", 5, "51 point Gauss-Kronrod rule"],
+ ["GSL_INTEG_GAUSS61", 6, "61 point Gauss-Kronrod rule"],
+ ["GSL_VEGAS_MODE_IMPORTANCE", 1, ""],
+ ["GSL_VEGAS_MODE_IMPORTANCE_ONLY", 0, ""],
+ ["GSL_VEGAS_MODE_STRATIFIED", -1, ""]]

data/ext/numo/gsl/sys/erbpp_sys.rb

@@ -0,0 +1,60 @@
+require_relative "../gen/erbpp_gsl"
+require "erbpp/line_number"
+
+func_list  = ErbppGsl.read_func
+const_list = ErbppGsl.read_const
+enum_list  = ErbppGsl.read_enum
+
+class DefSys < DefGslModule
+  def lookup(h)
+    case h
+    when FM(dbl, type:int);             "m_Int_f_DFloat"
+    when FM(*[dbl]*3, type:int);        "m_Int_f_DFloat_x3" # gsl_fcmp
+    when FM(dbl, type:dbl);             "m_DFloat_f_DFloat"
+    when FM(*[dbl]*2, type:dbl);        "m_DFloat_f_DFloat_x2"
+    when FM(*[dbl]*3, type:dbl);        "m_DFloat_f_DFloat_x3"
+    when FM(int, type:dbl);             "m_DFloat_f_Int"
+    when FM(dbl,int, type:dbl);         "m_DFloat_f_DFloat_Int"
+    when FM(dbl,uint, type:dbl);        "m_DFloat_f_DFloat_UInt"
+    when FM(dbl,intp, type:dbl);        "m_DFloat_Int_f_DFloat"  # gsl_frexp
+    end
+  end
+
+  def to_method_name(s)
+    s.sub(/^gsl_/,"")
+  end
+end
+
+DefLib.new do
+  set erb_dir: %w[tmpl ../gen/tmpl]
+  set erb_suffix: ".c"
+
+  set file_name: "gsl_sys.c"
+  set include_files: %w[gsl/gsl_sys.h gsl/gsl_pow_int.h gsl/gsl_math.h gsl/gsl_mode.h]
+  set lib_name: "sys"
+  set ns_var: "mGSL"
+
+  DefSys.new(self) do
+    set name: "sys"
+    set module_name: "GSL"
+    set module_var: "mGSL"
+    set full_module_name: "Numo::GSL"
+
+    func_list.each do |h|
+      check_func(h)
+    end
+
+    const_list.each do |a|
+      m = a[0].sub(/^GSL_/,"")
+      v = "DBL2NUM(#{a[0]})"
+      def_const(m, v, desc:a[1]||"")
+    end
+
+    enum_list.each do |a|
+      m = a[0].sub(/^GSL_/,"")
+      v = "INT2FIX(#{a[1]})"
+      def_const(m, v, desc:a[2]||"")
+    end
+  end
+
+end.run

data/ext/numo/gsl/sys/extconf.rb

@@ -0,0 +1,9 @@
+require_relative '../extconf_gsl.rb'
+
+# source file to compile
+srcs = %w(
+ gsl_sys
+)
+$objs = srcs.collect{|i| i+".o"}
+
+create_makefile('numo/gsl/sys')

data/ext/numo/gsl/sys/func_def.rb

@@ -0,0 +1,249 @@
+[{:func_name=>"gsl_isnan",
+  :func_type=>"int",
+  :args=>[["const double", "x"]],
+  :desc=>"This function returns 1 if x is not-a-number."},
+ {:func_name=>"gsl_isinf",
+  :func_type=>"int",
+  :args=>[["const double", "x"]],
+  :desc=>
+   "This function returns +1 if x is positive infinity,\n" +
+   "-1 if x is negative infinity and 0\n" +
+   "otherwise.Note that the C99 standard only requires the\n" +
+   "system isinf function to return a non-zero value, without the\n" +
+   "sign of the infinity.  The implementation in some earlier versions of\n" +
+   "GSL used the system isinf function and may have this behavior\n" +
+   "on some platforms.  Therefore, it is advisable to test the sign of\n" +
+   "x separately, if needed, rather than relying the sign of the\n" +
+   "return value from gsl_isinf()."},
+ {:func_name=>"gsl_finite",
+  :func_type=>"int",
+  :args=>[["const double", "x"]],
+  :desc=>
+   "This function returns 1 if x is a real number, and 0 if it is\n" +
+   "infinite or not-a-number."},
+ {:func_name=>"gsl_log1p",
+  :func_type=>"double",
+  :args=>[["const double", "x"]],
+  :desc=>
+   "This function computes the value of \\log(1+x) in a way that is\n" +
+   "accurate for small x. It provides an alternative to the BSD math\n" +
+   "function log1p(x)."},
+ {:func_name=>"gsl_expm1",
+  :func_type=>"double",
+  :args=>[["const double", "x"]],
+  :desc=>
+   "This function computes the value of \\exp(x)-1 in a way that is\n" +
+   "accurate for small x. It provides an alternative to the BSD math\n" +
+   "function expm1(x)."},
+ {:func_name=>"gsl_hypot",
+  :func_type=>"double",
+  :args=>[["const double", "x"], ["const double", "y"]],
+  :desc=>
+   "This function computes the value of\n" +
+   "$\\sqrt{x^2 + y^2}$\n" +
+   "\\sqrt@{x^2 + y^2@} in a way that avoids overflow. It provides an\n" +
+   "alternative to the BSD math function hypot(x,y)."},
+ {:func_name=>"gsl_hypot3",
+  :func_type=>"double",
+  :args=>[["const double", "x"], ["const double", "y"], ["const double", "z"]],
+  :desc=>
+   "This function computes the value of\n" +
+   "$\\sqrt{x^2 + y^2 + z^2}$\n" +
+   "\\sqrt@{x^2 + y^2 + z^2@} in a way that avoids overflow."},
+ {:func_name=>"gsl_acosh",
+  :func_type=>"double",
+  :args=>[["const double", "x"]],
+  :desc=>
+   "This function computes the value of \\arccosh(x). It provides an\n" +
+   "alternative to the standard math function acosh(x)."},
+ {:func_name=>"gsl_asinh",
+  :func_type=>"double",
+  :args=>[["const double", "x"]],
+  :desc=>
+   "This function computes the value of \\arcsinh(x). It provides an\n" +
+   "alternative to the standard math function asinh(x)."},
+ {:func_name=>"gsl_atanh",
+  :func_type=>"double",
+  :args=>[["const double", "x"]],
+  :desc=>
+   "This function computes the value of \\arctanh(x). It provides an\n" +
+   "alternative to the standard math function atanh(x)."},
+ {:func_name=>"gsl_ldexp",
+  :func_type=>"double",
+  :args=>[["double", "x"], ["int", "e"]],
+  :desc=>
+   "This function computes the value of x * 2^e. It provides an\n" +
+   "alternative to the standard math function ldexp(x,e)."},
+ {:func_name=>"gsl_frexp",
+  :func_type=>"double",
+  :args=>[["double", "x"], ["int *", "e"]],
+  :desc=>
+   "This function splits the number x into its normalized fraction\n" +
+   "f and exponent e, such that x = f * 2^e and\n" +
+   "$0.5 \\le f < 1$\n" +
+   "0.5 <= f < 1. The function returns f and stores the\n" +
+   "exponent in e. If x is zero, both f and e\n" +
+   "are set to zero. This function provides an alternative to the standard\n" +
+   "math function frexp(x, e)."},
+ {:func_name=>"gsl_pow_int",
+  :func_type=>"double",
+  :args=>[["double", "x"], ["int", "n"]],
+  :desc=>
+   "These routines computes the power x^n for integer n.  The\n" +
+   "power is computed efficiently---for example, x^8 is computed as\n" +
+   "((x^2)^2)^2, requiring only 3 multiplications.  A version of this\n" +
+   "function which also computes the numerical error in the result is\n" +
+   "available as gsl_sf_pow_int_e."},
+ {:func_name=>"gsl_pow_uint",
+  :func_type=>"double",
+  :args=>[["double", "x"], ["unsigned int", "n"]],
+  :desc=>
+   "These routines computes the power x^n for integer n.  The\n" +
+   "power is computed efficiently---for example, x^8 is computed as\n" +
+   "((x^2)^2)^2, requiring only 3 multiplications.  A version of this\n" +
+   "function which also computes the numerical error in the result is\n" +
+   "available as gsl_sf_pow_int_e."},
+ {:func_name=>"gsl_pow_2",
+  :func_type=>"double",
+  :args=>[["const double", "x"]],
+  :desc=>
+   "These functions can be used to compute small integer powers x^2,\n" +
+   "x^3, etc. efficiently. The functions will be inlined when \n" +
+   "HAVE_INLINE is defined, so that use of these functions \n" +
+   "should be as efficient as explicitly writing the corresponding \n" +
+   "product expression."},
+ {:func_name=>"gsl_pow_3",
+  :func_type=>"double",
+  :args=>[["const double", "x"]],
+  :desc=>
+   "These functions can be used to compute small integer powers x^2,\n" +
+   "x^3, etc. efficiently. The functions will be inlined when \n" +
+   "HAVE_INLINE is defined, so that use of these functions \n" +
+   "should be as efficient as explicitly writing the corresponding \n" +
+   "product expression."},
+ {:func_name=>"gsl_pow_4",
+  :func_type=>"double",
+  :args=>[["const double", "x"]],
+  :desc=>
+   "These functions can be used to compute small integer powers x^2,\n" +
+   "x^3, etc. efficiently. The functions will be inlined when \n" +
+   "HAVE_INLINE is defined, so that use of these functions \n" +
+   "should be as efficient as explicitly writing the corresponding \n" +
+   "product expression."},
+ {:func_name=>"gsl_pow_5",
+  :func_type=>"double",
+  :args=>[["const double", "x"]],
+  :desc=>
+   "These functions can be used to compute small integer powers x^2,\n" +
+   "x^3, etc. efficiently. The functions will be inlined when \n" +
+   "HAVE_INLINE is defined, so that use of these functions \n" +
+   "should be as efficient as explicitly writing the corresponding \n" +
+   "product expression."},
+ {:func_name=>"gsl_pow_6",
+  :func_type=>"double",
+  :args=>[["const double", "x"]],
+  :desc=>
+   "These functions can be used to compute small integer powers x^2,\n" +
+   "x^3, etc. efficiently. The functions will be inlined when \n" +
+   "HAVE_INLINE is defined, so that use of these functions \n" +
+   "should be as efficient as explicitly writing the corresponding \n" +
+   "product expression."},
+ {:func_name=>"gsl_pow_7",
+  :func_type=>"double",
+  :args=>[["const double", "x"]],
+  :desc=>
+   "These functions can be used to compute small integer powers x^2,\n" +
+   "x^3, etc. efficiently. The functions will be inlined when \n" +
+   "HAVE_INLINE is defined, so that use of these functions \n" +
+   "should be as efficient as explicitly writing the corresponding \n" +
+   "product expression."},
+ {:func_name=>"gsl_pow_8",
+  :func_type=>"double",
+  :args=>[["const double", "x"]],
+  :desc=>
+   "These functions can be used to compute small integer powers x^2,\n" +
+   "x^3, etc. efficiently. The functions will be inlined when \n" +
+   "HAVE_INLINE is defined, so that use of these functions \n" +
+   "should be as efficient as explicitly writing the corresponding \n" +
+   "product expression."},
+ {:func_name=>"gsl_pow_9",
+  :func_type=>"double",
+  :args=>[["const double", "x"]],
+  :desc=>
+   "These functions can be used to compute small integer powers x^2,\n" +
+   "x^3, etc. efficiently. The functions will be inlined when \n" +
+   "HAVE_INLINE is defined, so that use of these functions \n" +
+   "should be as efficient as explicitly writing the corresponding \n" +
+   "product expression."},
+ {:func_name=>"GSL_MAX_DBL",
+  :func_type=>"extern inline double",
+  :args=>[["double", "a"], ["double", "b"]],
+  :desc=>
+   "This function returns the maximum of the double precision numbers\n" +
+   "a and b using an inline function. The use of a function\n" +
+   "allows for type checking of the arguments as an extra safety feature. On\n" +
+   "platforms where inline functions are not available the macro\n" +
+   "GSL_MAX will be automatically substituted."},
+ {:func_name=>"GSL_MIN_DBL",
+  :func_type=>"extern inline double",
+  :args=>[["double", "a"], ["double", "b"]],
+  :desc=>
+   "This function returns the minimum of the double precision numbers\n" +
+   "a and b using an inline function. The use of a function\n" +
+   "allows for type checking of the arguments as an extra safety feature. On\n" +
+   "platforms where inline functions are not available the macro\n" +
+   "GSL_MIN will be automatically substituted."},
+ {:func_name=>"GSL_MAX_INT",
+  :func_type=>"extern inline int",
+  :args=>[["int", "a"], ["int", "b"]],
+  :desc=>
+   "These functions return the maximum or minimum of the integers a\n" +
+   "and b using an inline function.  On platforms where inline\n" +
+   "functions are not available the macros GSL_MAX or GSL_MIN\n" +
+   "will be automatically substituted."},
+ {:func_name=>"GSL_MIN_INT",
+  :func_type=>"extern inline int",
+  :args=>[["int", "a"], ["int", "b"]],
+  :desc=>
+   "These functions return the maximum or minimum of the integers a\n" +
+   "and b using an inline function.  On platforms where inline\n" +
+   "functions are not available the macros GSL_MAX or GSL_MIN\n" +
+   "will be automatically substituted."},
+ {:func_name=>"GSL_MAX_LDBL",
+  :func_type=>"extern inline long double",
+  :args=>[["long double", "a"], ["long double", "b"]],
+  :desc=>
+   "These functions return the maximum or minimum of the long doubles a\n" +
+   "and b using an inline function.  On platforms where inline\n" +
+   "functions are not available the macros GSL_MAX or GSL_MIN\n" +
+   "will be automatically substituted."},
+ {:func_name=>"GSL_MIN_LDBL",
+  :func_type=>"extern inline long double",
+  :args=>[["long double", "a"], ["long double", "b"]],
+  :desc=>
+   "These functions return the maximum or minimum of the long doubles a\n" +
+   "and b using an inline function.  On platforms where inline\n" +
+   "functions are not available the macros GSL_MAX or GSL_MIN\n" +
+   "will be automatically substituted."},
+ {:func_name=>"gsl_fcmp",
+  :func_type=>"int",
+  :args=>[["double", "x"], ["double", "y"], ["double", "epsilon"]],
+  :desc=>
+   "This function determines whether x and y are approximately\n" +
+   "equal to a relative accuracy epsilon.\n" +
+   "\n" +
+   "The relative accuracy is measured using an interval of size 2\n" +
+   "\\delta, where \\delta = 2^k \\epsilon and k is the\n" +
+   "maximum base-2 exponent of x and y as computed by the\n" +
+   "function frexp.  \n" +
+   "\n" +
+   "If x and y lie within this interval, they are considered\n" +
+   "approximately equal and the function returns 0. Otherwise if x <\n" +
+   "y, the function returns -1, or if x > y, the function returns\n" +
+   "+1.\n" +
+   "\n" +
+   "Note that x and y are compared to relative accuracy, so\n" +
+   "this function is not suitable for testing whether a value is\n" +
+   "approximately zero. \n" +
+   "\n" +
+   "The implementation is based on the package fcmp by T.C. Belding."}]