bigdecimal-math_r 0.2.0

data/ext/bigdecimal/math_r/math_r/globals.h

@@ -0,0 +1,71 @@
+#ifndef RB_BIGMATHR_GLOBALS_H_INCLUDED
+#define RB_BIGMATHR_GLOBALS_H_INCLUDED
+
+#include <ruby/internal/value.h> // VALUE
+#include "ext_extern.h"
+
+RUBY_EXT_EXTERN VALUE rb_cBigDecimal;
+RUBY_EXT_EXTERN VALUE rb_mBigMath;
+
+RUBY_EXT_EXTERN VALUE rb_mBigMathR;
+RUBY_EXT_EXTERN VALUE rb_mMathSolver;
+RUBY_EXT_EXTERN VALUE rb_mConst;
+RUBY_EXT_EXTERN VALUE rb_mConstPI;
+RUBY_EXT_EXTERN VALUE rb_mConstE;
+RUBY_EXT_EXTERN VALUE rb_mConstLOG2;
+RUBY_EXT_EXTERN VALUE rb_mConstEulerGamma;
+RUBY_EXT_EXTERN VALUE rb_mEDF;
+RUBY_EXT_EXTERN VALUE rb_mExp;
+RUBY_EXT_EXTERN VALUE rb_mLog;
+RUBY_EXT_EXTERN VALUE rb_mTrig;
+RUBY_EXT_EXTERN VALUE rb_mHyperb;
+RUBY_EXT_EXTERN VALUE rb_mComplexPlane;
+RUBY_EXT_EXTERN VALUE rb_mEulerF;
+RUBY_EXT_EXTERN VALUE rb_mLogRep;
+RUBY_EXT_EXTERN VALUE rb_mPower;
+RUBY_EXT_EXTERN VALUE rb_mGammaR;
+RUBY_EXT_EXTERN VALUE rb_mErf;
+RUBY_EXT_EXTERN VALUE rb_mSolver;
+
+RUBY_EXT_EXTERN ID mf_exp;
+RUBY_EXT_EXTERN ID mf_exp2;
+RUBY_EXT_EXTERN ID mf_expm1;
+
+RUBY_EXT_EXTERN ID mf_log;
+RUBY_EXT_EXTERN ID mf_log2;
+RUBY_EXT_EXTERN ID mf_log10;
+RUBY_EXT_EXTERN ID mf_log1p;
+
+RUBY_EXT_EXTERN ID mf_sqrt;
+RUBY_EXT_EXTERN ID mf_cbrt;
+
+RUBY_EXT_EXTERN ID mf_sin;
+RUBY_EXT_EXTERN ID mf_cos;
+RUBY_EXT_EXTERN ID mf_tan;
+RUBY_EXT_EXTERN ID mf_csc;
+RUBY_EXT_EXTERN ID mf_sec;
+RUBY_EXT_EXTERN ID mf_cot;
+
+RUBY_EXT_EXTERN ID mf_sinh;
+RUBY_EXT_EXTERN ID mf_cosh;
+RUBY_EXT_EXTERN ID mf_tanh;
+RUBY_EXT_EXTERN ID mf_csch;
+RUBY_EXT_EXTERN ID mf_sech;
+RUBY_EXT_EXTERN ID mf_coth;
+
+RUBY_EXT_EXTERN ID mf_asin;
+RUBY_EXT_EXTERN ID mf_acos;
+RUBY_EXT_EXTERN ID mf_atan;
+RUBY_EXT_EXTERN ID mf_acsc;
+RUBY_EXT_EXTERN ID mf_asec;
+RUBY_EXT_EXTERN ID mf_acot;
+
+RUBY_EXT_EXTERN ID mf_asinh;
+RUBY_EXT_EXTERN ID mf_acosh;
+RUBY_EXT_EXTERN ID mf_atanh;
+RUBY_EXT_EXTERN ID mf_acsch;
+RUBY_EXT_EXTERN ID mf_asech;
+RUBY_EXT_EXTERN ID mf_acoth;
+
+
+#endif /* RB_BIGMATHR_GLOBALS_H_INCLUDED */

data/ext/bigdecimal/math_r/math_r/numdiff.h

@@ -0,0 +1,18 @@
+#ifndef INTERNAL_API_NUMDIFF
+#define INTERNAL_API_NUMDIFF
+
+/* API for Numerical Differentiation */
+
+/**
+ * Query if the condition for exiting the iterator has been reached.
+ * It is use in numerical derivatives.
+ */
+bool rb_numdiff_condition_p(VALUE y, VALUE d, VALUE n, VALUE *m);
+
+/**
+ * Add BigDecimal#double_fig to the arbitrary precision number.
+ * The precision must be greater than or equal to 1.
+ */
+VALUE rb_numdiff_make_n(VALUE prec);
+
+#endif /* INTERNAL_API_NUMDIFF */

data/ext/bigdecimal/math_r/math_r/numeric.h

@@ -0,0 +1,63 @@
+#ifndef INTERNAL_API_NUMERIC
+#define INTERNAL_API_NUMERIC
+
+/* API for Numeric */
+
+VALUE rb_num_abs(VALUE x);
+
+VALUE rb_num_uminus(VALUE x);
+
+VALUE rb_num_real(VALUE z);
+VALUE rb_num_imag(VALUE z);
+
+bool rb_num_positive_p(VALUE z);
+bool rb_num_negative_p(VALUE z);
+
+bool rb_num_equal_p(VALUE lhs, VALUE rhs);
+bool rb_num_notequal_p(VALUE lhs, VALUE rhs);
+VALUE rb_num_cmpeql(VALUE lhs, VALUE rhs);
+
+bool rb_num_zero_p(VALUE z);
+bool rb_num_nonzero_p(VALUE z);
+bool rb_num_real_p(VALUE z);
+bool rb_num_finite_p(VALUE z);
+int rb_num_infinite_p(VALUE z);
+bool rb_num_nan_p(VALUE z);
+
+bool rb_num_numeric_p(VALUE self);
+
+
+/**
+ * Rounds the argument +x+ to an arbitrary precision +prec+. <br>
+ * It targets real numbers, but also supports Complex class. <br>
+ * 
+ */
+VALUE rb_num_round(VALUE x, VALUE prec);
+
+#define ARG_REAL        false
+#define ARG_COMPLEX     true
+#define ARG_RAWVALUE    false
+#define ARG_RECIPROCAL  true
+
+VALUE 
+rb_num_canonicalize(VALUE x, VALUE prec, bool complex_form, bool inversion);
+
+#define SIGN_PLUS false
+#define SIGN_MINUS true
+
+/**
+ *  ```Ruby
+ *  def rb_ImaginaryZ(z, signbit)
+ *    if signbit
+ *      -Complex::I * z
+ *    else
+ *       Complex::I * z
+ *    end
+ *  end
+ *  ```
+ */
+VALUE rb_ImaginaryZ(VALUE z, bool signbit);
+
+#define rb_funcall1(lhs, ops, rhs)  rb_funcall((lhs), (ops), 1, (rhs))
+
+#endif /* INTERNAL_API_NUMERIC */

data/ext/bigdecimal/math_r/math_r.c

