bigdecimal-math_r 0.2.0

data/ext/bigdecimal/math_r/trig.c

@@ -0,0 +1,205 @@
+/*******************************************************************************
+	trig.c -- Trigonometric Function
+
+	Author: tribusonz
+	Licence: MIT
+*******************************************************************************/
+#include <ruby.h>
+#include "math_r/globals.h"
+#include "math_r/bigmath_r.h"
+#include "decl.h"
+
+
+/**
+ * Computes at once sine and cosine of +x+.
+ * 
+ * @param x [Numeric] Numerical argument
+ * @param prec [Integer] Arbitrary precision
+ * @return [Array] Real solutions [sin(x), cos(x)]
+ * @raise [ArgumentError] Occurs when +prec+ is not a positive integer.
+ * @raise [TypeError] Occurs when +x+ is not a numeric class.
+ * @example
+ *  BigMathR::Trig.sincos(1, 20)
+ *  #=> [0.84147098480789650665e0, 0.5403023058681397174e0]
+ * @since 0.1.0
+ */
+static VALUE
+__impl_trig_sincos(VALUE unused_obj, VALUE x, VALUE prec)
+{
+	VALUE sin, cos, t;
+	rb_check_precise(prec);
+	x = rb_num_canonicalize(x, prec, ARG_REAL, ARG_RAWVALUE);
+	x = rb_bigmath_to_rad(x, prec, &t);
+	if (-1 == rb_bigmath_degree_sparg(t, prec, &sin, &cos))
+		rb_bigmath_sincos(x, prec, &sin, &cos);
+	sin = rb_num_round(sin, prec);
+	cos = rb_num_round(cos, prec);
+	return rb_assoc_new(sin, cos);
+}
+
+
+/**
+ * Computes sine of +x+. 
+ * <br>
+ * +x+ gives in radian.
+ * 
+ * @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::Trig.sin(1, 20)
+ *  #=> 0.84147098480789650665e0
+ * @since 0.1.0
+ */
+static VALUE
+__impl_trig_sin(VALUE unused_obj, VALUE x, VALUE prec)
+{
+	return sin_branch(x, prec, sin_ser);
+}
+
+
+/**
+ * Computes cosine of +x+.
+ * <br>
+ * +x+ gives in radian.
+ * 
+ * @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::Trig.cos(1, 20)
+ *  #=> 0.5403023058681397174e0
+ * @since 0.1.0
+ */
+static VALUE
+__impl_trig_cos(VALUE unused_obj, VALUE x, VALUE prec)
+{
+	return cos_branch(x, prec, cos_ser);
+}
+
+
+/**
+ * Computes tangent of +x+.
+ * <br>
+ * +x+ gives in radian.
+ * 
+ * @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::Trig.tan(1, 20)
+ *  #=> 0.15574077246549022305e1
+ * @since 0.1.0
+ */
+static VALUE
+__impl_trig_tan(VALUE unused_obj, VALUE x, VALUE prec)
+{
+	return tan_branch(x, prec, tan_ser);
+}
+
+/**
+ * Computes cosecant of +x+.
+ * <br>
+ * +x+ gives in radian.
+ * 
+ * @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::Trig.csc(1, 20)
+ *  #=> 0.11883951057781212163e1
+ * @since 0.1.0
+ */
+static VALUE
+__impl_trig_csc(VALUE unused_obj, VALUE x, VALUE prec)
+{
+	return csc_branch(x, prec, csc_ser);
+}
+
+/**
+ * Computes secant of +x+.
+ * <br>
+ * +x+ gives in radian.
+ * 
+ * @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::Trig.sec(1, 20)
+ *  #=> 0.18508157176809256179e1
+ * @since 0.1.0
+ */
+static VALUE
+__impl_trig_sec(VALUE unused_obj, VALUE x, VALUE prec)
+{
+	return sec_branch(x, prec, sec_ser);
+}
+
+
+/**
+ * Computes cotangent of +x+.
+ * <br>
+ * +x+ gives in radian.
+ * 
+ * @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::Trig.cot(1, 20)
+ *  #=> 0.64209261593433070301e0
+ * @since 0.1.0
+ */
+static VALUE
+__impl_trig_cot(VALUE unused_obj, VALUE x, VALUE prec)
+{
+	return cot_branch(x, prec, cot_ser);
+}
+
+/**
+ * Document-module: BigMathR::Trig
+ * 
+ * A module that provide the trigonometric functions.
+ * It is used internally.
+ * <br>
+ * All module functions are implemented by +:sincos+.
+ * <br>
+ * == Synopsis
+ * The function names defined are the same as those in the C/C++ standard.
+ * <br>
+ * - Sine:                +:sin+ <br>
+ * - Cosine:              +:cos+ <br>
+ * - Tangent:             +:tan+ <br>
+ * Follow, those reciprocals of not defined in C/C++ standard.
+ * <br>
+ * - Cosecant:            +:csc+ <br>
+ * - Secant:              +:sec+ <br>
+ * - Cotangent:           +:cot+ <br>
+ * The following are GNU extensions:
+ * <br>
+ * - sincos():            +:sincos+ <br>
+ * Reference::
+ * Kiso kara hatten made Sankaku kansuu (Japanese) - Michimasa Kobayashi (Beret Shuppan)
+ */
+void
+InitVM_Trig(void)
+{
+	rb_define_module_function(rb_mTrig, "sincos", __impl_trig_sincos, 2);
+	rb_define_module_function(rb_mTrig, "sin", __impl_trig_sin, 2);
+	rb_define_module_function(rb_mTrig, "cos", __impl_trig_cos, 2);
+	rb_define_module_function(rb_mTrig, "tan", __impl_trig_tan, 2);
+	rb_define_module_function(rb_mTrig, "csc", __impl_trig_csc, 2);
+	rb_define_module_function(rb_mTrig, "sec", __impl_trig_sec, 2);
+	rb_define_module_function(rb_mTrig, "cot", __impl_trig_cot, 2);
+}

