num4anova 0.0.3-java → 0.0.5-java

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 89f91d9c210bb998f14a726f1c7147470cba19fba721724625b7ec87e4c88ad9
-  data.tar.gz: a79f6e3ca4adc650193065ae62037cfed0580e5f7b9c5e1d06109d74f17a05d6
+  metadata.gz: 7a089d52ead2c9726d9ca61db475f128925afddca7cbcf6f65f0da75e41f0b1b
+  data.tar.gz: 050e29e04bd0e8272da89d5aba231fe08294f50f090d261da7aa6822f5df5bc5
 SHA512:
-  metadata.gz: 97a1409dfb791766292e8d6c0a49502555911529632d45b72aa6c68bc6fda7e82ed813fff4c005c9c76745a2ad05fe79d1131e23879da18afcc88d0652617c29
-  data.tar.gz: 4cd28879971daf44d20ff8122120327e8a74519f658a22e052724af316387c057cfb315a6d1cb23324bbd08634c066c1045594d6c8804f1f87e12d31b6acd0fb
+  metadata.gz: f0cc84d4cebb416b04ed0360ef4cf72799aaebcf70104b6e2d2dc2bc471400d3ac313b71f5885fd0854ae8b3ae22dd66c753066233b1ed2848aabf586cee2c05
+  data.tar.gz: 88a74fb295e7ce0e0bdba405a14239a37fac4f3115bd29f358ce7b54fcc3b71a1533ff095e5aea7e2b141d867051eca703d179874f1ed349aef92575d8d0a186

data/CHANGELOG.md

@@ -2,10 +2,20 @@
 
 ## Unreleased
 
+## [0.0.5] - 2024-02-01
+
+### add
+- add function of twoway_anova.
+
+## [0.0.4] - 2024-01-30
+### add
+- add function of replicate_plot
+- add function of replicate_test
+
 ## [0.0.3] - 2024-01-26
 
 ### add
-- add function of dunnet_test.
+- add function of dunnet_test
 
 ## [0.0.2] - 2024-01-23
 

data/ext/num4anova/MultiComp.java

