Random Number Generation

[GregoryTravis]

Introduction

Random contains a default global Random_Generator instance as well as methods for constructing new instances.

A Random_Generator is a single instance of a random number generator, with methods for obtaining different kinds of random values. These methods also exist on Random, implicitly using the default instance of Random_Generator.

For each method returning a single value, e.g. int, there is another method, ints, taking a count and returning a Vector of values. These exist on both Random and Random_Generator.

(Alternately, the single-value methods could all take a count parameter.)

All basic methods (int, float) are implemented using java.util.Random.

This subsumes all Faker functionality.

Future work / things to think about

• Random “Lorem Ipsum”
• Specific alphanumeric strings
• Phone numbers
• Passport numbers
• IP address
• Alternate rng algorithms
• SecureRandom
• True randomness sources
• Dataset generation
• Data anonymization

API

type Random
    # Default Random instance
    default_instance : Random

    # Set the seed of the default Random instance
    set_seed : Integer -> Nothing

    # Create a new Random with the specified seed
    new : Int -> Random

    # Static versions of methods from Random_Generator.
    int low=0 high = Random.default_instance.int low high
    int_32 low=MIN_INT high=MIN_INT =
    # ...

type Random_Generator
    # Return a random `Integer`
    int low=0 high =
    int self ... =

    # Return a random 64-bit `Float`
    float low=0.0 high=1.0 =

    # Return a random 32-bit `Integer` from the entire 32-bit range
    int_32 low=MIN_INT high=MIN_INT =

    # Return a random 64-bit `Integer` from the entire 64-bit range
    int_64 low=MIN_LONG high=MIN_LONG =

    # Return a random `Float` from the entire double precision range range
    double_precision low=MIN_DOUBLE high=MIN_DOUBLE =

    # Return a random `Boolean`
    boolean : Boolean

    # Return a random Gaussian distribution float in the range 0..1
    gaussian : Float

    # Return a random `Integer` in the range 0..255
    byte : Integer

    # Return a random `Integer` from the range [0, n-1], sampled without replacement.
    index : Integer -> Integer -> Integer

    # Return a random `Integer` in the given `Range` (respects `step`)
    in_range : Range -> Integer

    # Return a random `Date` in the given `Date_Range`
    in_date_range : Date_Range -> DAte

    # Return a random UUID
    uuid : Text

    # Generate a string by selecting a random character from each element of the list.
    # Previously `Faker.string_value`
    text_from_charsets : Vector (Text | Vector Char)

    ## Generate a string based on a pattern.
       (As seen in AlteryxAbacus.)
       Pattern language TBD.

       Example:
       rnd.text_from_pattern "AAaaa###" -> "BZdje533"
    text_from_pattern pattern : Text -> Text

    ## GROUP Standard.Base.Random
       Randomly converts some values to Nothing
    make_some_nothing : Any -> Float -> Any

    ## Return a random value from the given collection.
       If `with_replacement` is false, and `count` is equal to or greater than
       the size of the collection, a random permutation of the collection is returned.
    sample : Vector | Set | Map | Range -> Integer -> Boolean -> Any
    sample collection count with_replacement=True =

    permutation : Vector | Set | Map | Range -> Any
    permutation collection = Random.sample collection collection.length with_replacement=False

    # Return a list of random `Integers`
    ints count=1 low=0 high count=Nothing
    int_32s ...
    int_64s ...
    # etc.