
{{alias}}( shape, k, lambda[, options] )
    Returns an ndarray containing pseudorandom numbers drawn from a Weibull
    distribution.

    Parameters
    ----------
    shape: Array<integer>
        Array shape.

    k: number|ndarray
        Shape parameter. If an ndarray, must be broadcast compatible with the
        specified array shape.

    lambda: number|ndarray
        Scale parameter. If an ndarray, must be broadcast compatible with the
        specified array shape.

    options: Object (optional)
        Options.

    options.dtype: string|DataType (optional)
        Array data type. Must be a real-valued floating-point or "generic" data
        type.

    options.order: string (optional)
        Specifies whether an array is row-major (C-style) or column-major
        (Fortran-style). Default: 'row-major'.

    options.mode: string (optional)
        Specifies how to handle indices which exceed array dimensions. If equal
        to 'throw', an ndarray instance throws an error when an index exceeds
        array dimensions. If equal to 'wrap', an ndarray instance wraps around
        indices exceeding array dimensions using modulo arithmetic. If equal to
        'clamp', an ndarray instance sets an index exceeding array dimensions to
        either `0` (minimum index) or the maximum index. Default: 'throw'.

    options.submode: Array<string> (optional)
        Specifies how to handle subscripts which exceed array dimensions. If a
        mode for a corresponding dimension is equal to 'throw', an ndarray
        instance throws an error when a subscript exceeds array dimensions. If
        equal to 'wrap', an ndarray instance wraps around subscripts exceeding
        array dimensions using modulo arithmetic. If equal to 'clamp', an
        ndarray instance sets a subscript exceeding array dimensions to either
        `0` (minimum index) or the maximum index. If the number of modes is
        less than the number of dimensions, an ndarray instance recycles modes
        using modulo arithmetic. Default: [ options.mode ].

    options.readonly: boolean (optional)
        Boolean indicating whether an array should be read-only. Default: false.

    Returns
    -------
    out: ndarray
        Output array.

    Examples
    --------
    > var out = {{alias}}( [ 3, 3 ], 2.0, 5.0 )
    <ndarray>


{{alias}}.assign( k, lambda, out )
    Fills an ndarray with pseudorandom numbers drawn from a Weibull
    distribution.

    Parameters
    ----------
    k: number|ndarray
        Shape parameter. If an ndarray, must be broadcast compatible with the
        provided output array.

    lambda: number|ndarray
        Scale parameter. If an ndarray, must be broadcast compatible with the
        provided output array.

    out: ndarray
        Output array.

    Returns
    -------
    out: ndarray
        Output array.

    Examples
    --------
    > var out = {{alias:@stdlib/ndarray/zeros}}( [ 3, 3 ] );
    > var v = {{alias}}.assign( 2.0, 5.0, out )
    <ndarray>
    > var bool = ( v === out )
    true


{{alias}}.factory( [options] )
    Returns a function for generating pseudorandom numbers drawn from a Weibull
    distribution.

    The returned function has the same signature and accepts the same options as
    `{{alias}}` above.

    Parameters
    ----------
    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.

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

    Examples
    --------
    > var fcn = {{alias}}.factory();
    > var out = fcn( [ 3, 3 ], 2.0, 5.0 )
    <ndarray>


{{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, 3 ], 2.0, 5.0 )
    <ndarray>

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

    > out = {{alias}}( [ 3, 3 ], 2.0, 5.0 )
    <ndarray>
    > out = {{alias}}( [ 3, 3 ], 2.0, 5.0 )
    <ndarray>

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

    // Regenerate a previous array:
    > out = {{alias}}( [ 3, 3 ], 2.0, 5.0 )
    <ndarray>


{{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
    --------

