num4anova 0.0.4-java → 0.0.6-java

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ca0164a7092861bfca67f257129332375e90bfae762365194ced78ef75a293a7
-  data.tar.gz: 16f17fb717e3d92c27c4c651e034704cd81609a3adc293555eac54f9209884be
+  metadata.gz: 4dd60df363d899af7ca69bca4cb1da1689548f083abaacfd6441d5a589bf3501
+  data.tar.gz: 84469385e378cde1eddc3521582aefd2f5b2adce84e76d0c8a4c23bdd40d9374
 SHA512:
-  metadata.gz: e14efb373cde03fc5872f3dfb1d4186e5d2263b0b7597970d1629c562cfb6696ecf2cdbfc3325aa2d732e252241de093c156b7d9da21b51a8ea305f3e24e0e0f
-  data.tar.gz: c9b7f310d00d060d1c6fee3e8e9f5c43fce812a65d51b192315c72a378de7e2bc775e1118346373a93047c1cd8880240d03d52309ec0d8f567481923f14e31b4
+  metadata.gz: 7a036fe08363781f31b3583d7c7a454131680413e9c3aaeb0ebe135eec930912807e3f84be688d8bf70e1e56eafdefef0a3425f07eb18d6d042549dc2f7dd893
+  data.tar.gz: 7d7c136e1e457c08ac341fc542be1590888c233c161034eeff0f67d3d1466b4879ccd49c5f2a83e2f42f18f28a0279d66909d768d616afabf24b59be36a7e4e4

data/CHANGELOG.md

@@ -2,6 +2,16 @@
 
 ## Unreleased
 
+## [0.0.6] - 2024-02-04
+
+### add
+- add function of twoway2_anova.
+
+## [0.0.5] - 2024-02-01
+
+### add
+- add function of twoway_anova.
+
 ## [0.0.4] - 2024-01-30
 ### add
 - add function of replicate_plot

data/ext/num4anova/OneWayLayout.java

