num4anova 0.0.10-java → 0.0.12-java

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3dc8b0870b6c837111c8c59d391502dcea83fa1bb055834ccbe89823d24ba64a
-  data.tar.gz: d079fbc907bb2b0f72dc79affb51441efbbad8973842703194dac216be783e0b
+  metadata.gz: 87febfd8031fd924430223c93fad6b0606aa212ab109e1b758db2c1d23b6dace
+  data.tar.gz: 48b610b93d2c5341f05c25ef230acea09b02fa75c924129f5dafba56fcb6051f
 SHA512:
-  metadata.gz: 2ab2456e85fa85bb45fe021e5e6606353f7d957874ac6f5fe8f335ab78a4449c50f866ce5b8af14c5cfb5ece7b61bffc700c499d584e0d16df14c1d4e2370ab2
-  data.tar.gz: 0e43ed4956da47b8964f4f129ef27b46333c18f4c1cd84af0826f7f533ca7df185e2e9af83ce4cea202ad15d2115e4ed80c4335adfb7cf69654f39fbfd430af5
+  metadata.gz: 979fe122d0cf17086e80a45ff6c44b67153822a8d89d83bceb84a25d3d68190f087c3ed8bf4b192e9afd48a38b3ec0d1456fa0821c84256113154e04d5a6e461
+  data.tar.gz: 0bcad9f7a234a96759697440f540f0caddf70c1a25cf46409dead11478faa0017cfe9e98d2a23feaad2648bea641d5bca80cb73adab5001ec46d93ef8899ce70

data/CHANGELOG.md

@@ -2,6 +2,16 @@
 
 ## Unreleased
 
+## [0.0.12] - 2024-03-27
+
+### add
+- add fuction of interval_estim.
+
+## [0.0.11] - 2024-03-21
+
+### add
+- add fuction of difference_test.
+
 ## [0.0.10] - 2024-03-05
 
 ### add

data/ext/num4anova/Ancova.java

@@ -1,4 +1,5 @@
 import org.apache.commons.math3.distribution.FDistribution;