@@ -0,0 +1,130 @@
+/*******************************************************************************
+	math_r.c -- Entrypoint
+
+	Author: tribusonz
+	Licence: MIT
+*******************************************************************************/
+#include <ruby.h>
+#define DEFINE_SYMBOL
+#include "math_r/globals.h"
+
+void InitVM_Overrides(void);
+void InitVM_Const(void);
+void InitVM_EDF(void);
+void InitVM_Exp(void);
+void InitVM_Log(void);
+void InitVM_Trig(void);
+void InitVM_Hyperb(void);
+void InitVM_ComplexPlane(void);
+void InitVM_EulerF(void);
+void InitVM_LogRep(void);
+void InitVM_Power(void);
+void InitVM_Erf(void);
+void InitVM_GammaR(void);
+void InitVM_Solver(void);
+
+/**
+ * Document-module:  BigMathR
+ * 
+ * Refined BigMath module.
+ * It is a total solution for mathematics that also supports complex numbers.
+ *  
+ * Reference::
+ * Utsukusii Suugaku wo egaku π, ｅ, to Euler no teisuu γ (Japanese) - WAKAHARA Tatsuhiko (Kohdan-sha Editorial)
+ */
+void
+Init_math_r(void)
+{
+	mf_exp = rb_intern_const("exp");
+	mf_exp2 = rb_intern_const("exp2");
+	mf_expm1 = rb_intern_const("expm1");
+
+	mf_log = rb_intern_const("log");
+	mf_log2 = rb_intern_const("log2");
+	mf_log10 = rb_intern_const("log10");
+	mf_log1p = rb_intern_const("log1p");
+
+	mf_sqrt = rb_intern_const("sqrt");
+	mf_cbrt = rb_intern_const("cbrt");
+
+	mf_sin = rb_intern_const("sin");
+	mf_cos = rb_intern_const("cos");
+	mf_tan = rb_intern_const("tan");
+	mf_csc = rb_intern_const("csc");
+	mf_sec = rb_intern_const("sec");
+	mf_cot = rb_intern_const("cot");
+
+	mf_sinh = rb_intern_const("sinh");
+	mf_cosh = rb_intern_const("cosh");
+	mf_tanh = rb_intern_const("tanh");
+	mf_csch = rb_intern_const("csch");
+	mf_sech = rb_intern_const("sech");
+	mf_coth = rb_intern_const("coth");
+
+	mf_asin = rb_intern_const("asin");
+	mf_acos = rb_intern_const("acos");
+	mf_atan = rb_intern_const("atan");
+	mf_acsc = rb_intern_const("acsc");
+	mf_asec = rb_intern_const("asec");
+	mf_acot = rb_intern_const("acot");
+
+	mf_asinh = rb_intern_const("asinh");
+	mf_acosh = rb_intern_const("acosh");
+	mf_atanh = rb_intern_const("atanh");
+	mf_acsch = rb_intern_const("acsch");
+	mf_asech = rb_intern_const("asech");
+	mf_acoth = rb_intern_const("acoth");
+
+	rb_require("bigdecimal/math");
+	rb_cBigDecimal = rb_const_get_at(rb_cObject, rb_intern("BigDecimal"));
+	rb_mBigMath = rb_const_get_at(rb_cObject, rb_intern("BigMath"));
+
+	rb_mBigMathR = rb_define_module("BigMathR");
+	rb_mMathSolver = rb_define_module_under(rb_mBigMathR, "Solver");
+
+	InitVM(Overrides);
+
+	rb_mConst = rb_define_module_under(rb_mBigMathR, "Const");
+	rb_mConstPI = rb_define_module_under(rb_mConst, "PI");
+	rb_mConstE = rb_define_module_under(rb_mConst, "E");
+	rb_mConstLOG2 = rb_define_module_under(rb_mConst, "LOG2");
+	rb_mConstEulerGamma = rb_define_module_under(rb_mConst, "EulerGamma");
+	InitVM(Const);
+
+	rb_mEDF = rb_define_module_under(rb_mBigMathR, "EDF");
+	InitVM(EDF);
+
+	rb_mExp = rb_define_module_under(rb_mBigMathR, "Exp");
+	InitVM(Exp);
+
+	rb_mLog = rb_define_module_under(rb_mBigMathR, "Log");
+	InitVM(Log);
+
+	rb_mTrig = rb_define_module_under(rb_mBigMathR, "Trig");
+	InitVM(Trig);
+
+	rb_mHyperb = rb_define_module_under(rb_mBigMathR, "Hyperb");
+	InitVM(Hyperb);
+
+	rb_mComplexPlane = rb_define_module_under(rb_mBigMathR, "ComplexPlane");
+	InitVM(ComplexPlane);
+
+	rb_mEulerF = rb_define_module_under(rb_mBigMathR, "EulerF");
+	InitVM(EulerF);
+
+	rb_mLogRep = rb_define_module_under(rb_mBigMathR, "LogRep");
+	InitVM(LogRep);
+
+	rb_mPower = rb_define_module_under(rb_mBigMathR, "Power");
+	InitVM(Power);
+
+	rb_mErf = rb_define_module_under(rb_mBigMathR, "Erf");
+	InitVM(Erf);
+
+	rb_mGammaR = rb_define_module_under(rb_mBigMathR, "GammaR");
+	InitVM(GammaR);
+
+	rb_mSolver = rb_define_module_under(rb_mBigMathR, "Solver");
+	InitVM(Solver);
+}
+

data/ext/bigdecimal/math_r/nucomp.c

@@ -0,0 +1,158 @@
+/*******************************************************************************
+	nucomp.c -- Complex Plane
+
+	Author: tribusonz
+	Licence: MIT
+*******************************************************************************/
+#include <ruby.h>
+#include "math_r/globals.h"
+#include "math_r/bigmath_r.h"
+#include "decl.h"
+
+/**
+ * @overload l2norm(*args, prec)
+ *  Return solve of the euclidean norm (L2-norm) for argument as numerical sequence.
+ *  
+ *  @param *args [Array] Numerical sequence
+ *  @param prec [Integer] Arbitrary precision
+ *  @return [BigDecimal] Real solution
+ *  @raise [ArgumentError] Occurs when +prec+ is not a positive integer.
+ *  @raise [TypeError] Occurs when +z+ is not a numeric class.
+ *  @example
+ *   BigMathR::ComplexPlane.l2norm(2, 4, 5, 20)
+ *   #=> 0.670820393249936908923e1
+ *  @since 0.1.0
+ */
+static VALUE
+__impl_nucomp_l2norm(VALUE unused_obj, VALUE args)
+{
+	if (RARRAY_LEN(args) < 2)
+		rb_raise(rb_eArgError, 
+			"wrong number of arguments (given %ld, expected 2..)", 
+			RARRAY_LEN(args));
+	VALUE prec = rb_ary_pop(args);
+	rb_check_precise(prec);
+	return rb_bigmath_l2norm(args, prec);
+}
+
+
+/**
+ *  Returns the hypotenuse of a right triangle with side lengths of +a+ and +b+.
+ *  <br>
+ *  The return value will definitely be a positive real number. 
+ *  <br>
+ *  It is implemented by the norm, 
+ *  so even if the argument is a complex number, 
+ *  it will be a positive real number.
+ *  
+ *  @param a [Numeric] adjacent side or opposite side
+ *  @param b [Numeric] adjacent side or opposite side
+ *  @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.
+ *  @since 0.1.0
+ */
+static VALUE
+__impl_bigmathr_hypot(VALUE unused_obj, VALUE a, VALUE b, VALUE prec)
+{
+	return rb_bigmath_hypot(a, b, prec);
+}
+
+/**
+ *  Return complex absolute of +z+.
+ *  
+ *  @param z [Numeric] Complex variable
+ *  @param prec [Integer] Arbitrary precision
+ *  @return [BigDecimal] Real solution
+ *  @raise [ArgumentError] Occurs when +prec+ is not a positive integer.
+ *  @raise [TypeError] Occurs when +z+ is not a numeric class.
+ *  @since 0.1.0
+ */
+static VALUE
+__impl_nucomp_cabs(VALUE unused_obj, VALUE z, VALUE prec)
+{
+	z = rb_num_canonicalize(z, prec, ARG_COMPLEX, ARG_RAWVALUE);
+	return rb_bigmath_cabs(z, prec);
+}
+
+/**
+ *  Consider where the value is in quadrant XY and computes the inverse tangent of +y/x+.
+ *  
+ *  @param x [Numeric] X-axis
+ *  @param y [Numeric] Y-axis
+ *  @param prec [Integer] Arbitrary precision
+ *  @return [BigDecimal] Real solution
+ *  @return [Complex] Complex solution
+ *  @raise [ArgumentError] Occurs when +prec+ is not a positive integer.
+ *  @raise [TypeError] Occurs when +x+ is not a numeric class.
+ *  @since 0.1.0
+ */
+static VALUE
+__impl_nucomp_quadrant(VALUE unused_obj, VALUE x, VALUE y, VALUE prec)
+{
+	return rb_bigmath_quadrant(x, y, prec);
+}
+
+/**
+ *  Consider where the value is in quadrant XY and computes the inverse tangent of +y/x+.
+ *  
+ *  @param y [Numeric] Y-axis
+ *  @param x [Numeric] X-axis
+ *  @param prec [Integer] Arbitrary precision
+ *  @return [BigDecimal] Real solution
+ *  @return [Complex] Complex solution
+ *  @raise [ArgumentError] Occurs when +prec+ is not a positive integer.
+ *  @raise [TypeError] Occurs when +x+ is not a numeric class.
+ *  @since 0.1.0
+ */
+static VALUE
+__impl_bigmathr_atan2(VALUE unused_obj, VALUE y, VALUE x, VALUE prec)
+{
+	return rb_bigmath_quadrant(x, y, prec);
+}
+
+/**
+ *  Return complex argument of +z+.
+ *  
+ *  @param z [Numeric] Complex variable
+ *  @param prec [Integer] Arbitrary precision
+ *  @return [BigDecimal] Real solution
+ *  @raise [ArgumentError] Occurs when +prec+ is not a positive integer.
+ *  @raise [TypeError] Occurs when +z+ is not a numeric class.
+ *  @since 0.1.0
+ */
+static VALUE
+__impl_nucomp_carg(VALUE unused_obj, VALUE z, VALUE prec)
+{
+	z = rb_num_canonicalize(z, prec, ARG_COMPLEX, ARG_RAWVALUE);
+	return rb_bigmath_carg(z, prec);
+}
+
+/**
+ *  Document-module:  BigMathR::ComplexPlane
+ *  
+ *  A module that provides whole of functions related to the complex plane. 
+ *  It is used internally.
+ *  <br>
+ *  == Synopsis
+ *  The function names defined are the same as those in the C/C++ standard.
+ *  <br>
+ *  - Complex argument:    +:carg+ <br>
+ *  - Complex absolute:    +:cabs+ <br>
+ *  Follow, the name defined in C/C++ standard though, the function names are different.
+ *  <br>
+ *  - Quadrant XY:         +:quadrant+ ( +:atan2+ in C/C++ ) <br>
+ */
+void
+InitVM_ComplexPlane(void)
+{
+	rb_define_module_function(rb_mComplexPlane, "l2norm", __impl_nucomp_l2norm, -2);
+	rb_define_module_function(rb_mComplexPlane, "cabs", __impl_nucomp_cabs, 2);
+	rb_define_module_function(rb_mComplexPlane, "quadrant", __impl_nucomp_quadrant, 3);
+	rb_define_module_function(rb_mComplexPlane, "carg", __impl_nucomp_carg, 2);
+
+	rb_define_module_function(rb_mBigMathR, "hypot", __impl_bigmathr_hypot, 3);
+	rb_define_module_function(rb_mBigMathR, "atan2", __impl_bigmathr_atan2, 3);
+
+}

data/ext/bigdecimal/math_r/overrides.c

@@ -0,0 +1,91 @@
+/*******************************************************************************
+	overrides.c -- Overriddem Methods
+
+	Author: tribusonz
+	License: MIT
+*******************************************************************************/
+#include <ruby.h>
+#include "math_r/globals.h"
+#include "math_r/bigmath_r.h"
+#include "decl.h"
+
+/**
+ * The #nan? method for primitive. Always return false.
+ * 
+ * @example
+ *  1.nan? #=> false
+ * @return [false] Whether self is Not a Number(NaN).
+ */
+static VALUE
+numeric_nan_p(VALUE self)
+{
+	return Qfalse;
+}
+
+/**
+ * Calculates "i z" so inverts the real and imaginary maps of +z+.
+ * 
+ * @example
+ *  Complex.imaginary_z(1+2i) #=> (-2+1i)
+ *  -Complex.imaginary_z(1+2i) #=> (2-1i)
+ * @param z [Numeric] Numerical argument
+ * @return [Complex] Solve
+ */
+static VALUE
+__impl_nucomp_s_imaginary_z(VALUE self, VALUE z)
+{
+	return rb_ImaginaryZ(z, SIGN_PLUS);
+}
+
+/**
+ * Returns a boolean whether the object is a numeric class.
+ * 
+ * @example
+ *  1.numeric? #=> true
+ *  1.0.numric? #=> true
+ *  (1+1i).numeric? #=> true
+ *  (1/3r).numeric? #=> true
+ *  nil.numeric? #=> false
+ *  "1.0".numeric? #=> false
+ * @return [bool] Whether +self+ is a numeric class
+ */
+static VALUE
+__impl_obj_numeric_p(VALUE self)
+{
+	return rb_num_numeric_p(self) ? Qtrue : Qfalse;
+}
+
+/**
+ * Returns the reciprocal of itself with +prec+ as decimal precision.
+ * <br>
+ * If it is a complex number, 
+ * computes (x / ||w||) - (y / ||w||) * i). 
+ * <br>
+ * Where ||w|| = x^2 + y^2.
+ * 
+ * @example
+ *  3.reciprocal(20) #=> 0.33333333333333333333e0
+ *  -0.0.reciprocal(20) #=> -Infinity
+ *  1/3r.reciprocal(20) #=> 0.300000000000000000003e1
+ *  (3.5r+1.5ri).reciprocal(20) #=> (0.24137931034482758621e0-0.10344827586206896552e0i)
+ * @param prec [Integer] Arbitrary precision
+ * @return [BigDecimal] Real solution
+ * @return [Complex] Complex solution
+ */
+static VALUE
+__impl_numeric_reciprocal(VALUE self, VALUE prec)
+{
+	if (rb_num_real_p(self))
+		return rb_num_canonicalize(self, prec, ARG_REAL, ARG_RECIPROCAL);
+	else
+		return rb_num_canonicalize(self, prec, ARG_COMPLEX, ARG_RECIPROCAL);
+}
+
+void
+InitVM_Overrides(void)
+{
+	rb_define_method(rb_cNumeric, "nan?", numeric_nan_p, 0);
+	rb_define_singleton_method(rb_cComplex, "imaginary_z", __impl_nucomp_s_imaginary_z, 1);
+	rb_define_method(rb_cObject, "numeric?", __impl_obj_numeric_p, 0);
+	rb_define_method(rb_cNumeric, "reciprocal", __impl_numeric_reciprocal, 1);
+}