{{alias}}( len, k, lambda[, options] )
    Returns an array containing pseudorandom numbers drawn from an Erlang
    distribution.

    Parameters
    ----------
    len: integer
        Output array length.

    k: number
        Shape parameter.

    lambda: number
        Rate parameter.

    options: Object (optional)
        Options.

    options.dtype: string (optional)
        Output array data type. Default: 'float64'.

    Returns
    -------
    out: Array<number>|Float64Array|Float32Array
        Output array.

    Examples
    --------
    > var out = {{alias}}( 3, 2, 5.0 )
    <Float64Array>


{{alias}}.assign( k, lambda, out )
    Fills an array with pseudorandom numbers drawn from an Erlang distribution.

    Parameters
    ----------
    k: number
        Shape parameter.

    lambda: number
        Rate parameter.

    out: Array<number>|Float64Array|Float32Array
        Output array.

    Returns
    -------
    out: Array<number>|Float64Array|Float32Array
        Output array.

    Examples
    --------
    > var x = {{alias:@stdlib/array/zeros}}( 3, 'float64' );
    > var out = {{alias}}.assign( 2, 5.0, x )
    <Float64Array>
    > var bool = ( out === x )
    true


{{alias}}.factory( [k, lambda, ][options] )
    Returns a function for creating arrays containing pseudorandom numbers drawn
    from an Erlang distribution.

    If provided distribution parameters, the returned function returns random
    variates drawn from the specified distribution.

    If not provided distribution parameters, the returned function requires that
    distribution parameters be provided at each invocation.

    The returned function accepts the following options:

    - dtype: output array data type. This overrides the default output array
    data type.

    Parameters
    ----------
    k: number (optional)
        Shape parameter.

    lambda: number (optional)
        Rate parameter.

    options: Object (optional)
        Options.

    options.prng: Function (optional)
        Pseudorandom number generator (PRNG) for generating uniformly
        distributed pseudorandom numbers on the interval `[0,1)`. If provided,
        the `state` and `seed` options are ignored. In order to seed the
        returned pseudorandom number generator, one must seed the provided
        `prng` (assuming the provided `prng` is seedable).

    options.seed: integer|ArrayLikeObject<integer> (optional)
        Pseudorandom number generator seed. The seed may be either a positive
        unsigned 32-bit integer or, for arbitrary length seeds, an array-like
        object containing unsigned 32-bit integers.

    options.state: Uint32Array (optional)
        Pseudorandom number generator state. If provided, the `seed` option is
        ignored.

    options.copy: boolean (optional)
        Boolean indicating whether to copy a provided pseudorandom number
        generator state. Setting this option to `false` allows sharing state
        between two or more pseudorandom number generators. Setting this option
        to `true` ensures that a returned generator has exclusive control over
        its internal state. Default: true.

    options.dtype: string (optional)
        Default output array data type. Default: 'float64'.

    Returns
    -------
    fcn: Function
        Function for creating arrays.

    Examples
    --------
    > var fcn = {{alias}}.factory();
    > var out = fcn( 3, 2, 5.0 )
    <Float64Array>

    // Provide distribution parameters:
    > fcn = {{alias}}.factory( 2, 5.0 );
    > out = fcn( 3 )
    <Float64Array>


{{alias}}.PRNG
    Underlying pseudorandom number generator.

    Examples
    --------
    > var prng = {{alias}}.PRNG;


{{alias}}.seed
    Pseudorandom number generator seed.

    Examples
    --------
    > var seed = {{alias}}.seed;


{{alias}}.seedLength
    Length of generator seed.

    Examples
    --------
    > var len = {{alias}}.seedLength;


{{alias}}.state
    Generator state.

    Examples
    --------
    > var out = {{alias}}( 3, 2, 5.0 )
    <Float64Array>

    // Get a copy of the current state:
    > var state = {{alias}}.state
    <Uint32Array>

    > out = {{alias}}( 3, 2, 5.0 )
    <Float64Array>
    > out = {{alias}}( 3, 2, 5.0 )
    <Float64Array>

    // Set the state:
    > {{alias}}.state = state;

    // Regenerate a previous array:
    > out = {{alias}}( 3, 2, 5.0 )
    <Float64Array>


{{alias}}.stateLength
    Length of generator state.

    Examples
    --------
    > var len = {{alias}}.stateLength;


{{alias}}.byteLength
    Size (in bytes) of generator state.

    Examples
    --------
    > var sz = {{alias}}.byteLength;

    See Also
    --------