@stdlib/random-array-invgamma 0.1.0

package/dist/index.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../lib/defaults.json", "../lib/validate.js", "../lib/factory.js", "../lib/main.js", "../lib/index.js"],
+  "sourcesContent": ["{\n\t\"dtype\": \"float64\"\n}\n", "/**\n* @license Apache-2.0\n*\n* Copyright (c) 2023 The Stdlib Authors.\n*\n* Licensed under the Apache License, Version 2.0 (the \"License\");\n* you may not use this file except in compliance with the License.\n* You may obtain a copy of the License at\n*\n*    http://www.apache.org/licenses/LICENSE-2.0\n*\n* Unless required by applicable law or agreed to in writing, software\n* distributed under the License is distributed on an \"AS IS\" BASIS,\n* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n* See the License for the specific language governing permissions and\n* limitations under the License.\n*/\n\n'use strict';\n\n// MODULES //\n\nvar dtypes = require( '@stdlib/array-typed-real-float-dtypes' );\nvar isObject = require( '@stdlib/assert-is-plain-object' );\nvar hasOwnProp = require( '@stdlib/assert-has-own-property' );\nvar format = require( '@stdlib/string-format' );\n\n\n// VARIABLES //\n\nvar DTYPES = dtypes();\nDTYPES.push( 'generic' );\n\n\n// MAIN //\n\n/**\n* Validates function options.\n*\n* @private\n* @param {Object} opts - destination object\n* @param {Options} options - function options\n* @param {string} [options.dtype] - output array data type\n* @returns {(Error|null)} null or an error object\n*\n* @example\n* var opts = {};\n* var options = {\n*     'dtype': 'float64'\n* };\n* var err = validate( opts, options );\n* if ( err ) {\n*     throw err;\n* }\n*/\nfunction validate( opts, options ) {\n\tif ( !isObject( options ) ) {\n\t\treturn new TypeError( format( 'invalid argument. Options argument must be an object. Value: `%s`.', options ) );\n\t}\n\tif ( hasOwnProp( options, 'dtype' ) ) {\n\t\topts.dtype = options.dtype;\n\t\tif ( DTYPES.indexOf( opts.dtype ) < 0 ) {\n\t\t\treturn new TypeError( format( 'invalid option. `%s` option must be one of the following: \"%s\". Option: `%s`.', 'dtype', DTYPES.join( '\", \"' ), opts.dtype ) );\n\t\t}\n\t}\n\treturn null;\n}\n\n\n// EXPORTS //\n\nmodule.exports = validate;\n", "/**\n* @license Apache-2.0\n*\n* Copyright (c) 2023 The Stdlib Authors.\n*\n* Licensed under the Apache License, Version 2.0 (the \"License\");\n* you may not use this file except in compliance with the License.\n* You may obtain a copy of the License at\n*\n*    http://www.apache.org/licenses/LICENSE-2.0\n*\n* Unless required by applicable law or agreed to in writing, software\n* distributed under the License is distributed on an \"AS IS\" BASIS,\n* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n* See the License for the specific language governing permissions and\n* limitations under the License.\n*/\n\n'use strict';\n\n// MODULES //\n\nvar isNonNegativeInteger = require( '@stdlib/assert-is-nonnegative-integer' ).isPrimitive;\nvar setReadOnly = require( '@stdlib/utils-define-nonenumerable-read-only-property' );\nvar setReadOnlyAccessor = require( '@stdlib/utils-define-nonenumerable-read-only-accessor' );\nvar setReadWriteAccessor = require( '@stdlib/utils-define-nonenumerable-read-write-accessor' );\nvar constantFunction = require( '@stdlib/utils-constant-function' );\nvar noop = require( '@stdlib/utils-noop' );\nvar base = require( '@stdlib/random-base-invgamma' );\nvar ctors = require( '@stdlib/array-typed-real-float-ctors' );\nvar filledBy = require( '@stdlib/array-base-filled-by' );\nvar nullary = require( '@stdlib/strided-base-nullary' );\nvar binary = require( '@stdlib/strided-base-binary' );\nvar format = require( '@stdlib/string-format' );\nvar defaults = require( './defaults.json' );\nvar validate = require( './validate.js' );\n\n\n// MAIN //\n\n/**\n* Returns a function for creating arrays containing pseudorandom numbers drawn from an inverse gamma distribution.\n*\n* @param {PositiveNumber} [alpha] - shape parameter\n* @param {PositiveNumber} [beta] - scale parameter\n* @param {Options} [options] - function options\n* @param {PRNG} [options.prng] - pseudorandom number generator which generates uniformly distributed pseudorandom numbers\n* @param {PRNGSeedMT19937} [options.seed] - pseudorandom number generator seed\n* @param {PRNGStateMT19937} [options.state] - pseudorandom number generator state\n* @param {boolean} [options.copy=true] - boolean indicating whether to copy a provided pseudorandom number generator state\n* @param {string} [options.dtype=\"float64\"] - default data type\n* @throws {TypeError} `alpha` must be a positive number\n* @throws {TypeError} `beta` must be a positive number\n* @throws {TypeError} options argument must be an object\n* @throws {TypeError} must provide valid options\n* @throws {Error} must provide a valid state\n* @returns {Function} function for creating arrays\n*\n* @example\n* var invgamma = factory( 2.0, 5.0 );\n* // returns <Function>\n*\n* var arr = invgamma( 10 );\n* // returns <Float64Array>\n*\n* @example\n* var invgamma = factory( 2.0, 5.0 );\n* // returns <Function>\n*\n* var arr = invgamma( 10, {\n*     'dtype': 'generic'\n* });\n* // returns [...]\n*/\nfunction factory() {\n\tvar options;\n\tvar nargs;\n\tvar opts;\n\tvar rand;\n\tvar prng;\n\tvar err;\n\n\topts = {\n\t\t'dtype': defaults.dtype\n\t};\n\n\tnargs = arguments.length;\n\tif ( nargs === 0 ) {\n\t\tprng = base;\n\t\trand = invgamma2;\n\t} else if ( nargs === 1 ) {\n\t\toptions = arguments[ 0 ];\n\t\tprng = base.factory( options );\n\t\terr = validate( opts, options );\n\t\tif ( err ) {\n\t\t\tthrow err;\n\t\t}\n\t\trand = invgamma2;\n\t} else if ( nargs === 2 ) {\n\t\tprng = base.factory( arguments[ 0 ], arguments[ 1 ] );\n\t\trand = invgamma1;\n\t} else if ( nargs === 3 ) {\n\t\toptions = arguments[ 2 ];\n\t\tprng = base.factory( arguments[ 0 ], arguments[ 1 ], options );\n\t\terr = validate( opts, options );\n\t\tif ( err ) {\n\t\t\tthrow err;\n\t\t}\n\t\trand = invgamma1;\n\t}\n\tif ( options && options.prng ) {\n\t\tsetReadOnly( rand, 'seed', null );\n\t\tsetReadOnly( rand, 'seedLength', null );\n\t\tsetReadWriteAccessor( rand, 'state', constantFunction( null ), noop );\n\t\tsetReadOnly( rand, 'stateLength', null );\n\t\tsetReadOnly( rand, 'byteLength', null );\n\t} else {\n\t\tsetReadOnlyAccessor( rand, 'seed', getSeed );\n\t\tsetReadOnlyAccessor( rand, 'seedLength', getSeedLength );\n\t\tsetReadWriteAccessor( rand, 'state', getState, setState );\n\t\tsetReadOnlyAccessor( rand, 'stateLength', getStateLength );\n\t\tsetReadOnlyAccessor( rand, 'byteLength', getStateSize );\n\t}\n\tsetReadOnly( rand, 'PRNG', prng.PRNG );\n\treturn rand;\n\n\t/**\n\t* Returns an array containing pseudorandom numbers drawn from an inverse gamma distribution with parameters `alpha` (shape parameter) and `beta` (scale parameter).\n\t*\n\t* @private\n\t* @param {NonNegativeInteger} len - array length\n\t* @param {Options} [options] - function options\n\t* @param {string} [options.dtype] - output array data type\n\t* @throws {TypeError} first argument must be a nonnegative integer\n\t* @throws {TypeError} options argument must be an object\n\t* @throws {TypeError} must provide valid options\n\t* @returns {(Array|TypedArray)} output array\n\t*/\n\tfunction invgamma1( len, options ) {\n\t\tvar ctor;\n\t\tvar out;\n\t\tvar err;\n\t\tvar dt;\n\t\tvar o;\n\t\tif ( !isNonNegativeInteger( len ) ) {\n\t\t\tthrow new TypeError( format( 'invalid argument. First argument must be a nonnegative integer. Value: `%s`.', len ) );\n\t\t}\n\t\to = {};\n\t\tif ( arguments.length > 1 ) {\n\t\t\terr = validate( o, options );\n\t\t\tif ( err ) {\n\t\t\t\tthrow err;\n\t\t\t}\n\t\t}\n\t\tdt = o.dtype || opts.dtype;\n\t\tif ( dt === 'generic' ) {\n\t\t\treturn filledBy( len, prng );\n\t\t}\n\t\tctor = ctors( dt );\n\t\tout = new ctor( len );\n\t\tnullary( [ out ], [ len ], [ 1 ], prng );\n\t\treturn out;\n\t}\n\n\t/**\n\t* Returns an array containing pseudorandom numbers drawn from an inverse gamma distribution with parameters `alpha` (shape parameter) and `beta` (scale parameter).\n\t*\n\t* @private\n\t* @param {NonNegativeInteger} len - array length\n\t* @param {PositiveNumber} alpha - shape parameter\n\t* @param {PositiveNumber} beta - scale parameter\n\t* @param {Options} [options] - function options\n\t* @param {string} [options.dtype] - output array data type\n\t* @throws {TypeError} first argument must be a nonnegative integer\n\t* @throws {TypeError} options argument must be an object\n\t* @throws {TypeError} must provide valid options\n\t* @returns {(Array|TypedArray)} output array\n\t*/\n\tfunction invgamma2( len, alpha, beta, options ) {\n\t\tvar ctor;\n\t\tvar out;\n\t\tvar err;\n\t\tvar dt;\n\t\tvar o;\n\t\tif ( !isNonNegativeInteger( len ) ) {\n\t\t\tthrow new TypeError( format( 'invalid argument. First argument must be a nonnegative integer. Value: `%s`.', len ) );\n\t\t}\n\t\to = {};\n\t\tif ( arguments.length > 3 ) {\n\t\t\terr = validate( o, options );\n\t\t\tif ( err ) {\n\t\t\t\tthrow err;\n\t\t\t}\n\t\t}\n\t\t// NOTE: we could alternatively use the PRNG factory function to create a PRNG function which applies parameters for each invocation; however, this would impose a one-time cost which is likely to be rather expensive when generating small arrays. Decision made here to avoid this cost, despite a small cost due to repeatedly validating parameters for each generated pseudorandom number. Additionally, the current implementation has the added benefit that it mirrors the underlying PRNG where invalid parameters result in a return value of `NaN`.\n\t\tdt = o.dtype || opts.dtype;\n\t\tif ( dt === 'generic' ) {\n\t\t\treturn filledBy( len, wrapper );\n\t\t}\n\t\tctor = ctors( dt );\n\t\tout = new ctor( len );\n\t\tbinary( [ [ alpha ], [ beta ], out ], [ len ], [ 0, 0, 1 ], prng );\n\t\treturn out;\n\n\t\t/**\n\t\t* Applies parameters to a pseudorandom number generator function.\n\t\t*\n\t\t* @private\n\t\t* @returns {number} pseudorandom number\n\t\t*/\n\t\tfunction wrapper() {\n\t\t\treturn prng( alpha, beta );\n\t\t}\n\t}\n\n\t/**\n\t* Returns the PRNG seed.\n\t*\n\t* @private\n\t* @returns {PRNGSeedMT19937} seed\n\t*/\n\tfunction getSeed() {\n\t\treturn rand.PRNG.seed;\n\t}\n\n\t/**\n\t* Returns the PRNG seed length.\n\t*\n\t* @private\n\t* @returns {PositiveInteger} seed length\n\t*/\n\tfunction getSeedLength() {\n\t\treturn rand.PRNG.seedLength;\n\t}\n\n\t/**\n\t* Returns the PRNG state length.\n\t*\n\t* @private\n\t* @returns {PositiveInteger} state length\n\t*/\n\tfunction getStateLength() {\n\t\treturn rand.PRNG.stateLength;\n\t}\n\n\t/**\n\t* Returns the PRNG state size (in bytes).\n\t*\n\t* @private\n\t* @returns {PositiveInteger} state size (in bytes)\n\t*/\n\tfunction getStateSize() {\n\t\treturn rand.PRNG.byteLength;\n\t}\n\n\t/**\n\t* Returns the current pseudorandom number generator state.\n\t*\n\t* @private\n\t* @returns {PRNGStateMT19937} current state\n\t*/\n\tfunction getState() {\n\t\treturn rand.PRNG.state;\n\t}\n\n\t/**\n\t* Sets the pseudorandom number generator state.\n\t*\n\t* @private\n\t* @param {PRNGStateMT19937} s - generator state\n\t* @throws {Error} must provide a valid state\n\t*/\n\tfunction setState( s ) {\n\t\trand.PRNG.state = s;\n\t}\n}\n\n\n// EXPORTS //\n\nmodule.exports = factory;\n", "/**\n* @license Apache-2.0\n*\n* Copyright (c) 2023 The Stdlib Authors.\n*\n* Licensed under the Apache License, Version 2.0 (the \"License\");\n* you may not use this file except in compliance with the License.\n* You may obtain a copy of the License at\n*\n*    http://www.apache.org/licenses/LICENSE-2.0\n*\n* Unless required by applicable law or agreed to in writing, software\n* distributed under the License is distributed on an \"AS IS\" BASIS,\n* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n* See the License for the specific language governing permissions and\n* limitations under the License.\n*/\n\n'use strict';\n\n// MODULES //\n\nvar factory = require( './factory.js' );\n\n\n// MAIN //\n\n/**\n* Returns an array containing pseudorandom numbers drawn from an inverse gamma distribution with parameters `alpha` (shape parameter) and `beta` (scale parameter).\n*\n* @name invgamma\n* @type {Function}\n* @param {NonNegativeInteger} len - array length\n* @param {PositiveNumber} alpha - shape parameter\n* @param {PositiveNumber} beta - scale parameter\n* @param {Options} [options] - options\n* @param {string} [options.dtype=\"float64\"] - output array data type\n* @throws {TypeError} first argument must be a nonnegative integer\n* @throws {TypeError} options argument must be an object\n* @throws {TypeError} must provide valid options\n* @returns {(Array|TypedArray)} output array\n*\n* @example\n* var arr = invgamma( 10, 2.0, 5.0 );\n* // returns <Float64Array>\n*\n* @example\n* var arr = invgamma( 10, 2.0, 5.0, {\n*     'dtype': 'generic'\n* });\n* // returns [...]\n*/\nvar invgamma = factory();\n\n\n// EXPORTS //\n\nmodule.exports = invgamma;\n", "/**\n* @license Apache-2.0\n*\n* Copyright (c) 2023 The Stdlib Authors.\n*\n* Licensed under the Apache License, Version 2.0 (the \"License\");\n* you may not use this file except in compliance with the License.\n* You may obtain a copy of the License at\n*\n*    http://www.apache.org/licenses/LICENSE-2.0\n*\n* Unless required by applicable law or agreed to in writing, software\n* distributed under the License is distributed on an \"AS IS\" BASIS,\n* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n* See the License for the specific language governing permissions and\n* limitations under the License.\n*/\n\n'use strict';\n\n/**\n* Create an array containing pseudorandom numbers drawn from an inverse gamma distribution with parameters `alpha` (shape parameter) and `beta` (scale parameter).\n*\n* @module @stdlib/random-array-invgamma\n*\n* @example\n* var invgamma = require( '@stdlib/random-array-invgamma' );\n*\n* var arr = invgamma( 10, 2.0, 5.0 );\n* // returns <Float64Array>\n*\n* @example\n* var invgamma = require( '@stdlib/random-array-invgamma' );\n*\n* var arr = invgamma( 10, 2.0, 5.0, {\n*     'dtype': 'generic'\n* });\n* // returns [...]\n*\n* @example\n* var invgamma = require( '@stdlib/random-array-invgamma' );\n*\n* var rand = invgamma.factory( 2.0, 5.0 );\n* // returns <Function>\n*\n* var arr = rand( 10 );\n* // returns <Float64Array>\n*\n* @example\n* var invgamma = require( '@stdlib/random-array-invgamma' );\n*\n* var rand = invgamma.factory( 2.0, 5.0 );\n* // returns <Function>\n*\n* var arr = rand( 10, {\n*     'dtype': 'generic'\n* });\n* // returns [...]\n*/\n\n// MODULES //\n\nvar setReadOnly = require( '@stdlib/utils-define-nonenumerable-read-only-property' );\nvar main = require( './main.js' );\nvar factory = require( './factory.js' );\n\n\n// MAIN //\n\nsetReadOnly( main, 'factory', factory );\n\n\n// EXPORTS //\n\nmodule.exports = main;\n\n// exports: { \"factory\": \"main.factory\" }\n"],
+  "mappings": "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",
+  "names": ["require_defaults", "__commonJSMin", "exports", "module", "require_validate", "__commonJSMin", "exports", "module", "dtypes", "isObject", "hasOwnProp", "format", "DTYPES", "validate", "opts", "options", "require_factory", "__commonJSMin", "exports", "module", "isNonNegativeInteger", "setReadOnly", "setReadOnlyAccessor", "setReadWriteAccessor", "constantFunction", "noop", "base", "ctors", "filledBy", "nullary", "binary", "format", "defaults", "validate", "factory", "options", "nargs", "opts", "rand", "prng", "err", "invgamma2", "invgamma1", "getSeed", "getSeedLength", "getState", "setState", "getStateLength", "getStateSize", "len", "ctor", "out", "dt", "o", "alpha", "beta", "wrapper", "s", "require_main", "__commonJSMin", "exports", "module", "factory", "invgamma", "setReadOnly", "main", "factory"]
+}

package/docs/types/index.d.ts

@@ -0,0 +1,246 @@
+/*
+* @license Apache-2.0
+*
+* Copyright (c) 2023 The Stdlib Authors.
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+*    http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+
+// TypeScript Version: 4.1
+
+/// <reference types="@stdlib/types"/>
+
+import { FloatDataType, FloatTypedArray } from '@stdlib/types/array';
+import * as random from '@stdlib/types/random';
+
+/**
+* Supported data types.
+*/
+type DataType = FloatDataType | 'generic';
+
+/**
+* Output array.
+*/
+type RandomArray = FloatTypedArray | Array<number>;
+
+/**
+* Interface defining PRNG options.
+*/
+interface PRNGOptions {
+	/**
+	* Pseudorandom number generator which generates uniformly distributed pseudorandom numbers.
+	*/
+	prng?: random.PRNG;
+
+	/**
+	* Pseudorandom number generator seed.
+	*/
+	seed?: random.PRNGSeedMT19937;
+
+	/**
+	* Pseudorandom number generator state.
+	*/
+	state?: random.PRNGStateMT19937;
+
+	/**
+	* Specifies whether to copy a provided pseudorandom number generator state. Default: true.
+	*/
+	copy?: boolean;
+}
+
+/**
+* Interface defining factory options.
+*/
+interface FactoryOptions extends PRNGOptions {
+	/**
+	* Default output array data type. Default: 'float64'.
+	*/
+	dtype?: DataType;
+}
+
+/**
+* Interface defining options.
+*/
+interface Options {
+	/**
+	* Output array data type.
+	*/
+	dtype?: DataType;
+}
+
+/**
+* Interface for PRNG properties and methods.
+*/
+interface PRNG {
+	/**
+	* Underlying pseudorandom number generator.
+	*/
+	readonly PRNG: random.PRNG;
+
+	/**
+	* PRNG seed.
+	*/
+	readonly seed: random.PRNGSeedMT19937 | null;
+
+	/**
+	* PRNG seed length.
+	*/
+	readonly seedLength: number | null;
+
+	/**
+	* PRNG state.
+	*/
+	state: random.PRNGStateMT19937 | null;
+
+	/**
+	* PRNG state length.
+	*/
+	readonly stateLength: number | null;
+
+	/**
+	* PRNG state size (in bytes).
+	*/
+	readonly byteLength: number | null;
+}
+
+/**
+* Interface for generating pseudorandom numbers drawn from an inverse gamma distribution with pre-specified parameter values.
+*/
+interface UnaryFunction extends PRNG {
+	/**
+	* Returns an array containing pseudorandom numbers drawn from an inverse gamma distribution with parameters `alpha` (shape parameter) and `beta` (scale parameter).
+	*
+	* @param len - array length
+	* @param options - function options
+	* @returns output array
+	*/
+	( len: number, options?: Options ): RandomArray;
+}
+
+/**
+* Interface for generating pseudorandom numbers drawn from an inverse gamma distribution without pre-specified parameter values.
+*/
+interface TernaryFunction extends PRNG {
+	/**
+	* Returns an array containing pseudorandom numbers drawn from an inverse gamma distribution with parameters `alpha` (shape parameter) and `beta` (scale parameter).
+	*
+	* @param len - array length
+	* @param alpha - shape parameter
+	* @param beta - scale parameter
+	* @param options - function options
+	* @returns output array
+	*/
+	( len: number, alpha: number, beta: number, options?: Options ): RandomArray; // tslint:disable-line: max-line-length
+}
+
+/**
+* Interface for generating pseudorandom numbers drawn from an inverse gamma distribution.
+*/
+interface Random extends PRNG {
+	/**
+	* Returns an array containing pseudorandom numbers drawn from an inverse gamma distribution with parameters `alpha` (shape parameter) and `beta` (scale parameter).
+	*
+	* @param len - array length
+	* @param alpha - shape parameter
+	* @param beta - scale parameter
+	* @param options - function options
+	* @returns output array
+	*
+	* @example
+	* var out = invgamma( 10, 2.0, 5.0 );
+	* // returns <Float64Array>
+	*/
+	( len: number, alpha: number, beta: number, options?: Options ): RandomArray; // tslint:disable-line: max-line-length
+
+	/**
+	* Returns a function for creating arrays containing pseudorandom numbers drawn from an inverse gamma distribution.
+	*
+	* ## Notes
+	*
+	* -   When provided `alpha` and `beta`, the returned function returns random variates drawn from the specified distribution.
+	*
+	* @param alpha - shape parameter
+	* @param beta - scale parameter
+	* @param options - function options
+	* @throws `alpha` must be a positive number
+	* @throws `beta` must be a positive number
+	* @throws must provide a valid state
+	* @returns function for creating arrays
+	*
+	* @example
+	* var random = invgamma.factory( 2.0, 5.0 );
+	*
+	* var out = random( 10 );
+	* // returns <Float64Array>
+	*
+	* @example
+	* var random = invgamma.factory( 2.0, 5.0, {
+	*     'seed': 297
+	* });
+	* var out = random( 10 );
+	* // returns <Float64Array>
+	*/
+	factory( alpha: number, beta: number, options?: FactoryOptions ): UnaryFunction; // tslint:disable-line: max-line-length
+
+	/**
+	* Returns a function for creating arrays containing pseudorandom numbers drawn from an inverse gamma distribution.
+	*
+	* ## Notes
+	*
+	* -   When not provided `alpha` and `beta`, the returned function requires that both `alpha` and `beta` be provided at each invocation.
+	*
+	* @param options - function options
+	* @throws must provide a valid state
+	* @returns function for creating arrays
+	*
+	* @example
+	* var random = beta.factory();
+	*
+	* var out = random( 10, 2.0, 5.0 );
+	* // returns <Float64Array>
+	*
+	* @example
+	* var random = beta.factory({
+	*     'seed': 297
+	* });
+	* var out = random( 10, 2.0, 5.0 );
+	* // returns <Float64Array>
+	*/
+	factory( options?: FactoryOptions ): TernaryFunction;
+}
+
+/**
+* Returns an array containing pseudorandom numbers drawn from an inverse gamma distribution with parameters `alpha` (shape parameter) and `beta` (scale parameter).
+*
+* @param len - array length
+* @param alpha - shape parameter
+* @param beta - scale parameter
+* @param options - function options
+* @returns output array
+*
+* @example
+* var out = invgamma( 10, 2.0, 5.0 );
+* // returns <Float64Array>
+*
+* @example
+* var random = invgamma.factory( 2.0, 5.0 );
+*
+* var out = random( 10 );
+* // returns <Float64Array>
+*/
+declare var invgamma: Random;
+
+
+// EXPORTS //
+
+export = invgamma;