+import org.apache.commons.math3.distribution.TDistribution;
 
 public class Ancova {
     private static Ancova ancova = new Ancova();
@@ -17,6 +18,17 @@ public class Ancova {
         double statistic = hypoth.calcTestStatistic(xi);
         return hypoth.executeTest(statistic, a);
     }
+    public boolean differenceTest(double[][][] xi, double a) {
+        HypothesisTest hypoth = new DifferenceTest();
+
+        double statistic = hypoth.calcTestStatistic(xi);
+        return hypoth.executeTest(statistic, a);
+    }
+    public Interval intervalEstim(double[][][] xi, double a) {
+        Estim estim = new IntervalEstim();
+
+        return estim.calcInterval(xi, a);
+    }
     /*********************************/
     /* interface define              */
     /*********************************/
@@ -24,9 +36,22 @@ public class Ancova {
         double calcTestStatistic(double[][][] xi);
         boolean executeTest(double statistic, double a);
     }
+    private interface Estim {
+        Interval calcInterval(double[][][] xi, double a);
+    }
     /*********************************/
     /* class define                  */
     /*********************************/
+    public class Interval {
+        private double min;
+        private double max;
+        public Interval(double min, double max) {
+            this.min = min;
+            this.max = max;
+        }
+        public double getMin() { return this.min; }
+        public double getMax() { return this.max; }
+    }
     private class RegressionLine {
         protected int calcSumn(double[][][] xi) {
             int sum = 0;
@@ -36,34 +61,54 @@ public class Ancova {
             }
             return sum;
         }
-        protected double calcSex(double[][][] xi, int sumn) {
+        // 全変動
+        private double calcSty(double[][][] xi, int sumn) {
+            double sumy2 = calcSumy2(xi);
+            double sumy = calcSumy(xi);
+
+            return sumy2 - sumy*sumy / sumn;
+        }
+        private double calcStx(double[][][] xi, int sumn) {
             double sumx2 = calcSumx2(xi);
             double sumx = calcSumx(xi);
 
-            double sumtx = sumx2 - sumx*sumx / sumn;
-            double sumax = calcSumax(xi) - sumx*sumx / sumn;
+            return sumx2 - sumx*sumx / sumn;
+        }
+        private double calcStyx(double[][][] xi, int sumn) {
+            double sumx = calcSumx(xi);
+            double sumy = calcSumy(xi);
+            double sumyx = calcSumyx(xi);
 
-            return sumtx - sumax;
+            return sumyx - sumy*sumx / sumn;
         }
-        protected double calcSey(double[][][] xi, int sumn) {
-            double sumy2 = calcSumy2(xi);
+        // 水準間変動
+        private double calcSay(double[][][] xi, int sumn) {
             double sumy = calcSumy(xi);
 
-            double sumay = calcSumay(xi) - sumy*sumy / sumn;
-            double sumty = sumy2 - sumy*sumy / sumn;
+            return calcSumay(xi) - sumy*sumy / sumn;
+        }
+        private double calcSax(double[][][] xi, int sumn) {
+            double sumx = calcSumx(xi);
 
-            return sumty - sumay;
+            return calcSumax(xi) - sumx*sumx / sumn;
         }
-        protected double calcSeyx(double[][][] xi, int sumn) {
+        private double calcSayx(double[][][] xi, int sumn) {
             double sumx = calcSumx(xi);
             double sumy = calcSumy(xi);
-            double sumyx = calcSumyx(xi);
 
-            double sumayx = calcSumayx(xi) - sumy*sumx / sumn;
-            double sumtyx = sumyx - sumy*sumx / sumn;
-
-            return sumtyx - sumayx;
+            return calcSumayx(xi) - sumy*sumx / sumn;
+        }
+        // 水準内変動
+        protected double calcSex(double[][][] xi, int sumn) {
+            return calcStx(xi, sumn) - calcSax(xi, sumn);
+        }
+        protected double calcSey(double[][][] xi, int sumn) {
+            return calcSty(xi, sumn) - calcSay(xi, sumn);
+        }
+        protected double calcSeyx(double[][][] xi, int sumn) {
+            return calcStyx(xi, sumn) - calcSayx(xi, sumn);
         }
+
         // 平行性の検定
         protected double calcbx(double[][][] xi) {
             double sum = 0.0;
@@ -89,8 +134,20 @@ public class Ancova {
             }
             return sum;
         }
+        // 差の検定
+        protected double calcSa(double[][][] xi, int sumn) {
+            double sumty = calcSty(xi, sumn);
+            double sumtyx = calcStyx(xi, sumn);
+            double sumtx  = calcStx(xi, sumn);
+            double sumey  = calcSey(xi, sumn);
+            double sumeyx = calcSeyx(xi, sumn);
+            double sumex  = calcSex(xi, sumn);
 
+            return (sumty - sumtyx * sumtyx / sumtx)
+                 - (sumey - sumeyx * sumeyx / sumex);
+        }
 
+        // ETC
         private double calcSumay(double[][][] xi) {
             double sum = 0.0;
 
@@ -157,7 +214,6 @@ public class Ancova {
             }
             return sum;
         }
-        // 水準間変動
         private double calcSumax(double[][][] xi) {
             double sum = 0.0;
 
@@ -180,6 +236,7 @@ public class Ancova {
             }
             return sum;
         }
+
     }
     // 回帰直線モデルの平行性の検定
     private class Parallettest extends RegressionLine implements HypothesisTest {
@@ -232,6 +289,7 @@ public class Ancova {
 
             double vr = calcVr(xi, sumn);
             double ve = calcVe(xi, sumn);
+
             return vr / ve;
         }
         public boolean executeTest(double statistic, double a) {
@@ -254,5 +312,116 @@ public class Ancova {
             return (sumey * sumex - sumeyx * sumeyx) / (m * sumex);
         }
     }
+    // 水準間の差の検定
+    private class DifferenceTest 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 - xi.length - 1;
+
+            double va = calcSa(xi, sumn) / n;
+            double ve = calcVe(xi, sumn);
+
+            return va / 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 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);
+        }
+    }
+    //
+    private class IntervalEstim extends RegressionLine 
+                                implements Estim {
+        private int n = 0;
+        private int[] ni = null;
+        private double sumex = 0.0;
+        public Interval calcInterval(double[][][] xi, double a) {
+            ni = calcNi(xi);
+            int sumn = calcSumn(xi);
+            n = sumn - xi.length - 1;
+            sumex = calcSex(xi, sumn);
+            double ve = calcVe(xi, sumn);
+            double b = calcB(xi, sumn);
+
+            double[] meanyi = calcMeanyi(xi);
+            double[] meanxi = calcMeanxi(xi);
+            double meanx = calcMeanx(xi);
+
+            TDistribution tDist = new TDistribution(n);
+            double t = tDist.inverseCumulativeProbability(1.0 - a / 2.0);
+            double wk = (meanxi[0] - meanx);
+            double wk2 = t * Math.sqrt((1/ni[0] + wk * wk / sumex) * ve);
+            double min = meanyi[0] - b * wk - wk2;
+            double max = meanyi[0] - b * wk + wk2;
+
+            return new Interval(min, max);
+        }
+        private int[] calcNi(double[][][] xi) {
+            int[] ni = new int[xi.length];
+
+            for(int i = 0; i < xi.length; i++) {
+                ni[i] = xi[i].length;
+            }
+            return ni;
+        }
+        private double calcVe(double[][][] xi, int sumn) {
+            double sumey = calcSey(xi, sumn);
+            double sumeyx = calcSeyx(xi, sumn);
+
+            return (sumey * sumex - sumeyx * sumeyx) / (n * sumex);
+        }
+        private double calcB(double[][][] xi, int sumn) {
+            double sumeyx = calcSeyx(xi, sumn);
+            double sex = calcSex(xi, sumn);
+            
+            return sumeyx / sex;
+        }
+        private double[] calcMeanyi(double[][][] xi) {
+            double[] meanyi = new double[xi.length];
+
+            for(int i = 0; i < xi.length; i++) {
+                double sum = 0.0;
+                for(int j = 0; j < xi[i].length; j++) {
+                    sum += xi[i][j][0];
+                }
+                meanyi[i] = sum / xi[i].length;
+            }
+            return meanyi;
+        }
+        private double[] calcMeanxi(double[][][] xi) {
+            double[] meanxi = new double[xi.length];
+
+            for(int i = 0; i < xi.length; i++) {
+                double sum = 0.0;
+                for(int j = 0; j < xi[i].length; j++) {
+                    sum += xi[i][j][1];
+                }
+                meanxi[i] = sum / xi[i].length;
+            }
+            return meanxi;
+        }
+        private double calcMeanx(double[][][] xi) {
+            double sum = 0.0;
+            double n = 0;
+            for(int i = 0; i < xi.length; i++) {
+                for(int j = 0; j < xi[i].length; j++) {
+                    sum += xi[i][j][1];
+                    n++;
+                }
+            }
+            return sum / n;
+        }
+    }
 }
 

data/lib/num4anova.rb

@@ -256,7 +256,7 @@ module Num4AnovaLib
         end
         # 回帰直線の有意性検定
         #
-        # @overload significance_testt(xi, a)
+        # @overload significance_test(xi, a)
         #   @param [array]  xi データ(double[][][])
         #   @param [double] a  有意水準
         #   @return [boolean]  検定結果(boolean true:棄却域内 false:棄却域外)
@@ -284,6 +284,72 @@ module Num4AnovaLib
         def significance_test(xi, a)
             @ancova.significanceTest(xi.to_java(Java::double[][]), a)
         end
+        # 水準間の差の検定
+        #
+        # @overload difference_test(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.difference_test(xi, 0.05)
+        #    => true
+        def difference_test(xi, a)
+            @ancova.differenceTest(xi.to_java(Java::double[][]), a)
+        end
+        # 区間推定
+        #
+        # @overload interval_estim(xi, a)
+        #   @param [array]  xi データ(double[][][])
+        #   @param [double] a  有意水準
+        #   @return [Hash]  (min:下限信頼区間 max:上限信頼区間)
+        # @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.interval_estim(xi, 0.05)
+        #    =>
+        #      {:min=>4.466605469341916, :max=>7.1909253948556096}
+        def interval_estim(xi, a)
+            retJava = @ancova.intervalEstim(xi.to_java(Java::double[][]), a)
+            retHash = {
+                "min": retJava.getMin(),
+                "max": retJava.getMax()
+            }
+            return retHash
+        end
     end
 end
 

metadata

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