1
2
3
4
5
6
7
8
9
10
11
12
13
14
15 package ubic.basecode.math.linearmodels;
16
17 import static org.junit.Assert.assertArrayEquals;
18 import static org.junit.Assert.assertEquals;
19 import static org.junit.Assert.assertNotNull;
20 import static org.junit.Assert.assertNull;
21 import static org.junit.Assert.assertTrue;
22
23 import java.text.DecimalFormat;
24 import java.text.NumberFormat;
25 import java.util.List;
26 import java.util.Locale;
27 import java.util.Map;
28 import java.util.zip.GZIPInputStream;
29
30 import org.apache.commons.math3.distribution.FDistribution;
31 import org.junit.Test;
32
33 import cern.colt.list.DoubleArrayList;
34 import cern.colt.matrix.DoubleMatrix1D;
35 import cern.colt.matrix.DoubleMatrix2D;
36 import cern.colt.matrix.impl.DenseDoubleMatrix2D;
37 import cern.colt.matrix.linalg.Algebra;
38 import cern.jet.math.Functions;
39 import ubic.basecode.dataStructure.matrix.DenseDoubleMatrix;
40 import ubic.basecode.dataStructure.matrix.DenseDoubleMatrix1D;
41 import ubic.basecode.dataStructure.matrix.DoubleMatrix;
42 import ubic.basecode.dataStructure.matrix.ObjectMatrix;
43 import ubic.basecode.dataStructure.matrix.ObjectMatrixImpl;
44 import ubic.basecode.dataStructure.matrix.StringMatrix;
45 import ubic.basecode.io.reader.DoubleMatrixReader;
46 import ubic.basecode.io.reader.StringMatrixReader;
47 import ubic.basecode.io.writer.MatrixWriter;
48 import ubic.basecode.math.DescriptiveWithMissing;
49 import ubic.basecode.math.MatrixStats;
50
51
52
53
54 public class LeastSquaresFitTest {
55
56
57
58
59 @Test
60 public void testLSFOneContinuousWithMissing3() throws Exception {
61 DoubleMatrixReader f = new DoubleMatrixReader();
62 DoubleMatrix<String, String> testMatrix = f.read( this.getClass().getResourceAsStream(
63 "/data/example.madata.withmissing.small.txt" ) );
64
65 ObjectMatrix<String, String, Object> design = new ObjectMatrixImpl<>( 9, 1 );
66 design.set( 0, 0, 0.12 );
67 design.set( 1, 0, 0.24 );
68 design.set( 2, 0, 0.48 );
69 design.set( 3, 0, 0.96 );
70 design.set( 4, 0, 0.12 );
71 design.set( 5, 0, 0.24 );
72 design.set( 6, 0, 0.48 );
73 design.set( 7, 0, 0.96 );
74 design.set( 8, 0, 0.96 );
75
76 design.setRowNames( testMatrix.getColNames() );
77 design.addColumnName( "Value" );
78
79 LeastSquaresFit fit = new LeastSquaresFit( design, testMatrix );
80
81 Map<String, LinearModelSummary> sums = fit.summarizeByKeys( true );
82
83 LinearModelSummary s = sums.get( "228980_at" );
84 assertNotNull( s );
85 assertEquals( 0.1495, s.getF(), 0.01 );
86 assertEquals( 0.7123, s.getP(), 0.001 );
87 assertEquals( 10.9180, s.getContrastCoefficients().get( 0, 0 ), 0.001 );
88 assertEquals( 0.712, s.getContrastCoefficients().get( 1, 3 ), 0.001 );
89 assertEquals( 6, s.getResidualDof().intValue() );
90 GenericAnovaResult a = s.getAnova();
91 assertEquals( 0.1495, a.getMainEffectF( "Value" ), 0.0001 );
92 assertEquals( 1, a.getMainEffectDof( "Value" ).intValue() );
93 assertEquals( 6, a.getResidualDf().intValue() );
94
95 FDistribution fd = new FDistribution( 1, 6 );
96 double p = 1.0 - fd.cumulativeProbability( 0.1495 );
97 assertEquals( 0.7123, p, 0.0001 );
98 assertEquals( 0.7123, a.getMainEffectP( "Value" ), 0.0001 );
99
100 s = sums.get( "1553129_at" );
101 assertNotNull( s );
102 assertEquals( 2.095, s.getF(), 0.01 );
103 assertEquals( 0.1911, s.getP(), 0.001 );
104 assertEquals( 3.78719, s.getContrastCoefficients().get( 0, 0 ), 0.001 );
105 assertEquals( 0.191, s.getContrastCoefficients().get( 1, 3 ), 0.001 );
106 a = s.getAnova();
107 assertNotNull( a );
108 assertEquals( 0.1911, a.getMainEffectP( "Value" ), 0.0001 );
109
110 s = fit.summarize( 14 );
111 assertNotNull( s );
112 assertEquals( "214502_at", s.getKey() );
113 assertEquals( 1.992, s.getF(), 0.01 );
114 assertEquals( 0.2172, s.getP(), 0.001 );
115 assertEquals( 4.2871, s.getContrastCoefficients().get( 0, 0 ), 0.001 );
116 assertEquals( 0.217, s.getContrastCoefficients().get( 1, 3 ), 0.001 );
117
118 s = sums.get( "232018_at" );
119 assertNotNull( s );
120 assertEquals( 1.381, s.getF(), 0.01 );
121 assertEquals( 0.2783, s.getP(), 0.001 );
122 assertEquals( 6.6537, s.getContrastCoefficients().get( 0, 0 ), 0.001 );
123 assertEquals( 0.278, s.getContrastCoefficients().get( 1, 3 ), 0.001 );
124 a = s.getAnova();
125 assertNotNull( a );
126 assertEquals( 0.2783, a.getMainEffectP( "Value" ), 0.0001 );
127 s = sums.get( "228980_at" );
128 assertNotNull( s );
129 assertEquals( 0.1495, s.getF(), 0.01 );
130 assertEquals( 0.7123, s.getP(), 0.001 );
131 assertEquals( 10.9180, s.getContrastCoefficients().get( 0, 0 ), 0.001 );
132 assertEquals( 0.712, s.getContrastCoefficients().get( 1, 3 ), 0.001 );
133 a = s.getAnova();
134 assertNotNull( a );
135 assertEquals( 0.7123, a.getMainEffectP( "Value" ), 0.0001 );
136 }
137
138
139
140
141 @Test
142 public void testLSFThreeLevelsOnecontinous2() throws Exception {
143 DoubleMatrixReader f = new DoubleMatrixReader();
144 DoubleMatrix<String, String> testMatrix = f.read( this.getClass().getResourceAsStream(
145 "/data/example.madata.small.txt" ) );
146
147 ObjectMatrix<String, String, Object> design = new ObjectMatrixImpl<>( 9, 2 );
148
149 design.set( 0, 0, "A" );
150 design.set( 1, 0, "A" );
151 design.set( 2, 0, "A" );
152 design.set( 3, 0, "B" );
153 design.set( 4, 0, "B" );
154 design.set( 5, 0, "B" );
155 design.set( 6, 0, "C" );
156 design.set( 7, 0, "C" );
157 design.set( 8, 0, "C" );
158 design.set( 0, 1, 0.12 );
159 design.set( 1, 1, 0.24 );
160 design.set( 2, 1, 0.48 );
161 design.set( 3, 1, 0.96 );
162 design.set( 4, 1, 0.12 );
163 design.set( 5, 1, 0.24 );
164 design.set( 6, 1, 0.48 );
165 design.set( 7, 1, 0.96 );
166 design.set( 8, 1, 0.96 );
167
168 design.setRowNames( testMatrix.getColNames() );
169 design.addColumnName( "Factor" );
170 design.addColumnName( "Value" );
171
172 LeastSquaresFit fit = new LeastSquaresFit( design, testMatrix );
173
174 DoubleMatrix2D coeffs = fit.getCoefficients();
175 assertEquals( 3.7458080, coeffs.get( 0, 0 ), 0.0001 );
176 assertEquals( -0.4388889, coeffs.get( 1, 2 ), 0.0001 );
177 assertEquals( 0.5709091, coeffs.get( 2, 10 ), 0.0001 );
178 assertEquals( 0.04856061, coeffs.get( 2, 18 ), 0.0001 );
179 assertEquals( -1.1363636, coeffs.get( 3, 10 ), 0.0001 );
180 assertEquals( 0.11174242, coeffs.get( 3, 18 ), 0.0001 );
181
182 DoubleMatrix2D fitted = fit.getFitted();
183
184 assertEquals( 3.764747, fitted.get( 0, 0 ), 0.0001 );
185 assertEquals( 6.043990, fitted.get( 1, 3 ), 0.0001 );
186 assertEquals( 10.858586, fitted.get( 7, 2 ), 0.0001 );
187 assertEquals( 6.307879, fitted.get( 18, 8 ), 0.0001 );
188
189 List<GenericAnovaResult> anova = fit.anova();
190 assertEquals( 19, anova.size() );
191 }
192
193
194
195
196 @Test
197 public void testLSFThreeLevelsOneContinuousWithMissing3() throws Exception {
198 DoubleMatrixReader f = new DoubleMatrixReader();
199 DoubleMatrix<String, String> testMatrix = f.read( this.getClass().getResourceAsStream(
200 "/data/example.madata.withmissing.small.txt" ) );
201
202 ObjectMatrix<String, String, Object> design = new ObjectMatrixImpl<>( 9, 2 );
203
204 design.set( 0, 0, "A" );
205 design.set( 1, 0, "A" );
206 design.set( 2, 0, "A" );
207 design.set( 3, 0, "B" );
208 design.set( 4, 0, "B" );
209 design.set( 5, 0, "B" );
210 design.set( 6, 0, "C" );
211 design.set( 7, 0, "C" );
212 design.set( 8, 0, "C" );
213 design.set( 0, 1, 0.12 );
214 design.set( 1, 1, 0.24 );
215 design.set( 2, 1, 0.48 );
216 design.set( 3, 1, 0.96 );
217 design.set( 4, 1, 0.12 );
218 design.set( 5, 1, 0.24 );
219 design.set( 6, 1, 0.48 );
220 design.set( 7, 1, 0.96 );
221 design.set( 8, 1, 0.96 );
222
223 design.setRowNames( testMatrix.getColNames() );
224 design.addColumnName( "Factor" );
225 design.addColumnName( "Value" );
226
227 LeastSquaresFit fit = new LeastSquaresFit( design, new DenseDoubleMatrix2D( testMatrix.asArray() ) );
228
229 DoubleMatrix2D coeffs = fit.getCoefficients();
230 assertEquals( 3.7458080, coeffs.get( 0, 0 ), 0.0001 );
231 assertEquals( -0.4388889, coeffs.get( 1, 2 ), 0.0001 );
232 assertEquals( 0.5709091, coeffs.get( 2, 10 ), 0.0001 );
233 assertEquals( 0.04856061, coeffs.get( 2, 18 ), 0.0001 );
234 assertEquals( -1.1363636, coeffs.get( 3, 10 ), 0.0001 );
235 assertEquals( 0.11174242, coeffs.get( 3, 18 ), 0.0001 );
236
237 DoubleMatrix2D fitted = fit.getFitted();
238
239 assertEquals( 3.764747, fitted.get( 0, 0 ), 0.0001 );
240 assertEquals( 6.043990, fitted.get( 1, 3 ), 0.0001 );
241 assertEquals( 10.8333, fitted.get( 7, 2 ), 0.0001 );
242 assertEquals( 6.307879, fitted.get( 18, 8 ), 0.0001 );
243
244 List<GenericAnovaResult> anova = fit.anova();
245
246 assertEquals( 19, anova.size() );
247 }
248
249
250
251
252 @Test
253 public void testLSFTwoLevels() throws Exception {
254 DoubleMatrixReader f = new DoubleMatrixReader();
255 DoubleMatrix<String, String> testMatrix = f.read( this.getClass().getResourceAsStream(
256 "/data/example.madata.small.txt" ) );
257
258 ObjectMatrix<String, String, Object> design = new ObjectMatrixImpl<>( 9, 1 );
259
260 design.set( 0, 0, "A" );
261 design.set( 1, 0, "A" );
262 design.set( 2, 0, "A" );
263 design.set( 3, 0, "A" );
264 design.set( 4, 0, "B" );
265 design.set( 5, 0, "B" );
266 design.set( 6, 0, "B" );
267 design.set( 7, 0, "B" );
268 design.set( 8, 0, "B" );
269 design.setRowNames( testMatrix.getColNames() );
270 design.addColumnName( "Factor" );
271
272 LeastSquaresFit fit = new LeastSquaresFit( design, testMatrix );
273
274 Map<String, LinearModelSummary> sums = fit.summarizeByKeys( true );
275
276 LinearModelSummary s = sums.get( "1553129_at" );
277 assertEquals( 0.182999, s.getF(), 0.0001 );
278 assertEquals( 0.6817, s.getP(), 0.001 );
279 assertEquals( 3.84250, s.getContrastCoefficients().get( 0, 0 ), 0.001 );
280 assertEquals( 0.682, s.getContrastCoefficients().get( 1, 3 ), 0.001 );
281
282 Double[] effects = s.getEffects();
283 assertEquals( -11.58333, effects[0], 0.0001 );
284 assertEquals( 0.04999, effects[1], 0.0001 );
285
286 Double[] stdevUnscaled = s.getStdevUnscaled();
287 assertEquals( 0.5, stdevUnscaled[0], 0.0001 );
288 assertEquals( 0.6708203932, stdevUnscaled[1], 0.0001 );
289
290 Double sigma = s.getSigma();
291 assertEquals( 0.11673841331, sigma, 0.0001 );
292
293 s = sums.get( "232018_at" );
294 assertEquals( -18.9866667, s.getEffects()[0], 0.0001 );
295 assertEquals( 0.1714319, s.getEffects()[1], 0.0001 );
296 assertEquals( 0.07879, s.getF(), 0.01 );
297 assertEquals( 0.787, s.getP(), 0.001 );
298 assertEquals( 6.2650, s.getContrastCoefficients().get( 0, 0 ), 0.001 );
299 assertEquals( 0.787, s.getContrastCoefficients().get( 1, 3 ), 0.001 );
300 sigma = s.getSigma();
301 assertEquals( 0.61072556381, sigma, 0.0001 );
302 }
303
304
305
306
307
308
309 @Test
310 public void testLSFTwoLevels2() throws Exception {
311 DoubleMatrixReader f = new DoubleMatrixReader();
312 DoubleMatrix<String, String> testMatrix = f.read( this.getClass().getResourceAsStream(
313 "/data/lmtest1.dat.manymissing.txt" ) );
314
315 StringMatrixReader of = new StringMatrixReader();
316 StringMatrix<String, String> sampleInfo = of.read( this.getClass()
317 .getResourceAsStream( "/data/lmtest1.des.txt" ) );
318
319 DesignMatrix d = new DesignMatrix( sampleInfo, true );
320 d.addInteraction();
321
322 LeastSquaresFit fit = new LeastSquaresFit( d, testMatrix );
323 Map<String, LinearModelSummary> sums = fit.summarizeByKeys( true );
324 assertEquals( 100, sums.size() );
325
326 for ( LinearModelSummary lms : sums.values() ) {
327 GenericAnovaResult a = lms.getAnova();
328 assertNotNull( a );
329 Double interactionEffectP = a.getInteractionEffectP();
330 assertNotNull( interactionEffectP );
331 }
332
333 }
334
335
336
337
338 @Test
339 public void testLSFTwoLevels3() throws Exception {
340 DoubleMatrixReader f = new DoubleMatrixReader();
341 DoubleMatrix<String, String> testMatrix = f.read( this.getClass().getResourceAsStream(
342 "/data/anova-test-data.txt" ) );
343
344 StringMatrixReader of = new StringMatrixReader();
345 StringMatrix<String, String> sampleInfo = of.read( this.getClass().getResourceAsStream(
346 "/data/anova-test-des.txt" ) );
347
348 DesignMatrix d = new DesignMatrix( sampleInfo, true );
349 d.addInteraction( "factor1", "factor2" );
350
351 LeastSquaresFit fit = new LeastSquaresFit( d, testMatrix );
352 Map<String, LinearModelSummary> sums = fit.summarizeByKeys( true );
353 assertEquals( 100, sums.size() );
354
355 for ( LinearModelSummary lms : sums.values() ) {
356 GenericAnovaResult a = lms.getAnova();
357 assertNotNull( a );
358 Double interactionEffectP = a.getInteractionEffectP();
359 assertNotNull( interactionEffectP );
360 }
361
362 assertEquals( 0.0048, sums.get( "probe_4" ).getMainEffectP( "factor1" ), 0.0001 );
363 assertEquals( 5.158e-10, sums.get( "probe_10" ).getMainEffectP( "factor1" ), 1e-12 );
364 assertEquals( 0.6888, sums.get( "probe_98" ).getMainEffectP( "factor2" ), 1e-4 );
365 assertEquals( 0.07970, sums.get( "probe_10" ).getMainEffectP( "factor2" ), 1e-4 );
366
367 }
368
369
370
371
372 @Test
373 public void testLSFTwoLevelsOneContinuous() throws Exception {
374 DoubleMatrixReader f = new DoubleMatrixReader();
375 DoubleMatrix<String, String> testMatrix = f.read( this.getClass().getResourceAsStream(
376 "/data/example.madata.small.txt" ) );
377
378 ObjectMatrix<String, String, Object> design = new ObjectMatrixImpl<>( 9, 2 );
379
380 design.set( 0, 0, "A" );
381 design.set( 1, 0, "A" );
382 design.set( 2, 0, "A" );
383 design.set( 3, 0, "A" );
384 design.set( 4, 0, "B" );
385 design.set( 5, 0, "B" );
386 design.set( 6, 0, "B" );
387 design.set( 7, 0, "B" );
388 design.set( 8, 0, "B" );
389 design.set( 0, 1, 0.12 );
390 design.set( 1, 1, 0.24 );
391 design.set( 2, 1, 0.48 );
392 design.set( 3, 1, 0.96 );
393 design.set( 4, 1, 0.12 );
394 design.set( 5, 1, 0.24 );
395 design.set( 6, 1, 0.48 );
396 design.set( 7, 1, 0.96 );
397 design.set( 8, 1, 0.96 );
398
399 design.setRowNames( testMatrix.getColNames() );
400 design.addColumnName( "Factor" );
401 design.addColumnName( "Value" );
402
403 LeastSquaresFit fit = new LeastSquaresFit( design, testMatrix );
404
405 DoubleMatrix2D coeffs = fit.getCoefficients();
406 assertEquals( 3.77868, coeffs.get( 0, 0 ), 0.0001 );
407 assertEquals( 0.24476, coeffs.get( 1, 2 ), 0.0001 );
408 assertEquals( -0.680449, coeffs.get( 2, 10 ), 0.0001 );
409 assertEquals( 0.114084, coeffs.get( 2, 18 ), 0.0001 );
410
411 DoubleMatrix2D fitted = fit.getFitted();
412
413 assertEquals( 3.795698, fitted.get( 0, 0 ), 0.0001 );
414 assertEquals( 5.497165, fitted.get( 1, 3 ), 0.0001 );
415 assertEquals( 10.879917, fitted.get( 7, 2 ), 0.0001 );
416 assertEquals( 6.346546, fitted.get( 18, 8 ), 0.0001 );
417
418 List<GenericAnovaResult> anova = fit.anova();
419 assertEquals( 19, anova.size() );
420 Map<String, LinearModelSummary> sums = fit.summarizeByKeys( true );
421
422 LinearModelSummary s = sums.get( "1553129_at" );
423 assertEquals( 0.9389, s.getF(), 0.01 );
424 assertEquals( 0.4418, s.getP(), 0.001 );
425 assertEquals( 3.77868, s.getContrastCoefficients().get( 0, 0 ), 0.001 );
426 assertEquals( 0.810, s.getContrastCoefficients().get( 1, 3 ), 0.001 );
427 GenericAnovaResult a = s.getAnova();
428 assertEquals( 0.2429, a.getMainEffectP( "Value" ), 0.0001 );
429
430 s = sums.get( "232018_at" );
431 assertEquals( 0.7167, s.getF(), 0.01 );
432 assertEquals( 0.5259, s.getP(), 0.001 );
433 assertEquals( 6.5712, s.getContrastCoefficients().get( 0, 0 ), 0.001 );
434 assertEquals( 0.664, s.getContrastCoefficients().get( 1, 3 ), 0.001 );
435 a = s.getAnova();
436 assertEquals( 0.2893, a.getMainEffectP( "Value" ), 0.0001 );
437
438
439 DoubleMatrix2D studentizedResiduals = fit.getStudentizedResiduals();
440
441 double[] expectedStudentizedResiduals = new double[] { -0.34655041, 1.46251738, -0.61403124, -0.34663812,
442 -1.51245468, 0.06875469, 1.45818880, 1.02811044, -1.31696150 };
443
444 for ( int i = 0; i < 9; i++ ) {
445 assertEquals( expectedStudentizedResiduals[i], studentizedResiduals.viewRow( 10 ).get( i ), 0.001 );
446 }
447
448
449
450
451 assertEquals( 1.1,
452 DescriptiveWithMissing.variance( new DoubleArrayList( studentizedResiduals.viewRow( 10 ).toArray() ) ),
453 0.1 );
454
455
456 studentizedResiduals = fit.getStudentizedResiduals();
457 expectedStudentizedResiduals = new double[] { 0.46128657, -5.49429390, 0.84157385, 1.10053286, 1.10538546,
458 -0.01706794, -0.05318259, -0.56926585, -0.35107932 };
459 for ( int i = 0; i < 9; i++ ) {
460 assertEquals( expectedStudentizedResiduals[i], studentizedResiduals.viewRow( 0 ).get( i ), 0.001 );
461 }
462
463 }
464
465
466
467
468
469
470 @Test
471 public void testMatrixWeightedRegress() throws Exception {
472 DoubleMatrix2D dat = new DenseDoubleMatrix2D( new double[][] { { 1, 2, 3, 4, 5 }, { 1, 1, 6, 3, 2 } } );
473 DoubleMatrix2D des = new DenseDoubleMatrix2D( new double[][] { { 1, 1, 1, 1, 1 }, { 1, 2, 2, 3, 3 },
474 { 2, 1, 5, 3, 4 } } );
475
476 DoubleMatrix2D w = dat.copy();
477 w.assign( dat );
478 Algebra solver = new Algebra();
479 des = solver.transpose( des );
480 LeastSquaresFit fit = new LeastSquaresFit( des, dat, w );
481
482
483
484
485
486
487
488
489 DoubleMatrix2D actuals = solver.transpose( fit.getCoefficients() );
490 double[][] expected = new double[][] { { -1.7070, 1.7110, 0.3054 }, { 0.2092, -0.6642, 1.3640 } };
491 for ( int i = 0; i < expected.length; i++ ) {
492 assertArrayEquals( expected[i], actuals.viewRow( i ).toArray(), 0.001 );
493 }
494
495
496 actuals = fit.getFitted();
497 expected = new double[][] { { 0.6151, 2.0210, 3.2430, 4.3430, 4.6490 }, { 2.273, 0.245, 5.701, 2.309, 3.673 } };
498 for ( int i = 0; i < expected.length; i++ ) {
499 assertArrayEquals( expected[i], actuals.viewRow( i ).toArray(), 0.001 );
500 }
501
502
503 actuals = fit.getResiduals();
504 expected = new double[][] { { 0.38490, -0.02092, -0.24270, -0.34310, 0.35150 },
505 { -1.2730, 0.7550, 0.2986, 0.6910, -1.6730 } };
506 for ( int i = 0; i < expected.length; i++ ) {
507 assertArrayEquals( expected[i], actuals.viewRow( i ).toArray(), 0.001 );
508 }
509
510 }
511
512
513
514
515
516
517 @Test
518 public void testOneWayAnova() throws Exception {
519 DoubleMatrixReader f = new DoubleMatrixReader();
520 DoubleMatrix<String, String> testMatrix = f.read( this.getClass().getResourceAsStream(
521 "/data/anova-test-data.txt" ) );
522
523 ObjectMatrix<String, String, Object> design = new ObjectMatrixImpl<>( 8, 1 );
524 for ( int i = 0; i < 8; i++ ) {
525 design.set( i, 0, "A" + i % 3 );
526 }
527 design.addColumnName( "Factor1" );
528
529 DesignMatrix d = new DesignMatrix( design, true );
530
531 LeastSquaresFit fit = new LeastSquaresFit( d, testMatrix );
532 Map<String, LinearModelSummary> sums = fit.summarizeByKeys( true );
533 assertEquals( 100, sums.size() );
534
535 for ( LinearModelSummary lms : sums.values() ) {
536 GenericAnovaResult a = lms.getAnova();
537 assertNotNull( a );
538 Double interactionEffectP = a.getInteractionEffectP();
539 assertNull( interactionEffectP );
540 }
541
542 LinearModelSummary sum4 = sums.get( "probe_4" );
543 assertNotNull( sum4.getContrastCoefficients() );
544 assertEquals( 0.6531, sum4.getP(), 0.0001 );
545 assertEquals( 0.2735, sum4.getF(), 0.0001 );
546 assertEquals( 0.2735, sum4.getAnova().getMainEffectF( "Factor1" ), 0.0001 );
547 assertEquals( 2, sum4.getAnova().getResidualDf().intValue() );
548 assertEquals( 1, sum4.getAnova().getMainEffectDof( "Factor1" ).intValue() );
549 assertEquals( 0.6531, sum4.getMainEffectP( "Factor1" ), 0.0001 );
550
551 LinearModelSummary sum21 = sums.get( "probe_21" );
552 assertNotNull( sum21.getContrastCoefficients() );
553 assertEquals( 0.6492, sum21.getP(), 0.0001 );
554 assertEquals( 0.4821, sum21.getF(), 0.0001 );
555 assertEquals( 0.4821, sum21.getAnova().getMainEffectF( "Factor1" ), 0.0001 );
556 assertEquals( 4, sum21.getAnova().getResidualDf().intValue() );
557 assertEquals( 2, sum21.getAnova().getMainEffectDof( "Factor1" ).intValue() );
558 assertEquals( 0.6492, sum21.getMainEffectP( "Factor1" ), 0.0001 );
559
560 LinearModelSummary sum98 = sums.get( "probe_98" );
561 assertNotNull( sum98.getContrastCoefficients() );
562 assertEquals( 0.1604, sum98.getP(), 0.0001 );
563 assertEquals( 2.993, sum98.getF(), 0.0001 );
564 assertEquals( 4, sum98.getAnova().getResidualDf().intValue() );
565 assertEquals( 2, sum98.getAnova().getMainEffectDof( "Factor1" ).intValue() );
566 assertEquals( 2.9931, sum98.getAnova().getMainEffectF( "Factor1" ).doubleValue(), 0.0001 );
567 assertEquals( 0.1604, sum98.getMainEffectP( "Factor1" ), 1e-4 );
568
569 LinearModelSummary sum10 = sums.get( "probe_10" );
570 assertNotNull( sum10.getContrastCoefficients() );
571 assertEquals( 0.8014, sum10.getP(), 0.0001 );
572 assertEquals( 0.2314, sum10.getF(), 0.0001 );
573 assertEquals( 5, sum10.getAnova().getResidualDf().intValue() );
574 assertEquals( 2, sum10.getAnova().getMainEffectDof( "Factor1" ).intValue() );
575 assertEquals( 0.8014, sum10.getMainEffectP( "Factor1" ), 1e-4 );
576
577
578
579
580 LinearModelSummary sum60 = sums.get( "probe_60" );
581 assertNotNull( sum60.getContrastCoefficients() );
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596 assertEquals( 9.00145, sum60.getContrastCoefficients().get( 0, 0 ), 0.0001 );
597 assertEquals( -0.01020, sum60.getContrastCoefficients().get( 1, 0 ), 0.0001 );
598 assertEquals( Double.NaN, sum60.getContrastCoefficients().get( 2, 0 ), 0.0001 );
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614 assertEquals( 2, sum60.getResidualDof().intValue() );
615 assertEquals( 1, sum60.getNumeratorDof().intValue() );
616
617 assertEquals( 2, sum60.getAnova().getResidualDf().intValue() );
618 assertEquals( 1, sum60.getAnova().getMainEffectDof( "Factor1" ).intValue() );
619
620
621
622 assertEquals( 0.0004715, sum60.getF(), 1e-7 );
623 assertEquals( 0.9846482, sum60.getP(), 1e-5 );
624
625
626 assertEquals( 0.9846482, sum60.getMainEffectP( "Factor1" ), 1e-5 );
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713 }
714
715
716
717
718 @Test
719 public void testSingular() throws Exception {
720 DoubleMatrixReader f = new DoubleMatrixReader();
721 DoubleMatrix<String, String> testMatrix = f
722 .read( this.getClass().getResourceAsStream( "/data/lmtest2.dat.txt" ) );
723
724 StringMatrixReader of = new StringMatrixReader();
725 StringMatrix<String, String> sampleInfo = of.read( this.getClass()
726 .getResourceAsStream( "/data/lmtest2.des.txt" ) );
727 DesignMatrix d = new DesignMatrix( sampleInfo, true );
728
729 assertEquals( 9, d.getMatrix().columns() );
730
731 LeastSquaresFit fit = new LeastSquaresFit( d, testMatrix );
732
733 Map<String, LinearModelSummary> sums = fit.summarizeByKeys( true );
734 assertEquals( 81, sums.size() );
735
736 for ( LinearModelSummary lms : sums.values() ) {
737 GenericAnovaResult a = lms.getAnova();
738 assertNotNull( a );
739 }
740
741 LinearModelSummary s = sums.get( "A01157cds_s_at" );
742
743 assertNotNull( s.getContrastCoefficients() );
744
745 assertEquals( 7.3740000, s.getContrastCoefficients().get( 0, 0 ), 0.001 );
746
747 assertEquals( 6, s.getResidualDof().intValue() );
748 assertEquals( 7, s.getNumeratorDof().intValue() );
749 assertEquals( 0.8634, s.getF(), 0.01 );
750 assertEquals( 0.5795, s.getP(), 0.001 );
751
752 }
753
754
755
756
757
758
759 @Test
760 public void testSingular2() throws Exception {
761 DoubleMatrixReader f = new DoubleMatrixReader();
762 DoubleMatrix<String, String> testMatrix = f.read( this.getClass().getResourceAsStream(
763 "/data/1027_GSE6189.data.test.txt" ) );
764
765 StringMatrixReader of = new StringMatrixReader();
766 StringMatrix<String, String> sampleInfo = of.read( this.getClass().getResourceAsStream(
767 "/data/1027_GSE6189_expdesign.data.txt" ) );
768 DesignMatrix d = new DesignMatrix( sampleInfo, true );
769
770 LeastSquaresFit fit = new LeastSquaresFit( d, testMatrix.getRowRange( 0, 0 ) );
771
772 Map<String, LinearModelSummary> sums = fit.summarizeByKeys( true );
773 assertEquals( 1, sums.size() );
774 for ( LinearModelSummary lms : sums.values() ) {
775 GenericAnovaResult a = lms.getAnova();
776 assertNotNull( a );
777 }
778 LinearModelSummary s = sums.get( "1367452_at" );
779 assertNotNull( s );
780 assertNotNull( s.getContrastCoefficients() );
781
782
783
784
785
786
787
788
789
790
791 double[] coef = new double[] { 15.10776244, -0.01689300, 0.09835841, -0.20163964, Double.NaN, -0.04092962,
792 Double.NaN, 0.06660370 };
793
794 for ( int i = 0; i < s.getContrastCoefficients().rows(); i++ ) {
795 assertEquals( coef[i], s.getContrastCoefficients().get( i, 0 ), 0.0001 );
796 }
797
798 }
799
800 @Test
801 public void testThreeWaySingular() throws Exception {
802 DoubleMatrixReader f = new DoubleMatrixReader();
803 DoubleMatrix<String, String> testMatrix = f.read( this.getClass().getResourceAsStream(
804 "/data/1064_GSE7863.data.test.txt" ) );
805
806 StringMatrixReader of = new StringMatrixReader();
807 StringMatrix<String, String> sampleInfo = of.read( this.getClass().getResourceAsStream(
808 "/data/1064_GSE7863_expdesign.data.test.txt" ) );
809 DesignMatrix d = new DesignMatrix( sampleInfo, true );
810
811 assertEquals( 5, d.getMatrix().columns() );
812
813 LeastSquaresFit fit = new LeastSquaresFit( d, testMatrix );
814
815 Map<String, LinearModelSummary> sums = fit.summarizeByKeys( true );
816 assertEquals( 416, sums.size() );
817
818 for ( LinearModelSummary lms : sums.values() ) {
819 GenericAnovaResult a = lms.getAnova();
820 assertNotNull( a );
821 }
822
823 LinearModelSummary s = sums.get( "1415696_at" );
824
825 assertNotNull( s.getContrastCoefficients() );
826 assertEquals( 0.000794, s.getContrastCoefficients().get( 2, 3 ), 0.001 );
827 assertEquals( 11, s.getResidualDof().intValue() );
828 assertEquals( 4, s.getNumeratorDof().intValue() );
829 assertEquals( 24.38, s.getF(), 0.01 );
830 assertEquals( 2.025e-05, s.getP(), 0.001 );
831 GenericAnovaResult anova = s.getAnova();
832 assertEquals( 29.0386, anova.getMainEffectF( "Treatment" ), 0.0001 );
833
834 s = sums.get( "1415837_at" );
835 assertNotNull( s.getContrastCoefficients() );
836 assertEquals( 11, s.getResidualDof().intValue() );
837 assertEquals( 4, s.getNumeratorDof().intValue() );
838 assertEquals( 22.72, s.getF(), 0.01 );
839 assertEquals( 2.847e-05, s.getP(), 0.001 );
840 anova = s.getAnova();
841 assertEquals( 6.5977, anova.getMainEffectF( "Treatment" ), 0.0001 );
842
843 s = sums.get( "1416179_a_at" );
844 assertNotNull( s.getContrastCoefficients() );
845 assertEquals( 11, s.getResidualDof().intValue() );
846 assertEquals( 4, s.getNumeratorDof().intValue() );
847 assertEquals( 25.14, s.getF(), 0.01 );
848 assertEquals( 1.743e-05, s.getP(), 0.001 );
849 anova = s.getAnova();
850 assertEquals( 38.411, anova.getMainEffectF( "Treatment" ), 0.001 );
851
852 s = sums.get( "1456759_at" );
853 assertNotNull( s.getContrastCoefficients() );
854 assertEquals( 11, s.getResidualDof().intValue() );
855 assertEquals( 4, s.getNumeratorDof().intValue() );
856 assertEquals( 7.903, s.getF(), 0.01 );
857 assertEquals( 0.002960, s.getP(), 0.001 );
858 anova = s.getAnova();
859 assertEquals( 10.3792, anova.getMainEffectF( "Treatment" ), 0.001 );
860 assertEquals( 2.6253, anova.getMainEffectF( "Genotype" ), 0.001 );
861 }
862
863
864
865
866
867
868 @Test
869 public void testTwoWayAnovaUnfittable() throws Exception {
870 DoubleMatrixReader f = new DoubleMatrixReader();
871 DoubleMatrix<String, String> testMatrix = f.read( this.getClass()
872 .getResourceAsStream( "/data/lmtest10.dat.txt" ) );
873
874 StringMatrixReader of = new StringMatrixReader();
875 StringMatrix<String, String> sampleInfo = of.read( this.getClass().getResourceAsStream(
876 "/data/lmtest10.des.txt" ) );
877
878 DesignMatrix d = new DesignMatrix( sampleInfo, true );
879
880 LeastSquaresFit fit = new LeastSquaresFit( d, testMatrix );
881 Map<String, LinearModelSummary> sums = fit.summarizeByKeys( true );
882 assertEquals( 1, sums.size() );
883
884 for ( LinearModelSummary lms : sums.values() ) {
885 GenericAnovaResult a = lms.getAnova();
886 assertNotNull( a );
887 assertEquals( Double.NaN, a.getMainEffectP( "CellType" ), 0.0001 );
888 assertEquals( Double.NaN, a.getMainEffectP( "SamplingTimePoint" ), 0.0001 );
889 }
890
891 DoubleMatrix2D coefficients = fit.getCoefficients();
892 DoubleMatrix2D residuals = fit.getResiduals();
893
894 assertEquals( 2.238, coefficients.get( 0, 0 ), 0.0001 );
895 assertEquals( 0.0, coefficients.get( 1, 0 ), 0.0001 );
896
897 for ( int i = 0; i < residuals.rows(); i++ ) {
898 assertEquals( 0.0, residuals.get( 0, i ), 0.00001 );
899 }
900 }
901
902
903
904
905
906
907 @Test
908 public void testTwoWayAnovaWithInteractions() throws Exception {
909 DoubleMatrixReader f = new DoubleMatrixReader();
910 DoubleMatrix<String, String> testMatrix = f.read( this.getClass().getResourceAsStream(
911 "/data/GSE8441_expmat_8probes.txt" ) );
912
913 StringMatrixReader of = new StringMatrixReader();
914 StringMatrix<String, String> sampleInfo = of.read( this.getClass().getResourceAsStream(
915 "/data/606_GSE8441_expdesign.data.txt" ) );
916 DesignMatrix d = new DesignMatrix( sampleInfo, true );
917 d.addInteraction();
918
919 assertEquals( 4, d.getMatrix().columns() );
920
921 assertEquals( 22, testMatrix.columns() );
922
923 LeastSquaresFit fit = new LeastSquaresFit( d, testMatrix );
924
925 Map<String, LinearModelSummary> sums = fit.summarizeByKeys( true );
926 assertEquals( 8, sums.size() );
927
928 for ( LinearModelSummary lms : sums.values() ) {
929 GenericAnovaResult a = lms.getAnova();
930 assertNotNull( a );
931 }
932
933 LinearModelSummary s = sums.get( "217757_at" );
934 GenericAnovaResult anova = s.getAnova();
935
936 assertNotNull( s.getContrastCoefficients() );
937 assertEquals( 0.763, s.getContrastCoefficients().get( 2, 3 ), 0.001 );
938 assertEquals( 18, s.getResidualDof().intValue() );
939 assertEquals( 3, s.getNumeratorDof().intValue() );
940 assertEquals( 0.299, s.getF(), 0.01 );
941 assertEquals( 0.8257, s.getP(), 0.001 );
942
943 assertEquals( 0.5876, anova.getMainEffectF( "Treatment" ), 0.0001 );
944 assertEquals( 0.5925, anova.getInteractionEffectP(), 0.001 );
945
946 s = sums.get( "202851_at" );
947 anova = s.getAnova();
948 assertNotNull( s.getContrastCoefficients() );
949 assertEquals( 0.787, s.getContrastCoefficients().get( 2, 3 ), 0.001 );
950 assertEquals( 18, s.getResidualDof().intValue() );
951 assertEquals( 3, s.getNumeratorDof().intValue() );
952 assertEquals( 0.1773, s.getF(), 0.01 );
953 assertEquals( 0.9104, s.getP(), 0.001 );
954
955 assertEquals( 0.3777, anova.getMainEffectF( "Treatment" ), 0.0001 );
956 assertEquals( 0.9956, anova.getInteractionEffectP(), 0.001 );
957 }
958
959
960
961
962
963
964 @Test
965 public void testTwoWayTwoLevelsOneContinousInteractionC() throws Exception {
966 DoubleMatrixReader f = new DoubleMatrixReader();
967 DoubleMatrix<String, String> testMatrix = f.read( this.getClass().getResourceAsStream(
968 "/data/example.madata.small.txt" ) );
969
970 ObjectMatrix<String, String, Object> design = new ObjectMatrixImpl<>( 9, 3 );
971
972 design.set( 0, 0, "A" );
973 design.set( 1, 0, "A" );
974 design.set( 2, 0, "A" );
975 design.set( 3, 0, "A" );
976 design.set( 4, 0, "B" );
977 design.set( 5, 0, "B" );
978 design.set( 6, 0, "B" );
979 design.set( 7, 0, "B" );
980 design.set( 8, 0, "B" );
981 design.set( 0, 1, 0.12 );
982 design.set( 1, 1, 0.24 );
983 design.set( 2, 1, 0.48 );
984 design.set( 3, 1, 0.96 );
985 design.set( 4, 1, 0.12 );
986 design.set( 5, 1, 0.24 );
987 design.set( 6, 1, 0.48 );
988 design.set( 7, 1, 0.96 );
989 design.set( 8, 1, 0.96 );
990 design.set( 0, 2, "C" );
991 design.set( 1, 2, "C" );
992 design.set( 2, 2, "D" );
993 design.set( 3, 2, "D" );
994 design.set( 4, 2, "C" );
995 design.set( 5, 2, "C" );
996 design.set( 6, 2, "D" );
997 design.set( 7, 2, "D" );
998 design.set( 8, 2, "D" );
999 design.addColumnName( "Treat" );
1000 design.addColumnName( "Value" );
1001 design.addColumnName( "Geno" );
1002
1003 DesignMatrix designMatrix = new DesignMatrix( design, true );
1004 designMatrix.addInteraction( "Treat", "Geno" );
1005 LeastSquaresFit fit = new LeastSquaresFit( designMatrix, testMatrix );
1006
1007 Map<String, LinearModelSummary> sums = fit.summarizeByKeys( true );
1008
1009 LinearModelSummary s = sums.get( "1553129_at" );
1010 assertEquals( 1.791, s.getF(), 0.01 );
1011 assertEquals( 0.2930, s.getP(), 0.001 );
1012 assertEquals( 3.71542, s.getContrastCoefficients().get( 0, 0 ), 0.001 );
1013 assertEquals( 0.184, s.getContrastCoefficients().get( 1, 3 ), 0.001 );
1014 assertEquals( 0.137, s.getContrastCoefficients().get( 4, 3 ), 0.001 );
1015 GenericAnovaResult a = s.getAnova();
1016 assertEquals( 0.137, a.getInteractionEffectP(), 0.001 );
1017
1018 s = sums.get( "232018_at" );
1019 assertEquals( 0.7167, s.getF(), 0.01 );
1020 assertEquals( 0.6235, s.getP(), 0.001 );
1021 assertEquals( 6.8873, s.getContrastCoefficients().get( 0, 0 ), 0.001 );
1022 assertEquals( 0.587932, s.getContrastCoefficients().get( 1, 3 ), 0.001 );
1023 a = s.getAnova();
1024 assertEquals( 0.2904, a.getInteractionEffectP(), 0.001 );
1025
1026 for ( LinearModelSummary lms : sums.values() ) {
1027 GenericAnovaResult anova = lms.getAnova();
1028 assertNotNull( anova );
1029 Double interactionEffectP = anova.getInteractionEffectP();
1030 assertNotNull( interactionEffectP );
1031 assertTrue( !Double.isNaN( interactionEffectP ) );
1032
1033 }
1034
1035 }
1036
1037 @Test
1038 public void testVectorRegress() {
1039
1040 DoubleMatrix1D vectorA = new DenseDoubleMatrix1D( new double[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 } );
1041 DoubleMatrix1D vectorB = new DenseDoubleMatrix1D( new double[] { 1, 2, 2, 3, 3, 4, 4, 5, 5, 6 } );
1042
1043 LeastSquaresFit fit = new LeastSquaresFit( vectorA, vectorB );
1044
1045 DoubleMatrix2D coefficients = fit.getCoefficients();
1046 DoubleMatrix2D residuals = fit.getResiduals();
1047
1048 assertEquals( 0.666666, coefficients.get( 0, 0 ), 0.0001 );
1049 assertEquals( 0.5152, coefficients.get( 1, 0 ), 0.0001 );
1050
1051 double[] expectedResiduals = new double[] { -0.1818182, 0.3030303, -0.2121212, 0.2727273, -0.2424242,
1052 0.2424242, -0.2727273, 0.2121212, -0.3030303, 0.1818182 };
1053
1054 for ( int i = 0; i < expectedResiduals.length; i++ ) {
1055 assertEquals( expectedResiduals[i], residuals.get( 0, i ), 0.00001 );
1056 }
1057
1058 }
1059
1060
1061
1062
1063 @Test
1064 public void testVectorWeightedRegress() throws Exception {
1065
1066
1067
1068 DoubleMatrix1D vectorA = new DenseDoubleMatrix1D( new double[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 } );
1069 DoubleMatrix1D vectorB = new DenseDoubleMatrix1D( new double[] { 1, 2, 2, 3, 3, 4, 4, 5, 5, 6 } );
1070 DoubleMatrix1D w = vectorA.copy().assign( Functions.inv );
1071
1072 LeastSquaresFit fit = new LeastSquaresFit( vectorA, vectorB, w );
1073
1074 DoubleMatrix2D coefficients = fit.getCoefficients();
1075 DoubleMatrix2D residuals = fit.getResiduals();
1076
1077
1078 assertEquals( 0.60469, coefficients.get( 0, 0 ), 0.0001 );
1079 assertEquals( 0.52642, coefficients.get( 1, 0 ), 0.0001 );
1080
1081 double[] expectedResiduals = new double[] { -0.1311097, 0.3424702, -0.1839499, 0.2896301, -0.2367900,
1082 0.2367900, -0.2896301, 0.1839499, -0.3424702, 0.1311097 };
1083
1084 for ( int i = 0; i < expectedResiduals.length; i++ ) {
1085 assertEquals( expectedResiduals[i], residuals.get( 0, i ), 0.00001 );
1086 }
1087
1088 double[] expectedFitted = new double[] { 1.13111, 1.65753, 2.18395, 2.71037, 3.23679, 3.76321, 4.28963,
1089 4.81605, 5.34247, 5.86889 };
1090
1091 for ( int i = 0; i < expectedFitted.length; i++ ) {
1092 assertEquals( expectedFitted[i], fit.getFitted().get( 0, i ), 0.00001 );
1093 }
1094 }
1095
1096
1097
1098
1099 @Test
1100 public void testVectorWeightedRegressWithMissing() throws Exception {
1101
1102 DoubleMatrixReader f = new DoubleMatrixReader();
1103 DoubleMatrix<String, String> testMatrix = f.read( this.getClass().getResourceAsStream(
1104 "/data/example.madata.withmissing.small.txt" ) );
1105 DoubleMatrix1D libSize = MatrixStats.colSums( testMatrix );
1106 testMatrix = MatrixStats.convertToLog2Cpm( testMatrix, libSize );
1107
1108 StringMatrixReader of = new StringMatrixReader();
1109 StringMatrix<String, String> sampleInfo = of.read( this.getClass().getResourceAsStream(
1110 "/data/example.metadata.small.txt" ) );
1111 DesignMatrix designMatrix = new DesignMatrix( sampleInfo );
1112 DoubleMatrix2D weights = new DenseDoubleMatrix2D( testMatrix.asArray() );
1113 weights.assign( Functions.inv );
1114
1115 LeastSquaresFit fit = new LeastSquaresFit( designMatrix, testMatrix, weights );
1116 assertTrue( fit.isHasMissing() );
1117
1118 DoubleMatrix2D coefficients = fit.getCoefficients();
1119 DoubleMatrix2D residuals = fit.getResiduals();
1120
1121 assertEquals( 15.339801, coefficients.get( 0, 0 ), 0.0001 );
1122 assertEquals( -0.024058, coefficients.get( 1, 1 ), 0.0001 );
1123 assertEquals( -0.059586, coefficients.get( 2, 18 ), 0.0001 );
1124
1125 assertEquals( -0.073732, residuals.get( 0, 0 ), 0.0001 );
1126 assertEquals( -0.064656, residuals.get( 1, 1 ), 0.0001 );
1127 assertEquals( -0.085214, residuals.get( 18, 8 ), 0.0001 );
1128 assertTrue( Double.isNaN( residuals.get( 4, 2 ) ) );
1129
1130 }
1131
1132
1133
1134
1135
1136
1137
1138
1139 @Test
1140 public void testNHBE() throws Exception {
1141 DoubleMatrixReader f = new DoubleMatrixReader();
1142 DoubleMatrix<String, String> testMatrix = f.read( new GZIPInputStream( this.getClass().getResourceAsStream(
1143 "/data/NHBE_transcriptome_data.txt.gz" ) ) );
1144
1145 StringMatrixReader of = new StringMatrixReader();
1146 StringMatrix<String, String> sampleInfo = of.read( this.getClass().getResourceAsStream(
1147 "/data/NHBE_design.txt" ) );
1148
1149 DesignMatrix designMatrix = new DesignMatrix( sampleInfo );
1150 designMatrix.addInteraction();
1151 designMatrix.setBaseline( "time", "1_h" );
1152 designMatrix.setBaseline( "Treatment", "control" );
1153
1154 LeastSquaresFit fit = new LeastSquaresFit( designMatrix, testMatrix );
1155
1156
1157
1158
1159 ModeratedTstat.ebayes( fit );
1160
1161
1162
1163 List<LinearModelSummary> sums = fit.summarize( true );
1164
1165
1166 assertEquals( 0.34927, sums.get( 0 ).getSigma(), 0.0001 );
1167 assertEquals( 1.3859, sums.get( 0 ).getPriorDof(), 0.01 );
1168
1169
1170
1171
1172 }
1173
1174
1175
1176
1177
1178
1179 @Test
1180 public void testEstrogen() throws Exception {
1181 DoubleMatrixReader f = new DoubleMatrixReader();
1182 DoubleMatrix<String, String> testMatrix = f.read( new GZIPInputStream( this.getClass().getResourceAsStream(
1183 "/data/estrogen.data.txt.gz" ) ) );
1184
1185 StringMatrixReader of = new StringMatrixReader();
1186 StringMatrix<String, String> sampleInfo = of.read( this.getClass().getResourceAsStream(
1187 "/data/estrogen.meta.txt" ) );
1188
1189 DesignMatrix designMatrix = new DesignMatrix( sampleInfo );
1190 designMatrix.addInteraction();
1191 LeastSquaresFit fit = new LeastSquaresFit( designMatrix, testMatrix );
1192
1193
1194 List<LinearModelSummary> sums = fit.summarize( true );
1195
1196
1197 LinearModelSummary s = sums.get( 0 );
1198 assertEquals( 3.8976, s.getF(), 0.01 );
1199 assertEquals( 0.11092, s.getP(), 0.001 );
1200 assertEquals( 9.69220, s.getContrastCoefficients().get( 0, 0 ), 0.001 );
1201 assertEquals( -1.4517, s.getContrastCoefficients().get( 1, 2 ), 0.001 );
1202 assertEquals( 0.220, s.getContrastCoefficients().get( 1, 3 ), 0.001 );
1203 assertEquals( 4, s.getResidualDof().intValue() );
1204 GenericAnovaResult a = s.getAnova();
1205 assertEquals( 0.24143, a.getMainEffectF( "time" ), 0.0001 );
1206 assertEquals( 1, a.getMainEffectDof( "time" ).intValue() );
1207 assertEquals( 4, a.getResidualDf().intValue() );
1208 assertEquals( 2.43873, a.getInteractionEffectF(), 0.001 );
1209 assertEquals( 0.19340, a.getInteractionEffectP(), 0.001 );
1210
1211
1212 ModeratedTstat.ebayes( fit );
1213 sums = fit.summarize( true );
1214 LinearModelSummary x = sums.get( 0 );
1215
1216 assertEquals( 0.0765, x.getSigma(), 0.0001 );
1217 assertEquals( 4.48, x.getPriorDof(), 0.01 );
1218
1219 assertEquals( 3.8976, x.getF(), 0.01 );
1220 assertEquals( 0.11092, x.getP(), 0.001 );
1221
1222 assertEquals( 9.692196, x.getContrastCoefficients().get( 0, 0 ), 0.0001 );
1223 assertEquals( -0.92608, x.getContrastCoefficients().get( 1, 2 ), 0.001 );
1224 assertEquals( 0.38, x.getContrastCoefficients().get( 1, 3 ), 0.001 );
1225 assertEquals( 4, x.getResidualDof().intValue() );
1226
1227 assertEquals( 0.34671, x.getContrastCoefficients().get( 3, 3 ), 0.0001 );
1228
1229 GenericAnovaResult ax = x.getAnova();
1230
1231 assertEquals( 0.098252, ax.getMainEffectF( "time" ), 0.0001 );
1232 assertEquals( 1, ax.getMainEffectDof( "time" ).intValue() );
1233 assertEquals( 8.48, ax.getResidualDf(), 0.001 );
1234
1235 assertEquals( 3.6678, ax.getMainEffectF( "dose" ), 0.0001 );
1236 assertEquals( 1, ax.getMainEffectDof( "dose" ).intValue() );
1237 assertEquals( 8.48, ax.getResidualDf(), 0.001 );
1238
1239
1240
1241 assertEquals( 0.99247, ax.getInteractionEffectF(), 0.0001 );
1242 assertEquals( 0.34671, ax.getInteractionEffectP(), 0.0001 );
1243
1244 }
1245 }