CLHEP VERSION Reference Documentation
   
CLHEP Home Page     CLHEP Documentation     CLHEP Bug Reports

Functions | Variables
validation.doc File Reference

Functions

How the various random distributions are validated The distributions in for example are independently validated By we mean checking that *The algorithm is mathematically correct *The algorithm is properly coded *The compilation of the algorithm is proper for this plaform *There is no subtle interaction between the algorithm and the random engine used that detectably impacts the distribution This validation must be done without reference to the coded algorithm itself (independent). It must be done by generating some(selectable) number of deviates
 
How the various random distributions are validated The distributions in for example are independently validated By we mean checking that *The algorithm is mathematically correct *The algorithm is properly coded *The compilation of the algorithm is proper for this plaform *There is no subtle interaction between the algorithm and the random engine used that detectably impacts the distribution This validation must be done without reference to the coded algorithm and testing that these obey the mathematical properties of the desired distribution For each those properties (hence the tests) differ. Since one can always increase the number of deviates to detect smaller anomalies
 
the goal is to keep the overall false rejection probability down at the to level For each validated we discuss which of course is by necessity relative timing We take the time for a single random via one of the fastest good generators (DualRand) to be 1 unit. These are not super-carful timings
 
the goal is to keep the overall false rejection probability down at the to level For each validated we discuss which of course is by necessity relative timing We take the time for a single random via one of the fastest good and at any rate the ratios will vary by around depending on the processor and memory configuration used A timing for a distribution of units would mean no time used beyond the uniform random Summary Distribution Validated Validation Rejected Past N RandGauss RandGaussT RandGaussQ RandGeneral (approximating a gaussian) linear N
 