@@ -58,7 +58,7 @@ public class OneWayLayout {
         OneWayAnovaTest oneway = new BartletTest();
 
         double statistic = oneway.calcTestStatistic(xi);
-        return oneway.test(statistic, a);
+        return oneway.execute_test(statistic, a);
     }
     public void replicatePlot(String dname, Map<String, double[]> vals) {
         ChartPlot plot = new ReplicateChartPlot();
@@ -70,7 +70,7 @@ public class OneWayLayout {
         OneWayAnovaTest oneway = new ReplicateTest();
 
         double statistic = oneway.calcTestStatistic(xi);
-        return oneway.test(statistic, a);
+        return oneway.execute_test(statistic, a);
     }
     /*********************************/
     /* interface define              */
@@ -91,7 +91,7 @@ public class OneWayLayout {
     }
     private interface OneWayAnovaTest {
         double calcTestStatistic(double[][] xi);
-        boolean test(double statistic, double a);
+        boolean execute_test(double statistic, double a);
     }
     /*********************************/
     /* class define                  */
@@ -251,7 +251,7 @@ public class OneWayLayout {
                         * (invSumN - 1.0 / (sumN - n));
             return ln2L / deno;
         }
-        public boolean test(double statistic, double a) {
+        public boolean execute_test(double statistic, double a) {
             ChiSquaredDistribution chi2Dist = new ChiSquaredDistribution(n - 1);
             double r_val = chi2Dist.inverseCumulativeProbability(1.0 - a);
 
@@ -373,7 +373,7 @@ public class OneWayLayout {
             sumSb1 = stat.getSumsq() / a;
             return sumSb1 - sumSb2 * sumSb2 / (a * b);
         }
-        public boolean test(double statistic, double a) {
+        public boolean execute_test(double statistic, double a) {
             FDistribution fDist = new FDistribution(a1 - 1, (a1 - 1) * (b1 - 1));
             double f = fDist.inverseCumulativeProbability(1.0 - a);
             

data/ext/num4anova/TwoWayLayout.java

@@ -0,0 +1,286 @@
+import org.apache.commons.math3.stat.descriptive.DescriptiveStatistics;
+import org.apache.commons.math3.distribution.FDistribution;
+import java.util.Arrays;
+public class TwoWayLayout {
+    private static TwoWayLayout twoWay = new TwoWayLayout();
+    public static TwoWayLayout getInstance() {
+        return twoWay;
+    }
+    public boolean[] twowayAnova(double[][][] xij, double a) {
+        TwoWayAnovaTest twoway = new TwoWayAnova();
+
+        double[] statistic = twoway.calcTestStatistic(xij);
+        return twoway.execute_test(statistic, a);
+    }
+    public boolean[] twoway2Anova(double[][] xij, double a) {
+        TwoWay2AnovaTest twoway = new TwoWay2Anova();
+
+        double[] statistic = twoway.calcTestStatistic(xij);
+        return twoway.execute_test(statistic, a);
+    }
+    /*********************************/
+    /* interface define              */
+    /*********************************/
+    private interface TwoWayAnovaTest {
+        double[] calcTestStatistic(double[][][] xij);
+        boolean[] execute_test(double statistic[], double a);
+    }
+    private interface TwoWay2AnovaTest {
+        double[] calcTestStatistic(double[][] xij);
+        boolean[] execute_test(double statistic[], double a);
+    }
+    /*********************************/
+    /* class define                  */
+    /*********************************/
+    // 二元配置の分散分析(繰り返し数が等しい時)
+    private class TwoWayAnova implements TwoWayAnovaTest {
+        private int a = 0;
+        private int b = 0;
+        private int n = 0;
+        private int an = 0;
+        private int bn = 0;
+        private int abn = 0;
+        private int en = 0;
+        public double[] calcTestStatistic(double[][][] xij) {
+            double statistic[] = new double[3];
+
+            a = xij.length;
+            b = xij[0].length;
+            n = xij[0][0].length;
+            an = a- 1;
+            bn = b - 1;
+            abn = (a- 1) * (b - 1);
+            en = a * b * (n - 1);
+
+            double[][] meanXij = calcMeanXij(xij);
+            double[] meanAn = calcMeanAn(meanXij);
+            double[] meanBn = calcMeanBn(meanXij);
+            double meanABn = calcMeanABn(meanAn);
+
+            double anDrift  = calcAnDrift(meanAn, meanABn); // 水準Ai間変動
+            double bnDrift  = calcBnDrift(meanBn, meanABn); // 水準Bj間変動
+                                                            // 交互作用の変動
+            double interaDrift = calcInteraDrift(meanXij, meanAn, meanBn, meanABn);
+            double benchDrift  = calcBenchDrift(xij, meanXij);   // 水準内変動
+            double va = b * n * anDrift / an;
+            double vb = a * n * bnDrift / bn;
+            double vab = n * interaDrift / abn;
+            double ve = benchDrift / en;
+
+            statistic[0] = va / ve;
+            statistic[1] = vb / ve;
+            statistic[2] = vab/ ve;
+            return statistic;
+        }
+        private double[][] calcMeanXij(double[][][] xij) {
+            DescriptiveStatistics stat = new DescriptiveStatistics();
+            double[][] meanXij = new double[a][b];
+
+            for(int i = 0; i < a; i++) {
+                for(int j = 0; j < b; j++) {
+                    Arrays.stream(xij[i][j]).forEach(stat::addValue);
+                    meanXij[i][j] = stat.getMean();
+                    stat.clear();
+                }
+            }
+            return meanXij;
+        }
+        private double[] calcMeanAn(double[][] meanXij) {
+            double[] an = new double[a];
+
+            for(int i = 0; i < a; i++) {
+                double sumSa = 0.0;
+                for(int j = 0; j < b; j++) {
+                    an[i] += meanXij[i][j] / b;
+                }
+            }
+            return an;
+        }
+        private double[] calcMeanBn(double[][] meanXij) {
+            double[] bn = new double[b];
+
+            for(int i = 0; i < a; i++) {
+                for(int j = 0; j < b; j++) {
+                    bn[j] += meanXij[i][j] / a;
+                }
+            }
+            return bn;
+        }
+        private double calcMeanABn(double[] meanAn) {
+            DescriptiveStatistics stat = new DescriptiveStatistics();
+
+            Arrays.stream(meanAn).forEach(stat::addValue);
+            return stat.getMean();
+        }
+        // 水準Ai間変動
+        private double calcAnDrift(double[] meanAn, double meanABn) {
+            double sumDrift = 0.0;
+
+            for(int i =0; i < meanAn.length; i++) {
+                double diffXi = meanAn[i] - meanABn;
+
+                sumDrift += diffXi * diffXi;
+            }
+            return sumDrift;      
+        }
+        // 水準Bj間変動
+        private double calcBnDrift(double[] meanBn, double meanABn) {
+            double sumDrift = 0.0;
+
+            for(int j = 0; j < meanBn.length; j++) {
+                double diffXj = meanBn[j] - meanABn;
+
+                sumDrift += diffXj * diffXj;
+            }
+            return sumDrift;
+        }
+        // 交互作用の変動
+        private double calcInteraDrift(double[][] meanXij, double[] meanAn, double[] meanBn, double meanABn) {
+            double sumDrift = 0.0;
+
+            for(int i = 0; i< a; i++) {
+                for(int j = 0; j < b; j++) {
+                    double diffXj = meanXij[i][j] - meanAn[i] - meanBn[j] + meanABn;
+
+                    sumDrift += diffXj * diffXj;
+                }
+            }
+            return sumDrift;
+        }
+        // 水準内変動
+        private double calcBenchDrift(double[][][] xij, double[][] meanXij) {
+            double sumDrift = 0.0;
+
+            for(int i = 0; i < a; i++) {
+                for(int j = 0; j < b; j++) {
+                    for(int k = 0; k < xij[i][j].length; k++) {
+                        double diffXj = xij[i][j][k] - meanXij[i][j];
+
+                        sumDrift += diffXj * diffXj;
+                    }
+                }
+            }
+            return sumDrift;
+        }
+        public boolean[] execute_test(double statistic[], double a) {
+            boolean[] ret = new boolean[3];
+
+            ret[0] = evaluation(new FDistribution(an, en), statistic[0], a);
+            ret[1] = evaluation(new FDistribution(bn, en), statistic[1], a);
+            ret[2] = evaluation(new FDistribution(abn, en), statistic[2], a);
+            return ret;
+        }
+        private boolean evaluation(FDistribution fDist, double statistic, double a) {
+            double r_val = fDist.inverseCumulativeProbability(1.0 - a);
+
+            return (statistic >= r_val) ? true : false;
+        }
+    }
+    // 二元配置の分散分析(繰り返しのない時)
+    private class TwoWay2Anova implements TwoWay2AnovaTest {
+        private int a = 0;
+        private int b = 0;
+        private int an = 0;
+        private int bn = 0;
+        private int en = 0;
+        public double[] calcTestStatistic(double[][] xij) {
+            double statistic[] = new double[2];
+
+            a = xij.length;
+            b = xij[0].length;
+            an = a- 1;
+            bn = b - 1;
+            en = (a- 1) * (b - 1);
+
+            double[] meanAn = calcMeanAn(xij);
+            double[] meanBn = calcMeanBn(xij);
+            double meanAB = calcMeanAB(meanAn);
+
+            double anDrift  = calcAnDrift(meanAn, meanAB); // 水準Ai間変動
+            double bnDrift  = calcBnDrift(meanBn, meanAB); // 水準Bj間変動
+            double benchDrift  = calcBenchDrift(xij, meanAn, meanBn, meanAB);   // 水準内変動
+            double va = anDrift / an;
+            double vb = bnDrift / bn;
+            double ve = benchDrift / en;
+
+            statistic[0] = va / ve;
+            statistic[1] = vb / ve;
+            return statistic;
+        }
+        private double[] calcMeanAn(double[][] xij) {
+            double[] an = new double[a];
+
+            for(int i = 0; i < a; i++) {
+                for(int j = 0; j < b; j++) {
+                    an[i] += xij[i][j] / b;
+                }
+            }
+            return an;
+        }
+        private double[] calcMeanBn(double[][] xij) {
+            double[] bn = new double[b];
+
+            for(int i = 0; i < a; i++) {
+                for(int j = 0; j < b; j++) {
+                    bn[j] += xij[i][j] / a;
+                }
+            }
+            return bn;
+        }
+        private double calcMeanAB(double[] meanAn) {
+            DescriptiveStatistics stat = new DescriptiveStatistics();
+
+            Arrays.stream(meanAn).forEach(stat::addValue);
+            return stat.getMean();
+        }
+        // 水準Ai間変動
+        private double calcAnDrift(double[] meanAn, double meanAB) {
+            double sumDrift = 0.0;
+
+            for(int i =0; i < meanAn.length; i++) {
+                double diffXi = meanAn[i] - meanAB;
+
+                sumDrift += diffXi * diffXi;
+            }
+            return b * sumDrift;      
+        }
+        // 水準Bj間変動
+        private double calcBnDrift(double[] meanBn, double meanAB) {
+            double sumDrift = 0.0;
+
+            for(int j = 0; j < meanBn.length; j++) {
+                double diffXj = meanBn[j] - meanAB;
+
+                sumDrift += diffXj * diffXj;
+            }
+            return a * sumDrift;
+        }
+        // 水準内変動
+        private double calcBenchDrift(double[][] xij, double[] meanAn, double[] meanBn, double meanAB) {
+            double sumDrift = 0.0;
+
+            for(int i = 0; i < a; i++) {
+                for(int j = 0; j < b; j++) {
+                    double diffXj = xij[i][j] - meanAn[i] - meanBn[j] + meanAB;
+
+                    sumDrift += diffXj * diffXj;
+                }
+            }
+            return sumDrift;
+        }
+
+        public boolean[] execute_test(double statistic[], double a) {
+            boolean[] ret = new boolean[2];
+
+            ret[0] = evaluation(new FDistribution(an, en), statistic[0], a);
+            ret[1] = evaluation(new FDistribution(bn, en), statistic[1], a);
+            return ret;
+        }
+        private boolean evaluation(FDistribution fDist, double statistic, double a) {
+            double r_val = fDist.inverseCumulativeProbability(1.0 - a);
+
+            return (statistic >= r_val) ? true : false;
+        }
+    }
+}
+

data/lib/num4anova.rb

@@ -4,6 +4,7 @@ require 'jfreechart-1.5.4.jar'
 require 'commons-math3-3.6.1.jar'
 
 java_import 'OneWayLayout'
+java_import 'TwoWayLayout'
 java_import 'java.util.HashMap'
 # 分散分析を行う
 #  (Apache commoms math3使用)
@@ -144,11 +145,78 @@ module Num4AnovaLib
         #       [28, 50, 22, 26, 29],
         #   ]
         #   oneWay = Num4AnovaLib::OneWayLayoutLib.new 
-        #   oneWay.replicate_test("LDH", vals)
+        #   oneWay.replicate_test(xi, 0.05)
         #   => true
         def replicate_test(xi, a)
             return @oneWay.replicateTest(xi.to_java(Java::double[]), a)
         end
     end
+
+    # 二元配置の分散分析
+    class TwoWayLayoutLib
+        def initialize
+            @twoWay = TwoWayLayout.getInstance()
+        end
+        # 二元配置の分散分析
+        #  (繰り返し数が等しい時)
+        #
+        # @overload twoway_anova(xij, a)
+        #   @param [array]  xij データ(double[][][])
+        #   @param [double] a         有意水準
+        #   @return [Array] 検定結果(boolean[] true:棄却域内 false:棄却域外)
+        # @example
+        #   xij = [
+        #           [
+        #             [13.2, 15.7, 11.9],
+        #             [16.1, 15.7, 15.1],
+        #             [9.1,  10.3,  8.2],
+        #           ],
+        #           [
+        #             [22.8, 25.7, 18.5],
+        #             [24.5, 21.2, 24.2],
+        #             [11.9, 14.3, 13.7],
+        #           ],
+        #           [
+        #             [21.8, 26.3, 32.1],
+        #             [26.9, 31.3, 28.3],
+        #             [15.1, 13.6, 16.2],
+        #           ],
+        #           [
+        #             [25.7, 28.8, 29.5],
+        #             [30.1, 33.8, 29.6],
+        #             [15.2, 17.3, 14.8],
+        #           ],
+        #   ]
+        #   twoWay = Num4AnovaLib::TwoWayLayoutLib.new 
+        #   twoWay.twoway_anova(xij, 0.05)
+        #   =>
+        #     [true, true, true]
+        def twoway_anova(xij, a)
+            ret = @twoWay.twowayAnova(xij.to_java(Java::double[][]), a)
+            return ret.to_a
+        end
+        # 二元配置の分散分析
+        #  (繰り返しのない時)
+        #
+        # @overload twoway2_anova(xij, a)
+        #   @param [array]  xij データ(double[][])
+        #   @param [double] a         有意水準
+        #   @return [Array] 検定結果(boolean[] true:棄却域内 false:棄却域外)
+        # @example
+        #   xij = [
+        #       [13.6, 15.6, 9.2],
+        #       [22.3, 23.3, 13.3],
+        #       [26.7, 28.8, 15.0],
+        #       [28.0, 31.2, 15.8],
+        #   ]
+        #   twoWay = Num4AnovaLib::TwoWayLayoutLib.new 
+        #   twoWay.twoway2_anova(xij, 0.05)
+        #   =>
+        #     [true, true]
+        def twoway2_anova(xij, a)
+            ret = @twoWay.twoway2Anova(xij.to_java(Java::double[]), a)
+            return ret.to_a
+        end        
+    end
 end
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: num4anova
 version: !ruby/object:Gem::Version
-  version: 0.0.4
+  version: 0.0.6
 platform: java
 authors:
 - siranovel
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2024-01-30 00:00:00.000000000 Z
+date: 2024-02-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -63,6 +63,7 @@ files:
 - Rakefile
 - ext/num4anova/MultiComp.java
 - ext/num4anova/OneWayLayout.java
+- ext/num4anova/TwoWayLayout.java
 - lib/commons-math3-3.6.1.jar
 - lib/dunnet.rb
 - lib/jcommon-1.0.23.jar