package/lib/defaults.json

@@ -0,0 +1,3 @@
+{
+	"dtype": "float64"
+}

package/lib/factory.js

@@ -0,0 +1,281 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2023 The Stdlib Authors.
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+*    http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+
+'use strict';
+
+// MODULES //
+
+var isNonNegativeInteger = require( '@stdlib/assert-is-nonnegative-integer' ).isPrimitive;
+var setReadOnly = require( '@stdlib/utils-define-nonenumerable-read-only-property' );
+var setReadOnlyAccessor = require( '@stdlib/utils-define-nonenumerable-read-only-accessor' );
+var setReadWriteAccessor = require( '@stdlib/utils-define-nonenumerable-read-write-accessor' );
+var constantFunction = require( '@stdlib/utils-constant-function' );
+var noop = require( '@stdlib/utils-noop' );
+var base = require( '@stdlib/random-base-invgamma' );
+var ctors = require( '@stdlib/array-typed-real-float-ctors' );
+var filledBy = require( '@stdlib/array-base-filled-by' );
+var nullary = require( '@stdlib/strided-base-nullary' );
+var binary = require( '@stdlib/strided-base-binary' );
+var format = require( '@stdlib/string-format' );
+var defaults = require( './defaults.json' );
+var validate = require( './validate.js' );
+
+
+// MAIN //
+
+/**
+* Returns a function for creating arrays containing pseudorandom numbers drawn from an inverse gamma distribution.
+*
+* @param {PositiveNumber} [alpha] - shape parameter
+* @param {PositiveNumber} [beta] - scale parameter
+* @param {Options} [options] - function options
+* @param {PRNG} [options.prng] - pseudorandom number generator which generates uniformly distributed pseudorandom numbers
+* @param {PRNGSeedMT19937} [options.seed] - pseudorandom number generator seed
+* @param {PRNGStateMT19937} [options.state] - pseudorandom number generator state
+* @param {boolean} [options.copy=true] - boolean indicating whether to copy a provided pseudorandom number generator state
+* @param {string} [options.dtype="float64"] - default data type
+* @throws {TypeError} `alpha` must be a positive number
+* @throws {TypeError} `beta` must be a positive number
+* @throws {TypeError} options argument must be an object
+* @throws {TypeError} must provide valid options
+* @throws {Error} must provide a valid state
+* @returns {Function} function for creating arrays
+*
+* @example
+* var invgamma = factory( 2.0, 5.0 );
+* // returns <Function>
+*
+* var arr = invgamma( 10 );
+* // returns <Float64Array>
+*
+* @example
+* var invgamma = factory( 2.0, 5.0 );
+* // returns <Function>
+*
+* var arr = invgamma( 10, {
+*     'dtype': 'generic'
+* });
+* // returns [...]
+*/
+function factory() {
+	var options;
+	var nargs;
+	var opts;
+	var rand;
+	var prng;
+	var err;
+
+	opts = {
+		'dtype': defaults.dtype
+	};
+
+	nargs = arguments.length;
+	if ( nargs === 0 ) {
+		prng = base;
+		rand = invgamma2;
+	} else if ( nargs === 1 ) {
+		options = arguments[ 0 ];
+		prng = base.factory( options );
+		err = validate( opts, options );
+		if ( err ) {
+			throw err;
+		}
+		rand = invgamma2;
+	} else if ( nargs === 2 ) {
+		prng = base.factory( arguments[ 0 ], arguments[ 1 ] );
+		rand = invgamma1;
+	} else if ( nargs === 3 ) {
+		options = arguments[ 2 ];
+		prng = base.factory( arguments[ 0 ], arguments[ 1 ], options );
+		err = validate( opts, options );
+		if ( err ) {
+			throw err;
+		}
+		rand = invgamma1;
+	}
+	if ( options && options.prng ) {
+		setReadOnly( rand, 'seed', null );
+		setReadOnly( rand, 'seedLength', null );
+		setReadWriteAccessor( rand, 'state', constantFunction( null ), noop );
+		setReadOnly( rand, 'stateLength', null );
+		setReadOnly( rand, 'byteLength', null );
+	} else {
+		setReadOnlyAccessor( rand, 'seed', getSeed );
+		setReadOnlyAccessor( rand, 'seedLength', getSeedLength );
+		setReadWriteAccessor( rand, 'state', getState, setState );
+		setReadOnlyAccessor( rand, 'stateLength', getStateLength );
+		setReadOnlyAccessor( rand, 'byteLength', getStateSize );
+	}
+	setReadOnly( rand, 'PRNG', prng.PRNG );
+	return rand;
+
+	/**
+	* Returns an array containing pseudorandom numbers drawn from an inverse gamma distribution with parameters `alpha` (shape parameter) and `beta` (scale parameter).
+	*
+	* @private
+	* @param {NonNegativeInteger} len - array length
+	* @param {Options} [options] - function options
+	* @param {string} [options.dtype] - output array data type
+	* @throws {TypeError} first argument must be a nonnegative integer
+	* @throws {TypeError} options argument must be an object
+	* @throws {TypeError} must provide valid options
+	* @returns {(Array|TypedArray)} output array
+	*/
+	function invgamma1( len, options ) {
+		var ctor;
+		var out;
+		var err;
+		var dt;
+		var o;
+		if ( !isNonNegativeInteger( len ) ) {
+			throw new TypeError( format( 'invalid argument. First argument must be a nonnegative integer. Value: `%s`.', len ) );
+		}
+		o = {};
+		if ( arguments.length > 1 ) {
+			err = validate( o, options );
+			if ( err ) {
+				throw err;
+			}
+		}
+		dt = o.dtype || opts.dtype;
+		if ( dt === 'generic' ) {
+			return filledBy( len, prng );
+		}
+		ctor = ctors( dt );
+		out = new ctor( len );
+		nullary( [ out ], [ len ], [ 1 ], prng );
+		return out;
+	}
+
+	/**
+	* Returns an array containing pseudorandom numbers drawn from an inverse gamma distribution with parameters `alpha` (shape parameter) and `beta` (scale parameter).
+	*
+	* @private
+	* @param {NonNegativeInteger} len - array length
+	* @param {PositiveNumber} alpha - shape parameter
+	* @param {PositiveNumber} beta - scale parameter
+	* @param {Options} [options] - function options
+	* @param {string} [options.dtype] - output array data type
+	* @throws {TypeError} first argument must be a nonnegative integer
+	* @throws {TypeError} options argument must be an object
+	* @throws {TypeError} must provide valid options
+	* @returns {(Array|TypedArray)} output array
+	*/
+	function invgamma2( len, alpha, beta, options ) {
+		var ctor;
+		var out;
+		var err;
+		var dt;
+		var o;
+		if ( !isNonNegativeInteger( len ) ) {
+			throw new TypeError( format( 'invalid argument. First argument must be a nonnegative integer. Value: `%s`.', len ) );
+		}
+		o = {};
+		if ( arguments.length > 3 ) {
+			err = validate( o, options );
+			if ( err ) {
+				throw err;
+			}
+		}
+		// NOTE: we could alternatively use the PRNG factory function to create a PRNG function which applies parameters for each invocation; however, this would impose a one-time cost which is likely to be rather expensive when generating small arrays. Decision made here to avoid this cost, despite a small cost due to repeatedly validating parameters for each generated pseudorandom number. Additionally, the current implementation has the added benefit that it mirrors the underlying PRNG where invalid parameters result in a return value of `NaN`.
+		dt = o.dtype || opts.dtype;
+		if ( dt === 'generic' ) {
+			return filledBy( len, wrapper );
+		}
+		ctor = ctors( dt );
+		out = new ctor( len );
+		binary( [ [ alpha ], [ beta ], out ], [ len ], [ 0, 0, 1 ], prng );
+		return out;
+
+		/**
+		* Applies parameters to a pseudorandom number generator function.
+		*
+		* @private
+		* @returns {number} pseudorandom number
+		*/
+		function wrapper() {
+			return prng( alpha, beta );
+		}
+	}
+
+	/**
+	* Returns the PRNG seed.
+	*
+	* @private
+	* @returns {PRNGSeedMT19937} seed
+	*/
+	function getSeed() {
+		return rand.PRNG.seed;
+	}
+
+	/**
+	* Returns the PRNG seed length.
+	*
+	* @private
+	* @returns {PositiveInteger} seed length
+	*/
+	function getSeedLength() {
+		return rand.PRNG.seedLength;
+	}
+
+	/**
+	* Returns the PRNG state length.
+	*
+	* @private
+	* @returns {PositiveInteger} state length
+	*/
+	function getStateLength() {
+		return rand.PRNG.stateLength;
+	}
+
+	/**
+	* Returns the PRNG state size (in bytes).
+	*
+	* @private
+	* @returns {PositiveInteger} state size (in bytes)
+	*/
+	function getStateSize() {
+		return rand.PRNG.byteLength;
+	}
+
+	/**
+	* Returns the current pseudorandom number generator state.
+	*
+	* @private
+	* @returns {PRNGStateMT19937} current state
+	*/
+	function getState() {
+		return rand.PRNG.state;
+	}
+
+	/**
+	* Sets the pseudorandom number generator state.
+	*
+	* @private
+	* @param {PRNGStateMT19937} s - generator state
+	* @throws {Error} must provide a valid state
+	*/
+	function setState( s ) {
+		rand.PRNG.state = s;
+	}
+}
+
+
+// EXPORTS //
+
+module.exports = factory;