this we validated samples (it is more time consuming) with no problems. We validated the quick() routine(which differs only above mu
 

Variables

How the various random distributions are validated The distributions in CLHEP
 
How the various random distributions are validated The distributions in for example RandGauss
 
How the various random distributions are validated The distributions in for example are independently validated By validation
 
How the various random distributions are validated The distributions in for example are independently validated By we mean checking that *The algorithm is mathematically correct *The algorithm is properly coded *The compilation of the algorithm is proper for this plaform *There is no subtle interaction between the algorithm and the random engine used that detectably impacts the distribution This validation must be done without reference to the coded algorithm and testing that these obey the mathematical properties of the desired distribution For each distribution
 
How the various random distributions are validated The distributions in for example are independently validated By we mean checking that *The algorithm is mathematically correct *The algorithm is properly coded *The compilation of the algorithm is proper for this plaform *There is no subtle interaction between the algorithm and the random engine used that detectably impacts the distribution This validation must be done without reference to the coded algorithm and testing that these obey the mathematical properties of the desired distribution For each those we reject conservatively
 
How the various random distributions are validated The distributions in for example are independently validated By we mean checking that *The algorithm is mathematically correct *The algorithm is properly coded *The compilation of the algorithm is proper for this plaform *There is no subtle interaction between the algorithm and the random engine used that detectably impacts the distribution This validation must be done without reference to the coded algorithm and testing that these obey the mathematical properties of the desired distribution For each those we reject if the distribution is sigma away from the proper properties
 
How the various random distributions are validated The distributions in for example are independently validated By we mean checking that *The algorithm is mathematically correct *The algorithm is properly coded *The compilation of the algorithm is proper for this plaform *There is no subtle interaction between the algorithm and the random engine used that detectably impacts the distribution This validation must be done without reference to the coded algorithm and testing that these obey the mathematical properties of the desired distribution For each those we reject if the distribution is sigma away from the proper we reject
 
How the various random distributions are validated The distributions in for example are independently validated By we mean checking that *The algorithm is mathematically correct *The algorithm is properly coded *The compilation of the algorithm is proper for this plaform *There is no subtle interaction between the algorithm and the random engine used that detectably impacts the distribution This validation must be done without reference to the coded algorithm and testing that these obey the mathematical properties of the desired distribution For each those we reject if the distribution is sigma away from the proper we asserting that something is wrong with the algorithm of coding For distributions which will be tested in many ways
 
How the various random distributions are validated The distributions in for example are independently validated By we mean checking that *The algorithm is mathematically correct *The algorithm is properly coded *The compilation of the algorithm is proper for this plaform *There is no subtle interaction between the algorithm and the random engine used that detectably impacts the distribution This validation must be done without reference to the coded algorithm and testing that these obey the mathematical properties of the desired distribution For each those we reject if the distribution is sigma away from the proper we asserting that something is wrong with the algorithm of coding For distributions which will be tested in many we make our rejection criteria a bit more severe
 
the goal is to keep the overall false rejection probability down at the to level For each validated we discuss here
 
the goal is to keep the overall false rejection probability down at the to level For each validated we discuss which of course is by necessity relative timing We take the time for a single random via one of the fastest good and at any rate the ratios will vary by around depending on the processor and memory configuration used A timing for a distribution of units would mean no time used beyond the uniform random Summary Distribution Validated Validation Rejected Past N RandGauss N = 50
 
the goal is to keep the overall false rejection probability down at the to level For each validated we discuss which of course is by necessity relative timing We take the time for a single random via one of the fastest good and at any rate the ratios will vary by around depending on the processor and memory configuration used A timing for a distribution of units would mean no time used beyond the uniform random Summary Distribution Validated Validation Rejected Past N RandGauss RandGaussT RandGaussQ bins stepwise bins RandPoisson RandPoissonT mu< 100 N=50, 000, 000 ------- mu > RandPoissonQ mu< 100 N=50, 000, 000 -------(same as RandPoissonT) mu > RandGauss Method
 
the goal is to keep the overall false rejection probability down at the to level For each validated we discuss which of course is by necessity relative timing We take the time for a single random via one of the fastest good and at any rate the ratios will vary by around depending on the processor and memory configuration used A timing for a distribution of units would mean no time used beyond the uniform random Summary Distribution Validated Validation Rejected Past N RandGauss RandGaussT RandGaussQ bins stepwise bins RandPoisson RandPoissonT mu< 100 N=50, 000, 000 ------- mu > RandPoissonQ mu< 100 N=50, 000, 000 -------(same as RandPoissonT) mu > RandGauss shoot() etc 2.5 units Validation tests applied and below
 
the goal is to keep the overall false rejection probability down at the to level For each validated we discuss which of course is by necessity relative timing We take the time for a single random via one of the fastest good and at any rate the ratios will vary by around depending on the processor and memory configuration used A timing for a distribution of units would mean no time used beyond the uniform random Summary Distribution Validated Validation Rejected Past N RandGauss RandGaussT RandGaussQ bins stepwise bins RandPoisson RandPoissonT mu< 100 N=50, 000, 000 ------- mu > RandPoissonQ mu< 100 N=50, 000, 000 -------(same as RandPoissonT) mu > RandGauss shoot() etc 2.5 units Validation tests applied and a very accurate series is substituted for the table method Timing
 
the goal is to keep the overall false rejection probability down at the to level For each validated we discuss which of course is by necessity relative timing We take the time for a single random via one of the fastest good and at any rate the ratios will vary by around depending on the processor and memory configuration used A timing for a distribution of units would mean no time used beyond the uniform random Summary Distribution Validated Validation Rejected Past N RandGauss RandGaussT RandGaussQ bins stepwise bins RandPoisson RandPoissonT mu< 100 N=50, 000, 000 ------- mu > RandPoissonQ mu< 100 N=50, 000, 000 -------(same as RandPoissonT) mu > RandGauss shoot() etc 2.5 units Validation tests applied and a very accurate series is substituted for the table method shoot() etc 1.7 units Validation tests applied and below about **a series approximation is used
 
the goal is to keep the overall false rejection probability down at the to level For each validated we discuss which of course is by necessity relative timing We take the time for a single random via one of the fastest good and at any rate the ratios will vary by around depending on the processor and memory configuration used A timing for a distribution of units would mean no time used beyond the uniform random Summary Distribution Validated Validation Rejected Past N RandGauss RandGaussT RandGaussQ bins stepwise bins RandPoisson RandPoissonT mu< 100 N=50, 000, 000 ------- mu > RandPoissonQ mu< 100 N=50, 000, 000 -------(same as RandPoissonT) mu > RandGauss shoot() etc 2.5 units Validation tests applied and a very accurate series is substituted for the table method shoot() etc 1.7 units Validation tests applied and below about **a series approximation is but we have applied this test with N up to million
 
the goal is to keep the overall false rejection probability down at the to level For each validated we discuss which of course is by necessity relative timing We take the time for a single random via one of the fastest good and at any rate the ratios will vary by around depending on the processor and memory configuration used A timing for a distribution of units would mean no time used beyond the uniform random Summary Distribution Validated Validation Rejected Past N RandGauss RandGaussT RandGaussQ bins stepwise bins RandPoisson RandPoissonT mu< 100 N=50, 000, 000 ------- mu > RandPoissonQ mu< 100 N=50, 000, 000 -------(same as RandPoissonT) mu > RandGauss shoot() etc 2.5 units Validation tests applied and a very accurate series is substituted for the table method shoot() etc 1.7 units Validation tests applied and below about **a series approximation is but we have applied this test with N up to and never get anywhere near the rejection point Analytical considerations indicate that the validation test would not reject until O(10 **24) samples were inspected. ---------------------------------------------------------- 2. RandGeneral Method since we wish to have good resolution power even if just one of the mu values i flawed )
 
the goal is to keep the overall false rejection probability down at the to level For each validated we discuss which of course is by necessity relative timing We take the time for a single random via one of the fastest good and at any rate the ratios will vary by around depending on the processor and memory configuration used A timing for a distribution of units would mean no time used beyond the uniform random Summary Distribution Validated Validation Rejected Past N RandGauss RandGaussT RandGaussQ bins stepwise bins RandPoisson RandPoissonT mu< 100 N=50, 000, 000 ------- mu > RandPoissonQ mu< 100 N=50, 000, 000 -------(same as RandPoissonT) mu > RandGauss shoot() etc 2.5 units Validation tests applied and a very accurate series is substituted for the table method shoot() etc 1.7 units Validation tests applied and below about **a series approximation is but we have applied this test with N up to and never get anywhere near the rejection point Analytical considerations indicate that the validation test would not reject until O(10 **24) samples were inspected. ---------------------------------------------------------- 2. RandGeneral Method since we wish to have good resolution power even if just one of the mu values is it would be unwise to dial this down any further Validatio Level )
 
the goal is to keep the overall false rejection probability down at the to level For each validated we discuss which of course is by necessity relative timing We take the time for a single random via one of the fastest good and at any rate the ratios will vary by around depending on the processor and memory configuration used A timing for a distribution of units would mean no time used beyond the uniform random Summary Distribution Validated Validation Rejected Past N RandGauss RandGaussT RandGaussQ bins stepwise bins RandPoisson RandPoissonT mu< 100 N=50, 000, 000 ------- mu > RandPoissonQ mu< 100 N=50, 000, 000 -------(same as RandPoissonT) mu > RandGauss shoot() etc 2.5 units Validation tests applied and a very accurate series is substituted for the table method shoot() etc 1.7 units Validation tests applied and below about **a series approximation is but we have applied this test with N up to and never get anywhere near the rejection point Analytical considerations indicate that the validation test would not reject until O(10 **24) samples were inspected. ---------------------------------------------------------- 2. RandGeneral Method since we wish to have good resolution power even if just one of the mu values is it would be unwise to dial this down any further Validation for several values o mu )
 
the goal is to keep the overall false rejection probability down at the to level For each validated we discuss which of course is by necessity relative timing We take the time for a single random via one of the fastest good and at any rate the ratios will vary by around depending on the processor and memory configuration used A timing for a distribution of units would mean no time used beyond the uniform random Summary Distribution Validated Validation Rejected Past N RandGauss RandGaussT RandGaussQ bins stepwise bins RandPoisson RandPoissonT mu< 100 N=50, 000, 000 ------- mu > RandPoissonQ mu< 100 N=50, 000, 000 -------(same as RandPoissonT) mu > RandGauss shoot() etc 2.5 units Validation tests applied and a very accurate series is substituted for the table method shoot() etc 1.7 units Validation tests applied and below about **a series approximation is but we have applied this test with N up to and never get anywhere near the rejection point Analytical considerations indicate that the validation test would not reject until O(10 **24) samples were inspected. ---------------------------------------------------------- 2. RandGeneral Method since we wish to have good resolution power even if just one of the mu values is it would be unwise to dial this down any further Validation for several values of but we have applied this with much higher N We validated the mai fire )() method for a variety of mu values between 0 and 100 at a level of 10
 
I could not create a faster method completely accurate that does not require overly large tables and takes a major step up when we cross for several values of but we have applied this with much higher N We validated the main trials It showed no sign of approaching the rejectable p values or errors in mean and sigma Above
 
I could not create a faster method completely accurate that does not require overly large tables and takes a major step up when we cross for several values of but we have applied this with much higher N We validated the main trials It showed no sign of approaching the rejectable p values or errors in mean and sigma the method matches the original algorithm
 
this we validated with
 
the naive Gaussian approximation is inaccurate at a level which
 
the naive Gaussian approximation is inaccurate at a level for turns out to be detectable in a sample of only
 

Function Documentation

◆ generators()

the goal is to keep the overall false rejection probability down at the to level For each validated we discuss which of course is by necessity relative timing We take the time for a single random via one of the fastest good generators ( DualRand  )

◆ itself()

How the various random distributions are validated The distributions in for example are independently validated By we mean checking that* The algorithm is mathematically correct* The algorithm is properly coded* The compilation of the algorithm is proper for this plaform* There is no subtle interaction between the algorithm and the random engine used that detectably impacts the distribution This validation must be done without reference to the coded algorithm itself ( independent  )

◆ properties()

How the various random distributions are validated The distributions in for example are independently validated By we mean checking that* The algorithm is mathematically correct* The algorithm is properly coded* The compilation of the algorithm is proper for this plaform* There is no subtle interaction between the algorithm and the random engine used that detectably impacts the distribution This validation must be done without reference to the coded algorithm and testing that these obey the mathematical properties of the desired distribution For each those properties ( hence the  tests)

◆ RandGeneral()

the goal is to keep the overall false rejection probability down at the to level For each validated we discuss which of course is by necessity relative timing We take the time for a single random via one of the fastest good and at any rate the ratios will vary by around depending on the processor and memory configuration used A timing for a distribution of units would mean no time used beyond the uniform random Summary Distribution Validated Validation Rejected Past N RandGauss RandGaussT RandGaussQ RandGeneral ( approximating a  gaussian)

◆ samples()

this we validated samples ( it is more time  consuming)

Referenced by poissonTest().

Variable Documentation

◆ Above

I could not create a faster method completely accurate that does not require overly large tables and takes a major step up when we cross for several values of but we have applied this with much higher N We validated the main trials It showed no sign of approaching the rejectable p values or errors in mean and sigma Above

Definition at line 306 of file validation.doc.

◆ algorithm

I could not create a faster method completely accurate that does not require overly large tables and takes a major step up when we cross for several values of but we have applied this with much higher N We validated the main trials It showed no sign of approaching the rejectable p values or errors in mean and sigma the method matches the original algorithm

Definition at line 308 of file validation.doc.

Referenced by CLHEP::HepRandom::HepRandom().

◆ below

the goal is to keep the overall false rejection probability down at the to level For each validated we discuss which of course is by necessity relative timing We take the time for a single random via one of the fastest good and at any rate the ratios will vary by around depending on the processor and memory configuration used A timing for a distribution of units would mean no time used beyond the uniform random Summary Distribution Validated Validation Rejected Past N RandGauss RandGaussT RandGaussQ bins stepwise bins RandPoisson RandPoissonT mu<100 N = 50,000,000 ------- mu> RandPoissonQ mu<100 N = 50,000,000 ------- (same as RandPoissonT) mu> RandGauss shoot () etc 2.5 units Validation tests applied and below

Definition at line 78 of file validation.doc.

◆ CLHEP

How the various random distributions are validated The distributions in CLHEP

Definition at line 4 of file validation.doc.

◆ conservatively

How the various random distributions are validated The distributions in for example are independently validated By we mean checking that* The algorithm is mathematically correct* The algorithm is properly coded* The compilation of the algorithm is proper for this plaform* There is no subtle interaction between the algorithm and the random engine used that detectably impacts the distribution This validation must be done without reference to the coded algorithm and testing that these obey the mathematical properties of the desired distribution For each those we reject conservatively

Definition at line 22 of file validation.doc.

◆ distribution

the goal is to keep the overall false rejection probability down at the to level For each validated distribution

Definition at line 18 of file validation.doc.

◆ fire

I could not create a faster method completely accurate that does not require overly large tables and takes a major step up when we cross for several values of but we have applied this with much higher N We validated the main fire

Definition at line 266 of file validation.doc.

Referenced by CLHEP::RandMultiGauss::operator()().

◆ flawed

the goal is to keep the overall false rejection probability down at the to level For each validated we discuss which of course is by necessity relative timing We take the time for a single random via one of the fastest good and at any rate the ratios will vary by around depending on the processor and memory configuration used A timing for a distribution of units would mean no time used beyond the uniform random Summary Distribution Validated Validation Rejected Past N RandGauss RandGaussT RandGaussQ bins stepwise bins RandPoisson RandPoissonT mu<100 N = 50,000,000 ------- mu> RandPoissonQ mu<100 N = 50,000,000 ------- (same as RandPoissonT) mu> RandGauss shoot () etc 2.5 units Validation tests applied and a very accurate series is substituted for the table method shoot () etc 1.7 units Validation tests applied and below about** a series approximation is but we have applied this test with N up to and never get anywhere near the rejection point Analytical considerations indicate that the validation test would not reject until O (10**24) samples were inspected. ---------------------------------------------------------- 2. RandGeneral Method since we wish to have good resolution power even if just one of the mu values i flawed)

Definition at line 163 of file validation.doc.

◆ here

the goal is to keep the overall false rejection probability down at the to level For each validated we discuss here

Definition at line 35 of file validation.doc.

◆ Level

the goal is to keep the overall false rejection probability down at the to level For each validated we discuss which of course is by necessity relative timing We take the time for a single random via one of the fastest good and at any rate the ratios will vary by around depending on the processor and memory configuration used A timing for a distribution of units would mean no time used beyond the uniform random Summary Distribution Validated Validation Rejected Past N RandGauss RandGaussT RandGaussQ bins stepwise bins RandPoisson RandPoissonT mu<100 N = 50,000,000 ------- mu> RandPoissonQ mu<100 N = 50,000,000 ------- (same as RandPoissonT) mu> RandGauss shoot () etc 2.5 units Validation tests applied and a very accurate series is substituted for the table method shoot () etc 1.7 units Validation tests applied and below about** a series approximation is but we have applied this test with N up to and never get anywhere near the rejection point Analytical considerations indicate that the validation test would not reject until O (10**24) samples were inspected. ---------------------------------------------------------- 2. RandGeneral Method since we wish to have good resolution power even if just one of the mu values is it would be unwise to dial this down any further Validatio Level)

Definition at line 263 of file validation.doc.

◆ Method

the goal is to keep the overall false rejection probability down at the to level For each validated we discuss which of course is by necessity relative timing We take the time for a single random via one of the fastest good and at any rate the ratios will vary by around depending on the processor and memory configuration used A timing for a distribution of units would mean no time used beyond the uniform random Summary Distribution Validated Validation Rejected Past N RandGauss RandGaussT RandGaussQ bins stepwise bins RandPoisson RandPoissonT mu<100 N = 50,000,000 ------- mu> RandPoissonQ mu<100 N = 50,000,000 ------- (same as RandPoissonT) mu> RandGauss shoot () etc 2.5 units Validation tests applied and a very accurate series is substituted for the table method shoot () etc 1.7 units Validation tests applied and below about** a series approximation is but we have applied this test with N up to and never get anywhere near the rejection point Analytical considerations indicate that the validation test would not reject until O (10**24) samples were inspected. ---------------------------------------------------------- 2. RandGeneral Method since we wish to have good resolution power even if just one of the mu values is it would be unwise to dial this down any further Validation for several values of but we have applied this with much higher N We validated the main trials It showed no sign of approaching the rejectable p values or errors in mean and sigma RandPoisson Method)

Definition at line 63 of file validation.doc.

◆ million

the goal is to keep the overall false rejection probability down at the to level For each validated we discuss which of course is by necessity relative timing We take the time for a single random via one of the fastest good and at any rate the ratios will vary by around depending on the processor and memory configuration used A timing for a distribution of units would mean no time used beyond the uniform random Summary Distribution Validated Validation Rejected Past N RandGauss RandGaussT RandGaussQ bins stepwise bins RandPoisson RandPoissonT mu<100 N = 50,000,000 ------- mu> RandPoissonQ mu<100 N = 50,000,000 ------- (same as RandPoissonT) mu> RandGauss shoot () etc 2.5 units Validation tests applied and a very accurate series is substituted for the table method shoot () etc 1.7 units Validation tests applied and below about** a series approximation is but we have applied this test with N up to million

Definition at line 161 of file validation.doc.

◆ mu

the naive Gaussian approximation is inaccurate at a level for mu
Initial value:
=100 and go over to the lod algorithm.
mu time
2.5 1.6
7.5 3.9
11.0 3.9
51.0 3.9
94.9 3.9
110 14.8
Validation tests applied:
The same tests are applied as for RandPoisson.
Validation Level:
The standard validation suite uses N = 1 million

Definition at line 263 of file validation.doc.

Referenced by CLHEP::diag_step(), CLHEP::RandMultiGauss::fire(), CLHEP::RandMultiGauss::fireArray(), gaussianTest(), main(), CLHEP::RandMultiGauss::operator()(), poissonTest(), CLHEP::RandMultiGauss::RandMultiGauss(), skewNormalTest(), testRandGauss(), testRandGaussQ(), testRandGaussT(), testRandGeneral(), testRandMultiGauss(), testRandPoisson(), testRandPoissonQ(), and testRandPoissonT().

◆ N

the goal is to keep the overall false rejection probability down at the to level For each validated we discuss which of course is by necessity relative timing We take the time for a single random via one of the fastest good and at any rate the ratios will vary by around depending on the processor and memory configuration used A timing for a distribution of units would mean no time used beyond the uniform random Summary Distribution Validated Validation Rejected Past N RandGauss RandGaussT RandGaussQ bins stepwise bins RandPoisson RandPoissonT mu< 100 N=50, 000, 000 ------- mu > RandPoissonQ mu< 100 N=50, 000, 000 -------(same as RandPoissonT) mu > N = 50

◆ only

the naive Gaussian approximation is inaccurate at a level for turns out to be detectable in a sample of only

Definition at line 330 of file validation.doc.

◆ properties

How the various random distributions are validated The distributions in for example are independently validated By we mean checking that* The algorithm is mathematically correct* The algorithm is properly coded* The compilation of the algorithm is proper for this plaform* There is no subtle interaction between the algorithm and the random engine used that detectably impacts the distribution This validation must be done without reference to the coded algorithm and testing that these obey the mathematical properties of the desired distribution For each those we reject if the distribution is sigma away from the proper properties

Definition at line 23 of file validation.doc.

◆ RandGauss

How the various random distributions are validated The distributions in for example RandGauss

Definition at line 4 of file validation.doc.

◆ reject

How the various random distributions are validated The distributions in for example are independently validated By we mean checking that* The algorithm is mathematically correct* The algorithm is properly coded* The compilation of the algorithm is proper for this plaform* There is no subtle interaction between the algorithm and the random engine used that detectably impacts the distribution This validation must be done without reference to the coded algorithm and testing that these obey the mathematical properties of the desired distribution For each those we reject if the distribution is sigma away from the proper we reject

Definition at line 23 of file validation.doc.

◆ severe

How the various random distributions are validated The distributions in for example are independently validated By we mean checking that* The algorithm is mathematically correct* The algorithm is properly coded* The compilation of the algorithm is proper for this plaform* There is no subtle interaction between the algorithm and the random engine used that detectably impacts the distribution This validation must be done without reference to the coded algorithm and testing that these obey the mathematical properties of the desired distribution For each those we reject if the distribution is sigma away from the proper we asserting that something is wrong with the algorithm of coding For distributions which will be tested in many we make our rejection criteria a bit more severe

Definition at line 25 of file validation.doc.

◆ Timing

the naive Gaussian approximation is inaccurate at a level for turns out to be detectable in a sample of deviates Timing

Definition at line 118 of file validation.doc.

◆ used

the goal is to keep the overall false rejection probability down at the to level For each validated we discuss which of course is by necessity relative timing We take the time for a single random via one of the fastest good and at any rate the ratios will vary by around depending on the processor and memory configuration used A timing for a distribution of units would mean no time used beyond the uniform random Summary Distribution Validated Validation Rejected Past N RandGauss RandGaussT RandGaussQ bins stepwise bins RandPoisson RandPoissonT mu<100 N = 50,000,000 ------- mu> RandPoissonQ mu<100 N = 50,000,000 ------- (same as RandPoissonT) mu> RandGauss shoot () etc 2.5 units Validation tests applied and a very accurate series is substituted for the table method shoot () etc 1.7 units Validation tests applied and below about** a series approximation is used

Definition at line 118 of file validation.doc.

◆ validation

How the various random distributions are validated The distributions in for example are independently validated By validation

Definition at line 7 of file validation.doc.

◆ ways

How the various random distributions are validated The distributions in for example are independently validated By we mean checking that* The algorithm is mathematically correct* The algorithm is properly coded* The compilation of the algorithm is proper for this plaform* There is no subtle interaction between the algorithm and the random engine used that detectably impacts the distribution This validation must be done without reference to the coded algorithm and testing that these obey the mathematical properties of the desired distribution For each those we reject if the distribution is sigma away from the proper we asserting that something is wrong with the algorithm of coding For distributions which will be tested in many ways

Definition at line 25 of file validation.doc.

◆ which

the naive Gaussian approximation is inaccurate at a level which

Definition at line 329 of file validation.doc.

◆ with

this we validated with

Definition at line 308 of file validation.doc.