data/lib/bigdecimal/math_r/const/EulerGamma_engel.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+require 'bigdecimal'
+
+module BigMathR
+  module Const
+    module EulerGamma
+      module_function
+      # Implement by Engel expansion.
+      # 
+      # @example
+      #  BigMathR::Const::EulerGamma.engel(20)
+      #  #=> 0.57721566490153286061e0
+      # @param prec [Integer] Arbitrary precision
+      # @return [BigDecimal] Euler-Mascheroni constant gamma
+      # @raise [TypeError] not an Integer
+      # @raise [RangeError] Zero or negative precision
+      # @see https://oeis.org/A053977
+      def engel(prec)
+        raise TypeError, "precision must be an Integer" unless prec.class == Integer
+        raise RangeError, "Zero or negative precision" if prec <= 0
+        n = BigDecimal.double_fig + prec
+
+        f = File.open(__dir__ + '/b053977/b053977.txt', 'r')
+        g = 1
+        fread = -> do
+          raise "there is no more list" if f.eof?
+          _, coef = f.readline.chomp.split(' ');
+          raise "expansion maximum reached" if coef.nil?
+          g *= coef.to_i
+        end
+
+        d = BigDecimal(1)
+        y = BigDecimal(0)
+
+        while d.nonzero? && ((m = n - (y.exponent - d.exponent).abs) > 0)
+          m = BigDecimal.double_fig if m < BigDecimal.double_fig
+          d = BigDecimal(Rational(1, fread.call), m)
+          y += d
+        end
+        y.round(prec)
+      end
+    end
+  end
+end
+

data/lib/bigdecimal/math_r/const/LOG2_bbp2007.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module BigMathR
+  module Const
+    module LOG2
+      module_function
+      # Implement by BBP's formula (Bailey et al. 2007)
+      # 
+      # @example
+      #  BigMathR::Const::LOG2.bbp2007(20)
+      #  #=> 0.69314718055994530942e0
+      # @param prec [Integer] Arbitrary precision
+      # @return [BigDecimal] Natural logarithm of 2
+      # @raise [TypeError] not an Integer
+      # @raise [RangeError] Zero or negative precision
+      def bbp2007(prec)
+        raise TypeError, "precision must be an Integer" unless prec.class == Integer
+        raise RangeError, "Zero or negative precision" if prec <= 0
+
+        n = prec + BigDecimal.double_fig
+        one = BigDecimal(1)
+        two = BigDecimal(2)
+        i1 = one
+        i2 = two
+        d = one
+        y = BigDecimal(0)
+
+        while d.nonzero? && ((m = n - (y.exponent - d.exponent).abs) > 0)
+          m = BigDecimal.double_fig if m < BigDecimal.double_fig
+          d = one.div(i1 * i2, m)
+          y = y + d
+          i1 += one
+          i2 *= two
+        end
+        y.round(prec)
+      end
+    end
+  end
+end

data/lib/bigdecimal/math_r/const/PI_chudnovsky.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+require 'bigdecimal/math'
+
+module BigMathR
+  module Const
+    module PI
+      module_function
+      # Implement by Chudnovsky's formula
+      # 
+      # @example
+      #  BigMathR::Const::PI.chudnovsky(20)
+      #  #=> 0.31415926535897932385e1
+      # @param prec [Integer] Arbitrary precision
+      # @return [BigDecimal] Constant PI
+      # @raise [TypeError] not an Integer
+      # @raise [RangeError] Zero or negative precision
+      def chudnovsky(prec)
+        raise TypeError, "precision must be an Integer" unless prec.class == Integer
+        raise RangeError, "Zero or negative precision" if prec <= 0
+
+        zero = BigDecimal(0)
+        one = BigDecimal(1)
+
+        n = prec + BigDecimal.double_fig
+
+        m1_640320_3 = BigDecimal(-1/262537412640768000r, n)
+        p90856689_711822400 = BigDecimal(90856689/711822400r, n)
+        p90856689_711822400 *= BigDecimal(10005).sqrt(n)
+
+        _C = one
+        _AB = BigDecimal(13591409/545140134r, n)
+        _F = 1r
+
+        d = one
+        y = zero
+
+        i = 0
+
+        while d.nonzero? && ((m = n - (y.exponent - d.exponent).abs) > 0)
+          m = BigDecimal.double_fig if m < BigDecimal.double_fig
+
+          d = BigDecimal(_F, m).mult(_AB * _C, m)
+          y = y + d
+
+          _AB += one
+          _C *= m1_640320_3
+          i = i.succ
+          (6 * i - 5).step(6 * i) {|k| _F *= k}
+          (3 * i - 2).step(3 * i) {|k| _F /= k}
+          3.times { _F /= i }
+        end
+        
+        y = y.mult(p90856689_711822400, n)
+        one.div(y, prec)
+      end
+    end
+  end
+end

data/lib/bigdecimal/math_r/const/PI_euler.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require 'bigdecimal/math'
+
+module BigMathR
+  module Const
+    module PI
+      module_function
+      # Implement by Euler's formula.
+      # 
+      # @example
+      #  BigMathR::Const::PI.euler(20)
+      #  #=> 0.31415926535897932385e1
+      # @param prec [Integer] Arbitrary precision
+      # @return [BigDecimal] Constant PI
+      # @raise [TypeError] not an Integer
+      # @raise [RangeError] Zero or negative precision
+      def euler(prec)
+        raise TypeError, "precision must be an Integer" unless prec.class == Integer
+        raise RangeError, "Zero or negative precision" if prec <= 0
+        n = BigDecimal.double_fig + prec
+        one = BigDecimal(1)
+        two = BigDecimal(2)
+        s = BigDecimal(0)
+        t = one
+        t1 = BigDecimal(0)
+        t2 = one
+        n = prec + BigDecimal.double_fig
+        while t.nonzero? && ((m = n - (s.exponent - t.exponent).abs) > 0)
+          m = BigDecimal.double_fig if m < BigDecimal.double_fig
+          s = s + t
+          t1 = t1 + one;  t = t.mult(t1, m)
+          t2 = t2 + two;  t = t.div(t2, m)
+        end
+        two.mult(s, prec)
+      end
+    end
+  end
+end
+

data/lib/bigdecimal/math_r/const/PI_ramanujan1.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require 'bigdecimal/math'
+
+module BigMathR
+  module Const
+    module PI
+      module_function
+      # Implement by Ramanujan's formula.
+      # 
+      # @example
+      #  BigMathR::Const::PI.ramanujan1(20)
+      #  #=> 0.31415926535897932385e1
+      # @param prec [Integer] Arbitrary precision
+      # @return [BigDecimal] Constant PI
+      # @raise [TypeError] not an Integer
+      # @raise [RangeError] Zero or negative precision
+      def ramanujan1(prec)
+        raise TypeError, "precision must be an Integer" unless prec.class == Integer
+        raise RangeError, "Zero or negative precision" if prec <= 0
+        n = BigDecimal.double_fig + prec
+
+        i = 0
+        r = 1/9801r
+        k = 1103
+
+        d = BigDecimal(1)
+        y = BigDecimal(0)
+
+        while d.nonzero? && ((m = n - (y.exponent - d.exponent).abs) > 0)
+          m = BigDecimal.double_fig if m < BigDecimal.double_fig
+          d = BigDecimal(r * k, m)
+          y = y + d
+          i = i.succ
+          k += 26390
+          r *= (2 * i - 1) * (4 * i - 3) * (4 * i - 1)
+          r /= 96059601
+          r /= 32
+          3.times { r /= i }
+        end
+        BigDecimal(2).sqrt(n).div(y * BigDecimal(4), prec)
+      end
+    end
+  end
+end

data/lib/bigdecimal/math_r/const/PI_ramanujan2.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+require 'bigdecimal/math'
+
+module BigMathR
+  module Const
+    module PI
+      module_function
+      # Implement by Ramanujan's formula.
+      # 
+      # @example
+      #  BigMathR::Const::PI.ramanujan2(20)
+      #  #=> 0.31415926535897932385e1
+      # @param prec [Integer] Arbitrary precision
+      # @return [BigDecimal] Constant PI
+      # @raise [TypeError] not an Integer
+      # @raise [RangeError] Zero or negative precision
+      def ramanujan2(prec)
+        raise TypeError, "precision must be an Integer" unless prec.class == Integer
+        raise RangeError, "Zero or negative precision" if prec <= 0
+        n = BigDecimal.double_fig + prec
+
+        i = 0
+        r = 1/882r
+        k = 1123
+
+        d = BigDecimal(1)
+        y = BigDecimal(0)
+
+        while d.nonzero? && ((m = n - (y.exponent - d.exponent).abs) > 0)
+          m = BigDecimal.double_fig if m < BigDecimal.double_fig
+          d = BigDecimal(r * k, m)
+          y = y + d
+          i = i.succ
+          k += 21460
+          r = -r
+          r *= (2 * i - 1) * (4 * i - 3) * (4 * i - 1)
+          r /= 777924
+          r /= 32
+          3.times { r /= i }
+        end
+        BigDecimal(4).div(y, prec)
+      end
+    end
+  end
+end