Metadata-Version: 2.1
Name: Fortuna
Version: 3.4.2
Summary: Custom Random Value Generators
Home-page: https://sharpdesigndigital.com
Author: Broken aka Robert Sharp
Author-email: webmaster@sharpdesigndigital.com
License: Free for non-commercial use
Description: # Fortuna: Random Value Generator
        Fortuna's main goal is to provide a quick and easy way to build custom random-value generators.
        
        The core functionality of Fortuna is based on the RNG Storm engine. While Storm is a high quality random engine, Fortuna is not appropriate for cryptography of any kind. Fortuna is meant for games, data science, A.I. and experimental programming, not security.
        
        Suggested Installation: `$ pip install Fortuna`
        
        Installation on platforms other than MacOS may require building from source files.
        
        
        ### Documentation Table of Contents:
        - Numeric Limits
        - Project Definitions
        - Random Value Generators
        - Random Integer Generators
        - Random Index Generators
        - Random Float Generators
        - Random Bool Generator
        - Shuffle Algorithms
        - Test Suite
        - Test Suite Output
        - Development Log
        - Legal Information
        
        
        ##### Numeric Limits:
        - Integer: 64 bit signed integer.
            - Input & Output Range: `(-2**63, 2**63)` or approximately +/- 9.2 billion billion.
            - Minimum: -9223372036854775807
            - Maximum:  9223372036854775807
        - Float: 64 bit double precision floating point.
            - Minimum: -1.7976931348623157e+308
            - Maximum:  1.7976931348623157e+308
            - Epsilon Below Zero: -5e-324
            - Epsilon Above Zero:  5e-324
        
        
        ##### Project Definitions:
        - Value: Any python object: str, int, list and lambda to name a few.
        - Callable: Any callable object, function, method or lambda.
        - Sequence: Any object that can be converted into a list via `list(some_object)`.
            - List, Tuple, Set, etc...
            - Comprehensions and Generators that produce Sequences also qualify.
            - Classes that wrap a simple collection will take any Sequence or Array.
            - Functions that operate on a simple collection will require an Array.
        - Array: List, tuple or any object that inherits from either.
            - Must be an object that is indexed like a list.
            - List comprehensions qualify as Arrays, but sets and list generators do not.
            - All Arrays are Sequences but not all Sequences are Arrays.
        - Pair: Array of two Values.
        - Table: Array of Pairs.
            - List of lists of two values each.
            - Tuple of tuples of two values each.
            - Generators that produce Tables also qualify.
            - The result of zip(list_1, list_2) also qualifies.
        - Matrix: Dictionary of Arrays.
            - Generators or comprehensions that produces a Matrix also qualify.
        - Inclusive Range.
            - `[1, 10] -> 1, 2, 3, 4, 5, 6, 7, 8, 9, 10`
        - Exclusive Range.
            - `(0, 11) -> 1, 2, 3, 4, 5, 6, 7, 8, 9, 10`
        - Partial Ranges.
            - `[1, 11) -> 1, 2, 3, 4, 5, 6, 7, 8, 9, 10`
            - `(0, 10] -> 1, 2, 3, 4, 5, 6, 7, 8, 9, 10`
        - Automatic Flattening. 
            - All random value generators in Fortuna will recursively call or "flatten" callable objects returned from the dataset at call time. 
            - Un-callable objects or those that require arguments will be returned in an uncalled state without error. 
            - A callable that can be flattened is any class initializer, function, method or lambda so long as it requires no arguments, it will be automatically flattened. 
            - Mixing callable objects with un-callable objects is fully supported, but it can be a bit messy. 
            - Nested callable objects are fully supported. Because `lambda(lambda) -> lambda` fixes everything for arbitrary values of 'because', 'fixes' and 'everything'. 
            - To disable automatic flattening, pass the optional keyword argument `flat=False`.
        
        
        ## Random Value Generators: Functional
        `Fortuna.random_value(data: Array, flat=True) -> Value`
        - @param data :: Array of Values.
        - @param flat :: Bool. Default: True. Option to flatten callable values. Automatic Flattening.
        - @return :: Produces a random value from the list with a wide uniform distribution.
        
        ```python
        from Fortuna import random_value
        
        
        data = ("Apple", "Banana", "Cherry", "Grape", "Lime", "Orange")
        print(random_value(data))  # prints a random value from the data, flat uniform distribution.
        ```
        
        `Fortuna.cumulative_weighted_choice(weighted_table: Table, flat=True) -> Value`
        - @param weighted_table :: Table of weighted Pairs. `[(1, "a"), (2, "b"), (3, "c")]`
        - @param flat :: Bool. Default: True. Option to flatten callable values. Automatic Flattening.
        - @return :: Produces a random value from the list with a custom distribution.
        
        ```python
        from Fortuna import cumulative_weighted_choice
        
        
        weighted_data = (
            (7, "Apple"),
            (11, "Banana"),
            (13, "Cherry"),
            (23, "Grape"),
            (26, "Lime"),
            (30, "Orange"),
        )
        print(cumulative_weighted_choice(weighted_data))
        # prints a random value from the data, with probability based on cumulative weight.
        ```
        
        `Fortuna.lazy_cat(data, range_to=0, func=random_index, flat=True) -> Value`
        - The lazy_cat function is a more general form of the QuantumMonty class. Features dependency injection.
        - @param data :: Array of Values.
        - @param range_to :: Default is zero. Must be equal to or less than the length of data, this represents the size of the output distribution. When range_to == 0, the total length of data is used instead. This argument is passed to the input function to get a valid index into the data. When range_to is negative the back of the data will be considered the starting point.
        - @param func :: Optional. Default is random_index. This callable must follow the ZeroCool method specifications. All built-in ZeroCool methods qualify.
        - @param flat :: Bool. Default: True. Option to flatten callable values. Automatic Flattening.
        - @return :: Returns a random value from the data using the function you specify at call time.
        
        `Fortuna.truffle_shuffle(data: list, flat=True) -> Value`
        In-place micro-shuffle. Destructive. It is recommended to shuffle the list conventionally once before a series of truffle_shuffles.
        - @param data :: list of Values. Must be a mutable list. For best results, each Value should be unique and the number of Values should be more than just a few.
        - @param flat :: Bool. Default: True. Option to flatten callable values. Automatic Flattening.
        - @return :: Random value from the list with a wide uniform distribution. The average width of the output sequence will naturally scale up with the size of the list.
        
        **Wide Uniform Distribution**: *"Wide"* refers to the average distance between consecutive occurrences of the same value in the output sequence. The goal of this type of distribution is to keep the output sequence free of clumps or streaks, while maintaining randomness and uniform probability. This is not the same as a *flat uniform distribution*. The two distributions should be statistically similar for any given set, but the output sequence repetitiveness will be very different.
        
        
        ## Random Value Generators: Classes
        ### TruffleShuffle
        `Fortuna.TruffleShuffle(data: Sequence, flat=True) -> Callable -> Value`
        - In-place micro-shuffle. Non-destructive, copies the list_of_values.
        - @param data :: Sequence of Values. Automatically shuffles once with Knuth B at instantiation.
        - @param flat :: Bool. Default: True. Option to flatten callable values. Automatic Flattening.
        - @return :: Callable Instance.
            - @return :: Random value from the list with a wide uniform distribution, performs an internal micro-shuffle. Pop a Value for return then use front_poisson insert to randomly put it back near the front of the list. The relative width of the output sequence will naturally scale up with the size of the list.
        
        
        #### TruffleShuffle, Basic Use
        ```python
        from Fortuna import TruffleShuffle
        
        
        list_of_values = [1, 2, 3, 4, 5, 6]
        truffle_shuffle = TruffleShuffle(list_of_values)
        
        print(truffle_shuffle())
        ```
        
        #### Automatic Flattening
        ```python
        from Fortuna import TruffleShuffle
        
        
        auto_flat = TruffleShuffle([lambda: 1, lambda: 2, lambda: 3])
        print(auto_flat())  # will print the value 1, 2 or 3.
        # Note: the lambda will not be called until call time and stays dynamic for the life of the object.
        
        un_flat = TruffleShuffle([lambda: 1, lambda: 2, lambda: 3], flat=False)
        print(un_flat()())  # will print the value 1, 2 or 3, mind the double-double parenthesis
        
        auto_un_flat = TruffleShuffle([lambda x: x, lambda x: x + 1, lambda x:  x + 2], flat=False)
        # Note: flat=False is not required here because the lambdas can not be called without input x satisfied.
        # It is still recommended to specify flat=False if non-flat output is intend.
        print(auto_un_flat()(1))  # will print the value 1, 2 or 3, mind the double-double parenthesis
        
        ```
        
        
        #### Mixing Static Objects with Callable Objects
        ```python
        from Fortuna import TruffleShuffle
        
        
        """ With automatic flattening active, lambda() -> int can be treated as an int. """
        mixed_flat = TruffleShuffle([1, 2, lambda: 3])  # this is fine and works as intended.
        print(mixed_flat())  # will print 1, 2 or 3
        
        mixed_un_flat = TruffleShuffle([1, 2, lambda: 3], flat=False) # this pattern is not recommended.
        print(mixed_flat())  # will print 1, 2 or "Function <lambda at some_address>"
        # This pattern is not recommended because you wont know the nature of what you get back.
        # This is almost always not what you want, and it can give rise to messy logic in other areas of your code.
        ```
        
        
        #### Dynamic Strings
        To successfully express a dynamic string, and keep it dynamic, at least one level of indirection is required. Without an indirection the f-string would collapse into a static string too soon.
        
        ```python
        from Fortuna import TruffleShuffle, d
        
        
        # d() is a simple dice function, d(n) -> [1, n] flat uniform distribution.
        dynamic_strings = TruffleShuffle((
            # while the probability of all A == all B == all C, individual probabilities of each possible string will differ based on the number of possible outputs of each category.
            lambda: f"A{d(2)}",  # -> A1 - A2, each are twice as likely as any particular B, and three times as likely as any C.
            lambda: f"B{d(4)}",  # -> B1 - B4, each are half as likely as any particular A, and 3/2 as likely as any C.
            lambda: f"C{d(6)}",  # -> C1 - C6, each are 1/3 as likely as any particular A and 2/3 as likely of any B.
        ))
        
        print(dynamic_strings())  # prints a random dynamic string, flattened at call time.
        
        """
        Sample Distribution of 10,000 dynamic_strings():
            A1: 16.92%
            A2: 16.66%
            B1: 8.08%
            B2: 8.51%
            B3: 8.15%
            B4: 8.1%
            C1: 5.62%
            C2: 5.84%
            C3: 5.71%
            C4: 5.43%
            C5: 5.22%
            C6: 5.76%
        """
        ```
        
        
        ### QuantumMonty
        `Fortuna.QuantumMonty(data: Sequence, flat=True) -> Callable -> Value`
        - @param data :: Sequence of Values.
        - @param flat :: Bool. Default: True. Option to flatten callable values. Automatic Flattening.
        - @return :: Callable Object with Monty Methods for producing various distributions of the data.
            - @return :: Random value from the data. The instance will produce random values from the list using the selected distribution model or "monty". The default monty is the Quantum Monty Algorithm.
        
        ```python
        from Fortuna import QuantumMonty
        
        
        list_of_values = [1, 2, 3, 4, 5, 6]
        monty = QuantumMonty(list_of_values)
        
        print(monty())               # prints a random value from the list_of_values.
                                     # uses the default Quantum Monty Algorithm.
        
        print(monty.flat_uniform())  # prints a random value from the list_of_values.
                                     # uses the "uniform" monty: a flat uniform distribution.
                                     # equivalent to random.choice(list_of_values).
        ```
        The QuantumMonty class represents a diverse collection of strategies for producing random values from a sequence where the output distribution is based on the method you choose. Generally speaking, each value in the sequence will have a probability that is based on its position in the sequence. For example: the "front" monty produces random values where the beginning of the sequence is geometrically more common than the back. Given enough samples the "front" monty will always converge to a 45 degree slope down for any list of unique values.
        
        There are three primary method families: linear, gaussian, and poisson. Each family has three base methods; 'front', 'middle', 'back', plus a 'quantum' method that incorporates all three base methods. The quantum algorithms for each family produce distributions by overlapping the probability waves of the other methods in their family. The Quantum Monty Algorithm incorporates all nine base methods.
        
        ```python
        import Fortuna
        
        
        monty = Fortuna.QuantumMonty(
            ["Alpha", "Beta", "Delta", "Eta", "Gamma", "Kappa", "Zeta"]
        )
        
        # Each of the following methods will return a random value from the sequence.
        # Each method has its own unique distribution model for the same data set.
        
        """ Flat Base Case """
        monty.flat_uniform()             # Flat Uniform Distribution
        
        """ Geometric Positional """
        monty.front_linear()        # Linear Descending, Triangle
        monty.middle_linear()       # Linear Median Peak, Equilateral Triangle
        monty.back_linear()         # Linear Ascending, Triangle
        monty.quantum_linear()      # Linear Overlay, 3-way monty.
        
        """ Gaussian Positional """
        monty.front_gauss()         # Front Gamma
        monty.middle_gauss()        # Scaled Gaussian
        monty.back_gauss()          # Reversed Gamma
        monty.quantum_gauss()       # Gaussian Overlay, 3-way monty.
        
        """ Poisson Positional """
        monty.front_poisson()       # 1/4 Mean Poisson
        monty.middle_poisson()      # 1/2 Mean Poisson
        monty.back_poisson()        # 3/4 Mean Poisson
        monty.quantum_poisson()     # Poisson Overlay, 3-way monty.
        
        """ Quantum Monty Algorithm """
        monty()                     # Quantum Monty Algorithm, 9-way monty.
        monty.quantum_monty()
        ```
        
        ### Weighted Choice: Custom Rarity
        Weighted Choice offers two strategies for selecting random values from a sequence where programmable rarity is desired. Both produce a custom distribution of values based on the weights of the values.
        
        The choice to use one strategy over the other is purely about which one suits you or your data best. Relative weights are easier to understand at a glance. However, many RPG Treasure Tables map rather nicely to a cumulative weighted strategy.
        
        #### Cumulative Weight Strategy
        `Fortuna.CumulativeWeightedChoice(weighted_table: Table, flat=True) -> Callable -> Value`
        - @param weighted_table :: Table of weighted pairs.
        - @param flat :: Bool. Default: True. Option to flatten callable values. Automatic Flattening.
        - @return :: Callable Instance
            - @return :: Random value from the weighted_table, distribution based on the weights of the values.
        
        _Note: Logic dictates Cumulative Weights must be unique!_
        
        ```python
        from Fortuna import CumulativeWeightedChoice
        
        
        cum_weighted_choice = CumulativeWeightedChoice([
            (7, "Apple"),
            (11, "Banana"),
            (13, "Cherry"),
            (23, "Grape"),
            (26, "Lime"),
            (30, "Orange"),  # same as relative weight 4 because 30 - 26 = 4
        ])
        
        print(cum_weighted_choice())  # prints a weighted random value
        ```
        
        #### Relative Weight Strategy
        `Fortuna.RelativeWeightedChoice(weighted_table: Table) -> Callable -> Value`
        - @param weighted_table :: Table of weighted pairs.
        - @param flat :: Bool. Default: True. Option to flatten callable values. Automatic Flattening.
        - @return :: Callable Instance
            - @return :: Random value from the weighted_table, distribution based on the weights of the values.
        
        ```python
        from Fortuna import RelativeWeightedChoice
        
        
        population = ["Apple", "Banana", "Cherry", "Grape", "Lime", "Orange"]
        rel_weights = [7, 4, 2, 10, 3, 4]
        rel_weighted_choice = RelativeWeightedChoice(zip(rel_weights, population))
        
        print(rel_weighted_choice())  # prints a weighted random value
        ```
        
        ### FlexCat
        `Fortuna.FlexCat(dict_of_lists: Matrix, key_bias="front_linear", val_bias="truffle_shuffle", flat=True) -> Callable -> Value`
        - @param dict_of_lists :: Keyed Matrix of Value Sequences.
        - @parm key_bias :: String indicating the name of the algorithm to use for random key selection.
        - @parm val_bias :: String indicating the name of the algorithm to use for random value selection.
        - @param flat :: Bool. Default: True. Option to flatten callable values. Automatic Flattening.
        - @return :: Callable Instance
            - @param cat_key :: Optional. Default is None. Key selection by name. If specified, this will override the key_bias for a single call.
            - @return :: Value. Returns a random value generated with val_bias from a random sequence generated with key_bias.
        
        FlexCat is like a two dimensional QuantumMonty.
        
        The constructor takes two optional keyword arguments to specify the algorithms to be used to make random selections. The algorithm specified for selecting a key need not be the same as the one for selecting values. An optional key may be provided at call time to bypass the random key selection. Keys passed in this way must exactly match a key in the Matrix.
        
        By default, FlexCat will use key_bias="front" and val_bias="truffle_shuffle", this will make the top of the data structure geometrically more common than the bottom and it will truffle shuffle the sequence values. This config is known as TopCat, it produces a descending-step, micro-shuffled distribution sequence. Many other combinations are available.
        
        Algorithmic Options: _See QuantumMonty & TruffleShuffle for more details._
        - "front_linear", Linear Descending
        - "middle_linear", Linear Median Peak
        - "back_linear", Linear Ascending
        - "quantum_linear", Linear 3-way monty
        - "front_gauss", Gamma Descending
        - "middle_gauss", Scaled Gaussian
        - "back_gauss", Gamma Ascending
        - "quantum_gauss", Gaussian 3-way monty
        - "front_poisson", Front 1/3 Mean Poisson
        - "middle_poisson", Middle Mean Poisson
        - "back_poisson", Back 1/3 Mean Poisson
        - "quantum_poisson", Poisson 3-way monty
        - "quantum_monty", Quantum Monty Algorithm, 9-way monty
        - "flat_uniform", uniform flat distribution
        - "truffle_shuffle", TruffleShuffle, wide uniform distribution
        
        ```python
        from Fortuna import FlexCat
        
        
        matrix_data = {
            "Cat_A": ("A1", "A2", "A3", "A4", "A5"),
            "Cat_B": ("B1", "B2", "B3", "B4", "B5"),
            "Cat_C": ("C1", "C2", "C3", "C4", "C5"),
        }
        flex_cat = FlexCat(matrix_data, key_bias="front_linear", val_bias="flat_uniform")
        
        flex_cat()  # returns a "flat_uniform" random value from a random "front_linear" weighted category.
        flex_cat("Cat_B")  # returns a "flat_uniform" random value specifically from the "Cat_B" sequence.
        ```
        
        ### Random Integer Generators
        `Fortuna.random_below(number: int) -> int`
        - @param number :: Any Integer
        - @return :: Returns a random integer in the range...
            - `random_below(number) -> [0, number)` for positive values.
            - `random_below(number) -> (number, 0]` for negative values.
            - `random_below(0) -> 0` Always returns zero when input is zero
        - Flat uniform distribution.
        
        
        `Fortuna.random_int(left_limit: int, right_limit: int) -> int`
        - @param left_limit :: Any Integer
        - @param right_limit :: Any Integer
        - @return :: Returns a random integer in the range [left_limit, right_limit]
            - `random_int(1, 10) -> [1, 10]`
            - `random_int(10, 1) -> [1, 10]` same as above.
            - `random_int(A, B)` Always returns A when A == B
        - Flat uniform distribution.
        
        
        `Fortuna.random_range(start: int, stop: int = 0, step: int = 1) -> int`
        - @param start :: Any Integer. Required starting point.
            - `random_range(10) -> [0, 10)` from 0 to 9. Same as `Fortuna.random_index(N)`
            - `random_range(-10) -> [-10, 0)` from -10 to -1. Same as `Fortuna.random_index(-N)`
        - @param stop :: Any Integer. Optional stopping point. With at least two arguments, the order of the first two does not matter.
            - `random_range(0, 10) -> [0, 10)` from 0 to 9.
            - `random_range(10, 0) -> [0, 10)` same as above.
        - @param step :: optional step size.
            - `random_range(0, 10, 2) -> [0, 10) by 2` even numbers from 0 to 8.
            - The sign of the step parameter controls the phase of the output. Negative stepping will flip the inclusively.
            - `random_range(0, 10, -1) -> (0, 10]` from 10 to 1.
            - `random_range(10, 0, -1) -> (0, 10]` same as above.
            - `random_range(10, 10, 0) -> [10]` a step size or range size of zero always returns the first parameter.
        - @return :: Returns a random integer in the range [A, B) by increments of C.
        - Flat uniform distribution.
        
        
        `Fortuna.d(sides: int) -> int`
        - Represents a single roll of a given size die.
        - @param sides :: Any Integer. Represents the size or number of sides, most commonly six.
        - @return :: Returns a random integer in the range [1, sides].
        - Flat uniform distribution.
        
        
        `Fortuna.dice(rolls: int, sides: int) -> int`
        - Represents the sum of multiple rolls of the same size die.
        - @param rolls :: Any Integer. Represents the number of times to roll the die.
        - @param sides :: Any Integer. Represents the die size or number of sides, most commonly six.
        - @return :: Returns a random integer in range [X, Y] where X = rolls and Y = rolls * sides.
        - Geometric distribution based on the number and size of the dice rolled.
        - Complexity scales primarily with the number of rolls, not the size of the dice.
        
        
        `Fortuna.plus_or_minus(number: int) -> int`
        - @param number :: Any Integer.
        - @return :: Returns a random integer in range [-number, number].
        - Flat uniform distribution.
        
        
        `Fortuna.plus_or_minus_linear(number: int) -> int`
        - @param number :: Any Integer.
        - @return :: Returns a random integer in range [-number, number].
        - Linear geometric, 45 degree triangle distribution centered on zero.
        
        
        `Fortuna.plus_or_minus_gauss(number: int) -> int`
        - @param number :: Any Integer.
        - @return :: Returns a random integer in range [-number, number].
        - Stretched gaussian distribution centered on zero.
        
        
        ### Random Index, ZeroCool Specification
        ZeroCool Methods are used by lazy_cat via dependency injection to generate random indices with any distribution.
        
        ZeroCool methods must have the following properties:
        Any distribution model is acceptable, so long as: The method or function takes exactly one parameter N such that: The method returns a random int in range `[0, N)` for positive values of N, and returns a random int in range `[N, 0)` for negative values of N. This symmetry matches how python will naturally index a list from the back for negative index values or from the front for positive index values.
        
        ZeroCool functions often have an interesting limit as size goes to zero. ZeroCool does not place requirements the output of this input limit. At higher levels of abstraction, inside classes that employ ZeroCool methods- zero is always a sentinel to indicate the full range. In that case the length of the list is sent to the ZeroCool method, not zero. However for those who enjoy thinking a little deeper, consider the following:
        
        If given the fact that an empty range is never an option, we could design a better solution than failure for input zero. Calculus might suggest that both infinity and negative infinity are equally viable output for an input limit of zero, but both are inappropriate for indexing a list. However, if we map infinity to the back of the list and minus infinity to the front of the list, then the following might hold: `random_index(0) -> [-1, 0]`. This "Top or Bottom" solution is not required for a method to be ZeroCool compatible, it is just an interesting option. Other valid possibilities include: always return None or 0 or -1 or throw an exception or spawn nasal demons, however none of these seem terribly helpful or useful. At least the Top/Bottom solution accurately reflects the "off by one" symmetry of the domain mapping that defines ZeroCool methods in general.
        
        
        ```python
        from Fortuna import random_index
        
        
        some_list = [i for i in range(100)]
        
        print(some_list[random_index(10)])  # prints one of the first 10 items of some_list, [0, 9]
        print(some_list[random_index(-10)])  # prints one of the last 10 items of some_list, [90, 99]
        ```
        ### ZeroCool Methods
        `Fortuna.random_index(size: int) -> int` Flat uniform distribution
        
        `Fortuna.front_gauss(size: int) -> int` Gamma Distribution: Front Peak
        
        `Fortuna.middle_gauss(size: int) -> int` Stretched Gaussian Distribution: Median Peak
        
        `Fortuna.back_gauss(size: int) -> int` Gamma Distribution: Back Peak
        
        `Fortuna.quantum_gauss(size: int) -> int` Quantum Gaussian: Three-way Monty
        
        `Fortuna.front_poisson(size: int) -> int` Poisson Distribution: Front 1/3 Peak
        
        `Fortuna.middle_poisson(size: int) -> int` Poisson Distribution: Middle Peak
        
        `Fortuna.back_poisson(size: int) -> int` Poisson Distribution: Back 1/3 Peak
        
        `Fortuna.quantum_poisson(size: int) -> int` Quantum Poisson: Three-way Monty
        
        `Fortuna.front_geometric(size: int) -> int` Linear Geometric: 45 Degree Front Peak
        
        `Fortuna.middle_geometric(size: int) -> int` Linear Geometric: 45 Degree Middle Peak
        
        `Fortuna.back_geometric(size: int) -> int` Linear Geometric: 45 Degree Back Peak
        
        `Fortuna.quantum_geometric(size: int) -> int` Quantum Geometric: Three-way Monty
        
        `Fortuna.quantum_monty(size: int) -> int` Quantum Monty: Twelve-way Monty
        
        
        ### Random Float Generator
        `Fortuna.canonical() -> float`
        - @return :: random float in range [0.0, 1.0), flat uniform.
        
        
        `Fortuna.random_float(a: Float, b: Float) -> Float`
        - @param a :: Float
        - @param b :: Float
        - @return :: random Float in range [a, b), flat uniform distribution.
        
        
        ### Random Truth Generator
        `Fortuna.percent_true(truth_factor: Float = 50.0) -> bool`
        - @param truth_factor :: The probability of True as a percentage. Default is 50 percent.
        - @return :: Produces True or False based on the truth_factor.
            - Always returns False if num is 0 or less
            - Always returns True if num is 100 or more.
        
        
        ### Shuffle Algorithms
        `Fortuna.shuffle(array: list) -> None` 
        - Knuth B shuffle algorithm. Destructive, in-place shuffle.
        - @param array :: Must be a mutable list.
        
        `Fortuna.knuth(array: list) -> None` 
        - Knuth A shuffle algorithm. Destructive, in-place shuffle.
        - @param array :: Must be a mutable list.
        
        `Fortuna.fisher_yates(array: list) -> None` 
        - Fisher-Yates shuffle algorithm. Destructive, in-place shuffle.
        - @param array :: Must be a mutable list.
        
        
        ### Test Suite
        `Fortuna.distribution_timer(func: staticmethod, *args, num_cycles=100000, **kwargs) -> None`
        
        `Fortuna.quick_test(cycles=10000) -> None`
        
        
        ## Fortuna Distribution and Performance Test Suite
        ```
        Fortuna Test Suite: RNG Storm Engine
        
        Random Values:
        
        Base Case
        Output Distribution: Random.choice([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
        Typical Timing: 968 nano seconds
        Raw Samples: 9, 6, 1, 0, 2
        Statistics of 10000 Samples:
         Minimum: 0
         Median: 4
         Maximum: 9
         Mean: 4.4558
         Std Deviation: 2.8783111067920975
        Distribution of 100000 Samples:
         0: 10.096%
         1: 9.982%
         2: 9.892%
         3: 10.012%
         4: 9.977%
         5: 9.97%
         6: 9.985%
         7: 10.033%
         8: 10.036%
         9: 10.017%
        
        Output Distribution: random_value([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
        Typical Timing: 171 nano seconds
        Raw Samples: 7, 4, 9, 8, 5
        Statistics of 10000 Samples:
         Minimum: 0
         Median: 4
         Maximum: 9
         Mean: 4.4875
         Std Deviation: 2.8665075329647496
        Distribution of 100000 Samples:
         0: 10.014%
         1: 9.981%
         2: 9.921%
         3: 10.078%
         4: 9.98%
         5: 10.119%
         6: 9.964%
         7: 9.969%
         8: 9.996%
         9: 9.978%
        
        Output Analysis: TruffleShuffle(some_list)
        Typical Timing: 375 nano seconds
        Raw Samples: 3, 7, 4, 8, 5
        Statistics of 10000 Samples:
         Minimum: 0
         Median: 4
         Maximum: 9
         Mean: 4.5094
         Std Deviation: 2.888208062896691
        Distribution of 100000 Samples:
         0: 9.93%
         1: 9.989%
         2: 9.981%
         3: 10.16%
         4: 10.082%
         5: 10.023%
         6: 9.86%
         7: 10.031%
         8: 9.902%
         9: 10.042%
        
        Output Distribution: truffle_shuffle([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
        Typical Timing: 218 nano seconds
        Raw Samples: 0, 2, 3, 8, 5
        Statistics of 10000 Samples:
         Minimum: 0
         Median: 5
         Maximum: 9
         Mean: 4.5083
         Std Deviation: 2.8624727920189046
        Distribution of 100000 Samples:
         0: 9.845%
         1: 10.003%
         2: 10.12%
         3: 10.061%
         4: 10.013%
         5: 10.036%
         6: 9.935%
         7: 10.053%
         8: 9.96%
         9: 9.974%
        
        Output Analysis: QuantumMonty(some_list)
        Typical Timing: 343 nano seconds
        Raw Samples: 1, 7, 4, 5, 5
        Statistics of 10000 Samples:
         Minimum: 0
         Median: 4
         Maximum: 9
         Mean: 4.4878
         Std Deviation: 2.859347608611917
        Distribution of 100000 Samples:
         0: 10.959%
         1: 8.859%
         2: 8.909%
         3: 9.586%
         4: 11.633%
         5: 11.715%
         6: 9.738%
         7: 8.936%
         8: 8.91%
         9: 10.755%
        
        Output Distribution: lazy_cat([0, 1, 2, 3, 4, 5, 6, 7, 8, 9], zero_cool=<built-in function quantum_monty>)
        Typical Timing: 296 nano seconds
        Raw Samples: 5, 9, 0, 7, 6
        Statistics of 10000 Samples:
         Minimum: 0
         Median: 5
         Maximum: 9
         Mean: 4.5261
         Std Deviation: 2.8388597539276654
        Distribution of 100000 Samples:
         0: 10.725%
         1: 8.999%
         2: 9.023%
         3: 9.486%
         4: 11.345%
         5: 11.649%
         6: 9.858%
         7: 8.951%
         8: 9.069%
         9: 10.895%
        
        Base Case
        Output Distribution: Random.choices([36, 30, 24, 18], cum_weights=[1, 10, 100, 1000])
        Typical Timing: 1718 nano seconds
        Raw Samples: [18], [18], [18], [18], [18]
        Statistics of 10000 Samples:
         Minimum: 18
         Median: 18
         Maximum: 36
         Mean: 18.6594
         Std Deviation: 2.070077332375823
        Distribution of 100000 Samples:
         18: 90.102%
         24: 8.925%
         30: 0.87%
         36: 0.103%
        
        Output Analysis: CumulativeWeightedChoice(zip(cum_weights, population))
        Typical Timing: 250 nano seconds
        Raw Samples: 18, 18, 18, 18, 18
        Statistics of 10000 Samples:
         Minimum: 18
         Median: 18
         Maximum: 36
         Mean: 18.6708
         Std Deviation: 2.1391785733072517
        Distribution of 100000 Samples:
         18: 90.072%
         24: 8.924%
         30: 0.909%
         36: 0.095%
        
        Base Case
        Output Distribution: Random.choices([36, 30, 24, 18], weights=[1, 9, 90, 900])
        Typical Timing: 2125 nano seconds
        Raw Samples: [18], [18], [18], [18], [18]
        Statistics of 10000 Samples:
         Minimum: 18
         Median: 18
         Maximum: 36
         Mean: 18.6846
         Std Deviation: 2.0913536802802155
        Distribution of 100000 Samples:
         18: 89.994%
         24: 9.011%
         30: 0.917%
         36: 0.078%
        
        Output Analysis: RelativeWeightedChoice(zip(rel_weights, population))
        Typical Timing: 250 nano seconds
        Raw Samples: 18, 18, 24, 18, 18
        Statistics of 10000 Samples:
         Minimum: 18
         Median: 18
         Maximum: 36
         Mean: 18.6954
         Std Deviation: 2.130463031191278
        Distribution of 100000 Samples:
         18: 90.024%
         24: 8.95%
         30: 0.923%
         36: 0.103%
        
        Output Analysis: FlexCat(some_matrix, key_bias="flat_uniform", val_bias="flat_uniform")
        Typical Timing: 468 nano seconds
        Raw Samples: 20, 10, 3, 30, 20
        Statistics of 10000 Samples:
         Minimum: 1
         Median: 30
         Maximum: 400
         Mean: 93.7696
         Std Deviation: 129.79865132130027
        Distribution of 100000 Samples:
         1: 8.289%
         2: 8.378%
         3: 8.297%
         4: 8.352%
         10: 8.33%
         20: 8.287%
         30: 8.292%
         40: 8.138%
         100: 8.447%
         200: 8.433%
         300: 8.399%
         400: 8.358%
        
        Output Distribution: flex_cat({'A': [1, 2, 3, 4], 'B': [10, 20, 30, 40], 'C': [100, 200, 300, 400]})
        Typical Timing: 812 nano seconds
        Raw Samples: 20, 100, 20, 30, 40
        Statistics of 10000 Samples:
         Minimum: 1
         Median: 20
         Maximum: 400
         Mean: 92
         Std Deviation: 128.61422690331034
        Distribution of 100000 Samples:
         1: 8.44%
         2: 8.42%
         3: 8.161%
         4: 8.207%
         10: 8.323%
         20: 8.412%
         30: 8.389%
         40: 8.311%
         100: 8.287%
         200: 8.339%
         300: 8.379%
         400: 8.332%
        
        
        Random Integers:
        
        Base Case
        Output Distribution: Random.randrange(10)
        Typical Timing: 875 nano seconds
        Raw Samples: 3, 6, 2, 0, 8
        Statistics of 10000 Samples:
         Minimum: 0
         Median: 5
         Maximum: 9
         Mean: 4.5585
         Std Deviation: 2.8664960195233125
        Distribution of 100000 Samples:
         0: 9.995%
         1: 9.929%
         2: 10.015%
         3: 10.023%
         4: 10.139%
         5: 9.852%
         6: 10.034%
         7: 10.052%
         8: 9.975%
         9: 9.986%
        
        Output Distribution: random_below(10)
        Typical Timing: 62 nano seconds
        Raw Samples: 2, 0, 4, 2, 3
        Statistics of 10000 Samples:
         Minimum: 0
         Median: 5
         Maximum: 9
         Mean: 4.5075
         Std Deviation: 2.863453105320329
        Distribution of 100000 Samples:
         0: 10.145%
         1: 10.127%
         2: 9.991%
         3: 9.973%
         4: 10.177%
         5: 9.968%
         6: 9.771%
         7: 10.003%
         8: 9.919%
         9: 9.926%
        
        Output Distribution: random_index(10)
        Typical Timing: 62 nano seconds
        Raw Samples: 5, 0, 8, 8, 6
        Statistics of 10000 Samples:
         Minimum: 0
         Median: 4
         Maximum: 9
         Mean: 4.4639
         Std Deviation: 2.8888287112828817
        Distribution of 100000 Samples:
         0: 9.944%
         1: 10.156%
         2: 9.865%
         3: 9.994%
         4: 9.827%
         5: 9.912%
         6: 10.218%
         7: 10.11%
         8: 9.958%
         9: 10.016%
        
        Output Distribution: random_range(10)
        Typical Timing: 93 nano seconds
        Raw Samples: 9, 1, 2, 6, 9
        Statistics of 10000 Samples:
         Minimum: 0
         Median: 5
         Maximum: 9
         Mean: 4.542
         Std Deviation: 2.868773080238064
        Distribution of 100000 Samples:
         0: 10.018%
         1: 9.857%
         2: 10.106%
         3: 10.157%
         4: 9.868%
         5: 9.992%
         6: 9.883%
         7: 9.992%
         8: 10.146%
         9: 9.981%
        
        Output Distribution: random_below(-10)
        Typical Timing: 77 nano seconds
        Raw Samples: -6, -1, -2, -7, -5
        Statistics of 10000 Samples:
         Minimum: -9
         Median: -5
         Maximum: 0
         Mean: -4.5066
         Std Deviation: 2.8786776683942668
        Distribution of 100000 Samples:
         -9: 10.095%
         -8: 10.023%
         -7: 10.092%
         -6: 9.993%
         -5: 10.058%
         -4: 9.896%
         -3: 10.092%
         -2: 9.879%
         -1: 9.896%
         0: 9.976%
        
        Output Distribution: random_index(-10)
        Typical Timing: 93 nano seconds
        Raw Samples: -3, -7, -10, -6, -8
        Statistics of 10000 Samples:
         Minimum: -10
         Median: -6
         Maximum: -1
         Mean: -5.5132
         Std Deviation: 2.852409399777387
        Distribution of 100000 Samples:
         -10: 10.023%
         -9: 10.105%
         -8: 10.061%
         -7: 9.941%
         -6: 10.054%
         -5: 9.973%
         -4: 9.974%
         -3: 10.032%
         -2: 9.749%
         -1: 10.088%
        
        Output Distribution: random_range(-10)
        Typical Timing: 93 nano seconds
        Raw Samples: -7, -9, -10, -3, -3
        Statistics of 10000 Samples:
         Minimum: -10
         Median: -5
         Maximum: -1
         Mean: -5.4679
         Std Deviation: 2.869458654397538
        Distribution of 100000 Samples:
         -10: 9.955%
         -9: 9.945%
         -8: 10.044%
         -7: 9.887%
         -6: 9.951%
         -5: 9.983%
         -4: 10.017%
         -3: 10.237%
         -2: 10.023%
         -1: 9.958%
        
        Base Case
        Output Distribution: Random.randrange(1, 10)
        Typical Timing: 1093 nano seconds
        Raw Samples: 2, 3, 3, 5, 7
        Statistics of 10000 Samples:
         Minimum: 1
         Median: 5
         Maximum: 9
         Mean: 4.9762
         Std Deviation: 2.570465772856924
        Distribution of 100000 Samples:
         1: 11.145%
         2: 11.078%
         3: 11.142%
         4: 11.078%
         5: 11.198%
         6: 11.018%
         7: 11.112%
         8: 11.034%
         9: 11.195%
        
        Output Distribution: random_range(1, 10)
        Typical Timing: 93 nano seconds
        Raw Samples: 1, 7, 8, 6, 8
        Statistics of 10000 Samples:
         Minimum: 1
         Median: 5
         Maximum: 9
         Mean: 5.0095
         Std Deviation: 2.5857839000654685
        Distribution of 100000 Samples:
         1: 11.046%
         2: 11.277%
         3: 11.197%
         4: 11.032%
         5: 11.08%
         6: 11.203%
         7: 11.204%
         8: 10.891%
         9: 11.07%
        
        Output Distribution: random_range(10, 1)
        Typical Timing: 93 nano seconds
        Raw Samples: 3, 6, 7, 6, 6
        Statistics of 10000 Samples:
         Minimum: 1
         Median: 5
         Maximum: 9
         Mean: 5.0071
         Std Deviation: 2.5762207361420204
        Distribution of 100000 Samples:
         1: 11.188%
         2: 11.061%
         3: 11.189%
         4: 11.227%
         5: 11.191%
         6: 11.112%
         7: 11.236%
         8: 10.791%
         9: 11.005%
        
        Base Case
        Output Distribution: Random.randint(-5, 5)
        Typical Timing: 1218 nano seconds
        Raw Samples: 3, -4, 1, 5, 1
        Statistics of 10000 Samples:
         Minimum: -5
         Median: 0
         Maximum: 5
         Mean: 0.0283
         Std Deviation: 3.14068233009164
        Distribution of 100000 Samples:
         -5: 9.097%
         -4: 9.094%
         -3: 9.064%
         -2: 9.193%
         -1: 9.104%
         0: 9.054%
         1: 9.037%
         2: 9.06%
         3: 9.0%
         4: 9.041%
         5: 9.256%
        
        Output Distribution: random_int(-5, 5)
        Typical Timing: 62 nano seconds
        Raw Samples: 0, 1, -5, 4, 0
        Statistics of 10000 Samples:
         Minimum: -5
         Median: 0
         Maximum: 5
         Mean: 0.0215
         Std Deviation: 3.1664554937720824
        Distribution of 100000 Samples:
         -5: 9.327%
         -4: 9.001%
         -3: 9.043%
         -2: 9.019%
         -1: 9.108%
         0: 8.982%
         1: 9.039%
         2: 8.994%
         3: 9.062%
         4: 9.273%
         5: 9.152%
        
        Base Case
        Output Distribution: Random.randrange(1, 20, 2)
        Typical Timing: 1312 nano seconds
        Raw Samples: 1, 17, 7, 5, 19
        Statistics of 10000 Samples:
         Minimum: 1
         Median: 11
         Maximum: 19
         Mean: 10.1248
         Std Deviation: 5.748506718526934
        Distribution of 100000 Samples:
         1: 10.028%
         3: 10.058%
         5: 9.916%
         7: 9.973%
         9: 9.959%
         11: 10.048%
         13: 9.826%
         15: 10.123%
         17: 10.021%
         19: 10.048%
        
        Output Distribution: random_range(1, 20, 2)
        Typical Timing: 93 nano seconds
        Raw Samples: 19, 19, 17, 9, 3
        Statistics of 10000 Samples:
         Minimum: 1
         Median: 11
         Maximum: 19
         Mean: 10.0532
         Std Deviation: 5.741817360963397
        Distribution of 100000 Samples:
         1: 9.995%
         3: 10.084%
         5: 9.883%
         7: 10.083%
         9: 9.943%
         11: 9.946%
         13: 10.007%
         15: 9.836%
         17: 10.001%
         19: 10.222%
        
        Output Distribution: random_range(1, 20, -2)
        Typical Timing: 93 nano seconds
        Raw Samples: 18, 6, 14, 16, 8
        Statistics of 10000 Samples:
         Minimum: 2
         Median: 10
         Maximum: 20
         Mean: 10.9372
         Std Deviation: 5.687116183888712
        Distribution of 100000 Samples:
         2: 9.814%
         4: 10.026%
         6: 10.133%
         8: 10.109%
         10: 10.108%
         12: 10.011%
         14: 10.011%
         16: 9.969%
         18: 9.953%
         20: 9.866%
        
        Output Distribution: d(10)
        Typical Timing: 62 nano seconds
        Raw Samples: 1, 3, 3, 4, 7
        Statistics of 10000 Samples:
         Minimum: 1
         Median: 6
         Maximum: 10
         Mean: 5.4897
         Std Deviation: 2.885468160047909
        Distribution of 100000 Samples:
         1: 10.182%
         2: 9.845%
         3: 9.859%
         4: 10.01%
         5: 9.778%
         6: 10.062%
         7: 10.044%
         8: 10.049%
         9: 10.137%
         10: 10.034%
        
        Output Distribution: dice(3, 6)
        Typical Timing: 125 nano seconds
        Raw Samples: 4, 9, 11, 9, 17
        Statistics of 10000 Samples:
         Minimum: 3
         Median: 11
         Maximum: 18
         Mean: 10.5499
         Std Deviation: 2.9634756973562113
        Distribution of 100000 Samples:
         3: 0.485%
         4: 1.418%
         5: 2.757%
         6: 4.616%
         7: 6.958%
         8: 9.817%
         9: 11.512%
         10: 12.238%
         11: 12.588%
         12: 11.683%
         13: 9.75%
         14: 6.944%
         15: 4.698%
         16: 2.629%
         17: 1.434%
         18: 0.473%
        
        Output Distribution: ability_dice(4)
        Typical Timing: 218 nano seconds
        Raw Samples: 9, 16, 11, 10, 12
        Statistics of 10000 Samples:
         Minimum: 3
         Median: 12
         Maximum: 18
         Mean: 12.2258
         Std Deviation: 2.870302810475296
        Distribution of 100000 Samples:
         3: 0.086%
         4: 0.309%
         5: 0.719%
         6: 1.577%
         7: 2.865%
         8: 4.783%
         9: 7.179%
         10: 9.305%
         11: 11.443%
         12: 12.72%
         13: 13.38%
         14: 12.403%
         15: 10.213%
         16: 7.246%
         17: 4.163%
         18: 1.609%
        
        Output Distribution: plus_or_minus(5)
        Typical Timing: 62 nano seconds
        Raw Samples: 2, 3, 4, 3, -1
        Statistics of 10000 Samples:
         Minimum: -5
         Median: 0
         Maximum: 5
         Mean: 0.0891
         Std Deviation: 3.1677696675210854
        Distribution of 100000 Samples:
         -5: 9.164%
         -4: 9.093%
         -3: 8.869%
         -2: 9.133%
         -1: 9.068%
         0: 9.231%
         1: 8.933%
         2: 9.134%
         3: 9.104%
         4: 9.053%
         5: 9.218%
        
        Output Distribution: plus_or_minus_linear(5)
        Typical Timing: 77 nano seconds
        Raw Samples: -3, -3, -4, 0, 0
        Statistics of 10000 Samples:
         Minimum: -5
         Median: 0
         Maximum: 5
         Mean: 0.0053
         Std Deviation: 2.4250896923622434
        Distribution of 100000 Samples:
         -5: 2.778%
         -4: 5.515%
         -3: 8.317%
         -2: 11.102%
         -1: 13.981%
         0: 16.572%
         1: 13.948%
         2: 11.135%
         3: 8.291%
         4: 5.569%
         5: 2.792%
        
        Output Distribution: plus_or_minus_gauss(5)
        Typical Timing: 93 nano seconds
        Raw Samples: 0, -2, -1, -3, 1
        Statistics of 10000 Samples:
         Minimum: -5
         Median: 0
         Maximum: 5
         Mean: -0.0122
         Std Deviation: 1.2490024662570012
        Distribution of 100000 Samples:
         -5: 0.093%
         -4: 0.515%
         -3: 2.331%
         -2: 7.403%
         -1: 16.06%
         0: 47.035%
         1: 15.998%
         2: 7.49%
         3: 2.471%
         4: 0.52%
         5: 0.084%
        
        
        Random Floats:
        
        Output Distribution: canonical()
        Typical Timing: 62 nano seconds
        Raw Samples: 0.07021970757222648, 0.31747083698360273, 0.15863519225852157, 0.09067134155513228, 0.5664287974954809
        Statistics of 10000 Samples:
         Minimum: 2.1622411629218996e-05
         Median: (0.49876177263117494, 0.49888049786863325)
         Maximum: 0.9995763570245703
         Mean: 0.4991818640180143
         Std Deviation: 0.2879651475762035
        Post-processor Distribution of 100000 Samples using round method:
         0: 49.965%
         1: 50.035%
        
        Output Distribution: random_float(0.0, 10.0)
        Typical Timing: 62 nano seconds
        Raw Samples: 5.219040166022521, 8.83400688142569, 0.8169746943874825, 9.815990162232831, 6.848839607753801
        Statistics of 10000 Samples:
         Minimum: 0.0011836805473487175
         Median: (4.948945667748921, 4.949319393677276)
         Maximum: 9.999315669457632
         Mean: 5.003740220101194
         Std Deviation: 2.8670290635820512
        Post-processor Distribution of 100000 Samples using floor method:
         0: 9.925%
         1: 9.942%
         2: 9.976%
         3: 9.945%
         4: 10.156%
         5: 10.059%
         6: 9.938%
         7: 9.97%
         8: 9.887%
         9: 10.202%
        
        
        Random Booleans:
        
        Output Distribution: percent_true(33.33)
        Typical Timing: 62 nano seconds
        Raw Samples: False, True, False, True, True
        Statistics of 10000 Samples:
         Minimum: False
         Median: False
         Maximum: True
         Mean: 0.3393
         Std Deviation: 0.4734954379853932
        Distribution of 100000 Samples:
         False: 66.671%
         True: 33.329%
        
        
        Shuffle Performance Tests:
        
        Base Case: random.shuffle(some_list_100)
        Typical Timing: 67781 nano seconds
        
        fisher_yates(some_list_100)
        Typical Timing: 6937 nano seconds
        
        knuth(some_list_100)
        Typical Timing: 6937 nano seconds
        
        shuffle(some_list_100)
        Typical Timing: 3968 nano seconds
        
        -------------------------------------------------------------------------
        Total Test Time: 3.189 seconds
        
        ```
        
        
        ## Fortuna Development Log
        ##### Fortuna 3.4.1
        - Major Bug Fix: random_index()
        
        ##### Fortuna 3.4.0 - internal
        - ZeroCool Poisson Algorithm Family Updated
        
        ##### Fortuna 3.3.8 - internal
        - Docs Update
        
        ##### Fortuna 3.3.7
        - Fixed Performance Bug: ZeroCool Linear Algorithm Family
        
        ##### Fortuna 3.3.6
        - Docs Update
        
        ##### Fortuna 3.3.5
        - ABI Updates
        - Bug Fixes
        
        ##### Fortuna 3.3.4
        - Examples Update
        
        ##### Fortuna 3.3.3
        - Test Suite Update
        
        ##### Fortuna 3.3.2 - internal
        - Documentation Update
        
        ##### Fortuna 3.3.1 - internal
        - Minor Bug Fix
        
        ##### Fortuna 3.3.0 - internal
        - Added `plus_or_minus_gauss(N: int) -> int` random int in range [-N, N] Stretched Gaussian Distribution
        
        ##### Fortuna 3.2.3
        - Small Typos Fixed
        
        ##### Fortuna 3.2.2
        - Documentation update.
        
        ##### Fortuna 3.2.1
        - Small Typo Fixed
        
        ##### Fortuna 3.2.0
        - API updates:
            - QunatumMonty.uniform -> QunatumMonty.flat_uniform
            - QunatumMonty.front -> QunatumMonty.front_linear
            - QunatumMonty.middle -> QunatumMonty.middle_linear
            - QunatumMonty.back -> QunatumMonty.back_linear
            - QunatumMonty.quantum -> QunatumMonty.quantum_linear
            - randindex -> random_index
            - randbelow -> random_below
            - randrange -> random_range
            - randint   -> random_int
        
        ##### Fortuna 3.1.0
        - `discrete()` has been removed, see Weighted Choice.
        - `lazy_cat()` added.
        - All ZeroCool methods have been raised to top level API, for use with lazy_cat()
        
        ##### Fortuna 3.0.1
        - minor typos.
        
        ##### Fortuna 3.0.0
        - Storm 2 Rebuild.
        
        ##### Fortuna 2.1.1
        - Small bug fixes.
        - Test updates.
        
        ##### Fortuna 2.1.0, Major Feature Update
        - Fortuna now includes the best of RNG and Pyewacket.
        
        ##### Fortuna 2.0.3
        - Bug fix.
        
        ##### Fortuna 2.0.2
        - Clarified some documentation.
        
        ##### Fortuna 2.0.1
        - Fixed some typos.
        
        ##### Fortuna 2.0.0b1-10
        - Total rebuild. New RNG Storm Engine.
        
        ##### Fortuna 1.26.7.1
        - README updated.
        
        ##### Fortuna 1.26.7
        - Small bug fix.
        
        ##### Fortuna 1.26.6
        - Updated README to reflect recent changes to the test script.
        
        ##### Fortuna 1.26.5
        - Fixed small bug in test script.
        
        ##### Fortuna 1.26.4
        - Updated documentation for clarity.
        - Fixed a minor typo in the test script.
        
        ##### Fortuna 1.26.3
        - Clean build.
        
        ##### Fortuna 1.26.2
        - Fixed some minor typos.
        
        ##### Fortuna 1.26.1
        - Release.
        
        ##### Fortuna 1.26.0 beta 2
        - Moved README and LICENSE files into fortuna_extras folder.
        
        ##### Fortuna 1.26.0 beta 1
        - Dynamic version scheme implemented.
        - The Fortuna Extension now requires the fortuna_extras package, previously it was optional.
        
        ##### Fortuna 1.25.4
        - Fixed some minor typos in the test script.
        
        ##### Fortuna 1.25.3
        - Since version 1.24 Fortuna requires Python 3.7 or higher. This patch corrects an issue where the setup script incorrectly reported requiring Python 3.6 or higher.
        
        ##### Fortuna 1.25.2
        - Updated test suite.
        - Major performance update for TruffleShuffle.
        - Minor performance update for QuantumMonty & FlexCat: cycle monty.
        
        ##### Fortuna 1.25.1
        - Important bug fix for TruffleShuffle, QuantumMonty and FlexCat.
        
        ##### Fortuna 1.25
        - Full 64bit support.
        - The Distribution & Performance Tests have been redesigned.
        - Bloat Control: Two experimental features have been removed.
            - RandomWalk
            - CatWalk
        - Bloat Control: Several utility functions have been removed from the top level API. These function remain in the Fortuna namespace for now, but may change in the future without warning.
            - stretch_bell, internal only.
            - min_max, not used anymore.
            - analytic_continuation, internal only.
            - flatten, internal only.
        
        ##### Fortuna 1.24.3
        - Low level refactoring, non-breaking patch.
        
        ##### Fortuna 1.24.2
        - Setup config updated to improve installation.
        
        ##### Fortuna 1.24.1
        - Low level patch to avoid potential ADL issue. All low level function calls are now qualified.
        
        ##### Fortuna 1.24
        - Documentation updated for even more clarity.
        - Bloat Control: Two naïve utility functions that are no longer used in the module have been removed.
            - n_samples -> use a list comprehension instead. `[f(x) for _ in range(n)]`
            - bind -> use a lambda instead. `lambda: f(x)`
        
        ##### Fortuna 1.23.7
        - Documentation updated for clarity.
        - Minor bug fixes.
        - TruffleShuffle has been redesigned slightly, it now uses a random rotate instead of swap.
        - Custom `__repr__` methods have been added to each class.
        
        ##### Fortuna 1.23.6
        - New method for QuantumMonty: quantum_not_monty - produces the upside down quantum_monty.
        - New bias option for FlexCat: not_monty.
        
        ##### Fortuna 1.23.5.1
        - Fixed some small typos.
        
        ##### Fortuna 1.23.5
        - Documentation updated for clarity.
        - All sequence wrappers can now accept generators as input.
        - Six new functions added:
            - random_float() -> float in range [0.0..1.0) exclusive, uniform flat distribution.
            - percent_true_float(num: float) -> bool, Like percent_true but with floating point precision.
            - plus_or_minus_linear_down(num: int) -> int in range [-num..num], upside down pyramid.
            - plus_or_minus_curve_down(num: int) -> int in range [-num..num], upside down bell curve.
            - mostly_not_middle(num: int) -> int in range [0..num], upside down pyramid.
            - mostly_not_center(num: int) -> int in range [0..num], upside down bell curve.
        - Two new methods for QuantumMonty:
            - mostly_not_middle
            - mostly_not_center
        - Two new bias options for FlexCat, either can be used to define x and/or y axis bias:
            - not_middle
            - not_center
        
        ##### Fortuna 1.23.4.2
        - Fixed some minor typos in the README.md file.
        
        ##### Fortuna 1.23.4.1
        - Fixed some minor typos in the test suite.
        
        ##### Fortuna 1.23.4
        - Fortuna is now Production/Stable!
        - Fortuna and Fortuna Pure now use the same test suite.
        
        ##### Fortuna 0.23.4, first release candidate.
        - RandomCycle, BlockCycle and TruffleShuffle have been refactored and combined into one class: TruffleShuffle.
        - QuantumMonty and FlexCat will now use the new TruffleShuffle for cycling.
        - Minor refactoring across the module.
        
        ##### Fortuna 0.23.3, internal
        - Function shuffle(arr: list) added.
        
        ##### Fortuna 0.23.2, internal
        - Simplified the plus_or_minus_curve(num: int) function, output will now always be bounded to the range [-num..num].
        - Function stretched_bell(num: int) added, this matches the previous behavior of an unbounded plus_or_minus_curve.
        
        ##### Fortuna 0.23.1, internal
        - Small bug fixes and general clean up.
        
        ##### Fortuna 0.23.0
        - The number of test cycles in the test suite has been reduced to 10,000 (down from 100,000). The performance of the pure python implementation and the c-extension are now directly comparable.
        - Minor tweaks made to the examples in `.../fortuna_extras/fortuna_examples.py`
        
        ##### Fortuna 0.22.2, experimental features
        - BlockCycle class added.
        - RandomWalk class added.
        - CatWalk class added.
        
        ##### Fortuna 0.22.1
        - Fortuna classes no longer return lists of values, this behavior has been extracted to a free function called n_samples.
        
        ##### Fortuna 0.22.0, experimental features
        - Function bind added.
        - Function n_samples added.
        
        ##### Fortuna 0.21.3
        - Flatten will no longer raise an error if passed a callable item that it can't call. It correctly returns such items in an uncalled state without error.
        - Simplified `.../fortuna_extras/fortuna_examples.py` - removed unnecessary class structure.
        
        ##### Fortuna 0.21.2
        - Fix some minor bugs.
        
        ##### Fortuna 0.21.1
        - Fixed a bug in `.../fortuna_extras/fortuna_examples.py`
        
        ##### Fortuna 0.21.0
        - Function flatten added.
        - Flatten: The Fortuna classes will recursively unpack callable objects in the data set.
        
        ##### Fortuna 0.20.10
        - Documentation updated.
        
        ##### Fortuna 0.20.9
        - Minor bug fixes.
        
        ##### Fortuna 0.20.8, internal
        - Testing cycle for potential new features.
        
        ##### Fortuna 0.20.7
        - Documentation updated for clarity.
        
        ##### Fortuna 0.20.6
        - Tests updated based on recent changes.
        
        ##### Fortuna 0.20.5, internal
        - Documentation updated based on recent changes.
        
        ##### Fortuna 0.20.4, internal
        - WeightedChoice (both types) can optionally return a list of samples rather than just one value, control the length of the list via the n_samples argument.
        
        ##### Fortuna 0.20.3, internal
        - RandomCycle can optionally return a list of samples rather than just one value,
        control the length of the list via the n_samples argument.
        
        ##### Fortuna 0.20.2, internal
        - QuantumMonty can optionally return a list of samples rather than just one value,
        control the length of the list via the n_samples argument.
        
        ##### Fortuna 0.20.1, internal
        - FlexCat can optionally return a list of samples rather than just one value,
        control the length of the list via the n_samples argument.
        
        ##### Fortuna 0.20.0, internal
        - FlexCat now accepts a standard dict as input. The ordered(ness) of dict is now part of the standard in Python 3.7.1. Previously FlexCat required an OrderedDict, now it accepts either and treats them the same.
        
        ##### Fortuna 0.19.7
        - Fixed bug in `.../fortuna_extras/fortuna_examples.py`.
        
        ##### Fortuna 0.19.6
        - Updated documentation formatting.
        - Small performance tweak for QuantumMonty and FlexCat.
        
        ##### Fortuna 0.19.5
        - Minor documentation update.
        
        ##### Fortuna 0.19.4
        - Minor update to all classes for better debugging.
        
        ##### Fortuna 0.19.3
        - Updated plus_or_minus_curve to allow unbounded output.
        
        ##### Fortuna 0.19.2
        - Internal development cycle.
        - Minor update to FlexCat for better debugging.
        
        ##### Fortuna 0.19.1
        - Internal development cycle.
        
        ##### Fortuna 0.19.0
        - Updated documentation for clarity.
        - MultiCat has been removed, it is replaced by FlexCat.
        - Mostly has been removed, it is replaced by QuantumMonty.
        
        ##### Fortuna 0.18.7
        - Fixed some more README typos.
        
        ##### Fortuna 0.18.6
        - Fixed some README typos.
        
        ##### Fortuna 0.18.5
        - Updated documentation.
        - Fixed another minor test bug.
        
        ##### Fortuna 0.18.4
        - Updated documentation to reflect recent changes.
        - Fixed some small test bugs.
        - Reduced default number of test cycles to 10,000 - down from 100,000.
        
        ##### Fortuna 0.18.3
        - Fixed some minor README typos.
        
        ##### Fortuna 0.18.2
        - Fixed a bug with Fortuna Pure.
        
        ##### Fortuna 0.18.1
        - Fixed some minor typos.
        - Added tests for `.../fortuna_extras/fortuna_pure.py`
        
        ##### Fortuna 0.18.0
        - Introduced new test format, now includes average call time in nanoseconds.
        - Reduced default number of test cycles to 100,000 - down from 1,000,000.
        - Added pure Python implementation of Fortuna: `.../fortuna_extras/fortuna_pure.py`
        - Promoted several low level functions to top level.
            - `zero_flat(num: int) -> int`
            - `zero_cool(num: int) -> int`
            - `zero_extreme(num: int) -> int`
            - `max_cool(num: int) -> int`
            - `max_extreme(num: int) -> int`
            - `analytic_continuation(func: staticmethod, num: int) -> int`
            - `min_max(num: int, lo: int, hi: int) -> int`
        
        ##### Fortuna 0.17.3
        - Internal development cycle.
        
        ##### Fortuna 0.17.2
        - User Requested: dice() and d() functions now support negative numbers as input.
        
        ##### Fortuna 0.17.1
        - Fixed some minor typos.
        
        ##### Fortuna 0.17.0
        - Added QuantumMonty to replace Mostly, same default behavior with more options.
        - Mostly is depreciated and may be removed in a future release.
        - Added FlexCat to replace MultiCat, same default behavior with more options.
        - MultiCat is depreciated and may be removed in a future release.
        - Expanded the Treasure Table example in `.../fortuna_extras/fortuna_examples.py`
        
        ##### Fortuna 0.16.2
        - Minor refactoring for WeightedChoice.
        
        ##### Fortuna 0.16.1
        - Redesigned fortuna_examples.py to feature a dynamic random magic item generator.
        - Raised cumulative_weighted_choice function to top level.
        - Added test for cumulative_weighted_choice as free function.
        - Updated MultiCat documentation for clarity.
        
        ##### Fortuna 0.16.0
        - Pushed distribution_timer to the .pyx layer.
        - Changed default number of iterations of tests to 1 million, up form 1 hundred thousand.
        - Reordered tests to better match documentation.
        - Added Base Case Fortuna.fast_rand_below.
        - Added Base Case Fortuna.fast_d.
        - Added Base Case Fortuna.fast_dice.
        
        ##### Fortuna 0.15.10
        - Internal Development Cycle
        
        ##### Fortuna 0.15.9
        - Added Base Cases for random_value()
        - Added Base Case for randint()
        
        ##### Fortuna 0.15.8
        - Clarified MultiCat Test
        
        ##### Fortuna 0.15.7
        - Fixed minor typos.
        
        ##### Fortuna 0.15.6
        - Fixed minor typos.
        - Simplified MultiCat example.
        
        ##### Fortuna 0.15.5
        - Added MultiCat test.
        - Fixed some minor typos in docs.
        
        ##### Fortuna 0.15.4
        - Performance optimization for both WeightedChoice() variants.
        - Cython update provides small performance enhancement across the board.
        - Compilation now leverages Python3 all the way down.
        - MultiCat pushed to the .pyx layer for better performance.
        
        ##### Fortuna 0.15.3
        - Reworked the MultiCat example to include several randomizing strategies working in concert.
        - Added Multi Dice 10d10 performance tests.
        - Updated sudo code in documentation to be more pythonic.
        
        ##### Fortuna 0.15.2
        - Fixed: Linux installation failure.
        - Added: complete source files to the distribution (.cpp .hpp .pyx).
        
        ##### Fortuna 0.15.1
        - Updated & simplified distribution_timer in `fortuna_tests.py`
        - Readme updated, fixed some typos.
        - Known issue preventing successful installation on some linux platforms.
        
        ##### Fortuna 0.15.0
        - Performance tweaks.
        - Readme updated, added some details.
        
        ##### Fortuna 0.14.1
        - Readme updated, fixed some typos.
        
        ##### Fortuna 0.14.0
        - Fixed a bug where the analytic continuation algorithm caused a rare issue during compilation on some platforms.
        
        ##### Fortuna 0.13.3
        - Fixed Test Bug: percent sign was missing in output distributions.
        - Readme updated: added update history, fixed some typos.
        
        ##### Fortuna 0.13.2
        - Readme updated for even more clarity.
        
        ##### Fortuna 0.13.1
        - Readme updated for clarity.
        
        ##### Fortuna 0.13.0
        - Minor Bug Fixes.
        - Readme updated for aesthetics.
        - Added Tests: `.../fortuna_extras/fortuna_tests.py`
        
        ##### Fortuna 0.12.0
        - Internal test for future update.
        
        ##### Fortuna 0.11.0
        - Initial Release: Public Beta
        
        ##### Fortuna 0.10.0
        - Module name changed from Dice to Fortuna
        
        ##### Dice 0.1.x - 0.9.x
        - Experimental Phase
        
        
        ## Legal Information
        Fortuna © 2019 Broken aka Robert W Sharp, all rights reserved.
        
        Fortuna is licensed under a Creative Commons Attribution-NonCommercial 3.0 Unported License.
        
        See online version of this license here: <http://creativecommons.org/licenses/by-nc/3.0/>
        
Keywords: Fortuna,Random Patterns,Data Perturbation,Game Dice,Weighted Choice,Random Value Generator,Gaussian Distribution,Linear Distribution,TruffleShuffle,FlexCat,Percent True,ZeroCool,QuantumMonty,Custom Distribution,Rarity Table
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
