Metadata-Version: 2.1
Name: RNG
Version: 1.4.1
Summary: Python3 API for the C++ Random library
Home-page: https://sharpdesigndigital.com
Author: Broken aka Robert Sharp
Author-email: webmaster@sharpdesigndigital.com
License: Free for non-commercial use
Description: # RNG Engine for Python
        ### Python3 interface to the c++ random library
        #### Designed for python developers familiar with the c++ random header
        
        
        ## Sister Projects:
        - Fortuna: Collection of abstractions to make custom random value generators. https://pypi.org/project/Fortuna/
        - Pyewacket: Complete drop-in replacement for the Python3 Random Module. https://pypi.org/project/Pyewacket/
        
        Support these and other random projects: https://www.patreon.com/brokencode
        
        ### Warning: RNG is not suitable for cryptography or secure hashing.
        *Quick Install for Mac and Linux:* `$ pip install RNG`, `import RNG` as needed.<br>
        
        ---
        
        ## Random Generator Specifications
        
        #### Random Boolean
        - `RNG.bernoulli_distribution(ratio_of_truth: float) -> bool`
            - Produce a Bernoulli distribution of booleans.
            - @param ratio_of_truth :: the probability of True. Expected input range: `[0.0, 1.0]`, clamped.
            - @return :: True or False
        ```python
        # bernoulli_distribution.py
        from RNG import bernoulli_distribution
        
        
        print(bernoulli_distribution(0.25))
        # prints a random boolean, 25% probability of True
        ```
        
        #### Random Integer
        - `RNG.uniform_int_distribution(left_limit: int, right_limit: int) -> int`
            - Flat uniform distribution.
            - 20x faster than random.randint()
            - @param left_limit :: input A.
            - @param right_limit :: input B. 
            - @return :: random integer in the inclusive range `[A, B]` or `[B, A]` if B < A
        ```python
        # uniform_int_distribution.py
        from RNG import uniform_int_distribution
        
        
        print(uniform_int_distribution(-6, 5))
        # prints a random int in range [-6, 5]
        ```
        
        - `RNG.binomial_distribution(number_of_trials: int, probability: float) -> int`
            - Based on the idea of flipping a coin and counting how many heads come up after some number of flips.
            - @param number_of_trials :: how many times to flip a coin.
            - @param probability :: how likely heads will be flipped. 0.5 is a fair coin. 1.0 is a double headed coin.
            - @return :: count of how many heads came up.
        - `RNG.negative_binomial_distribution(trial_successes: int, probability: float) -> int`
            - Based on the idea of flipping a coin as long as it takes to succeed.
            - @param trial_successes :: the required number of heads flipped to succeed.
            - @param probability :: how likely heads will be flipped. 0.50 is a fair coin.
            - @return :: the count of how many tails came up before the required number of heads.
        - `RNG.geometric_distribution(probability: float) -> int`
            - Same as random_negative_binomial(1, probability). 
        - `RNG.poisson_distribution(mean: float) -> int`
            - @param mean :: sets the average output of the function.
            - @return :: random integer, poisson distribution centered on the mean.
        
        
        #### Random Floating Point
        - `RNG.generate_canonical() -> float`
            - Evenly distributes floats of maximum precision.
            - @return :: random float in range (0.0, 1.0)
        ```python
        # generate_canonical.py
        from RNG import generate_canonical
        
        
        print(generate_canonical())
        # prints a random float in range (0.0, 1.0)
        ```
        - `RNG.uniform_real_distribution(left_limit: float, right_limit: float) -> float`
            - Flat uniform distribution of floats.
            - @return :: random Float between left_limit and right_limit.
        - `RNG.normal_distribution(mean: float, std_dev: float) -> float`
            - @param mean :: sets the average output of the function.
            - @param std_dev :: standard deviation. Specifies spread of data from the mean.
        - `RNG.lognormal_distribution(log_mean: float, log_deviation: float) -> float`
            - @param log_mean :: sets the log of the mean of the function.
            - @param log_deviation :: log of the standard deviation. Specifies spread of data from the mean.
        - `RNG.exponential_distribution(lambda_rate: float) -> float`
            - Produces random non-negative floating-point values, distributed according to probability density function.
            - @param lambda_rate :: λ constant rate of a random event per unit of time/distance.
            - @return :: The time/distance until the next random event. For example, this distribution describes the time between the clicks of a Geiger counter or the distance between point mutations in a DNA strand.
        - `RNG.gamma_distribution(shape: float, scale: float) -> float`
            - Generalization of the exponential distribution.
            - Produces random positive floating-point values, distributed according to probability density function.    
            - @param shape :: α the number of independent exponentially distributed random variables.
            - @param scale :: β the scale factor or the mean of each of the distributed random variables.
            - @return :: the sum of α independent exponentially distributed random variables, each of which has a mean of β.
        - `RNG.weibull_distribution(shape: float, scale: float) -> float`
            - Generalization of the exponential distribution.
            - Similar to the gamma distribution but uses a closed form distribution function.
            - Popular in reliability and survival analysis.
        - `RNG.extreme_value_distribution(location: float, scale: float) -> float`
            - Based on Extreme Value Theory. 
            - Used for statistical models of the magnitude of earthquakes and volcanoes.
        - `RNG.chi_squared_distribution(degrees_of_freedom: float) -> float`
            - Used with the Chi Squared Test and Null Hypotheses to test if sample data fits an expected distribution.
        - `RNG.cauchy_distribution(location: float, scale: float) -> float`
            - @param location :: It specifies the location of the peak. The default value is 0.0.
            - @param scale :: It represents the half-width at half-maximum. The default value is 1.0.
            - @return :: Continuous Distribution.
        - `RNG.fisher_f_distribution(degrees_of_freedom_1: float, degrees_of_freedom_2: float) -> float`
            - F distributions often arise when comparing ratios of variances.
        - `RNG.student_t_distribution(degrees_of_freedom: float) -> float`
            - T distribution. Same as a normal distribution except it uses the sample standard deviation rather than the population standard deviation.
            - As degrees_of_freedom goes to infinity it converges with the normal distribution.
        
        
        #### Distribution & Performance Test Suite
        - `RNG.quick_test() -> None` 
            - Runs a quick battery of tests for every function in the module.
        - `RNG.timer(func: staticmethod, *args, **kwargs) -> None`
            - Temporal analysis of non-deterministic functions.
            - @param func :: Function, method or lambda to analyze. `func(*args, **kwargs)`
        - `RNG.distribution(func: staticmethod, *args, **kwargs) -> None`
            - Statistical analysis of non-deterministic functions.
            - @param func :: Function, method or lambda to analyze. `func(*args, **kwargs)`
        - `RNG.distribution_timer(func: staticmethod, *args, **kwargs) -> None`
            - Statistical and temporal analysis of non-deterministic functions.
            - @param func :: Function, method or lambda to analyze. `func(*args, **kwargs)`
            - @optional_kw num_cycles :: Total number of samples for distribution analysis, statistical analysis is limited to the first 1000 samples, timing estimates are handled separately.
            - @optional_kw post_processor :: Used to scale a large set of data into a smaller set of groupings, this function is invoked on the output and collated after the stats battery.
        ##### Example Terminal Usage: `distribution_timer`
        ```
        $ python3
        Python 3.7.3 ...
        >>> import RNG
        >>> RNG.distribution_timer(RNG.student_t_distribution, 8.0, post_processor=round)
        Output Analysis: student_t_distribution(8.0)
        Typical Timing: 188 ± 12 ns
        Statistics of 1024 samples:
         Minimum: -5.529308742357413
         Median: (-0.03683794055898661, -0.036446794399765815)
         Maximum: 4.271791506160894
         Mean: -0.0028963868958856932
         Std Deviation: 1.1614795623947607
        Post-processor distribution of 100000 samples using round method:
         -16: 0.001%
         -8: 0.002%
         -7: 0.006%
         -6: 0.02%
         -5: 0.058%
         -4: 0.289%
         -3: 1.426%
         -2: 6.705%
         -1: 23.096%
         0: 36.703%
         1: 23.048%
         2: 6.769%
         3: 1.52%
         4: 0.269%
         5: 0.06%
         6: 0.02%
         7: 0.006%
         9: 0.001%
         10: 0.001%
        
        ```
        
        
        ## Development Log
        ##### RNG 1.4.1
        - Test Patch for new API
        - Documentation Updates
        
        ##### RNG 1.4.0
        - API Refactoring
        
        ##### RNG 1.3.4
        - Storm Update 3.1.1
        
        ##### RNG 1.3.3
        - Installer script update
        
        ##### RNG 1.3.2
        - Minor Bug Fix
        
        ##### RNG 1.3.1
        - Test Update
        
        ##### RNG 1.3.1
        - Fixed Typos
        
        ##### RNG 1.3.0
        - Storm Update
        
        ##### RNG 1.2.5
        - Low level clean up
        
        ##### RNG 1.2.4
        - Minor Typos Fixed
        
        ##### RNG 1.2.3
        - Documentation Update
        - Test Update
        - Bug Fixes
        
        ##### RNG 1.0.0 - 1.2.2, internal
        - API Changes:
            - randint changed to random_int
            - randbelow changed to random_below
            - random changed to generate_canonical
            - uniform changed to random_float
        
        ##### RNG 0.2.3
        - Bug Fixes
        
        ##### RNG 0.2.2
        - discrete() removed.
        
        ##### RNG 0.2.1
        - minor typos
        - discrete() depreciated.
        
        ##### RNG 0.2.0
        - Major Rebuild.
        
        ##### RNG 0.1.22
        - The RNG Storm Engine is now the default standard.
        - Experimental Vortex Engine added for testing.
        
        ##### RNG 0.1.21 beta
        - Small update to the testing suite.
        
        ##### RNG 0.1.20 beta
        - Changed default inputs for random_int and random_below to sane values.
            - random_int(left_limit=1, right_limit=20) down from `-2**63, 2**63 - 1`
            - random_below(upper_bound=10) down from `2**63 - 1`
        
        ##### RNG 0.1.19 beta
        - Broke some fixed typos, for a change of pace.
        
        ##### RNG 0.1.18 beta
        - Fixed some typos.
        
        ##### RNG 0.1.17 beta
        - Major Refactoring.
        - New primary engine: Hurricane.
        - Experimental engine Typhoon added: random_below() only.
        
        ##### RNG 0.1.16 beta
        - Internal Engine Performance Tuning. 
        
        ##### RNG 0.1.15 beta
        - Engine Testing.
        
        ##### RNG 0.1.14 beta
        - Fixed a few typos.
        
        ##### RNG 0.1.13 beta
        - Fixed a few typos.
        
        ##### RNG 0.1.12 beta
        - Major Test Suite Upgrade.
        - Major Bug Fixes.
            - Removed several 'foot-guns' in prep for fuzz testing in future releases.
        
        ##### RNG 0.1.11 beta
        - Fixed small bug in the install script.
        
        ##### RNG 0.1.10 beta
        - Fixed some typos.
        
        ##### RNG 0.1.9 beta
        - Fixed some typos.
        
        ##### RNG 0.1.8 beta
        - Fixed some typos.
        - More documentation added.
        
        ##### RNG 0.1.7 beta
        - The `random_floating_point` function renamed to `random_float`.
        - The function `c_rand()` has been removed as well as all the cruft it required.
        - Major Documentation Upgrade.
        - Fixed an issue where keyword arguments would fail to propagate. Both, positional args and kwargs now work as intended.
        - Added this Dev Log.
        
        ##### RNG 0.0.6 alpha
        - Minor ABI changes.
        
        ##### RNG 0.0.5 alpha
        - Tests redesigned slightly for Float functions.
        
        ##### RNG 0.0.4 alpha
        - Random Float Functions Implemented.
        
        ##### RNG 0.0.3 alpha
        - Random Integer Functions Implemented.
        
        ##### RNG 0.0.2 alpha
        - Random Bool Function Implemented.
        
        ##### RNG 0.0.1 pre-alpha
        - Planning & Design.
        
        
        ## Distribution and Performance Test Suite
        ```
        Quick Test: RNG Storm Engine
        =========================================================================
        
        Boolean Variate Distributions
        
        Output Analysis: bernoulli_distribution(0.0)
        Typical Timing: 63 ± 1 ns
        Statistics of 1024 samples:
         Minimum: False
         Median: False
         Maximum: False
         Mean: 0
         Std Deviation: 0.0
        Distribution of 10240 samples:
         False: 100.0%
        
        Output Analysis: bernoulli_distribution(0.3333333333333333)
        Typical Timing: 63 ± 22 ns
        Statistics of 1024 samples:
         Minimum: False
         Median: False
         Maximum: True
         Mean: 0.330078125
         Std Deviation: 0.4704707338273809
        Distribution of 10240 samples:
         False: 66.484375%
         True: 33.515625%
        
        Output Analysis: bernoulli_distribution(0.5)
        Typical Timing: 63 ± 22 ns
        Statistics of 1024 samples:
         Minimum: False
         Median: False
         Maximum: True
         Mean: 0.484375
         Std Deviation: 0.5
        Distribution of 10240 samples:
         False: 49.375%
         True: 50.625%
        
        Output Analysis: bernoulli_distribution(0.6666666666666666)
        Typical Timing: 63 ± 16 ns
        Statistics of 1024 samples:
         Minimum: False
         Median: True
         Maximum: True
         Mean: 0.671875
         Std Deviation: 0.46976003108344483
        Distribution of 10240 samples:
         False: 33.57421875%
         True: 66.42578125%
        
        Output Analysis: bernoulli_distribution(1.0)
        Typical Timing: 63 ± 1 ns
        Statistics of 1024 samples:
         Minimum: True
         Median: True
         Maximum: True
         Mean: 1
         Std Deviation: 0.0
        Distribution of 10240 samples:
         True: 100.0%
        
        
        Integer Variate Distributions
        
        Base Case
        Output Analysis: Random.randint(1, 6)
        Typical Timing: 1250 ± 36 ns
        Statistics of 1024 samples:
         Minimum: 1
         Median: 4
         Maximum: 6
         Mean: 3.5400390625
         Std Deviation: 1.7125716511292923
        Distribution of 10240 samples:
         1: 16.5234375%
         2: 16.58203125%
         3: 17.255859375%
         4: 16.9140625%
         5: 16.650390625%
         6: 16.07421875%
        
        Output Analysis: uniform_int_distribution(1, 6)
        Typical Timing: 63 ± 22 ns
        Statistics of 1024 samples:
         Minimum: 1
         Median: 3
         Maximum: 6
         Mean: 3.4990234375
         Std Deviation: 1.705032234378946
        Distribution of 10240 samples:
         1: 16.81640625%
         2: 16.005859375%
         3: 17.158203125%
         4: 16.396484375%
         5: 17.001953125%
         6: 16.62109375%
        
        Output Analysis: binomial_distribution(4, 0.5)
        Typical Timing: 125 ± 26 ns
        Statistics of 1024 samples:
         Minimum: 0
         Median: 2
         Maximum: 4
         Mean: 2.037109375
         Std Deviation: 0.9939159219826769
        Distribution of 10240 samples:
         0: 6.103515625%
         1: 25.68359375%
         2: 36.8359375%
         3: 25.322265625%
         4: 6.0546875%
        
        Output Analysis: negative_binomial_distribution(5, 0.75)
        Typical Timing: 125 ± 26 ns
        Statistics of 1024 samples:
         Minimum: 0
         Median: 1
         Maximum: 10
         Mean: 1.65625
         Std Deviation: 1.5120887911161052
        Distribution of 10240 samples:
         0: 23.84765625%
         1: 29.345703125%
         2: 21.73828125%
         3: 13.212890625%
         4: 7.119140625%
         5: 2.705078125%
         6: 1.181640625%
         7: 0.576171875%
         8: 0.17578125%
         9: 0.048828125%
         10: 0.029296875%
         11: 0.01953125%
        
        Output Analysis: geometric_distribution(0.75)
        Typical Timing: 63 ± 16 ns
        Statistics of 1024 samples:
         Minimum: 0
         Median: 0
         Maximum: 4
         Mean: 0.3505859375
         Std Deviation: 0.6999089791664276
        Distribution of 10240 samples:
         0: 74.62890625%
         1: 19.140625%
         2: 4.58984375%
         3: 1.3671875%
         4: 0.205078125%
         5: 0.05859375%
         8: 0.009765625%
        
        Output Analysis: poisson_distribution(4.5)
        Typical Timing: 125 ± 16 ns
        Statistics of 1024 samples:
         Minimum: 0
         Median: 4
         Maximum: 14
         Mean: 4.4013671875
         Std Deviation: 2.161160328330198
        Distribution of 10240 samples:
         0: 1.025390625%
         1: 4.892578125%
         2: 11.93359375%
         3: 16.85546875%
         4: 19.23828125%
         5: 16.962890625%
         6: 12.63671875%
         7: 7.98828125%
         8: 4.3359375%
         9: 2.3828125%
         10: 0.99609375%
         11: 0.478515625%
         12: 0.185546875%
         13: 0.048828125%
         14: 0.029296875%
         16: 0.009765625%
        
        
        Floating Point Variate Distributions
        
        Base Case
        Output Analysis: Random.random()
        Typical Timing: 63 ± 16 ns
        Statistics of 1024 samples:
         Minimum: 0.0015374923967464982
         Median: (0.5196775499786613, 0.5201452992848603)
         Maximum: 0.9987149343350875
         Mean: 0.5135985165451736
         Std Deviation: 0.2872077742443504
        Post-processor distribution of 10240 samples using round method:
         0: 49.990234375%
         1: 50.009765625%
        
        Output Analysis: generate_canonical()
        Typical Timing: 63 ± 1 ns
        Statistics of 1024 samples:
         Minimum: 0.0024532443909225936
         Median: (0.4704302613312534, 0.47070265570766634)
         Maximum: 0.9998085591861998
         Mean: 0.4816443312228179
         Std Deviation: 0.28505829105163644
        Post-processor distribution of 10240 samples using round method:
         0: 50.76171875%
         1: 49.23828125%
        
        Output Analysis: uniform_real_distribution(0.0, 10.0)
        Typical Timing: 63 ± 1 ns
        Statistics of 1024 samples:
         Minimum: 0.0304742668372541
         Median: (5.0679328370819, 5.0745963145984)
         Maximum: 9.995076243319797
         Mean: 5.03638577315081
         Std Deviation: 2.927418688090237
        Post-processor distribution of 10240 samples using floor method:
         0: 9.716796875%
         1: 10.205078125%
         2: 9.53125%
         3: 10.0390625%
         4: 9.84375%
         5: 9.873046875%
         6: 10.244140625%
         7: 10.107421875%
         8: 10.244140625%
         9: 10.1953125%
        
        Base Case
        Output Analysis: Random.expovariate(1.0)
        Typical Timing: 313 ± 22 ns
        Statistics of 1024 samples:
         Minimum: 0.0011568737678774406
         Median: (0.7158428546719676, 0.7163397895389789)
         Maximum: 7.058762791117456
         Mean: 1.0003670451068172
         Std Deviation: 0.9929125036109278
        Post-processor distribution of 10240 samples using floor method:
         0: 63.232421875%
         1: 23.45703125%
         2: 8.330078125%
         3: 3.115234375%
         4: 1.181640625%
         5: 0.458984375%
         6: 0.13671875%
         7: 0.05859375%
         8: 0.029296875%
        
        Output Analysis: exponential_distribution(1.0)
        Typical Timing: 63 ± 26 ns
        Statistics of 1024 samples:
         Minimum: 0.0025122822776642434
         Median: (0.6926712837170756, 0.6930328371051944)
         Maximum: 9.39530049353006
         Mean: 1.0056226590260526
         Std Deviation: 1.0484645113797768
        Post-processor distribution of 10240 samples using floor method:
         0: 62.83203125%
         1: 23.69140625%
         2: 8.798828125%
         3: 2.9296875%
         4: 1.15234375%
         5: 0.439453125%
         6: 0.078125%
         7: 0.048828125%
         8: 0.01953125%
         9: 0.009765625%
        
        Base Case
        Output Analysis: Random.gammavariate(1.0, 1.0)
        Typical Timing: 500 ± 22 ns
        Statistics of 1024 samples:
         Minimum: 0.00093728283210992
         Median: (0.7020867139788857, 0.7071066908471326)
         Maximum: 5.852497568696576
         Mean: 1.016675397909145
         Std Deviation: 0.9686118387182048
        Post-processor distribution of 10240 samples using floor method:
         0: 63.330078125%
         1: 23.02734375%
         2: 8.515625%
         3: 3.1640625%
         4: 1.25%
         5: 0.458984375%
         6: 0.17578125%
         7: 0.048828125%
         8: 0.01953125%
         11: 0.009765625%
        
        Output Analysis: gamma_distribution(1.0, 1.0)
        Typical Timing: 63 ± 22 ns
        Statistics of 1024 samples:
         Minimum: 0.001372659872622037
         Median: (0.6646145271070529, 0.6674215920332173)
         Maximum: 7.826229254409556
         Mean: 1.0171504870770647
         Std Deviation: 1.0534461608954686
        Post-processor distribution of 10240 samples using floor method:
         0: 63.69140625%
         1: 23.466796875%
         2: 8.33984375%
         3: 2.87109375%
         4: 0.9765625%
         5: 0.3515625%
         6: 0.185546875%
         7: 0.078125%
         8: 0.01953125%
         9: 0.009765625%
         10: 0.009765625%
        
        Base Case
        Output Analysis: Random.weibullvariate(1.0, 1.0)
        Typical Timing: 438 ± 16 ns
        Statistics of 1024 samples:
         Minimum: 0.0002213042054813901
         Median: (0.6637421285607475, 0.6647256311160707)
         Maximum: 7.577325950724918
         Mean: 0.9388616508262337
         Std Deviation: 0.9262630791900074
        Post-processor distribution of 10240 samples using floor method:
         0: 63.095703125%
         1: 23.525390625%
         2: 8.369140625%
         3: 3.154296875%
         4: 1.11328125%
         5: 0.419921875%
         6: 0.185546875%
         7: 0.09765625%
         8: 0.01953125%
         9: 0.009765625%
         10: 0.009765625%
        
        Output Analysis: weibull_distribution(1.0, 1.0)
        Typical Timing: 125 ± 1 ns
        Statistics of 1024 samples:
         Minimum: 0.0021553647893082424
         Median: (0.6423084268263919, 0.6449853983396836)
         Maximum: 8.25735324498559
         Mean: 0.9488955731431038
         Std Deviation: 0.9685188492760336
        Post-processor distribution of 10240 samples using floor method:
         0: 62.646484375%
         1: 24.189453125%
         2: 8.251953125%
         3: 3.06640625%
         4: 1.064453125%
         5: 0.498046875%
         6: 0.15625%
         7: 0.087890625%
         8: 0.0390625%
        
        Output Analysis: extreme_value_distribution(0.0, 1.0)
        Typical Timing: 63 ± 30 ns
        Statistics of 1024 samples:
         Minimum: -2.2790218979883816
         Median: (0.4189807983736489, 0.4190244749042273)
         Maximum: 8.473866194466257
         Mean: 0.6289731042527902
         Std Deviation: 1.2785070103129572
        Post-processor distribution of 10240 samples using round method:
         -2: 1.03515625%
         -1: 18.1640625%
         0: 36.3671875%
         1: 24.951171875%
         2: 11.93359375%
         3: 4.677734375%
         4: 1.708984375%
         5: 0.712890625%
         6: 0.341796875%
         7: 0.05859375%
         8: 0.029296875%
         9: 0.009765625%
         15: 0.009765625%
        
        Base Case
        Output Analysis: Random.gauss(5.0, 2.0)
        Typical Timing: 625 ± 16 ns
        Statistics of 1024 samples:
         Minimum: -2.3907657725045857
         Median: (4.985395439098846, 4.996011596071374)
         Maximum: 10.555392950303524
         Mean: 4.9661175609442205
         Std Deviation: 1.9645358055174982
        Post-processor distribution of 10240 samples using round method:
         -3: 0.009765625%
         -2: 0.05859375%
         -1: 0.13671875%
         0: 0.810546875%
         1: 2.65625%
         2: 6.58203125%
         3: 11.943359375%
         4: 17.412109375%
         5: 19.951171875%
         6: 17.724609375%
         7: 12.177734375%
         8: 6.85546875%
         9: 2.55859375%
         10: 0.859375%
         11: 0.224609375%
         12: 0.0390625%
        
        Output Analysis: normal_distribution(5.0, 2.0)
        Typical Timing: 63 ± 26 ns
        Statistics of 1024 samples:
         Minimum: -1.62657420753664
         Median: (5.013721347171976, 5.020716600368835)
         Maximum: 11.229805396983904
         Mean: 5.013390643443666
         Std Deviation: 1.9906280203704514
        Post-processor distribution of 10240 samples using round method:
         -2: 0.048828125%
         -1: 0.263671875%
         0: 0.771484375%
         1: 2.87109375%
         2: 6.650390625%
         3: 12.255859375%
         4: 17.6171875%
         5: 19.86328125%
         6: 17.34375%
         7: 12.021484375%
         8: 6.34765625%
         9: 2.83203125%
         10: 0.810546875%
         11: 0.2734375%
         12: 0.029296875%
        
        Base Case
        Output Analysis: Random.lognormvariate(1.6, 0.25)
        Typical Timing: 813 ± 61 ns
        Statistics of 1024 samples:
         Minimum: 2.444946183342167
         Median: (4.858676895757656, 4.861475879554381)
         Maximum: 9.95451975540616
         Mean: 5.02207782789318
         Std Deviation: 1.2616130112120112
        Post-processor distribution of 10240 samples using round method:
         2: 0.41015625%
         3: 8.37890625%
         4: 26.50390625%
         5: 31.806640625%
         6: 19.31640625%
         7: 8.84765625%
         8: 3.232421875%
         9: 1.005859375%
         10: 0.361328125%
         11: 0.09765625%
         12: 0.009765625%
         13: 0.01953125%
         17: 0.009765625%
        
        Output Analysis: lognormal_distribution(1.6, 0.25)
        Typical Timing: 125 ± 1 ns
        Statistics of 1024 samples:
         Minimum: 2.3351913272374305
         Median: (4.976527485880496, 4.976764063343573)
         Maximum: 11.857833898396995
         Mean: 5.101654163992373
         Std Deviation: 1.2844079163290805
        Post-processor distribution of 10240 samples using round method:
         2: 0.302734375%
         3: 8.14453125%
         4: 26.884765625%
         5: 30.732421875%
         6: 20.576171875%
         7: 8.564453125%
         8: 3.26171875%
         9: 1.11328125%
         10: 0.29296875%
         11: 0.09765625%
         12: 0.029296875%
        
        Output Analysis: chi_squared_distribution(1.0)
        Typical Timing: 125 ± 16 ns
        Statistics of 1024 samples:
         Minimum: 1.994422287393394e-08
         Median: (0.478090162293184, 0.48077084515478813)
         Maximum: 11.542849837937665
         Mean: 1.0195884796387298
         Std Deviation: 1.5077490645120968
        Post-processor distribution of 10240 samples using floor method:
         0: 68.408203125%
         1: 15.576171875%
         2: 7.83203125%
         3: 3.33984375%
         4: 2.158203125%
         5: 1.044921875%
         6: 0.732421875%
         7: 0.380859375%
         8: 0.17578125%
         9: 0.15625%
         10: 0.078125%
         11: 0.0390625%
         12: 0.0390625%
         13: 0.009765625%
         14: 0.009765625%
         16: 0.01953125%
        
        Output Analysis: cauchy_distribution(0.0, 1.0)
        Typical Timing: 63 ± 30 ns
        Statistics of 1024 samples:
         Minimum: -1873.8445794786624
         Median: (0.03842207304543185, 0.03956748654031884)
         Maximum: 708.8387160386458
         Mean: -1.1950569789186223
         Std Deviation: 65.30270851255942
        Post-processor distribution of 10240 samples using floor_mod_10 method:
         0: 26.42578125%
         1: 11.2109375%
         2: 6.005859375%
         3: 3.681640625%
         4: 3.134765625%
         5: 2.919921875%
         6: 3.916015625%
         7: 5.986328125%
         8: 11.328125%
         9: 25.390625%
        
        Output Analysis: fisher_f_distribution(8.0, 8.0)
        Typical Timing: 188 ± 28 ns
        Statistics of 1024 samples:
         Minimum: 0.08316936366235625
         Median: (0.9394689435023765, 0.9395990307459007)
         Maximum: 12.249274210433379
         Mean: 1.2974719840804878
         Std Deviation: 1.2755170906032696
        Post-processor distribution of 10240 samples using floor method:
         0: 50.244140625%
         1: 32.412109375%
         2: 10.185546875%
         3: 3.8671875%
         4: 1.650390625%
         5: 0.68359375%
         6: 0.380859375%
         7: 0.13671875%
         8: 0.1171875%
         9: 0.068359375%
         10: 0.146484375%
         11: 0.029296875%
         12: 0.0390625%
         13: 0.01953125%
         15: 0.009765625%
         16: 0.009765625%
        
        Output Analysis: student_t_distribution(8.0)
        Typical Timing: 188 ± 16 ns
        Statistics of 1024 samples:
         Minimum: -5.073069466854821
         Median: (-0.01535503285345772, -0.015291640440016156)
         Maximum: 5.711128871513843
         Mean: 0.0018949731517060805
         Std Deviation: 1.1610777090451412
        Post-processor distribution of 10240 samples using round method:
         -6: 0.009765625%
         -5: 0.107421875%
         -4: 0.21484375%
         -3: 1.494140625%
         -2: 6.767578125%
         -1: 22.24609375%
         0: 36.640625%
         1: 23.3984375%
         2: 7.197265625%
         3: 1.474609375%
         4: 0.3125%
         5: 0.078125%
         6: 0.029296875%
         7: 0.009765625%
         8: 0.009765625%
         12: 0.009765625%
        
        
        =========================================================================
        Total Test Time: 0.3041 seconds
        
        ```
        
Keywords: rng,Mersenne Twister,random number generator,cpp random library,random integer,Bernoulli,binomial,negative_binomial,geometric,poisson,discrete,normal,distribution,log normal,gamma,exponential,weibull,extreme value,chi squared,cauchy,fisher f,student t
Platform: Darwin
Platform: Linux
Classifier: Development Status :: 5 - Production/Stable
Classifier: Programming Language :: Python :: 3.7
Classifier: Programming Language :: Cython
Classifier: Programming Language :: C++
Classifier: Operating System :: MacOS :: MacOS X
Classifier: Operating System :: POSIX :: Linux
Classifier: Topic :: Software Development :: Libraries :: Python Modules
Requires: Cython
Requires-Python: >=3.7
Description-Content-Type: text/markdown
