num4equ 0.0.8 → 0.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: df19fd2bb0a886f566c14a1cbfc2a4cc27de3f720a6cd96fa664e10d14a5d412
-  data.tar.gz: 31f369bdc107b02c4aa6472dc38c5ebcecd46f4ec74f380d24c0d4f2c003685d
+  metadata.gz: 0f4d45a4303869d3bc6c7a47da7dddf6cc67f47e6de2f96be6d0e04a2f0fefd0
+  data.tar.gz: 4c4cc2f0c5c88d016826d5575df652ce113a7c934bf693332eac4e5d8d8a43fa
 SHA512:
-  metadata.gz: c45aa264ded3405d2e9fac971f3dc79ed51fb135a577b823ac64b463a6c2a7d52684897e46d791bb985310b6f3da449759c77006ab143a80966fdbbb00740546
-  data.tar.gz: ed545922c2a69db002d7d49b6caeb583caac170292e2e4503831ed178bcccefc85b6079d00fcdee9ff77d2b5aac4eeff3e61f1674d3087907798a89fd5fcfa52
+  metadata.gz: d897598486152d6fba6a732d36a4d4b725fe99b78b2720c12c43e0bf39d8f0c0e0db2825068c6a2a4c91490f806596279b2b429e3d2e267fe9dd87ee1bf6d498
+  data.tar.gz: 19c36fde2ef67d634e5bb6c206a94b589ca302cc0d3ddafb3fefea902dac03a0e326b3005b702f6a65fa4e016c26c0a668e2a5fdba627822cb3c1b6a80f2209d

data/CHANGELOG.md

@@ -2,10 +2,23 @@
 
 ## Unreleased
 
+## [0.1.1] - 2023-05-20
+
+### fixed
+- fix use definition of derivative for newtonMethod  
+
+### Added
+- Add wiki_rui into file of gemspec.
+
+## [0.0.9] - 2023-04-18 
+
+### Added
+- Add function of secantMethod.
+
 ## [0.0.8] - 2023-04-17 
 
 ### Added
-- Add file of LICENSE.
+- Add file of CHANGELOH.md.
 
 ## [0.0.7] - 2023-03-17
 

data/ext/num4equ/CNum4Equ.c

@@ -4,12 +4,14 @@
 #include <math.h>
 #include "CNum4Equ.h"
 
-static double CNum4Equ_doNewtonMethodFFI(double a, Func func, DFunc dFunc, int *ok);
+static double CNum4Equ_doNewtonMethodFFI(double a, Func func, int *ok);
 static double CNum4Equ_doBisectionMethodFFI(double a, double b, Func func, int *ok);
+static double CNum4Equ_doSecantMethodFFI(double a, double b, Func func, int *ok);
 
 static CNum4Equ _cNum4Equ = {
     .FP_newtonMethodFFI = CNum4Equ_doNewtonMethodFFI,
     .FP_bisectionMethodFFI = CNum4Equ_doBisectionMethodFFI,
+    .FP_secantMethodFFI = CNum4Equ_doSecantMethodFFI,
 };
 
 /**************************************/
@@ -18,12 +20,11 @@ static CNum4Equ _cNum4Equ = {
 /**************************************/
 /* Class部                            */
 /**************************************/
-double CNum4Equ_newtonMethodFFI(double a, Func func, DFunc dFunc, int *ok)
+double CNum4Equ_newtonMethodFFI(double a, Func func, int *ok)
 {
     assert(func != 0);
-    assert(dFunc != 0);
 
-    return _cNum4Equ.FP_newtonMethodFFI(a, func, dFunc, ok);
+    return _cNum4Equ.FP_newtonMethodFFI(a, func, ok);
 }
 double CNum4Equ_bisectionMethodFFI(double a, double b, Func func, int *ok)
 {
@@ -32,33 +33,48 @@ double CNum4Equ_bisectionMethodFFI(double a, double b, Func func, int *ok)
 
     return _cNum4Equ.FP_bisectionMethodFFI(a, b, func, ok);
 }
+double CNum4Equ_secantMethodFFI(double a, double b, Func func, int *ok)
+{
+    assert(func != 0);
+    assert(a < b);
+
+    return _cNum4Equ.FP_secantMethodFFI(a, b, func, ok);
+}
 /**************************************/
-/* 処理実行部                         */
+/* 処理実行部                          */
 /**************************************/
-static double CNum4Equ_doNewtonMethodFFI(double a, Func func, DFunc dFunc, int *ok)
+/*
+ * ニュートン法
+ */
+static double CNum4Equ_doNewtonMethodFFI(double a, Func func, int *ok)
 {
-    double xn;
-    double x0 = a;
+    double xn = a;
+    double xn_1;
     long idx = 0;
 
     *ok = 0;
-    xn = x0;
     do {
-        double f;
+        double fx;
+        double fxh;
         double df;
 
-        x0 = xn;
-        f = func(x0);
-        df = dFunc(x0);
-        xn = -1 * f / df + x0;
+        fx = func(xn);
+        fxh = func(xn + DX);
+        df = (fxh - fx) / DX;
+        xn_1 = xn + -1 * fx / df;
+        if (fabs(xn_1 - xn) < EPS) break;
+        xn = xn_1;
         idx++;
         if (100000 < idx) {
             *ok = -1;
             break;
         } 
-    } while(fabs(xn - x0) > EPS);
+    } while(1);
     return xn;
 }
+/*
+ * ２分法
+ */
 static double CNum4Equ_doBisectionMethodFFI(double a, double b, Func func, int *ok)
 {
     double fa = func(a);
@@ -81,4 +97,35 @@ static double CNum4Equ_doBisectionMethodFFI(double a, double b, Func func, int *
     } while(fxc != 0 && fabs(b - a) > EPS);
     return xc; 
 }
+/*
+ * 割線法
+ */
+static double CNum4Equ_doSecantMethodFFI(double a, double b, Func func, int *ok)
+{
+    double new_x = 0.0;
+    double x_n = b;
+    double x_n_1 = a;
+    double fa = 0.0;
+    double fb = 0.0;
+    double df;
+    long idx = 0;
+
+    *ok = 0; 
+    do {
+        fa = func(x_n_1);
+        fb = func(x_n);
+        df = (x_n - x_n_1 ) / (fb - fa);
+        new_x = x_n - fb * df;
+        if (fabs(fb * df) < EPS) break;
+        if (fabs(func(new_x)) < EPS) break;
+        idx++;
+        if (100000 < idx) {
+            *ok = -1;
+            break;
+        } 
+        x_n_1 = x_n;
+        x_n = new_x;
+    } while(1);
+    return new_x;
+}
 

data/ext/num4equ/CNum4Equ.h

@@ -6,20 +6,22 @@
 /**********************************************/
 typedef struct _CNum4Equ CNum4Equ;
 typedef double (*Func)(double x);
-typedef double (*DFunc)(double x);
 
 struct _CNum4Equ
 {
-    double (*FP_newtonMethodFFI)(double a, Func func, DFunc dFunc, int *ok);
+    double (*FP_newtonMethodFFI)(double a, Func func, int *ok);
     double (*FP_bisectionMethodFFI)(double a, double b, Func func, int *ok);
+    double (*FP_secantMethodFFI)(double a, double b, Func func, int *ok);
 };
 /**********************************************/
 /* definen宣言                                */
 /**********************************************/
-#define EPS (1.0e-6)
+#define EPS (1.0e-7)
+#define DX  0.001
 /**********************************************/
 /* プロトタイプ宣言                           */
 /**********************************************/
-double CNum4Equ_newtonMethodFFI(double a, Func func, DFunc dFunc, int *ok);
+double CNum4Equ_newtonMethodFFI(double a, Func func, int *ok);
 double CNum4Equ_bisectionMethodFFI(double a, double b, Func func, int *ok);
+double CNum4Equ_secantMethodFFI(double a, double b, Func func, int *ok);
 #endif

data/lib/num4equ.rb

@@ -8,24 +8,28 @@ module Num4EquLib
     extend FFI::Library
 
     ffi_lib FFI::Compiler::Loader.find('num4equ') 
+    # @overload func(a)
+    #   @yield [a] 関数  
+    #   @yieldparam [double] aの値
+    #   @return [double] xの値
     callback   :f, [:double], :double
-    callback   :df, [:double], :double
 
     attach_function :newtonMethodFFI,
-        :CNum4Equ_newtonMethodFFI, [:double, :f, :df, :buffer_out], :double
+        :CNum4Equ_newtonMethodFFI, [:double, :f, :buffer_out], :double
     attach_function :bisectionMethodFFI,
         :CNum4Equ_bisectionMethodFFI, [:double, :double, :f, :buffer_out], :double
+    attach_function :secantMethodFFI,
+        :CNum4Equ_secantMethodFFI, [:double, :double, :f, :buffer_out], :double
     class << self
-        # @overload newtonMethod(a, func, dfunc)
+        # @overload newtonMethod(a, func)
         #   ニュートン法による解法
         #   @param [double] a aの値
         #   @param [callback] func aに対する値を計算
-        #   @param [callback] dfunc fに対する微分関数
         #   @return [double] xの値
         #   @raise RangeError
-        def newtonMethod(a, func, dfunc)
+        def newtonMethod(a, func)
             ok_ptr = FFI::MemoryPointer.new :int 
-            x = newtonMethodFFI(a, func, dfunc, ok_ptr)
+            x = newtonMethodFFI(a, func, ok_ptr)
             ok = ok_ptr.read_int
             ok_ptr.free()
             if ok < 0 then
@@ -50,7 +54,25 @@ module Num4EquLib
             end
             return x
         end
-
-        private :newtonMethodFFI, :bisectionMethodFFI
+        # @overload secantMethod(a, b, func)
+        #   割線法による解法
+        #   @param [double] a aの値
+        #   @param [double] b bの値
+        #   @param [callback] func aに対する値を計算
+        #   @return [double] xの値
+        #   @raise RangeError
+        def secantMethod(a, b, func)
+            ok_ptr = FFI::MemoryPointer.new :int 
+            x = secantMethodFFI(a, b, func, ok_ptr)
+            ok = ok_ptr.read_int
+            ok_ptr.free()
+            if ok < 0 then
+                raise RangeError.new("a:" + a.to_s + " " + "b:" + b.to_s)
+            end
+            return x
+        end
+        private :newtonMethodFFI
+        private :bisectionMethodFFI
+        private :secantMethodFFI
     end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: num4equ
 version: !ruby/object:Gem::Version
-  version: 0.0.8
+  version: 0.1.1
 platform: ruby
 authors:
 - siranovel
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2023-04-16 00:00:00.000000000 Z
+date: 2023-05-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ffi-compiler
@@ -69,8 +69,9 @@ licenses:
 - MIT
 metadata:
   changelog_uri: http://github.com/siranovel/num4equation/blob/main/CHANGELOG.md
-  documentation_uri: https://rubydoc.info/gems/num4equ/0.0.8
+  documentation_uri: https://rubydoc.info/gems/num4equ/0.1.1
   homepage_uri: http://github.com/siranovel/num4equation
+  wiki_uri: https://github.com/siranovel/mydocs/tree/main/num4equation
 post_install_message: 
 rdoc_options: []
 require_paths: