num4anova 0.0.9-java → 0.0.11-java

Sign up to get free protection for your applications and to get access to all the features.
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