tests
Test tests[]
Definition: testBug90848.cc:27
mu
the goal is to keep the overall false rejection probability down at the to level For each validated we discuss which of course is by necessity relative timing We take the time for a single random via one of the fastest good and at any rate the ratios will vary by around depending on the processor and memory configuration used A timing for a distribution of units would mean no time used beyond the uniform random Summary Distribution Validated Validation Rejected Past N RandGauss RandGaussT RandGaussQ bins stepwise bins RandPoisson RandPoissonT mu< 100 N=50, 000, 000 ------- mu > RandPoissonQ mu< 100 N=50, 000, 000 -------(same as RandPoissonT) mu > RandGauss shoot() etc 2.5 units Validation tests applied and a very accurate series is substituted for the table method shoot() etc 1.7 units Validation tests applied and below about **a series approximation is but we have applied this test with N up to and never get anywhere near the rejection point Analytical considerations indicate that the validation test would not reject until O(10 **24) samples were inspected. ---------------------------------------------------------- 2. RandGeneral Method since we wish to have good resolution power even if just one of the mu values is it would be unwise to dial this down any further Validation for several values o mu)
Definition: validation.doc:263
validation
How the various random distributions are validated The distributions in for example are independently validated By validation
Definition: validation.doc:7
N
the goal is to keep the overall false rejection probability down at the to level For each validated we discuss which of course is by necessity relative timing We take the time for a single random via one of the fastest good and at any rate the ratios will vary by around depending on the processor and memory configuration used A timing for a distribution of units would mean no time used beyond the uniform random Summary Distribution Validated Validation Rejected Past N RandGauss N
Definition: validation.doc:48
algorithm
I could not create a faster method completely accurate that does not require overly large tables and takes a major step up when we cross for several values of but we have applied this with much higher N We validated the main trials It showed no sign of approaching the rejectable p values or errors in mean and sigma the method matches the original algorithm
Definition: validation.doc:308
Level
the goal is to keep the overall false rejection probability down at the to level For each validated we discuss which of course is by necessity relative timing We take the time for a single random via one of the fastest good and at any rate the ratios will vary by around depending on the processor and memory configuration used A timing for a distribution of units would mean no time used beyond the uniform random Summary Distribution Validated Validation Rejected Past N RandGauss RandGaussT RandGaussQ bins stepwise bins RandPoisson RandPoissonT mu< 100 N=50, 000, 000 ------- mu > RandPoissonQ mu< 100 N=50, 000, 000 -------(same as RandPoissonT) mu > RandGauss shoot() etc 2.5 units Validation tests applied and a very accurate series is substituted for the table method shoot() etc 1.7 units Validation tests applied and below about **a series approximation is but we have applied this test with N up to and never get anywhere near the rejection point Analytical considerations indicate that the validation test would not reject until O(10 **24) samples were inspected. ---------------------------------------------------------- 2. RandGeneral Method since we wish to have good resolution power even if just one of the mu values is it would be unwise to dial this down any further Validatio Level)
Definition: validation.doc:263
million
the goal is to keep the overall false rejection probability down at the to level For each validated we discuss which of course is by necessity relative timing We take the time for a single random via one of the fastest good and at any rate the ratios will vary by around depending on the processor and memory configuration used A timing for a distribution of units would mean no time used beyond the uniform random Summary Distribution Validated Validation Rejected Past N RandGauss RandGaussT RandGaussQ bins stepwise bins RandPoisson RandPoissonT mu< 100 N=50, 000, 000 ------- mu > RandPoissonQ mu< 100 N=50, 000, 000 -------(same as RandPoissonT) mu > RandGauss shoot() etc 2.5 units Validation tests applied and a very accurate series is substituted for the table method shoot() etc 1.7 units Validation tests applied and below about **a series approximation is but we have applied this test with N up to million
Definition: validation.doc:161
are
Issues Concerning the PhysicsVectors CLHEP Vector Merge The merge of ZOOM PhysicsVdectors and the CLHEP Vector package is completed The purpose of this document is to list the major issues that affected the merge of these and where relevant describe the resolutions More detailed documents describe more minor issues General Approach As agreed at the June CLHEP the approach is to combine the features of each ZOOM class with the corresponding CLHEP class expanding the interface to create a single lingua franca of what a I have placed almost all the new features in a second section of the and have created separate cc files for sensible subsets of the methods In if a program uses only the methods found in the original CLHEP very little additional code is linked in Classes The corresponding classes are
Definition: keyMergeIssues.doc:61