bigdecimal-math_r 0.2.0

data/ext/bigdecimal/math_r/euler_f.c

@@ -0,0 +1,572 @@
+/*******************************************************************************
+	euler_f.c -- Euler's formula
+
+	Author: tribusonz
+	Licence: MIT
+*******************************************************************************/
+#include <ruby.h>
+#include "math_r/globals.h"
+#include "math_r/bigmath_r.h"
+#include "decl.h"
+
+
+/**
+ * Computes complex exponential function of +z+.
+ * 
+ * @param z [Numeric] Numerical argument
+ * @param prec [Integer] Arbitrary precision
+ * @return [Complex] Complex solution
+ * @raise [ArgumentError] Occurs when +prec+ is not a positive integer.
+ * @raise [TypeError] Occurs when +z+ is not a numeric class.
+ * @example
+ *  BigMathR::EulerF.cexp(1+1i, 20)
+ *  #=> (0.14686939399158851572e1+0.22873552871788423912e1i)
+ * @since 0.1.0
+ */
+static VALUE
+__impl_eulerf_cexp(VALUE unused_obj, VALUE z, VALUE prec)
+{
+	return cexp_branch(z, prec, cexp_eulerf);
+}
+
+
+/**
+ * Computes complex binary exponent of +z+.
+ * 
+ * @param z [Numeric] Numerical argument
+ * @param prec [Integer] Arbitrary precision
+ * @return [Complex] Complex solution
+ * @raise [ArgumentError] Occurs when +prec+ is not a positive integer.
+ * @raise [TypeError] Occurs when +z+ is not a numeric class.
+ * @example
+ *  BigMathR::EulerF.cexp2(1+1i, 20)
+ *  #=> (0.15384778027279442532e1+0.12779225526272696023e1i)
+ * @since 0.1.0
+ */
+static VALUE
+__impl_eulerf_cexp2(VALUE unused_obj, VALUE z, VALUE prec)
+{
+	return cexp2_branch(z, prec, cexp2_eulerf);
+}
+
+/**
+ * Computes sine of +x+.
+ * 
+ * @param x [Numeric] Numerical argument
+ * @param prec [Integer] Arbitrary precision
+ * @return [Complex] Complex solution
+ * @raise [ArgumentError] Occurs when +prec+ is not a positive integer.
+ * @raise [TypeError] Occurs when +x+ is not a numeric class.
+ * @example
+ *  BigMathR::EulerF.sin(1, 20)
+ *  #=> 0.84147098480789650665e0
+ * @since 0.1.0
+ */
+static VALUE
+__impl_eulerf_sin(VALUE unused_obj, VALUE x, VALUE prec)
+{
+	return sin_branch(x, prec, sin_eulerf);
+}
+
+/**
+ * Computes cosine of +x+.
+ * 
+ * @param x [Numeric] Numerical argument
+ * @param prec [Integer] Arbitrary precision
+ * @return [Complex] Complex solution
+ * @raise [ArgumentError] Occurs when +prec+ is not a positive integer.
+ * @raise [TypeError] Occurs when +x+ is not a numeric class.
+ * @example
+ *  BigMathR::EulerF.cos(1, 20)
+ *  #=> 0.5403023058681397174e0
+ * @since 0.1.0
+ */
+static VALUE
+__impl_eulerf_cos(VALUE unused_obj, VALUE x, VALUE prec)
+{
+	return cos_branch(x, prec, cos_eulerf);
+}
+
+/**
+ * Computes tangent of +x+.
+ * 
+ * @param x [Numeric] Numerical argument
+ * @param prec [Integer] Arbitrary precision
+ * @return [Complex] Complex solution
+ * @raise [ArgumentError] Occurs when +prec+ is not a positive integer.
+ * @raise [TypeError] Occurs when +x+ is not a numeric class.
+ * @example
+ *  BigMathR::EulerF.tan(1, 20)
+ *  #=> 0.15574077246549022305e1
+ * @since 0.1.0
+ */
+static VALUE
+__impl_eulerf_tan(VALUE unused_obj, VALUE x, VALUE prec)
+{
+	return tan_branch(x, prec, tan_eulerf);
+}
+
+/**
+ * Computes cosecant of +x+.
+ * 
+ * @param x [Numeric] Numerical argument
+ * @param prec [Integer] Arbitrary precision
+ * @return [Complex] Complex solution
+ * @raise [ArgumentError] Occurs when +prec+ is not a positive integer.
+ * @raise [TypeError] Occurs when +x+ is not a numeric class.
+ * @example
+ *  BigMathR::EulerF.csc(1, 20)
+ *  #=> 0.11883951057781212163e1
+ * @since 0.1.0
+ */
+static VALUE
+__impl_eulerf_csc(VALUE unused_obj, VALUE x, VALUE prec)
+{
+	return csc_branch(x, prec, csc_eulerf);
+}
+
+/**
+ * Computes secant of +x+.
+ * 
+ * @param x [Numeric] Numerical argument
+ * @param prec [Integer] Arbitrary precision
+ * @return [Complex] Complex solution
+ * @raise [ArgumentError] Occurs when +prec+ is not a positive integer.
+ * @raise [TypeError] Occurs when +x+ is not a numeric class.
+ * @example
+ *  BigMathR::EulerF.sec(1, 20)
+ *  #=> 0.18508157176809256179e1
+ * @since 0.1.0
+ */
+static VALUE
+__impl_eulerf_sec(VALUE unused_obj, VALUE x, VALUE prec)
+{
+	return sec_branch(x, prec, sec_eulerf);
+}
+
+/**
+ * Computes cotangent of +x+.
+ * 
+ * @param x [Numeric] Numerical argument
+ * @param prec [Integer] Arbitrary precision
+ * @return [Complex] Complex solution
+ * @raise [ArgumentError] Occurs when +prec+ is not a positive integer.
+ * @raise [TypeError] Occurs when +x+ is not a numeric class.
+ * @example
+ *  BigMathR::EulerF.cot(1, 20)
+ *  #=> 0.64209261593433070301e0
+ * @since 0.1.0
+ */
+static VALUE
+__impl_eulerf_cot(VALUE unused_obj, VALUE x, VALUE prec)
+{
+	return cot_branch(x, prec, cot_eulerf);
+}
+
+/**
+ * Computes complex sine of +z+.
+ * 
+ * @param z [Numeric] Numerical argument
+ * @param prec [Integer] Arbitrary precision
+ * @return [Complex] Complex solution
+ * @raise [ArgumentError] Occurs when +prec+ is not a positive integer.
+ * @raise [TypeError] Occurs when +z+ is not a numeric class.
+ * @example
+ *  BigMathR::EulerF.csin(1+1i, 20)
+ *  #=> (0.12984575814159772948e1+0.63496391478473610827e0i)
+ * @since 0.1.0
+ */
+static VALUE
+__impl_eulerf_csin(VALUE unused_obj, VALUE z, VALUE prec)
+{
+	return csin_branch(z, prec, csin_eulerf);
+}
+
+/**
+ * Computes complex cosine of +z+.
+ * 
+ * @param z [Numeric] Numerical argument
+ * @param prec [Integer] Arbitrary precision
+ * @return [Complex] Complex solution
+ * @raise [ArgumentError] Occurs when +prec+ is not a positive integer.
+ * @raise [TypeError] Occurs when +z+ is not a numeric class.
+ * @example
+ *  BigMathR::EulerF.ccos(1+1i, 20)
+ *  #=> (0.83373002513114904889e0-0.9888977057628650964e0i)
+ * @since 0.1.0
+ */
+static VALUE
+__impl_eulerf_ccos(VALUE unused_obj, VALUE z, VALUE prec)
+{
+	return ccos_branch(z, prec, ccos_eulerf);
+}
+
+/**
+ * Computes complex tangent of +z+.
+ * 
+ * @param z [Numeric] Numerical argument
+ * @param prec [Integer] Arbitrary precision
+ * @return [Complex] Complex solution
+ * @raise [ArgumentError] Occurs when +prec+ is not a positive integer.
+ * @raise [TypeError] Occurs when +z+ is not a numeric class.
+ * @example
+ *  BigMathR::EulerF.ctan(1+1i, 20)
+ *  #=> (0.27175258531951171652e0+0.10839233273386945435e1i)
+ * @since 0.1.0
+ */
+static VALUE
+__impl_eulerf_ctan(VALUE unused_obj, VALUE z, VALUE prec)
+{
+	return ctan_branch(z, prec, ctan_eulerf);
+}
+
+/**
+ * Computes complex cosecant of +z+.
+ * 
+ * @param z [Numeric] Numerical argument
+ * @param prec [Integer] Arbitrary precision
+ * @return [Complex] Complex solution
+ * @raise [ArgumentError] Occurs when +prec+ is not a positive integer.
+ * @raise [TypeError] Occurs when +z+ is not a numeric class.
+ * @example
+ *  BigMathR::EulerF.ccsc(1+1i, 20)
+ *  #=> (0.62151801717042842124e0-0.30393100162842645035e0i)
+ * @since 0.1.0
+ */
+static VALUE
+__impl_eulerf_ccsc(VALUE unused_obj, VALUE z, VALUE prec)
+{
+	return ccsc_branch(z, prec, ccsc_eulerf);
+}
+
+/**
+ * Computes complex secant of +z+.
+ * 
+ * @param z [Numeric] Numerical argument
+ * @param prec [Integer] Arbitrary precision
+ * @return [Complex] Complex solution
+ * @raise [ArgumentError] Occurs when +prec+ is not a positive integer.
+ * @raise [TypeError] Occurs when +z+ is not a numeric class.
+ * @example
+ *  BigMathR::EulerF.csec(1+1i, 20)
+ *  #=> (0.4983370305551867852e0+0.59108384172104504804e0i)
+ * @since 0.1.0
+ */
+static VALUE
+__impl_eulerf_csec(VALUE unused_obj, VALUE z, VALUE prec)
+{
+	return csec_branch(z, prec, csec_eulerf);
+}
+
+/**
+ * Computes complex cotangent of +z+.
+ * 
+ * @param z [Numeric] Numerical argument
+ * @param prec [Integer] Arbitrary precision
+ * @return [Complex] Complex solution
+ * @raise [ArgumentError] Occurs when +prec+ is not a positive integer.
+ * @raise [TypeError] Occurs when +z+ is not a numeric class.
+ * @example
+ *  BigMathR::EulerF.ccot(1+1i, 20)
+ *  #=> (0.21762156185440268135e0-0.86801414289592494862e0i)
+ * @since 0.1.0
+ */
+static VALUE
+__impl_eulerf_ccot(VALUE unused_obj, VALUE z, VALUE prec)
+{
+	return ccot_branch(z, prec, ccot_eulerf);
+}
+
+/**
+ * Computes hyperbolic sine of +x+.
+ * 
+ * @param x [Numeric] Numerical argument
+ * @param prec [Integer] Arbitrary precision
+ * @return [BigDecimal] Real solution
+ * @raise [ArgumentError] Occurs when +prec+ is not a positive integer.
+ * @raise [TypeError] Occurs when +x+ is not a numeric class.
+ * @example
+ *  BigMathR::EulerF.sinh(1, 20)
+ *  #=> 0.11752011936438014569e1
+ * @since 0.1.0
+ */
+static VALUE
+__impl_eulerf_sinh(VALUE unused_obj, VALUE x, VALUE prec)
+{
+	return sinh_branch(x, prec, sinh_eulerf);
+}
+
+/**
+ * Computes hyperbolic cosine of +x+.
+ * 
+ * @param x [Numeric] Numerical argument
+ * @param prec [Integer] Arbitrary precision
+ * @return [BigDecimal] Real solution
+ * @raise [ArgumentError] Occurs when +prec+ is not a positive integer.
+ * @raise [TypeError] Occurs when +x+ is not a numeric class.
+ * @example
+ *  BigMathR::EulerF.cosh(1, 20)
+ *  #=> 0.15430806348152437785e1
+ * @since 0.1.0
+ */
+static VALUE
+__impl_eulerf_cosh(VALUE unused_obj, VALUE x, VALUE prec)
+{
+	return cosh_branch(x, prec, cosh_eulerf);
+}
+
+/**
+ * Computes hyperbolic tangent of +x+.
+ * 
+ * @param x [Numeric] Numerical argument
+ * @param prec [Integer] Arbitrary precision
+ * @return [BigDecimal] Real solution
+ * @raise [ArgumentError] Occurs when +prec+ is not a positive integer.
+ * @raise [TypeError] Occurs when +x+ is not a numeric class.
+ * @example
+ *  BigMathR::EulerF.tanh(1, 20)
+ *  #=> 0.76159415595576488813e0
+ * @since 0.1.0
+ */
+static VALUE
+__impl_eulerf_tanh(VALUE unused_obj, VALUE x, VALUE prec)
+{
+	return tanh_branch(x, prec, tanh_eulerf);
+}
+
+/**
+ * Computes hyperbolic cosecant of +x+.
+ * 
+ * @param x [Numeric] Numerical argument
+ * @param prec [Integer] Arbitrary precision
+ * @return [BigDecimal] Real solution
+ * @raise [ArgumentError] Occurs when +prec+ is not a positive integer.
+ * @raise [TypeError] Occurs when +x+ is not a numeric class.
+ * @example
+ *  BigMathR::EulerF.csch(1, 20)
+ *  #=> 0.85091812823932154512e0
+ * @since 0.1.0
+ */
+static VALUE
+__impl_eulerf_csch(VALUE unused_obj, VALUE x, VALUE prec)
+{
+	return csch_branch(x, prec, csch_eulerf);
+}
+
+/**
+ * Computes hyperbolic secant of +x+.
+ * 
+ * @param x [Numeric] Numerical argument
+ * @param prec [Integer] Arbitrary precision
+ * @return [BigDecimal] Real solution
+ * @raise [ArgumentError] Occurs when +prec+ is not a positive integer.
+ * @raise [TypeError] Occurs when +x+ is not a numeric class.
+ * @example
+ *  BigMathR::EulerF.sech(1, 20)
+ *  #=> 0.64805427366388539957e0
+ * @since 0.1.0
+ */
+static VALUE
+__impl_eulerf_sech(VALUE unused_obj, VALUE x, VALUE prec)
+{
+	return sech_branch(x, prec, sech_eulerf);
+}
+
+/**
+ * Computes hyperbolic cotangent of +x+.
+ * 
+ * @param x [Numeric] Numerical argument
+ * @param prec [Integer] Arbitrary precision
+ * @return [BigDecimal] Real solution
+ * @raise [ArgumentError] Occurs when +prec+ is not a positive integer.
+ * @raise [TypeError] Occurs when +x+ is not a numeric class.
+ * @example
+ *  BigMathR::EulerF.coth(1, 20)
+ *  #=> 0.13130352854993313036e1
+ * @since 0.1.0
+ */
+static VALUE
+__impl_eulerf_coth(VALUE unused_obj, VALUE x, VALUE prec)
+{
+	return coth_branch(x, prec, coth_eulerf);
+}
+
+/**
+ * Computes complex hyperbolic sine of +z+.
+ * 
+ * @param z [Numeric] Numerical argument
+ * @param prec [Integer] Arbitrary precision
+ * @return [Complex] Complex solution
+ * @raise [ArgumentError] Occurs when +prec+ is not a positive integer.
+ * @raise [TypeError] Occurs when +z+ is not a numeric class.
+ * @example
+ *  BigMathR::EulerF.csinh(1+1i, 20)
+ *  #=> (0.63496391478473610827e0+0.12984575814159772948e1i)
+ * @since 0.1.0
+ */
+static VALUE
+__impl_eulerf_csinh(VALUE unused_obj, VALUE z, VALUE prec)
+{
+	return csinh_branch(z, prec, csinh_eulerf);
+}
+
+/**
+ * Computes complex hyperbolic cosine of +z+.
+ * 
+ * @param z [Numeric] Numerical argument
+ * @param prec [Integer] Arbitrary precision
+ * @return [Complex] Complex solution
+ * @raise [ArgumentError] Occurs when +prec+ is not a positive integer.
+ * @raise [TypeError] Occurs when +z+ is not a numeric class.
+ * @example
+ *  BigMathR::EulerF.ccosh(1+1i, 20)
+ *  #=> (0.83373002513114904889e0+0.9888977057628650964e0i)
+ * @since 0.1.0
+ */
+static VALUE
+__impl_eulerf_ccosh(VALUE unused_obj, VALUE z, VALUE prec)
+{
+	return ccosh_branch(z, prec, ccosh_eulerf);
+}
+
+/**
+ * Computes complex hyperbolic tangent of +z+.
+ * 
+ * @param z [Numeric] Numerical argument
+ * @param prec [Integer] Arbitrary precision
+ * @return [Complex] Complex solution
+ * @raise [ArgumentError] Occurs when +prec+ is not a positive integer.
+ * @raise [TypeError] Occurs when +z+ is not a numeric class.
+ * @example
+ *  BigMathR::EulerF.ctanh(1+1i, 20)
+ *  #=> (0.10839233273386945435e1+0.27175258531951171652e0i)
+ * @since 0.1.0
+ */
+static VALUE
+__impl_eulerf_ctanh(VALUE unused_obj, VALUE z, VALUE prec)
+{
+	return ctanh_branch(z, prec, ctanh_eulerf);
+}
+
+/**
+ * Computes complex hyperbolic cosecant of +z+.
+ * 
+ * @param z [Numeric] Numerical argument
+ * @param prec [Integer] Arbitrary precision
+ * @return [Complex] Complex solution
+ * @raise [ArgumentError] Occurs when +prec+ is not a positive integer.
+ * @raise [TypeError] Occurs when +z+ is not a numeric class.
+ * @example
+ *  BigMathR::EulerF.ccsch(1+1i, 20)
+ *  #=> (0.30393100162842645035e0-0.62151801717042842124e0i)
+ * @since 0.1.0
+ */
+static VALUE
+__impl_eulerf_ccsch(VALUE unused_obj, VALUE z, VALUE prec)
+{
+	return ccsch_branch(z, prec, ccsch_eulerf);
+}
+
+/**
+ * Computes complex hyperbolic secant of +z+.
+ * 
+ * @param z [Numeric] Numerical argument
+ * @param prec [Integer] Arbitrary precision
+ * @return [Complex] Complex solution
+ * @raise [ArgumentError] Occurs when +prec+ is not a positive integer.
+ * @raise [TypeError] Occurs when +z+ is not a numeric class.
+ * @example
+ *  BigMathR::EulerF.csech(1+1i, 20)
+ *  #=> (0.4983370305551867852e0-0.59108384172104504804e0i)
+ * @since 0.1.0
+ */
+static VALUE
+__impl_eulerf_csech(VALUE unused_obj, VALUE z, VALUE prec)
+{
+	return csech_branch(z, prec, csech_eulerf);
+}
+
+/**
+ * Computes complex hyperbolic cotangent of +z+.
+ * 
+ * @param z [Numeric] Numerical argument
+ * @param prec [Integer] Arbitrary precision
+ * @return [Complex] Complex solution
+ * @raise [ArgumentError] Occurs when +prec+ is not a positive integer.
+ * @raise [TypeError] Occurs when +z+ is not a numeric class.
+ * @example
+ *  BigMathR::EulerF.ccoth(1+1i, 20)
+ *  #=> (0.86801414289592494862e0-0.21762156185440268135e0i)
+ * @since 0.1.0
+ */
+static VALUE
+__impl_eulerf_ccoth(VALUE unused_obj, VALUE z, VALUE prec)
+{
+	return ccoth_branch(z, prec, ccoth_eulerf);
+}
+
+/**
+ *  Document-module:  BigMathR::EulerF
+ *  
+ *  A module that provides using Euler's formula. 
+ *  It is used internally.
+ *  <br>
+ *  By using this formula for complex analysis, 
+ *  it can be applied to differential equations and Fourier transforms.
+ *  <br>
+ *  == Synopsis
+ *  The function names defined are the same as those in the C/C++ standard.
+ *  <br>
+ *  - Exponential function:         +:cexp+ <br>
+ *  - Base-2 (Binary) exponent:     +:cexp2+ <br>
+ *  - Sine:                 +:sin+  +:csin+ <br>
+ *  - Cosine:               +:cos+  +:ccos+ <br>
+ *  - Tangent:              +:tan+  +:ctan+ <br>
+ *  - Hyperbolic sine:      +:sinh+ +:csinh+ <br>
+ *  - Hyperbolic cosine:    +:cosh+ +:ccosh+ <br>
+ *  - Hyperbolic tangent:   +:tanh+ +:ctanh+ <br>
+ *  Follow, those reciprocals of not defined in C/C++ standard.
+ *  <br>
+ *  - Cosecant:             +:csc+  +:ccsc+ <br>
+ *  - Secant:               +:sec+  +:csec+ <br>
+ *  - Cotangent:            +:cot+  +:ccot+ <br>
+ *  - Hyperbolic cosecant:  +:csch+ +:ccsch+ <br>
+ *  - Hyperbolic secant:    +:sech+ +:csech+ <br>
+ *  - Hyperbolic cotangent: +:coth+ +:ccoth+ <br>
+ *  Reference::
+ *  Kiso kara hatten made Sankaku kansuu (Japanese) - Michimasa Kobayashi (Beret Shuppan)
+ */
+void
+InitVM_EulerF(void)
+{
+	rb_define_module_function(rb_mEulerF, "cexp", __impl_eulerf_cexp, 2);
+	rb_define_module_function(rb_mEulerF, "cexp2", __impl_eulerf_cexp2, 2);
+
+	rb_define_module_function(rb_mEulerF, "sin", __impl_eulerf_sin, 2);
+	rb_define_module_function(rb_mEulerF, "cos", __impl_eulerf_cos, 2);
+	rb_define_module_function(rb_mEulerF, "tan", __impl_eulerf_tan, 2);
+	rb_define_module_function(rb_mEulerF, "csc", __impl_eulerf_csc, 2);
+	rb_define_module_function(rb_mEulerF, "sec", __impl_eulerf_sec, 2);
+	rb_define_module_function(rb_mEulerF, "cot", __impl_eulerf_cot, 2);
+
+	rb_define_module_function(rb_mEulerF, "csin", __impl_eulerf_csin, 2);
+	rb_define_module_function(rb_mEulerF, "ccos", __impl_eulerf_ccos, 2);
+	rb_define_module_function(rb_mEulerF, "ctan", __impl_eulerf_ctan, 2);
+	rb_define_module_function(rb_mEulerF, "ccsc", __impl_eulerf_ccsc, 2);
+	rb_define_module_function(rb_mEulerF, "csec", __impl_eulerf_csec, 2);
+	rb_define_module_function(rb_mEulerF, "ccot", __impl_eulerf_ccot, 2);
+
+	rb_define_module_function(rb_mEulerF, "sinh", __impl_eulerf_sinh, 2);
+	rb_define_module_function(rb_mEulerF, "cosh", __impl_eulerf_cosh, 2);
+	rb_define_module_function(rb_mEulerF, "tanh", __impl_eulerf_tanh, 2);
+	rb_define_module_function(rb_mEulerF, "csch", __impl_eulerf_csch, 2);
+	rb_define_module_function(rb_mEulerF, "sech", __impl_eulerf_sech, 2);
+	rb_define_module_function(rb_mEulerF, "coth", __impl_eulerf_coth, 2);
+
+	rb_define_module_function(rb_mEulerF, "csinh", __impl_eulerf_csinh, 2);
+	rb_define_module_function(rb_mEulerF, "ccosh", __impl_eulerf_ccosh, 2);
+	rb_define_module_function(rb_mEulerF, "ctanh", __impl_eulerf_ctanh, 2);
+	rb_define_module_function(rb_mEulerF, "ccsch", __impl_eulerf_ccsch, 2);
+	rb_define_module_function(rb_mEulerF, "csech", __impl_eulerf_csech, 2);
+	rb_define_module_function(rb_mEulerF, "ccoth", __impl_eulerf_ccoth, 2);
+}

data/ext/bigdecimal/math_r/exp.c

@@ -0,0 +1,72 @@
+/******************************************************************************
+	exp.c -- Exponential Functions
+
+	Author: tribusonz
+	Lisence: MIT
+******************************************************************************/
+#include <ruby.h>
+#include "math_r/globals.h"
+#include "math_r/bigmath_r.h"
+#include "decl.h"
+
+/**
+ * Computes exponential function of +x+.
+ * 
+ * @param x [Numeric] Numerical argument
+ * @param prec [Integer] Arbitrary precision
+ * @return [BigDecimal] Real solution
+ * @raise [ArgumentError] Occurs when +prec+ is not a positive integer.
+ * @raise [TypeError] Occurs when +x+ is not a numeric class.
+ * @example
+ *  BigMathR::EDF.exp(1, 20)
+ *  #=> 0.27182818284590452354e1
+ * @since 0.1.0
+ */
+static VALUE
+__impl_exp_edf(VALUE unused_obj, VALUE x, VALUE prec)
+{
+	return exp_branch(x, prec, exp_edf);
+}
+
+
+/**
+ * Computes binary exponent of +x+.
+ * 
+ * @param x [Numeric] Numerical argument
+ * @param prec [Integer] Arbitrary precision
+ * @return [BigDecimal] Real solution
+ * @raise [ArgumentError] Occurs when +prec+ is not a positive integer.
+ * @raise [TypeError] Occurs when +x+ is not a numeric class.
+ * @example
+ *  BigMathR::EDF.exp2(1/2r, 20)
+ *  #=> 0.14142135623730950488e1
+ * @since 0.1.0
+ */
+static VALUE
+__impl_exp2_edf(VALUE unused_obj, VALUE x, VALUE prec)
+{
+	return exp2_branch(x, prec, exp2_edf);
+}
+
+
+/**
+ *  Document-module:  BigMathR::Exp
+ *  
+ *  A module that treats the exponential functions.
+ *  It is used internally.
+ *  <br>
+ *  This formula was discovered by the author shortly afterwards. It will be proven in time.
+ *  <br>
+ *  == Synopsis:
+ *  The function names defined are the same as those in the C/C++ standard.
+ *  <br>
+ *  Exponential function:     +exp()+ <br>
+ *  Base-2 (binary) exponent: +exp2()+ <br>
+ *  
+ */
+void
+InitVM_Exp(void)
+{
+	rb_define_module_function(rb_mExp, "exp_edf", __impl_exp_edf, 2);
+	rb_define_module_function(rb_mExp, "exp2_edf", __impl_exp2_edf, 2);
+}