1 #include "TestNormalDistribution.h"
2 #include "Distribution.h"
3 #include "StdDeviation.h"
4 #include "Mean.h"
5 #include "arrcmp.h"
6 #include <iostream>
7 #include <fstream>
8 #include <cstdlib>
9 #include <cstdio>
10 #include <cmath>
11 #include <string.h>
12
13 using namespace std;
14
TestNormalDistribution()15 TestNormalDistribution::TestNormalDistribution()
16 {
17 // set the seed
18 seed = 779;
19 DistributionBase::setSeed( seed );
20
21 // set the mean, standard deviation and data set
22 data.resize( 10 );
23 for( int i = 0; i < 10; i++ )
24 {
25 data[i] = i+1;
26 }
27 mean = new Mean( 5.5 );
28 stdDev = new StdDeviation( data );
29
30 // set lower and upper bounds and number of deviations
31 numDevs = 2;
32 lb = 5;
33 ub = 10;
34 lb_est = mean->value() - numDevs*stdDev->value();
35 ub_est = mean->value() + numDevs*stdDev->value();
36
37
38
39
40 DistributionBase::setSeed( seed );
41 NormalDistribution distSigmaWithNumDeviations( *mean, *stdDev, numDevs );
42 DistributionBase::setSeed( seed );
43 this->deviates[0] = distSigmaWithNumDeviations.getDeviate();
44 DistributionBase::setSeed( seed );
45 NormalDistribution distSigmaWithoutNumDeviations( *mean, *stdDev );
46 DistributionBase::setSeed( seed );
47 this->deviates[1] = distSigmaWithoutNumDeviations.getDeviate();
48 DistributionBase::setSeed( seed );
49 NormalDistribution distBoundsWithoutNumDeviations( lb, ub );
50 DistributionBase::setSeed( seed );
51 this->deviates[2] = distBoundsWithoutNumDeviations.getDeviate();
52 DistributionBase::setSeed( seed );
53 NormalDistribution distBoundsWithNumDeviations( lb, ub, numDevs );
54 DistributionBase::setSeed( seed );
55 this->deviates[3] = distBoundsWithNumDeviations.getDeviate();
56 DistributionBase::setSeed( seed );
57
58
59 }
60
~TestNormalDistribution()61 TestNormalDistribution::~TestNormalDistribution()
62 {
63 // clean up memory
64 delete mean;
65 delete stdDev;
66 }
67
run()68 void TestNormalDistribution::run()
69 {
70 testNormalDistributionSigmaWithNumDeviations();
71 testNormalDistributionSigmaWithoutNumDeviations();
72 testNormalDistributionBoundsWithoutNumDeviations();
73 testNormalDistributionBoundsWithNumDeviations();
74 testClone();
75 testGetDeviateNoProb();
76 testGetDeviateWithProb();
77 testGetCDF();
78 testLowerBound();
79 testUpperBound();
80 testMean();
81 testStdDev();
82 testPrint();
83 testPrintAttributes();
84 testTypeName();
85 }
86
testNormalDistributionSigmaWithNumDeviations()87 void TestNormalDistribution::testNormalDistributionSigmaWithNumDeviations()
88 {
89 // use constructor NormalDistribution(const mean& m,
90 // const stdDeviation& sigma,
91 // double numDeviations)
92 NormalDistribution distSigmaWithNumDeviations( *mean, *stdDev, numDevs );
93
94 _test( distSigmaWithNumDeviations.lowerBound() == lb_est );
95 _test( distSigmaWithNumDeviations.upperBound() == ub_est );
96 _test( distSigmaWithNumDeviations.mean() == mean->value() );
97 _test( distSigmaWithNumDeviations.stdDev() == stdDev->value() );
98 }
99
testNormalDistributionSigmaWithoutNumDeviations()100 void TestNormalDistribution::testNormalDistributionSigmaWithoutNumDeviations()
101 {
102 // use constructor NormalDistribution(const mean& m,
103 // const stdDeviation& sigma)
104 NormalDistribution distSigmaWithoutNumDeviations( *mean, *stdDev );
105
106 _test( distSigmaWithoutNumDeviations.lowerBound() == lb_est );
107 _test( distSigmaWithoutNumDeviations.upperBound() == ub_est );
108 _test( distSigmaWithoutNumDeviations.mean() == mean->value() );
109 _test( distSigmaWithoutNumDeviations.stdDev() == stdDev->value() );
110 }
111
testNormalDistributionBoundsWithoutNumDeviations()112 void TestNormalDistribution::testNormalDistributionBoundsWithoutNumDeviations()
113 {
114 // use constructor NormalDistribution(double lower, double upper)
115 NormalDistribution distBoundsWithoutNumDeviations( lb, ub );
116
117 _test( distBoundsWithoutNumDeviations.lowerBound() == lb );
118 _test( distBoundsWithoutNumDeviations.upperBound() == ub );
119 _test( distBoundsWithoutNumDeviations.mean() == 7.5 );
120 _test( fabs(distBoundsWithoutNumDeviations.stdDev()) - 1.275533 < 0.001 );
121 }
122
testNormalDistributionBoundsWithNumDeviations()123 void TestNormalDistribution::testNormalDistributionBoundsWithNumDeviations()
124 {
125 // use constructor NormalDistribution(double lower,
126 // double upper,
127 // double numDeviations)
128 NormalDistribution distBoundsWithNumDeviations( lb, ub, numDevs );
129
130 _test( distBoundsWithNumDeviations.lowerBound() == lb );
131 _test( distBoundsWithNumDeviations.upperBound() == ub );
132 _test( distBoundsWithNumDeviations.mean() == (lb + ub)/2 );
133 _test( distBoundsWithNumDeviations.stdDev() == (ub-lb)/(2*numDevs) );
134 }
135
testClone()136 void TestNormalDistribution::testClone()
137 {
138 NormalDistribution distSigmaWithNumDeviations( *mean, *stdDev, numDevs );
139 NormalDistribution distSigmaWithoutNumDeviations( *mean, *stdDev );
140 NormalDistribution distBoundsWithoutNumDeviations( lb, ub );
141 NormalDistribution distBoundsWithNumDeviations( lb, ub, numDevs );
142
143 // call clone and test results
144 NormalDistribution* rtn = (NormalDistribution*)distSigmaWithNumDeviations.clone();
145
146 _test( rtn->lowerBound() == distSigmaWithNumDeviations.lowerBound() );
147 _test( rtn->upperBound() == distSigmaWithNumDeviations.upperBound() );
148 _test( rtn->mean() == distSigmaWithNumDeviations.mean() );
149 _test( rtn->stdDev() == distSigmaWithNumDeviations.stdDev() );
150 _test( rtn->typeName() == distSigmaWithNumDeviations.typeName() );
151
152 // clean up memory
153 delete rtn;
154
155 // call clone and test results
156 rtn = (NormalDistribution*)distSigmaWithoutNumDeviations.clone();
157
158 _test( rtn->lowerBound() == distSigmaWithoutNumDeviations.lowerBound() );
159 _test( rtn->upperBound() == distSigmaWithoutNumDeviations.upperBound() );
160 _test( rtn->mean() == distSigmaWithoutNumDeviations.mean() );
161 _test( rtn->stdDev() == distSigmaWithoutNumDeviations.stdDev() );
162 _test( rtn->typeName() == distSigmaWithoutNumDeviations.typeName() );
163
164 // clean up memory
165 delete rtn;
166
167 // call clone and test results
168 rtn = (NormalDistribution*)distBoundsWithoutNumDeviations.clone();
169
170 _test( rtn->lowerBound() == distBoundsWithoutNumDeviations.lowerBound() );
171 _test( rtn->upperBound() == distBoundsWithoutNumDeviations.upperBound() );
172 _test( rtn->mean() == distBoundsWithoutNumDeviations.mean() );
173 _test( rtn->stdDev() == distBoundsWithoutNumDeviations.stdDev() );
174 _test( rtn->typeName() == distBoundsWithoutNumDeviations.typeName() );
175
176 // clean up memory
177 delete rtn;
178
179 // call clone and test results
180 rtn = (NormalDistribution*)distBoundsWithNumDeviations.clone();
181
182 _test( rtn->lowerBound() ==distBoundsWithNumDeviations.lowerBound() );
183 _test( rtn->upperBound() ==distBoundsWithNumDeviations.upperBound() );
184 _test( rtn->mean() ==distBoundsWithNumDeviations.mean() );
185 _test( rtn->stdDev() ==distBoundsWithNumDeviations.stdDev() );
186 _test( rtn->typeName() ==distBoundsWithNumDeviations.typeName() );
187
188 // clean up memory
189 delete rtn;
190 }
191
testGetDeviateNoProb()192 void TestNormalDistribution::testGetDeviateNoProb()
193 {
194 DistributionBase::setSeed( seed );
195 NormalDistribution distSigmaWithNumDeviations( *mean, *stdDev, numDevs );
196 DistributionBase::setSeed( seed );
197 _test( fabs(distSigmaWithNumDeviations.getDeviate()) - this->deviates[0] < 0.001 );
198 DistributionBase::setSeed( seed );
199 NormalDistribution distSigmaWithoutNumDeviations( *mean, *stdDev );
200 DistributionBase::setSeed( seed );
201 _test( fabs(distSigmaWithoutNumDeviations.getDeviate()) - this->deviates[1] < 0.001 );
202 DistributionBase::setSeed( seed );
203 NormalDistribution distBoundsWithoutNumDeviations( lb, ub );
204 DistributionBase::setSeed( seed );
205 _test( fabs(distBoundsWithoutNumDeviations.getDeviate()) - this->deviates[2] < 0.001 );
206 DistributionBase::setSeed( seed );
207 NormalDistribution distBoundsWithNumDeviations( lb, ub, numDevs );
208 DistributionBase::setSeed( seed );
209 _test( fabs(distBoundsWithNumDeviations.getDeviate()) - this->deviates[3] < 0.001 );
210 DistributionBase::setSeed( seed );
211
212 }
213
testGetDeviateWithProb()214 void TestNormalDistribution::testGetDeviateWithProb()
215 {
216 NormalDistribution distSigmaWithNumDeviations( *mean, *stdDev, numDevs );
217 NormalDistribution distSigmaWithoutNumDeviations( *mean, *stdDev );
218 NormalDistribution distBoundsWithoutNumDeviations( lb, ub );
219 NormalDistribution distBoundsWithNumDeviations( lb, ub, numDevs );
220
221 // test the returned deviate value
222 _test( distSigmaWithNumDeviations.getDeviate( 0.5 ) == 5.5 );
223 _test( distSigmaWithoutNumDeviations.getDeviate( 0.5 ) == 5.5 );
224 _test( distBoundsWithoutNumDeviations.getDeviate( 0.5 ) == 7.5 );
225 _test( distBoundsWithNumDeviations.getDeviate( 0.5 ) == 7.5 );
226 }
227
testGetCDF()228 void TestNormalDistribution::testGetCDF()
229 {
230 NormalDistribution distSigmaWithNumDeviations( *mean, *stdDev, numDevs );
231 NormalDistribution distSigmaWithoutNumDeviations( *mean, *stdDev );
232 NormalDistribution distBoundsWithoutNumDeviations( lb, ub );
233 NormalDistribution distBoundsWithNumDeviations( lb, ub, numDevs );
234
235 // test the returned CDF value
236 _test( fabs(distSigmaWithNumDeviations.getCDF( 0.5 )) - 0.0568407 < 0.001 );
237 _test( fabs(distSigmaWithoutNumDeviations.getCDF( 0.5 )) - 0.0568407 < 0.001 );
238 _test( fabs(distBoundsWithoutNumDeviations.getCDF( 0.5 )) - 0.0263157 < 0.001 );
239 _test( fabs(distBoundsWithNumDeviations.getCDF( 0.5 )) - 0.0263157 < 0.001 );
240 }
241
testLowerBound()242 void TestNormalDistribution::testLowerBound()
243 {
244 NormalDistribution distSigmaWithNumDeviations( *mean, *stdDev, numDevs );
245 NormalDistribution distSigmaWithoutNumDeviations( *mean, *stdDev );
246 NormalDistribution distBoundsWithoutNumDeviations( lb, ub );
247 NormalDistribution distBoundsWithNumDeviations( lb, ub, numDevs );
248
249 // call lowerBound() and test the results
250 _test( distSigmaWithNumDeviations.lowerBound() == (mean->value() - numDevs*(stdDev->value())) );
251 _test( distSigmaWithoutNumDeviations.lowerBound() == (mean->value() - 2*(stdDev->value())) );
252 _test( distBoundsWithoutNumDeviations.lowerBound() == lb );
253 _test( distBoundsWithNumDeviations.lowerBound() == lb );
254 }
255
testUpperBound()256 void TestNormalDistribution::testUpperBound()
257 {
258 NormalDistribution distSigmaWithNumDeviations( *mean, *stdDev, numDevs );
259 NormalDistribution distSigmaWithoutNumDeviations( *mean, *stdDev );
260 NormalDistribution distBoundsWithoutNumDeviations( lb, ub );
261 NormalDistribution distBoundsWithNumDeviations( lb, ub, numDevs );
262
263 // call upperBound() and test the results
264 _test( distSigmaWithNumDeviations.upperBound() - (mean->value() + numDevs*(stdDev->value())) < 0.001 );
265 _test( distSigmaWithoutNumDeviations.upperBound() - (mean->value() + 2*(stdDev->value())) < 0.001 );
266 _test( distBoundsWithoutNumDeviations.upperBound() == ub );
267 _test( distBoundsWithNumDeviations.upperBound() == ub );
268 }
269
testMean()270 void TestNormalDistribution::testMean()
271 {
272 NormalDistribution distSigmaWithNumDeviations( *mean, *stdDev, numDevs );
273 NormalDistribution distSigmaWithoutNumDeviations( *mean, *stdDev );
274 NormalDistribution distBoundsWithoutNumDeviations( lb, ub );
275 NormalDistribution distBoundsWithNumDeviations( lb, ub, numDevs );
276
277 // call mean() and tests result
278 _test( distSigmaWithNumDeviations.mean() == mean->value() );
279 _test( distSigmaWithoutNumDeviations.mean() == mean->value() );
280 _test( distBoundsWithoutNumDeviations.mean() == 7.5 );
281 _test( distBoundsWithNumDeviations.mean() == (lb + ub)/2 );
282 }
283
testStdDev()284 void TestNormalDistribution::testStdDev()
285 {
286 NormalDistribution distSigmaWithNumDeviations( *mean, *stdDev, numDevs );
287 NormalDistribution distSigmaWithoutNumDeviations( *mean, *stdDev );
288 NormalDistribution distBoundsWithoutNumDeviations( lb, ub );
289 NormalDistribution distBoundsWithNumDeviations( lb, ub, numDevs );
290
291 // call stdDev() and test results
292 _test( distSigmaWithNumDeviations.stdDev() == stdDev->value() );
293 _test( distSigmaWithoutNumDeviations.stdDev() == stdDev->value() );
294 _test( fabs(distBoundsWithoutNumDeviations.stdDev()) - 1.275533 < 0.001 );
295 _test( distBoundsWithNumDeviations.stdDev() == (ub-lb)/(2*numDevs) );
296 }
297
testPrint()298 void TestNormalDistribution::testPrint()
299 {
300 char buf[128];
301
302 NormalDistribution distSigmaWithNumDeviations( *mean, *stdDev, numDevs );
303 NormalDistribution distSigmaWithoutNumDeviations( *mean, *stdDev );
304 NormalDistribution distBoundsWithoutNumDeviations( lb, ub );
305 NormalDistribution distBoundsWithNumDeviations( lb, ub, numDevs );
306
307 ofstream fout;
308 ifstream fin;
309
310 string data;
311 string test_str;
312
313 #ifdef HAVE_SNPRINTF
314 snprintf( buf, 127, "NORMAL MEAN %.1f DEV %.5f CUTOFF %d", distSigmaWithNumDeviations.mean(),
315 distSigmaWithNumDeviations.stdDev(),
316 (int)floor((distSigmaWithNumDeviations.upperBound()-distSigmaWithNumDeviations.lowerBound())/
317 2.0/distSigmaWithNumDeviations.stdDev()) );
318 #else
319 int numberOfChars = sprintf( buf, "NORMAL MEAN %.1f DEV %.5f CUTOFF %d", distSigmaWithNumDeviations.mean(),
320 distSigmaWithNumDeviations.stdDev(),
321 (int)floor((distSigmaWithNumDeviations.upperBound()-distSigmaWithNumDeviations.lowerBound())/
322 2.0/distSigmaWithNumDeviations.stdDev()) );
323 assert(numberOfChars<127);
324 #endif // HAVE_SNPRINTF
325
326 test_str = buf;
327
328 // write the data to a file, then reopen the
329 // file and verify the data was written correctly
330 fout.open( "TestNormalDistribution_Log" );
331 if( fout )
332 {
333 distSigmaWithNumDeviations.print( fout );
334 fout << endl;
335 fout.close();
336 }
337 else
338 {
339 _test( false );
340 }
341
342 fin.open( "TestNormalDistribution_Log" );
343 if( fin )
344 {
345 fin.getline( buf, 128 );
346 data = buf;
347
348 if( _test( data == test_str ) == false )
349 {
350 cerr << "data: \"" << data << "\"" << endl
351 << "test_str: \"" << test_str << "\"" << endl;
352 }
353 fin.close();
354 }
355 else
356 {
357 _test( false );
358 }
359
360 // write the data to a file, then reopen the
361 // file and verify the data was written correctly
362 memset( buf, 0, 128 );
363
364 //
365 // HERE!!! add formatting info to format string
366 //
367
368 #ifdef HAVE_SNPRINTF
369 snprintf( buf, 127, "NORMAL MEAN %.1f DEV %.5f CUTOFF %d", distSigmaWithoutNumDeviations.mean(),
370 distSigmaWithoutNumDeviations.stdDev(),
371 (int)floor((distSigmaWithoutNumDeviations.upperBound()-distSigmaWithoutNumDeviations.lowerBound())/
372 2.0/distSigmaWithoutNumDeviations.stdDev()) );
373 #else
374 numberOfChars = sprintf( buf, "NORMAL MEAN %.1f DEV %.5f CUTOFF %d", distSigmaWithoutNumDeviations.mean(),
375 distSigmaWithoutNumDeviations.stdDev(),
376 (int)floor((distSigmaWithoutNumDeviations.upperBound()-distSigmaWithoutNumDeviations.lowerBound())/
377 2.0/distSigmaWithoutNumDeviations.stdDev()) );
378 assert(numberOfChars<127);
379 #endif // HAVE_SNPRINTF
380
381 test_str = buf;
382
383 fout.open( "TestNormalDistribution_Log" );
384 if( fout )
385 {
386 distSigmaWithoutNumDeviations.print( fout );
387 fout << endl;
388 fout.close();
389 }
390 else
391 {
392 _test( false );
393 }
394
395 fin.open( "TestNormalDistribution_Log" );
396 if( fin )
397 {
398 fin.getline( buf, 128 );
399 data = buf;
400
401 if( _test( data == test_str ) == false )
402 {
403 cerr << "data: \"" << data << "\"" << endl
404 << "test_str: \"" << test_str << "\"" << endl;
405 }
406 fin.close();
407 }
408 else
409 {
410 _test( false );
411 }
412
413 // write the data to a file, then reopen the
414 // file and verify the data was written correctly
415 memset( buf, 0, 128 );
416
417
418 #ifdef HAVE_SNPRINTF
419 snprintf( buf, 127, "NORMAL MEAN %.1f DEV %.5f CUTOFF %.5f", distBoundsWithoutNumDeviations.mean(),
420 distBoundsWithoutNumDeviations.stdDev(),
421 (distBoundsWithoutNumDeviations.upperBound()-distBoundsWithoutNumDeviations.lowerBound())/
422 2.0/distBoundsWithoutNumDeviations.stdDev() );
423
424 #else
425 numberOfChars = sprintf( buf, "NORMAL MEAN %.1f DEV %.5f CUTOFF %.5f", distBoundsWithoutNumDeviations.mean(),
426 distBoundsWithoutNumDeviations.stdDev(),
427 (distBoundsWithoutNumDeviations.upperBound()-distBoundsWithoutNumDeviations.lowerBound())/
428 2.0/distBoundsWithoutNumDeviations.stdDev() );
429 assert(numberOfChars<127);
430 #endif // HAVE_SNPRINTF
431 test_str = buf;
432
433 fout.open( "TestNormalDistribution_Log" );
434 if( fout )
435 {
436 distBoundsWithoutNumDeviations.print( fout );
437 fout << endl;
438 fout.close();
439 }
440 else
441 {
442 _test( false );
443 }
444
445 fin.open( "TestNormalDistribution_Log" );
446 if( fin )
447 {
448 fin.getline( buf, 128 );
449 data = buf;
450
451 if( _test( data == test_str ) == false )
452 {
453 cerr << "data: \"" << data << "\"" << endl
454 << "test_str: \"" << test_str << "\"" << endl;
455 }
456 fin.close();
457 }
458 else
459 {
460 _test( false );
461 }
462
463 // write the data to a file, then reopen the
464 // file and verify the data was written correctly
465 memset( buf, 0, 128 );
466
467 #ifdef HAVE_SNPRINTF
468 snprintf( buf, 127, "NORMAL MEAN %.1f DEV %.2f CUTOFF %d", distBoundsWithNumDeviations.mean(),
469 distBoundsWithNumDeviations.stdDev(),
470 (int)floor((distBoundsWithNumDeviations.upperBound()-distBoundsWithNumDeviations.lowerBound())/
471 2.0/distBoundsWithNumDeviations.stdDev()) );
472
473 #else
474 numberOfChars = sprintf( buf, "NORMAL MEAN %.1f DEV %.2f CUTOFF %d", distBoundsWithNumDeviations.mean(),
475 distBoundsWithNumDeviations.stdDev(),
476 (int)floor((distBoundsWithNumDeviations.upperBound()-distBoundsWithNumDeviations.lowerBound())/
477 2.0/distBoundsWithNumDeviations.stdDev()) );
478 assert(numberOfChars<127);
479 #endif // HAVE_SNPRINTF
480
481 test_str = buf;
482
483 fout.open( "TestNormalDistribution_Log" );
484 if( fout )
485 {
486 distBoundsWithNumDeviations.print( fout );
487 fout << endl;
488 fout.close();
489 }
490 else
491 {
492 _test( false );
493 }
494
495 fin.open( "TestNormalDistribution_Log" );
496 if( fin )
497 {
498 fin.getline( buf, 128 );
499 data = buf;
500
501 if( _test( data == test_str ) == false )
502 {
503 cerr << "data: \"" << data << "\"" << endl
504 << "test_str: \"" << test_str << "\"" << endl;
505 }
506 fin.close();
507 }
508 else
509 {
510 _test( false );
511 }
512 }
513
514
testPrintAttributes()515 void TestNormalDistribution::testPrintAttributes()
516 {
517 char buf[128];
518
519 NormalDistribution distSigmaWithNumDeviations( *mean, *stdDev, numDevs );
520 NormalDistribution distSigmaWithoutNumDeviations( *mean, *stdDev );
521 NormalDistribution distBoundsWithoutNumDeviations( lb, ub );
522 NormalDistribution distBoundsWithNumDeviations( lb, ub, numDevs );
523
524 ofstream fout;
525 ifstream fin;
526
527 string data;
528 string test_str;
529
530 #ifdef HAVE_SNPRINTF
531 snprintf( buf, 127, "distribution=\"normal\" mean=\"%.1f\" sigma=\"%.5f\" cutoff=\"%d\"",
532 distSigmaWithNumDeviations.mean(), distSigmaWithNumDeviations.stdDev(),
533 (int)floor((distSigmaWithNumDeviations.upperBound()-distSigmaWithNumDeviations.lowerBound())/
534 2.0/distSigmaWithNumDeviations.stdDev()) );
535 #else
536 int numberOfChars = sprintf( buf, "distribution=\"normal\" mean=\"%.1f\" sigma=\"%.5f\" cutoff=\"%d\"",
537 distSigmaWithNumDeviations.mean(), distSigmaWithNumDeviations.stdDev(),
538 (int)floor((distSigmaWithNumDeviations.upperBound()-distSigmaWithNumDeviations.lowerBound())/
539 2.0/distSigmaWithNumDeviations.stdDev()) );
540 assert(numberOfChars<127);
541 #endif // HAVE_SNPRINTF
542
543 test_str = buf;
544
545 // write the data to a file, then reopen the
546 // file and verify the data was written correctly
547 fout.open( "TestNormalDistribution_Log" );
548 if( fout )
549 {
550 distSigmaWithNumDeviations.printAttributes( fout );
551 fout << endl;
552 fout.close();
553 }
554 else
555 {
556 _test( false );
557 }
558
559 fin.open( "TestNormalDistribution_Log" );
560 if( fin )
561 {
562 fin.getline( buf, 128 );
563 data = buf;
564
565 if( _test( data == test_str ) == false )
566 {
567 cerr << "data: \"" << data << "\"" << endl
568 << "test_str: \"" << test_str << "\"" << endl;
569 }
570 fin.close();
571 }
572 else
573 {
574 _test( false );
575 }
576
577 // write the data to a file, then reopen the
578 // file and verify the data was written correctly
579 memset( buf, 0, 128 );
580
581 #ifdef HAVE_SNPRINTF
582 snprintf( buf, 127, "distribution=\"normal\" mean=\"%.1f\" sigma=\"%.5f\" cutoff=\"%d\"",
583 distSigmaWithoutNumDeviations.mean(), distSigmaWithoutNumDeviations.stdDev(),
584 (int)floor((distSigmaWithoutNumDeviations.upperBound()-distSigmaWithoutNumDeviations.lowerBound())/
585 2.0/distSigmaWithoutNumDeviations.stdDev()) );
586 #else
587 numberOfChars = sprintf( buf, "distribution=\"normal\" mean=\"%.1f\" sigma=\"%.5f\" cutoff=\"%d\"",
588 distSigmaWithoutNumDeviations.mean(), distSigmaWithoutNumDeviations.stdDev(),
589 (int)floor((distSigmaWithoutNumDeviations.upperBound()-distSigmaWithoutNumDeviations.lowerBound())/
590 2.0/distSigmaWithoutNumDeviations.stdDev()) );
591 assert(numberOfChars<127);
592 #endif // HAVE_SNPRINTF
593 test_str = buf;
594
595 fout.open( "TestNormalDistribution_Log" );
596 if( fout )
597 {
598 distSigmaWithoutNumDeviations.printAttributes( fout );
599 fout << endl;
600 fout.close();
601 }
602 else
603 {
604 _test( false );
605 }
606
607 fin.open( "TestNormalDistribution_Log" );
608 if( fin )
609 {
610 fin.getline( buf, 128 );
611 data = buf;
612
613 if( _test( data == test_str ) == false )
614 {
615 cerr << "data: \"" << data << "\"" << endl
616 << "test_str: \"" << test_str << "\"" << endl;
617 }
618 fin.close();
619 }
620 else
621 {
622 _test( false );
623 }
624
625 // write the data to a file, then reopen the
626 // file and verify the data was written correctly
627 memset( buf, 0, 128 );
628 #ifdef HAVE_SNPRINTF
629 snprintf( buf, 127, "distribution=\"normal\" mean=\"%.1f\" sigma=\"%.5f\" cutoff=\"%.5f\"",
630 distBoundsWithoutNumDeviations.mean(), distBoundsWithoutNumDeviations.stdDev(),
631 (distBoundsWithoutNumDeviations.upperBound()-distBoundsWithoutNumDeviations.lowerBound())/
632 2.0/distBoundsWithoutNumDeviations.stdDev() );
633 #else
634 numberOfChars = sprintf( buf, "distribution=\"normal\" mean=\"%.1f\" sigma=\"%.5f\" cutoff=\"%.5f\"",
635 distBoundsWithoutNumDeviations.mean(), distBoundsWithoutNumDeviations.stdDev(),
636 (distBoundsWithoutNumDeviations.upperBound()-distBoundsWithoutNumDeviations.lowerBound())/
637 2.0/distBoundsWithoutNumDeviations.stdDev() );
638 assert(numberOfChars<127);
639 #endif // HAVE_SNPRINTF
640 test_str = buf;
641
642 fout.open( "TestNormalDistribution_Log" );
643 if( fout )
644 {
645 distBoundsWithoutNumDeviations.printAttributes( fout );
646 fout << endl;
647 fout.close();
648 }
649 else
650 {
651 _test( false );
652 }
653
654 fin.open( "TestNormalDistribution_Log" );
655 if( fin )
656 {
657 fin.getline( buf, 128 );
658 data = buf;
659
660 if( _test( data == test_str ) == false )
661 {
662 cerr << "data: \"" << data << "\"" << endl
663 << "test_str: \"" << test_str << "\"" << endl;
664 }
665 fin.close();
666 }
667 else
668 {
669 _test( false );
670 }
671
672 // write the data to a file, then reopen the
673 // file and verify the data was written correctly
674 memset( buf, 0, 128 );
675 #ifdef HAVE_SNPRINTF
676 snprintf( buf, 127, "distribution=\"normal\" mean=\"%.1f\" sigma=\"%.2f\" cutoff=\"%d\"",
677 distBoundsWithNumDeviations.mean(), distBoundsWithNumDeviations.stdDev(),
678 (int)floor((distBoundsWithNumDeviations.upperBound()-distBoundsWithNumDeviations.lowerBound())/
679 2.0/distBoundsWithNumDeviations.stdDev()) );
680 #else
681 numberOfChars = sprintf( buf, "distribution=\"normal\" mean=\"%.1f\" sigma=\"%.2f\" cutoff=\"%d\"",
682 distBoundsWithNumDeviations.mean(), distBoundsWithNumDeviations.stdDev(),
683 (int)floor((distBoundsWithNumDeviations.upperBound()-distBoundsWithNumDeviations.lowerBound())/
684 2.0/distBoundsWithNumDeviations.stdDev()) );
685 assert(numberOfChars<127);
686 #endif // HAVE_SNPRINTF
687 test_str = buf;
688
689 fout.open( "TestNormalDistribution_Log" );
690 if( fout )
691 {
692 distBoundsWithNumDeviations.printAttributes( fout );
693 fout << endl;
694 fout.close();
695 }
696 else
697 {
698 _test( false );
699 }
700
701 fin.open( "TestNormalDistribution_Log" );
702 if( fin )
703 {
704 fin.getline( buf, 128 );
705 data = buf;
706
707 if( _test( data == test_str ) == false )
708 {
709 cerr << "data: \"" << data << "\"" << endl
710 << "test_str: \"" << test_str << "\"" << endl;
711 }
712 fin.close();
713 }
714 else
715 {
716 _test( false );
717 }
718 }
719
testTypeName()720 void TestNormalDistribution::testTypeName()
721 {
722 NormalDistribution distSigmaWithNumDeviations( *mean, *stdDev, numDevs );
723 NormalDistribution distSigmaWithoutNumDeviations( *mean, *stdDev );
724 NormalDistribution distBoundsWithoutNumDeviations( lb, ub );
725 NormalDistribution distBoundsWithNumDeviations( lb, ub, numDevs );
726
727 std::string normal( "NormalDistribution" );
728
729 _test( distSigmaWithNumDeviations.typeName() == normal );
730 _test( distSigmaWithoutNumDeviations.typeName() == normal );
731 _test( distBoundsWithoutNumDeviations.typeName() == normal );
732 _test( distBoundsWithNumDeviations.typeName() == normal );
733 }
734
735