num4anova 0.0.2-java → 0.0.4-java

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3987057ab3576c0da8a66256901cf7548ad7bf4bef7aaafccf128b083655333d
-  data.tar.gz: 4b35674f595de9f05b4056ec6c20d671549341aad88083e5dfd928a881de5c7a
+  metadata.gz: ca0164a7092861bfca67f257129332375e90bfae762365194ced78ef75a293a7
+  data.tar.gz: 16f17fb717e3d92c27c4c651e034704cd81609a3adc293555eac54f9209884be
 SHA512:
-  metadata.gz: 75fd29b81f0c79fa4f72520ced191bccc543d1cf86875425f9408a7c25aeeb8dc0b3417a3af3838bbc2dadee641da79f1fd43b46dc3a02f7e920ffafc1f6e1e7
-  data.tar.gz: 4a9226cc5d20f86fda993eecc91048edc77a7157da8b2d44c305fdcbf9849aeb0c2c6d4c270b623d62a061daee67aff8864e039280282fc8c2a415453f8e8334
+  metadata.gz: e14efb373cde03fc5872f3dfb1d4186e5d2263b0b7597970d1629c562cfb6696ecf2cdbfc3325aa2d732e252241de093c156b7d9da21b51a8ea305f3e24e0e0f
+  data.tar.gz: c9b7f310d00d060d1c6fee3e8e9f5c43fce812a65d51b192315c72a378de7e2bc775e1118346373a93047c1cd8880240d03d52309ec0d8f567481923f14e31b4

data/CHANGELOG.md

@@ -2,6 +2,16 @@
 
 ## Unreleased
 
+## [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
+
 ## [0.0.2] - 2024-01-23
 
 ### add

data/ext/num4anova/MultiComp.java

@@ -23,6 +23,28 @@ public class MultiComp {
             double[][] statistic = hypoth.calcTestStatistic(xi);
             return hypoth.executeTest(statistic, a * 0.5);
         }
+        public boolean scheffe_test(double[][] xi, double a) {
+            return false;
+        }
+
+        public boolean[][] twosideTest(double[][] xi, double a) {
+            HypothesisTest hypoth = new TwoSideTest();
+            double[][] statistic = hypoth.calcTestStatistic(xi);
+
+            return hypoth.executeTest(statistic, a / 2.0);
+        }
+        public boolean[][] rightsideTest(double[][] xi, double a) {
+            HypothesisTest hypoth = new RightSideTest();
+            double[][] statistic = hypoth.calcTestStatistic(xi);
+
+            return hypoth.executeTest(statistic, a);
+        }
+        public boolean[][] leftsideTest(double[][] xi, double a) {
+            HypothesisTest hypoth = new LeftSideTest();
+            double[][] statistic = hypoth.calcTestStatistic(xi);
+
+            return hypoth.executeTest(statistic, a);
+        }
         /*********************************/
         /* interface define              */
         /*********************************/
@@ -145,7 +167,6 @@ public class MultiComp {
                 TDistribution tDist = new TDistribution(v);
                 double t = 
                     tDist.inverseCumulativeProbability(p);
-
                 return Math.sqrt(2) * t;
             }
         }
@@ -220,6 +241,130 @@ public class MultiComp {
                 return sumSq / na;
             } 
         }
+        // ダネット法
+        private class DunnetTest{
+            private int k = 0;
+            private int v = 0;
+            private double[] mean = null;
+            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];
+                n = new double[k];
+                double[][] statistic = new double[k][k];
+                double ve = calcVe(xi);
+
+                for(int i = 0; i < k; i++) {
+                    for(int j = 0; j < k; j++) {
+                        statistic[i][j] = (mean[j] - mean[i]) 
+                                        / Math.sqrt(ve * (1.0 / n[j] + 1.0 / n[i]));
+                    }
+                }                
+                return statistic;
+            }
+            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();
+                    sumSq += (n[i] - 1) * stat.getVariance();
+                    sumN += n[i];
+                    stat.clear();
+                }
+                v = sumN - k;
+                return sumSq / v;
+            }
+        }        
+        private class TwoSideTest extends DunnetTest 
+                                  implements HypothesisTest {
+            public boolean[][] executeTest(double[][] statistic, double a) {
+                int v = super.getV();
+                int k = super.getK();
+                double den = k - 1;
+
+                TDistribution tDist = new TDistribution(v);
+                double l_val = tDist.inverseCumulativeProbability(a  / den);
+                double r_val = tDist.inverseCumulativeProbability(1.0 - a / den);
+                boolean[][] ret = new boolean[k][k];
+
+                for(int i = 0; i < k; i++) {
+                    for(int j = 0; j < k; j++) {
+                       ret[i][j] = evaluation(statistic[i][j], l_val, r_val ); 
+                    }
+                }
+                return ret;
+            }
+            private boolean evaluation(double statistic, double l_val, double r_val) {
+                boolean ret = true;
+
+                if ((l_val < statistic) && (statistic < r_val)) {
+                    ret = false;
+                }
+                return ret;
+            }
+        }
+        private class RightSideTest extends DunnetTest 
+                                  implements HypothesisTest {
+            public boolean[][] executeTest(double[][] statistic, double a) {
+                int v = super.getV();
+                int k = super.getK();
+                double den = k - 1;
+                double p = 1.0 - a / den;
+                TDistribution tDist = new TDistribution(v);
+                double r_val = tDist.inverseCumulativeProbability(1.0 - a);
+                boolean[][] ret = new boolean[k][k];
+
+                for(int i = 0; i < k; i++) {
+                    for(int j = 0; j < k; j++) {
+                       ret[i][j] = evaluation(statistic[i][j], r_val ); 
+                    }
+                }
+                return ret;
+            }
+            private boolean evaluation(double statistic, double r_val) {
+                boolean ret = true;
+
+                if (statistic < r_val) {
+                    ret = false;
+                }
+                return ret;
+            }
+        }
+        private class LeftSideTest extends DunnetTest 
+                                  implements HypothesisTest {
+            public boolean[][] executeTest(double[][] statistic, double a) {
+                int v = super.getV();
+                int k = super.getK();
+                double den = k - 1;
+                double p = a / den;
+                TDistribution tDist = new TDistribution(v);
+                double l_val = tDist.inverseCumulativeProbability(a);
+                boolean[][] ret = new boolean[k][k];
+
+                for(int i = 0; i < k; i++) {
+                    for(int j = 0; j < k; j++) {
+                       ret[i][j] = evaluation(statistic[i][j], l_val ); 
+                    }
+                }
+                return ret;
+            }
+            private boolean evaluation(double statistic, double l_val) {
+                boolean ret = true;
+
+                if (l_val < statistic) {
+                    ret = false;
+                }
+                return ret;
+            }
+        }
     }
 }
 

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();
@@ -59,6 +60,18 @@ public class OneWayLayout {
         double statistic = oneway.calcTestStatistic(xi);
         return oneway.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.test(statistic, a);
+    }
     /*********************************/
     /* interface 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);
@@ -243,5 +258,127 @@ public class OneWayLayout {
             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 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/lib/dunnet.rb

@@ -0,0 +1,89 @@
+# Dunnet検定
+#  (Apache commoms math3使用)
+module DunnetTestLib
+    # Dunnet検定の両側検定
+    #
+    # @overload twoside_test(xi, a)
+    #   @param [array]  xi データ(double[][])
+    #   @param [double] a         有意水準
+    #   @return [Array] 検定結果(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],
+    #    ]
+    #    paraTest = MultiCompLib::ParametrixTestLib.new
+    #    paraTest.twoside_test(xi, 0.05)
+    #    => 
+    #      res = [
+    #          [false, false, false, true, false],
+    #          [false, false, false, true, false],
+    #          [false, false, false, false, false],
+    #          [true,  true,  false, false, false],
+    #          [false, false, false, false, false],
+    #      ]
+    def twoside_test(xi, a)
+        ret = @paramTest.twosideTest(xi.to_java(Java::double[]), a)
+        return ret.to_a
+    end
+    # Dunnet検定の右側検定
+    #
+    # @overload rightside_test(xi, a)
+    #   @param [array]  xi データ(double[][])
+    #   @param [double] a         有意水準
+    #   @return [Array] 検定結果(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],
+    #    ]
+    #    paraTest = MultiCompLib::ParametrixTestLib.new
+    #    paraTest.rightside_test(xi, 0.05)
+    #    => 
+    #      res = [
+    #          [false, false, true,  true,  true],
+    #          [false, false, false, true,  false],
+    #          [false, false, false, true,  false],
+    #          [false, false, false, false, false],
+    #          [false, false, false, true, false],
+    #      ]
+    def rightside_test(xi, a)
+        ret = @paramTest.rightsideTest(xi.to_java(Java::double[]), a)
+        return ret.to_a
+    end
+    # Dunnet検定の左側検定
+    #
+    # @overload leftside_test(xi, a)
+    #   @param [array]  xi データ(double[][])
+    #   @param [double] a         有意水準
+    #   @return [Array] 検定結果(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],
+    #    ]
+    #    paraTest = MultiCompLib::ParametrixTestLib.new
+    #    paraTest.leftside_test(xi, 0.05)
+    #    => 
+    #      res = [
+    #          [false, false, false, false, false],
+    #          [false, false, false, false, false],
+    #          [true,  false, false, false, false],
+    #          [true,  true,  true,  false, true],
+    #          [true,  false, false, false, false],
+    #      ]
+    def leftside_test(xi, a)
+        ret = @paramTest.leftsideTest(xi.to_java(Java::double[]), a)
+        return ret.to_a
+    end
+end
+

data/lib/multicomp.rb

@@ -3,12 +3,15 @@ require 'num4anova.jar'
 require 'jfreechart-1.5.4.jar'
 require 'commons-math3-3.6.1.jar'
 
+require_relative('dunnet')
+
 java_import 'MultiComp'
 # 多重比較を行う
 #  (Apache commoms math3使用)
 module MultiCompLib
     # パラメトリック検定
     class ParametrixTestLib
+        include DunnetTestLib
         def initialize
             @paramTest = MultiComp::ParametrixTest.getInstance()
         end
@@ -26,7 +29,8 @@ module MultiCompLib
         #        [26.4, 32.5, 31.3],
         #        [24.5, 21.2, 22.4],
         #    ]
-        #    paraTest.turkey_test(xi, a)
+        #    paraTest = MultiCompLib::ParametrixTestLib.new
+        #    paraTest.turkey_test(xi, 0.05)
         #    => 
         #      [
         #        [false, false, false, true, false],
@@ -53,7 +57,8 @@ module MultiCompLib
         #        [26.4, 32.5, 31.3],
         #        [24.5, 21.2, 22.4],
         #    ]
-        #    paraTest.bonferrono_test(xi, a)
+        #    paraTest = MultiCompLib::ParametrixTestLib.new
+        #    paraTest.bonferrono_test(xi, 0.05)
         #    => 
         #      [
         #        [false, false, false, true, false],

data/lib/num4anova.rb

@@ -72,13 +72,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 +92,63 @@ 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("LDH", vals)
+        #   => true
+        def replicate_test(xi, a)
+            return @oneWay.replicateTest(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.2
+  version: 0.0.4
 platform: java
 authors:
 - siranovel
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2024-01-23 00:00:00.000000000 Z
+date: 2024-01-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -64,6 +64,7 @@ files:
 - ext/num4anova/MultiComp.java
 - ext/num4anova/OneWayLayout.java
 - lib/commons-math3-3.6.1.jar
+- lib/dunnet.rb
 - lib/jcommon-1.0.23.jar
 - lib/jfreechart-1.5.4.jar
 - lib/multicomp.rb