num4anova 0.0.9-java → 0.0.10-java

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f5d31afc9315035a148a1b2a755ecc64422c64d82c548378c8f4ea3bb940d91d
-  data.tar.gz: 249a18fb9ec372037d32b1bafc4ba37d35916e8d3fe25a96fc576f627e8ab89b
+  metadata.gz: 3dc8b0870b6c837111c8c59d391502dcea83fa1bb055834ccbe89823d24ba64a
+  data.tar.gz: d079fbc907bb2b0f72dc79affb51441efbbad8973842703194dac216be783e0b
 SHA512:
-  metadata.gz: de66c54f9facc61769f2a40c4b936bcc8a6e93cfe8eb1d2d185504b9d9e59cfd6dc45654a2ec7f26a6a72c7debfef00396058a1c0db405b47e4deed7963382be
-  data.tar.gz: 908b725baa8aa4b68102b66f65fb789cc496124283e210dfd0b7c05dac4c6e22701e3c2e5bcb16c6ec01631aa3b20a8e50908b994f3dfd78e8f5804dfb245391
+  metadata.gz: 2ab2456e85fa85bb45fe021e5e6606353f7d957874ac6f5fe8f335ab78a4449c50f866ce5b8af14c5cfb5ece7b61bffc700c499d584e0d16df14c1d4e2370ab2
+  data.tar.gz: 0e43ed4956da47b8964f4f129ef27b46333c18f4c1cd84af0826f7f533ca7df185e2e9af83ce4cea202ad15d2115e4ed80c4335adfb7cf69654f39fbfd430af5

data/CHANGELOG.md

@@ -2,6 +2,11 @@
 
 ## Unreleased
 
+## [0.0.10] - 2024-03-05
+
+### add
+- add fuction of significance_test.
+
 ## [0.0.9] - 2024-03-02
 
 ### add

data/ext/num4anova/Ancova.java

@@ -11,6 +11,12 @@ public class Ancova {
         double statistic = hypoth.calcTestStatistic(xi);
         return hypoth.executeTest(statistic, a);
     }
+    public boolean significanceTest(double[][][] xi, double a) {
+        HypothesisTest hypoth = new SignificanceTest();
+
+        double statistic = hypoth.calcTestStatistic(xi);
+        return hypoth.executeTest(statistic, a);
+    }
     /*********************************/
     /* interface define              */
     /*********************************/
