num4simdiff 0.0.3 → 0.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 95091b2bd9e2416f649f80e1e5448759e7886de139a14444b685052cf7b20ee1
-  data.tar.gz: 236099213bb0bbc094763d2417491da6ba4fb42eca0cc4c0b3e194dd4d3c4ed9
+  metadata.gz: 61244490a74e2b2b27f14967ce4d45cc073cfe2323021a488babcd39f921995b
+  data.tar.gz: 57b1d91fa1b8e7c1e0114eb749722f9a25a5bb60613608a4b5db30f8a375910a
 SHA512:
-  metadata.gz: 5707ff3d96a6f47054da58fa00b345d2099942d9c79c8461f86546c348c51a2205be8beeccdecfc0074ef39b46c825989a2a2a0b31229ce3d03d8cdde388fc93
-  data.tar.gz: e29c905c5df822e684813c9d6daa5e5aa2a2e51971fa7d767701773a8c12cf7313b3e491d3a5e13ce4f85113255715f8570fca5afcce16df94e938df80bb28ed
+  metadata.gz: f3f0e6cc7764903302b93212e93b58e46a04703950c229bb9e3775bf4cd28a90e1d8f18010f9007c25b762ce76c005f97bb1e19f45a46c4aa72c14c50819248b
+  data.tar.gz: f60265b9f41b006209937b8cf055ff7043658033dd66fc92c48f9e098fecbd599c8d5c9cd442dd98e002a251be422338bbbb6b20448c99eaa7a6217995b14bd0

data/CHANGELOG.md

@@ -2,6 +2,22 @@
 
 ## Unreleased
 
+## [0.2.1] - 2023-05-08
+
+### Fixed
+- change cnvRbAry2pt to private
+- change cnvPt2RbAry to private
+
+## [0.1.1] - 2023-05-02
+
+### Fixed
+- Fix support function of multiple 
+
+## [0.0.3] - 2023-05-01
+
+### Added
+- add file of .yardopts
+
 ## [0.0.2] - 2023-04-30
 
 ### Added

data/ext/num4simdiff/CNum4SimDiff.c

@@ -4,9 +4,9 @@
 #include <stdlib.h>
 #include "CNum4SimDiff.h"
 
-static double* CNum4SimDiff_doEulerMethod(double *yi, double xi, double h, Func func1, Func func2);
-static double* CNum4SimDiff_doHeunMethod(double *yi, double xi, double h, Func func1, Func func2);
-static double* CNum4SimDiff_doRungeKuttaMethod(double *yi, double xi, double h, Func func1, Func func2);
+static double* CNum4SimDiff_doEulerMethod(int n, double *yi, double h, double *f);
+static double* CNum4SimDiff_doHeunMethod(int n, double *yi, double h, double *f);
+static double* CNum4SimDiff_doRungeKuttaMethod(int n, double *yi, double h, double *f);
 static CNum4SimDiff _cNum4SiDiff = {
     .FP_eulerMethod      = CNum4SimDiff_doEulerMethod,
     .FP_heunMethod       = CNum4SimDiff_doHeunMethod,
@@ -18,26 +18,29 @@ static CNum4SimDiff _cNum4SiDiff = {
 /**************************************/
 /* Class部                            */
 /**************************************/
-double* CNum4SimDiff_eulerMethod(double *yi, double xi, double h, Func func1, Func func2)
+double* CNum4SimDiff_eulerMethod(int n, double *yi, double h, double *f)
 {
-    assert(func1 != 0);
-    assert(func2 != 0);
+    assert(f != 0);
+    assert(yi != 0);
+    assert( n > 0);
 
-    return _cNum4SiDiff.FP_eulerMethod(yi, xi, h, func1, func2);
+    return _cNum4SiDiff.FP_eulerMethod(n, yi,  h, f);
 }
-double* CNum4SimDiff_heunMethod(double *yi, double xi, double h, Func func1, Func func2)
+double* CNum4SimDiff_heunMethod(int n, double *yi, double h, double *f)
 {
-    assert(func1 != 0);
-    assert(func2 != 0);
+    assert(f != 0);
+    assert(yi != 0);
+    assert( n > 0);
 
-    return _cNum4SiDiff.FP_heunMethod(yi, xi, h, func1, func2);
+    return _cNum4SiDiff.FP_heunMethod(n, yi, h, f);
 }
-double* CNum4SimDiff_rungeKuttaMethod(double *yi, double xi, double h, Func func1, Func func2)
+double* CNum4SimDiff_rungeKuttaMethod(int n, double *yi, double h, double *f)
 {
-    assert(func1 != 0);
-    assert(func2 != 0);
+    assert(f != 0);
+    assert(yi != 0);
+    assert( n > 0);
 
-    return _cNum4SiDiff.FP_rungeKuttaMethod(yi, xi, h, func1, func2);
+    return _cNum4SiDiff.FP_rungeKuttaMethod(n, yi, h, f);
 }
 /**************************************/
 /* 処理実行部                         */
@@ -45,16 +48,14 @@ double* CNum4SimDiff_rungeKuttaMethod(double *yi, double xi, double h, Func func
 /* 
  * オイラー法
  */
-static double* CNum4SimDiff_doEulerMethod(double *yi, double xi, double h, Func func1, Func func2)
+static double* CNum4SimDiff_doEulerMethod(int n, double *yi, double h, double *f)
 {
     int i;
-    double *f = malloc(sizeof(double) * N);
-    double *yi_1 = malloc(sizeof(double) * N);
+    double *yi_1 = malloc(sizeof(double) * n);
 
-    f[0] = func1(xi, yi[1]);
-    f[1] = func2(xi, yi[1]);
+    assert(yi_1 != 0);
     // yi_1 = yi + h * f(xi, y)
-    for (i = 0; i < N; i++) {
+    for (i = 0; i < n; i++) {
         yi_1[i] = yi[i] + h * f[i];
     }
     return yi_1;
@@ -62,43 +63,45 @@ static double* CNum4SimDiff_doEulerMethod(double *yi, double xi, double h, Func
 /*
  * ホイン法
  */
-static double* CNum4SimDiff_doHeunMethod(double *yi, double xi, double h, Func func1, Func func2)
+static double* CNum4SimDiff_doHeunMethod(int n, double *yi, double h, double *f)
 {
     int i;
-    double *f = malloc(sizeof(double) * N);
-    double *yi_1 = malloc(sizeof(double) * N);
-    double *k1 = malloc(sizeof(double) * N);
-    double *k2 = malloc(sizeof(double) * N);
+    double *yi_1 = malloc(sizeof(double) * n);
+    double *k1 = malloc(sizeof(double) * n);
+    double *k2 = malloc(sizeof(double) * n);
 
-    f[0] = func1(xi, yi[1]);
-    f[1] = func2(xi, yi[1]);
+    assert(yi_1 != 0);
+    assert(k1 != 0);
+    assert(k2 != 0);
     // k1 = h * f(xi, y)
     // k2 = h * f(xi + h, h * f(xi + h, yi + k1)
     // yi_1 = yi + (k1 + k2) / 2.0;
-    for (i = 0; i < N; i++) {
+    for (i = 0; i < n; i++) {
         k1[i] = h * f[i];
         k2[i] = h * (yi[i] + k1[i]);
         yi_1[i] = yi[i] + (k1[i] + k2[i]) / 2.0;
     }
     return yi_1;
 }
-static double* CNum4SimDiff_doRungeKuttaMethod(double *yi, double xi, double h, Func func1, Func func2)
+static double* CNum4SimDiff_doRungeKuttaMethod(int n, double *yi, double h, double *f)
 {
     int i;
-    double *f = malloc(sizeof(double) * N);
-    double *yi_1 = malloc(sizeof(double) * N);
-    double *k1 = malloc(sizeof(double) * N);
-    double *k2 = malloc(sizeof(double) * N);
-    double *k3 = malloc(sizeof(double) * N);
-    double *k4 = malloc(sizeof(double) * N);
+    double *yi_1 = malloc(sizeof(double) * n);
+    double *k1 = malloc(sizeof(double) * n);
+    double *k2 = malloc(sizeof(double) * n);
+    double *k3 = malloc(sizeof(double) * n);
+    double *k4 = malloc(sizeof(double) * n);
 
-    f[0] = func1(xi, yi[1]);
-    f[1] = func2(xi, yi[1]);
+    assert(yi_1 != 0);
+    assert(k1 != 0);
+    assert(k2 != 0);
+    assert(k3 != 0);
+    assert(k4 != 0);
     // k1 = h * f(xi, y)
     // k2 = h * f(xi + h / 2, yi + k1 / 2)
     // k3 = h * f(xi + h / 2, y1 + k2 / 2)
     // k4 = h * f(xi + h, yi + k3)
-    for (i = 0; i < N; i++) {
+    for (i = 0; i < n; i++) {
         k1[i] = h * f[i];
         k2[i] = h * (yi[i] + k1[i] / 2.0);
         k3[i] = h * (yi[i] + k2[i] / 2.0); 

data/ext/num4simdiff/CNum4SimDiff.h

@@ -5,22 +5,20 @@
 /* 構造体宣言                          */
 /**************************************/
 typedef struct _CNum4SimDiff CNum4SimDiff;
-typedef double (*Func)(double x, double dx);
 
 struct _CNum4SimDiff
 {
-    double* (*FP_eulerMethod)(double *yi, double xi, double h, Func func1, Func func2);
-    double* (*FP_heunMethod)(double *yi, double xi, double h, Func func1, Func func2);
-    double* (*FP_rungeKuttaMethod)(double *yi, double xi, double h, Func func1, Func func2);
+    double* (*FP_eulerMethod)(int n, double *yi, double h, double *f);
+    double* (*FP_heunMethod)(int n, double *yi, double h, double *f);
+    double* (*FP_rungeKuttaMethod)(int n, double *yi, double h, double *f);
 };
 /**************************************/
 /* define宣言                         */
 /**************************************/
-#define N 2
 /**************************************/
 /* プロトタイプ宣言                    */
 /**************************************/
-double* CNum4SimDiff_eulerMethod(double *yi, double xi, double h, Func func1, Func func2);
-double* CNum4SimDiff_heunMethod(double *yi, double xi, double h, Func func1, Func func2);
-double* CNum4SimDiff_rungeKuttaMethod(double *yi, double xi, double h, Func func1, Func func2);
+double* CNum4SimDiff_eulerMethod(int n, double *yi, double h, double *f);
+double* CNum4SimDiff_heunMethod(int n, double *yi, double h, double *f);
+double* CNum4SimDiff_rungeKuttaMethod(int n, double *yi, double h, double *f);
 #endif

data/lib/num4simdiff.rb

@@ -6,77 +6,100 @@ module Num4SimDiffLib
     extend FFI::Library
 
     ffi_lib FFI::Compiler::Loader.find('num4simdiff')
-
-    # @overload f(x, dx)
-    #   dy = f(x, dx)
-    #   @yield [x, dx] dy = f(x, dx)
-    #   @yieldparam [double] x xiの値
-    #   @yieldparam [double] dx xiの値
-    #   @return [double] xiに対するyの値
-    callback   :f, [:double, :double], :double
-
     attach_function :eulerMethodFFI,
-        :CNum4SimDiff_eulerMethod, [:buffer_in, :double, :double, :f, :f], :pointer
+        :CNum4SimDiff_eulerMethod, [:int, :buffer_in, :double, :buffer_in], :pointer
     attach_function :heunMethodFFI,
-        :CNum4SimDiff_heunMethod, [:buffer_in, :double, :double, :f, :f], :pointer
+        :CNum4SimDiff_heunMethod, [:int, :buffer_in, :double,  :buffer_in], :pointer
     attach_function :rungeKuttaMethodFFI,
-        :CNum4SimDiff_rungeKuttaMethod, [:buffer_in, :double, :double, :f, :f], :pointer
+        :CNum4SimDiff_rungeKuttaMethod, [:int, :buffer_in, :double, :buffer_in], :pointer
     class << self
         #
         # オイラー法による数値計算
-        # @overload eulerMethod(yi, xi, h, func1, func2)
-        #   yi_1 = eulerMethod(yi, xi, h, func1, func2)
-        #   @param [double] yi xiに対するyiの値(配列)
-        #   @param [double] xi xiの値
+        # @overload eulerMethod(yi, h, func)
+        #   yi_1 = eulerMethod(yi, h, func)
+        #   @param [double[]] yi xiに対するyiの値(配列)
         #   @param [double] h  刻み幅
-        #   @param [callback] func1 xiに対する傾きを計算する関数
-        #   @param [callback] func2 xiに対する傾きを計算する関数
-        #   @return [double] xi+hに対するyi_1の値(配列)
+        #   @param [callback] func xiに対する傾きを計算する関数
+        #   @return [double[]] xi+hに対するyi_1の値(配列)
+        # @example
+        #   func = Proc.new do | n, yi |
+        #     f = []
+        #     f[0] = yi[0]
+        #     f[1] = yi[1]
+        #     next f
+        #   end
+        #   yi = [1.0, 1.0] 
+        #   yi_1 =  Num4SimDiffLib.eulerMethod(yi, 0.001, func)
         #
-        def eulerMethod(yi, xi, h, func1, func2)
-          yi_ptr = cnvRbAry2pt(2, yi)
-          yi_1_ptr = eulerMethodFFI(yi_ptr, xi, h, func1, func2)
-          yi_1 = cnvPt2RbAry(2, yi_1_ptr)
-          return 1 + yi_1[0] + 0.5 * yi_1[1]
+        def eulerMethod(yi, h, func)
+          n = yi.size
+          f = func.call(n, yi)
+          f_ptr = cnvRbAry2pt(n, f)
+          yi_ptr = cnvRbAry2pt(n, yi)
+          yi_1_ptr = eulerMethodFFI(n, yi_ptr, h, f_ptr)
+          yi_1 = cnvPt2RbAry(n, yi_1_ptr)
+          f_ptr.free()
+          return yi_1
         end
         #
         # ホイン法による数値計算
-        # @overload heunMethod(yi, xi, h, func1, func2)
-        #   yi_1 = heunMethod(yi, xi, h, func1, func2)
-        #   @param [double] yi xiに対するyiの値(配列)
-        #   @param [double] xi xiの値
+        # @overload heunMethod(yi, h, func)
+        #   yi_1 = heunMethod(yi, h, func)
+        #   @param [double[]] yi xiに対するyiの値(配列)
         #   @param [double] h  刻み幅
-        #   @param [callback] func1 xiに対する傾きを計算する関数
-        #   @param [callback] func2 xiに対する傾きを計算する関数
-        #   @return [double] xi+hに対するyi_1の値(配列)
+        #   @param [callback] func xiに対する傾きを計算する関数
+        #   @return [double[]] xi+hに対するyi_1の値(配列)
+        # @example
+        #   func = Proc.new do | n, yi |
+        #     f = []
+        #     f[0] = yi[0]
+        #     f[1] = yi[1]
+        #     next f
+        #   end
+        #   yi = [1.0, 1.0] 
+        #   yi_1 =  Num4SimDiffLib.heunMethod(yi, 0.001, func)
         #
-        def heunMethod(yi, xi, h, func1, func2)
-          yi_ptr = cnvRbAry2pt(2, yi)
-          yi_1_ptr = heunMethodFFI(yi_ptr, xi, h, func1, func2)
-          yi_1 = cnvPt2RbAry(2, yi_1_ptr)
-          return 1 + yi_1[0] + 0.5 * yi_1[1] 
+        def heunMethod(yi, h, func)
+          n = yi.size
+          f = func.call(n, yi)
+          f_ptr = cnvRbAry2pt(n, f)
+          yi_ptr = cnvRbAry2pt(n, yi)
+          yi_1_ptr = heunMethodFFI(n, yi_ptr, h, f_ptr)
+          yi_1 = cnvPt2RbAry(n, yi_1_ptr)
+          f_ptr.free()
+          return yi_1
         end
         #
         # 4次のルンゲ＝クッタ法による数値計算
-        # @overload  rungeKuttaMethod(yi, xi, h, func1, func2)
-        #   yi_1 = rungeKuttaMethod(yi, xi, h, func1, func2)
-        #   @param [double] yi xiに対するyiの値(配列)
-        #   @param [double] xi xiの値
+        # @overload  rungeKuttaMethod(yi, h, func)
+        #   yi_1 = rungeKuttaMethod(yi, h, func)
+        #   @param [double[]] yi xiに対するyiの値(配列)
         #   @param [double] h  刻み幅
-        #   @param [callback] func1 xiに対する傾きを計算する関数
-        #   @param [callback] func2 xiに対する傾きを計算する関数
-        #   @return [double] xi+hに対するyi_1の値(配列)
+        #   @param [callback] func xiに対する傾きを計算する関数
+        #   @return [double[]] xi+hに対するyi_1の値(配列)
+        # @example
+        #   func = Proc.new do | n, yi |
+        #     f = []
+        #     f[0] = yi[0]
+        #     f[1] = yi[1]
+        #     next f
+        #   end
+        #   yi = [1.0, 1.0] 
+        #   yi_1 =  Num4SimDiffLib.rungeKuttaMethod(yi, 0.001, func)
         #
-        def rungeKuttaMethod(yi, x, h, func1, func2)
-          yi_ptr = cnvRbAry2pt(2, yi)
-          yi_1_ptr = rungeKuttaMethodFFI(yi_ptr, x, h, func1, func2)
-          yi_1 = cnvPt2RbAry(2, yi_1_ptr)
-          return 1 + yi_1[0] + 0.5 * yi_1[1]
+        def rungeKuttaMethod(yi, h, func)
+          n = yi.size
+          f = func.call(n, yi)
+          f_ptr = cnvRbAry2pt(n, f)
+          yi_ptr = cnvRbAry2pt(n, yi)
+          yi_1_ptr = rungeKuttaMethodFFI(n, yi_ptr, h, f_ptr)
+          yi_1 = cnvPt2RbAry(n, yi_1_ptr)
+          f_ptr.free()
+          return yi_1
         end
 
         #
         # @private
-        #
         def cnvRbAry2pt(n, ary)
             yi_ptr = FFI::MemoryPointer.new(:double, n)
             n.times.map { |i|
@@ -86,17 +109,16 @@ module Num4SimDiffLib
         end
         #
         # @private
-        #
         def cnvPt2RbAry(n, pt)
           rbAry = n.times.map { |i|
              pt.get_double(i * Fiddle::SIZEOF_DOUBLE)
           }
           return rbAry  
         end
+        private :cnvRbAry2pt
+        private :cnvPt2RbAry
         private :eulerMethodFFI
         private :heunMethodFFI
         private :rungeKuttaMethodFFI
-        private :cnvRbAry2pt
-        private :cnvPt2RbAry
     end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: num4simdiff
 version: !ruby/object:Gem::Version
-  version: 0.0.3
+  version: 0.2.1
 platform: ruby
 authors:
 - siranovel
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2023-05-01 00:00:00.000000000 Z
+date: 2023-05-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ffi-compiler
@@ -70,10 +70,12 @@ licenses:
 - MIT
 metadata:
   changelog_uri: http://github.com/siranovel/num4simdiffrent/blob/main/CHANGELOG.md
-  documentation_uri: https://rubydoc.info/gems/num4simdiff/0.0.3
+  documentation_uri: https://rubydoc.info/gems/num4simdiff/0.2.1
   homepage_uri: http://github.com/siranovel/num4simdiffrent
+  wiki_uri: https://github.com/siranovel/mydocs/tree/main/num4simdiff
 post_install_message: 
-rdoc_options: []
+rdoc_options:
+- "--no-private"
 require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement