p1788 0.1.0

data/ext/p1788/p1788.cc

@@ -0,0 +1,3764 @@
+/*
+ *                              P1788
+ *
+ *   A Ruby extension wrapping the C++ libieeep1788 interval arithmetic library.
+ *
+ *   Copyright 2022
+ *
+ *   Théotime Bollengier (theotime.bollengier@ensta-bretagne.fr)
+ *   ENSTA Bretagne, France
+ *
+ *   Licensed under the Apache License, Version 2.0 (the "License");
+ *   you may not use this file except in compliance with the License.
+ *   You may obtain a copy of the License at
+ *
+ *       http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *   Unless required by applicable law or agreed to in writing, software
+ *   distributed under the License is distributed on an "AS IS" BASIS,
+ *   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *   See the License for the specific language governing permissions and
+ *   limitations under the License.
+ */
+ 
+/* 𝑠𝑒𝑙𝑓 √⪽  𝒔𝒆𝒍𝒇 ∅ℝ₊₋±∞𝐱𝐲𝐳 𝑎𝑏𝑐𝑥𝑦𝑧⋅𝒂𝒃𝒄𝒙𝒚𝒛|≠∀∃⨆⋀⋁⋂⋃∧∨∩∪≤≥⊔⊂⊃⊄⊅⊆⊇⊈⊉∈∈∉∋∌∑↑↓↕⎧⎨⎩⎪⎫⎬⎭⎮ */
+/* TODO:
+ * function index with groups
+ * README
+ */
+
+#include <ruby.h>
+#include <limits>
+#include <p1788/p1788.hpp>
+
+
+/* Document-module: P1788
+ *
+ * The {P1788} module defines forward and reverse functions to work on intervals.
+ *
+ * Set operations
+ * --------------
+ *
+ * {intersection} {convex_hull}
+ *
+ * Forward-mode and reverse-mode elementary functions
+ * --------------------------------------------------
+ *
+ * ### Basic operations
+ *
+ * {neg} {add} {sub} {mul} {div} {recip} {sqr} {sqrt} {fma}
+ *
+ * ### Power functions
+ *
+ * {pown} {pow} {exp} {exp2} {exp10} {log} {log2} {log10}
+ *
+ * ### Trigonometric functions
+ *
+ * {sin} {cos} {tan} {asin} {acos} {atan} {atan2}
+ *
+ * ### Hyperbolic functions
+ *
+ * {sinh} {cosh} {tanh} {asinh} {acosh} {atanh}
+ *
+ * ### Integer functions
+ *
+ * {sign} {ceil} {floor} {floorceil} {trunc} {round_ties_to_even} {round_ties_to_away}
+ *
+ * ### Absmax functions
+ *
+ * {abs} {min} {max}
+ *
+ *
+ * Reverse-mode elementary functions
+ * ---------------------------------
+ *
+ * ### Reverse basic operations
+ *
+ * {neg_rev} {add_rev} {sub_rev} {mul_rev} {mul_rev_to_pair} {div_rev} {recip_rev} {sqr_rev} {sqrt_rev}
+ *
+ * ### Reverse power functions
+ *
+ * {pown_rev} {pow_rev1} {pow_rev2} {exp_rev} {exp2_rev} {exp10_rev} {log_rev} {log2_rev} {log10_rev}
+ *
+ * ### Reverse trigonometric functions
+ *
+ * {sin_rev} {cos_rev} {tan_rev} {asin_rev} {acos_rev} {atan_rev}
+ *
+ * ### Reverse yperbolic functions
+ *
+ * {sinh_rev} {cosh_rev} {tanh_rev} {asinh_rev} {acosh_rev} {atanh_rev}
+ *
+ * ### Reverse abs function
+ *
+ * {abs_rev}
+ *
+ *
+ * Two-output division
+ * -------------------
+ *
+ * {div_to_pair}
+ *
+ *
+ * Cancellative addition and subtraction
+ * ------------------------------------
+ *
+ * {cancel_plus} {cancel_minus}
+ */
+
+
+/* Document-class: P1788::Interval
+ *
+ * The set of mathematical intervals implemented by the {Interval} class is denoted 𝕀ℝ.
+ * It comprises those subsets [𝒙] of the real line ℝ that are closed and connected in the topological sense:
+ * that is, the empty set (∅) together with all the nonempty intervals,
+ * denoted [<span style="text-decoration:underline">𝒙</span>, <span style="text-decoration:overline">𝒙</span>], 
+ * defined by
+ *
+ * [<span style="text-decoration:underline">𝒙</span>, <span style="text-decoration:overline">𝒙</span>] = { 𝑥 ∈ ℝ \| <span style="text-decoration:underline">𝒙</span> ≤ 𝑥 ≤ <span style="text-decoration:overline">𝒙</span> },
+ *
+ * where <span style="text-decoration:underline">𝒙</span> = inf([𝒙]) ∈ ℝ ∪ \\{-∞\} and
+ * <span style="text-decoration:overline">𝒙</span> = sup([𝒙]) ∈ ℝ ∪ \\{+∞} are extended-real numbers satisfying
+ * <span style="text-decoration:underline">𝒙</span> ≤ <span style="text-decoration:overline">𝒙</span>,
+ * <span style="text-decoration:underline">𝒙</span> < +∞ and <span style="text-decoration:overline">𝒙</span> > -∞.
+ *
+ * Set operation methods
+ * ---------------------
+ * 
+ * {&}
+ * {Interval#|}
+ * {bisect}
+ * 
+ * Boolean methods
+ * ---------------
+ *
+ * {empty?} {entire?} {all_reals?} {pos_reals?} {neg_reals?} {positive?} {strictly_positive?} {negative?}
+ * {strictly_negative?} {common?} {finite?} {symmetric?} {singleton?} {eql?} {==} {less?} {greater?}
+ * {strictly_less?} {strictly_greater?} {precedes?} {succeeds?} {strictly_precedes?} {strictly_succeeds?}
+ * {disjoint_from?} {intersect?} {strict_subset_of?} {subset_of?} {strictly_contain?} {contain?} {include?}
+ *
+ * Numeric methods
+ * ---------------
+ *
+ * {inf} {sup} {midpoint} {splitpoint} {radius} {mid_rad} {width} {magnitude} {mignitude}
+ * 
+ * Forward elementary function methods
+ * -----------------------------------
+ *
+ * {+@} {-@} {+} {-} {*} {/} {**} {pow} {pown} {recip} {abs}
+ * {sqr} {sqrt} {exp} {exp2} {exp10} {log} {log2} {log10}
+ * {sin} {cos} {tan} {asin} {acos} {atan} {sinh} {cosh} {tanh} {asinh} {acosh} {atanh}
+ * {sign} {ceil} {floor} {floorceil} {truncate} {round_ties_to_even} {round_ties_to_away}
+ * {min} {max} {div_to_pair} {cancel_plus} {cancel_minus} {fma}
+ *
+ * Reverse elementary functions methods
+ * ------------------------------------
+ *
+ * {mul_rev_to_pair} {mul_rev} {sqr_rev} {abs_rev} {pown_rev} {pow_rev1} {pow_rev2}
+ * {sin_rev} {cos_rev} {tan_rev} {cosh_rev}
+ *
+ * Ruby object methods
+ * -------------------
+ *
+ * {inspect} {coerce} {===} {to_s} {to_a} {to_latex} {dup} {clone}
+ */
+
+typedef union {
+	double   d;
+	uint64_t u;
+} double_int_t;
+
+using InfSupDouble = p1788::infsup::interval<double, p1788::flavor::infsup::setbased::mpfr_bin_ieee754_flavor>;
+
+static const double INF = std::numeric_limits<double>::infinity();
+static const double MAXF = std::numeric_limits<double>::max();
+
+static const double_int_t pi_inf  = {.u = 0x400921fb54442d18ULL};
+static const double_int_t pi_sup  = {.u = 0x400921fb54442d19ULL};
+static const double_int_t e_inf   = {.u = 0x4005bf0a8b145769ULL};
+static const double_int_t e_sup   = {.u = 0x4005bf0a8b14576aULL};
+static const double_int_t hpi_inf = {.u = 0x3ff921fb54442d18ULL};
+static const double_int_t hpi_sup = {.u = 0x3ff921fb54442d19ULL};
+static const double_int_t pi2_inf = {.u = 0x401921fb54442d18ULL};
+static const double_int_t pi2_sup = {.u = 0x401921fb54442d19ULL};
+
+
+
+
+static const InfSupDouble all_reals_set(-INF, INF);
+static const InfSupDouble pos_reals_set( 0.0, INF);
+static const InfSupDouble neg_reals_set(-INF, 0.0);
+static const InfSupDouble pi_set(pi_inf.d, pi_sup.d);
+static const InfSupDouble hpi_set(hpi_inf.d, hpi_sup.d);
+static const InfSupDouble pi2_set(pi2_inf.d, pi2_sup.d);
+static const InfSupDouble e_set(e_inf.d, e_sup.d);
+static const InfSupDouble minus_one_one_set(-1.0, 1.0);
+static const InfSupDouble minus_pi_pi_set(-pi_sup.d, pi_sup.d);
+static const InfSupDouble minus_hpi_hpi_set(-hpi_sup.d, hpi_sup.d);
+static const InfSupDouble zero_pi_set(0.0, pi_sup.d);
+
+static VALUE m_P1788;
+static VALUE c_Interval;
+
+static ID id_to_s;
+
+
+
+static void p1788_interval_free(void *p)
+{
+	InfSupDouble *i = (InfSupDouble*)p;
+	delete i;
+}
+
+
+static size_t p1788_interval_size(const void* p)
+{
+	return sizeof(InfSupDouble);
+}
+
+
+static const rb_data_type_t p1788_interval_type = {
+	.wrap_struct_name = "P1788::Interval",
+	.function = {
+		.dmark = NULL,
+		.dfree = p1788_interval_free,
+		.dsize = p1788_interval_size,
+	},
+	.parent = NULL,
+	.data = NULL,
+	.flags = RUBY_TYPED_FREE_IMMEDIATELY
+};
+
+
+static VALUE p1788_interval_alloc(VALUE klass)
+{
+	InfSupDouble *inter = new InfSupDouble(-INF, INF);
+	return TypedData_Wrap_Struct(klass, &p1788_interval_type, inter);
+}
+
+
+// static inline VALUE p1788_interval_new(const InfSupDouble& isd) {
+// 	InfSupDouble *inter = new InfSupDouble(isd);
+// 	return TypedData_Wrap_Struct(c_Interval, &p1788_interval_type, inter);
+// }
+
+
+#define P1788_NEW_RB_INTERVAL(new_rb_obj, ...)                                       \
+	do {                                                                                    \
+		InfSupDouble *isdp_ = new InfSupDouble(__VA_ARGS__);                                \
+ 	 	new_rb_obj = TypedData_Wrap_Struct(c_Interval, &p1788_interval_type, isdp_); \
+	} while (0)
+
+
+static inline InfSupDouble& p1788_interval_rb2ref(VALUE obj) {
+	InfSupDouble *i;
+	TypedData_Get_Struct(obj, InfSupDouble, &p1788_interval_type, i);
+	return *i;
+}
+
+
+static InfSupDouble p1788_rbobj2infsupdouble(VALUE obj)
+{
+	InfSupDouble inter;
+	double lower, upper;
+	VALUE beg, end;
+	int i, arlen;
+
+	if (rb_class_of(obj) == c_Interval)
+		inter = p1788_interval_rb2ref(obj);
+	else if (rb_obj_is_kind_of(obj, rb_cNumeric)) {
+		lower = NUM2DBL(obj);
+		inter = InfSupDouble(lower, lower);
+	}
+	else if (rb_obj_is_kind_of(obj, rb_cRange)) {
+		rb_range_values(obj, &beg, &end, &i);
+		lower = NUM2DBL(beg);
+		upper = NUM2DBL(end);
+		inter = InfSupDouble(lower, upper);
+	}
+	else if (rb_obj_is_kind_of(obj, rb_cArray)) {
+		arlen = rb_array_len(obj);
+		if (arlen == 0)
+			inter = InfSupDouble();
+		else if (arlen == 1) {
+			lower = NUM2DBL(rb_ary_entry(obj, 0));
+			inter = InfSupDouble(lower, lower);
+		}
+		else if (arlen == 2) {
+			lower = NUM2DBL(rb_ary_entry(obj, 0));
+			upper = NUM2DBL(rb_ary_entry(obj, 1));
+			inter = InfSupDouble(lower, upper);
+		}
+		else
+			rb_raise(rb_eArgError, "the array must have 0 to 2 elements, not %d", arlen);
+	}
+	else
+		rb_raise(rb_eTypeError, "Cannot convert a %" PRIsVALUE " to a %" PRIsVALUE,
+				rb_class_name(rb_class_of(obj)), rb_class_name(c_Interval));
+
+	return inter;
+}
+
+
+/* Create a new {Interval}
+ * @return [Interval]
+ * @overload new()
+ *  return a new interval [-∞, +∞]
+ * @overload new(lower, upper)
+ *  @param lower [Float] lower bound
+ *  @param upper [Float] upper bound
+ * @overload new(range_or_array)
+ *  @param range_or_array [Range<Float>, Array<Float>] a range of Floats or a two elements array of Floats
+ * @overload new(str)
+ *  @param str [String] something like '[0.1, 1/10]' or "[0.1]" or "[1/10]"
+ * @overload new(other_interval)
+ *  @param other_interval [Interval]
+ * @see []
+ */
+static VALUE p1788_interval_initialize(int argc, VALUE *argv, VALUE self)
+{
+	InfSupDouble &inter = p1788_interval_rb2ref(self);
+	double lower, upper;
+	VALUE beg, end;
+	int i, arlen;
+
+	switch (argc) {
+		case 0:
+			break;
+		case 1:
+			if (rb_obj_is_kind_of(argv[0], rb_cNumeric)) {
+				lower = NUM2DBL(argv[0]);
+				inter = InfSupDouble(lower, lower);
+			}
+			else if (rb_obj_is_kind_of(argv[0], rb_cString)) {
+				inter = InfSupDouble(std::string(StringValueCStr(argv[0])));
+			}
+			else if (rb_obj_is_kind_of(argv[0], rb_cRange)) {
+				rb_range_values(argv[0], &beg, &end, &i);
+				lower = NUM2DBL(beg);
+				upper = NUM2DBL(end);
+				inter = InfSupDouble(lower, upper);
+			}
+			else if (rb_obj_is_kind_of(argv[0], rb_cArray)) {
+				arlen = rb_array_len(argv[0]);
+				if (arlen == 0)
+					inter = InfSupDouble();
+				else if (arlen == 1) {
+					lower = NUM2DBL(rb_ary_entry(argv[0], 0));
+					inter = InfSupDouble(lower, lower);
+				}
+				else if (arlen == 2) {
+					lower = NUM2DBL(rb_ary_entry(argv[0], 0));
+					upper = NUM2DBL(rb_ary_entry(argv[0], 1));
+					inter = InfSupDouble(lower, upper);
+				}
+				else
+					rb_raise(rb_eArgError, "the array must have 0 to 2 elements, not %d", arlen);
+			}
+			else if (rb_obj_is_kind_of(argv[0], c_Interval)) {
+				inter = InfSupDouble(p1788_interval_rb2ref(argv[0]));
+			}
+			else
+				rb_raise(rb_eArgError, "expecting Numeric, String, Range, Array or Interval, not %" PRIsVALUE, rb_class_name(rb_class_of(argv[0])));
+			break;
+		case 2:
+			if (rb_obj_is_kind_of(argv[0], rb_cNumeric) && rb_obj_is_kind_of(argv[1], rb_cNumeric)) {
+				lower = NUM2DBL(argv[0]);
+				upper = NUM2DBL(argv[1]);
+				inter = InfSupDouble(lower, upper);
+			}
+			else
+				rb_raise(rb_eArgError, "expecting two Numerics, or a [Numeric, Range or Array]");
+			break;
+		default:
+			rb_raise(rb_eArgError, "expecting 0 to 2 arguments, not %d", argc);
+	}
+
+	return self;
+}
+
+
+/* Create a new {Interval}
+ * @example
+ *  P1788::Interval[]              #=> #<P1788::Interval ℝ>
+ *  P1788::Interval[0.7]           #=> #<P1788::Interval {0.7}>
+ *  P1788::Interval[1, 2.3]        #=> #<P1788::Interval [1, 2.3]>
+ *  P1788::Interval[-3.4 .. 5.6]   #=> #<P1788::Interval [-3.4, 5.6]>
+ *  a = [7, 8]                     
+ *  P1788::Interval[a]             #=> #<P1788::Interval [7, 8]>
+ *  P1788::Interval['[-4.9]']      #=> #<P1788::Interval [-4.9, -4.8999999999999995]>
+ *  P1788::Interval['[1/10, Inf]'] #=> #<P1788::Interval [0.09999999999999999, +∞]>
+ *  P1788::Interval[0, Float::INFINITY] #=> #<P1788::Interval ℝ₊>
+ *  P1788::Interval[Float::NAN]    #=> #<P1788::Interval ∅>
+ *
+ * @overload []()
+ *  return a new interval [-∞, +∞]
+ * @overload [](lower, upper)
+ *  @param lower [Float] lower bound
+ *  @param upper [Float] upper bound
+ * @overload [](range_or_array)
+ *  @param range_or_array [Range<Float>, Array<Float>] a range of Floats or a two elements array of Floats
+ * @overload [](str)
+ *  @param str [String] something like '[0.1, 1/10]' or "[0.1]" or "[1/10]"
+ */
+static VALUE p1788_interval_rb_new(int argc, VALUE *argv, VALUE self)
+{
+	return rb_class_new_instance(argc, argv, c_Interval);
+}
+
+
+/* Return a new {Interval} equal to `self`.
+ * @return [Interval]
+ */
+static VALUE p1788_interval_dup(VALUE self)
+{
+	return rb_class_new_instance(1, &self, c_Interval);
+}
+
+
+/* Return a new {Interval} equal to `self`, also copying its singleton class.
+ * @return [Interval]
+ */
+static VALUE p1788_interval_clone(VALUE self)
+{
+	VALUE c = rb_call_super(0, NULL);
+	p1788_interval_rb2ref(c) = p1788_interval_rb2ref(self);
+	return c;
+}
+
+
+/* Returns a two element arrays containing the bounds of `self`.
+ * @return [Array<Float>]
+ */
+static VALUE p1788_interval_to_a(VALUE self)
+{
+	InfSupDouble &inter = p1788_interval_rb2ref(self);
+	if (InfSupDouble::is_empty(inter))
+		return rb_ary_new_capa(0);
+	VALUE r = rb_ary_new_capa(2);
+	rb_ary_store(r, 0, DBL2NUM(InfSupDouble::inf(inter)));
+	rb_ary_store(r, 1, DBL2NUM(InfSupDouble::sup(inter)));
+	return r;
+}
+
+
+/* Returns a unicode string representation of _self_.
+ * @return [String]
+ */
+static VALUE p1788_interval_to_s(VALUE self)
+{
+	double lb, ub;
+	VALUE lbc, ubc;
+	InfSupDouble &inter = p1788_interval_rb2ref(self);
+
+	if (InfSupDouble::is_empty(inter))
+		return rb_utf8_str_new_cstr("∅");
+	if (InfSupDouble::is_entire(inter))
+		return rb_utf8_str_new_cstr("ℝ");
+
+	lb = InfSupDouble::inf(inter);
+	ub = InfSupDouble::sup(inter);
+
+	if ((lb == 0.0) && (ub == INF))
+		return rb_utf8_str_new_cstr("ℝ₊");
+	if ((lb == -INF) && (ub == 0.0))
+		return rb_utf8_str_new_cstr("ℝ₋");
+
+	if (lb == -INF)
+		lbc = rb_utf8_str_new_cstr("-∞");
+	else if (lb == INF)
+		lbc = rb_utf8_str_new_cstr("+∞");
+	else if ((double)((int)(lb)) == lb)
+		lbc = rb_funcallv(INT2NUM((int)lb), id_to_s, 0, NULL);
+	else
+		lbc = rb_funcallv(DBL2NUM(lb), id_to_s, 0, NULL);
+
+	if (InfSupDouble::is_singleton(inter))
+		return rb_sprintf("{%" PRIsVALUE "}", lbc);
+
+	if (ub == -INF)
+		ubc = rb_utf8_str_new_cstr("-∞");
+	else if (ub == INF)
+		ubc = rb_utf8_str_new_cstr("+∞");
+	else if ((double)((int)(ub)) == ub)
+		ubc = rb_funcallv(INT2NUM((int)ub), id_to_s, 0, NULL);
+	else
+		ubc = rb_funcallv(DBL2NUM(ub), id_to_s, 0, NULL);
+
+	return rb_sprintf("[%" PRIsVALUE ", %" PRIsVALUE "]", lbc, ubc);
+}
+
+
+/* @return [String]
+ */
+static VALUE p1788_interval_inspect(VALUE self)
+{
+	InfSupDouble &i = p1788_interval_rb2ref(self);
+	return rb_sprintf("#<%" PRIsVALUE " %" PRIsVALUE ">",
+			rb_class_name(c_Interval),
+			p1788_interval_to_s(self));
+}
+
+
+static VALUE p1788_interval_to_tex(VALUE self)
+{
+	double lb, ub;
+	VALUE lbc, ubc;
+	InfSupDouble &inter = p1788_interval_rb2ref(self);
+
+	if (InfSupDouble::is_empty(inter))
+		return rb_utf8_str_new_cstr("\\emptyset");
+	if (InfSupDouble::is_entire(inter))
+		return rb_utf8_str_new_cstr("\\mathbb{R}");
+
+	lb = InfSupDouble::inf(inter);
+	ub = InfSupDouble::sup(inter);
+
+	if ((lb == 0.0) && (ub == INF))
+		return rb_utf8_str_new_cstr("\\mathbb{R}_+");
+	if ((lb == -INF) && (ub == 0.0))
+		return rb_utf8_str_new_cstr("\\mathbb{R}_-");
+
+	if (lb == -INF)
+		lbc = rb_utf8_str_new_cstr("-\\infty");
+	else if (lb == INF)
+		lbc = rb_utf8_str_new_cstr("+\\infty");
+	else if ((double)((int)(lb)) == lb)
+		lbc = rb_funcallv(INT2NUM((int)lb), id_to_s, 0, NULL);
+	else
+		lbc = rb_funcallv(DBL2NUM(lb), id_to_s, 0, NULL);
+
+	if (InfSupDouble::is_singleton(inter))
+		return rb_sprintf("\\left\\{ %" PRIsVALUE " \\right\\}", lbc);
+
+	if (ub == -INF)
+		ubc = rb_utf8_str_new_cstr("-\\infty");
+	else if (ub == INF)
+		ubc = rb_utf8_str_new_cstr("+\\infty");
+	else if ((double)((int)(ub)) == ub)
+		ubc = rb_funcallv(INT2NUM((int)ub), id_to_s, 0, NULL);
+	else
+		ubc = rb_funcallv(DBL2NUM(ub), id_to_s, 0, NULL);
+
+	return rb_sprintf("\\left[ %" PRIsVALUE " , %" PRIsVALUE " \\right]", lbc, ubc);
+}
+
+
+/* Returns a LaTex representation as a string.
+ * @return [String]
+ * @overload to_latex(print_dollars = true)
+ *  @param print_dollars [Boolean] if true, will surround the string with `$$` signs.
+ */
+static VALUE p1788_interval_to_latex(int argc, VALUE *argv, VALUE self)
+{
+	VALUE arg;
+	if (rb_scan_args(argc, argv, "01", &arg) > 0) {
+		if (arg == Qnil || arg == Qfalse)
+			return p1788_interval_to_tex(self);
+	}
+	return rb_sprintf("$$ %" PRIsVALUE " $$", p1788_interval_to_tex(self));
+}
+
+
+/* @param other [Numeric]
+ * @return [Array<Interval>] [other.to_interval, self]
+ */
+static VALUE p1788_interval_coerce(VALUE self, VALUE other)
+{
+	VALUE rbo;
+	P1788_NEW_RB_INTERVAL(rbo, p1788_rbobj2infsupdouble(other));
+	return rb_ary_new_from_args(2, rbo, self);
+}
+
+
+/* Boolean functions on intervals */
+
+
+/* [𝒔𝒆𝒍𝒇] = ∅ ?
+ * @return [Boolean]
+ */
+static VALUE p1788_interval_empty(VALUE self)
+{
+	return InfSupDouble::is_empty(p1788_interval_rb2ref(self)) ? Qtrue : Qfalse;
+}
+
+
+/* [𝒔𝒆𝒍𝒇] = ℝ ?
+ * @return [Boolean]
+ */
+static VALUE p1788_interval_entire(VALUE self)
+{
+	return InfSupDouble::is_entire(p1788_interval_rb2ref(self)) ? Qtrue : Qfalse;
+}
+
+
+/* [𝒔𝒆𝒍𝒇] = ℝ₊ ?
+ * @return [Boolean]
+ */
+static VALUE p1788_interval_pos_reals(VALUE self)
+{
+	InfSupDouble &inter = p1788_interval_rb2ref(self);
+	return ((InfSupDouble::inf(inter) == 0.0) && (InfSupDouble::sup(inter) == INF)) ? Qtrue : Qfalse;
+}
+
+
+/* [𝒔𝒆𝒍𝒇] = ℝ₋ ?
+ * @return [Boolean]
+ */
+static VALUE p1788_interval_neg_reals(VALUE self)
+{
+	InfSupDouble &inter = p1788_interval_rb2ref(self);
+	return ((InfSupDouble::inf(inter) == -INF) && (InfSupDouble::sup(inter) == 0.0)) ? Qtrue : Qfalse;
+}
+
+
+/* [𝒔𝒆𝒍𝒇] ⊆ [0, +∞]
+ *
+ * _true_ if [𝒔𝒆𝒍𝒇] = ∅ ∨ <span style="text-decoration:underline">𝒔𝒆𝒍𝒇</span> ≥ 0<br/>
+ * _false_ otherwise
+ * @return [Boolean]
+ */
+static VALUE p1788_interval_positive(VALUE self)
+{
+	InfSupDouble &inter = p1788_interval_rb2ref(self);
+	return (InfSupDouble::is_empty(inter) || InfSupDouble::inf(inter) >= 0.0) ? Qtrue : Qfalse;
+}
+
+
+
+/* [𝒔𝒆𝒍𝒇] ⊂ [0, +∞]
+ *
+ * _true_ if [𝒔𝒆𝒍𝒇] = ∅ ∨ <span style="text-decoration:underline">𝒔𝒆𝒍𝒇</span> > 0<br/>
+ * _false_ otherwise
+ * @return [Boolean]
+ */
+static VALUE p1788_interval_strictly_positive(VALUE self)
+{
+	InfSupDouble &inter = p1788_interval_rb2ref(self);
+	return (InfSupDouble::is_empty(inter) || InfSupDouble::inf(inter) > 0.0) ? Qtrue : Qfalse;
+}
+
+
+/* [𝒔𝒆𝒍𝒇] ⊆ [-∞, 0]
+ *
+ * _true_ if [𝒔𝒆𝒍𝒇] = ∅ ∨ <span style="text-decoration:overline">𝒔𝒆𝒍𝒇</span> ≤ 0<br/>
+ * _false_ otherwise
+ * @return [Boolean]
+ */
+static VALUE p1788_interval_negative(VALUE self)
+{
+	InfSupDouble &inter = p1788_interval_rb2ref(self);
+	return (InfSupDouble::is_empty(inter) || InfSupDouble::sup(inter) <= 0.0) ? Qtrue : Qfalse;
+}
+
+
+
+/* [𝒔𝒆𝒍𝒇] ⊂ [-∞, 0]
+ *
+ * _true_ if [𝒔𝒆𝒍𝒇] = ∅ ∨ <span style="text-decoration:overline">𝒔𝒆𝒍𝒇</span> < 0<br/>
+ * _false_ otherwise
+ * @return [Boolean]
+ */
+static VALUE p1788_interval_strictly_negative(VALUE self)
+{
+	InfSupDouble &inter = p1788_interval_rb2ref(self);
+	return (InfSupDouble::is_empty(inter) || InfSupDouble::sup(inter) < 0.0) ? Qtrue : Qfalse;
+}
+
+
+
+/* _self_ is a bounded nonempty interval
+ * @return [Boolean]
+ */
+static VALUE p1788_interval_common(VALUE self)
+{
+	return InfSupDouble::is_common_interval(p1788_interval_rb2ref(self)) ? Qtrue : Qfalse;
+}
+
+
+/* _self_ is empty or a bounded interval
+ * @return [Boolean]
+ */
+static VALUE p1788_interval_finite(VALUE self)
+{
+	InfSupDouble &inter = p1788_interval_rb2ref(self);
+	return (InfSupDouble::is_empty(inter) || InfSupDouble::is_common_interval(inter)) ? Qtrue : Qfalse;
+}
+
+
+/* The lower bound of _self_ is the opposite of the upper bound.
+ * An empty interval is not symmetric.
+ * @return [Boolean]
+ */
+static VALUE p1788_interval_symmetric(VALUE self)
+{
+	InfSupDouble &inter = p1788_interval_rb2ref(self);
+	return (InfSupDouble::is_empty(inter) || InfSupDouble::inf(inter) != -InfSupDouble::sup(inter)) ? Qfalse : Qtrue;
+}
+
+
+/* Tels if _self_ contains only one value.
+ * @return [Boolean]
+ */
+static VALUE p1788_interval_singleton(VALUE self)
+{
+	return InfSupDouble::is_singleton(p1788_interval_rb2ref(self)) ? Qtrue : Qfalse;
+}
+
+
+/* _self_ {==} _y_ and _y_ is an {Interval}
+ * @return [Boolean]
+ */
+static VALUE p1788_interval_eql(VALUE self, VALUE y)
+{
+	if (!rb_obj_is_kind_of(y, c_Interval))
+		return Qfalse;
+	return InfSupDouble::equal(p1788_interval_rb2ref(self), p1788_interval_rb2ref(y)) ? Qtrue : Qfalse;
+}
+
+
+/* _self_ = _y_
+ *
+ * (∀ 𝑥 ∈ [𝒔𝒆𝒍𝒇], ∃ 𝑦 ∈ [𝒚], 𝑥 = 𝑦) ∧ (∀ 𝑦 ∈ [𝒚], ∃ 𝑥 ∈ [𝒔𝒆𝒍𝒇], 𝑦 = 𝑥)
+ *
+ * _true_ if ([𝒔𝒆𝒍𝒇] = ∅ ∧ [𝒚] = ∅) ∨ ([𝒔𝒆𝒍𝒇] ≠ ∅ ∧ [𝒚] ≠ ∅ ∧ <span style="text-decoration:underline">𝒔𝒆𝒍𝒇</span> = <span style="text-decoration:underline">𝒚</span> ∧ <span style="text-decoration:overline">𝒔𝒆𝒍𝒇</span> = <span style="text-decoration:overline">𝒚</span>)<br/>
+ * _false_ otherwise
+ * @return [Boolean]
+ */
+static VALUE p1788_interval_equal(VALUE self, VALUE y)
+{
+	InfSupDouble iother = p1788_rbobj2infsupdouble(y);
+	InfSupDouble &inter = p1788_interval_rb2ref(self);
+	return InfSupDouble::equal(inter, iother) ? Qtrue : Qfalse;
+}
+
+
+static VALUE p1788_casesubsumption_func(VALUE obj)
+{
+	VALUE r;
+	P1788_NEW_RB_INTERVAL(r, p1788_rbobj2infsupdouble(obj));
+	return r;
+}
+
+
+static VALUE p1788_casesubsumption_rescue(VALUE obj, VALUE except)
+{
+	return obj;
+}
+
+/* Case subsumption operator.
+ *
+ * Used to write `case` expressions with intervals.
+ *
+ * Returns _true_ if _obj_ can be converted to a {Interval} and _obj_ is contained in _self_, _false_ otherwise.
+ * @return [Boolean]
+ */
+static VALUE p1788_interval_tripleequal(VALUE self, VALUE obj)
+{
+	VALUE other = rb_rescue(p1788_casesubsumption_func, obj, p1788_casesubsumption_rescue, Qnil);
+	if (other == Qnil)
+		return Qfalse;
+	InfSupDouble &a = p1788_interval_rb2ref(self);
+	InfSupDouble &b = p1788_interval_rb2ref(other);
+	return InfSupDouble::subset(b, a) ? Qtrue : Qfalse;
+}
+
+
+/* _self_ is weakly less than _y_
+ *
+ * (∀ 𝑥 ∈ [𝒔𝒆𝒍𝒇], ∃ 𝑦 ∈ [𝒚], 𝑥 ≤ 𝑦) ∧ (∀ 𝑦 ∈ [𝒚], ∃ 𝑥 ∈ [𝒔𝒆𝒍𝒇], 𝑥 ≤ 𝑦) 
+ *
+ * _true_ if ([𝒔𝒆𝒍𝒇] = ∅ ∧ [𝒚] = ∅) ∨ ([𝒔𝒆𝒍𝒇] ≠ ∅ ∧ [𝒚] ≠ ∅ ∧ <span style="text-decoration:underline">𝒔𝒆𝒍𝒇</span> ≤ <span style="text-decoration:underline">𝒚</span> ∧ <span style="text-decoration:overline">𝒔𝒆𝒍𝒇</span> ≤ <span style="text-decoration:overline">𝒚</span>)<br/>
+ * _false_ otherwise
+ * @return [Boolean]
+ */
+static VALUE p1788_interval_less(VALUE self, VALUE y)
+{
+	InfSupDouble iother = p1788_rbobj2infsupdouble(y);
+	InfSupDouble &inter = p1788_interval_rb2ref(self);
+	return InfSupDouble::less(inter, iother) ? Qtrue : Qfalse;
+}
+
+
+/* _self_ is weakly greater than _y_
+ *
+ * (∀ 𝑥 ∈ [𝒔𝒆𝒍𝒇], ∃ 𝑦 ∈ [𝒚], 𝑥 ≥ 𝑦) ∧ (∀ 𝑦 ∈ [𝒚], ∃ 𝑥 ∈ [𝒔𝒆𝒍𝒇], 𝑥 ≥ 𝑦) 
+ *
+ * _true_ if ([𝒔𝒆𝒍𝒇] = ∅ ∧ [𝒚] = ∅) ∨ ([𝒔𝒆𝒍𝒇] ≠ ∅ ∧ [𝒚] ≠ ∅ ∧ <span style="text-decoration:underline">𝒔𝒆𝒍𝒇</span> ≥ <span style="text-decoration:underline">𝒚</span> ∧ <span style="text-decoration:overline">𝒔𝒆𝒍𝒇</span> ≥ <span style="text-decoration:overline">𝒚</span>)<br/>
+ * _false_ otherwise
+ * @return [Boolean]
+ */
+static VALUE p1788_interval_greater(VALUE self, VALUE y)
+{
+	InfSupDouble iother = p1788_rbobj2infsupdouble(y);
+	InfSupDouble &inter = p1788_interval_rb2ref(self);
+	return InfSupDouble::greater(inter, iother) ? Qtrue : Qfalse;
+}
+
+
+/* _self_ is strictly less than _y_
+ *
+ * (∀ 𝑥 ∈ [𝒔𝒆𝒍𝒇], ∃ 𝑦 ∈ [𝒚], 𝑥 < 𝑦) ∧ (∀ 𝑦 ∈ [𝒚], ∃ 𝑥 ∈ [𝒔𝒆𝒍𝒇], 𝑥 < 𝑦) 
+ *
+ * _true_ if ([𝒔𝒆𝒍𝒇] = ∅ ∧ [𝒚] = ∅) ∨ ([𝒔𝒆𝒍𝒇] ≠ ∅ ∧ [𝒚] ≠ ∅ ∧ <span style="text-decoration:underline">𝒔𝒆𝒍𝒇</span> < <span style="text-decoration:underline">𝒚</span> ∧ <span style="text-decoration:overline">𝒔𝒆𝒍𝒇</span> < <span style="text-decoration:overline">𝒚</span>)<br/>
+ * _false_ otherwise
+ * @return [Boolean]
+ */
+static VALUE p1788_interval_strictly_less(VALUE self, VALUE y)
+{
+	InfSupDouble iother = p1788_rbobj2infsupdouble(y);
+	InfSupDouble &inter = p1788_interval_rb2ref(self);
+	return InfSupDouble::strictly_less(inter, iother) ? Qtrue : Qfalse;
+}
+
+
+/* _self_ is strictly greater than _y_
+ *
+ * (∀ 𝑥 ∈ [𝒔𝒆𝒍𝒇], ∃ 𝑦 ∈ [𝒚], 𝑥 > 𝑦) ∧ (∀ 𝑦 ∈ [𝒚], ∃ 𝑥 ∈ [𝒔𝒆𝒍𝒇], 𝑥 > 𝑦) 
+ *
+ * _true_ if ([𝒔𝒆𝒍𝒇] = ∅ ∧ [𝒚] = ∅) ∨ ([𝒔𝒆𝒍𝒇] ≠ ∅ ∧ [𝒚] ≠ ∅ ∧ <span style="text-decoration:underline">𝒔𝒆𝒍𝒇</span> > <span style="text-decoration:underline">𝒚</span> ∧ <span style="text-decoration:overline">𝒔𝒆𝒍𝒇</span> > <span style="text-decoration:overline">𝒚</span>)<br/>
+ * _false_ otherwise
+ * @return [Boolean]
+ */
+static VALUE p1788_interval_strictly_greater(VALUE self, VALUE y)
+{
+	InfSupDouble iother = p1788_rbobj2infsupdouble(y);
+	InfSupDouble &inter = p1788_interval_rb2ref(self);
+	return InfSupDouble::strictly_greater(inter, iother) ? Qtrue : Qfalse;
+}
+
+
+/* _self_ is to the left of but may touch _y_
+ *
+ * ∀ 𝑥 ∈ [𝒔𝒆𝒍𝒇], ∀ 𝑦 ∈ [𝒚], 𝑥 ≤ 𝑦
+ *
+ * _true_ if [𝒔𝒆𝒍𝒇] = ∅ ∨ [𝒚] = ∅ ∨ <span style="text-decoration:overline">𝒔𝒆𝒍𝒇</span> ≤ <span style="text-decoration:underline">𝒚</span><br/>
+ * _false_ otherwise
+ * @return [Boolean]
+ */
+static VALUE p1788_interval_precedes(VALUE self, VALUE y)
+{
+	InfSupDouble iother = p1788_rbobj2infsupdouble(y);
+	InfSupDouble &inter = p1788_interval_rb2ref(self);
+	return InfSupDouble::precedes(inter, iother) ? Qtrue : Qfalse;
+}
+
+
+/* _self_ is to the right of but may touch _y_
+ *
+ * ∀ 𝑥 ∈ [𝒔𝒆𝒍𝒇], ∀ 𝑦 ∈ [𝒚], 𝑥 ≥ 𝑦
+ *
+ * _true_ if [𝒔𝒆𝒍𝒇] = ∅ ∨ [𝒚] = ∅ ∨ <span style="text-decoration:overline">𝒔𝒆𝒍𝒇</span> ≥ <span style="text-decoration:underline">𝒚</span><br/>
+ * _false_ otherwise
+ * @return [Boolean]
+ */
+static VALUE p1788_interval_succeeds(VALUE self, VALUE y)
+{
+	InfSupDouble iother = p1788_rbobj2infsupdouble(y);
+	InfSupDouble &inter = p1788_interval_rb2ref(self);
+	return InfSupDouble::succeeds(inter, iother) ? Qtrue : Qfalse;
+}
+
+
+/* _self_ is strictly to the left of  _y_
+ *
+ * ∀ 𝑥 ∈ [𝒔𝒆𝒍𝒇], ∀ 𝑦 ∈ [𝒚], 𝑥 < 𝑦
+ *
+ * _true_ if [𝒔𝒆𝒍𝒇] = ∅ ∨ [𝒚] = ∅ ∨ <span style="text-decoration:overline">𝒔𝒆𝒍𝒇</span> < <span style="text-decoration:underline">𝒚</span><br/>
+ * _false_ otherwise
+ * @return [Boolean]
+ */
+static VALUE p1788_interval_strictly_precedes(VALUE self, VALUE y)
+{
+	InfSupDouble iother = p1788_rbobj2infsupdouble(y);
+	InfSupDouble &inter = p1788_interval_rb2ref(self);
+	return InfSupDouble::strictly_precedes(inter, iother) ? Qtrue : Qfalse;
+}
+
+
+/* _self_ is strictly to the right of _y_
+ *
+ * ∀ 𝑥 ∈ [𝒔𝒆𝒍𝒇], ∀ 𝑦 ∈ [𝒚], 𝑥 > 𝑦
+ *
+ * _true_ if [𝒔𝒆𝒍𝒇] = ∅ ∨ [𝒚] = ∅ ∨ <span style="text-decoration:overline">𝒔𝒆𝒍𝒇</span> > <span style="text-decoration:underline">𝒚</span><br/>
+ * _false_ otherwise
+ * @return [Boolean]
+ */
+static VALUE p1788_interval_strictly_succeeds(VALUE self, VALUE y)
+{
+	InfSupDouble iother = p1788_rbobj2infsupdouble(y);
+	InfSupDouble &inter = p1788_interval_rb2ref(self);
+	return InfSupDouble::strictly_succeeds(inter, iother) ? Qtrue : Qfalse;
+}
+
+
+/* [𝒔𝒆𝒍𝒇] ∩ [𝒚] = ∅
+ *
+ * ∀ 𝑥 ∈ [𝒔𝒆𝒍𝒇], ∀ 𝑦 ∈ [𝒚], 𝑥 ≠ 𝑦
+ *
+ * _true_ if [𝒔𝒆𝒍𝒇] = ∅ ∨ [𝒚] = ∅ ∨ <span style="text-decoration:overline">𝒔𝒆𝒍𝒇</span> < <span style="text-decoration:underline">𝒚</span> ∨ <span style="text-decoration:overline">𝒚</span> < <span style="text-decoration:underline">𝒔𝒆𝒍𝒇</span><br/>
+ * _false_ otherwise
+ * @see intersect
+ * @return [Boolean]
+ */
+static VALUE p1788_interval_disjoint(VALUE self, VALUE y)
+{
+	InfSupDouble iother = p1788_rbobj2infsupdouble(y);
+	InfSupDouble &inter = p1788_interval_rb2ref(self);
+	return InfSupDouble::disjoint(inter, iother) ? Qtrue : Qfalse;
+}
+
+
+/* [𝒔𝒆𝒍𝒇] ∩ [𝒚] ≠ ∅
+ *
+ * ∃ 𝑥 ∈ [𝒔𝒆𝒍𝒇], ∃ 𝑦 ∈ [𝒚], 𝑥 = 𝑦
+ *
+ * _true_ if [𝒔𝒆𝒍𝒇] ≠ ∅ ∧ [𝒚] ≠ ∅ ∧ <span style="text-decoration:overline">𝒔𝒆𝒍𝒇</span> ≥ <span style="text-decoration:underline">𝒚</span> ∧ <span style="text-decoration:underline">𝒔𝒆𝒍𝒇</span> ≤ <span style="text-decoration:overline">𝒚</span><br/>
+ * _false_ otherwise
+ * @see disjoint_from
+ * @return [Boolean]
+ */
+static VALUE p1788_interval_intersect(VALUE self, VALUE y)
+{
+	InfSupDouble iother = p1788_rbobj2infsupdouble(y);
+	InfSupDouble &inter = p1788_interval_rb2ref(self);
+	if (InfSupDouble::is_empty(inter) || InfSupDouble::is_empty(iother))
+		return Qfalse;
+	double al = InfSupDouble::inf(inter);
+	double au = InfSupDouble::sup(inter);
+	double bl = InfSupDouble::inf(iother);
+	double bu = InfSupDouble::sup(iother);
+	return (au >= bl && al <= bu) ? Qtrue : Qfalse;
+}
+
+
+/* _self_ is interior to _y_
+ *
+ * [𝒔𝒆𝒍𝒇] ⊂ [𝒚]
+ *
+ * (∀ 𝑥 ∈ [𝒔𝒆𝒍𝒇], ∃ 𝑦 ∈ [𝒚] : 𝑥 > 𝑦) ∧ (∀ 𝑥 ∈ [𝒔𝒆𝒍𝒇], ∃ 𝑦 ∈ [𝒚] : 𝑥 < 𝑦 )
+ *
+ * _true_ if [𝒔𝒆𝒍𝒇] = ∅ ∨ ([𝒚] ≠ ∅ ∧ <span style="text-decoration:underline">𝒚</span> < <span style="text-decoration:underline">𝒔𝒆𝒍𝒇</span> ∧ <span style="text-decoration:overline">𝒔𝒆𝒍𝒇</span> < <span style="text-decoration:overline">𝒚</span>)<br/>
+ * _false_ otherwise
+ * @see subset_of?
+ * @see strictly_contain?
+ * @return [Boolean]
+ */
+static VALUE p1788_interval_strict_subset(VALUE self, VALUE y)
+{
+	InfSupDouble &inter = p1788_interval_rb2ref(self);
+	InfSupDouble iother = p1788_rbobj2infsupdouble(y);
+	return InfSupDouble::interior(inter, iother) ? Qtrue : Qfalse;
+}
+
+
+/* _y_ is interior to _self_
+ *
+ * [𝒚] ⊂ [𝒔𝒆𝒍𝒇]
+ *
+ * (∀ 𝑦 ∈ [𝒚], ∃ 𝑥 ∈ [𝒔𝒆𝒍𝒇] : 𝑦 < 𝑥) ∧ (∀ 𝑦 ∈ [𝒚], ∃ 𝑥 ∈ [𝒔𝒆𝒍𝒇] : 𝑦 > 𝑥)
+ *
+ * _true_ if [𝒚] = ∅ ∨ ([𝒔𝒆𝒍𝒇] ≠ ∅ ∧ <span style="text-decoration:underline">𝒔𝒆𝒍𝒇</span> < <span style="text-decoration:underline">𝒚</span> ∧ <span style="text-decoration:overline">𝒚</span> < <span style="text-decoration:overline">𝒔𝒆𝒍𝒇</span>)<br/>
+ * _false_ otherwise
+ * @see strict_subset_of?
+ * @see contain?
+ * @return [Boolean]
+ */
+static VALUE p1788_interval_strictly_contain(VALUE self, VALUE y)
+{
+	InfSupDouble &inter = p1788_interval_rb2ref(self);
+	InfSupDouble iother = p1788_rbobj2infsupdouble(y);
+	return InfSupDouble::interior(iother, inter) ? Qtrue : Qfalse;
+}
+
+
+/* _self_ is a subset or equal to _y_
+ *
+ * [𝒔𝒆𝒍𝒇] ⊆ [𝒚]
+ *
+ * ∀ 𝑥 ∈ [𝒔𝒆𝒍𝒇], ∃ 𝑦 ∈ [𝒚] : 𝑥 = 𝑦
+ *
+ * _true_ if [𝒔𝒆𝒍𝒇] = ∅ ∨ ([𝒚] ≠ ∅ ∧ <span style="text-decoration:underline">𝒚</span> ≤ <span style="text-decoration:underline">𝒔𝒆𝒍𝒇</span> ∧ <span style="text-decoration:overline">𝒔𝒆𝒍𝒇</span> ≤ <span style="text-decoration:overline">𝒚</span>)<br/>
+ * _false_ otherwise
+ * @see contain?
+ * @see strict_subset_of?
+ * @return [Boolean]
+ */
+static VALUE p1788_interval_subset(VALUE self, VALUE y)
+{
+	InfSupDouble &inter = p1788_interval_rb2ref(self);
+	InfSupDouble iother = p1788_rbobj2infsupdouble(y);
+	return InfSupDouble::subset(inter, iother) ? Qtrue : Qfalse;
+}
+
+
+/* _y_ is a subset or equal to _self_
+ *
+ * [𝒚] ⊆ [𝒔𝒆𝒍𝒇]
+ *
+ * ∀ 𝑦 ∈ [𝒚], ∃ 𝑥 ∈ [𝒔𝒆𝒍𝒇] : 𝑦 = 𝑥
+ *
+ * _true_ if [𝒚] = ∅ ∨ ([𝒔𝒆𝒍𝒇] ≠ ∅ ∧ <span style="text-decoration:underline">𝒔𝒆𝒍𝒇</span> ≤ <span style="text-decoration:underline">𝒚</span> ∧ <span style="text-decoration:overline">𝒚</span> ≤ <span style="text-decoration:overline">𝒔𝒆𝒍𝒇</span>)<br/>
+ * _false_ otherwise
+ * @see subset_of?
+ * @see strictly_contain?
+ * @return [Boolean]
+ */
+static VALUE p1788_interval_contain(VALUE self, VALUE y)
+{
+	InfSupDouble &inter = p1788_interval_rb2ref(self);
+	InfSupDouble iother = p1788_rbobj2infsupdouble(y);
+	return InfSupDouble::subset(iother, inter) ? Qtrue : Qfalse;
+}
+
+
+/* _y_ is a member of _self_
+ *
+ * 𝑦 ∈ [𝒔𝒆𝒍𝒇]
+ *
+ * _true_ if [𝒔𝒆𝒍𝒇] ≠ ∅ ∧ <span style="text-decoration:underline">𝒔𝒆𝒍𝒇</span> ≤ 𝑦 ∧ 𝑦 ≤ <span style="text-decoration:overline">𝒔𝒆𝒍𝒇</span> ∧ 𝑦 ≠ ±∞<br/>
+ * _false_ otherwise
+ * @param y [Numeric]
+ * @return [Boolean]
+ */
+static VALUE p1788_interval_include(VALUE self, VALUE y)
+{
+	InfSupDouble &inter = p1788_interval_rb2ref(self);
+	double od = NUM2DBL(y);
+	return InfSupDouble::is_member(od, inter) ? Qtrue : Qfalse;
+}
+
+/* Numeric functions on intervals */
+
+
+/* Lower bound of the interval.
+ * Returns _nil_ if the interval is empty.
+ * @return [Float, nil]
+ */
+static VALUE p1788_interval_inf(VALUE self)
+{
+	InfSupDouble &inter = p1788_interval_rb2ref(self);
+	if (InfSupDouble::is_empty(inter))
+		return Qnil;
+	return DBL2NUM(InfSupDouble::inf(inter));
+}
+
+
+/* Upper bound of the interval.
+ * Returns _nil_ if the interval is empty.
+ * @return [Float, nil]
+ */
+static VALUE p1788_interval_sup(VALUE self)
+{
+	InfSupDouble &inter = p1788_interval_rb2ref(self);
+	if (InfSupDouble::is_empty(inter))
+		return Qnil;
+	return DBL2NUM(InfSupDouble::sup(inter));
+}
+
+
+static double p1788_interval_splitpoint_double(const InfSupDouble& inter)
+{
+	if (InfSupDouble::is_empty(inter))
+		return std::numeric_limits<double>::quiet_NaN();
+	if (InfSupDouble::wid(inter) == INF) {
+		double lb = InfSupDouble::inf(inter);
+		double ub = InfSupDouble::sup(inter);
+		if (lb == -INF) {
+			if (ub == INF)
+				return 0.0;
+			return -MAXF;
+		}
+		return MAXF;
+	}
+	return InfSupDouble::mid(inter);
+}
+
+
+/* Split point used to bisect
+ *
+ * Split point is:<br/>
+ * (<span style="text-decoration:underline">𝒔𝒆𝒍𝒇</span> + <span style="text-decoration:overline">𝒔𝒆𝒍𝒇</span>)/2 if [𝒔𝒆𝒍𝒇] is nonempty and bounded,<br/>
+ * `0` if [𝒔𝒆𝒍𝒇] = ℝ,<br/>
+ * `-Float::MAX` if <span style="text-decoration:underline">𝒔𝒆𝒍𝒇</span> = -∞<br/>
+ * `Float::MAX` if <span style="text-decoration:overline">𝒔𝒆𝒍𝒇</span> = +∞<br/> 
+ * `nil` if [𝒔𝒆𝒍𝒇] = ∅
+ * @return [Float, nil]
+ */
+static VALUE p1788_interval_splitpoint(VALUE self)
+{
+	InfSupDouble &inter = p1788_interval_rb2ref(self);
+	double sp = p1788_interval_splitpoint_double(inter);
+	if (std::isnan(sp))
+		return Qnil;
+	return DBL2NUM(sp);
+}
+
+
+/* Midpoint of _self_
+ *
+ * Midpoint is (<span style="text-decoration:underline">𝒔𝒆𝒍𝒇</span> + <span style="text-decoration:overline">𝒔𝒆𝒍𝒇</span>)/2 if [𝒔𝒆𝒍𝒇] ≠ ∅ and [𝒔𝒆𝒍𝒇] is bounded, nil otherwise
+ * @return [Float, nil]
+ */
+static VALUE p1788_interval_mid(VALUE self)
+{
+	InfSupDouble &inter = p1788_interval_rb2ref(self);
+	if (InfSupDouble::is_empty(inter) || InfSupDouble::wid(inter) == INF)
+		return Qnil;
+	double mid = InfSupDouble::mid(inter);
+	if (std::isnan(mid))
+		return Qnil;
+	return DBL2NUM(mid);
+}
+
+
+/* Radius of _self_
+ *
+ * Radius is (<span style="text-decoration:overline">𝒔𝒆𝒍𝒇</span> - <span style="text-decoration:underline">𝒔𝒆𝒍𝒇</span>)/2 if [𝒔𝒆𝒍𝒇] ≠ ∅, nil if [𝒔𝒆𝒍𝒇] = ∅
+ * @return [Float, nil]
+ */
+static VALUE p1788_interval_rad(VALUE self)
+{
+	InfSupDouble &inter = p1788_interval_rb2ref(self);
+	if (InfSupDouble::is_empty(inter))
+		return Qnil;
+	return DBL2NUM(InfSupDouble::rad(inter));
+}
+
+
+/* Midpoint and radius
+ * @return [Array<Float,nil>] [{midpoint}, {radius}]
+ */
+static VALUE p1788_interval_mid_rad(VALUE self)
+{
+	std::pair< double, double > p = InfSupDouble::mid_rad(p1788_interval_rb2ref(self));
+	VALUE r1 = DBL2NUM(p.first);
+	VALUE r2 = DBL2NUM(p.second);
+	if (std::isnan(p.first))
+		r1 = Qnil;
+	if (std::isnan(p.second))
+		r2 = Qnil;
+	return rb_ary_new_from_args(2, r1, r2);
+}
+
+
+/* Width of _self_
+ *
+ * Width is <span style="text-decoration:overline">𝒔𝒆𝒍𝒇</span> - <span style="text-decoration:underline">𝒔𝒆𝒍𝒇</span> if [𝒔𝒆𝒍𝒇] ≠ ∅, nil if [𝒔𝒆𝒍𝒇] = ∅
+ *
+ * @return [Float, nil]
+ */
+static VALUE p1788_interval_wid(VALUE self)
+{
+	InfSupDouble &inter = p1788_interval_rb2ref(self);
+	if (InfSupDouble::is_empty(inter))
+		return Qnil;
+	return DBL2NUM(InfSupDouble::wid(inter));
+}
+
+
+/* Magnitude of _self_
+ *
+ * [𝒔𝒆𝒍𝒇].mignitude  =  sup{ \|𝑥\| ￨ 𝑥 ∈ [𝒔𝒆𝒍𝒇] } if [𝒔𝒆𝒍𝒇] ≠ ∅, nil if [𝒔𝒆𝒍𝒇] = ∅
+ * @return [Float, nil]
+ */
+static VALUE p1788_interval_mag(VALUE self)
+{
+	InfSupDouble &inter = p1788_interval_rb2ref(self);
+	if (InfSupDouble::is_empty(inter))
+		return Qnil;
+	return DBL2NUM(InfSupDouble::mag(inter));
+}
+
+
+/* Mignitude of _self_
+ *
+ * [𝒔𝒆𝒍𝒇].mignitude  =  inf{ \|𝑥\| ￨ 𝑥 ∈ [𝒔𝒆𝒍𝒇] } if [𝒔𝒆𝒍𝒇] ≠ ∅, nil if [𝒔𝒆𝒍𝒇] = ∅
+ * @return [Float, nil]
+ */
+static VALUE p1788_interval_mig(VALUE self)
+{
+	InfSupDouble &inter = p1788_interval_rb2ref(self);
+	if (InfSupDouble::is_empty(inter))
+		return Qnil;
+	return DBL2NUM(InfSupDouble::mig(inter));
+}
+
+
+/* Split _self_ into two intervals using {splitpoint}.
+ * @return [Array[Interval]] An Array of two intervals
+ */
+static VALUE p1788_interval_bisect(VALUE self)
+{
+	VALUE r1, r2;
+	InfSupDouble &inter = p1788_interval_rb2ref(self);
+	double midpoint = p1788_interval_splitpoint_double(inter);
+	if (std::isnan(midpoint)) {
+		P1788_NEW_RB_INTERVAL(r2, InfSupDouble());
+		return rb_ary_new_from_args(2, self, r2);
+	}
+	const double lb = InfSupDouble::inf(inter);
+	const double ub = InfSupDouble::sup(inter);
+	InfSupDouble i1(lb, midpoint);
+	InfSupDouble i2(midpoint, ub);
+	if (i1 == i2) {
+		P1788_NEW_RB_INTERVAL(r2, InfSupDouble());
+		return rb_ary_new_from_args(2, self, r2);
+	}
+	P1788_NEW_RB_INTERVAL(r1, i1);
+	P1788_NEW_RB_INTERVAL(r2, i2);
+	return rb_ary_new_from_args(2, r1, r2);
+}
+
+
+/* Set operations */
+
+
+/* Intersection
+ *
+ * [𝒔𝒆𝒍𝒇].intersection([𝒚])  =  [𝒔𝒆𝒍𝒇] ∩ [𝒚]
+ */
+static VALUE p1788_interval_intersection(VALUE self, VALUE y)
+{
+	InfSupDouble iother = p1788_rbobj2infsupdouble(y);
+	InfSupDouble &inter = p1788_interval_rb2ref(self);
+	VALUE r;
+	P1788_NEW_RB_INTERVAL(r, InfSupDouble::intersection(inter, iother));
+	return r;
+}
+
+
+/* Interval hull of the union of _self_ and _y_
+ *
+ * [𝒔𝒆𝒍𝒇].convex_hull([𝒚])  =  hull( [𝒔𝒆𝒍𝒇] ∪ [𝒚] )
+ */
+static VALUE p1788_interval_convex_hull(VALUE self, VALUE y)
+{
+	InfSupDouble iother = p1788_rbobj2infsupdouble(y);
+	InfSupDouble &inter = p1788_interval_rb2ref(self);
+	VALUE r;
+	P1788_NEW_RB_INTERVAL(r, InfSupDouble::convex_hull(inter, iother));
+	return r;
+}
+
+
+/* Forward elementary functions */
+
+
+/* @return [Interval] `self`
+ */
+static VALUE p1788_interval_pos(VALUE self)
+{
+	VALUE r;
+	P1788_NEW_RB_INTERVAL(r, InfSupDouble::pos(p1788_interval_rb2ref(self)));
+	return r;
+}
+
+
+/* Opposite
+ *
+ * [𝒔𝒆𝒍𝒇].neg  =  [-<span style="text-decoration:overline">𝒔𝒆𝒍𝒇</span>, -<span style="text-decoration:underline">𝒔𝒆𝒍𝒇</span>]
+ */
+static VALUE p1788_interval_neg(VALUE self)
+{
+	VALUE r;
+	P1788_NEW_RB_INTERVAL(r, InfSupDouble::neg(p1788_interval_rb2ref(self)));
+	return r;
+}
+
+
+/* Reciprocal
+ *
+ * [𝒔𝒆𝒍𝒇].recip  =  hull{ 1/𝑥 \| 𝑥 ∈ [𝒔𝒆𝒍𝒇] }  ⊆  ℝ
+ *
+ * Reverse function: {recip}
+ */
+static VALUE p1788_interval_recip(VALUE self)
+{
+	VALUE r;
+	P1788_NEW_RB_INTERVAL(r, InfSupDouble::recip(p1788_interval_rb2ref(self)));
+	return r;
+}
+
+
+/* Square
+ *
+ * [𝒔𝒆𝒍𝒇].sqr  =  hull{ 𝑥² \| 𝑥 ∈ [𝒔𝒆𝒍𝒇] }  ⊆  ℝ₊
+ *
+ * Reverse function: {sqr_rev}
+ */
+static VALUE p1788_interval_sqr(VALUE self)
+{
+	VALUE r;
+	P1788_NEW_RB_INTERVAL(r, InfSupDouble::sqr(p1788_interval_rb2ref(self)));
+	return r;
+}
+
+
+/* Square root
+ *
+ * [𝒔𝒆𝒍𝒇].sqrt  =  hull{ 𝑥<sup>½</sup> \| 𝑥 ∈ [𝒔𝒆𝒍𝒇]∩ℝ₊ }  ⊆  ℝ₊
+ *
+ * Reverse function: {sqr}
+ */
+static VALUE p1788_interval_sqrt(VALUE self)
+{
+	VALUE r;
+	P1788_NEW_RB_INTERVAL(r, InfSupDouble::sqrt(p1788_interval_rb2ref(self)));
+	return r;
+}
+
+
+/* _e_ raised to the power of _self_
+ *
+ * [𝒔𝒆𝒍𝒇].exp  =  hull{ 𝑒<sup>𝑥</sup> \| 𝑥 ∈ [𝒔𝒆𝒍𝒇] }  ⊆  ℝ₊
+ *
+ * Reverse function: {log}
+ */
+static VALUE p1788_interval_exp(VALUE self)
+{
+	VALUE r;
+	P1788_NEW_RB_INTERVAL(r, InfSupDouble::exp(p1788_interval_rb2ref(self)));
+	return r;
+}
+
+
+/* 2 raised to the power of _self_
+ *
+ * [𝒔𝒆𝒍𝒇].exp2  =  hull{ 2<sup>𝑥</sup> \| 𝑥 ∈ [𝒔𝒆𝒍𝒇] }  ⊆  ℝ₊
+ *
+ * Reverse function: {log2}
+ */
+static VALUE p1788_interval_exp2(VALUE self)
+{
+	VALUE r;
+	P1788_NEW_RB_INTERVAL(r, InfSupDouble::exp2(p1788_interval_rb2ref(self)));
+	return r;
+}
+
+
+/* 10 raised to the power of _self_
+ *
+ * [𝒔𝒆𝒍𝒇].exp10  =  hull{ 10<sup>𝑥</sup> \| 𝑥 ∈ [𝒔𝒆𝒍𝒇] }  ⊆  ℝ₊
+ *
+ * Reverse function: {log10}
+ */
+static VALUE p1788_interval_exp10(VALUE self)
+{
+	VALUE r;
+	P1788_NEW_RB_INTERVAL(r, InfSupDouble::exp10(p1788_interval_rb2ref(self)));
+	return r;
+}
+
+
+/* Natural logarithm
+ *
+ * [𝒔𝒆𝒍𝒇].log  =  hull{ ln(𝑥) \| 𝑥 ∈ [𝒔𝒆𝒍𝒇]∩ℝ₊ }  ⊆  ℝ
+ *
+ * Reverse function: {exp}
+ */
+static VALUE p1788_interval_log(VALUE self)
+{
+	VALUE r;
+	P1788_NEW_RB_INTERVAL(r, InfSupDouble::log(p1788_interval_rb2ref(self)));
+	return r;
+}
+
+
+/* Base 2 logarithm
+ *
+ * [𝒔𝒆𝒍𝒇].log2  =  hull{ ln(𝑥)/ln(2) \| 𝑥 ∈ [𝒔𝒆𝒍𝒇]∩ℝ₊ }  ⊆  ℝ
+ *
+ * Reverse function: {exp2}
+ */
+static VALUE p1788_interval_log2(VALUE self)
+{
+	VALUE r;
+	P1788_NEW_RB_INTERVAL(r, InfSupDouble::log2(p1788_interval_rb2ref(self)));
+	return r;
+}
+
+
+/* Base 10 logarithm
+ *
+ * [𝒔𝒆𝒍𝒇].log10  =  hull{ ln(𝑥)/ln(10) \| 𝑥 ∈ [𝒔𝒆𝒍𝒇]∩ℝ₊ }  ⊆  ℝ
+ *
+ * Reverse function: {exp10}
+ */
+static VALUE p1788_interval_log10(VALUE self)
+{
+	VALUE r;
+	P1788_NEW_RB_INTERVAL(r, InfSupDouble::log10(p1788_interval_rb2ref(self)));
+	return r;
+}
+
+
+/* Sine
+ *
+ * [𝒔𝒆𝒍𝒇].sin  =  hull{ sin(𝑥) \| 𝑥 ∈ [𝒔𝒆𝒍𝒇] }  ⊆  [-1, 1]
+ *
+ * Reverse function: {sin_rev}
+ */
+static VALUE p1788_interval_sin(VALUE self)
+{
+	VALUE r;
+	P1788_NEW_RB_INTERVAL(r, InfSupDouble::sin(p1788_interval_rb2ref(self)));
+	return r;
+}
+
+
+/* Cosine
+ *
+ * [𝒔𝒆𝒍𝒇].cos  =  hull{ cos(𝑥) \| 𝑥 ∈ [𝒔𝒆𝒍𝒇] }  ⊆  [-1, 1]
+ *
+ * Reverse function: {cos_rev}
+ */
+static VALUE p1788_interval_cos(VALUE self)
+{
+	VALUE r;
+	P1788_NEW_RB_INTERVAL(r, InfSupDouble::cos(p1788_interval_rb2ref(self)));
+	return r;
+}
+
+
+/* Tangent
+ *
+ * [𝒔𝒆𝒍𝒇].tan  =  hull{ tan(𝑥) \| 𝑥 ∈ [𝒔𝒆𝒍𝒇] }  ⊆  ℝ
+ *
+ * Reverse function: {tan_rev}
+ */
+static VALUE p1788_interval_tan(VALUE self)
+{
+	VALUE r;
+	P1788_NEW_RB_INTERVAL(r, InfSupDouble::tan(p1788_interval_rb2ref(self)));
+	return r;
+}
+
+
+/* Arc sine
+ *
+ * [𝒔𝒆𝒍𝒇].asin  =  hull{ asin(𝑥) \| 𝑥 ∈ [𝒔𝒆𝒍𝒇]∩[-1, 1] }  ⊆  [-𝛑/2, 𝛑/2]
+ *
+ * Reverse function: {sin}
+ */
+static VALUE p1788_interval_asin(VALUE self)
+{
+	VALUE r;
+	P1788_NEW_RB_INTERVAL(r, InfSupDouble::asin(p1788_interval_rb2ref(self)));
+	return r;
+}
+
+
+/* Arc cosine
+ *
+ * [𝒔𝒆𝒍𝒇].acos  =  hull{ acos(𝑥) \| 𝑥 ∈ [𝒔𝒆𝒍𝒇]∩[-1, 1] }  ⊆  [0, 𝛑]
+ *
+ * Reverse function: {cos}
+ */
+static VALUE p1788_interval_acos(VALUE self)
+{
+	VALUE r;
+	P1788_NEW_RB_INTERVAL(r, InfSupDouble::acos(p1788_interval_rb2ref(self)));
+	return r;
+}
+
+
+/* Arc tangent
+ *
+ * [𝒔𝒆𝒍𝒇].atan  =  hull{ atan(𝑥) \| 𝑥 ∈ [𝒔𝒆𝒍𝒇] }  ⊆  [-𝛑/2, 𝛑/2] 
+ *
+ * Reverse function: {tan}
+ */
+static VALUE p1788_interval_atan(VALUE self)
+{
+	VALUE r;
+	P1788_NEW_RB_INTERVAL(r, InfSupDouble::atan(p1788_interval_rb2ref(self)));
+	return r;
+}
+
+
+/* Hyperbolic sine
+ *
+ * [𝒔𝒆𝒍𝒇].sinh  =  hull{ (𝑒<sup>𝑥</sup> - 𝑒<sup>-𝑥</sup>) / 2 \| 𝑥 ∈ [𝒔𝒆𝒍𝒇] }  ⊆  ℝ
+ *
+ * Reverse function: {asinh}
+ */
+static VALUE p1788_interval_sinh(VALUE self)
+{
+	VALUE r;
+	P1788_NEW_RB_INTERVAL(r, InfSupDouble::sinh(p1788_interval_rb2ref(self)));
+	return r;
+}
+
+
+/* Hyperbolic cosine
+ *
+ * [𝒔𝒆𝒍𝒇].cosh  =  hull{ (𝑒<sup>𝑥</sup> + 𝑒<sup>-𝑥</sup>) / 2 \| 𝑥 ∈ [𝒔𝒆𝒍𝒇] }  ⊆  [1, +∞]
+ *
+ * Reverse function: {cosh_rev}
+ */
+static VALUE p1788_interval_cosh(VALUE self)
+{
+	VALUE r;
+	P1788_NEW_RB_INTERVAL(r, InfSupDouble::cosh(p1788_interval_rb2ref(self)));
+	return r;
+}
+
+
+/* Hyperbolic tangent
+ *
+ * [𝒔𝒆𝒍𝒇].tanh  =  hull{ sinh(𝑥) / cosh(𝑥) \| 𝑥 ∈ [𝒔𝒆𝒍𝒇] }  ⊆  [-1, 1]
+ *
+ * Reverse function: {atanh}
+ */
+static VALUE p1788_interval_tanh(VALUE self)
+{
+	VALUE r;
+	P1788_NEW_RB_INTERVAL(r, InfSupDouble::tanh(p1788_interval_rb2ref(self)));
+	return r;
+}
+
+
+/* Inverse hyperbolic sine
+ *
+ * [𝒔𝒆𝒍𝒇].asinh  =  hull{ asinh(𝑥) \| 𝑥 ∈ [𝒔𝒆𝒍𝒇] }  ⊆  ℝ
+ *
+ * Reverse function: {sinh}
+ */
+static VALUE p1788_interval_asinh(VALUE self)
+{
+	VALUE r;
+	P1788_NEW_RB_INTERVAL(r, InfSupDouble::asinh(p1788_interval_rb2ref(self)));
+	return r;
+}
+
+
+/* Inverse hyperbolic cosine
+ *
+ * [𝒔𝒆𝒍𝒇].acosh  =  hull{ acosh(𝑥) \| 𝑥 ∈ [𝒔𝒆𝒍𝒇]∩[1,+∞] }  ⊆  ℝ₊
+ *
+ * Reverse function: {cosh}
+ */
+static VALUE p1788_interval_acosh(VALUE self)
+{
+	VALUE r;
+	P1788_NEW_RB_INTERVAL(r, InfSupDouble::acosh(p1788_interval_rb2ref(self)));
+	return r;
+}
+
+
+/* Inverse hyperbolic tangent
+ *
+ * [𝒔𝒆𝒍𝒇].atanh  =  hull{ atanh(𝑥) \| 𝑥 ∈ [𝒔𝒆𝒍𝒇]∩[-1,1] }  ⊆  ℝ
+ *
+ * Reverse function: {tanh}
+ */
+static VALUE p1788_interval_atanh(VALUE self)
+{
+	VALUE r;
+	P1788_NEW_RB_INTERVAL(r, InfSupDouble::atanh(p1788_interval_rb2ref(self)));
+	return r;
+}
+
+
+/* Sign of _self_
+ *
+ * [𝒔𝒆𝒍𝒇].sign  ⊆  [-1, 1]  (\\{-1} if <span style="text-decoration:overline">𝒔𝒆𝒍𝒇</span> < 0, \\{1} if <span style="text-decoration:underline">𝒔𝒆𝒍𝒇</span> > 0, \\{0} if [𝒔𝒆𝒍𝒇] = \\{0})
+ */
+static VALUE p1788_interval_sign(VALUE self)
+{
+	VALUE r;
+	P1788_NEW_RB_INTERVAL(r, InfSupDouble::sign(p1788_interval_rb2ref(self)));
+	return r;
+}
+
+
+/* Round towards +∞
+ *
+ * [𝒔𝒆𝒍𝒇].ceil  =  [ceil(<span style="text-decoration:underline">𝒔𝒆𝒍𝒇</span>), ceil(<span style="text-decoration:overline">𝒔𝒆𝒍𝒇</span>)]
+ */
+static VALUE p1788_interval_ceil(VALUE self)
+{
+	VALUE r;
+	P1788_NEW_RB_INTERVAL(r, InfSupDouble::ceil(p1788_interval_rb2ref(self)));
+	return r;
+}
+
+
+/* Round towards -∞
+ *
+ * [𝒔𝒆𝒍𝒇].floor  =  [floor(<span style="text-decoration:underline">𝒔𝒆𝒍𝒇</span>), floor(<span style="text-decoration:overline">𝒔𝒆𝒍𝒇</span>)]
+ */
+static VALUE p1788_interval_floor(VALUE self)
+{
+	VALUE r;
+	P1788_NEW_RB_INTERVAL(r, InfSupDouble::floor(p1788_interval_rb2ref(self)));
+	return r;
+}
+
+
+/* Inflate _self_ towards nearest integer bounds
+ *
+ * [𝒔𝒆𝒍𝒇].floorceil  =  [floor(<span style="text-decoration:underline">𝒔𝒆𝒍𝒇</span>), ceil(<span style="text-decoration:overline">𝒔𝒆𝒍𝒇</span>)]
+ */
+static VALUE p1788_interval_floorceil(VALUE self)
+{
+	InfSupDouble &inter = p1788_interval_rb2ref(self);
+	VALUE r;
+	P1788_NEW_RB_INTERVAL(r, InfSupDouble(std::floor(InfSupDouble::inf(inter)), std::ceil(InfSupDouble::sup(inter))));
+	return r;
+}
+
+
+/* Round towards 0
+ *
+ * [𝒔𝒆𝒍𝒇].trunc  =  [trunc(<span style="text-decoration:underline">𝒔𝒆𝒍𝒇</span>), trunc(<span style="text-decoration:overline">𝒔𝒆𝒍𝒇</span>)]
+ */
+static VALUE p1788_interval_trunc(VALUE self)
+{
+	VALUE r;
+	P1788_NEW_RB_INTERVAL(r, InfSupDouble::trunc(p1788_interval_rb2ref(self)));
+	return r;
+}
+
+
+/* Round, ties to even
+ *
+ * Round bounds of _self_ to their nearest integer values, rounding halfway cases to nearest even.
+ *
+ * [𝒔𝒆𝒍𝒇].round_ties_to_even  =  [round_ties_to_even(<span style="text-decoration:underline">𝒔𝒆𝒍𝒇</span>), round_ties_to_even(<span style="text-decoration:overline">𝒔𝒆𝒍𝒇</span>)]
+ */
+static VALUE p1788_interval_round_ties_to_even(VALUE self)
+{
+	VALUE r;
+	P1788_NEW_RB_INTERVAL(r, InfSupDouble::round_ties_to_even(p1788_interval_rb2ref(self)));
+	return r;
+}
+
+
+/* Round, ties to away from zero
+ *
+ * Round bounds of _self_ to their nearest integer values, rounding halfway cases away from zero.
+ *
+ * [𝒔𝒆𝒍𝒇].round_ties_to_away  =  [round_ties_to_away(<span style="text-decoration:underline">𝒔𝒆𝒍𝒇</span>), round_ties_to_away(<span style="text-decoration:overline">𝒔𝒆𝒍𝒇</span>)]
+ */
+static VALUE p1788_interval_round_ties_to_away(VALUE self)
+{
+	VALUE r;
+	P1788_NEW_RB_INTERVAL(r, InfSupDouble::round_ties_to_away(p1788_interval_rb2ref(self)));
+	return r;
+}
+
+
+/* Absolute value
+ *
+ * [𝒔𝒆𝒍𝒇].abs  =  hull{ \|𝑥\| ￨ 𝑥 ∈ [𝒔𝒆𝒍𝒇] }  ⊆  ℝ₊
+ *
+ * Reverse function: {abs_rev}
+ */
+static VALUE p1788_interval_abs(VALUE self)
+{
+	VALUE r;
+	P1788_NEW_RB_INTERVAL(r, InfSupDouble::abs(p1788_interval_rb2ref(self)));
+	return r;
+}
+
+
+/* Arithmetic addition
+ *
+ * [𝒔𝒆𝒍𝒇] + [𝒚]  =  hull{ 𝑥 + 𝑦 \| 𝑥 ∈ [𝒔𝒆𝒍𝒇], 𝑦 ∈ [𝒚] }  ⊆  ℝ
+ *
+ * Reverse function: {-}
+ */
+static VALUE p1788_interval_add(VALUE self, VALUE y)
+{
+	InfSupDouble iother = p1788_rbobj2infsupdouble(y);
+	InfSupDouble &inter = p1788_interval_rb2ref(self);
+	VALUE r;
+	P1788_NEW_RB_INTERVAL(r, InfSupDouble::add(inter, iother));
+	return r;
+}
+
+
+/* Arithmetic subtraction
+ *
+ * [𝒔𝒆𝒍𝒇] - [𝒚]  =  hull{ 𝑥 - 𝑦 \| 𝑥 ∈ [𝒔𝒆𝒍𝒇], 𝑦 ∈ [𝒚] }  ⊆  ℝ
+ *
+ * Reverse function: {+}
+ */
+static VALUE p1788_interval_sub(VALUE self, VALUE y)
+{
+	InfSupDouble iother = p1788_rbobj2infsupdouble(y);
+	InfSupDouble &inter = p1788_interval_rb2ref(self);
+	VALUE r;
+	P1788_NEW_RB_INTERVAL(r, InfSupDouble::sub(inter, iother));
+	return r;
+}
+
+
+/* Arithmetic multiplication
+ *
+ * [𝒔𝒆𝒍𝒇]*[𝒚]  =  hull{ 𝑥⋅𝑦 \| 𝑥 ∈ [𝒔𝒆𝒍𝒇], 𝑦 ∈ [𝒚] }  ⊆  ℝ
+ *
+ * Reverse function: {mul_rev}
+ */
+static VALUE p1788_interval_mul(VALUE self, VALUE y)
+{
+	InfSupDouble iother = p1788_rbobj2infsupdouble(y);
+	InfSupDouble &inter = p1788_interval_rb2ref(self);
+	VALUE r;
+	P1788_NEW_RB_INTERVAL(r, InfSupDouble::mul(inter, iother));
+	return r;
+}
+
+
+/* Arithmetic division
+ *
+ * [𝒔𝒆𝒍𝒇] / [𝒚]  =  hull{ 𝑥/𝑦 \| 𝑥 ∈ [𝒔𝒆𝒍𝒇], 𝑦 ∈ [𝒚] }  ⊆  ℝ
+ *
+ * Reverse function: {*}
+ */
+static VALUE p1788_interval_div(VALUE self, VALUE y)
+{
+	InfSupDouble iother = p1788_rbobj2infsupdouble(y);
+	InfSupDouble &inter = p1788_interval_rb2ref(self);
+	VALUE r;
+	P1788_NEW_RB_INTERVAL(r, InfSupDouble::div(inter, iother));
+	return r;
+}
+
+
+/* Two-output division
+ *
+ * Returns a pair of intervals, 𝒔𝒆𝒍𝒇 / (𝒚 ∩ ℝ₋) and 𝒔𝒆𝒍𝒇 / (𝒚 ∩ ℝ₊)
+ * @return [Array<Interval>] [∅, ∅] if 𝒔𝒆𝒍𝒇/𝒚 is empty, [[𝒔𝒆𝒍𝒇/𝒚], ∅] if 𝒔𝒆𝒍𝒇/𝒚 has one component, [[𝒔𝒆𝒍𝒇/𝒚]₁, [𝒔𝒆𝒍𝒇/𝒚]₂] if 𝒔𝒆𝒍𝒇/𝒚 has two components
+ */
+static VALUE p1788_interval_div_to_pair(VALUE self, VALUE y)
+{
+	VALUE r1, r2;
+	InfSupDouble iother = p1788_rbobj2infsupdouble(y);
+	InfSupDouble &inter = p1788_interval_rb2ref(self);
+	std::pair< InfSupDouble, InfSupDouble > p = InfSupDouble::mul_rev_to_pair(iother, inter);
+	P1788_NEW_RB_INTERVAL(r1, p.first);
+	P1788_NEW_RB_INTERVAL(r2, p.second);
+	return rb_ary_new_from_args(2, r1, r2);
+}
+
+
+/* Power operator
+ *
+ * If _exponent_ is an integer, calls {pown}, else call {pow}.
+ * @param exponent [Interval, Integer]
+ */
+static VALUE p1788_interval_powop(VALUE self, VALUE exponent)
+{
+	VALUE r;
+	int p;
+	double d;
+	if (rb_obj_is_kind_of(exponent, rb_cInteger)) {
+		p = NUM2INT(exponent);
+		if (p == 2)
+			P1788_NEW_RB_INTERVAL(r, InfSupDouble::sqr(p1788_interval_rb2ref(self)));
+		else
+			P1788_NEW_RB_INTERVAL(r, InfSupDouble::pown(p1788_interval_rb2ref(self), p));
+	}
+	else if (rb_obj_is_kind_of(exponent, rb_cNumeric)) {
+		d = NUM2DBL(exponent);
+		p = NUM2INT(exponent);
+		if (d == (double)p) {
+			if (p == 2)
+				P1788_NEW_RB_INTERVAL(r, InfSupDouble::sqr(p1788_interval_rb2ref(self)));
+			else
+				P1788_NEW_RB_INTERVAL(r, InfSupDouble::pown(p1788_interval_rb2ref(self), p));
+		}
+		else
+			P1788_NEW_RB_INTERVAL(r, InfSupDouble::pow(p1788_interval_rb2ref(self), InfSupDouble(d, d)));
+	}
+	else {
+		P1788_NEW_RB_INTERVAL(r, InfSupDouble::pow(p1788_interval_rb2ref(self), p1788_rbobj2infsupdouble(exponent)));
+	}
+	return r;
+}
+
+
+/* Power function
+ *
+ * [𝒔𝒆𝒍𝒇].pow([𝒚])  =  hull{ 𝑥<sup>𝑦</sup> \| (𝑥, 𝑦) ∈ \\{𝑥 ∈ [𝒔𝒆𝒍𝒇], 𝑦 ∈ [𝒚] \| 𝑥>0\} ∪ \\{𝑥 ∈ [𝒔𝒆𝒍𝒇]∩\{0\}, 𝑦 ∈ [𝒚] \| 𝑦>0\} }  ⊆  ℝ₊
+ *
+ * Reverse functions: {pow_rev1} and {pow_rev2}
+ */
+static VALUE p1788_interval_pow(VALUE self, VALUE y)
+{
+	VALUE r;
+	P1788_NEW_RB_INTERVAL(r, InfSupDouble::pow(p1788_interval_rb2ref(self), p1788_rbobj2infsupdouble(y)));
+	return r;
+}
+
+
+/* Power with integer exponent
+ * 
+ * [𝒔𝒆𝒍𝒇].pow(n)  =  hull{ 𝑥ⁿ \| 𝑥 ∈ [𝒔𝒆𝒍𝒇] }  ⊆  ℝ if n odd, ℝ₊ if n even, \\{1\} if n = 0
+ *
+ * Reverse function {pown_rev}
+ * @param n [Integer] integer exponent
+ */
+static VALUE p1788_interval_pown(VALUE self, VALUE n)
+{
+	VALUE r;
+	int p;
+	if (!RB_TYPE_P(n, T_FIXNUM))
+		rb_raise(rb_eTypeError, "expecting an integer (Fixnum) as exponent, not a %" PRIsVALUE, rb_class_name(rb_class_of(n)));
+	p = NUM2INT(n);
+	P1788_NEW_RB_INTERVAL(r, InfSupDouble::pown(p1788_interval_rb2ref(self), p));
+	return r;
+}
+
+
+/* Minimum of two intervals
+ *
+ * [𝒔𝒆𝒍𝒇].min([𝒃])  =  [min(<span style="text-decoration:underline">𝒔𝒆𝒍𝒇</span>, <span style="text-decoration:underline">𝒃</span>), min(<span style="text-decoration:overline">𝒔𝒆𝒍𝒇</span>, <span style="text-decoration:overline">𝒃</span>)]
+ */
+static VALUE p1788_interval_min(VALUE self, VALUE y)
+{
+	InfSupDouble iother = p1788_rbobj2infsupdouble(y);
+	InfSupDouble &inter = p1788_interval_rb2ref(self);
+	VALUE r;
+	P1788_NEW_RB_INTERVAL(r, InfSupDouble::min(inter, iother));
+	return r;
+}
+
+
+/* Maximum of two intervals
+ *
+ * [𝒔𝒆𝒍𝒇].max([𝒃])  =  [max(<span style="text-decoration:underline">𝒔𝒆𝒍𝒇</span>, <span style="text-decoration:underline">𝒃</span>), max(<span style="text-decoration:overline">𝒔𝒆𝒍𝒇</span>, <span style="text-decoration:overline">𝒃</span>)]
+ */
+static VALUE p1788_interval_max(VALUE self, VALUE b)
+{
+	InfSupDouble iother = p1788_rbobj2infsupdouble(b);
+	InfSupDouble &inter = p1788_interval_rb2ref(self);
+	VALUE r;
+	P1788_NEW_RB_INTERVAL(r, InfSupDouble::max(inter, iother));
+	return r;
+}
+
+
+/* Cancellative subtraction
+ *
+ * Cancellative subtraction solves the following problem: Recover interval [𝒛] from intervals [𝒔𝒆𝒍𝒇] and [𝒚], given that [𝒔𝒆𝒍𝒇] = [𝒚] + [𝒛].
+ * 
+ * For any two bounded intervals [𝒔𝒆𝒍𝒇] and [𝒚], [𝒔𝒆𝒍𝒇].cancel_minus([𝒚]) is the tightest interval [𝒛] such that [𝒚] + [𝒛] ⊇ [𝒔𝒆𝒍𝒇].
+ */
+static VALUE p1788_interval_cancel_minus(VALUE self, VALUE y)
+{
+	InfSupDouble iother = p1788_rbobj2infsupdouble(y);
+	InfSupDouble &inter = p1788_interval_rb2ref(self);
+	VALUE r;
+	P1788_NEW_RB_INTERVAL(r, InfSupDouble::cancel_minus(inter, iother));
+	return r;
+}
+
+
+/* Cancellative addition
+ *
+ * self.cancel_plux([𝒚]) = self.cancel_minus(-[𝒚])
+ * @see cancel_minus
+ */
+static VALUE p1788_interval_cancel_plus(VALUE self, VALUE y)
+{
+	InfSupDouble iother = p1788_rbobj2infsupdouble(y);
+	InfSupDouble &inter = p1788_interval_rb2ref(self);
+	VALUE r;
+	P1788_NEW_RB_INTERVAL(r, InfSupDouble::cancel_plus(inter, iother));
+	return r;
+}
+
+
+/* Fused multiply add
+ *
+ *fma([𝒙], [𝒚])  =  hull{ 𝑥⋅𝑦 + 𝑧 \| 𝑥 ∈ [𝒙], 𝑦 ∈ [𝒚], 𝑧 ∈ [𝒔𝒆𝒍𝒇] }  ⊆  ℝ
+ */
+static VALUE p1788_interval_fma(VALUE self, VALUE x, VALUE y)
+{
+	InfSupDouble ix = p1788_rbobj2infsupdouble(x);
+	InfSupDouble iy = p1788_rbobj2infsupdouble(y);
+	InfSupDouble &inter = p1788_interval_rb2ref(self);
+	VALUE r;
+	P1788_NEW_RB_INTERVAL(r, InfSupDouble::fma(ix, iy, inter));
+	return r;
+}
+
+
+/* Reverse elementary functions */
+
+
+/* The reverse interval extension φRev
+ * for a unary function φ is an interval fulfill the following
+ * requirement:
+ * φRev([c], [x]) ⊇ {x ∈ [x] | φ(x) is defined and in [c]}
+ * For a binary function φ there are naturally two reverse
+ * interval extensions φRev1 and φRev2, for details, see
+ * M. Nehmeier, “Motion 11 - Basic Reverse Arithmetic Operations,”
+ * IEEE Interval Standard Working Group - P1788, January 2010
+ * φRev1([b], [c], [x]) ⊇ {x ∈ [x] | ∃ b ∈ [b], x φ b is defined and in [c]}
+ * φRev2([a], [c], [x]) ⊇ {x ∈ [x] | ∃ a ∈ [a], a φ x is defined and in [c]}
+ * if φ is commutative, then φRev1 and φRev2 agree and may be implemented simply as φRev
+ */
+
+
+/* Two-output division
+ *
+ * [𝒔𝒆𝒍𝒇]/[𝒃] = { 𝑥 ∈ ℝ \| ∃ 𝑏 ∈ [𝒃] : 𝑥⋅𝑏 ∈ [𝒔𝒆𝒍𝒇] }
+ * @return [Array<Interval>] a two elements array of intervals: [∅, ∅] if 𝒔𝒆𝒍𝒇/𝒃 is empty, [[𝒔𝒆𝒍𝒇/𝒃], ∅] if 𝒔𝒆𝒍𝒇/𝒃 has one component, [[𝒔𝒆𝒍𝒇/𝒃]₁, [𝒔𝒆𝒍𝒇/𝒃]₂] if 𝒔𝒆𝒍𝒇/𝒃 has two components
+ */
+static VALUE p1788_interval_mul_rev_to_pair(VALUE self, VALUE y)
+{
+	VALUE r1, r2;
+	InfSupDouble iother = p1788_rbobj2infsupdouble(y);
+	InfSupDouble &inter = p1788_interval_rb2ref(self);
+	std::pair< InfSupDouble, InfSupDouble > p = InfSupDouble::mul_rev_to_pair(inter, iother);
+	P1788_NEW_RB_INTERVAL(r1, p.first);
+	P1788_NEW_RB_INTERVAL(r2, p.second);
+	return rb_ary_new_from_args(2, r1, r2);
+}
+
+
+/* Reverse multiplication
+ *
+ * mul_rev([𝒃], [𝒙])  =  hull{ 𝑥 ∈ [𝒙] \| ∃ 𝑏 ∈ [𝒃] : 𝑥⋅𝑏 ∈ [𝒔𝒆𝒍𝒇] }  ⊆  ℝ
+ *
+ * Reverse function {mul}
+ * @overload mul_rev(b, x = ALL_REALS)
+ */
+static VALUE p1788_interval_mul_rev(int argc, VALUE *argv, VALUE self)
+{
+	VALUE b, x, r;
+	rb_scan_args(argc, argv, "11", &b, &x);
+	if (x == Qnil) {
+		P1788_NEW_RB_INTERVAL(r, InfSupDouble::mul_rev(p1788_rbobj2infsupdouble(b), p1788_interval_rb2ref(self)));
+	}
+	else {
+		P1788_NEW_RB_INTERVAL(r, InfSupDouble::mul_rev(p1788_rbobj2infsupdouble(b), p1788_interval_rb2ref(self), p1788_rbobj2infsupdouble(x)));
+	}
+	return r;
+}
+
+
+/* Reverse square
+ *
+ * sqr_rev([𝒙])  =  hull{ 𝑥 ∈ [𝒙] \| 𝑥² ∈ [𝒔𝒆𝒍𝒇] }  ⊆  ℝ
+ *
+ * Reverse function: {sqr}
+ * @overload sqr_rev(x = ALL_REALS)
+ */
+static VALUE p1788_interval_sqr_rev(int argc, VALUE *argv, VALUE self)
+{
+	VALUE x, r;
+	rb_scan_args(argc, argv, "01", &x);
+	if (x == Qnil) {
+		P1788_NEW_RB_INTERVAL(r, InfSupDouble::sqr_rev(p1788_interval_rb2ref(self)));
+	}
+	else {
+		P1788_NEW_RB_INTERVAL(r, InfSupDouble::sqr_rev(p1788_interval_rb2ref(self), p1788_rbobj2infsupdouble(x)));
+	}
+	return r;
+}
+
+
+/* Reverse absolute value.
+ *
+ * abs_rev([𝒙])  =  hull{ 𝑥 ∈ [𝒙] ￨ \|𝑥\| ∈ [𝒔𝒆𝒍𝒇] }  ⊆  ℝ
+ *
+ * Reverse function: {abs}
+ * @overload abs_rev(x = ALL_REALS)
+ */
+static VALUE p1788_interval_abs_rev(int argc, VALUE *argv, VALUE self)
+{
+	VALUE x, r;
+	rb_scan_args(argc, argv, "01", &x);
+	if (x == Qnil) {
+		P1788_NEW_RB_INTERVAL(r, InfSupDouble::abs_rev(p1788_interval_rb2ref(self)));
+	}
+	else {
+		P1788_NEW_RB_INTERVAL(r, InfSupDouble::abs_rev(p1788_interval_rb2ref(self), p1788_rbobj2infsupdouble(x)));
+	}
+	return r;
+}
+
+
+/* Reverse power with integer exponent
+ *
+ * pown_rev(𝑛, [𝒙])  =  hull{ 𝑥 ∈ [𝒙] \| 𝑥ⁿ ∈ [𝒔𝒆𝒍𝒇] }  ⊆  ℝ
+ *
+ * Reverse function: {pown}
+ * @overload pown_rev(n, x = ALL_REALS)
+ *  @param n [Integer] integer exponent
+ *  @param x [Interval]
+ */
+static VALUE p1788_interval_pown_rev(int argc, VALUE *argv, VALUE self)
+{
+	VALUE x, r, n;
+	int p;
+	rb_scan_args(argc, argv, "11", &n, &x);
+	p = NUM2INT(n);
+	if (x == Qnil) {
+		P1788_NEW_RB_INTERVAL(r, InfSupDouble::pown_rev(p1788_interval_rb2ref(self), p));
+	}
+	else {
+		P1788_NEW_RB_INTERVAL(r, InfSupDouble::pown_rev(p1788_interval_rb2ref(self), p1788_rbobj2infsupdouble(x), p));
+	}
+	return r;
+}
+
+
+/* Reverse power function (base)
+ *
+ * pow_rev1([𝒃], [𝒙])  =  hull{ 𝑥 ∈ [𝒙] \|  ∃ 𝑏 ∈ [𝒃] : 𝑥<sup>𝑏</sup> ∈ [𝒔𝒆𝒍𝒇] }  ⊆  ℝ₊
+ *
+ * Reverse function: {pow}
+ * @overload pow_rev1(b, x = ALL_REALS)
+ */
+static VALUE p1788_interval_pow_rev1(int argc, VALUE *argv, VALUE self)
+{
+	VALUE rbb, rbx, rbr;
+	rb_scan_args(argc, argv, "11", &rbb, &rbx);
+	InfSupDouble  b = p1788_rbobj2infsupdouble(rbb);
+	InfSupDouble  x = (rbx == Qnil) ? InfSupDouble(-INF, INF) : p1788_rbobj2infsupdouble(rbx);
+	InfSupDouble &c = p1788_interval_rb2ref(self);
+
+	InfSupDouble lnx = InfSupDouble::log(x);
+	InfSupDouble m   = InfSupDouble::intersection(InfSupDouble::log(c), InfSupDouble::mul(b, lnx));
+	InfSupDouble l   = InfSupDouble::mul_rev(b, m, lnx);
+	InfSupDouble r   = InfSupDouble::intersection(InfSupDouble::exp(l), x);
+
+	P1788_NEW_RB_INTERVAL(rbr, r);
+	return rbr;
+}
+
+
+/* Reverse power function (exponent)
+ *
+ * pow_rev2([𝒂], [𝒙])  =  hull{ 𝑥 ∈ [𝒙] \|  ∃ 𝑎 ∈ [𝒂] : 𝑎<sup>𝑥</sup> ∈ [𝒔𝒆𝒍𝒇] }  ⊆  ℝ
+ *
+ * Reverse function: {pow}
+ * @overload pow_rev2(a, x = ALL_REALS)
+ */
+static VALUE p1788_interval_pow_rev2(int argc, VALUE *argv, VALUE self)
+{
+	VALUE rba, rbx, rbr;
+	rb_scan_args(argc, argv, "11", &rba, &rbx);
+	InfSupDouble a = p1788_rbobj2infsupdouble(rba);
+	InfSupDouble x = (rbx == Qnil) ? InfSupDouble(-INF, INF) : p1788_rbobj2infsupdouble(rbx);
+	InfSupDouble &c = p1788_interval_rb2ref(self);
+
+	InfSupDouble lna = InfSupDouble::log(a);
+	InfSupDouble m   = InfSupDouble::intersection(InfSupDouble::log(c), InfSupDouble::mul(x, lna));
+	InfSupDouble r   = InfSupDouble::mul_rev(lna, m, x);
+
+	P1788_NEW_RB_INTERVAL(rbr, r);
+	return rbr;
+}
+
+
+/* Reverse sine
+ *
+ * sin_rev([𝒙])  =  hull{ 𝑥 ∈ [𝒙] \| sin(𝑥) ∈ [𝒔𝒆𝒍𝒇] }  ⊆  ℝ
+ *
+ * Reverse function: {sin}
+ * @overload sin_rev(x = ALL_REALS)
+ */
+static VALUE p1788_interval_sin_rev(int argc, VALUE *argv, VALUE self)
+{
+	VALUE x, r;
+	rb_scan_args(argc, argv, "01", &x);
+	if (x == Qnil) {
+		P1788_NEW_RB_INTERVAL(r, InfSupDouble::sin_rev(p1788_interval_rb2ref(self)));
+	}
+	else {
+		P1788_NEW_RB_INTERVAL(r, InfSupDouble::sin_rev(p1788_interval_rb2ref(self), p1788_rbobj2infsupdouble(x)));
+	}
+	return r;
+}
+
+
+/* Reverse cosine
+ *
+ * cos_rev([𝒙])  =  hull{ 𝑥 ∈ [𝒙] \| cos(𝑥) ∈ [𝒔𝒆𝒍𝒇] }  ⊆  ℝ
+ *
+ * Reverse function: {cos}
+ * @overload cos_rev(x = ALL_REALS)
+ */
+static VALUE p1788_interval_cos_rev(int argc, VALUE *argv, VALUE self)
+{
+	VALUE x, r;
+	rb_scan_args(argc, argv, "01", &x);
+	if (x == Qnil) {
+		P1788_NEW_RB_INTERVAL(r, InfSupDouble::cos_rev(p1788_interval_rb2ref(self)));
+	}
+	else {
+		P1788_NEW_RB_INTERVAL(r, InfSupDouble::cos_rev(p1788_interval_rb2ref(self), p1788_rbobj2infsupdouble(x)));
+	}
+	return r;
+}
+
+
+/* Reverse tangent
+ *
+ * tan_rev([𝒙])  =  hull{ 𝑥 ∈ [𝒙] \| tan(𝑥) ∈ [𝒔𝒆𝒍𝒇] }  ⊆  ℝ
+ *
+ * Reverse function: {tan}
+ * @overload tan_rev(x = ALL_REALS)
+ */
+static VALUE p1788_interval_tan_rev(int argc, VALUE *argv, VALUE self)
+{
+	VALUE x, r;
+	rb_scan_args(argc, argv, "01", &x);
+	if (x == Qnil) {
+		P1788_NEW_RB_INTERVAL(r, InfSupDouble::tan_rev(p1788_interval_rb2ref(self)));
+	}
+	else {
+		P1788_NEW_RB_INTERVAL(r, InfSupDouble::tan_rev(p1788_interval_rb2ref(self), p1788_rbobj2infsupdouble(x)));
+	}
+	return r;
+}
+
+
+/* Reverse hyperbolic cosine
+ *
+ * cosh_rev([𝒙])  =  hull{ 𝑥 ∈ [𝒙] \| cosh(𝑥) ∈ [𝒔𝒆𝒍𝒇] }  ⊆  ℝ
+ * 
+ * Reverse function: {cosh}
+ * @overload cosh_rev(x = ALL_REALS)
+ */
+static VALUE p1788_interval_cosh_rev(int argc, VALUE *argv, VALUE self)
+{
+	VALUE x, r;
+	rb_scan_args(argc, argv, "01", &x);
+	if (x == Qnil) {
+		P1788_NEW_RB_INTERVAL(r, InfSupDouble::cosh_rev(p1788_interval_rb2ref(self)));
+	}
+	else {
+		P1788_NEW_RB_INTERVAL(r, InfSupDouble::cosh_rev(p1788_interval_rb2ref(self), p1788_rbobj2infsupdouble(x)));
+	}
+	return r;
+}
+ 
+
+/* Math module functions */
+
+
+/* Reciprocal of _x_
+ *
+ * recip([𝒙])  =  hull{ 1/𝑥 \| 𝑥 ∈ [𝒙] }  ⊆  ℝ
+ *
+ * Reverse function: {recip_rev}
+ */
+static VALUE p1788_recip(VALUE self, VALUE x)
+{
+	VALUE r;
+	P1788_NEW_RB_INTERVAL(r, InfSupDouble::recip(p1788_rbobj2infsupdouble(x)));
+	return r;
+}
+
+
+/* Reverse reciprocal
+ *
+ * recip_rev([𝒄], [𝒙])  =  hull{ 𝑥 ∈ [𝒙] \| 1/𝑥 ∈ [𝒄] }  ⊆  ℝ
+ *
+ * Reverse function: {recip}
+ * @overload recip_rev(c, x = ALL_REALS)
+ */
+static VALUE p1788_recip_rev(int argc, VALUE *argv, VALUE self)
+{
+	VALUE x, c, r;
+	rb_scan_args(argc, argv, "11", &c, &x);
+	if (x == Qnil) {
+		P1788_NEW_RB_INTERVAL(r, InfSupDouble::mul_rev(p1788_rbobj2infsupdouble(c), InfSupDouble(1.0, 1.0)));
+	}
+	else {
+		P1788_NEW_RB_INTERVAL(r, InfSupDouble::mul_rev(p1788_rbobj2infsupdouble(c), InfSupDouble(1.0, 1.0), p1788_rbobj2infsupdouble(x)));
+	}
+	return r;
+}
+
+
+/* Square of _x_
+ *
+ * sqr([𝒙])  =  hull{ 𝑥² \| 𝑥 ∈ [𝒙] }  ⊆  ℝ₊
+ *
+ * Reverse function: {sqr_rev}
+ */
+static VALUE p1788_sqr(VALUE self, VALUE x)
+{
+	VALUE r;
+	P1788_NEW_RB_INTERVAL(r, InfSupDouble::sqr(p1788_rbobj2infsupdouble(x)));
+	return r;
+}
+
+
+/* Square root of _x_
+ *
+ * sqrt([𝒙])  =  hull{ 𝑥<sup>½</sup> \| 𝑥 ∈ [𝒙]∩ℝ₊ }  ⊆  ℝ₊
+ *
+ * Reverse function: {sqrt_rev}
+ */
+static VALUE p1788_sqrt(VALUE self, VALUE x)
+{
+	VALUE r;
+	P1788_NEW_RB_INTERVAL(r, InfSupDouble::sqrt(p1788_rbobj2infsupdouble(x)));
+	return r;
+}
+
+
+/* Reverse square root
+ *
+ * sqrt_rev([𝒄], [𝒙])  =  hull{ 𝑥 ∈ [𝒙] \| 𝑥<sup>½</sup> ∈ [𝒄] }  =  { 𝑐² \| 𝑐 ∈ [𝒄]∩ℝ₊ } ∩ [𝒙]  ⊆  ℝ₊
+ *
+ * Reverse function: {sqrt}
+ * @overload sqrt_rev(c, x = ALL_REALS)
+ */
+static VALUE p1788_sqrt_rev(int argc, VALUE *argv, VALUE self)
+{
+	VALUE rbc, rbx, rbr;
+	rb_scan_args(argc, argv, "11", &rbc, &rbx);
+	InfSupDouble  c = p1788_rbobj2infsupdouble(rbc);
+	InfSupDouble  r = InfSupDouble::sqr(InfSupDouble::intersection(c, pos_reals_set));
+	if (rbx != Qnil)
+		r = InfSupDouble::intersection(r, p1788_rbobj2infsupdouble(rbx));
+	P1788_NEW_RB_INTERVAL(rbr, r);
+	return rbr;
+}
+
+
+/* _e_ raised to the power of _x_
+ *
+ * exp([𝒙])  =  hull{ 𝑒<sup>𝑥</sup> \| 𝑥 ∈ [𝒙] }  ⊆  ℝ₊
+ *
+ * Reverse function: {exp_rev}
+ */
+static VALUE p1788_exp(VALUE self, VALUE x)
+{
+	VALUE r;
+	P1788_NEW_RB_INTERVAL(r, InfSupDouble::exp(p1788_rbobj2infsupdouble(x)));
+	return r;
+}
+
+
+/* Reverse exponential
+ *
+ * exp_rev([𝒄], [𝒙])  =  hull{ 𝑥 ∈ [𝒙] \| 𝑒<sup>𝑥</sup> ∈ [𝒄] }  =  { log(𝑐) \| 𝑐 ∈ [𝒄]∩ℝ₊ } ∩ [𝒙]  ⊆  ℝ
+ *
+ * Reverse function: {exp}
+ * @overload exp_rev(c, x = ALL_REALS)
+ */
+static VALUE p1788_exp_rev(int argc, VALUE *argv, VALUE self)
+{
+	VALUE rbc, rbx, rbr;
+	rb_scan_args(argc, argv, "11", &rbc, &rbx);
+	InfSupDouble  r = InfSupDouble::log(p1788_rbobj2infsupdouble(rbc));
+	if (rbx != Qnil)
+		r = InfSupDouble::intersection(r, p1788_rbobj2infsupdouble(rbx));
+	P1788_NEW_RB_INTERVAL(rbr, r);
+	return rbr;
+}
+
+
+/* 2 raised to the power of _x_
+ *
+ * exp2([𝒙])  =  hull{ 2<sup>𝑥</sup> \| 𝑥 ∈ [𝒙] }  ⊆  ℝ₊
+ *
+ * Reverse function: {exp2_rev}
+ */
+static VALUE p1788_exp2(VALUE self, VALUE x)
+{
+	VALUE r;
+	P1788_NEW_RB_INTERVAL(r, InfSupDouble::exp2(p1788_rbobj2infsupdouble(x)));
+	return r;
+}
+
+
+/* Reverse base 2 exponential
+ *
+ * exp2_rev([𝒄], [𝒙])  =  hull{ 𝑥 ∈ [𝒙] \| 2<sup>𝑥</sup> ∈ [𝒄] }  =  { log2(𝑐) \| 𝑐 ∈ [𝒄]∩ℝ₊ } ∩ [𝒙]  ⊆  ℝ
+ *
+ * Reverse function: {exp2}
+ * @overload exp2_rev(c, x = ALL_REALS)
+ */
+static VALUE p1788_exp2_rev(int argc, VALUE *argv, VALUE self)
+{
+	VALUE rbc, rbx, rbr;
+	rb_scan_args(argc, argv, "11", &rbc, &rbx);
+	InfSupDouble  r = InfSupDouble::log2(p1788_rbobj2infsupdouble(rbc));
+	if (rbx != Qnil)
+		r = InfSupDouble::intersection(r, p1788_rbobj2infsupdouble(rbx));
+	P1788_NEW_RB_INTERVAL(rbr, r);
+	return rbr;
+}
+
+
+/* 10 raised to the power of _x_
+ *
+ * exp10([𝒙])  =  hull{ 10<sup>𝑥</sup> \| 𝑥 ∈ [𝒙] }  ⊆  ℝ₊
+ *
+ * Reverse function: {exp10_rev}
+ */
+static VALUE p1788_exp10(VALUE self, VALUE x)
+{
+	VALUE r;
+	P1788_NEW_RB_INTERVAL(r, InfSupDouble::exp10(p1788_rbobj2infsupdouble(x)));
+	return r;
+}
+
+
+/* Reverse base 10 exponential
+ *
+ * exp10_rev([𝒄], [𝒙])  =  hull{ 𝑥 ∈ [𝒙] \| 10<sup>𝑥</sup> ∈ [𝒄] }  =  { log10(𝑐) \| 𝑐 ∈ [𝒄]∩ℝ₊ } ∩ [𝒙]  ⊆  ℝ
+ *
+ * Reverse function: {exp10}
+ * @overload exp2_rev(c, x = ALL_REALS)
+ */
+static VALUE p1788_exp10_rev(int argc, VALUE *argv, VALUE self)
+{
+	VALUE rbc, rbx, rbr;
+	rb_scan_args(argc, argv, "11", &rbc, &rbx);
+	InfSupDouble  r = InfSupDouble::log10(p1788_rbobj2infsupdouble(rbc));
+	if (rbx != Qnil)
+		r = InfSupDouble::intersection(r, p1788_rbobj2infsupdouble(rbx));
+	P1788_NEW_RB_INTERVAL(rbr, r);
+	return rbr;
+}
+
+
+/* Natural logarithm of _x_.
+ *
+ * log([𝒙])  =  hull{ ln(𝑥) \| 𝑥 ∈ [𝒙]∩ℝ₊ }  ⊆  ℝ
+ *
+ * Reverse function: {log_rev}
+ */
+static VALUE p1788_log(VALUE self, VALUE x)
+{
+	VALUE r;
+	P1788_NEW_RB_INTERVAL(r, InfSupDouble::log(p1788_rbobj2infsupdouble(x)));
+	return r;
+}
+
+
+/* Reverse natural logarithm
+ *
+ * log_rev([𝒄], [𝒙])  =  hull{ 𝑥 ∈ [𝒙] \| log(𝑥) ∈ [𝒄] }  =  { 𝑒<sup>𝑐</sup> \| 𝑐 ∈ [𝒄] } ∩ [𝒙]  ⊆  ℝ₊
+ *
+ * Reverse function: {log}
+ * @overload log_rev(c, x = ALL_REALS)
+ */
+static VALUE p1788_log_rev(int argc, VALUE *argv, VALUE self)
+{
+	VALUE rbc, rbx, rbr;
+	rb_scan_args(argc, argv, "11", &rbc, &rbx);
+	InfSupDouble  r = InfSupDouble::exp(p1788_rbobj2infsupdouble(rbc));
+	if (rbx != Qnil)
+		r = InfSupDouble::intersection(r, p1788_rbobj2infsupdouble(rbx));
+	P1788_NEW_RB_INTERVAL(rbr, r);
+	return rbr;
+}
+
+
+/* Base 2 logarithm of _x_
+ *
+ * log2([𝒙])  =  hull{ ln(𝑥)/ln(2) \| 𝑥 ∈ [𝒙]∩ℝ₊ }  ⊆  ℝ
+ *
+ * Reverse function: {log2_rev}
+ */
+static VALUE p1788_log2(VALUE self, VALUE x)
+{
+	VALUE r;
+	P1788_NEW_RB_INTERVAL(r, InfSupDouble::log2(p1788_rbobj2infsupdouble(x)));
+	return r;
+}
+
+
+/* Reverse base 2 logarithm
+ *
+ * log2_rev([𝒄], [𝒙])  =  hull{ 𝑥 ∈ [𝒙] \| log2(𝑥) ∈ [𝒄] }  =  { 2<sup>𝑐</sup> \| 𝑐 ∈ [𝒄] } ∩ [𝒙]  ⊆  ℝ₊
+ *
+ * Reverse function: {log2}
+ * @overload log2_rev(c, x = ALL_REALS)
+ */
+static VALUE p1788_log2_rev(int argc, VALUE *argv, VALUE self)
+{
+	VALUE rbc, rbx, rbr;
+	rb_scan_args(argc, argv, "11", &rbc, &rbx);
+	InfSupDouble  r = InfSupDouble::exp2(p1788_rbobj2infsupdouble(rbc));
+	if (rbx != Qnil)
+		r = InfSupDouble::intersection(r, p1788_rbobj2infsupdouble(rbx));
+	P1788_NEW_RB_INTERVAL(rbr, r);
+	return rbr;
+}
+
+
+/* Base 10 logarithm of _x_
+ *
+ * log10([𝒙])  =  hull{ ln(𝑥)/ln(10) \| 𝑥 ∈ [𝒙]∩ℝ₊ }  ⊆  ℝ
+ *
+ * Reverse function: {log10_rev}
+ */
+static VALUE p1788_log10(VALUE self, VALUE x)
+{
+	VALUE r;
+	P1788_NEW_RB_INTERVAL(r, InfSupDouble::log10(p1788_rbobj2infsupdouble(x)));
+	return r;
+}
+
+
+/* Reverse base 10 logarithm
+ *
+ * log10_rev([𝒄], [𝒙])  =  hull{ 𝑥 ∈ [𝒙] \| log10(𝑥) ∈ [𝒄] }  =  { 10<sup>𝑐</sup> \| 𝑐 ∈ [𝒄] } ∩ [𝒙]  ⊆  ℝ₊
+ *
+ * Reverse function: {log10}
+ * @overload log10_rev(c, x = ALL_REALS)
+ */
+static VALUE p1788_log10_rev(int argc, VALUE *argv, VALUE self)
+{
+	VALUE rbc, rbx, rbr;
+	rb_scan_args(argc, argv, "11", &rbc, &rbx);
+	InfSupDouble  r = InfSupDouble::exp10(p1788_rbobj2infsupdouble(rbc));
+	if (rbx != Qnil)
+		r = InfSupDouble::intersection(r, p1788_rbobj2infsupdouble(rbx));
+	P1788_NEW_RB_INTERVAL(rbr, r);
+	return rbr;
+}
+
+
+/* Sine of _x_ in radians.
+ *
+ * sin([𝒙])  =  hull{ sin(𝑥) \| 𝑥 ∈ [𝒙] }  ⊆  [-1, 1]
+ *
+ * Reverse function: {sin_rev}
+ */
+static VALUE p1788_sin(VALUE self, VALUE x)
+{
+	VALUE r;
+	P1788_NEW_RB_INTERVAL(r, InfSupDouble::sin(p1788_rbobj2infsupdouble(x)));
+	return r;
+}
+
+
+/* Cosine of _x_ in radians.
+ *
+ * cos([𝒙])  =  hull{ cos(𝑥) \| 𝑥 ∈ [𝒙] }  ⊆  [-1, 1]
+ *
+ * Reverse function: {cos_rev}
+ */
+static VALUE p1788_cos(VALUE self, VALUE x)
+{
+	VALUE r;
+	P1788_NEW_RB_INTERVAL(r, InfSupDouble::cos(p1788_rbobj2infsupdouble(x)));
+	return r;
+}
+
+
+/* Tangent of _x_ in radians.
+ *
+ * tan([𝒙])  =  hull{ tan(𝑥) \| 𝑥 ∈ [𝒙] }  ⊆  ℝ
+ *
+ * Reverse function: {tan_rev}
+ */
+static VALUE p1788_tan(VALUE self, VALUE x)
+{
+	VALUE r;
+	P1788_NEW_RB_INTERVAL(r, InfSupDouble::tan(p1788_rbobj2infsupdouble(x)));
+	return r;
+}
+
+
+/* Arc sine of _x_, in radians.
+ *
+ * asin([𝒙])  =  hull{ asin(𝑥) \| 𝑥 ∈ [𝒙]∩[-1, 1] }  ⊆  [-𝛑/2, 𝛑/2]
+ *
+ * Reverse function: {asin_rev}
+ */
+static VALUE p1788_asin(VALUE self, VALUE x)
+{
+	VALUE r;
+	P1788_NEW_RB_INTERVAL(r, InfSupDouble::asin(p1788_rbobj2infsupdouble(x)));
+	return r;
+}
+
+
+/* Reverse arc sine
+ *
+ * asin_rev([𝒄], [𝒙])  =  hull{ 𝑥 ∈ [𝒙] \| asin(𝑥) ∈ [𝒄] }  =  { sin(𝑐) \| 𝑐 ∈ [𝒄]∩[-𝛑/2, 𝛑/2] } ∩ [𝒙]  ⊆  [-1, 1]
+ *
+ * Reverse function: {asin}
+ * @overload asin_rev(c, x = ALL_REALS)
+ */
+static VALUE p1788_asin_rev(int argc, VALUE *argv, VALUE self)
+{
+	VALUE rbc, rbx, rbr;
+	rb_scan_args(argc, argv, "11", &rbc, &rbx);
+	InfSupDouble  r = InfSupDouble::sin(InfSupDouble::intersection(p1788_rbobj2infsupdouble(rbc), minus_hpi_hpi_set));
+	if (rbx != Qnil)
+		r = InfSupDouble::intersection(r, p1788_rbobj2infsupdouble(rbx));
+	P1788_NEW_RB_INTERVAL(rbr, r);
+	return rbr;
+}
+
+
+/* Arc cosine of _x_, in radians.
+ *
+ * acos([𝒙])  =  hull{ acos(𝑥) \| 𝑥 ∈ [𝒙]∩[-1, 1] }  ⊆  [0, 𝛑]
+ *
+ * Reverse function: {acos_rev}
+ */
+static VALUE p1788_acos(VALUE self, VALUE x)
+{
+	VALUE r;
+	P1788_NEW_RB_INTERVAL(r, InfSupDouble::acos(p1788_rbobj2infsupdouble(x)));
+	return r;
+}
+
+
+/* Reverse arc cosine
+ *
+ * acos_rev([𝒄], [𝒙])  =  hull{ 𝑥 ∈ [𝒙] \| acos(𝑥) ∈ [𝒄] }  =  { cos(𝑐) \| 𝑐 ∈ [𝒄]∩[0, 𝛑] } ∩ [𝒙]  ⊆  [-1, 1]
+ *
+ * Reverse function: {cos}
+ * @overload acos_rev(c, x = ALL_REALS)
+ */
+static VALUE p1788_acos_rev(int argc, VALUE *argv, VALUE self)
+{
+	VALUE rbc, rbx, rbr;
+	rb_scan_args(argc, argv, "11", &rbc, &rbx);
+	InfSupDouble  r = InfSupDouble::cos(InfSupDouble::intersection(p1788_rbobj2infsupdouble(rbc), zero_pi_set));
+	if (rbx != Qnil)
+		r = InfSupDouble::intersection(r, p1788_rbobj2infsupdouble(rbx));
+	P1788_NEW_RB_INTERVAL(rbr, r);
+	return rbr;
+}
+
+
+/* Arc tangent of _x_.
+ *
+ * atan([𝒙])  =  hull{ atan(𝑥) \| 𝑥 ∈ [𝒙] }  ⊆  [-𝛑/2, 𝛑/2] 
+ *
+ * Reverse function: {atan_rev}
+ */
+static VALUE p1788_atan(VALUE self, VALUE x)
+{
+	VALUE r;
+	P1788_NEW_RB_INTERVAL(r, InfSupDouble::atan(p1788_rbobj2infsupdouble(x)));
+	return r;
+}
+
+
+/* Reverse arc tangent
+ *
+ * atan_rev([𝒄], [𝒙])  =  hull{ 𝑥 ∈ [𝒙] \| atan(𝑥) ∈ [𝒄] }  =  { tan(𝑐) \| 𝑐 ∈ [𝒄]∩[-𝛑/2, 𝛑/2] } ∩ [𝒙]  ⊆  ℝ
+ *
+ * Reverse function: {tan}
+ * @overload atan_rev(c, x = ALL_REALS)
+ */
+static VALUE p1788_atan_rev(int argc, VALUE *argv, VALUE self)
+{
+	VALUE rbc, rbx, rbr;
+	rb_scan_args(argc, argv, "11", &rbc, &rbx);
+	InfSupDouble  r = InfSupDouble::tan(InfSupDouble::intersection(p1788_rbobj2infsupdouble(rbc), minus_hpi_hpi_set));
+	if (rbx != Qnil)
+		r = InfSupDouble::intersection(r, p1788_rbobj2infsupdouble(rbx));
+	P1788_NEW_RB_INTERVAL(rbr, r);
+	return rbr;
+}
+
+
+/* Principal value of the arc tangent of _y_/_x_
+ *
+ * atan2([𝒚], [𝒙])  =  hull{ atan2(𝑦, 𝑥) \| 𝑥 ∈ [𝒙], 𝑦 ∈ [𝒚] }  ⊆  [-𝛑, 𝛑] 
+ *
+ * Reverse function: atan2_rev (not implemented yet)
+ */
+static VALUE p1788_atan2(VALUE self, VALUE y, VALUE x)
+{
+	VALUE r;
+	P1788_NEW_RB_INTERVAL(r, InfSupDouble::atan2(p1788_interval_rb2ref(y), p1788_interval_rb2ref(x)));
+	return r;
+}
+
+
+/* Hyperbolic sine of _x_.
+ *
+ * sinh([𝒙])  =  hull{ (𝑒<sup>𝑥</sup> - 𝑒<sup>-𝑥</sup>) / 2 \| 𝑥 ∈ [𝒙] }  ⊆  ℝ
+ *
+ * Reverse function: {sinh_rev}
+ */
+static VALUE p1788_sinh(VALUE self, VALUE x)
+{
+	VALUE r;
+	P1788_NEW_RB_INTERVAL(r, InfSupDouble::sinh(p1788_rbobj2infsupdouble(x)));
+	return r;
+}
+
+
+/* Reverse hyperbolic sine
+ *
+ * sinh_rev([𝒄], [𝒙])  =  hull{ 𝑥 ∈ [𝒙] \| sinh(𝑥) ∈ [𝒄] }  =  { asinh(𝑐) \| 𝑐 ∈ [𝒄] } ∩ [𝒙]  ⊆  ℝ
+ *
+ * Reverse function: {sinh}
+ * @overload sinh_rev(c, x = ALL_REALS)
+ */
+static VALUE p1788_sinh_rev(int argc, VALUE *argv, VALUE self)
+{
+	VALUE rbc, rbx, rbr;
+	rb_scan_args(argc, argv, "11", &rbc, &rbx);
+	InfSupDouble  r = InfSupDouble::asinh(p1788_rbobj2infsupdouble(rbc));
+	if (rbx != Qnil)
+		r = InfSupDouble::intersection(r, p1788_rbobj2infsupdouble(rbx));
+	P1788_NEW_RB_INTERVAL(rbr, r);
+	return rbr;
+}
+
+
+/* Hyperbolic cosine of _x_.
+ *
+ * cosh([𝒙])  =  hull{ (𝑒<sup>𝑥</sup> + 𝑒<sup>-𝑥</sup>) / 2 \| 𝑥 ∈ [𝒙] }  ⊆  [1, +∞]
+ *
+ * Reverse function: {cosh_rev}
+ */
+static VALUE p1788_cosh(VALUE self, VALUE x)
+{
+	VALUE r;
+	P1788_NEW_RB_INTERVAL(r, InfSupDouble::cosh(p1788_rbobj2infsupdouble(x)));
+	return r;
+}
+
+
+/* Hyperbolic tangent of _x_.
+ *
+ * tanh([𝒙])  =  hull{ sinh(𝑥) / cosh(𝑥) \| 𝑥 ∈ [𝒙] }  ⊆  [-1, 1]
+ *
+ * Reverse function: {tanh_rev}
+ */
+static VALUE p1788_tanh(VALUE self, VALUE x)
+{
+	VALUE r;
+	P1788_NEW_RB_INTERVAL(r, InfSupDouble::tanh(p1788_rbobj2infsupdouble(x)));
+	return r;
+}
+
+
+/* Reverse hyperbolic tangent
+ *
+ * tanh_rev([𝒄], [𝒙])  =  hull{ 𝑥 ∈ [𝒙] \| tanh(𝑥) ∈ [𝒄] }  =  { atanh(𝑐) \| 𝑐 ∈ [𝒄]∩[-1, 1] } ∩ [𝒙]  ⊆  ℝ
+ *
+ * Reverse function: {tanh}
+ * @overload tanh_rev(c, x = ALL_REALS)
+ */
+static VALUE p1788_tanh_rev(int argc, VALUE *argv, VALUE self)
+{
+	VALUE rbc, rbx, rbr;
+	rb_scan_args(argc, argv, "11", &rbc, &rbx);
+	InfSupDouble  r = InfSupDouble::atanh(p1788_rbobj2infsupdouble(rbc));
+	if (rbx != Qnil)
+		r = InfSupDouble::intersection(r, p1788_rbobj2infsupdouble(rbx));
+	P1788_NEW_RB_INTERVAL(rbr, r);
+	return rbr;
+}
+
+
+/* Inverse hyperbolic sine of _x_.
+ *
+ * asinh([𝒙])  =  hull{ asinh(𝑥) \| 𝑥 ∈ [𝒙] }  ⊆  ℝ
+ *
+ * Reverse function: {asinh_rev}
+ */
+static VALUE p1788_asinh(VALUE self, VALUE x)
+{
+	VALUE r;
+	P1788_NEW_RB_INTERVAL(r, InfSupDouble::asinh(p1788_rbobj2infsupdouble(x)));
+	return r;
+}
+
+
+/* Reverse inverse hyperbolic sine
+ *
+ * asinh_rev([𝒄], [𝒙])  =  hull{ 𝑥 ∈ [𝒙] \| asinh(𝑥) ∈ [𝒄] }  =  { sinh(𝑐) \| 𝑐 ∈ [𝒄] } ∩ [𝒙]  ⊆  ℝ
+ *
+ * Reverse function: {asinh}
+ * @overload tanh_rev(c, x = ALL_REALS)
+ */
+static VALUE p1788_asinh_rev(int argc, VALUE *argv, VALUE self)
+{
+	VALUE rbc, rbx, rbr;
+	rb_scan_args(argc, argv, "11", &rbc, &rbx);
+	InfSupDouble  r = InfSupDouble::sinh(p1788_rbobj2infsupdouble(rbc));
+	if (rbx != Qnil)
+		r = InfSupDouble::intersection(r, p1788_rbobj2infsupdouble(rbx));
+	P1788_NEW_RB_INTERVAL(rbr, r);
+	return rbr;
+}
+
+
+/* Inverse hyperbolic cosine of _x_.
+ *
+ * acosh([𝒙])  =  hull{ acosh(𝑥) \| 𝑥 ∈ [𝒙]∩[1,+∞] }  ⊆  ℝ₊
+ *
+ * Reverse function: {acosh_rev}
+ */
+static VALUE p1788_acosh(VALUE self, VALUE x)
+{
+	VALUE r;
+	P1788_NEW_RB_INTERVAL(r, InfSupDouble::acosh(p1788_rbobj2infsupdouble(x)));
+	return r;
+}
+
+
+/* Reverse inverse hyperbolic cosine
+ *
+ * acosh_rev([𝒄], [𝒙])  =  hull{ 𝑥 ∈ [𝒙] \| acosh(𝑥) ∈ [𝒄] }  =  { cosh(𝑐) \| 𝑐 ∈ [𝒄] ∩ ℝ₊ } ∩ [𝒙]  ⊆  [1, +∞]
+ *
+ * Reverse function: {acosh}
+ * @overload tanh_rev(c, x = ALL_REALS)
+ */
+static VALUE p1788_acosh_rev(int argc, VALUE *argv, VALUE self)
+{
+	VALUE rbc, rbx, rbr;
+	rb_scan_args(argc, argv, "11", &rbc, &rbx);
+	InfSupDouble  r = InfSupDouble::cosh(InfSupDouble::intersection(p1788_rbobj2infsupdouble(rbc), pos_reals_set));
+	if (rbx != Qnil)
+		r = InfSupDouble::intersection(r, p1788_rbobj2infsupdouble(rbx));
+	P1788_NEW_RB_INTERVAL(rbr, r);
+	return rbr;
+}
+
+
+/* Inverse hyperbolic tangent of _x_.
+ *
+ * atanh([𝒙])  =  hull{ atanh(𝑥) \| 𝑥 ∈ [𝒙]∩[-1,1] }  ⊆  ℝ
+ *
+ * Reverse function: {atanh_rev}
+ */
+static VALUE p1788_atanh(VALUE self, VALUE x)
+{
+	VALUE r;
+	P1788_NEW_RB_INTERVAL(r, InfSupDouble::atanh(p1788_rbobj2infsupdouble(x)));
+	return r;
+}
+
+
+/* Reverse inverse hyperbolic tangent
+ *
+ * atanh_rev([𝒄], [𝒙])  =  hull{ 𝑥 ∈ [𝒙] \| atanh(𝑥) ∈ [𝒄] }  =  { tanh(𝑐) \| 𝑐 ∈ [𝒄] } ∩ [𝒙]  ⊆  [-1, -1]
+ *
+ * Reverse function: {atanh}
+ * @overload tanh_rev(c, x = ALL_REALS)
+ */
+static VALUE p1788_atanh_rev(int argc, VALUE *argv, VALUE self)
+{
+	VALUE rbc, rbx, rbr;
+	rb_scan_args(argc, argv, "11", &rbc, &rbx);
+	InfSupDouble  r = InfSupDouble::tanh(p1788_rbobj2infsupdouble(rbc));
+	if (rbx != Qnil)
+		r = InfSupDouble::intersection(r, p1788_rbobj2infsupdouble(rbx));
+	P1788_NEW_RB_INTERVAL(rbr, r);
+	return rbr;
+}
+
+
+/* Sign of _x_
+ *
+ * sign([𝒙])  ⊆  [-1, 1]  (\\{-1} if <span style="text-decoration:overline">𝒙</span> < 0, \\{1} if <span style="text-decoration:underline">𝒙</span> > 0, \\{0} if [𝒙] = \\{0})
+ */
+static VALUE p1788_sign(VALUE self, VALUE x)
+{
+	VALUE r;
+	P1788_NEW_RB_INTERVAL(r, InfSupDouble::sign(p1788_rbobj2infsupdouble(x)));
+	return r;
+}
+
+
+/* Round _x_ towards +∞
+ * 
+ * ceil([𝒙])  =  [ceil(<span style="text-decoration:underline">𝒙</span>), ceil(<span style="text-decoration:overline">𝒙</span>)]
+ */
+static VALUE p1788_ceil(VALUE self, VALUE x)
+{
+	VALUE r;
+	P1788_NEW_RB_INTERVAL(r, InfSupDouble::ceil(p1788_rbobj2infsupdouble(x)));
+	return r;
+}
+
+
+/* Round _x_ towards -∞
+ *
+ * floor([𝒙])  =  [floor(<span style="text-decoration:underline">𝒙</span>), floor(<span style="text-decoration:overline">𝒙</span>)]
+ */
+static VALUE p1788_floor(VALUE self, VALUE x)
+{
+	VALUE r;
+	P1788_NEW_RB_INTERVAL(r, InfSupDouble::floor(p1788_rbobj2infsupdouble(x)));
+	return r;
+}
+
+
+/* Inflate _x_ towards nearest integer bounds
+ *
+ * floorceil([𝒙])  =  [floor(<span style="text-decoration:underline">𝒙</span>), ceil(<span style="text-decoration:overline">𝒙</span>)]
+ */
+static VALUE p1788_floorceil(VALUE self, VALUE x)
+{
+	InfSupDouble inter = p1788_rbobj2infsupdouble(x);
+	VALUE r;
+	P1788_NEW_RB_INTERVAL(r, InfSupDouble(std::floor(InfSupDouble::inf(inter)), std::ceil(InfSupDouble::sup(inter))));
+	return r;
+}
+
+
+/* Inflate _x_ towards nearest integer bounds
+ *
+ * floorceil(𝒙)  =  [floor(<span style="text-decoration:underline">𝒙</span>), ceil(<span style="text-decoration:overline">𝒙</span>)]
+ */
+static VALUE p1788_interval_floorceil(VALUE self, VALUE x)
+{
+	InfSupDouble inter = p1788_rbobj2infsupdouble(x);
+	VALUE r;
+	P1788_NEW_RB_INTERVAL(r, InfSupDouble(std::floor(InfSupDouble::inf(inter)), std::ceil(InfSupDouble::sup(inter))));
+	return r;
+}
+
+
+/* Round _x_ towards 0
+ *
+ * trunc([𝒙])  =  [trunc(<span style="text-decoration:underline">𝒙</span>), trunc(<span style="text-decoration:overline">𝒙</span>)]
+ */
+static VALUE p1788_trunc(VALUE self, VALUE x)
+{
+	VALUE r;
+	P1788_NEW_RB_INTERVAL(r, InfSupDouble::trunc(p1788_rbobj2infsupdouble(x)));
+	return r;
+}
+
+
+/* Round _x_, ties to even
+ *
+ * Round bounds to their nearest integer values, rounding halfway cases to nearest even.
+ *
+ * round_ties_to_even([𝒙])  =  [round_ties_to_even(<span style="text-decoration:underline">𝒙</span>), round_ties_to_even(<span style="text-decoration:overline">𝒙</span>)]
+ */
+static VALUE p1788_round_ties_to_even(VALUE self, VALUE x)
+{
+	VALUE r;
+	P1788_NEW_RB_INTERVAL(r, InfSupDouble::round_ties_to_even(p1788_rbobj2infsupdouble(x)));
+	return r;
+}
+
+
+/* Round _x_, ties to away from zero
+ *
+ * Round bounds to their nearest integer values, rounding halfway cases away from zero.
+ *
+ * round_ties_to_away([𝒙])  =  [round_ties_to_away(<span style="text-decoration:underline">𝒙</span>), round_ties_to_away(<span style="text-decoration:overline">𝒙</span>)]
+ */
+static VALUE p1788_round_ties_to_away(VALUE self, VALUE x)
+{
+	VALUE r;
+	P1788_NEW_RB_INTERVAL(r, InfSupDouble::round_ties_to_away(p1788_rbobj2infsupdouble(x)));
+	return r;
+}
+
+
+/* Absolute value of _x_
+ *
+ * abs([𝒙])  =  hull{ \|𝑥\| ￨ 𝑥 ∈ [𝒙] }  ⊆  ℝ₊
+ *
+ * Reverse function: {abs_rev}
+ */
+static VALUE p1788_abs(VALUE self, VALUE x)
+{
+	VALUE r;
+	P1788_NEW_RB_INTERVAL(r, InfSupDouble::abs(p1788_rbobj2infsupdouble(x)));
+	return r;
+}
+
+
+/* _+x_
+ * @return [Interval] `self`
+ */
+static VALUE p1788_pos(VALUE self, VALUE x)
+{
+	VALUE r;
+	P1788_NEW_RB_INTERVAL(r, InfSupDouble::pos(p1788_rbobj2infsupdouble(x)));
+	return r;
+}
+
+
+/* Arithmetic opposite
+ *
+ * neg([𝒙])  =  { -𝑥 ￨ 𝑥 ∈ [𝒙] }  =  [-<span style="text-decoration:overline">𝒙</span>, -<span style="text-decoration:underline">𝒙</span>]
+ *
+ * Reverse function: {neg_rev}
+ */
+static VALUE p1788_neg(VALUE self, VALUE x)
+{
+	VALUE r;
+	P1788_NEW_RB_INTERVAL(r, InfSupDouble::neg(p1788_rbobj2infsupdouble(x)));
+	return r;
+}
+
+
+/* Reverse opposite
+ *
+ * neg_rev([𝒄], [𝒙])  =  { 𝑥 ∈ [𝒙] \| -𝑥 ∈ [𝒄] }  =  { -𝑐 \| 𝑐 ∈ [𝒄] } ∩ [𝒙]
+ *
+ * Reverse function: {neg}
+ * @overload neg_rev(c, x = ALL_REALS)
+ */
+static VALUE p1788_neg_rev(int argc, VALUE *argv, VALUE self)
+{
+	VALUE rbc, rbx, rbr;
+	rb_scan_args(argc, argv, "11", &rbc, &rbx);
+	InfSupDouble  r = InfSupDouble::neg(p1788_rbobj2infsupdouble(rbc));
+	if (rbx != Qnil)
+		r = InfSupDouble::intersection(r, p1788_rbobj2infsupdouble(rbx));
+	P1788_NEW_RB_INTERVAL(rbr, r);
+	return rbr;
+}
+
+
+/* Arithmetic addition
+ *
+ * add([𝒙], [𝒚])  =  hull{ 𝑥 + 𝑦 \| 𝑥 ∈ [𝒙], 𝑦 ∈ [𝒚] }  ⊆  ℝ
+ *
+ * Reverse function: {add_rev}
+ */
+static VALUE p1788_add(VALUE self, VALUE x, VALUE y)
+{
+	VALUE r;
+	P1788_NEW_RB_INTERVAL(r, InfSupDouble::add(p1788_rbobj2infsupdouble(x), p1788_rbobj2infsupdouble(y)));
+	return r;
+}
+
+
+/* Reverse addition
+ *
+ * add_rev([𝒃], [𝒄], [𝒙])  =  { 𝑥 ∈ [𝒙] \| ∃ 𝑏 ∈ [𝒃] : 𝑥 + 𝑏 ∈ [𝒄] }  =  { 𝑐 - 𝑏 \| 𝑏 ∈ [𝒃], 𝑐 ∈ [𝒄] } ∩ [𝒙]
+ *
+ * Reverse function {add}
+ * @overload add_rev(b, c, x = ALL_REALS)
+ */
+static VALUE p1788_add_rev(int argc, VALUE *argv, VALUE self)
+{
+	VALUE rbb, rbc, rbx, rbr;
+	rb_scan_args(argc, argv, "21", &rbb, &rbc, &rbx);
+	InfSupDouble r = InfSupDouble::sub(p1788_rbobj2infsupdouble(rbc), p1788_rbobj2infsupdouble(rbb));
+	if (rbx != Qnil)
+		r = InfSupDouble::intersection(r, p1788_rbobj2infsupdouble(rbx));
+	P1788_NEW_RB_INTERVAL(rbr, r);
+	return rbr;
+}
+
+
+/* Arithmetic subtraction
+ *
+ * sub([𝒙], [𝒚])  =  hull{ 𝑥 - 𝑦 \| 𝑥 ∈ [𝒙], 𝑦 ∈ [𝒚] }  ⊆  ℝ
+ *
+ * Reverse function: {sub_rev}
+ */
+static VALUE p1788_sub(VALUE self, VALUE x, VALUE y)
+{
+	VALUE r;
+	P1788_NEW_RB_INTERVAL(r, InfSupDouble::sub(p1788_rbobj2infsupdouble(x), p1788_rbobj2infsupdouble(y)));
+	return r;
+}
+
+
+/* Reverse subtraction
+ *
+ * sub_rev([𝒃], [𝒄], [𝒙])  =  { 𝑥 ∈ [𝒙] \| ∃ 𝑏 ∈ [𝒃] : 𝑥 - 𝑏 ∈ [𝒄] }  =  { 𝑐 + 𝑏 \| 𝑏 ∈ [𝒃], 𝑐 ∈ [𝒄] } ∩ [𝒙]
+ *
+ * Reverse function {sub}
+ * @overload sub_rev(b, c, x = ALL_REALS)
+ */
+static VALUE p1788_sub_rev(int argc, VALUE *argv, VALUE self)
+{
+	VALUE rbb, rbc, rbx, rbr;
+	rb_scan_args(argc, argv, "21", &rbb, &rbc, &rbx);
+	InfSupDouble r = InfSupDouble::add(p1788_rbobj2infsupdouble(rbc), p1788_rbobj2infsupdouble(rbb));
+	if (rbx != Qnil)
+		r = InfSupDouble::intersection(r, p1788_rbobj2infsupdouble(rbx));
+	P1788_NEW_RB_INTERVAL(rbr, r);
+	return rbr;
+}
+
+
+/* Arithmetic multiplication
+ *
+ * mul([𝒙], [𝒚])  =  hull{ 𝑥⋅𝑦 \| 𝑥 ∈ [𝒙], 𝑦 ∈ [𝒚] }  ⊆  ℝ
+ *
+ * Reverse function: {mul_rev}
+ */
+static VALUE p1788_mul(VALUE self, VALUE x, VALUE y)
+{
+	VALUE r;
+	P1788_NEW_RB_INTERVAL(r, InfSupDouble::mul(p1788_rbobj2infsupdouble(x), p1788_rbobj2infsupdouble(y)));
+	return r;
+}
+
+
+/* Arithmetic division
+ *
+ * div([𝒙], [𝒚])  =  hull{ 𝑥/𝑦 \| 𝑥 ∈ [𝒙], 𝑦 ∈ [𝒚] }  ⊆  ℝ
+ *
+ * Reverse function: {div_rev}
+ */
+static VALUE p1788_div(VALUE self, VALUE x, VALUE y)
+{
+	VALUE r;
+	P1788_NEW_RB_INTERVAL(r, InfSupDouble::div(p1788_rbobj2infsupdouble(x), p1788_rbobj2infsupdouble(y)));
+	return r;
+}
+
+
+/* Reverse division
+ *
+ * div_rev([𝒃], [𝒄], [𝒙])  =  { 𝑥 ∈ [𝒙] \| ∃ 𝑏 ∈ [𝒃] : 𝑥/𝑏 ∈ [𝒄] }  =  { 𝑐⋅𝑏 \| 𝑏 ∈ [𝒃], 𝑐 ∈ [𝒄] } ∩ [𝒙]
+ *
+ * Reverse function {div}
+ * @overload div_rev(b, c, x = ALL_REALS)
+ */
+static VALUE p1788_div_rev(int argc, VALUE *argv, VALUE self)
+{
+	VALUE rbb, rbc, rbx, rbr;
+	rb_scan_args(argc, argv, "21", &rbb, &rbc, &rbx);
+	InfSupDouble r = InfSupDouble::mul(p1788_rbobj2infsupdouble(rbc), p1788_rbobj2infsupdouble(rbb));
+	if (rbx != Qnil)
+		r = InfSupDouble::intersection(r, p1788_rbobj2infsupdouble(rbx));
+	P1788_NEW_RB_INTERVAL(rbr, r);
+	return rbr;
+}
+
+
+/* Two-output division
+ *
+ * Returns a pair of intervals, 𝒙 / (𝒚 ∩ ℝ₋) and 𝒙 / (𝒚 ∩ ℝ₊)
+ * @param x [Interval] dividend
+ * @param y [Interval] divisor
+ * @return [Array<Interval>] [∅, ∅] if 𝒙/𝒚 is empty, [[𝒙/𝒚], ∅] if 𝒙/𝒚 has one component, [[𝒙/𝒚]₁, [𝒙/𝒚]₂] if 𝒙/𝒚 has two components
+ */
+static VALUE p1788_div_to_pair(VALUE self, VALUE x, VALUE y)
+{
+	VALUE r1, r2;
+	std::pair< InfSupDouble, InfSupDouble > p = InfSupDouble::mul_rev_to_pair(p1788_rbobj2infsupdouble(y), p1788_rbobj2infsupdouble(x));
+	P1788_NEW_RB_INTERVAL(r1, p.first);
+	P1788_NEW_RB_INTERVAL(r2, p.second);
+	return rb_ary_new_from_args(2, r1, r2);
+}
+
+
+/* Power function
+ *
+ * pow([𝒙], [𝒚])  =  hull{ 𝑥<sup>𝑦</sup> \| (𝑥, 𝑦) ∈ \\{𝑥 ∈ [𝒙], 𝑦 ∈ [𝒚] \| 𝑥>0\} ∪ \\{𝑥=0, 𝑦 ∈ [𝒚] \| 𝑦>0\} }  ⊆  ℝ₊
+ *
+ * Reverse functions: {pow_rev1} and {pow_rev2}
+ */
+static VALUE p1788_pow(VALUE self, VALUE x, VALUE y)
+{
+	VALUE r;
+	P1788_NEW_RB_INTERVAL(r, InfSupDouble::pow(p1788_rbobj2infsupdouble(x), p1788_rbobj2infsupdouble(y)));
+	return r;
+}
+
+
+/* Power with integer exponent
+ * 
+ * pow([𝒃], n)  =  hull{ 𝑏ⁿ \| 𝑏 ∈ [𝒃] }  ⊆  ℝ if n odd, ℝ₊ if n even, \\{1\} if n = 0
+ *
+ * Reverse function {pown_rev}
+ * @param b [Interval] base
+ * @param n [Integer] integer exponent
+ */
+static VALUE p1788_pown(VALUE self, VALUE b, VALUE n)
+{
+	VALUE r;
+	int p;
+	if (!RB_TYPE_P(n, T_FIXNUM))
+		rb_raise(rb_eTypeError, "expecting an integer (Fixnum) as exponent, not a %" PRIsVALUE, rb_class_name(rb_class_of(n)));
+	p = NUM2INT(n);
+	P1788_NEW_RB_INTERVAL(r, InfSupDouble::pown(p1788_rbobj2infsupdouble(b), p));
+	return r;
+}
+
+
+/* Minimum of two or more intervals
+ *
+ * min([𝒂], [𝒃])  =  [min(<span style="text-decoration:underline">𝒂</span>, <span style="text-decoration:underline">𝒃</span>), min(<span style="text-decoration:overline">𝒂</span>, <span style="text-decoration:overline">𝒃</span>)]
+ * @overload min(a, b, ...)
+ */
+static VALUE p1788_min(int argc, VALUE *argv, VALUE self)
+{
+	if (argc < 2)
+		rb_raise(rb_eArgError, "expecting at leas 2 arguments, not %d", argc);
+	InfSupDouble m = InfSupDouble::min(p1788_rbobj2infsupdouble(argv[0]), p1788_rbobj2infsupdouble(argv[1]));
+	for (int i = 2; i < argc; i++)
+		m = InfSupDouble::min(m, p1788_rbobj2infsupdouble(argv[i]));
+	VALUE r;
+	P1788_NEW_RB_INTERVAL(r, m);
+	return r;
+}
+
+
+/* Maximum of two or more intervals
+ *
+ * max([𝒂], [𝒃])  =  [max(<span style="text-decoration:underline">𝒂</span>, <span style="text-decoration:underline">𝒃</span>), max(<span style="text-decoration:overline">𝒂</span>, <span style="text-decoration:overline">𝒃</span>)]
+ * @overload max(a, b, ...)
+ */
+static VALUE p1788_max(int argc, VALUE *argv, VALUE self)
+{
+	if (argc < 2)
+		rb_raise(rb_eArgError, "expecting at leas 2 arguments, not %d", argc);
+	InfSupDouble m = InfSupDouble::max(p1788_rbobj2infsupdouble(argv[0]), p1788_rbobj2infsupdouble(argv[1]));
+	for (int i = 2; i < argc; i++)
+		m = InfSupDouble::max(m, p1788_rbobj2infsupdouble(argv[i]));
+	VALUE r;
+	P1788_NEW_RB_INTERVAL(r, m);
+	return r;
+}
+
+
+/* Cancellative subtraction
+ *
+ * Cancellative subtraction solves the following problem: Recover interval [𝒛] from intervals [𝒙] and [𝒚], given that [𝒙] = [𝒚] + [𝒛].
+ * 
+ * For any two bounded intervals [𝒙] and [𝒚], cancel_minus([𝒙], [𝒚]) is the tightest interval [𝒛] such that [𝒚] + [𝒛] ⊇ [𝒙].
+ */
+static VALUE p1788_cancel_minus(VALUE self, VALUE x, VALUE y)
+{
+	VALUE r;
+	P1788_NEW_RB_INTERVAL(r, InfSupDouble::cancel_minus(p1788_rbobj2infsupdouble(x), p1788_rbobj2infsupdouble(y)));
+	return r;
+}
+
+
+/* Cancellative addition
+ *
+ * cancel_plux([𝒙], [𝒚]) = cancel_minus([𝒙], -[𝒚])
+ * @see cancel_minus
+ */
+static VALUE p1788_cancel_plus(VALUE self, VALUE x, VALUE y)
+{
+	VALUE r;
+	P1788_NEW_RB_INTERVAL(r, InfSupDouble::cancel_plus(p1788_rbobj2infsupdouble(x), p1788_rbobj2infsupdouble(y)));
+	return r;
+}
+
+
+/* Fused multiply add
+ *
+ *fma([𝒙], [𝒚], [𝒛])  =  hull{ 𝑥⋅𝑦 + 𝑧 \| 𝑥 ∈ [𝒙], 𝑦 ∈ [𝒚], 𝑧 ∈ [𝒛] }  ⊆  ℝ
+ */
+static VALUE p1788_fma(VALUE self, VALUE x, VALUE y, VALUE z)
+{
+	VALUE r;
+	P1788_NEW_RB_INTERVAL(
+			r,
+			InfSupDouble::fma(
+				p1788_rbobj2infsupdouble(x),
+				p1788_rbobj2infsupdouble(y),
+				p1788_rbobj2infsupdouble(z)
+			)
+	);
+	return r;
+}
+
+
+/* Two-output division
+ *
+ * [𝒄]/[𝒃] = { 𝑥 ∈ ℝ \| ∃ 𝑏 ∈ [𝒃] : 𝑥⋅𝑏 ∈ [𝒄] }
+ * @return [Array<Interval>] a two elements array of intervals: [∅, ∅] if 𝒄/𝒃 is empty, [[𝒄/𝒃], ∅] if 𝒄/𝒃 has one component, [[𝒄/𝒃]₁, [𝒄/𝒃]₂] if 𝒄/𝒃 has two components
+ */
+static VALUE p1788_mul_rev_to_pair(VALUE self, VALUE b, VALUE c)
+{
+	VALUE r1, r2;
+	std::pair< InfSupDouble, InfSupDouble > p = InfSupDouble::mul_rev_to_pair(p1788_rbobj2infsupdouble(b), p1788_rbobj2infsupdouble(c));
+	P1788_NEW_RB_INTERVAL(r1, p.first);
+	P1788_NEW_RB_INTERVAL(r2, p.second);
+	return rb_ary_new_from_args(2, r1, r2);
+}
+
+
+/* Reverse multiplication
+ *
+ * mul_rev([𝒃], [𝒄], [𝒙])  =  hull{ 𝑥 ∈ [𝒙] \| ∃ 𝑏 ∈ [𝒃] : 𝑥⋅𝑏 ∈ [𝒄] }  ⊆  ℝ
+ *
+ * Reverse function {mul}
+ * @overload mul_rev(b, c, x = ALL_REALS)
+ */
+static VALUE p1788_mul_rev(int argc, VALUE *argv, VALUE self)
+{
+	VALUE b, c, x, r;
+	rb_scan_args(argc, argv, "21", &b, &c, &x);
+	if (x == Qnil) {
+		P1788_NEW_RB_INTERVAL(r, InfSupDouble::mul_rev(p1788_rbobj2infsupdouble(b), p1788_rbobj2infsupdouble(c)));
+	}
+	else {
+		P1788_NEW_RB_INTERVAL(r, InfSupDouble::mul_rev(p1788_rbobj2infsupdouble(b), p1788_rbobj2infsupdouble(c), p1788_rbobj2infsupdouble(x)));
+	}
+	return r;
+}
+
+
+/* Reverse square
+ *
+ * sqr_rev([𝒄], [𝒙])  =  hull{ 𝑥 ∈ [𝒙] \| 𝑥² ∈ [𝒄] }  ⊆  ℝ
+ *
+ * Reverse function: {sqr}
+ * @overload sqr_rev(c, x = ALL_REALS)
+ */
+static VALUE p1788_sqr_rev(int argc, VALUE *argv, VALUE self)
+{
+	VALUE x, c, r;
+	rb_scan_args(argc, argv, "11", &c, &x);
+	if (x == Qnil) {
+		P1788_NEW_RB_INTERVAL(r, InfSupDouble::sqr_rev(p1788_rbobj2infsupdouble(c)));
+	}
+	else {
+		P1788_NEW_RB_INTERVAL(r, InfSupDouble::sqr_rev(p1788_rbobj2infsupdouble(c), p1788_rbobj2infsupdouble(x)));
+	}
+	return r;
+}
+
+
+/* Reverse absolute value.
+ *
+ * abs_rev([𝒄], [𝒙])  =  hull{ 𝑥 ∈ [𝒙] ￨ \|𝑥\| ∈ [𝒄] }  ⊆  ℝ
+ *
+ * Reverse function: {abs}
+ * @overload abs_rev(c, x = ALL_REALS)
+ */
+static VALUE p1788_abs_rev(int argc, VALUE *argv, VALUE self)
+{
+	VALUE x, c, r;
+	rb_scan_args(argc, argv, "11", &c, &x);
+	if (x == Qnil) {
+		P1788_NEW_RB_INTERVAL(r, InfSupDouble::abs_rev(p1788_rbobj2infsupdouble(c)));
+	}
+	else {
+		P1788_NEW_RB_INTERVAL(r, InfSupDouble::abs_rev(p1788_rbobj2infsupdouble(c), p1788_rbobj2infsupdouble(x)));
+	}
+	return r;
+}
+
+
+/* Reverse power with integer exponent
+ *
+ * pown_rev(𝑛, [𝒄], [𝒙])  =  hull{ 𝑥 ∈ [𝒙] \| 𝑥ⁿ ∈ [𝒄] }  ⊆  ℝ
+ *
+ * Reverse function: {pown}
+ * @overload pown_rev(n, c, x = ALL_REALS)
+ *  @param n [Integer] integer exponent
+ *  @param c [Interval]
+ *  @param x [Interval]
+ */
+static VALUE p1788_pown_rev(int argc, VALUE *argv, VALUE self)
+{
+	VALUE x, c, r, n;
+	int p;
+	rb_scan_args(argc, argv, "21", &n, &c, &x);
+	if (!RB_TYPE_P(n, T_FIXNUM))
+		rb_raise(rb_eTypeError, "expecting an integer (Fixnum) as exponent, not a %" PRIsVALUE, rb_class_name(rb_class_of(n)));
+	p = NUM2INT(n);
+	if (x == Qnil) {
+		P1788_NEW_RB_INTERVAL(r, InfSupDouble::pown_rev(p1788_rbobj2infsupdouble(c), p));
+	}
+	else {
+		P1788_NEW_RB_INTERVAL(r, InfSupDouble::pown_rev(p1788_rbobj2infsupdouble(c), p1788_rbobj2infsupdouble(x), p));
+	}
+	return r;
+}
+
+
+/* Reverse power function (base)
+ *
+ * pow_rev1([𝒃], [𝒄], [𝒙])  =  hull{ 𝑥 ∈ [𝒙] \|  ∃ 𝑏 ∈ [𝒃] : 𝑥<sup>𝑏</sup> ∈ [𝒄] }  ⊆  ℝ₊
+ *
+ * Reverse function: {pow}
+ * @overload pow_rev1(b, c, x = ALL_REALS)
+ */
+static VALUE p1788_pow_rev1(int argc, VALUE *argv, VALUE self)
+{
+	VALUE rbb, rbc, rbx, rbr;
+	rb_scan_args(argc, argv, "21", &rbb, &rbc, &rbx);
+	InfSupDouble b = p1788_rbobj2infsupdouble(rbb);
+	InfSupDouble c = p1788_rbobj2infsupdouble(rbc);
+	InfSupDouble x = (rbx == Qnil) ? InfSupDouble(-INF, INF) : p1788_rbobj2infsupdouble(rbx);
+
+	InfSupDouble lnx = InfSupDouble::log(x);
+	InfSupDouble m   = InfSupDouble::intersection(InfSupDouble::log(c), InfSupDouble::mul(b, lnx));
+	InfSupDouble l   = InfSupDouble::mul_rev(b, m, lnx);
+	InfSupDouble r   = InfSupDouble::intersection(InfSupDouble::exp(l), x);
+
+	P1788_NEW_RB_INTERVAL(rbr, r);
+	return rbr;
+}
+
+
+/* Reverse power function (exponent)
+ *
+ * pow_rev2([𝒂], [𝒄], [𝒙])  =  hull{ 𝑥 ∈ [𝒙] \|  ∃ 𝑎 ∈ [𝒂] : 𝑎<sup>𝑥</sup> ∈ [𝒄] }  ⊆  ℝ
+ *
+ * Reverse function: {pow}
+ * @overload pow_rev2(a, c, x = ALL_REALS)
+ */
+static VALUE p1788_pow_rev2(int argc, VALUE *argv, VALUE self)
+{
+	VALUE rba, rbc, rbx, rbr;
+	rb_scan_args(argc, argv, "21", &rba, &rbc, &rbx);
+	InfSupDouble a = p1788_rbobj2infsupdouble(rba);
+	InfSupDouble c = p1788_rbobj2infsupdouble(rbc);
+	InfSupDouble x = (rbx == Qnil) ? InfSupDouble(-INF, INF) : p1788_rbobj2infsupdouble(rbx);
+
+	InfSupDouble lna = InfSupDouble::log(a);
+	InfSupDouble m   = InfSupDouble::intersection(InfSupDouble::log(c), InfSupDouble::mul(x, lna));
+	InfSupDouble r   = InfSupDouble::mul_rev(lna, m, x);
+
+	P1788_NEW_RB_INTERVAL(rbr, r);
+	return rbr;
+}
+
+
+/* Reverse sine
+ *
+ * sin_rev([𝒄], [𝒙])  =  hull{ 𝑥 ∈ [𝒙] \| sin(𝑥) ∈ [𝒄] }  ⊆  ℝ
+ *
+ * Reverse function: {sin}
+ * @overload sin_rev(c, x = ALL_REALS)
+ */
+static VALUE p1788_sin_rev(int argc, VALUE *argv, VALUE self)
+{
+	VALUE x, c, r;
+	rb_scan_args(argc, argv, "11", &c, &x);
+	if (x == Qnil) {
+		P1788_NEW_RB_INTERVAL(r, InfSupDouble::sin_rev(p1788_rbobj2infsupdouble(c)));
+	}
+	else {
+		P1788_NEW_RB_INTERVAL(r, InfSupDouble::sin_rev(p1788_rbobj2infsupdouble(c), p1788_rbobj2infsupdouble(x)));
+	}
+	return r;
+}
+
+
+/* Reverse cosine
+ *
+ * cos_rev([𝒄], [𝒙])  =  hull{ 𝑥 ∈ [𝒙] \| cos(𝑥) ∈ [𝒄] }  ⊆  ℝ
+ *
+ * Reverse function: {cos}
+ * @overload cos_rev(c, x = ALL_REALS)
+ */
+static VALUE p1788_cos_rev(int argc, VALUE *argv, VALUE self)
+{
+	VALUE x, c, r;
+	rb_scan_args(argc, argv, "11", &c, &x);
+	if (x == Qnil) {
+		P1788_NEW_RB_INTERVAL(r, InfSupDouble::cos_rev(p1788_rbobj2infsupdouble(c)));
+	}
+	else {
+		P1788_NEW_RB_INTERVAL(r, InfSupDouble::cos_rev(p1788_rbobj2infsupdouble(c), p1788_rbobj2infsupdouble(x)));
+	}
+	return r;
+}
+
+
+/* Reverse tangent
+ *
+ * tan_rev([𝒄], [𝒙])  =  hull{ 𝑥 ∈ [𝒙] \| tan(𝑥) ∈ [𝒄] }  ⊆  ℝ
+ *
+ * Reverse function: {tan}
+ * @overload tan_rev(c, x = ALL_REALS)
+ */
+static VALUE p1788_tan_rev(int argc, VALUE *argv, VALUE self)
+{
+	VALUE x, c, r;
+	rb_scan_args(argc, argv, "11", &c, &x);
+	if (x == Qnil) {
+		P1788_NEW_RB_INTERVAL(r, InfSupDouble::tan_rev(p1788_rbobj2infsupdouble(c)));
+	}
+	else {
+		P1788_NEW_RB_INTERVAL(r, InfSupDouble::tan_rev(p1788_rbobj2infsupdouble(c), p1788_rbobj2infsupdouble(x)));
+	}
+	return r;
+}
+
+
+/* Reverse hyperbolic cosine
+ *
+ * cosh_rev([𝒄], [𝒙])  =  hull{ 𝑥 ∈ [𝒙] \| cosh(𝑥) ∈ [𝒄] }  ⊆  ℝ
+ * 
+ * Reverse function: {cosh}
+ * @overload cosh_rev(c, x = ALL_REALS)
+ */
+static VALUE p1788_cosh_rev(int argc, VALUE *argv, VALUE self)
+{
+	VALUE x, c, r;
+	rb_scan_args(argc, argv, "11", &c, &x);
+	if (x == Qnil) {
+		P1788_NEW_RB_INTERVAL(r, InfSupDouble::cosh_rev(p1788_rbobj2infsupdouble(c)));
+	}
+	else {
+		P1788_NEW_RB_INTERVAL(r, InfSupDouble::cosh_rev(p1788_rbobj2infsupdouble(c), p1788_rbobj2infsupdouble(x)));
+	}
+	return r;
+}
+ 
+
+/* Intersection
+ *
+ * intersection([𝒙], [𝒚])  =  [𝒙] ∩ [𝒚]
+ */
+static VALUE p1788_intersection(VALUE self, VALUE x, VALUE y)
+{
+	VALUE r;
+	P1788_NEW_RB_INTERVAL(r, InfSupDouble::intersection(p1788_rbobj2infsupdouble(x), p1788_rbobj2infsupdouble(y)));
+	return r;
+}
+
+
+/* Interval hull of the union of _x_ and _y_
+ *
+ * convex_hull([𝒙], [𝒚])  =  hull( [𝒙] ∪ [𝒚] )
+ */
+static VALUE p1788_convex_hull(VALUE self, VALUE x, VALUE y)
+{
+	VALUE r;
+	P1788_NEW_RB_INTERVAL(r, InfSupDouble::convex_hull(p1788_rbobj2infsupdouble(x), p1788_rbobj2infsupdouble(y)));
+	return r;
+}
+
+
+static void print_inspect_obj(VALUE obj)
+{
+	VALUE str = rb_funcallv(obj, rb_intern("inspect"), 0, NULL);
+	printf("%s\n", StringValueCStr(str));
+}
+
+
+static VALUE my_test_proc_func(VALUE yielded_arg, VALUE callback_arg, int argc, const VALUE *argv, VALUE blockarg)
+{
+	printf("----------------------------------------------------\n");
+	printf("yielded_arg = "); print_inspect_obj(yielded_arg);
+	printf("callback_arg = "); print_inspect_obj(callback_arg);
+	printf("argc = %d\n", argc);
+	for (int i = 0; i < argc; i++) {
+		printf("argv[%d] = ", i);
+		print_inspect_obj(argv[i]);
+	}
+	printf("blockarg = "); print_inspect_obj(blockarg);
+	printf("----------------------------------------------------\n");
+	return INT2NUM(sizeof(InfSupDouble));
+}
+
+
+/* @return [Proc]
+ */
+static VALUE p1788_test(int argc, VALUE *argv, VALUE self)
+{
+	VALUE rb_proc_new_arg = rb_sprintf("rb_proc_new_arg");
+	return rb_proc_new(my_test_proc_func, rb_proc_new_arg);
+//	return rb_block_call(rb_mKernel, rb_intern("lambda"), 0, NULL, my_test_proc_func, rb_proc_new_arg);
+}
+
+
+/* This function is the content of Init_p1788() moved out of the 'extern "C" {}'
+ * to allow yard to parse it.
+ */
+static inline void Init_p1788_func()
+{
+	id_to_s = rb_intern("to_s");
+
+	m_P1788 = rb_define_module("P1788");
+	c_Interval = rb_define_class_under(m_P1788, "Interval", rb_cObject);
+	rb_define_alloc_func(c_Interval, p1788_interval_alloc);
+	rb_undef_method(rb_class_of(c_Interval), "allocate");
+
+	rb_define_method(c_Interval, "initialize",         p1788_interval_initialize,          -1);
+	rb_define_method(c_Interval, "inspect",            p1788_interval_inspect,              0);
+	rb_define_method(c_Interval, "dup",                p1788_interval_dup,                  0);
+	rb_define_method(c_Interval, "clone",              p1788_interval_clone,                0);
+	rb_define_method(c_Interval, "to_a",               p1788_interval_to_a,                 0);
+	rb_define_method(c_Interval, "to_s",               p1788_interval_to_s,                 0);
+	rb_define_method(c_Interval, "to_latex",           p1788_interval_to_latex,            -1);
+	rb_define_method(c_Interval, "coerce",             p1788_interval_coerce,               1);
+	rb_define_method(c_Interval, "===",                p1788_interval_tripleequal,          1);
+
+	/* Boolean functions on intervals */
+	rb_define_method(c_Interval, "empty?",             p1788_interval_empty,                0);
+	rb_define_method(c_Interval, "entire?",            p1788_interval_entire,               0);
+	rb_define_alias(c_Interval,  "all_reals?", "entire?");
+	rb_define_method(c_Interval, "pos_reals?",         p1788_interval_pos_reals,            0);
+	rb_define_method(c_Interval, "neg_reals?",         p1788_interval_neg_reals,            0);
+	rb_define_method(c_Interval, "positive?",          p1788_interval_positive,             0);
+	rb_define_method(c_Interval, "strictly_positive?", p1788_interval_strictly_positive,    0);
+	rb_define_method(c_Interval, "negative?",          p1788_interval_negative,             0);
+	rb_define_method(c_Interval, "strictly_negative?", p1788_interval_strictly_negative,    0);
+	rb_define_method(c_Interval, "common?",            p1788_interval_common,               0);
+	rb_define_method(c_Interval, "finite?",            p1788_interval_finite,               0);
+	rb_define_method(c_Interval, "symmetric?",         p1788_interval_symmetric,            0);
+	rb_define_method(c_Interval, "singleton?",         p1788_interval_singleton,            0);
+	rb_define_method(c_Interval, "eql?",               p1788_interval_eql,                  1);
+	rb_define_method(c_Interval, "==",                 p1788_interval_equal,                1);
+	rb_define_method(c_Interval, "less?",              p1788_interval_less,                 1);
+	rb_define_method(c_Interval, "greater?",           p1788_interval_greater,              1);
+	rb_define_method(c_Interval, "strictly_less?",     p1788_interval_strictly_less,        1);
+	rb_define_method(c_Interval, "strictly_greater?",  p1788_interval_strictly_greater,     1);
+	rb_define_method(c_Interval, "precedes?",          p1788_interval_precedes,             1);
+	rb_define_method(c_Interval, "succeeds?",          p1788_interval_succeeds,             1);
+	rb_define_method(c_Interval, "strictly_precedes?", p1788_interval_strictly_precedes,    1);
+	rb_define_method(c_Interval, "strictly_succeeds?", p1788_interval_strictly_succeeds,    1);
+	rb_define_method(c_Interval, "disjoint_from?",     p1788_interval_disjoint,             1);
+	rb_define_method(c_Interval, "intersect?",         p1788_interval_intersect,            1);
+	rb_define_method(c_Interval, "strict_subset_of?",  p1788_interval_strict_subset,        1);
+	rb_define_method(c_Interval, "subset_of?",         p1788_interval_subset,               1);
+	rb_define_method(c_Interval, "strictly_contain?",  p1788_interval_strictly_contain,     1);
+	rb_define_method(c_Interval, "contain?",           p1788_interval_contain,              1);
+	rb_define_method(c_Interval, "include?",           p1788_interval_include,              1);
+
+	/* Numeric functions on intervals */
+	rb_define_method(c_Interval, "inf",        p1788_interval_inf,                  0);
+	rb_define_alias(c_Interval,  "lower_bound", "inf");
+	rb_define_method(c_Interval, "sup",        p1788_interval_sup,                  0);
+	rb_define_alias(c_Interval,  "upper_bound", "sup");
+	rb_define_method(c_Interval, "midpoint",           p1788_interval_mid,                  0);
+	rb_define_method(c_Interval, "splitpoint",         p1788_interval_splitpoint,           0);
+	rb_define_method(c_Interval, "radius",             p1788_interval_rad,                  0);
+	rb_define_method(c_Interval, "mid_rad",            p1788_interval_mid_rad,              0);
+	rb_define_method(c_Interval, "width",              p1788_interval_wid,                  0);
+	rb_define_method(c_Interval, "magnitude",          p1788_interval_mag,                  0);
+	rb_define_method(c_Interval, "mignitude",          p1788_interval_mig,                  0);
+
+	/* Set operations */
+	rb_define_method(c_Interval, "intersection",       p1788_interval_intersection,         1);
+	rb_define_alias(c_Interval,  "&", "intersection");
+	rb_define_method(c_Interval, "convex_hull",        p1788_interval_convex_hull,          1);
+	rb_define_alias(c_Interval,  "|", "convex_hull");
+	rb_define_method(c_Interval, "bisect",             p1788_interval_bisect,               0);
+	rb_define_alias(c_Interval,  "split", "bisect");
+
+	/* Forward elementary functions */
+	rb_define_method(c_Interval, "recip",              p1788_interval_recip,                0);
+	rb_define_method(c_Interval, "sqr",                p1788_interval_sqr,                  0);
+	rb_define_method(c_Interval, "sqrt",               p1788_interval_sqrt,                 0);
+	rb_define_method(c_Interval, "exp",                p1788_interval_exp,                  0);
+	rb_define_method(c_Interval, "exp2",               p1788_interval_exp2,                 0);
+	rb_define_method(c_Interval, "exp10",              p1788_interval_exp10,                0);
+	rb_define_method(c_Interval, "log",                p1788_interval_log,                  0);
+	rb_define_method(c_Interval, "log2",               p1788_interval_log2,                 0);
+	rb_define_method(c_Interval, "log10",              p1788_interval_log10,                0);
+	rb_define_method(c_Interval, "sin",                p1788_interval_sin,                  0);
+	rb_define_method(c_Interval, "cos",                p1788_interval_cos,                  0);
+	rb_define_method(c_Interval, "tan",                p1788_interval_tan,                  0);
+	rb_define_method(c_Interval, "asin",               p1788_interval_asin,                 0);
+	rb_define_method(c_Interval, "acos",               p1788_interval_acos,                 0);
+	rb_define_method(c_Interval, "atan",               p1788_interval_atan,                 0);
+	rb_define_method(c_Interval, "sinh",               p1788_interval_sinh,                 0);
+	rb_define_method(c_Interval, "cosh",               p1788_interval_cosh,                 0);
+	rb_define_method(c_Interval, "tanh",               p1788_interval_tanh,                 0);
+	rb_define_method(c_Interval, "asinh",              p1788_interval_asinh,                0);
+	rb_define_method(c_Interval, "acosh",              p1788_interval_acosh,                0);
+	rb_define_method(c_Interval, "atanh",              p1788_interval_atanh,                0);
+	rb_define_method(c_Interval, "sign",               p1788_interval_sign,                 0);
+	rb_define_method(c_Interval, "ceil",               p1788_interval_ceil,                 0);
+	rb_define_method(c_Interval, "floor",              p1788_interval_floor,                0);
+	rb_define_method(c_Interval, "floorceil",          p1788_interval_floorceil,            0);
+	rb_define_method(c_Interval, "truncate",           p1788_interval_trunc,                0);
+	rb_define_method(c_Interval, "round_ties_to_even", p1788_interval_round_ties_to_even,   0);
+	rb_define_method(c_Interval, "round_ties_to_away", p1788_interval_round_ties_to_away,   0);
+	rb_define_method(c_Interval, "abs",                p1788_interval_abs,                  0);
+	rb_define_method(c_Interval, "+@",                 p1788_interval_pos,                  0);
+	rb_define_method(c_Interval, "-@",                 p1788_interval_neg,                  0);
+	rb_define_method(c_Interval, "+",                  p1788_interval_add,                  1);
+	rb_define_method(c_Interval, "-",                  p1788_interval_sub,                  1);
+	rb_define_method(c_Interval, "*",                  p1788_interval_mul,                  1);
+	rb_define_method(c_Interval, "/",                  p1788_interval_div,                  1);
+	rb_define_method(c_Interval, "div_to_pair",        p1788_interval_div_to_pair,          1);
+	rb_define_method(c_Interval, "**",                 p1788_interval_powop,                1);
+	rb_define_method(c_Interval, "pow",                p1788_interval_pow,                  1);
+	rb_define_method(c_Interval, "pown",               p1788_interval_pown,                 1);
+	rb_define_method(c_Interval, "min",                p1788_interval_min,                  1);
+	rb_define_method(c_Interval, "max",                p1788_interval_max,                  1);
+	rb_define_method(c_Interval, "cancel_plus",        p1788_interval_cancel_plus,          1);
+	rb_define_method(c_Interval, "cancel_minus",       p1788_interval_cancel_minus,         1);
+	rb_define_method(c_Interval, "fma",                p1788_interval_fma,                  2);
+
+	/* reverse elementary functions */
+	rb_define_method(c_Interval, "mul_rev_to_pair",    p1788_interval_mul_rev_to_pair,      1);
+	rb_define_method(c_Interval, "mul_rev",            p1788_interval_mul_rev,             -1);
+	rb_define_method(c_Interval, "sqr_rev",            p1788_interval_sqr_rev,             -1);
+	rb_define_method(c_Interval, "abs_rev",            p1788_interval_abs_rev,             -1);
+	rb_define_method(c_Interval, "pown_rev",           p1788_interval_pown_rev,            -1);
+	rb_define_method(c_Interval, "pow_rev1",           p1788_interval_pow_rev1,            -1);
+	rb_define_method(c_Interval, "pow_rev2",           p1788_interval_pow_rev2,            -1);
+	rb_define_method(c_Interval, "sin_rev",            p1788_interval_sin_rev,             -1);
+	rb_define_method(c_Interval, "cos_rev",            p1788_interval_cos_rev,             -1);
+	rb_define_method(c_Interval, "tan_rev",            p1788_interval_tan_rev,             -1);
+	rb_define_method(c_Interval, "cosh_rev",           p1788_interval_cosh_rev,            -1);
+
+	rb_define_module_function(c_Interval, "[]",        p1788_interval_rb_new,              -1);
+
+	/* Constants */
+
+	VALUE empty_set;
+	P1788_NEW_RB_INTERVAL(empty_set, InfSupDouble());
+	/* ∅
+	 */
+	rb_define_const(c_Interval, "EMPTY_SET", empty_set);
+
+	VALUE all_reals;
+	P1788_NEW_RB_INTERVAL(all_reals, all_reals_set);
+	/* [-∞, ∞]
+	 */
+	rb_define_const(c_Interval, "ALL_REALS", all_reals);
+
+	VALUE pos_reals;
+	P1788_NEW_RB_INTERVAL(pos_reals, pos_reals_set);
+	/* [0, ∞]
+	 */
+	rb_define_const(c_Interval, "POS_REALS", pos_reals);
+
+	VALUE neg_reals;
+	P1788_NEW_RB_INTERVAL(neg_reals, neg_reals_set);
+	/* [-∞, 0]
+	 */
+	rb_define_const(c_Interval, "NEG_REALS", neg_reals);
+
+	VALUE pi;
+	P1788_NEW_RB_INTERVAL(pi, pi_set);
+	/* [↓𝛑↓, ↑𝛑↑]
+	 */
+	rb_define_const(c_Interval, "PI", pi);
+
+	VALUE hpi;
+	P1788_NEW_RB_INTERVAL(hpi, hpi_set);
+	/* [↓𝛑/2↓, ↑𝛑/2↑]
+	 */
+	rb_define_const(c_Interval, "HALF_PI", hpi);
+
+	VALUE pi2;
+	P1788_NEW_RB_INTERVAL(pi2, pi2_set);
+	/* [↓2𝛑↓, ↑2𝛑↑]
+	 */
+	rb_define_const(c_Interval, "TWO_PI", pi2);
+
+	VALUE minus_pi_pi;
+	P1788_NEW_RB_INTERVAL(minus_pi_pi, minus_pi_pi_set);
+	/* [↓-𝛑↓, ↑𝛑↑]
+	 */
+	rb_define_const(c_Interval, "MINUS_PI_PI", minus_pi_pi);
+
+	VALUE minus_hpi_hpi;
+	P1788_NEW_RB_INTERVAL(minus_hpi_hpi, minus_hpi_hpi_set);
+	/* [↓-𝛑/2↓, ↑𝛑/2↑]
+	 */
+	rb_define_const(c_Interval, "MINUS_HPI_HPI", minus_hpi_hpi);
+
+	VALUE minus_one_one;
+	P1788_NEW_RB_INTERVAL(minus_one_one, minus_one_one_set);
+	/* [-1, 1]
+	 */
+	rb_define_const(c_Interval, "MINUS_ONE_ONE", minus_one_one);
+
+	VALUE e;
+	P1788_NEW_RB_INTERVAL(e, e_set);
+	/* [↓𝑒↓, ↑𝑒↑]
+	 */
+	rb_define_const(c_Interval, "E", e);
+
+	VALUE libieeep1788_version = rb_sprintf(P1788_VERSION_STRING);
+	/* Version of libieeep1788
+	 * @return [String]
+	 */
+	rb_define_const(m_P1788, "LIBIEEEP1788_VERSION", libieeep1788_version);
+
+	/* Math module functions */
+	rb_define_module_function(m_P1788, "recip",              p1788_recip,              1);
+	rb_define_module_function(m_P1788, "sqr",                p1788_sqr,                1);
+	rb_define_module_function(m_P1788, "sqrt",               p1788_sqrt,               1);
+	rb_define_module_function(m_P1788, "exp",                p1788_exp,                1);
+	rb_define_module_function(m_P1788, "exp2",               p1788_exp2,               1);
+	rb_define_module_function(m_P1788, "exp10",              p1788_exp10,              1);
+	rb_define_module_function(m_P1788, "log",                p1788_log,                1);
+	rb_define_module_function(m_P1788, "log2",               p1788_log2,               1);
+	rb_define_module_function(m_P1788, "log10",              p1788_log10,              1);
+	rb_define_module_function(m_P1788, "sin",                p1788_sin,                1);
+	rb_define_module_function(m_P1788, "cos",                p1788_cos,                1);
+	rb_define_module_function(m_P1788, "tan",                p1788_tan,                1);
+	rb_define_module_function(m_P1788, "asin",               p1788_asin,               1);
+	rb_define_module_function(m_P1788, "acos",               p1788_acos,               1);
+	rb_define_module_function(m_P1788, "atan",               p1788_atan,               1);
+	rb_define_module_function(m_P1788, "atan2",              p1788_atan2,              2);
+	rb_define_module_function(m_P1788, "sinh",               p1788_sinh,               1);
+	rb_define_module_function(m_P1788, "cosh",               p1788_cosh,               1);
+	rb_define_module_function(m_P1788, "tanh",               p1788_tanh,               1);
+	rb_define_module_function(m_P1788, "asinh",              p1788_asinh,              1);
+	rb_define_module_function(m_P1788, "acosh",              p1788_acosh,              1);
+	rb_define_module_function(m_P1788, "atanh",              p1788_atanh,              1);
+	rb_define_module_function(m_P1788, "sign",               p1788_sign,               1);
+	rb_define_module_function(m_P1788, "ceil",               p1788_ceil,               1);
+	rb_define_module_function(m_P1788, "floor",              p1788_floor,              1);
+	rb_define_module_function(m_P1788, "floorceil",          p1788_floorceil,          1);
+	rb_define_module_function(m_P1788, "trunc",              p1788_trunc,              1);
+	rb_define_module_function(m_P1788, "round_ties_to_even", p1788_round_ties_to_even, 1);
+	rb_define_module_function(m_P1788, "round_ties_to_away", p1788_round_ties_to_away, 1);
+	rb_define_module_function(m_P1788, "abs",                p1788_abs,                1);
+	rb_define_module_function(m_P1788, "pos",                p1788_pos,                1);
+	rb_define_module_function(m_P1788, "neg",                p1788_neg,                1);
+	rb_define_module_function(m_P1788, "add",                p1788_add,                2);
+	rb_define_module_function(m_P1788, "sub",                p1788_sub,                2);
+	rb_define_module_function(m_P1788, "mul",                p1788_mul,                2);
+	rb_define_module_function(m_P1788, "div",                p1788_div,                2);
+	rb_define_module_function(m_P1788, "div_to_pair",        p1788_div_to_pair,        2);
+	rb_define_module_function(m_P1788, "pow",                p1788_pow,                2);
+	rb_define_module_function(m_P1788, "pown",               p1788_pown,               2);
+	rb_define_module_function(m_P1788, "min",                p1788_min,               -1);
+	rb_define_module_function(m_P1788, "max",                p1788_max,               -1);
+	rb_define_module_function(m_P1788, "cancel_plus",        p1788_cancel_plus,        2);
+	rb_define_module_function(m_P1788, "cancel_minus",       p1788_cancel_minus,       2);
+	rb_define_module_function(m_P1788, "fma",                p1788_fma,                3);
+
+	rb_define_module_function(m_P1788, "recip_rev",          p1788_recip_rev,         -1);
+	rb_define_module_function(m_P1788, "sqr_rev",            p1788_sqr_rev,           -1);
+	rb_define_module_function(m_P1788, "sqrt_rev",           p1788_sqrt_rev,          -1);
+	rb_define_module_function(m_P1788, "exp_rev",            p1788_exp_rev,           -1);
+	rb_define_module_function(m_P1788, "exp2_rev",           p1788_exp2_rev,          -1);
+	rb_define_module_function(m_P1788, "exp10_rev",          p1788_exp10_rev,         -1);
+	rb_define_module_function(m_P1788, "log_rev",            p1788_log_rev,           -1);
+	rb_define_module_function(m_P1788, "log2_rev",           p1788_log2_rev,          -1);
+	rb_define_module_function(m_P1788, "log10_rev",          p1788_log10_rev,         -1);
+	rb_define_module_function(m_P1788, "sin_rev",            p1788_sin_rev,           -1);
+	rb_define_module_function(m_P1788, "cos_rev",            p1788_cos_rev,           -1);
+	rb_define_module_function(m_P1788, "tan_rev",            p1788_tan_rev,           -1);
+	rb_define_module_function(m_P1788, "asin_rev",           p1788_asin_rev,          -1);
+	rb_define_module_function(m_P1788, "acos_rev",           p1788_acos_rev,          -1);
+	rb_define_module_function(m_P1788, "atan_rev",           p1788_atan_rev,          -1);
+	rb_define_module_function(m_P1788, "sinh_rev",           p1788_sinh_rev,          -1);
+	rb_define_module_function(m_P1788, "cosh_rev",           p1788_cosh_rev,          -1);
+	rb_define_module_function(m_P1788, "tanh_rev",           p1788_tanh_rev,          -1);
+	rb_define_module_function(m_P1788, "asinh_rev",          p1788_asinh_rev,         -1);
+	rb_define_module_function(m_P1788, "acosh_rev",          p1788_acosh_rev,         -1);
+	rb_define_module_function(m_P1788, "atanh_rev",          p1788_atanh_rev,         -1);
+	rb_define_module_function(m_P1788, "abs_rev",            p1788_abs_rev,           -1);
+	rb_define_module_function(m_P1788, "neg_rev",            p1788_neg_rev,           -1);
+	rb_define_module_function(m_P1788, "add_rev",            p1788_add_rev,           -1);
+	rb_define_module_function(m_P1788, "sub_rev",            p1788_sub_rev,           -1);
+	rb_define_module_function(m_P1788, "mul_rev",            p1788_mul_rev,           -1);
+	rb_define_module_function(m_P1788, "mul_rev_to_pair",    p1788_mul_rev_to_pair,    2);
+	rb_define_module_function(m_P1788, "div_rev",            p1788_div_rev,           -1);
+	rb_define_module_function(m_P1788, "pown_rev",           p1788_pown_rev,          -1);
+	rb_define_module_function(m_P1788, "pow_rev1",           p1788_pow_rev1,          -1);
+	rb_define_module_function(m_P1788, "pow_rev2",           p1788_pow_rev2,          -1);
+	rb_define_module_function(m_P1788, "test",               p1788_test,              -1);
+
+	rb_define_module_function(m_P1788, "intersection",       p1788_intersection,       2);
+	rb_define_module_function(m_P1788, "convex_hull",        p1788_convex_hull,        2);
+}
+
+extern "C" {
+	void Init_p1788()
+	{
+		Init_p1788_func();
+	}
+}
+