@@ -249,6 +249,7 @@ public class MultiComp {
             private double[] n = null;
             protected int getK() { return k;}
             protected int getV() { return v;}
+
             public double[][] calcTestStatistic(double[][] xi) {
                 k = xi.length;
                 mean = new double[k];
@@ -267,8 +268,10 @@ public class MultiComp {
             private double calcVe(double[][] xi) {
                 double sumSq = 0.0;
                 int sumN = 0;
+
                 for(int i = 0; i < k; i++) {
                     DescriptiveStatistics stat = new DescriptiveStatistics();
+
                     Arrays.stream(xi[i]).forEach(stat::addValue);
                     mean[i] = stat.getMean();
                     n[i] = stat.getN();
@@ -286,7 +289,7 @@ public class MultiComp {
                 int v = super.getV();
                 int k = super.getK();
                 double den = k - 1;
-                double p = 1.0 - a / den;
+
                 TDistribution tDist = new TDistribution(v);
                 double l_val = tDist.inverseCumulativeProbability(a  / den);
                 double r_val = tDist.inverseCumulativeProbability(1.0 - a / den);

data/ext/num4anova/OneWayLayout.java

@@ -28,6 +28,7 @@ import java.util.ArrayList;
 import org.apache.commons.math3.stat.inference.OneWayAnova;
 import org.apache.commons.math3.stat.descriptive.DescriptiveStatistics;
 import org.apache.commons.math3.distribution.ChiSquaredDistribution;
+import org.apache.commons.math3.distribution.FDistribution;
 import java.util.Map;
 public class OneWayLayout {
     private static OneWayLayout oneWay = new OneWayLayout();
@@ -57,7 +58,19 @@ 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();
+
+        JFreeChart chart = plot.createChart("反復測定", dname, vals);
+        plot.writeJPEG("replicate.jpeg", chart, 800, 500);
+    }
+    public boolean replicateTest(double[][] xi, double a) {
+        OneWayAnovaTest oneway = new ReplicateTest();
+
+        double statistic = oneway.calcTestStatistic(xi);
+        return oneway.execute_test(statistic, a);
     }
     /*********************************/
     /* interface define              */
@@ -78,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                  */
@@ -196,6 +209,7 @@ public class OneWayLayout {
             }
         }
     }
+    // バートレット検定
     private class BartletTest implements OneWayAnovaTest {
         private int n = 0;
         public double calcTestStatistic(double[][] xi) {
@@ -226,6 +240,7 @@ public class OneWayLayout {
             double invSumN = 0.0;
             int sumN = 0;
             DescriptiveStatistics stat = new DescriptiveStatistics();
+
             for(int i = 0; i < n; i++) {
                 Arrays.stream(xi[i]).forEach(stat::addValue);
                 invSumN += 1.0 / (stat.getN() - 1.0);
@@ -236,12 +251,134 @@ 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);
 
             return (r_val < statistic) ? true : false;
         }
     }
+    // 反復測定Plot
+    private class ReplicateChartPlot implements ChartPlot {
+        public JFreeChart createChart(String title, String dname, Map<String, double[]> vals) {
+            CategoryPlot plot = createPlot(dname, vals);
+            ChartFactory.setChartTheme(StandardChartTheme.createLegacyTheme());
+            JFreeChart chart = new JFreeChart(title, plot);
+
+            ChartUtils.applyCurrentTheme(chart);
+            return chart;
+        }
+        private CategoryPlot createPlot( String dname, Map<String, double[]> vals) {
+            CreatePlot plotImpl = new ReplicatePlot();
+
+            return plotImpl.createPlot(dname, vals);
+        }
+        private class ReplicatePlot implements CreatePlot {
+            public CategoryPlot createPlot(String dname, Map<String, double[]> vals) {
+                LineAndShapeRenderer renderer = new LineAndShapeRenderer(true, true);
+
+                renderer.setDefaultToolTipGenerator(
+                    new StandardCategoryToolTipGenerator()
+                );
+                CategoryPlot plot = new CategoryPlot();
+
+                plot.setOrientation(PlotOrientation.VERTICAL);
+                plot.mapDatasetToRangeAxis(0,0);
+	        plot.setDatasetRenderingOrder(DatasetRenderingOrder.FORWARD);
+                
+                /*--- 横軸 ---*/
+                CategoryAxis categoryAxis = new CategoryAxis("因子");
+                plot.setDomainAxis(categoryAxis);
+
+                /*--- 縦軸 ---*/
+                NumberAxis valueAxis0 = new NumberAxis("推定周辺平均");
+                plot.setRangeAxis(valueAxis0);
+
+                plot.setRenderer(0, renderer);
+                plot.setDataset(0, createDataset(dname, vals));
+                return plot;
+            }
+            private CategoryDataset createDataset(String dname, Map<String, double[]> vals) {
+                DefaultCategoryDataset data = new DefaultCategoryDataset();
+                DescriptiveStatistics stat = new DescriptiveStatistics();
+
+                for(Map.Entry<String, double[]> entry : vals.entrySet()) {
+                    double[] v = entry.getValue();
+
+                    Arrays.stream(v).forEach(stat::addValue);
+                    data.addValue(stat.getMean(), dname, entry.getKey());
+                    stat.clear();
+                }
+                return data;
+            }
+        }
+    }
+    private class ReplicateTest implements OneWayAnovaTest {
+        private int a1 = 0;
+        private int b1 = 0;
+        public double calcTestStatistic(double[][] xi) {
+            b1 = xi[0].length;
+            a1 = xi.length;
+            double st = calcSt(xi, a1, b1);
+            double sa = calcSa(xi, a1, b1);
+            double sb = calcSb(xi, a1, b1);       
+            double se = st - sa - sb;
+            double meanSa = sa / (a1 - 1);
+            double meanSe = se / ((a1 - 1) * (b1 - 1));
+
+            return meanSa / meanSe ;
+        }
+        private double calcSt(double[][] xi, int a, int b) {
+            DescriptiveStatistics stat = new DescriptiveStatistics();
+            double sumSt1 = 0.0;
+            double sumSt2 = 0.0;
+
+            for(int i = 0; i < a; i++) {
+                Arrays.stream(xi[i]).forEach(stat::addValue);
+                sumSt1 += stat.getSumsq();
+                sumSt2 += stat.getSum();
+                stat.clear();
+            }
+            return sumSt1 - sumSt2 * sumSt2 / (a * b);
+        }
+        private double calcSa(double[][] xi, int a, int b) {
+            double sumSa1 = 0.0;
+            double sumSa2 = 0.0;
+            double[] an = new double[a];
+
+            for(int i = 0; i < a; i++) {
+                for(int j = 0; j < b; j++) {
+                    an[i] += xi[i][j];
+                    sumSa2 += xi[i][j];
+                }
+            }
+            DescriptiveStatistics stat = new DescriptiveStatistics();
+            Arrays.stream(an).forEach(stat::addValue);
+            sumSa1 = stat.getSumsq() / b;
+            return sumSa1 - sumSa2 * sumSa2 / (a * b);
+        }
+        private double calcSb(double[][] xi, int a, int b) {
+            double[] bn = new double[b];
+            double sumSb1 = 0.0;
+            double sumSb2 = 0.0;
+
+            for(int i = 0; i < a; i++) {
+                for(int j = 0; j < b; j++) {
+                    bn[j] += xi[i][j];
+                    sumSb2 += xi[i][j];
+                }
+            }
+            DescriptiveStatistics stat = new DescriptiveStatistics();
+            Arrays.stream(bn).forEach(stat::addValue);
+            sumSb1 = stat.getSumsq() / a;
+            return sumSb1 - sumSb2 * sumSb2 / (a * b);
+        }
+        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);
+            
+            return (statistic >= f) ? true : false;
+        }
+    }
 }
 

data/ext/num4anova/TwoWayLayout.java

@@ -0,0 +1,186 @@
+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);
+    }
+    /*********************************/
+    /* interface define              */
+    /*********************************/
+    private interface TwoWayAnovaTest {
+        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 allDrift = calcAllDrift(xij, meanABn); // 全変動
+            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];
+            DescriptiveStatistics stat = new DescriptiveStatistics();
+
+            for(int i = 0; i < a; i++) {
+                double sumSa = 0.0;
+                for(int j = 0; j < b; j++) {
+                    sumSa += meanXij[i][j];
+                }
+                an[i] = sumSa / b;
+            }
+            return an;
+        }
+        private double[] calcMeanBn(double[][] meanXij) {
+            double[] bn = new double[b];
+            double[] sumA = 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();
+        }
+        // 全変動
+        private double calcAllDrift(double[][][] xij, double meanABn) {
+            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 diffXijk = xij[i][j][k] - meanABn;
+                        sumDrift += diffXijk * diffXijk; 
+                    }
+                }
+            }
+            return sumDrift;
+        }
+        // 水準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) ? false : true;
+        }
+    }
+}
+

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使用)
@@ -72,13 +73,13 @@ module Num4AnovaLib
         #   @param [double] a         有意水準
         #   @return [boolean] 検定結果(true:棄却域内 false:棄却域外)
         # @example
-        #    xi = [
-        #        [12.2, 18.8, 18.2],
-        #        [22.2, 20.5, 14.6],
-        #        [20.8, 19.5, 26.3],
-        #        [26.4, 32.5, 31.3],
-        #        [24.5, 21.2, 22.4],
-        #    ]
+        #   xi = [
+        #       [12.2, 18.8, 18.2],
+        #       [22.2, 20.5, 14.6],
+        #       [20.8, 19.5, 26.3],
+        #       [26.4, 32.5, 31.3],
+        #       [24.5, 21.2, 22.4],
+        #   ]
         #   oneWay = Num4AnovaLib::OneWayLayoutLib.new 
         #   oneWay.oneWay.oneway_anova(xi, 0.05)
         #   => true
@@ -92,19 +93,107 @@ module Num4AnovaLib
         #   @param [double] a         有意水準
         #   @return [boolean] 検定結果(true:棄却域内 false:棄却域外)
         # @example
-        #    xi = [
-        #        [12.2, 18.8, 18.2],
-        #        [22.2, 20.5, 14.6],
-        #        [20.8, 19.5, 26.3],
-        #        [26.4, 32.5, 31.3],
-        #        [24.5, 21.2, 22.4],
-        #    ]
+        #   xi = [
+        #       [12.2, 18.8, 18.2],
+        #       [22.2, 20.5, 14.6],
+        #       [20.8, 19.5, 26.3],
+        #       [26.4, 32.5, 31.3],
+        #       [24.5, 21.2, 22.4],
+        #   ]
         #   oneWay = Num4AnovaLib::OneWayLayoutLib.new 
         #   oneWay.bartlet(xi, 0.05)
         #   => true
         def bartlet(xi, a)
             return @oneWay.bartletTest(xi.to_java(Java::double[]), a)
         end
+        # 反復測定Plot
+        #
+        # @overload replicate_plot(dname, vals)
+        #   @param [String] dname データ名
+        #   @param [Hash] vals Hash(String, double[])
+        #   @return [void]  replicate.jpegファイルを出力
+        # @example
+        #   vals = {
+        #        "stageA1" => [27, 52, 18, 21, 32],
+        #        "stageA2" => [52, 72, 31, 50, 45],
+        #        "stageA3" => [47, 54, 29, 43, 32],
+        #        "stageA4" => [28, 50, 22, 26, 29],
+        #       }
+        #   oneWay = Num4AnovaLib::OneWayLayoutLib.new 
+        #   oneWay.replicate_plot("LDH", vals)
+        #   => replicate.jpeg
+        # @note
+        #   グラフは、jfreechartを使用
+        def replicate_plot(dname, vals)
+            o = HashMap.new
+            vals.each{|k, v|
+                o[k] = v.to_java(Java::double)
+            }
+            return @oneWay.replicatePlot(dname, o)
+        end
+        # 反復測定検定
+        #
+        # @overload replicate_test(xi, a)
+        #   @param [array]  xi データ(double[][])
+        #   @param [double] a         有意水準
+        #   @return [boolean] 検定結果(true:棄却域内 false:棄却域外)
+        # @example
+        #   xi = [
+        #       [27, 52, 18, 21, 32],
+        #       [52, 72, 31, 50, 45],
+        #       [47, 54, 29, 43, 32],
+        #       [28, 50, 22, 26, 29],
+        #   ]
+        #   oneWay = Num4AnovaLib::OneWayLayoutLib.new 
+        #   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
     end
 end
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: num4anova
 version: !ruby/object:Gem::Version
-  version: 0.0.3
+  version: 0.0.5
 platform: java
 authors:
 - siranovel
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2024-01-26 00:00:00.000000000 Z
+date: 2024-02-01 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