package/lib/index.js

@@ -0,0 +1,77 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2023 The Stdlib Authors.
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+*    http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+
+'use strict';
+
+/**
+* Create an array containing pseudorandom numbers drawn from an inverse gamma distribution with parameters `alpha` (shape parameter) and `beta` (scale parameter).
+*
+* @module @stdlib/random-array-invgamma
+*
+* @example
+* var invgamma = require( '@stdlib/random-array-invgamma' );
+*
+* var arr = invgamma( 10, 2.0, 5.0 );
+* // returns <Float64Array>
+*
+* @example
+* var invgamma = require( '@stdlib/random-array-invgamma' );
+*
+* var arr = invgamma( 10, 2.0, 5.0, {
+*     'dtype': 'generic'
+* });
+* // returns [...]
+*
+* @example
+* var invgamma = require( '@stdlib/random-array-invgamma' );
+*
+* var rand = invgamma.factory( 2.0, 5.0 );
+* // returns <Function>
+*
+* var arr = rand( 10 );
+* // returns <Float64Array>
+*
+* @example
+* var invgamma = require( '@stdlib/random-array-invgamma' );
+*
+* var rand = invgamma.factory( 2.0, 5.0 );
+* // returns <Function>
+*
+* var arr = rand( 10, {
+*     'dtype': 'generic'
+* });
+* // returns [...]
+*/
+
+// MODULES //
+
+var setReadOnly = require( '@stdlib/utils-define-nonenumerable-read-only-property' );
+var main = require( './main.js' );
+var factory = require( './factory.js' );
+
+
+// MAIN //
+
+setReadOnly( main, 'factory', factory );
+
+
+// EXPORTS //
+
+module.exports = main;
+
+// exports: { "factory": "main.factory" }