@@ -21,101 +27,113 @@ public class Ancova {
     /*********************************/
     /* class define                  */
     /*********************************/
-    // 回帰直線モデルの平行性の検定
-    private class Parallettest implements HypothesisTest {
-        private int n = 0;
-        private int m = 0;
-        public double calcTestStatistic(double[][][] xi) {
-            int sumn = calcSumn(xi);
-            double sumx = calcSumx(xi);
-            double sumy = calcSumy(xi);
-            n = xi.length - 1;
-            m = sumn - 2 * xi.length;
+    private class RegressionLine {
+        protected int calcSumn(double[][][] xi) {
+            int sum = 0;
 
-        // 全変動
+            for(int i = 0; i < xi.length; i++) {
+                sum += xi[i].length;
+            }
+            return sum;
+        }
+        protected double calcSex(double[][][] xi, int sumn) {
             double sumx2 = calcSumx2(xi);
-            double sumy2 = calcSumy2(xi);
-            double sumyx = calcSumyx(xi);
+            double sumx = calcSumx(xi);
 
             double sumtx = sumx2 - sumx*sumx / sumn;
-            double sumty = sumy2 - sumy*sumy / sumn;
-            double sumtyx = sumyx - sumy*sumx / sumn;
-
-        // 水準間変動
             double sumax = calcSumax(xi) - sumx*sumx / sumn;
-            double sumay = calcSumay(xi) - sumy*sumy / sumn;
-            double sumayx = calcSumayx(xi) - sumy*sumx / sumn;
 
-        // 水準内変動
-            double sumex = sumtx - sumax;
-            double sumey = sumty - sumay;
-            double sumeyx = sumtyx - sumayx;
+            return sumtx - sumax;
+        }
+        protected double calcSey(double[][][] xi, int sumn) {
+            double sumy2 = calcSumy2(xi);
+            double sumy = calcSumy(xi);
 
-            double sumbx = calcbx(xi);
-            double sumnp = sumbx - sumeyx * sumeyx / sumex;
-            double sume2 = sumey - sumbx;
+            double sumay = calcSumay(xi) - sumy*sumy / sumn;
+            double sumty = sumy2 - sumy*sumy / sumn;
 
-       // 
-            double vnp = sumnp / n;
-            double ve2 = sume2 / m;
-            return vnp / ve2;
+            return sumty - sumay;
         }
-        public boolean executeTest(double statistic, double a) {
-            FDistribution fDist = new FDistribution(n, m);
-            double f = fDist.inverseCumulativeProbability(1.0 - a);
+        protected double calcSeyx(double[][][] xi, int sumn) {
+            double sumx = calcSumx(xi);
+            double sumy = calcSumy(xi);
+            double sumyx = calcSumyx(xi);
 
-            return (statistic >= f) ? true : false;
+            double sumayx = calcSumayx(xi) - sumy*sumx / sumn;
+            double sumtyx = sumyx - sumy*sumx / sumn;
+
+            return sumtyx - sumayx;
         }
-        private int calcSumn(double[][][] xi) {
-            int sum = 0;
+        // 平行性の検定
+        protected double calcbx(double[][][] xi) {
+            double sum = 0.0;
 
-            for(int i = 0; i < xi.length; i++) {
-                sum += xi[i].length;
+            for (int i = 0; i < xi.length; i++) {
+                int n = xi[i].length;
+                double sumx = 0.0;
+                double sumy = 0.0;
+                double sumyx = 0.0;
+                double sumx2 = 0.0;
+                for (int j = 0; j < n; j++) {
+                    sumx +=  xi[i][j][1];
+                    sumy +=  xi[i][j][0];
+                    sumyx += xi[i][j][1] * xi[i][j][0];
+
+                    sumx2 += xi[i][j][1] * xi[i][j][1];
+
+                }
+                double wki = n * sumyx - sumy * sumx;
+                double wk = wki * wki / (n * (n * sumx2 - sumx * sumx));
+
+                sum += wk;
             }
             return sum;
         }
-        // 全変動
-        private double calcSumx(double[][][] xi) {
+
+
+        private double calcSumay(double[][][] xi) {
             double sum = 0.0;
 
             for (int i = 0; i < xi.length; i++) {
+                double sumyi = 0.0;
                 for (int j = 0; j < xi[i].length; j++) {
-                    sum += xi[i][j][1];
+                    sumyi += xi[i][j][0];
                 }
+                sum += sumyi * sumyi / xi[i].length;
             }
             return sum;
         }
-        private double calcSumy(double[][][] xi) {
+        private double calcSumy2(double[][][] xi) {
             double sum = 0.0;
 
             for (int i = 0; i < xi.length; i++) {
                 for (int j = 0; j < xi[i].length; j++) {
-                    sum += xi[i][j][0];
+                    sum += xi[i][j][0] * xi[i][j][0];
                 }
             }
             return sum;
         }
-        private double calcSumx2(double[][][] xi) {
+        private double calcSumx(double[][][] xi) {
             double sum = 0.0;
 
             for (int i = 0; i < xi.length; i++) {
                 for (int j = 0; j < xi[i].length; j++) {
-                    sum += xi[i][j][1] * xi[i][j][1];
+                    sum += xi[i][j][1];
                 }
             }
             return sum;
         }
-        private double calcSumy2(double[][][] xi) {
+        protected double calcSumx2(double[][][] xi) {
             double sum = 0.0;
 
             for (int i = 0; i < xi.length; i++) {
                 for (int j = 0; j < xi[i].length; j++) {
-                    sum += xi[i][j][0] * xi[i][j][0];
+                    sum += xi[i][j][1] * xi[i][j][1];
                 }
             }
             return sum;
         }
-        private double calcSumyx(double[][][] xi) {
+        protected double calcSumyx(double[][][] xi) {
             double sum = 0.0;
 
             for (int i = 0; i < xi.length; i++) {
@@ -125,70 +143,115 @@ public class Ancova {
             }
             return sum;
         }
-        // 水準間変動
-        private double calcSumax(double[][][] xi) {
+        private double calcSumayx(double[][][] xi) {
             double sum = 0.0;
 
             for (int i = 0; i < xi.length; i++) {
                 double sumxi = 0.0;
+                double sumyi = 0.0;
                 for (int j = 0; j < xi[i].length; j++) {
                     sumxi += xi[i][j][1];
+                    sumyi += xi[i][j][0];
                 }
-                sum += sumxi * sumxi / xi[i].length;
+                sum += sumxi * sumyi / xi[i].length;
             }
             return sum;
-
         }
-        private double calcSumay(double[][][] xi) {
+        // 水準間変動
+        private double calcSumax(double[][][] xi) {
             double sum = 0.0;
 
             for (int i = 0; i < xi.length; i++) {
-                double sumyi = 0.0;
+                double sumxi = 0.0;
                 for (int j = 0; j < xi[i].length; j++) {
-                    sumyi += xi[i][j][0];
+                    sumxi += xi[i][j][1];
                 }
-                sum += sumyi * sumyi / xi[i].length;
+                sum += sumxi * sumxi / xi[i].length;
             }
             return sum;
         }
-        private double calcSumayx(double[][][] xi) {
+        private double calcSumy(double[][][] xi) {
             double sum = 0.0;
 
             for (int i = 0; i < xi.length; i++) {
-                double sumxi = 0.0;
-                double sumyi = 0.0;
                 for (int j = 0; j < xi[i].length; j++) {
-                    sumxi += xi[i][j][1];
-                    sumyi += xi[i][j][0];
+                    sum += xi[i][j][0];
                 }
-                sum += sumxi * sumyi / xi[i].length;
             }
             return sum;
         }
-        // 平行性の検定
-        private double calcbx(double[][][] xi) {
-            double sum = 0.0;
+    }
+    // 回帰直線モデルの平行性の検定
+    private class Parallettest extends RegressionLine implements HypothesisTest {
+        private int n = 0;
+        private int m = 0;
+        public double calcTestStatistic(double[][][] xi) {
+            int sumn = calcSumn(xi);
+            n = xi.length - 1;
+            m = sumn - 2 * xi.length;
+ 
+            double vnp = calcVnp(xi, sumn);
+            double ve2 = calcVe2(xi, sumn);
 
-            for (int i = 0; i < xi.length; i++) {
-                int n = xi[i].length;
-                double sumx = 0.0;
-                double sumy = 0.0;
-                double sumyx = 0.0;
-                double sumx2 = 0.0;
-                for (int j = 0; j < n; j++) {
-                    sumx +=  xi[i][j][1];
-                    sumy +=  xi[i][j][0];
-                    sumyx += xi[i][j][1] * xi[i][j][0];
+            return vnp / ve2;
+        }
+        private double calcVnp(double[][][] xi, int sumn){
+            return calcSnp(xi, sumn) / n;
+        }
+        private double calcSnp(double[][][] xi, int sumn) {
+            double sumbx = calcbx(xi);
+            double sumeyx = calcSeyx(xi, sumn);
+            double sumex = calcSex(xi, sumn);
 
-                    sumx2 += xi[i][j][1] * xi[i][j][1];
+            return sumbx - sumeyx * sumeyx / sumex;
+        }
+        private double calcVe2(double[][][] xi, int sumn) {
+            return calcSe2(xi, sumn) / m;
+        }
+        private double calcSe2(double[][][] xi, int sumn) {
+            double sumey = calcSey(xi, sumn);
+            double sumbx = calcbx(xi);
 
-                }
-                double wki = n * sumyx - sumy * sumx;
-                double wk = wki * wki / (n * (n * sumx2 - sumx * sumx));
+            return sumey - sumbx;
+        }
+        public boolean executeTest(double statistic, double a) {
+            FDistribution fDist = new FDistribution(n, m);
+            double f = fDist.inverseCumulativeProbability(1.0 - a);
 
-                sum += wk;
-            }
-            return sum;
+            return (statistic >= f) ? true : false;
+        }
+    }
+    // 回帰直線モデルの平行性の検定
+    private class SignificanceTest extends RegressionLine implements HypothesisTest {
+        private int n = 0;
+        private int m = 0;
+        public double calcTestStatistic(double[][][] xi) {
+            int sumn = calcSumn(xi);
+            n = 1;
+            m = sumn - xi.length - 1;
+
+            double vr = calcVr(xi, sumn);
+            double ve = calcVe(xi, sumn);
+            return vr / ve;
+        }
+        public boolean executeTest(double statistic, double a) {
+            FDistribution fDist = new FDistribution(n, m);
+            double f = fDist.inverseCumulativeProbability(1.0 - a);
+
+            return (statistic >= f) ? true : false;
+        }
+        private double calcVr(double[][][] xi, int sumn) {
+            double sumeyx = calcSeyx(xi, sumn);
+            double sumex = calcSex(xi, sumn);
+
+            return (sumeyx * sumeyx) / sumex;
+        }
+        private double calcVe(double[][][] xi, int sumn) {
+            double sumey = calcSey(xi, sumn);
+            double sumex = calcSex(xi, sumn);
+            double sumeyx = calcSeyx(xi, sumn);
+
+            return (sumey * sumex - sumeyx * sumeyx) / (m * sumex);
         }
     }
 }

data/lib/num4anova.rb

@@ -228,8 +228,8 @@ module Num4AnovaLib
         #
         # @overload parallel_test(xi, a)
         #   @param [array]  xi データ(double[][][])
-        #   @param [double] a         有意水準
-        #   @return [boolean] 検定結果(boolean true:棄却域内 false:棄却域外)
+        #   @param [double] a  有意水準
+        #   @return [boolean]  検定結果(boolean true:棄却域内 false:棄却域外)
         # @example
         #   xi = [
         #      [
@@ -254,6 +254,36 @@ module Num4AnovaLib
         def parallel_test(xi, a)
             @ancova.parallelTest(xi.to_java(Java::double[][]), a)
         end
+        # 回帰直線の有意性検定
+        #
+        # @overload significance_testt(xi, a)
+        #   @param [array]  xi データ(double[][][])
+        #   @param [double] a  有意水準
+        #   @return [boolean]  検定結果(boolean true:棄却域内 false:棄却域外)
+        # @example
+        #   xi = [
+        #      [
+        #          [3,35], [5,38], [3,39],
+        #      ],
+        #      [
+        #          [3,36], [3,39], [8,54],
+        #      ],
+        #      [
+        #          [2,40], [2,45], [2,39],
+        #      ],
+        #      [
+        #          [3,47], [4,52], [2,48],
+        #      ],
+        #      [
+        #          [1,64], [2,80], [0,70],
+        #      ],
+        #    ]
+        #    ancova = Num4AnovaLib::Num4AncovaLib.new
+        #    ancova.significance_test(xi, 0.05)
+        #    => true
+        def significance_test(xi, a)
+            @ancova.significanceTest(xi.to_java(Java::double[][]), a)
+        end
     end
 end
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: num4anova
 version: !ruby/object:Gem::Version
-  version: 0.0.9
+  version: 0.0.10
 platform: java
 authors:
 - siranovel
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2024-03-02 00:00:00.000000000 Z
+date: 2024-03-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake