num4anova 0.0.9-java → 0.0.11-java

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (5) hide show
  1. checksums.yaml +4 -4
  2. data/CHANGELOG.md +10 -0
  3. data/ext/num4anova/Ancova.java +212 -82
  4. data/lib/num4anova.rb +62 -2
  5. metadata +2 -2
checksums.yaml CHANGED
@@ -1,7 +1,7 @@
1
1
  ---
2
2
  SHA256:
3
- metadata.gz: f5d31afc9315035a148a1b2a755ecc64422c64d82c548378c8f4ea3bb940d91d
4
- data.tar.gz: 249a18fb9ec372037d32b1bafc4ba37d35916e8d3fe25a96fc576f627e8ab89b
3
+ metadata.gz: 2a278a4c32d7e1ef21ccbb1200573d5c1b4e326c59602327f9968afb29f134b6
4
+ data.tar.gz: e8520453d70e0276e6bb0587aefcd31b90b84d703cf670ae25297af73172bcdd
5
5
  SHA512:
6
- metadata.gz: de66c54f9facc61769f2a40c4b936bcc8a6e93cfe8eb1d2d185504b9d9e59cfd6dc45654a2ec7f26a6a72c7debfef00396058a1c0db405b47e4deed7963382be
7
- data.tar.gz: 908b725baa8aa4b68102b66f65fb789cc496124283e210dfd0b7c05dac4c6e22701e3c2e5bcb16c6ec01631aa3b20a8e50908b994f3dfd78e8f5804dfb245391
6
+ metadata.gz: 42836d15f6460c2650a7c6cb17c15de206bbabb52c40d988714fe26564d019974a416db4c22f67ed0c535694022575d380603da7c029f0b04476d4994ffca7a5
7
+ data.tar.gz: ed1698ed0b05da8d2f0d7417fd1271bcb41754d76fa68b19fb300245449a634c830636ea790a49b89d87066c320c55e2260464bb791ba795f8193664a0babb28
data/CHANGELOG.md CHANGED
@@ -2,6 +2,16 @@
2
2
 
3
3
  ## Unreleased
4
4
 
5
+ ## [0.0.11] - 2024-03-21
6
+
7
+ ### add
8
+ - add fuction of difference_test.
9
+
10
+ ## [0.0.10] - 2024-03-05
11
+
12
+ ### add
13
+ - add fuction of significance_test.
14
+
5
15
  ## [0.0.9] - 2024-03-02
6
16
 
7
17
  ### add
data/ext/num4anova/Ancova.java CHANGED
@@ -11,6 +11,18 @@ public class Ancova {
11
11
  double statistic = hypoth.calcTestStatistic(xi);
12
12
  return hypoth.executeTest(statistic, a);
13
13
  }
14
+ public boolean significanceTest(double[][][] xi, double a) {
15
+ HypothesisTest hypoth = new SignificanceTest();
16
+
17
+ double statistic = hypoth.calcTestStatistic(xi);
18
+ return hypoth.executeTest(statistic, a);
19
+ }
20
+ public boolean differenceTest(double[][][] xi, double a) {
21
+ HypothesisTest hypoth = new DifferenceTest();
22
+
23
+ double statistic = hypoth.calcTestStatistic(xi);
24
+ return hypoth.executeTest(statistic, a);
25
+ }
14
26
  /*********************************/
15
27
  /* interface define */
16
28
  /*********************************/
@@ -21,101 +33,145 @@ public class Ancova {
21
33
  /*********************************/
22
34
  /* class define */
23
35
  /*********************************/
24
- // 回帰直線モデルの平行性の検定
25
- private class Parallettest implements HypothesisTest {
26
- private int n = 0;
27
- private int m = 0;
28
- public double calcTestStatistic(double[][][] xi) {
29
- int sumn = calcSumn(xi);
30
- double sumx = calcSumx(xi);
31
- double sumy = calcSumy(xi);
32
- n = xi.length - 1;
33
- m = sumn - 2 * xi.length;
36
+ private class RegressionLine {
37
+ protected int calcSumn(double[][][] xi) {
38
+ int sum = 0;
34
39
 
40
+ for(int i = 0; i < xi.length; i++) {
41
+ sum += xi[i].length;
42
+ }
43
+ return sum;
44
+ }
35
45
  // 全変動
36
- double sumx2 = calcSumx2(xi);
46
+ private double calcSty(double[][][] xi, int sumn) {
37
47
  double sumy2 = calcSumy2(xi);
38
- double sumyx = calcSumyx(xi);
48
+ double sumy = calcSumy(xi);
39
49
 
40
- double sumtx = sumx2 - sumx*sumx / sumn;
41
- double sumty = sumy2 - sumy*sumy / sumn;
42
- double sumtyx = sumyx - sumy*sumx / sumn;
50
+ return sumy2 - sumy*sumy / sumn;
51
+ }
52
+ private double calcStx(double[][][] xi, int sumn) {
53
+ double sumx2 = calcSumx2(xi);
54
+ double sumx = calcSumx(xi);
43
55
 
44
- // 水準間変動
45
- double sumax = calcSumax(xi) - sumx*sumx / sumn;
46
- double sumay = calcSumay(xi) - sumy*sumy / sumn;
47
- double sumayx = calcSumayx(xi) - sumy*sumx / sumn;
56
+ return sumx2 - sumx*sumx / sumn;
57
+ }
58
+ private double calcStyx(double[][][] xi, int sumn) {
59
+ double sumx = calcSumx(xi);
60
+ double sumy = calcSumy(xi);
61
+ double sumyx = calcSumyx(xi);
48
62
 
49
- // 水準内変動
50
- double sumex = sumtx - sumax;
51
- double sumey = sumty - sumay;
52
- double sumeyx = sumtyx - sumayx;
63
+ return sumyx - sumy*sumx / sumn;
64
+ }
65
+ // 水準間変動
66
+ private double calcSay(double[][][] xi, int sumn) {
67
+ double sumy = calcSumy(xi);
53
68
 
54
- double sumbx = calcbx(xi);
55
- double sumnp = sumbx - sumeyx * sumeyx / sumex;
56
- double sume2 = sumey - sumbx;
69
+ return calcSumay(xi) - sumy*sumy / sumn;
70
+ }
71
+ private double calcSax(double[][][] xi, int sumn) {
72
+ double sumx = calcSumx(xi);
57
73
 
58
- //
59
- double vnp = sumnp / n;
60
- double ve2 = sume2 / m;
61
- return vnp / ve2;
74
+ return calcSumax(xi) - sumx*sumx / sumn;
62
75
  }
63
- public boolean executeTest(double statistic, double a) {
64
- FDistribution fDist = new FDistribution(n, m);
65
- double f = fDist.inverseCumulativeProbability(1.0 - a);
76
+ private double calcSayx(double[][][] xi, int sumn) {
77
+ double sumx = calcSumx(xi);
78
+ double sumy = calcSumy(xi);
66
79
 
67
- return (statistic >= f) ? true : false;
80
+ return calcSumayx(xi) - sumy*sumx / sumn;
81
+ }
82
+ // 水準内変動
83
+ protected double calcSex(double[][][] xi, int sumn) {
84
+ return calcStx(xi, sumn) - calcSax(xi, sumn);
85
+ }
86
+ protected double calcSey(double[][][] xi, int sumn) {
87
+ return calcSty(xi, sumn) - calcSay(xi, sumn);
88
+ }
89
+ protected double calcSeyx(double[][][] xi, int sumn) {
90
+ return calcStyx(xi, sumn) - calcSayx(xi, sumn);
68
91
  }
69
- private int calcSumn(double[][][] xi) {
70
- int sum = 0;
71
92
 
72
- for(int i = 0; i < xi.length; i++) {
73
- sum += xi[i].length;
93
+ // 平行性の検定
94
+ protected double calcbx(double[][][] xi) {
95
+ double sum = 0.0;
96
+
97
+ for (int i = 0; i < xi.length; i++) {
98
+ int n = xi[i].length;
99
+ double sumx = 0.0;
100
+ double sumy = 0.0;
101
+ double sumyx = 0.0;
102
+ double sumx2 = 0.0;
103
+ for (int j = 0; j < n; j++) {
104
+ sumx += xi[i][j][1];
105
+ sumy += xi[i][j][0];
106
+ sumyx += xi[i][j][1] * xi[i][j][0];
107
+
108
+ sumx2 += xi[i][j][1] * xi[i][j][1];
109
+
110
+ }
111
+ double wki = n * sumyx - sumy * sumx;
112
+ double wk = wki * wki / (n * (n * sumx2 - sumx * sumx));
113
+
114
+ sum += wk;
74
115
  }
75
116
  return sum;
76
117
  }
77
- // 全変動
78
- private double calcSumx(double[][][] xi) {
118
+ // 差の検定
119
+ protected double calcSa(double[][][] xi, int sumn) {
120
+ double sumty = calcSty(xi, sumn);
121
+ double sumtyx = calcStyx(xi, sumn);
122
+ double sumtx = calcStx(xi, sumn);
123
+ double sumey = calcSey(xi, sumn);
124
+ double sumeyx = calcSeyx(xi, sumn);
125
+ double sumex = calcSex(xi, sumn);
126
+
127
+ return (sumty - sumtyx * sumtyx / sumtx)
128
+ - (sumey - sumeyx * sumeyx / sumex);
129
+ }
130
+
131
+ // ETC
132
+ private double calcSumay(double[][][] xi) {
79
133
  double sum = 0.0;
80
134
 
81
135
  for (int i = 0; i < xi.length; i++) {
136
+ double sumyi = 0.0;
82
137
  for (int j = 0; j < xi[i].length; j++) {
83
- sum += xi[i][j][1];
138
+ sumyi += xi[i][j][0];
84
139
  }
140
+ sum += sumyi * sumyi / xi[i].length;
85
141
  }
86
142
  return sum;
87
143
  }
88
- private double calcSumy(double[][][] xi) {
144
+ private double calcSumy2(double[][][] xi) {
89
145
  double sum = 0.0;
90
146
 
91
147
  for (int i = 0; i < xi.length; i++) {
92
148
  for (int j = 0; j < xi[i].length; j++) {
93
- sum += xi[i][j][0];
149
+ sum += xi[i][j][0] * xi[i][j][0];
94
150
  }
95
151
  }
96
152
  return sum;
97
153
  }
98
- private double calcSumx2(double[][][] xi) {
154
+ private double calcSumx(double[][][] xi) {
99
155
  double sum = 0.0;
100
156
 
101
157
  for (int i = 0; i < xi.length; i++) {
102
158
  for (int j = 0; j < xi[i].length; j++) {
103
- sum += xi[i][j][1] * xi[i][j][1];
159
+ sum += xi[i][j][1];
104
160
  }
105
161
  }
106
162
  return sum;
107
163
  }
108
- private double calcSumy2(double[][][] xi) {
164
+ protected double calcSumx2(double[][][] xi) {
109
165
  double sum = 0.0;
110
166
 
111
167
  for (int i = 0; i < xi.length; i++) {
112
168
  for (int j = 0; j < xi[i].length; j++) {
113
- sum += xi[i][j][0] * xi[i][j][0];
169
+ sum += xi[i][j][1] * xi[i][j][1];
114
170
  }
115
171
  }
116
172
  return sum;
117
173
  }
118
- private double calcSumyx(double[][][] xi) {
174
+ protected double calcSumyx(double[][][] xi) {
119
175
  double sum = 0.0;
120
176
 
121
177
  for (int i = 0; i < xi.length; i++) {
@@ -125,70 +181,144 @@ public class Ancova {
125
181
  }
126
182
  return sum;
127
183
  }
128
- // 水準間変動
129
- private double calcSumax(double[][][] xi) {
184
+ private double calcSumayx(double[][][] xi) {
130
185
  double sum = 0.0;
131
186
 
132
187
  for (int i = 0; i < xi.length; i++) {
133
188
  double sumxi = 0.0;
189
+ double sumyi = 0.0;
134
190
  for (int j = 0; j < xi[i].length; j++) {
135
191
  sumxi += xi[i][j][1];
192
+ sumyi += xi[i][j][0];
136
193
  }
137
- sum += sumxi * sumxi / xi[i].length;
194
+ sum += sumxi * sumyi / xi[i].length;
138
195
  }
139
196
  return sum;
140
-
141
197
  }
142
- private double calcSumay(double[][][] xi) {
198
+ private double calcSumax(double[][][] xi) {
143
199
  double sum = 0.0;
144
200
 
145
201
  for (int i = 0; i < xi.length; i++) {
146
- double sumyi = 0.0;
202
+ double sumxi = 0.0;
147
203
  for (int j = 0; j < xi[i].length; j++) {
148
- sumyi += xi[i][j][0];
204
+ sumxi += xi[i][j][1];
149
205
  }
150
- sum += sumyi * sumyi / xi[i].length;
206
+ sum += sumxi * sumxi / xi[i].length;
151
207
  }
152
208
  return sum;
153
209
  }
154
- private double calcSumayx(double[][][] xi) {
210
+ private double calcSumy(double[][][] xi) {
155
211
  double sum = 0.0;
156
212
 
157
213
  for (int i = 0; i < xi.length; i++) {
158
- double sumxi = 0.0;
159
- double sumyi = 0.0;
160
214
  for (int j = 0; j < xi[i].length; j++) {
161
- sumxi += xi[i][j][1];
162
- sumyi += xi[i][j][0];
215
+ sum += xi[i][j][0];
163
216
  }
164
- sum += sumxi * sumyi / xi[i].length;
165
217
  }
166
218
  return sum;
167
219
  }
168
- // 平行性の検定
169
- private double calcbx(double[][][] xi) {
170
- double sum = 0.0;
171
220
 
172
- for (int i = 0; i < xi.length; i++) {
173
- int n = xi[i].length;
174
- double sumx = 0.0;
175
- double sumy = 0.0;
176
- double sumyx = 0.0;
177
- double sumx2 = 0.0;
178
- for (int j = 0; j < n; j++) {
179
- sumx += xi[i][j][1];
180
- sumy += xi[i][j][0];
181
- sumyx += xi[i][j][1] * xi[i][j][0];
221
+ }
222
+ // 回帰直線モデルの平行性の検定
223
+ private class Parallettest extends RegressionLine implements HypothesisTest {
224
+ private int n = 0;
225
+ private int m = 0;
226
+ public double calcTestStatistic(double[][][] xi) {
227
+ int sumn = calcSumn(xi);
228
+ n = xi.length - 1;
229
+ m = sumn - 2 * xi.length;
230
+
231
+ double vnp = calcVnp(xi, sumn);
232
+ double ve2 = calcVe2(xi, sumn);
182
233
 
183
- sumx2 += xi[i][j][1] * xi[i][j][1];
234
+ return vnp / ve2;
235
+ }
236
+ private double calcVnp(double[][][] xi, int sumn){
237
+ return calcSnp(xi, sumn) / n;
238
+ }
239
+ private double calcSnp(double[][][] xi, int sumn) {
240
+ double sumbx = calcbx(xi);
241
+ double sumeyx = calcSeyx(xi, sumn);
242
+ double sumex = calcSex(xi, sumn);
184
243
 
185
- }
186
- double wki = n * sumyx - sumy * sumx;
187
- double wk = wki * wki / (n * (n * sumx2 - sumx * sumx));
244
+ return sumbx - sumeyx * sumeyx / sumex;
245
+ }
246
+ private double calcVe2(double[][][] xi, int sumn) {
247
+ return calcSe2(xi, sumn) / m;
248
+ }
249
+ private double calcSe2(double[][][] xi, int sumn) {
250
+ double sumey = calcSey(xi, sumn);
251
+ double sumbx = calcbx(xi);
188
252
 
189
- sum += wk;
190
- }
191
- return sum;
253
+ return sumey - sumbx;
254
+ }
255
+ public boolean executeTest(double statistic, double a) {
256
+ FDistribution fDist = new FDistribution(n, m);
257
+ double f = fDist.inverseCumulativeProbability(1.0 - a);
258
+
259
+ return (statistic >= f) ? true : false;
260
+ }
261
+ }
262
+ // 回帰直線モデルの平行性の検定
263
+ private class SignificanceTest extends RegressionLine implements HypothesisTest {
264
+ private int n = 0;
265
+ private int m = 0;
266
+ public double calcTestStatistic(double[][][] xi) {
267
+ int sumn = calcSumn(xi);
268
+ n = 1;
269
+ m = sumn - xi.length - 1;
270
+
271
+ double vr = calcVr(xi, sumn);
272
+ double ve = calcVe(xi, sumn);
273
+
274
+ return vr / ve;
275
+ }
276
+ public boolean executeTest(double statistic, double a) {
277
+ FDistribution fDist = new FDistribution(n, m);
278
+ double f = fDist.inverseCumulativeProbability(1.0 - a);
279
+
280
+ return (statistic >= f) ? true : false;
281
+ }
282
+ private double calcVr(double[][][] xi, int sumn) {
283
+ double sumeyx = calcSeyx(xi, sumn);
284
+ double sumex = calcSex(xi, sumn);
285
+
286
+ return (sumeyx * sumeyx) / sumex;
287
+ }
288
+ private double calcVe(double[][][] xi, int sumn) {
289
+ double sumey = calcSey(xi, sumn);
290
+ double sumex = calcSex(xi, sumn);
291
+ double sumeyx = calcSeyx(xi, sumn);
292
+
293
+ return (sumey * sumex - sumeyx * sumeyx) / (m * sumex);
294
+ }
295
+ }
296
+ // 水準間の差の検定
297
+ private class DifferenceTest extends RegressionLine implements HypothesisTest {
298
+ private int n = 0;
299
+ private int m = 0;
300
+ public double calcTestStatistic(double[][][] xi) {
301
+ int sumn = calcSumn(xi);
302
+ n = xi.length - 1;
303
+ m = sumn - xi.length - 1;
304
+
305
+ double va = calcSa(xi, sumn) / n;
306
+ double ve = calcVe(xi, sumn);
307
+
308
+ return va / ve;
309
+ }
310
+ public boolean executeTest(double statistic, double a) {
311
+ FDistribution fDist = new FDistribution(n, m);
312
+ double f = fDist.inverseCumulativeProbability(1.0 - a);
313
+
314
+ return (statistic >= f) ? true : false;
315
+ }
316
+ private double calcVe(double[][][] xi, int sumn) {
317
+ double sumey = calcSey(xi, sumn);
318
+ double sumex = calcSex(xi, sumn);
319
+ double sumeyx = calcSeyx(xi, sumn);
320
+
321
+ return (sumey * sumex - sumeyx * sumeyx) / (m * sumex);
192
322
  }
193
323
  }
194
324
  }
data/lib/num4anova.rb CHANGED
@@ -228,8 +228,8 @@ module Num4AnovaLib
228
228
  #
229
229
  # @overload parallel_test(xi, a)
230
230
  # @param [array] xi データ(double[][][])
231
- # @param [double] a 有意水準
232
- # @return [boolean] 検定結果(boolean true:棄却域内 false:棄却域外)
231
+ # @param [double] a 有意水準
232
+ # @return [boolean] 検定結果(boolean true:棄却域内 false:棄却域外)
233
233
  # @example
234
234
  # xi = [
235
235
  # [
@@ -254,6 +254,66 @@ module Num4AnovaLib
254
254
  def parallel_test(xi, a)
255
255
  @ancova.parallelTest(xi.to_java(Java::double[][]), a)
256
256
  end
257
+ # 回帰直線の有意性検定
258
+ #
259
+ # @overload significance_test(xi, a)
260
+ # @param [array] xi データ(double[][][])
261
+ # @param [double] a 有意水準
262
+ # @return [boolean] 検定結果(boolean true:棄却域内 false:棄却域外)
263
+ # @example
264
+ # xi = [
265
+ # [
266
+ # [3,35], [5,38], [3,39],
267
+ # ],
268
+ # [
269
+ # [3,36], [3,39], [8,54],
270
+ # ],
271
+ # [
272
+ # [2,40], [2,45], [2,39],
273
+ # ],
274
+ # [
275
+ # [3,47], [4,52], [2,48],
276
+ # ],
277
+ # [
278
+ # [1,64], [2,80], [0,70],
279
+ # ],
280
+ # ]
281
+ # ancova = Num4AnovaLib::Num4AncovaLib.new
282
+ # ancova.significance_test(xi, 0.05)
283
+ # => true
284
+ def significance_test(xi, a)
285
+ @ancova.significanceTest(xi.to_java(Java::double[][]), a)
286
+ end
287
+ # 水準間の差の検定
288
+ #
289
+ # @overload difference_test(xi, a)
290
+ # @param [array] xi データ(double[][][])
291
+ # @param [double] a 有意水準
292
+ # @return [boolean] 検定結果(boolean true:棄却域内 false:棄却域外)
293
+ # @example
294
+ # xi = [
295
+ # [
296
+ # [3,35], [5,38], [3,39],
297
+ # ],
298
+ # [
299
+ # [3,36], [3,39], [8,54],
300
+ # ],
301
+ # [
302
+ # [2,40], [2,45], [2,39],
303
+ # ],
304
+ # [
305
+ # [3,47], [4,52], [2,48],
306
+ # ],
307
+ # [
308
+ # [1,64], [2,80], [0,70],
309
+ # ],
310
+ # ]
311
+ # ancova = Num4AnovaLib::Num4AncovaLib.new
312
+ # ancova.difference_test(xi, 0.05)
313
+ # => true
314
+ def difference_test(xi, a)
315
+ @ancova.differenceTest(xi.to_java(Java::double[][]), a)
316
+ end
257
317
  end
258
318
  end
259
319
 
metadata CHANGED
@@ -1,14 +1,14 @@
1
1
  --- !ruby/object:Gem::Specification
2
2
  name: num4anova
3
3
  version: !ruby/object:Gem::Version
4
- version: 0.0.9
4
+ version: 0.0.11
5
5
  platform: java
6
6
  authors:
7
7
  - siranovel
8
8
  autorequire:
9
9
  bindir: bin
10
10
  cert_chain: []
11
- date: 2024-03-02 00:00:00.000000000 Z
11
+ date: 2024-03-21 00:00:00.000000000 Z
12
12
  dependencies:
13
13
  - !ruby/object:Gem::Dependency
14
14
  name: rake