num4simdiff 0.0.2 → 0.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: eb95aa62cec23aba9d5dce5d67ab559e413ca450e8f27b582daee07705d8ab25
-  data.tar.gz: ceccfc8d500e2494a03c7446a2c10e52a04c9b74c9baa158e23bcfbe7ef9917c
+  metadata.gz: bbcf09943d885f3b0cbf0a59397859d39fbb8b74073952b3886e5103da0764d5
+  data.tar.gz: 5332e037a491ffcf970aa863eb5310d57db35c9e29fdbf3795f9585bab67e086
 SHA512:
-  metadata.gz: 8dc2d88b4b0ea780065be4d11188cd7e4abe300281aab215513afe106bfd3ba91a91d5947fc6029a9be0471a364488d7714f5f2ffc230029484a8c8804c09e1b
-  data.tar.gz: ea0a990c0c5a2a9b377eae6b72205db0d20141c1bad6ffe795fdd5bdcdacb92d1871f3ca734d3664bcbb9ac00bfb9270dd0103e03208739dff72464aa819e73a
+  metadata.gz: 6fbc94177cb48dbb77ce6d173309f132647f70ee42ca03d79ade6033d8e034cbad53288a869e4afacd2db56133425870f55e578a67b44bcc16b6cd0f8dfb43b6
+  data.tar.gz: 50688bd54df072e060cf2e503de3d9016e8743ca8d9e39c63c1c5c792f060e40c18d9607cb78c11515e9514b3dce303187c75c20507a292cdcfd0391b59d153b

data/.yardopts

@@ -0,0 +1 @@
+--no-private

data/CHANGELOG.md

@@ -2,6 +2,16 @@
 
 ## Unreleased
 
+## [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,10 +4,12 @@
 #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_doDmy(int n, double *yi, double h, Func func);
+static double* CNum4SimDiff_doEulerMethod(int n, double *yi, double h, Func func);
+static double* CNum4SimDiff_doHeunMethod(int n, double *yi, double h, Func func);
+static double* CNum4SimDiff_doRungeKuttaMethod(int n, double *yi, double h, Func func);
 static CNum4SimDiff _cNum4SiDiff = {
+    .FP_dmy              = CNum4SimDiff_doDmy,
     .FP_eulerMethod      = CNum4SimDiff_doEulerMethod,
     .FP_heunMethod       = CNum4SimDiff_doHeunMethod,
     .FP_rungeKuttaMethod = CNum4SimDiff_doRungeKuttaMethod,
@@ -18,43 +20,48 @@ static CNum4SimDiff _cNum4SiDiff = {
 /**************************************/
 /* Class部                            */
 /**************************************/
-double* CNum4SimDiff_eulerMethod(double *yi, double xi, double h, Func func1, Func func2)
+double* CNum4SimDiff_dmy(int n, double *yi, double h, Func func)
 {
-    assert(func1 != 0);
-    assert(func2 != 0);
+    assert(func != 0);
 
-    return _cNum4SiDiff.FP_eulerMethod(yi, xi, h, func1, func2);
+    return _cNum4SiDiff.FP_dmy(n, yi, h, func);
 }
-double* CNum4SimDiff_heunMethod(double *yi, double xi, double h, Func func1, Func func2)
+double* CNum4SimDiff_eulerMethod(int n, double *yi, double h, Func func)
 {
-    assert(func1 != 0);
-    assert(func2 != 0);
+    assert(func != 0);
 
-    return _cNum4SiDiff.FP_heunMethod(yi, xi, h, func1, func2);
+    return _cNum4SiDiff.FP_eulerMethod(n, yi,  h, func);
 }
-double* CNum4SimDiff_rungeKuttaMethod(double *yi, double xi, double h, Func func1, Func func2)
+double* CNum4SimDiff_heunMethod(int n, double *yi, double h, Func func)
 {
-    assert(func1 != 0);
-    assert(func2 != 0);
+    assert(func != 0);
 
-    return _cNum4SiDiff.FP_rungeKuttaMethod(yi, xi, h, func1, func2);
+    return _cNum4SiDiff.FP_heunMethod(n, yi, h, func);
+}
+double* CNum4SimDiff_rungeKuttaMethod(int n, double *yi, double h, Func func)
+{
+    assert(func != 0);
+
+    return _cNum4SiDiff.FP_rungeKuttaMethod(n, yi, h, func);
 }
 /**************************************/
 /* 処理実行部                         */
 /**************************************/
+static double* CNum4SimDiff_doDmy(int n, double *yi, double h, Func func)
+{
+    return func(2, yi);
+}
 /* 
  * オイラー法
  */
-static double* CNum4SimDiff_doEulerMethod(double *yi, double xi, double h, Func func1, Func func2)
+static double* CNum4SimDiff_doEulerMethod(int n, double *yi, double h, Func func)
 {
     int i;
-    double *f = malloc(sizeof(double) * N);
-    double *yi_1 = malloc(sizeof(double) * N);
+    double *f = func(n, yi);
+    double *yi_1 = malloc(sizeof(double) * n);
 
-    f[0] = func1(xi, yi[1]);
-    f[1] = func2(xi, yi[1]);
     // 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 +69,39 @@ 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, Func func)
 {
     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 *f = func(n, yi);
+    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]);
     // 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, Func func)
 {
     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 *f = func(n, yi);
+    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]);
     // 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,23 @@
 /* 構造体宣言                          */
 /**************************************/
 typedef struct _CNum4SimDiff CNum4SimDiff;
-typedef double (*Func)(double x, double dx);
+typedef double* (*Func)(int n, double* yi);
 
 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_dmy)(int n, double *yi, double h, Func func);
+    double* (*FP_eulerMethod)(int n, double *yi, double h, Func func);
+    double* (*FP_heunMethod)(int n, double *yi, double h, Func func);
+    double* (*FP_rungeKuttaMethod)(int n, double *yi, double h, Func func);
 };
 /**************************************/
 /* 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_dmy(int n, double *yi, double h, Func func);
+double* CNum4SimDiff_eulerMethod(int n, double *yi, double h, Func func);
+double* CNum4SimDiff_heunMethod(int n, double *yi, double h, Func func);
+double* CNum4SimDiff_rungeKuttaMethod(int n, double *yi, double h, Func func);
 #endif

data/lib/num4simdiff.rb

@@ -7,76 +7,85 @@ module Num4SimDiffLib
 
     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
+    # @overload f(n, yn)
+    #   dy = f(n, yn)
+    #   @yield [n, yn] dy = f(n, yn)
+    #   @yieldparam [int] n ynの個数
+    #   @yieldparam [pointer] yn FFI::Pointer
+    #   @return [pointer] xiに対するyの値(FFI::Pointer)
+    callback   :f, [:int, :pointer], :pointer
 
+    attach_function :dmyFFI,
+        :CNum4SimDiff_dmy, [:int, :buffer_in, :double, :f], :pointer
     attach_function :eulerMethodFFI,
-        :CNum4SimDiff_eulerMethod, [:buffer_in, :double, :double, :f, :f], :pointer
+        :CNum4SimDiff_eulerMethod, [:int, :buffer_in, :double, :f], :pointer
     attach_function :heunMethodFFI,
-        :CNum4SimDiff_heunMethod, [:buffer_in, :double, :double, :f, :f], :pointer
+        :CNum4SimDiff_heunMethod, [:int, :buffer_in, :double,  :f], :pointer
     attach_function :rungeKuttaMethodFFI,
-        :CNum4SimDiff_rungeKuttaMethod, [:buffer_in, :double, :double, :f, :f], :pointer
+        :CNum4SimDiff_rungeKuttaMethod, [:int, :buffer_in, :double, :f], :pointer
     class << self
+        # @private
+        def dmy(yi, h, func)
+          n = yi.size
+          yi_ptr = cnvRbAry2pt(n, yi)
+          yi_1_ptr = dmyFFI(n, yi_ptr, h, func)
+          yi_1 = cnvPt2RbAry(n, yi_1_ptr)
+        end
         #
         # オイラー法による数値計算
-        # @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の値(配列)
         #
-        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
+          yi_ptr = cnvRbAry2pt(n, yi)
+          yi_1_ptr = eulerMethodFFI(n, yi_ptr, h, func)
+          yi_1 = cnvPt2RbAry(n, yi_1_ptr)
+          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の値(配列)
         #
-        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
+          yi_ptr = cnvRbAry2pt(n, yi)
+          yi_1_ptr = heunMethodFFI(n, yi_ptr, h, func)
+          yi_1 = cnvPt2RbAry(n, yi_1_ptr)
+          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の値(配列)
         #
-        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
+          yi_ptr = cnvRbAry2pt(n, yi)
+          yi_1_ptr = rungeKuttaMethodFFI(n, yi_ptr, h, func)
+          yi_1 = cnvPt2RbAry(n, yi_1_ptr)
+          return yi_1
         end
 
         #
-        # @private
-        #
+        # ruby配列からFFI::Pointer型に変換
+        # @overload  cnvRbAry2pt(n, ary)
+        # @param [int] n 配列の個数
+        # @param [double[]] ary yiの値(配列)
+        # @return [pointer] FFI::Pointer
         def cnvRbAry2pt(n, ary)
             yi_ptr = FFI::MemoryPointer.new(:double, n)
             n.times.map { |i|
@@ -85,8 +94,11 @@ module Num4SimDiffLib
             return yi_ptr   
         end
         #
-        # @private
-        #
+        # FFI::Pointer型からruby配列に変換
+        # @overload  cnvPt2RbAry(n, pt)
+        # @param [int] n 配列の個数
+        # @param [pointer] pt FFI::Pointer
+        # @return [double[]] yiの値(配列)
         def cnvPt2RbAry(n, pt)
           rbAry = n.times.map { |i|
              pt.get_double(i * Fiddle::SIZEOF_DOUBLE)
@@ -96,7 +108,5 @@ module Num4SimDiffLib
         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.2
+  version: 0.1.1
 platform: ruby
 authors:
 - siranovel
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2023-04-30 00:00:00.000000000 Z
+date: 2023-05-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ffi-compiler
@@ -57,6 +57,7 @@ extensions:
 - ext/num4simdiff/Rakefile
 extra_rdoc_files: []
 files:
+- ".yardopts"
 - CHANGELOG.md
 - Gemfile
 - LICENSE
@@ -69,7 +70,7 @@ licenses:
 - MIT
 metadata:
   changelog_uri: http://github.com/siranovel/num4simdiffrent/blob/main/CHANGELOG.md
-  documentation_uri: https://rubydoc.info/gems/num4simdiff/0.0.2
+  documentation_uri: https://rubydoc.info/gems/num4simdiff/0.1.1
   homepage_uri: http://github.com/siranovel/num4simdiffrent
 post_install_message: 
 rdoc_options: