File: data.csv

package info (click to toggle)
node-stdlib 0.0.96%2Bds1%2B~cs0.0.429-2
links: PTS, VCS
area: main
in suites: forky, sid, trixie
size: 421,476 kB
sloc: javascript: 1,562,831; ansic: 109,702; lisp: 49,823; cpp: 27,224; python: 7,871; sh: 6,807; makefile: 6,089; fortran: 3,102; awk: 387
file content (4178 lines) | stat: -rw-r--r-- 758,964 bytes
abs,"\nabs( x:ndarray|ArrayLikeObject|number[, options:Object] )\n    Computes the absolute value.\n"
abs.assign,"\nabs.assign( x:ndarray|ArrayLikeObject, y:ndarray|ArrayLikeObject )\n    Computes the absolute value and assigns results to a provided output array.\n"
AFINN_96,"\nAFINN_96()\n    Returns a list of English words rated for valence.\n"
AFINN_111,"\nAFINN_111()\n    Returns a list of English words rated for valence.\n"
alias2pkg,"\nalias2pkg( alias:string )\n    Returns the package name associated with a provided alias.\n"
alias2related,"\nalias2related( alias:string )\n    Returns aliases related to a specified alias.\n"
alias2standalone,"\nalias2standalone( alias:string )\n    Returns the standalone package name associated with a provided alias.\n"
aliases,"\naliases( [namespace:string] )\n    Returns a list of standard library aliases.\n"
allocUnsafe,"\nallocUnsafe( size:integer )\n    Allocates a buffer having a specified number of bytes.\n"
anova1,"\nanova1( x:Array<number>, factor:Array[, options:Object] )\n    Performs a one-way analysis of variance.\n"
ANSCOMBES_QUARTET,"\nANSCOMBES_QUARTET()\n    Returns Anscombe's quartet.\n"
any,"\nany( collection:Array|TypedArray|Object )\n    Tests whether at least one element in a collection is truthy.\n"
anyBy,"\nanyBy( collection:Array|TypedArray|Object, predicate:Function[, thisArg:any ] )\n    Tests whether at least one element in a collection passes a test implemented\n    by a predicate function.\n"
anyByAsync,"\nanyByAsync( collection:Array|TypedArray|Object, [options:Object,] \n  predicate:Function, done:Function )\n    Tests whether at least one element in a collection passes a test implemented\n    by a predicate function.\n"
anyByAsync.factory,"\nanyByAsync.factory( [options:Object,] predicate:Function )\n    Returns a function which tests whether at least one element in a collection\n    passes a test implemented by a predicate function.\n"
anyByRight,"\nanyByRight( collection:Array|TypedArray|Object, predicate:Function[, \n  thisArg:any ] )\n    Tests whether at least one element in a collection passes a test implemented\n    by a predicate function, iterating from right to left.\n"
anyByRightAsync,"\nanyByRightAsync( collection:Array|TypedArray|Object, [options:Object,] \n  predicate:Function, done:Function )\n    Tests whether at least one element in a collection passes a test implemented\n    by a predicate function, iterating from right to left.\n"
anyByRightAsync.factory,"\nanyByRightAsync.factory( [options:Object,] predicate:Function )\n    Returns a function which tests whether at least one element in a collection\n    passes a test implemented by a predicate function, iterating from right to\n    left.\n"
APERY,"\nAPERY\n    Apéry's constant.\n"
append,"\nappend( collection1:Array|TypedArray|Object, \n  collection2:Array|TypedArray|Object )\n    Adds the elements of one collection to the end of another collection.\n"
ARCH,"\nARCH\n    Operating system CPU architecture.\n"
argumentFunction,"\nargumentFunction( idx:integer )\n    Returns a function which always returns a specified argument.\n"
ARGV,"\nARGV\n    An array containing command-line arguments passed when launching the calling\n    process.\n"
array,"\narray( [buffer:Array|TypedArray|Buffer|ndarray,] [options:Object] )\n    Returns a multidimensional array.\n"
array2buffer,"\narray2buffer( arr:Array<integer> )\n    Allocates a buffer using an octet array.\n"
array2iterator,"\narray2iterator( src:ArrayLikeObject[, mapFcn:Function[, thisArg:any]] )\n    Returns an iterator which iterates over the elements of an array-like\n    object.\n"
array2iteratorRight,"\narray2iteratorRight( src:ArrayLikeObject[, mapFcn:Function[, thisArg:any]] )\n    Returns an iterator which iterates from right to left over the elements of\n    an array-like object.\n"
ArrayBuffer,"\nArrayBuffer( size:integer )\n    Returns an array buffer having a specified number of bytes.\n"
ArrayBuffer.length,"\nArrayBuffer.length\n    Number of input arguments the constructor accepts.\n"
ArrayBuffer.isView,"\nArrayBuffer.isView( arr:any )\n    Returns a boolean indicating if provided an array buffer view.\n"
ArrayBuffer.prototype.byteLength,"\nArrayBuffer.prototype.byteLength\n    Read-only property which returns the length (in bytes) of the array buffer.\n"
ArrayBuffer.prototype.slice,"\nArrayBuffer.prototype.slice( [start:integer[, end:integer]] )\n    Copies the bytes of an array buffer to a new array buffer.\n"
arraybuffer2buffer,"\narraybuffer2buffer( buf:ArrayBuffer[, byteOffset:integer[, length:integer]] )\n    Allocates a buffer from an ArrayBuffer.\n"
arrayCtors,"\narrayCtors( dtype:string )\n    Returns an array constructor.\n"
arrayDataType,"\narrayDataType( array:any )\n    Returns the data type of an array.\n"
arrayDataTypes,"\narrayDataTypes()\n    Returns a list of array data types.\n"
arrayMinDataType,"\narrayMinDataType( value:any )\n    Returns the minimum array data type of the closest \"kind\" necessary for\n    storing a provided scalar value.\n"
arrayNextDataType,"\narrayNextDataType( [dtype:string] )\n    Returns the next larger array data type of the same kind.\n"
arrayPromotionRules,"\narrayPromotionRules( [dtype1:string, dtype2:string] )\n    Returns the array data type with the smallest size and closest \"kind\" to\n    which array data types can be safely cast.\n"
arraySafeCasts,"\narraySafeCasts( [dtype:string] )\n    Returns a list of array data types to which a provided array data type can\n    be safely cast.\n"
arraySameKindCasts,"\narraySameKindCasts( [dtype:string] )\n    Returns a list of array data types to which a provided array data type can\n    be safely cast or cast within the same \"kind\".\n"
arrayShape,"\narrayShape( arr:Array )\n    Determines array dimensions.\n"
arrayStream,"\narrayStream( src:ArrayLikeObject[, options:Object] )\n    Creates a readable stream from an array-like object.\n"
arrayStream.factory,"\narrayStream.factory( [options:Object] )\n    Returns a function for creating readable streams from array-like objects.\n"
arrayStream.objectMode,"\narrayStream.objectMode( src:ArrayLikeObject[, options:Object] )\n    Returns an \"objectMode\" readable stream from an array-like object.\n"
arrayview2iterator,"\narrayview2iterator( src:ArrayLikeObject[, begin:integer[, end:integer]][, \n  mapFcn:Function[, thisArg:any]] )\n    Returns an iterator which iterates over the elements of an array-like\n    object view.\n"
arrayview2iteratorRight,"\narrayview2iteratorRight( src:ArrayLikeObject[, begin:integer[, end:integer]][, \n  mapFcn:Function[, thisArg:any]] )\n    Returns an iterator which iterates from right to left over the elements of\n    an array-like object view.\n"
AsyncIteratorSymbol,"\nAsyncIteratorSymbol\n    Async iterator symbol.\n"
bartlettTest,"\nbartlettTest( ...x:Array[, options:Object] )\n    Computes Bartlett’s test for equal variances.\n"
base.abs,"\nbase.abs( x:number )\n    Computes the absolute value of a double-precision floating-point number `x`.\n"
base.abs2,"\nbase.abs2( x:number )\n    Computes the squared absolute value of a double-precision floating-point\n    `x`.\n"
base.abs2f,"\nbase.abs2f( x:number )\n    Computes the squared absolute value of a single-precision floating-point\n    `x`.\n"
base.absdiff,"\nbase.absdiff( x:number, y:number )\n    Computes the absolute difference.\n"
base.absf,"\nbase.absf( x:number )\n    Computes the absolute value of a single-precision floating-point number `x`.\n"
base.acos,"\nbase.acos( x:number )\n    Compute the arccosine of a number.\n"
base.acosh,"\nbase.acosh( x:number )\n    Computes the hyperbolic arccosine of a number.\n"
base.acot,"\nbase.acot( x:number )\n    Computes the inverse cotangent of a number.\n"
base.acoth,"\nbase.acoth( x:number )\n    Computes the inverse hyperbolic cotangent of a number.\n"
base.acovercos,"\nbase.acovercos( x:number )\n    Computes the inverse coversed cosine.\n"
base.acoversin,"\nbase.acoversin( x:number )\n    Computes the inverse coversed sine.\n"
base.ahavercos,"\nbase.ahavercos( x:number )\n    Computes the inverse half-value versed cosine.\n"
base.ahaversin,"\nbase.ahaversin( x:number )\n    Computes the inverse half-value versed sine.\n"
base.asin,"\nbase.asin( x:number )\n    Computes the arcsine of a number.\n"
base.asinh,"\nbase.asinh( x:number )\n    Computes the hyperbolic arcsine of a number.\n"
base.atan,"\nbase.atan( x:number )\n    Computes the arctangent of a number.\n"
base.atan2,"\nbase.atan2( y:number, x:number )\n    Computes the angle in the plane (in radians) between the positive x-axis and\n    the ray from (0,0) to the point (x,y).\n"
base.atanh,"\nbase.atanh( x:number )\n    Computes the hyperbolic arctangent of a number.\n"
base.avercos,"\nbase.avercos( x:number )\n    Computes the inverse versed cosine.\n"
base.aversin,"\nbase.aversin( x:number )\n    Computes the inverse versed sine.\n"
base.bernoulli,"\nbase.bernoulli( n:integer )\n    Computes the nth Bernoulli number.\n"
base.besselj0,"\nbase.besselj0( x:number )\n    Computes the Bessel function of the first kind of order zero.\n"
base.besselj1,"\nbase.besselj1( x:number )\n    Computes the Bessel function of the first kind of order one.\n"
base.bessely0,"\nbase.bessely0( x:number )\n    Computes the Bessel function of the second kind of order zero.\n"
base.bessely1,"\nbase.bessely1( x:number )\n    Computes the Bessel function of the second kind of order one.\n"
base.beta,"\nbase.beta( x:number, y:number )\n    Evaluates the beta function.\n"
base.betainc,"\nbase.betainc( x:number, a:number, b:number[, regularized:boolean[, \n  upper:boolean]] )\n    Computes the regularized incomplete beta function.\n"
base.betaincinv,"\nbase.betaincinv( p:number, a:number, b:number[, upper:boolean] )\n    Computes the inverse of the lower incomplete beta function.\n"
base.betaln,"\nbase.betaln( a:number, b:number )\n    Evaluates the natural logarithm of the beta function.\n"
base.binet,"\nbase.binet( x:number )\n    Evaluates Binet's formula extended to real numbers.\n"
base.binomcoef,"\nbase.binomcoef( n:integer, k:integer )\n    Computes the binomial coefficient of two integers.\n"
base.binomcoefln,"\nbase.binomcoefln( n:integer, k:integer )\n    Computes the natural logarithm of the binomial coefficient of two integers.\n"
base.boxcox,"\nbase.boxcox( x:number, lambda:number )\n    Computes a one-parameter Box-Cox transformation.\n"
base.boxcox1p,"\nbase.boxcox1p( x:number, lambda:number )\n    Computes a one-parameter Box-Cox transformation of 1+x.\n"
base.boxcox1pinv,"\nbase.boxcox1pinv( y:number, lambda:number )\n    Computes the inverse of a one-parameter Box-Cox transformation for 1+x.\n"
base.boxcoxinv,"\nbase.boxcoxinv( y:number, lambda:number )\n    Computes the inverse of a one-parameter Box-Cox transformation.\n"
base.cabs,"\nbase.cabs( re:number, im:number )\n    Computes the absolute value of a complex number.\n"
base.cabs2,"\nbase.cabs2( re:number, im:number )\n    Computes the squared absolute value of a complex number.\n"
base.cadd,"\nbase.cadd( [out:Array|TypedArray|Object,] re1:number, im1:number, re2:number, \n  im2:number )\n    Adds two complex numbers.\n"
base.cbrt,"\nbase.cbrt( x:number )\n    Computes the cube root of a double-precision floating-point number.\n"
base.cbrtf,"\nbase.cbrtf( x:number )\n    Computes the cube root of a single-precision floating-point number.\n"
base.cceil,"\nbase.cceil( [out:Array|TypedArray|Object,] re:number, im:number )\n    Rounds a complex number toward positive infinity.\n"
base.cceiln,"\nbase.cceiln( [out:Array|TypedArray|Object,] re:number, im:number, n:integer )\n    Rounds a complex number to the nearest multiple of `10^n` toward positive\n    infinity.\n"
base.ccis,"\nbase.ccis( [out:Array|TypedArray|Object,] re:number, im:number )\n    Computes the cis function of a complex number.\n"
base.cdiv,"\nbase.cdiv( [out:Array|TypedArray|Object,] re1:number, im1:number, re2:number, \n  im2:number )\n    Divides two complex numbers.\n"
base.ceil,"\nbase.ceil( x:number )\n    Rounds a double-precision floating-point number toward positive infinity.\n"
base.ceil2,"\nbase.ceil2( x:number )\n    Rounds a numeric value to the nearest power of two toward positive infinity.\n"
base.ceil10,"\nbase.ceil10( x:number )\n    Rounds a numeric value to the nearest power of ten toward positive infinity.\n"
base.ceilb,"\nbase.ceilb( x:number, n:integer, b:integer )\n    Rounds a numeric value to the nearest multiple of `b^n` toward positive\n    infinity.\n"
base.ceilf,"\nbase.ceilf( x:number )\n    Rounds a single-precision floating-point number toward positive infinity.\n"
base.ceiln,"\nbase.ceiln( x:number, n:integer )\n    Rounds a numeric value to the nearest multiple of `10^n` toward positive\n    infinity.\n"
base.ceilsd,"\nbase.ceilsd( x:number, n:integer[, b:integer] )\n    Rounds a numeric value to the nearest number toward positive infinity with\n    `n` significant figures.\n"
base.cexp,"\nbase.cexp( [out:Array|TypedArray|Object,] re:number, im:number )\n    Computes the exponential function of a complex number.\n"
base.cflipsign,"\nbase.cflipsign( [out:Array|TypedArray|Object,] re:number, im:number, y:number )\n    Returns a complex number with the same magnitude as `z` and the sign of\n    `y*z`.\n"
base.cfloor,"\nbase.cfloor( [out:Array|TypedArray|Object,] re:number, im:number )\n    Rounds a complex number toward negative infinity.\n"
base.cfloorn,"\nbase.cfloorn( [out:Array|TypedArray|Object,] re:number, im:number, n:integer )\n    Rounds a complex number to the nearest multiple of `10^n` toward negative\n    infinity.\n"
base.cinv,"\nbase.cinv( [out:Array|TypedArray|Object,] re:number, im:number )\n    Computes the inverse of a complex number.\n"
base.clamp,"\nbase.clamp( v:number, min:number, max:number )\n    Restricts a double-precision floating-point number to a specified range.\n"
base.clampf,"\nbase.clampf( v:number, min:number, max:number )\n    Restricts a single-precision floating-point number to a specified range.\n"
base.cmul,"\nbase.cmul( [out:Array|TypedArray|Object,] re1:number, im1:number, re2:number, \n  im2:number )\n    Multiplies two complex numbers.\n"
base.cneg,"\nbase.cneg( [out:Array|TypedArray|Object,] re:number, im:number )\n    Negates a complex number.\n"
base.continuedFraction,"\nbase.continuedFraction( generator:Function[, options:Object] )\n    Evaluates the continued fraction approximation for the supplied series\n    generator using the modified Lentz algorithm.\n"
base.copysign,"\nbase.copysign( x:number, y:number )\n    Returns a double-precision floating-point number with the magnitude of `x`\n    and the sign of `y`.\n"
base.cos,"\nbase.cos( x:number )\n    Computes the cosine of a number.\n"
base.cosh,"\nbase.cosh( x:number )\n    Computes the hyperbolic cosine of a number.\n"
base.cosm1,"\nbase.cosm1( x:number )\n    Computes the cosine of a number minus one.\n"
base.cospi,"\nbase.cospi( x:number )\n    Computes the value of `cos(πx)`.\n"
base.covercos,"\nbase.covercos( x:number )\n    Computes the coversed cosine.\n"
base.coversin,"\nbase.coversin( x:number )\n    Computes the coversed sine.\n"
base.cphase,"\nbase.cphase( re:number, im:number )\n    Computes the argument of a complex number in radians.\n"
base.cpolar,"\nbase.cpolar( [out:Array|TypedArray|Object,] re:number, im:number )\n    Returns the absolute value and phase of a complex number.\n"
base.cround,"\nbase.cround( [out:Array|TypedArray|Object,] re:number, im:number )\n    Rounds a complex number to the nearest integer.\n"
base.croundn,"\nbase.croundn( [out:Array|TypedArray|Object,] re:number, im:number, n:integer )\n    Rounds a complex number to the nearest multiple of `10^n`.\n"
base.csignum,"\nbase.csignum( [out:Array|TypedArray|Object,] re:number, im:number )\n    Evaluates the signum function of a complex number.\n"
base.csub,"\nbase.csub( [out:Array|TypedArray|Object,] re1:number, im1:number, re2:number, \n  im2:number )\n    Subtracts two complex numbers.\n"
base.deg2rad,"\nbase.deg2rad( x:number )\n    Converts an angle from degrees to radians.\n"
base.deg2radf,"\nbase.deg2radf( x:number )\n    Converts an angle from degrees to radians (single-precision).\n"
base.digamma,"\nbase.digamma( x:number )\n    Evaluates the digamma function.\n"
base.diracDelta,"\nbase.diracDelta( x:number )\n    Evaluates the Dirac delta function.\n"
base.dists.arcsine.Arcsine,"\nbase.dists.arcsine.Arcsine( [a:number, b:number] )\n    Returns an arcsine distribution object.\n"
base.dists.arcsine.cdf,"\nbase.dists.arcsine.cdf( x:number, a:number, b:number )\n    Evaluates the cumulative distribution function (CDF) for an arcsine\n    distribution with minimum support `a` and maximum support `b` at a value\n    `x`.\n"
base.dists.arcsine.cdf.factory,"\nbase.dists.arcsine.cdf.factory( a:number, b:number )\n    Returns a function for evaluating the cumulative distribution function (CDF)\n    of an arcsine distribution with minimum support `a` and maximum support `b`.\n"
base.dists.arcsine.entropy,"\nbase.dists.arcsine.entropy( a:number, b:number )\n    Returns the differential entropy of an arcsine distribution (in nats).\n"
base.dists.arcsine.kurtosis,"\nbase.dists.arcsine.kurtosis( a:number, b:number )\n    Returns the excess kurtosis of an arcsine distribution.\n"
base.dists.arcsine.logcdf,"\nbase.dists.arcsine.logcdf( x:number, a:number, b:number )\n    Evaluates the logarithm of the cumulative distribution function (CDF) for an\n    arcsine distribution with minimum support `a` and maximum support `b` at a\n    value `x`.\n"
base.dists.arcsine.logcdf.factory,"\nbase.dists.arcsine.logcdf.factory( a:number, b:number )\n    Returns a function for evaluating the logarithm of the cumulative\n    distribution function (CDF) of an arcsine distribution with minimum support\n    `a` and maximum support `b`.\n"
base.dists.arcsine.logpdf,"\nbase.dists.arcsine.logpdf( x:number, a:number, b:number )\n    Evaluates the logarithm of the probability density function (PDF) for an\n    arcsine distribution with minimum support `a` and maximum support `b` at a\n    value `x`.\n"
base.dists.arcsine.logpdf.factory,"\nbase.dists.arcsine.logpdf.factory( a:number, b:number )\n    Returns a function for evaluating the logarithm of the probability density\n    function (PDF) of an arcsine distribution with minimum support `a` and\n    maximum support `b`.\n"
base.dists.arcsine.mean,"\nbase.dists.arcsine.mean( a:number, b:number )\n    Returns the expected value of an arcsine distribution.\n"
base.dists.arcsine.median,"\nbase.dists.arcsine.median( a:number, b:number )\n    Returns the median of an arcsine distribution.\n"
base.dists.arcsine.mode,"\nbase.dists.arcsine.mode( a:number, b:number )\n    Returns the mode of an arcsine distribution.\n"
base.dists.arcsine.pdf,"\nbase.dists.arcsine.pdf( x:number, a:number, b:number )\n    Evaluates the probability density function (PDF) for an arcsine distribution\n    with minimum support `a` and maximum support `b` at a value `x`.\n"
base.dists.arcsine.pdf.factory,"\nbase.dists.arcsine.pdf.factory( a:number, b:number )\n    Returns a function for evaluating the probability density function (PDF) of\n    an arcsine distribution with minimum support `a` and maximum support `b`.\n"
base.dists.arcsine.quantile,"\nbase.dists.arcsine.quantile( p:number, a:number, b:number )\n    Evaluates the quantile function for an arcsine distribution with minimum\n    support `a` and maximum support `b` at a probability `p`.\n"
base.dists.arcsine.quantile.factory,"\nbase.dists.arcsine.quantile.factory( a:number, b:number )\n    Returns a function for evaluating the quantile function of an arcsine\n    distribution with minimum support `a` and maximum support `b`.\n"
base.dists.arcsine.skewness,"\nbase.dists.arcsine.skewness( a:number, b:number )\n    Returns the skewness of an arcsine distribution.\n"
base.dists.arcsine.stdev,"\nbase.dists.arcsine.stdev( a:number, b:number )\n    Returns the standard deviation of an arcsine distribution.\n"
base.dists.arcsine.variance,"\nbase.dists.arcsine.variance( a:number, b:number )\n    Returns the variance of an arcsine distribution.\n"
base.dists.bernoulli.Bernoulli,"\nbase.dists.bernoulli.Bernoulli( [p:number] )\n    Returns a Bernoulli distribution object.\n"
base.dists.bernoulli.cdf,"\nbase.dists.bernoulli.cdf( x:number, p:number )\n    Evaluates the cumulative distribution function (CDF) for a Bernoulli\n    distribution with success probability `p` at a value `x`.\n"
base.dists.bernoulli.cdf.factory,"\nbase.dists.bernoulli.cdf.factory( p:number )\n    Returns a function for evaluating the cumulative distribution function (CDF)\n    of a Bernoulli distribution with success probability `p`.\n"
base.dists.bernoulli.entropy,"\nbase.dists.bernoulli.entropy( p:number )\n    Returns the entropy of a Bernoulli distribution with success probability\n    `p` (in nats).\n"
base.dists.bernoulli.kurtosis,"\nbase.dists.bernoulli.kurtosis( p:number )\n    Returns the excess kurtosis of a Bernoulli distribution with success\n    probability `p`.\n"
base.dists.bernoulli.mean,"\nbase.dists.bernoulli.mean( p:number )\n    Returns the expected value of a Bernoulli distribution with success\n    probability `p`.\n"
base.dists.bernoulli.median,"\nbase.dists.bernoulli.median( p:number )\n    Returns the median of a Bernoulli distribution with success probability `p`.\n"
base.dists.bernoulli.mgf,"\nbase.dists.bernoulli.mgf( t:number, p:number )\n    Evaluates the moment-generating function (MGF) for a Bernoulli\n    distribution with success probability `p` at a value `t`.\n"
base.dists.bernoulli.mgf.factory,"\nbase.dists.bernoulli.mgf.factory( p:number )\n    Returns a function for evaluating the moment-generating function (MGF) of a\n    Bernoulli distribution with success probability `p`.\n"
base.dists.bernoulli.mode,"\nbase.dists.bernoulli.mode( p:number )\n    Returns the mode of a Bernoulli distribution with success probability `p`.\n"
base.dists.bernoulli.pmf,"\nbase.dists.bernoulli.pmf( x:number, p:number )\n    Evaluates the probability mass function (PMF) for a Bernoulli distribution\n    with success probability `p` at a value `x`.\n"
base.dists.bernoulli.pmf.factory,"\nbase.dists.bernoulli.pmf.factory( p:number )\n    Returns a function for evaluating the probability mass function (PMF) of a\n    Bernoulli distribution with success probability `p`.\n"
base.dists.bernoulli.quantile,"\nbase.dists.bernoulli.quantile( r:number, p:number )\n    Evaluates the quantile function for a Bernoulli distribution with success\n    probability `p` at a probability `r`.\n"
base.dists.bernoulli.quantile.factory,"\nbase.dists.bernoulli.quantile.factory( p:number )\n    Returns a function for evaluating the quantile function of a Bernoulli\n    distribution with success probability `p`.\n"
base.dists.bernoulli.skewness,"\nbase.dists.bernoulli.skewness( p:number )\n    Returns the skewness of a Bernoulli distribution with success probability\n    `p`.\n"
base.dists.bernoulli.stdev,"\nbase.dists.bernoulli.stdev( p:number )\n    Returns the standard deviation of a Bernoulli distribution with success\n    probability `p`.\n"
base.dists.bernoulli.variance,"\nbase.dists.bernoulli.variance( p:number )\n    Returns the variance of a Bernoulli distribution with success probability\n    `p`.\n"
base.dists.beta.Beta,"\nbase.dists.beta.Beta( [α:number, β:number] )\n    Returns a beta distribution object.\n"
base.dists.beta.cdf,"\nbase.dists.beta.cdf( x:number, α:number, β:number )\n    Evaluates the cumulative distribution function (CDF) for a beta distribution\n    with first shape parameter `α` and second shape parameter `β` at a value\n    `x`.\n"
base.dists.beta.cdf.factory,"\nbase.dists.beta.cdf.factory( α:number, β:number )\n    Returns a function for evaluating the cumulative distribution function (CDF)\n    of a beta distribution with first shape parameter `α` and second shape\n    parameter `β`.\n"
base.dists.beta.entropy,"\nbase.dists.beta.entropy( α:number, β:number )\n    Returns the differential entropy of a beta distribution.\n"
base.dists.beta.kurtosis,"\nbase.dists.beta.kurtosis( α:number, β:number )\n    Returns the excess kurtosis of a beta distribution.\n"
base.dists.beta.logcdf,"\nbase.dists.beta.logcdf( x:number, α:number, β:number )\n    Evaluates the natural logarithm of the cumulative distribution function\n    (CDF) for a beta distribution with first shape parameter `α` and second\n    shape parameter `β` at a value `x`.\n"
base.dists.beta.logcdf.factory,"\nbase.dists.beta.logcdf.factory( α:number, β:number )\n    Returns a function for evaluating the natural logarithm of the cumulative\n    distribution function (CDF) of a beta distribution with first shape\n    parameter `α` and second shape parameter `β`.\n"
base.dists.beta.logpdf,"\nbase.dists.beta.logpdf( x:number, α:number, β:number )\n    Evaluates the natural logarithm of the probability density function (PDF)\n    for a beta distribution with first shape parameter `α` and second shape\n    parameter `β` at a value `x`.\n"
base.dists.beta.logpdf.factory,"\nbase.dists.beta.logpdf.factory( α:number, β:number )\n    Returns a function for evaluating the natural logarithm of the probability\n    density function (PDF) of a beta distribution with first shape parameter `α`\n    and second shape parameter `β`.\n"
base.dists.beta.mean,"\nbase.dists.beta.mean( α:number, β:number )\n    Returns the expected value of a beta distribution.\n"
base.dists.beta.median,"\nbase.dists.beta.median( α:number, β:number )\n    Returns the median of a beta distribution.\n"
base.dists.beta.mgf,"\nbase.dists.beta.mgf( t:number, α:number, β:number )\n    Evaluates the moment-generating function (MGF) for a beta distribution with\n    first shape parameter `α` and second shape parameter `β` at a value `t`.\n"
base.dists.beta.mgf.factory,"\nbase.dists.beta.mgf.factory( α:number, β:number )\n    Returns a function for evaluating the moment-generating function (MGF) of a\n    beta distribution with first shape parameter `α` and second shape parameter\n    `β`.\n"
base.dists.beta.mode,"\nbase.dists.beta.mode( α:number, β:number )\n    Returns the mode of a beta distribution.\n"
base.dists.beta.pdf,"\nbase.dists.beta.pdf( x:number, α:number, β:number )\n    Evaluates the probability density function (PDF) for a beta distribution\n    with first shape parameter `α` and second shape parameter `β` at a value\n    `x`.\n"
base.dists.beta.pdf.factory,"\nbase.dists.beta.pdf.factory( α:number, β:number )\n    Returns a function for evaluating the probability density function (PDF) of\n    a beta distribution with first shape parameter `α` and second shape\n    parameter `β`.\n"
base.dists.beta.quantile,"\nbase.dists.beta.quantile( p:number, α:number, β:number )\n    Evaluates the quantile function for a beta distribution with first shape\n    parameter `α` and second shape parameter `β` at a probability `p`.\n"
base.dists.beta.quantile.factory,"\nbase.dists.beta.quantile.factory( α:number, β:number )\n    Returns a function for evaluating the quantile function of a beta\n    distribution with first shape parameter `α` and second shape parameter `β`.\n"
base.dists.beta.skewness,"\nbase.dists.beta.skewness( α:number, β:number )\n    Returns the skewness of a beta distribution.\n"
base.dists.beta.stdev,"\nbase.dists.beta.stdev( α:number, β:number )\n    Returns the standard deviation of a beta distribution.\n"
base.dists.beta.variance,"\nbase.dists.beta.variance( α:number, β:number )\n    Returns the variance of a beta distribution.\n"
base.dists.betaprime.BetaPrime,"\nbase.dists.betaprime.BetaPrime( [α:number, β:number] )\n    Returns a beta prime distribution object.\n"
base.dists.betaprime.cdf,"\nbase.dists.betaprime.cdf( x:number, α:number, β:number )\n    Evaluates the cumulative distribution function (CDF) for a beta prime\n    distribution with first shape parameter `α` and second shape parameter `β`\n    at a value `x`.\n"
base.dists.betaprime.cdf.factory,"\nbase.dists.betaprime.cdf.factory( α:number, β:number )\n    Returns a function for evaluating the cumulative distribution function (CDF)\n    of a beta prime distribution with first shape parameter `α` and second shape\n    parameter `β`.\n"
base.dists.betaprime.kurtosis,"\nbase.dists.betaprime.kurtosis( α:number, β:number )\n    Returns the excess kurtosis of a beta prime distribution.\n"
base.dists.betaprime.logcdf,"\nbase.dists.betaprime.logcdf( x:number, α:number, β:number )\n    Evaluates the natural logarithm of the cumulative distribution function\n    (CDF) for a beta prime distribution with first shape parameter `α` and\n    second shape parameter `β` at a value `x`.\n"
base.dists.betaprime.logcdf.factory,"\nbase.dists.betaprime.logcdf.factory( α:number, β:number )\n    Returns a function for evaluating the natural logarithm of the cumulative\n    distribution function (CDF) of a beta prime distribution with first shape\n    parameter `α` and second shape parameter `β`.\n"
base.dists.betaprime.logpdf,"\nbase.dists.betaprime.logpdf( x:number, α:number, β:number )\n    Evaluates the natural logarithm of the probability density function (PDF)\n    for a beta prime distribution with first shape parameter `α` and second\n    shape parameter `β` at a value `x`.\n"
base.dists.betaprime.logpdf.factory,"\nbase.dists.betaprime.logpdf.factory( α:number, β:number )\n    Returns a function for evaluating the natural logarithm of the probability\n    density function (PDF) of a beta prime distribution with first shape\n    parameter `α` and second shape parameter `β`.\n"
base.dists.betaprime.mean,"\nbase.dists.betaprime.mean( α:number, β:number )\n    Returns the expected value of a beta prime distribution.\n"
base.dists.betaprime.mode,"\nbase.dists.betaprime.mode( α:number, β:number )\n    Returns the mode of a beta prime distribution.\n"
base.dists.betaprime.pdf,"\nbase.dists.betaprime.pdf( x:number, α:number, β:number )\n    Evaluates the probability density function (PDF) for a beta prime\n    distribution  with first shape parameter `α` and second shape parameter `β`\n    at a value `x`.\n"
base.dists.betaprime.pdf.factory,"\nbase.dists.betaprime.pdf.factory( α:number, β:number )\n    Returns a function for evaluating the probability density function (PDF) of\n    a beta prime distribution with first shape parameter `α` and second shape\n    parameter `β`.\n"
base.dists.betaprime.quantile,"\nbase.dists.betaprime.quantile( p:number, α:number, β:number )\n    Evaluates the quantile function for a beta prime distribution with first\n    shape parameter `α` and second shape parameter `β` at a probability `p`.\n"
base.dists.betaprime.quantile.factory,"\nbase.dists.betaprime.quantile.factory( α:number, β:number )\n    Returns a function for evaluating the quantile function of a beta prime\n    distribution with first shape parameter `α` and second shape parameter `β`.\n"
base.dists.betaprime.skewness,"\nbase.dists.betaprime.skewness( α:number, β:number )\n    Returns the skewness of a beta prime distribution.\n"
base.dists.betaprime.stdev,"\nbase.dists.betaprime.stdev( α:number, β:number )\n    Returns the standard deviation of a beta prime distribution.\n"
base.dists.betaprime.variance,"\nbase.dists.betaprime.variance( α:number, β:number )\n    Returns the variance of a beta prime distribution.\n"
base.dists.binomial.Binomial,"\nbase.dists.binomial.Binomial( [n:integer, p:number] )\n    Returns a binomial distribution object.\n"
base.dists.binomial.cdf,"\nbase.dists.binomial.cdf( x:number, n:integer, p:number )\n    Evaluates the cumulative distribution function (CDF) for a binomial\n    distribution with number of trials `n` and success probability `p` at a\n    value `x`.\n"
base.dists.binomial.cdf.factory,"\nbase.dists.binomial.cdf.factory( n:integer, p:number )\n    Returns a function for evaluating the cumulative distribution function (CDF)\n    of a binomial distribution with number of trials `n` and success probability\n    `p`.\n"
base.dists.binomial.entropy,"\nbase.dists.binomial.entropy( n:integer, p:number )\n    Returns the entropy of a binomial distribution.\n"
base.dists.binomial.kurtosis,"\nbase.dists.binomial.kurtosis( n:integer, p:number )\n    Returns the excess kurtosis of a binomial distribution.\n"
base.dists.binomial.logpmf,"\nbase.dists.binomial.logpmf( x:number, n:integer, p:number )\n    Evaluates the natural logarithm of the probability mass function (PMF) for a\n    binomial distribution with number of trials `n` and success probability `p`\n    at a value `x`.\n"
base.dists.binomial.logpmf.factory,"\nbase.dists.binomial.logpmf.factory( n:integer, p:number )\n    Returns a function for evaluating the natural logarithm of the probability\n    mass function (PMF) of a binomial distribution with number of trials `n` and\n    success probability `p`.\n"
base.dists.binomial.mean,"\nbase.dists.binomial.mean( n:integer, p:number )\n    Returns the expected value of a binomial distribution.\n"
base.dists.binomial.median,"\nbase.dists.binomial.median( n:integer, p:number )\n    Returns the median of a binomial distribution.\n"
base.dists.binomial.mgf,"\nbase.dists.binomial.mgf( t:number, n:integer, p:number )\n    Evaluates the moment-generating function (MGF) for a binomial distribution\n    with number of trials `n` and success probability `p` at a value `t`.\n"
base.dists.binomial.mgf.factory,"\nbase.dists.binomial.mgf.factory( n:integer, p:number )\n    Returns a function for evaluating the moment-generating function (MGF) of a\n    binomial distribution with number of trials `n` and success probability `p`.\n"
base.dists.binomial.mode,"\nbase.dists.binomial.mode( n:integer, p:number )\n    Returns the mode of a binomial distribution.\n"
base.dists.binomial.pmf,"\nbase.dists.binomial.pmf( x:number, n:integer, p:number )\n    Evaluates the probability mass function (PMF) for a binomial distribution\n    with number of trials `n` and success probability `p` at a value `x`.\n"
base.dists.binomial.pmf.factory,"\nbase.dists.binomial.pmf.factory( n:integer, p:number )\n    Returns a function for evaluating the probability mass function (PMF) of a\n    binomial distribution with number of trials `n` and success probability `p`.\n"
base.dists.binomial.quantile,"\nbase.dists.binomial.quantile( r:number, n:integer, p:number )\n    Evaluates the quantile function for a binomial distribution with number of\n    trials `n` and success probability `p` at a probability `r`.\n"
base.dists.binomial.quantile.factory,"\nbase.dists.binomial.quantile.factory( n:integer, p:number )\n    Returns a function for evaluating the quantile function of a binomial\n    distribution with number of trials `n` and success probability `p`.\n"
base.dists.binomial.skewness,"\nbase.dists.binomial.skewness( n:integer, p:number )\n    Returns the skewness of a binomial distribution.\n"
base.dists.binomial.stdev,"\nbase.dists.binomial.stdev( n:integer, p:number )\n    Returns the standard deviation of a binomial distribution.\n"
base.dists.binomial.variance,"\nbase.dists.binomial.variance( n:integer, p:number )\n    Returns the variance of a binomial distribution.\n"
base.dists.cauchy.Cauchy,"\nbase.dists.cauchy.Cauchy( [x0:number, Ɣ:number] )\n    Returns a Cauchy distribution object.\n"
base.dists.cauchy.cdf,"\nbase.dists.cauchy.cdf( x:number, x0:number, Ɣ:number )\n    Evaluates the cumulative distribution function (CDF) for a Cauchy\n    distribution with location parameter `x0` and scale parameter `Ɣ` at a value\n    `x`.\n"
base.dists.cauchy.cdf.factory,"\nbase.dists.cauchy.cdf.factory( x0:number, Ɣ:number )\n    Returns a function for evaluating the cumulative distribution function (CDF)\n    of a Cauchy distribution with location parameter `x0` and scale parameter\n    `Ɣ`.\n"
base.dists.cauchy.entropy,"\nbase.dists.cauchy.entropy( x0:number, Ɣ:number )\n    Returns the differential entropy of a Cauchy distribution (in nats).\n"
base.dists.cauchy.logcdf,"\nbase.dists.cauchy.logcdf( x:number, x0:number, Ɣ:number )\n    Evaluates the natural logarithm of the cumulative distribution function\n    (logCDF) for a Cauchy distribution with location parameter `x0` and scale\n    parameter `Ɣ` at a value `x`.\n"
base.dists.cauchy.logcdf.factory,"\nbase.dists.cauchy.logcdf.factory( x0:number, Ɣ:number )\n    Returns a function for evaluating the natural logarithm of the cumulative\n    distribution function (logCDF) of a Cauchy distribution with location\n    parameter `x0` and scale parameter `Ɣ`.\n"
base.dists.cauchy.logpdf,"\nbase.dists.cauchy.logpdf( x:number, x0:number, Ɣ:number )\n    Evaluates the natural logarithm of the probability density function (logPDF)\n    for a Cauchy distribution with location parameter `x0` and scale parameter\n    `Ɣ` at a value `x`.\n"
base.dists.cauchy.logpdf.factory,"\nbase.dists.cauchy.logpdf.factory( x0:number, Ɣ:number )\n    Returns a function for evaluating the natural logarithm of the probability\n    density function (logPDF) of a Cauchy distribution with location parameter\n    `x0` and scale parameter `Ɣ`.\n"
base.dists.cauchy.median,"\nbase.dists.cauchy.median( x0:number, Ɣ:number )\n    Returns the median of a Cauchy distribution.\n"
base.dists.cauchy.mode,"\nbase.dists.cauchy.mode( x0:number, Ɣ:number )\n    Returns the mode of a Cauchy distribution.\n"
base.dists.cauchy.pdf,"\nbase.dists.cauchy.pdf( x:number, x0:number, Ɣ:number )\n    Evaluates the probability density function (PDF) for a Cauchy distribution\n    with location parameter `x0` and scale parameter `Ɣ` at a value `x`.\n"
base.dists.cauchy.pdf.factory,"\nbase.dists.cauchy.pdf.factory( x0:number, Ɣ:number )\n    Returns a function for evaluating the probability density function (PDF) of\n    a Cauchy distribution with location parameter `x0` and scale parameter `Ɣ`.\n"
base.dists.cauchy.quantile,"\nbase.dists.cauchy.quantile( p:number, x0:number, Ɣ:number )\n    Evaluates the quantile function for a Cauchy distribution with location\n    parameter `x0`  and scale parameter `Ɣ` at a probability `p`.\n"
base.dists.cauchy.quantile.factory,"\nbase.dists.cauchy.quantile.factory( x0:number, Ɣ:number )\n    Returns a function for evaluating the quantile function of a Cauchy\n    distribution with location parameter `x0` and scale parameter `Ɣ`.\n"
base.dists.chi.cdf,"\nbase.dists.chi.cdf( x:number, k:number )\n    Evaluates the cumulative distribution function (CDF) for a chi distribution\n    with degrees of freedom `k` at a value `x`.\n"
base.dists.chi.cdf.factory,"\nbase.dists.chi.cdf.factory( k:number )\n    Returns a function for evaluating the cumulative distribution function (CDF)\n    of a chi distribution with degrees of freedom `k`.\n"
base.dists.chi.Chi,"\nbase.dists.chi.Chi( [k:number] )\n    Returns a chi distribution object.\n"
base.dists.chi.entropy,"\nbase.dists.chi.entropy( k:number )\n    Returns the differential entropy of a chi distribution (in nats).\n"
base.dists.chi.kurtosis,"\nbase.dists.chi.kurtosis( k:number )\n    Returns the excess kurtosis of a chi distribution.\n"
base.dists.chi.logpdf,"\nbase.dists.chi.logpdf( x:number, k:number )\n    Evaluates the natural logarithm of the probability density function (PDF)\n    for a chi distribution with degrees of freedom `k` at a value `x`.\n"
base.dists.chi.logpdf.factory,"\nbase.dists.chi.logpdf.factory( k:number )\n    Returns a function for evaluating the natural logarithm of the  probability\n    density function (PDF) of a chi distribution with degrees of freedom `k`.\n"
base.dists.chi.mean,"\nbase.dists.chi.mean( k:number )\n    Returns the expected value of a chi distribution.\n"
base.dists.chi.mode,"\nbase.dists.chi.mode( k:number )\n    Returns the mode of a chi distribution.\n"
base.dists.chi.pdf,"\nbase.dists.chi.pdf( x:number, k:number )\n    Evaluates the probability density function (PDF) for a chi distribution with\n    degrees of freedom `k` at a value `x`.\n"
base.dists.chi.pdf.factory,"\nbase.dists.chi.pdf.factory( k:number )\n    Returns a function for evaluating the probability density function (PDF) of\n    a chi distribution with degrees of freedom `k`.\n"
base.dists.chi.quantile,"\nbase.dists.chi.quantile( p:number, k:number )\n    Evaluates the quantile function for a chi distribution with degrees of\n    freedom `k` at a probability `p`.\n"
base.dists.chi.quantile.factory,"\nbase.dists.chi.quantile.factory( k:number )\n    Returns a function for evaluating the quantile function of a chi\n    distribution with degrees of freedom `k`.\n"
base.dists.chi.skewness,"\nbase.dists.chi.skewness( k:number )\n    Returns the skewness of a chi distribution.\n"
base.dists.chi.stdev,"\nbase.dists.chi.stdev( k:number )\n    Returns the standard deviation of a chi distribution.\n"
base.dists.chi.variance,"\nbase.dists.chi.variance( k:number )\n    Returns the variance of a chi distribution.\n"
base.dists.chisquare.cdf,"\nbase.dists.chisquare.cdf( x:number, k:number )\n    Evaluates the cumulative distribution function (CDF) for a chi-squared\n    distribution with degrees of freedom `k` at a value `x`.\n"
base.dists.chisquare.cdf.factory,"\nbase.dists.chisquare.cdf.factory( k:number )\n    Returns a function for evaluating the cumulative distribution function (CDF)\n    of a chi-squared distribution with degrees of freedom `k`.\n"
base.dists.chisquare.ChiSquare,"\nbase.dists.chisquare.ChiSquare( [k:number] )\n    Returns a  chi-squared distribution object.\n"
base.dists.chisquare.entropy,"\nbase.dists.chisquare.entropy( k:number )\n    Returns the differential entropy of a chi-squared distribution (in nats).\n"
base.dists.chisquare.kurtosis,"\nbase.dists.chisquare.kurtosis( k:number )\n    Returns the excess kurtosis of a chi-squared distribution.\n"
base.dists.chisquare.logpdf,"\nbase.dists.chisquare.logpdf( x:number, k:number )\n    Evaluates the natural logarithm of the probability density function (PDF)\n    for a chi-squared distribution with degrees of freedom `k` at a value `x`.\n"
base.dists.chisquare.logpdf.factory,"\nbase.dists.chisquare.logpdf.factory( k:number )\n    Returns a function for evaluating the natural logarithm of the probability\n    density function (PDF) of a chi-squared distribution with degrees of freedom\n    `k`.\n"
base.dists.chisquare.mean,"\nbase.dists.chisquare.mean( k:number )\n    Returns the expected value of a chi-squared distribution.\n"
base.dists.chisquare.median,"\nbase.dists.chisquare.median( k:number )\n    Returns the median of a chi-squared distribution.\n"
base.dists.chisquare.mgf,"\nbase.dists.chisquare.mgf( t:number, k:number )\n    Evaluates the moment-generating function (MGF) for a chi-squared\n    distribution with degrees of freedom `k` at a value `t`.\n"
base.dists.chisquare.mgf.factory,"\nbase.dists.chisquare.mgf.factory( k:number )\n    Returns a function for evaluating the moment-generating function (MGF) of a\n    chi-squared distribution with degrees of freedom `k`.\n"
base.dists.chisquare.mode,"\nbase.dists.chisquare.mode( k:number )\n    Returns the mode of a chi-squared distribution.\n"
base.dists.chisquare.pdf,"\nbase.dists.chisquare.pdf( x:number, k:number )\n    Evaluates the probability density function (PDF) for a chi-squared\n    distribution with degrees of freedom `k` at a value `x`.\n"
base.dists.chisquare.pdf.factory,"\nbase.dists.chisquare.pdf.factory( k:number )\n    Returns a function for evaluating the probability density function (PDF) of\n    a chi-squared distribution with degrees of freedom `k`.\n"
base.dists.chisquare.quantile,"\nbase.dists.chisquare.quantile( p:number, k:number )\n    Evaluates the quantile function for a chi-squared distribution with degrees\n    of freedom `k` at a probability `p`.\n"
base.dists.chisquare.quantile.factory,"\nbase.dists.chisquare.quantile.factory( k:number )\n    Returns a function for evaluating the quantile function of a chi-squared\n    distribution with degrees of freedom `k`.\n"
base.dists.chisquare.skewness,"\nbase.dists.chisquare.skewness( k:number )\n    Returns the skewness of a chi-squared distribution.\n"
base.dists.chisquare.stdev,"\nbase.dists.chisquare.stdev( k:number )\n    Returns the standard deviation of a chi-squared distribution.\n"
base.dists.chisquare.variance,"\nbase.dists.chisquare.variance( k:number )\n    Returns the variance of a chi-squared distribution.\n"
base.dists.cosine.cdf,"\nbase.dists.cosine.cdf( x:number, μ:number, s:number )\n    Evaluates the cumulative distribution function (CDF) for a raised cosine\n    distribution with location parameter `μ` and scale parameter `s` at a value\n    `x`.\n"
base.dists.cosine.cdf.factory,"\nbase.dists.cosine.cdf.factory( μ:number, s:number )\n    Returns a function for evaluating the cumulative distribution function (CDF)\n    of a raised cosine distribution with location parameter `μ` and scale\n    parameter `s`.\n"
base.dists.cosine.Cosine,"\nbase.dists.cosine.Cosine( [μ:number, s:number] )\n    Returns a raised cosine distribution object.\n"
base.dists.cosine.kurtosis,"\nbase.dists.cosine.kurtosis( μ:number, s:number )\n    Returns the excess kurtosis of a raised cosine distribution with location\n    parameter `μ` and scale parameter `s`.\n"
base.dists.cosine.logcdf,"\nbase.dists.cosine.logcdf( x:number, μ:number, s:number )\n    Evaluates the natural logarithm of the cumulative distribution function\n    (CDF) for a raised cosine distribution with location parameter `μ` and scale\n     parameter `s` at a value `x`.\n"
base.dists.cosine.logcdf.factory,"\nbase.dists.cosine.logcdf.factory( μ:number, s:number )\n    Returns a function for evaluating the natural logarithm of the  cumulative\n    distribution function (CDF) of a raised cosine distribution with location\n    parameter `μ` and scale parameter `s`.\n"
base.dists.cosine.logpdf,"\nbase.dists.cosine.logpdf( x:number, μ:number, s:number )\n    Evaluates the logarithm of the probability density function (PDF) for a\n    raised cosine distribution with location parameter `μ` and scale parameter\n    `s` at a value `x`.\n"
base.dists.cosine.logpdf.factory,"\nbase.dists.cosine.logpdf.factory( μ:number, s:number )\n    Returns a function for evaluating the logarithm of the probability density\n    function (PDF) of a raised cosine distribution with location parameter `μ`\n    and scale parameter `s`.\n"
base.dists.cosine.mean,"\nbase.dists.cosine.mean( μ:number, s:number )\n    Returns the expected value of a raised cosine distribution with location\n    parameter `μ` and scale parameter `s`.\n"
base.dists.cosine.median,"\nbase.dists.cosine.median( μ:number, s:number )\n    Returns the median of a raised cosine distribution with location parameter\n    `μ` and scale parameter `s`.\n"
base.dists.cosine.mgf,"\nbase.dists.cosine.mgf( t:number, μ:number, s:number )\n    Evaluates the moment-generating function (MGF) for a raised cosine\n    distribution with location parameter `μ` and scale parameter `s` at a value\n    `t`.\n"
base.dists.cosine.mgf.factory,"\nbase.dists.cosine.mgf.factory( μ:number, s:number )\n    Returns a function for evaluating the moment-generating function (MGF) of a\n    raised cosine distribution with location parameter `μ` and scale parameter\n    `s`.\n"
base.dists.cosine.mode,"\nbase.dists.cosine.mode( μ:number, s:number )\n    Returns the mode of a raised cosine distribution with location parameter `μ`\n    and scale parameter `s`.\n"
base.dists.cosine.pdf,"\nbase.dists.cosine.pdf( x:number, μ:number, s:number )\n    Evaluates the probability density function (PDF) for a raised cosine\n    distribution with location parameter `μ` and scale parameter `s` at a value\n    `x`.\n"
base.dists.cosine.pdf.factory,"\nbase.dists.cosine.pdf.factory( μ:number, s:number )\n    Returns a function for evaluating the probability density function (PDF) of\n    a raised cosine distribution with location parameter `μ` and scale parameter\n    `s`.\n"
base.dists.cosine.quantile,"\nbase.dists.cosine.quantile( p:number, μ:number, s:number )\n    Evaluates the quantile function for a raised cosine distribution with\n    location parameter `μ` and scale parameter `s` at a probability `p`.\n"
base.dists.cosine.quantile.factory,"\nbase.dists.cosine.quantile.factory( μ:number, s:number )\n    Returns a function for evaluating the quantile function of a raised cosine\n    distribution with location parameter `μ` and scale parameter `s`.\n"
base.dists.cosine.skewness,"\nbase.dists.cosine.skewness( μ:number, s:number )\n    Returns the skewness of a raised cosine distribution with location parameter\n    `μ` and scale parameter `s`.\n"
base.dists.cosine.stdev,"\nbase.dists.cosine.stdev( μ:number, s:number )\n    Returns the standard deviation of a raised cosine distribution with location\n    parameter `μ` and scale parameter `s`.\n"
base.dists.cosine.variance,"\nbase.dists.cosine.variance( μ:number, s:number )\n    Returns the variance of a raised cosine distribution with location parameter\n    `μ` and scale parameter `s`.\n"
base.dists.degenerate.cdf,"\nbase.dists.degenerate.cdf( x:number, μ:number )\n    Evaluates the cumulative distribution function (CDF) for a degenerate\n    distribution with mean value `μ`.\n"
base.dists.degenerate.cdf.factory,"\nbase.dists.degenerate.cdf.factory( μ:number )\n    Returns a function for evaluating the cumulative distribution function (CDF)\n    of a degenerate distribution centered at a provided mean value.\n"
base.dists.degenerate.Degenerate,"\nbase.dists.degenerate.Degenerate( [μ:number] )\n    Returns a degenerate distribution object.\n"
base.dists.degenerate.entropy,"\nbase.dists.degenerate.entropy( μ:number )\n    Returns the entropy of a degenerate distribution with constant value `μ`.\n"
base.dists.degenerate.logcdf,"\nbase.dists.degenerate.logcdf( x:number, μ:number )\n    Evaluates the natural logarithm of the cumulative distribution function\n    (logCDF) for a degenerate distribution with mean `μ`.\n"
base.dists.degenerate.logcdf.factory,"\nbase.dists.degenerate.logcdf.factory( μ:number )\n    Returns a function for evaluating the natural logarithm of the cumulative\n    distribution function (logCDF) of a degenerate distribution with mean `μ`.\n"
base.dists.degenerate.logpdf,"\nbase.dists.degenerate.logpdf( x:number, μ:number )\n    Evaluates the natural logarithm of the probability density function (logPDF)\n    for a degenerate distribution with mean `μ`.\n"
base.dists.degenerate.logpdf.factory,"\nbase.dists.degenerate.logpdf.factory( μ:number )\n    Returns a function for evaluating the natural logarithm of the probability\n    density function (logPDF) of a degenerate distribution with mean `μ`.\n"
base.dists.degenerate.logpmf,"\nbase.dists.degenerate.logpmf( x:number, μ:number )\n    Evaluates the natural logarithm of the probability mass function (PMF) for a\n    degenerate distribution with mean `μ`.\n"
base.dists.degenerate.logpmf.factory,"\nbase.dists.degenerate.logpmf.factory( μ:number )\n    Returns a function for evaluating the natural logarithm of the probability\n    mass function (PMF) of a degenerate distribution with mean `μ`.\n"
base.dists.degenerate.mean,"\nbase.dists.degenerate.mean( μ:number )\n    Returns the expected value of a degenerate distribution with constant value\n    `μ`.\n"
base.dists.degenerate.median,"\nbase.dists.degenerate.median( μ:number )\n    Returns the median of a degenerate distribution with constant value `μ`.\n"
base.dists.degenerate.mgf,"\nbase.dists.degenerate.mgf( x:number, μ:number )\n    Evaluates the moment-generating function (MGF) for a degenerate distribution\n    with mean `μ`.\n"
base.dists.degenerate.mgf.factory,"\nbase.dists.degenerate.mgf.factory( μ:number )\n    Returns a function for evaluating the moment-generating function (MGF) of a\n    degenerate distribution with mean `μ`.\n"
base.dists.degenerate.mode,"\nbase.dists.degenerate.mode( μ:number )\n    Returns the mode of a degenerate distribution with constant value `μ`.\n"
base.dists.degenerate.pdf,"\nbase.dists.degenerate.pdf( x:number, μ:number )\n    Evaluates the probability density function (PDF) for a degenerate\n    distribution with mean `μ`.\n"
base.dists.degenerate.pdf.factory,"\nbase.dists.degenerate.pdf.factory( μ:number )\n    Returns a function for evaluating the probability density function (PDF) of\n    a degenerate distribution with mean `μ`.\n"
base.dists.degenerate.pmf,"\nbase.dists.degenerate.pmf( x:number, μ:number )\n    Evaluates the probability mass function (PMF) for a degenerate distribution\n    with mean `μ`.\n"
base.dists.degenerate.pmf.factory,"\nbase.dists.degenerate.pmf.factory( μ:number )\n    Returns a function for evaluating the probability mass function (PMF) of a\n    degenerate distribution with mean `μ`.\n"
base.dists.degenerate.quantile,"\nbase.dists.degenerate.quantile( p:number, μ:number )\n    Evaluates the quantile function for a degenerate distribution with mean `μ`.\n"
base.dists.degenerate.quantile.factory,"\nbase.dists.degenerate.quantile.factory( μ:number )\n    Returns a function for evaluating the quantile function of a degenerate\n    distribution with mean `μ`.\n"
base.dists.degenerate.stdev,"\nbase.dists.degenerate.stdev( μ:number )\n    Returns the standard deviation of a degenerate distribution with constant\n    value `μ`.\n"
base.dists.degenerate.variance,"\nbase.dists.degenerate.variance( μ:number )\n    Returns the variance of a degenerate distribution with constant value `μ`.\n"
base.dists.discreteUniform.cdf,"\nbase.dists.discreteUniform.cdf( x:number, a:integer, b:integer )\n    Evaluates the cumulative distribution function (CDF) for a discrete uniform\n    distribution with minimum support `a` and maximum support `b` at a value\n    `x`.\n"
base.dists.discreteUniform.cdf.factory,"\nbase.dists.discreteUniform.cdf.factory( a:integer, b:integer )\n    Returns a function for evaluating the cumulative distribution function (CDF)\n    of a discrete uniform distribution with minimum support `a` and maximum\n    support `b`.\n"
base.dists.discreteUniform.DiscreteUniform,"\nbase.dists.discreteUniform.DiscreteUniform( [a:integer, b:integer] )\n    Returns a discrete uniform distribution object.\n"
base.dists.discreteUniform.kurtosis,"\nbase.dists.discreteUniform.kurtosis( a:integer, b:integer )\n    Returns the excess kurtosis of a discrete uniform distribution.\n"
base.dists.discreteUniform.logcdf,"\nbase.dists.discreteUniform.logcdf( x:number, a:integer, b:integer )\n    Evaluates the natural logarithm of the cumulative distribution function\n    (CDF) for a discrete uniform distribution with minimum support `a` and\n    maximum support `b` at a value `x`.\n"
base.dists.discreteUniform.logcdf.factory,"\nbase.dists.discreteUniform.logcdf.factory( a:integer, b:integer )\n    Returns a function for evaluating the natural logarithm of the cumulative\n    distribution function (CDF) of a discrete uniform distribution with minimum\n    support `a` and maximum support `b`.\n"
base.dists.discreteUniform.logpmf,"\nbase.dists.discreteUniform.logpmf( x:number, a:integer, b:integer )\n    Evaluates the natural logarithm of the probability mass function (PMF) for a\n    discrete uniform distribution with minimum support `a` and maximum support\n    `b` at a value `x`.\n"
base.dists.discreteUniform.logpmf.factory,"\nbase.dists.discreteUniform.logpmf.factory( a:integer, b:integer )\n    Returns a function for evaluating the natural logarithm of the probability\n    mass function (PMF) of a discrete uniform distribution with minimum support\n    `a` and maximum support `b`.\n"
base.dists.discreteUniform.mean,"\nbase.dists.discreteUniform.mean( a:integer, b:integer )\n    Returns the expected value of a discrete uniform distribution.\n"
base.dists.discreteUniform.median,"\nbase.dists.discreteUniform.median( a:integer, b:integer )\n    Returns the median of a discrete uniform distribution.\n"
base.dists.discreteUniform.mgf,"\nbase.dists.discreteUniform.mgf( t:number, a:integer, b:integer )\n    Evaluates the moment-generating function (MGF) for a discrete uniform\n    distribution with minimum support `a` and maximum support `b` at a value\n    `t`.\n"
base.dists.discreteUniform.mgf.factory,"\nbase.dists.discreteUniform.mgf.factory( a:integer, b:integer )\n    Returns a function for evaluating the moment-generating function (MGF)\n    of a discrete uniform distribution with minimum support `a` and maximum\n    support `b`.\n"
base.dists.discreteUniform.pmf,"\nbase.dists.discreteUniform.pmf( x:number, a:integer, b:integer )\n    Evaluates the probability mass function (PMF) for a discrete uniform\n    distribution with minimum support `a` and maximum support `b` at a value\n    `x`.\n"
base.dists.discreteUniform.pmf.factory,"\nbase.dists.discreteUniform.pmf.factory( a:integer, b:integer )\n    Returns a function for evaluating the probability mass function (PMF) of\n    a discrete uniform distribution with minimum support `a` and maximum support\n    `b`.\n"
base.dists.discreteUniform.quantile,"\nbase.dists.discreteUniform.quantile( p:number, a:integer, b:integer )\n    Evaluates the quantile function for a discrete uniform distribution with\n    minimum support `a` and maximum support `b` at a probability `p`.\n"
base.dists.discreteUniform.quantile.factory,"\nbase.dists.discreteUniform.quantile.factory( a:integer, b:integer )\n    Returns a function for evaluating the quantile function of a discrete\n    uniform distribution with minimum support `a` and maximum support `b`.\n"
base.dists.discreteUniform.skewness,"\nbase.dists.discreteUniform.skewness( a:integer, b:integer )\n    Returns the skewness of a discrete uniform distribution.\n"
base.dists.discreteUniform.stdev,"\nbase.dists.discreteUniform.stdev( a:integer, b:integer )\n    Returns the standard deviation of a discrete uniform distribution.\n"
base.dists.discreteUniform.variance,"\nbase.dists.discreteUniform.variance( a:integer, b:integer )\n    Returns the variance of a discrete uniform distribution.\n"
base.dists.erlang.cdf,"\nbase.dists.erlang.cdf( x:number, k:number, λ:number )\n    Evaluates the cumulative distribution function (CDF) for an Erlang\n    distribution with shape parameter `k` and rate parameter `λ` at a value\n    `x`.\n"
base.dists.erlang.cdf.factory,"\nbase.dists.erlang.cdf.factory( k:number, λ:number )\n    Returns a function for evaluating the cumulative distribution function (CDF)\n    of an Erlang distribution with shape parameter `k` and rate parameter `λ`.\n"
base.dists.erlang.entropy,"\nbase.dists.erlang.entropy( k:integer, λ:number )\n    Returns the differential entropy of an Erlang distribution (in nats).\n"
base.dists.erlang.Erlang,"\nbase.dists.erlang.Erlang( [k:number, λ:number] )\n    Returns an Erlang distribution object.\n"
base.dists.erlang.kurtosis,"\nbase.dists.erlang.kurtosis( k:integer, λ:number )\n    Returns the excess kurtosis of an Erlang distribution.\n"
base.dists.erlang.logpdf,"\nbase.dists.erlang.logpdf( x:number, k:number, λ:number )\n    Evaluates the natural logarithm of the probability density function (PDF)\n    for an Erlang distribution with shape parameter `k` and rate parameter `λ`\n    at a value `x`.\n"
base.dists.erlang.logpdf.factory,"\nbase.dists.erlang.logpdf.factory( k:number, λ:number )\n    Returns a function for evaluating the natural logarithm of the probability\n    density function (PDF) of an Erlang distribution with shape parameter `k`\n    and rate parameter `λ`.\n"
base.dists.erlang.mean,"\nbase.dists.erlang.mean( k:integer, λ:number )\n    Returns the expected value of an Erlang distribution.\n"
base.dists.erlang.mgf,"\nbase.dists.erlang.mgf( t:number, k:number, λ:number )\n    Evaluates the moment-generating function (MGF) for an Erlang distribution\n    with shape parameter `k` and rate parameter `λ` at a value `t`.\n"
base.dists.erlang.mgf.factory,"\nbase.dists.erlang.mgf.factory( k:number, λ:number )\n    Returns a function for evaluating the moment-generating function (MGF) of an\n    Erlang distribution with shape parameter `k` and rate parameter `λ`.\n"
base.dists.erlang.mode,"\nbase.dists.erlang.mode( k:integer, λ:number )\n    Returns the mode of an Erlang distribution.\n"
base.dists.erlang.pdf,"\nbase.dists.erlang.pdf( x:number, k:number, λ:number )\n    Evaluates the probability density function (PDF) for an Erlang distribution\n    with shape parameter `k` and rate parameter `λ` at a value `x`.\n"
base.dists.erlang.pdf.factory,"\nbase.dists.erlang.pdf.factory( k:number, λ:number )\n    Returns a function for evaluating the probability density function (PDF)\n    of an Erlang distribution with shape parameter `k` and rate parameter `λ`.\n"
base.dists.erlang.quantile,"\nbase.dists.erlang.quantile( p:number, k:number, λ:number )\n    Evaluates the quantile function for an Erlang distribution with shape\n    parameter `k` and rate parameter `λ` at a probability `p`.\n"
base.dists.erlang.quantile.factory,"\nbase.dists.erlang.quantile.factory( k:number, λ:number )\n    Returns a function for evaluating the quantile function of an Erlang\n    distribution with shape parameter `k` and rate parameter `λ`.\n"
base.dists.erlang.skewness,"\nbase.dists.erlang.skewness( k:integer, λ:number )\n    Returns the skewness of an Erlang distribution.\n"
base.dists.erlang.stdev,"\nbase.dists.erlang.stdev( k:integer, λ:number )\n    Returns the standard deviation of an Erlang distribution.\n"
base.dists.erlang.variance,"\nbase.dists.erlang.variance( k:integer, λ:number )\n    Returns the variance of an Erlang distribution.\n"
base.dists.exponential.cdf,"\nbase.dists.exponential.cdf( x:number, λ:number )\n    Evaluates the cumulative distribution function (CDF) for an exponential\n    distribution with rate parameter `λ` at a value `x`.\n"
base.dists.exponential.cdf.factory,"\nbase.dists.exponential.cdf.factory( λ:number )\n    Returns a function for evaluating the cumulative distribution function (CDF)\n    for an exponential distribution with rate parameter `λ`.\n"
base.dists.exponential.entropy,"\nbase.dists.exponential.entropy( λ:number )\n    Returns the differential entropy of an exponential distribution.\n"
base.dists.exponential.Exponential,"\nbase.dists.exponential.Exponential( [λ:number] )\n    Returns an exponential distribution object.\n"
base.dists.exponential.kurtosis,"\nbase.dists.exponential.kurtosis( λ:number )\n    Returns the excess kurtosis of an exponential distribution.\n"
base.dists.exponential.logcdf,"\nbase.dists.exponential.logcdf( x:number, λ:number )\n    Evaluates the natural logarithm of the cumulative distribution function\n    (CDF) for an exponential distribution with rate parameter `λ` at a value\n    `x`.\n"
base.dists.exponential.logcdf.factory,"\nbase.dists.exponential.logcdf.factory( λ:number )\n    Returns a function for evaluating the natural logarithm of the cumulative\n    distribution function (CDF) for an exponential distribution with rate\n    parameter `λ`.\n"
base.dists.exponential.logpdf,"\nbase.dists.exponential.logpdf( x:number, λ:number )\n    Evaluates the natural logarithm of the probability density function (PDF)\n    for an exponential distribution with rate parameter `λ` at a value `x`.\n"
base.dists.exponential.logpdf.factory,"\nbase.dists.exponential.logpdf.factory( λ:number )\n    Returns a function for evaluating the natural logarithm of the probability\n    density function (PDF) for an exponential distribution with rate parameter\n    `λ`.\n"
base.dists.exponential.mean,"\nbase.dists.exponential.mean( λ:number )\n    Returns the expected value of an exponential distribution.\n"
base.dists.exponential.median,"\nbase.dists.exponential.median( λ:number )\n    Returns the median of an exponential distribution.\n"
base.dists.exponential.mgf,"\nbase.dists.exponential.mgf( t:number, λ:number )\n    Evaluates the moment-generating function (MGF) for an exponential\n    distribution with rate parameter `λ` at a value `t`.\n"
base.dists.exponential.mgf.factory,"\nbase.dists.exponential.mgf.factory( λ:number )\n    Returns a function for evaluating the moment-generating function (MGF) for\n    an exponential distribution with rate parameter `λ`.\n"
base.dists.exponential.mode,"\nbase.dists.exponential.mode( λ:number )\n    Returns the mode of an exponential distribution.\n"
base.dists.exponential.pdf,"\nbase.dists.exponential.pdf( x:number, λ:number )\n    Evaluates the probability density function (PDF) for an exponential\n    distribution with rate parameter `λ` at a value `x`.\n"
base.dists.exponential.pdf.factory,"\nbase.dists.exponential.pdf.factory( λ:number )\n    Returns a function for evaluating the probability density function (PDF)\n    for an exponential distribution with rate parameter `λ`.\n"
base.dists.exponential.quantile,"\nbase.dists.exponential.quantile( p:number, λ:number )\n    Evaluates the quantile function for an exponential distribution with rate\n    parameter `λ` at a probability `p`.\n"
base.dists.exponential.quantile.factory,"\nbase.dists.exponential.quantile.factory( λ:number )\n    Returns a function for evaluating the quantile function for an exponential\n    distribution with rate parameter `λ`.\n"
base.dists.exponential.skewness,"\nbase.dists.exponential.skewness( λ:number )\n    Returns the skewness of an exponential distribution.\n"
base.dists.exponential.stdev,"\nbase.dists.exponential.stdev( λ:number )\n    Returns the standard deviation of an exponential distribution.\n"
base.dists.exponential.variance,"\nbase.dists.exponential.variance( λ:number )\n    Returns the variance of an exponential distribution.\n"
base.dists.f.cdf,"\nbase.dists.f.cdf( x:number, d1:number, d2:number )\n    Evaluates the cumulative distribution function (CDF) for an F distribution\n    with numerator degrees of freedom `d1` and denominator degrees of freedom\n    `d2` at a value `x`.\n"
base.dists.f.cdf.factory,"\nbase.dists.f.cdf.factory( d1:number, d2:number )\n    Returns a function for evaluating the cumulative distribution function (CDF)\n    of an F distribution with numerator degrees of freedom `d1` and denominator\n    degrees of freedom `d2`.\n"
base.dists.f.entropy,"\nbase.dists.f.entropy( d1:number, d2:number )\n    Returns the differential entropy of an F distribution (in nats).\n"
base.dists.f.F,"\nbase.dists.f.F( [d1:number, d2:number] )\n    Returns an F distribution object.\n"
base.dists.f.kurtosis,"\nbase.dists.f.kurtosis( d1:number, d2:number )\n    Returns the excess kurtosis of an F distribution.\n"
base.dists.f.mean,"\nbase.dists.f.mean( d1:number, d2:number )\n    Returns the expected value of an F distribution.\n"
base.dists.f.mode,"\nbase.dists.f.mode( d1:number, d2:number )\n    Returns the mode of an F distribution.\n"
base.dists.f.pdf,"\nbase.dists.f.pdf( x:number, d1:number, d2:number )\n    Evaluates the probability density function (PDF) for an F distribution with\n    numerator degrees of freedom `d1` and denominator degrees of freedom `d2` at\n    a value `x`.\n"
base.dists.f.pdf.factory,"\nbase.dists.f.pdf.factory( d1:number, d2:number )\n    Returns a function for evaluating the probability density function (PDF) of\n    an F distribution with numerator degrees of freedom `d1` and denominator\n    degrees of freedom `d2`.\n"
base.dists.f.quantile,"\nbase.dists.f.quantile( p:number, d1:number, d2:number )\n    Evaluates the quantile function for an F distribution with numerator degrees\n    of freedom `d1` and denominator degrees of freedom `d2` at a probability\n    `p`.\n"
base.dists.f.quantile.factory,"\nbase.dists.f.quantile.factory( d1:number, d2:number )\n    Returns a function for evaluating the quantile function of an F distribution\n    with numerator degrees of freedom `d1` and denominator degrees of freedom\n    `d2`.\n"
base.dists.f.skewness,"\nbase.dists.f.skewness( d1:number, d2:number )\n    Returns the skewness of an F distribution.\n"
base.dists.f.stdev,"\nbase.dists.f.stdev( d1:number, d2:number )\n    Returns the standard deviation of an F distribution.\n"
base.dists.f.variance,"\nbase.dists.f.variance( d1:number, d2:number )\n    Returns the variance of an F distribution.\n"
base.dists.frechet.cdf,"\nbase.dists.frechet.cdf( x:number, α:number, s:number, m:number )\n    Evaluates the cumulative distribution function (CDF) for a Fréchet\n    distribution with shape parameter `α`, scale parameter `s`, and location\n    `m`.\n"
base.dists.frechet.cdf.factory,"\nbase.dists.frechet.cdf.factory( α:number, s:number, m:number )\n    Returns a function for evaluating the cumulative distribution function (CDF)\n    of a Fréchet distribution with shape parameter `α`, scale parameter `s`, and\n    location `m`.\n"
base.dists.frechet.entropy,"\nbase.dists.frechet.entropy( α:number, s:number, m:number )\n    Returns the differential entropy of a Fréchet distribution with shape\n    parameter `α`, scale parameter `s`, and location `m` (in nats).\n"
base.dists.frechet.Frechet,"\nbase.dists.frechet.Frechet( [α:number, s:number, m:number] )\n    Returns a Fréchet distribution object.\n"
base.dists.frechet.kurtosis,"\nbase.dists.frechet.kurtosis( α:number, s:number, m:number )\n    Returns the excess kurtosis of a Fréchet distribution with shape parameter\n    `α`, scale parameter `s`, and location `m`.\n"
base.dists.frechet.logcdf,"\nbase.dists.frechet.logcdf( x:number, α:number, s:number, m:number )\n    Evaluates the natural logarithm of the cumulative distribution function\n    (CDF) for a Fréchet distribution with shape parameter `α`, scale parameter\n    `s`, and location `m`.\n"
base.dists.frechet.logcdf.factory,"\nbase.dists.frechet.logcdf.factory( α:number, s:number, m:number )\n    Returns a function for evaluating the natural logarithm of the cumulative\n    distribution function (CDF) of a Fréchet distribution with shape parameter\n    `α`, scale parameter `s`, and location `m`.\n"
base.dists.frechet.logpdf,"\nbase.dists.frechet.logpdf( x:number, α:number, s:number, m:number )\n    Evaluates the logarithm of the probability density function (PDF) for a\n    Fréchet distribution with shape parameter `α`, scale parameter `s`, and\n    location `m`.\n"
base.dists.frechet.logpdf.factory,"\nbase.dists.frechet.logpdf.factory( α:number, s:number, m:number )\n    Returns a function for evaluating the logarithm of the probability density\n    function (PDF) of a Fréchet distribution with shape parameter `α`, scale\n    parameter `s`, and location `m`.\n"
base.dists.frechet.mean,"\nbase.dists.frechet.mean( α:number, s:number, m:number )\n    Returns the expected value of a Fréchet distribution with shape parameter\n    `α`, scale parameter `s`, and location `m`.\n"
base.dists.frechet.median,"\nbase.dists.frechet.median( α:number, s:number, m:number )\n    Returns the median of a Fréchet distribution with shape parameter\n    `α`, scale parameter `s`, and location `m`.\n"
base.dists.frechet.mode,"\nbase.dists.frechet.mode( α:number, s:number, m:number )\n    Returns the mode of a Fréchet distribution with shape parameter `α`, scale\n    parameter `s`, and location `m`.\n"
base.dists.frechet.pdf,"\nbase.dists.frechet.pdf( x:number, α:number, s:number, m:number )\n    Evaluates the probability density function (PDF) for a Fréchet distribution\n    with shape parameter `α`, scale parameter `s`, and location `m`.\n"
base.dists.frechet.pdf.factory,"\nbase.dists.frechet.pdf.factory( α:number, s:number, m:number )\n    Returns a function for evaluating the probability density function (PDF) of\n    a Fréchet distribution with shape parameter `α`, scale parameter `s`, and\n    location `m`.\n"
base.dists.frechet.quantile,"\nbase.dists.frechet.quantile( p:number, α:number, s:number, m:number )\n    Evaluates the quantile function for a Fréchet distribution with shape\n    parameter `α`, scale parameter `s`, and location `m`.\n"
base.dists.frechet.quantile.factory,"\nbase.dists.frechet.quantile.factory( α:number, s:number, m:number )\n    Returns a function for evaluating the quantile function of a Fréchet\n    distribution with shape parameter `α`, scale parameter `s`, and location\n    `m`.\n"
base.dists.frechet.skewness,"\nbase.dists.frechet.skewness( α:number, s:number, m:number )\n    Returns the skewness of a Fréchet distribution with shape parameter `α`,\n    scale parameter `s`, and location `m`.\n"
base.dists.frechet.stdev,"\nbase.dists.frechet.stdev( α:number, s:number, m:number )\n    Returns the standard deviation of a Fréchet distribution with shape\n    parameter `α`, scale parameter `s`, and location `m`.\n"
base.dists.frechet.variance,"\nbase.dists.frechet.variance( α:number, s:number, m:number )\n    Returns the variance of a Fréchet distribution with shape parameter `α`,\n    scale parameter `s`, and location `m`.\n"
base.dists.gamma.cdf,"\nbase.dists.gamma.cdf( x:number, α:number, β:number )\n    Evaluates the cumulative distribution function (CDF) for a gamma\n    distribution with shape parameter `α` and rate parameter `β` at a value `x`.\n"
base.dists.gamma.cdf.factory,"\nbase.dists.gamma.cdf.factory( α:number, β:number )\n    Returns a function for evaluating the cumulative distribution function (CDF)\n    of a gamma distribution with shape parameter `α` and rate parameter `β`.\n"
base.dists.gamma.entropy,"\nbase.dists.gamma.entropy( α:number, β:number )\n    Returns the differential entropy of a gamma distribution.\n"
base.dists.gamma.Gamma,"\nbase.dists.gamma.Gamma( [α:number, β:number] )\n    Returns a gamma distribution object.\n"
base.dists.gamma.kurtosis,"\nbase.dists.gamma.kurtosis( α:number, β:number )\n    Returns the excess kurtosis of a gamma distribution.\n"
base.dists.gamma.logcdf,"\nbase.dists.gamma.logcdf( x:number, α:number, β:number )\n    Evaluates the logarithm of the cumulative distribution function (CDF) for a\n    gamma distribution with shape parameter `α` and rate parameter `β` at a\n    value `x`.\n"
base.dists.gamma.logcdf.factory,"\nbase.dists.gamma.logcdf.factory( α:number, β:number )\n    Returns a function for evaluating the logarithm of the cumulative\n    distribution function (CDF) of a gamma distribution with shape parameter `α`\n    and rate parameter `β`.\n"
base.dists.gamma.logpdf,"\nbase.dists.gamma.logpdf( x:number, α:number, β:number )\n    Evaluates the logarithm of the probability density function (PDF) for a\n    gamma distribution with shape parameter `α` and rate parameter `β` at a\n    value `x`.\n"
base.dists.gamma.logpdf.factory,"\nbase.dists.gamma.logpdf.factory( α:number, β:number )\n    Returns a function for evaluating the logarithm of the probability density\n    function (PDF) of a gamma distribution with shape parameter `α` and rate\n    parameter `β`.\n"
base.dists.gamma.mean,"\nbase.dists.gamma.mean( α:number, β:number )\n    Returns the expected value of a gamma distribution.\n"
base.dists.gamma.mgf,"\nbase.dists.gamma.mgf( t:number, α:number, β:number )\n    Evaluates the moment-generating function (MGF) for a gamma distribution with\n    shape parameter `α` and rate parameter `β` at a value `t`.\n"
base.dists.gamma.mgf.factory,"\nbase.dists.gamma.mgf.factory( α:number, β:number )\n    Returns a function for evaluating the moment-generating function (MGF) of a\n    gamma distribution with shape parameter `α` and rate parameter `β`.\n"
base.dists.gamma.mode,"\nbase.dists.gamma.mode( α:number, β:number )\n    Returns the mode of a gamma distribution.\n"
base.dists.gamma.pdf,"\nbase.dists.gamma.pdf( x:number, α:number, β:number )\n    Evaluates the probability density function (PDF) for a gamma distribution\n    with shape parameter `α` and rate parameter `β` at a value `x`.\n"
base.dists.gamma.pdf.factory,"\nbase.dists.gamma.pdf.factory( α:number, β:number )\n    Returns a function for evaluating the probability density function (PDF) of\n    a gamma distribution with shape parameter `α` and rate parameter `β`.\n"
base.dists.gamma.quantile,"\nbase.dists.gamma.quantile( p:number, α:number, β:number )\n    Evaluates the quantile function for a gamma distribution with shape\n    parameter `α` and rate parameter `β` at a probability `p`.\n"
base.dists.gamma.quantile.factory,"\nbase.dists.gamma.quantile.factory( α:number, β:number )\n    Returns a function for evaluating the quantile function of a gamma\n    distribution with shape parameter `α` and rate parameter `β`.\n"
base.dists.gamma.skewness,"\nbase.dists.gamma.skewness( α:number, β:number )\n    Returns the skewness of a gamma distribution.\n"
base.dists.gamma.stdev,"\nbase.dists.gamma.stdev( α:number, β:number )\n    Returns the standard deviation of a gamma distribution.\n"
base.dists.gamma.variance,"\nbase.dists.gamma.variance( α:number, β:number )\n    Returns the variance of a gamma distribution.\n"
base.dists.geometric.cdf,"\nbase.dists.geometric.cdf( x:number, p:number )\n    Evaluates the cumulative distribution function (CDF) for a geometric\n    distribution with success probability `p` at a value `x`.\n"
base.dists.geometric.cdf.factory,"\nbase.dists.geometric.cdf.factory( p:number )\n    Returns a function for evaluating the cumulative distribution function (CDF)\n    of a geometric distribution with success probability `p`.\n"
base.dists.geometric.entropy,"\nbase.dists.geometric.entropy( p:number )\n    Returns the entropy of a geometric distribution with success probability\n    `p` (in nats).\n"
base.dists.geometric.Geometric,"\nbase.dists.geometric.Geometric( [p:number] )\n    Returns a geometric distribution object.\n"
base.dists.geometric.kurtosis,"\nbase.dists.geometric.kurtosis( p:number )\n    Returns the excess kurtosis of a geometric distribution with success\n    probability `p`.\n"
base.dists.geometric.logcdf,"\nbase.dists.geometric.logcdf( x:number, p:number )\n    Evaluates the logarithm of the cumulative distribution function (CDF) for a\n    geometric distribution with success probability `p` at a value `x`.\n"
base.dists.geometric.logcdf.factory,"\nbase.dists.geometric.logcdf.factory( p:number )\n    Returns a function for evaluating the logarithm of the cumulative\n    distribution function (CDF) of a geometric distribution with success\n    probability `p`.\n"
base.dists.geometric.logpmf,"\nbase.dists.geometric.logpmf( x:number, p:number )\n    Evaluates the logarithm of the probability mass function (PMF) for a\n    geometric distribution with success probability `p` at a value `x`.\n"
base.dists.geometric.logpmf.factory,"\nbase.dists.geometric.logpmf.factory( p:number )\n    Returns a function for evaluating the logarithm of the probability mass\n    function (PMF) of a geometric distribution with success probability `p`.\n"
base.dists.geometric.mean,"\nbase.dists.geometric.mean( p:number )\n    Returns the expected value of a geometric distribution with success\n    probability `p`.\n"
base.dists.geometric.median,"\nbase.dists.geometric.median( p:number )\n    Returns the median of a geometric distribution with success probability `p`.\n"
base.dists.geometric.mgf,"\nbase.dists.geometric.mgf( t:number, p:number )\n    Evaluates the moment-generating function (MGF) for a geometric\n    distribution with success probability `p` at a value `t`.\n"
base.dists.geometric.mgf.factory,"\nbase.dists.geometric.mgf.factory( p:number )\n    Returns a function for evaluating the moment-generating function (MGF) of a\n    geometric distribution with success probability `p`.\n"
base.dists.geometric.mode,"\nbase.dists.geometric.mode( p:number )\n    Returns the mode of a geometric distribution with success probability `p`.\n"
base.dists.geometric.pmf,"\nbase.dists.geometric.pmf( x:number, p:number )\n    Evaluates the probability mass function (PMF) for a geometric distribution\n    with success probability `p` at a value `x`.\n"
base.dists.geometric.pmf.factory,"\nbase.dists.geometric.pmf.factory( p:number )\n    Returns a function for evaluating the probability mass function (PMF) of a\n    geometric distribution with success probability `p`.\n"
base.dists.geometric.quantile,"\nbase.dists.geometric.quantile( r:number, p:number )\n    Evaluates the quantile function for a geometric distribution with success\n    probability `p` at a probability `r`.\n"
base.dists.geometric.quantile.factory,"\nbase.dists.geometric.quantile.factory( p:number )\n    Returns a function for evaluating the quantile function of a geometric\n    distribution with success probability `p`.\n"
base.dists.geometric.skewness,"\nbase.dists.geometric.skewness( p:number )\n    Returns the skewness of a geometric distribution with success probability\n    `p`.\n"
base.dists.geometric.stdev,"\nbase.dists.geometric.stdev( p:number )\n    Returns the standard deviation of a geometric distribution with success\n    probability `p`.\n"
base.dists.geometric.variance,"\nbase.dists.geometric.variance( p:number )\n    Returns the variance of a geometric distribution with success probability\n    `p`.\n"
base.dists.gumbel.cdf,"\nbase.dists.gumbel.cdf( x:number, μ:number, β:number )\n    Evaluates the cumulative distribution function (CDF) for a Gumbel\n    distribution with location parameter `μ` and scale parameter `β` at a value\n    `x`.\n"
base.dists.gumbel.cdf.factory,"\nbase.dists.gumbel.cdf.factory( μ:number, β:number )\n    Returns a function for evaluating the cumulative distribution function (CDF)\n    of a Gumbel distribution with location parameter `μ` and scale parameter\n    `β`.\n"
base.dists.gumbel.entropy,"\nbase.dists.gumbel.entropy( μ:number, β:number )\n    Returns the differential entropy of a Gumbel distribution with location\n    parameter `μ` and scale parameter `β` (in nats).\n"
base.dists.gumbel.Gumbel,"\nbase.dists.gumbel.Gumbel( [μ:number, β:number] )\n    Returns a Gumbel distribution object.\n"
base.dists.gumbel.kurtosis,"\nbase.dists.gumbel.kurtosis( μ:number, β:number )\n    Returns the excess kurtosis of a Gumbel distribution with location parameter\n    `μ` and scale parameter `β`.\n"
base.dists.gumbel.logcdf,"\nbase.dists.gumbel.logcdf( x:number, μ:number, β:number )\n    Evaluates the logarithm of the cumulative distribution function (CDF) for a\n    Gumbel distribution with location parameter `μ` and scale parameter `β` at a\n    value `x`.\n"
base.dists.gumbel.logcdf.factory,"\nbase.dists.gumbel.logcdf.factory( μ:number, β:number )\n    Returns a function for evaluating the logarithm of the cumulative\n    distribution function (CDF) of a Gumbel distribution with location parameter\n    `μ` and scale parameter `β`.\n"
base.dists.gumbel.logpdf,"\nbase.dists.gumbel.logpdf( x:number, μ:number, β:number )\n    Evaluates the logarithm of the probability density function (PDF) for a\n    Gumbel distribution with location parameter `μ` and scale parameter `β` at a\n    value `x`.\n"
base.dists.gumbel.logpdf.factory,"\nbase.dists.gumbel.logpdf.factory( μ:number, β:number )\n    Returns a function for evaluating the logarithm of the probability density\n    function (PDF) of a Gumbel distribution with location parameter `μ` and\n    scale parameter `β`.\n"
base.dists.gumbel.mean,"\nbase.dists.gumbel.mean( μ:number, β:number )\n    Returns the expected value of a Gumbel distribution with location parameter\n    `μ` and scale parameter `β`.\n"
base.dists.gumbel.median,"\nbase.dists.gumbel.median( μ:number, β:number )\n    Returns the median of a Gumbel distribution with location parameter `μ` and\n    scale parameter `β`.\n"
base.dists.gumbel.mgf,"\nbase.dists.gumbel.mgf( t:number, μ:number, β:number )\n    Evaluates the moment-generating function (MGF) for a Gumbel distribution\n    with location parameter `μ` and scale parameter `β` at a value `t`.\n"
base.dists.gumbel.mgf.factory,"\nbase.dists.gumbel.mgf.factory( μ:number, β:number )\n    Returns a function for evaluating the moment-generating function (MGF) of a\n    Gumbel distribution with location parameter `μ` and scale parameter `β`.\n"
base.dists.gumbel.mode,"\nbase.dists.gumbel.mode( μ:number, β:number )\n    Returns the mode of a Gumbel distribution with location parameter `μ` and\n    scale parameter `β`.\n"
base.dists.gumbel.pdf,"\nbase.dists.gumbel.pdf( x:number, μ:number, β:number )\n    Evaluates the probability density function (PDF) for a Gumbel distribution\n    with location parameter `μ` and scale parameter `β` at a value `x`.\n"
base.dists.gumbel.pdf.factory,"\nbase.dists.gumbel.pdf.factory( μ:number, β:number )\n    Returns a function for evaluating the probability density function (PDF)\n    of a Gumbel distribution with location parameter `μ` and scale parameter\n    `β`.\n"
base.dists.gumbel.quantile,"\nbase.dists.gumbel.quantile( p:number, μ:number, β:number )\n    Evaluates the quantile function for a Gumbel distribution with location\n    parameter `μ` and scale parameter `β` at a probability `p`.\n"
base.dists.gumbel.quantile.factory,"\nbase.dists.gumbel.quantile.factory( μ:number, β:number )\n    Returns a function for evaluating the quantile function of a Gumbel\n    distribution with location parameter `μ` and scale parameter `β`.\n"
base.dists.gumbel.skewness,"\nbase.dists.gumbel.skewness( μ:number, β:number )\n    Returns the skewness of a Gumbel distribution with location parameter `μ`\n    and scale parameter `β`.\n"
base.dists.gumbel.stdev,"\nbase.dists.gumbel.stdev( μ:number, β:number )\n    Returns the standard deviation of a Gumbel distribution with location\n    parameter `μ` and scale parameter `β`.\n"
base.dists.gumbel.variance,"\nbase.dists.gumbel.variance( μ:number, β:number )\n    Returns the variance of a Gumbel distribution with location parameter `μ`\n    and scale parameter `β`.\n"
base.dists.hypergeometric.cdf,"\nbase.dists.hypergeometric.cdf( x:number, N:integer, K:integer, n:integer )\n    Evaluates the cumulative distribution function (CDF) for a hypergeometric\n    distribution with population size `N`, subpopulation size `K`, and number of\n    draws `n` at a value `x`.\n"
base.dists.hypergeometric.cdf.factory,"\nbase.dists.hypergeometric.cdf.factory( N:integer, K:integer, n:integer )\n    Returns a function for evaluating the cumulative distribution function (CDF)\n    of a hypergeometric distribution with population size `N`, subpopulation\n    size `K`, and number of draws `n`.\n"
base.dists.hypergeometric.Hypergeometric,"\nbase.dists.hypergeometric.Hypergeometric( [N:integer, K:integer, n:integer] )\n    Returns a hypergeometric distribution object.\n"
base.dists.hypergeometric.kurtosis,"\nbase.dists.hypergeometric.kurtosis( N:integer, K:integer, n:integer )\n    Returns the excess kurtosis of a hypergeometric distribution.\n"
base.dists.hypergeometric.logpmf,"\nbase.dists.hypergeometric.logpmf( x:number, N:integer, K:integer, n:integer )\n    Evaluates the natural logarithm of the probability mass function (PMF) for a\n    hypergeometric distribution with population size `N`, subpopulation size\n    `K`, and number of draws `n` at a value `x`.\n"
base.dists.hypergeometric.logpmf.factory,"\nbase.dists.hypergeometric.logpmf.factory( N:integer, K:integer, n:integer )\n    Returns a function for evaluating the natural logarithm of the probability\n    mass function (PMF) of a hypergeometric distribution with population size\n    `N`, subpopulation size `K`, and number of draws `n`.\n"
base.dists.hypergeometric.mean,"\nbase.dists.hypergeometric.mean( N:integer, K:integer, n:integer )\n    Returns the expected value of a hypergeometric distribution.\n"
base.dists.hypergeometric.mode,"\nbase.dists.hypergeometric.mode( N:integer, K:integer, n:integer )\n    Returns the mode of a hypergeometric distribution.\n"
base.dists.hypergeometric.pmf,"\nbase.dists.hypergeometric.pmf( x:number, N:integer, K:integer, n:integer )\n    Evaluates the probability mass function (PMF) for a hypergeometric\n    distribution with population size `N`, subpopulation size `K`, and number of\n    draws `n` at a value `x`.\n"
base.dists.hypergeometric.pmf.factory,"\nbase.dists.hypergeometric.pmf.factory( N:integer, K:integer, n:integer )\n    Returns a function for evaluating the probability mass function (PMF) of a\n    hypergeometric distribution with population size `N`, subpopulation size\n    `K`, and number of draws `n`.\n"
base.dists.hypergeometric.quantile,"\nbase.dists.hypergeometric.quantile( p:number, N:integer, K:integer, n:integer )\n    Evaluates the quantile function for a hypergeometric distribution with\n    population size `N`, subpopulation size `K`, and number of draws `n` at a\n    probability `p`.\n"
base.dists.hypergeometric.quantile.factory,"\nbase.dists.hypergeometric.quantile.factory( N:integer, K:integer, n:integer )\n    Returns a function for evaluating the quantile function of a hypergeometric\n    distribution with population size `N`, subpopulation size `K`, and number of\n    draws `n`.\n"
base.dists.hypergeometric.skewness,"\nbase.dists.hypergeometric.skewness( N:integer, K:integer, n:integer )\n    Returns the skewness of a hypergeometric distribution.\n"
base.dists.hypergeometric.stdev,"\nbase.dists.hypergeometric.stdev( N:integer, K:integer, n:integer )\n    Returns the standard deviation of a hypergeometric distribution.\n"
base.dists.hypergeometric.variance,"\nbase.dists.hypergeometric.variance( N:integer, K:integer, n:integer )\n    Returns the variance of a hypergeometric distribution.\n"
base.dists.invgamma.cdf,"\nbase.dists.invgamma.cdf( x:number, α:number, β:number )\n    Evaluates the cumulative distribution function (CDF) for an inverse gamma\n    distribution with shape parameter `α` and scale parameter `β` at a value\n    `x`.\n"
base.dists.invgamma.cdf.factory,"\nbase.dists.invgamma.cdf.factory( α:number, β:number )\n    Returns a function for evaluating the cumulative distribution function (CDF)\n    of an inverse gamma distribution with shape parameter `α` and scale\n    parameter `β`.\n"
base.dists.invgamma.entropy,"\nbase.dists.invgamma.entropy( α:number, β:number )\n    Returns the differential entropy of an inverse gamma distribution.\n"
base.dists.invgamma.InvGamma,"\nbase.dists.invgamma.InvGamma( [α:number, β:number] )\n    Returns an inverse gamma distribution object.\n"
base.dists.invgamma.kurtosis,"\nbase.dists.invgamma.kurtosis( α:number, β:number )\n    Returns the excess kurtosis of an inverse gamma distribution.\n"
base.dists.invgamma.logpdf,"\nbase.dists.invgamma.logpdf( x:number, α:number, β:number )\n    Evaluates the natural logarithm of the probability density function (PDF)\n    for an inverse gamma distribution with shape parameter `α` and scale\n    parameter `β` at a value `x`.\n"
base.dists.invgamma.logpdf.factory,"\nbase.dists.invgamma.logpdf.factory( α:number, β:number )\n    Returns a function for evaluating the natural logarithm of the probability\n    density function (PDF) for an inverse gamma distribution with shape\n    parameter `α` and scale parameter `β`.\n"
base.dists.invgamma.mean,"\nbase.dists.invgamma.mean( α:number, β:number )\n    Returns the expected value of an inverse gamma distribution.\n"
base.dists.invgamma.mode,"\nbase.dists.invgamma.mode( α:number, β:number )\n    Returns the mode of an inverse gamma distribution.\n"
base.dists.invgamma.pdf,"\nbase.dists.invgamma.pdf( x:number, α:number, β:number )\n    Evaluates the probability density function (PDF) for an inverse gamma\n    distribution with shape parameter `α` and scale parameter `β` at a value\n    `x`.\n"
base.dists.invgamma.pdf.factory,"\nbase.dists.invgamma.pdf.factory( α:number, β:number )\n    Returns a function for evaluating the probability density function (PDF)\n    of an inverse gamma distribution with shape parameter `α` and scale\n    parameter `β`.\n"
base.dists.invgamma.quantile,"\nbase.dists.invgamma.quantile( p:number, α:number, β:number )\n    Evaluates the quantile function for an inverse gamma distribution with shape\n    parameter `α` and scale parameter `β` at a probability `p`.\n"
base.dists.invgamma.quantile.factory,"\nbase.dists.invgamma.quantile.factory( α:number, β:number )\n    Returns a function for evaluating the quantile function of an inverse gamma\n    distribution with shape parameter `α` and scale parameter `β`.\n"
base.dists.invgamma.skewness,"\nbase.dists.invgamma.skewness( α:number, β:number )\n    Returns the skewness of an inverse gamma distribution.\n"
base.dists.invgamma.stdev,"\nbase.dists.invgamma.stdev( α:number, β:number )\n    Returns the standard deviation of an inverse gamma distribution.\n"
base.dists.invgamma.variance,"\nbase.dists.invgamma.variance( α:number, β:number )\n    Returns the variance of an inverse gamma distribution.\n"
base.dists.kumaraswamy.cdf,"\nbase.dists.kumaraswamy.cdf( x:number, a:number, b:number )\n    Evaluates the cumulative distribution function (CDF) for Kumaraswamy's\n    double bounded distribution with first shape parameter `a` and second shape\n    parameter `b` at a value `x`.\n"
base.dists.kumaraswamy.cdf.factory,"\nbase.dists.kumaraswamy.cdf.factory( a:number, b:number )\n    Returns a function for evaluating the cumulative distribution function (CDF)\n    of a Kumaraswamy's double bounded distribution with first shape parameter\n    `a` and second shape parameter `b`.\n"
base.dists.kumaraswamy.Kumaraswamy,"\nbase.dists.kumaraswamy.Kumaraswamy( [a:number, b:number] )\n    Returns a Kumaraswamy's double bounded distribution object.\n"
base.dists.kumaraswamy.kurtosis,"\nbase.dists.kumaraswamy.kurtosis( a:number, b:number )\n    Returns the excess kurtosis of a Kumaraswamy's double bounded distribution.\n"
base.dists.kumaraswamy.logcdf,"\nbase.dists.kumaraswamy.logcdf( x:number, a:number, b:number )\n    Evaluates the natural logarithm of the cumulative distribution function\n    (CDF) for Kumaraswamy's double bounded distribution with first shape\n    parameter `a` and second shape parameter `b` at a value `x`.\n"
base.dists.kumaraswamy.logcdf.factory,"\nbase.dists.kumaraswamy.logcdf.factory( a:number, b:number )\n    Returns a function for evaluating the natural logarithm of the cumulative\n    distribution function (CDF) of a Kumaraswamy's double bounded distribution\n    with first shape parameter `a` and second shape parameter `b`.\n"
base.dists.kumaraswamy.logpdf,"\nbase.dists.kumaraswamy.logpdf( x:number, a:number, b:number )\n    Evaluates the natural logarithm of the probability density function (PDF)\n    for Kumaraswamy's double bounded distribution with first shape parameter `a`\n    and second shape parameter `b` at a value `x`.\n"
base.dists.kumaraswamy.logpdf.factory,"\nbase.dists.kumaraswamy.logpdf.factory( a:number, b:number )\n    Returns a function for evaluating the natural logarithm of the probability\n    density function (PDF) of a Kumaraswamy's double bounded distribution with\n    first shape parameter `a` and second shape parameter `b`.\n"
base.dists.kumaraswamy.mean,"\nbase.dists.kumaraswamy.mean( a:number, b:number )\n    Returns the mean of a Kumaraswamy's double bounded distribution.\n"
base.dists.kumaraswamy.median,"\nbase.dists.kumaraswamy.median( a:number, b:number )\n    Returns the median of a Kumaraswamy's double bounded distribution.\n"
base.dists.kumaraswamy.mode,"\nbase.dists.kumaraswamy.mode( a:number, b:number )\n    Returns the mode of a Kumaraswamy's double bounded distribution.\n"
base.dists.kumaraswamy.pdf,"\nbase.dists.kumaraswamy.pdf( x:number, a:number, b:number )\n    Evaluates the probability density function (PDF) for Kumaraswamy's double\n    bounded distribution with first shape parameter `a` and second shape\n    parameter `b` at a value `x`.\n"
base.dists.kumaraswamy.pdf.factory,"\nbase.dists.kumaraswamy.pdf.factory( a:number, b:number )\n    Returns a function for evaluating the probability density function (PDF)\n    of a Kumaraswamy's double bounded distribution with first shape parameter\n    `a` and second shape parameter `b`.\n"
base.dists.kumaraswamy.quantile,"\nbase.dists.kumaraswamy.quantile( p:number, a:number, b:number )\n    Evaluates the quantile function for a Kumaraswamy's double bounded\n    distribution with first shape parameter `a` and second shape parameter `b`\n    at a probability `p`.\n"
base.dists.kumaraswamy.quantile.factory,"\nbase.dists.kumaraswamy.quantile.factory( a:number, b:number )\n    Returns a function for evaluating the quantile function of a Kumaraswamy's\n    double bounded distribution with first shape parameter `a` and second shape\n    parameter `b`.\n"
base.dists.kumaraswamy.skewness,"\nbase.dists.kumaraswamy.skewness( a:number, b:number )\n    Returns the skewness of a Kumaraswamy's double bounded distribution.\n"
base.dists.kumaraswamy.stdev,"\nbase.dists.kumaraswamy.stdev( a:number, b:number )\n    Returns the standard deviation of a Kumaraswamy's double bounded\n    distribution.\n"
base.dists.kumaraswamy.variance,"\nbase.dists.kumaraswamy.variance( a:number, b:number )\n    Returns the variance of a Kumaraswamy's double bounded distribution.\n"
base.dists.laplace.cdf,"\nbase.dists.laplace.cdf( x:number, μ:number, b:number )\n    Evaluates the cumulative distribution function (CDF) for a Laplace\n    distribution with scale parameter `b` and location parameter `μ` at a\n    value `x`.\n"
base.dists.laplace.cdf.factory,"\nbase.dists.laplace.cdf.factory( μ:number, b:number )\n    Returns a function for evaluating the cumulative distribution function (CDF)\n    of a Laplace distribution with scale parameter `b` and location parameter\n    `μ`.\n"
base.dists.laplace.entropy,"\nbase.dists.laplace.entropy( μ:number, b:number )\n    Returns the differential entropy of a Laplace distribution with location\n    parameter `μ` and scale parameter `b`.\n"
base.dists.laplace.kurtosis,"\nbase.dists.laplace.kurtosis( μ:number, b:number )\n    Returns the excess kurtosis of a Laplace distribution with location\n    parameter `μ` and scale parameter `b`.\n"
base.dists.laplace.Laplace,"\nbase.dists.laplace.Laplace( [μ:number, b:number] )\n    Returns a Laplace distribution object.\n"
base.dists.laplace.logcdf,"\nbase.dists.laplace.logcdf( x:number, μ:number, b:number )\n    Evaluates the logarithm of the cumulative distribution function (CDF) for a\n    Laplace distribution with scale parameter `b` and location parameter `μ` at\n    a value `x`.\n"
base.dists.laplace.logcdf.factory,"\nbase.dists.laplace.logcdf.factory( μ:number, b:number )\n    Returns a function for evaluating the logarithm of the cumulative\n    distribution function (CDF) of a Laplace distribution with scale parameter\n    `b` and location parameter `μ`.\n"
base.dists.laplace.logpdf,"\nbase.dists.laplace.logpdf( x:number, μ:number, b:number )\n    Evaluates the logarithm of the probability density function (PDF) for a\n    Laplace distribution with scale parameter `b` and location parameter `μ` at\n    a value `x`.\n"
base.dists.laplace.logpdf.factory,"\nbase.dists.laplace.logpdf.factory( μ:number, b:number )\n    Returns a function for evaluating the logarithm of the probability density\n    function (PDF) of a Laplace distribution with scale parameter `b` and\n    location parameter `μ`.\n"
base.dists.laplace.mean,"\nbase.dists.laplace.mean( μ:number, b:number )\n    Returns the expected value of a Laplace distribution with location parameter\n    `μ` and scale parameter `b`.\n"
base.dists.laplace.median,"\nbase.dists.laplace.median( μ:number, b:number )\n    Returns the median of a Laplace distribution with location parameter `μ` and\n    scale parameter `b`.\n"
base.dists.laplace.mgf,"\nbase.dists.laplace.mgf( t:number, μ:number, b:number )\n    Evaluates the moment-generating function (MGF) for a Laplace\n    distribution with scale parameter `b` and location parameter `μ` at a\n    value `t`.\n"
base.dists.laplace.mgf.factory,"\nbase.dists.laplace.mgf.factory( μ:number, b:number )\n    Returns a function for evaluating the moment-generating function (MGF)\n    of a Laplace distribution with scale parameter `b` and location parameter\n    `μ`.\n"
base.dists.laplace.mode,"\nbase.dists.laplace.mode( μ:number, b:number )\n    Returns the mode of a Laplace distribution with location parameter `μ` and\n    scale parameter `b`.\n"
base.dists.laplace.pdf,"\nbase.dists.laplace.pdf( x:number, μ:number, b:number )\n    Evaluates the probability density function (PDF) for a Laplace\n    distribution with scale parameter `b` and location parameter `μ` at a\n    value `x`.\n"
base.dists.laplace.pdf.factory,"\nbase.dists.laplace.pdf.factory( μ:number, b:number )\n    Returns a function for evaluating the probability density function (PDF)\n    of a Laplace distribution with scale parameter `b` and location parameter\n    `μ`.\n"
base.dists.laplace.quantile,"\nbase.dists.laplace.quantile( p:number, μ:number, b:number )\n    Evaluates the quantile function for a Laplace distribution with scale\n    parameter `b` and location parameter `μ` at a probability `p`.\n"
base.dists.laplace.quantile.factory,"\nbase.dists.laplace.quantile.factory( μ:number, b:number )\n    Returns a function for evaluating the quantile function of a Laplace\n    distribution with scale parameter `b` and location parameter `μ`.\n"
base.dists.laplace.skewness,"\nbase.dists.laplace.skewness( μ:number, b:number )\n    Returns the skewness of a Laplace distribution with location parameter `μ`\n    and scale parameter `b`.\n"
base.dists.laplace.stdev,"\nbase.dists.laplace.stdev( μ:number, b:number )\n    Returns the standard deviation of a Laplace distribution with location\n    parameter `μ` and scale parameter `b`.\n"
base.dists.laplace.variance,"\nbase.dists.laplace.variance( μ:number, b:number )\n    Returns the variance of a Laplace distribution with location parameter `μ`\n    and scale parameter `b`.\n"
base.dists.levy.cdf,"\nbase.dists.levy.cdf( x:number, μ:number, c:number )\n    Evaluates the cumulative distribution function (CDF) for a Lévy distribution\n    with location parameter `μ` and scale parameter `c` at a value `x`.\n"
base.dists.levy.cdf.factory,"\nbase.dists.levy.cdf.factory( μ:number, c:number )\n    Returns a function for evaluating the cumulative distribution function (CDF)\n    of a Lévy distribution with location parameter `μ` and scale parameter `c`.\n"
base.dists.levy.entropy,"\nbase.dists.levy.entropy( μ:number, c:number )\n    Returns the entropy of a Lévy distribution with location parameter `μ` and\n    scale parameter `c`.\n"
base.dists.levy.Levy,"\nbase.dists.levy.Levy( [μ:number, c:number] )\n    Returns a Lévy distribution object.\n"
base.dists.levy.logcdf,"\nbase.dists.levy.logcdf( x:number, μ:number, c:number )\n    Evaluates the logarithm of the cumulative distribution function (CDF) for a\n    Lévy distribution with location parameter `μ` and scale parameter `c` at a\n    value `x`.\n"
base.dists.levy.logcdf.factory,"\nbase.dists.levy.logcdf.factory( μ:number, c:number )\n    Returns a function for evaluating the logarithm of the cumulative\n    distribution function (CDF) of a Lévy distribution with location parameter\n    `μ` and scale parameter `c`.\n"
base.dists.levy.logpdf,"\nbase.dists.levy.logpdf( x:number, μ:number, c:number )\n    Evaluates the logarithm of the probability density function (PDF) for a Lévy\n    distribution with location parameter `μ` and scale parameter `c` at a value\n    `x`.\n"
base.dists.levy.logpdf.factory,"\nbase.dists.levy.logpdf.factory( μ:number, c:number )\n    Returns a function for evaluating the logarithm of the probability density\n    function (PDF) of a Lévy distribution with location parameter `μ` and scale\n    parameter `c`.\n"
base.dists.levy.mean,"\nbase.dists.levy.mean( μ:number, c:number )\n    Returns the expected value of a Lévy distribution with location parameter\n    `μ` and scale parameter `c`.\n"
base.dists.levy.median,"\nbase.dists.levy.median( μ:number, c:number )\n    Returns the median of a Lévy distribution with location parameter `μ` and\n    scale parameter `c`.\n"
base.dists.levy.mode,"\nbase.dists.levy.mode( μ:number, c:number )\n    Returns the mode of a Lévy distribution with location parameter `μ` and\n    scale parameter `c`.\n"
base.dists.levy.pdf,"\nbase.dists.levy.pdf( x:number, μ:number, c:number )\n    Evaluates the probability density function (PDF) for a Lévy distribution\n    with location parameter `μ` and scale parameter `c` at a value `x`.\n"
base.dists.levy.pdf.factory,"\nbase.dists.levy.pdf.factory( μ:number, c:number )\n    Returns a function for evaluating the probability density function (PDF) of\n    a Lévy distribution with location parameter `μ` and scale parameter `c`.\n"
base.dists.levy.quantile,"\nbase.dists.levy.quantile( p:number, μ:number, c:number )\n    Evaluates the quantile function for a Lévy distribution with location\n    parameter `μ` and scale parameter `c` at a probability `p`.\n"
base.dists.levy.quantile.factory,"\nbase.dists.levy.quantile.factory( μ:number, c:number )\n    Returns a function for evaluating the quantile function of a Lévy\n    distribution with location parameter `μ` and scale parameter `c`.\n"
base.dists.levy.stdev,"\nbase.dists.levy.stdev( μ:number, c:number )\n    Returns the standard deviation of a Lévy distribution with location\n    parameter `μ` and scale parameter `c`.\n"
base.dists.levy.variance,"\nbase.dists.levy.variance( μ:number, c:number )\n    Returns the variance of a Lévy distribution with location parameter `μ` and\n    scale parameter `c`.\n"
base.dists.logistic.cdf,"\nbase.dists.logistic.cdf( x:number, μ:number, s:number )\n    Evaluates the cumulative distribution function (CDF) for a logistic\n    distribution with location parameter `μ` and scale parameter `s` at a value\n    `x`.\n"
base.dists.logistic.cdf.factory,"\nbase.dists.logistic.cdf.factory( μ:number, s:number )\n    Returns a function for evaluating the cumulative distribution function (CDF)\n    of a logistic distribution with location parameter `μ` and scale parameter\n    `s`.\n"
base.dists.logistic.entropy,"\nbase.dists.logistic.entropy( μ:number, s:number )\n    Returns the entropy of a logistic distribution with location parameter `μ`\n    and scale parameter `s`.\n"
base.dists.logistic.kurtosis,"\nbase.dists.logistic.kurtosis( μ:number, s:number )\n    Returns the excess kurtosis of a logistic distribution with location\n    parameter `μ` and scale parameter `s`.\n"
base.dists.logistic.logcdf,"\nbase.dists.logistic.logcdf( x:number, μ:number, s:number )\n    Evaluates the logarithm of the cumulative distribution function (CDF) for a\n    logistic distribution with location parameter `μ` and scale parameter `s` at\n    a value `x`.\n"
base.dists.logistic.logcdf.factory,"\nbase.dists.logistic.logcdf.factory( μ:number, s:number )\n    Returns a function for evaluating the logarithm of the cumulative\n    distribution function (CDF) of a Logistic distribution with location\n    parameter `μ` and scale parameter `s`.\n"
base.dists.logistic.Logistic,"\nbase.dists.logistic.Logistic( [μ:number, s:number] )\n    Returns a logistic distribution object.\n"
base.dists.logistic.logpdf,"\nbase.dists.logistic.logpdf( x:number, μ:number, s:number )\n    Evaluates the logarithm of the probability density function (PDF) for a\n    logistic distribution with location parameter `μ` and scale parameter `s` at\n    a value `x`.\n"
base.dists.logistic.logpdf.factory,"\nbase.dists.logistic.logpdf.factory( μ:number, s:number )\n    Returns a function for evaluating the logarithm of the probability density\n    function (PDF) of a Logistic distribution with location parameter `μ` and\n    scale parameter `s`.\n"
base.dists.logistic.mean,"\nbase.dists.logistic.mean( μ:number, s:number )\n    Returns the expected value of a logistic distribution with location\n    parameter `μ` and scale parameter `s`.\n"
base.dists.logistic.median,"\nbase.dists.logistic.median( μ:number, s:number )\n    Returns the median of a logistic distribution with location parameter `μ`\n    and scale parameter `s`.\n"
base.dists.logistic.mgf,"\nbase.dists.logistic.mgf( t:number, μ:number, s:number )\n    Evaluates the moment-generating function (MGF) for a logistic distribution\n    with location parameter `μ` and scale parameter `s` at a value `t`.\n"
base.dists.logistic.mgf.factory,"\nbase.dists.logistic.mgf.factory( μ:number, s:number )\n    Returns a function for evaluating the moment-generating function (MGF)\n    of a Logistic distribution with location parameter `μ` and scale parameter\n    `s`.\n"
base.dists.logistic.mode,"\nbase.dists.logistic.mode( μ:number, s:number )\n    Returns the mode of a logistic distribution with location parameter `μ` and\n    scale parameter `s`.\n"
base.dists.logistic.pdf,"\nbase.dists.logistic.pdf( x:number, μ:number, s:number )\n    Evaluates the probability density function (PDF) for a logistic distribution\n    with location parameter `μ` and scale parameter `s` at a value `x`.\n"
base.dists.logistic.pdf.factory,"\nbase.dists.logistic.pdf.factory( μ:number, s:number )\n    Returns a function for evaluating the probability density function (PDF) of\n    a Logistic distribution with location parameter `μ` and scale parameter `s`.\n"
base.dists.logistic.quantile,"\nbase.dists.logistic.quantile( p:number, μ:number, s:number )\n    Evaluates the quantile function for a logistic distribution with location\n    parameter `μ` and scale parameter `s` at a probability `p`.\n"
base.dists.logistic.quantile.factory,"\nbase.dists.logistic.quantile.factory( μ:number, s:number )\n    Returns a function for evaluating the quantile function of a logistic\n    distribution with location parameter `μ` and scale parameter `s`.\n"
base.dists.logistic.skewness,"\nbase.dists.logistic.skewness( μ:number, s:number )\n    Returns the skewness of a logistic distribution with location parameter `μ`\n    and scale parameter `s`.\n"
base.dists.logistic.stdev,"\nbase.dists.logistic.stdev( μ:number, s:number )\n    Returns the standard deviation of a logistic distribution with location\n    parameter `μ` and scale parameter `s`.\n"
base.dists.logistic.variance,"\nbase.dists.logistic.variance( μ:number, s:number )\n    Returns the variance of a logistic distribution with location parameter `μ`\n    and scale parameter `s`.\n"
base.dists.lognormal.cdf,"\nbase.dists.lognormal.cdf( x:number, μ:number, σ:number )\n    Evaluates the cumulative distribution function (CDF) for a lognormal\n    distribution with location parameter `μ` and scale parameter `σ` at a value\n    `x`.\n"
base.dists.lognormal.cdf.factory,"\nbase.dists.lognormal.cdf.factory( μ:number, σ:number )\n    Returns a function for evaluating the cumulative distribution function (CDF)\n    of a lognormal distribution with location parameter `μ` and scale parameter\n    `σ`.\n"
base.dists.lognormal.entropy,"\nbase.dists.lognormal.entropy( μ:number, σ:number )\n    Returns the differential entropy of a lognormal distribution with location\n    `μ` and scale `σ` (in nats).\n"
base.dists.lognormal.kurtosis,"\nbase.dists.lognormal.kurtosis( μ:number, σ:number )\n    Returns the excess kurtosis of a lognormal distribution with location `μ`\n    and scale `σ`.\n"
base.dists.lognormal.LogNormal,"\nbase.dists.lognormal.LogNormal( [μ:number, σ:number] )\n    Returns a lognormal distribution object.\n"
base.dists.lognormal.logpdf,"\nbase.dists.lognormal.logpdf( x:number, μ:number, σ:number )\n    Evaluates the natural logarithm of the probability density function (PDF)\n    for a lognormal distribution with location parameter `μ` and scale parameter\n    `σ` at a value `x`.\n"
base.dists.lognormal.logpdf.factory,"\nbase.dists.lognormal.logpdf.factory( μ:number, σ:number )\n    Returns a function for evaluating the natural logarithm of the probability\n    density function (PDF) of a lognormal distribution with location parameter\n    `μ` and scale parameter `σ`.\n"
base.dists.lognormal.mean,"\nbase.dists.lognormal.mean( μ:number, σ:number )\n    Returns the expected value of a lognormal distribution with location `μ` and\n    scale `σ`.\n"
base.dists.lognormal.median,"\nbase.dists.lognormal.median( μ:number, σ:number )\n    Returns the median of a lognormal distribution with location `μ` and scale\n    `σ`.\n"
base.dists.lognormal.mode,"\nbase.dists.lognormal.mode( μ:number, σ:number )\n    Returns the mode of a lognormal distribution with location `μ` and scale\n    `σ`.\n"
base.dists.lognormal.pdf,"\nbase.dists.lognormal.pdf( x:number, μ:number, σ:number )\n    Evaluates the probability density function (PDF) for a lognormal\n    distribution with location parameter `μ` and scale parameter `σ` at a value\n    `x`.\n"
base.dists.lognormal.pdf.factory,"\nbase.dists.lognormal.pdf.factory( μ:number, σ:number )\n    Returns a function for evaluating the probability density function (PDF) of\n    a lognormal distribution with location parameter `μ` and scale parameter\n    `σ`.\n"
base.dists.lognormal.quantile,"\nbase.dists.lognormal.quantile( p:number, μ:number, σ:number )\n    Evaluates the quantile function for a lognormal distribution with location\n    parameter `μ` and scale parameter `σ` at a probability `p`.\n"
base.dists.lognormal.quantile.factory,"\nbase.dists.lognormal.quantile.factory( μ:number, σ:number )\n    Returns a function for evaluating the quantile function of a lognormal\n    distribution with location parameter `μ` and scale parameter `σ`.\n"
base.dists.lognormal.skewness,"\nbase.dists.lognormal.skewness( μ:number, σ:number )\n    Returns the skewness of a lognormal distribution with location `μ` and scale\n    `σ`.\n"
base.dists.lognormal.stdev,"\nbase.dists.lognormal.stdev( μ:number, σ:number )\n    Returns the standard deviation of a lognormal distribution with location `μ`\n    and scale `σ`.\n"
base.dists.lognormal.variance,"\nbase.dists.lognormal.variance( μ:number, σ:number )\n    Returns the variance of a lognormal distribution with location `μ` and scale\n    `σ`.\n"
base.dists.negativeBinomial.cdf,"\nbase.dists.negativeBinomial.cdf( x:number, r:number, p:number )\n    Evaluates the cumulative distribution function (CDF) for a negative binomial\n    distribution with number of successes until experiment is stopped `r` and\n    success probability `p` at a value `x`.\n"
base.dists.negativeBinomial.cdf.factory,"\nbase.dists.negativeBinomial.cdf.factory( r:number, p:number )\n    Returns a function for evaluating the cumulative distribution function (CDF)\n    of a negative binomial distribution with number of successes until\n    experiment is stopped `r` and success probability `p`.\n"
base.dists.negativeBinomial.kurtosis,"\nbase.dists.negativeBinomial.kurtosis( r:integer, p:number )\n    Returns the excess kurtosis of a negative binomial distribution.\n"
base.dists.negativeBinomial.logpmf,"\nbase.dists.negativeBinomial.logpmf( x:number, r:number, p:number )\n    Evaluates the natural logarithm of the probability mass function (PMF) for a\n    negative binomial distribution with number of successes until experiment is\n    stopped `r` and success probability `p` at a value `x`.\n"
base.dists.negativeBinomial.logpmf.factory,"\nbase.dists.negativeBinomial.logpmf.factory( r:number, p:number )\n    Returns a function for evaluating the natural logarithm of the probability\n    mass function (PMF) of a negative binomial distribution with number of\n    successes until experiment is stopped `r` and success probability `p`.\n"
base.dists.negativeBinomial.mean,"\nbase.dists.negativeBinomial.mean( r:integer, p:number )\n    Returns the expected value of a negative binomial distribution.\n"
base.dists.negativeBinomial.mgf,"\nbase.dists.negativeBinomial.mgf( x:number, r:number, p:number )\n    Evaluates the moment-generating function (MGF) for a negative binomial\n    distribution with number of successes until experiment is stopped `r` and\n    success probability `p` at a value `t`.\n"
base.dists.negativeBinomial.mgf.factory,"\nbase.dists.negativeBinomial.mgf.factory( r:number, p:number )\n    Returns a function for evaluating the moment-generating function (MGF) of a\n    negative binomial distribution with number of successes until experiment is\n    stopped `r` and success probability `p`.\n"
base.dists.negativeBinomial.mode,"\nbase.dists.negativeBinomial.mode( r:integer, p:number )\n    Returns the mode of a negative binomial distribution.\n"
base.dists.negativeBinomial.NegativeBinomial,"\nbase.dists.negativeBinomial.NegativeBinomial( [r:number, p:number] )\n    Returns a negative binomial distribution object.\n"
base.dists.negativeBinomial.pmf,"\nbase.dists.negativeBinomial.pmf( x:number, r:number, p:number )\n    Evaluates the probability mass function (PMF) for a negative binomial\n    distribution with number of successes until experiment is stopped `r` and\n    success probability `p` at a value `x`.\n"
base.dists.negativeBinomial.pmf.factory,"\nbase.dists.negativeBinomial.pmf.factory( r:number, p:number )\n    Returns a function for evaluating the probability mass function (PMF) of a\n    negative binomial distribution with number of successes until experiment is\n    stopped `r` and success probability `p`.\n"
base.dists.negativeBinomial.quantile,"\nbase.dists.negativeBinomial.quantile( k:number, r:number, p:number )\n    Evaluates the quantile function for a negative binomial distribution with\n    number of successes until experiment is stopped `r` and success probability\n    `p` at a probability `k`.\n"
base.dists.negativeBinomial.quantile.factory,"\nbase.dists.negativeBinomial.quantile.factory( r:number, p:number )\n    Returns a function for evaluating the quantile function of a negative\n    binomial distribution with number of successes until experiment is stopped\n    `r` and success probability `p`.\n"
base.dists.negativeBinomial.skewness,"\nbase.dists.negativeBinomial.skewness( r:integer, p:number )\n    Returns the skewness of a negative binomial distribution.\n"
base.dists.negativeBinomial.stdev,"\nbase.dists.negativeBinomial.stdev( r:integer, p:number )\n    Returns the standard deviation of a negative binomial distribution.\n"
base.dists.negativeBinomial.variance,"\nbase.dists.negativeBinomial.variance( r:integer, p:number )\n    Returns the variance of a negative binomial distribution.\n"
base.dists.normal.cdf,"\nbase.dists.normal.cdf( x:number, μ:number, σ:number )\n    Evaluates the cumulative distribution function (CDF) for a normal\n    distribution with mean `μ` and standard deviation `σ` at a value `x`.\n"
base.dists.normal.cdf.factory,"\nbase.dists.normal.cdf.factory( μ:number, σ:number )\n    Returns a function for evaluating the cumulative distribution function (CDF)\n    of a normal distribution with mean `μ` and standard deviation `σ`.\n"
base.dists.normal.entropy,"\nbase.dists.normal.entropy( μ:number, σ:number )\n    Returns the differential entropy of a normal distribution with mean `μ` and\n    standard deviation `σ`.\n"
base.dists.normal.kurtosis,"\nbase.dists.normal.kurtosis( μ:number, σ:number )\n    Returns the excess kurtosis of a normal distribution with mean `μ` and\n    standard deviation `σ`.\n"
base.dists.normal.logpdf,"\nbase.dists.normal.logpdf( x:number, μ:number, σ:number )\n    Evaluates the natural logarithm of the probability density function (PDF)\n    for a normal distribution with mean `μ` and standard deviation `σ` at a\n    value `x`.\n"
base.dists.normal.logpdf.factory,"\nbase.dists.normal.logpdf.factory( μ:number, σ:number )\n    Returns a function for evaluating the natural logarithm of the probability\n    density function (PDF) of a normal distribution with mean `μ` and standard\n    deviation `σ`.\n"
base.dists.normal.mean,"\nbase.dists.normal.mean( μ:number, σ:number )\n    Returns the expected value of a normal distribution with mean `μ` and\n    standard deviation `σ`.\n"
base.dists.normal.median,"\nbase.dists.normal.median( μ:number, σ:number )\n    Returns the median of a normal distribution with mean `μ` and standard\n    deviation `σ`.\n"
base.dists.normal.mgf,"\nbase.dists.normal.mgf( x:number, μ:number, σ:number )\n    Evaluates the moment-generating function (MGF) for a normal distribution\n    with mean `μ` and standard deviation `σ` at a value `t`.\n"
base.dists.normal.mgf.factory,"\nbase.dists.normal.mgf.factory( μ:number, σ:number )\n    Returns a function for evaluating the moment-generating function (MGF) of a\n    normal distribution with mean `μ` and standard deviation `σ`.\n"
base.dists.normal.mode,"\nbase.dists.normal.mode( μ:number, σ:number )\n    Returns the mode of a normal distribution with mean `μ` and standard\n    deviation `σ`.\n"
base.dists.normal.Normal,"\nbase.dists.normal.Normal( [μ:number, σ:number] )\n    Returns a normal distribution object.\n"
base.dists.normal.pdf,"\nbase.dists.normal.pdf( x:number, μ:number, σ:number )\n    Evaluates the probability density function (PDF) for a normal distribution\n    with mean `μ` and standard deviation `σ` at a value `x`.\n"
base.dists.normal.pdf.factory,"\nbase.dists.normal.pdf.factory( μ:number, σ:number )\n    Returns a function for evaluating the probability density function (PDF) of\n    a normal distribution with mean `μ` and standard deviation `σ`.\n"
base.dists.normal.quantile,"\nbase.dists.normal.quantile( p:number, μ:number, σ:number )\n    Evaluates the quantile function for a normal distribution with mean `μ` and\n    standard deviation `σ` at a probability `p`.\n"
base.dists.normal.quantile.factory,"\nbase.dists.normal.quantile.factory( μ:number, σ:number )\n    Returns a function for evaluating the quantile function\n    of a normal distribution with mean `μ` and standard deviation `σ`.\n"
base.dists.normal.skewness,"\nbase.dists.normal.skewness( μ:number, σ:number )\n    Returns the skewness of a normal distribution with mean `μ` and standard\n    deviation `σ`.\n"
base.dists.normal.stdev,"\nbase.dists.normal.stdev( μ:number, σ:number )\n    Returns the standard deviation of a normal distribution with mean `μ` and\n    standard deviation `σ`.\n"
base.dists.normal.variance,"\nbase.dists.normal.variance( μ:number, σ:number )\n    Returns the variance of a normal distribution with mean `μ` and standard\n    deviation `σ`.\n"
base.dists.pareto1.cdf,"\nbase.dists.pareto1.cdf( x:number, α:number, β:number )\n    Evaluates the cumulative distribution function (CDF) for a Pareto (Type I)\n    distribution with shape parameter `α` and scale parameter `β` at a value\n    `x`.\n"
base.dists.pareto1.cdf.factory,"\nbase.dists.pareto1.cdf.factory( α:number, β:number )\n    Returns a function for evaluating the cumulative distribution function (CDF)\n    of a Pareto (Type I) distribution with shape parameter `α` and scale\n    parameter `β`.\n"
base.dists.pareto1.entropy,"\nbase.dists.pareto1.entropy( α:number, β:number )\n    Returns the differential entropy of a Pareto (Type I) distribution\n    (in nats).\n"
base.dists.pareto1.kurtosis,"\nbase.dists.pareto1.kurtosis( α:number, β:number )\n    Returns the excess kurtosis of a Pareto (Type I) distribution.\n"
base.dists.pareto1.logcdf,"\nbase.dists.pareto1.logcdf( x:number, α:number, β:number )\n    Evaluates the natural logarithm of the cumulative distribution function\n    (CDF) for a Pareto (Type I) distribution with shape parameter `α` and scale\n    parameter `β` at a value `x`.\n"
base.dists.pareto1.logcdf.factory,"\nbase.dists.pareto1.logcdf.factory( α:number, β:number )\n    Returns a function for evaluating the natural logarithm of the cumulative\n    distribution function (CDF) of a Pareto (Type I) distribution with shape\n    parameter `α` and scale parameter `β`.\n"
base.dists.pareto1.logpdf,"\nbase.dists.pareto1.logpdf( x:number, α:number, β:number )\n    Evaluates the natural logarithm of the probability density function (PDF)\n    for a Pareto (Type I) distribution with shape parameter `α` and scale\n    parameter `β` at a value `x`.\n"
base.dists.pareto1.logpdf.factory,"\nbase.dists.pareto1.logpdf.factory( α:number, β:number )\n    Returns a function for evaluating the natural logarithm of the probability\n    density function (PDF) of a Pareto (Type I) distribution with shape\n    parameter `α` and scale parameter `β`.\n"
base.dists.pareto1.mean,"\nbase.dists.pareto1.mean( α:number, β:number )\n    Returns the expected value of a Pareto (Type I) distribution.\n"
base.dists.pareto1.median,"\nbase.dists.pareto1.median( α:number, β:number )\n    Returns the median of a Pareto (Type I) distribution.\n"
base.dists.pareto1.mode,"\nbase.dists.pareto1.mode( α:number, β:number )\n    Returns the mode of a Pareto (Type I) distribution.\n"
base.dists.pareto1.Pareto1,"\nbase.dists.pareto1.Pareto1( [α:number, β:number] )\n    Returns a Pareto (Type I) distribution object.\n"
base.dists.pareto1.pdf,"\nbase.dists.pareto1.pdf( x:number, α:number, β:number )\n    Evaluates the probability density function (PDF) for a Pareto (Type I)\n    distribution with shape parameter `α` and scale parameter `β` at a value\n    `x`.\n"
base.dists.pareto1.pdf.factory,"\nbase.dists.pareto1.pdf.factory( α:number, β:number )\n    Returns a function for evaluating the probability density function (PDF) of\n    a Pareto (Type I) distribution with shape parameter `α` and scale parameter\n    `β`.\n"
base.dists.pareto1.quantile,"\nbase.dists.pareto1.quantile( p:number, α:number, β:number )\n    Evaluates the quantile function for a Pareto (Type I) distribution with\n    shape parameter `α` and scale parameter `β` at a probability `p`.\n"
base.dists.pareto1.quantile.factory,"\nbase.dists.pareto1.quantile.factory( α:number, β:number )\n    Returns a function for evaluating the quantile function of a Pareto (Type I)\n    distribution with shape parameter `α` and scale parameter `β`.\n"
base.dists.pareto1.skewness,"\nbase.dists.pareto1.skewness( α:number, β:number )\n    Returns the skewness of a Pareto (Type I) distribution.\n"
base.dists.pareto1.stdev,"\nbase.dists.pareto1.stdev( α:number, β:number )\n    Returns the standard deviation of a Pareto (Type I) distribution.\n"
base.dists.pareto1.variance,"\nbase.dists.pareto1.variance( α:number, β:number )\n    Returns the variance of a Pareto (Type I) distribution.\n"
base.dists.poisson.cdf,"\nbase.dists.poisson.cdf( x:number, λ:number )\n    Evaluates the cumulative distribution function (CDF) for a Poisson\n    distribution with mean parameter `λ` at a value `x`.\n"
base.dists.poisson.cdf.factory,"\nbase.dists.poisson.cdf.factory( λ:number )\n    Returns a function for evaluating the cumulative distribution function (CDF)\n    of a Poisson distribution with mean parameter `λ`.\n"
base.dists.poisson.entropy,"\nbase.dists.poisson.entropy( λ:number )\n    Returns the entropy of a Poisson distribution.\n"
base.dists.poisson.kurtosis,"\nbase.dists.poisson.kurtosis( λ:number )\n    Returns the excess kurtosis of a Poisson distribution.\n"
base.dists.poisson.logpmf,"\nbase.dists.poisson.logpmf( x:number, λ:number )\n    Evaluates the natural logarithm of the probability mass function (PMF) for a\n    Poisson distribution with mean parameter `λ` at a value `x`.\n"
base.dists.poisson.logpmf.factory,"\nbase.dists.poisson.logpmf.factory( λ:number )\n    Returns a function for evaluating the natural logarithm of the probability\n    mass function (PMF) of a Poisson distribution with mean parameter `λ`.\n"
base.dists.poisson.mean,"\nbase.dists.poisson.mean( λ:number )\n    Returns the expected value of a Poisson distribution.\n"
base.dists.poisson.median,"\nbase.dists.poisson.median( λ:number )\n    Returns the median of a Poisson distribution.\n"
base.dists.poisson.mgf,"\nbase.dists.poisson.mgf( x:number, λ:number )\n    Evaluates the moment-generating function (MGF) for a Poisson distribution\n    with mean parameter `λ` at a value `x`.\n"
base.dists.poisson.mgf.factory,"\nbase.dists.poisson.mgf.factory( λ:number )\n    Returns a function for evaluating the moment-generating function (MGF) of a\n    Poisson distribution with mean parameter `λ`.\n"
base.dists.poisson.mode,"\nbase.dists.poisson.mode( λ:number )\n    Returns the mode of a Poisson distribution.\n"
base.dists.poisson.pmf,"\nbase.dists.poisson.pmf( x:number, λ:number )\n    Evaluates the probability mass function (PMF) for a Poisson\n    distribution with mean parameter `λ` at a value `x`.\n"
base.dists.poisson.pmf.factory,"\nbase.dists.poisson.pmf.factory( λ:number )\n    Returns a function for evaluating the probability mass function (PMF)\n    of a Poisson distribution with mean parameter `λ`.\n"
base.dists.poisson.Poisson,"\nbase.dists.poisson.Poisson( [λ:number] )\n    Returns a Poisson distribution object.\n"
base.dists.poisson.quantile,"\nbase.dists.poisson.quantile( p:number, λ:number )\n    Evaluates the quantile function for a Poisson distribution with mean\n    parameter `λ` at a probability `p`.\n"
base.dists.poisson.quantile.factory,"\nbase.dists.poisson.quantile.factory( λ:number )\n    Returns a function for evaluating the quantile function of a Poisson\n    distribution with mean parameter `λ`.\n"
base.dists.poisson.skewness,"\nbase.dists.poisson.skewness( λ:number )\n    Returns the skewness of a Poisson distribution.\n"
base.dists.poisson.stdev,"\nbase.dists.poisson.stdev( λ:number )\n    Returns the standard deviation of a Poisson distribution.\n"
base.dists.poisson.variance,"\nbase.dists.poisson.variance( λ:number )\n    Returns the variance of a Poisson distribution.\n"
base.dists.rayleigh.cdf,"\nbase.dists.rayleigh.cdf( x:number, sigma:number )\n    Evaluates the cumulative distribution function (CDF) for a Rayleigh\n    distribution with scale parameter `sigma` at a value `x`.\n"
base.dists.rayleigh.cdf.factory,"\nbase.dists.rayleigh.cdf.factory( sigma:number )\n    Returns a function for evaluating the cumulative distribution function (CDF)\n    of a Rayleigh distribution with scale parameter `sigma`.\n"
base.dists.rayleigh.entropy,"\nbase.dists.rayleigh.entropy( σ:number )\n    Returns the differential entropy of a Rayleigh distribution.\n"
base.dists.rayleigh.kurtosis,"\nbase.dists.rayleigh.kurtosis( σ:number )\n    Returns the excess kurtosis of a Rayleigh distribution.\n"
base.dists.rayleigh.logcdf,"\nbase.dists.rayleigh.logcdf( x:number, sigma:number )\n    Evaluates the logarithm of the cumulative distribution function (CDF) for a\n    Rayleigh distribution with scale parameter `sigma` at a value `x`.\n"
base.dists.rayleigh.logcdf.factory,"\nbase.dists.rayleigh.logcdf.factory( sigma:number )\n    Returns a function for evaluating the logarithm of the cumulative\n    distribution function (CDF) of a Rayleigh distribution with scale parameter\n    `sigma`.\n"
base.dists.rayleigh.logpdf,"\nbase.dists.rayleigh.logpdf( x:number, sigma:number )\n    Evaluates the logarithm of the probability density function (PDF) for a\n    Rayleigh distribution with scale parameter `sigma` at a value `x`.\n"
base.dists.rayleigh.logpdf.factory,"\nbase.dists.rayleigh.logpdf.factory( sigma:number )\n    Returns a function for evaluating the logarithm of the probability density\n    function (PDF) of a Rayleigh distribution with scale parameter `sigma`.\n"
base.dists.rayleigh.mean,"\nbase.dists.rayleigh.mean( σ:number )\n    Returns the expected value of a Rayleigh distribution.\n"
base.dists.rayleigh.median,"\nbase.dists.rayleigh.median( σ:number )\n    Returns the median of a Rayleigh distribution.\n"
base.dists.rayleigh.mgf,"\nbase.dists.rayleigh.mgf( t:number, sigma:number )\n    Evaluates the moment-generating function (MGF) for a Rayleigh distribution\n    with scale parameter `sigma` at a value `t`.\n"
base.dists.rayleigh.mgf.factory,"\nbase.dists.rayleigh.mgf.factory( sigma:number )\n    Returns a function for evaluating the moment-generating function (MGF) of a\n    Rayleigh distribution with scale parameter `sigma`.\n"
base.dists.rayleigh.mode,"\nbase.dists.rayleigh.mode( σ:number )\n    Returns the mode of a Rayleigh distribution.\n"
base.dists.rayleigh.pdf,"\nbase.dists.rayleigh.pdf( x:number, sigma:number )\n    Evaluates the probability density function (PDF) for a Rayleigh\n    distribution with scale parameter `sigma` at a value `x`.\n"
base.dists.rayleigh.pdf.factory,"\nbase.dists.rayleigh.pdf.factory( sigma:number )\n    Returns a function for evaluating the probability density function (PDF) of\n    a Rayleigh distribution with scale parameter `sigma`.\n"
base.dists.rayleigh.quantile,"\nbase.dists.rayleigh.quantile( p:number, sigma:number )\n    Evaluates the quantile function for a Rayleigh distribution with scale\n    parameter `sigma` at a probability `p`.\n"
base.dists.rayleigh.quantile.factory,"\nbase.dists.rayleigh.quantile.factory( sigma:number )\n    Returns a function for evaluating the quantile function of a Rayleigh\n    distribution with scale parameter `sigma`.\n"
base.dists.rayleigh.Rayleigh,"\nbase.dists.rayleigh.Rayleigh( [σ:number] )\n    Returns a Rayleigh distribution object.\n"
base.dists.rayleigh.skewness,"\nbase.dists.rayleigh.skewness( σ:number )\n    Returns the skewness of a Rayleigh distribution.\n"
base.dists.rayleigh.stdev,"\nbase.dists.rayleigh.stdev( σ:number )\n    Returns the standard deviation of a Rayleigh distribution.\n"
base.dists.rayleigh.variance,"\nbase.dists.rayleigh.variance( σ:number )\n    Returns the variance of a Rayleigh distribution.\n"
base.dists.signrank.cdf,"\nbase.dists.signrank.cdf( x:number, n:integer )\n    Evaluates the cumulative distribution function (CDF) for the distribution of\n    the Wilcoxon signed rank test statistic with `n` observations.\n"
base.dists.signrank.cdf.factory,"\nbase.dists.signrank.cdf.factory( n:integer )\n    Returns a function for evaluating the cumulative distribution function (CDF)\n    of the distribution of the Wilcoxon signed rank test statistic.\n"
base.dists.signrank.pdf,"\nbase.dists.signrank.pdf( x:number, n:integer )\n    Evaluates the probability density function (PDF) for the distribution of\n    the Wilcoxon signed rank test statistic with `n` observations.\n"
base.dists.signrank.pdf.factory,"\nbase.dists.signrank.pdf.factory( n:integer )\n    Returns a function for evaluating the probability density function (PDF)\n    of the distribution of the Wilcoxon signed rank test statistic.\n"
base.dists.signrank.quantile,"\nbase.dists.signrank.quantile( p:number, n:integer )\n    Evaluates the quantile function for the Wilcoxon signed rank test statistic\n    with `n` observations at a probability `p`.\n"
base.dists.signrank.quantile.factory,"\nbase.dists.signrank.quantile.factory( n:integer )\n    Returns a function for evaluating the quantile function of the Wilcoxon\n    signed rank test statistic with `n` observations.\n"
base.dists.t.cdf,"\nbase.dists.t.cdf( x:number, v:number )\n    Evaluates the cumulative distribution function (CDF) for a Student's t\n    distribution with degrees of freedom `v` at a value `x`.\n"
base.dists.t.cdf.factory,"\nbase.dists.t.cdf.factory( v:number )\n    Returns a function for evaluating the cumulative distribution function (CDF)\n    of a Student's t distribution with degrees of freedom `v`.\n"
base.dists.t.entropy,"\nbase.dists.t.entropy( v:number )\n    Returns the differential entropy of a Student's t distribution.\n"
base.dists.t.kurtosis,"\nbase.dists.t.kurtosis( v:number )\n    Returns the excess kurtosis of a Student's t distribution.\n"
base.dists.t.mean,"\nbase.dists.t.mean( v:number )\n    Returns the expected value of a Student's t distribution.\n"
base.dists.t.median,"\nbase.dists.t.median( v:number )\n    Returns the median of a Student's t distribution.\n"
base.dists.t.mode,"\nbase.dists.t.mode( v:number )\n    Returns the mode of a Student's t distribution.\n"
base.dists.t.pdf,"\nbase.dists.t.pdf( x:number, v:number )\n    Evaluates the probability density function (PDF) for a Student's t\n    distribution with degrees of freedom `v` at a value `x`.\n"
base.dists.t.pdf.factory,"\nbase.dists.t.pdf.factory( v:number )\n    Returns a function for evaluating the probability density function (PDF)\n    of a Student's t distribution with degrees of freedom `v`.\n"
base.dists.t.quantile,"\nbase.dists.t.quantile( p:number, v:number )\n    Evaluates the quantile function for a Student's t distribution with degrees\n    of freedom `v` at a probability `p`.\n"
base.dists.t.quantile.factory,"\nbase.dists.t.quantile.factory( v:number )\n    Returns a function for evaluating the quantile function of a Student's t\n    distribution with degrees of freedom `v`.\n"
base.dists.t.skewness,"\nbase.dists.t.skewness( v:number )\n    Returns the skewness of a Student's t distribution.\n"
base.dists.t.stdev,"\nbase.dists.t.stdev( v:number )\n    Returns the standard deviation of a Student's t distribution.\n"
base.dists.t.T,"\nbase.dists.t.T( [v:number] )\n    Returns a Student's t distribution object.\n"
base.dists.t.variance,"\nbase.dists.t.variance( v:number )\n    Returns the variance of a Student's t distribution.\n"
base.dists.triangular.cdf,"\nbase.dists.triangular.cdf( x:number, a:number, b:number, c:number )\n    Evaluates the cumulative distribution function (CDF) for a triangular\n    distribution with minimum support `a`, maximum support `b`, and mode `c` at\n    a value `x`.\n"
base.dists.triangular.cdf.factory,"\nbase.dists.triangular.cdf.factory( a:number, b:number, c:number )\n    Returns a function for evaluating the cumulative distribution function (CDF)\n    of a triangular distribution with minimum support `a`, maximum support `b`,\n    and mode `c`.\n"
base.dists.triangular.entropy,"\nbase.dists.triangular.entropy( a:number, b:number, c:number )\n    Returns the differential entropy of a triangular distribution (in nats).\n"
base.dists.triangular.kurtosis,"\nbase.dists.triangular.kurtosis( a:number, b:number, c:number )\n    Returns the excess kurtosis of a triangular distribution.\n"
base.dists.triangular.logcdf,"\nbase.dists.triangular.logcdf( x:number, a:number, b:number, c:number )\n    Evaluates the natural logarithm of the cumulative distribution function\n    (CDF) for a triangular distribution with minimum support `a`, maximum\n    support `b`, and mode `c` at a value `x`.\n"
base.dists.triangular.logcdf.factory,"\nbase.dists.triangular.logcdf.factory( a:number, b:number, c:number )\n    Returns a function for evaluating the natural logarithm of the cumulative\n    distribution function (CDF) of a triangular distribution with minimum\n    support `a`, maximum support `b`, and mode `c`.\n"
base.dists.triangular.logpdf,"\nbase.dists.triangular.logpdf( x:number, a:number, b:number, c:number )\n    Evaluates the natural logarithm of the probability density function (PDF)\n    for a triangular distribution with minimum support `a`, maximum support `b`,\n    and mode `c` at a value `x`.\n"
base.dists.triangular.logpdf.factory,"\nbase.dists.triangular.logpdf.factory( a:number, b:number, c:number )\n    Returns a function for evaluating the natural logarithm of the  probability\n    density function (PDF) of a triangular distribution with minimum support\n    `a`, maximum support `b`, and mode `c`.\n"
base.dists.triangular.mean,"\nbase.dists.triangular.mean( a:number, b:number, c:number )\n    Returns the expected value of a triangular distribution.\n"
base.dists.triangular.median,"\nbase.dists.triangular.median( a:number, b:number, c:number )\n    Returns the median of a triangular distribution.\n"
base.dists.triangular.mgf,"\nbase.dists.triangular.mgf( t:number, a:number, b:number, c:number )\n    Evaluates the moment-generating function (MGF) for a triangular distribution\n    with minimum support `a`, maximum support `b`, and mode `c` at a value `t`.\n"
base.dists.triangular.mgf.factory,"\nbase.dists.triangular.mgf.factory( a:number, b:number, c:number )\n    Returns a function for evaluating the moment-generating function (MGF) of a\n    triangular distribution with minimum support `a`, maximum support `b`, and\n    mode `c`.\n"
base.dists.triangular.mode,"\nbase.dists.triangular.mode( a:number, b:number, c:number )\n    Returns the mode of a triangular distribution.\n"
base.dists.triangular.pdf,"\nbase.dists.triangular.pdf( x:number, a:number, b:number, c:number )\n    Evaluates the probability density function (PDF) for a triangular\n    distribution with minimum support `a`, maximum support `b`, and mode `c` at\n    a value `x`.\n"
base.dists.triangular.pdf.factory,"\nbase.dists.triangular.pdf.factory( a:number, b:number, c:number )\n    Returns a function for evaluating the probability density function (PDF) of\n    a triangular distribution with minimum support `a`, maximum support `b`, and\n    mode `c`.\n"
base.dists.triangular.quantile,"\nbase.dists.triangular.quantile( p:number, a:number, b:number, c:number )\n    Evaluates the quantile function for a triangular distribution with minimum\n    support `a`, maximum support `b`, and mode `c` at a value `x`.\n"
base.dists.triangular.quantile.factory,"\nbase.dists.triangular.quantile.factory( a:number, b:number, c:number )\n    Returns a function for evaluating the quantile function of a triangular\n    distribution with minimum support `a`, maximum support `b`, and mode `c`.\n"
base.dists.triangular.skewness,"\nbase.dists.triangular.skewness( a:number, b:number, c:number )\n    Returns the skewness of a triangular distribution.\n"
base.dists.triangular.stdev,"\nbase.dists.triangular.stdev( a:number, b:number, c:number )\n    Returns the standard deviation of a triangular distribution.\n"
base.dists.triangular.Triangular,"\nbase.dists.triangular.Triangular( [a:number, b:number, c:number] )\n    Returns a triangular distribution object.\n"
base.dists.triangular.variance,"\nbase.dists.triangular.variance( a:number, b:number, c:number )\n    Returns the variance of a triangular distribution.\n"
base.dists.uniform.cdf,"\nbase.dists.uniform.cdf( x:number, a:number, b:number )\n    Evaluates the cumulative distribution function (CDF) for a uniform\n    distribution with minimum support `a` and maximum support `b` at a value\n    `x`.\n"
base.dists.uniform.cdf.factory,"\nbase.dists.uniform.cdf.factory( a:number, b:number )\n    Returns a function for evaluating the cumulative distribution function (CDF)\n    of a uniform distribution with minimum support `a` and maximum support `b`.\n"
base.dists.uniform.entropy,"\nbase.dists.uniform.entropy( a:number, b:number )\n    Returns the differential entropy of a uniform distribution.\n"
base.dists.uniform.kurtosis,"\nbase.dists.uniform.kurtosis( a:number, b:number )\n    Returns the excess kurtosis of a uniform distribution.\n"
base.dists.uniform.logcdf,"\nbase.dists.uniform.logcdf( x:number, a:number, b:number )\n    Evaluates the logarithm of the cumulative distribution function (CDF) for a\n    uniform distribution with minimum support `a` and maximum support `b` at a\n    value `x`.\n"
base.dists.uniform.logcdf.factory,"\nbase.dists.uniform.logcdf.factory( a:number, b:number )\n    Returns a function for evaluating the logarithm of the cumulative\n    distribution function (CDF) of a uniform distribution with minimum support\n    `a` and maximum support `b`.\n"
base.dists.uniform.logpdf,"\nbase.dists.uniform.logpdf( x:number, a:number, b:number )\n    Evaluates the logarithm of the probability density function (PDF) for a\n    uniform distribution with minimum support `a` and maximum support `b` at a\n    value `x`.\n"
base.dists.uniform.logpdf.factory,"\nbase.dists.uniform.logpdf.factory( a:number, b:number )\n    Returns a function for evaluating the logarithm of the probability density\n    function (PDF) of a uniform distribution with minimum support `a` and\n    maximum support `b`.\n"
base.dists.uniform.mean,"\nbase.dists.uniform.mean( a:number, b:number )\n    Returns the expected value of a uniform distribution.\n"
base.dists.uniform.median,"\nbase.dists.uniform.median( a:number, b:number )\n    Returns the median of a uniform distribution.\n"
base.dists.uniform.mgf,"\nbase.dists.uniform.mgf( t:number, a:number, b:number )\n    Evaluates the moment-generating function (MGF) for a uniform\n    distribution with minimum support `a` and maximum support `b` at a value\n    `t`.\n"
base.dists.uniform.mgf.factory,"\nbase.dists.uniform.mgf.factory( a:number, b:number )\n    Returns a function for evaluating the moment-generating function (MGF)\n    of a uniform distribution with minimum support `a` and maximum support `b`.\n"
base.dists.uniform.pdf,"\nbase.dists.uniform.pdf( x:number, a:number, b:number )\n    Evaluates the probability density function (PDF) for a uniform distribution\n    with minimum support `a` and maximum support `b` at a value `x`.\n"
base.dists.uniform.pdf.factory,"\nbase.dists.uniform.pdf.factory( a:number, b:number )\n    Returns a function for evaluating the probability density function (PDF) of\n    a uniform distribution with minimum support `a` and maximum support `b`.\n"
base.dists.uniform.quantile,"\nbase.dists.uniform.quantile( p:number, a:number, b:number )\n    Evaluates the quantile function for a uniform distribution with minimum\n    support `a` and maximum support `b` at a probability `p`.\n"
base.dists.uniform.quantile.factory,"\nbase.dists.uniform.quantile.factory( a:number, b:number )\n    Returns a function for evaluating the quantile function of a uniform\n    distribution with minimum support `a` and maximum support `b`.\n"
base.dists.uniform.skewness,"\nbase.dists.uniform.skewness( a:number, b:number )\n    Returns the skewness of a uniform distribution.\n"
base.dists.uniform.stdev,"\nbase.dists.uniform.stdev( a:number, b:number )\n    Returns the standard deviation of a uniform distribution.\n"
base.dists.uniform.Uniform,"\nbase.dists.uniform.Uniform( [a:number, b:number] )\n    Returns a uniform distribution object.\n"
base.dists.uniform.variance,"\nbase.dists.uniform.variance( a:number, b:number )\n    Returns the variance of a uniform distribution.\n"
base.dists.weibull.cdf,"\nbase.dists.weibull.cdf( x:number, k:number, λ:number )\n    Evaluates the cumulative distribution function (CDF) for a Weibull\n    distribution with shape parameter `k` and scale parameter `λ` at a value\n    `x`.\n"
base.dists.weibull.cdf.factory,"\nbase.dists.weibull.cdf.factory( k:number, λ:number )\n    Returns a function for evaluating the cumulative distribution function (CDF)\n    of a Weibull distribution with shape parameter `k` and scale parameter `λ`.\n"
base.dists.weibull.entropy,"\nbase.dists.weibull.entropy( k:number, λ:number )\n    Returns the differential entropy of a Weibull distribution (in nats).\n"
base.dists.weibull.kurtosis,"\nbase.dists.weibull.kurtosis( k:number, λ:number )\n    Returns the excess kurtosis of a Weibull distribution.\n"
base.dists.weibull.logcdf,"\nbase.dists.weibull.logcdf( x:number, k:number, λ:number )\n    Evaluates the logarithm of the cumulative distribution function (CDF) for a\n    Weibull distribution with shape parameter `k` and scale parameter `λ` at a\n    value `x`.\n"
base.dists.weibull.logcdf.factory,"\nbase.dists.weibull.logcdf.factory( k:number, λ:number)\n    Returns a function for evaluating the logarithm of the cumulative\n    distribution function (CDF) of a Weibull distribution with scale parameter\n    `λ` and shape parameter `k`.\n"
base.dists.weibull.logpdf,"\nbase.dists.weibull.logpdf( x:number, k:number, λ:number )\n    Evaluates the logarithm of the probability density function (PDF) for a\n    Weibull distribution with shape parameter `k` and scale parameter `λ` at a\n    value `x`.\n"
base.dists.weibull.logpdf.factory,"\nbase.dists.weibull.logpdf.factory( k:number, λ:number )\n    Returns a function for evaluating the logarithm of the probability density\n    function (PDF) of a Weibull distribution with shape parameter `k` and scale\n    parameter `λ`.\n"
base.dists.weibull.mean,"\nbase.dists.weibull.mean( k:number, λ:number )\n    Returns the expected value of a Weibull distribution.\n"
base.dists.weibull.median,"\nbase.dists.weibull.median( k:number, λ:number )\n    Returns the median of a Weibull distribution.\n"
base.dists.weibull.mgf,"\nbase.dists.weibull.mgf( x:number, k:number, λ:number )\n    Evaluates the moment-generating function (MGF) for a Weibull distribution\n    with shape parameter `k` and scale parameter `λ` at a value `t`.\n"
base.dists.weibull.mgf.factory,"\nbase.dists.weibull.mgf.factory( k:number, λ:number )\n    Returns a function for evaluating the moment-generating function (MGF) of a\n    Weibull distribution with shape parameter `k` and scale parameter `λ`.\n"
base.dists.weibull.mode,"\nbase.dists.weibull.mode( k:number, λ:number )\n    Returns the mode of a Weibull distribution.\n"
base.dists.weibull.pdf,"\nbase.dists.weibull.pdf( x:number, k:number, λ:number )\n    Evaluates the probability density function (PDF) for a Weibull distribution\n    with shape parameter `k` and scale parameter `λ` at a value `x`.\n"
base.dists.weibull.pdf.factory,"\nbase.dists.weibull.pdf.factory( k:number, λ:number )\n    Returns a function for evaluating the probability density function (PDF) of\n    a Weibull distribution with shape parameter `k` and scale parameter `λ`.\n"
base.dists.weibull.quantile,"\nbase.dists.weibull.quantile( p:number, k:number, λ:number )\n    Evaluates the quantile function for a Weibull distribution with scale\n    parameter `k` and shape parameter `λ` at a probability `p`.\n"
base.dists.weibull.quantile.factory,"\nbase.dists.weibull.quantile.factory( k:number, λ:number )\n    Returns a function for evaluating the quantile function of a Weibull\n    distribution with scale parameter `k` and shape parameter `λ`.\n"
base.dists.weibull.skewness,"\nbase.dists.weibull.skewness( k:number, λ:number )\n    Returns the skewness of a Weibull distribution.\n"
base.dists.weibull.stdev,"\nbase.dists.weibull.stdev( k:number, λ:number )\n    Returns the standard deviation of a Weibull distribution.\n"
base.dists.weibull.variance,"\nbase.dists.weibull.variance( k:number, λ:number )\n    Returns the variance of a Weibull distribution.\n"
base.dists.weibull.Weibull,"\nbase.dists.weibull.Weibull( [k:number, λ:number] )\n    Returns a Weibull distribution object.\n"
base.ellipe,"\nbase.ellipe( m:number )\n    Computes the complete elliptic integral of the second kind.\n"
base.ellipk,"\nbase.ellipk( m:number )\n    Computes the complete elliptic integral of the first kind.\n"
base.epsdiff,"\nbase.epsdiff( x:number, y:number[, scale:string|Function] )\n    Computes the relative difference of two real numbers in units of double-\n    precision floating-point epsilon.\n"
base.erf,"\nbase.erf( x:number )\n    Evaluates the error function.\n"
base.erfc,"\nbase.erfc( x:number )\n    Evaluates the complementary error function.\n"
base.erfcinv,"\nbase.erfcinv( x:number )\n    Evaluates the inverse complementary error function.\n"
base.erfinv,"\nbase.erfinv( x:number )\n    Evaluates the inverse error function.\n"
base.eta,"\nbase.eta( s:number )\n    Evaluates the Dirichlet eta function as a function of a real variable `s`.\n"
base.evalpoly,"\nbase.evalpoly( c:Array<number>, x:number )\n    Evaluates a polynomial.\n"
base.evalpoly.factory,"\nbase.evalpoly.factory( c:Array<number> )\n    Returns a function for evaluating a polynomial.\n"
base.evalrational,"\nbase.evalrational( P:Array<number>, Q:Array<number>, x:number )\n    Evaluates a rational function.\n"
base.evalrational.factory,"\nbase.evalrational.factory( P:Array<number>, Q:Array<number> )\n    Returns a function for evaluating a rational function.\n"
base.exp,"\nbase.exp( x:number )\n    Evaluates the natural exponential function.\n"
base.exp2,"\nbase.exp2( x:number )\n    Evaluates the base 2 exponential function.\n"
base.exp10,"\nbase.exp10( x:number )\n    Evaluates the base 10 exponential function.\n"
base.expit,"\nbase.expit( x:number )\n    Evaluates the standard logistic function.\n"
base.expm1,"\nbase.expm1( x:number )\n    Computes `exp(x)-1`, where `exp(x)` is the natural exponential function.\n"
base.expm1rel,"\nbase.expm1rel( x:number )\n    Relative error exponential.\n"
base.exponent,"\nbase.exponent( x:number )\n    Returns an integer corresponding to the unbiased exponent of a double-\n    precision floating-point number.\n"
base.exponentf,"\nbase.exponentf( x:float )\n    Returns an integer corresponding to the unbiased exponent of a single-\n    precision floating-point number.\n"
base.factorial,"\nbase.factorial( x:number )\n    Evaluates the factorial of `x`.\n"
base.factorialln,"\nbase.factorialln( x:number )\n    Evaluates the natural logarithm of the factorial of `x`.\n"
base.fallingFactorial,"\nbase.fallingFactorial( x:number, n:integer )\n    Computes the falling factorial of `x` and `n`.\n"
base.fibonacci,"\nbase.fibonacci( n:integer )\n    Computes the nth Fibonacci number.\n"
base.fibonacciIndex,"\nbase.fibonacciIndex( F:integer )\n    Computes the Fibonacci number index.\n"
base.fibpoly,"\nbase.fibpoly( n:integer, x:number )\n    Evaluates a Fibonacci polynomial.\n"
base.fibpoly.factory,"\nbase.fibpoly.factory( n:integer )\n    Returns a function for evaluating a Fibonacci polynomial.\n"
base.flipsign,"\nbase.flipsign( x:number, y:number )\n    Returns a double-precision floating-point number with the magnitude of `x`\n    and the sign of `x*y`.\n"
base.float32ToInt32,"\nbase.float32ToInt32( x:float )\n    Converts a single-precision floating-point number to a signed 32-bit\n    integer.\n"
base.float32ToUint32,"\nbase.float32ToUint32( x:float )\n    Converts a single-precision floating-point number to a unsigned 32-bit\n    integer.\n"
base.float64ToFloat32,"\nbase.float64ToFloat32( x:number )\n    Converts a double-precision floating-point number to the nearest single-\n    precision floating-point number.\n"
base.float64ToInt32,"\nbase.float64ToInt32( x:number )\n    Converts a double-precision floating-point number to a signed 32-bit\n    integer.\n"
base.float64ToInt64Bytes,"\nbase.float64ToInt64Bytes( x:integer )\n    Converts an integer-valued double-precision floating-point number to a\n    signed 64-bit integer byte array according to host byte order (endianness).\n"
base.float64ToInt64Bytes.assign,"\nbase.float64ToInt64Bytes.assign( x:integer, out:Array|TypedArray|Object, \n  stride:integer, offset:integer )\n    Converts an integer-valued double-precision floating-point number to a\n    signed 64-bit integer byte array according to host byte order (endianness)\n    and assigns results to a provided output array.\n"
base.float64ToUint32,"\nbase.float64ToUint32( x:number )\n    Converts a double-precision floating-point number to a unsigned 32-bit\n    integer.\n"
base.floor,"\nbase.floor( x:number )\n    Rounds a double-precision floating-point number toward negative infinity.\n"
base.floor2,"\nbase.floor2( x:number )\n    Rounds a numeric value to the nearest power of two toward negative infinity.\n"
base.floor10,"\nbase.floor10( x:number )\n    Rounds a numeric value to the nearest power of ten toward negative infinity.\n"
base.floorb,"\nbase.floorb( x:number, n:integer, b:integer )\n    Rounds a numeric value to the nearest multiple of `b^n` toward negative\n    infinity.\n"
base.floorf,"\nbase.floorf( x:number )\n    Rounds a single-precision floating-point number toward negative infinity.\n"
base.floorn,"\nbase.floorn( x:number, n:integer )\n    Rounds a numeric value to the nearest multiple of `10^n` toward negative\n    infinity.\n"
base.floorsd,"\nbase.floorsd( x:number, n:integer[, b:integer] )\n    Rounds a numeric value to the nearest number toward negative infinity with\n    `n` significant figures.\n"
base.fresnel,"\nbase.fresnel( [out:Array|TypedArray|Object,] x:number )\n    Computes the Fresnel integrals S(x) and C(x).\n"
base.fresnelc,"\nbase.fresnelc( x:number )\n    Computes the Fresnel integral C(x).\n"
base.fresnels,"\nbase.fresnels( x:number )\n    Computes the Fresnel integral S(x).\n"
base.frexp,"\nbase.frexp( [out:Array|TypedArray|Object,] x:number )\n    Splits a double-precision floating-point number into a normalized fraction\n    and an integer power of two.\n"
base.fromBinaryString,"\nbase.fromBinaryString( bstr:string )\n    Creates a double-precision floating-point number from a literal bit\n    representation.\n"
base.fromBinaryStringf,"\nbase.fromBinaryStringf( bstr:string )\n    Creates a single-precision floating-point number from an IEEE 754 literal\n    bit representation.\n"
base.fromBinaryStringUint8,"\nbase.fromBinaryStringUint8( bstr:string )\n    Creates an unsigned 8-bit integer from a literal bit representation.\n"
base.fromBinaryStringUint16,"\nbase.fromBinaryStringUint16( bstr:string )\n    Creates an unsigned 16-bit integer from a literal bit representation.\n"
base.fromBinaryStringUint32,"\nbase.fromBinaryStringUint32( bstr:string )\n    Creates an unsigned 32-bit integer from a literal bit representation.\n"
base.fromInt64Bytes,"\nbase.fromInt64Bytes( bytes:Array|TypedArray|Object, stride:integer, \n  offset:integer )\n    Converts a signed 64-bit integer byte array to a double-precision floating-\n    point number.\n"
base.fromWordf,"\nbase.fromWordf( word:integer )\n    Creates a single-precision floating-point number from an unsigned integer\n    corresponding to an IEEE 754 binary representation.\n"
base.fromWords,"\nbase.fromWords( high:integer, low:integer )\n    Creates a double-precision floating-point number from a higher order word\n    (unsigned 32-bit integer) and a lower order word (unsigned 32-bit integer).\n"
base.gamma,"\nbase.gamma( x:number )\n    Evaluates the gamma function.\n"
base.gamma1pm1,"\nbase.gamma1pm1( x:number )\n    Computes `gamma(x+1) - 1` without cancellation errors, where `gamma(x)` is\n    the gamma function.\n"
base.gammaDeltaRatio,"\nbase.gammaDeltaRatio( z:number, delta:number )\n    Computes the ratio of two gamma functions.\n"
base.gammainc,"\nbase.gammainc( x:number, s:number[, regularized:boolean[, upper:boolean]] )\n    Computes the regularized incomplete gamma function.\n"
base.gammaincinv,"\nbase.gammaincinv( p:number, a:number[, upper:boolean] )\n    Computes the inverse of the lower incomplete gamma function.\n"
base.gammaLanczosSum,"\nbase.gammaLanczosSum( x:number )\n    Calculates the Lanczos sum for the approximation of the gamma function.\n"
base.gammaLanczosSumExpGScaled,"\nbase.gammaLanczosSumExpGScaled( x:number )\n    Calculates the scaled Lanczos sum for the approximation of the gamma\n    function.\n"
base.gammaln,"\nbase.gammaln( x:number )\n    Evaluates the natural logarithm of the gamma function.\n"
base.gcd,"\nbase.gcd( a:integer, b:integer )\n    Computes the greatest common divisor (gcd).\n"
base.getHighWord,"\nbase.getHighWord( x:number )\n    Returns an unsigned 32-bit integer corresponding to the more significant 32\n    bits of a double-precision floating-point number.\n"
base.getLowWord,"\nbase.getLowWord( x:number )\n    Returns an unsigned 32-bit integer corresponding to the less significant 32\n    bits of a double-precision floating-point number.\n"
base.hacovercos,"\nbase.hacovercos( x:number )\n    Computes the half-value coversed cosine.\n"
base.hacoversin,"\nbase.hacoversin( x:number )\n    Computes the half-value coversed sine.\n"
base.havercos,"\nbase.havercos( x:number )\n    Computes the half-value versed cosine.\n"
base.haversin,"\nbase.haversin( x:number )\n    Computes the half-value versed sine.\n"
base.heaviside,"\nbase.heaviside( x:number[, continuity:string] )\n    Evaluates the Heaviside function.\n"
base.hermitepoly,"\nbase.hermitepoly( n:integer, x:number )\n    Evaluates a physicist's Hermite polynomial.\n"
base.hermitepoly.factory,"\nbase.hermitepoly.factory( n:integer )\n    Returns a function for evaluating a physicist's Hermite polynomial.\n"
base.hypot,"\nbase.hypot( x:number, y:number )\n    Computes the hypotenuse avoiding overflow and underflow.\n"
base.hypotf,"\nbase.hypotf( x:number, y:number )\n    Computes the hypotenuse avoiding overflow and underflow (single-precision).\n"
base.identity,"\nbase.identity( x:number )\n    Evaluates the identity function for a double-precision floating-point number\n    `x`.\n"
base.identityf,"\nbase.identityf( x:number )\n    Evaluates the identity function for a single-precision floating-point number\n    `x`.\n"
base.imul,"\nbase.imul( a:integer, b:integer )\n    Performs C-like multiplication of two signed 32-bit integers.\n"
base.imuldw,"\nbase.imuldw( [out:ArrayLikeObject,] a:integer, b:integer )\n    Multiplies two signed 32-bit integers and returns an array of two signed 32-\n    bit integers which represents the signed 64-bit integer product.\n"
base.int32ToUint32,"\nbase.int32ToUint32( x:integer )\n    Converts a signed 32-bit integer to an unsigned 32-bit integer.\n"
base.inv,"\nbase.inv( x:number )\n    Computes the multiplicative inverse of a double-precision floating-point\n    number `x`.\n"
base.invf,"\nbase.invf( x:number )\n    Computes the multiplicative inverse of a single-precision floating-point\n    number `x`.\n"
base.isComposite,"\nbase.isComposite( x:number )\n    Tests if a number is composite.\n"
base.isCoprime,"\nbase.isCoprime( a:number, b:number )\n    Tests if two numbers are coprime.\n"
base.isEven,"\nbase.isEven( x:number )\n    Tests if a finite numeric value is an even number.\n"
base.isEvenInt32,"\nbase.isEvenInt32( x:integer )\n    Tests if a 32-bit integer is even.\n"
base.isFinite,"\nbase.isFinite( x:number )\n    Tests if a double-precision floating-point numeric value is finite.\n"
base.isFinitef,"\nbase.isFinitef( x:number )\n    Tests if a single-precision floating-point numeric value is finite.\n"
base.isInfinite,"\nbase.isInfinite( x:number )\n    Tests if a double-precision floating-point numeric value is infinite.\n"
base.isInfinitef,"\nbase.isInfinitef( x:number )\n    Tests if a single-precision floating-point numeric value is infinite.\n"
base.isInteger,"\nbase.isInteger( x:number )\n    Tests if a finite double-precision floating-point number is an integer.\n"
base.isnan,"\nbase.isnan( x:number )\n     Tests if a double-precision floating-point numeric value is `NaN`.\n"
base.isnanf,"\nbase.isnanf( x:number )\n     Tests if a single-precision floating-point numeric value is `NaN`.\n"
base.isNegativeInteger,"\nbase.isNegativeInteger( x:number )\n    Tests if a finite double-precision floating-point number is a negative\n    integer.\n"
base.isNegativeZero,"\nbase.isNegativeZero( x:number )\n    Tests if a double-precision floating-point numeric value is negative zero.\n"
base.isNegativeZerof,"\nbase.isNegativeZerof( x:number )\n    Tests if a single-precision floating-point numeric value is negative zero.\n"
base.isNonNegativeInteger,"\nbase.isNonNegativeInteger( x:number )\n    Tests if a finite double-precision floating-point number is a nonnegative\n    integer.\n"
base.isNonPositiveInteger,"\nbase.isNonPositiveInteger( x:number )\n    Tests if a finite double-precision floating-point number is a nonpositive\n    integer.\n"
base.isOdd,"\nbase.isOdd( x:number )\n    Tests if a finite numeric value is an odd number.\n"
base.isOddInt32,"\nbase.isOddInt32( x:integer )\n    Tests if a 32-bit integer is odd.\n"
base.isPositiveInteger,"\nbase.isPositiveInteger( x:number )\n    Tests if a finite double-precision floating-point number is a positive\n    integer.\n"
base.isPositiveZero,"\nbase.isPositiveZero( x:number )\n    Tests if a double-precision floating-point numeric value is positive zero.\n"
base.isPositiveZerof,"\nbase.isPositiveZerof( x:number )\n    Tests if a single-precision floating-point numeric value is positive zero.\n"
base.isPow2Uint32,"\nbase.isPow2Uint32( x:integer )\n    Tests whether an unsigned integer is a power of 2.\n"
base.isPrime,"\nbase.isPrime( x:number )\n    Tests if a number is prime.\n"
base.isProbability,"\nbase.isProbability( x:number )\n    Tests if a numeric value is a probability.\n"
base.isSafeInteger,"\nbase.isSafeInteger( x:number )\n    Tests if a finite double-precision floating-point number is a safe integer.\n"
base.kernelBetainc,"\nbase.kernelBetainc( x:number, a:number, b:number, regularized:boolean, \n  upper:boolean )\n    Computes the kernel function for the regularized incomplete beta function.\n"
base.kernelBetainc.assign,"\nbase.kernelBetainc.assign( x:number, a:number, b:number, regularized:boolean, \n  upper:boolean, out:Array|TypedArray|Object, stride:integer, offset:integer )\n    Computes the kernel function for the regularized incomplete beta function.\n"
base.kernelBetaincinv,"\nbase.kernelBetaincinv( a:number, b:number, p:number, q:number )\n    Computes the inverse of the lower incomplete beta function.\n"
base.kernelCos,"\nbase.kernelCos( x:number, y:number )\n    Computes the cosine of a number on `[-π/4, π/4]`.\n"
base.kernelSin,"\nbase.kernelSin( x:number, y:number )\n    Computes the sine of a number on `[-π/4, π/4]`.\n"
base.kernelTan,"\nbase.kernelTan( x:number, y:number, k:integer )\n    Computes the tangent of a number on `[-π/4, π/4]`.\n"
base.kroneckerDelta,"\nbase.kroneckerDelta( i:number, j:number )\n    Evaluates the Kronecker delta.\n"
base.kroneckerDeltaf,"\nbase.kroneckerDeltaf( i:number, j:number )\n    Evaluates the Kronecker delta (single-precision).\n"
base.labs,"\nbase.labs( x:integer )\n    Computes an absolute value of a signed 32-bit integer in two's complement\n    format.\n"
base.lcm,"\nbase.lcm( a:integer, b:integer )\n    Computes the least common multiple (lcm).\n"
base.ldexp,"\nbase.ldexp( frac:number, exp:number )\n    Multiplies a double-precision floating-point number by an integer power of\n    two; i.e., `x = frac * 2^exp`.\n"
base.ln,"\nbase.ln( x:number )\n    Evaluates the natural logarithm.\n"
base.log,"\nbase.log( x:number, b:number )\n    Computes the base `b` logarithm of `x`.\n"
base.log1mexp,"\nbase.log1mexp( x:number )\n    Evaluates the natural logarithm of `1-exp(-|x|)`.\n"
base.log1p,"\nbase.log1p( x:number )\n    Evaluates the natural logarithm of `1+x`.\n"
base.log1pexp,"\nbase.log1pexp( x:number )\n    Evaluates the natural logarithm of `1+exp(x)`.\n"
base.log2,"\nbase.log2( x:number )\n    Evaluates the binary logarithm (base two).\n"
base.log10,"\nbase.log10( x:number )\n    Evaluates the common logarithm (base 10).\n"
base.logaddexp,"\nbase.logaddexp( x:number, y:number )\n    Computes the natural logarithm of `exp(x) + exp(y)`.\n"
base.logit,"\nbase.logit( p:number )\n    Evaluates the logit function.\n"
base.lucas,"\nbase.lucas( n:integer )\n    Computes the nth Lucas number.\n"
base.lucaspoly,"\nbase.lucaspoly( n:integer, x:number )\n    Evaluates a Lucas polynomial.\n"
base.lucaspoly.factory,"\nbase.lucaspoly.factory( n:integer )\n    Returns a function for evaluating a Lucas polynomial.\n"
base.max,"\nbase.max( [x:number[, y:number[, ...args:number]]] )\n    Returns the maximum value.\n"
base.maxabs,"\nbase.maxabs( [x:number[, y:number[, ...args:number]]] )\n    Returns the maximum absolute value.\n"
base.min,"\nbase.min( [x:number[, y:number[, ...args:number]]] )\n    Returns the minimum value.\n"
base.minabs,"\nbase.minabs( [x:number[, y:number[, ...args:number]]] )\n    Returns the minimum absolute value.\n"
base.minmax,"\nbase.minmax( [out:Array|TypedArray|Object,] x:number[, y:number[, \n  ...args:number]] )\n    Returns the minimum and maximum values.\n"
base.minmaxabs,"\nbase.minmaxabs( [out:Array|TypedArray|Object,] x:number[, y:number[, \n  ...args:number]] )\n    Returns the minimum and maximum absolute values.\n"
base.modf,"\nbase.modf( [out:Array|TypedArray|Object,] x:number )\n    Decomposes a double-precision floating-point number into integral and\n    fractional parts, each having the same type and sign as the input value.\n"
base.ndarray,"\nbase.ndarray( dtype:string, buffer:ArrayLikeObject|TypedArray|Buffer, \n  shape:ArrayLikeObject<integer>, strides:ArrayLikeObject<integer>, \n  offset:integer, order:string )\n    Returns an ndarray.\n"
base.ndarray.prototype.byteLength,"\nbase.ndarray.prototype.byteLength\n    Size (in bytes) of the array (if known).\n"
base.ndarray.prototype.BYTES_PER_ELEMENT,"\nbase.ndarray.prototype.BYTES_PER_ELEMENT\n    Size (in bytes) of each array element (if known).\n"
base.ndarray.prototype.data,"\nbase.ndarray.prototype.data\n    Pointer to the underlying data buffer.\n"
base.ndarray.prototype.dtype,"\nbase.ndarray.prototype.dtype\n    Underlying data type.\n"
base.ndarray.prototype.flags,"\nbase.ndarray.prototype.flags\n    Information about the memory layout of the array.\n"
base.ndarray.prototype.length,"\nbase.ndarray.prototype.length\n    Length of the array (i.e., number of elements).\n"
base.ndarray.prototype.ndims,"\nbase.ndarray.prototype.ndims\n    Number of dimensions.\n"
base.ndarray.prototype.offset,"\nbase.ndarray.prototype.offset\n    Index offset which specifies the buffer index at which to start iterating\n    over array elements.\n"
base.ndarray.prototype.order: string,"\nbase.ndarray.prototype.order: string\n    Array order.\n"
base.ndarray.prototype.shape,"\nbase.ndarray.prototype.shape\n    Array shape.\n"
base.ndarray.prototype.strides,"\nbase.ndarray.prototype.strides\n    Index strides which specify how to access data along corresponding array\n    dimensions.\n"
base.ndarray.prototype.get,"\nbase.ndarray.prototype.get( ...idx:integer )\n    Returns an array element specified according to provided subscripts.\n"
base.ndarray.prototype.iget,"\nbase.ndarray.prototype.iget( idx:integer )\n    Returns an array element located at a specified linear index.\n"
base.ndarray.prototype.set,"\nbase.ndarray.prototype.set( ...idx:integer, v:any )\n    Sets an array element specified according to provided subscripts.\n"
base.ndarray.prototype.iset,"\nbase.ndarray.prototype.iset( idx:integer, v:any )\n    Sets an array element located at a specified linear index.\n"
base.ndarray.prototype.toString,"\nbase.ndarray.prototype.toString()\n    Serializes an ndarray as a string.\n"
base.ndarray.prototype.toJSON,"\nbase.ndarray.prototype.toJSON()\n    Serializes an ndarray as a JSON object.\n"
base.ndarrayUnary,"\nbase.ndarrayUnary( arrays:ArrayLikeObject<ndarray>, fcn:Function )\n    Applies a unary callback to elements in an input ndarray and assigns results\n    to elements in an output ndarray.\n"
base.negafibonacci,"\nbase.negafibonacci( n:integer )\n    Computes the nth negaFibonacci number.\n"
base.negalucas,"\nbase.negalucas( n:integer )\n    Computes the nth negaLucas number.\n"
base.nonfibonacci,"\nbase.nonfibonacci( n:integer )\n    Computes the nth non-Fibonacci number.\n"
base.normalize,"\nbase.normalize( [out:Array|TypedArray|Object,] x:number )\n    Returns a normal number and exponent satisfying `x = y * 2^exp` as an array.\n"
base.normalizef,"\nbase.normalizef( [out:Array|TypedArray|Object,] x:float )\n    Returns a normal number `y` and exponent `exp` satisfying `x = y * 2^exp` as\n    an array.\n"
base.normhermitepoly,"\nbase.normhermitepoly( n:integer, x:number )\n    Evaluates a normalized Hermite polynomial.\n"
base.normhermitepoly.factory,"\nbase.normhermitepoly.factory( n:integer )\n    Returns a function for evaluating a normalized Hermite polynomial.\n"
base.pdiff,"\nbase.pdiff( x:number, y:number )\n    Returns the positive difference between `x` and `y` if `x > y`; otherwise,\n    returns `0`.\n"
base.pdifff,"\nbase.pdifff( x:number, y:number )\n    Returns the positive difference between `x` and `y` if `x > y`; otherwise,\n    returns `0`.\n"
base.polygamma,"\nbase.polygamma( n:integer, x:number )\n    Evaluates the polygamma function of order `n`; i.e., the (n+1)th derivative\n    of the natural logarithm of the gamma function.\n"
base.pow,"\nbase.pow( b:number, x:number )\n    Evaluates the exponential function `bˣ`.\n"
base.powm1,"\nbase.powm1( b:number, x:number )\n    Evaluates `bˣ - 1`.\n"
base.rad2deg,"\nbase.rad2deg( x:number )\n    Converts an angle from radians to degrees.\n"
base.ramp,"\nbase.ramp( x:number )\n    Evaluates the ramp function.\n"
base.rampf,"\nbase.rampf( x:number )\n    Evaluates the ramp function (single-precision).\n"
base.random.arcsine,"\nbase.random.arcsine( a:number, b:number )\n    Returns a pseudorandom number drawn from an arcsine distribution.\n"
base.random.arcsine.factory,"\nbase.random.arcsine.factory( [a:number, b:number, ][options:Object] )\n    Returns a pseudorandom number generator (PRNG) for generating pseudorandom\n    numbers drawn from an arcsine distribution.\n"
base.random.arcsine.NAME,"\nbase.random.arcsine.NAME\n    Generator name.\n"
base.random.arcsine.PRNG,"\nbase.random.arcsine.PRNG\n    Underlying pseudorandom number generator.\n"
base.random.arcsine.seed,"\nbase.random.arcsine.seed\n    Pseudorandom number generator seed.\n"
base.random.arcsine.seedLength,"\nbase.random.arcsine.seedLength\n    Length of generator seed.\n"
base.random.arcsine.state,"\nbase.random.arcsine.state\n    Generator state.\n"
base.random.arcsine.stateLength,"\nbase.random.arcsine.stateLength\n    Length of generator state.\n"
base.random.arcsine.byteLength,"\nbase.random.arcsine.byteLength\n    Size (in bytes) of generator state.\n"
base.random.arcsine.toJSON,"\nbase.random.arcsine.toJSON()\n    Serializes the pseudorandom number generator as a JSON object.\n"
base.random.bernoulli,"\nbase.random.bernoulli( p:number )\n    Returns a pseudorandom number drawn from a Bernoulli distribution.\n"
base.random.bernoulli.factory,"\nbase.random.bernoulli.factory( [p:number, ][options:Object] )\n    Returns a pseudorandom number generator (PRNG) for generating pseudorandom\n    numbers drawn from a Bernoulli distribution.\n"
base.random.bernoulli.NAME,"\nbase.random.bernoulli.NAME\n    Generator name.\n"
base.random.bernoulli.PRNG,"\nbase.random.bernoulli.PRNG\n    Underlying pseudorandom number generator.\n"
base.random.bernoulli.seed,"\nbase.random.bernoulli.seed\n    Pseudorandom number generator seed.\n"
base.random.bernoulli.seedLength,"\nbase.random.bernoulli.seedLength\n    Length of generator seed.\n"
base.random.bernoulli.state,"\nbase.random.bernoulli.state\n    Generator state.\n"
base.random.bernoulli.stateLength,"\nbase.random.bernoulli.stateLength\n    Length of generator state.\n"
base.random.bernoulli.byteLength,"\nbase.random.bernoulli.byteLength\n    Size (in bytes) of generator state.\n"
base.random.bernoulli.toJSON,"\nbase.random.bernoulli.toJSON()\n    Serializes the pseudorandom number generator as a JSON object.\n"
base.random.beta,"\nbase.random.beta( α:number, β:number )\n    Returns a pseudorandom number drawn from a beta distribution.\n"
base.random.beta.factory,"\nbase.random.beta.factory( [α:number, β:number, ][options:Object] )\n    Returns a pseudorandom number generator (PRNG) for generating pseudorandom\n    numbers drawn from a beta distribution.\n"
base.random.beta.NAME,"\nbase.random.beta.NAME\n    Generator name.\n"
base.random.beta.PRNG,"\nbase.random.beta.PRNG\n    Underlying pseudorandom number generator.\n"
base.random.beta.seed,"\nbase.random.beta.seed\n    Pseudorandom number generator seed.\n"
base.random.beta.seedLength,"\nbase.random.beta.seedLength\n    Length of generator seed.\n"
base.random.beta.state,"\nbase.random.beta.state\n    Generator state.\n"
base.random.beta.stateLength,"\nbase.random.beta.stateLength\n    Length of generator state.\n"
base.random.beta.byteLength,"\nbase.random.beta.byteLength\n    Size (in bytes) of generator state.\n"
base.random.beta.toJSON,"\nbase.random.beta.toJSON()\n    Serializes the pseudorandom number generator as a JSON object.\n"
base.random.betaprime,"\nbase.random.betaprime( α:number, β:number )\n    Returns a pseudorandom number drawn from a beta prime distribution.\n"
base.random.betaprime.factory,"\nbase.random.betaprime.factory( [α:number, β:number, ][options:Object] )\n    Returns a pseudorandom number generator (PRNG) for generating pseudorandom\n    numbers drawn from a beta prime distribution.\n"
base.random.betaprime.NAME,"\nbase.random.betaprime.NAME\n    Generator name.\n"
base.random.betaprime.PRNG,"\nbase.random.betaprime.PRNG\n    Underlying pseudorandom number generator.\n"
base.random.betaprime.seed,"\nbase.random.betaprime.seed\n    Pseudorandom number generator seed.\n"
base.random.betaprime.seedLength,"\nbase.random.betaprime.seedLength\n    Length of generator seed.\n"
base.random.betaprime.state,"\nbase.random.betaprime.state\n    Generator state.\n"
base.random.betaprime.stateLength,"\nbase.random.betaprime.stateLength\n    Length of generator state.\n"
base.random.betaprime.byteLength,"\nbase.random.betaprime.byteLength\n    Size (in bytes) of generator state.\n"
base.random.betaprime.toJSON,"\nbase.random.betaprime.toJSON()\n    Serializes the pseudorandom number generator as a JSON object.\n"
base.random.binomial,"\nbase.random.binomial( n:integer, p:number )\n    Returns a pseudorandom number drawn from a binomial distribution.\n"
base.random.binomial.factory,"\nbase.random.binomial.factory( [n:integer, p:number, ][options:Object] )\n    Returns a pseudorandom number generator (PRNG) for generating pseudorandom\n    numbers drawn from a binomial distribution.\n"
base.random.binomial.NAME,"\nbase.random.binomial.NAME\n    Generator name.\n"
base.random.binomial.PRNG,"\nbase.random.binomial.PRNG\n    Underlying pseudorandom number generator.\n"
base.random.binomial.seed,"\nbase.random.binomial.seed\n    Pseudorandom number generator seed.\n"
base.random.binomial.seedLength,"\nbase.random.binomial.seedLength\n    Length of generator seed.\n"
base.random.binomial.state,"\nbase.random.binomial.state\n    Generator state.\n"
base.random.binomial.stateLength,"\nbase.random.binomial.stateLength\n    Length of generator state.\n"
base.random.binomial.byteLength,"\nbase.random.binomial.byteLength\n    Size of generator state.\n"
base.random.binomial.toJSON,"\nbase.random.binomial.toJSON()\n    Serializes the pseudorandom number generator as a JSON object.\n"
base.random.boxMuller,"\nbase.random.boxMuller()\n    Returns a pseudorandom number drawn from a standard normal distribution.\n"
base.random.boxMuller.factory,"\nbase.random.boxMuller.factory( [options:Object] )\n    Returns a pseudorandom number generator (PRNG) for generating pseudorandom\n    numbers drawn from a standard normal distribution.\n"
base.random.boxMuller.NAME,"\nbase.random.boxMuller.NAME\n    Generator name.\n"
base.random.boxMuller.PRNG,"\nbase.random.boxMuller.PRNG\n    Underlying pseudorandom number generator.\n"
base.random.boxMuller.seed,"\nbase.random.boxMuller.seed\n    Pseudorandom number generator seed.\n"
base.random.boxMuller.seedLength,"\nbase.random.boxMuller.seedLength\n    Length of generator seed.\n"
base.random.boxMuller.state,"\nbase.random.boxMuller.state\n    Generator state.\n"
base.random.boxMuller.stateLength,"\nbase.random.boxMuller.stateLength\n    Length of generator state.\n"
base.random.boxMuller.byteLength,"\nbase.random.boxMuller.byteLength\n    Size (in bytes) of generator state.\n"
base.random.boxMuller.toJSON,"\nbase.random.boxMuller.toJSON()\n    Serializes the pseudorandom number generator as a JSON object.\n"
base.random.cauchy,"\nbase.random.cauchy( x0:number, Ɣ:number )\n    Returns a pseudorandom number drawn from a Cauchy distribution.\n"
base.random.cauchy.factory,"\nbase.random.cauchy.factory( [x0:number, Ɣ:number, ][options:Object] )\n    Returns a pseudorandom number generator (PRNG) for generating pseudorandom\n    numbers drawn from a Cauchy distribution.\n"
base.random.cauchy.NAME,"\nbase.random.cauchy.NAME\n    Generator name.\n"
base.random.cauchy.PRNG,"\nbase.random.cauchy.PRNG\n    Underlying pseudorandom number generator.\n"
base.random.cauchy.seed,"\nbase.random.cauchy.seed\n    Pseudorandom number generator seed.\n"
base.random.cauchy.seedLength,"\nbase.random.cauchy.seedLength\n    Length of generator seed.\n"
base.random.cauchy.state,"\nbase.random.cauchy.state\n    Generator state.\n"
base.random.cauchy.stateLength,"\nbase.random.cauchy.stateLength\n    Length of generator state.\n"
base.random.cauchy.byteLength,"\nbase.random.cauchy.byteLength\n    Size (in bytes) of generator state.\n"
base.random.cauchy.toJSON,"\nbase.random.cauchy.toJSON()\n    Serializes the pseudorandom number generator as a JSON object.\n"
base.random.chi,"\nbase.random.chi( k:number )\n    Returns a pseudorandom number drawn from a chi distribution.\n"
base.random.chi.factory,"\nbase.random.chi.factory( [k:number, ][options:Object] )\n    Returns a pseudorandom number generator (PRNG) for generating pseudorandom\n    numbers drawn from a chi distribution.\n"
base.random.chi.NAME,"\nbase.random.chi.NAME\n    Generator name.\n"
base.random.chi.PRNG,"\nbase.random.chi.PRNG\n    Underlying pseudorandom number generator.\n"
base.random.chi.seed,"\nbase.random.chi.seed\n    Pseudorandom number generator seed.\n"
base.random.chi.seedLength,"\nbase.random.chi.seedLength\n    Length of generator seed.\n"
base.random.chi.state,"\nbase.random.chi.state\n    Generator state.\n"
base.random.chi.stateLength,"\nbase.random.chi.stateLength\n    Length of generator state.\n"
base.random.chi.byteLength,"\nbase.random.chi.byteLength\n    Size (in bytes) of generator state.\n"
base.random.chi.toJSON,"\nbase.random.chi.toJSON()\n    Serializes the pseudorandom number generator as a JSON object.\n"
base.random.chisquare,"\nbase.random.chisquare( k:number )\n    Returns a pseudorandom number drawn from a chi-square distribution.\n"
base.random.chisquare.factory,"\nbase.random.chisquare.factory( [k:number, ][options:Object] )\n    Returns a pseudorandom number generator (PRNG) for generating pseudorandom\n    numbers drawn from a chi-square distribution.\n"
base.random.chisquare.NAME,"\nbase.random.chisquare.NAME\n    Generator name.\n"
base.random.chisquare.PRNG,"\nbase.random.chisquare.PRNG\n    Underlying pseudorandom number generator.\n"
base.random.chisquare.seed,"\nbase.random.chisquare.seed\n    Pseudorandom number generator seed.\n"
base.random.chisquare.seedLength,"\nbase.random.chisquare.seedLength\n    Length of generator seed.\n"
base.random.chisquare.state,"\nbase.random.chisquare.state\n    Generator state.\n"
base.random.chisquare.stateLength,"\nbase.random.chisquare.stateLength\n    Length of generator state.\n"
base.random.chisquare.byteLength,"\nbase.random.chisquare.byteLength\n    Size (in bytes) of generator state.\n"
base.random.chisquare.toJSON,"\nbase.random.chisquare.toJSON()\n    Serializes the pseudorandom number generator as a JSON object.\n"
base.random.cosine,"\nbase.random.cosine( μ:number, s:number )\n    Returns a pseudorandom number drawn from a raised cosine distribution.\n"
base.random.cosine.factory,"\nbase.random.cosine.factory( [μ:number, s:number, ][options:Object] )\n    Returns a pseudorandom number generator (PRNG) for generating pseudorandom\n    numbers drawn from a raised cosine distribution.\n"
base.random.cosine.NAME,"\nbase.random.cosine.NAME\n    Generator name.\n"
base.random.cosine.PRNG,"\nbase.random.cosine.PRNG\n    Underlying pseudorandom number generator.\n"
base.random.cosine.seed,"\nbase.random.cosine.seed\n    Pseudorandom number generator seed.\n"
base.random.cosine.seedLength,"\nbase.random.cosine.seedLength\n    Length of generator seed.\n"
base.random.cosine.state,"\nbase.random.cosine.state\n    Generator state.\n"
base.random.cosine.stateLength,"\nbase.random.cosine.stateLength\n    Length of generator state.\n"
base.random.cosine.byteLength,"\nbase.random.cosine.byteLength\n    Size (in bytes) of generator state.\n"
base.random.cosine.toJSON,"\nbase.random.cosine.toJSON()\n    Serializes the pseudorandom number generator as a JSON object.\n"
base.random.discreteUniform,"\nbase.random.discreteUniform( a:integer, b:integer )\n    Returns a pseudorandom number drawn from a discrete uniform distribution.\n"
base.random.discreteUniform.factory,"\nbase.random.discreteUniform.factory( [a:integer, b:integer, ][options:Object] )\n    Returns a pseudorandom number generator (PRNG) for generating pseudorandom\n    numbers drawn from a discrete uniform distribution.\n"
base.random.discreteUniform.NAME,"\nbase.random.discreteUniform.NAME\n    Generator name.\n"
base.random.discreteUniform.PRNG,"\nbase.random.discreteUniform.PRNG\n    Underlying pseudorandom number generator.\n"
base.random.discreteUniform.seed,"\nbase.random.discreteUniform.seed\n    Pseudorandom number generator seed.\n"
base.random.discreteUniform.seedLength,"\nbase.random.discreteUniform.seedLength\n    Length of generator seed.\n"
base.random.discreteUniform.state,"\nbase.random.discreteUniform.state\n    Generator state.\n"
base.random.discreteUniform.stateLength,"\nbase.random.discreteUniform.stateLength\n    Length of generator state.\n"
base.random.discreteUniform.byteLength,"\nbase.random.discreteUniform.byteLength\n    Size (in bytes) of generator state.\n"
base.random.discreteUniform.toJSON,"\nbase.random.discreteUniform.toJSON()\n    Serializes the pseudorandom number generator as a JSON object.\n"
base.random.erlang,"\nbase.random.erlang( k:integer, λ:number )\n    Returns a pseudorandom number drawn from an Erlang distribution.\n"
base.random.erlang.factory,"\nbase.random.erlang.factory( [k:integer, λ:number, ][options:Object] )\n    Returns a pseudorandom number generator (PRNG) for generating pseudorandom\n    numbers drawn from an Erlang distribution.\n"
base.random.erlang.NAME,"\nbase.random.erlang.NAME\n    Generator name.\n"
base.random.erlang.PRNG,"\nbase.random.erlang.PRNG\n    Underlying pseudorandom number generator.\n"
base.random.erlang.seed,"\nbase.random.erlang.seed\n    Pseudorandom number generator seed.\n"
base.random.erlang.seedLength,"\nbase.random.erlang.seedLength\n    Length of generator seed.\n"
base.random.erlang.state,"\nbase.random.erlang.state\n    Generator state.\n"
base.random.erlang.stateLength,"\nbase.random.erlang.stateLength\n    Length of generator state.\n"
base.random.erlang.byteLength,"\nbase.random.erlang.byteLength\n    Size (in bytes) of generator state.\n"
base.random.erlang.toJSON,"\nbase.random.erlang.toJSON()\n    Serializes the pseudorandom number generator as a JSON object.\n"
base.random.exponential,"\nbase.random.exponential( λ:number )\n    Returns a pseudorandom number drawn from an exponential distribution.\n"
base.random.exponential.factory,"\nbase.random.exponential.factory( [λ:number, ][options:Object] )\n    Returns a pseudorandom number generator (PRNG) for generating pseudorandom\n    numbers drawn from an exponential distribution.\n"
base.random.exponential.NAME,"\nbase.random.exponential.NAME\n    Generator name.\n"
base.random.exponential.PRNG,"\nbase.random.exponential.PRNG\n    Underlying pseudorandom number generator.\n"
base.random.exponential.seed,"\nbase.random.exponential.seed\n    Pseudorandom number generator seed.\n"
base.random.exponential.seedLength,"\nbase.random.exponential.seedLength\n    Length of generator seed.\n"
base.random.exponential.state,"\nbase.random.exponential.state\n    Generator state.\n"
base.random.exponential.stateLength,"\nbase.random.exponential.stateLength\n    Length of generator state.\n"
base.random.exponential.byteLength,"\nbase.random.exponential.byteLength\n    Size (in bytes) of generator state.\n"
base.random.exponential.toJSON,"\nbase.random.exponential.toJSON()\n    Serializes the pseudorandom number generator as a JSON object.\n"
base.random.f,"\nbase.random.f( d1:number, d2:number )\n    Returns a pseudorandom number drawn from an F distribution.\n"
base.random.f.factory,"\nbase.random.f.factory( [d1:number, d2:number, ][options:Object] )\n    Returns a pseudorandom number generator (PRNG) for generating pseudorandom\n    numbers drawn from an F distribution.\n"
base.random.f.NAME,"\nbase.random.f.NAME\n    Generator name.\n"
base.random.f.PRNG,"\nbase.random.f.PRNG\n    Underlying pseudorandom number generator.\n"
base.random.f.seed,"\nbase.random.f.seed\n    Pseudorandom number generator seed.\n"
base.random.f.seedLength,"\nbase.random.f.seedLength\n    Length of generator seed.\n"
base.random.f.state,"\nbase.random.f.state\n    Generator state.\n"
base.random.f.stateLength,"\nbase.random.f.stateLength\n    Length of generator state.\n"
base.random.f.byteLength,"\nbase.random.f.byteLength\n    Size (in bytes) of generator state.\n"
base.random.f.toJSON,"\nbase.random.f.toJSON()\n    Serializes the pseudorandom number generator as a JSON object.\n"
base.random.frechet,"\nbase.random.frechet( α:number, s:number, m:number )\n    Returns a pseudorandom number drawn from a Fréchet distribution.\n"
base.random.frechet.factory,"\nbase.random.frechet.factory( [α:number, s:number, m:number, ][options:Object] )\n    Returns a pseudorandom number generator (PRNG) for generating pseudorandom\n    numbers drawn from a triangular distribution.\n"
base.random.frechet.NAME,"\nbase.random.frechet.NAME\n    Generator name.\n"
base.random.frechet.PRNG,"\nbase.random.frechet.PRNG\n    Underlying pseudorandom number generator.\n"
base.random.frechet.seed,"\nbase.random.frechet.seed\n    Pseudorandom number generator seed.\n"
base.random.frechet.seedLength,"\nbase.random.frechet.seedLength\n    Length of generator seed.\n"
base.random.frechet.state,"\nbase.random.frechet.state\n    Generator state.\n"
base.random.frechet.stateLength,"\nbase.random.frechet.stateLength\n    Length of generator state.\n"
base.random.frechet.byteLength,"\nbase.random.frechet.byteLength\n    Size (in bytes) of generator state.\n"
base.random.frechet.toJSON,"\nbase.random.frechet.toJSON()\n    Serializes the pseudorandom number generator as a JSON object.\n"
base.random.gamma,"\nbase.random.gamma( α:number, β:number )\n    Returns a pseudorandom number drawn from a gamma distribution.\n"
base.random.gamma.factory,"\nbase.random.gamma.factory( [α:number, β:number, ][options:Object] )\n    Returns a pseudorandom number generator (PRNG) for generating pseudorandom\n    numbers drawn from a gamma distribution.\n"
base.random.gamma.NAME,"\nbase.random.gamma.NAME\n    Generator name.\n"
base.random.gamma.PRNG,"\nbase.random.gamma.PRNG\n    Underlying pseudorandom number generator.\n"
base.random.gamma.seed,"\nbase.random.gamma.seed\n    Pseudorandom number generator seed.\n"
base.random.gamma.seedLength,"\nbase.random.gamma.seedLength\n    Length of generator seed.\n"
base.random.gamma.state,"\nbase.random.gamma.state\n    Generator state.\n"
base.random.gamma.stateLength,"\nbase.random.gamma.stateLength\n    Length of generator state.\n"
base.random.gamma.byteLength,"\nbase.random.gamma.byteLength\n    Size of generator state.\n"
base.random.gamma.toJSON,"\nbase.random.gamma.toJSON()\n    Serializes the pseudorandom number generator as a JSON object.\n"
base.random.geometric,"\nbase.random.geometric( p:number )\n    Returns a pseudorandom number drawn from a geometric distribution.\n"
base.random.geometric.factory,"\nbase.random.geometric.factory( [p:number, ][options:Object] )\n    Returns a pseudorandom number generator (PRNG) for generating pseudorandom\n    numbers drawn from a geometric distribution.\n"
base.random.geometric.NAME,"\nbase.random.geometric.NAME\n    Generator name.\n"
base.random.geometric.PRNG,"\nbase.random.geometric.PRNG\n    Underlying pseudorandom number generator.\n"
base.random.geometric.seed,"\nbase.random.geometric.seed\n    Pseudorandom number generator seed.\n"
base.random.geometric.seedLength,"\nbase.random.geometric.seedLength\n    Length of generator seed.\n"
base.random.geometric.state,"\nbase.random.geometric.state\n    Generator state.\n"
base.random.geometric.stateLength,"\nbase.random.geometric.stateLength\n    Length of generator state.\n"
base.random.geometric.byteLength,"\nbase.random.geometric.byteLength\n    Size (in bytes) of generator state.\n"
base.random.geometric.toJSON,"\nbase.random.geometric.toJSON()\n    Serializes the pseudorandom number generator as a JSON object.\n"
base.random.gumbel,"\nbase.random.gumbel( μ:number, β:number )\n    Returns a pseudorandom number drawn from a Gumbel distribution.\n"
base.random.gumbel.factory,"\nbase.random.gumbel.factory( [μ:number, β:number, ][options:Object] )\n    Returns a pseudorandom number generator (PRNG) for generating pseudorandom\n    numbers drawn from a Gumbel distribution.\n"
base.random.gumbel.NAME,"\nbase.random.gumbel.NAME\n    Generator name.\n"
base.random.gumbel.PRNG,"\nbase.random.gumbel.PRNG\n    Underlying pseudorandom number generator.\n"
base.random.gumbel.seed,"\nbase.random.gumbel.seed\n    Pseudorandom number generator seed.\n"
base.random.gumbel.seedLength,"\nbase.random.gumbel.seedLength\n    Length of generator seed.\n"
base.random.gumbel.state,"\nbase.random.gumbel.state\n    Generator state.\n"
base.random.gumbel.stateLength,"\nbase.random.gumbel.stateLength\n    Length of generator state.\n"
base.random.gumbel.byteLength,"\nbase.random.gumbel.byteLength\n    Size (in bytes) of generator state.\n"
base.random.gumbel.toJSON,"\nbase.random.gumbel.toJSON()\n    Serializes the pseudorandom number generator as a JSON object.\n"
base.random.hypergeometric,"\nbase.random.hypergeometric( N:integer, K:integer, n:integer )\n    Returns a pseudorandom number drawn from a hypergeometric distribution.\n"
base.random.hypergeometric.factory,"\nbase.random.hypergeometric.factory( [N:integer, K:integer, n:integer, ]\n  [options:Object] )\n    Returns a pseudorandom number generator (PRNG) for generating pseudorandom\n    numbers drawn from a hypergeometric distribution.\n"
base.random.hypergeometric.NAME,"\nbase.random.hypergeometric.NAME\n    Generator name.\n"
base.random.hypergeometric.PRNG,"\nbase.random.hypergeometric.PRNG\n    Underlying pseudorandom number generator.\n"
base.random.hypergeometric.seed,"\nbase.random.hypergeometric.seed\n    Pseudorandom number generator seed.\n"
base.random.hypergeometric.seedLength,"\nbase.random.hypergeometric.seedLength\n    Length of generator seed.\n"
base.random.hypergeometric.state,"\nbase.random.hypergeometric.state\n    Generator state.\n"
base.random.hypergeometric.stateLength,"\nbase.random.hypergeometric.stateLength\n    Length of generator state.\n"
base.random.hypergeometric.byteLength,"\nbase.random.hypergeometric.byteLength\n    Size (in bytes) of generator state.\n"
base.random.hypergeometric.toJSON,"\nbase.random.hypergeometric.toJSON()\n    Serializes the pseudorandom number generator as a JSON object.\n"
base.random.improvedZiggurat,"\nbase.random.improvedZiggurat()\n    Returns a pseudorandom number drawn from a standard normal distribution.\n"
base.random.improvedZiggurat.factory,"\nbase.random.improvedZiggurat.factory( [options:Object] )\n    Returns a pseudorandom number generator (PRNG) for generating pseudorandom\n    numbers drawn from a standard normal distribution.\n"
base.random.improvedZiggurat.NAME,"\nbase.random.improvedZiggurat.NAME\n    Generator name.\n"
base.random.improvedZiggurat.PRNG,"\nbase.random.improvedZiggurat.PRNG\n    Underlying pseudorandom number generator.\n"
base.random.improvedZiggurat.seed,"\nbase.random.improvedZiggurat.seed\n    Pseudorandom number generator seed.\n"
base.random.improvedZiggurat.seedLength,"\nbase.random.improvedZiggurat.seedLength\n    Length of generator seed.\n"
base.random.improvedZiggurat.state,"\nbase.random.improvedZiggurat.state\n    Generator state.\n"
base.random.improvedZiggurat.stateLength,"\nbase.random.improvedZiggurat.stateLength\n    Length of generator state.\n"
base.random.improvedZiggurat.byteLength,"\nbase.random.improvedZiggurat.byteLength\n    Size (in bytes) of generator state.\n"
base.random.improvedZiggurat.toJSON,"\nbase.random.improvedZiggurat.toJSON()\n    Serializes the pseudorandom number generator as a JSON object.\n"
base.random.invgamma,"\nbase.random.invgamma( α:number, β:number )\n    Returns a pseudorandom number drawn from an inverse gamma distribution.\n"
base.random.invgamma.factory,"\nbase.random.invgamma.factory( [α:number, β:number, ][options:Object] )\n    Returns a pseudorandom number generator (PRNG) for generating pseudorandom\n    numbers drawn from an inverse gamma distribution.\n"
base.random.invgamma.NAME,"\nbase.random.invgamma.NAME\n    Generator name.\n"
base.random.invgamma.PRNG,"\nbase.random.invgamma.PRNG\n    Underlying pseudorandom number generator.\n"
base.random.invgamma.seed,"\nbase.random.invgamma.seed\n    Pseudorandom number generator seed.\n"
base.random.invgamma.seedLength,"\nbase.random.invgamma.seedLength\n    Length of generator seed.\n"
base.random.invgamma.state,"\nbase.random.invgamma.state\n    Generator state.\n"
base.random.invgamma.stateLength,"\nbase.random.invgamma.stateLength\n    Length of generator state.\n"
base.random.invgamma.byteLength,"\nbase.random.invgamma.byteLength\n    Size of generator state.\n"
base.random.invgamma.toJSON,"\nbase.random.invgamma.toJSON()\n    Serializes the pseudorandom number generator as a JSON object.\n"
base.random.kumaraswamy,"\nbase.random.kumaraswamy( a:number, b:number )\n    Returns a pseudorandom number drawn from Kumaraswamy's double bounded\n    distribution.\n"
base.random.kumaraswamy.factory,"\nbase.random.kumaraswamy.factory( [a:number, b:number, ][options:Object] )\n    Returns a pseudorandom number generator (PRNG) for generating pseudorandom\n    numbers drawn from Kumaraswamy's double bounded distribution.\n"
base.random.kumaraswamy.NAME,"\nbase.random.kumaraswamy.NAME\n    Generator name.\n"
base.random.kumaraswamy.PRNG,"\nbase.random.kumaraswamy.PRNG\n    Underlying pseudorandom number generator.\n"
base.random.kumaraswamy.seed,"\nbase.random.kumaraswamy.seed\n    Pseudorandom number generator seed.\n"
base.random.kumaraswamy.seedLength,"\nbase.random.kumaraswamy.seedLength\n    Length of generator seed.\n"
base.random.kumaraswamy.state,"\nbase.random.kumaraswamy.state\n    Generator state.\n"
base.random.kumaraswamy.stateLength,"\nbase.random.kumaraswamy.stateLength\n    Length of generator state.\n"
base.random.kumaraswamy.byteLength,"\nbase.random.kumaraswamy.byteLength\n    Size (in bytes) of generator state.\n"
base.random.kumaraswamy.toJSON,"\nbase.random.kumaraswamy.toJSON()\n    Serializes the pseudorandom number generator as a JSON object.\n"
base.random.laplace,"\nbase.random.laplace( μ:number, b:number )\n    Returns a pseudorandom number drawn from a Laplace distribution.\n"
base.random.laplace.factory,"\nbase.random.laplace.factory( [μ:number, b:number, ][options:Object] )\n    Returns a pseudorandom number generator (PRNG) for generating pseudorandom\n    numbers drawn from a Laplace distribution.\n"
base.random.laplace.NAME,"\nbase.random.laplace.NAME\n    Generator name.\n"
base.random.laplace.PRNG,"\nbase.random.laplace.PRNG\n    Underlying pseudorandom number generator.\n"
base.random.laplace.seed,"\nbase.random.laplace.seed\n    Pseudorandom number generator seed.\n"
base.random.laplace.seedLength,"\nbase.random.laplace.seedLength\n    Length of generator seed.\n"
base.random.laplace.state,"\nbase.random.laplace.state\n    Generator state.\n"
base.random.laplace.stateLength,"\nbase.random.laplace.stateLength\n    Length of generator state.\n"
base.random.laplace.byteLength,"\nbase.random.laplace.byteLength\n    Size (in bytes) of generator state.\n"
base.random.laplace.toJSON,"\nbase.random.laplace.toJSON()\n    Serializes the pseudorandom number generator as a JSON object.\n"
base.random.levy,"\nbase.random.levy( μ:number, c:number )\n    Returns a pseudorandom number drawn from a Lévy distribution.\n"
base.random.levy.factory,"\nbase.random.levy.factory( [μ:number, c:number, ][options:Object] )\n    Returns a pseudorandom number generator (PRNG) for generating pseudorandom\n    numbers drawn from a Lévy distribution.\n"
base.random.levy.NAME,"\nbase.random.levy.NAME\n    Generator name.\n"
base.random.levy.PRNG,"\nbase.random.levy.PRNG\n    Underlying pseudorandom number generator.\n"
base.random.levy.seed,"\nbase.random.levy.seed\n    Pseudorandom number generator seed.\n"
base.random.levy.seedLength,"\nbase.random.levy.seedLength\n    Length of generator seed.\n"
base.random.levy.state,"\nbase.random.levy.state\n    Generator state.\n"
base.random.levy.stateLength,"\nbase.random.levy.stateLength\n    Length of generator state.\n"
base.random.levy.byteLength,"\nbase.random.levy.byteLength\n    Size (in bytes) of generator state.\n"
base.random.levy.toJSON,"\nbase.random.levy.toJSON()\n    Serializes the pseudorandom number generator as a JSON object.\n"
base.random.logistic,"\nbase.random.logistic( μ:number, s:number )\n    Returns a pseudorandom number drawn from a logistic distribution.\n"
base.random.logistic.factory,"\nbase.random.logistic.factory( [μ:number, s:number, ][options:Object] )\n    Returns a pseudorandom number generator (PRNG) for generating pseudorandom\n    numbers drawn from a logistic distribution.\n"
base.random.logistic.NAME,"\nbase.random.logistic.NAME\n    Generator name.\n"
base.random.logistic.PRNG,"\nbase.random.logistic.PRNG\n    Underlying pseudorandom number generator.\n"
base.random.logistic.seed,"\nbase.random.logistic.seed\n    Pseudorandom number generator seed.\n"
base.random.logistic.seedLength,"\nbase.random.logistic.seedLength\n    Length of generator seed.\n"
base.random.logistic.state,"\nbase.random.logistic.state\n    Generator state.\n"
base.random.logistic.stateLength,"\nbase.random.logistic.stateLength\n    Length of generator state.\n"
base.random.logistic.byteLength,"\nbase.random.logistic.byteLength\n    Size (in bytes) of generator state.\n"
base.random.logistic.toJSON,"\nbase.random.logistic.toJSON()\n    Serializes the pseudorandom number generator as a JSON object.\n"
base.random.lognormal,"\nbase.random.lognormal( μ:number, σ:number )\n    Returns a pseudorandom number drawn from a lognormal distribution.\n"
base.random.lognormal.factory,"\nbase.random.lognormal.factory( [μ:number, σ:number, ][options:Object] )\n    Returns a pseudorandom number generator (PRNG) for generating pseudorandom\n    numbers drawn from a lognormal distribution.\n"
base.random.lognormal.NAME,"\nbase.random.lognormal.NAME\n    Generator name.\n"
base.random.lognormal.PRNG,"\nbase.random.lognormal.PRNG\n    Underlying pseudorandom number generator.\n"
base.random.lognormal.seed,"\nbase.random.lognormal.seed\n    Pseudorandom number generator seed.\n"
base.random.lognormal.seedLength,"\nbase.random.lognormal.seedLength\n    Length of generator seed.\n"
base.random.lognormal.state,"\nbase.random.lognormal.state\n    Generator state.\n"
base.random.lognormal.stateLength,"\nbase.random.lognormal.stateLength\n    Length of generator state.\n"
base.random.lognormal.byteLength,"\nbase.random.lognormal.byteLength\n    Size (in bytes) of generator state.\n"
base.random.lognormal.toJSON,"\nbase.random.lognormal.toJSON()\n    Serializes the pseudorandom number generator as a JSON object.\n"
base.random.minstd,"\nbase.random.minstd()\n    Returns a pseudorandom integer on the interval `[1, 2147483646]`.\n"
base.random.minstd.normalized,"\nbase.random.minstd.normalized()\n    Returns a pseudorandom number on the interval `[0,1)`.\n"
base.random.minstd.factory,"\nbase.random.minstd.factory( [options:Object] )\n    Returns a linear congruential pseudorandom number generator (LCG).\n"
base.random.minstd.NAME,"\nbase.random.minstd.NAME\n    Generator name.\n"
base.random.minstd.MIN,"\nbase.random.minstd.MIN\n    Minimum possible value.\n"
base.random.minstd.MAX,"\nbase.random.minstd.MAX\n    Maximum possible value.\n"
base.random.minstd.seed,"\nbase.random.minstd.seed\n    Pseudorandom number generator seed.\n"
base.random.minstd.seedLength,"\nbase.random.minstd.seedLength\n    Length of generator seed.\n"
base.random.minstd.state,"\nbase.random.minstd.state\n    Generator state.\n"
base.random.minstd.stateLength,"\nbase.random.minstd.stateLength\n    Length of generator state.\n"
base.random.minstd.byteLength,"\nbase.random.minstd.byteLength\n    Size (in bytes) of generator state.\n"
base.random.minstd.toJSON,"\nbase.random.minstd.toJSON()\n    Serializes the pseudorandom number generator as a JSON object.\n"
base.random.minstdShuffle,"\nbase.random.minstdShuffle()\n    Returns a pseudorandom integer on the interval `[1, 2147483646]`.\n"
base.random.minstdShuffle.normalized,"\nbase.random.minstdShuffle.normalized()\n    Returns a pseudorandom number on the interval `[0,1)`.\n"
base.random.minstdShuffle.factory,"\nbase.random.minstdShuffle.factory( [options:Object] )\n    Returns a linear congruential pseudorandom number generator (LCG) whose\n    output is shuffled.\n"
base.random.minstdShuffle.NAME,"\nbase.random.minstdShuffle.NAME\n    Generator name.\n"
base.random.minstdShuffle.MIN,"\nbase.random.minstdShuffle.MIN\n    Minimum possible value.\n"
base.random.minstdShuffle.MAX,"\nbase.random.minstdShuffle.MAX\n    Maximum possible value.\n"
base.random.minstdShuffle.seed,"\nbase.random.minstdShuffle.seed\n    Pseudorandom number generator seed.\n"
base.random.minstdShuffle.seedLength,"\nbase.random.minstdShuffle.seedLength\n    Length of generator seed.\n"
base.random.minstdShuffle.state,"\nbase.random.minstdShuffle.state\n    Generator state.\n"
base.random.minstdShuffle.stateLength,"\nbase.random.minstdShuffle.stateLength\n    Length of generator state.\n"
base.random.minstdShuffle.byteLength,"\nbase.random.minstdShuffle.byteLength\n    Size (in bytes) of generator state.\n"
base.random.minstdShuffle.toJSON,"\nbase.random.minstdShuffle.toJSON()\n    Serializes the pseudorandom number generator as a JSON object.\n"
base.random.mt19937,"\nbase.random.mt19937()\n    Returns a pseudorandom integer on the interval `[1, 4294967295]`.\n"
base.random.mt19937.normalized,"\nbase.random.mt19937.normalized()\n    Returns a pseudorandom number on the interval `[0,1)` with 53-bit precision.\n"
base.random.mt19937.factory,"\nbase.random.mt19937.factory( [options:Object] )\n    Returns a 32-bit Mersenne Twister pseudorandom number generator.\n"
base.random.mt19937.NAME,"\nbase.random.mt19937.NAME\n    Generator name.\n"
base.random.mt19937.MIN,"\nbase.random.mt19937.MIN\n    Minimum possible value.\n"
base.random.mt19937.MAX,"\nbase.random.mt19937.MAX\n    Maximum possible value.\n"
base.random.mt19937.seed,"\nbase.random.mt19937.seed\n    Pseudorandom number generator seed.\n"
base.random.mt19937.seedLength,"\nbase.random.mt19937.seedLength\n    Length of generator seed.\n"
base.random.mt19937.state,"\nbase.random.mt19937.state\n    Generator state.\n"
base.random.mt19937.stateLength,"\nbase.random.mt19937.stateLength\n    Length of generator state.\n"
base.random.mt19937.byteLength,"\nbase.random.mt19937.byteLength\n    Size (in bytes) of generator state.\n"
base.random.mt19937.toJSON,"\nbase.random.mt19937.toJSON()\n    Serializes the pseudorandom number generator as a JSON object.\n"
base.random.negativeBinomial,"\nbase.random.negativeBinomial( r:number, p:number )\n    Returns a pseudorandom number drawn from a negative binomial distribution.\n"
base.random.negativeBinomial.factory,"\nbase.random.negativeBinomial.factory( [r:number, p:number, ][options:Object] )\n    Returns a pseudorandom number generator (PRNG) for generating pseudorandom\n    numbers drawn from a negative binomial distribution.\n"
base.random.negativeBinomial.NAME,"\nbase.random.negativeBinomial.NAME\n    Generator name.\n"
base.random.negativeBinomial.PRNG,"\nbase.random.negativeBinomial.PRNG\n    Underlying pseudorandom number generator.\n"
base.random.negativeBinomial.seed,"\nbase.random.negativeBinomial.seed\n    Pseudorandom number generator seed.\n"
base.random.negativeBinomial.seedLength,"\nbase.random.negativeBinomial.seedLength\n    Length of generator seed.\n"
base.random.negativeBinomial.state,"\nbase.random.negativeBinomial.state\n    Generator state.\n"
base.random.negativeBinomial.stateLength,"\nbase.random.negativeBinomial.stateLength\n    Length of generator state.\n"
base.random.negativeBinomial.byteLength,"\nbase.random.negativeBinomial.byteLength\n    Size (in bytes) of generator state.\n"
base.random.negativeBinomial.toJSON,"\nbase.random.negativeBinomial.toJSON()\n    Serializes the pseudorandom number generator as a JSON object.\n"
base.random.normal,"\nbase.random.normal( μ:number, σ:number )\n    Returns a pseudorandom number drawn from a normal distribution.\n"
base.random.normal.factory,"\nbase.random.normal.factory( [μ:number, σ:number, ][options:Object] )\n    Returns a pseudorandom number generator (PRNG) for generating pseudorandom\n    numbers drawn from a normal distribution.\n"
base.random.normal.NAME,"\nbase.random.normal.NAME\n    Generator name.\n"
base.random.normal.PRNG,"\nbase.random.normal.PRNG\n    Underlying pseudorandom number generator.\n"
base.random.normal.seed,"\nbase.random.normal.seed\n    Pseudorandom number generator seed.\n"
base.random.normal.seedLength,"\nbase.random.normal.seedLength\n    Length of generator seed.\n"
base.random.normal.state,"\nbase.random.normal.state\n    Generator state.\n"
base.random.normal.stateLength,"\nbase.random.normal.stateLength\n    Length of generator state.\n"
base.random.normal.byteLength,"\nbase.random.normal.byteLength\n    Size of generator state.\n"
base.random.normal.toJSON,"\nbase.random.normal.toJSON()\n    Serializes the pseudorandom number generator as a JSON object.\n"
base.random.pareto1,"\nbase.random.pareto1( α:number, β:number )\n    Returns a pseudorandom number drawn from a Pareto (Type I) distribution.\n"
base.random.pareto1.factory,"\nbase.random.pareto1.factory( [α:number, β:number, ][options:Object] )\n    Returns a pseudorandom number generator (PRNG) for generating pseudorandom\n    numbers drawn from a Pareto (Type I) distribution.\n"
base.random.pareto1.NAME,"\nbase.random.pareto1.NAME\n    Generator name.\n"
base.random.pareto1.PRNG,"\nbase.random.pareto1.PRNG\n    Underlying pseudorandom number generator.\n"
base.random.pareto1.seed,"\nbase.random.pareto1.seed\n    Pseudorandom number generator seed.\n"
base.random.pareto1.seedLength,"\nbase.random.pareto1.seedLength\n    Length of generator seed.\n"
base.random.pareto1.state,"\nbase.random.pareto1.state\n    Generator state.\n"
base.random.pareto1.stateLength,"\nbase.random.pareto1.stateLength\n    Length of generator state.\n"
base.random.pareto1.byteLength,"\nbase.random.pareto1.byteLength\n    Size (in bytes) of generator state.\n"
base.random.pareto1.toJSON,"\nbase.random.pareto1.toJSON()\n    Serializes the pseudorandom number generator as a JSON object.\n"
base.random.poisson,"\nbase.random.poisson( λ:number )\n    Returns a pseudorandom number drawn from a Poisson distribution.\n"
base.random.poisson.factory,"\nbase.random.poisson.factory( [λ:number, ][options:Object] )\n    Returns a pseudorandom number generator (PRNG) for generating pseudorandom\n    numbers drawn from a Poisson distribution.\n"
base.random.poisson.NAME,"\nbase.random.poisson.NAME\n    Generator name.\n"
base.random.poisson.PRNG,"\nbase.random.poisson.PRNG\n    Underlying pseudorandom number generator.\n"
base.random.poisson.seed,"\nbase.random.poisson.seed\n    Pseudorandom number generator seed.\n"
base.random.poisson.seedLength,"\nbase.random.poisson.seedLength\n    Length of generator seed.\n"
base.random.poisson.state,"\nbase.random.poisson.state\n    Generator state.\n"
base.random.poisson.stateLength,"\nbase.random.poisson.stateLength\n    Length of generator state.\n"
base.random.poisson.byteLength,"\nbase.random.poisson.byteLength\n    Size (in bytes) of generator state.\n"
base.random.poisson.toJSON,"\nbase.random.poisson.toJSON()\n    Serializes the pseudorandom number generator as a JSON object.\n"
base.random.randi,"\nbase.random.randi()\n    Returns a pseudorandom number having an integer value.\n"
base.random.randi.factory,"\nbase.random.randi.factory( [options:Object] )\n    Returns a pseudorandom number generator (PRNG) for generating pseudorandom\n    numbers having integer values.\n"
base.random.randi.NAME,"\nbase.random.randi.NAME\n    Generator name.\n"
base.random.randi.PRNG,"\nbase.random.randi.PRNG\n    Underlying pseudorandom number generator.\n"
base.random.randi.MIN,"\nbase.random.randi.MIN\n    Minimum possible value (specific to underlying PRNG).\n"
base.random.randi.MAX,"\nbase.random.randi.MAX\n    Maximum possible value (specific to underlying PRNG).\n"
base.random.randi.seed,"\nbase.random.randi.seed\n    Pseudorandom number generator seed.\n"
base.random.randi.seedLength,"\nbase.random.randi.seedLength\n    Length of generator seed.\n"
base.random.randi.state,"\nbase.random.randi.state\n    Generator state.\n"
base.random.randi.stateLength,"\nbase.random.randi.stateLength\n    Length of generator state.\n"
base.random.randi.byteLength,"\nbase.random.randi.byteLength\n    Size (in bytes) of generator state.\n"
base.random.randi.toJSON,"\nbase.random.randi.toJSON()\n    Serializes the pseudorandom number generator as a JSON object.\n"
base.random.randn,"\nbase.random.randn()\n    Returns a pseudorandom number drawn from a standard normal distribution.\n"
base.random.randn.factory,"\nbase.random.randn.factory( [options:Object] )\n    Returns a pseudorandom number generator (PRNG) for generating pseudorandom\n    numbers drawn from a standard normal distribution.\n"
base.random.randn.NAME,"\nbase.random.randn.NAME\n    Generator name.\n"
base.random.randn.PRNG,"\nbase.random.randn.PRNG\n    Underlying pseudorandom number generator.\n"
base.random.randn.seed,"\nbase.random.randn.seed\n    Pseudorandom number generator seed.\n"
base.random.randn.seedLength,"\nbase.random.randn.seedLength\n    Length of generator seed.\n"
base.random.randn.state,"\nbase.random.randn.state\n    Generator state.\n"
base.random.randn.stateLength,"\nbase.random.randn.stateLength\n    Length of generator state.\n"
base.random.randn.byteLength,"\nbase.random.randn.byteLength\n    Size (in bytes) of generator state.\n"
base.random.randn.toJSON,"\nbase.random.randn.toJSON()\n    Serializes the pseudorandom number generator as a JSON object.\n"
base.random.randu,"\nbase.random.randu()\n    Returns a pseudorandom number drawn from a uniform distribution.\n"
base.random.randu.factory,"\nbase.random.randu.factory( [options:Object] )\n    Returns a pseudorandom number generator (PRNG) for generating pseudorandom\n    numbers drawn from a uniform distribution.\n"
base.random.randu.NAME,"\nbase.random.randu.NAME\n    Generator name.\n"
base.random.randu.PRNG,"\nbase.random.randu.PRNG\n    Underlying pseudorandom number generator.\n"
base.random.randu.MIN,"\nbase.random.randu.MIN\n    Minimum possible value (specific to underlying PRNG).\n"
base.random.randu.MAX,"\nbase.random.randu.MAX\n    Maximum possible value (specific to underlying PRNG).\n"
base.random.randu.seed,"\nbase.random.randu.seed\n    Pseudorandom number generator seed.\n"
base.random.randu.seedLength,"\nbase.random.randu.seedLength\n    Length of generator seed.\n"
base.random.randu.state,"\nbase.random.randu.state\n    Generator state.\n"
base.random.randu.stateLength,"\nbase.random.randu.stateLength\n    Length of generator state.\n"
base.random.randu.byteLength,"\nbase.random.randu.byteLength\n    Size (in bytes) of generator state.\n"
base.random.randu.toJSON,"\nbase.random.randu.toJSON()\n    Serializes the pseudorandom number generator as a JSON object.\n"
base.random.rayleigh,"\nbase.random.rayleigh( σ:number )\n    Returns a pseudorandom number drawn from a Rayleigh distribution.\n"
base.random.rayleigh.factory,"\nbase.random.rayleigh.factory( [σ:number, ][options:Object] )\n    Returns a pseudorandom number generator (PRNG) for generating pseudorandom\n    numbers drawn from a Rayleigh distribution.\n"
base.random.rayleigh.NAME,"\nbase.random.rayleigh.NAME\n    Generator name.\n"
base.random.rayleigh.PRNG,"\nbase.random.rayleigh.PRNG\n    Underlying pseudorandom number generator.\n"
base.random.rayleigh.seed,"\nbase.random.rayleigh.seed\n    Pseudorandom number generator seed.\n"
base.random.rayleigh.seedLength,"\nbase.random.rayleigh.seedLength\n    Length of generator seed.\n"
base.random.rayleigh.state,"\nbase.random.rayleigh.state\n    Generator state.\n"
base.random.rayleigh.stateLength,"\nbase.random.rayleigh.stateLength\n    Length of generator state.\n"
base.random.rayleigh.byteLength,"\nbase.random.rayleigh.byteLength\n    Size (in bytes) of generator state.\n"
base.random.rayleigh.toJSON,"\nbase.random.rayleigh.toJSON()\n    Serializes the pseudorandom number generator as a JSON object.\n"
base.random.t,"\nbase.random.t( v:number )\n    Returns a pseudorandom number drawn from a Student's t distribution.\n"
base.random.t.factory,"\nbase.random.t.factory( [v:number, ][options:Object] )\n    Returns a pseudorandom number generator (PRNG) for generating pseudorandom\n    numbers drawn from a Student's t distribution.\n"
base.random.t.NAME,"\nbase.random.t.NAME\n    Generator name.\n"
base.random.t.PRNG,"\nbase.random.t.PRNG\n    Underlying pseudorandom number generator.\n"
base.random.t.seed,"\nbase.random.t.seed\n    Pseudorandom number generator seed.\n"
base.random.t.seedLength,"\nbase.random.t.seedLength\n    Length of generator seed.\n"
base.random.t.state,"\nbase.random.t.state\n    Generator state.\n"
base.random.t.stateLength,"\nbase.random.t.stateLength\n    Length of generator state.\n"
base.random.t.byteLength,"\nbase.random.t.byteLength\n    Size (in bytes) of generator state.\n"
base.random.t.toJSON,"\nbase.random.t.toJSON()\n    Serializes the pseudorandom number generator as a JSON object.\n"
base.random.triangular,"\nbase.random.triangular( a:number, b:number, c:number )\n    Returns a pseudorandom number drawn from a triangular distribution.\n"
base.random.triangular.factory,"\nbase.random.triangular.factory( [a:number, b:number, c:number, ]\n  [options:Object] )\n    Returns a pseudorandom number generator (PRNG) for generating pseudorandom\n    numbers drawn from a triangular distribution.\n"
base.random.triangular.NAME,"\nbase.random.triangular.NAME\n    Generator name.\n"
base.random.triangular.PRNG,"\nbase.random.triangular.PRNG\n    Underlying pseudorandom number generator.\n"
base.random.triangular.seed,"\nbase.random.triangular.seed\n    Pseudorandom number generator seed.\n"
base.random.triangular.seedLength,"\nbase.random.triangular.seedLength\n    Length of generator seed.\n"
base.random.triangular.state,"\nbase.random.triangular.state\n    Generator state.\n"
base.random.triangular.stateLength,"\nbase.random.triangular.stateLength\n    Length of generator state.\n"
base.random.triangular.byteLength,"\nbase.random.triangular.byteLength\n    Size (in bytes) of generator state.\n"
base.random.triangular.toJSON,"\nbase.random.triangular.toJSON()\n    Serializes the pseudorandom number generator as a JSON object.\n"
base.random.uniform,"\nbase.random.uniform( a:number, b:number )\n    Returns a pseudorandom number drawn from a continuous uniform distribution.\n"
base.random.uniform.factory,"\nbase.random.uniform.factory( [a:number, b:number, ][options:Object] )\n    Returns a pseudorandom number generator (PRNG) for generating pseudorandom\n    numbers drawn from a continuous uniform distribution.\n"
base.random.uniform.NAME,"\nbase.random.uniform.NAME\n    Generator name.\n"
base.random.uniform.PRNG,"\nbase.random.uniform.PRNG\n    Underlying pseudorandom number generator.\n"
base.random.uniform.seed,"\nbase.random.uniform.seed\n    Pseudorandom number generator seed.\n"
base.random.uniform.seedLength,"\nbase.random.uniform.seedLength\n    Length of generator seed.\n"
base.random.uniform.state,"\nbase.random.uniform.state\n    Generator state.\n"
base.random.uniform.stateLength,"\nbase.random.uniform.stateLength\n    Length of generator state.\n"
base.random.uniform.byteLength,"\nbase.random.uniform.byteLength\n    Size (in bytes) of generator state.\n"
base.random.uniform.toJSON,"\nbase.random.uniform.toJSON()\n    Serializes the pseudorandom number generator as a JSON object.\n"
base.random.weibull,"\nbase.random.weibull( k:number, λ:number )\n    Returns a pseudorandom number drawn from a Weibull distribution.\n"
base.random.weibull.factory,"\nbase.random.weibull.factory( [k:number, λ:number, ][options:Object] )\n    Returns a pseudorandom number generator (PRNG) for generating pseudorandom\n    numbers drawn from a Weibull distribution.\n"
base.random.weibull.NAME,"\nbase.random.weibull.NAME\n    Generator name.\n"
base.random.weibull.PRNG,"\nbase.random.weibull.PRNG\n    Underlying pseudorandom number generator.\n"
base.random.weibull.seed,"\nbase.random.weibull.seed\n    Pseudorandom number generator seed.\n"
base.random.weibull.seedLength,"\nbase.random.weibull.seedLength\n    Length of generator seed.\n"
base.random.weibull.state,"\nbase.random.weibull.state\n    Generator state.\n"
base.random.weibull.stateLength,"\nbase.random.weibull.stateLength\n    Length of generator state.\n"
base.random.weibull.byteLength,"\nbase.random.weibull.byteLength\n    Size (in bytes) of generator state.\n"
base.random.weibull.toJSON,"\nbase.random.weibull.toJSON()\n    Serializes the pseudorandom number generator as a JSON object.\n"
base.reldiff,"\nbase.reldiff( x:number, y:number[, scale:string|Function] )\n    Computes the relative difference of two real numbers.\n"
base.rempio2,"\nbase.rempio2( x:number, y:Array|TypedArray|Object )\n    Computes `x - nπ/2 = r`.\n"
base.risingFactorial,"\nbase.risingFactorial( x:number, n:integer )\n    Computes the rising factorial of `x` and `n`.\n"
base.rotl32,"\nbase.rotl32( x:integer, shift:integer )\n    Performs a bitwise rotation to the left.\n"
base.rotr32,"\nbase.rotr32( x:integer, shift:integer )\n    Performs a bitwise rotation to the right.\n"
base.round,"\nbase.round( x:number )\n    Rounds a numeric value to the nearest integer.\n"
base.round2,"\nbase.round2( x:number )\n    Rounds a numeric value to the nearest power of two on a linear scale.\n"
base.round10,"\nbase.round10( x:number )\n    Rounds a numeric value to the nearest power of ten on a linear scale.\n"
base.roundb,"\nbase.roundb( x:number, n:integer, b:integer )\n    Rounds a numeric value to the nearest multiple of `b^n` on a linear scale.\n"
base.roundn,"\nbase.roundn( x:number, n:integer )\n    Rounds a numeric value to the nearest multiple of `10^n`.\n"
base.roundsd,"\nbase.roundsd( x:number, n:integer[, b:integer] )\n    Rounds a numeric value to the nearest number with `n` significant figures.\n"
base.rsqrt,"\nbase.rsqrt( x:number )\n    Computes the reciprocal square root of a double-precision floating-point\n    number.\n"
base.rsqrtf,"\nbase.rsqrtf( x:number )\n    Computes the reciprocal square root of a single-precision floating-point\n    number.\n"
base.setHighWord,"\nbase.setHighWord( x:number, high:integer )\n    Sets the more significant 32 bits of a double-precision floating-point\n    number.\n"
base.setLowWord,"\nbase.setLowWord( x:number, low:integer )\n    Sets the less significant 32 bits of a double-precision floating-point\n    number.\n"
base.sici,"\nbase.sici( [out:Array|TypedArray|Object,] x:number )\n    Computes the sine and cosine integrals.\n"
base.signbit,"\nbase.signbit( x:number )\n    Returns a boolean indicating if the sign bit is on (true) or off (false).\n"
base.signbitf,"\nbase.signbitf( x:float )\n    Returns a boolean indicating if the sign bit is on (true) or off (false).\n"
base.significandf,"\nbase.significandf( x:float )\n    Returns an integer corresponding to the significand of a single-precision\n    floating-point number.\n"
base.signum,"\nbase.signum( x:number )\n    Evaluates the signum function for a double-precision floating-point number.\n"
base.signumf,"\nbase.signumf( x:number )\n    Evaluates the signum function for a single-precision floating-point number.\n"
base.sin,"\nbase.sin( x:number )\n    Computes the sine of a number.\n"
base.sinc,"\nbase.sinc( x:number )\n    Computes the normalized cardinal sine of a number.\n"
base.sincos,"\nbase.sincos( [out:Array|TypedArray|Object,] x:number )\n    Simultaneously computes the sine and cosine of a number.\n"
base.sincospi,"\nbase.sincospi( [out:Array|TypedArray|Object,] x:number )\n    Simultaneously computes the sine and cosine of a number times π.\n"
base.sinh,"\nbase.sinh( x:number )\n    Computes the hyperbolic sine of a number.\n"
base.sinpi,"\nbase.sinpi( x:number )\n    Computes the value of `sin(πx)`.\n"
base.spence,"\nbase.spence( x:number )\n    Evaluates Spence’s function, which is also known as the dilogarithm.\n"
base.sqrt,"\nbase.sqrt( x:number )\n    Computes the principal square root of a double-precision floating-point\n    number.\n"
base.sqrt1pm1,"\nbase.sqrt1pm1( x:number )\n    Computes the principal square root of `1+x` minus one.\n"
base.sqrtf,"\nbase.sqrtf( x:number )\n    Computes the principal square root of a single-precision floating-point\n    number.\n"
base.strided.binary,"\nbase.strided.binary( arrays:ArrayLikeObject<ArrayLikeObject>, \n  shape:ArrayLikeObject<integer>, strides:ArrayLikeObject<integer>, \n  fcn:Function )\n    Applies a binary callback to strided input array elements and assigns\n    results to elements in a strided output array.\n"
base.strided.binary.ndarray,"\nbase.strided.binary.ndarray( arrays:ArrayLikeObject<ArrayLikeObject>, \n  shape:ArrayLikeObject<integer>, strides:ArrayLikeObject<integer>, \n  offsets:ArrayLikeObject<integer>, fcn:Function )\n    Applies a binary callback to strided input array elements and assigns\n    results to elements in a strided output array using alternative indexing\n    semantics.\n"
base.strided.ccopy,"\nbase.strided.ccopy( N:integer, x:Complex64Array, strideX:integer, \n  y:Complex64Array, strideY:integer )\n    Copies values from one complex single-precision floating-point vector to\n    another complex single-precision floating-point vector.\n"
base.strided.ccopy.ndarray,"\nbase.strided.ccopy.ndarray( N:integer, x:Complex64Array, strideX:integer, \n  offsetX:integer, y:Complex64Array, strideY:integer, offsetY:integer )\n    Copies values from one complex single-precision floating-point vector to\n    another complex single-precision floating-point vector using alternative\n    indexing semantics.\n"
base.strided.cswap,"\nbase.strided.cswap( N:integer, x:Complex64Array, strideX:integer, \n  y:Complex64Array, strideY:integer )\n    Interchanges two complex single-precision floating-point vectors.\n"
base.strided.cswap.ndarray,"\nbase.strided.cswap.ndarray( N:integer, x:Complex64Array, strideX:integer, \n  offsetX:integer, y:Complex64Array, strideY:integer, offsetY:integer )\n    Interchanges two complex single-precision floating-point vectors using\n    alternative indexing semantics.\n"
base.strided.cumax,"\nbase.strided.cumax( N:integer, x:Array|TypedArray, strideX:integer, \n  y:Array|TypedArray, strideY:integer )\n    Computes the cumulative maximum of a strided array.\n"
base.strided.cumax.ndarray,"\nbase.strided.cumax.ndarray( N:integer, x:Array|TypedArray, strideX:integer, \n  offsetX:integer, y:Array|TypedArray, strideY:integer, offsetY:integer )\n    Computes the cumulative maximum of a strided array using alternative\n    indexing semantics.\n"
base.strided.cumaxabs,"\nbase.strided.cumaxabs( N:integer, x:Array|TypedArray, strideX:integer, \n  y:Array|TypedArray, strideY:integer )\n    Computes the cumulative maximum absolute value of a strided array.\n"
base.strided.cumaxabs.ndarray,"\nbase.strided.cumaxabs.ndarray( N:integer, x:Array|TypedArray, strideX:integer, \n  offsetX:integer, y:Array|TypedArray, strideY:integer, offsetY:integer )\n    Computes the cumulative maximum absolute value of a strided array using\n    alternative indexing semantics.\n"
base.strided.cumin,"\nbase.strided.cumin( N:integer, x:Array|TypedArray, strideX:integer, \n  y:Array|TypedArray, strideY:integer )\n    Computes the cumulative minimum of a strided array.\n"
base.strided.cumin.ndarray,"\nbase.strided.cumin.ndarray( N:integer, x:Array|TypedArray, strideX:integer, \n  offsetX:integer, y:Array|TypedArray, strideY:integer, offsetY:integer )\n    Computes the cumulative minimum of a strided array using alternative\n    indexing semantics.\n"
base.strided.cuminabs,"\nbase.strided.cuminabs( N:integer, x:Array|TypedArray, strideX:integer, \n  y:Array|TypedArray, strideY:integer )\n    Computes the cumulative minimum absolute value of a strided array.\n"
base.strided.cuminabs.ndarray,"\nbase.strided.cuminabs.ndarray( N:integer, x:Array|TypedArray, strideX:integer, \n  offsetX:integer, y:Array|TypedArray, strideY:integer, offsetY:integer )\n    Computes the cumulative minimum absolute value of a strided array using\n    alternative indexing semantics.\n"
base.strided.dapx,"\nbase.strided.dapx( N:integer, alpha:number, x:Float64Array, stride:integer )\n    Adds a constant to each element in a double-precision floating-point strided\n    array.\n"
base.strided.dapx.ndarray,"\nbase.strided.dapx.ndarray( N:integer, alpha:number, x:Float64Array, \n  stride:integer, offset:integer )\n    Adds a constant to each element in a double-precision floating-point strided\n    array using alternative indexing semantics.\n"
base.strided.dapxsum,"\nbase.strided.dapxsum( N:integer, alpha:number, x:Float64Array, stride:integer )\n    Adds a constant to each double-precision floating-point strided array\n    element and computes the sum.\n"
base.strided.dapxsum.ndarray,"\nbase.strided.dapxsum.ndarray( N:integer, alpha:number, x:Float64Array, \n  stride:integer, offset:integer )\n    Adds a constant to each double-precision floating-point strided array\n    element and computes the sum using alternative indexing semantics.\n"
base.strided.dapxsumkbn,"\nbase.strided.dapxsumkbn( N:integer, alpha:number, x:Float64Array, \n  stride:integer )\n    Adds a constant to each double-precision floating-point strided array\n    element and computes the sum using an improved Kahan–Babuška algorithm.\n"
base.strided.dapxsumkbn.ndarray,"\nbase.strided.dapxsumkbn.ndarray( N:integer, alpha:number, x:Float64Array, \n  stride:integer, offset:integer )\n    Adds a constant to each double-precision floating-point strided array\n    element and computes the sum using an improved Kahan–Babuška algorithm and\n    alternative indexing semantics.\n"
base.strided.dapxsumkbn2,"\nbase.strided.dapxsumkbn2( N:integer, alpha:number, x:Float64Array, \n  stride:integer )\n    Adds a constant to each double-precision floating-point strided array\n    element and computes the sum using a second-order iterative Kahan–Babuška\n    algorithm.\n"
base.strided.dapxsumkbn2.ndarray,"\nbase.strided.dapxsumkbn2.ndarray( N:integer, alpha:number, x:Float64Array, \n  stride:integer, offset:integer )\n    Adds a constant to each double-precision floating-point strided array\n    element and computes the sum using a second-order iterative Kahan–Babuška\n    algorithm and alternative indexing semantics.\n"
base.strided.dapxsumors,"\nbase.strided.dapxsumors( N:integer, alpha:number, x:Float64Array, \n  stride:integer )\n    Adds a constant to each double-precision floating-point strided array\n    element and computes the sum using ordinary recursive summation.\n"
base.strided.dapxsumors.ndarray,"\nbase.strided.dapxsumors.ndarray( N:integer, alpha:number, x:Float64Array, \n  stride:integer, offset:integer )\n    Adds a constant to each double-precision floating-point strided array\n    element and computes the sum using ordinary recursive summation and\n    alternative indexing semantics.\n"
base.strided.dapxsumpw,"\nbase.strided.dapxsumpw( N:integer, alpha:number, x:Float64Array, \n  stride:integer )\n    Adds a constant to each double-precision floating-point strided array\n    element and computes the sum using pairwise summation.\n"
base.strided.dapxsumpw.ndarray,"\nbase.strided.dapxsumpw.ndarray( N:integer, alpha:number, x:Float64Array, \n  stride:integer, offset:integer )\n    Adds a constant to each double-precision floating-point strided array\n    element and computes the sum using pairwise summation and alternative\n    indexing semantics.\n"
base.strided.dasum,"\nbase.strided.dasum( N:integer, x:Float64Array, stride:integer )\n    Computes the sum of the absolute values.\n"
base.strided.dasum.ndarray,"\nbase.strided.dasum.ndarray( N:integer, x:Float64Array, stride:integer, \n  offset:integer )\n    Computes the sum of absolute values using alternative indexing semantics.\n"
base.strided.dasumpw,"\nbase.strided.dasumpw( N:integer, x:Float64Array, stride:integer )\n    Computes the sum of absolute values (L1 norm) of double-precision floating-\n    point strided array elements using pairwise summation.\n"
base.strided.dasumpw.ndarray,"\nbase.strided.dasumpw.ndarray( N:integer, x:Float64Array, stride:integer, \n  offset:integer )\n    Computes the sum of absolute values (L1 norm) of double-precision floating-\n    point strided array elements using pairwise summation and alternative\n    indexing semantics.\n"
base.strided.daxpy,"\nbase.strided.daxpy( N:integer, alpha:number, x:Float64Array, strideX:integer, \n  y:Float64Array, strideY:integer )\n    Multiplies a vector `x` by a constant `alpha` and adds the result to `y`.\n"
base.strided.daxpy.ndarray,"\nbase.strided.daxpy.ndarray( N:integer, alpha:number, x:Float64Array, \n  strideX:integer, offsetX:integer, y:Float64Array, strideY:integer, \n  offsetY:integer )\n    Multiplies a vector `x` by a constant `alpha` and adds the result to `y`,\n    using alternative indexing semantics.\n"
base.strided.dcopy,"\nbase.strided.dcopy( N:integer, x:Float64Array, strideX:integer, y:Float64Array, \n  strideY:integer )\n    Copies values from `x` into `y`.\n"
base.strided.dcopy.ndarray,"\nbase.strided.dcopy.ndarray( N:integer, x:Float64Array, strideX:integer, \n  offsetX:integer, y:Float64Array, strideY:integer, offsetY:integer )\n    Copies values from `x` into `y` using alternative indexing semantics.\n"
base.strided.dcumax,"\nbase.strided.dcumax( N:integer, x:Float64Array, strideX:integer, \n  y:Float64Array, strideY:integer )\n    Computes the cumulative maximum of double-precision floating-point strided\n    array elements.\n"
base.strided.dcumax.ndarray,"\nbase.strided.dcumax.ndarray( N:integer, x:Float64Array, strideX:integer, \n  offsetX:integer, y:Float64Array, strideY:integer, offsetY:integer )\n    Computes the cumulative maximum of double-precision floating-point strided\n    array elements using alternative indexing semantics.\n"
base.strided.dcumaxabs,"\nbase.strided.dcumaxabs( N:integer, x:Float64Array, strideX:integer, \n  y:Float64Array, strideY:integer )\n    Computes the cumulative maximum absolute value of double-precision floating-\n    point strided array elements.\n"
base.strided.dcumaxabs.ndarray,"\nbase.strided.dcumaxabs.ndarray( N:integer, x:Float64Array, strideX:integer, \n  offsetX:integer, y:Float64Array, strideY:integer, offsetY:integer )\n    Computes the cumulative maximum absolute value of double-precision floating-\n    point strided array elements using alternative indexing semantics.\n"
base.strided.dcumin,"\nbase.strided.dcumin( N:integer, x:Float64Array, strideX:integer, \n  y:Float64Array, strideY:integer )\n    Computes the cumulative minimum of double-precision floating-point strided\n    array elements.\n"
base.strided.dcumin.ndarray,"\nbase.strided.dcumin.ndarray( N:integer, x:Float64Array, strideX:integer, \n  offsetX:integer, y:Float64Array, strideY:integer, offsetY:integer )\n    Computes the cumulative minimum of double-precision floating-point strided\n    array elements using alternative indexing semantics.\n"
base.strided.dcuminabs,"\nbase.strided.dcuminabs( N:integer, x:Float64Array, strideX:integer, \n  y:Float64Array, strideY:integer )\n    Computes the cumulative minimum absolute value of double-precision floating-\n    point strided array elements.\n"
base.strided.dcuminabs.ndarray,"\nbase.strided.dcuminabs.ndarray( N:integer, x:Float64Array, strideX:integer, \n  offsetX:integer, y:Float64Array, strideY:integer, offsetY:integer )\n    Computes the cumulative minimum absolute value of double-precision floating-\n    point strided array elements using alternative indexing semantics.\n"
base.strided.dcusum,"\nbase.strided.dcusum( N:integer, sum:number, x:Float64Array, strideX:integer, \n  y:Float64Array, strideY:integer )\n    Computes the cumulative sum of double-precision floating-point strided array\n    elements.\n"
base.strided.dcusum.ndarray,"\nbase.strided.dcusum.ndarray( N:integer, sum:number, x:Float64Array, \n  strideX:integer, offsetX:integer, y:Float64Array, strideY:integer, \n  offsetY:integer )\n    Computes the cumulative sum of double-precision floating-point strided array\n    elements using alternative indexing semantics.\n"
base.strided.dcusumkbn,"\nbase.strided.dcusumkbn( N:integer, sum:number, x:Float64Array, strideX:integer, \n  y:Float64Array, strideY:integer )\n    Computes the cumulative sum of double-precision floating-point strided array\n    elements using an improved Kahan–Babuška algorithm.\n"
base.strided.dcusumkbn.ndarray,"\nbase.strided.dcusumkbn.ndarray( N:integer, sum:number, x:Float64Array, \n  strideX:integer, offsetX:integer, y:Float64Array, strideY:integer, \n  offsetY:integer )\n    Computes the cumulative sum of double-precision floating-point strided array\n    elements using an improved Kahan–Babuška algorithm and alternative indexing\n    semantics.\n"
base.strided.dcusumkbn2,"\nbase.strided.dcusumkbn2( N:integer, sum:number, x:Float64Array, \n  strideX:integer, y:Float64Array, strideY:integer )\n    Computes the cumulative sum of double-precision floating-point strided array\n    elements using a second-order iterative Kahan–Babuška algorithm.\n"
base.strided.dcusumkbn2.ndarray,"\nbase.strided.dcusumkbn2.ndarray( N:integer, sum:number, x:Float64Array, \n  strideX:integer, offsetX:integer, y:Float64Array, strideY:integer, \n  offsetY:integer )\n    Computes the cumulative sum of double-precision floating-point strided array\n    elements using a second-order iterative Kahan–Babuška algorithm and\n    alternative indexing semantics.\n"
base.strided.dcusumors,"\nbase.strided.dcusumors( N:integer, sum:number, x:Float64Array, strideX:integer, \n  y:Float64Array, strideY:integer )\n    Computes the cumulative sum of double-precision floating-point strided array\n    elements using ordinary recursive summation.\n"
base.strided.dcusumors.ndarray,"\nbase.strided.dcusumors.ndarray( N:integer, sum:number, x:Float64Array, \n  strideX:integer, offsetX:integer, y:Float64Array, strideY:integer, \n  offsetY:integer )\n    Computes the cumulative sum of double-precision floating-point strided array\n    elements using ordinary recursive summation and alternative indexing\n    semantics.\n"
base.strided.dcusumpw,"\nbase.strided.dcusumpw( N:integer, sum:number, x:Float64Array, strideX:integer, \n  y:Float64Array, strideY:integer )\n    Computes the cumulative sum of double-precision floating-point strided array\n    elements using pairwise summation.\n"
base.strided.dcusumpw.ndarray,"\nbase.strided.dcusumpw.ndarray( N:integer, sum:number, x:Float64Array, \n  strideX:integer, offsetX:integer, y:Float64Array, strideY:integer, \n  offsetY:integer )\n    Computes the cumulative sum of double-precision floating-point strided array\n    elements using pairwise summation and alternative indexing semantics.\n"
base.strided.ddot,"\nbase.strided.ddot( N:integer, x:Float64Array, strideX:integer, y:Float64Array, \n  strideY:integer )\n    Computes the dot product of two double-precision floating-point vectors.\n"
base.strided.ddot.ndarray,"\nbase.strided.ddot.ndarray( N:integer, x:Float64Array, strideX:integer, \n  offsetX:integer, y:Float64Array, strideY:integer, offsetY:integer )\n    Computes the dot product of two double-precision floating-point vectors\n    using alternative indexing semantics.\n"
base.strided.dfill,"\nbase.strided.dfill( N:integer, alpha:number, x:Float64Array, stride:integer )\n    Fills a double-precision floating-point strided array with a specified\n    scalar value.\n"
base.strided.dfill.ndarray,"\nbase.strided.dfill.ndarray( N:integer, alpha:number, x:Float64Array, \n  stride:integer, offset:integer )\n    Fills a double-precision floating-point strided array with a specified\n    scalar value using alternative indexing semantics.\n"
base.strided.dmap,"\nbase.strided.dmap( N:integer, x:Float64Array, strideX:integer, y:Float64Array, \n  strideY:integer, fcn:Function )\n    Applies a unary function accepting and returning double-precision floating-\n    point numbers to each element in a double-precision floating-point strided\n    input array and assigns each result to an element in a double-precision\n    floating-point strided output array.\n"
base.strided.dmap.ndarray,"\nbase.strided.dmap.ndarray( N:integer, x:Float64Array, strideX:integer, \n  offsetX:integer, y:Float64Array, strideY:integer, offsetY:integer, \n  fcn:Function )\n    Applies a unary function accepting and returning double-precision floating-\n    point numbers to each element in a double-precision floating-point strided\n    input array and assigns each result to an element in a double-precision\n    floating-point strided output array using alternative indexing semantics.\n"
base.strided.dmax,"\nbase.strided.dmax( N:integer, x:Float64Array, stride:integer )\n    Computes the maximum value of a double-precision floating-point strided\n    array.\n"
base.strided.dmax.ndarray,"\nbase.strided.dmax.ndarray( N:integer, x:Float64Array, stride:integer, \n  offset:integer )\n    Computes the maximum value of a double-precision floating-point strided\n    array using alternative indexing semantics.\n"
base.strided.dmaxabs,"\nbase.strided.dmaxabs( N:integer, x:Float64Array, stride:integer )\n    Computes the maximum absolute value of a double-precision floating-point\n    strided array.\n"
base.strided.dmaxabs.ndarray,"\nbase.strided.dmaxabs.ndarray( N:integer, x:Float64Array, stride:integer, \n  offset:integer )\n    Computes the maximum absolute value of a double-precision floating-point\n    strided array using alternative indexing semantics.\n"
base.strided.dmaxabssorted,"\nbase.strided.dmaxabssorted( N:integer, x:Float64Array, stride:integer )\n    Computes the maximum absolute value of a sorted double-precision floating-\n    point strided array.\n"
base.strided.dmaxabssorted.ndarray,"\nbase.strided.dmaxabssorted.ndarray( N:integer, x:Float64Array, stride:integer, \n  offset:integer )\n    Computes the maximum absolute value of a sorted double-precision floating-\n    point strided array using alternative indexing semantics.\n"
base.strided.dmaxsorted,"\nbase.strided.dmaxsorted( N:integer, x:Float64Array, stride:integer )\n    Computes the maximum value of a sorted double-precision floating-point\n    strided array.\n"
base.strided.dmaxsorted.ndarray,"\nbase.strided.dmaxsorted.ndarray( N:integer, x:Float64Array, stride:integer, \n  offset:integer )\n    Computes the maximum value of a sorted double-precision floating-point\n    strided array using alternative indexing semantics.\n"
base.strided.dmean,"\nbase.strided.dmean( N:integer, x:Float64Array, stride:integer )\n    Computes the arithmetic mean of a double-precision floating-point strided\n    array.\n"
base.strided.dmean.ndarray,"\nbase.strided.dmean.ndarray( N:integer, x:Float64Array, stride:integer, \n  offset:integer )\n    Computes the arithmetic mean of a double-precision floating-point strided\n    array using alternative indexing semantics.\n"
base.strided.dmeankbn,"\nbase.strided.dmeankbn( N:integer, x:Float64Array, stride:integer )\n    Computes the arithmetic mean of a double-precision floating-point strided\n    array using an improved Kahan–Babuška algorithm.\n"
base.strided.dmeankbn.ndarray,"\nbase.strided.dmeankbn.ndarray( N:integer, x:Float64Array, stride:integer, \n  offset:integer )\n    Computes the arithmetic mean of a double-precision floating-point strided\n    array using an improved Kahan–Babuška algorithm and alternative indexing\n    semantics.\n"
base.strided.dmeankbn2,"\nbase.strided.dmeankbn2( N:integer, x:Float64Array, stride:integer )\n    Computes the arithmetic mean of a double-precision floating-point strided\n    array using a second-order iterative Kahan–Babuška algorithm.\n"
base.strided.dmeankbn2.ndarray,"\nbase.strided.dmeankbn2.ndarray( N:integer, x:Float64Array, stride:integer, \n  offset:integer )\n    Computes the arithmetic mean of a double-precision floating-point strided\n    array using a second-order iterative Kahan–Babuška algorithm and alternative\n    indexing semantics.\n"
base.strided.dmeanli,"\nbase.strided.dmeanli( N:integer, x:Float64Array, stride:integer )\n    Computes the arithmetic mean of a double-precision floating-point strided\n    array using a one-pass trial mean algorithm.\n"
base.strided.dmeanli.ndarray,"\nbase.strided.dmeanli.ndarray( N:integer, x:Float64Array, stride:integer, \n  offset:integer )\n    Computes the arithmetic mean of a double-precision floating-point strided\n    array using a one-pass trial mean algorithm and alternative indexing\n    semantics.\n"
base.strided.dmeanlipw,"\nbase.strided.dmeanlipw( N:integer, x:Float64Array, stride:integer )\n    Computes the arithmetic mean of a double-precision floating-point strided\n    array using a one-pass trial mean algorithm with pairwise summation.\n"
base.strided.dmeanlipw.ndarray,"\nbase.strided.dmeanlipw.ndarray( N:integer, x:Float64Array, stride:integer, \n  offset:integer )\n    Computes the arithmetic mean of a double-precision floating-point strided\n    array using a one-pass trial mean algorithm with pairwise summation and\n    alternative indexing semantics.\n"
base.strided.dmeanors,"\nbase.strided.dmeanors( N:integer, x:Float64Array, stride:integer )\n    Computes the arithmetic mean of a double-precision floating-point strided\n    array using ordinary recursive summation.\n"
base.strided.dmeanors.ndarray,"\nbase.strided.dmeanors.ndarray( N:integer, x:Float64Array, stride:integer, \n  offset:integer )\n    Computes the arithmetic mean of a double-precision floating-point strided\n    array using ordinary recursive summation and alternative indexing semantics.\n"
base.strided.dmeanpn,"\nbase.strided.dmeanpn( N:integer, x:Float64Array, stride:integer )\n    Computes the arithmetic mean of a double-precision floating-point strided\n    array using a two-pass error correction algorithm.\n"
base.strided.dmeanpn.ndarray,"\nbase.strided.dmeanpn.ndarray( N:integer, x:Float64Array, stride:integer, \n  offset:integer )\n    Computes the arithmetic mean of a double-precision floating-point strided\n    array using a two-pass error correction algorithm and alternative indexing\n    semantics.\n"
base.strided.dmeanpw,"\nbase.strided.dmeanpw( N:integer, x:Float64Array, stride:integer )\n    Computes the arithmetic mean of a double-precision floating-point strided\n    array using pairwise summation.\n"
base.strided.dmeanpw.ndarray,"\nbase.strided.dmeanpw.ndarray( N:integer, x:Float64Array, stride:integer, \n  offset:integer )\n    Computes the arithmetic mean of a double-precision floating-point strided\n    array using pairwise summation and alternative indexing semantics.\n"
base.strided.dmeanstdev,"\nbase.strided.dmeanstdev( N:integer, c:number, x:Float64Array, strideX:integer, \n  out:Float64Array, strideOut:integer )\n    Computes the mean and standard deviation of a double-precision floating-\n    point strided array.\n"
base.strided.dmeanstdev.ndarray,"\nbase.strided.dmeanstdev.ndarray( N:integer, c:number, x:Float64Array, \n  strideX:integer, offsetX:integer, out:Float64Array, strideOut:integer, \n  offsetOut:integer )\n    Computes the mean and standard deviation of a double-precision floating-\n    point strided array using alternative indexing semantics.\n"
base.strided.dmeanstdevpn,"\nbase.strided.dmeanstdevpn( N:integer, c:number, x:Float64Array, \n  strideX:integer, out:Float64Array, strideOut:integer )\n    Computes the mean and standard deviation of a double-precision floating-\n    point strided array using a two-pass algorithm.\n"
base.strided.dmeanstdevpn.ndarray,"\nbase.strided.dmeanstdevpn.ndarray( N:integer, c:number, x:Float64Array, \n  strideX:integer, offsetX:integer, out:Float64Array, strideOut:integer, \n  offsetOut:integer )\n    Computes the mean and standard deviation of a double-precision floating-\n    point strided array using a two-pass algorithm and alternative indexing\n    semantics.\n"
base.strided.dmeanvar,"\nbase.strided.dmeanvar( N:integer, c:number, x:Float64Array, strideX:integer, \n  out:Float64Array, strideOut:integer )\n    Computes the mean and variance of a double-precision floating-point strided\n    array.\n"
base.strided.dmeanvar.ndarray,"\nbase.strided.dmeanvar.ndarray( N:integer, c:number, x:Float64Array, \n  strideX:integer, offsetX:integer, out:Float64Array, strideOut:integer, \n  offsetOut:integer )\n    Computes the mean and variance of a double-precision floating-point strided\n    array using alternative indexing semantics.\n"
base.strided.dmeanvarpn,"\nbase.strided.dmeanvarpn( N:integer, c:number, x:Float64Array, strideX:integer, \n  out:Float64Array, strideOut:integer )\n    Computes the mean and variance of a double-precision floating-point strided\n    array using a two-pass algorithm.\n"
base.strided.dmeanvarpn.ndarray,"\nbase.strided.dmeanvarpn.ndarray( N:integer, c:number, x:Float64Array, \n  strideX:integer, offsetX:integer, out:Float64Array, strideOut:integer, \n  offsetOut:integer )\n    Computes the mean and variance of a double-precision floating-point strided\n    array using a two-pass algorithm and alternative indexing semantics.\n"
base.strided.dmeanwd,"\nbase.strided.dmeanwd( N:integer, x:Float64Array, stride:integer )\n    Computes the arithmetic mean of a double-precision floating-point strided\n    array using Welford's algorithm.\n"
base.strided.dmeanwd.ndarray,"\nbase.strided.dmeanwd.ndarray( N:integer, x:Float64Array, stride:integer, \n  offset:integer )\n    Computes the arithmetic mean of a double-precision floating-point strided\n    array using Welford's algorithm and alternative indexing semantics.\n"
base.strided.dmediansorted,"\nbase.strided.dmediansorted( N:integer, x:Float64Array, stride:integer )\n    Computes the median value of a sorted double-precision floating-point\n    strided array.\n"
base.strided.dmediansorted.ndarray,"\nbase.strided.dmediansorted.ndarray( N:integer, x:Float64Array, stride:integer, \n  offset:integer )\n    Computes the median value of a sorted double-precision floating-point\n    strided array using alternative indexing semantics.\n"
base.strided.dmidrange,"\nbase.strided.dmidrange( N:integer, x:Float64Array, stride:integer )\n    Computes the mid-range of a double-precision floating-point strided array.\n"
base.strided.dmidrange.ndarray,"\nbase.strided.dmidrange.ndarray( N:integer, x:Float64Array, stride:integer, \n  offset:integer )\n    Computes the mid-range of a double-precision floating-point strided array\n    using alternative indexing semantics.\n"
base.strided.dmin,"\nbase.strided.dmin( N:integer, x:Float64Array, stride:integer )\n    Computes the minimum value of a double-precision floating-point strided\n    array.\n"
base.strided.dmin.ndarray,"\nbase.strided.dmin.ndarray( N:integer, x:Float64Array, stride:integer, \n  offset:integer )\n    Computes the minimum value of a double-precision floating-point strided\n    array using alternative indexing semantics.\n"
base.strided.dminabs,"\nbase.strided.dminabs( N:integer, x:Float64Array, stride:integer )\n    Computes the minimum absolute value of a double-precision floating-point\n    strided array.\n"
base.strided.dminabs.ndarray,"\nbase.strided.dminabs.ndarray( N:integer, x:Float64Array, stride:integer, \n  offset:integer )\n    Computes the minimum absolute value of a double-precision floating-point\n    strided array using alternative indexing semantics.\n"
base.strided.dminsorted,"\nbase.strided.dminsorted( N:integer, x:Float64Array, stride:integer )\n    Computes the minimum value of a sorted double-precision floating-point\n    strided array.\n"
base.strided.dminsorted.ndarray,"\nbase.strided.dminsorted.ndarray( N:integer, x:Float64Array, stride:integer, \n  offset:integer )\n    Computes the minimum value of a sorted double-precision floating-point\n    strided array using alternative indexing semantics.\n"
base.strided.dmskmap,"\nbase.strided.dmskmap( N:integer, x:Float64Array, sx:integer, m:Uint8Array, \n  sm:integer, y:Float64Array, sy:integer, fcn:Function )\n    Applies a unary function accepting and returning double-precision floating-\n    point numbers to each element in a double-precision floating-point strided\n    input array according to a corresponding element in a strided mask array and\n    assigns each result to an element in a double-precision floating-point\n    strided output array.\n"
base.strided.dmskmap.ndarray,"\nbase.strided.dmskmap.ndarray( N:integer, x:Float64Array, sx:integer, \n  ox:integer, m:Uint8Array, sm:integer, om:integer, y:Float64Array, sy:integer, \n  oy:integer, fcn:Function )\n    Applies a unary function accepting and returning double-precision floating-\n    point numbers to each element in a double-precision floating-point strided\n    input array according to a corresponding element in a strided mask array and\n    assigns each result to an element in a double-precision floating-point\n    strided output array using alternative indexing semantics.\n"
base.strided.dmskmax,"\nbase.strided.dmskmax( N:integer, x:Float64Array, strideX:integer, \n  mask:Uint8Array, strideMask:integer )\n    Computes the maximum value of a double-precision floating-point strided\n    array according to a mask.\n"
base.strided.dmskmax.ndarray,"\nbase.strided.dmskmax.ndarray( N:integer, x:Float64Array, strideX:integer, \n  offsetX:integer, mask:Uint8Array, strideMask:integer, offsetMask:integer )\n    Computes the maximum value of a double-precision floating-point strided\n    array according to a mask and using alternative indexing semantics.\n"
base.strided.dmskmin,"\nbase.strided.dmskmin( N:integer, x:Float64Array, strideX:integer, \n  mask:Uint8Array, strideMask:integer )\n    Computes the minimum value of a double-precision floating-point strided\n    array according to a mask.\n"
base.strided.dmskmin.ndarray,"\nbase.strided.dmskmin.ndarray( N:integer, x:Float64Array, strideX:integer, \n  offsetX:integer, mask:Uint8Array, strideMask:integer, offsetMask:integer )\n    Computes the minimum value of a double-precision floating-point strided\n    array according to a mask and using alternative indexing semantics.\n"
base.strided.dmskrange,"\nbase.strided.dmskrange( N:integer, x:Float64Array, strideX:integer, \n  mask:Uint8Array, strideMask:integer )\n    Computes the range of a double-precision floating-point strided array\n    according to a mask.\n"
base.strided.dmskrange.ndarray,"\nbase.strided.dmskrange.ndarray( N:integer, x:Float64Array, strideX:integer, \n  offsetX:integer, mask:Uint8Array, strideMask:integer, offsetMask:integer )\n    Computes the range of a double-precision floating-point strided array\n    according to a mask and using alternative indexing semantics.\n"
base.strided.dnanasum,"\nbase.strided.dnanasum( N:integer, x:Float64Array, stride:integer )\n    Computes the sum of absolute values (L1 norm) of double-precision floating-\n    point strided array elements, ignoring `NaN` values.\n"
base.strided.dnanasum.ndarray,"\nbase.strided.dnanasum.ndarray( N:integer, x:Float64Array, stride:integer, \n  offset:integer )\n    Computes the sum of absolute values (L1 norm) of double-precision floating-\n    point strided array elements, ignoring `NaN` values and using alternative\n    indexing semantics.\n"
base.strided.dnanasumors,"\nbase.strided.dnanasumors( N:integer, x:Float64Array, stride:integer )\n    Computes the sum of absolute values (L1 norm) of double-precision floating-\n    point strided array elements, ignoring `NaN` values and using ordinary\n    recursive summation.\n"
base.strided.dnanasumors.ndarray,"\nbase.strided.dnanasumors.ndarray( N:integer, x:Float64Array, stride:integer, \n  offset:integer )\n    Computes the sum of absolute values (L1 norm) of double-precision floating-\n    point strided array elements, ignoring `NaN` values and using ordinary\n    recursive summation alternative indexing semantics.\n"
base.strided.dnanmax,"\nbase.strided.dnanmax( N:integer, x:Float64Array, stride:integer )\n    Computes the maximum value of a double-precision floating-point strided\n    array, ignoring `NaN` values.\n"
base.strided.dnanmax.ndarray,"\nbase.strided.dnanmax.ndarray( N:integer, x:Float64Array, stride:integer, \n  offset:integer )\n    Computes the maximum value of a double-precision floating-point strided\n    array, ignoring `NaN` values and using alternative indexing semantics.\n"
base.strided.dnanmaxabs,"\nbase.strided.dnanmaxabs( N:integer, x:Float64Array, stride:integer )\n    Computes the maximum absolute value of a double-precision floating-point\n    strided array, ignoring `NaN` values.\n"
base.strided.dnanmaxabs.ndarray,"\nbase.strided.dnanmaxabs.ndarray( N:integer, x:Float64Array, stride:integer, \n  offset:integer )\n    Computes the maximum absolute value of a double-precision floating-point\n    strided array, ignoring `NaN` values and using alternative indexing\n    semantics.\n"
base.strided.dnanmean,"\nbase.strided.dnanmean( N:integer, x:Float64Array, stride:integer )\n    Computes the arithmetic mean of a double-precision floating-point strided\n    array, ignoring `NaN` values.\n"
base.strided.dnanmean.ndarray,"\nbase.strided.dnanmean.ndarray( N:integer, x:Float64Array, stride:integer, \n  offset:integer )\n    Computes the arithmetic mean of a double-precision floating-point strided\n    array, ignoring `NaN` values and using alternative indexing semantics.\n"
base.strided.dnanmeanors,"\nbase.strided.dnanmeanors( N:integer, x:Float64Array, stride:integer )\n    Computes the arithmetic mean of a double-precision floating-point strided\n    array, ignoring `NaN` values and using ordinary recursive summation.\n"
base.strided.dnanmeanors.ndarray,"\nbase.strided.dnanmeanors.ndarray( N:integer, x:Float64Array, stride:integer, \n  offset:integer )\n    Computes the arithmetic mean of a double-precision floating-point strided\n    array, ignoring `NaN` values and using ordinary recursive summation and\n    alternative indexing semantics.\n"
base.strided.dnanmeanpn,"\nbase.strided.dnanmeanpn( N:integer, x:Float64Array, stride:integer )\n    Computes the arithmetic mean of a double-precision floating-point strided\n    array, ignoring `NaN` values and using a two-pass error correction\n    algorithm.\n"
base.strided.dnanmeanpn.ndarray,"\nbase.strided.dnanmeanpn.ndarray( N:integer, x:Float64Array, stride:integer, \n  offset:integer )\n    Computes the arithmetic mean of a double-precision floating-point strided\n    array, ignoring `NaN` values and using a two-pass error correction algorithm\n    and alternative indexing semantics.\n"
base.strided.dnanmeanpw,"\nbase.strided.dnanmeanpw( N:integer, x:Float64Array, stride:integer )\n    Computes the arithmetic mean of a double-precision floating-point strided\n    array, ignoring `NaN` values and using pairwise summation.\n"
base.strided.dnanmeanpw.ndarray,"\nbase.strided.dnanmeanpw.ndarray( N:integer, x:Float64Array, stride:integer, \n  offset:integer )\n    Computes the arithmetic mean of a double-precision floating-point strided\n    array, ignoring `NaN` values and using pairwise summation and alternative\n    indexing semantics.\n"
base.strided.dnanmeanwd,"\nbase.strided.dnanmeanwd( N:integer, x:Float64Array, stride:integer )\n    Computes the arithmetic mean of a double-precision floating-point strided\n    array, using Welford's algorithm and ignoring `NaN` values.\n"
base.strided.dnanmeanwd.ndarray,"\nbase.strided.dnanmeanwd.ndarray( N:integer, x:Float64Array, stride:integer, \n  offset:integer )\n    Computes the arithmetic mean of a double-precision floating-point strided\n    array, ignoring `NaN` values and using Welford's algorithm and alternative\n    indexing semantics.\n"
base.strided.dnanmin,"\nbase.strided.dnanmin( N:integer, x:Float64Array, stride:integer )\n    Computes the minimum value of a double-precision floating-point strided\n    array, ignoring `NaN` values.\n"
base.strided.dnanmin.ndarray,"\nbase.strided.dnanmin.ndarray( N:integer, x:Float64Array, stride:integer, \n  offset:integer )\n    Computes the minimum value of a double-precision floating-point strided\n    array, ignoring `NaN` values and using alternative indexing semantics.\n"
base.strided.dnanminabs,"\nbase.strided.dnanminabs( N:integer, x:Float64Array, stride:integer )\n    Computes the minimum absolute value of a double-precision floating-point\n    strided array, ignoring `NaN` values.\n"
base.strided.dnanminabs.ndarray,"\nbase.strided.dnanminabs.ndarray( N:integer, x:Float64Array, stride:integer, \n  offset:integer )\n    Computes the minimum absolute value of a double-precision floating-point\n    strided array, ignoring `NaN` values and using alternative indexing\n    semantics.\n"
base.strided.dnanmskmax,"\nbase.strided.dnanmskmax( N:integer, x:Float64Array, strideX:integer, \n  mask:Uint8Array, strideMask:integer )\n    Computes the maximum value of a double-precision floating-point strided\n    array according to a mask, ignoring `NaN` values.\n"
base.strided.dnanmskmax.ndarray,"\nbase.strided.dnanmskmax.ndarray( N:integer, x:Float64Array, strideX:integer, \n  offsetX:integer, mask:Uint8Array, strideMask:integer, offsetMask:integer )\n    Computes the maximum value of a double-precision floating-point strided\n    array according to a mask, ignoring `NaN` values and using alternative\n    indexing semantics.\n"
base.strided.dnanmskmin,"\nbase.strided.dnanmskmin( N:integer, x:Float64Array, strideX:integer, \n  mask:Uint8Array, strideMask:integer )\n    Computes the minimum value of a double-precision floating-point strided\n    array according to a mask, ignoring `NaN` values.\n"
base.strided.dnanmskmin.ndarray,"\nbase.strided.dnanmskmin.ndarray( N:integer, x:Float64Array, strideX:integer, \n  offsetX:integer, mask:Uint8Array, strideMask:integer, offsetMask:integer )\n    Computes the minimum value of a double-precision floating-point strided\n    array according to a mask, ignoring `NaN` values and using alternative\n    indexing semantics.\n"
base.strided.dnanmskrange,"\nbase.strided.dnanmskrange( N:integer, x:Float64Array, strideX:integer, \n  mask:Uint8Array, strideMask:integer )\n    Computes the range of a double-precision floating-point strided array\n    according to a mask, ignoring `NaN` values.\n"
base.strided.dnanmskrange.ndarray,"\nbase.strided.dnanmskrange.ndarray( N:integer, x:Float64Array, strideX:integer, \n  offsetX:integer, mask:Uint8Array, strideMask:integer, offsetMask:integer )\n    Computes the range of a double-precision floating-point strided array\n    according to a mask, ignoring `NaN` values and using alternative indexing\n    semantics.\n"
base.strided.dnannsum,"\nbase.strided.dnannsum( N:integer, x:Float64Array, strideX:integer, \n  out:Float64Array, strideOut:integer )\n    Computes the sum of double-precision floating-point strided array elements,\n    ignoring `NaN` values.\n"
base.strided.dnannsum.ndarray,"\nbase.strided.dnannsum.ndarray( N:integer, x:Float64Array, strideX:integer, \n  offsetX:integer, out:Float64Array, strideOut:integer, offsetOut:integer )\n    Computes the sum of double-precision floating-point strided array elements,\n    ignoring `NaN` values and using alternative indexing semantics.\n"
base.strided.dnannsumkbn,"\nbase.strided.dnannsumkbn( N:integer, x:Float64Array, strideX:integer, \n  out:Float64Array, strideOut:integer )\n    Computes the sum of double-precision floating-point strided array elements,\n    ignoring `NaN` values and using an improved Kahan–Babuška algorithm.\n"
base.strided.dnannsumkbn.ndarray,"\nbase.strided.dnannsumkbn.ndarray( N:integer, x:Float64Array, strideX:integer, \n  offsetX:integer, out:Float64Array, strideOut:integer, offsetOut:integer )\n    Computes the sum of double-precision floating-point strided array elements,\n    ignoring `NaN` values and using an improved Kahan–Babuška algorithm and\n    alternative indexing semantics.\n"
base.strided.dnannsumkbn2,"\nbase.strided.dnannsumkbn2( N:integer, x:Float64Array, strideX:integer, \n  out:Float64Array, strideOut:integer )\n    Computes the sum of double-precision floating-point strided array elements,\n    ignoring `NaN` values and using a second-order iterative Kahan–Babuška\n    algorithm.\n"
base.strided.dnannsumkbn2.ndarray,"\nbase.strided.dnannsumkbn2.ndarray( N:integer, x:Float64Array, strideX:integer, \n  offsetX:integer, out:Float64Array, strideOut:integer, offsetOut:integer )\n    Computes the sum of double-precision floating-point strided array elements,\n    ignoring `NaN` values and using a second-order iterative Kahan–Babuška\n    algorithm and alternative indexing semantics.\n"
base.strided.dnannsumors,"\nbase.strided.dnannsumors( N:integer, x:Float64Array, strideX:integer, \n  out:Float64Array, strideOut:integer )\n    Computes the sum of double-precision floating-point strided array elements,\n    ignoring `NaN` values and using ordinary recursive summation.\n"
base.strided.dnannsumors.ndarray,"\nbase.strided.dnannsumors.ndarray( N:integer, x:Float64Array, strideX:integer, \n  offsetX:integer, out:Float64Array, strideOut:integer, offsetOut:integer )\n    Computes the sum of double-precision floating-point strided array elements,\n    ignoring `NaN` values and using ordinary recursive summation and alternative\n    indexing semantics.\n"
base.strided.dnannsumpw,"\nbase.strided.dnannsumpw( N:integer, x:Float64Array, strideX:integer, \n  out:Float64Array, strideOut:integer )\n    Computes the sum of double-precision floating-point strided array elements,\n    ignoring `NaN` values and using pairwise summation.\n"
base.strided.dnannsumpw.ndarray,"\nbase.strided.dnannsumpw.ndarray( N:integer, x:Float64Array, strideX:integer, \n  offsetX:integer, out:Float64Array, strideOut:integer, offsetOut:integer )\n    Computes the sum of double-precision floating-point strided array elements,\n    ignoring `NaN` values and using pairwise summation and alternative indexing\n    semantics.\n"
base.strided.dnanrange,"\nbase.strided.dnanrange( N:integer, x:Float64Array, stride:integer )\n    Computes the range of a double-precision floating-point strided array,\n    ignoring `NaN` values.\n"
base.strided.dnanrange.ndarray,"\nbase.strided.dnanrange.ndarray( N:integer, x:Float64Array, stride:integer, \n  offset:integer )\n    Computes the range of a double-precision floating-point strided array,\n    ignoring `NaN` values and using alternative indexing semantics.\n"
base.strided.dnanstdev,"\nbase.strided.dnanstdev( N:integer, correction:number, x:Float64Array, \n  stride:integer )\n    Computes the standard deviation of a double-precision floating-point strided\n    array ignoring `NaN` values.\n"
base.strided.dnanstdev.ndarray,"\nbase.strided.dnanstdev.ndarray( N:integer, correction:number, x:Float64Array, \n  stride:integer, offset:integer )\n    Computes the standard deviation of a double-precision floating-point strided\n    array ignoring `NaN` values and using alternative indexing semantics.\n"
base.strided.dnanstdevch,"\nbase.strided.dnanstdevch( N:integer, correction:number, x:Float64Array, \n  stride:integer )\n    Computes the standard deviation of a double-precision floating-point strided\n    array ignoring `NaN` values and using a one-pass trial mean algorithm.\n"
base.strided.dnanstdevch.ndarray,"\nbase.strided.dnanstdevch.ndarray( N:integer, correction:number, x:Float64Array, \n  stride:integer, offset:integer )\n    Computes the standard deviation of a double-precision floating-point strided\n    array ignoring `NaN` values and using a one-pass trial mean algorithm and\n    alternative indexing semantics.\n"
base.strided.dnanstdevpn,"\nbase.strided.dnanstdevpn( N:integer, correction:number, x:Float64Array, \n  stride:integer )\n    Computes the standard deviation of a double-precision floating-point strided\n    array ignoring `NaN` values and using a two-pass algorithm.\n"
base.strided.dnanstdevpn.ndarray,"\nbase.strided.dnanstdevpn.ndarray( N:integer, correction:number, x:Float64Array, \n  stride:integer, offset:integer )\n    Computes the standard deviation of a double-precision floating-point strided\n    array ignoring `NaN` values and using a two-pass algorithm and alternative\n    indexing semantics.\n"
base.strided.dnanstdevtk,"\nbase.strided.dnanstdevtk( N:integer, correction:number, x:Float64Array, \n  stride:integer )\n    Computes the standard deviation of a double-precision floating-point strided\n    array ignoring `NaN` values and using a one-pass textbook algorithm.\n"
base.strided.dnanstdevtk.ndarray,"\nbase.strided.dnanstdevtk.ndarray( N:integer, correction:number, x:Float64Array, \n  stride:integer, offset:integer )\n    Computes the standard deviation of a double-precision floating-point strided\n    array ignoring `NaN` values and using a one-pass textbook algorithm and\n    alternative indexing semantics.\n"
base.strided.dnanstdevwd,"\nbase.strided.dnanstdevwd( N:integer, correction:number, x:Float64Array, \n  stride:integer )\n    Computes the standard deviation of a double-precision floating-point strided\n    array ignoring `NaN` values and using Welford's algorithm.\n"
base.strided.dnanstdevwd.ndarray,"\nbase.strided.dnanstdevwd.ndarray( N:integer, correction:number, x:Float64Array, \n  stride:integer, offset:integer )\n    Computes the standard deviation of a double-precision floating-point strided\n    array ignoring `NaN` values and using Welford's algorithm and alternative\n    indexing semantics.\n"
base.strided.dnanstdevyc,"\nbase.strided.dnanstdevyc( N:integer, correction:number, x:Float64Array, \n  stride:integer )\n    Computes the standard deviation of a double-precision floating-point strided\n    array ignoring `NaN` values and using a one-pass algorithm proposed by\n    Youngs and Cramer.\n"
base.strided.dnanstdevyc.ndarray,"\nbase.strided.dnanstdevyc.ndarray( N:integer, correction:number, x:Float64Array, \n  stride:integer, offset:integer )\n    Computes the standard deviation of a double-precision floating-point strided\n    array ignoring `NaN` values and using a one-pass algorithm proposed by\n    Youngs and Cramer and alternative indexing semantics.\n"
base.strided.dnansum,"\nbase.strided.dnansum( N:integer, x:Float64Array, stride:integer )\n    Computes the sum of double-precision floating-point strided array elements,\n    ignoring `NaN` values.\n"
base.strided.dnansum.ndarray,"\nbase.strided.dnansum.ndarray( N:integer, x:Float64Array, stride:integer, \n  offset:integer )\n    Computes the sum of double-precision floating-point strided array elements,\n    ignoring `NaN` values and using alternative indexing semantics.\n"
base.strided.dnansumkbn,"\nbase.strided.dnansumkbn( N:integer, x:Float64Array, stride:integer )\n    Computes the sum of double-precision floating-point strided array elements,\n    ignoring `NaN` values and using an improved Kahan–Babuška algorithm.\n"
base.strided.dnansumkbn.ndarray,"\nbase.strided.dnansumkbn.ndarray( N:integer, x:Float64Array, stride:integer, \n  offset:integer )\n    Computes the sum of double-precision floating-point strided array elements,\n    ignoring `NaN` values and using an improved Kahan–Babuška algorithm and\n    alternative indexing semantics.\n"
base.strided.dnansumkbn2,"\nbase.strided.dnansumkbn2( N:integer, x:Float64Array, stride:integer )\n    Computes the sum of double-precision floating-point strided array elements,\n    ignoring `NaN` values and using a second-order iterative Kahan–Babuška\n    algorithm.\n"
base.strided.dnansumkbn2.ndarray,"\nbase.strided.dnansumkbn2.ndarray( N:integer, x:Float64Array, stride:integer, \n  offset:integer )\n    Computes the sum of double-precision floating-point strided array elements,\n    ignoring `NaN` values and using a second-order iterative Kahan–Babuška\n    algorithm and alternative indexing semantics.\n"
base.strided.dnansumors,"\nbase.strided.dnansumors( N:integer, x:Float64Array, stride:integer )\n    Computes the sum of double-precision floating-point strided array elements,\n    ignoring `NaN` values and using ordinary recursive summation.\n"
base.strided.dnansumors.ndarray,"\nbase.strided.dnansumors.ndarray( N:integer, x:Float64Array, stride:integer, \n  offset:integer )\n    Computes the sum of double-precision floating-point strided array elements,\n    ignoring `NaN` values and using ordinary recursive summation and alternative\n    indexing semantics.\n"
base.strided.dnansumpw,"\nbase.strided.dnansumpw( N:integer, x:Float64Array, stride:integer )\n    Computes the sum of double-precision floating-point strided array elements,\n    ignoring `NaN` values and using pairwise summation.\n"
base.strided.dnansumpw.ndarray,"\nbase.strided.dnansumpw.ndarray( N:integer, x:Float64Array, stride:integer, \n  offset:integer )\n    Computes the sum of double-precision floating-point strided array elements,\n    ignoring `NaN` values and using pairwise summation and alternative indexing\n    semantics.\n"
base.strided.dnanvariance,"\nbase.strided.dnanvariance( N:integer, correction:number, x:Float64Array, \n  stride:integer )\n    Computes the variance of a double-precision floating-point strided array\n    ignoring `NaN` values.\n"
base.strided.dnanvariance.ndarray,"\nbase.strided.dnanvariance.ndarray( N:integer, correction:number, \n  x:Float64Array, stride:integer, offset:integer )\n    Computes the variance of a double-precision floating-point strided array\n    ignoring `NaN` values and using alternative indexing semantics.\n"
base.strided.dnanvariancech,"\nbase.strided.dnanvariancech( N:integer, correction:number, x:Float64Array, \n  stride:integer )\n    Computes the variance of a double-precision floating-point strided array\n    ignoring `NaN` values and using a one-pass trial mean algorithm.\n"
base.strided.dnanvariancech.ndarray,"\nbase.strided.dnanvariancech.ndarray( N:integer, correction:number, \n  x:Float64Array, stride:integer, offset:integer )\n    Computes the variance of a double-precision floating-point strided array\n    ignoring `NaN` values and using a one-pass trial mean algorithm and\n    alternative indexing semantics.\n"
base.strided.dnanvariancepn,"\nbase.strided.dnanvariancepn( N:integer, correction:number, x:Float64Array, \n  stride:integer )\n    Computes the variance of a double-precision floating-point strided array\n    ignoring `NaN` values and using a two-pass algorithm.\n"
base.strided.dnanvariancepn.ndarray,"\nbase.strided.dnanvariancepn.ndarray( N:integer, correction:number, \n  x:Float64Array, stride:integer, offset:integer )\n    Computes the variance of a double-precision floating-point strided array\n    ignoring `NaN` values and using a two-pass algorithm and alternative\n    indexing semantics.\n"
base.strided.dnanvariancetk,"\nbase.strided.dnanvariancetk( N:integer, correction:number, x:Float64Array, \n  stride:integer )\n    Computes the variance of a double-precision floating-point strided array\n    ignoring `NaN` values and using a one-pass textbook algorithm.\n"
base.strided.dnanvariancetk.ndarray,"\nbase.strided.dnanvariancetk.ndarray( N:integer, correction:number, \n  x:Float64Array, stride:integer, offset:integer )\n    Computes the variance of a double-precision floating-point strided array\n    ignoring `NaN` values and using a one-pass textbook algorithm and\n    alternative indexing semantics.\n"
base.strided.dnanvariancewd,"\nbase.strided.dnanvariancewd( N:integer, correction:number, x:Float64Array, \n  stride:integer )\n    Computes the variance of a double-precision floating-point strided array\n    ignoring `NaN` values and using Welford's algorithm.\n"
base.strided.dnanvariancewd.ndarray,"\nbase.strided.dnanvariancewd.ndarray( N:integer, correction:number, \n  x:Float64Array, stride:integer, offset:integer )\n    Computes the variance of a double-precision floating-point strided array\n    ignoring `NaN` values and using Welford's algorithm and alternative indexing\n    semantics.\n"
base.strided.dnanvarianceyc,"\nbase.strided.dnanvarianceyc( N:integer, correction:number, x:Float64Array, \n  stride:integer )\n    Computes the variance of a double-precision floating-point strided array\n    ignoring `NaN` values and using a one-pass algorithm proposed by Youngs and\n    Cramer.\n"
base.strided.dnanvarianceyc.ndarray,"\nbase.strided.dnanvarianceyc.ndarray( N:integer, correction:number, \n  x:Float64Array, stride:integer, offset:integer )\n    Computes the variance of a double-precision floating-point strided array\n    ignoring `NaN` values and using a one-pass algorithm proposed by Youngs and\n    Cramer and alternative indexing semantics.\n"
base.strided.dnrm2,"\nbase.strided.dnrm2( N:integer, x:Float64Array, stride:integer )\n    Computes the L2-norm of a double-precision floating-point vector.\n"
base.strided.dnrm2.ndarray,"\nbase.strided.dnrm2.ndarray( N:integer, x:Float64Array, stride:integer, \n  offset:integer )\n    Computes the L2-norm of a double-precision floating-point vector using\n    alternative indexing semantics.\n"
base.strided.drange,"\nbase.strided.drange( N:integer, x:Float64Array, stride:integer )\n    Computes the range of a double-precision floating-point strided array.\n"
base.strided.drange.ndarray,"\nbase.strided.drange.ndarray( N:integer, x:Float64Array, stride:integer, \n  offset:integer )\n    Computes the range of a double-precision floating-point strided array using\n    alternative indexing semantics.\n"
base.strided.drev,"\nbase.strided.drev( N:integer, x:Float64Array, stride:integer )\n    Reverses a double-precision floating-point strided array in-place.\n"
base.strided.drev.ndarray,"\nbase.strided.drev.ndarray( N:integer, x:Float64Array, stride:integer, \n  offset:integer )\n    Reverses a double-precision floating-point strided array in-place using\n    alternative indexing semantics.\n"
base.strided.dsapxsum,"\nbase.strided.dsapxsum( N:integer, alpha:number, x:Float32Array, stride:integer )\n    Adds a constant to each single-precision floating-point strided array\n    element and computes the sum using extended accumulation and returning an\n    extended precision result.\n"
base.strided.dsapxsum.ndarray,"\nbase.strided.dsapxsum.ndarray( N:integer, alpha:number, x:Float32Array, \n  stride:integer, offset:integer )\n    Adds a constant to each single-precision floating-point strided array\n    element and computes the sum using extended accumulation and alternative\n    indexing semantics and returning an extended precision result.\n"
base.strided.dsapxsumpw,"\nbase.strided.dsapxsumpw( N:integer, alpha:number, x:Float32Array, \n  stride:integer )\n    Adds a constant to each single-precision floating-point strided array\n    element and computes the sum using pairwise summation with extended\n    accumulation and returning an extended precision result.\n"
base.strided.dsapxsumpw.ndarray,"\nbase.strided.dsapxsumpw.ndarray( N:integer, alpha:number, x:Float32Array, \n  stride:integer, offset:integer )\n    Adds a constant to each single-precision floating-point strided array\n    element and computes the sum using pairwise summation with extended\n    accumulation and alternative indexing semantics and returning an extended\n    precision result.\n"
base.strided.dscal,"\nbase.strided.dscal( N:integer, alpha:number, x:Float64Array, stride:integer )\n    Multiplies a double-precision floating-point vector `x` by a constant\n    `alpha`.\n"
base.strided.dscal.ndarray,"\nbase.strided.dscal.ndarray( N:integer, alpha:number, x:Float64Array, \n  stride:integer, offset:integer )\n    Multiplies a double-precision floating-point vector `x` by a constant\n    `alpha` using alternative indexing semantics.\n"
base.strided.dsdot,"\nbase.strided.dsdot( N:integer, x:Float32Array, strideX:integer, y:Float32Array, \n  strideY:integer )\n    Computes the dot product of two single-precision floating-point vectors with\n    extended accumulation and result.\n"
base.strided.dsdot.ndarray,"\nbase.strided.dsdot.ndarray( N:integer, x:Float32Array, strideX:integer, \n  offsetX:integer, y:Float32Array, strideY:integer, offsetY:integer )\n    Computes the dot product of two single-precision floating-point vectors\n    using alternative indexing semantics and with extended accumulation and\n    result.\n"
base.strided.dsem,"\nbase.strided.dsem( N:integer, correction:number, x:Float64Array, \n  stride:integer )\n    Computes the standard error of the mean for a double-precision floating-\n    point strided array.\n"
base.strided.dsem.ndarray,"\nbase.strided.dsem.ndarray( N:integer, correction:number, x:Float64Array, \n  stride:integer, offset:integer )\n    Computes the standard error of the mean for a double-precision floating-\n    point strided array using alternative indexing semantics.\n"
base.strided.dsemch,"\nbase.strided.dsemch( N:integer, correction:number, x:Float64Array, \n  stride:integer )\n    Computes the standard error of the mean for a double-precision floating-\n    point strided array using a one-pass trial mean algorithm.\n"
base.strided.dsemch.ndarray,"\nbase.strided.dsemch.ndarray( N:integer, correction:number, x:Float64Array, \n  stride:integer, offset:integer )\n    Computes the standard error of the mean for a double-precision floating-\n    point strided array using a one-pass trial mean algorithm and alternative\n    indexing semantics.\n"
base.strided.dsempn,"\nbase.strided.dsempn( N:integer, correction:number, x:Float64Array, \n  stride:integer )\n    Computes the standard error of the mean for a double-precision floating-\n    point strided array using a two-pass algorithm.\n"
base.strided.dsempn.ndarray,"\nbase.strided.dsempn.ndarray( N:integer, correction:number, x:Float64Array, \n  stride:integer, offset:integer )\n    Computes the standard error of the mean for a double-precision floating-\n    point strided array using a two-pass algorithm and alternative indexing\n    semantics.\n"
base.strided.dsemtk,"\nbase.strided.dsemtk( N:integer, correction:number, x:Float64Array, \n  stride:integer )\n    Computes the standard error of the mean for a double-precision floating-\n    point strided array using a one-pass textbook algorithm.\n"
base.strided.dsemtk.ndarray,"\nbase.strided.dsemtk.ndarray( N:integer, correction:number, x:Float64Array, \n  stride:integer, offset:integer )\n    Computes the standard error of the mean for a double-precision floating-\n    point strided array using a one-pass textbook algorithm and alternative\n    indexing semantics.\n"
base.strided.dsemwd,"\nbase.strided.dsemwd( N:integer, correction:number, x:Float64Array, \n  stride:integer )\n    Computes the standard error of the mean for a double-precision floating-\n    point strided array using Welford's algorithm.\n"
base.strided.dsemwd.ndarray,"\nbase.strided.dsemwd.ndarray( N:integer, correction:number, x:Float64Array, \n  stride:integer, offset:integer )\n    Computes the standard error of the mean for a double-precision floating-\n    point strided array using Welford's algorithm and alternative indexing\n    semantics.\n"
base.strided.dsemyc,"\nbase.strided.dsemyc( N:integer, correction:number, x:Float64Array, \n  stride:integer )\n    Computes the standard error of the mean for a double-precision floating-\n    point strided array using a one-pass algorithm proposed by Youngs and\n    Cramer.\n"
base.strided.dsemyc.ndarray,"\nbase.strided.dsemyc.ndarray( N:integer, correction:number, x:Float64Array, \n  stride:integer, offset:integer )\n    Computes the standard error of the mean for a double-precision floating-\n    point strided array using a one-pass algorithm proposed by Youngs and Cramer\n    and alternative indexing semantics.\n"
base.strided.dsmean,"\nbase.strided.dsmean( N:integer, x:Float32Array, stride:integer )\n    Computes the arithmetic mean of a single-precision floating-point strided\n    array using extended accumulation and returning an extended precision\n    result.\n"
base.strided.dsmean.ndarray,"\nbase.strided.dsmean.ndarray( N:integer, x:Float32Array, stride:integer, \n  offset:integer )\n    Computes the arithmetic mean of a single-precision floating-point strided\n    array using extended accumulation and alternative indexing semantics and\n    returning an extended precision result.\n"
base.strided.dsmeanors,"\nbase.strided.dsmeanors( N:integer, x:Float32Array, stride:integer )\n    Computes the arithmetic mean of a single-precision floating-point strided\n    array using ordinary recursive summation with extended accumulation and\n    returning an extended precision result.\n"
base.strided.dsmeanors.ndarray,"\nbase.strided.dsmeanors.ndarray( N:integer, x:Float32Array, stride:integer, \n  offset:integer )\n    Computes the arithmetic mean of a single-precision floating-point strided\n    array using ordinary recursive summation with extended accumulation and\n    alternative indexing semantics and returning an extended precision result.\n"
base.strided.dsmeanpn,"\nbase.strided.dsmeanpn( N:integer, x:Float32Array, stride:integer )\n    Computes the arithmetic mean of a single-precision floating-point strided\n    array using a two-pass error correction algorithm with extended accumulation\n    and returning an extended precision result.\n"
base.strided.dsmeanpn.ndarray,"\nbase.strided.dsmeanpn.ndarray( N:integer, x:Float32Array, stride:integer, \n  offset:integer )\n    Computes the arithmetic mean of a single-precision floating-point strided\n    array using a two-pass error correction algorithm with extended accumulation\n    and alternative indexing semantics and returning an extended precision\n    result.\n"
base.strided.dsmeanpw,"\nbase.strided.dsmeanpw( N:integer, x:Float32Array, stride:integer )\n    Computes the arithmetic mean of a single-precision floating-point strided\n    array using pairwise summation with extended accumulation and returning an\n    extended precision result.\n"
base.strided.dsmeanpw.ndarray,"\nbase.strided.dsmeanpw.ndarray( N:integer, x:Float32Array, stride:integer, \n  offset:integer )\n    Computes the arithmetic mean of a single-precision floating-point strided\n    array using pairwise summation with extended accumulation and alternative\n    indexing semantics and returning an extended precision result.\n"
base.strided.dsmeanwd,"\nbase.strided.dsmeanwd( N:integer, x:Float32Array, stride:integer )\n    Computes the arithmetic mean of a single-precision floating-point strided\n    array using Welford's algorithm with extended accumulation and returning an\n    extended precision result.\n"
base.strided.dsmeanwd.ndarray,"\nbase.strided.dsmeanwd.ndarray( N:integer, x:Float32Array, stride:integer, \n  offset:integer )\n    Computes the arithmetic mean of a single-precision floating-point strided\n    array using Welford's algorithm with extended accumulation and alternative\n    indexing semantics and returning an extended precision result.\n"
base.strided.dsnanmean,"\nbase.strided.dsnanmean( N:integer, x:Float32Array, stride:integer )\n    Computes the arithmetic mean of a single-precision floating-point strided\n    array, ignoring `NaN` values, using extended accumulation, and returning an\n    extended precision result.\n"
base.strided.dsnanmean.ndarray,"\nbase.strided.dsnanmean.ndarray( N:integer, x:Float32Array, stride:integer, \n  offset:integer )\n    Computes the arithmetic mean of a single-precision floating-point strided\n    array, ignoring `NaN` values and using extended accumulation and alternative\n    indexing semantics.\n"
base.strided.dsnanmeanors,"\nbase.strided.dsnanmeanors( N:integer, x:Float32Array, stride:integer )\n    Computes the arithmetic mean of a single-precision floating-point strided\n    array, ignoring `NaN` values, using ordinary recursive summation with\n    extended accumulation, and returning an extended precision result.\n"
base.strided.dsnanmeanors.ndarray,"\nbase.strided.dsnanmeanors.ndarray( N:integer, x:Float32Array, stride:integer, \n  offset:integer )\n    Computes the arithmetic mean of a single-precision floating-point strided\n    array, ignoring `NaN` values and using ordinary recursive summation with\n    extended accumulation and alternative indexing semantics.\n"
base.strided.dsnanmeanpn,"\nbase.strided.dsnanmeanpn( N:integer, x:Float32Array, stride:integer )\n    Computes the arithmetic mean of a single-precision floating-point strided\n    array, ignoring `NaN` values, using a two-pass error correction algorithm\n    with extended accumulation, and returning an extended precision result.\n"
base.strided.dsnanmeanpn.ndarray,"\nbase.strided.dsnanmeanpn.ndarray( N:integer, x:Float32Array, stride:integer, \n  offset:integer )\n    Computes the arithmetic mean of a single-precision floating-point strided\n    array, ignoring `NaN` values and using a two-pass error correction algorithm\n    with extended accumulation and alternative indexing semantics.\n"
base.strided.dsnanmeanwd,"\nbase.strided.dsnanmeanwd( N:integer, x:Float32Array, stride:integer )\n    Computes the arithmetic mean of a single-precision floating-point strided\n    array, ignoring `NaN` values, using Welford's algorithm with extended\n    accumulation, and returning an extended precision result.\n"
base.strided.dsnanmeanwd.ndarray,"\nbase.strided.dsnanmeanwd.ndarray( N:integer, x:Float32Array, stride:integer, \n  offset:integer )\n    Computes the arithmetic mean of a single-precision floating-point strided\n    array, ignoring `NaN` values and using Welford's algorithm with extended\n    accumulation and alternative indexing semantics.\n"
base.strided.dsnannsumors,"\nbase.strided.dsnannsumors( N:integer, x:Float32Array, strideX:integer, \n  out:Float64Array, strideOut:integer )\n    Computes the sum of single-precision floating-point strided array elements,\n    ignoring `NaN` values, using ordinary recursive summation with extended\n    accumulation, and returning an extended precision result.\n"
base.strided.dsnannsumors.ndarray,"\nbase.strided.dsnannsumors.ndarray( N:integer, x:Float32Array, strideX:integer, \n  offsetX:integer, out:Float64Array, strideOut:integer, offsetOut:integer )\n    Computes the sum of single-precision floating-point strided array elements,\n    ignoring `NaN` values and using ordinary recursive summation with extended\n    accumulation and alternative indexing semantics.\n"
base.strided.dsnansum,"\nbase.strided.dsnansum( N:integer, x:Float32Array, stride:integer )\n    Computes the sum of single-precision floating-point strided array elements,\n    ignoring `NaN` values, using extended accumulation, and returning an\n    extended precision result.\n"
base.strided.dsnansum.ndarray,"\nbase.strided.dsnansum.ndarray( N:integer, x:Float32Array, stride:integer, \n  offset:integer )\n    Computes the sum of single-precision floating-point strided array elements,\n    ignoring `NaN` values and using extended accumulation and alternative\n    indexing semantics.\n"
base.strided.dsnansumors,"\nbase.strided.dsnansumors( N:integer, x:Float32Array, stride:integer )\n    Computes the sum of single-precision floating-point strided array elements,\n    ignoring `NaN` values, using ordinary recursive summation with extended\n    accumulation, and returning an extended precision result.\n"
base.strided.dsnansumors.ndarray,"\nbase.strided.dsnansumors.ndarray( N:integer, x:Float32Array, stride:integer, \n  offset:integer )\n    Computes the sum of single-precision floating-point strided array elements,\n    ignoring `NaN` values and using ordinary recursive summation with extended\n    accumulation and alternative indexing semantics.\n"
base.strided.dsnansumpw,"\nbase.strided.dsnansumpw( N:integer, x:Float32Array, stride:integer )\n    Computes the sum of single-precision floating-point strided array elements,\n    ignoring `NaN` values, using pairwise summation with extended accumulation,\n    and returning an extended precision result.\n"
base.strided.dsnansumpw.ndarray,"\nbase.strided.dsnansumpw.ndarray( N:integer, x:Float32Array, stride:integer, \n  offset:integer )\n    Computes the sum of single-precision floating-point strided array elements,\n    ignoring `NaN` values and using pairwise summation with extended\n    accumulation and alternative indexing semantics.\n"
base.strided.dsort2hp,"\nbase.strided.dsort2hp( N:integer, order:number, x:Float64Array, \n  strideX:integer, y:Float64Array, strideY:integer )\n    Simultaneously sorts two double-precision floating-point strided arrays\n    based on the sort order of the first array using heapsort.\n"
base.strided.dsort2hp.ndarray,"\nbase.strided.dsort2hp.ndarray( N:integer, order:number, x:Float64Array, \n  strideX:integer, offsetX:integer, y:Float64Array, strideY:integer, \n  offsetY:integer )\n    Simultaneously sorts two double-precision floating-point strided arrays\n    based on the sort order of the first array using heapsort and alternative\n    indexing semantics.\n"
base.strided.dsort2ins,"\nbase.strided.dsort2ins( N:integer, order:number, x:Float64Array, \n  strideX:integer, y:Float64Array, strideY:integer )\n    Simultaneously sorts two double-precision floating-point strided arrays\n    based on the sort order of the first array using insertion sort.\n"
base.strided.dsort2ins.ndarray,"\nbase.strided.dsort2ins.ndarray( N:integer, order:number, x:Float64Array, \n  strideX:integer, offsetX:integer, y:Float64Array, strideY:integer, \n  offsetY:integer )\n    Simultaneously sorts two double-precision floating-point strided arrays\n    based on the sort order of the first array using insertion sort and\n    alternative indexing semantics.\n"
base.strided.dsort2sh,"\nbase.strided.dsort2sh( N:integer, order:number, x:Float64Array, \n  strideX:integer, y:Float64Array, strideY:integer )\n    Simultaneously sorts two double-precision floating-point strided arrays\n    based on the sort order of the first array using Shellsort.\n"
base.strided.dsort2sh.ndarray,"\nbase.strided.dsort2sh.ndarray( N:integer, order:number, x:Float64Array, \n  strideX:integer, offsetX:integer, y:Float64Array, strideY:integer, \n  offsetY:integer )\n    Simultaneously sorts two double-precision floating-point strided arrays\n    based on the sort order of the first array using Shellsort and alternative\n    indexing semantics.\n"
base.strided.dsorthp,"\nbase.strided.dsorthp( N:integer, order:number, x:Float64Array, stride:integer )\n    Sorts a double-precision floating-point strided array using heapsort.\n"
base.strided.dsorthp.ndarray,"\nbase.strided.dsorthp.ndarray( N:integer, order:number, x:Float64Array, \n  stride:integer, offset:integer )\n    Sorts a double-precision floating-point strided array using heapsort and\n    alternative indexing semantics.\n"
base.strided.dsortins,"\nbase.strided.dsortins( N:integer, order:number, x:Float64Array, stride:integer )\n    Sorts a double-precision floating-point strided array using insertion sort.\n"
base.strided.dsortins.ndarray,"\nbase.strided.dsortins.ndarray( N:integer, order:number, x:Float64Array, \n  stride:integer, offset:integer )\n    Sorts a double-precision floating-point strided array using insertion sort\n    and alternative indexing semantics.\n"
base.strided.dsortsh,"\nbase.strided.dsortsh( N:integer, order:number, x:Float64Array, stride:integer )\n    Sorts a double-precision floating-point strided array using Shellsort.\n"
base.strided.dsortsh.ndarray,"\nbase.strided.dsortsh.ndarray( N:integer, order:number, x:Float64Array, \n  stride:integer, offset:integer )\n    Sorts a double-precision floating-point strided array using Shellsort and\n    alternative indexing semantics.\n"
base.strided.dssum,"\nbase.strided.dssum( N:integer, x:Float32Array, stride:integer )\n    Computes the sum of single-precision floating-point strided array elements\n    using extended accumulation and returning an extended precision result.\n"
base.strided.dssum.ndarray,"\nbase.strided.dssum.ndarray( N:integer, x:Float32Array, stride:integer, \n  offset:integer )\n    Computes the sum of single-precision floating-point strided array elements\n    using extended accumulation and alternative indexing semantics and returning\n    an extended precision result.\n"
base.strided.dssumors,"\nbase.strided.dssumors( N:integer, x:Float32Array, stride:integer )\n    Computes the sum of single-precision floating-point strided array elements\n    using ordinary recursive summation with extended accumulation and returning\n    an extended precision result.\n"
base.strided.dssumors.ndarray,"\nbase.strided.dssumors.ndarray( N:integer, x:Float32Array, stride:integer, \n  offset:integer )\n    Computes the sum of single-precision floating-point strided array elements\n    using ordinary recursive summation with extended accumulation and\n    alternative indexing semantics and returning an extended precision result.\n"
base.strided.dssumpw,"\nbase.strided.dssumpw( N:integer, x:Float32Array, stride:integer )\n    Computes the sum of single-precision floating-point strided array elements\n    using pairwise summation with extended accumulation and returning an\n    extended precision result.\n"
base.strided.dssumpw.ndarray,"\nbase.strided.dssumpw.ndarray( N:integer, x:Float32Array, stride:integer, \n  offset:integer )\n    Computes the sum of single-precision floating-point strided array elements\n    using pairwise summation with extended accumulation and alternative indexing\n    semantics and returning an extended precision result.\n"
base.strided.dstdev,"\nbase.strided.dstdev( N:integer, correction:number, x:Float64Array, \n  stride:integer )\n    Computes the standard deviation of a double-precision floating-point strided\n    array.\n"
base.strided.dstdev.ndarray,"\nbase.strided.dstdev.ndarray( N:integer, correction:number, x:Float64Array, \n  stride:integer, offset:integer )\n    Computes the standard deviation of a double-precision floating-point strided\n    array using alternative indexing semantics.\n"
base.strided.dstdevch,"\nbase.strided.dstdevch( N:integer, correction:number, x:Float64Array, \n  stride:integer )\n    Computes the standard deviation of a double-precision floating-point strided\n    array using a one-pass trial mean algorithm.\n"
base.strided.dstdevch.ndarray,"\nbase.strided.dstdevch.ndarray( N:integer, correction:number, x:Float64Array, \n  stride:integer, offset:integer )\n    Computes the standard deviation of a double-precision floating-point strided\n    array using a one-pass trial mean algorithm and alternative indexing\n    semantics.\n"
base.strided.dstdevpn,"\nbase.strided.dstdevpn( N:integer, correction:number, x:Float64Array, \n  stride:integer )\n    Computes the standard deviation of a double-precision floating-point strided\n    array using a two-pass algorithm.\n"
base.strided.dstdevpn.ndarray,"\nbase.strided.dstdevpn.ndarray( N:integer, correction:number, x:Float64Array, \n  stride:integer, offset:integer )\n    Computes the standard deviation of a double-precision floating-point strided\n    array using a two-pass algorithm and alternative indexing semantics.\n"
base.strided.dstdevtk,"\nbase.strided.dstdevtk( N:integer, correction:number, x:Float64Array, \n  stride:integer )\n    Computes the standard deviation of a double-precision floating-point strided\n    array using a one-pass textbook algorithm.\n"
base.strided.dstdevtk.ndarray,"\nbase.strided.dstdevtk.ndarray( N:integer, correction:number, x:Float64Array, \n  stride:integer, offset:integer )\n    Computes the standard deviation of a double-precision floating-point strided\n    array using a one-pass textbook algorithm and alternative indexing\n    semantics.\n"
base.strided.dstdevwd,"\nbase.strided.dstdevwd( N:integer, correction:number, x:Float64Array, \n  stride:integer )\n    Computes the standard deviation of a double-precision floating-point strided\n    array using Welford's algorithm.\n"
base.strided.dstdevwd.ndarray,"\nbase.strided.dstdevwd.ndarray( N:integer, correction:number, x:Float64Array, \n  stride:integer, offset:integer )\n    Computes the standard deviation of a double-precision floating-point strided\n    array using Welford's algorithm and alternative indexing semantics.\n"
base.strided.dstdevyc,"\nbase.strided.dstdevyc( N:integer, correction:number, x:Float64Array, \n  stride:integer )\n    Computes the standard deviation of a double-precision floating-point strided\n    array using a one-pass algorithm proposed by Youngs and Cramer.\n"
base.strided.dstdevyc.ndarray,"\nbase.strided.dstdevyc.ndarray( N:integer, correction:number, x:Float64Array, \n  stride:integer, offset:integer )\n    Computes the standard deviation of a double-precision floating-point strided\n    array using a one-pass algorithm proposed by Youngs and Cramer and\n    alternative indexing semantics.\n"
base.strided.dsum,"\nbase.strided.dsum( N:integer, x:Float64Array, stride:integer )\n    Computes the sum of double-precision floating-point strided array elements.\n"
base.strided.dsum.ndarray,"\nbase.strided.dsum.ndarray( N:integer, x:Float64Array, stride:integer, \n  offset:integer )\n    Computes the sum of double-precision floating-point strided array elements\n    using alternative indexing semantics.\n"
base.strided.dsumkbn,"\nbase.strided.dsumkbn( N:integer, x:Float64Array, stride:integer )\n    Computes the sum of double-precision floating-point strided array elements\n    using an improved Kahan–Babuška algorithm.\n"
base.strided.dsumkbn.ndarray,"\nbase.strided.dsumkbn.ndarray( N:integer, x:Float64Array, stride:integer, \n  offset:integer )\n    Computes the sum of double-precision floating-point strided array elements\n    using an improved Kahan–Babuška algorithm and alternative indexing\n    semantics.\n"
base.strided.dsumkbn2,"\nbase.strided.dsumkbn2( N:integer, x:Float64Array, stride:integer )\n    Computes the sum of double-precision floating-point strided array elements\n    using a second-order iterative Kahan–Babuška algorithm.\n"
base.strided.dsumkbn2.ndarray,"\nbase.strided.dsumkbn2.ndarray( N:integer, x:Float64Array, stride:integer, \n  offset:integer )\n    Computes the sum of double-precision floating-point strided array elements\n    using a second-order iterative Kahan–Babuška algorithm and alternative\n    indexing semantics.\n"
base.strided.dsumors,"\nbase.strided.dsumors( N:integer, x:Float64Array, stride:integer )\n    Computes the sum of double-precision floating-point strided array elements\n    using ordinary recursive summation.\n"
base.strided.dsumors.ndarray,"\nbase.strided.dsumors.ndarray( N:integer, x:Float64Array, stride:integer, \n  offset:integer )\n    Computes the sum of double-precision floating-point strided array elements\n    using ordinary recursive summation and alternative indexing semantics.\n"
base.strided.dsumpw,"\nbase.strided.dsumpw( N:integer, x:Float64Array, stride:integer )\n    Computes the sum of double-precision floating-point strided array elements\n    using pairwise summation.\n"
base.strided.dsumpw.ndarray,"\nbase.strided.dsumpw.ndarray( N:integer, x:Float64Array, stride:integer, \n  offset:integer )\n    Computes the sum of double-precision floating-point strided array elements\n    using pairwise summation and alternative indexing semantics.\n"
base.strided.dsvariance,"\nbase.strided.dsvariance( N:integer, correction:number, x:Float32Array, \n  stride:integer )\n    Computes the variance of a single-precision floating-point strided array\n    using extended accumulation and returning an extended precision result.\n"
base.strided.dsvariance.ndarray,"\nbase.strided.dsvariance.ndarray( N:integer, correction:number, x:Float32Array, \n  stride:integer, offset:integer )\n    Computes the variance of a single-precision floating-point strided array\n    using extended accumulation and alternative indexing semantics and\n    returning an extended precision result.\n"
base.strided.dsvariancepn,"\nbase.strided.dsvariancepn( N:integer, correction:number, x:Float32Array, \n  stride:integer )\n    Computes the variance of a single-precision floating-point strided array\n    using a two-pass algorithm with extended accumulation and returning an\n    extended precision result.\n"
base.strided.dsvariancepn.ndarray,"\nbase.strided.dsvariancepn.ndarray( N:integer, correction:number, \n  x:Float32Array, stride:integer, offset:integer )\n    Computes the variance of a single-precision floating-point strided array\n    using a two-pass algorithm with extended accumulation and alternative\n    indexing semantics and returning an extended precision result.\n"
base.strided.dswap,"\nbase.strided.dswap( N:integer, x:Float64Array, strideX:integer, y:Float64Array, \n  strideY:integer )\n    Interchanges two double-precision floating-point vectors.\n"
base.strided.dswap.ndarray,"\nbase.strided.dswap.ndarray( N:integer, x:Float64Array, strideX:integer, \n  offsetX:integer, y:Float64Array, strideY:integer, offsetY:integer )\n    Interchanges two double-precision floating-point vectors using alternative\n    indexing semantics.\n"
base.strided.dvariance,"\nbase.strided.dvariance( N:integer, correction:number, x:Float64Array, \n  stride:integer )\n    Computes the variance of a double-precision floating-point strided array.\n"
base.strided.dvariance.ndarray,"\nbase.strided.dvariance.ndarray( N:integer, correction:number, x:Float64Array, \n  stride:integer, offset:integer )\n    Computes the variance of a double-precision floating-point strided array\n    using alternative indexing semantics.\n"
base.strided.dvariancech,"\nbase.strided.dvariancech( N:integer, correction:number, x:Float64Array, \n  stride:integer )\n    Computes the variance of a double-precision floating-point strided array\n    using a one-pass trial mean algorithm.\n"
base.strided.dvariancech.ndarray,"\nbase.strided.dvariancech.ndarray( N:integer, correction:number, x:Float64Array, \n  stride:integer, offset:integer )\n    Computes the variance of a double-precision floating-point strided array\n    using a one-pass trial mean algorithm and alternative indexing semantics.\n"
base.strided.dvariancepn,"\nbase.strided.dvariancepn( N:integer, correction:number, x:Float64Array, \n  stride:integer )\n    Computes the variance of a double-precision floating-point strided array\n    using a two-pass algorithm.\n"
base.strided.dvariancepn.ndarray,"\nbase.strided.dvariancepn.ndarray( N:integer, correction:number, x:Float64Array, \n  stride:integer, offset:integer )\n    Computes the variance of a double-precision floating-point strided array\n    using a two-pass algorithm and alternative indexing semantics.\n"
base.strided.dvariancetk,"\nbase.strided.dvariancetk( N:integer, correction:number, x:Float64Array, \n  stride:integer )\n    Computes the variance of a double-precision floating-point strided array\n    using a one-pass textbook algorithm.\n"
base.strided.dvariancetk.ndarray,"\nbase.strided.dvariancetk.ndarray( N:integer, correction:number, x:Float64Array, \n  stride:integer, offset:integer )\n    Computes the variance of a double-precision floating-point strided array\n    using a one-pass textbook algorithm and alternative indexing semantics.\n"
base.strided.dvariancewd,"\nbase.strided.dvariancewd( N:integer, correction:number, x:Float64Array, \n  stride:integer )\n    Computes the variance of a double-precision floating-point strided array\n    using Welford's algorithm.\n"
base.strided.dvariancewd.ndarray,"\nbase.strided.dvariancewd.ndarray( N:integer, correction:number, x:Float64Array, \n  stride:integer, offset:integer )\n    Computes the variance of a double-precision floating-point strided array\n    using Welford's algorithm and alternative indexing semantics.\n"
base.strided.dvarianceyc,"\nbase.strided.dvarianceyc( N:integer, correction:number, x:Float64Array, \n  stride:integer )\n    Computes the variance of a double-precision floating-point strided array\n    using a one-pass algorithm proposed by Youngs and Cramer.\n"
base.strided.dvarianceyc.ndarray,"\nbase.strided.dvarianceyc.ndarray( N:integer, correction:number, x:Float64Array, \n  stride:integer, offset:integer )\n    Computes the variance of a double-precision floating-point strided array\n    using a one-pass algorithm proposed by Youngs and Cramer and alternative\n    indexing semantics.\n"
base.strided.dvarm,"\nbase.strided.dvarm( N:integer, mean:number, correction:number, x:Float64Array, \n  stride:integer )\n    Computes the variance of a double-precision floating-point strided array\n    provided a known mean.\n"
base.strided.dvarm.ndarray,"\nbase.strided.dvarm.ndarray( N:integer, mean:number, correction:number, \n  x:Float64Array, stride:integer, offset:integer )\n    Computes the variance of a double-precision floating-point strided array\n    provided a known mean and using alternative indexing semantics.\n"
base.strided.dvarmpn,"\nbase.strided.dvarmpn( N:integer, mean:number, correction:number, \n  x:Float64Array, stride:integer )\n    Computes the variance of a double-precision floating-point strided array\n    provided a known mean and using Neely's correction algorithm.\n"
base.strided.dvarmpn.ndarray,"\nbase.strided.dvarmpn.ndarray( N:integer, mean:number, correction:number, \n  x:Float64Array, stride:integer, offset:integer )\n    Computes the variance of a double-precision floating-point strided array\n    provided a known mean and using Neely's correction algorithm and alternative\n    indexing semantics.\n"
base.strided.dvarmtk,"\nbase.strided.dvarmtk( N:integer, mean:number, correction:number, \n  x:Float64Array, stride:integer )\n    Computes the variance of a double-precision floating-point strided array\n    provided a known mean and using a one-pass textbook algorithm.\n"
base.strided.dvarmtk.ndarray,"\nbase.strided.dvarmtk.ndarray( N:integer, mean:number, correction:number, \n  x:Float64Array, stride:integer, offset:integer )\n    Computes the variance of a double-precision floating-point strided array\n    provided a known mean and using a one-pass textbook algorithm and\n    alternative indexing semantics.\n"
base.strided.gapx,"\nbase.strided.gapx( N:integer, alpha:number, x:Array|TypedArray, stride:integer )\n    Adds a constant to each element in a strided array.\n"
base.strided.gapx.ndarray,"\nbase.strided.gapx.ndarray( N:integer, alpha:number, x:Array|TypedArray, \n  stride:integer, offset:integer )\n    Adds a constant to each element in a strided array using alternative\n    indexing semantics.\n"
base.strided.gapxsum,"\nbase.strided.gapxsum( N:integer, alpha:number, x:Array|TypedArray, \n  stride:integer )\n    Adds a constant to each strided array element and computes the sum.\n"
base.strided.gapxsum.ndarray,"\nbase.strided.gapxsum.ndarray( N:integer, alpha:number, x:Array|TypedArray, \n  stride:integer, offset:integer )\n    Adds a constant to each strided array element and computes the sum using\n    alternative indexing semantics.\n"
base.strided.gapxsumkbn,"\nbase.strided.gapxsumkbn( N:integer, alpha:number, x:Array|TypedArray, \n  stride:integer )\n    Adds a constant to each strided array element and computes the sum using an\n    improved Kahan–Babuška algorithm.\n"
base.strided.gapxsumkbn.ndarray,"\nbase.strided.gapxsumkbn.ndarray( N:integer, alpha:number, x:Array|TypedArray, \n  stride:integer, offset:integer )\n    Adds a constant to each strided array element and computes the sum using an\n    improved Kahan–Babuška algorithm and alternative indexing semantics.\n"
base.strided.gapxsumkbn2,"\nbase.strided.gapxsumkbn2( N:integer, alpha:number, x:Array|TypedArray, \n  stride:integer )\n    Adds a constant to each strided array element and computes the sum using a\n    second-order iterative Kahan–Babuška algorithm.\n"
base.strided.gapxsumkbn2.ndarray,"\nbase.strided.gapxsumkbn2.ndarray( N:integer, alpha:number, x:Array|TypedArray, \n  stride:integer, offset:integer )\n    Adds a constant to each strided array element and computes the sum using a\n    second-order iterative Kahan–Babuška algorithm and alternative indexing\n    semantics.\n"
base.strided.gapxsumors,"\nbase.strided.gapxsumors( N:integer, alpha:number, x:Array|TypedArray, \n  stride:integer )\n    Adds a constant to each strided array element and computes the sum using\n    ordinary recursive summation.\n"
base.strided.gapxsumors.ndarray,"\nbase.strided.gapxsumors.ndarray( N:integer, alpha:number, x:Array|TypedArray, \n  stride:integer, offset:integer )\n    Adds a constant to each strided array element and computes the sum using\n    ordinary recursive summation and alternative indexing semantics.\n"
base.strided.gapxsumpw,"\nbase.strided.gapxsumpw( N:integer, alpha:number, x:Array|TypedArray, \n  stride:integer )\n    Adds a constant to each strided array element and computes the sum using\n    pairwise summation.\n"
base.strided.gapxsumpw.ndarray,"\nbase.strided.gapxsumpw.ndarray( N:integer, alpha:number, x:Array|TypedArray, \n  stride:integer, offset:integer )\n    Adds a constant to each strided array element and computes the sum using\n    pairwise summation and alternative indexing semantics.\n"
base.strided.gasum,"\nbase.strided.gasum( N:integer, x:Array|TypedArray, stride:integer )\n    Computes the sum of the absolute values.\n"
base.strided.gasum.ndarray,"\nbase.strided.gasum.ndarray( N:integer, x:Array|TypedArray, stride:integer, \n  offset:integer )\n    Computes the sum of absolute values using alternative indexing semantics.\n"
base.strided.gasumpw,"\nbase.strided.gasumpw( N:integer, x:Array|TypedArray, stride:integer )\n    Computes the sum of absolute values (L1 norm) of strided array elements\n    using pairwise summation.\n"
base.strided.gasumpw.ndarray,"\nbase.strided.gasumpw.ndarray( N:integer, x:Array|TypedArray, stride:integer, \n  offset:integer )\n    Computes the sum of absolute values (L1 norm) of strided array elements\n    using pairwise summation and alternative indexing semantics.\n"
base.strided.gaxpy,"\nbase.strided.gaxpy( N:integer, alpha:number, x:Array|TypedArray, \n  strideX:integer, y:Array|TypedArray, strideY:integer )\n    Multiplies `x` by a constant `alpha` and adds the result to `y`.\n"
base.strided.gaxpy.ndarray,"\nbase.strided.gaxpy.ndarray( N:integer, alpha:number, x:Array|TypedArray, \n  strideX:integer, offsetX:integer, y:Array|TypedArray, strideY:integer, \n  offsetY:integer )\n    Multiplies `x` by a constant `alpha` and adds the result to `y`, with\n    alternative indexing semantics.\n"
base.strided.gcopy,"\nbase.strided.gcopy( N:integer, x:Array|TypedArray, strideX:integer, \n  y:Array|TypedArray, strideY:integer )\n    Copies values from `x` into `y`.\n"
base.strided.gcopy.ndarray,"\nbase.strided.gcopy.ndarray( N:integer, x:Array|TypedArray, strideX:integer, \n  offsetX:integer, y:Array|TypedArray, strideY:integer, offsetY:integer )\n    Copies values from `x` into `y` using alternative indexing semantics.\n"
base.strided.gcusum,"\nbase.strided.gcusum( N:integer, sum:number, x:Array|TypedArray, \n  strideX:integer, y:Array|TypedArray, strideY:integer )\n    Computes the cumulative sum of strided array elements.\n"
base.strided.gcusum.ndarray,"\nbase.strided.gcusum.ndarray( N:integer, sum:number, x:Array|TypedArray, \n  strideX:integer, offsetX:integer, y:Array|TypedArray, strideY:integer, \n  offsetY:integer )\n    Computes the cumulative sum of strided array elements using alternative\n    indexing semantics.\n"
base.strided.gcusumkbn,"\nbase.strided.gcusumkbn( N:integer, sum:number, x:Array|TypedArray, \n  strideX:integer, y:Array|TypedArray, strideY:integer )\n    Computes the cumulative sum of strided array elements using an improved\n    Kahan–Babuška algorithm.\n"
base.strided.gcusumkbn.ndarray,"\nbase.strided.gcusumkbn.ndarray( N:integer, sum:number, x:Array|TypedArray, \n  strideX:integer, offsetX:integer, y:Array|TypedArray, strideY:integer, \n  offsetY:integer )\n    Computes the cumulative sum of strided array elements using an improved\n    Kahan–Babuška algorithm and alternative indexing semantics.\n"
base.strided.gcusumkbn2,"\nbase.strided.gcusumkbn2( N:integer, sum:number, x:Array|TypedArray, \n  strideX:integer, y:Array|TypedArray, strideY:integer )\n    Computes the cumulative sum of strided array elements using a second-order\n    iterative Kahan–Babuška algorithm.\n"
base.strided.gcusumkbn2.ndarray,"\nbase.strided.gcusumkbn2.ndarray( N:integer, sum:number, x:Array|TypedArray, \n  strideX:integer, offsetX:integer, y:Array|TypedArray, strideY:integer, \n  offsetY:integer )\n    Computes the cumulative sum of strided array elements using a second-order\n    iterative Kahan–Babuška algorithm and alternative indexing semantics.\n"
base.strided.gcusumors,"\nbase.strided.gcusumors( N:integer, sum:number, x:Array|TypedArray, \n  strideX:integer, y:Array|TypedArray, strideY:integer )\n    Computes the cumulative sum of strided array elements using ordinary\n    recursive summation.\n"
base.strided.gcusumors.ndarray,"\nbase.strided.gcusumors.ndarray( N:integer, sum:number, x:Array|TypedArray, \n  strideX:integer, offsetX:integer, y:Array|TypedArray, strideY:integer, \n  offsetY:integer )\n    Computes the cumulative sum of strided array elements using ordinary\n    recursive summation and alternative indexing semantics.\n"
base.strided.gcusumpw,"\nbase.strided.gcusumpw( N:integer, sum:number, x:Array|TypedArray, \n  strideX:integer, y:Array|TypedArray, strideY:integer )\n    Computes the cumulative sum of strided array elements using pairwise\n    summation.\n"
base.strided.gcusumpw.ndarray,"\nbase.strided.gcusumpw.ndarray( N:integer, sum:number, x:Array|TypedArray, \n  strideX:integer, offsetX:integer, y:Array|TypedArray, strideY:integer, \n  offsetY:integer )\n    Computes the cumulative sum of strided array elements using pairwise\n    summation and alternative indexing semantics.\n"
base.strided.gdot,"\nbase.strided.gdot( N:integer, x:Array|TypedArray, strideX:integer, \n  y:Array|TypedArray, strideY:integer )\n    Computes the dot product of two vectors.\n"
base.strided.gdot.ndarray,"\nbase.strided.gdot.ndarray( N:integer, x:Array|TypedArray, strideX:integer, \n  offsetX:integer, y:Array|TypedArray, strideY:integer, offsetY:integer )\n    Computes the dot product of two vectors using alternative indexing\n    semantics.\n"
base.strided.gfill,"\nbase.strided.gfill( N:integer, alpha:number, x:Array|TypedArray, \n  stride:integer )\n    Fills a strided array with a specified scalar value.\n"
base.strided.gfill.ndarray,"\nbase.strided.gfill.ndarray( N:integer, alpha:number, x:Array|TypedArray, \n  stride:integer, offset:integer )\n    Fills a strided array with a specified scalar value using alternative\n    indexing semantics.\n"
base.strided.gfillBy,"\nbase.strided.gfillBy( N:integer, x:Array|TypedArray|Object, stride:integer, \n  clbk:Function[, thisArg:any] )\n    Fills a strided array according to a provided callback function.\n"
base.strided.gfillBy.ndarray,"\nbase.strided.gfillBy.ndarray( N:integer, x:Array|TypedArray|Object, \n  stride:integer, offset:integer, clbk:Function[, thisArg:any] )\n    Fills a strided array according to a provided callback function and using\n    alternative indexing semantics.\n"
base.strided.gnannsumkbn,"\nbase.strided.gnannsumkbn( N:integer, x:Array|TypedArray, strideX:integer, \n  out:Array|TypedArray, strideOut:integer )\n    Computes the sum of strided array elements, ignoring `NaN` values and using\n    an improved Kahan–Babuška algorithm.\n"
base.strided.gnannsumkbn.ndarray,"\nbase.strided.gnannsumkbn.ndarray( N:integer, x:Array|TypedArray, \n  strideX:integer, offsetX:integer, out:Array|TypedArray, strideOut:integer, \n  offsetOut:integer )\n    Computes the sum of strided array elements, ignoring `NaN` values and using\n    an improved Kahan–Babuška algorithm and alternative indexing semantics.\n"
base.strided.gnansum,"\nbase.strided.gnansum( N:integer, x:Array|TypedArray, stride:integer )\n    Computes the sum of strided array elements, ignoring `NaN` values.\n"
base.strided.gnansum.ndarray,"\nbase.strided.gnansum.ndarray( N:integer, x:Array|TypedArray, stride:integer, \n  offset:integer )\n    Computes the sum of strided array elements, ignoring `NaN` values and using\n    alternative indexing semantics.\n"
base.strided.gnansumkbn,"\nbase.strided.gnansumkbn( N:integer, x:Array|TypedArray, stride:integer )\n    Computes the sum of strided array elements, ignoring `NaN` values and using\n    an improved Kahan–Babuška algorithm.\n"
base.strided.gnansumkbn.ndarray,"\nbase.strided.gnansumkbn.ndarray( N:integer, x:Array|TypedArray, stride:integer, \n  offset:integer )\n    Computes the sum of strided array elements, ignoring `NaN` values and using\n    an improved Kahan–Babuška algorithm and alternative indexing semantics.\n"
base.strided.gnansumkbn2,"\nbase.strided.gnansumkbn2( N:integer, x:Array|TypedArray, stride:integer )\n    Computes the sum of strided array elements, ignoring `NaN` values and using\n    a second-order iterative Kahan–Babuška algorithm.\n"
base.strided.gnansumkbn2.ndarray,"\nbase.strided.gnansumkbn2.ndarray( N:integer, x:Array|TypedArray, \n  stride:integer, offset:integer )\n    Computes the sum of strided array elements, ignoring `NaN` values and using\n    a second-order iterative Kahan–Babuška algorithm and alternative indexing\n    semantics.\n"
base.strided.gnansumors,"\nbase.strided.gnansumors( N:integer, x:Array|TypedArray, stride:integer )\n    Computes the sum of strided array elements, ignoring `NaN` values and using\n    ordinary recursive summation.\n"
base.strided.gnansumors.ndarray,"\nbase.strided.gnansumors.ndarray( N:integer, x:Array|TypedArray, stride:integer, \n  offset:integer )\n    Computes the sum of strided array elements, ignoring `NaN` values and using\n    ordinary recursive summation and alternative indexing semantics.\n"
base.strided.gnansumpw,"\nbase.strided.gnansumpw( N:integer, x:Array|TypedArray, stride:integer )\n    Computes the sum of strided array elements, ignoring `NaN` values and\n    pairwise summation.\n"
base.strided.gnansumpw.ndarray,"\nbase.strided.gnansumpw.ndarray( N:integer, x:Array|TypedArray, stride:integer, \n  offset:integer )\n    Computes the sum of strided array elements, ignoring `NaN` values and using\n    pairwise summation and alternative indexing semantics.\n"
base.strided.gnrm2,"\nbase.strided.gnrm2( N:integer, x:Array|TypedArray, stride:integer )\n    Computes the L2-norm of a vector.\n"
base.strided.gnrm2.ndarray,"\nbase.strided.gnrm2.ndarray( N:integer, x:Array|TypedArray, stride:integer, \n  offset:integer )\n    Computes the L2-norm of a vector using alternative indexing semantics.\n"
base.strided.grev,"\nbase.strided.grev( N:integer, x:Array|TypedArray, stride:integer )\n    Reverses a strided array in-place.\n"
base.strided.grev.ndarray,"\nbase.strided.grev.ndarray( N:integer, x:Array|TypedArray, stride:integer, \n  offset:integer )\n    Reverses a strided array in-place using alternative indexing semantics.\n"
base.strided.gscal,"\nbase.strided.gscal( N:integer, alpha:number, x:Array|TypedArray, \n  stride:integer )\n    Multiplies a vector `x` by a constant `alpha`.\n"
base.strided.gscal.ndarray,"\nbase.strided.gscal.ndarray( N:integer, alpha:number, x:Array|TypedArray, \n  stride:integer, offset:integer )\n    Multiplies `x` by a constant `alpha` using alternative indexing semantics.\n"
base.strided.gsort2hp,"\nbase.strided.gsort2hp( N:integer, order:number, x:Array|TypedArray, \n  strideX:integer, y:Array|TypedArray, strideY:integer )\n    Simultaneously sorts two strided arrays based on the sort order of the first\n    array using heapsort.\n"
base.strided.gsort2hp.ndarray,"\nbase.strided.gsort2hp.ndarray( N:integer, order:number, x:Array|TypedArray, \n  strideX:integer, offsetX:integer, y:Array|TypedArray, strideY:integer, \n  offsetY:integer )\n    Simultaneously sorts two strided arrays based on the sort order of the first\n    array using heapsort and alternative indexing semantics.\n"
base.strided.gsort2ins,"\nbase.strided.gsort2ins( N:integer, order:number, x:Array|TypedArray, \n  strideX:integer, y:Array|TypedArray, strideY:integer )\n    Simultaneously sorts two strided arrays based on the sort order of the first\n    array using insertion sort.\n"
base.strided.gsort2ins.ndarray,"\nbase.strided.gsort2ins.ndarray( N:integer, order:number, x:Array|TypedArray, \n  strideX:integer, offsetX:integer, y:Array|TypedArray, strideY:integer, \n  offsetY:integer )\n    Simultaneously sorts two strided arrays based on the sort order of the first\n    array using insertion sort and alternative indexing semantics.\n"
base.strided.gsort2sh,"\nbase.strided.gsort2sh( N:integer, order:number, x:Array|TypedArray, \n  strideX:integer, y:Array|TypedArray, strideY:integer )\n    Simultaneously sorts two strided arrays based on the sort order of the first\n    array using Shellsort.\n"
base.strided.gsort2sh.ndarray,"\nbase.strided.gsort2sh.ndarray( N:integer, order:number, x:Array|TypedArray, \n  strideX:integer, offsetX:integer, y:Array|TypedArray, strideY:integer, \n  offsetY:integer )\n    Simultaneously sorts two strided arrays based on the sort order of the first\n    array using Shellsort and alternative indexing semantics.\n"
base.strided.gsorthp,"\nbase.strided.gsorthp( N:integer, order:number, x:Array|TypedArray, \n  stride:integer )\n    Sorts a strided array using heapsort.\n"
base.strided.gsorthp.ndarray,"\nbase.strided.gsorthp.ndarray( N:integer, order:number, x:Array|TypedArray, \n  stride:integer, offset:integer )\n    Sorts a strided array using heapsort and alternative indexing semantics.\n"
base.strided.gsortins,"\nbase.strided.gsortins( N:integer, order:number, x:Array|TypedArray, \n  stride:integer )\n    Sorts a strided array using insertion sort.\n"
base.strided.gsortins.ndarray,"\nbase.strided.gsortins.ndarray( N:integer, order:number, x:Array|TypedArray, \n  stride:integer, offset:integer )\n    Sorts a strided array using insertion sort and alternative indexing\n    semantics.\n"
base.strided.gsortsh,"\nbase.strided.gsortsh( N:integer, order:number, x:Array|TypedArray, \n  stride:integer )\n    Sorts a strided array using Shellsort.\n"
base.strided.gsortsh.ndarray,"\nbase.strided.gsortsh.ndarray( N:integer, order:number, x:Array|TypedArray, \n  stride:integer, offset:integer )\n    Sorts a strided array using Shellsort and alternative indexing semantics.\n"
base.strided.gsum,"\nbase.strided.gsum( N:integer, x:Array|TypedArray, stride:integer )\n    Computes the sum of strided array elements.\n"
base.strided.gsum.ndarray,"\nbase.strided.gsum.ndarray( N:integer, x:Array|TypedArray, stride:integer, \n  offset:integer )\n    Computes the sum of strided array elements using alternative indexing\n    semantics.\n"
base.strided.gsumkbn,"\nbase.strided.gsumkbn( N:integer, x:Array|TypedArray, stride:integer )\n    Computes the sum of strided array elements using an improved Kahan–Babuška\n    algorithm.\n"
base.strided.gsumkbn.ndarray,"\nbase.strided.gsumkbn.ndarray( N:integer, x:Array|TypedArray, stride:integer, \n  offset:integer )\n    Computes the sum of strided array elements using an improved Kahan–Babuška\n    algorithm and alternative indexing semantics.\n"
base.strided.gsumkbn2,"\nbase.strided.gsumkbn2( N:integer, x:Array|TypedArray, stride:integer )\n    Computes the sum of strided array elements using a second-order iterative\n    Kahan–Babuška algorithm.\n"
base.strided.gsumkbn2.ndarray,"\nbase.strided.gsumkbn2.ndarray( N:integer, x:Array|TypedArray, stride:integer, \n  offset:integer )\n    Computes the sum of strided array elements using a second-order iterative\n    Kahan–Babuška algorithm and alternative indexing semantics.\n"
base.strided.gsumors,"\nbase.strided.gsumors( N:integer, x:Array|TypedArray, stride:integer )\n    Computes the sum of strided array elements using ordinary recursive\n    summation.\n"
base.strided.gsumors.ndarray,"\nbase.strided.gsumors.ndarray( N:integer, x:Array|TypedArray, stride:integer, \n  offset:integer )\n    Computes the sum of strided array elements using ordinary recursive\n    summation and alternative indexing semantics.\n"
base.strided.gsumpw,"\nbase.strided.gsumpw( N:integer, x:Array|TypedArray, stride:integer )\n    Computes the sum of strided array elements using pairwise summation.\n"
base.strided.gsumpw.ndarray,"\nbase.strided.gsumpw.ndarray( N:integer, x:Array|TypedArray, stride:integer, \n  offset:integer )\n    Computes the sum of strided array elements using pairwise summation and\n    alternative indexing semantics.\n"
base.strided.gswap,"\nbase.strided.gswap( N:integer, x:Array|TypedArray, strideX:integer, \n  y:Array|TypedArray, strideY:integer )\n    Interchanges vectors `x` and `y`.\n"
base.strided.gswap.ndarray,"\nbase.strided.gswap.ndarray( N:integer, x:Array|TypedArray, strideX:integer, \n  offsetX:integer, y:Array|TypedArray, strideY:integer, offsetY:integer )\n    Interchanges vectors `x` and `y` using alternative indexing semantics.\n"
base.strided.max,"\nbase.strided.max( N:integer, x:Array|TypedArray, stride:integer )\n    Computes the maximum value of a strided array.\n"
base.strided.max.ndarray,"\nbase.strided.max.ndarray( N:integer, x:Array|TypedArray, stride:integer, \n  offset:integer )\n    Computes the maximum value of a strided array using alternative indexing\n    semantics.\n"
base.strided.maxabs,"\nbase.strided.maxabs( N:integer, x:Array|TypedArray, stride:integer )\n    Computes the maximum absolute value of a strided array.\n"
base.strided.maxabs.ndarray,"\nbase.strided.maxabs.ndarray( N:integer, x:Array|TypedArray, stride:integer, \n  offset:integer )\n    Computes the maximum absolute value of a strided array using alternative\n    indexing semantics.\n"
base.strided.maxBy,"\nbase.strided.maxBy( N:integer, x:Array|TypedArray|Object, stride:integer, \n  clbk:Function[, thisArg:any] )\n    Calculates the maximum value of a strided array via a callback function.\n"
base.strided.maxBy.ndarray,"\nbase.strided.maxBy.ndarray( N:integer, x:Array|TypedArray|Object, \n  stride:integer, offset:integer, clbk:Function[, thisArg:any] )\n    Calculates the maximum value of a strided array via a callback function and\n    using alternative indexing semantics.\n"
base.strided.maxsorted,"\nbase.strided.maxsorted( N:integer, x:Array|TypedArray, stride:integer )\n    Computes the maximum value of a sorted strided array.\n"
base.strided.maxsorted.ndarray,"\nbase.strided.maxsorted.ndarray( N:integer, x:Array|TypedArray, stride:integer, \n  offset:integer )\n    Computes the maximum value of a sorted strided array using alternative\n    indexing semantics.\n"
base.strided.mean,"\nbase.strided.mean( N:integer, x:Array|TypedArray, stride:integer )\n    Computes the arithmetic mean of a strided array.\n"
base.strided.mean.ndarray,"\nbase.strided.mean.ndarray( N:integer, x:Array|TypedArray, stride:integer, \n  offset:integer )\n    Computes the arithmetic mean of a strided array using alternative indexing\n    semantics.\n"
base.strided.meankbn,"\nbase.strided.meankbn( N:integer, x:Array|TypedArray, stride:integer )\n    Computes the arithmetic mean of a strided array using an improved Kahan–\n    Babuška algorithm.\n"
base.strided.meankbn.ndarray,"\nbase.strided.meankbn.ndarray( N:integer, x:Array|TypedArray, stride:integer, \n  offset:integer )\n    Computes the arithmetic mean of a strided array using an improved Kahan–\n    Babuška algorithm and alternative indexing semantics.\n"
base.strided.meankbn2,"\nbase.strided.meankbn2( N:integer, x:Array|TypedArray, stride:integer )\n    Computes the arithmetic mean of a strided array using a second-order\n    iterative Kahan–Babuška algorithm.\n"
base.strided.meankbn2.ndarray,"\nbase.strided.meankbn2.ndarray( N:integer, x:Array|TypedArray, stride:integer, \n  offset:integer )\n    Computes the arithmetic mean of a strided array using a second-order\n    iterative Kahan–Babuška algorithm and alternative indexing semantics.\n"
base.strided.meanors,"\nbase.strided.meanors( N:integer, x:Array|TypedArray, stride:integer )\n    Computes the arithmetic mean of a strided array using ordinary recursive\n    summation.\n"
base.strided.meanors.ndarray,"\nbase.strided.meanors.ndarray( N:integer, x:Array|TypedArray, stride:integer, \n  offset:integer )\n    Computes the arithmetic mean of a strided array using ordinary recursive\n    summation and alternative indexing semantics.\n"
base.strided.meanpn,"\nbase.strided.meanpn( N:integer, x:Array|TypedArray, stride:integer )\n    Computes the arithmetic mean of a strided array using a two-pass error\n    correction algorithm.\n"
base.strided.meanpn.ndarray,"\nbase.strided.meanpn.ndarray( N:integer, x:Array|TypedArray, stride:integer, \n  offset:integer )\n    Computes the arithmetic mean of a strided array using a two-pass error\n    correction algorithm and alternative indexing semantics.\n"
base.strided.meanpw,"\nbase.strided.meanpw( N:integer, x:Array|TypedArray, stride:integer )\n    Computes the arithmetic mean of a strided array using pairwise summation.\n"
base.strided.meanpw.ndarray,"\nbase.strided.meanpw.ndarray( N:integer, x:Array|TypedArray, stride:integer, \n  offset:integer )\n    Computes the arithmetic mean of a strided array using pairwise summation and\n    alternative indexing semantics.\n"
base.strided.meanwd,"\nbase.strided.meanwd( N:integer, x:Array|TypedArray, stride:integer )\n    Computes the arithmetic mean of a strided array using Welford's algorithm.\n"
base.strided.meanwd.ndarray,"\nbase.strided.meanwd.ndarray( N:integer, x:Array|TypedArray, stride:integer, \n  offset:integer )\n    Computes the arithmetic mean of a strided array using Welford's algorithm\n    and alternative indexing semantics.\n"
base.strided.mediansorted,"\nbase.strided.mediansorted( N:integer, x:Array|TypedArray, stride:integer )\n    Computes the median value of a sorted strided array.\n"
base.strided.mediansorted.ndarray,"\nbase.strided.mediansorted.ndarray( N:integer, x:Array|TypedArray, \n  stride:integer, offset:integer )\n    Computes the median value of a sorted strided array using alternative\n    indexing semantics.\n"
base.strided.min,"\nbase.strided.min( N:integer, x:Array|TypedArray, stride:integer )\n    Computes the minimum value of a strided array.\n"
base.strided.min.ndarray,"\nbase.strided.min.ndarray( N:integer, x:Array|TypedArray, stride:integer, \n  offset:integer )\n    Computes the minimum value of a strided array using alternative indexing\n    semantics.\n"
base.strided.minabs,"\nbase.strided.minabs( N:integer, x:Array|TypedArray, stride:integer )\n    Computes the minimum absolute value of a strided array.\n"
base.strided.minabs.ndarray,"\nbase.strided.minabs.ndarray( N:integer, x:Array|TypedArray, stride:integer, \n  offset:integer )\n    Computes the minimum absolute value of a strided array using alternative\n    indexing semantics.\n"
base.strided.minBy,"\nbase.strided.minBy( N:integer, x:Array|TypedArray|Object, stride:integer, \n  clbk:Function[, thisArg:any] )\n    Calculates the minimum value of a strided array via a callback function.\n"
base.strided.minBy.ndarray,"\nbase.strided.minBy.ndarray( N:integer, x:Array|TypedArray|Object, \n  stride:integer, offset:integer, clbk:Function[, thisArg:any] )\n    Calculates the minimum value of a strided array via a callback function and\n    using alternative indexing semantics.\n"
base.strided.minsorted,"\nbase.strided.minsorted( N:integer, x:Array|TypedArray, stride:integer )\n    Computes the minimum value of a sorted strided array.\n"
base.strided.minsorted.ndarray,"\nbase.strided.minsorted.ndarray( N:integer, x:Array|TypedArray, stride:integer, \n  offset:integer )\n    Computes the minimum value of a sorted strided array using alternative\n    indexing semantics.\n"
base.strided.mskmax,"\nbase.strided.mskmax( N:integer, x:Array|TypedArray, strideX:integer, \n  mask:Array|TypedArray, strideMask:integer )\n    Computes the maximum value of a strided array according to a mask.\n"
base.strided.mskmax.ndarray,"\nbase.strided.mskmax.ndarray( N:integer, x:Array|TypedArray, strideX:integer, \n  offsetX:integer, mask:Array|TypedArray, strideMask:integer, \n  offsetMask:integer )\n    Computes the maximum value of a strided array according to a mask and using\n    alternative indexing semantics.\n"
base.strided.mskmin,"\nbase.strided.mskmin( N:integer, x:Array|TypedArray, strideX:integer, \n  mask:Array|TypedArray, strideMask:integer )\n    Computes the minimum value of a strided array according to a mask.\n"
base.strided.mskmin.ndarray,"\nbase.strided.mskmin.ndarray( N:integer, x:Array|TypedArray, strideX:integer, \n  offsetX:integer, mask:Array|TypedArray, strideMask:integer, \n  offsetMask:integer )\n    Computes the minimum value of a strided array according to a mask and using\n    alternative indexing semantics.\n"
base.strided.mskrange,"\nbase.strided.mskrange( N:integer, x:Array|TypedArray, strideX:integer, \n  mask:Array|TypedArray, strideMask:integer )\n    Computes the range of a strided array according to a mask.\n"
base.strided.mskrange.ndarray,"\nbase.strided.mskrange.ndarray( N:integer, x:Array|TypedArray, strideX:integer, \n  offsetX:integer, mask:Array|TypedArray, strideMask:integer, \n  offsetMask:integer )\n    Computes the range of a strided array according to a mask and using\n    alternative indexing semantics.\n"
base.strided.mskunary,"\nbase.strided.mskunary( arrays:ArrayLikeObject<ArrayLikeObject>, \n  shape:ArrayLikeObject<integer>, strides:ArrayLikeObject<integer>, \n  fcn:Function )\n    Applies a unary callback to elements in a strided input array according to\n    elements in a strided mask array and assigns results to elements in a\n    strided output array.\n"
base.strided.mskunary.ndarray,"\nbase.strided.mskunary.ndarray( arrays:ArrayLikeObject<ArrayLikeObject>, \n  shape:ArrayLikeObject<integer>, strides:ArrayLikeObject<integer>, \n  offsets:ArrayLikeObject<integer>, fcn:Function )\n    Applies a unary callback to elements in a strided input array according to\n    elements in a strided mask array, and assigns results to elements in a\n    strided output array using alternative indexing semantics.\n"
base.strided.nanmax,"\nbase.strided.nanmax( N:integer, x:Array|TypedArray, stride:integer )\n    Computes the maximum value of a strided array, ignoring `NaN` values.\n"
base.strided.nanmax.ndarray,"\nbase.strided.nanmax.ndarray( N:integer, x:Array|TypedArray, stride:integer, \n  offset:integer )\n    Computes the maximum value of a strided array, ignoring `NaN` values and\n    using alternative indexing semantics.\n"
base.strided.nanmaxabs,"\nbase.strided.nanmaxabs( N:integer, x:Array|TypedArray, stride:integer )\n    Computes the maximum absolute value of a strided array, ignoring `NaN`\n    values.\n"
base.strided.nanmaxabs.ndarray,"\nbase.strided.nanmaxabs.ndarray( N:integer, x:Array|TypedArray, stride:integer, \n  offset:integer )\n    Computes the maximum absolute value of a strided array, ignoring `NaN`\n    values and using alternative indexing semantics.\n"
base.strided.nanmaxBy,"\nbase.strided.nanmaxBy( N:integer, x:Array|TypedArray|Object, stride:integer, \n  clbk:Function[, thisArg:any] )\n    Calculates the maximum value of a strided array via a callback function,\n    ignoring `NaN` values.\n"
base.strided.nanmaxBy.ndarray,"\nbase.strided.nanmaxBy.ndarray( N:integer, x:Array|TypedArray|Object, \n  stride:integer, offset:integer, clbk:Function[, thisArg:any] )\n    Calculates the maximum value of a strided array via a callback function,\n    ignoring `NaN` values and using alternative indexing semantics.\n"
base.strided.nanmean,"\nbase.strided.nanmean( N:integer, x:Array|TypedArray, stride:integer )\n    Computes the arithmetic mean of a strided array, ignoring `NaN` values.\n"
base.strided.nanmean.ndarray,"\nbase.strided.nanmean.ndarray( N:integer, x:Array|TypedArray, stride:integer, \n  offset:integer )\n    Computes the arithmetic mean of a strided array, ignoring `NaN` values and\n    using alternative indexing semantics.\n"
base.strided.nanmeanors,"\nbase.strided.nanmeanors( N:integer, x:Array|TypedArray, stride:integer )\n    Computes the arithmetic mean of a strided array, ignoring `NaN` values and\n    using ordinary recursive summation.\n"
base.strided.nanmeanors.ndarray,"\nbase.strided.nanmeanors.ndarray( N:integer, x:Array|TypedArray, stride:integer, \n  offset:integer )\n    Computes the arithmetic mean of a strided array, ignoring `NaN` values and\n    using ordinary recursive summation and alternative indexing semantics.\n"
base.strided.nanmeanpn,"\nbase.strided.nanmeanpn( N:integer, x:Array|TypedArray, stride:integer )\n    Computes the arithmetic mean of a strided array, ignoring `NaN` values and\n    using a two-pass error correction algorithm.\n"
base.strided.nanmeanpn.ndarray,"\nbase.strided.nanmeanpn.ndarray( N:integer, x:Array|TypedArray, stride:integer, \n  offset:integer )\n    Computes the arithmetic mean of a strided array, ignoring `NaN` values and\n    using a two-pass error correction algorithm and alternative indexing\n    semantics.\n"
base.strided.nanmeanwd,"\nbase.strided.nanmeanwd( N:integer, x:Array|TypedArray, stride:integer )\n    Computes the arithmetic mean of a strided array, ignoring `NaN` values and\n    using Welford's algorithm.\n"
base.strided.nanmeanwd.ndarray,"\nbase.strided.nanmeanwd.ndarray( N:integer, x:Array|TypedArray, stride:integer, \n  offset:integer )\n    Computes the arithmetic mean of a strided array, ignoring `NaN` values and\n    using Welford's algorithm and alternative indexing semantics.\n"
base.strided.nanmin,"\nbase.strided.nanmin( N:integer, x:Array|TypedArray, stride:integer )\n    Computes the minimum value of a strided array, ignoring `NaN` values.\n"
base.strided.nanmin.ndarray,"\nbase.strided.nanmin.ndarray( N:integer, x:Array|TypedArray, stride:integer, \n  offset:integer )\n    Computes the minimum value of a strided array, ignoring `NaN` values and\n    using alternative indexing semantics.\n"
base.strided.nanminabs,"\nbase.strided.nanminabs( N:integer, x:Array|TypedArray, stride:integer )\n    Computes the minimum absolute value of a strided array, ignoring `NaN`\n    values.\n"
base.strided.nanminabs.ndarray,"\nbase.strided.nanminabs.ndarray( N:integer, x:Array|TypedArray, stride:integer, \n  offset:integer )\n    Computes the minimum absolute value of a strided array, ignoring `NaN`\n    values and using alternative indexing semantics.\n"
base.strided.nanminBy,"\nbase.strided.nanminBy( N:integer, x:Array|TypedArray|Object, stride:integer, \n  clbk:Function[, thisArg:any] )\n    Calculates the minimum value of a strided array via a callback function,\n    ignoring `NaN` values.\n"
base.strided.nanminBy.ndarray,"\nbase.strided.nanminBy.ndarray( N:integer, x:Array|TypedArray|Object, \n  stride:integer, offset:integer, clbk:Function[, thisArg:any] )\n    Calculates the minimum value of a strided array via a callback function,\n    ignoring `NaN` values and using alternative indexing semantics.\n"
base.strided.nanmskmax,"\nbase.strided.nanmskmax( N:integer, x:Array|TypedArray, strideX:integer, \n  mask:Array|TypedArray, strideMask:integer )\n    Computes the maximum value of a strided array according to a mask and\n    ignoring `NaN` values.\n"
base.strided.nanmskmax.ndarray,"\nbase.strided.nanmskmax.ndarray( N:integer, x:Array|TypedArray, strideX:integer, \n  offsetX:integer, mask:Array|TypedArray, strideMask:integer, \n  offsetMask:integer )\n    Computes the maximum value of a strided array according to a mask,\n    ignoring `NaN` values and using alternative indexing semantics.\n"
base.strided.nanmskmin,"\nbase.strided.nanmskmin( N:integer, x:Array|TypedArray, strideX:integer, \n  mask:Array|TypedArray, strideMask:integer )\n    Computes the minimum value of a strided array according to a mask and\n    ignoring `NaN` values.\n"
base.strided.nanmskmin.ndarray,"\nbase.strided.nanmskmin.ndarray( N:integer, x:Array|TypedArray, strideX:integer, \n  offsetX:integer, mask:Array|TypedArray, strideMask:integer, \n  offsetMask:integer )\n    Computes the minimum value of a strided array according to a mask, ignoring\n    `NaN` values and using alternative indexing semantics.\n"
base.strided.nanmskrange,"\nbase.strided.nanmskrange( N:integer, x:Array|TypedArray, strideX:integer, \n  mask:Array|TypedArray, strideMask:integer )\n    Computes the range of a strided array according to a mask and ignoring `NaN`\n    values.\n"
base.strided.nanmskrange.ndarray,"\nbase.strided.nanmskrange.ndarray( N:integer, x:Array|TypedArray, \n  strideX:integer, offsetX:integer, mask:Array|TypedArray, strideMask:integer, \n  offsetMask:integer )\n    Computes the range of a strided array according to a mask, ignoring `NaN`\n    values and using alternative indexing semantics.\n"
base.strided.nanrange,"\nbase.strided.nanrange( N:integer, x:Array|TypedArray, stride:integer )\n    Computes the range of a strided array, ignoring `NaN` values.\n"
base.strided.nanrange.ndarray,"\nbase.strided.nanrange.ndarray( N:integer, x:Array|TypedArray, stride:integer, \n  offset:integer )\n    Computes the range of a strided array, ignoring `NaN` values and using\n    alternative indexing semantics.\n"
base.strided.nanrangeBy,"\nbase.strided.nanrangeBy( N:integer, x:Array|TypedArray|Object, stride:integer, \n  clbk:Function[, thisArg:any] )\n    Calculates the range of a strided array via a callback function, ignoring\n    `NaN` values.\n"
base.strided.nanrangeBy.ndarray,"\nbase.strided.nanrangeBy.ndarray( N:integer, x:Array|TypedArray|Object, \n  stride:integer, offset:integer, clbk:Function[, thisArg:any] )\n    Calculates the range of a strided array via a callback function, ignoring\n    `NaN` values and using alternative indexing semantics.\n"
base.strided.nanstdev,"\nbase.strided.nanstdev( N:integer, correction:number, x:Array|TypedArray, \n  stride:integer )\n    Computes the standard deviation of a strided array ignoring `NaN` values.\n"
base.strided.nanstdev.ndarray,"\nbase.strided.nanstdev.ndarray( N:integer, correction:number, \n  x:Array|TypedArray, stride:integer, offset:integer )\n    Computes the standard deviation of a strided array ignoring `NaN` values and\n    using alternative indexing semantics.\n"
base.strided.nanstdevch,"\nbase.strided.nanstdevch( N:integer, correction:number, x:Array|TypedArray, \n  stride:integer )\n    Computes the standard deviation of a strided array ignoring `NaN` values and\n    using a one-pass trial mean algorithm.\n"
base.strided.nanstdevch.ndarray,"\nbase.strided.nanstdevch.ndarray( N:integer, correction:number, \n  x:Array|TypedArray, stride:integer, offset:integer )\n    Computes the standard deviation of a strided array ignoring `NaN` values and\n    using a one-pass trial mean algorithm and alternative indexing semantics.\n"
base.strided.nanstdevpn,"\nbase.strided.nanstdevpn( N:integer, correction:number, x:Array|TypedArray, \n  stride:integer )\n    Computes the standard deviation of a strided array ignoring `NaN` values and\n    using a two-pass algorithm.\n"
base.strided.nanstdevpn.ndarray,"\nbase.strided.nanstdevpn.ndarray( N:integer, correction:number, \n  x:Array|TypedArray, stride:integer, offset:integer )\n    Computes the standard deviation of a strided array ignoring `NaN` values and\n    using a two-pass algorithm and alternative indexing semantics.\n"
base.strided.nanstdevtk,"\nbase.strided.nanstdevtk( N:integer, correction:number, x:Array|TypedArray, \n  stride:integer )\n    Computes the standard deviation of a strided array ignoring `NaN` values and\n    using a one-pass textbook algorithm.\n"
base.strided.nanstdevtk.ndarray,"\nbase.strided.nanstdevtk.ndarray( N:integer, correction:number, \n  x:Array|TypedArray, stride:integer, offset:integer )\n    Computes the standard deviation of a strided array ignoring `NaN` values and\n    using a one-pass textbook algorithm and alternative indexing semantics.\n"
base.strided.nanstdevwd,"\nbase.strided.nanstdevwd( N:integer, correction:number, x:Array|TypedArray, \n  stride:integer )\n    Computes the standard deviation of a strided array ignoring `NaN` values and\n    using Welford's algorithm.\n"
base.strided.nanstdevwd.ndarray,"\nbase.strided.nanstdevwd.ndarray( N:integer, correction:number, \n  x:Array|TypedArray, stride:integer, offset:integer )\n    Computes the standard deviation of a strided array ignoring `NaN` values and\n    using Welford's algorithm and alternative indexing semantics.\n"
base.strided.nanstdevyc,"\nbase.strided.nanstdevyc( N:integer, correction:number, x:Array|TypedArray, \n  stride:integer )\n    Computes the standard deviation of a strided array ignoring `NaN` values and\n    using a one-pass algorithm proposed by Youngs and Cramer.\n"
base.strided.nanstdevyc.ndarray,"\nbase.strided.nanstdevyc.ndarray( N:integer, correction:number, \n  x:Array|TypedArray, stride:integer, offset:integer )\n    Computes the standard deviation of a strided array ignoring `NaN` values and\n    using a one-pass algorithm proposed by Youngs and Cramer and alternative\n    indexing semantics.\n"
base.strided.nanvariance,"\nbase.strided.nanvariance( N:integer, correction:number, x:Array|TypedArray, \n  stride:integer )\n    Computes the variance of a strided array ignoring `NaN` values.\n"
base.strided.nanvariance.ndarray,"\nbase.strided.nanvariance.ndarray( N:integer, correction:number, \n  x:Array|TypedArray, stride:integer, offset:integer )\n    Computes the variance of a strided array ignoring `NaN` values and using\n    alternative indexing semantics.\n"
base.strided.nanvariancech,"\nbase.strided.nanvariancech( N:integer, correction:number, x:Array|TypedArray, \n  stride:integer )\n    Computes the variance of a strided array ignoring `NaN` values and using a\n    one-pass trial mean algorithm.\n"
base.strided.nanvariancech.ndarray,"\nbase.strided.nanvariancech.ndarray( N:integer, correction:number, \n  x:Array|TypedArray, stride:integer, offset:integer )\n    Computes the variance of a strided array ignoring `NaN` values and using a\n    one-pass trial mean algorithm and alternative indexing semantics.\n"
base.strided.nanvariancepn,"\nbase.strided.nanvariancepn( N:integer, correction:number, x:Array|TypedArray, \n  stride:integer )\n    Computes the variance of a strided array ignoring `NaN` values and using a\n    two-pass algorithm.\n"
base.strided.nanvariancepn.ndarray,"\nbase.strided.nanvariancepn.ndarray( N:integer, correction:number, \n  x:Array|TypedArray, stride:integer, offset:integer )\n    Computes the variance of a strided array ignoring `NaN` values and using a\n    two-pass algorithm and alternative indexing semantics.\n"
base.strided.nanvariancetk,"\nbase.strided.nanvariancetk( N:integer, correction:number, x:Array|TypedArray, \n  stride:integer )\n    Computes the variance of a strided array ignoring `NaN` values and using a\n    one-pass textbook algorithm.\n"
base.strided.nanvariancetk.ndarray,"\nbase.strided.nanvariancetk.ndarray( N:integer, correction:number, \n  x:Array|TypedArray, stride:integer, offset:integer )\n    Computes the variance of a strided array ignoring `NaN` values and using a\n    one-pass textbook algorithm and alternative indexing semantics.\n"
base.strided.nanvariancewd,"\nbase.strided.nanvariancewd( N:integer, correction:number, x:Array|TypedArray, \n  stride:integer )\n    Computes the variance of a strided array ignoring `NaN` values and using\n    Welford's algorithm.\n"
base.strided.nanvariancewd.ndarray,"\nbase.strided.nanvariancewd.ndarray( N:integer, correction:number, \n  x:Array|TypedArray, stride:integer, offset:integer )\n    Computes the variance of a strided array ignoring `NaN` values and using\n    Welford's algorithm and alternative indexing semantics.\n"
base.strided.nanvarianceyc,"\nbase.strided.nanvarianceyc( N:integer, correction:number, x:Array|TypedArray, \n  stride:integer )\n    Computes the variance of a strided array ignoring `NaN` values and using a\n    one-pass algorithm proposed by Youngs and Cramer.\n"
base.strided.nanvarianceyc.ndarray,"\nbase.strided.nanvarianceyc.ndarray( N:integer, correction:number, \n  x:Array|TypedArray, stride:integer, offset:integer )\n    Computes the variance of a strided array ignoring `NaN` values and using a\n    one-pass algorithm proposed by Youngs and Cramer and alternative indexing\n    semantics.\n"
base.strided.nullary,"\nbase.strided.nullary( arrays:ArrayLikeObject<ArrayLikeObject>, \n  shape:ArrayLikeObject<integer>, strides:ArrayLikeObject<integer>, \n  fcn:Function )\n    Applies a nullary callback and assigns results to elements in a strided\n    output array.\n"
base.strided.nullary.ndarray,"\nbase.strided.nullary.ndarray( arrays:ArrayLikeObject<ArrayLikeObject>, \n  shape:ArrayLikeObject<integer>, strides:ArrayLikeObject<integer>, \n  offsets:ArrayLikeObject<integer>, fcn:Function )\n    Applies a nullary callback and assigns results to elements in a strided\n    output array using alternative indexing semantics.\n"
base.strided.quaternary,"\nbase.strided.quaternary( arrays:ArrayLikeObject<ArrayLikeObject>, \n  shape:ArrayLikeObject<integer>, strides:ArrayLikeObject<integer>, \n  fcn:Function )\n    Applies a quaternary callback to strided input array elements and assigns\n    results to elements in a strided output array.\n"
base.strided.quaternary.ndarray,"\nbase.strided.quaternary.ndarray( arrays:ArrayLikeObject<ArrayLikeObject>, \n  shape:ArrayLikeObject<integer>, strides:ArrayLikeObject<integer>, \n  offsets:ArrayLikeObject<integer>, fcn:Function )\n    Applies a quaternary callback to strided input array elements and assigns\n    results to elements in a strided output array using alternative indexing\n    semantics.\n"
base.strided.quinary,"\nbase.strided.quinary( arrays:ArrayLikeObject<ArrayLikeObject>, \n  shape:ArrayLikeObject<integer>, strides:ArrayLikeObject<integer>, \n  fcn:Function )\n    Applies a quinary callback to strided input array elements and assigns\n    results to elements in a strided output array.\n"
base.strided.quinary.ndarray,"\nbase.strided.quinary.ndarray( arrays:ArrayLikeObject<ArrayLikeObject>, \n  shape:ArrayLikeObject<integer>, strides:ArrayLikeObject<integer>, \n  offsets:ArrayLikeObject<integer>, fcn:Function )\n    Applies a quinary callback to strided input array elements and assigns\n    results to elements in a strided output array using alternative indexing\n    semantics.\n"
base.strided.range,"\nbase.strided.range( N:integer, x:Array|TypedArray, stride:integer )\n    Computes the range of a strided array.\n"
base.strided.range.ndarray,"\nbase.strided.range.ndarray( N:integer, x:Array|TypedArray, stride:integer, \n  offset:integer )\n    Computes the range of a strided array using alternative indexing semantics.\n"
base.strided.rangeBy,"\nbase.strided.rangeBy( N:integer, x:Array|TypedArray|Object, stride:integer, \n  clbk:Function[, thisArg:any] )\n    Calculates the range of a strided array via a callback function.\n"
base.strided.rangeBy.ndarray,"\nbase.strided.rangeBy.ndarray( N:integer, x:Array|TypedArray|Object, \n  stride:integer, offset:integer, clbk:Function[, thisArg:any] )\n    Calculates the range of a strided array via a callback function and using\n    alternative indexing semantics.\n"
base.strided.sapx,"\nbase.strided.sapx( N:integer, alpha:number, x:Float32Array, stride:integer )\n    Adds a constant to each element in a single-precision floating-point strided\n    array.\n"
base.strided.sapx.ndarray,"\nbase.strided.sapx.ndarray( N:integer, alpha:number, x:Float32Array, \n  stride:integer, offset:integer )\n    Adds a constant to each element in a single-precision floating-point strided\n    array using alternative indexing semantics.\n"
base.strided.sapxsum,"\nbase.strided.sapxsum( N:integer, alpha:number, x:Float32Array, stride:integer )\n    Adds a constant to each single-precision floating-point strided array\n    element and computes the sum.\n"
base.strided.sapxsum.ndarray,"\nbase.strided.sapxsum.ndarray( N:integer, alpha:number, x:Float32Array, \n  stride:integer, offset:integer )\n    Adds a constant to each single-precision floating-point strided array\n    element and computes the sum using alternative indexing semantics.\n"
base.strided.sapxsumkbn,"\nbase.strided.sapxsumkbn( N:integer, alpha:number, x:Float32Array, \n  stride:integer )\n    Adds a constant to each single-precision floating-point strided array\n    element and computes the sum using an improved Kahan–Babuška algorithm.\n"
base.strided.sapxsumkbn.ndarray,"\nbase.strided.sapxsumkbn.ndarray( N:integer, alpha:number, x:Float32Array, \n  stride:integer, offset:integer )\n    Adds a constant to each single-precision floating-point strided array\n    element and computes the sum using an improved Kahan–Babuška algorithm and\n    alternative indexing semantics.\n"
base.strided.sapxsumkbn2,"\nbase.strided.sapxsumkbn2( N:integer, alpha:number, x:Float32Array, \n  stride:integer )\n    Adds a constant to each single-precision floating-point strided array\n    element and computes the sum using a second-order iterative Kahan–Babuška\n    algorithm.\n"
base.strided.sapxsumkbn2.ndarray,"\nbase.strided.sapxsumkbn2.ndarray( N:integer, alpha:number, x:Float32Array, \n  stride:integer, offset:integer )\n    Adds a constant to each single-precision floating-point strided array\n    element and computes the sum using a second-order iterative Kahan–Babuška\n    algorithm and alternative indexing semantics.\n"
base.strided.sapxsumors,"\nbase.strided.sapxsumors( N:integer, alpha:number, x:Float32Array, \n  stride:integer )\n    Adds a constant to each single-precision floating-point strided array\n    element and computes the sum using ordinary recursive summation.\n"
base.strided.sapxsumors.ndarray,"\nbase.strided.sapxsumors.ndarray( N:integer, alpha:number, x:Float32Array, \n  stride:integer, offset:integer )\n    Adds a constant to each single-precision floating-point strided array\n    element and computes the sum using ordinary recursive summation and\n    alternative indexing semantics.\n"
base.strided.sapxsumpw,"\nbase.strided.sapxsumpw( N:integer, alpha:number, x:Float32Array, \n  stride:integer )\n    Adds a constant to each single-precision floating-point strided array\n    element and computes the sum using pairwise summation.\n"
base.strided.sapxsumpw.ndarray,"\nbase.strided.sapxsumpw.ndarray( N:integer, alpha:number, x:Float32Array, \n  stride:integer, offset:integer )\n    Adds a constant to each single-precision floating-point strided array\n    element and computes the sum using pairwise summation and alternative\n    indexing semantics.\n"
base.strided.sasum,"\nbase.strided.sasum( N:integer, x:Float32Array, stride:integer )\n    Computes the sum of the absolute values.\n"
base.strided.sasum.ndarray,"\nbase.strided.sasum.ndarray( N:integer, x:Float32Array, stride:integer, \n  offset:integer )\n    Computes the sum of absolute values using alternative indexing semantics.\n"
base.strided.sasumpw,"\nbase.strided.sasumpw( N:integer, x:Float32Array, stride:integer )\n    Computes the sum of absolute values (L1 norm) of single-precision floating-\n    point strided array elements using pairwise summation.\n"
base.strided.sasumpw.ndarray,"\nbase.strided.sasumpw.ndarray( N:integer, x:Float32Array, stride:integer, \n  offset:integer )\n    Computes the sum of absolute values (L1 norm) of single-precision floating-\n    point strided array elements using pairwise summation and alternative\n    indexing semantics.\n"
base.strided.saxpy,"\nbase.strided.saxpy( N:integer, alpha:number, x:Float32Array, strideX:integer, \n  y:Float32Array, strideY:integer )\n    Multiplies a vector `x` by a constant `alpha` and adds the result to `y`.\n"
base.strided.saxpy.ndarray,"\nbase.strided.saxpy.ndarray( N:integer, alpha:number, x:Float32Array, \n  strideX:integer, offsetX:integer, y:Float32Array, strideY:integer, \n  offsetY:integer )\n    Multiplies a vector `x` by a constant `alpha` and adds the result to `y`,\n    using alternative indexing semantics.\n"
base.strided.scopy,"\nbase.strided.scopy( N:integer, x:Float32Array, strideX:integer, y:Float32Array, \n  strideY:integer )\n    Copies values from `x` into `y`.\n"
base.strided.scopy.ndarray,"\nbase.strided.scopy.ndarray( N:integer, x:Float32Array, strideX:integer, \n  offsetX:integer, y:Float32Array, strideY:integer, offsetY:integer )\n    Copies values from `x` into `y` using alternative indexing semantics.\n"
base.strided.scumax,"\nbase.strided.scumax( N:integer, x:Float32Array, strideX:integer, \n  y:Float32Array, strideY:integer )\n    Computes the cumulative maximum of single-precision floating-point strided\n    array elements.\n"
base.strided.scumax.ndarray,"\nbase.strided.scumax.ndarray( N:integer, x:Float32Array, strideX:integer, \n  offsetX:integer, y:Float32Array, strideY:integer, offsetY:integer )\n    Computes the cumulative maximum of single-precision floating-point strided\n    array elements using alternative indexing semantics.\n"
base.strided.scumaxabs,"\nbase.strided.scumaxabs( N:integer, x:Float32Array, strideX:integer, \n  y:Float32Array, strideY:integer )\n    Computes the cumulative maximum absolute value of single-precision floating-\n    point strided array elements.\n"
base.strided.scumaxabs.ndarray,"\nbase.strided.scumaxabs.ndarray( N:integer, x:Float32Array, strideX:integer, \n  offsetX:integer, y:Float32Array, strideY:integer, offsetY:integer )\n    Computes the cumulative maximum absolute value of single-precision floating-\n    point strided array elements using alternative indexing semantics.\n"
base.strided.scumin,"\nbase.strided.scumin( N:integer, x:Float32Array, strideX:integer, \n  y:Float32Array, strideY:integer )\n    Computes the cumulative minimum of single-precision floating-point strided\n    array elements.\n"
base.strided.scumin.ndarray,"\nbase.strided.scumin.ndarray( N:integer, x:Float32Array, strideX:integer, \n  offsetX:integer, y:Float32Array, strideY:integer, offsetY:integer )\n    Computes the cumulative minimum of single-precision floating-point strided\n    array elements using alternative indexing semantics.\n"
base.strided.scuminabs,"\nbase.strided.scuminabs( N:integer, x:Float32Array, strideX:integer, \n  y:Float32Array, strideY:integer )\n    Computes the cumulative minimum absolute value of single-precision floating-\n    point strided array elements.\n"
base.strided.scuminabs.ndarray,"\nbase.strided.scuminabs.ndarray( N:integer, x:Float32Array, strideX:integer, \n  offsetX:integer, y:Float32Array, strideY:integer, offsetY:integer )\n    Computes the cumulative minimum absolute value of single-precision floating-\n    point strided array elements using alternative indexing semantics.\n"
base.strided.scusum,"\nbase.strided.scusum( N:integer, sum:number, x:Float32Array, strideX:integer, \n  y:Float32Array, strideY:integer )\n    Computes the cumulative sum of single-precision floating-point strided array\n    elements.\n"
base.strided.scusum.ndarray,"\nbase.strided.scusum.ndarray( N:integer, sum:number, x:Float32Array, \n  strideX:integer, offsetX:integer, y:Float32Array, strideY:integer, \n  offsetY:integer )\n    Computes the cumulative sum of single-precision floating-point strided array\n    elements using alternative indexing semantics.\n"
base.strided.scusumkbn,"\nbase.strided.scusumkbn( N:integer, sum:number, x:Float32Array, strideX:integer, \n  y:Float32Array, strideY:integer )\n    Computes the cumulative sum of single-precision floating-point strided array\n    elements using an improved Kahan–Babuška algorithm.\n"
base.strided.scusumkbn.ndarray,"\nbase.strided.scusumkbn.ndarray( N:integer, sum:number, x:Float32Array, \n  strideX:integer, offsetX:integer, y:Float32Array, strideY:integer, \n  offsetY:integer )\n    Computes the cumulative sum of single-precision floating-point strided array\n    elements using an improved Kahan–Babuška algorithm and alternative indexing\n    semantics.\n"
base.strided.scusumkbn2,"\nbase.strided.scusumkbn2( N:integer, sum:number, x:Float32Array, \n  strideX:integer, y:Float32Array, strideY:integer )\n    Computes the cumulative sum of single-precision floating-point strided array\n    elements using a second-order iterative Kahan–Babuška algorithm.\n"
base.strided.scusumkbn2.ndarray,"\nbase.strided.scusumkbn2.ndarray( N:integer, sum:number, x:Float32Array, \n  strideX:integer, offsetX:integer, y:Float32Array, strideY:integer, \n  offsetY:integer )\n    Computes the cumulative sum of single-precision floating-point strided array\n    elements using a second-order iterative Kahan–Babuška algorithm and\n    alternative indexing semantics.\n"
base.strided.scusumors,"\nbase.strided.scusumors( N:integer, sum:number, x:Float32Array, strideX:integer, \n  y:Float32Array, strideY:integer )\n    Computes the cumulative sum of single-precision floating-point strided array\n    elements using ordinary recursive summation.\n"
base.strided.scusumors.ndarray,"\nbase.strided.scusumors.ndarray( N:integer, sum:number, x:Float32Array, \n  strideX:integer, offsetX:integer, y:Float32Array, strideY:integer, \n  offsetY:integer )\n    Computes the cumulative sum of single-precision floating-point strided array\n    elements using ordinary recursive summation and alternative indexing\n    semantics.\n"
base.strided.scusumpw,"\nbase.strided.scusumpw( N:integer, sum:number, x:Float32Array, strideX:integer, \n  y:Float32Array, strideY:integer )\n    Computes the cumulative sum of single-precision floating-point strided array\n    elements using pairwise summation.\n"
base.strided.scusumpw.ndarray,"\nbase.strided.scusumpw.ndarray( N:integer, sum:number, x:Float32Array, \n  strideX:integer, offsetX:integer, y:Float32Array, strideY:integer, \n  offsetY:integer )\n    Computes the cumulative sum of single-precision floating-point strided array\n    elements using pairwise summation and alternative indexing semantics.\n"
base.strided.sdot,"\nbase.strided.sdot( N:integer, x:Float32Array, strideX:integer, y:Float32Array, \n  strideY:integer )\n    Computes the dot product of two single-precision floating-point vectors.\n"
base.strided.sdot.ndarray,"\nbase.strided.sdot.ndarray( N:integer, x:Float32Array, strideX:integer, \n  offsetX:integer, y:Float32Array, strideY:integer, offsetY:integer )\n    Computes the dot product of two single-precision floating-point vectors\n    using alternative indexing semantics.\n"
base.strided.sdsapxsum,"\nbase.strided.sdsapxsum( N:integer, alpha:number, x:Float32Array, \n  stride:integer )\n    Adds a constant to each single-precision floating-point strided array\n    element and computes the sum using extended accumulation.\n"
base.strided.sdsapxsum.ndarray,"\nbase.strided.sdsapxsum.ndarray( N:integer, alpha:number, x:Float32Array, \n  stride:integer, offset:integer )\n    Adds a constant to each single-precision floating-point strided array\n    element and computes the sum using extended accumulation and alternative\n    indexing semantics.\n"
base.strided.sdsapxsumpw,"\nbase.strided.sdsapxsumpw( N:integer, alpha:number, x:Float32Array, \n  stride:integer )\n    Adds a constant to each single-precision floating-point strided array\n    element and computes the sum using pairwise summation with extended\n    accumulation.\n"
base.strided.sdsapxsumpw.ndarray,"\nbase.strided.sdsapxsumpw.ndarray( N:integer, alpha:number, x:Float32Array, \n  stride:integer, offset:integer )\n    Adds a constant to each single-precision floating-point strided array\n    element and computes the sum using pairwise summation with extended\n    accumulation and alternative indexing semantics.\n"
base.strided.sdsdot,"\nbase.strided.sdsdot( N:integer, scalar:number, x:Float32Array, strideX:integer, \n  y:Float32Array, strideY:integer )\n    Computes the dot product of two single-precision floating-point vectors with\n    extended accumulation.\n"
base.strided.sdsdot.ndarray,"\nbase.strided.sdsdot.ndarray( N:integer, scalar:number, x:Float32Array, \n  strideX:integer, offsetX:integer, y:Float32Array, strideY:integer, \n  offsetY:integer )\n    Computes the dot product of two single-precision floating-point vectors\n    using alternative indexing semantics and with extended accumulation.\n"
base.strided.sdsmean,"\nbase.strided.sdsmean( N:integer, x:Float32Array, stride:integer )\n    Computes the arithmetic mean of a single-precision floating-point strided\n    array using extended accumulation.\n"
base.strided.sdsmean.ndarray,"\nbase.strided.sdsmean.ndarray( N:integer, x:Float32Array, stride:integer, \n  offset:integer )\n    Computes the arithmetic mean of a single-precision floating-point strided\n    array using extended accumulation and alternative indexing semantics.\n"
base.strided.sdsmeanors,"\nbase.strided.sdsmeanors( N:integer, x:Float32Array, stride:integer )\n    Computes the arithmetic mean of a single-precision floating-point strided\n    array using ordinary recursive summation with extended accumulation.\n"
base.strided.sdsmeanors.ndarray,"\nbase.strided.sdsmeanors.ndarray( N:integer, x:Float32Array, stride:integer, \n  offset:integer )\n    Computes the arithmetic mean of a single-precision floating-point strided\n    array using ordinary recursive summation with extended accumulation and\n    alternative indexing semantics.\n"
base.strided.sdsnanmean,"\nbase.strided.sdsnanmean( N:integer, x:Float32Array, stride:integer )\n    Computes the arithmetic mean of a single-precision floating-point strided\n    array, ignoring `NaN` values and using extended accumulation.\n"
base.strided.sdsnanmean.ndarray,"\nbase.strided.sdsnanmean.ndarray( N:integer, x:Float32Array, stride:integer, \n  offset:integer )\n    Computes the arithmetic mean of a single-precision floating-point strided\n    array, ignoring `NaN` values and using extended accumulation and alternative\n    indexing semantics.\n"
base.strided.sdsnanmeanors,"\nbase.strided.sdsnanmeanors( N:integer, x:Float32Array, stride:integer )\n    Computes the arithmetic mean of a single-precision floating-point strided\n    array, ignoring `NaN` values and using ordinary recursive summation with\n    extended accumulation.\n"
base.strided.sdsnanmeanors.ndarray,"\nbase.strided.sdsnanmeanors.ndarray( N:integer, x:Float32Array, stride:integer, \n  offset:integer )\n    Computes the arithmetic mean of a single-precision floating-point strided\n    array, ignoring `NaN` values and using ordinary recursive summation with\n    extended accumulation and alternative indexing semantics.\n"
base.strided.sdsnansum,"\nbase.strided.sdsnansum( N:integer, x:Float32Array, stride:integer )\n    Computes the sum of single-precision floating-point strided array elements,\n    ignoring `NaN` values and using extended accumulation.\n"
base.strided.sdsnansum.ndarray,"\nbase.strided.sdsnansum.ndarray( N:integer, x:Float32Array, stride:integer, \n  offset:integer )\n    Computes the sum of single-precision floating-point strided array elements,\n    ignoring `NaN` values and using extended accumulation and alternative\n    indexing semantics.\n"
base.strided.sdsnansumpw,"\nbase.strided.sdsnansumpw( N:integer, x:Float32Array, stride:integer )\n    Computes the sum of single-precision floating-point strided array elements,\n    ignoring `NaN` values and using pairwise summation with extended\n    accumulation.\n"
base.strided.sdsnansumpw.ndarray,"\nbase.strided.sdsnansumpw.ndarray( N:integer, x:Float32Array, stride:integer, \n  offset:integer )\n    Computes the sum of single-precision floating-point strided array elements,\n    ignoring `NaN` values and using pairwise summation with extended\n    accumulation and alternative indexing semantics.\n"
base.strided.sdssum,"\nbase.strided.sdssum( N:integer, x:Float32Array, stride:integer )\n    Computes the sum of single-precision floating-point strided array elements\n    using extended accumulation.\n"
base.strided.sdssum.ndarray,"\nbase.strided.sdssum.ndarray( N:integer, x:Float32Array, stride:integer, \n  offset:integer )\n    Computes the sum of single-precision floating-point strided array elements\n    using extended accumulation and alternative indexing semantics.\n"
base.strided.sdssumpw,"\nbase.strided.sdssumpw( N:integer, x:Float32Array, stride:integer )\n    Computes the sum of single-precision floating-point strided array elements\n    using pairwise summation with extended accumulation.\n"
base.strided.sdssumpw.ndarray,"\nbase.strided.sdssumpw.ndarray( N:integer, x:Float32Array, stride:integer, \n  offset:integer )\n    Computes the sum of single-precision floating-point strided array elements\n    using pairwise summation with extended accumulation and alternative indexing\n    semantics.\n"
base.strided.sfill,"\nbase.strided.sfill( N:integer, alpha:number, x:Float32Array, stride:integer )\n    Fills a single-precision floating-point strided array with a specified\n    scalar value.\n"
base.strided.sfill.ndarray,"\nbase.strided.sfill.ndarray( N:integer, alpha:number, x:Float32Array, \n  stride:integer, offset:integer )\n    Fills a single-precision floating-point strided array with a specified\n    scalar value using alternative indexing semantics.\n"
base.strided.smap,"\nbase.strided.smap( N:integer, x:Float32Array, strideX:integer, y:Float32Array, \n  strideY:integer, fcn:Function )\n    Applies a unary function accepting and returning single-precision floating-\n    point numbers to each element in a single-precision floating-point strided\n    input array and assigns each result to an element in a single-precision\n    floating-point strided output array.\n"
base.strided.smap.ndarray,"\nbase.strided.smap.ndarray( N:integer, x:Float32Array, strideX:integer, \n  offsetX:integer, y:Float32Array, strideY:integer, offsetY:integer, \n  fcn:Function )\n    Applies a unary function accepting and returning single-precision floating-\n    point numbers to each element in a single-precision floating-point strided\n    input array and assigns each result to an element in a single-precision\n    floating-point strided output array using alternative indexing semantics.\n"
base.strided.smax,"\nbase.strided.smax( N:integer, x:Float32Array, stride:integer )\n    Computes the maximum value of a single-precision floating-point strided\n    array.\n"
base.strided.smax.ndarray,"\nbase.strided.smax.ndarray( N:integer, x:Float32Array, stride:integer, \n  offset:integer )\n    Computes the maximum value of a single-precision floating-point strided\n    array using alternative indexing semantics.\n"
base.strided.smaxabs,"\nbase.strided.smaxabs( N:integer, x:Float32Array, stride:integer )\n    Computes the maximum absolute value of a single-precision floating-point\n    strided array.\n"
base.strided.smaxabs.ndarray,"\nbase.strided.smaxabs.ndarray( N:integer, x:Float32Array, stride:integer, \n  offset:integer )\n    Computes the maximum absolute value of a single-precision floating-point\n    strided array using alternative indexing semantics.\n"
base.strided.smaxabssorted,"\nbase.strided.smaxabssorted( N:integer, x:Float32Array, stride:integer )\n    Computes the maximum absolute value of a sorted single-precision floating-\n    point strided array.\n"
base.strided.smaxabssorted.ndarray,"\nbase.strided.smaxabssorted.ndarray( N:integer, x:Float32Array, stride:integer, \n  offset:integer )\n    Computes the maximum absolute value of a sorted single-precision floating-\n    point strided array using alternative indexing semantics.\n"
base.strided.smaxsorted,"\nbase.strided.smaxsorted( N:integer, x:Float32Array, stride:integer )\n    Computes the maximum value of a sorted single-precision floating-point\n    strided array.\n"
base.strided.smaxsorted.ndarray,"\nbase.strided.smaxsorted.ndarray( N:integer, x:Float32Array, stride:integer, \n  offset:integer )\n    Computes the maximum value of a sorted single-precision floating-point\n    strided array using alternative indexing semantics.\n"
base.strided.smean,"\nbase.strided.smean( N:integer, x:Float32Array, stride:integer )\n    Computes the arithmetic mean of a single-precision floating-point strided\n    array.\n"
base.strided.smean.ndarray,"\nbase.strided.smean.ndarray( N:integer, x:Float32Array, stride:integer, \n  offset:integer )\n    Computes the arithmetic mean of a single-precision floating-point strided\n    array using alternative indexing semantics.\n"
base.strided.smeankbn,"\nbase.strided.smeankbn( N:integer, x:Float32Array, stride:integer )\n    Computes the arithmetic mean of a single-precision floating-point strided\n    array using an improved Kahan–Babuška algorithm.\n"
base.strided.smeankbn.ndarray,"\nbase.strided.smeankbn.ndarray( N:integer, x:Float32Array, stride:integer, \n  offset:integer )\n    Computes the arithmetic mean of a single-precision floating-point strided\n    array using an improved Kahan–Babuška algorithm and alternative indexing\n    semantics.\n"
base.strided.smeankbn2,"\nbase.strided.smeankbn2( N:integer, x:Float32Array, stride:integer )\n    Computes the arithmetic mean of a single-precision floating-point strided\n    array using a second-order iterative Kahan–Babuška algorithm.\n"
base.strided.smeankbn2.ndarray,"\nbase.strided.smeankbn2.ndarray( N:integer, x:Float32Array, stride:integer, \n  offset:integer )\n    Computes the arithmetic mean of a single-precision floating-point strided\n    array using a second-order iterative Kahan–Babuška algorithm and alternative\n    indexing semantics.\n"
base.strided.smeanli,"\nbase.strided.smeanli( N:integer, x:Float32Array, stride:integer )\n    Computes the arithmetic mean of a single-precision floating-point strided\n    array using a one-pass trial mean algorithm.\n"
base.strided.smeanli.ndarray,"\nbase.strided.smeanli.ndarray( N:integer, x:Float32Array, stride:integer, \n  offset:integer )\n    Computes the arithmetic mean of a single-precision floating-point strided\n    array using a one-pass trial mean algorithm and alternative indexing\n    semantics.\n"
base.strided.smeanlipw,"\nbase.strided.smeanlipw( N:integer, x:Float32Array, stride:integer )\n    Computes the arithmetic mean of a single-precision floating-point strided\n    array using a one-pass trial mean algorithm with pairwise summation.\n"
base.strided.smeanlipw.ndarray,"\nbase.strided.smeanlipw.ndarray( N:integer, x:Float32Array, stride:integer, \n  offset:integer )\n    Computes the arithmetic mean of a single-precision floating-point strided\n    array using a one-pass trial mean algorithm with pairwise summation and\n    alternative indexing semantics.\n"
base.strided.smeanors,"\nbase.strided.smeanors( N:integer, x:Float32Array, stride:integer )\n    Computes the arithmetic mean of a single-precision floating-point strided\n    array using ordinary recursive summation.\n"
base.strided.smeanors.ndarray,"\nbase.strided.smeanors.ndarray( N:integer, x:Float32Array, stride:integer, \n  offset:integer )\n    Computes the arithmetic mean of a single-precision floating-point strided\n    array using ordinary recursive summation and alternative indexing semantics.\n"
base.strided.smeanpn,"\nbase.strided.smeanpn( N:integer, x:Float32Array, stride:integer )\n    Computes the arithmetic mean of a single-precision floating-point strided\n    array using a two-pass error correction algorithm.\n"
base.strided.smeanpn.ndarray,"\nbase.strided.smeanpn.ndarray( N:integer, x:Float32Array, stride:integer, \n  offset:integer )\n    Computes the arithmetic mean of a single-precision floating-point strided\n    array using a two-pass error correction algorithm and alternative indexing\n    semantics.\n"
base.strided.smeanpw,"\nbase.strided.smeanpw( N:integer, x:Float32Array, stride:integer )\n    Computes the arithmetic mean of a single-precision floating-point strided\n    array using pairwise summation.\n"
base.strided.smeanpw.ndarray,"\nbase.strided.smeanpw.ndarray( N:integer, x:Float32Array, stride:integer, \n  offset:integer )\n    Computes the arithmetic mean of a single-precision floating-point strided\n    array using pairwise summation and alternative indexing semantics.\n"
base.strided.smeanwd,"\nbase.strided.smeanwd( N:integer, x:Float32Array, stride:integer )\n    Computes the arithmetic mean of a single-precision floating-point strided\n    array using Welford's algorithm.\n"
base.strided.smeanwd.ndarray,"\nbase.strided.smeanwd.ndarray( N:integer, x:Float32Array, stride:integer, \n  offset:integer )\n    Computes the arithmetic mean of a single-precision floating-point strided\n    array using Welford's algorithm and alternative indexing semantics.\n"
base.strided.smediansorted,"\nbase.strided.smediansorted( N:integer, x:Float32Array, stride:integer )\n    Computes the median value of a sorted single-precision floating-point\n    strided array.\n"
base.strided.smediansorted.ndarray,"\nbase.strided.smediansorted.ndarray( N:integer, x:Float32Array, stride:integer, \n  offset:integer )\n    Computes the median value of a sorted single-precision floating-point\n    strided array using alternative indexing semantics.\n"
base.strided.smidrange,"\nbase.strided.smidrange( N:integer, x:Float32Array, stride:integer )\n    Computes the mid-range of a single-precision floating-point strided array.\n"
base.strided.smidrange.ndarray,"\nbase.strided.smidrange.ndarray( N:integer, x:Float32Array, stride:integer, \n  offset:integer )\n    Computes the mid-range of a single-precision floating-point strided array\n    using alternative indexing semantics.\n"
base.strided.smin,"\nbase.strided.smin( N:integer, x:Float32Array, stride:integer )\n    Computes the minimum value of a single-precision floating-point strided\n    array.\n"
base.strided.smin.ndarray,"\nbase.strided.smin.ndarray( N:integer, x:Float32Array, stride:integer, \n  offset:integer )\n    Computes the minimum value of a single-precision floating-point strided\n    array using alternative indexing semantics.\n"
base.strided.sminabs,"\nbase.strided.sminabs( N:integer, x:Float32Array, stride:integer )\n    Computes the minimum absolute value of a single-precision floating-point\n    strided array.\n"
base.strided.sminabs.ndarray,"\nbase.strided.sminabs.ndarray( N:integer, x:Float32Array, stride:integer, \n  offset:integer )\n    Computes the minimum absolute value of a single-precision floating-point\n    strided array using alternative indexing semantics.\n"
base.strided.sminsorted,"\nbase.strided.sminsorted( N:integer, x:Float32Array, stride:integer )\n    Computes the minimum value of a sorted single-precision floating-point\n    strided array.\n"
base.strided.sminsorted.ndarray,"\nbase.strided.sminsorted.ndarray( N:integer, x:Float32Array, stride:integer, \n  offset:integer )\n    Computes the minimum value of a sorted single-precision floating-point\n    strided array using alternative indexing semantics.\n"
base.strided.smskmap,"\nbase.strided.smskmap( N:integer, x:Float32Array, sx:integer, m:Uint8Array, \n  sm:integer, y:Float32Array, sy:integer, fcn:Function )\n    Applies a unary function accepting and returning single-precision floating-\n    point numbers to each element in a single-precision floating-point strided\n    input array according to a corresponding element in a strided mask array and\n    assigns each result to an element in a single-precision floating-point\n    strided output array.\n"
base.strided.smskmap.ndarray,"\nbase.strided.smskmap.ndarray( N:integer, x:Float32Array, sx:integer, \n  ox:integer, m:Uint8Array, sm:integer, om:integer, y:Float32Array, sy:integer, \n  oy:integer, fcn:Function )\n    Applies a unary function accepting and returning single-precision floating-\n    point numbers to each element in a single-precision floating-point strided\n    input array according to a corresponding element in a strided mask array and\n    assigns each result to an element in a single-precision floating-point\n    strided output array using alternative indexing semantics.\n"
base.strided.smskmax,"\nbase.strided.smskmax( N:integer, x:Float32Array, strideX:integer, \n  mask:Uint8Array, strideMask:integer )\n    Computes the maximum value of a single-precision floating-point strided\n    array according to a mask.\n"
base.strided.smskmax.ndarray,"\nbase.strided.smskmax.ndarray( N:integer, x:Float32Array, strideX:integer, \n  offsetX:integer, mask:Uint8Array, strideMask:integer, offsetMask:integer )\n    Computes the maximum value of a single-precision floating-point strided\n    array according to a mask and using alternative indexing semantics.\n"
base.strided.smskmin,"\nbase.strided.smskmin( N:integer, x:Float32Array, strideX:integer, \n  mask:Uint8Array, strideMask:integer )\n    Computes the minimum value of a single-precision floating-point strided\n    array according to a mask.\n"
base.strided.smskmin.ndarray,"\nbase.strided.smskmin.ndarray( N:integer, x:Float32Array, strideX:integer, \n  offsetX:integer, mask:Uint8Array, strideMask:integer, offsetMask:integer )\n    Computes the minimum value of a single-precision floating-point strided\n    array according to a mask and using alternative indexing semantics.\n"
base.strided.smskrange,"\nbase.strided.smskrange( N:integer, x:Float32Array, strideX:integer, \n  mask:Uint8Array, strideMask:integer )\n    Computes the range of a single-precision floating-point strided array\n    according to a mask.\n"
base.strided.smskrange.ndarray,"\nbase.strided.smskrange.ndarray( N:integer, x:Float32Array, strideX:integer, \n  offsetX:integer, mask:Uint8Array, strideMask:integer, offsetMask:integer )\n    Computes the range of a single-precision floating-point strided array\n    according to a mask and using alternative indexing semantics.\n"
base.strided.snanmax,"\nbase.strided.snanmax( N:integer, x:Float32Array, stride:integer )\n    Computes the maximum value of a single-precision floating-point strided\n    array, ignoring `NaN` values.\n"
base.strided.snanmax.ndarray,"\nbase.strided.snanmax.ndarray( N:integer, x:Float32Array, stride:integer, \n  offset:integer )\n    Computes the maximum value of a single-precision floating-point strided\n    array, ignoring `NaN` values and using alternative indexing semantics.\n"
base.strided.snanmaxabs,"\nbase.strided.snanmaxabs( N:integer, x:Float32Array, stride:integer )\n    Computes the maximum absolute value of a single-precision floating-point\n    strided array, ignoring `NaN` values.\n"
base.strided.snanmaxabs.ndarray,"\nbase.strided.snanmaxabs.ndarray( N:integer, x:Float32Array, stride:integer, \n  offset:integer )\n    Computes the maximum absolute value of a single-precision floating-point\n    strided array, ignoring `NaN` values and using alternative indexing\n    semantics.\n"
base.strided.snanmean,"\nbase.strided.snanmean( N:integer, x:Float32Array, stride:integer )\n    Computes the arithmetic mean of a single-precision floating-point strided\n    array, ignoring `NaN` values.\n"
base.strided.snanmean.ndarray,"\nbase.strided.snanmean.ndarray( N:integer, x:Float32Array, stride:integer, \n  offset:integer )\n    Computes the arithmetic mean of a single-precision floating-point strided\n    array, ignoring `NaN` values and using alternative indexing semantics.\n"
base.strided.snanmeanors,"\nbase.strided.snanmeanors( N:integer, x:Float32Array, stride:integer )\n    Computes the arithmetic mean of a single-precision floating-point strided\n    array, ignoring `NaN` values and using ordinary recursive summation.\n"
base.strided.snanmeanors.ndarray,"\nbase.strided.snanmeanors.ndarray( N:integer, x:Float32Array, stride:integer, \n  offset:integer )\n    Computes the arithmetic mean of a single-precision floating-point strided\n    array, ignoring `NaN` values and using ordinary recursive summation and\n    alternative indexing semantics.\n"
base.strided.snanmeanpn,"\nbase.strided.snanmeanpn( N:integer, x:Float32Array, stride:integer )\n    Computes the arithmetic mean of a single-precision floating-point strided\n    array, ignoring `NaN` values and using a two-pass error correction\n    algorithm.\n"
base.strided.snanmeanpn.ndarray,"\nbase.strided.snanmeanpn.ndarray( N:integer, x:Float32Array, stride:integer, \n  offset:integer )\n    Computes the arithmetic mean of a single-precision floating-point strided\n    array, ignoring `NaN` values and using a two-pass error correction algorithm\n    and alternative indexing semantics.\n"
base.strided.snanmeanwd,"\nbase.strided.snanmeanwd( N:integer, x:Float32Array, stride:integer )\n    Computes the arithmetic mean of a single-precision floating-point strided\n    array, ignoring `NaN` values and using Welford's algorithm.\n"
base.strided.snanmeanwd.ndarray,"\nbase.strided.snanmeanwd.ndarray( N:integer, x:Float32Array, stride:integer, \n  offset:integer )\n    Computes the arithmetic mean of a single-precision floating-point strided\n    array, ignoring `NaN` values and using Welford's algorithm and alternative\n    indexing semantics.\n"
base.strided.snanmin,"\nbase.strided.snanmin( N:integer, x:Float32Array, stride:integer )\n    Computes the minimum value of a single-precision floating-point strided\n    array, ignoring `NaN` values.\n"
base.strided.snanmin.ndarray,"\nbase.strided.snanmin.ndarray( N:integer, x:Float32Array, stride:integer, \n  offset:integer )\n    Computes the minimum value of a single-precision floating-point strided\n    array, ignoring `NaN` values and using alternative indexing semantics.\n"
base.strided.snanminabs,"\nbase.strided.snanminabs( N:integer, x:Float32Array, stride:integer )\n    Computes the minimum absolute value of a single-precision floating-point\n    strided array, ignoring `NaN` values.\n"
base.strided.snanminabs.ndarray,"\nbase.strided.snanminabs.ndarray( N:integer, x:Float32Array, stride:integer, \n  offset:integer )\n    Computes the minimum absolute value of a single-precision floating-point\n    strided array, ignoring `NaN` values and using alternative indexing\n    semantics.\n"
base.strided.snanmskmax,"\nbase.strided.snanmskmax( N:integer, x:Float32Array, strideX:integer, \n  mask:Uint8Array, strideMask:integer )\n    Computes the maximum value of a single-precision floating-point strided\n    array according to a mask, ignoring `NaN` values.\n"
base.strided.snanmskmax.ndarray,"\nbase.strided.snanmskmax.ndarray( N:integer, x:Float32Array, strideX:integer, \n  offsetX:integer, mask:Uint8Array, strideMask:integer, offsetMask:integer )\n    Computes the maximum value of a single-precision floating-point strided\n    array according to a mask, ignoring `NaN` values and using alternative\n    indexing semantics.\n"
base.strided.snanmskmin,"\nbase.strided.snanmskmin( N:integer, x:Float32Array, strideX:integer, \n  mask:Uint8Array, strideMask:integer )\n    Computes the minimum value of a single-precision floating-point strided\n    array according to a mask, ignoring `NaN` values.\n"
base.strided.snanmskmin.ndarray,"\nbase.strided.snanmskmin.ndarray( N:integer, x:Float32Array, strideX:integer, \n  offsetX:integer, mask:Uint8Array, strideMask:integer, offsetMask:integer )\n    Computes the minimum value of a single-precision floating-point strided\n    array according to a mask, ignoring `NaN` values and using alternative\n    indexing semantics.\n"
base.strided.snanmskrange,"\nbase.strided.snanmskrange( N:integer, x:Float32Array, strideX:integer, \n  mask:Uint8Array, strideMask:integer )\n    Computes the range of a single-precision floating-point strided array\n    according to a mask, ignoring `NaN` values.\n"
base.strided.snanmskrange.ndarray,"\nbase.strided.snanmskrange.ndarray( N:integer, x:Float32Array, strideX:integer, \n  offsetX:integer, mask:Uint8Array, strideMask:integer, offsetMask:integer )\n    Computes the range of a single-precision floating-point strided array\n    according to a mask, ignoring `NaN` values and using alternative indexing\n    semantics.\n"
base.strided.snanrange,"\nbase.strided.snanrange( N:integer, x:Float32Array, stride:integer )\n    Computes the range of a single-precision floating-point strided array,\n    ignoring `NaN` values.\n"
base.strided.snanrange.ndarray,"\nbase.strided.snanrange.ndarray( N:integer, x:Float32Array, stride:integer, \n  offset:integer )\n    Computes the range of a single-precision floating-point strided array,\n    ignoring `NaN` values and using alternative indexing semantics.\n"
base.strided.snanstdev,"\nbase.strided.snanstdev( N:integer, correction:number, x:Float32Array, \n  stride:integer )\n    Computes the standard deviation of a single-precision floating-point strided\n    array ignoring `NaN` values.\n"
base.strided.snanstdev.ndarray,"\nbase.strided.snanstdev.ndarray( N:integer, correction:number, x:Float32Array, \n  stride:integer, offset:integer )\n    Computes the standard deviation of a single-precision floating-point strided\n    array ignoring `NaN` values and alternative indexing semantics.\n"
base.strided.snanstdevch,"\nbase.strided.snanstdevch( N:integer, correction:number, x:Float32Array, \n  stride:integer )\n    Computes the standard deviation of a single-precision floating-point strided\n    array ignoring `NaN` values and using a one-pass trial mean algorithm.\n"
base.strided.snanstdevch.ndarray,"\nbase.strided.snanstdevch.ndarray( N:integer, correction:number, x:Float32Array, \n  stride:integer, offset:integer )\n    Computes the standard deviation of a single-precision floating-point strided\n    array ignoring `NaN` values and using a one-pass trial mean algorithm and\n    alternative indexing semantics.\n"
base.strided.snanstdevpn,"\nbase.strided.snanstdevpn( N:integer, correction:number, x:Float32Array, \n  stride:integer )\n    Computes the standard deviation of a single-precision floating-point strided\n    array ignoring `NaN` values and using a two-pass algorithm.\n"
base.strided.snanstdevpn.ndarray,"\nbase.strided.snanstdevpn.ndarray( N:integer, correction:number, x:Float32Array, \n  stride:integer, offset:integer )\n    Computes the standard deviation of a single-precision floating-point strided\n    array ignoring `NaN` values and using a two-pass algorithm and alternative\n    indexing semantics.\n"
base.strided.snanstdevtk,"\nbase.strided.snanstdevtk( N:integer, correction:number, x:Float32Array, \n  stride:integer )\n    Computes the standard deviation of a single-precision floating-point strided\n    array ignoring `NaN` values and using a one-pass textbook algorithm.\n"
base.strided.snanstdevtk.ndarray,"\nbase.strided.snanstdevtk.ndarray( N:integer, correction:number, x:Float32Array, \n  stride:integer, offset:integer )\n    Computes the standard deviation of a single-precision floating-point strided\n    array ignoring `NaN` values and using a one-pass textbook algorithm and\n    alternative indexing semantics.\n"
base.strided.snanstdevwd,"\nbase.strided.snanstdevwd( N:integer, correction:number, x:Float32Array, \n  stride:integer )\n    Computes the standard deviation of a single-precision floating-point strided\n    array ignoring `NaN` values and using Welford's algorithm.\n"
base.strided.snanstdevwd.ndarray,"\nbase.strided.snanstdevwd.ndarray( N:integer, correction:number, x:Float32Array, \n  stride:integer, offset:integer )\n    Computes the standard deviation of a single-precision floating-point strided\n    array ignoring `NaN` values and using Welford's algorithm and alternative\n    indexing semantics.\n"
base.strided.snanstdevyc,"\nbase.strided.snanstdevyc( N:integer, correction:number, x:Float32Array, \n  stride:integer )\n    Computes the standard deviation of a single-precision floating-point strided\n    array ignoring `NaN` values and using a one-pass algorithm proposed by\n    Youngs and Cramer.\n"
base.strided.snanstdevyc.ndarray,"\nbase.strided.snanstdevyc.ndarray( N:integer, correction:number, x:Float32Array, \n  stride:integer, offset:integer )\n    Computes the standard deviation of a single-precision floating-point strided\n    array ignoring `NaN` values and using a one-pass algorithm proposed by\n    Youngs and Cramer and alternative indexing semantics.\n"
base.strided.snansum,"\nbase.strided.snansum( N:integer, x:Float32Array, stride:integer )\n    Computes the sum of single-precision floating-point strided array elements,\n    ignoring `NaN` values.\n"
base.strided.snansum.ndarray,"\nbase.strided.snansum.ndarray( N:integer, x:Float32Array, stride:integer, \n  offset:integer )\n    Computes the sum of single-precision floating-point strided array elements,\n    ignoring `NaN` values and using alternative indexing semantics.\n"
base.strided.snansumkbn,"\nbase.strided.snansumkbn( N:integer, x:Float32Array, stride:integer )\n    Computes the sum of single-precision floating-point strided array elements,\n    ignoring `NaN` values and using an improved Kahan–Babuška algorithm.\n"
base.strided.snansumkbn.ndarray,"\nbase.strided.snansumkbn.ndarray( N:integer, x:Float32Array, stride:integer, \n  offset:integer )\n    Computes the sum of single-precision floating-point strided array elements,\n    ignoring `NaN` values and using an improved Kahan–Babuška algorithm and\n    alternative indexing semantics.\n"
base.strided.snansumkbn2,"\nbase.strided.snansumkbn2( N:integer, x:Float32Array, stride:integer )\n    Computes the sum of single-precision floating-point strided array elements,\n    ignoring `NaN` values and using a second-order iterative Kahan–Babuška\n    algorithm.\n"
base.strided.snansumkbn2.ndarray,"\nbase.strided.snansumkbn2.ndarray( N:integer, x:Float32Array, stride:integer, \n  offset:integer )\n    Computes the sum of single-precision floating-point strided array elements,\n    ignoring `NaN` values and using a second-order iterative Kahan–Babuška\n    algorithm and alternative indexing semantics.\n"
base.strided.snansumors,"\nbase.strided.snansumors( N:integer, x:Float32Array, stride:integer )\n    Computes the sum of single-precision floating-point strided array elements,\n    ignoring `NaN` values and using ordinary recursive summation.\n"
base.strided.snansumors.ndarray,"\nbase.strided.snansumors.ndarray( N:integer, x:Float32Array, stride:integer, \n  offset:integer )\n    Computes the sum of single-precision floating-point strided array elements,\n    ignoring `NaN` values and using ordinary recursive summation and alternative\n    indexing semantics.\n"
base.strided.snansumpw,"\nbase.strided.snansumpw( N:integer, x:Float32Array, stride:integer )\n    Computes the sum of single-precision floating-point strided array elements,\n    ignoring `NaN` values and using pairwise summation.\n"
base.strided.snansumpw.ndarray,"\nbase.strided.snansumpw.ndarray( N:integer, x:Float32Array, stride:integer, \n  offset:integer )\n    Computes the sum of single-precision floating-point strided array elements,\n    ignoring `NaN` values and using pairwise summation and alternative indexing\n    semantics.\n"
base.strided.snanvariance,"\nbase.strided.snanvariance( N:integer, correction:number, x:Float32Array, \n  stride:integer )\n    Computes the variance of a single-precision floating-point strided array\n    ignoring `NaN` values.\n"
base.strided.snanvariance.ndarray,"\nbase.strided.snanvariance.ndarray( N:integer, correction:number, \n  x:Float32Array, stride:integer, offset:integer )\n    Computes the variance of a single-precision floating-point strided array\n    ignoring `NaN` values and using alternative indexing semantics.\n"
base.strided.snanvariancech,"\nbase.strided.snanvariancech( N:integer, correction:number, x:Float32Array, \n  stride:integer )\n    Computes the variance of a single-precision floating-point strided array\n    ignoring `NaN` values and using a one-pass trial mean algorithm.\n"
base.strided.snanvariancech.ndarray,"\nbase.strided.snanvariancech.ndarray( N:integer, correction:number, \n  x:Float32Array, stride:integer, offset:integer )\n    Computes the variance of a single-precision floating-point strided array\n    ignoring `NaN` values and using a one-pass trial mean algorithm and\n    alternative indexing semantics.\n"
base.strided.snanvariancepn,"\nbase.strided.snanvariancepn( N:integer, correction:number, x:Float32Array, \n  stride:integer )\n    Computes the variance of a single-precision floating-point strided array\n    ignoring `NaN` values and using a two-pass algorithm.\n"
base.strided.snanvariancepn.ndarray,"\nbase.strided.snanvariancepn.ndarray( N:integer, correction:number, \n  x:Float32Array, stride:integer, offset:integer )\n    Computes the variance of a single-precision floating-point strided array\n    ignoring `NaN` values and using a two-pass algorithm and alternative\n    indexing semantics.\n"
base.strided.snanvariancetk,"\nbase.strided.snanvariancetk( N:integer, correction:number, x:Float32Array, \n  stride:integer )\n    Computes the variance of a single-precision floating-point strided array\n    ignoring `NaN` values and using a one-pass textbook algorithm.\n"
base.strided.snanvariancetk.ndarray,"\nbase.strided.snanvariancetk.ndarray( N:integer, correction:number, \n  x:Float32Array, stride:integer, offset:integer )\n    Computes the variance of a single-precision floating-point strided array\n    ignoring `NaN` values and using a one-pass textbook algorithm and\n    alternative indexing semantics.\n"
base.strided.snanvariancewd,"\nbase.strided.snanvariancewd( N:integer, correction:number, x:Float32Array, \n  stride:integer )\n    Computes the variance of a single-precision floating-point strided array\n    ignoring `NaN` values and using Welford's algorithm.\n"
base.strided.snanvariancewd.ndarray,"\nbase.strided.snanvariancewd.ndarray( N:integer, correction:number, \n  x:Float32Array, stride:integer, offset:integer )\n    Computes the variance of a single-precision floating-point strided array\n    ignoring `NaN` values and using Welford's algorithm and alternative indexing\n    semantics.\n"
base.strided.snanvarianceyc,"\nbase.strided.snanvarianceyc( N:integer, correction:number, x:Float32Array, \n  stride:integer )\n    Computes the variance of a single-precision floating-point strided array\n    ignoring `NaN` values and using a one-pass algorithm proposed by Youngs and\n    Cramer.\n"
base.strided.snanvarianceyc.ndarray,"\nbase.strided.snanvarianceyc.ndarray( N:integer, correction:number, \n  x:Float32Array, stride:integer, offset:integer )\n    Computes the variance of a single-precision floating-point strided array\n    ignoring `NaN` values and using a one-pass algorithm proposed by Youngs and\n    Cramer and alternative indexing semantics.\n"
base.strided.snrm2,"\nbase.strided.snrm2( N:integer, x:Float32Array, stride:integer )\n    Computes the L2-norm of a single-precision floating-point vector.\n"
base.strided.snrm2.ndarray,"\nbase.strided.snrm2.ndarray( N:integer, x:Float32Array, stride:integer, \n  offset:integer )\n    Computes the L2-norm of a single-precision floating-point vector using\n    alternative indexing semantics.\n"
base.strided.srange,"\nbase.strided.srange( N:integer, x:Float32Array, stride:integer )\n    Computes the range of a single-precision floating-point strided array.\n"
base.strided.srange.ndarray,"\nbase.strided.srange.ndarray( N:integer, x:Float32Array, stride:integer, \n  offset:integer )\n    Computes the range of a single-precision floating-point strided array using\n    alternative indexing semantics.\n"
base.strided.srev,"\nbase.strided.srev( N:integer, x:Float32Array, stride:integer )\n    Reverses a single-precision floating-point strided array in-place.\n"
base.strided.srev.ndarray,"\nbase.strided.srev.ndarray( N:integer, x:Float32Array, stride:integer, \n  offset:integer )\n    Reverses a single-precision floating-point strided array in-place using\n    alternative indexing semantics.\n"
base.strided.sscal,"\nbase.strided.sscal( N:integer, alpha:number, x:Float32Array, stride:integer )\n    Multiplies a single-precision floating-point vector `x` by a constant\n    `alpha`.\n"
base.strided.sscal.ndarray,"\nbase.strided.sscal.ndarray( N:integer, alpha:number, x:Float32Array, \n  stride:integer, offset:integer )\n    Multiplies a single-precision floating-point vector `x` by a constant\n    `alpha` using alternative indexing semantics.\n"
base.strided.ssort2hp,"\nbase.strided.ssort2hp( N:integer, order:number, x:Float32Array, \n  strideX:integer, y:Float32Array, strideY:integer )\n    Simultaneously sorts two single-precision floating-point strided arrays\n    based on the sort order of the first array using heapsort.\n"
base.strided.ssort2hp.ndarray,"\nbase.strided.ssort2hp.ndarray( N:integer, order:number, x:Float32Array, \n  strideX:integer, offsetX:integer, y:Float32Array, strideY:integer, \n  offsetY:integer )\n    Simultaneously sorts two single-precision floating-point strided arrays\n    based on the sort order of the first array using heapsort and alternative\n    indexing semantics.\n"
base.strided.ssort2ins,"\nbase.strided.ssort2ins( N:integer, order:number, x:Float32Array, \n  strideX:integer, y:Float32Array, strideY:integer )\n    Simultaneously sorts two single-precision floating-point strided arrays\n    based on the sort order of the first array using insertion sort.\n"
base.strided.ssort2ins.ndarray,"\nbase.strided.ssort2ins.ndarray( N:integer, order:number, x:Float32Array, \n  strideX:integer, offsetX:integer, y:Float32Array, strideY:integer, \n  offsetY:integer )\n    Simultaneously sorts two single-precision floating-point strided arrays\n    based on the sort order of the first array using insertion sort and\n    alternative indexing semantics.\n"
base.strided.ssort2sh,"\nbase.strided.ssort2sh( N:integer, order:number, x:Float32Array, \n  strideX:integer, y:Float32Array, strideY:integer )\n    Simultaneously sorts two single-precision floating-point strided arrays\n    based on the sort order of the first array using Shellsort.\n"
base.strided.ssort2sh.ndarray,"\nbase.strided.ssort2sh.ndarray( N:integer, order:number, x:Float32Array, \n  strideX:integer, offsetX:integer, y:Float32Array, strideY:integer, \n  offsetY:integer )\n    Simultaneously sorts two single-precision floating-point strided arrays\n    based on the sort order of the first array using Shellsort and alternative\n    indexing semantics.\n"
base.strided.ssorthp,"\nbase.strided.ssorthp( N:integer, order:number, x:Float32Array, stride:integer )\n    Sorts a single-precision floating-point strided array using heapsort.\n"
base.strided.ssorthp.ndarray,"\nbase.strided.ssorthp.ndarray( N:integer, order:number, x:Float32Array, \n  stride:integer, offset:integer )\n    Sorts a single-precision floating-point strided array using heapsort and\n    alternative indexing semantics.\n"
base.strided.ssortins,"\nbase.strided.ssortins( N:integer, order:number, x:Float32Array, stride:integer )\n    Sorts a single-precision floating-point strided array using insertion sort.\n"
base.strided.ssortins.ndarray,"\nbase.strided.ssortins.ndarray( N:integer, order:number, x:Float32Array, \n  stride:integer, offset:integer )\n    Sorts a single-precision floating-point strided array using insertion sort\n    and alternative indexing semantics.\n"
base.strided.ssortsh,"\nbase.strided.ssortsh( N:integer, order:number, x:Float32Array, stride:integer )\n    Sorts a single-precision floating-point strided array using Shellsort.\n"
base.strided.ssortsh.ndarray,"\nbase.strided.ssortsh.ndarray( N:integer, order:number, x:Float32Array, \n  stride:integer, offset:integer )\n    Sorts a single-precision floating-point strided array using Shellsort and\n    alternative indexing semantics.\n"
base.strided.sstdev,"\nbase.strided.sstdev( N:integer, correction:number, x:Float32Array, \n  stride:integer )\n    Computes the standard deviation of a single-precision floating-point strided\n    array.\n"
base.strided.sstdev.ndarray,"\nbase.strided.sstdev.ndarray( N:integer, correction:number, x:Float32Array, \n  stride:integer, offset:integer )\n    Computes the standard deviation of a single-precision floating-point strided\n    array using alternative indexing semantics.\n"
base.strided.sstdevch,"\nbase.strided.sstdevch( N:integer, correction:number, x:Float32Array, \n  stride:integer )\n    Computes the standard deviation of a single-precision floating-point strided\n    array using a one-pass trial mean algorithm.\n"
base.strided.sstdevch.ndarray,"\nbase.strided.sstdevch.ndarray( N:integer, correction:number, x:Float32Array, \n  stride:integer, offset:integer )\n    Computes the standard deviation of a single-precision floating-point strided\n    array using a one-pass trial mean algorithm and alternative indexing\n    semantics.\n"
base.strided.sstdevpn,"\nbase.strided.sstdevpn( N:integer, correction:number, x:Float32Array, \n  stride:integer )\n    Computes the standard deviation of a single-precision floating-point strided\n    array using a two-pass algorithm.\n"
base.strided.sstdevpn.ndarray,"\nbase.strided.sstdevpn.ndarray( N:integer, correction:number, x:Float32Array, \n  stride:integer, offset:integer )\n    Computes the standard deviation of a single-precision floating-point strided\n    array using a two-pass algorithm and alternative indexing semantics.\n"
base.strided.sstdevtk,"\nbase.strided.sstdevtk( N:integer, correction:number, x:Float32Array, \n  stride:integer )\n    Computes the standard deviation of a single-precision floating-point strided\n    array using a one-pass textbook algorithm.\n"
base.strided.sstdevtk.ndarray,"\nbase.strided.sstdevtk.ndarray( N:integer, correction:number, x:Float32Array, \n  stride:integer, offset:integer )\n    Computes the standard deviation of a single-precision floating-point strided\n    array using a one-pass textbook algorithm and alternative indexing\n    semantics.\n"
base.strided.sstdevwd,"\nbase.strided.sstdevwd( N:integer, correction:number, x:Float32Array, \n  stride:integer )\n    Computes the standard deviation of a single-precision floating-point strided\n    array using Welford's algorithm.\n"
base.strided.sstdevwd.ndarray,"\nbase.strided.sstdevwd.ndarray( N:integer, correction:number, x:Float32Array, \n  stride:integer, offset:integer )\n    Computes the standard deviation of a single-precision floating-point strided\n    array using Welford's algorithm and alternative indexing semantics.\n"
base.strided.sstdevyc,"\nbase.strided.sstdevyc( N:integer, correction:number, x:Float32Array, \n  stride:integer )\n    Computes the standard deviation of a single-precision floating-point strided\n    array using a one-pass algorithm proposed by Youngs and Cramer.\n"
base.strided.sstdevyc.ndarray,"\nbase.strided.sstdevyc.ndarray( N:integer, correction:number, x:Float32Array, \n  stride:integer, offset:integer )\n    Computes the standard deviation of a single-precision floating-point strided\n    array using a one-pass algorithm proposed by Youngs and Cramer and\n    alternative indexing semantics.\n"
base.strided.ssum,"\nbase.strided.ssum( N:integer, x:Float32Array, stride:integer )\n    Computes the sum of single-precision floating-point strided array elements.\n"
base.strided.ssum.ndarray,"\nbase.strided.ssum.ndarray( N:integer, x:Float32Array, stride:integer, \n  offset:integer )\n    Computes the sum of single-precision floating-point strided array elements\n    using alternative indexing semantics.\n"
base.strided.ssumkbn,"\nbase.strided.ssumkbn( N:integer, x:Float32Array, stride:integer )\n    Computes the sum of single-precision floating-point strided array elements\n    using an improved Kahan–Babuška algorithm.\n"
base.strided.ssumkbn.ndarray,"\nbase.strided.ssumkbn.ndarray( N:integer, x:Float32Array, stride:integer, \n  offset:integer )\n    Computes the sum of single-precision floating-point strided array elements\n    using an improved Kahan–Babuška algorithm and alternative indexing\n    semantics.\n"
base.strided.ssumkbn2,"\nbase.strided.ssumkbn2( N:integer, x:Float32Array, stride:integer )\n    Computes the sum of single-precision floating-point strided array elements\n    using a second-order iterative Kahan–Babuška algorithm.\n"
base.strided.ssumkbn2.ndarray,"\nbase.strided.ssumkbn2.ndarray( N:integer, x:Float32Array, stride:integer, \n  offset:integer )\n    Computes the sum of single-precision floating-point strided array elements\n    using a second-order iterative Kahan–Babuška algorithm and alternative\n    indexing semantics.\n"
base.strided.ssumors,"\nbase.strided.ssumors( N:integer, x:Float32Array, stride:integer )\n    Computes the sum of single-precision floating-point strided array elements\n    using ordinary recursive summation.\n"
base.strided.ssumors.ndarray,"\nbase.strided.ssumors.ndarray( N:integer, x:Float32Array, stride:integer, \n  offset:integer )\n    Computes the sum of single-precision floating-point strided array elements\n    using ordinary recursive summation and alternative indexing semantics.\n"
base.strided.ssumpw,"\nbase.strided.ssumpw( N:integer, x:Float32Array, stride:integer )\n    Computes the sum of single-precision floating-point strided array elements\n    using pairwise summation.\n"
base.strided.ssumpw.ndarray,"\nbase.strided.ssumpw.ndarray( N:integer, x:Float32Array, stride:integer, \n  offset:integer )\n    Computes the sum of single-precision floating-point strided array elements\n    using pairwise summation and alternative indexing semantics.\n"
base.strided.sswap,"\nbase.strided.sswap( N:integer, x:Float32Array, strideX:integer, y:Float32Array, \n  strideY:integer )\n    Interchanges two single-precision floating-point vectors.\n"
base.strided.sswap.ndarray,"\nbase.strided.sswap.ndarray( N:integer, x:Float32Array, strideX:integer, \n  offsetX:integer, y:Float32Array, strideY:integer, offsetY:integer )\n    Interchanges two single-precision floating-point vectors using alternative\n    indexing semantics.\n"
base.strided.stdev,"\nbase.strided.stdev( N:integer, correction:number, x:Array|TypedArray, \n  stride:integer )\n    Computes the standard deviation of a strided array.\n"
base.strided.stdev.ndarray,"\nbase.strided.stdev.ndarray( N:integer, correction:number, x:Array|TypedArray, \n  stride:integer, offset:integer )\n    Computes the standard deviation of a strided array using alternative\n    indexing semantics.\n"
base.strided.stdevch,"\nbase.strided.stdevch( N:integer, correction:number, x:Array|TypedArray, \n  stride:integer )\n    Computes the standard deviation of a strided array using a one-pass trial\n    mean algorithm.\n"
base.strided.stdevch.ndarray,"\nbase.strided.stdevch.ndarray( N:integer, correction:number, x:Array|TypedArray, \n  stride:integer, offset:integer )\n    Computes the standard deviation of a strided array using a one-pass trial\n    mean algorithm and alternative indexing semantics.\n"
base.strided.stdevpn,"\nbase.strided.stdevpn( N:integer, correction:number, x:Array|TypedArray, \n  stride:integer )\n    Computes the standard deviation of a strided array using a two-pass\n    algorithm.\n"
base.strided.stdevpn.ndarray,"\nbase.strided.stdevpn.ndarray( N:integer, correction:number, x:Array|TypedArray, \n  stride:integer, offset:integer )\n    Computes the standard deviation of a strided array using a two-pass\n    algorithm and alternative indexing semantics.\n"
base.strided.stdevtk,"\nbase.strided.stdevtk( N:integer, correction:number, x:Array|TypedArray, \n  stride:integer )\n    Computes the standard deviation of a strided array using a one-pass textbook\n    algorithm.\n"
base.strided.stdevtk.ndarray,"\nbase.strided.stdevtk.ndarray( N:integer, correction:number, x:Array|TypedArray, \n  stride:integer, offset:integer )\n    Computes the standard deviation of a strided array using a one-pass textbook\n    algorithm and alternative indexing semantics.\n"
base.strided.stdevwd,"\nbase.strided.stdevwd( N:integer, correction:number, x:Array|TypedArray, \n  stride:integer )\n    Computes the standard deviation of a strided array using Welford's\n    algorithm.\n"
base.strided.stdevwd.ndarray,"\nbase.strided.stdevwd.ndarray( N:integer, correction:number, x:Array|TypedArray, \n  stride:integer, offset:integer )\n    Computes the standard deviation of a strided array using Welford's algorithm\n    and alternative indexing semantics.\n"
base.strided.stdevyc,"\nbase.strided.stdevyc( N:integer, correction:number, x:Array|TypedArray, \n  stride:integer )\n    Computes the standard deviation of a strided array using a one-pass\n    algorithm proposed by Youngs and Cramer.\n"
base.strided.stdevyc.ndarray,"\nbase.strided.stdevyc.ndarray( N:integer, correction:number, x:Array|TypedArray, \n  stride:integer, offset:integer )\n    Computes the standard deviation of a strided array using a one-pass\n    algorithm proposed by Youngs and Cramer and alternative indexing semantics.\n"
base.strided.svariance,"\nbase.strided.svariance( N:integer, correction:number, x:Float32Array, \n  stride:integer )\n    Computes the variance of a single-precision floating-point strided array.\n"
base.strided.svariance.ndarray,"\nbase.strided.svariance.ndarray( N:integer, correction:number, x:Float32Array, \n  stride:integer, offset:integer )\n    Computes the variance of a single-precision floating-point strided array\n    using alternative indexing semantics.\n"
base.strided.svariancech,"\nbase.strided.svariancech( N:integer, correction:number, x:Float32Array, \n  stride:integer )\n    Computes the variance of a single-precision floating-point strided array\n    using a one-pass trial mean algorithm.\n"
base.strided.svariancech.ndarray,"\nbase.strided.svariancech.ndarray( N:integer, correction:number, x:Float32Array, \n  stride:integer, offset:integer )\n    Computes the variance of a single-precision floating-point strided array\n    using a one-pass trial mean algorithm and alternative indexing semantics.\n"
base.strided.svariancepn,"\nbase.strided.svariancepn( N:integer, correction:number, x:Float32Array, \n  stride:integer )\n    Computes the variance of a single-precision floating-point strided array\n    using a two-pass algorithm.\n"
base.strided.svariancepn.ndarray,"\nbase.strided.svariancepn.ndarray( N:integer, correction:number, x:Float32Array, \n  stride:integer, offset:integer )\n    Computes the variance of a single-precision floating-point strided array\n    using a two-pass algorithm and alternative indexing semantics.\n"
base.strided.svariancetk,"\nbase.strided.svariancetk( N:integer, correction:number, x:Float32Array, \n  stride:integer )\n    Computes the variance of a single-precision floating-point strided array\n    using a one-pass textbook algorithm.\n"
base.strided.svariancetk.ndarray,"\nbase.strided.svariancetk.ndarray( N:integer, correction:number, x:Float32Array, \n  stride:integer, offset:integer )\n    Computes the variance of a single-precision floating-point strided array\n    using a one-pass textbook algorithm and alternative indexing semantics.\n"
base.strided.svariancewd,"\nbase.strided.svariancewd( N:integer, correction:number, x:Float32Array, \n  stride:integer )\n    Computes the variance of a single-precision floating-point strided array\n    using Welford's algorithm.\n"
base.strided.svariancewd.ndarray,"\nbase.strided.svariancewd.ndarray( N:integer, correction:number, x:Float32Array, \n  stride:integer, offset:integer )\n    Computes the variance of a single-precision floating-point strided array\n    using Welford's algorithm and alternative indexing semantics.\n"
base.strided.svarianceyc,"\nbase.strided.svarianceyc( N:integer, correction:number, x:Float32Array, \n  stride:integer )\n    Computes the variance of a single-precision floating-point strided array\n    using a one-pass algorithm proposed by Youngs and Cramer.\n"
base.strided.svarianceyc.ndarray,"\nbase.strided.svarianceyc.ndarray( N:integer, correction:number, x:Float32Array, \n  stride:integer, offset:integer )\n    Computes the variance of a single-precision floating-point strided array\n    using a one-pass algorithm proposed by Youngs and Cramer and alternative\n    indexing semantics.\n"
base.strided.ternary,"\nbase.strided.ternary( arrays:ArrayLikeObject<ArrayLikeObject>, \n  shape:ArrayLikeObject<integer>, strides:ArrayLikeObject<integer>, \n  fcn:Function )\n    Applies a ternary callback to strided input array elements and assigns\n    results to elements in a strided output array.\n"
base.strided.ternary.ndarray,"\nbase.strided.ternary.ndarray( arrays:ArrayLikeObject<ArrayLikeObject>, \n  shape:ArrayLikeObject<integer>, strides:ArrayLikeObject<integer>, \n  offsets:ArrayLikeObject<integer>, fcn:Function )\n    Applies a ternary callback to strided input array elements and assigns\n    results to elements in a strided output array using alternative indexing\n    semantics.\n"
base.strided.unary,"\nbase.strided.unary( arrays:ArrayLikeObject<ArrayLikeObject>, \n  shape:ArrayLikeObject<integer>, strides:ArrayLikeObject<integer>, \n  fcn:Function )\n    Applies a unary callback to elements in a strided input array and assigns\n    results to elements in a strided output array.\n"
base.strided.unary.ndarray,"\nbase.strided.unary.ndarray( arrays:ArrayLikeObject<ArrayLikeObject>, \n  shape:ArrayLikeObject<integer>, strides:ArrayLikeObject<integer>, \n  offsets:ArrayLikeObject<integer>, fcn:Function )\n    Applies a unary callback to elements in a strided input array and assigns\n    results to elements in a strided output array using alternative indexing\n    semantics.\n"
base.strided.variance,"\nbase.strided.variance( N:integer, correction:number, x:Array|TypedArray, \n  stride:integer )\n    Computes the variance of a strided array.\n"
base.strided.variance.ndarray,"\nbase.strided.variance.ndarray( N:integer, correction:number, \n  x:Array|TypedArray, stride:integer, offset:integer )\n    Computes the variance of a strided array using alternative indexing\n    semantics.\n"
base.strided.variancech,"\nbase.strided.variancech( N:integer, correction:number, x:Array|TypedArray, \n  stride:integer )\n    Computes the variance of a strided array using a one-pass trial mean\n    algorithm.\n"
base.strided.variancech.ndarray,"\nbase.strided.variancech.ndarray( N:integer, correction:number, \n  x:Array|TypedArray, stride:integer, offset:integer )\n    Computes the variance of a strided array using a one-pass trial mean\n    algorithm and alternative indexing semantics.\n"
base.strided.variancepn,"\nbase.strided.variancepn( N:integer, correction:number, x:Array|TypedArray, \n  stride:integer )\n    Computes the variance of a strided array using a two-pass algorithm.\n"
base.strided.variancepn.ndarray,"\nbase.strided.variancepn.ndarray( N:integer, correction:number, \n  x:Array|TypedArray, stride:integer, offset:integer )\n    Computes the variance of a strided array using a two-pass algorithm and\n    alternative indexing semantics.\n"
base.strided.variancetk,"\nbase.strided.variancetk( N:integer, correction:number, x:Array|TypedArray, \n  stride:integer )\n    Computes the variance of a strided array using a one-pass textbook\n    algorithm.\n"
base.strided.variancetk.ndarray,"\nbase.strided.variancetk.ndarray( N:integer, correction:number, \n  x:Array|TypedArray, stride:integer, offset:integer )\n    Computes the variance of a strided array using a one-pass textbook algorithm\n    and alternative indexing semantics.\n"
base.strided.variancewd,"\nbase.strided.variancewd( N:integer, correction:number, x:Array|TypedArray, \n  stride:integer )\n    Computes the variance of a strided array using Welford's algorithm.\n"
base.strided.variancewd.ndarray,"\nbase.strided.variancewd.ndarray( N:integer, correction:number, \n  x:Array|TypedArray, stride:integer, offset:integer )\n    Computes the variance of a strided array using Welford's algorithm and\n    alternative indexing semantics.\n"
base.strided.varianceyc,"\nbase.strided.varianceyc( N:integer, correction:number, x:Array|TypedArray, \n  stride:integer )\n    Computes the variance of a strided array using a one-pass algorithm proposed\n    by Youngs and Cramer.\n"
base.strided.varianceyc.ndarray,"\nbase.strided.varianceyc.ndarray( N:integer, correction:number, \n  x:Array|TypedArray, stride:integer, offset:integer )\n    Computes the variance of a strided array using a one-pass algorithm proposed\n    by Youngs and Cramer and alternative indexing semantics.\n"
base.sumSeries,"\nbase.sumSeries( generator:Function[, options:Object] )\n    Sum the elements of the series given by the supplied function.\n"
base.tan,"\nbase.tan( x:number )\n    Computes the tangent of a number.\n"
base.tanh,"\nbase.tanh( x:number )\n    Computes the hyperbolic tangent of a number.\n"
base.toBinaryString,"\nbase.toBinaryString( x:number )\n    Returns a string giving the literal bit representation of a double-precision\n    floating-point number.\n"
base.toBinaryStringf,"\nbase.toBinaryStringf( x:float )\n    Returns a string giving the literal bit representation of a single-precision\n    floating-point number.\n"
base.toBinaryStringUint8,"\nbase.toBinaryStringUint8( x:integer )\n    Returns a string giving the literal bit representation of an unsigned 8-bit\n    integer.\n"
base.toBinaryStringUint16,"\nbase.toBinaryStringUint16( x:integer )\n    Returns a string giving the literal bit representation of an unsigned 16-bit\n    integer.\n"
base.toBinaryStringUint32,"\nbase.toBinaryStringUint32( x:integer )\n    Returns a string giving the literal bit representation of an unsigned 32-bit\n    integer.\n"
base.toWordf,"\nbase.toWordf( x:float )\n    Returns an unsigned 32-bit integer corresponding to the IEEE 754 binary\n    representation of a single-precision floating-point number.\n"
base.toWords,"\nbase.toWords( [out:Array|TypedArray|Object,] x:number )\n    Splits a double-precision floating-point number into a higher order word\n    (unsigned 32-bit integer) and a lower order word (unsigned 32-bit integer).\n"
base.tribonacci,"\nbase.tribonacci( n:integer )\n    Computes the nth Tribonacci number.\n"
base.trigamma,"\nbase.trigamma( x:number )\n    Evaluates the trigamma function.\n"
base.trunc,"\nbase.trunc( x:number )\n    Rounds a double-precision floating-point number toward zero.\n"
base.trunc2,"\nbase.trunc2( x:number )\n    Rounds a numeric value to the nearest power of two toward zero.\n"
base.trunc10,"\nbase.trunc10( x:number )\n    Rounds a numeric value to the nearest power of ten toward zero.\n"
base.truncb,"\nbase.truncb( x:number, n:integer, b:integer )\n    Rounds a numeric value to the nearest multiple of `b^n` toward zero.\n"
base.truncf,"\nbase.truncf( x:number )\n    Rounds a single-precision floating-point number toward zero.\n"
base.truncn,"\nbase.truncn( x:number, n:integer )\n    Rounds a numeric value to the nearest multiple of `10^n` toward zero.\n"
base.truncsd,"\nbase.truncsd( x:number, n:integer[, b:integer] )\n    Rounds a numeric value to the nearest number toward zero with `n`\n    significant figures.\n"
base.uimul,"\nbase.uimul( a:integer, b:integer )\n    Performs C-like multiplication of two unsigned 32-bit integers.\n"
base.uimuldw,"\nbase.uimuldw( [out:ArrayLikeObject,] a:integer, b:integer )\n    Multiplies two unsigned 32-bit integers and returns an array of two unsigned\n    32-bit integers which represents the unsigned 64-bit integer product.\n"
base.uint32ToInt32,"\nbase.uint32ToInt32( x:integer )\n    Converts an unsigned 32-bit integer to a signed 32-bit integer.\n"
base.vercos,"\nbase.vercos( x:number )\n    Computes the versed cosine.\n"
base.versin,"\nbase.versin( x:number )\n    Computes the versed sine.\n"
base.wrap,"\nbase.wrap( v:number, min:number, max:number )\n    Wraps a value on the half-open interval `[min,max)`.\n"
base.xlog1py,"\nbase.xlog1py( x:number, y:number )\n    Computes `x * ln(y+1)` so that the result is `0` if `x = 0`.\n"
base.xlogy,"\nbase.xlogy( x:number, y:number )\n    Computes `x * ln(y)` so that the result is `0` if `x = 0`.\n"
base.zeta,"\nbase.zeta( s:number )\n    Evaluates the Riemann zeta function as a function of a real variable `s`.\n"
BERNDT_CPS_WAGES_1985,"\nBERNDT_CPS_WAGES_1985()\n    Returns a random sample of 534 workers from the Current Population Survey\n    (CPS) from 1985, including their wages and and other characteristics.\n"
bifurcate,"\nbifurcate( collection:Array|TypedArray|Object, [options:Object,] \n  filter:Array|TypedArray|Object )\n    Splits values into two groups.\n"
bifurcateBy,"\nbifurcateBy( collection:Array|TypedArray|Object, [options:Object,] \n  predicate:Function )\n    Splits values into two groups according to a predicate function.\n"
bifurcateByAsync,"\nbifurcateByAsync( collection:Array|TypedArray|Object, [options:Object,] \n  predicate:Function, done:Function )\n    Splits values into two groups according to a predicate function.\n"
bifurcateByAsync.factory,"\nbifurcateByAsync.factory( [options:Object,] predicate:Function )\n    Returns a function which splits values into two groups according to an\n    predicate function.\n"
bifurcateIn,"\nbifurcateIn( obj:Object|Array|TypedArray, [options:Object,] predicate:Function )\n    Splits values into two groups according to a predicate function.\n"
bifurcateOwn,"\nbifurcateOwn( obj:Object|Array|TypedArray, [options:Object,] \n  predicate:Function )\n    Splits values into two groups according to a predicate function.\n"
BigInt,"\nBigInt( value:integer|string )\n    Returns a BigInt.\n"
binomialTest,"\nbinomialTest( x:(number|Array[, n:Array<number>][, options:Object] )\n    Computes an exact test for the success probability in a Bernoulli\n    experiment.\n"
Buffer,"\nBuffer\n\nBuffer( size:integer )\n    Allocates a buffer having a specified number of bytes.\n\nBuffer( buffer:Buffer )\n    Copies buffer data to a new Buffer instance.\n\nBuffer( array:Array )\n    Allocates a buffer using an array of octets.\n\nBuffer( str:string[, encoding:string] )\n    Allocates a buffer containing a provided string.\n"
buffer2json,"\nbuffer2json( buffer:Buffer )\n    Returns a JSON representation of a buffer.\n"
BYTE_ORDER,"\nBYTE_ORDER\n    Platform byte order.\n"
capitalize,"\ncapitalize( str:string )\n    Capitalizes the first character in a `string`.\n"
capitalizeKeys,"\ncapitalizeKeys( obj:Object )\n    Converts the first letter of each object key to uppercase.\n"
CATALAN,"\nCATALAN\n    Catalan's constant.\n"
CBRT_EPS,"\nCBRT_EPS\n    Cube root of double-precision floating-point epsilon.\n"
CDC_NCHS_US_BIRTHS_1969_1988,"\nCDC_NCHS_US_BIRTHS_1969_1988()\n    Returns US birth data from 1969 to 1988, as provided by the Center for\n    Disease Control and Prevention's National Center for Health Statistics.\n"
CDC_NCHS_US_BIRTHS_1994_2003,"\nCDC_NCHS_US_BIRTHS_1994_2003()\n    Returns US birth data from 1994 to 2003, as provided by the Center for\n    Disease Control and Prevention's National Center for Health Statistics.\n"
CDC_NCHS_US_INFANT_MORTALITY_BW_1915_2013,"\nCDC_NCHS_US_INFANT_MORTALITY_BW_1915_2013()\n    Returns US infant mortality data, by race, from 1915 to 2013, as provided by\n    the Center for Disease Control and Prevention's National Center for Health\n    Statistics.\n"
chdir,"\nchdir( path:string )\n    Changes the current working directory.\n"
chi2gof,"\nchi2gof( x:ndarray|Array|TypedArray, y:ndarray|Array|TypedArray|string[, \n  ...args:number][, options:Object] )\n    Performs a chi-square goodness-of-fit test.\n"
chi2test,"\nchi2test( x:(MatrixLike|Array[, options:Object] )\n    Performs a chi-square independence test.\n"
circarray2iterator,"\ncircarray2iterator( src:ArrayLikeObject[, options:Object][, mapFcn:Function[, \n  thisArg:any]] )\n    Returns an iterator which repeatedly iterates over the elements of an array-\n    like object.\n"
circularArrayStream,"\ncircularArrayStream( src:ArrayLikeObject[, options:Object] )\n    Creates a readable stream from an array-like object which repeatedly\n    iterates over the provided value's elements.\n"
circularArrayStream.factory,"\ncircularArrayStream.factory( [options:Object] )\n    Returns a function for creating readable streams from array-like objects\n    which repeatedly iterate over the elements of provided values.\n"
circularArrayStream.objectMode,"\ncircularArrayStream.objectMode( src:ArrayLikeObject[, options:Object] )\n    Returns an \"objectMode\" readable stream from an array-like object which\n    repeatedly iterates over a provided value's elements.\n"
CircularBuffer,"\nCircularBuffer( buffer:integer|ArrayLike )\n    Circular buffer constructor.\n"
close,"\nclose( fd:integer, clbk:Function )\n    Asynchronously closes a file descriptor, so that the file descriptor no\n    longer refers to any file and may be reused.\n"
close.sync,"\nclose.sync( fd:integer )\n    Synchronously closes a file descriptor.\n"
CMUDICT,"\nCMUDICT( [options:Object] )\n    Returns datasets from the Carnegie Mellon Pronouncing Dictionary (CMUdict).\n"
codePointAt,"\ncodePointAt( str:string, idx:integer[, backward:boolean] )\n    Returns a Unicode code point from a string at a specified position.\n"
complex,"\ncomplex( real:number, imag:number[, dtype:string] )\n    Creates a complex number.\n"
Complex64,"\nComplex64( real:number, imag:number )\n    64-bit complex number constructor.\n"
COMPLEX64_NUM_BYTES,"\nCOMPLEX64_NUM_BYTES\n    Size (in bytes) of a 64-bit complex number.\n"
Complex128,"\nComplex128( real:number, imag:number )\n    128-bit complex number constructor.\n"
COMPLEX128_NUM_BYTES,"\nCOMPLEX128_NUM_BYTES\n    Size (in bytes) of a 128-bit complex number.\n"
compose,"\ncompose( ...f:Function )\n    Function composition.\n"
composeAsync,"\ncomposeAsync( ...f:Function )\n    Function composition.\n"
configdir,"\nconfigdir( [p:string] )\n    Returns a directory for user-specific configuration files.\n"
conj,"\nconj( z:Complex )\n    Returns the complex conjugate of a complex number.\n"
constantFunction,"\nconstantFunction( val:any )\n    Creates a function which always returns the same value.\n"
constantStream,"\nconstantStream( value:string|Buffer|Uint8Array|any[, options:Object] )\n    Returns a readable stream which always streams the same value.\n"
constantStream.factory,"\nconstantStream.factory( [value:string|Buffer|Uint8Array|any, ][options:Object] )\n    Returns a function for creating readable streams which always stream the\n    same value.\n"
constantStream.objectMode,"\nconstantStream.objectMode( value:any[, options:Object] )\n    Returns an \"objectMode\" readable stream which always streams the same value.\n"
constructorName,"\nconstructorName( val:any )\n    Determines the name of a value's constructor.\n"
contains,"\ncontains( val:ArrayLike, searchValue:any[, position:integer] )\n    Tests if an array-like value contains a search value.\n"
convertArray,"\nconvertArray( arr:Array|TypedArray, dtype:string )\n    Converts an input array to an array of a different data type.\n"
convertArraySame,"\nconvertArraySame( x:Array|TypedArray, y:Array|TypedArray )\n    Converts an input array to the same data type as a second input array.\n"
convertPath,"\nconvertPath( from:string, to:string )\n    Converts between POSIX and Windows paths.\n"
copy,"\ncopy( value:any[, level:integer] )\n    Copy or deep clone a value to an arbitrary depth.\n"
copyBuffer,"\ncopyBuffer( buffer:Buffer )\n    Copies buffer data to a new Buffer instance.\n"
countBy,"\ncountBy( collection:Array|TypedArray|Object, [options:Object,] \n  indicator:Function )\n    Groups values according to an indicator function and returns group counts.\n"
countByAsync,"\ncountByAsync( collection:Array|TypedArray|Object, [options:Object,] \n  indicator:Function, done:Function )\n    Groups values according to an indicator function and returns group counts.\n"
countByAsync.factory,"\ncountByAsync.factory( [options:Object,] indicator:Function )\n    Returns a function which groups values according to an indicator function\n    and returns group counts.\n"
curry,"\ncurry( fcn:Function[, arity:integer][, thisArg:any] )\n    Transforms a function into a sequence of functions each accepting a single\n    argument.\n"
curryRight,"\ncurryRight( fcn:Function[, arity:integer][, thisArg:any] )\n    Transforms a function into a sequence of functions each accepting a single\n    argument.\n"
cwd,"\ncwd()\n    Returns the current working directory.\n"
DALE_CHALL_NEW,"\nDALE_CHALL_NEW()\n    Returns a list of familiar English words.\n"
datasets,"\ndatasets( name:string[, options:Object] )\n    Returns a dataset.\n"
DataView,"\nDataView( buffer:ArrayBuffer|SharedArrayBuffer[, byteOffset:integer[, \n  byteLength:integer]] )\n    Returns a data view representing a provided array buffer.\n"
DataView.prototype.buffer,"\nDataView.prototype.buffer\n    Read-only property which returns the underyling array buffer.\n"
DataView.prototype.byteLength,"\nDataView.prototype.byteLength\n    Read-only property which returns the length (in bytes) of the view.\n"
DataView.prototype.byteOffset,"\nDataView.prototype.byteOffset\n    Read-only property which returns the offset (in bytes) of the view to the\n    start of the underlying array buffer.\n"
datespace,"\ndatespace( start:number, stop:number[, length:integer][ , options:Object] )\n    Generates an array of linearly spaced dates.\n"
dayOfQuarter,"\ndayOfQuarter( [month:string|integer|Date[, day:integer, year:integer]] )\n    Returns the day of the quarter.\n"
dayOfYear,"\ndayOfYear( [month:string|integer|Date[, day:integer, year:integer]] )\n    Returns the day of the year.\n"
daysInMonth,"\ndaysInMonth( [month:string|integer|Date[, year:integer]] )\n    Returns the number of days in a month.\n"
daysInYear,"\ndaysInYear( [value:integer|Date] )\n    Returns the number of days in a year according to the Gregorian calendar.\n"
ddot,"\nddot( x:ndarray, y:ndarray )\n    Computes the dot product of two double-precision floating-point vectors.\n"
debugSinkStream,"\ndebugSinkStream( [options:Object,] [clbk:Function] )\n    Returns a writable stream for debugging stream pipelines.\n"
debugSinkStream.factory,"\ndebugSinkStream.factory( [options:Object] )\n    Returns a function for creating writable streams for debugging stream\n    pipelines.\n"
debugSinkStream.objectMode,"\ndebugSinkStream.objectMode( [options:Object,] [clbk:Function] )\n    Returns an \"objectMode\" writable stream for debugging stream pipelines.\n"
debugStream,"\ndebugStream( [options:Object,] [clbk:Function] )\n    Returns a transform stream for debugging stream pipelines.\n"
debugStream.factory,"\ndebugStream.factory( [options:Object] )\n    Returns a function for creating transform streams for debugging stream\n    pipelines.\n"
debugStream.objectMode,"\ndebugStream.objectMode( [options:Object,] [clbk:Function] )\n    Returns an \"objectMode\" transform stream for debugging stream pipelines.\n"
deepEqual,"\ndeepEqual( a:any, b:any )\n    Tests for deep equality between two values.\n"
deepGet,"\ndeepGet( obj:ObjectLike, path:string|Array[, options:Object] )\n    Returns a nested property value.\n"
deepGet.factory,"\ndeepGet.factory( path:string|Array[, options:Object] )\n    Creates a reusable deep get function.\n"
deepHasOwnProp,"\ndeepHasOwnProp( value:any, path:string|Array[, options:Object] )\n    Returns a boolean indicating whether an object contains a nested key path.\n"
deepHasOwnProp.factory,"\ndeepHasOwnProp.factory( path:string|Array[, options:Object] )\n    Returns a function which tests whether an object contains a nested key path.\n"
deepHasProp,"\ndeepHasProp( value:any, path:string|Array[, options:Object] )\n    Returns a boolean indicating whether an object contains a nested key path,\n    either own or inherited.\n"
deepHasProp.factory,"\ndeepHasProp.factory( path:string|Array[, options:Object] )\n    Returns a function which tests whether an object contains a nested key path,\n    either own or inherited.\n"
deepPluck,"\ndeepPluck( arr:Array, path:string|Array[, options:Object] )\n    Extracts a nested property value from each element of an object array.\n"
deepSet,"\ndeepSet( obj:ObjectLike, path:string|Array, value:any[, options:Object] )\n    Sets a nested property value.\n"
deepSet.factory,"\ndeepSet.factory( path:string|Array[, options:Object] )\n    Creates a reusable deep set function.\n"
defineMemoizedProperty,"\ndefineMemoizedProperty( obj:Object, prop:string|symbol, descriptor:Object )\n    Defines a memoized object property.\n"
defineProperties,"\ndefineProperties( obj:Object, properties:Object )\n    Defines (and/or modifies) object properties.\n"
defineProperty,"\ndefineProperty( obj:Object, prop:string|symbol, descriptor:Object )\n    Defines (or modifies) an object property.\n"
dirname,"\ndirname( path:string )\n    Returns a directory name.\n"
DoublyLinkedList,"\nDoublyLinkedList()\n    Doubly linked list constructor.\n"
doUntil,"\ndoUntil( fcn:Function, predicate:Function[, thisArg:any] )\n    Invokes a function until a test condition is true.\n"
doUntilAsync,"\ndoUntilAsync( fcn:Function, predicate:Function, done:Function[, thisArg:any] )\n    Invokes a function until a test condition is true.\n"
doUntilEach,"\ndoUntilEach( collection:Array|TypedArray|Object, fcn:Function, \n  predicate:Function[, thisArg:any] )\n    Until a test condition is true, invokes a function for each element in a\n    collection.\n"
doUntilEachRight,"\ndoUntilEachRight( collection:Array|TypedArray|Object, fcn:Function, \n  predicate:Function[, thisArg:any] )\n    Until a test condition is true, invokes a function for each element in a\n    collection, iterating from right to left.\n"
doWhile,"\ndoWhile( fcn:Function, predicate:Function[, thisArg:any] )\n    Invokes a function while a test condition is true.\n"
doWhileAsync,"\ndoWhileAsync( fcn:Function, predicate:Function, done:Function[, thisArg:any] )\n    Invokes a function while a test condition is true.\n"
doWhileEach,"\ndoWhileEach( collection:Array|TypedArray|Object, fcn:Function, \n  predicate:Function[, thisArg:any] )\n    While a test condition is true, invokes a function for each element in a\n    collection.\n"
doWhileEachRight,"\ndoWhileEachRight( collection:Array|TypedArray|Object, fcn:Function, \n  predicate:Function[, thisArg:any] )\n    While a test condition is true, invokes a function for each element in a\n    collection, iterating from right to left.\n"
dswap,"\ndswap( x:ndarray, y:ndarray )\n    Interchanges two double-precision floating-point vectors.\n"
E,"\nE\n    Euler's number.\n"
EMOJI,"\nEMOJI()\n    Returns an emoji database.\n"
EMOJI_CODE_PICTO,"\nEMOJI_CODE_PICTO()\n    Returns an object mapping emoji codes to pictographs.\n"
EMOJI_PICTO_CODE,"\nEMOJI_PICTO_CODE()\n    Returns an object mapping emoji pictographs to codes.\n"
emptyStream,"\nemptyStream( [options:Object] )\n    Returns an \"empty\" readable stream.\n"
emptyStream.factory,"\nemptyStream.factory( [options:Object] )\n    Returns a function for creating empty readable streams.\n"
emptyStream.objectMode,"\nemptyStream.objectMode()\n    Returns an \"objectMode\" empty readable stream.\n"
endsWith,"\nendsWith( str:string, search:string[, len:integer] )\n    Tests if a `string` ends with the characters of another `string`.\n"
enumerableProperties,"\nenumerableProperties( value:any )\n    Returns an array of an object's own enumerable property names and symbols.\n"
enumerablePropertiesIn,"\nenumerablePropertiesIn( value:any )\n    Returns an array of an object's own and inherited enumerable property names\n    and symbols.\n"
enumerablePropertySymbols,"\nenumerablePropertySymbols( value:any )\n    Returns an array of an object's own enumerable symbol properties.\n"
enumerablePropertySymbolsIn,"\nenumerablePropertySymbolsIn( value:any )\n    Returns an array of an object's own and inherited enumerable symbol\n    properties.\n"
ENV,"\nENV\n    An object containing the user environment.\n"
EPS,"\nEPS\n    Difference between one and the smallest value greater than one that can be\n    represented as a double-precision floating-point number.\n"
error2json,"\nerror2json( error:Error )\n    Returns a JSON representation of an error object.\n"
EULERGAMMA,"\nEULERGAMMA\n    The Euler-Mascheroni constant.\n"
every,"\nevery( collection:Array|TypedArray|Object )\n    Tests whether all elements in a collection are truthy.\n"
everyBy,"\neveryBy( collection:Array|TypedArray|Object, predicate:Function[, \n  thisArg:any ] )\n    Tests whether all elements in a collection pass a test implemented by a\n    predicate function.\n"
everyByAsync,"\neveryByAsync( collection:Array|TypedArray|Object, [options:Object,] \n  predicate:Function, done:Function )\n    Tests whether all elements in a collection pass a test implemented by a\n    predicate function.\n"
everyByAsync.factory,"\neveryByAsync.factory( [options:Object,] predicate:Function )\n    Returns a function which tests whether all elements in a collection pass a\n    test implemented by a predicate function.\n"
everyByRight,"\neveryByRight( collection:Array|TypedArray|Object, predicate:Function[, \n  thisArg:any ] )\n    Tests whether all elements in a collection pass a test implemented by a\n    predicate function, iterating from right to left.\n"
everyByRightAsync,"\neveryByRightAsync( collection:Array|TypedArray|Object, [options:Object,] \n  predicate:Function, done:Function )\n    Tests whether all elements in a collection pass a test implemented by a\n    predicate function, iterating from right to left.\n"
everyByRightAsync.factory,"\neveryByRightAsync.factory( [options:Object,] predicate:Function )\n    Returns a function which tests whether all elements in a collection pass a\n    test implemented by a predicate function, iterating from right to left.\n"
evil,"\nevil( str:string )\n    Alias for `eval` global.\n"
EXEC_PATH,"\nEXEC_PATH\n    Absolute pathname of the executable which started the current Node.js\n    process.\n"
exists,"\nexists( path:string|Buffer, clbk:Function )\n    Asynchronously tests whether a path exists on the filesystem.\n"
exists.sync,"\nexists.sync( path:string|Buffer )\n    Synchronously tests whether a path exists on the filesystem.\n"
expandContractions,"\nexpandContractions( str:string )\n    Expands all contractions to their formal equivalents.\n"
extname,"\nextname( filename:string )\n    Returns a filename extension.\n"
fastmath.abs,"\nfastmath.abs( x:number )\n    Computes an absolute value.\n"
fastmath.acosh,"\nfastmath.acosh( x:number )\n    Computes the hyperbolic arccosine of a number.\n"
fastmath.ampbm,"\nfastmath.ampbm( x:number, y:number )\n    Computes the hypotenuse using the alpha max plus beta min algorithm.\n"
fastmath.ampbm.factory,"\nfastmath.ampbm.factory( alpha:number, beta:number, [nonnegative:boolean[, \n  ints:boolean]] )\n    Returns a function to compute a hypotenuse using the alpha max plus beta min\n    algorithm.\n"
fastmath.asinh,"\nfastmath.asinh( x:number )\n    Computes the hyperbolic arcsine of a number.\n"
fastmath.atanh,"\nfastmath.atanh( x:number )\n    Computes the hyperbolic arctangent of a number.\n"
fastmath.hypot,"\nfastmath.hypot( x:number, y:number )\n    Computes the hypotenuse.\n"
fastmath.log2Uint32,"\nfastmath.log2Uint32( x:uinteger )\n    Returns an approximate binary logarithm (base two) of an unsigned 32-bit\n    integer `x`.\n"
fastmath.max,"\nfastmath.max( x:number, y:number )\n    Returns the maximum value.\n"
fastmath.min,"\nfastmath.min( x:number, y:number )\n    Returns the minimum value.\n"
fastmath.powint,"\nfastmath.powint( x:number, y:integer )\n    Evaluates the exponential function given a signed 32-bit integer exponent.\n"
fastmath.sqrtUint32,"\nfastmath.sqrtUint32( x:uinteger )\n    Returns an approximate square root of an unsigned 32-bit integer `x`.\n"
FEMALE_FIRST_NAMES_EN,"\nFEMALE_FIRST_NAMES_EN()\n    Returns a list of common female first names in English speaking countries.\n"
FIFO,"\nFIFO()\n    First-in-first-out (FIFO) queue constructor.\n"
filledarray,"\nfilledarray( [dtype:string] )\n    Creates a filled array.\n\nfilledarray( value:any, length:integer[, dtype:string] )\n    Returns a filled array having a specified length.\n\nfilledarray( value:any, array:ArrayLikeObject[, dtype:string] )\n    Creates a filled array from another array (or array-like object).\n\nfilledarray( value:any, iterable:Object[, dtype:string] )\n    Creates a filled array from an iterable.\n\nfilledarray( value:any, buffer:ArrayBuffer[, byteOffset:integer[, \n  length:integer]][, dtype:string] )\n    Returns a filled typed array view of an ArrayBuffer.\n"
find,"\nfind( arr:Array|TypedArray|string, [options:Object,] clbk:Function )\n    Finds elements in an array-like object that satisfy a test condition.\n"
FIVETHIRTYEIGHT_FFQ,"\nFIVETHIRTYEIGHT_FFQ()\n    Returns FiveThirtyEight reader responses to a food frequency questionnaire\n    (FFQ).\n"
flattenArray,"\nflattenArray( arr:Array[, options:Object] )\n    Flattens an array.\n"
flattenArray.factory,"\nflattenArray.factory( dims:Array<integer>[, options:Object] )\n    Returns a function for flattening arrays having specified dimensions.\n"
flattenObject,"\nflattenObject( obj:ObjectLike[, options:Object] )\n    Flattens an object.\n"
flattenObject.factory,"\nflattenObject.factory( [options:Object] )\n    Returns a function to flatten an object.\n"
flignerTest,"\nflignerTest( ...x:Array[, options:Object] )\n    Computes the Fligner-Killeen test for equal variances.\n"
FLOAT_WORD_ORDER,"\nFLOAT_WORD_ORDER\n    Platform float word order.\n"
FLOAT16_CBRT_EPS,"\nFLOAT16_CBRT_EPS\n    Cube root of half-precision floating-point epsilon.\n"
FLOAT16_EPS,"\nFLOAT16_EPS\n    Difference between one and the smallest value greater than one that can be\n    represented as a half-precision floating-point number.\n"
FLOAT16_EXPONENT_BIAS,"\nFLOAT16_EXPONENT_BIAS\n    The bias of a half-precision floating-point number's exponent.\n"
FLOAT16_MAX,"\nFLOAT16_MAX\n    Maximum half-precision floating-point number.\n"
FLOAT16_MAX_SAFE_INTEGER,"\nFLOAT16_MAX_SAFE_INTEGER\n    Maximum safe half-precision floating-point integer.\n"
FLOAT16_MIN_SAFE_INTEGER,"\nFLOAT16_MIN_SAFE_INTEGER\n    Minimum safe half-precision floating-point integer.\n"
FLOAT16_NINF,"\nFLOAT16_NINF\n    Half-precision floating-point negative infinity.\n"
FLOAT16_NUM_BYTES,"\nFLOAT16_NUM_BYTES\n    Size (in bytes) of a half-precision floating-point number.\n"
FLOAT16_PINF,"\nFLOAT16_PINF\n    Half-precision floating-point positive infinity.\n"
FLOAT16_PRECISION,"\nFLOAT16_PRECISION\n    Effective number of bits in the significand of a half-precision floating-\n    point number.\n"
FLOAT16_SMALLEST_NORMAL,"\nFLOAT16_SMALLEST_NORMAL\n    Smallest positive normalized half-precision floating-point number.\n"
FLOAT16_SMALLEST_SUBNORMAL,"\nFLOAT16_SMALLEST_SUBNORMAL\n    Smallest positive denormalized half-precision floating-point number.\n"
FLOAT16_SQRT_EPS,"\nFLOAT16_SQRT_EPS\n    Square root of half-precision floating-point epsilon.\n"
FLOAT32_CBRT_EPS,"\nFLOAT32_CBRT_EPS\n    Cube root of single-precision floating-point epsilon.\n"
FLOAT32_EPS,"\nFLOAT32_EPS\n    Difference between one and the smallest value greater than one that can be\n    represented as a single-precision floating-point number.\n"
FLOAT32_EXPONENT_BIAS,"\nFLOAT32_EXPONENT_BIAS\n    The bias of a single-precision floating-point number's exponent.\n"
FLOAT32_MAX,"\nFLOAT32_MAX\n    Maximum single-precision floating-point number.\n"
FLOAT32_MAX_SAFE_INTEGER,"\nFLOAT32_MAX_SAFE_INTEGER\n    Maximum safe single-precision floating-point integer.\n"
FLOAT32_MIN_SAFE_INTEGER,"\nFLOAT32_MIN_SAFE_INTEGER\n    Minimum safe single-precision floating-point integer.\n"
FLOAT32_NINF,"\nFLOAT32_NINF\n    Single-precision floating-point negative infinity.\n"
FLOAT32_NUM_BYTES,"\nFLOAT32_NUM_BYTES\n    Size (in bytes) of a single-precision floating-point number.\n"
FLOAT32_PINF,"\nFLOAT32_PINF\n    Single-precision floating-point positive infinity.\n"
FLOAT32_PRECISION,"\nFLOAT32_PRECISION\n    Effective number of bits in the significand of a single-precision floating-\n    point number.\n"
FLOAT32_SMALLEST_NORMAL,"\nFLOAT32_SMALLEST_NORMAL\n    Smallest positive normalized single-precision floating-point number.\n"
FLOAT32_SMALLEST_SUBNORMAL,"\nFLOAT32_SMALLEST_SUBNORMAL\n    Smallest positive denormalized single-precision floating-point number.\n"
FLOAT32_SQRT_EPS,"\nFLOAT32_SQRT_EPS\n    Square root of single-precision floating-point epsilon.\n"
Float32Array,"\nFloat32Array()\n    A typed array constructor which returns a typed array representing an array\n    of single-precision floating-point numbers in the platform byte order.\n\nFloat32Array( length:integer )\n    Returns a typed array having a specified length.\n\nFloat32Array( typedarray:TypedArray )\n    Creates a typed array from another typed array.\n\nFloat32Array( obj:Object )\n    Creates a typed array from an array-like object or iterable.\n\nFloat32Array( buffer:ArrayBuffer[, byteOffset:integer[, length:integer]] )\n    Returns a typed array view of an ArrayBuffer.\n"
Float32Array.from,"\nFloat32Array.from( src:ArrayLike|Iterable[, map:Function[, thisArg:Any]] )\n    Creates a new typed array from an array-like object or an iterable.\n"
Float32Array.of,"\nFloat32Array.of( element0:number[, element1:number[, ...elementN:number]] )\n    Creates a new typed array from a variable number of arguments.\n"
Float32Array.BYTES_PER_ELEMENT,"\nFloat32Array.BYTES_PER_ELEMENT\n    Number of bytes per view element.\n"
Float32Array.name,"\nFloat32Array.name\n    Typed array constructor name.\n"
Float32Array.prototype.buffer,"\nFloat32Array.prototype.buffer\n    Read-only property which returns the ArrayBuffer referenced by the typed\n    array.\n"
Float32Array.prototype.byteLength,"\nFloat32Array.prototype.byteLength\n    Read-only property which returns the length (in bytes) of the typed array.\n"
Float32Array.prototype.byteOffset,"\nFloat32Array.prototype.byteOffset\n    Read-only property which returns the offset (in bytes) of the typed array\n    from the start of its ArrayBuffer.\n"
Float32Array.prototype.BYTES_PER_ELEMENT,"\nFloat32Array.prototype.BYTES_PER_ELEMENT\n    Number of bytes per view element.\n"
Float32Array.prototype.length,"\nFloat32Array.prototype.length\n    Read-only property which returns the number of view elements.\n"
Float32Array.prototype.copyWithin,"\nFloat32Array.prototype.copyWithin( target:integer, start:integer[, \n  end:integer] )\n    Copies a sequence of elements within the array starting at `start` and\n    ending at `end` (non-inclusive) to the position starting at `target`.\n"
Float32Array.prototype.entries,"\nFloat32Array.prototype.entries()\n    Returns an iterator for iterating over array key-value pairs.\n"
Float32Array.prototype.every,"\nFloat32Array.prototype.every( predicate:Function[, thisArg:Any] )\n    Tests whether all array elements pass a test implemented by a predicate\n    function.\n"
Float32Array.prototype.fill,"\nFloat32Array.prototype.fill( value:number[, start:integer[, end:integer]] )\n    Fills an array from a start index to an end index (non-inclusive) with a\n    provided value.\n"
Float32Array.prototype.filter,"\nFloat32Array.prototype.filter( predicate:Function[, thisArg:Any] )\n    Creates a new array which includes those elements for which a predicate\n    function returns a truthy value.\n"
Float32Array.prototype.find,"\nFloat32Array.prototype.find( predicate:Function[, thisArg:Any] )\n    Returns the first array element for which a provided predicate function\n    returns a truthy value.\n"
Float32Array.prototype.findIndex,"\nFloat32Array.prototype.findIndex( predicate:Function[, thisArg:Any] )\n    Returns the index of the first array element for which a provided predicate\n    function returns a truthy value.\n"
Float32Array.prototype.forEach,"\nFloat32Array.prototype.forEach( fcn:Function[, thisArg:Any] )\n    Invokes a callback for each array element.\n"
Float32Array.prototype.includes,"\nFloat32Array.prototype.includes( searchElement:number[, fromIndex:integer] )\n    Returns a boolean indicating whether an array includes a search element.\n"
Float32Array.prototype.indexOf,"\nFloat32Array.prototype.indexOf( searchElement:number[, fromIndex:integer] )\n    Returns the index of the first array element strictly equal to a search\n    element.\n"
Float32Array.prototype.join,"\nFloat32Array.prototype.join( [separator:string] )\n    Serializes an array by joining all array elements as a string.\n"
Float32Array.prototype.keys,"\nFloat32Array.prototype.keys()\n    Returns an iterator for iterating over array keys.\n"
Float32Array.prototype.lastIndexOf,"\nFloat32Array.prototype.lastIndexOf( searchElement:number[, fromIndex:integer] )\n    Returns the index of the last array element strictly equal to a search\n    element.\n"
Float32Array.prototype.map,"\nFloat32Array.prototype.map( fcn:Function[, thisArg:Any] )\n    Maps each array element to an element in a new typed array.\n"
Float32Array.prototype.reduce,"\nFloat32Array.prototype.reduce( fcn:Function[, initialValue:Any] )\n    Applies a function against an accumulator and each element in an array and\n    returns the accumulated result.\n"
Float32Array.prototype.reduceRight,"\nFloat32Array.prototype.reduceRight( fcn:Function[, initialValue:Any] )\n    Applies a function against an accumulator and each element in an array and\n    returns the accumulated result, iterating from right to left.\n"
Float32Array.prototype.reverse,"\nFloat32Array.prototype.reverse()\n    Reverses an array *in-place*.\n"
Float32Array.prototype.set,"\nFloat32Array.prototype.set( arr:ArrayLike[, offset:integer] )\n    Sets array elements.\n"
Float32Array.prototype.slice,"\nFloat32Array.prototype.slice( [begin:integer[, end:integer]] )\n    Copies array elements to a new array with the same underlying data type as\n    the host array.\n"
Float32Array.prototype.some,"\nFloat32Array.prototype.some( predicate:Function[, thisArg:Any] )\n    Tests whether at least one array element passes a test implemented by a\n    predicate function.\n"
Float32Array.prototype.sort,"\nFloat32Array.prototype.sort( [compareFunction:Function] )\n    Sorts an array *in-place*.\n"
Float32Array.prototype.subarray,"\nFloat32Array.prototype.subarray( [begin:integer[, end:integer]] )\n    Creates a new typed array over the same underlying ArrayBuffer and with the\n    same underlying data type as the host array.\n"
Float32Array.prototype.toLocaleString,"\nFloat32Array.prototype.toLocaleString( [locales:string|Array[, \n  options:Object]] )\n    Serializes an array as a locale-specific string.\n"
Float32Array.prototype.toString,"\nFloat32Array.prototype.toString()\n    Serializes an array as a string.\n"
Float32Array.prototype.values,"\nFloat32Array.prototype.values()\n    Returns an iterator for iterating over array elements.\n"
FLOAT64_EXPONENT_BIAS,"\nFLOAT64_EXPONENT_BIAS\n    The bias of a double-precision floating-point number's exponent.\n"
FLOAT64_HIGH_WORD_EXPONENT_MASK,"\nFLOAT64_HIGH_WORD_EXPONENT_MASK\n    High word mask for the exponent of a double-precision floating-point number.\n"
FLOAT64_HIGH_WORD_SIGNIFICAND_MASK,"\nFLOAT64_HIGH_WORD_SIGNIFICAND_MASK\n    High word mask for the significand of a double-precision floating-point\n    number.\n"
FLOAT64_MAX,"\nFLOAT64_MAX\n    Maximum double-precision floating-point number.\n"
FLOAT64_MAX_BASE2_EXPONENT,"\nFLOAT64_MAX_BASE2_EXPONENT\n    The maximum biased base 2 exponent for a double-precision floating-point\n    number.\n"
FLOAT64_MAX_BASE2_EXPONENT_SUBNORMAL,"\nFLOAT64_MAX_BASE2_EXPONENT_SUBNORMAL\n    The maximum biased base 2 exponent for a subnormal double-precision\n    floating-point number.\n"
FLOAT64_MAX_BASE10_EXPONENT,"\nFLOAT64_MAX_BASE10_EXPONENT\n    The maximum base 10 exponent for a double-precision floating-point number.\n"
FLOAT64_MAX_BASE10_EXPONENT_SUBNORMAL,"\nFLOAT64_MAX_BASE10_EXPONENT_SUBNORMAL\n    The maximum base 10 exponent for a subnormal double-precision floating-point\n    number.\n"
FLOAT64_MAX_LN,"\nFLOAT64_MAX_LN\n    Natural logarithm of the maximum double-precision floating-point number.\n"
FLOAT64_MAX_SAFE_FIBONACCI,"\nFLOAT64_MAX_SAFE_FIBONACCI\n    Maximum safe Fibonacci number when stored in double-precision floating-point\n    format.\n"
FLOAT64_MAX_SAFE_INTEGER,"\nFLOAT64_MAX_SAFE_INTEGER\n    Maximum safe double-precision floating-point integer.\n"
FLOAT64_MAX_SAFE_LUCAS,"\nFLOAT64_MAX_SAFE_LUCAS\n    Maximum safe Lucas number when stored in double-precision floating-point\n    format.\n"
FLOAT64_MAX_SAFE_NTH_FIBONACCI,"\nFLOAT64_MAX_SAFE_NTH_FIBONACCI\n    Maximum safe nth Fibonacci number when stored in double-precision floating-\n    point format.\n"
FLOAT64_MAX_SAFE_NTH_LUCAS,"\nFLOAT64_MAX_SAFE_NTH_LUCAS\n    Maximum safe nth Lucas number when stored in double-precision floating-point\n    format.\n"
FLOAT64_MIN_BASE2_EXPONENT,"\nFLOAT64_MIN_BASE2_EXPONENT\n    The minimum biased base 2 exponent for a normalized double-precision\n    floating-point number.\n"
FLOAT64_MIN_BASE2_EXPONENT_SUBNORMAL,"\nFLOAT64_MIN_BASE2_EXPONENT_SUBNORMAL\n    The minimum biased base 2 exponent for a subnormal double-precision\n    floating-point number.\n"
FLOAT64_MIN_BASE10_EXPONENT,"\nFLOAT64_MIN_BASE10_EXPONENT\n    The minimum base 10 exponent for a normalized double-precision floating-\n    point number.\n"
FLOAT64_MIN_BASE10_EXPONENT_SUBNORMAL,"\nFLOAT64_MIN_BASE10_EXPONENT_SUBNORMAL\n    The minimum base 10 exponent for a subnormal double-precision floating-\n    point number.\n"
FLOAT64_MIN_LN,"\nFLOAT64_MIN_LN\n    Natural logarithm of the smallest normalized double-precision floating-point\n    number.\n"
FLOAT64_MIN_SAFE_INTEGER,"\nFLOAT64_MIN_SAFE_INTEGER\n    Minimum safe double-precision floating-point integer.\n"
FLOAT64_NUM_BYTES,"\nFLOAT64_NUM_BYTES\n    Size (in bytes) of a double-precision floating-point number.\n"
FLOAT64_PRECISION,"\nFLOAT64_PRECISION\n    Effective number of bits in the significand of a double-precision floating-\n    point number.\n"
FLOAT64_SMALLEST_NORMAL,"\nFLOAT64_SMALLEST_NORMAL\n    Smallest positive normalized double-precision floating-point number.\n"
FLOAT64_SMALLEST_SUBNORMAL,"\nFLOAT64_SMALLEST_SUBNORMAL\n    Smallest positive denormalized double-precision floating-point number.\n"
Float64Array,"\nFloat64Array()\n    A typed array constructor which returns a typed array representing an array\n    of double-precision floating-point numbers in the platform byte order.\n\nFloat64Array( length:integer )\n    Returns a typed array having a specified length.\n\nFloat64Array( typedarray:TypedArray )\n    Creates a typed array from another typed array.\n\nFloat64Array( obj:Object )\n    Creates a typed array from an array-like object or iterable.\n\nFloat64Array( buffer:ArrayBuffer[, byteOffset:integer[, length:integer]] )\n    Returns a typed array view of an ArrayBuffer.\n"
Float64Array.from,"\nFloat64Array.from( src:ArrayLike|Iterable[, map:Function[, thisArg:Any]] )\n    Creates a new typed array from an array-like object or an iterable.\n"
Float64Array.of,"\nFloat64Array.of( element0:number[, element1:number[, ...elementN:number]] )\n    Creates a new typed array from a variable number of arguments.\n"
Float64Array.BYTES_PER_ELEMENT,"\nFloat64Array.BYTES_PER_ELEMENT\n    Number of bytes per view element.\n"
Float64Array.name,"\nFloat64Array.name\n    Typed array constructor name.\n"
Float64Array.prototype.buffer,"\nFloat64Array.prototype.buffer\n    Read-only property which returns the ArrayBuffer referenced by the typed\n    array.\n"
Float64Array.prototype.byteLength,"\nFloat64Array.prototype.byteLength\n    Read-only property which returns the length (in bytes) of the typed array.\n"
Float64Array.prototype.byteOffset,"\nFloat64Array.prototype.byteOffset\n    Read-only property which returns the offset (in bytes) of the typed array\n    from the start of its ArrayBuffer.\n"
Float64Array.prototype.BYTES_PER_ELEMENT,"\nFloat64Array.prototype.BYTES_PER_ELEMENT\n    Number of bytes per view element.\n"
Float64Array.prototype.length,"\nFloat64Array.prototype.length\n    Read-only property which returns the number of view elements.\n"
Float64Array.prototype.copyWithin,"\nFloat64Array.prototype.copyWithin( target:integer, start:integer[, \n  end:integer] )\n    Copies a sequence of elements within the array starting at `start` and\n    ending at `end` (non-inclusive) to the position starting at `target`.\n"
Float64Array.prototype.entries,"\nFloat64Array.prototype.entries()\n    Returns an iterator for iterating over array key-value pairs.\n"
Float64Array.prototype.every,"\nFloat64Array.prototype.every( predicate:Function[, thisArg:Any] )\n    Tests whether all array elements pass a test implemented by a predicate\n    function.\n"
Float64Array.prototype.fill,"\nFloat64Array.prototype.fill( value:number[, start:integer[, end:integer]] )\n    Fills an array from a start index to an end index (non-inclusive) with a\n    provided value.\n"
Float64Array.prototype.filter,"\nFloat64Array.prototype.filter( predicate:Function[, thisArg:Any] )\n    Creates a new array which includes those elements for which a predicate\n    function returns a truthy value.\n"
Float64Array.prototype.find,"\nFloat64Array.prototype.find( predicate:Function[, thisArg:Any] )\n    Returns the first array element for which a provided predicate function\n    returns a truthy value.\n"
Float64Array.prototype.findIndex,"\nFloat64Array.prototype.findIndex( predicate:Function[, thisArg:Any] )\n    Returns the index of the first array element for which a provided predicate\n    function returns a truthy value.\n"
Float64Array.prototype.forEach,"\nFloat64Array.prototype.forEach( fcn:Function[, thisArg:Any] )\n    Invokes a callback for each array element.\n"
Float64Array.prototype.includes,"\nFloat64Array.prototype.includes( searchElement:number[, fromIndex:integer] )\n    Returns a boolean indicating whether an array includes a search element.\n"
Float64Array.prototype.indexOf,"\nFloat64Array.prototype.indexOf( searchElement:number[, fromIndex:integer] )\n    Returns the index of the first array element strictly equal to a search\n    element.\n"
Float64Array.prototype.join,"\nFloat64Array.prototype.join( [separator:string] )\n    Serializes an array by joining all array elements as a string.\n"
Float64Array.prototype.keys,"\nFloat64Array.prototype.keys()\n    Returns an iterator for iterating over array keys.\n"
Float64Array.prototype.lastIndexOf,"\nFloat64Array.prototype.lastIndexOf( searchElement:number[, fromIndex:integer] )\n    Returns the index of the last array element strictly equal to a search\n    element.\n"
Float64Array.prototype.map,"\nFloat64Array.prototype.map( fcn:Function[, thisArg:Any] )\n    Maps each array element to an element in a new typed array.\n"
Float64Array.prototype.reduce,"\nFloat64Array.prototype.reduce( fcn:Function[, initialValue:Any] )\n    Applies a function against an accumulator and each element in an array and\n    returns the accumulated result.\n"
Float64Array.prototype.reduceRight,"\nFloat64Array.prototype.reduceRight( fcn:Function[, initialValue:Any] )\n    Applies a function against an accumulator and each element in an array and\n    returns the accumulated result, iterating from right to left.\n"
Float64Array.prototype.reverse,"\nFloat64Array.prototype.reverse()\n    Reverses an array *in-place*.\n"
Float64Array.prototype.set,"\nFloat64Array.prototype.set( arr:ArrayLike[, offset:integer] )\n    Sets array elements.\n"
Float64Array.prototype.slice,"\nFloat64Array.prototype.slice( [begin:integer[, end:integer]] )\n    Copies array elements to a new array with the same underlying data type as\n    the host array.\n"
Float64Array.prototype.some,"\nFloat64Array.prototype.some( predicate:Function[, thisArg:Any] )\n    Tests whether at least one array element passes a test implemented by a\n    predicate function.\n"
Float64Array.prototype.sort,"\nFloat64Array.prototype.sort( [compareFunction:Function] )\n    Sorts an array *in-place*.\n"
Float64Array.prototype.subarray,"\nFloat64Array.prototype.subarray( [begin:integer[, end:integer]] )\n    Creates a new typed array over the same underlying ArrayBuffer and with the\n    same underlying data type as the host array.\n"
Float64Array.prototype.toLocaleString,"\nFloat64Array.prototype.toLocaleString( [locales:string|Array[, \n  options:Object]] )\n    Serializes an array as a locale-specific string.\n"
Float64Array.prototype.toString,"\nFloat64Array.prototype.toString()\n    Serializes an array as a string.\n"
Float64Array.prototype.values,"\nFloat64Array.prototype.values()\n    Returns an iterator for iterating over array elements.\n"
forEach,"\nforEach( collection:Array|TypedArray|Object, fcn:Function[, thisArg:any] )\n    Invokes a function for each element in a collection.\n"
forEachAsync,"\nforEachAsync( collection:Array|TypedArray|Object, [options:Object,] \n  fcn:Function, done:Function )\n    Invokes a function once for each element in a collection.\n"
forEachAsync.factory,"\nforEachAsync.factory( [options:Object,] fcn:Function )\n    Returns a function which invokes a function once for each element in a\n    collection.\n"
forEachRight,"\nforEachRight( collection:Array|TypedArray|Object, fcn:Function[, thisArg:any] )\n    Invokes a function for each element in a collection, iterating from right to\n    left.\n"
forEachRightAsync,"\nforEachRightAsync( collection:Array|TypedArray|Object, [options:Object,] \n  fcn:Function, done:Function )\n    Invokes a function once for each element in a collection, iterating from\n    right to left.\n"
forEachRightAsync.factory,"\nforEachRightAsync.factory( [options:Object,] fcn:Function )\n    Returns a function which invokes a function once for each element in a\n    collection, iterating from right to left.\n"
forIn,"\nforIn( obj:Object, fcn:Function[, thisArg:any] )\n    Invokes a function for each own and inherited enumerable property of an\n    object.\n"
forOwn,"\nforOwn( obj:Object, fcn:Function[, thisArg:any] )\n    Invokes a function for each own enumerable property of an object.\n"
FOURTH_PI,"\nFOURTH_PI\n    One fourth times the mathematical constant `π`.\n"
FOURTH_ROOT_EPS,"\nFOURTH_ROOT_EPS\n    Fourth root of double-precision floating-point epsilon.\n"
FRB_SF_WAGE_RIGIDITY,"\nFRB_SF_WAGE_RIGIDITY()\n    Returns wage rates for U.S. workers that have not changed jobs within the\n    year.\n"
fromCodePoint,"\nfromCodePoint( ...pt:integer )\n    Creates a string from a sequence of Unicode code points.\n"
functionName,"\nfunctionName( fcn:Function )\n    Returns the name of a function.\n"
functionSequence,"\nfunctionSequence( ...fcn:Function )\n    Returns a pipeline function.\n"
functionSequenceAsync,"\nfunctionSequenceAsync( ...fcn:Function )\n    Returns a pipeline function.\n"
GAMMA_LANCZOS_G,"\nGAMMA_LANCZOS_G\n    Arbitrary constant `g` to be used in Lanczos approximation functions.\n"
gdot,"\ngdot( x:ndarray|ArrayLikeObject, y:ndarray|ArrayLikeObject )\n    Computes the dot product of two vectors.\n"
getegid,"\ngetegid()\n    Returns the effective numeric group identity of the calling process.\n"
geteuid,"\ngeteuid()\n    Returns the effective numeric user identity of the calling process.\n"
getgid,"\ngetgid()\n    Returns the numeric group identity of the calling process.\n"
getGlobal,"\ngetGlobal( [codegen:boolean] )\n    Returns the global object.\n"
getPrototypeOf,"\ngetPrototypeOf( value:any )\n    Returns the prototype of a provided object.\n"
getuid,"\ngetuid()\n    Returns the numeric user identity of the calling process.\n"
GLAISHER,"\nGLAISHER\n    Glaisher-Kinkelin constant.\n"
group,"\ngroup( collection:Array|TypedArray|Object, [options:Object,] \n  groups:Array|TypedArray|Object )\n    Groups values as arrays associated with distinct keys.\n"
groupBy,"\ngroupBy( collection:Array|TypedArray|Object, [options:Object,] \n  indicator:Function )\n    Groups values according to an indicator function.\n"
groupByAsync,"\ngroupByAsync( collection:Array|TypedArray|Object, [options:Object,] \n  indicator:Function, done:Function )\n    Groups values according to an indicator function.\n"
groupByAsync.factory,"\ngroupByAsync.factory( [options:Object,] indicator:Function )\n    Returns a function which groups values according to an indicator function.\n"
groupIn,"\ngroupIn( obj:Object|Array|TypedArray, [options:Object,] indicator:Function )\n    Group values according to an indicator function.\n"
groupOwn,"\ngroupOwn( obj:Object|Array|TypedArray, [options:Object,] indicator:Function )\n    Group values according to an indicator function.\n"
gswap,"\ngswap( x:ndarray|ArrayLikeObject, y:ndarray|ArrayLikeObject )\n    Interchanges two vectors.\n"
HALF_LN2,"\nHALF_LN2\n    One half times the natural logarithm of `2`.\n"
HALF_PI,"\nHALF_PI\n    One half times the mathematical constant `π`.\n"
HARRISON_BOSTON_HOUSE_PRICES,"\nHARRISON_BOSTON_HOUSE_PRICES()\n    Returns a dataset derived from information collected by the US Census\n    Service concerning housing in Boston, Massachusetts (1978).\n"
HARRISON_BOSTON_HOUSE_PRICES_CORRECTED,"\nHARRISON_BOSTON_HOUSE_PRICES_CORRECTED()\n    Returns a (corrected) dataset derived from information collected by the US\n    Census Service concerning housing in Boston, Massachusetts (1978).\n"
hasArrayBufferSupport,"\nhasArrayBufferSupport()\n    Tests for native `ArrayBuffer` support.\n"
hasAsyncAwaitSupport,"\nhasAsyncAwaitSupport()\n    Tests for native `async`/`await` support.\n"
hasAsyncIteratorSymbolSupport,"\nhasAsyncIteratorSymbolSupport()\n    Tests for native `Symbol.asyncIterator` support.\n"
hasBigInt64ArraySupport,"\nhasBigInt64ArraySupport()\n    Tests for native `BigInt64Array` support.\n"
hasBigIntSupport,"\nhasBigIntSupport()\n    Tests for native `BigInt` support.\n"
hasBigUint64ArraySupport,"\nhasBigUint64ArraySupport()\n    Tests for native `BigUint64Array` support.\n"
hasClassSupport,"\nhasClassSupport()\n    Tests for native `class` support.\n"
hasDefinePropertiesSupport,"\nhasDefinePropertiesSupport()\n    Tests for `Object.defineProperties` support.\n"
hasDefinePropertySupport,"\nhasDefinePropertySupport()\n    Tests for `Object.defineProperty` support.\n"
hasFloat32ArraySupport,"\nhasFloat32ArraySupport()\n    Tests for native `Float32Array` support.\n"
hasFloat64ArraySupport,"\nhasFloat64ArraySupport()\n    Tests for native `Float64Array` support.\n"
hasFunctionNameSupport,"\nhasFunctionNameSupport()\n    Tests for native function `name` support.\n"
hasGeneratorSupport,"\nhasGeneratorSupport()\n    Tests whether an environment supports native generator functions.\n"
hasGlobalThisSupport,"\nhasGlobalThisSupport()\n    Tests for `globalThis` support.\n"
hasInt8ArraySupport,"\nhasInt8ArraySupport()\n    Tests for native `Int8Array` support.\n"
hasInt16ArraySupport,"\nhasInt16ArraySupport()\n    Tests for native `Int16Array` support.\n"
hasInt32ArraySupport,"\nhasInt32ArraySupport()\n    Tests for native `Int32Array` support.\n"
hasIteratorSymbolSupport,"\nhasIteratorSymbolSupport()\n    Tests for native `Symbol.iterator` support.\n"
hasMapSupport,"\nhasMapSupport()\n    Tests for native `Map` support.\n"
hasNodeBufferSupport,"\nhasNodeBufferSupport()\n    Tests for native `Buffer` support.\n"
hasOwnProp,"\nhasOwnProp( value:any, property:any )\n    Tests if an object has a specified property.\n"
hasProp,"\nhasProp( value:any, property:any )\n    Tests if an object has a specified property, either own or inherited.\n"
hasProxySupport,"\nhasProxySupport()\n    Tests whether an environment has native `Proxy` support.\n"
hasSetSupport,"\nhasSetSupport()\n    Tests for native `Set` support.\n"
hasSharedArrayBufferSupport,"\nhasSharedArrayBufferSupport()\n    Tests for native `SharedArrayBuffer` support.\n"
hasSymbolSupport,"\nhasSymbolSupport()\n    Tests for native `Symbol` support.\n"
hasToStringTagSupport,"\nhasToStringTagSupport()\n    Tests for native `toStringTag` support.\n"
hasUint8ArraySupport,"\nhasUint8ArraySupport()\n    Tests for native `Uint8Array` support.\n"
hasUint8ClampedArraySupport,"\nhasUint8ClampedArraySupport()\n    Tests for native `Uint8ClampedArray` support.\n"
hasUint16ArraySupport,"\nhasUint16ArraySupport()\n    Tests for native `Uint16Array` support.\n"
hasUint32ArraySupport,"\nhasUint32ArraySupport()\n    Tests for native `Uint32Array` support.\n"
hasUTF16SurrogatePairAt,"\nhasUTF16SurrogatePairAt( str:string, pos:integer )\n    Tests if a position in a string marks the start of a UTF-16 surrogate pair.\n"
hasWeakMapSupport,"\nhasWeakMapSupport()\n    Tests for native `WeakMap` support.\n"
hasWeakSetSupport,"\nhasWeakSetSupport()\n    Tests for native `WeakSet` support.\n"
hasWebAssemblySupport,"\nhasWebAssemblySupport()\n    Tests for native WebAssembly support.\n"
HERNDON_VENUS_SEMIDIAMETERS,"\nHERNDON_VENUS_SEMIDIAMETERS()\n    Returns fifteen observations of the vertical semidiameter of Venus, made by\n    Lieutenant Herndon, with the meridian circle at Washington, in the year\n    1846.\n"
homedir,"\nhomedir()\n    Returns the current user's home directory.\n"
HOURS_IN_DAY,"\nHOURS_IN_DAY\n    Number of hours in a day.\n"
HOURS_IN_WEEK,"\nHOURS_IN_WEEK\n    Number of hours in a week.\n"
hoursInMonth,"\nhoursInMonth( [month:string|Date|integer[, year:integer]] )\n    Returns the number of hours in a month.\n"
hoursInYear,"\nhoursInYear( [value:integer|Date] )\n    Returns the number of hours in a year according to the Gregorian calendar.\n"
httpServer,"\nhttpServer( [options:Object,] [requestListener:Function] )\n    Returns a function to create an HTTP server.\n"
identity,"\nidentity( x:any )\n    Identity function.\n"
ifelse,"\nifelse( bool:boolean, x:any, y:any )\n    If a condition is truthy, returns `x`; otherwise, returns `y`.\n"
ifelseAsync,"\nifelseAsync( predicate:Function, x:any, y:any, done:Function )\n    If a predicate function returns a truthy value, returns `x`; otherwise,\n    returns `y`.\n"
ifthen,"\nifthen( bool:boolean, x:Function, y:Function )\n    If a condition is truthy, invoke `x`; otherwise, invoke `y`.\n"
ifthenAsync,"\nifthenAsync( predicate:Function, x:Function, y:Function, done:Function )\n    If a predicate function returns a truthy value, invokes `x`; otherwise,\n    invokes `y`.\n"
imag,"\nimag( z:Complex )\n    Returns the imaginary component of a complex number.\n"
IMG_ACANTHUS_MOLLIS,"\nIMG_ACANTHUS_MOLLIS()\n    Returns a `Buffer` containing image data of Karl Blossfeldt's gelatin silver\n    print *Acanthus mollis*.\n"
IMG_AIRPLANE_FROM_ABOVE,"\nIMG_AIRPLANE_FROM_ABOVE()\n    Returns a `Buffer` containing image data of Fédèle Azari's gelatin silver\n    print of an airplane, viewed from above looking down.\n"
IMG_ALLIUM_OREOPHILUM,"\nIMG_ALLIUM_OREOPHILUM()\n    Returns a `Buffer` containing image data of Karl Blossfeldt's gelatin silver\n    print *Allium ostrowskianum*.\n"
IMG_BLACK_CANYON,"\nIMG_BLACK_CANYON()\n    Returns a `Buffer` containing image data of Timothy H. O'Sullivan's albumen\n    silver print *Black Cañon, Colorado River, From Camp 8, Looking Above*.\n"
IMG_DUST_BOWL_HOME,"\nIMG_DUST_BOWL_HOME()\n    Returns a `Buffer` containing image data of Dorothea Lange's gelatin silver\n    print of an abandoned Dust Bowl home.\n"
IMG_FRENCH_ALPINE_LANDSCAPE,"\nIMG_FRENCH_ALPINE_LANDSCAPE()\n    Returns a `Buffer` containing image data of Adolphe Braun's carbon print of\n    a French alpine landscape.\n"
IMG_LOCOMOTION_HOUSE_CAT,"\nIMG_LOCOMOTION_HOUSE_CAT()\n    Returns a `Buffer` containing image data of Eadweard J. Muybridge's\n    collotype of a house cat (24 views).\n"
IMG_LOCOMOTION_NUDE_MALE,"\nIMG_LOCOMOTION_NUDE_MALE()\n    Returns a `Buffer` containing image data of Eadweard J. Muybridge's\n    collotype of a nude male moving in place (48 views).\n"
IMG_MARCH_PASTORAL,"\nIMG_MARCH_PASTORAL()\n    Returns a `Buffer` containing image data of Peter Henry Emerson's\n    photogravure of sheep in a pastoral setting.\n"
IMG_NAGASAKI_BOATS,"\nIMG_NAGASAKI_BOATS()\n    Returns a `Buffer` containing image data of Felice Beato's albumen silver\n    print of boats in a river in Nagasaki.\n"
incrapcorr,"\nincrapcorr( [mx:number, my:number] )\n    Returns an accumulator function which incrementally computes the absolute\n    value of the sample Pearson product-moment correlation coefficient.\n"
incrBinaryClassification,"\nincrBinaryClassification( N:integer[, options:Object] )\n    Returns an accumulator function which incrementally performs binary\n    classification using stochastic gradient descent (SGD).\n"
incrcount,"\nincrcount()\n    Returns an accumulator function which incrementally updates a count.\n"
incrcovariance,"\nincrcovariance( [mx:number, my:number] )\n    Returns an accumulator function which incrementally computes an unbiased\n    sample covariance.\n"
incrcovmat,"\nincrcovmat( out:integer|ndarray[, means:ndarray] )\n    Returns an accumulator function which incrementally computes an unbiased\n    sample covariance matrix.\n"
incrcv,"\nincrcv( [mean:number] )\n    Returns an accumulator function which incrementally computes the coefficient\n    of variation (CV).\n"
increwmean,"\nincrewmean( α:number )\n    Returns an accumulator function which incrementally computes an\n    exponentially weighted mean, where α is a smoothing factor between 0 and 1.\n"
increwstdev,"\nincrewstdev( α:number )\n    Returns an accumulator function which incrementally computes an\n    exponentially weighted standard deviation, where α is a smoothing factor\n    between 0 and 1.\n"
increwvariance,"\nincrewvariance( α:number )\n    Returns an accumulator function which incrementally computes an\n    exponentially weighted variance, where α is a smoothing factor between 0 and\n    1.\n"
incrgmean,"\nincrgmean()\n    Returns an accumulator function which incrementally computes a geometric\n    mean.\n"
incrgrubbs,"\nincrgrubbs( [options:Object] )\n    Returns an accumulator function which incrementally performs Grubbs' test\n    for detecting outliers.\n"
incrhmean,"\nincrhmean()\n    Returns an accumulator function which incrementally computes a harmonic\n    mean.\n"
incrkmeans,"\nincrkmeans( k:integer|ndarray[, ndims:integer][, options:Object] )\n    Returns an accumulator function which incrementally partitions data into `k`\n    clusters.\n"
incrkurtosis,"\nincrkurtosis()\n    Returns an accumulator function which incrementally computes a corrected\n    sample excess kurtosis.\n"
incrmaape,"\nincrmaape()\n    Returns an accumulator function which incrementally computes the mean\n    arctangent absolute percentage error (MAAPE).\n"
incrmae,"\nincrmae()\n    Returns an accumulator function which incrementally computes the mean\n    absolute error (MAE).\n"
incrmapcorr,"\nincrmapcorr( W:integer[, mx:number, my:number] )\n    Returns an accumulator function which incrementally computes a moving\n    sample absolute Pearson product-moment correlation coefficient.\n"
incrmape,"\nincrmape()\n    Returns an accumulator function which incrementally computes the mean\n    absolute percentage error (MAPE).\n"
incrmax,"\nincrmax()\n    Returns an accumulator function which incrementally computes a maximum\n    value.\n"
incrmaxabs,"\nincrmaxabs()\n    Returns an accumulator function which incrementally computes a maximum\n    absolute value.\n"
incrmcovariance,"\nincrmcovariance( W:integer[, mx:number, my:number] )\n    Returns an accumulator function which incrementally computes a moving\n    unbiased sample covariance.\n"
incrmcv,"\nincrmcv( W:integer[, mean:number] )\n    Returns an accumulator function which incrementally computes a moving\n    coefficient of variation (CV).\n"
incrmda,"\nincrmda()\n    Returns an accumulator function which incrementally computes the mean\n    directional accuracy (MDA).\n"
incrme,"\nincrme()\n    Returns an accumulator function which incrementally computes the mean error\n    (ME).\n"
incrmean,"\nincrmean()\n    Returns an accumulator function which incrementally computes an arithmetic\n    mean.\n"
incrmeanabs,"\nincrmeanabs()\n    Returns an accumulator function which incrementally computes an arithmetic\n    mean of absolute values.\n"
incrmeanabs2,"\nincrmeanabs2()\n    Returns an accumulator function which incrementally computes an arithmetic\n    mean of squared absolute values.\n"
incrmeanstdev,"\nincrmeanstdev( [out:Array|TypedArray] )\n    Returns an accumulator function which incrementally computes an arithmetic\n    mean and corrected sample standard deviation.\n"
incrmeanvar,"\nincrmeanvar( [out:Array|TypedArray] )\n    Returns an accumulator function which incrementally computes an arithmetic\n    mean and unbiased sample variance.\n"
incrmgmean,"\nincrmgmean( W:integer )\n    Returns an accumulator function which incrementally computes a moving\n    geometric mean.\n"
incrmgrubbs,"\nincrmgrubbs( W:integer[, options:Object] )\n    Returns an accumulator function which incrementally performs a moving\n    Grubbs' test for detecting outliers.\n"
incrmhmean,"\nincrmhmean( W:integer )\n    Returns an accumulator function which incrementally computes a moving\n    harmonic mean.\n"
incrmidrange,"\nincrmidrange()\n    Returns an accumulator function which incrementally computes a mid-range.\n"
incrmin,"\nincrmin()\n    Returns an accumulator function which incrementally computes a minimum\n    value.\n"
incrminabs,"\nincrminabs()\n    Returns an accumulator function which incrementally computes a minimum\n    absolute value.\n"
incrminmax,"\nincrminmax( [out:Array|TypedArray] )\n    Returns an accumulator function which incrementally computes a minimum and\n    maximum.\n"
incrminmaxabs,"\nincrminmaxabs( [out:Array|TypedArray] )\n    Returns an accumulator function which incrementally computes a minimum and\n    maximum absolute value.\n"
incrmmaape,"\nincrmmaape( W:integer )\n    Returns an accumulator function which incrementally computes a moving\n    mean arctangent absolute percentage error (MAAPE).\n"
incrmmae,"\nincrmmae( W:integer )\n    Returns an accumulator function which incrementally computes a moving\n    mean absolute error (MAE).\n"
incrmmape,"\nincrmmape( W:integer )\n    Returns an accumulator function which incrementally computes a moving\n    mean absolute percentage error (MAPE).\n"
incrmmax,"\nincrmmax( W:integer )\n    Returns an accumulator function which incrementally computes a moving\n    maximum value.\n"
incrmmaxabs,"\nincrmmaxabs( W:integer )\n    Returns an accumulator function which incrementally computes a moving\n    maximum absolute value.\n"
incrmmda,"\nincrmmda( W:integer )\n    Returns an accumulator function which incrementally computes a moving\n    mean directional accuracy (MDA).\n"
incrmme,"\nincrmme( W:integer )\n    Returns an accumulator function which incrementally computes a moving\n    mean error (ME).\n"
incrmmean,"\nincrmmean( W:integer )\n    Returns an accumulator function which incrementally computes a moving\n    arithmetic mean.\n"
incrmmeanabs,"\nincrmmeanabs( W:integer )\n    Returns an accumulator function which incrementally computes a moving\n    arithmetic mean of absolute values.\n"
incrmmeanabs2,"\nincrmmeanabs2( W:integer )\n    Returns an accumulator function which incrementally computes a moving\n    arithmetic mean of squared absolute values.\n"
incrmmeanstdev,"\nincrmmeanstdev( [out:Array|TypedArray,] W:integer )\n    Returns an accumulator function which incrementally computes a moving\n    arithmetic mean and corrected sample standard deviation.\n"
incrmmeanvar,"\nincrmmeanvar( [out:Array|TypedArray,] W:integer )\n    Returns an accumulator function which incrementally computes a moving\n    arithmetic mean and unbiased sample variance.\n"
incrmmidrange,"\nincrmmidrange( W:integer )\n    Returns an accumulator function which incrementally computes a moving mid-\n    range.\n"
incrmmin,"\nincrmmin( W:integer )\n    Returns an accumulator function which incrementally computes a moving\n    minimum value.\n"
incrmminabs,"\nincrmminabs( W:integer )\n    Returns an accumulator function which incrementally computes a moving\n    minimum absolute value.\n"
incrmminmax,"\nincrmminmax( [out:Array|TypedArray,] W:integer )\n    Returns an accumulator function which incrementally computes a moving\n    minimum and maximum.\n"
incrmminmaxabs,"\nincrmminmaxabs( [out:Array|TypedArray,] W:integer )\n    Returns an accumulator function which incrementally computes moving minimum\n    and maximum absolute values.\n"
incrmmpe,"\nincrmmpe( W:integer )\n    Returns an accumulator function which incrementally computes a moving\n    mean percentage error (MPE).\n"
incrmmse,"\nincrmmse( W:integer )\n    Returns an accumulator function which incrementally computes a moving mean\n    squared error (MSE).\n"
incrmpcorr,"\nincrmpcorr( W:integer[, mx:number, my:number] )\n    Returns an accumulator function which incrementally computes a moving\n    sample Pearson product-moment correlation coefficient.\n"
incrmpcorr2,"\nincrmpcorr2( W:integer[, mx:number, my:number] )\n    Returns an accumulator function which incrementally computes a moving\n    squared sample Pearson product-moment correlation coefficient.\n"
incrmpcorrdist,"\nincrmpcorrdist( W:integer[, mx:number, my:number] )\n    Returns an accumulator function which incrementally computes a moving\n    sample Pearson product-moment correlation distance.\n"
incrmpe,"\nincrmpe()\n    Returns an accumulator function which incrementally computes the mean\n    percentage error (MPE).\n"
incrmprod,"\nincrmprod( W:integer )\n    Returns an accumulator function which incrementally computes a moving\n    product.\n"
incrmrange,"\nincrmrange( W:integer )\n    Returns an accumulator function which incrementally computes a moving range.\n"
incrmrmse,"\nincrmrmse( W:integer )\n    Returns an accumulator function which incrementally computes a moving root\n    mean squared error (RMSE).\n"
incrmrss,"\nincrmrss( W:integer )\n    Returns an accumulator function which incrementally computes a moving\n    residual sum of squares (RSS).\n"
incrmse,"\nincrmse()\n    Returns an accumulator function which incrementally computes the mean\n    squared error (MSE).\n"
incrmstdev,"\nincrmstdev( W:integer[, mean:number] )\n    Returns an accumulator function which incrementally computes a moving\n    corrected sample standard deviation.\n"
incrmsum,"\nincrmsum( W:integer )\n    Returns an accumulator function which incrementally computes a moving sum.\n"
incrmsumabs,"\nincrmsumabs( W:integer )\n    Returns an accumulator function which incrementally computes a moving sum of\n    absolute values.\n"
incrmsumabs2,"\nincrmsumabs2( W:integer )\n    Returns an accumulator function which incrementally computes a moving sum of\n    squared absolute values.\n"
incrmsummary,"\nincrmsummary( W:integer )\n    Returns an accumulator function which incrementally computes a moving\n    statistical summary.\n"
incrmsumprod,"\nincrmsumprod( W:integer )\n    Returns an accumulator function which incrementally computes a moving sum of\n    products.\n"
incrmvariance,"\nincrmvariance( W:integer[, mean:number] )\n    Returns an accumulator function which incrementally computes a moving\n    unbiased sample variance.\n"
incrmvmr,"\nincrmvmr( W:integer[, mean:number] )\n    Returns an accumulator function which incrementally computes a moving\n    variance-to-mean (VMR).\n"
incrnancount,"\nincrnancount()\n    Returns an accumulator function which incrementally updates a count,\n    ignoring `NaN` values.\n"
incrnansum,"\nincrnansum()\n    Returns an accumulator function which incrementally computes a sum, ignoring\n    `NaN` values.\n"
incrnansumabs,"\nincrnansumabs()\n    Returns an accumulator function which incrementally computes a sum of\n    absolute values, ignoring NaN values.\n"
incrnansumabs2,"\nincrnansumabs2()\n    Returns an accumulator function which incrementally computes a sum of\n    squared absolute values, ignoring NaN values.\n"
incrpcorr,"\nincrpcorr( [mx:number, my:number] )\n    Returns an accumulator function which incrementally computes a sample\n    Pearson product-moment correlation coefficient.\n"
incrpcorr2,"\nincrpcorr2( [mx:number, my:number] )\n    Returns an accumulator function which incrementally computes the squared\n    sample Pearson product-moment correlation coefficient.\n"
incrpcorrdist,"\nincrpcorrdist( [mx:number, my:number] )\n    Returns an accumulator function which incrementally computes a sample\n    Pearson product-moment correlation distance.\n"
incrpcorrdistmat,"\nincrpcorrdistmat( out:integer|ndarray[, means:ndarray] )\n    Returns an accumulator function which incrementally computes a sample\n    Pearson product-moment correlation distance matrix.\n"
incrpcorrmat,"\nincrpcorrmat( out:integer|ndarray[, means:ndarray] )\n    Returns an accumulator function which incrementally computes a sample\n    Pearson product-moment correlation matrix.\n"
incrprod,"\nincrprod()\n    Returns an accumulator function which incrementally computes a product.\n"
incrrange,"\nincrrange()\n    Returns an accumulator function which incrementally computes a range.\n"
incrrmse,"\nincrrmse()\n    Returns an accumulator function which incrementally computes the root mean\n    squared error (RMSE).\n"
incrrss,"\nincrrss()\n    Returns an accumulator function which incrementally computes the residual\n    sum of squares (RSS).\n"
incrskewness,"\nincrskewness()\n    Returns an accumulator function which incrementally computes a corrected\n    sample skewness.\n"
incrspace,"\nincrspace( start:number, stop:number[, increment:number] )\n    Generates a linearly spaced numeric array using a provided increment.\n"
incrstdev,"\nincrstdev( [mean:number] )\n    Returns an accumulator function which incrementally computes a corrected\n    sample standard deviation.\n"
incrsum,"\nincrsum()\n    Returns an accumulator function which incrementally computes a sum.\n"
incrsumabs,"\nincrsumabs()\n    Returns an accumulator function which incrementally computes a sum of\n    absolute values.\n"
incrsumabs2,"\nincrsumabs2()\n    Returns an accumulator function which incrementally computes a sum of\n    squared absolute values.\n"
incrsummary,"\nincrsummary()\n    Returns an accumulator function which incrementally computes a statistical\n    summary.\n"
incrsumprod,"\nincrsumprod()\n    Returns an accumulator function which incrementally computes a sum of\n    products.\n"
incrvariance,"\nincrvariance( [mean:number] )\n    Returns an accumulator function which incrementally computes an unbiased\n    sample variance.\n"
incrvmr,"\nincrvmr( [mean:number] )\n    Returns an accumulator function which incrementally computes a variance-to-\n    mean ratio (VMR).\n"
incrwmean,"\nincrwmean()\n    Returns an accumulator function which incrementally computes a weighted\n    arithmetic mean.\n"
ind2sub,"\nind2sub( shape:ArrayLike, idx:integer[, options:Object] )\n    Converts a linear index to an array of subscripts.\n"
ind2sub.assign,"\nind2sub.assign( shape:ArrayLike, idx:integer[, options:Object], \n  out:Array|TypedArray|Object )\n    Converts a linear index to an array of subscripts and assigns results to a\n    provided output array.\n"
indexOf,"\nindexOf( arr:ArrayLike, searchElement:any[, fromIndex:integer] )\n    Returns the first index at which a given element can be found.\n"
inherit,"\ninherit( ctor:Object|Function, superCtor:Object|Function )\n    Prototypical inheritance by replacing the prototype of one constructor with\n    the prototype of another constructor.\n"
inheritedEnumerableProperties,"\ninheritedEnumerableProperties( value:any[, level:integer] )\n    Returns an array of an object's inherited enumerable property names and\n    symbols.\n"
inheritedEnumerablePropertySymbols,"\ninheritedEnumerablePropertySymbols( value:any[, level:integer] )\n    Returns an array of an object's inherited enumerable symbol properties.\n"
inheritedKeys,"\ninheritedKeys( value:any[, level:integer] )\n    Returns an array of an object's inherited enumerable property names.\n"
inheritedNonEnumerableProperties,"\ninheritedNonEnumerableProperties( value:any[, level:integer] )\n    Returns an array of an object's inherited non-enumerable property names and\n    symbols.\n"
inheritedNonEnumerablePropertyNames,"\ninheritedNonEnumerablePropertyNames( value:any[, level:integer] )\n    Returns an array of an object's inherited non-enumerable property names.\n"
inheritedNonEnumerablePropertySymbols,"\ninheritedNonEnumerablePropertySymbols( value:any[, level:integer] )\n    Returns an array of an object's inherited non-enumerable symbol properties.\n"
inheritedProperties,"\ninheritedProperties( value:any[, level:integer] )\n    Returns an array of an object's inherited property names and symbols.\n"
inheritedPropertyDescriptor,"\ninheritedPropertyDescriptor( value:any, property:string|symbol[, \n  level:integer] )\n    Returns a property descriptor for an object's inherited property.\n"
inheritedPropertyDescriptors,"\ninheritedPropertyDescriptors( value:any[, level:integer] )\n    Returns an object's inherited property descriptors.\n"
inheritedPropertyNames,"\ninheritedPropertyNames( value:any[, level:integer] )\n    Returns an array of an object's inherited enumerable and non-enumerable\n    property names.\n"
inheritedPropertySymbols,"\ninheritedPropertySymbols( value:any[, level:integer] )\n    Returns an array of an object's inherited symbol properties.\n"
inheritedWritableProperties,"\ninheritedWritableProperties( value:any[, level:integer] )\n    Returns an array of an object's inherited writable property names and\n    symbols.\n"
inheritedWritablePropertyNames,"\ninheritedWritablePropertyNames( value:any[, level:integer] )\n    Returns an array of an object's inherited writable property names.\n"
inheritedWritablePropertySymbols,"\ninheritedWritablePropertySymbols( value:any[, level:integer] )\n    Returns an array of an object's inherited writable symbol properties.\n"
inmap,"\ninmap( collection:Array|TypedArray|Object, fcn:Function[, thisArg:any] )\n    Invokes a function for each element in a collection and updates the\n    collection in-place.\n"
inmapAsync,"\ninmapAsync( collection:Array|TypedArray|Object, [options:Object,] fcn:Function, \n  done:Function )\n    Invokes a function once for each element in a collection and updates a\n    collection in-place.\n"
inmapAsync.factory,"\ninmapAsync.factory( [options:Object,] fcn:Function )\n    Returns a function which invokes a function once for each element in a\n    collection and updates a collection in-place.\n"
inmapRight,"\ninmapRight( collection:Array|TypedArray|Object, fcn:Function[, thisArg:any] )\n    Invokes a function for each element in a collection and updates the\n    collection in-place, iterating from right to left.\n"
inmapRightAsync,"\ninmapRightAsync( collection:Array|TypedArray|Object, [options:Object,] \n  fcn:Function, done:Function )\n    Invokes a function once for each element in a collection and updates a\n    collection in-place, iterating from right to left.\n"
inmapRightAsync.factory,"\ninmapRightAsync.factory( [options:Object,] fcn:Function )\n    Returns a function which invokes a function once for each element in a\n    collection and updates a collection in-place, iterating from right to left.\n"
inspectSinkStream,"\ninspectSinkStream( [options:Object,] clbk:Function )\n    Returns a writable stream for inspecting stream data.\n"
inspectSinkStream.factory,"\ninspectSinkStream.factory( [options:Object] )\n    Returns a function for creating writable streams for inspecting stream data.\n"
inspectSinkStream.objectMode,"\ninspectSinkStream.objectMode( [options:Object,] clbk:Function )\n    Returns an \"objectMode\" writable stream for inspecting stream data.\n"
inspectStream,"\ninspectStream( [options:Object,] clbk:Function )\n    Returns a transform stream for inspecting stream data.\n"
inspectStream.factory,"\ninspectStream.factory( [options:Object] )\n    Returns a function for creating transform streams for inspecting stream\n    data.\n"
inspectStream.objectMode,"\ninspectStream.objectMode( [options:Object,] clbk:Function )\n    Returns an \"objectMode\" transform stream for inspecting stream data.\n"
instanceOf,"\ninstanceOf( value:any, constructor:Function )\n    Tests whether a value has in its prototype chain a specified constructor as\n    a prototype property.\n"
INT8_MAX,"\nINT8_MAX\n    Maximum signed 8-bit integer.\n"
INT8_MIN,"\nINT8_MIN\n    Minimum signed 8-bit integer.\n"
INT8_NUM_BYTES,"\nINT8_NUM_BYTES\n    Size (in bytes) of an 8-bit signed integer.\n"
Int8Array,"\nInt8Array()\n    A typed array constructor which returns a typed array representing an array\n    of twos-complement 8-bit signed integers in the platform byte order.\n\nInt8Array( length:integer )\n    Returns a typed array having a specified length.\n\nInt8Array( typedarray:TypedArray )\n    Creates a typed array from another typed array.\n\nInt8Array( obj:Object )\n    Creates a typed array from an array-like object or iterable.\n\nInt8Array( buffer:ArrayBuffer[, byteOffset:integer[, length:integer]] )\n    Returns a typed array view of an ArrayBuffer.\n"
Int8Array.from,"\nInt8Array.from( src:ArrayLike|Iterable[, map:Function[, thisArg:Any]] )\n    Creates a new typed array from an array-like object or an iterable.\n"
Int8Array.of,"\nInt8Array.of( element0:number[, element1:number[, ...elementN:number]] )\n    Creates a new typed array from a variable number of arguments.\n"
Int8Array.BYTES_PER_ELEMENT,"\nInt8Array.BYTES_PER_ELEMENT\n    Number of bytes per view element.\n"
Int8Array.name,"\nInt8Array.name\n    Typed array constructor name.\n"
Int8Array.prototype.buffer,"\nInt8Array.prototype.buffer\n    Read-only property which returns the ArrayBuffer referenced by the typed\n    array.\n"
Int8Array.prototype.byteLength,"\nInt8Array.prototype.byteLength\n    Read-only property which returns the length (in bytes) of the typed array.\n"
Int8Array.prototype.byteOffset,"\nInt8Array.prototype.byteOffset\n    Read-only property which returns the offset (in bytes) of the typed array\n    from the start of its ArrayBuffer.\n"
Int8Array.prototype.BYTES_PER_ELEMENT,"\nInt8Array.prototype.BYTES_PER_ELEMENT\n    Number of bytes per view element.\n"
Int8Array.prototype.length,"\nInt8Array.prototype.length\n    Read-only property which returns the number of view elements.\n"
Int8Array.prototype.copyWithin,"\nInt8Array.prototype.copyWithin( target:integer, start:integer[, end:integer] )\n    Copies a sequence of elements within the array starting at `start` and\n    ending at `end` (non-inclusive) to the position starting at `target`.\n"
Int8Array.prototype.entries,"\nInt8Array.prototype.entries()\n    Returns an iterator for iterating over array key-value pairs.\n"
Int8Array.prototype.every,"\nInt8Array.prototype.every( predicate:Function[, thisArg:Any] )\n    Tests whether all array elements pass a test implemented by a predicate\n    function.\n"
Int8Array.prototype.fill,"\nInt8Array.prototype.fill( value:number[, start:integer[, end:integer]] )\n    Fills an array from a start index to an end index (non-inclusive) with a\n    provided value.\n"
Int8Array.prototype.filter,"\nInt8Array.prototype.filter( predicate:Function[, thisArg:Any] )\n    Creates a new array which includes those elements for which a predicate\n    function returns a truthy value.\n"
Int8Array.prototype.find,"\nInt8Array.prototype.find( predicate:Function[, thisArg:Any] )\n    Returns the first array element for which a provided predicate function\n    returns a truthy value.\n"
Int8Array.prototype.findIndex,"\nInt8Array.prototype.findIndex( predicate:Function[, thisArg:Any] )\n    Returns the index of the first array element for which a provided predicate\n    function returns a truthy value.\n"
Int8Array.prototype.forEach,"\nInt8Array.prototype.forEach( fcn:Function[, thisArg:Any] )\n    Invokes a callback for each array element.\n"
Int8Array.prototype.includes,"\nInt8Array.prototype.includes( searchElement:number[, fromIndex:integer] )\n    Returns a boolean indicating whether an array includes a search element.\n"
Int8Array.prototype.indexOf,"\nInt8Array.prototype.indexOf( searchElement:number[, fromIndex:integer] )\n    Returns the index of the first array element strictly equal to a search\n    element.\n"
Int8Array.prototype.join,"\nInt8Array.prototype.join( [separator:string] )\n    Serializes an array by joining all array elements as a string.\n"
Int8Array.prototype.keys,"\nInt8Array.prototype.keys()\n    Returns an iterator for iterating over array keys.\n"
Int8Array.prototype.lastIndexOf,"\nInt8Array.prototype.lastIndexOf( searchElement:number[, fromIndex:integer] )\n    Returns the index of the last array element strictly equal to a search\n    element.\n"
Int8Array.prototype.map,"\nInt8Array.prototype.map( fcn:Function[, thisArg:Any] )\n    Maps each array element to an element in a new typed array.\n"
Int8Array.prototype.reduce,"\nInt8Array.prototype.reduce( fcn:Function[, initialValue:Any] )\n    Applies a function against an accumulator and each element in an array and\n    returns the accumulated result.\n"
Int8Array.prototype.reduceRight,"\nInt8Array.prototype.reduceRight( fcn:Function[, initialValue:Any] )\n    Applies a function against an accumulator and each element in an array and\n    returns the accumulated result, iterating from right to left.\n"
Int8Array.prototype.reverse,"\nInt8Array.prototype.reverse()\n    Reverses an array *in-place*.\n"
Int8Array.prototype.set,"\nInt8Array.prototype.set( arr:ArrayLike[, offset:integer] )\n    Sets array elements.\n"
Int8Array.prototype.slice,"\nInt8Array.prototype.slice( [begin:integer[, end:integer]] )\n    Copies array elements to a new array with the same underlying data type as\n    the host array.\n"
Int8Array.prototype.some,"\nInt8Array.prototype.some( predicate:Function[, thisArg:Any] )\n    Tests whether at least one array element passes a test implemented by a\n    predicate function.\n"
Int8Array.prototype.sort,"\nInt8Array.prototype.sort( [compareFunction:Function] )\n    Sorts an array *in-place*.\n"
Int8Array.prototype.subarray,"\nInt8Array.prototype.subarray( [begin:integer[, end:integer]] )\n    Creates a new typed array over the same underlying ArrayBuffer and with the\n    same underlying data type as the host array.\n"
Int8Array.prototype.toLocaleString,"\nInt8Array.prototype.toLocaleString( [locales:string|Array[, options:Object]] )\n    Serializes an array as a locale-specific string.\n"
Int8Array.prototype.toString,"\nInt8Array.prototype.toString()\n    Serializes an array as a string.\n"
Int8Array.prototype.values,"\nInt8Array.prototype.values()\n    Returns an iterator for iterating over array elements.\n"
INT16_MAX,"\nINT16_MAX\n    Maximum signed 16-bit integer.\n"
INT16_MIN,"\nINT16_MIN\n    Minimum signed 16-bit integer.\n"
INT16_NUM_BYTES,"\nINT16_NUM_BYTES\n    Size (in bytes) of a 16-bit signed integer.\n"
Int16Array,"\nInt16Array()\n    A typed array constructor which returns a typed array representing an array\n    of twos-complement 16-bit signed integers in the platform byte order.\n\nInt16Array( length:integer )\n    Returns a typed array having a specified length.\n\nInt16Array( typedarray:TypedArray )\n    Creates a typed array from another typed array.\n\nInt16Array( obj:Object )\n    Creates a typed array from an array-like object or iterable.\n\nInt16Array( buffer:ArrayBuffer[, byteOffset:integer[, length:integer]] )\n    Returns a typed array view of an ArrayBuffer.\n"
Int16Array.from,"\nInt16Array.from( src:ArrayLike|Iterable[, map:Function[, thisArg:Any]] )\n    Creates a new typed array from an array-like object or an iterable.\n"
Int16Array.of,"\nInt16Array.of( element0:number[, element1:number[, ...elementN:number]] )\n    Creates a new typed array from a variable number of arguments.\n"
Int16Array.BYTES_PER_ELEMENT,"\nInt16Array.BYTES_PER_ELEMENT\n    Number of bytes per view element.\n"
Int16Array.name,"\nInt16Array.name\n    Typed array constructor name.\n"
Int16Array.prototype.buffer,"\nInt16Array.prototype.buffer\n    Read-only property which returns the ArrayBuffer referenced by the typed\n    array.\n"
Int16Array.prototype.byteLength,"\nInt16Array.prototype.byteLength\n    Read-only property which returns the length (in bytes) of the typed array.\n"
Int16Array.prototype.byteOffset,"\nInt16Array.prototype.byteOffset\n    Read-only property which returns the offset (in bytes) of the typed array\n    from the start of its ArrayBuffer.\n"
Int16Array.prototype.BYTES_PER_ELEMENT,"\nInt16Array.prototype.BYTES_PER_ELEMENT\n    Number of bytes per view element.\n"
Int16Array.prototype.length,"\nInt16Array.prototype.length\n    Read-only property which returns the number of view elements.\n"
Int16Array.prototype.copyWithin,"\nInt16Array.prototype.copyWithin( target:integer, start:integer[, end:integer] )\n    Copies a sequence of elements within the array starting at `start` and\n    ending at `end` (non-inclusive) to the position starting at `target`.\n"
Int16Array.prototype.entries,"\nInt16Array.prototype.entries()\n    Returns an iterator for iterating over array key-value pairs.\n"
Int16Array.prototype.every,"\nInt16Array.prototype.every( predicate:Function[, thisArg:Any] )\n    Tests whether all array elements pass a test implemented by a predicate\n    function.\n"
Int16Array.prototype.fill,"\nInt16Array.prototype.fill( value:number[, start:integer[, end:integer]] )\n    Fills an array from a start index to an end index (non-inclusive) with a\n    provided value.\n"
Int16Array.prototype.filter,"\nInt16Array.prototype.filter( predicate:Function[, thisArg:Any] )\n    Creates a new array which includes those elements for which a predicate\n    function returns a truthy value.\n"
Int16Array.prototype.find,"\nInt16Array.prototype.find( predicate:Function[, thisArg:Any] )\n    Returns the first array element for which a provided predicate function\n    returns a truthy value.\n"
Int16Array.prototype.findIndex,"\nInt16Array.prototype.findIndex( predicate:Function[, thisArg:Any] )\n    Returns the index of the first array element for which a provided predicate\n    function returns a truthy value.\n"
Int16Array.prototype.forEach,"\nInt16Array.prototype.forEach( fcn:Function[, thisArg:Any] )\n    Invokes a callback for each array element.\n"
Int16Array.prototype.includes,"\nInt16Array.prototype.includes( searchElement:number[, fromIndex:integer] )\n    Returns a boolean indicating whether an array includes a search element.\n"
Int16Array.prototype.indexOf,"\nInt16Array.prototype.indexOf( searchElement:number[, fromIndex:integer] )\n    Returns the index of the first array element strictly equal to a search\n    element.\n"
Int16Array.prototype.join,"\nInt16Array.prototype.join( [separator:string] )\n    Serializes an array by joining all array elements as a string.\n"
Int16Array.prototype.keys,"\nInt16Array.prototype.keys()\n    Returns an iterator for iterating over array keys.\n"
Int16Array.prototype.lastIndexOf,"\nInt16Array.prototype.lastIndexOf( searchElement:number[, fromIndex:integer] )\n    Returns the index of the last array element strictly equal to a search\n    element.\n"
Int16Array.prototype.map,"\nInt16Array.prototype.map( fcn:Function[, thisArg:Any] )\n    Maps each array element to an element in a new typed array.\n"
Int16Array.prototype.reduce,"\nInt16Array.prototype.reduce( fcn:Function[, initialValue:Any] )\n    Applies a function against an accumulator and each element in an array and\n    returns the accumulated result.\n"
Int16Array.prototype.reduceRight,"\nInt16Array.prototype.reduceRight( fcn:Function[, initialValue:Any] )\n    Applies a function against an accumulator and each element in an array and\n    returns the accumulated result, iterating from right to left.\n"
Int16Array.prototype.reverse,"\nInt16Array.prototype.reverse()\n    Reverses an array *in-place*.\n"
Int16Array.prototype.set,"\nInt16Array.prototype.set( arr:ArrayLike[, offset:integer] )\n    Sets array elements.\n"
Int16Array.prototype.slice,"\nInt16Array.prototype.slice( [begin:integer[, end:integer]] )\n    Copies array elements to a new array with the same underlying data type as\n    the host array.\n"
Int16Array.prototype.some,"\nInt16Array.prototype.some( predicate:Function[, thisArg:Any] )\n    Tests whether at least one array element passes a test implemented by a\n    predicate function.\n"
Int16Array.prototype.sort,"\nInt16Array.prototype.sort( [compareFunction:Function] )\n    Sorts an array *in-place*.\n"
Int16Array.prototype.subarray,"\nInt16Array.prototype.subarray( [begin:integer[, end:integer]] )\n    Creates a new typed array over the same underlying ArrayBuffer and with the\n    same underlying data type as the host array.\n"
Int16Array.prototype.toLocaleString,"\nInt16Array.prototype.toLocaleString( [locales:string|Array[, options:Object]] )\n    Serializes an array as a locale-specific string.\n"
Int16Array.prototype.toString,"\nInt16Array.prototype.toString()\n    Serializes an array as a string.\n"
Int16Array.prototype.values,"\nInt16Array.prototype.values()\n    Returns an iterator for iterating over array elements.\n"
INT32_MAX,"\nINT32_MAX\n    Maximum signed 32-bit integer.\n"
INT32_MIN,"\nINT32_MIN\n    Minimum signed 32-bit integer.\n"
INT32_NUM_BYTES,"\nINT32_NUM_BYTES\n    Size (in bytes) of a 32-bit signed integer.\n"
Int32Array,"\nInt32Array()\n    A typed array constructor which returns a typed array representing an array\n    of twos-complement 32-bit signed integers in the platform byte order.\n\nInt32Array( length:integer )\n    Returns a typed array having a specified length.\n\nInt32Array( typedarray:TypedArray )\n    Creates a typed array from another typed array.\n\nInt32Array( obj:Object )\n    Creates a typed array from an array-like object or iterable.\n\nInt32Array( buffer:ArrayBuffer[, byteOffset:integer[, length:integer]] )\n    Returns a typed array view of an ArrayBuffer.\n"
Int32Array.from,"\nInt32Array.from( src:ArrayLike|Iterable[, map:Function[, thisArg:Any]] )\n    Creates a new typed array from an array-like object or an iterable.\n"
Int32Array.of,"\nInt32Array.of( element0:number[, element1:number[, ...elementN:number]] )\n    Creates a new typed array from a variable number of arguments.\n"
Int32Array.BYTES_PER_ELEMENT,"\nInt32Array.BYTES_PER_ELEMENT\n    Number of bytes per view element.\n"
Int32Array.name,"\nInt32Array.name\n    Typed array constructor name.\n"
Int32Array.prototype.buffer,"\nInt32Array.prototype.buffer\n    Read-only property which returns the ArrayBuffer referenced by the typed\n    array.\n"
Int32Array.prototype.byteLength,"\nInt32Array.prototype.byteLength\n    Read-only property which returns the length (in bytes) of the typed array.\n"
Int32Array.prototype.byteOffset,"\nInt32Array.prototype.byteOffset\n    Read-only property which returns the offset (in bytes) of the typed array\n    from the start of its ArrayBuffer.\n"
Int32Array.prototype.BYTES_PER_ELEMENT,"\nInt32Array.prototype.BYTES_PER_ELEMENT\n    Number of bytes per view element.\n"
Int32Array.prototype.length,"\nInt32Array.prototype.length\n    Read-only property which returns the number of view elements.\n"
Int32Array.prototype.copyWithin,"\nInt32Array.prototype.copyWithin( target:integer, start:integer[, end:integer] )\n    Copies a sequence of elements within the array starting at `start` and\n    ending at `end` (non-inclusive) to the position starting at `target`.\n"
Int32Array.prototype.entries,"\nInt32Array.prototype.entries()\n    Returns an iterator for iterating over array key-value pairs.\n"
Int32Array.prototype.every,"\nInt32Array.prototype.every( predicate:Function[, thisArg:Any] )\n    Tests whether all array elements pass a test implemented by a predicate\n    function.\n"
Int32Array.prototype.fill,"\nInt32Array.prototype.fill( value:number[, start:integer[, end:integer]] )\n    Fills an array from a start index to an end index (non-inclusive) with a\n    provided value.\n"
Int32Array.prototype.filter,"\nInt32Array.prototype.filter( predicate:Function[, thisArg:Any] )\n    Creates a new array which includes those elements for which a predicate\n    function returns a truthy value.\n"
Int32Array.prototype.find,"\nInt32Array.prototype.find( predicate:Function[, thisArg:Any] )\n    Returns the first array element for which a provided predicate function\n    returns a truthy value.\n"
Int32Array.prototype.findIndex,"\nInt32Array.prototype.findIndex( predicate:Function[, thisArg:Any] )\n    Returns the index of the first array element for which a provided predicate\n    function returns a truthy value.\n"
Int32Array.prototype.forEach,"\nInt32Array.prototype.forEach( fcn:Function[, thisArg:Any] )\n    Invokes a callback for each array element.\n"
Int32Array.prototype.includes,"\nInt32Array.prototype.includes( searchElement:number[, fromIndex:integer] )\n    Returns a boolean indicating whether an array includes a search element.\n"
Int32Array.prototype.indexOf,"\nInt32Array.prototype.indexOf( searchElement:number[, fromIndex:integer] )\n    Returns the index of the first array element strictly equal to a search\n    element.\n"
Int32Array.prototype.join,"\nInt32Array.prototype.join( [separator:string] )\n    Serializes an array by joining all array elements as a string.\n"
Int32Array.prototype.keys,"\nInt32Array.prototype.keys()\n    Returns an iterator for iterating over array keys.\n"
Int32Array.prototype.lastIndexOf,"\nInt32Array.prototype.lastIndexOf( searchElement:number[, fromIndex:integer] )\n    Returns the index of the last array element strictly equal to a search\n    element.\n"
Int32Array.prototype.map,"\nInt32Array.prototype.map( fcn:Function[, thisArg:Any] )\n    Maps each array element to an element in a new typed array.\n"
Int32Array.prototype.reduce,"\nInt32Array.prototype.reduce( fcn:Function[, initialValue:Any] )\n    Applies a function against an accumulator and each element in an array and\n    returns the accumulated result.\n"
Int32Array.prototype.reduceRight,"\nInt32Array.prototype.reduceRight( fcn:Function[, initialValue:Any] )\n    Applies a function against an accumulator and each element in an array and\n    returns the accumulated result, iterating from right to left.\n"
Int32Array.prototype.reverse,"\nInt32Array.prototype.reverse()\n    Reverses an array *in-place*.\n"
Int32Array.prototype.set,"\nInt32Array.prototype.set( arr:ArrayLike[, offset:integer] )\n    Sets array elements.\n"
Int32Array.prototype.slice,"\nInt32Array.prototype.slice( [begin:integer[, end:integer]] )\n    Copies array elements to a new array with the same underlying data type as\n    the host array.\n"
Int32Array.prototype.some,"\nInt32Array.prototype.some( predicate:Function[, thisArg:Any] )\n    Tests whether at least one array element passes a test implemented by a\n    predicate function.\n"
Int32Array.prototype.sort,"\nInt32Array.prototype.sort( [compareFunction:Function] )\n    Sorts an array *in-place*.\n"
Int32Array.prototype.subarray,"\nInt32Array.prototype.subarray( [begin:integer[, end:integer]] )\n    Creates a new typed array over the same underlying ArrayBuffer and with the\n    same underlying data type as the host array.\n"
Int32Array.prototype.toLocaleString,"\nInt32Array.prototype.toLocaleString( [locales:string|Array[, options:Object]] )\n    Serializes an array as a locale-specific string.\n"
Int32Array.prototype.toString,"\nInt32Array.prototype.toString()\n    Serializes an array as a string.\n"
Int32Array.prototype.values,"\nInt32Array.prototype.values()\n    Returns an iterator for iterating over array elements.\n"
IS_BIG_ENDIAN,"\nIS_BIG_ENDIAN\n    Boolean indicating if the environment is big endian.\n"
IS_BROWSER,"\nIS_BROWSER\n    Boolean indicating if the runtime is a web browser.\n"
IS_DARWIN,"\nIS_DARWIN\n    Boolean indicating if the current process is running on Darwin.\n"
IS_ELECTRON,"\nIS_ELECTRON\n    Boolean indicating if the runtime is Electron.\n"
IS_ELECTRON_MAIN,"\nIS_ELECTRON_MAIN\n    Boolean indicating if the runtime is the main Electron process.\n"
IS_ELECTRON_RENDERER,"\nIS_ELECTRON_RENDERER\n    Boolean indicating if the runtime is the Electron renderer process.\n"
IS_LITTLE_ENDIAN,"\nIS_LITTLE_ENDIAN\n    Boolean indicating if the environment is little endian.\n"
IS_NODE,"\nIS_NODE\n    Boolean indicating if the runtime is Node.js.\n"
IS_WEB_WORKER,"\nIS_WEB_WORKER\n    Boolean indicating if the runtime is a web worker.\n"
IS_WINDOWS,"\nIS_WINDOWS\n    Boolean indicating if the current process is running on Windows.\n"
isAbsolutePath,"\nisAbsolutePath( value:any )\n    Tests if a value is an absolute path.\n"
isAbsolutePath.posix,"\nisAbsolutePath.posix( value:any )\n    Tests if a value is a POSIX absolute path.\n"
isAbsolutePath.win32,"\nisAbsolutePath.win32( value:any )\n    Tests if a value is a Windows absolute path.\n"
isAccessorProperty,"\nisAccessorProperty( value:any, property:any )\n    Tests if an object's own property has an accessor descriptor.\n"
isAccessorPropertyIn,"\nisAccessorPropertyIn( value:any, property:any )\n    Tests if an object's own or inherited property has an accessor descriptor.\n"
isAlphagram,"\nisAlphagram( value:any )\n    Tests if a value is an alphagram (i.e., a sequence of characters arranged in\n    alphabetical order).\n"
isAlphaNumeric,"\nisAlphaNumeric( str:string )\n    Tests whether a string contains only alphanumeric characters.\n"
isAnagram,"\nisAnagram( str:string, value:any )\n    Tests if a value is an anagram.\n"
isArguments,"\nisArguments( value:any )\n    Tests if a value is an arguments object.\n"
isArray,"\nisArray( value:any )\n    Tests if a value is an array.\n"
isArrayArray,"\nisArrayArray( value:any )\n    Tests if a value is an array of arrays.\n"
isArrayBuffer,"\nisArrayBuffer( value:any )\n    Tests if a value is an ArrayBuffer.\n"
isArrayLength,"\nisArrayLength( value:any )\n    Tests if a value is a valid array length.\n"
isArrayLike,"\nisArrayLike( value:any )\n    Tests if a value is array-like.\n"
isArrayLikeObject,"\nisArrayLikeObject( value:any )\n    Tests if a value is an array-like object.\n"
isASCII,"\nisASCII( str:string )\n    Tests whether a character belongs to the ASCII character set and whether\n    this is true for all characters in a provided string.\n"
isBetween,"\nisBetween( value:any, a:any, b:any[, left:string, right:string] )\n    Tests if a value is between two values.\n"
isBetweenArray,"\nisBetweenArray( value:any, a:any, b:any[, left:string, right:string] )\n    Tests if a value is an array-like object where every element is between two\n    values.\n"
isBigInt,"\nisBigInt( value:any )\n    Tests if a value is a BigInt.\n"
isBigUint64Array,"\nisBigUint64Array( value:any )\n    Tests if a value is a BigUint64Array.\n"
isBinaryString,"\nisBinaryString( value:any )\n    Tests if a value is a binary string.\n"
isBoolean,"\nisBoolean( value:any )\n    Tests if a value is a boolean.\n"
isBoolean.isPrimitive,"\nisBoolean.isPrimitive( value:any )\n    Tests if a value is a boolean primitive.\n"
isBoolean.isObject,"\nisBoolean.isObject( value:any )\n    Tests if a value is a boolean object.\n"
isBooleanArray,"\nisBooleanArray( value:any )\n    Tests if a value is an array-like object of booleans.\n"
isBooleanArray.primitives,"\nisBooleanArray.primitives( value:any )\n    Tests if a value is an array-like object containing only boolean primitives.\n"
isBooleanArray.objects,"\nisBooleanArray.objects( value:any )\n    Tests if a value is an array-like object containing only Boolean objects.\n"
isBoxedPrimitive,"\nisBoxedPrimitive( value:any )\n    Tests if a value is a JavaScript boxed primitive.\n"
isBuffer,"\nisBuffer( value:any )\n    Tests if a value is a Buffer instance.\n"
isCapitalized,"\nisCapitalized( value:any )\n    Tests if a value is a string having an uppercase first character.\n"
isCentrosymmetricMatrix,"\nisCentrosymmetricMatrix( value:any )\n    Tests if a value is a matrix which is symmetric about its center.\n"
isCircular,"\nisCircular( value:any )\n    Tests if an object-like value contains a circular reference.\n"
isCircularArray,"\nisCircularArray( value:any )\n    Tests if a value is an array containing a circular reference.\n"
isCircularPlainObject,"\nisCircularPlainObject( value:any )\n    Tests if a value is a plain object containing a circular reference.\n"
isCollection,"\nisCollection( value:any )\n    Tests if a value is a collection.\n"
isComplex,"\nisComplex( value:any )\n    Tests if a value is a 64-bit or 128-bit complex number.\n"
isComplex64,"\nisComplex64( value:any )\n    Tests if a value is a 64-bit complex number.\n"
isComplex64Array,"\nisComplex64Array( value:any )\n    Tests if a value is a Complex64Array.\n"
isComplex128,"\nisComplex128( value:any )\n    Tests if a value is a 128-bit complex number.\n"
isComplex128Array,"\nisComplex128Array( value:any )\n    Tests if a value is a Complex128Array.\n"
isComplexLike,"\nisComplexLike( value:any )\n    Tests if a value is a complex number-like object.\n"
isComplexTypedArray,"\nisComplexTypedArray( value:any )\n    Tests if a value is a complex typed array.\n"
isComplexTypedArrayLike,"\nisComplexTypedArrayLike( value:any )\n    Tests if a value is complex-typed-array-like.\n"
isComposite,"\nisComposite( value:any )\n    Tests if a value is a composite number.\n"
isComposite.isPrimitive,"\nisComposite.isPrimitive( value:any )\n    Tests if a value is a number primitive which is a composite number.\n"
isComposite.isObject,"\nisComposite.isObject( value:any )\n    Tests if a value is a number object having a value which is a composite\n    number.\n"
isConfigurableProperty,"\nisConfigurableProperty( value:any, property:any )\n    Tests if an object's own property is configurable.\n"
isConfigurablePropertyIn,"\nisConfigurablePropertyIn( value:any, property:any )\n    Tests if an object's own or inherited property is configurable.\n"
isCubeNumber,"\nisCubeNumber( value:any )\n    Tests if a value is a cube number.\n"
isCubeNumber.isPrimitive,"\nisCubeNumber.isPrimitive( value:any )\n    Tests if a value is a number primitive which is a cube number.\n"
isCubeNumber.isObject,"\nisCubeNumber.isObject( value:any )\n    Tests if a value is a number object having a value which is a cube number.\n"
isDataProperty,"\nisDataProperty( value:any, property:any )\n    Tests if an object's own property has a data descriptor.\n"
isDataPropertyIn,"\nisDataPropertyIn( value:any, property:any )\n    Tests if an object's own or inherited property has a data descriptor.\n"
isDataView,"\nisDataView( value:any )\n    Tests if a value is a DataView.\n"
isDateObject,"\nisDateObject( value:any )\n    Tests if a value is a Date object.\n"
isDigitString,"\nisDigitString( str:string )\n    Tests whether a string contains only numeric digits.\n"
isEmailAddress,"\nisEmailAddress( value:any )\n    Tests if a value is an email address.\n"
isEmptyArray,"\nisEmptyArray( value:any )\n    Tests if a value is an empty array.\n"
isEmptyObject,"\nisEmptyObject( value:any )\n    Tests if a value is an empty object.\n"
isEmptyString,"\nisEmptyString( value:any )\n    Tests if a value is an empty string.\n"
isEmptyString.isPrimitive,"\nisEmptyString.isPrimitive( value:any )\n    Tests if a value is an empty string primitive.\n"
isEmptyString.isObject,"\nisEmptyString.isObject( value:any )\n    Tests if a value is an empty `String` object.\n"
isEnumerableProperty,"\nisEnumerableProperty( value:any, property:any )\n    Tests if an object's own property is enumerable.\n"
isEnumerablePropertyIn,"\nisEnumerablePropertyIn( value:any, property:any )\n    Tests if an object's own or inherited property is enumerable.\n"
isError,"\nisError( value:any )\n    Tests if a value is an Error object.\n"
isEvalError,"\nisEvalError( value:any )\n    Tests if a value is an EvalError object.\n"
isEven,"\nisEven( value:any )\n    Tests if a value is an even number.\n"
isEven.isPrimitive,"\nisEven.isPrimitive( value:any )\n    Tests if a value is a number primitive that is an even number.\n"
isEven.isObject,"\nisEven.isObject( value:any )\n    Tests if a value is a number object that is an even number.\n"
isFalsy,"\nisFalsy( value:any )\n    Tests if a value is a value which translates to `false` when evaluated in a\n    boolean context.\n"
isFalsyArray,"\nisFalsyArray( value:any )\n    Tests if a value is an array-like object containing only falsy values.\n"
isFinite,"\nisFinite( value:any )\n    Tests if a value is a finite number.\n"
isFinite.isPrimitive,"\nisFinite.isPrimitive( value:any )\n    Tests if a value is a number primitive having a finite value.\n"
isFinite.isObject,"\nisFinite.isObject( value:any )\n    Tests if a value is a number object having a finite value.\n"
isFiniteArray,"\nisFiniteArray( value:any )\n    Tests if a value is an array-like object of finite numbers.\n"
isFiniteArray.primitives,"\nisFiniteArray.primitives( value:any )\n    Tests if a value is an array-like object containing only primitive finite\n    numbers.\n"
isFiniteArray.objects,"\nisFiniteArray.objects( value:any )\n    Tests if a value is an array-like object containing only number objects\n    having finite values.\n"
isFloat32Array,"\nisFloat32Array( value:any )\n    Tests if a value is a Float32Array.\n"
isFloat32MatrixLike,"\nisFloat32MatrixLike( value:any )\n    Tests if a value is a 2-dimensional ndarray-like object containing single-\n    precision floating-point numbers.\n"
isFloat32ndarrayLike,"\nisFloat32ndarrayLike( value:any )\n    Tests if a value is an ndarray-like object containing single-precision\n    floating-point numbers.\n"
isFloat32VectorLike,"\nisFloat32VectorLike( value:any )\n    Tests if a value is a 1-dimensional ndarray-like object containing single-\n    precision floating-point numbers.\n"
isFloat64Array,"\nisFloat64Array( value:any )\n    Tests if a value is a Float64Array.\n"
isFloat64MatrixLike,"\nisFloat64MatrixLike( value:any )\n    Tests if a value is a 2-dimensional ndarray-like object containing double-\n    precision floating-point numbers.\n"
isFloat64ndarrayLike,"\nisFloat64ndarrayLike( value:any )\n    Tests if a value is an ndarray-like object containing double-precision\n    floating-point numbers.\n"
isFloat64VectorLike,"\nisFloat64VectorLike( value:any )\n    Tests if a value is a 1-dimensional ndarray-like object containing double-\n    precision floating-point numbers.\n"
isFunction,"\nisFunction( value:any )\n    Tests if a value is a function.\n"
isFunctionArray,"\nisFunctionArray( value:any )\n    Tests if a value is an array-like object containing only functions.\n"
isGeneratorObject,"\nisGeneratorObject( value:any )\n    Tests if a value is a generator object.\n"
isGeneratorObjectLike,"\nisGeneratorObjectLike( value:any )\n    Tests if a value is generator object-like.\n"
isgzipBuffer,"\nisgzipBuffer( value:any )\n    Tests if a value is a gzip buffer.\n"
isHexString,"\nisHexString( str:string )\n    Tests whether a string contains only hexadecimal digits.\n"
isInfinite,"\nisInfinite( value:any )\n    Tests if a value is an infinite number.\n"
isInfinite.isPrimitive,"\nisInfinite.isPrimitive( value:any )\n    Tests if a value is a number primitive having an infinite value.\n"
isInfinite.isObject,"\nisInfinite.isObject( value:any )\n    Tests if a value is a number object having an infinite value.\n"
isInheritedProperty,"\nisInheritedProperty( value:any, property:any )\n    Tests if an object has an inherited property.\n"
isInt8Array,"\nisInt8Array( value:any )\n    Tests if a value is an Int8Array.\n"
isInt16Array,"\nisInt16Array( value:any )\n    Tests if a value is an Int16Array.\n"
isInt32Array,"\nisInt32Array( value:any )\n    Tests if a value is an Int32Array.\n"
isInteger,"\nisInteger( value:any )\n    Tests if a value is an integer.\n"
isInteger.isPrimitive,"\nisInteger.isPrimitive( value:any )\n    Tests if a value is a number primitive having an integer value.\n"
isInteger.isObject,"\nisInteger.isObject( value:any )\n    Tests if a value is a number object having an integer value.\n"
isIntegerArray,"\nisIntegerArray( value:any )\n    Tests if a value is an array-like object of integer values.\n"
isIntegerArray.primitives,"\nisIntegerArray.primitives( value:any )\n    Tests if a value is an array-like object containing only primitive integer\n    values.\n"
isIntegerArray.objects,"\nisIntegerArray.objects( value:any )\n    Tests if a value is an array-like object containing only number objects\n    having integer values.\n"
isIterableLike,"\nisIterableLike( value:any )\n    Tests if a value is iterable-like.\n"
isIteratorLike,"\nisIteratorLike( value:any )\n    Tests if a value is iterator-like.\n"
isJSON,"\nisJSON( value:any )\n    Tests if a value is a parseable JSON string.\n"
isLeapYear,"\nisLeapYear( value:any )\n    Tests whether a value corresponds to a leap year in the Gregorian calendar.\n"
isLowercase,"\nisLowercase( value:any )\n    Tests if a value is a lowercase string.\n"
isMatrixLike,"\nisMatrixLike( value:any )\n    Tests if a value is a 2-dimensional ndarray-like object.\n"
isMethod,"\nisMethod( value:any, property:any )\n    Tests if an object has a specified method name.\n"
isMethodIn,"\nisMethodIn( value:any, property:any )\n    Tests if an object has a specified method name, either own or inherited.\n"
isNamedTypedTupleLike,"\nisNamedTypedTupleLike( value:any )\n    Tests if a value is named typed tuple-like.\n"
isnan,"\nisnan( value:any )\n    Tests if a value is NaN.\n"
isnan.isPrimitive,"\nisnan.isPrimitive( value:any )\n    Tests if a value is a NaN number primitive.\n"
isnan.isObject,"\nisnan.isObject( value:any )\n    Tests if a value is a number object having a value of NaN.\n"
isNaNArray,"\nisNaNArray( value:any )\n    Tests if a value is an array-like object containing only NaN values.\n"
isNaNArray.primitives,"\nisNaNArray.primitives( value:any )\n    Tests if a value is an array-like object containing only primitive NaN\n    values.\n"
isNaNArray.objects,"\nisNaNArray.objects( value:any )\n    Tests if a value is an array-like object containing only number objects\n    having NaN values.\n"
isNativeFunction,"\nisNativeFunction( value:any )\n    Tests if a value is a native function.\n"
isndarrayLike,"\nisndarrayLike( value:any )\n    Tests if a value is ndarray-like.\n"
isNegativeInteger,"\nisNegativeInteger( value:any )\n    Tests if a value is a negative integer.\n"
isNegativeInteger.isPrimitive,"\nisNegativeInteger.isPrimitive( value:any )\n    Tests if a value is a number primitive having a negative integer value.\n"
isNegativeInteger.isObject,"\nisNegativeInteger.isObject( value:any )\n    Tests if a value is a number object having a negative integer value.\n"
isNegativeIntegerArray,"\nisNegativeIntegerArray( value:any )\n    Tests if a value is an array-like object containing only negative integers.\n"
isNegativeIntegerArray.primitives,"\nisNegativeIntegerArray.primitives( value:any )\n    Tests if a value is an array-like object containing only negative primitive\n    integer values.\n"
isNegativeIntegerArray.objects,"\nisNegativeIntegerArray.objects( value:any )\n    Tests if a value is an array-like object containing only number objects\n    having negative integer values.\n"
isNegativeNumber,"\nisNegativeNumber( value:any )\n    Tests if a value is a negative number.\n"
isNegativeNumber.isPrimitive,"\nisNegativeNumber.isPrimitive( value:any )\n    Tests if a value is a number primitive having a negative value.\n"
isNegativeNumber.isObject,"\nisNegativeNumber.isObject( value:any )\n    Tests if a value is a number object having a negative value.\n"
isNegativeNumberArray,"\nisNegativeNumberArray( value:any )\n    Tests if a value is an array-like object containing only negative numbers.\n"
isNegativeNumberArray.primitives,"\nisNegativeNumberArray.primitives( value:any )\n    Tests if a value is an array-like object containing only primitive negative\n    numbers.\n"
isNegativeNumberArray.objects,"\nisNegativeNumberArray.objects( value:any )\n    Tests if a value is an array-like object containing only number objects\n    having negative number values.\n"
isNegativeZero,"\nisNegativeZero( value:any )\n    Tests if a value is negative zero.\n"
isNegativeZero.isPrimitive,"\nisNegativeZero.isPrimitive( value:any )\n    Tests if a value is a number primitive equal to negative zero.\n"
isNegativeZero.isObject,"\nisNegativeZero.isObject( value:any )\n    Tests if a value is a number object having a value equal to negative zero.\n"
isNodeBuiltin,"\nisNodeBuiltin( str:string )\n    Tests whether a string matches a Node.js built-in module name.\n"
isNodeDuplexStreamLike,"\nisNodeDuplexStreamLike( value:any )\n    Tests if a value is Node duplex stream-like.\n"
isNodeReadableStreamLike,"\nisNodeReadableStreamLike( value:any )\n    Tests if a value is Node readable stream-like.\n"
isNodeREPL,"\nisNodeREPL()\n    Returns a boolean indicating if running in a Node.js REPL environment.\n"
isNodeStreamLike,"\nisNodeStreamLike( value:any )\n    Tests if a value is Node stream-like.\n"
isNodeTransformStreamLike,"\nisNodeTransformStreamLike( value:any )\n    Tests if a value is Node transform stream-like.\n"
isNodeWritableStreamLike,"\nisNodeWritableStreamLike( value:any )\n    Tests if a value is Node writable stream-like.\n"
isNonConfigurableProperty,"\nisNonConfigurableProperty( value:any, property:any )\n    Tests if an object's own property is non-configurable.\n"
isNonConfigurablePropertyIn,"\nisNonConfigurablePropertyIn( value:any, property:any )\n    Tests if an object's own or inherited property is non-configurable.\n"
isNonEnumerableProperty,"\nisNonEnumerableProperty( value:any, property:any )\n    Tests if an object's own property is non-enumerable.\n"
isNonEnumerablePropertyIn,"\nisNonEnumerablePropertyIn( value:any, property:any )\n    Tests if an object's own or inherited property is non-enumerable.\n"
isNonNegativeInteger,"\nisNonNegativeInteger( value:any )\n    Tests if a value is a nonnegative integer.\n"
isNonNegativeInteger.isPrimitive,"\nisNonNegativeInteger.isPrimitive( value:any )\n    Tests if a value is a number primitive having a nonnegative integer value.\n"
isNonNegativeInteger.isObject,"\nisNonNegativeInteger.isObject( value:any )\n    Tests if a value is a number object having a nonnegative integer value.\n"
isNonNegativeIntegerArray,"\nisNonNegativeIntegerArray( value:any )\n    Tests if a value is an array-like object containing only nonnegative\n    integers.\n"
isNonNegativeIntegerArray.primitives,"\nisNonNegativeIntegerArray.primitives( value:any )\n    Tests if a value is an array-like object containing only nonnegative\n    primitive integer values.\n"
isNonNegativeIntegerArray.objects,"\nisNonNegativeIntegerArray.objects( value:any )\n    Tests if a value is an array-like object containing only number objects\n    having nonnegative integer values.\n"
isNonNegativeNumber,"\nisNonNegativeNumber( value:any )\n    Tests if a value is a nonnegative number.\n"
isNonNegativeNumber.isPrimitive,"\nisNonNegativeNumber.isPrimitive( value:any )\n    Tests if a value is a number primitive having a nonnegative value.\n"
isNonNegativeNumber.isObject,"\nisNonNegativeNumber.isObject( value:any )\n    Tests if a value is a number object having a nonnegative value.\n"
isNonNegativeNumberArray,"\nisNonNegativeNumberArray( value:any )\n    Tests if a value is an array-like object containing only nonnegative\n    numbers.\n"
isNonNegativeNumberArray.primitives,"\nisNonNegativeNumberArray.primitives( value:any )\n    Tests if a value is an array-like object containing only primitive\n    nonnegative numbers.\n"
isNonNegativeNumberArray.objects,"\nisNonNegativeNumberArray.objects( value:any )\n    Tests if a value is an array-like object containing only number objects\n    having nonnegative number values.\n"
isNonPositiveInteger,"\nisNonPositiveInteger( value:any )\n    Tests if a value is a nonpositive integer.\n"
isNonPositiveInteger.isPrimitive,"\nisNonPositiveInteger.isPrimitive( value:any )\n    Tests if a value is a number primitive having a nonpositive integer value.\n"
isNonPositiveInteger.isObject,"\nisNonPositiveInteger.isObject( value:any )\n    Tests if a value is a number object having a nonpositive integer value.\n"
isNonPositiveIntegerArray,"\nisNonPositiveIntegerArray( value:any )\n    Tests if a value is an array-like object containing only nonpositive\n    integers.\n"
isNonPositiveIntegerArray.primitives,"\nisNonPositiveIntegerArray.primitives( value:any )\n    Tests if a value is an array-like object containing only nonpositive\n    primitive integer values.\n"
isNonPositiveIntegerArray.objects,"\nisNonPositiveIntegerArray.objects( value:any )\n    Tests if a value is an array-like object containing only number objects\n    having nonpositive integer values.\n"
isNonPositiveNumber,"\nisNonPositiveNumber( value:any )\n    Tests if a value is a nonpositive number.\n"
isNonPositiveNumber.isPrimitive,"\nisNonPositiveNumber.isPrimitive( value:any )\n    Tests if a value is a number primitive having a nonpositive value.\n"
isNonPositiveNumber.isObject,"\nisNonPositiveNumber.isObject( value:any )\n    Tests if a value is a number object having a nonpositive value.\n"
isNonPositiveNumberArray,"\nisNonPositiveNumberArray( value:any )\n    Tests if a value is an array-like object containing only nonpositive\n    numbers.\n"
isNonPositiveNumberArray.primitives,"\nisNonPositiveNumberArray.primitives( value:any )\n    Tests if a value is an array-like object containing only primitive\n    nonpositive numbers.\n"
isNonPositiveNumberArray.objects,"\nisNonPositiveNumberArray.objects( value:any )\n    Tests if a value is an array-like object containing only number objects\n    having nonpositive number values.\n"
isNonSymmetricMatrix,"\nisNonSymmetricMatrix( value:any )\n    Tests if a value is a non-symmetric matrix.\n"
isNull,"\nisNull( value:any )\n    Tests if a value is null.\n"
isNullArray,"\nisNullArray( value:any )\n    Tests if a value is an array-like object containing only null values.\n"
isNumber,"\nisNumber( value:any )\n    Tests if a value is a number.\n"
isNumber.isPrimitive,"\nisNumber.isPrimitive( value:any )\n    Tests if a value is a number primitive.\n"
isNumber.isObject,"\nisNumber.isObject( value:any )\n    Tests if a value is a `Number` object.\n"
isNumberArray,"\nisNumberArray( value:any )\n    Tests if a value is an array-like object containing only numbers.\n"
isNumberArray.primitives,"\nisNumberArray.primitives( value:any )\n    Tests if a value is an array-like object containing only number primitives.\n"
isNumberArray.objects,"\nisNumberArray.objects( value:any )\n    Tests if a value is an array-like object containing only `Number` objects.\n"
isNumericArray,"\nisNumericArray( value:any )\n    Tests if a value is a numeric array.\n"
isObject,"\nisObject( value:any )\n    Tests if a value is an object; e.g., `{}`.\n"
isObjectArray,"\nisObjectArray( value:any )\n    Tests if a value is an array-like object containing only objects.\n"
isObjectLike,"\nisObjectLike( value:any )\n    Tests if a value is object-like.\n"
isOdd,"\nisOdd( value:any )\n    Tests if a value is an odd number.\n"
isOdd.isPrimitive,"\nisOdd.isPrimitive( value:any )\n    Tests if a value is a number primitive that is an odd number.\n"
isOdd.isObject,"\nisOdd.isObject( value:any )\n    Tests if a value is a number object that has an odd number value.\n"
isoWeeksInYear,"\nisoWeeksInYear( [year:integer] )\n    Returns the number of ISO weeks in a year according to the Gregorian\n    calendar.\n"
isPersymmetricMatrix,"\nisPersymmetricMatrix( value:any )\n    Tests if a value is a square matrix which is symmetric about its\n    antidiagonal.\n"
isPlainObject,"\nisPlainObject( value:any )\n    Tests if a value is a plain object.\n"
isPlainObjectArray,"\nisPlainObjectArray( value:any )\n    Tests if a value is an array-like object containing only plain objects.\n"
isPositiveInteger,"\nisPositiveInteger( value:any )\n    Tests if a value is a positive integer.\n"
isPositiveInteger.isPrimitive,"\nisPositiveInteger.isPrimitive( value:any )\n    Tests if a value is a number primitive having a positive integer value.\n"
isPositiveInteger.isObject,"\nisPositiveInteger.isObject( value:any )\n    Tests if a value is a number object having a positive integer value.\n"
isPositiveIntegerArray,"\nisPositiveIntegerArray( value:any )\n    Tests if a value is an array-like object containing only positive integers.\n"
isPositiveIntegerArray.primitives,"\nisPositiveIntegerArray.primitives( value:any )\n    Tests if a value is an array-like object containing only positive primitive\n    integer values.\n"
isPositiveIntegerArray.objects,"\nisPositiveIntegerArray.objects( value:any )\n    Tests if a value is an array-like object containing only number objects\n    having positive integer values.\n"
isPositiveNumber,"\nisPositiveNumber( value:any )\n    Tests if a value is a positive number.\n"
isPositiveNumber.isPrimitive,"\nisPositiveNumber.isPrimitive( value:any )\n    Tests if a value is a number primitive having a positive value.\n"
isPositiveNumber.isObject,"\nisPositiveNumber.isObject( value:any )\n    Tests if a value is a number object having a positive value.\n"
isPositiveNumberArray,"\nisPositiveNumberArray( value:any )\n    Tests if a value is an array-like object containing only positive numbers.\n"
isPositiveNumberArray.primitives,"\nisPositiveNumberArray.primitives( value:any )\n    Tests if a value is an array-like object containing only positive primitive\n    number values.\n"
isPositiveNumberArray.objects,"\nisPositiveNumberArray.objects( value:any )\n    Tests if a value is an array-like object containing only number objects\n    having positive values.\n"
isPositiveZero,"\nisPositiveZero( value:any )\n    Tests if a value is positive zero.\n"
isPositiveZero.isPrimitive,"\nisPositiveZero.isPrimitive( value:any )\n    Tests if a value is a number primitive equal to positive zero.\n"
isPositiveZero.isObject,"\nisPositiveZero.isObject( value:any )\n    Tests if a value is a number object having a value equal to positive zero.\n"
isPrime,"\nisPrime( value:any )\n    Tests if a value is a prime number.\n"
isPrime.isPrimitive,"\nisPrime.isPrimitive( value:any )\n    Tests if a value is a number primitive which is a prime number.\n"
isPrime.isObject,"\nisPrime.isObject( value:any )\n    Tests if a value is a number object having a value which is a prime number.\n"
isPrimitive,"\nisPrimitive( value:any )\n    Tests if a value is a JavaScript primitive.\n"
isPrimitiveArray,"\nisPrimitiveArray( value:any )\n    Tests if a value is an array-like object containing only JavaScript\n    primitives.\n"
isPRNGLike,"\nisPRNGLike( value:any )\n    Tests if a value is PRNG-like.\n"
isProbability,"\nisProbability( value:any )\n    Tests if a value is a probability.\n"
isProbability.isPrimitive,"\nisProbability.isPrimitive( value:any )\n    Tests if a value is a number primitive which is a probability.\n"
isProbability.isObject,"\nisProbability.isObject( value:any )\n    Tests if a value is a number object having a value which is a probability.\n"
isProbabilityArray,"\nisProbabilityArray( value:any )\n    Tests if a value is an array-like object containing only probabilities.\n"
isProbabilityArray.primitives,"\nisProbabilityArray.primitives( value:any )\n    Tests if a value is an array-like object containing only primitive\n    probabilities.\n"
isProbabilityArray.objects,"\nisProbabilityArray.objects( value:any )\n    Tests if a value is an array-like object containing only number objects\n    having probability values.\n"
isPrototypeOf,"\nisPrototypeOf( value:any, proto:Object|Function )\n    Tests if an object's prototype chain contains a provided prototype.\n"
isRangeError,"\nisRangeError( value:any )\n    Tests if a value is a RangeError object.\n"
isReadableProperty,"\nisReadableProperty( value:any, property:any )\n    Tests if an object's own property is readable.\n"
isReadablePropertyIn,"\nisReadablePropertyIn( value:any, property:any )\n    Tests if an object's own or inherited property is readable.\n"
isReadOnlyProperty,"\nisReadOnlyProperty( value:any, property:any )\n    Tests if an object's own property is read-only.\n"
isReadOnlyPropertyIn,"\nisReadOnlyPropertyIn( value:any, property:any )\n    Tests if an object's own or inherited property is read-only.\n"
isReadWriteProperty,"\nisReadWriteProperty( value:any, property:any )\n    Tests if an object's own property is readable and writable.\n"
isReadWritePropertyIn,"\nisReadWritePropertyIn( value:any, property:any )\n    Tests if an object's own or inherited property is readable and writable.\n"
isReferenceError,"\nisReferenceError( value:any )\n    Tests if a value is a ReferenceError object.\n"
isRegExp,"\nisRegExp( value:any )\n    Tests if a value is a regular expression.\n"
isRegExpString,"\nisRegExpString( value:any )\n    Tests if a value is a regular expression string.\n"
isRelativePath,"\nisRelativePath( value:any )\n    Tests if a value is a relative path.\n"
isRelativePath.posix,"\nisRelativePath.posix( value:any )\n    Tests if a value is a POSIX relative path.\n"
isRelativePath.win32,"\nisRelativePath.win32( value:any )\n    Tests if a value is a Windows relative path.\n"
isSafeInteger,"\nisSafeInteger( value:any )\n    Tests if a value is a safe integer.\n"
isSafeInteger.isPrimitive,"\nisSafeInteger.isPrimitive( value:any )\n    Tests if a value is a number primitive having a safe integer value.\n"
isSafeInteger.isObject,"\nisSafeInteger.isObject( value:any )\n    Tests if a value is a `Number` object having a safe integer value.\n"
isSafeIntegerArray,"\nisSafeIntegerArray( value:any )\n    Tests if a value is an array-like object containing only safe integers.\n"
isSafeIntegerArray.primitives,"\nisSafeIntegerArray.primitives( value:any )\n    Tests if a value is an array-like object containing only primitive safe\n    integer values.\n"
isSafeIntegerArray.objects,"\nisSafeIntegerArray.objects( value:any )\n    Tests if a value is an array-like object containing only `Number` objects\n    having safe integer values.\n"
isSameValue,"\nisSameValue( a:any, b:any )\n    Tests if two arguments are the same value.\n"
isSameValueZero,"\nisSameValueZero( a:any, b:any )\n    Tests if two arguments are the same value.\n"
isSharedArrayBuffer,"\nisSharedArrayBuffer( value:any )\n    Tests if a value is a SharedArrayBuffer.\n"
isSkewCentrosymmetricMatrix,"\nisSkewCentrosymmetricMatrix( value:any )\n    Tests if a value is a skew-centrosymmetric matrix.\n"
isSkewPersymmetricMatrix,"\nisSkewPersymmetricMatrix( value:any )\n    Tests if a value is a skew-persymmetric matrix.\n"
isSkewSymmetricMatrix,"\nisSkewSymmetricMatrix( value:any )\n    Tests if a value is a skew-symmetric (or antisymmetric) matrix.\n"
isSquareMatrix,"\nisSquareMatrix( value:any )\n    Tests if a value is a 2-dimensional ndarray-like object having equal\n    dimensions.\n"
isSquareNumber,"\nisSquareNumber( value:any )\n    Tests if a value is a square number.\n"
isSquareNumber.isPrimitive,"\nisSquareNumber.isPrimitive( value:any )\n    Tests if a value is a number primitive which is a square number.\n"
isSquareNumber.isObject,"\nisSquareNumber.isObject( value:any )\n    Tests if a value is a number object having a value which is a square number.\n"
isSquareTriangularNumber,"\nisSquareTriangularNumber( value:any )\n    Tests if a value is a square triangular number.\n"
isSquareTriangularNumber.isPrimitive,"\nisSquareTriangularNumber.isPrimitive( value:any )\n    Tests if a value is a number primitive which is a square triangular number.\n"
isSquareTriangularNumber.isObject,"\nisSquareTriangularNumber.isObject( value:any )\n    Tests if a value is a number object having a value which is a square\n    triangular number.\n"
isStrictEqual,"\nisStrictEqual( a:any, b:any )\n    Tests if two arguments are strictly equal.\n"
isString,"\nisString( value:any )\n    Tests if a value is a string.\n"
isString.isPrimitive,"\nisString.isPrimitive( value:any )\n    Tests if a value is a string primitive.\n"
isString.isObject,"\nisString.isObject( value:any )\n    Tests if a value is a `String` object.\n"
isStringArray,"\nisStringArray( value:any )\n    Tests if a value is an array of strings.\n"
isStringArray.primitives,"\nisStringArray.primitives( value:any )\n    Tests if a value is an array containing only string primitives.\n"
isStringArray.objects,"\nisStringArray.objects( value:any )\n    Tests if a value is an array containing only `String` objects.\n"
isSymbol,"\nisSymbol( value:any )\n    Tests if a value is a symbol.\n"
isSymbolArray,"\nisSymbolArray( value:any )\n    Tests if a value is an array-like object containing only symbols.\n"
isSymbolArray.primitives,"\nisSymbolArray.primitives( value:any )\n    Tests if a value is an array-like object containing only `symbol`\n    primitives.\n"
isSymbolArray.objects,"\nisSymbolArray.objects( value:any )\n    Tests if a value is an array-like object containing only `Symbol`\n    objects.\n"
isSymmetricMatrix,"\nisSymmetricMatrix( value:any )\n    Tests if a value is a square matrix which equals its transpose.\n"
isSyntaxError,"\nisSyntaxError( value:any )\n    Tests if a value is a SyntaxError object.\n"
isTriangularNumber,"\nisTriangularNumber( value:any )\n    Tests if a value is a triangular number.\n"
isTriangularNumber.isPrimitive,"\nisTriangularNumber.isPrimitive( value:any )\n    Tests if a value is a number primitive which is a triangular number.\n"
isTriangularNumber.isObject,"\nisTriangularNumber.isObject( value:any )\n    Tests if a value is a number object having a value which is a triangular\n    number.\n"
isTruthy,"\nisTruthy( value:any )\n    Tests if a value is a value which translates to `true` when evaluated in a\n    boolean context.\n"
isTruthyArray,"\nisTruthyArray( value:any )\n    Tests if a value is an array-like object containing only truthy values.\n"
isTypedArray,"\nisTypedArray( value:any )\n    Tests if a value is a typed array.\n"
isTypedArrayLength,"\nisTypedArrayLength( value:any )\n    Tests if a value is a valid typed array length.\n"
isTypedArrayLike,"\nisTypedArrayLike( value:any )\n    Tests if a value is typed-array-like.\n"
isTypeError,"\nisTypeError( value:any )\n    Tests if a value is a TypeError object.\n"
isUint8Array,"\nisUint8Array( value:any )\n    Tests if a value is a Uint8Array.\n"
isUint8ClampedArray,"\nisUint8ClampedArray( value:any )\n    Tests if a value is a Uint8ClampedArray.\n"
isUint16Array,"\nisUint16Array( value:any )\n    Tests if a value is a Uint16Array.\n"
isUint32Array,"\nisUint32Array( value:any )\n    Tests if a value is a Uint32Array.\n"
isUNCPath,"\nisUNCPath( value:any )\n    Tests if a value is a UNC path.\n"
isUndefined,"\nisUndefined( value:any )\n    Tests if a value is undefined.\n"
isUndefinedOrNull,"\nisUndefinedOrNull( value:any )\n    Tests if a value is undefined or null.\n"
isUnityProbabilityArray,"\nisUnityProbabilityArray( value:any )\n    Tests if a value is an array of probabilities that sum to one.\n"
isUppercase,"\nisUppercase( value:any )\n    Tests if a value is an uppercase string.\n"
isURI,"\nisURI( value:any )\n    Tests if a value is a URI.\n"
isURIError,"\nisURIError( value:any )\n    Tests if a value is a URIError object.\n"
isVectorLike,"\nisVectorLike( value:any )\n    Tests if a value is a 1-dimensional ndarray-like object.\n"
isWhitespace,"\nisWhitespace( str:string )\n    Tests whether a string contains only white space characters.\n"
isWritableProperty,"\nisWritableProperty( value:any, property:any )\n    Tests if an object's own property is writable.\n"
isWritablePropertyIn,"\nisWritablePropertyIn( value:any, property:any )\n    Tests if an object's own or inherited property is writable.\n"
isWriteOnlyProperty,"\nisWriteOnlyProperty( value:any, property:any )\n    Tests if an object's own property is write-only.\n"
isWriteOnlyPropertyIn,"\nisWriteOnlyPropertyIn( value:any, property:any )\n    Tests if an object's own or inherited property is write-only.\n"
iterAbs,"\niterAbs( iterator:Object )\n    Returns an iterator which iteratively computes the absolute value.\n"
iterAbs2,"\niterAbs2( iterator:Object )\n    Returns an iterator which iteratively computes the squared absolute value.\n"
iterAcos,"\niterAcos( iterator:Object )\n    Returns an iterator which iteratively computes the arccosine.\n"
iterAcosh,"\niterAcosh( iterator:Object )\n    Returns an iterator which iteratively computes the hyperbolic arccosine.\n"
iterAcot,"\niterAcot( iterator:Object )\n    Returns an iterator which iteratively computes the inverse cotangent.\n"
iterAcoth,"\niterAcoth( iterator:Object )\n    Returns an iterator which iteratively computes the inverse hyperbolic\n    cotangent.\n"
iterAcovercos,"\niterAcovercos( iterator:Object )\n    Returns an iterator which iteratively computes the inverse coversed cosine.\n"
iterAcoversin,"\niterAcoversin( iterator:Object )\n    Returns an iterator which iteratively computes the inverse coversed sine.\n"
iterAdd,"\niterAdd( iter0:Object, ...iterator:Object )\n    Returns an iterator which performs element-wise addition of two or more\n    iterators.\n"
iterAdvance,"\niterAdvance( iterator:Object[, n:integer] )\n    Advances an entire iterator.\n"
iterAhavercos,"\niterAhavercos( iterator:Object )\n    Returns an iterator which iteratively computes the inverse half-value versed\n    cosine.\n"
iterAhaversin,"\niterAhaversin( iterator:Object )\n    Returns an iterator which iteratively computes the inverse half-value versed\n    sine.\n"
iterAny,"\niterAny( iterator:Object )\n    Tests whether at least one iterated value is truthy.\n"
iterAnyBy,"\niterAnyBy( iterator:Object, predicate:Function[, thisArg:any ] )\n    Tests whether at least one iterated value passes a test implemented by a\n    predicate function.\n"
iterAsin,"\niterAsin( iterator:Object )\n    Returns an iterator which iteratively computes the arcsine.\n"
iterAsinh,"\niterAsinh( iterator:Object )\n    Returns an iterator which iteratively computes the hyperbolic arcsine.\n"
iterAtan,"\niterAtan( iterator:Object )\n    Returns an iterator which iteratively computes the arctangent.\n"
iterAtan2,"\niterAtan2( y:Object|number, x:Object|number )\n    Returns an iterator which iteratively computes the angle in the plane (in\n    radians) between the positive x-axis and the ray from (0,0) to the point\n    (x,y).\n"
iterAtanh,"\niterAtanh( iterator:Object )\n    Returns an iterator which iteratively computes the hyperbolic arctangent.\n"
iterator2array,"\niterator2array( iterator:Object[, out:ArrayLikeObject][, mapFcn:Function[, \n  thisArg:any]] )\n    Creates (or fills) an array from an iterator.\n"
iterator2arrayview,"\niterator2arrayview( iterator:Object, dest:ArrayLikeObject[, begin:integer[, \n  end:integer]][, mapFcn:Function[, thisArg:any]] )\n    Fills an array-like object view with values returned from an iterator.\n"
iterator2arrayviewRight,"\niterator2arrayviewRight( iterator:Object, dest:ArrayLikeObject[, \n  begin:integer[, end:integer]][, mapFcn:Function[, thisArg:any]] )\n    Fills an array-like object view from right to left with values returned from\n    an iterator.\n"
iteratorStream,"\niteratorStream( iterator:Object[, options:Object] )\n    Creates a readable stream from an iterator.\n"
iteratorStream.factory,"\niteratorStream.factory( [options:Object] )\n    Returns a function for creating readable streams from iterators.\n"
iteratorStream.objectMode,"\niteratorStream.objectMode( iterator:Object[, options:Object] )\n    Returns an \"objectMode\" readable stream from an iterator.\n"
IteratorSymbol,"\nIteratorSymbol\n    Iterator symbol.\n"
iterAvercos,"\niterAvercos( iterator:Object )\n    Returns an iterator which iteratively computes the inverse versed cosine.\n"
iterAversin,"\niterAversin( iterator:Object )\n    Returns an iterator which iteratively computes the inverse versed sine.\n"
iterawgn,"\niterawgn( iterator:Object, sigma:number[, options:Object] )\n    Returns an iterator which introduces additive white Gaussian noise (AWGN)\n    with standard deviation `sigma`.\n"
iterawln,"\niterawln( iterator:Object, sigma:number[, options:Object] )\n    Returns an iterator which introduces additive white Laplacian noise (AWLN)\n    with standard deviation `sigma`.\n"
iterawun,"\niterawun( iterator:Object, sigma:number[, options:Object] )\n    Returns an iterator which introduces additive white uniform noise (AWUN)\n    with standard deviation `sigma`.\n"
iterBartlettHannPulse,"\niterBartlettHannPulse( [options:Object] )\n    Returns an iterator which generates a Bartlett-Hann pulse waveform.\n"
iterBartlettPulse,"\niterBartlettPulse( [options:Object] )\n    Returns an iterator which generates a Bartlett pulse waveform.\n"
iterBesselj0,"\niterBesselj0( iterator:Object )\n    Returns an iterator which iteratively evaluates the Bessel function of the\n    first kind of order zero.\n"
iterBesselj1,"\niterBesselj1( iterator:Object )\n    Returns an iterator which iteratively evaluates the Bessel function of the\n    first kind of order one.\n"
iterBessely0,"\niterBessely0( iterator:Object )\n    Returns an iterator which iteratively evaluates the Bessel function of the\n    second kind of order zero.\n"
iterBessely1,"\niterBessely1( iterator:Object )\n    Returns an iterator which iteratively evaluates the Bessel function of the\n    second kind of order one.\n"
iterBeta,"\niterBeta( x:Object|number, y:Object|number )\n    Returns an iterator which iteratively evaluates the beta function.\n"
iterBetaln,"\niterBetaln( x:Object|number, y:Object|number )\n    Returns an iterator which iteratively evaluates the natural logarithm of the\n    beta function.\n"
iterBinet,"\niterBinet( iterator:Object )\n    Returns an iterator which iteratively evaluates Binet's formula extended to\n    real numbers.\n"
iterCbrt,"\niterCbrt( iterator:Object )\n    Returns an iterator which iteratively computes the cube root.\n"
iterCeil,"\niterCeil( iterator:Object )\n    Returns an iterator which rounds each iterated value toward positive\n    infinity.\n"
iterCeil2,"\niterCeil2( iterator:Object )\n    Returns an iterator which rounds each iterated value to the nearest power of\n    two toward positive infinity.\n"
iterCeil10,"\niterCeil10( iterator:Object )\n    Returns an iterator which rounds each iterated value to the nearest power of\n    10 toward positive infinity.\n"
iterCompositesSeq,"\niterCompositesSeq( [options:Object] )\n    Returns an iterator which generates a sequence of composite numbers.\n"
iterConcat,"\niterConcat( iter0:Object, ...iterator:Object )\n    Returns an iterator which iterates over the values of two or more iterators.\n"
iterConstant,"\niterConstant( value:any[, options:Object] )\n    Returns an iterator which always returns the same value.\n"
iterCos,"\niterCos( iterator:Object )\n    Returns an iterator which iteratively computes the cosine.\n"
iterCosh,"\niterCosh( iterator:Object )\n    Returns an iterator which iteratively computes the hyperbolic cosine.\n"
iterCosineWave,"\niterCosineWave( [options:Object] )\n    Returns an iterator which generates a cosine wave.\n"
iterCosm1,"\niterCosm1( iterator:Object )\n    Returns an iterator which iteratively computes `cos(x) - 1`.\n"
iterCospi,"\niterCospi( iterator:Object )\n    Returns an iterator which computes the cosine of each iterated value times\n    π.\n"
iterCounter,"\niterCounter( iterator:Object )\n    Returns an iterator which iteratively computes the number of iterated\n    values.\n"
iterCovercos,"\niterCovercos( iterator:Object )\n    Returns an iterator which iteratively computes the coversed cosine.\n"
iterCoversin,"\niterCoversin( iterator:Object )\n    Returns an iterator which iteratively computes the coversed sine.\n"
iterCubesSeq,"\niterCubesSeq( [options:Object] )\n    Returns an iterator which generates a sequence of cubes.\n"
itercugmean,"\nitercugmean( iterator:Object )\n    Returns an iterator which iteratively computes a cumulative geometric mean.\n"
itercuhmean,"\nitercuhmean( iterator:Object )\n    Returns an iterator which iteratively computes a cumulative harmonic mean.\n"
itercumax,"\nitercumax( iterator:Object )\n    Returns an iterator which iteratively computes a cumulative maximum value.\n"
itercumaxabs,"\nitercumaxabs( iterator:Object )\n    Returns an iterator which iteratively computes a cumulative maximum absolute\n    value.\n"
itercumean,"\nitercumean( iterator:Object )\n    Returns an iterator which iteratively computes a cumulative arithmetic mean.\n"
itercumeanabs,"\nitercumeanabs( iterator:Object )\n    Returns an iterator which iteratively computes a cumulative arithmetic mean\n    of absolute values.\n"
itercumeanabs2,"\nitercumeanabs2( iterator:Object )\n    Returns an iterator which iteratively computes a cumulative arithmetic mean\n    of squared absolute values.\n"
itercumidrange,"\nitercumidrange( iterator:Object )\n    Returns an iterator which iteratively computes a cumulative mid-range.\n"
itercumin,"\nitercumin( iterator:Object )\n    Returns an iterator which iteratively computes a cumulative minimum value.\n"
itercuminabs,"\nitercuminabs( iterator:Object )\n    Returns an iterator which iteratively computes a cumulative minimum absolute\n    value.\n"
itercuprod,"\nitercuprod( iterator:Object )\n    Returns an iterator which iteratively computes a cumulative product.\n"
itercurange,"\nitercurange( iterator:Object )\n    Returns an iterator which iteratively computes a cumulative range.\n"
itercusum,"\nitercusum( iterator:Object )\n    Returns an iterator which iteratively computes a cumulative sum.\n"
itercusumabs,"\nitercusumabs( iterator:Object )\n    Returns an iterator which iteratively computes a cumulative sum of absolute\n    values.\n"
itercusumabs2,"\nitercusumabs2( iterator:Object )\n    Returns an iterator which iteratively computes a cumulative sum of squared\n    absolute values.\n"
iterDatespace,"\niterDatespace( start:integer|string|Date, stop:integer|string|Date[, \n  N:integer][, options:Object] )\n    Returns an iterator which returns evenly spaced dates over a specified\n    interval.\n"
iterDedupe,"\niterDedupe( iterator:Object[, limit:integer] )\n    Returns an iterator which removes consecutive duplicated values.\n"
iterDedupeBy,"\niterDedupeBy( iterator:Object, [limit:integer,] fcn:Function )\n    Returns an iterator which removes consecutive values that resolve to the\n    same value according to a provided function.\n"
iterDeg2rad,"\niterDeg2rad( iterator:Object )\n    Returns an iterator which iteratively converts an angle from degrees to\n    radians.\n"
iterDigamma,"\niterDigamma( iterator:Object )\n    Returns an iterator which iteratively evaluates the digamma function.\n"
iterDiracComb,"\niterDiracComb( [options:Object] )\n    Returns an iterator which generates a Dirac comb.\n"
iterDiracDelta,"\niterDiracDelta( iterator:Object )\n    Returns an iterator which iteratively evaluates the Dirac delta function.\n"
iterDivide,"\niterDivide( iter0:Object, ...iterator:Object )\n    Returns an iterator which performs element-wise division of two or more\n    iterators.\n"
iterEllipe,"\niterEllipe( iterator:Object )\n    Returns an iterator which iteratively computes the complete elliptic\n    integral of the second kind.\n"
iterEllipk,"\niterEllipk( iterator:Object )\n    Returns an iterator which iteratively computes the complete elliptic\n    integral of the first kind.\n"
iterEmpty,"\niterEmpty()\n    Returns an empty iterator.\n"
iterErf,"\niterErf( iterator:Object )\n    Returns an iterator which iteratively evaluates the error function.\n"
iterErfc,"\niterErfc( iterator:Object )\n    Returns an iterator which iteratively evaluates the complementary error\n    function.\n"
iterErfcinv,"\niterErfcinv( iterator:Object )\n    Returns an iterator which iteratively evaluates the inverse complementary\n    error function.\n"
iterErfinv,"\niterErfinv( iterator:Object )\n    Returns an iterator which iteratively evaluates the inverse error function.\n"
iterEta,"\niterEta( iterator:Object )\n    Returns an iterator which iteratively evaluates the Dirichlet eta function.\n"
iterEvenIntegersSeq,"\niterEvenIntegersSeq( [options:Object] )\n    Returns an iterator which generates an interleaved sequence of even\n    integers.\n"
iterEvery,"\niterEvery( iterator:Object )\n    Tests whether all iterated values are truthy.\n"
iterEveryBy,"\niterEveryBy( iterator:Object, predicate:Function[, thisArg:any ] )\n    Tests whether every iterated value passes a test implemented by a predicate\n    function.\n"
iterExp,"\niterExp( iterator:Object )\n    Returns an iterator which iteratively evaluates the natural exponential\n    function.\n"
iterExp2,"\niterExp2( iterator:Object )\n    Returns an iterator which iteratively evaluates the base `2` exponential\n    function.\n"
iterExp10,"\niterExp10( iterator:Object )\n    Returns an iterator which iteratively evaluates the base `10` exponential\n    function.\n"
iterExpit,"\niterExpit( iterator:Object )\n    Returns an iterator which iteratively evaluates the standard logistic\n    function.\n"
iterExpm1,"\niterExpm1( iterator:Object )\n    Returns an iterator which iteratively computes `exp(x) - 1`.\n"
iterExpm1rel,"\niterExpm1rel( iterator:Object )\n    Returns an iterator which iteratively evaluates the relative error\n    exponential.\n"
iterFactorial,"\niterFactorial( iterator:Object )\n    Returns an iterator which iteratively evaluates the factorial function.\n"
iterFactorialln,"\niterFactorialln( iterator:Object )\n    Returns an iterator which iteratively evaluates the natural logarithm of the\n    factorial function.\n"
iterFactorialsSeq,"\niterFactorialsSeq( [options:Object] )\n    Returns an iterator which generates a sequence of factorials.\n"
iterFibonacciSeq,"\niterFibonacciSeq( [options:Object] )\n    Returns an iterator which generates a Fibonacci sequence.\n"
iterFifthPowersSeq,"\niterFifthPowersSeq( [options:Object] )\n    Returns an iterator which generates a sequence of fifth powers.\n"
iterFill,"\niterFill( iterator:Object, value:any[, begin:integer[, end:integer]] )\n    Returns an iterator which replaces all values from a provided iterator from\n    a start index to an end index with a static value.\n"
iterFilter,"\niterFilter( iterator:Object, predicate:Function[, thisArg:any] )\n    Returns an iterator which filters a provided iterator's values according to\n    a predicate function.\n"
iterFilterMap,"\niterFilterMap( iterator:Object, fcn:Function[, thisArg:any] )\n    Returns an iterator which both filters and maps a provided iterator's\n    values.\n"
iterFirst,"\niterFirst( iterator:Object )\n    Returns the first iterated value.\n"
iterFlatTopPulse,"\niterFlatTopPulse( [options:Object] )\n    Returns an iterator which generates a flat top pulse waveform.\n"
iterFloor,"\niterFloor( iterator:Object )\n    Returns an iterator which rounds each iterated value toward negative\n    infinity.\n"
iterFloor2,"\niterFloor2( iterator:Object )\n    Returns an iterator which rounds each iterated value to the nearest power of\n    two toward negative infinity.\n"
iterFloor10,"\niterFloor10( iterator:Object )\n    Returns an iterator which rounds each iterated value to the nearest power of\n    10 toward negative infinity.\n"
iterFlow,"\niterFlow( methods:Object )\n    Returns a fluent interface iterator constructor with a customized prototype\n    based on provided methods.\n"
iterForEach,"\niterForEach( iterator:Object, fcn:Function[, thisArg:any] )\n    Returns an iterator which invokes a function for each iterated value before\n    returning the iterated value.\n"
iterFourthPowersSeq,"\niterFourthPowersSeq( [options:Object] )\n    Returns an iterator which generates a sequence of fourth powers.\n"
iterFresnelc,"\niterFresnelc( iterator:Object )\n    Returns an iterator which iteratively computes the Fresnel integral C(x).\n"
iterFresnels,"\niterFresnels( iterator:Object )\n    Returns an iterator which iteratively computes the Fresnel integral S(x).\n"
iterGamma,"\niterGamma( iterator:Object )\n    Returns an iterator which iteratively evaluates the gamma function.\n"
iterGamma1pm1,"\niterGamma1pm1( iterator:Object )\n    Returns an iterator which iteratively computes `gamma(x+1) - 1` without\n    cancellation errors for small `x`.\n"
iterGammaln,"\niterGammaln( iterator:Object )\n    Returns an iterator which iteratively evaluates the natural logarithm of the\n    gamma function.\n"
iterHacovercos,"\niterHacovercos( iterator:Object )\n    Returns an iterator which iteratively computes the half-value coversed\n    cosine.\n"
iterHacoversin,"\niterHacoversin( iterator:Object )\n    Returns an iterator which iteratively computes the half-value coversed sine.\n"
iterHannPulse,"\niterHannPulse( [options:Object] )\n    Returns an iterator which generates a Hann pulse waveform.\n"
iterHavercos,"\niterHavercos( iterator:Object )\n    Returns an iterator which iteratively computes the half-value versed cosine.\n"
iterHaversin,"\niterHaversin( iterator:Object )\n    Returns an iterator which iteratively computes the half-value versed sine.\n"
iterHead,"\niterHead( iterator:Object, n:integer )\n    Returns an iterator which returns the first `n` values of a provided\n    iterator.\n"
iterIncrspace,"\niterIncrspace( start:number, stop:number[, increment:number] )\n    Returns an iterator which returns evenly spaced numbers according to a\n    specified increment.\n"
iterIntegersSeq,"\niterIntegersSeq( [options:Object] )\n    Returns an iterator which generates an interleaved integer sequence.\n"
iterIntersection,"\niterIntersection( iter0:Object, ...iterator:Object )\n    Returns an iterator which returns the intersection of two or more iterators.\n"
iterIntersectionByHash,"\niterIntersectionByHash( iter0:Object, ...iterator:Object, hashFcn:Function[, \n  thisArg:any] )\n    Returns an iterator which returns the intersection of two or more iterators\n    according to a hash function.\n"
iterInv,"\niterInv( iterator:Object )\n    Returns an iterator which iteratively computes the multiplicative inverse.\n"
iterLanczosPulse,"\niterLanczosPulse( [options:Object] )\n    Returns an iterator which generates a Lanczos pulse waveform.\n"
iterLast,"\niterLast( iterator:Object )\n    Consumes an entire iterator and returns the last iterated value.\n"
iterLength,"\niterLength( iterator:Object )\n    Consumes an entire iterator and returns the number of iterated values.\n"
iterLinspace,"\niterLinspace( start:number, stop:number[, N:integer] )\n    Returns an iterator which returns evenly spaced numbers over a specified\n    interval.\n"
iterLn,"\niterLn( iterator:Object )\n    Returns an iterator which iteratively evaluates the natural logarithm.\n"
iterLog,"\niterLog( x:Object|number, b:Object|number )\n    Returns an iterator which iteratively computes the base `b` logarithm.\n"
iterLog1mexp,"\niterLog1mexp( iterator:Object )\n    Returns an iterator which iteratively evaluates the natural logarithm of\n    `1-exp(-|x|)`.\n"
iterLog1p,"\niterLog1p( iterator:Object )\n    Returns an iterator which iteratively evaluates the natural logarithm of\n    `1+x`.\n"
iterLog1pexp,"\niterLog1pexp( iterator:Object )\n    Returns an iterator which iteratively evaluates the natural logarithm of\n    `1+exp(x)`.\n"
iterLog2,"\niterLog2( iterator:Object )\n    Returns an iterator which iteratively evaluates the binary logarithm.\n"
iterLog10,"\niterLog10( iterator:Object )\n    Returns an iterator which iteratively evaluates the common logarithm\n    (logarithm with base 10).\n"
iterLogit,"\niterLogit( iterator:Object )\n    Returns an iterator which iteratively evaluates the logit function.\n"
iterLogspace,"\niterLogspace( start:number, stop:number[, N:integer][, options:Object] )\n    Returns an iterator which returns evenly spaced numbers on a log scale.\n"
iterLucasSeq,"\niterLucasSeq( [options:Object] )\n    Returns an iterator which generates a Lucas sequence.\n"
iterMap,"\niterMap( iterator:Object, fcn:Function[, thisArg:any] )\n    Returns an iterator which invokes a function for each iterated value.\n"
iterMapN,"\niterMapN( iter0:Object, ...iterator:Object, fcn:Function[, thisArg:any] )\n    Returns an iterator which transforms iterated values from two or more\n    iterators by applying the iterated values as arguments to a provided\n    function.\n"
itermax,"\nitermax( iterator:Object )\n    Computes the maximum value of all iterated values.\n"
itermaxabs,"\nitermaxabs( iterator:Object )\n    Computes the maximum absolute value of all iterated values.\n"
itermean,"\nitermean( iterator:Object )\n    Computes an arithmetic mean over all iterated values.\n"
itermeanabs,"\nitermeanabs( iterator:Object )\n    Computes an arithmetic mean of absolute values for all iterated values.\n"
itermeanabs2,"\nitermeanabs2( iterator:Object )\n    Computes an arithmetic mean of squared absolute values for all iterated\n    values.\n"
itermidrange,"\nitermidrange( iterator:Object )\n    Computes the mid-range of all iterated values.\n"
itermin,"\nitermin( iterator:Object )\n    Computes the minimum value of all iterated values.\n"
iterminabs,"\niterminabs( iterator:Object )\n    Computes the minimum absolute value of all iterated values.\n"
itermmax,"\nitermmax( iterator:Object, W:integer )\n    Returns an iterator which iteratively computes a moving maximum value.\n"
itermmaxabs,"\nitermmaxabs( iterator:Object, W:integer )\n    Returns an iterator which iteratively computes a moving maximum absolute\n    value.\n"
itermmean,"\nitermmean( iterator:Object, W:integer )\n    Returns an iterator which iteratively computes a moving arithmetic mean.\n"
itermmeanabs,"\nitermmeanabs( iterator:Object, W:integer )\n    Returns an iterator which iteratively computes a moving arithmetic mean of\n    absolute values.\n"
itermmeanabs2,"\nitermmeanabs2( iterator:Object, W:integer )\n    Returns an iterator which iteratively computes a moving arithmetic mean of\n    squared absolute values.\n"
itermmidrange,"\nitermmidrange( iterator:Object, W:integer )\n    Returns an iterator which iteratively computes a moving mid-range.\n"
itermmin,"\nitermmin( iterator:Object, W:integer )\n    Returns an iterator which iteratively computes a moving minimum value.\n"
itermminabs,"\nitermminabs( iterator:Object, W:integer )\n    Returns an iterator which iteratively computes a moving minimum absolute\n    value.\n"
iterMod,"\niterMod( iter0:Object, ...iterator:Object )\n    Returns an iterator which performs an element-wise modulo operation of two\n    or more iterators.\n"
itermprod,"\nitermprod( iterator:Object, W:integer )\n    Returns an iterator which iteratively computes a moving product.\n"
itermrange,"\nitermrange( iterator:Object, W:integer )\n    Returns an iterator which iteratively computes a moving range.\n"
itermsum,"\nitermsum( iterator:Object, W:integer )\n    Returns an iterator which iteratively computes a moving sum.\n"
itermsumabs,"\nitermsumabs( iterator:Object, W:integer )\n    Returns an iterator which iteratively computes a moving sum of absolute\n    values.\n"
itermsumabs2,"\nitermsumabs2( iterator:Object, W:integer )\n    Returns an iterator which iteratively computes a moving sum of squared\n    absolute values.\n"
iterMultiply,"\niterMultiply( iter0:Object, ...iterator:Object )\n    Returns an iterator which performs element-wise multiplication of two or\n    more iterators.\n"
iterNegaFibonacciSeq,"\niterNegaFibonacciSeq( [options:Object] )\n    Returns an iterator which generates a negaFibonacci sequence.\n"
iterNegaLucasSeq,"\niterNegaLucasSeq( [options:Object] )\n    Returns an iterator which generates a negaLucas sequence.\n"
iterNegativeEvenIntegersSeq,"\niterNegativeEvenIntegersSeq( [options:Object] )\n    Returns an iterator which generates a sequence of negative even integers.\n"
iterNegativeIntegersSeq,"\niterNegativeIntegersSeq( [options:Object] )\n    Returns an iterator which generates a negative integer sequence.\n"
iterNegativeOddIntegersSeq,"\niterNegativeOddIntegersSeq( [options:Object] )\n    Returns an iterator which generates a sequence of negative odd integers.\n"
iterNone,"\niterNone( iterator:Object )\n    Tests whether all iterated values are falsy.\n"
iterNoneBy,"\niterNoneBy( iterator:Object, predicate:Function[, thisArg:any ] )\n    Tests whether every iterated value fails a test implemented by a predicate\n    function.\n"
iterNonFibonacciSeq,"\niterNonFibonacciSeq( [options:Object] )\n    Returns an iterator which generates a non-Fibonacci integer sequence.\n"
iterNonNegativeEvenIntegersSeq,"\niterNonNegativeEvenIntegersSeq( [options:Object] )\n    Returns an iterator which generates a sequence of nonnegative even integers.\n"
iterNonNegativeIntegersSeq,"\niterNonNegativeIntegersSeq( [options:Object] )\n    Returns an iterator which generates a nonnegative integer sequence.\n"
iterNonPositiveEvenIntegersSeq,"\niterNonPositiveEvenIntegersSeq( [options:Object] )\n    Returns an iterator which generates a sequence of nonpositive even integers.\n"
iterNonPositiveIntegersSeq,"\niterNonPositiveIntegersSeq( [options:Object] )\n    Returns an iterator which generates a nonpositive integer sequence.\n"
iterNonSquaresSeq,"\niterNonSquaresSeq( [options:Object] )\n    Returns an iterator which generates a sequence of nonsquares.\n"
iterNth,"\niterNth( iterator:Object, n:integer )\n    Returns the nth iterated value.\n"
iterOddIntegersSeq,"\niterOddIntegersSeq( [options:Object] )\n    Returns an iterator which generates an interleaved sequence of odd integers.\n"
iterPeriodicSinc,"\niterPeriodicSinc( n:integer[, options:Object] )\n    Returns an iterator which generates a periodic sinc waveform.\n"
iterPipeline,"\niterPipeline( iterFcn:Function|Array[, ...iterFcn:Function] )\n    Returns an iterator pipeline.\n"
iterPop,"\niterPop( iterator:Object[, clbk:Function[, thisArg:any]] )\n    Returns an iterator which skips the last value of a provided iterator.\n"
iterPositiveEvenIntegersSeq,"\niterPositiveEvenIntegersSeq( [options:Object] )\n    Returns an iterator which generates a sequence of positive even integers.\n"
iterPositiveIntegersSeq,"\niterPositiveIntegersSeq( [options:Object] )\n    Returns an iterator which generates a positive integer sequence.\n"
iterPositiveOddIntegersSeq,"\niterPositiveOddIntegersSeq( [options:Object] )\n    Returns an iterator which generates a sequence of positive odd integers.\n"
iterPow,"\niterPow( base:Object|number, exponent:Object|number )\n    Returns an iterator which iteratively evaluates the exponential function.\n"
iterPrimesSeq,"\niterPrimesSeq( [options:Object] )\n    Returns an iterator which generates a sequence of prime numbers.\n"
iterprod,"\niterprod( iterator:Object )\n    Computes the product of all iterated values.\n"
iterPulse,"\niterPulse( [options:Object] )\n    Returns an iterator which generates a pulse waveform.\n"
iterPush,"\niterPush( iterator:Object, ...items:any )\n    Returns an iterator which appends additional values to the end of a provided\n    iterator.\n"
iterRad2deg,"\niterRad2deg( iterator:Object )\n    Returns an iterator which iteratively converts an angle from radians to\n    degrees.\n"
iterRamp,"\niterRamp( iterator:Object )\n    Returns an iterator which iteratively evaluates the ramp function.\n"
iterrange,"\niterrange( iterator:Object )\n    Computes the range of all iterated values.\n"
iterReject,"\niterReject( iterator:Object, predicate:Function[, thisArg:any] )\n    Returns an iterator which rejects a provided iterator's values according to\n    a predicate function.\n"
iterReplicate,"\niterReplicate( iterator:Object, n:integer )\n    Returns an iterator which replicates each iterated value `n` times.\n"
iterReplicateBy,"\niterReplicateBy( iterator:Object, fcn:Function[, thisArg:any] )\n    Returns an iterator which replicates each iterated value according to a\n    provided function.\n"
iterRound,"\niterRound( iterator:Object )\n    Returns an iterator which rounds each iterated value to the nearest integer.\n"
iterRound2,"\niterRound2( iterator:Object )\n    Returns an iterator which rounds each iterated value to the nearest power of\n    two on a linear scale.\n"
iterRound10,"\niterRound10( iterator:Object )\n    Returns an iterator which rounds each iterated value to the nearest power of\n    10 on a linear scale.\n"
iterRsqrt,"\niterRsqrt( iterator:Object )\n    Returns an iterator which iteratively computes the reciprocal (inverse)\n    square root.\n"
iterSawtoothWave,"\niterSawtoothWave( [options:Object] )\n    Returns an iterator which generates a sawtooth wave.\n"
iterShift,"\niterShift( iterator:Object[, clbk:Function[, thisArg:any]] )\n    Returns an iterator which skips the first value of a provided iterator.\n"
iterSignum,"\niterSignum( iterator:Object )\n    Returns an iterator which iteratively evaluates the signum function.\n"
iterSin,"\niterSin( iterator:Object )\n    Returns an iterator which iteratively computes the sine.\n"
iterSinc,"\niterSinc( iterator:Object )\n    Returns an iterator which iteratively computes the normalized cardinal sine.\n"
iterSineWave,"\niterSineWave( [options:Object] )\n    Returns an iterator which generates a sine wave.\n"
iterSinh,"\niterSinh( iterator:Object )\n    Returns an iterator which iteratively evaluates the hyperbolic sine.\n"
iterSinpi,"\niterSinpi( iterator:Object )\n    Returns an iterator which computes the sine of each iterated value times π.\n"
iterSlice,"\niterSlice( iterator:Object[, begin:integer[, end:integer]] )\n    Returns an iterator which returns a subsequence of iterated values from a\n    provided iterator.\n"
iterSome,"\niterSome( iterator:Object, n:number )\n    Tests whether at least `n` iterated values are truthy.\n"
iterSomeBy,"\niterSomeBy( iterator:Object, n:integer, predicate:Function[, thisArg:any ] )\n    Tests whether at least `n` iterated values pass a test implemented by a\n    predicate function.\n"
iterSpence,"\niterSpence( iterator:Object )\n    Returns an iterator which iteratively evaluates Spence's function.\n"
iterSqrt,"\niterSqrt( iterator:Object )\n    Returns an iterator which iteratively computes the principal square root.\n"
iterSqrt1pm1,"\niterSqrt1pm1( iterator:Object )\n    Returns an iterator which iteratively computes `sqrt(1+x) - 1` more \n    accurately for small `x`.\n"
iterSquaredTriangularSeq,"\niterSquaredTriangularSeq( [options:Object] )\n    Returns an iterator which generates a sequence of squared triangular\n    numbers.\n"
iterSquaresSeq,"\niterSquaresSeq( [options:Object] )\n    Returns an iterator which generates a sequence of squares.\n"
iterSquareWave,"\niterSquareWave( [options:Object] )\n    Returns an iterator which generates a square wave.\n"
iterstdev,"\niterstdev( iterator:Object[, mean:number] )\n    Computes a correct sample standard deviation over all iterated values.\n"
iterStep,"\niterStep( start:number, increment:number[, N:number] )\n    Returns an iterator which returns a sequence of numbers according to a\n    specified increment.\n"
iterStrided,"\niterStrided( iterator:Object, stride:integer[, offset:integer[, \n  eager:boolean]] )\n    Returns an iterator which steps by a specified amount.\n"
iterStridedBy,"\niterStridedBy( iterator:Object, fcn:Function[, offset:integer[, \n  eager:boolean]][, thisArg:any] )\n    Returns an iterator which steps according to a provided callback function.\n"
iterSubtract,"\niterSubtract( iter0:Object, ...iterator:Object )\n    Returns an iterator which performs element-wise subtraction of two or more\n    iterators.\n"
itersum,"\nitersum( iterator:Object )\n    Computes the sum of all iterated values.\n"
itersumabs,"\nitersumabs( iterator:Object )\n    Computes the sum of absolute values for all iterated values.\n"
itersumabs2,"\nitersumabs2( iterator:Object )\n    Computes the sum of squared absolute values for all iterated values.\n"
iterTan,"\niterTan( iterator:Object )\n    Returns an iterator which iteratively evaluates the tangent.\n"
iterTanh,"\niterTanh( iterator:Object )\n    Returns an iterator which iteratively evaluates the hyperbolic tangent.\n"
iterThunk,"\niterThunk( iterFcn:Function[, ...args:any] )\n    Returns an iterator \"thunk\".\n"
iterTriangleWave,"\niterTriangleWave( [options:Object] )\n    Returns an iterator which generates a triangle wave.\n"
iterTriangularSeq,"\niterTriangularSeq( [options:Object] )\n    Returns an iterator which generates a sequence of triangular numbers.\n"
iterTrigamma,"\niterTrigamma( iterator:Object )\n    Returns an iterator which iteratively evaluates the trigamma function.\n"
iterTrunc,"\niterTrunc( iterator:Object )\n    Returns an iterator which rounds each iterated value toward zero.\n"
iterTrunc2,"\niterTrunc2( iterator:Object )\n    Returns an iterator which rounds each iterated value to the nearest power of\n    two toward zero.\n"
iterTrunc10,"\niterTrunc10( iterator:Object )\n    Returns an iterator which rounds each iterated value to the nearest power of\n    10 toward zero.\n"
iterUnion,"\niterUnion( iter0:Object, ...iterator:Object )\n    Returns an iterator which returns the union of two or more iterators.\n"
iterUnique,"\niterUnique( iterator:Object )\n    Returns an iterator which returns unique values.\n"
iterUniqueBy,"\niterUniqueBy( iterator:Object, predicate:Function[, thisArg:any] )\n    Returns an iterator which returns unique values according to a predicate\n    function.\n"
iterUniqueByHash,"\niterUniqueByHash( iterator:Object, hashFcn:Function[, thisArg:any] )\n    Returns an iterator which returns unique values according to a hash\n    function.\n"
iterUnitspace,"\niterUnitspace( start:number[, stop:number] )\n    Returns an iterator which returns numbers incremented by one.\n"
iterUnshift,"\niterUnshift( iterator:Object, ...items:any )\n    Returns an iterator which prepends values to the beginning of a provided\n    iterator.\n"
itervariance,"\nitervariance( iterator:Object[, mean:number] )\n    Computes an unbiased sample variance over all iterated values.\n"
iterVercos,"\niterVercos( iterator:Object )\n    Returns an iterator which iteratively computes the versed cosine.\n"
iterVersin,"\niterVersin( iterator:Object )\n    Returns an iterator which iteratively computes the versed sine.\n"
iterZeta,"\niterZeta( iterator:Object )\n    Returns an iterator which iteratively evaluates the Riemann zeta function.\n"
joinStream,"\njoinStream( [options:Object] )\n    Returns a transform stream which joins streamed data.\n"
joinStream.factory,"\njoinStream.factory( [options:Object] )\n    Returns a function for creating transform streams for joined streamed data.\n"
joinStream.objectMode,"\njoinStream.objectMode( [options:Object] )\n    Returns an \"objectMode\" transform stream for joining streamed data.\n"
kde2d,"\nkde2d( x:Array<number>, y:Array<number>[, options:Object] )\n    Two-dimensional kernel density estimation.\n"
keyBy,"\nkeyBy( collection:Array|TypedArray|Object, fcn:Function[, thisArg:any] )\n    Converts a collection to an object whose keys are determined by a provided\n    function and whose values are the collection values.\n"
keyByRight,"\nkeyByRight( collection:Array|TypedArray|Object, fcn:Function[, thisArg:any] )\n    Converts a collection to an object whose keys are determined by a provided\n    function and whose values are the collection values, iterating from right to\n    left.\n"
keysIn,"\nkeysIn( obj:any )\n    Returns an array of an object's own and inherited enumerable property\n    names.\n"
kruskalTest,"\nkruskalTest( ...x:Array[, options:Object] )\n    Computes the Kruskal-Wallis test for equal medians.\n"
kstest,"\nkstest( x:Array<number>, y:Function|string[, ...params:number][, \n  options:Object] )\n    Computes a Kolmogorov-Smirnov goodness-of-fit test.\n"
leveneTest,"\nleveneTest( x:Array<number>[, ...y:Array<number>[, options:Object]] )\n    Computes Levene's test for equal variances.\n"
LinkedList,"\nLinkedList()\n    Linked list constructor.\n"
linspace,"\nlinspace( start:number, stop:number[, length:integer] )\n    Generates a linearly spaced numeric array.\n"
LIU_NEGATIVE_OPINION_WORDS_EN,"\nLIU_NEGATIVE_OPINION_WORDS_EN()\n    Returns a list of negative opinion words.\n"
LIU_POSITIVE_OPINION_WORDS_EN,"\nLIU_POSITIVE_OPINION_WORDS_EN()\n    Returns a list of positive opinion words.\n"
LN_HALF,"\nLN_HALF\n    Natural logarithm of `1/2`.\n"
LN_PI,"\nLN_PI\n    Natural logarithm of the mathematical constant `π`.\n"
LN_SQRT_TWO_PI,"\nLN_SQRT_TWO_PI\n    Natural logarithm of the square root of `2π`.\n"
LN_TWO_PI,"\nLN_TWO_PI\n    Natural logarithm of `2π`.\n"
LN2,"\nLN2\n    Natural logarithm of `2`.\n"
LN10,"\nLN10\n    Natural logarithm of `10`.\n"
LOG2E,"\nLOG2E\n    Base 2 logarithm of Euler's number.\n"
LOG10E,"\nLOG10E\n    Base 10 logarithm of Euler's number.\n"
logspace,"\nlogspace( a:number, b:number[, length:integer] )\n    Generates a logarithmically spaced numeric array between `10^a` and `10^b`.\n"
lowercase,"\nlowercase( str:string )\n    Converts a `string` to lowercase.\n"
lowercaseKeys,"\nlowercaseKeys( obj:Object )\n    Converts each object key to lowercase.\n"
lowess,"\nlowess( x:Array<number>, y:Array<number>[, options:Object] )\n    Locally-weighted polynomial regression via the LOWESS algorithm.\n"
lpad,"\nlpad( str:string, len:integer[, pad:string] )\n    Left pads a `string` such that the padded `string` has a length of at least\n    `len`.\n"
ltrim,"\nltrim( str:string )\n    Trims whitespace from the beginning of a `string`.\n"
MALE_FIRST_NAMES_EN,"\nMALE_FIRST_NAMES_EN()\n    Returns a list of common male first names in English speaking countries.\n"
mapFun,"\nmapFun( fcn:Function, n:integer[, thisArg:any] )\n    Invokes a function `n` times and returns an array of accumulated function\n    return values.\n"
mapFunAsync,"\nmapFunAsync( fcn:Function, n:integer, [options:Object,] done:Function )\n    Invokes a function `n` times and returns an array of accumulated function\n    return values.\n"
mapFunAsync.factory,"\nmapFunAsync.factory( [options:Object,] fcn:Function )\n    Returns a function which invokes a function `n` times and returns an array\n    of accumulated function return values.\n"
mapKeys,"\nmapKeys( obj:Object, transform:Function )\n    Maps keys from one object to a new object having the same values.\n"
mapKeysAsync,"\nmapKeysAsync( obj:Object, [options:Object,] transform:Function, done:Function )\n    Maps keys from one object to a new object having the same values.\n"
mapKeysAsync.factory,"\nmapKeysAsync.factory( [options:Object,] transform:Function )\n    Returns a function which maps keys from one object to a new object having\n    the same values.\n"
mapValues,"\nmapValues( obj:Object, transform:Function )\n    Maps values from one object to a new object having the same keys.\n"
mapValuesAsync,"\nmapValuesAsync( obj:Object, [options:Object,] transform:Function, \n  done:Function )\n    Maps values from one object to a new object having the same keys.\n"
mapValuesAsync.factory,"\nmapValuesAsync.factory( [options:Object,] transform:Function )\n    Returns a function which maps values from one object to a new object having\n    the same keys.\n"
MAX_ARRAY_LENGTH,"\nMAX_ARRAY_LENGTH\n    Maximum length for a generic array.\n"
MAX_TYPED_ARRAY_LENGTH,"\nMAX_TYPED_ARRAY_LENGTH\n    Maximum length for a typed array.\n"
memoize,"\nmemoize( fcn:Function[, hashFunction:Function] )\n    Returns a memoized function.\n"
merge,"\nmerge( target:Object, ...source:Object )\n    Merges objects into a target object.\n"
merge.factory,"\nmerge.factory( options:Object )\n    Returns a function for merging and extending objects.\n"
MILLISECONDS_IN_DAY,"\nMILLISECONDS_IN_DAY\n    Number of milliseconds in a day.\n"
MILLISECONDS_IN_HOUR,"\nMILLISECONDS_IN_HOUR\n    Number of milliseconds in an hour.\n"
MILLISECONDS_IN_MINUTE,"\nMILLISECONDS_IN_MINUTE\n    Number of milliseconds in a minute.\n"
MILLISECONDS_IN_SECOND,"\nMILLISECONDS_IN_SECOND\n    Number of milliseconds in a second.\n"
MILLISECONDS_IN_WEEK,"\nMILLISECONDS_IN_WEEK\n    Number of milliseconds in a week.\n"
MINARD_NAPOLEONS_MARCH,"\nMINARD_NAPOLEONS_MARCH( [options:Object] )\n    Returns data for Charles Joseph Minard's cartographic depiction of\n    Napoleon's Russian campaign of 1812.\n"
MINUTES_IN_DAY,"\nMINUTES_IN_DAY\n    Number of minutes in a day.\n"
MINUTES_IN_HOUR,"\nMINUTES_IN_HOUR\n    Number of minutes in an hour.\n"
MINUTES_IN_WEEK,"\nMINUTES_IN_WEEK\n    Number of minutes in a week.\n"
minutesInMonth,"\nminutesInMonth( [month:string|Date|integer[, year:integer]] )\n    Returns the number of minutes in a month.\n"
minutesInYear,"\nminutesInYear( [value:integer|Date] )\n    Returns the number of minutes in a year according to the Gregorian calendar.\n"
MOBY_DICK,"\nMOBY_DICK()\n    Returns the text of Moby Dick by Herman Melville.\n"
MONTH_NAMES_EN,"\nMONTH_NAMES_EN()\n    Returns a list of month names (English).\n"
MONTHS_IN_YEAR,"\nMONTHS_IN_YEAR\n    Number of months in a year.\n"
moveProperty,"\nmoveProperty( source:Object, prop:string, target:Object )\n    Moves a property from one object to another object.\n"
namedtypedtuple,"\nnamedtypedtuple( fields:Array<string>[, options:Object] )\n    Returns a named typed tuple factory.\n"
nativeClass,"\nnativeClass( value:any )\n    Returns a string value indicating a specification defined classification of\n    an object.\n"
ndarray,"\nndarray( dtype:string, buffer:ArrayLikeObject|TypedArray|Buffer, \n  shape:ArrayLikeObject<integer>, strides:ArrayLikeObject<integer>, \n  offset:integer, order:string[, options:Object] )\n    Returns an ndarray.\n"
ndarray.prototype.byteLength,"\nndarray.prototype.byteLength\n    Size (in bytes) of the array (if known).\n"
ndarray.prototype.BYTES_PER_ELEMENT,"\nndarray.prototype.BYTES_PER_ELEMENT\n    Size (in bytes) of each array element (if known).\n"
ndarray.prototype.data,"\nndarray.prototype.data\n    Pointer to the underlying data buffer.\n"
ndarray.prototype.dtype,"\nndarray.prototype.dtype\n    Underlying data type.\n"
ndarray.prototype.flags,"\nndarray.prototype.flags\n    Information about the memory layout of the array.\n"
ndarray.prototype.length,"\nndarray.prototype.length\n    Length of the array (i.e., number of elements).\n"
ndarray.prototype.ndims,"\nndarray.prototype.ndims\n    Number of dimensions.\n"
ndarray.prototype.offset,"\nndarray.prototype.offset\n    Index offset which specifies the buffer index at which to start iterating\n    over array elements.\n"
ndarray.prototype.order,"\nndarray.prototype.order\n    Array order.\n"
ndarray.prototype.shape,"\nndarray.prototype.shape\n    Array shape.\n"
ndarray.prototype.strides,"\nndarray.prototype.strides\n    Index strides which specify how to access data along corresponding array\n    dimensions.\n"
ndarray.prototype.get,"\nndarray.prototype.get( ...idx:integer )\n    Returns an array element specified according to provided subscripts.\n"
ndarray.prototype.iget,"\nndarray.prototype.iget( idx:integer )\n    Returns an array element located at a specified linear index.\n"
ndarray.prototype.set,"\nndarray.prototype.set( ...idx:integer, v:any )\n    Sets an array element specified according to provided subscripts.\n"
ndarray.prototype.iset,"\nndarray.prototype.iset( idx:integer, v:any )\n    Sets an array element located at a specified linear index.\n"
ndarray.prototype.toString,"\nndarray.prototype.toString()\n    Serializes an ndarray as a string.\n"
ndarray.prototype.toJSON,"\nndarray.prototype.toJSON()\n    Serializes an ndarray as a JSON object.\n"
ndarrayCastingModes,"\nndarrayCastingModes()\n    Returns a list of ndarray casting modes.\n"
ndarrayDataTypes,"\nndarrayDataTypes()\n    Returns a list of ndarray data types.\n"
ndarrayDispatch,"\nndarrayDispatch( fcns:Function|ArrayLikeObject<Function>, \n  types:ArrayLikeObject<string>, data:ArrayLikeObject|null, nargs:integer, \n  nin:integer, nout:integer )\n    Returns an ndarray function interface which performs multiple dispatch.\n"
ndarrayIndexModes,"\nndarrayIndexModes()\n    Returns a list of ndarray index modes.\n"
ndarrayMinDataType,"\nndarrayMinDataType( value:any )\n    Returns the minimum ndarray data type of the closest \"kind\" necessary for\n    storing a provided scalar value.\n"
ndarrayNextDataType,"\nndarrayNextDataType( [dtype:string] )\n    Returns the next larger ndarray data type of the same kind.\n"
ndarrayOrders,"\nndarrayOrders()\n    Returns a list of ndarray orders.\n"
ndarrayPromotionRules,"\nndarrayPromotionRules( [dtype1:string, dtype2:string] )\n    Returns the ndarray data type with the smallest size and closest \"kind\" to\n    which ndarray data types can be safely cast.\n"
ndarraySafeCasts,"\nndarraySafeCasts( [dtype:string] )\n    Returns a list of ndarray data types to which a provided ndarray data type\n    can be safely cast.\n"
ndarraySameKindCasts,"\nndarraySameKindCasts( [dtype:string] )\n    Returns a list of ndarray data types to which a provided ndarray data type\n    can be safely cast or cast within the same \"kind\".\n"
nextGraphemeClusterBreak,"\nnextGraphemeClusterBreak( str:string[, fromIndex:integer] )\n    Returns the next extended grapheme cluster break in a string after a\n    specified position.\n"
nextTick,"\nnextTick( clbk[, ...args] )\n    Adds a callback to the \"next tick queue\".\n"
NIGHTINGALES_ROSE,"\nNIGHTINGALES_ROSE()\n    Returns data for Nightingale's famous polar area diagram.\n"
NINF,"\nNINF\n    Double-precision floating-point negative infinity.\n"
NODE_VERSION,"\nNODE_VERSION\n    Node version.\n"
none,"\nnone( collection:Array|TypedArray|Object )\n    Tests whether all elements in a collection are falsy.\n"
noneBy,"\nnoneBy( collection:Array|TypedArray|Object, predicate:Function[, thisArg:any ] )\n    Tests whether all elements in a collection fail a test implemented by a\n    predicate function.\n"
noneByAsync,"\nnoneByAsync( collection:Array|TypedArray|Object, [options:Object,] \n  predicate:Function, done:Function )\n    Tests whether all elements in a collection fail a test implemented by a\n    predicate function.\n"
noneByAsync.factory,"\nnoneByAsync.factory( [options:Object,] predicate:Function )\n    Returns a function which tests whether all elements in a collection fail a\n    test implemented by a predicate function.\n"
noneByRight,"\nnoneByRight( collection:Array|TypedArray|Object, predicate:Function[, \n  thisArg:any ] )\n    Tests whether all elements in a collection fail a test implemented by a\n    predicate function, iterating from right to left.\n"
noneByRightAsync,"\nnoneByRightAsync( collection:Array|TypedArray|Object, [options:Object,] \n  predicate:Function, done:Function )\n    Tests whether all elements in a collection fail a test implemented by a\n    predicate function, iterating from right to left.\n"
noneByRightAsync.factory,"\nnoneByRightAsync.factory( [options:Object,] predicate:Function )\n    Returns a function which tests whether all elements in a collection fail a\n    test implemented by a predicate function, iterating from right to left.\n"
nonEnumerableProperties,"\nnonEnumerableProperties( value:any )\n    Returns an array of an object's own non-enumerable property names and\n    symbols.\n"
nonEnumerablePropertiesIn,"\nnonEnumerablePropertiesIn( value:any )\n    Returns an array of an object's own and inherited non-enumerable property\n    names and symbols.\n"
nonEnumerablePropertyNames,"\nnonEnumerablePropertyNames( value:any )\n    Returns an array of an object's own non-enumerable property names.\n"
nonEnumerablePropertyNamesIn,"\nnonEnumerablePropertyNamesIn( value:any )\n    Returns an array of an object's own and inherited non-enumerable property\n    names.\n"
nonEnumerablePropertySymbols,"\nnonEnumerablePropertySymbols( value:any )\n    Returns an array of an object's own non-enumerable symbol properties.\n"
nonEnumerablePropertySymbolsIn,"\nnonEnumerablePropertySymbolsIn( value:any )\n    Returns an array of an object's own and inherited non-enumerable symbol\n    properties.\n"
nonIndexKeys,"\nnonIndexKeys( obj:any )\n    Returns an array of an object's own enumerable property names which are not\n    integer indices.\n"
noop,"\nnoop()\n    A function which does nothing.\n"
now,"\nnow()\n    Returns the time in seconds since the epoch.\n"
NUM_CPUS,"\nNUM_CPUS\n    Number of CPUs.\n"
Number,"\nNumber( value:number )\n    Returns a Number object.\n"
numGraphemeClusters,"\nnumGraphemeClusters( str:string )\n    Returns the number of grapheme clusters in a string.\n"
objectEntries,"\nobjectEntries( obj:ObjectLike )\n    Returns an array of an object's own enumerable property `[key, value]`\n    pairs.\n"
objectEntriesIn,"\nobjectEntriesIn( obj:ObjectLike )\n    Returns an array of an object's own and inherited enumerable property\n    `[key, value]` pairs.\n"
objectFromEntries,"\nobjectFromEntries( entries:Array<Array> )\n    Creates an object from an array of key-value pairs.\n"
objectInverse,"\nobjectInverse( obj:ObjectLike[, options:Object] )\n    Inverts an object, such that keys become values and values become keys.\n"
objectInverseBy,"\nobjectInverseBy( obj:ObjectLike, [options:Object,] transform:Function )\n    Inverts an object, such that keys become values and values become keys,\n    according to a transform function.\n"
objectKeys,"\nobjectKeys( value:any )\n    Returns an array of an object's own enumerable property names.\n"
objectValues,"\nobjectValues( obj:ObjectLike )\n    Returns an array of an object's own enumerable property values.\n"
objectValuesIn,"\nobjectValuesIn( obj:ObjectLike )\n    Returns an array of an object's own and inherited enumerable property\n    values.\n"
omit,"\nomit( obj:Object, keys:string|Array )\n    Returns a partial object copy excluding specified keys.\n"
omitBy,"\nomitBy( obj:Object, predicate:Function )\n    Returns a partial object copy excluding properties for which a predicate\n    returns a truthy value.\n"
open,"\nopen( path:string|Buffer[, flags:string|number[, mode:integer]], clbk:Function )\n    Asynchronously opens a file.\n"
open.sync,"\nopen.sync( path:string|Buffer[, flags:string|number[, mode:integer]] )\n    Synchronously opens a file.\n"
openURL,"\nopenURL( url:string )\n    Opens a URL in a user's default browser.\n"
PACE_BOSTON_HOUSE_PRICES,"\nPACE_BOSTON_HOUSE_PRICES()\n    Returns a (corrected) dataset derived from information collected by the US\n    Census Service concerning housing in Boston, Massachusetts (1978).\n"
pad,"\npad( str:string, len:integer[, options:Object] )\n    Pads a `string` such that the padded `string` has length `len`.\n"
padjust,"\npadjust( pvals:Array<number>, method:string[, comparisons:integer] )\n    Adjusts supplied p-values for multiple comparisons via a specified method.\n"
papply,"\npapply( fcn:Function, ...args:any )\n    Returns a function of smaller arity by partially applying arguments.\n"
papplyRight,"\npapplyRight( fcn:Function, ...args:any )\n    Returns a function of smaller arity by partially applying arguments from the\n    right.\n"
parallel,"\nparallel( files:Array<string>, [options:Object,] clbk:Function )\n    Executes scripts in parallel.\n"
parseJSON,"\nparseJSON( str:string[, reviver:Function] )\n    Attempts to parse a string as JSON.\n"
PATH_DELIMITER,"\nPATH_DELIMITER\n    Platform-specific path delimiter.\n"
PATH_DELIMITER_POSIX,"\nPATH_DELIMITER_POSIX\n    POSIX path delimiter.\n"
PATH_DELIMITER_WIN32,"\nPATH_DELIMITER_WIN32\n    Windows path delimiter.\n"
PATH_SEP,"\nPATH_SEP\n    Platform-specific path segment separator.\n"
PATH_SEP_POSIX,"\nPATH_SEP_POSIX\n    POSIX path segment separator.\n"
PATH_SEP_WIN32,"\nPATH_SEP_WIN32\n    Windows path segment separator.\n"
pcorrtest,"\npcorrtest( x:Array<number>, y:Array<number>[, options:Object] )\n    Computes a Pearson product-moment correlation test between paired samples.\n"
percentEncode,"\npercentEncode( str:string )\n    Percent-encodes a UTF-16 encoded string according to RFC 3986.\n"
PHI,"\nPHI\n    Golden ratio.\n"
PI,"\nPI\n    The mathematical constant `π`.\n"
PI_SQUARED,"\nPI_SQUARED\n    Square of the mathematical constant `π`.\n"
pick,"\npick( obj:Object, keys:string|Array )\n    Returns a partial object copy containing only specified keys.\n"
pickBy,"\npickBy( obj:Object, predicate:Function )\n    Returns a partial object copy containing properties for which a predicate\n    returns a truthy value.\n"
PINF,"\nPINF\n    Double-precision floating-point positive infinity.\n"
pkg2alias,"\npkg2alias( pkg:string )\n    Returns the alias associated with a specified package name.\n"
pkg2related,"\npkg2related( pkg:string )\n    Returns package names related to a specified package name.\n"
pkg2standalone,"\npkg2standalone( pkg:string )\n    Returns the standalone package name associated with a provided internal\n    package name.\n"
PLATFORM,"\nPLATFORM\n    Platform on which the current process is running.\n"
plot,"\nplot( [x:Array|Array, y:Array|Array,] [options:Object] )\n    Returns a plot instance for creating 2-dimensional plots.\n"
Plot,"\nPlot( [x:Array|Array, y:Array|Array,] [options:Object] )\n    Returns a plot instance for creating 2-dimensional plots.\n"
pluck,"\npluck( arr:Array, prop:string[, options:Object] )\n    Extracts a property value from each element of an object array.\n"
pop,"\npop( collection:Array|TypedArray|Object )\n    Removes and returns the last element of a collection.\n"
porterStemmer,"\nporterStemmer( word:string )\n    Extracts the stem of a given word.\n"
prepend,"\nprepend( collection1:Array|TypedArray|Object, \n  collection2:Array|TypedArray|Object )\n    Adds the elements of one collection to the beginning of another collection.\n"
PRIMES_100K,"\nPRIMES_100K()\n    Returns an array containing the first 100,000 prime numbers.\n"
properties,"\nproperties( value:any )\n    Returns an array of an object's own enumerable and non-enumerable property\n    names and symbols.\n"
propertiesIn,"\npropertiesIn( value:any )\n    Returns an array of an object's own and inherited property names and\n    symbols.\n"
propertyDescriptor,"\npropertyDescriptor( value:any, property:string|symbol )\n    Returns a property descriptor for an object's own property.\n"
propertyDescriptorIn,"\npropertyDescriptorIn( value:any, property:string|symbol )\n    Returns a property descriptor for an object's own or inherited property.\n"
propertyDescriptors,"\npropertyDescriptors( value:any )\n    Returns an object's own property descriptors.\n"
propertyDescriptorsIn,"\npropertyDescriptorsIn( value:any )\n    Returns an object's own and inherited property descriptors.\n"
propertyNames,"\npropertyNames( value:any )\n    Returns an array of an object's own enumerable and non-enumerable property\n    names.\n"
propertyNamesIn,"\npropertyNamesIn( value:any )\n    Returns an array of an object's own and inherited enumerable and non-\n    enumerable property names.\n"
propertySymbols,"\npropertySymbols( value:any )\n    Returns an array of an object's own symbol properties.\n"
propertySymbolsIn,"\npropertySymbolsIn( value:any )\n    Returns an array of an object's own and inherited symbol properties.\n"
Proxy,"\nProxy( target:Object, handlers:Object )\n    Returns a proxy object implementing custom behavior for specified object\n    operations.\n"
Proxy.revocable,"\nProxy.revocable( target:Object, handlers:Object )\n    Returns a revocable proxy object.\n"
push,"\npush( collection:Array|TypedArray|Object, ...items:any )\n    Adds one or more elements to the end of a collection.\n"
quarterOfYear,"\nquarterOfYear( [month:integer|string|Date] )\n    Returns the quarter of the year.\n"
random.iterators.arcsine,"\nrandom.iterators.arcsine( a:number, b:number[, options:Object] )\n    Returns an iterator for generating pseudorandom numbers drawn from an\n    arcsine distribution.\n"
random.iterators.bernoulli,"\nrandom.iterators.bernoulli( p:number[, options:Object] )\n    Returns an iterator for generating pseudorandom numbers drawn from a\n    Bernoulli distribution.\n"
random.iterators.beta,"\nrandom.iterators.beta( α:number, β:number[, options:Object] )\n    Returns an iterator for generating pseudorandom numbers drawn from a\n    beta distribution.\n"
random.iterators.betaprime,"\nrandom.iterators.betaprime( α:number, β:number[, options:Object] )\n    Returns an iterator for generating pseudorandom numbers drawn from a\n    beta prime distribution.\n"
random.iterators.binomial,"\nrandom.iterators.binomial( n:integer, p:number[, options:Object] )\n    Returns an iterator for generating pseudorandom numbers drawn from a\n    binomial distribution.\n"
random.iterators.boxMuller,"\nrandom.iterators.boxMuller( [options:Object] )\n    Returns an iterator for generating pseudorandom numbers drawn from a\n    standard normal distribution using the Box-Muller transform.\n"
random.iterators.cauchy,"\nrandom.iterators.cauchy( x0:number, Ɣ:number[, options:Object] )\n    Returns an iterator for generating pseudorandom numbers drawn from a\n    Cauchy distribution.\n"
random.iterators.chi,"\nrandom.iterators.chi( k:number[, options:Object] )\n    Returns an iterator for generating pseudorandom numbers drawn from a chi\n    distribution.\n"
random.iterators.chisquare,"\nrandom.iterators.chisquare( k:number[, options:Object] )\n    Returns an iterator for generating pseudorandom numbers drawn from a\n    chi-square distribution.\n"
random.iterators.cosine,"\nrandom.iterators.cosine( μ:number, s:number[, options:Object] )\n    Returns an iterator for generating pseudorandom numbers drawn from a raised\n    cosine distribution.\n"
random.iterators.discreteUniform,"\nrandom.iterators.discreteUniform( a:integer, b:integer[, options:Object] )\n    Returns an iterator for generating pseudorandom numbers drawn from a\n    discrete uniform distribution.\n"
random.iterators.erlang,"\nrandom.iterators.erlang( k:integer, λ:number[, options:Object] )\n    Returns an iterator for generating pseudorandom numbers drawn from an Erlang\n    distribution.\n"
random.iterators.exponential,"\nrandom.iterators.exponential( λ:number[, options:Object] )\n    Returns an iterator for generating pseudorandom numbers drawn from an\n    exponential distribution.\n"
random.iterators.f,"\nrandom.iterators.f( d1:number, d2:number[, options:Object] )\n    Returns an iterator for generating pseudorandom numbers drawn from an F\n    distribution.\n"
random.iterators.frechet,"\nrandom.iterators.frechet( α:number, s:number, m:number[, options:Object] )\n    Returns an iterator for generating pseudorandom numbers drawn from a Fréchet\n    distribution.\n"
random.iterators.gamma,"\nrandom.iterators.gamma( α:number, β:number[, options:Object] )\n    Returns an iterator for generating pseudorandom numbers drawn from a gamma\n    distribution.\n"
random.iterators.geometric,"\nrandom.iterators.geometric( p:number[, options:Object] )\n    Returns an iterator for generating pseudorandom numbers drawn from a\n    geometric distribution.\n"
random.iterators.gumbel,"\nrandom.iterators.gumbel( μ:number, β:number[, options:Object] )\n    Returns an iterator for generating pseudorandom numbers drawn from a Gumbel\n    distribution.\n"
random.iterators.hypergeometric,"\nrandom.iterators.hypergeometric( N:integer, K:integer, n:integer[, \n  options:Object] )\n    Returns an iterator for generating pseudorandom numbers drawn from a\n    hypergeometric distribution.\n"
random.iterators.improvedZiggurat,"\nrandom.iterators.improvedZiggurat( [options:Object] )\n    Returns an iterator for generating pseudorandom numbers drawn from a\n    standard normal distribution using the Improved Ziggurat algorithm.\n"
random.iterators.invgamma,"\nrandom.iterators.invgamma( α:number, β:number[, options:Object] )\n    Returns an iterator for generating pseudorandom numbers drawn from an\n    inverse gamma distribution.\n"
random.iterators.kumaraswamy,"\nrandom.iterators.kumaraswamy( a:number, b:number[, options:Object] )\n    Returns an iterator for generating pseudorandom numbers drawn from a\n    Kumaraswamy's double bounded distribution.\n"
random.iterators.laplace,"\nrandom.iterators.laplace( μ:number, b:number[, options:Object] )\n    Returns an iterator for generating pseudorandom numbers drawn from a Laplace\n    (double exponential) distribution.\n"
random.iterators.levy,"\nrandom.iterators.levy( μ:number, c:number[, options:Object] )\n    Returns an iterator for generating pseudorandom numbers drawn from a Lévy\n    distribution.\n"
random.iterators.logistic,"\nrandom.iterators.logistic( μ:number, s:number[, options:Object] )\n    Returns an iterator for generating pseudorandom numbers drawn from a\n    logistic distribution.\n"
random.iterators.lognormal,"\nrandom.iterators.lognormal( μ:number, σ:number[, options:Object] )\n    Returns an iterator for generating pseudorandom numbers drawn from a\n    lognormal distribution.\n"
random.iterators.minstd,"\nrandom.iterators.minstd( [options:Object] )\n    Returns an iterator for generating pseudorandom integers on the interval\n    `[1, 2147483646]`.\n"
random.iterators.minstdShuffle,"\nrandom.iterators.minstdShuffle( [options:Object] )\n    Returns an iterator for generating pseudorandom integers on the interval\n    `[1, 2147483646]`.\n"
random.iterators.mt19937,"\nrandom.iterators.mt19937( [options:Object] )\n    Returns an iterator for generating pseudorandom integers on the interval\n    `[1, 4294967295]`.\n"
random.iterators.negativeBinomial,"\nrandom.iterators.negativeBinomial( r:number, p:number[, options:Object] )\n    Returns an iterator for generating pseudorandom numbers drawn from a\n    negative binomial distribution.\n"
random.iterators.normal,"\nrandom.iterators.normal( μ:number, σ:number[, options:Object] )\n    Returns an iterator for generating pseudorandom numbers drawn from a normal\n    distribution.\n"
random.iterators.pareto1,"\nrandom.iterators.pareto1( α:number, β:number[, options:Object] )\n    Returns an iterator for generating pseudorandom numbers drawn from a Pareto\n    (Type I) distribution.\n"
random.iterators.poisson,"\nrandom.iterators.poisson( λ:number[, options:Object] )\n    Returns an iterator for generating pseudorandom numbers drawn from a Poisson\n    distribution.\n"
random.iterators.randi,"\nrandom.iterators.randi( [options:Object] )\n    Create an iterator for generating pseudorandom numbers having integer\n    values.\n"
random.iterators.randn,"\nrandom.iterators.randn( [options:Object] )\n    Create an iterator for generating pseudorandom numbers drawn from a standard\n    normal distribution.\n"
random.iterators.randu,"\nrandom.iterators.randu( [options:Object] )\n    Create an iterator for generating uniformly distributed pseudorandom numbers\n    between 0 and 1.\n"
random.iterators.rayleigh,"\nrandom.iterators.rayleigh( σ:number[, options:Object] )\n    Returns an iterator for generating pseudorandom numbers drawn from a\n    Rayleigh distribution.\n"
random.iterators.t,"\nrandom.iterators.t( v:number[, options:Object] )\n    Returns an iterator for generating pseudorandom numbers drawn from a\n    Student's t distribution.\n"
random.iterators.triangular,"\nrandom.iterators.triangular( a:number, b:number, c:number[, options:Object] )\n    Returns an iterator for generating pseudorandom numbers drawn from a\n    triangular distribution.\n"
random.iterators.uniform,"\nrandom.iterators.uniform( a:number, b:number[, options:Object] )\n    Returns an iterator for generating pseudorandom numbers drawn from a\n    continuous uniform distribution.\n"
random.iterators.weibull,"\nrandom.iterators.weibull( k:number, λ:number[, options:Object] )\n    Returns an iterator for generating pseudorandom numbers drawn from a\n    Weibull distribution.\n"
random.streams.arcsine,"\nrandom.streams.arcsine( a:number, b:number[, options:Object] )\n    Returns a readable stream for generating pseudorandom numbers drawn from an\n    arcsine distribution.\n"
random.streams.arcsine.factory,"\nrandom.streams.arcsine.factory( [a:number, b:number, ][options:Object] )\n    Returns a function for creating readable streams which generate pseudorandom\n    numbers drawn from an arcsine distribution.\n"
random.streams.arcsine.objectMode,"\nrandom.streams.arcsine.objectMode( a:number, b:number[, options:Object] )\n    Returns an \"objectMode\" readable stream for generating pseudorandom numbers\n    drawn from an arcsine distribution.\n"
random.streams.bernoulli,"\nrandom.streams.bernoulli( p:number[, options:Object] )\n    Returns a readable stream for generating pseudorandom numbers drawn from a\n    Bernoulli distribution.\n"
random.streams.bernoulli.factory,"\nrandom.streams.bernoulli.factory( [p:number, ][options:Object] )\n    Returns a function for creating readable streams which generate pseudorandom\n    numbers drawn from a Bernoulli distribution.\n"
random.streams.bernoulli.objectMode,"\nrandom.streams.bernoulli.objectMode( p:number[, options:Object] )\n    Returns an \"objectMode\" readable stream for generating pseudorandom numbers\n    drawn from a Bernoulli distribution.\n"
random.streams.beta,"\nrandom.streams.beta( α:number, β:number[, options:Object] )\n    Returns a readable stream for generating pseudorandom numbers drawn from a\n    beta distribution.\n"
random.streams.beta.factory,"\nrandom.streams.beta.factory( [α:number, β:number, ][options:Object] )\n    Returns a function for creating readable streams which generate pseudorandom\n    numbers drawn from a beta distribution.\n"
random.streams.beta.objectMode,"\nrandom.streams.beta.objectMode( α:number, β:number[, options:Object] )\n    Returns an \"objectMode\" readable stream for generating pseudorandom numbers\n    drawn from a beta distribution.\n"
random.streams.betaprime,"\nrandom.streams.betaprime( α:number, β:number[, options:Object] )\n    Returns a readable stream for generating pseudorandom numbers drawn from a\n    beta prime distribution.\n"
random.streams.betaprime.factory,"\nrandom.streams.betaprime.factory( [α:number, β:number, ][options:Object] )\n    Returns a function for creating readable streams which generate pseudorandom\n    numbers drawn from a beta prime distribution.\n"
random.streams.betaprime.objectMode,"\nrandom.streams.betaprime.objectMode( α:number, β:number[, options:Object] )\n    Returns an \"objectMode\" readable stream for generating pseudorandom numbers\n    drawn from a beta prime distribution.\n"
random.streams.binomial,"\nrandom.streams.binomial( n:integer, p:number[, options:Object] )\n    Returns a readable stream for generating pseudorandom numbers drawn from a\n    binomial distribution.\n"
random.streams.binomial.factory,"\nrandom.streams.binomial.factory( [n:integer, p:number, ][options:Object] )\n    Returns a function for creating readable streams which generate pseudorandom\n    numbers drawn from a binomial distribution.\n"
random.streams.binomial.objectMode,"\nrandom.streams.binomial.objectMode( n:integer, p:number[, options:Object] )\n    Returns an \"objectMode\" readable stream for generating pseudorandom numbers\n    drawn from a binomial distribution.\n"
random.streams.boxMuller,"\nrandom.streams.boxMuller( [options:Object] )\n    Returns a readable stream for generating pseudorandom numbers drawn from a\n    standard normal distribution using the Box-Muller transform.\n"
random.streams.boxMuller.factory,"\nrandom.streams.boxMuller.factory( [options:Object] )\n    Returns a function for creating readable streams which generate pseudorandom\n    numbers drawn from a standard normal distribution using the Box-Muller\n    transform.\n"
random.streams.boxMuller.objectMode,"\nrandom.streams.boxMuller.objectMode( [options:Object] )\n    Returns an \"objectMode\" readable stream for generating pseudorandom numbers\n    drawn from a standard normal distribution using the Box-Muller transform.\n"
random.streams.cauchy,"\nrandom.streams.cauchy( x0:number, γ:number[, options:Object] )\n    Returns a readable stream for generating pseudorandom numbers drawn from a\n    Cauchy distribution.\n"
random.streams.cauchy.factory,"\nrandom.streams.cauchy.factory( [x0:number, γ:number, ][options:Object] )\n    Returns a function for creating readable streams which generate pseudorandom\n    numbers drawn from a Cauchy distribution.\n"
random.streams.cauchy.objectMode,"\nrandom.streams.cauchy.objectMode( x0:number, γ:number[, options:Object] )\n    Returns an \"objectMode\" readable stream for generating pseudorandom numbers\n    drawn from a Cauchy distribution.\n"
random.streams.chi,"\nrandom.streams.chi( k:number[, options:Object] )\n    Returns a readable stream for generating pseudorandom numbers drawn from a\n    chi distribution.\n"
random.streams.chi.factory,"\nrandom.streams.chi.factory( [k:number, ][options:Object] )\n    Returns a function for creating readable streams which generate pseudorandom\n    numbers drawn from a chi distribution.\n"
random.streams.chi.objectMode,"\nrandom.streams.chi.objectMode( k:number[, options:Object] )\n    Returns an \"objectMode\" readable stream for generating pseudorandom numbers\n    drawn from a chi distribution.\n"
random.streams.chisquare,"\nrandom.streams.chisquare( k:number[, options:Object] )\n    Returns a readable stream for generating pseudorandom numbers drawn from a\n    chi-square distribution.\n"
random.streams.chisquare.factory,"\nrandom.streams.chisquare.factory( [k:number, ][options:Object] )\n    Returns a function for creating readable streams which generate pseudorandom\n    numbers drawn from a chi-square distribution.\n"
random.streams.chisquare.objectMode,"\nrandom.streams.chisquare.objectMode( k:number[, options:Object] )\n    Returns an \"objectMode\" readable stream for generating pseudorandom numbers\n    drawn from a chi-square distribution.\n"
random.streams.cosine,"\nrandom.streams.cosine( μ:number, s:number[, options:Object] )\n    Returns a readable stream for generating pseudorandom numbers drawn from a\n    raised cosine distribution.\n"
random.streams.cosine.factory,"\nrandom.streams.cosine.factory( [μ:number, s:number, ][options:Object] )\n    Returns a function for creating readable streams which generate pseudorandom\n    numbers drawn from a raised cosine distribution.\n"
random.streams.cosine.objectMode,"\nrandom.streams.cosine.objectMode( μ:number, s:number[, options:Object] )\n    Returns an \"objectMode\" readable stream for generating pseudorandom numbers\n    drawn from a raised cosine distribution.\n"
random.streams.discreteUniform,"\nrandom.streams.discreteUniform( a:integer, b:integer[, options:Object] )\n    Returns a readable stream for generating pseudorandom numbers drawn from a\n    discrete uniform distribution.\n"
random.streams.discreteUniform.factory,"\nrandom.streams.discreteUniform.factory( [a:integer, b:integer, ]\n  [options:Object] )\n    Returns a function for creating readable streams which generate pseudorandom\n    numbers drawn from a discrete uniform distribution.\n"
random.streams.discreteUniform.objectMode,"\nrandom.streams.discreteUniform.objectMode( a:integer, b:integer[, \n  options:Object] )\n    Returns an \"objectMode\" readable stream for generating pseudorandom numbers\n    drawn from a discrete uniform distribution.\n"
random.streams.erlang,"\nrandom.streams.erlang( k:integer, λ:number[, options:Object] )\n    Returns a readable stream for generating pseudorandom numbers drawn from an\n    Erlang distribution.\n"
random.streams.erlang.factory,"\nrandom.streams.erlang.factory( [k:number, λ:number, ][options:Object] )\n    Returns a function for creating readable streams which generate pseudorandom\n    numbers drawn from an Erlang distribution.\n"
random.streams.erlang.objectMode,"\nrandom.streams.erlang.objectMode( k:number, λ:number[, options:Object] )\n    Returns an \"objectMode\" readable stream for generating pseudorandom numbers\n    drawn from an Erlang distribution.\n"
random.streams.exponential,"\nrandom.streams.exponential( λ:number[, options:Object] )\n    Returns a readable stream for generating pseudorandom numbers drawn from an\n    exponential distribution.\n"
random.streams.exponential.factory,"\nrandom.streams.exponential.factory( [λ:number, ][options:Object] )\n    Returns a function for creating readable streams which generate pseudorandom\n    numbers drawn from an exponential distribution.\n"
random.streams.exponential.objectMode,"\nrandom.streams.exponential.objectMode( λ:number[, options:Object] )\n    Returns an \"objectMode\" readable stream for generating pseudorandom numbers\n    drawn from an exponential distribution.\n"
random.streams.f,"\nrandom.streams.f( d1:number, d2:number[, options:Object] )\n    Returns a readable stream for generating pseudorandom numbers drawn from an\n    F distribution.\n"
random.streams.f.factory,"\nrandom.streams.f.factory( [d1:number, d2:number, ][options:Object] )\n    Returns a function for creating readable streams which generate pseudorandom\n    numbers drawn from an F distribution.\n"
random.streams.f.objectMode,"\nrandom.streams.f.objectMode( d1:number, d2:number[, options:Object] )\n    Returns an \"objectMode\" readable stream for generating pseudorandom numbers\n    drawn from an F distribution.\n"
random.streams.frechet,"\nrandom.streams.frechet( α:number, s:number, m:number[, options:Object] )\n    Returns a readable stream for generating pseudorandom numbers drawn from a\n    Fréchet distribution.\n"
random.streams.frechet.factory,"\nrandom.streams.frechet.factory( [α:number, s:number, m:number,]\n  [options:Object] )\n    Returns a function for creating readable streams which generate pseudorandom\n    numbers drawn from a Fréchet distribution.\n"
random.streams.frechet.objectMode,"\nrandom.streams.frechet.objectMode( α:number, s:number, m:number[, \n  options:Object] )\n    Returns an \"objectMode\" readable stream for generating pseudorandom numbers\n    drawn from a Fréchet distribution.\n"
random.streams.gamma,"\nrandom.streams.gamma( α:number, β:number[, options:Object] )\n    Returns a readable stream for generating pseudorandom numbers drawn from a\n    gamma distribution.\n"
random.streams.gamma.factory,"\nrandom.streams.gamma.factory( [α:number, β:number, ][options:Object] )\n    Returns a function for creating readable streams which generate pseudorandom\n    numbers drawn from a gamma distribution.\n"
random.streams.gamma.objectMode,"\nrandom.streams.gamma.objectMode( α:number, β:number[, options:Object] )\n    Returns an \"objectMode\" readable stream for generating pseudorandom numbers\n    drawn from a gamma distribution.\n"
random.streams.geometric,"\nrandom.streams.geometric( p:number[, options:Object] )\n    Returns a readable stream for generating pseudorandom numbers drawn from a\n    geometric distribution.\n"
random.streams.geometric.factory,"\nrandom.streams.geometric.factory( [p:number, ][options:Object] )\n    Returns a function for creating readable streams which generate pseudorandom\n    numbers drawn from a geometric distribution.\n"
random.streams.geometric.objectMode,"\nrandom.streams.geometric.objectMode( p:number[, options:Object] )\n    Returns an \"objectMode\" readable stream for generating pseudorandom numbers\n    drawn from a geometric distribution.\n"
random.streams.gumbel,"\nrandom.streams.gumbel( μ:number, β:number[, options:Object] )\n    Returns a readable stream for generating pseudorandom numbers drawn from a\n    Gumbel distribution.\n"
random.streams.gumbel.factory,"\nrandom.streams.gumbel.factory( [μ:number, β:number, ][options:Object] )\n    Returns a function for creating readable streams which generate pseudorandom\n    numbers drawn from a Gumbel distribution.\n"
random.streams.gumbel.objectMode,"\nrandom.streams.gumbel.objectMode( μ:number, β:number[, options:Object] )\n    Returns an \"objectMode\" readable stream for generating pseudorandom numbers\n    drawn from a Gumbel distribution.\n"
random.streams.hypergeometric,"\nrandom.streams.hypergeometric( N:integer, K:integer, n:integer[, \n  options:Object] )\n    Returns a readable stream for generating pseudorandom numbers drawn from a\n    hypergeometric distribution.\n"
random.streams.hypergeometric.factory,"\nrandom.streams.hypergeometric.factory( [N:integer, K:integer, n:integer,]\n  [options:Object] )\n    Returns a function for creating readable streams which generate pseudorandom\n    numbers drawn from a hypergeometric distribution.\n"
random.streams.hypergeometric.objectMode,"\nrandom.streams.hypergeometric.objectMode( N:integer, K:integer, n:integer[, \n  options:Object] )\n    Returns an \"objectMode\" readable stream for generating pseudorandom numbers\n    drawn from a hypergeometric distribution.\n"
random.streams.improvedZiggurat,"\nrandom.streams.improvedZiggurat( [options:Object] )\n    Returns a readable stream for generating pseudorandom numbers drawn from a\n    standard normal distribution using the Improved Ziggurat algorithm.\n"
random.streams.improvedZiggurat.factory,"\nrandom.streams.improvedZiggurat.factory( [options:Object] )\n    Returns a function for creating readable streams which generate pseudorandom\n    numbers drawn from a standard normal distribution using the Improved\n    Ziggurat algorithm.\n"
random.streams.improvedZiggurat.objectMode,"\nrandom.streams.improvedZiggurat.objectMode( [options:Object] )\n    Returns an \"objectMode\" readable stream for generating pseudorandom numbers\n    drawn from a standard normal distribution using the Improved Ziggurat\n    algorithm.\n"
random.streams.invgamma,"\nrandom.streams.invgamma( α:number, β:number[, options:Object] )\n    Returns a readable stream for generating pseudorandom numbers drawn from an\n    inverse gamma distribution.\n"
random.streams.invgamma.factory,"\nrandom.streams.invgamma.factory( [α:number, β:number, ][options:Object] )\n    Returns a function for creating readable streams which generate pseudorandom\n    numbers drawn from an inverse gamma distribution.\n"
random.streams.invgamma.objectMode,"\nrandom.streams.invgamma.objectMode( α:number, β:number[, options:Object] )\n    Returns an \"objectMode\" readable stream for generating pseudorandom numbers\n    drawn from an inverse gamma distribution.\n"
random.streams.kumaraswamy,"\nrandom.streams.kumaraswamy( a:number, b:number[, options:Object] )\n    Returns a readable stream for generating pseudorandom numbers drawn from a\n    Kumaraswamy's double bounded distribution.\n"
random.streams.kumaraswamy.factory,"\nrandom.streams.kumaraswamy.factory( [a:number, b:number, ][options:Object] )\n    Returns a function for creating readable streams which generate pseudorandom\n    numbers drawn from a Kumaraswamy's double bounded distribution.\n"
random.streams.kumaraswamy.objectMode,"\nrandom.streams.kumaraswamy.objectMode( a:number, b:number[, options:Object] )\n    Returns an \"objectMode\" readable stream for generating pseudorandom numbers\n    drawn from a Kumaraswamy's double bounded distribution.\n"
random.streams.laplace,"\nrandom.streams.laplace( μ:number, b:number[, options:Object] )\n    Returns a readable stream for generating pseudorandom numbers drawn from a\n    Laplace (double exponential) distribution.\n"
random.streams.laplace.factory,"\nrandom.streams.laplace.factory( [μ:number, b:number, ][options:Object] )\n    Returns a function for creating readable streams which generate pseudorandom\n    numbers drawn from a Laplace (double exponential) distribution.\n"
random.streams.laplace.objectMode,"\nrandom.streams.laplace.objectMode( μ:number, b:number[, options:Object] )\n    Returns an \"objectMode\" readable stream for generating pseudorandom numbers\n    drawn from a Laplace (double exponential) distribution.\n"
random.streams.levy,"\nrandom.streams.levy( μ:number, c:number[, options:Object] )\n    Returns a readable stream for generating pseudorandom numbers drawn from a\n    Lévy distribution.\n"
random.streams.levy.factory,"\nrandom.streams.levy.factory( [μ:number, c:number, ][options:Object] )\n    Returns a function for creating readable streams which generate pseudorandom\n    numbers drawn from a Lévy distribution.\n"
random.streams.levy.objectMode,"\nrandom.streams.levy.objectMode( μ:number, c:number[, options:Object] )\n    Returns an \"objectMode\" readable stream for generating pseudorandom numbers\n    drawn from a Lévy distribution.\n"
random.streams.logistic,"\nrandom.streams.logistic( μ:number, s:number[, options:Object] )\n    Returns a readable stream for generating pseudorandom numbers drawn from a\n    logistic distribution.\n"
random.streams.logistic.factory,"\nrandom.streams.logistic.factory( [μ:number, s:number, ][options:Object] )\n    Returns a function for creating readable streams which generate pseudorandom\n    numbers drawn from a logistic distribution.\n"
random.streams.logistic.objectMode,"\nrandom.streams.logistic.objectMode( μ:number, s:number[, options:Object] )\n    Returns an \"objectMode\" readable stream for generating pseudorandom numbers\n    drawn from a logistic distribution.\n"
random.streams.lognormal,"\nrandom.streams.lognormal( μ:number, σ:number[, options:Object] )\n    Returns a readable stream for generating pseudorandom numbers drawn from a\n    lognormal distribution.\n"
random.streams.lognormal.factory,"\nrandom.streams.lognormal.factory( [μ:number, σ:number, ][options:Object] )\n    Returns a function for creating readable streams which generate pseudorandom\n    numbers drawn from a lognormal distribution.\n"
random.streams.lognormal.objectMode,"\nrandom.streams.lognormal.objectMode( μ:number, σ:number[, options:Object] )\n    Returns an \"objectMode\" readable stream for generating pseudorandom numbers\n    drawn from a lognormal distribution.\n"
random.streams.minstd,"\nrandom.streams.minstd( [options:Object] )\n    Returns a readable stream for generating pseudorandom numbers on the\n    interval `[1, 2147483646]`.\n"
random.streams.minstd.factory,"\nrandom.streams.minstd.factory( [options] )\n    Returns a function for creating readable streams which generate pseudorandom\n    numbers on the interval `[1, 2147483646]`.\n"
random.streams.minstd.objectMode,"\nrandom.streams.minstd.objectMode( [options:Object] )\n    Returns an \"objectMode\" readable stream for generating pseudorandom numbers\n    on the interval `[1, 2147483646]`.\n"
random.streams.minstdShuffle,"\nrandom.streams.minstdShuffle( [options:Object] )\n    Returns a readable stream for generating pseudorandom numbers on the\n    interval `[1, 2147483646]`.\n"
random.streams.minstdShuffle.factory,"\nrandom.streams.minstdShuffle.factory( [options] )\n    Returns a function for creating readable streams which generate pseudorandom\n    numbers on the interval `[1, 2147483646]`.\n"
random.streams.minstdShuffle.objectMode,"\nrandom.streams.minstdShuffle.objectMode( [options:Object] )\n    Returns an \"objectMode\" readable stream for generating pseudorandom numbers\n    on the interval `[1, 2147483646]`.\n"
random.streams.mt19937,"\nrandom.streams.mt19937( [options:Object] )\n    Returns a readable stream for generating pseudorandom numbers on the\n    interval `[1, 4294967295]`.\n"
random.streams.mt19937.factory,"\nrandom.streams.mt19937.factory( [options] )\n    Returns a function for creating readable streams which generate pseudorandom\n    numbers on the interval `[1, 4294967295]`.\n"
random.streams.mt19937.objectMode,"\nrandom.streams.mt19937.objectMode( [options:Object] )\n    Returns an \"objectMode\" readable stream for generating pseudorandom numbers\n    on the interval `[1, 4294967295]`.\n"
random.streams.negativeBinomial,"\nrandom.streams.negativeBinomial( r:number, p:number[, options:Object] )\n    Returns a readable stream for generating pseudorandom numbers drawn from a\n    negative binomial distribution.\n"
random.streams.negativeBinomial.factory,"\nrandom.streams.negativeBinomial.factory( [r:number, p:number, ]\n  [options:Object] )\n    Returns a function for creating readable streams which generate pseudorandom\n    numbers drawn from a negative binomial distribution.\n"
random.streams.negativeBinomial.objectMode,"\nrandom.streams.negativeBinomial.objectMode( r:integer, p:number[, \n  options:Object] )\n    Returns an \"objectMode\" readable stream for generating pseudorandom numbers\n    drawn from a negative binomial distribution.\n"
random.streams.normal,"\nrandom.streams.normal( μ:number, σ:number[, options:Object] )\n    Returns a readable stream for generating pseudorandom numbers drawn from a\n    normal distribution.\n"
random.streams.normal.factory,"\nrandom.streams.normal.factory( [μ:number, σ:number, ][options:Object] )\n    Returns a function for creating readable streams which generate pseudorandom\n    numbers drawn from a normal distribution.\n"
random.streams.normal.objectMode,"\nrandom.streams.normal.objectMode( μ:number, σ:number[, options:Object] )\n    Returns an \"objectMode\" readable stream for generating pseudorandom numbers\n    drawn from a normal distribution.\n"
random.streams.pareto1,"\nrandom.streams.pareto1( α:number, β:number[, options:Object] )\n    Returns a readable stream for generating pseudorandom numbers drawn from a\n    Pareto (Type I) distribution.\n"
random.streams.pareto1.factory,"\nrandom.streams.pareto1.factory( [α:number, β:number, ][options:Object] )\n    Returns a function for creating readable streams which generate pseudorandom\n    numbers drawn from a Pareto (Type I) distribution.\n"
random.streams.pareto1.objectMode,"\nrandom.streams.pareto1.objectMode( α:number, β:number[, options:Object] )\n    Returns an \"objectMode\" readable stream for generating pseudorandom numbers\n    drawn from a Pareto (Type I) distribution.\n"
random.streams.poisson,"\nrandom.streams.poisson( λ:number[, options:Object] )\n    Returns a readable stream for generating pseudorandom numbers drawn from a\n    Poisson distribution.\n"
random.streams.poisson.factory,"\nrandom.streams.poisson.factory( [λ:number, ][options:Object] )\n    Returns a function for creating readable streams which generate pseudorandom\n    numbers drawn from a Poisson distribution.\n"
random.streams.poisson.objectMode,"\nrandom.streams.poisson.objectMode( λ:number[, options:Object] )\n    Returns an \"objectMode\" readable stream for generating pseudorandom numbers\n    drawn from a Poisson distribution.\n"
random.streams.randi,"\nrandom.streams.randi( [options:Object] )\n    Returns a readable stream for generating pseudorandom numbers having integer\n    values.\n"
random.streams.randi.factory,"\nrandom.streams.randi.factory( [options] )\n    Returns a function for creating readable streams which generate pseudorandom\n    numbers having integer values.\n"
random.streams.randi.objectMode,"\nrandom.streams.randi.objectMode( [options:Object] )\n    Returns an \"objectMode\" readable stream for generating pseudorandom numbers\n    having integer values.\n"
random.streams.randn,"\nrandom.streams.randn( [options:Object] )\n    Returns a readable stream for generating pseudorandom numbers drawn from a\n    standard normal distribution.\n"
random.streams.randn.factory,"\nrandom.streams.randn.factory( [options] )\n    Returns a function for creating readable streams which generate pseudorandom\n    numbers drawn from a standard normal distribution.\n"
random.streams.randn.objectMode,"\nrandom.streams.randn.objectMode( [options:Object] )\n    Returns an \"objectMode\" readable stream for generating pseudorandom numbers\n    drawn from a standard normal distribution.\n"
random.streams.randu,"\nrandom.streams.randu( [options:Object] )\n    Returns a readable stream for generating uniformly distributed pseudorandom\n    numbers between 0 and 1.\n"
random.streams.randu.factory,"\nrandom.streams.randu.factory( [options] )\n    Returns a function for creating readable streams which generate uniformly\n    distributed pseudorandom numbers between 0 and 1.\n"
random.streams.randu.objectMode,"\nrandom.streams.randu.objectMode( [options:Object] )\n    Returns an \"objectMode\" readable stream for generating uniformly distributed\n    pseudorandom numbers between 0 and 1.\n"
random.streams.rayleigh,"\nrandom.streams.rayleigh( σ:number[, options:Object] )\n    Returns a readable stream for generating pseudorandom numbers drawn from a\n    Rayleigh distribution.\n"
random.streams.rayleigh.factory,"\nrandom.streams.rayleigh.factory( [σ:number, ][options:Object] )\n    Returns a function for creating readable streams which generate pseudorandom\n    numbers drawn from a Rayleigh distribution.\n"
random.streams.rayleigh.objectMode,"\nrandom.streams.rayleigh.objectMode( σ:number[, options:Object] )\n    Returns an \"objectMode\" readable stream for generating pseudorandom numbers\n    drawn from a Rayleigh distribution.\n"
random.streams.t,"\nrandom.streams.t( v:number[, options:Object] )\n    Returns a readable stream for generating pseudorandom numbers drawn from a\n    Student's t distribution.\n"
random.streams.t.factory,"\nrandom.streams.t.factory( [v:number, ][options:Object] )\n    Returns a function for creating readable streams which generate pseudorandom\n    numbers drawn from a Student's t distribution.\n"
random.streams.t.objectMode,"\nrandom.streams.t.objectMode( v:number[, options:Object] )\n    Returns an \"objectMode\" readable stream for generating pseudorandom numbers\n    drawn from a Student's t distribution.\n"
random.streams.triangular,"\nrandom.streams.triangular( a:number, b:number, c:number[, options:Object] )\n    Returns a readable stream for generating pseudorandom numbers drawn from a\n    triangular distribution.\n"
random.streams.triangular.factory,"\nrandom.streams.triangular.factory( [a:number, b:number, c:number, ]\n  [options:Object] )\n    Returns a function for creating readable streams which generate pseudorandom\n    numbers drawn from a triangular distribution.\n"
random.streams.triangular.objectMode,"\nrandom.streams.triangular.objectMode( a:number, b:number, c:number[, \n  options:Object] )\n    Returns an \"objectMode\" readable stream for generating pseudorandom numbers\n    drawn from a triangular distribution.\n"
random.streams.uniform,"\nrandom.streams.uniform( a:number, b:number[, options:Object] )\n    Returns a readable stream for generating pseudorandom numbers drawn from a\n    uniform distribution.\n"
random.streams.uniform.factory,"\nrandom.streams.uniform.factory( [a:number, b:number, ][options:Object] )\n    Returns a function for creating readable streams which generate pseudorandom\n    numbers drawn from a uniform distribution.\n"
random.streams.uniform.objectMode,"\nrandom.streams.uniform.objectMode( a:number, b:number[, options:Object] )\n    Returns an \"objectMode\" readable stream for generating pseudorandom numbers\n    drawn from a uniform distribution.\n"
random.streams.weibull,"\nrandom.streams.weibull( k:number, λ:number[, options:Object] )\n    Returns a readable stream for generating pseudorandom numbers drawn from a\n    Weibull distribution.\n"
random.streams.weibull.factory,"\nrandom.streams.weibull.factory( [k:number, λ:number, ][options:Object] )\n    Returns a function for creating readable streams which generate pseudorandom\n    numbers drawn from a Weibull distribution.\n"
random.streams.weibull.objectMode,"\nrandom.streams.weibull.objectMode( k:number, λ:number[, options:Object] )\n    Returns an \"objectMode\" readable stream for generating pseudorandom numbers\n    drawn from a Weibull distribution.\n"
ranks,"\nranks( arr:Array<number>[, options:Object] )\n    Computes the sample ranks for the values of an array-like object.\n"
readDir,"\nreadDir( path:string|Buffer, clbk:Function )\n    Asynchronously reads the contents of a directory.\n"
readDir.sync,"\nreadDir.sync( path:string|Buffer )\n    Synchronously reads the contents of a directory.\n"
readFile,"\nreadFile( file:string|Buffer|integer[, options:Object|string], clbk:Function )\n    Asynchronously reads the entire contents of a file.\n"
readFile.sync,"\nreadFile.sync( file:string|Buffer|integer[, options:Object|string] )\n    Synchronously reads the entire contents of a file.\n"
readFileList,"\nreadFileList( filepaths:Array<string>[, options:Object|string], clbk:Function )\n    Asynchronously reads the entire contents of each file in a file list.\n"
readFileList.sync,"\nreadFileList.sync( filepaths:Array<string>[, options:Object|string] )\n    Synchronously reads the entire contents of each file in a file list.\n"
readJSON,"\nreadJSON( file:string|Buffer|integer[, options:Object|string], clbk:Function )\n    Asynchronously reads a file as JSON.\n"
readJSON.sync,"\nreadJSON.sync( file:string|Buffer|integer[, options:Object|string] )\n    Synchronously reads a file as JSON.\n"
readWASM,"\nreadWASM( file:string|Buffer|integer[, options:Object], clbk:Function )\n    Asynchronously reads a file as WebAssembly.\n"
readWASM.sync,"\nreadWASM.sync( file:string|Buffer|integer[, options:Object] )\n    Synchronously reads a file as WebAssembly.\n"
real,"\nreal( z:Complex )\n    Returns the real component of a complex number.\n"
realmax,"\nrealmax( dtype:string )\n    Returns the maximum finite value capable of being represented by a numeric\n    real type.\n"
realmin,"\nrealmin( dtype:string )\n    Returns the smallest positive normal value capable of being represented by a\n    numeric real type.\n"
reBasename,"\nreBasename( [platform:string] )\n    Returns a regular expression to capture the last part of a path.\n"
reBasename.REGEXP,"\nreBasename.REGEXP\n    Regular expression to capture the last part of a POSIX path.\n"
reBasename.REGEXP_POSIX,"\nreBasename.REGEXP_POSIX\n    Regular expression to capture the last part of a POSIX path.\n"
reBasename.REGEXP_WIN32,"\nreBasename.REGEXP_WIN32\n    Regular expression to capture the last part of a Windows path.\n"
reBasenamePosix,"\nreBasenamePosix()\n    Returns a regular expression to capture the last part of a POSIX path.\n"
reBasenamePosix.REGEXP,"\nreBasenamePosix.REGEXP\n    Regular expression to capture the last part of a POSIX path.\n"
reBasenameWindows,"\nreBasenameWindows()\n    Returns a regular expression to capture the last part of a Windows path.\n"
reBasenameWindows.REGEXP,"\nreBasenameWindows.REGEXP\n    Regular expression to capture the last part of a Windows path.\n"
reColorHexadecimal,"\nreColorHexadecimal( [mode:string] )\n    Returns a regular expression to match a hexadecimal color.\n"
reColorHexadecimal.REGEXP,"\nreColorHexadecimal.REGEXP\n    Regular expression to match a full hexadecimal color.\n"
reColorHexadecimal.REGEXP_SHORTHAND,"\nreColorHexadecimal.REGEXP_SHORTHAND\n    Regular expression to match a shorthand hexadecimal color.\n"
reColorHexadecimal.REGEXP_EITHER,"\nreColorHexadecimal.REGEXP_EITHER\n    Regular expression to match either a shorthand or full length hexadecimal\n    color.\n"
reDecimalNumber,"\nreDecimalNumber( [options:Object] )\n    Returns a regular expression to match a decimal number.\n"
reDecimalNumber.REGEXP,"\nreDecimalNumber.REGEXP\n    Regular expression to match a decimal number.\n"
reDecimalNumber.REGEXP_CAPTURE,"\nreDecimalNumber.REGEXP_CAPTURE\n    Regular expression to capture a decimal number.\n"
reDirname,"\nreDirname( [platform:string] )\n    Returns a regular expression to capture a path dirname.\n"
reDirname.REGEXP,"\nreDirname.REGEXP\n    Regular expression to capture a path dirname.\n"
reDirname.REGEXP_POSIX,"\nreDirname.REGEXP_POSIX\n    Regular expression to capture a POSIX path dirname.\n"
reDirname.REGEXP_WIN32,"\nreDirname.REGEXP_WIN32\n    Regular expression to capture a Windows path dirname.\n"
reDirnamePosix,"\nreDirnamePosix()\n    Returns a regular expression to capture a POSIX path dirname.\n"
reDirnamePosix.REGEXP,"\nreDirnamePosix.REGEXP\n    Regular expression to capture a POSIX path dirname.\n"
reDirnameWindows,"\nreDirnameWindows()\n    Returns a regular expression to capture a Windows path dirname.\n"
reDirnameWindows.REGEXP,"\nreDirnameWindows.REGEXP\n    Regular expression to capture a Windows path dirname.\n"
reduce,"\nreduce( collection:Array|TypedArray|Object, initial:any, reducer:Function[, \n  thisArg:any] )\n    Applies a function against an accumulator and each element in a collection\n    and returns the accumulated result.\n"
reduceAsync,"\nreduceAsync( collection:Array|TypedArray|Object, initial:any, [options:Object,] \n  reducer:Function, done:Function )\n    Applies a function against an accumulator and each element in a collection\n    and returns the accumulated result.\n"
reduceAsync.factory,"\nreduceAsync.factory( [options:Object,] fcn:Function )\n    Returns a function which applies a function against an accumulator and each\n    element in a collection and returns the accumulated result.\n"
reduceRight,"\nreduceRight( collection:Array|TypedArray|Object, initial:any, \n  reducer:Function[, thisArg:any] )\n    Applies a function against an accumulator and each element in a collection\n    and returns the accumulated result, iterating from right to left.\n"
reduceRightAsync,"\nreduceRightAsync( collection:Array|TypedArray|Object, initial:any, \n  [options:Object,] reducer:Function, done:Function )\n    Applies a function against an accumulator and each element in a collection\n    and returns the accumulated result, iterating from right to left.\n"
reduceRightAsync.factory,"\nreduceRightAsync.factory( [options:Object,] fcn:Function )\n    Returns a function which applies a function against an accumulator and each\n    element in a collection and returns the accumulated result, iterating from\n    right to left.\n"
reEOL,"\nreEOL( [options:Object] )\n    Regular expression to match a newline character sequence: /\r?\n/.\n"
reEOL.REGEXP,"\nreEOL.REGEXP\n    Regular expression to match a newline character sequence: /\r?\n/.\n"
reEOL.REGEXP_CAPTURE,"\nreEOL.REGEXP_CAPTURE\n    Regular expression to capture a newline character sequence: /\r?\n/.\n"
reExtendedLengthPath,"\nreExtendedLengthPath()\n    Returns a regular expression to test if a string is an extended-length path.\n"
reExtendedLengthPath.REGEXP,"\nreExtendedLengthPath.REGEXP\n    Regular expression to test if a string is an extended-length path.\n"
reExtname,"\nreExtname( [platform:string] )\n    Returns a regular expression to capture a filename extension.\n"
reExtname.REGEXP,"\nreExtname.REGEXP\n    Regular expression to capture a filename extension.\n"
reExtname.REGEXP_POSIX,"\nreExtname.REGEXP_POSIX\n    Regular expression to capture a POSIX filename extension.\n"
reExtname.REGEXP_WIN32,"\nreExtname.REGEXP_WIN32\n    Regular expression to capture a Windows filename extension.\n"
reExtnamePosix,"\nreExtnamePosix\n    Returns a regular expression to capture a POSIX filename extension.\n"
reExtnamePosix.REGEXP,"\nreExtnamePosix.REGEXP\n    Regular expression to capture a POSIX filename extension.\n"
reExtnameWindows,"\nreExtnameWindows\n    Returns a regular expression to capture a Windows filename extension.\n"
reExtnameWindows.REGEXP,"\nreExtnameWindows.REGEXP\n    Regular expression to capture a Windows filename extension.\n"
reFilename,"\nreFilename( [platform:string] )\n    Regular expression to split a filename.\n"
reFilename.REGEXP,"\nreFilename.REGEXP\n    Regular expression to split a filename.\n"
reFilename.REGEXP_POSIX,"\nreFilename.REGEXP_POSIX\n    Regular expression to split a POSIX filename.\n"
reFilename.REGEXP_WIN32,"\nreFilename.REGEXP_WIN32\n    Regular expression to split a Windows filename.\n"
reFilenamePosix,"\nreFilenamePosix()\n    Returns a regular expression to split a POSIX filename.\n"
reFilenamePosix.REGEXP,"\nreFilenamePosix.REGEXP\n    Regular expression to split a POSIX filename.\n"
reFilenameWindows,"\nreFilenameWindows()\n    Returns a regular expression to split a Windows filename.\n"
reFilenameWindows.REGEXP,"\nreFilenameWindows.REGEXP\n    Regular expression to split a Windows filename.\n"
reFromString,"\nreFromString( str:string )\n    Parses a regular expression string and returns a new regular expression.\n"
reFunctionName,"\nreFunctionName()\n    Return a regular expression to capture a function name.\n"
reFunctionName.REGEXP,"\nreFunctionName.REGEXP\n    Regular expression to capture a function name.\n"
reim,"\nreim( z:Complex )\n    Returns the real and imaginary components of a complex number.\n"
removeFirst,"\nremoveFirst( str:string )\n    Removes the first character of a `string`.\n"
removeLast,"\nremoveLast( str:string )\n    Removes the last character of a `string`.\n"
removePunctuation,"\nremovePunctuation( str:string )\n    Removes punctuation characters from a `string`.\n"
removeUTF8BOM,"\nremoveUTF8BOM( str:string )\n    Removes a UTF-8 byte order mark (BOM) from the beginning of a `string`.\n"
removeWords,"\nremoveWords( str:string, words:Array<string>[, ignoreCase:boolean] )\n    Removes all occurrences of the given words from a `string`.\n"
rename,"\nrename( oldPath:string|Buffer, newPath:string|Buffer, clbk:Function )\n    Asynchronously renames a file.\n"
rename.sync,"\nrename.sync( oldPath:string|Buffer, newPath:string|Buffer )\n    Synchronously renames a file.\n"
reNativeFunction,"\nreNativeFunction()\n    Returns a regular expression to match a native function.\n"
reNativeFunction.REGEXP,"\nreNativeFunction.REGEXP\n    Regular expression to match a native function.\n"
reorderArguments,"\nreorderArguments( fcn:Function, indices:Array<integer>[, thisArg:any] )\n    Returns a function that invokes a provided function with reordered\n    arguments.\n"
repeat,"\nrepeat( str:string, n:integer )\n    Repeats a string `n` times and returns the concatenated result.\n"
replace,"\nreplace( str:string, search:string|RegExp, newval:string|Function )\n    Replaces `search` occurrences with a replacement `string`.\n"
reRegExp,"\nreRegExp()\n    Returns a regular expression to parse a regular expression string.\n"
reRegExp.REGEXP,"\nreRegExp.REGEXP\n    Regular expression to parse a regular expression string.\n"
rescape,"\nrescape( str:string )\n    Escapes a regular expression string.\n"
resolveParentPath,"\nresolveParentPath( path:string[, options:Object], clbk:Function )\n    Asynchronously resolves a path by walking parent directories.\n"
resolveParentPath.sync,"\nresolveParentPath.sync( path:string[, options:Object] )\n    Synchronously resolves a path by walking parent directories.\n"
resolveParentPathBy,"\nresolveParentPathBy( path:string[, options:Object], predicate:Function, \n  clbk:Function )\n    Asynchronously resolves a path according to a predicate function by walking\n    parent directories.\n"
resolveParentPathBy.sync,"\nresolveParentPathBy.sync( path:string[, options:Object], predicate:Function )\n    Synchronously resolves a path according to a predicate function by walking\n    parent directories.\n"
reUncPath,"\nreUncPath()\n    Return a regular expression to parse a UNC path.\n"
reUncPath.REGEXP,"\nreUncPath.REGEXP\n    Regular expression to parse a UNC path.\n"
reUtf16SurrogatePair,"\nreUtf16SurrogatePair()\n    Returns a regular expression to match a UTF-16 surrogate pair.\n"
reUtf16SurrogatePair.REGEXP,"\nreUtf16SurrogatePair.REGEXP\n    Regular expression to match a UTF-16 surrogate pair.\n"
reUtf16UnpairedSurrogate,"\nreUtf16UnpairedSurrogate()\n    Returns a regular expression to match an unpaired UTF-16 surrogate.\n"
reUtf16UnpairedSurrogate.REGEXP,"\nreUtf16UnpairedSurrogate.REGEXP\n    Regular expression to match an unpaired UTF-16 surrogate.\n"
reverseArguments,"\nreverseArguments( fcn:Function[, thisArg:any] )\n    Returns a function that invokes a provided function with arguments in\n    reverse order.\n"
reverseString,"\nreverseString( str:string )\n    Reverses a `string`.\n"
reviveBasePRNG,"\nreviveBasePRNG( key:string, value:any )\n    Revives a JSON-serialized pseudorandom number generator (PRNG).\n"
reviveBuffer,"\nreviveBuffer( key:string, value:any )\n    Revives a JSON-serialized Buffer.\n"
reviveComplex,"\nreviveComplex( key:string, value:any )\n    Revives a JSON-serialized complex number.\n"
reviveComplex64,"\nreviveComplex64( key:string, value:any )\n    Revives a JSON-serialized 64-bit complex number.\n"
reviveComplex128,"\nreviveComplex128( key:string, value:any )\n    Revives a JSON-serialized 128-bit complex number.\n"
reviveError,"\nreviveError( key:string, value:any )\n    Revives a JSON-serialized error object.\n"
reviveTypedArray,"\nreviveTypedArray( key:string, value:any )\n    Revives a JSON-serialized typed array.\n"
reWhitespace,"\nreWhitespace( [options:Object] )\n    Returns a regular expression to match a white space character.\n"
reWhitespace.REGEXP,"\nreWhitespace.REGEXP\n    Regular expression to match a white space character.\n"
reWhitespace.REGEXP_CAPTURE,"\nreWhitespace.REGEXP_CAPTURE\n    Regular expression to capture white space characters.\n"
rpad,"\nrpad( str:string, len:integer[, pad:string] )\n    Right pads a `string` such that the padded `string` has a length of at least\n    `len`.\n"
rtrim,"\nrtrim( str:string )\n    Trims whitespace from the end of a `string`.\n"
safeintmax,"\nsafeintmax( dtype:string )\n    Returns the maximum safe integer capable of being represented by a numeric\n    real type.\n"
safeintmin,"\nsafeintmin( dtype:string )\n    Returns the minimum safe integer capable of being represented by a numeric\n    real type.\n"
sample,"\nsample( x:ArrayLike[, options:Object] )\n    Samples elements from an array-like object.\n"
sample.factory,"\nsample.factory( [pool:ArrayLike, ][options:Object] )\n    Returns a function to sample elements from an array-like object.\n"
SAVOY_STOPWORDS_FIN,"\nSAVOY_STOPWORDS_FIN()\n    Returns a list of Finnish stop words.\n"
SAVOY_STOPWORDS_FR,"\nSAVOY_STOPWORDS_FR()\n    Returns a list of French stop words.\n"
SAVOY_STOPWORDS_GER,"\nSAVOY_STOPWORDS_GER()\n    Returns a list of German stop words.\n"
SAVOY_STOPWORDS_IT,"\nSAVOY_STOPWORDS_IT()\n    Returns a list of Italian stop words.\n"
SAVOY_STOPWORDS_POR,"\nSAVOY_STOPWORDS_POR()\n    Returns a list of Portuguese stop words.\n"
SAVOY_STOPWORDS_SP,"\nSAVOY_STOPWORDS_SP()\n    Returns a list of Spanish stop words.\n"
SAVOY_STOPWORDS_SWE,"\nSAVOY_STOPWORDS_SWE()\n    Returns a list of Swedish stop words.\n"
sdot,"\nsdot( x:ndarray, y:ndarray )\n    Computes the dot product of two single-precision floating-point vectors.\n"
SECONDS_IN_DAY,"\nSECONDS_IN_DAY\n    Number of seconds in a day.\n"
SECONDS_IN_HOUR,"\nSECONDS_IN_HOUR\n    Number of seconds in an hour.\n"
SECONDS_IN_MINUTE,"\nSECONDS_IN_MINUTE\n    Number of seconds in a minute.\n"
SECONDS_IN_WEEK,"\nSECONDS_IN_WEEK\n    Number of seconds in a week.\n"
secondsInMonth,"\nsecondsInMonth( [month:string|Date|integer[, year:integer]] )\n    Returns the number of seconds in a month.\n"
secondsInYear,"\nsecondsInYear( [value:integer|Date] )\n    Returns the number of seconds in a year according to the Gregorian calendar.\n"
setConfigurableReadOnly,"\nsetConfigurableReadOnly( obj:Object, prop:string|symbol, value:any )\n    Defines a configurable read-only property.\n"
setConfigurableReadOnlyAccessor,"\nsetConfigurableReadOnlyAccessor( obj:Object, prop:string|symbol, \n  getter:Function )\n    Defines a configurable read-only accessor.\n"
setConfigurableReadWriteAccessor,"\nsetConfigurableReadWriteAccessor( obj:Object, prop:string|symbol, \n  getter:Function, setter:Function )\n    Defines a configurable property having read-write accessors.\n"
setConfigurableWriteOnlyAccessor,"\nsetConfigurableWriteOnlyAccessor( obj:Object, prop:string|symbol, \n  setter:Function )\n    Defines a configurable write-only accessor.\n"
setMemoizedConfigurableReadOnly,"\nsetMemoizedConfigurableReadOnly( obj:Object, prop:string|symbol, fcn:Function )\n    Defines a configurable memoized read-only object property.\n"
setMemoizedReadOnly,"\nsetMemoizedReadOnly( obj:Object, prop:string|symbol, fcn:Function )\n    Defines a memoized read-only object property.\n"
setNonEnumerableProperty,"\nsetNonEnumerableProperty( obj:Object, prop:string|symbol, value:any )\n    Defines a non-enumerable property.\n"
setNonEnumerableReadOnly,"\nsetNonEnumerableReadOnly( obj:Object, prop:string|symbol, value:any )\n    Defines a non-enumerable read-only property.\n"
setNonEnumerableReadOnlyAccessor,"\nsetNonEnumerableReadOnlyAccessor( obj:Object, prop:string|symbol, \n  getter:Function )\n    Defines a non-enumerable read-only accessor.\n"
setNonEnumerableReadWriteAccessor,"\nsetNonEnumerableReadWriteAccessor( obj:Object, prop:string|symbol, \n  getter:Function, setter:Function )\n    Defines a non-enumerable property having read-write accessors.\n"
setNonEnumerableWriteOnlyAccessor,"\nsetNonEnumerableWriteOnlyAccessor( obj:Object, prop:string|symbol, \n  setter:Function )\n    Defines a non-enumerable write-only accessor.\n"
setReadOnly,"\nsetReadOnly( obj:Object, prop:string|symbol, value:any )\n    Defines a read-only property.\n"
setReadOnlyAccessor,"\nsetReadOnlyAccessor( obj:Object, prop:string|symbol, getter:Function )\n    Defines a read-only accessor.\n"
setReadWriteAccessor,"\nsetReadWriteAccessor( obj:Object, prop:string|symbol, getter:Function, \n  setter:Function )\n    Defines a property having read-write accessors.\n"
setWriteOnlyAccessor,"\nsetWriteOnlyAccessor( obj:Object, prop:string|symbol, setter:Function )\n    Defines a write-only accessor.\n"
SharedArrayBuffer,"\nSharedArrayBuffer( size:integer )\n    Returns a shared array buffer having a specified number of bytes.\n"
SharedArrayBuffer.length,"\nSharedArrayBuffer.length\n    Number of input arguments the constructor accepts.\n"
SharedArrayBuffer.prototype.byteLength,"\nSharedArrayBuffer.prototype.byteLength\n    Read-only property which returns the length (in bytes) of the array buffer.\n"
SharedArrayBuffer.prototype.slice,"\nSharedArrayBuffer.prototype.slice( [start:integer[, end:integer]] )\n    Copies the bytes of a shared array buffer to a new shared array buffer.\n"
shift,"\nshift( collection:Array|TypedArray|Object )\n    Removes and returns the first element of a collection.\n"
shuffle,"\nshuffle( arr:ArrayLike[, options:Object] )\n    Shuffles elements of an array-like object.\n"
shuffle.factory,"\nshuffle.factory( [options:Object] )\n    Returns a function to shuffle elements of array-like objects.\n"
sizeOf,"\nsizeOf( dtype:string )\n    Returns the size (in bytes) of the canonical binary representation of a\n    specified numeric type.\n"
some,"\nsome( collection:Array|TypedArray|Object, n:number )\n    Tests whether at least `n` elements in a collection are truthy.\n"
someBy,"\nsomeBy( collection:Array|TypedArray|Object, n:number, predicate:Function[, \n  thisArg:any ] )\n    Tests whether a collection contains at least `n` elements which pass a test\n    implemented by a predicate function.\n"
someByAsync,"\nsomeByAsync( collection:Array|TypedArray|Object, n:number, [options:Object,] \n  predicate:Function, done:Function )\n    Tests whether a collection contains at least `n` elements which pass a test\n    implemented by a predicate function.\n"
someByAsync.factory,"\nsomeByAsync.factory( [options:Object,] predicate:Function )\n    Returns a function which tests whether a collection contains at least `n`\n    elements which pass a test implemented by a predicate function.\n"
someByRight,"\nsomeByRight( collection:Array|TypedArray|Object, n:number, predicate:Function[, \n  thisArg:any ] )\n    Tests whether a collection contains at least `n` elements which pass a test\n    implemented by a predicate function, iterating from right to left.\n"
someByRightAsync,"\nsomeByRightAsync( collection:Array|TypedArray|Object, n:number, \n  [options:Object,] predicate:Function, done:Function )\n    Tests whether a collection contains at least `n` elements which pass a test\n    implemented by a predicate function, iterating from right to left.\n"
someByRightAsync.factory,"\nsomeByRightAsync.factory( [options:Object,] predicate:Function )\n    Returns a function which tests whether a collection contains at least `n`\n    elements which pass a test implemented by a predicate function, iterating\n    from right to left.\n"
SOTU,"\nSOTU( [options:Object] )\n    Returns State of the Union (SOTU) addresses.\n"
SPACHE_REVISED,"\nSPACHE_REVISED()\n    Returns a list of simple American-English words (revised Spache).\n"
SPAM_ASSASSIN,"\nSPAM_ASSASSIN()\n    Returns the Spam Assassin public mail corpus.\n"
SparklineBase,"\nSparklineBase( [data:ArrayLike|ndarray,] [options:Object] )\n    Returns a Sparkline instance.\n"
sparsearray2iterator,"\nsparsearray2iterator( src:ArrayLikeObject[, mapFcn:Function[, thisArg:any]] )\n    Returns an iterator which iterates over the elements of a sparse array-like\n    object.\n"
sparsearray2iteratorRight,"\nsparsearray2iteratorRight( src:ArrayLikeObject[, mapFcn:Function[, \n  thisArg:any]] )\n    Returns an iterator which iterates from right to left over the elements of a\n    sparse array-like object.\n"
splitStream,"\nsplitStream( [options:Object] )\n    Returns a transform stream which splits streamed data.\n"
splitStream.factory,"\nsplitStream.factory( [options:Object] )\n    Returns a function for creating transform streams for splitting streamed\n    data.\n"
splitStream.objectMode,"\nsplitStream.objectMode( [options:Object] )\n    Returns an \"objectMode\" transform stream for splitting streamed data.\n"
SQRT_EPS,"\nSQRT_EPS\n    Square root of double-precision floating-point epsilon.\n"
SQRT_HALF,"\nSQRT_HALF\n    Square root of `1/2`.\n"
SQRT_HALF_PI,"\nSQRT_HALF_PI\n    Square root of the mathematical constant `π` divided by `2`.\n"
SQRT_PHI,"\nSQRT_PHI\n    Square root of the golden ratio.\n"
SQRT_PI,"\nSQRT_PI\n    Square root of the mathematical constant `π`.\n"
SQRT_THREE,"\nSQRT_THREE\n    Square root of `3`.\n"
SQRT_TWO,"\nSQRT_TWO\n    Square root of `2`.\n"
SQRT_TWO_PI,"\nSQRT_TWO_PI\n    Square root of the mathematical constant `π` times `2`.\n"
SSA_US_BIRTHS_2000_2014,"\nSSA_US_BIRTHS_2000_2014()\n    Returns US birth data from 2000 to 2014, as provided by the Social Security\n    Administration.\n"
sswap,"\nsswap( x:ndarray, y:ndarray )\n    Interchanges two single-precision floating-point vectors.\n"
Stack,"\nStack()\n    Stack constructor.\n"
standalone2pkg,"\nstandalone2pkg( pkg:string )\n    Returns the internal package name associated with a provided standalone\n    package name.\n"
STANDARD_CARD_DECK,"\nSTANDARD_CARD_DECK()\n    Returns a string array containing two or three letter abbreviations for each\n    card in a standard 52-card deck.\n"
startcase,"\nstartcase( str:string )\n    Capitalizes the first letter of each word in an input `string`.\n"
startsWith,"\nstartsWith( str:string, search:string[, position:integer] )\n    Tests if a `string` starts with the characters of another `string`.\n"
STOPWORDS_EN,"\nSTOPWORDS_EN()\n    Returns a list of English stop words.\n"
strided.abs,"\nstrided.abs( N:integer, x:ArrayLikeObject, strideX:integer, y:ArrayLikeObject, \n  strideY:integer )\n    Computes the absolute value for each element in `x` and assigns the results\n    to elements in `y`.\n"
strided.abs.ndarray,"\nstrided.abs.ndarray( N:integer, x:ArrayLikeObject, strideX:integer, \n  offsetX:integer, y:ArrayLikeObject, strideY:integer, offsetY:integer )\n    Computes the absolute value for each element in `x` and assigns the results\n    to elements in `y` using alternative indexing semantics.\n"
strided.abs2,"\nstrided.abs2( N:integer, x:ArrayLikeObject, strideX:integer, y:ArrayLikeObject, \n  strideY:integer )\n    Computes the squared absolute value for each element in `x` and assigns the\n    results to elements in `y`.\n"
strided.abs2.ndarray,"\nstrided.abs2.ndarray( N:integer, x:ArrayLikeObject, strideX:integer, \n  offsetX:integer, y:ArrayLikeObject, strideY:integer, offsetY:integer )\n    Computes the squared absolute value for each element in `x` and assigns the\n    results to elements in `y` using alternative indexing semantics.\n"
strided.abs2By,"\nstrided.abs2By( N:integer, x:Array|TypedArray|Object, sx:integer, \n  y:Array|TypedArray|Object, sy:integer, clbk:Function[, thisArg:any] )\n    Computes the squared absolute value of each element retrieved from an input\n    strided array `x` via a callback function and assigns each result to an\n    element in an output strided array `y`.\n"
strided.abs2By.ndarray,"\nstrided.abs2By.ndarray( N:integer, x:Array|TypedArray|Object, sx:integer, \n  ox:integer, y:Array|TypedArray|Object, sy:integer, oy:integer, \n  clbk:Function[, thisArg:any] )\n    Computes the squared absolute value of each element retrieved from an input\n    strided array `x` via a callback function and assigns each result to an\n    element in an output strided array `y` using alternative indexing semantics.\n"
strided.absBy,"\nstrided.absBy( N:integer, x:Array|TypedArray|Object, sx:integer, \n  y:Array|TypedArray|Object, sy:integer, clbk:Function[, thisArg:any] )\n    Computes the absolute value of each element retrieved from a strided input\n    array `x` via a callback function and assigns each result to an element in a\n    strided output array `y`.\n"
strided.absBy.ndarray,"\nstrided.absBy.ndarray( N:integer, x:Array|TypedArray|Object, sx:integer, \n  ox:integer, y:Array|TypedArray|Object, sy:integer, oy:integer, \n  clbk:Function[, thisArg:any] )\n    Computes the absolute value of each element retrieved from a strided input\n    array `x` via a callback function and assigns each result to an element in a\n    strided output array `y` using alternative indexing semantics.\n"
strided.cbrt,"\nstrided.cbrt( N:integer, x:ArrayLikeObject, strideX:integer, y:ArrayLikeObject, \n  strideY:integer )\n    Computes the cube root of each element in a strided array `x` and assigns \n    the results to elements in a strided array `y`.\n"
strided.cbrt.ndarray,"\nstrided.cbrt.ndarray( N:integer, x:ArrayLikeObject, strideX:integer, \n  offsetX:integer, y:ArrayLikeObject, strideY:integer, offsetY:integer )\n    Computes the cube root of each element in a strided array `x` and assigns \n    the results to elements in a strided array `y` using alternative indexing \n    semantics.\n"
strided.ceil,"\nstrided.ceil( N:integer, x:ArrayLikeObject, strideX:integer, y:ArrayLikeObject, \n  strideY:integer )\n    Rounds each element in a strided array `x` toward positive infinity and \n    assigns the results to elements in a strided array `y`.\n"
strided.ceil.ndarray,"\nstrided.ceil.ndarray( N:integer, x:ArrayLikeObject, strideX:integer, \n  offsetX:integer, y:ArrayLikeObject, strideY:integer, offsetY:integer )\n    Rounds each element in a strided array `x` toward positive infinity and \n    assigns the results to elements in a strided array `y` using alternative \n    indexing semantics.\n"
strided.dabs,"\nstrided.dabs( N:integer, x:Float64Array, strideX:integer, y:Float64Array, \n  strideY:integer )\n    Computes the absolute value for each element in a double-precision floating-\n    point strided array `x` and assigns the results to elements in a double-\n    precision floating-point strided array `y`.\n"
strided.dabs.ndarray,"\nstrided.dabs.ndarray( N:integer, x:Float64Array, strideX:integer, \n  offsetX:integer, y:Float64Array, strideY:integer, offsetY:integer )\n    Computes the absolute value for each element in a double-precision floating-\n    point strided array `x` and assigns the results to elements in a double-\n    precision floating-point strided array `y` using alternative indexing\n    semantics.\n"
strided.dabs2,"\nstrided.dabs2( N:integer, x:Float64Array, strideX:integer, y:Float64Array, \n  strideY:integer )\n    Computes the squared absolute value for each element in a double-precision\n    floating-point strided array `x` and assigns the results to elements in a\n    double-precision floating-point strided array `y`.\n"
strided.dabs2.ndarray,"\nstrided.dabs2.ndarray( N:integer, x:Float64Array, strideX:integer, \n  offsetX:integer, y:Float64Array, strideY:integer, offsetY:integer )\n    Computes the squared absolute value for each element in a double-precision\n    floating-point strided array `x` and assigns the results to elements in a\n    double-precision floating-point strided array `y` using alternative indexing\n    semantics.\n"
strided.dcbrt,"\nstrided.dcbrt( N:integer, x:Float64Array, strideX:integer, y:Float64Array, \n  strideY:integer )\n    Computes the cube root of each element in a double-precision floating-point\n    strided array `x` and assigns the results to elements in a double-precision\n    floating-point strided array `y`.\n"
strided.dcbrt.ndarray,"\nstrided.dcbrt.ndarray( N:integer, x:Float64Array, strideX:integer, \n  offsetX:integer, y:Float64Array, strideY:integer, offsetY:integer )\n    Computes the cube root of each element in a double-precision floating-point\n    strided array `x` and assigns the results to elements in a double-precision\n    floating-point strided array `y` using alternative indexing semantics.\n"
strided.dceil,"\nstrided.dceil( N:integer, x:Float64Array, strideX:integer, y:Float64Array, \n  strideY:integer )\n    Rounds each element in a double-precision floating-point strided array `x`\n    toward positive infinity and assigns the results to elements in a double-\n    precision floating-point strided array `y`.\n"
strided.dceil.ndarray,"\nstrided.dceil.ndarray( N:integer, x:Float64Array, strideX:integer, \n  offsetX:integer, y:Float64Array, strideY:integer, offsetY:integer )\n    Rounds each element in a double-precision floating-point strided array `x`\n    toward positive infinity and assigns the results to elements in a double-\n    precision floating-point strided array `y` using alternative indexing\n    semantics.\n"
strided.ddeg2rad,"\nstrided.ddeg2rad( N:integer, x:Float64Array, strideX:integer, y:Float64Array, \n  strideY:integer )\n    Converts each element in a double-precision floating-point strided array `x`\n    from degrees to radians and assigns the results to elements in a double-\n    precision floating-point strided array `y`.\n"
strided.ddeg2rad.ndarray,"\nstrided.ddeg2rad.ndarray( N:integer, x:Float64Array, strideX:integer, \n  offsetX:integer, y:Float64Array, strideY:integer, offsetY:integer )\n    Converts each element in a double-precision floating-point strided array `x`\n    from degrees to radians and assigns the results to elements in a double-\n    precision floating-point strided array `y` using alternative indexing\n    semantics.\n"
strided.deg2rad,"\nstrided.deg2rad( N:integer, x:ArrayLikeObject, strideX:integer, \n  y:ArrayLikeObject, strideY:integer )\n    Converts each element in a strided array `x` from degrees to radians and \n    assigns the results to elements in a strided array `y`.\n"
strided.deg2rad.ndarray,"\nstrided.deg2rad.ndarray( N:integer, x:ArrayLikeObject, strideX:integer, \n  offsetX:integer, y:ArrayLikeObject, strideY:integer, offsetY:integer )\n    Converts each element in a strided array `x` from degrees to radians and \n    assigns the results to elements in a strided array `y` using alternative \n    indexing semantics.\n"
strided.dfloor,"\nstrided.dfloor( N:integer, x:Float64Array, strideX:integer, y:Float64Array, \n  strideY:integer )\n    Rounds each element in a double-precision floating-point strided array `x`\n    toward negative infinity and assigns the results to elements in a double-\n    precision floating-point strided array `y`.\n"
strided.dfloor.ndarray,"\nstrided.dfloor.ndarray( N:integer, x:Float64Array, strideX:integer, \n  offsetX:integer, y:Float64Array, strideY:integer, offsetY:integer )\n    Rounds each element in a double-precision floating-point strided array `x`\n    toward negative infinity and assigns the results to elements in a double-\n    precision floating-point strided array `y` using alternative indexing\n    semantics.\n"
strided.dinv,"\nstrided.dinv( N:integer, x:Float64Array, strideX:integer, y:Float64Array, \n  strideY:integer )\n    Computes the multiplicative inverse for each element in a double-precision\n    floating-point strided array `x` and assigns the results to elements in a\n    double-precision floating-point strided array `y`.\n"
strided.dinv.ndarray,"\nstrided.dinv.ndarray( N:integer, x:Float64Array, strideX:integer, \n  offsetX:integer, y:Float64Array, strideY:integer, offsetY:integer )\n    Computes the multiplicative inverse for each element in a double-precision\n    floating-point strided array `x` and assigns the results to elements in a\n    double-precision floating-point strided array `y` using alternative indexing\n    semantics.\n"
strided.dispatch,"\nstrided.dispatch( fcns:Function|ArrayLikeObject<Function>, \n  types:ArrayLikeObject<string>, data:ArrayLikeObject|null, nargs:integer, \n  nin:integer, nout:integer )\n    Returns a strided array function interface which performs multiple dispatch.\n"
strided.dmskabs,"\nstrided.dmskabs( N:integer, x:Float64Array, sx:integer, m:Uint8Array, \n  sm:integer, y:Float64Array, sy:integer )\n    Computes the absolute value for each element in a double-precision floating-\n    point strided array `x` according to a strided mask array and assigns the\n    results to elements in a double-precision floating-point strided array `y`.\n"
strided.dmskabs.ndarray,"\nstrided.dmskabs.ndarray( N:integer, x:Float64Array, sx:integer, ox:integer, \n  m:Float64Array, sm:integer, om:integer, y:Float64Array, sy:integer, \n  oy:integer )\n    Computes the absolute value for each element in a double-precision floating-\n    point strided array `x` according to a strided mask array and assigns the\n    results to elements in a double-precision floating-point strided array `y`\n    using alternative indexing semantics.\n"
strided.dmskabs2,"\nstrided.dmskabs2( N:integer, x:Float64Array, sx:integer, m:Uint8Array, \n  sm:integer, y:Float64Array, sy:integer )\n    Computes the squared absolute value for each element in a double-precision\n    floating-point strided array `x` according to a strided mask array and\n    assigns the results to elements in a double-precision floating-point\n    strided array `y`.\n"
strided.dmskabs2.ndarray,"\nstrided.dmskabs2.ndarray( N:integer, x:Float64Array, sx:integer, ox:integer, \n  m:Float64Array, sm:integer, om:integer, y:Float64Array, sy:integer, \n  oy:integer )\n    Computes the squared absolute value for each element in a double-precision\n    floating-point strided array `x` according to a strided mask array and\n    assigns the results to elements in a double-precision floating-point\n    strided array `y` using alternative indexing semantics.\n"
strided.dmskcbrt,"\nstrided.dmskcbrt( N:integer, x:Float64Array, sx:integer, m:Uint8Array, \n  sm:integer, y:Float64Array, sy:integer )\n    Computes the cube root for each element in a double-precision floating-point\n    strided array `x` according to a strided mask array and assigns the results\n    to elements in a double-precision floating-point strided array `y`.\n"
strided.dmskcbrt.ndarray,"\nstrided.dmskcbrt.ndarray( N:integer, x:Float64Array, sx:integer, ox:integer, \n  m:Float64Array, sm:integer, om:integer, y:Float64Array, sy:integer, \n  oy:integer )\n    Computes the cube root for each element in a double-precision floating-point\n    strided array `x` according to a strided mask array and assigns the results\n    to elements in a double-precision floating-point strided array `y` using\n    alternative indexing semantics.\n"
strided.dmskceil,"\nstrided.dmskceil( N:integer, x:Float64Array, sx:integer, m:Uint8Array, \n  sm:integer, y:Float64Array, sy:integer )\n    Rounds each element in a double-precision floating-point strided array `x`\n    toward positive infinity according to a strided mask array and assigns the\n    results to elements in a double-precision floating-point strided array `y`.\n"
strided.dmskceil.ndarray,"\nstrided.dmskceil.ndarray( N:integer, x:Float64Array, sx:integer, ox:integer, \n  m:Float64Array, sm:integer, om:integer, y:Float64Array, sy:integer, \n  oy:integer )\n    Rounds each element in a double-precision floating-point strided array `x`\n    toward positive infinity according to a strided mask array and assigns the\n    results to elements in a double-precision floating-point strided array `y`\n    using alternative indexing semantics.\n"
strided.dmskdeg2rad,"\nstrided.dmskdeg2rad( N:integer, x:Float64Array, sx:integer, m:Uint8Array, \n  sm:integer, y:Float64Array, sy:integer )\n    Converts each element in a double-precision floating-point strided array `x`\n    from degrees to radians according to a strided mask array and assigns the\n    results to elements in a double-precision floating-point strided array `y`.\n"
strided.dmskdeg2rad.ndarray,"\nstrided.dmskdeg2rad.ndarray( N:integer, x:Float64Array, sx:integer, ox:integer, \n  m:Float64Array, sm:integer, om:integer, y:Float64Array, sy:integer, \n  oy:integer )\n    Converts each element in a double-precision floating-point strided array `x`\n    from degrees to radians according to a strided mask array and assigns the\n    results to elements in a double-precision floating-point strided array `y`\n    using alternative indexing semantics.\n"
strided.dmskfloor,"\nstrided.dmskfloor( N:integer, x:Float64Array, sx:integer, m:Uint8Array, \n  sm:integer, y:Float64Array, sy:integer )\n    Rounds each element in a double-precision floating-point strided array `x`\n    toward negative infinity according to a strided mask array and assigns the\n    results to elements in a double-precision floating-point strided array `y`.\n"
strided.dmskfloor.ndarray,"\nstrided.dmskfloor.ndarray( N:integer, x:Float64Array, sx:integer, ox:integer, \n  m:Float64Array, sm:integer, om:integer, y:Float64Array, sy:integer, \n  oy:integer )\n    Rounds each element in a double-precision floating-point strided array `x`\n    toward negative infinity according to a strided mask array and assigns the\n    results to elements in a double-precision floating-point strided array `y`\n    using alternative indexing semantics.\n"
strided.dmskinv,"\nstrided.dmskinv( N:integer, x:Float64Array, sx:integer, m:Uint8Array, \n  sm:integer, y:Float64Array, sy:integer )\n    Computes the multiplicative inverse for each element in a double-precision\n    floating-point strided array `x` according to a strided mask array and\n    assigns the results to elements in a double-precision floating-point strided\n    array `y`.\n"
strided.dmskinv.ndarray,"\nstrided.dmskinv.ndarray( N:integer, x:Float64Array, sx:integer, ox:integer, \n  m:Float64Array, sm:integer, om:integer, y:Float64Array, sy:integer, \n  oy:integer )\n    Computes the multiplicative inverse for each element in a double-precision\n    floating-point strided array `x` according to a strided mask array and\n    assigns the results to elements in a double-precision floating-point strided\n    array `y` using alternative indexing semantics.\n"
strided.dmskramp,"\nstrided.dmskramp( N:integer, x:Float64Array, sx:integer, m:Uint8Array, \n  sm:integer, y:Float64Array, sy:integer )\n    Evaluates the ramp function for each element in a double-precision floating-\n    point strided array `x` according to a strided mask array and assigns the\n    results to elements in a double-precision floating-point strided array `y`.\n"
strided.dmskramp.ndarray,"\nstrided.dmskramp.ndarray( N:integer, x:Float64Array, sx:integer, ox:integer, \n  m:Float64Array, sm:integer, om:integer, y:Float64Array, sy:integer, \n  oy:integer )\n    Evaluates the ramp function for each element in a double-precision floating-\n    point strided array `x` according to a strided mask array and assigns the\n    results to elements in a double-precision floating-point strided array `y`\n    using alternative indexing semantics.\n"
strided.dmskrsqrt,"\nstrided.dmskrsqrt( N:integer, x:Float64Array, sx:integer, m:Uint8Array, \n  sm:integer, y:Float64Array, sy:integer )\n    Computes the reciprocal square root for each element in a double-precision\n    floating-point strided array `x` according to a strided mask array and\n    assigns the results to elements in a double-precision floating-point strided\n    array `y`.\n"
strided.dmskrsqrt.ndarray,"\nstrided.dmskrsqrt.ndarray( N:integer, x:Float64Array, sx:integer, ox:integer, \n  m:Float64Array, sm:integer, om:integer, y:Float64Array, sy:integer, \n  oy:integer )\n    Computes the reciprocal square root for each element in a double-precision\n    floating-point strided array `x` according to a strided mask array and\n    assigns the results to elements in a double-precision floating-point strided\n    array `y` using alternative indexing semantics.\n"
strided.dmsksqrt,"\nstrided.dmsksqrt( N:integer, x:Float64Array, sx:integer, m:Uint8Array, \n  sm:integer, y:Float64Array, sy:integer )\n    Computes the principal square root for each element in a double-precision\n    floating-point strided array `x` according to a strided mask array and\n    assigns the results to elements in a double-precision floating-point strided\n    array `y`.\n"
strided.dmsksqrt.ndarray,"\nstrided.dmsksqrt.ndarray( N:integer, x:Float64Array, sx:integer, ox:integer, \n  m:Float64Array, sm:integer, om:integer, y:Float64Array, sy:integer, \n  oy:integer )\n    Computes the principal square root for each element in a double-precision\n    floating-point strided array `x` according to a strided mask array and\n    assigns the results to elements in a double-precision floating-point strided\n    array `y` using alternative indexing semantics.\n"
strided.dmsktrunc,"\nstrided.dmsktrunc( N:integer, x:Float64Array, sx:integer, m:Uint8Array, \n  sm:integer, y:Float64Array, sy:integer )\n    Rounds each element in a double-precision floating-point strided array `x`\n    toward zero according to a strided mask array and assigns the results to\n    elements in a double-precision floating-point strided array `y`.\n"
strided.dmsktrunc.ndarray,"\nstrided.dmsktrunc.ndarray( N:integer, x:Float64Array, sx:integer, ox:integer, \n  m:Float64Array, sm:integer, om:integer, y:Float64Array, sy:integer, \n  oy:integer )\n    Rounds each element in a double-precision floating-point strided array `x`\n    toward zero according to a strided mask array and assigns the results to\n    elements in a double-precision floating-point strided array `y` using\n    alternative indexing semantics.\n"
strided.dramp,"\nstrided.dramp( N:integer, x:Float64Array, strideX:integer, y:Float64Array, \n  strideY:integer )\n    Evaluates the ramp function for each element in a double-precision floating-\n    point strided array `x` and assigns the results to elements in a double-\n    precision floating-point strided array `y`.\n"
strided.dramp.ndarray,"\nstrided.dramp.ndarray( N:integer, x:Float64Array, strideX:integer, \n  offsetX:integer, y:Float64Array, strideY:integer, offsetY:integer )\n    Evaluates the ramp function for each element in a double-precision floating-\n    point strided array `x` and assigns the results to elements in a double-\n    precision floating-point strided array `y` using alternative indexing\n    semantics.\n"
strided.drsqrt,"\nstrided.drsqrt( N:integer, x:Float64Array, strideX:integer, y:Float64Array, \n  strideY:integer )\n    Computes the reciprocal square root for each element in a double-precision\n    floating-point strided array `x` and assigns the results to elements in a\n    double-precision floating-point strided array `y`.\n"
strided.drsqrt.ndarray,"\nstrided.drsqrt.ndarray( N:integer, x:Float64Array, strideX:integer, \n  offsetX:integer, y:Float64Array, strideY:integer, offsetY:integer )\n    Computes the reciprocal square root for each element in a double-precision\n    floating-point strided array `x` and assigns the results to elements in a\n    double-precision floating-point strided array `y` using alternative indexing\n    semantics.\n"
strided.dsqrt,"\nstrided.dsqrt( N:integer, x:Float64Array, strideX:integer, y:Float64Array, \n  strideY:integer )\n    Computes the principal square root for each element in a double-precision\n    floating-point strided array `x` and assigns the results to elements in a\n    double-precision floating-point strided array `y`.\n"
strided.dsqrt.ndarray,"\nstrided.dsqrt.ndarray( N:integer, x:Float64Array, strideX:integer, \n  offsetX:integer, y:Float64Array, strideY:integer, offsetY:integer )\n    Computes the principal square root for each element in a double-precision\n    floating-point strided array `x` and assigns the results to elements in a\n    double-precision floating-point strided array `y` using alternative indexing\n    semantics.\n"
strided.dtrunc,"\nstrided.dtrunc( N:integer, x:Float64Array, strideX:integer, y:Float64Array, \n  strideY:integer )\n    Rounds each element in a double-precision floating-point strided array `x`\n    toward zero and assigns the results to elements in a double-precision\n    floating-point strided array `y`.\n"
strided.dtrunc.ndarray,"\nstrided.dtrunc.ndarray( N:integer, x:Float64Array, strideX:integer, \n  offsetX:integer, y:Float64Array, strideY:integer, offsetY:integer )\n    Rounds each element in a double-precision floating-point strided array `x`\n    toward zero and assigns the results to elements in a double-precision\n    floating-point strided array `y` using alternative indexing semantics.\n"
strided.floor,"\nstrided.floor( N:integer, x:ArrayLikeObject, strideX:integer, \n  y:ArrayLikeObject, strideY:integer )\n    Rounds each element in a strided array `x` toward negative infinity and \n    assigns the results to elements in a strided array `y`.\n"
strided.floor.ndarray,"\nstrided.floor.ndarray( N:integer, x:ArrayLikeObject, strideX:integer, \n  offsetX:integer, y:ArrayLikeObject, strideY:integer, offsetY:integer )\n    Rounds each element in a strided array `x` toward negative infinity and \n    assigns the results to elements in a strided array `y` using alternative \n    indexing semantics.\n"
strided.inv,"\nstrided.inv( N:integer, x:ArrayLikeObject, strideX:integer, y:ArrayLikeObject, \n  strideY:integer )\n    Computes the multiplicative inverse for each element in a strided array `x`\n    and assigns the results to elements in a strided array `y`.\n"
strided.inv.ndarray,"\nstrided.inv.ndarray( N:integer, x:ArrayLikeObject, strideX:integer, \n  offsetX:integer, y:ArrayLikeObject, strideY:integer, offsetY:integer )\n    Computes the multiplicative inverse for each element in a strided array `x`\n    and assigns the results to elements in a strided array `y` using alternative\n    indexing semantics.\n"
strided.ramp,"\nstrided.ramp( N:integer, x:ArrayLikeObject, strideX:integer, y:ArrayLikeObject, \n  strideY:integer )\n    Evaluates the ramp function for each element in a strided array `x` and \n    assigns the results to elements in a strided array `y`.\n"
strided.ramp.ndarray,"\nstrided.ramp.ndarray( N:integer, x:ArrayLikeObject, strideX:integer, \n  offsetX:integer, y:ArrayLikeObject, strideY:integer, offsetY:integer )\n    Evaluates the ramp function for each element in a strided array `x` and \n    assigns the results to elements in a strided array `y` using alternative \n    indexing semantics.\n"
strided.rsqrt,"\nstrided.rsqrt( N:integer, x:ArrayLikeObject, strideX:integer, \n  y:ArrayLikeObject, strideY:integer )\n    Computes the reciprocal square root for each element in a strided array `x`\n    and assigns the results to elements in a strided array `y`.\n"
strided.rsqrt.ndarray,"\nstrided.rsqrt.ndarray( N:integer, x:ArrayLikeObject, strideX:integer, \n  offsetX:integer, y:ArrayLikeObject, strideY:integer, offsetY:integer )\n    Computes the reciprocal square root for each element in a strided array `x`\n    and assigns the results to elements in a strided array `y` using alternative\n    indexing semantics.\n"
strided.sabs,"\nstrided.sabs( N:integer, x:Float32Array, strideX:integer, y:Float32Array, \n  strideY:integer )\n    Computes the absolute value for each element in a single-precision floating-\n    point strided array `x` and assigns the results to elements in a single-\n    precision floating-point strided array `y`.\n"
strided.sabs.ndarray,"\nstrided.sabs.ndarray( N:integer, x:Float32Array, strideX:integer, \n  offsetX:integer, y:Float32Array, strideY:integer, offsetY:integer )\n    Computes the absolute value for each element in a single-precision floating-\n    point strided array `x` and assigns the results to elements in a single-\n    precision floating-point strided array `y` using alternative indexing\n    semantics.\n"
strided.sabs2,"\nstrided.sabs2( N:integer, x:Float32Array, strideX:integer, y:Float32Array, \n  strideY:integer )\n    Computes the squared absolute value for each element in a single-precision\n    floating-point strided array `x` and assigns the results to elements in a\n    single-precision floating-point strided array `y`.\n"
strided.sabs2.ndarray,"\nstrided.sabs2.ndarray( N:integer, x:Float32Array, strideX:integer, \n  offsetX:integer, y:Float32Array, strideY:integer, offsetY:integer )\n    Computes the squared absolute value for each element in a single-precision\n    floating-point strided array `x` and assigns the results to elements in a\n    single-precision floating-point strided array `y` using alternative indexing\n    semantics.\n"
strided.scbrt,"\nstrided.scbrt( N:integer, x:Float32Array, strideX:integer, y:Float32Array, \n  strideY:integer )\n    Computes the cube root of each element in a single-precision floating-point \n    strided array `x` and assigns the results to elements in a single-precision \n    floating-point strided array `y`.\n"
strided.scbrt.ndarray,"\nstrided.scbrt.ndarray( N:integer, x:Float32Array, strideX:integer, \n  offsetX:integer, y:Float32Array, strideY:integer, offsetY:integer )\n    Computes the cube root of each element in a single-precision floating-point \n    strided array `x` and assigns the results to elements in a single-precision \n    floating-point strided array `y` using alternative indexing semantics.\n"
strided.sceil,"\nstrided.sceil( N:integer, x:Float32Array, strideX:integer, y:Float32Array, \n  strideY:integer )\n    Rounds each element in a single-precision floating-point strided array `x`\n    toward positive infinity and assigns the results to elements in a single-\n    precision floating-point strided array `y`.\n"
strided.sceil.ndarray,"\nstrided.sceil.ndarray( N:integer, x:Float32Array, strideX:integer, \n  offsetX:integer, y:Float32Array, strideY:integer, offsetY:integer )\n    Rounds each element in a single-precision floating-point strided array `x`\n    toward positive infinity and assigns the results to elements in a single-\n    precision floating-point strided array `y` using alternative indexing\n    semantics.\n"
strided.sdeg2rad,"\nstrided.sdeg2rad( N:integer, x:Float32Array, strideX:integer, y:Float32Array, \n  strideY:integer )\n    Converts each element in a single-precision floating-point strided array `x`\n    from degrees to radians and assigns the results to elements in a single-\n    precision floating-point strided array `y`.\n"
strided.sdeg2rad.ndarray,"\nstrided.sdeg2rad.ndarray( N:integer, x:Float32Array, strideX:integer, \n  offsetX:integer, y:Float32Array, strideY:integer, offsetY:integer )\n    Converts each element in a single-precision floating-point strided array `x`\n    from degrees to radians and assigns the results to elements in a single-\n    precision floating-point strided array `y` using alternative indexing\n    semantics.\n"
strided.sfloor,"\nstrided.sfloor( N:integer, x:Float32Array, strideX:integer, y:Float32Array, \n  strideY:integer )\n    Rounds each element in a single-precision floating-point strided array `x`\n    toward negative infinity and assigns the results to elements in a single-\n    precision floating-point strided array `y`.\n"
strided.sfloor.ndarray,"\nstrided.sfloor.ndarray( N:integer, x:Float32Array, strideX:integer, \n  offsetX:integer, y:Float32Array, strideY:integer, offsetY:integer )\n    Rounds each element in a single-precision floating-point strided array `x`\n    toward negative infinity and assigns the results to elements in a single-\n    precision floating-point strided array `y` using alternative indexing\n    semantics.\n"
strided.sinv,"\nstrided.sinv( N:integer, x:Float32Array, strideX:integer, y:Float32Array, \n  strideY:integer )\n    Computes the multiplicative inverse for each element in a single-precision\n    floating-point strided array `x` and assigns the results to elements in a\n    single-precision floating-point strided array `y`.\n"
strided.sinv.ndarray,"\nstrided.sinv.ndarray( N:integer, x:Float32Array, strideX:integer, \n  offsetX:integer, y:Float32Array, strideY:integer, offsetY:integer )\n    Computes the multiplicative inverse for each element in a single-precision\n    floating-point strided array `x` and assigns the results to elements in a\n    single-precision floating-point strided array `y` using alternative indexing\n    semantics.\n"
strided.smskabs,"\nstrided.smskabs( N:integer, x:Float32Array, sx:integer, m:Uint8Array, \n  sm:integer, y:Float32Array, sy:integer )\n    Computes the absolute value for each element in a single-precision floating-\n    point strided array `x` according to a strided mask array and assigns the\n    results to elements in a single-precision floating-point strided array `y`.\n"
strided.smskabs.ndarray,"\nstrided.smskabs.ndarray( N:integer, x:Float32Array, sx:integer, ox:integer, \n  m:Float32Array, sm:integer, om:integer, y:Float32Array, sy:integer, \n  oy:integer )\n    Computes the absolute value for each element in a single-precision floating-\n    point strided array `x` according to a strided mask array and assigns the\n    results to elements in a single-precision floating-point strided array `y`\n    using alternative indexing semantics.\n"
strided.smskabs2,"\nstrided.smskabs2( N:integer, x:Float32Array, sx:integer, m:Uint8Array, \n  sm:integer, y:Float32Array, sy:integer )\n    Computes the squared absolute value for each element in a single-precision\n    floating-point strided array `x` according to a strided mask array and\n    assigns the results to elements in a single-precision floating-point\n    strided array `y`.\n"
strided.smskabs2.ndarray,"\nstrided.smskabs2.ndarray( N:integer, x:Float32Array, sx:integer, ox:integer, \n  m:Float32Array, sm:integer, om:integer, y:Float32Array, sy:integer, \n  oy:integer )\n    Computes the squared absolute value for each element in a single-precision\n    floating-point strided array `x` according to a strided mask array and\n    assigns the results to elements in a single-precision floating-point\n    strided array `y` using alternative indexing semantics.\n"
strided.smskcbrt,"\nstrided.smskcbrt( N:integer, x:Float32Array, sx:integer, m:Uint8Array, \n  sm:integer, y:Float32Array, sy:integer )\n    Computes the cube root for each element in a single-precision floating-point\n    strided array `x` according to a strided mask array and assigns the results\n    to elements in a single-precision floating-point strided array `y`.\n"
strided.smskcbrt.ndarray,"\nstrided.smskcbrt.ndarray( N:integer, x:Float32Array, sx:integer, ox:integer, \n  m:Float32Array, sm:integer, om:integer, y:Float32Array, sy:integer, \n  oy:integer )\n    Computes the cube root for each element in a single-precision floating-point\n    strided array `x` according to a strided mask array and assigns the results\n    to elements in a single-precision floating-point strided array `y` using\n    alternative indexing semantics.\n"
strided.smskceil,"\nstrided.smskceil( N:integer, x:Float32Array, sx:integer, m:Uint8Array, \n  sm:integer, y:Float32Array, sy:integer )\n    Rounds each element in a single-precision floating-point strided array `x`\n    toward positive infinity according to a strided mask array and assigns the\n    results to elements in a single-precision floating-point strided array `y`.\n"
strided.smskceil.ndarray,"\nstrided.smskceil.ndarray( N:integer, x:Float32Array, sx:integer, ox:integer, \n  m:Float32Array, sm:integer, om:integer, y:Float32Array, sy:integer, \n  oy:integer )\n    Rounds each element in a single-precision floating-point strided array `x`\n    toward positive infinity according to a strided mask array and assigns the\n    results to elements in a single-precision floating-point strided array `y`\n    using alternative indexing semantics.\n"
strided.smskdeg2rad,"\nstrided.smskdeg2rad( N:integer, x:Float32Array, sx:integer, m:Uint8Array, \n  sm:integer, y:Float32Array, sy:integer )\n    Converts each element in a single-precision floating-point strided array `x`\n    from degrees to radians according to a strided mask array and assigns the\n    results to elements in a single-precision floating-point strided array `y`.\n"
strided.smskdeg2rad.ndarray,"\nstrided.smskdeg2rad.ndarray( N:integer, x:Float32Array, sx:integer, ox:integer, \n  m:Float32Array, sm:integer, om:integer, y:Float32Array, sy:integer, \n  oy:integer )\n    Converts each element in a single-precision floating-point strided array `x`\n    from degrees to radians according to a strided mask array and assigns the\n    results to elements in a single-precision floating-point strided array `y`\n    using alternative indexing semantics.\n"
strided.smskfloor,"\nstrided.smskfloor( N:integer, x:Float32Array, sx:integer, m:Uint8Array, \n  sm:integer, y:Float32Array, sy:integer )\n    Rounds each element in a single-precision floating-point strided array `x`\n    toward negative infinity according to a strided mask array and assigns the\n    results to elements in a single-precision floating-point strided array `y`.\n"
strided.smskfloor.ndarray,"\nstrided.smskfloor.ndarray( N:integer, x:Float32Array, sx:integer, ox:integer, \n  m:Float32Array, sm:integer, om:integer, y:Float32Array, sy:integer, \n  oy:integer )\n    Rounds each element in a single-precision floating-point strided array `x`\n    toward negative infinity according to a strided mask array and assigns the\n    results to elements in a single-precision floating-point strided array `y`\n    using alternative indexing semantics.\n"
strided.smskinv,"\nstrided.smskinv( N:integer, x:Float32Array, sx:integer, m:Uint8Array, \n  sm:integer, y:Float32Array, sy:integer )\n    Computes the multiplicative inverse for each element in a single-precision\n    floating-point strided array `x` according to a strided mask array and\n    assigns the results to elements in a single-precision floating-point strided\n    array `y`.\n"
strided.smskinv.ndarray,"\nstrided.smskinv.ndarray( N:integer, x:Float32Array, sx:integer, ox:integer, \n  m:Float32Array, sm:integer, om:integer, y:Float32Array, sy:integer, \n  oy:integer )\n    Computes the multiplicative inverse for each element in a single-precision\n    floating-point strided array `x` according to a strided mask array and\n    assigns the results to elements in a single-precision floating-point strided\n    array `y` using alternative indexing semantics.\n"
strided.smskramp,"\nstrided.smskramp( N:integer, x:Float32Array, sx:integer, m:Uint8Array, \n  sm:integer, y:Float32Array, sy:integer )\n    Evaluates the ramp function for each element in a single-precision floating-\n    point strided array `x` according to a strided mask array and assigns the\n    results to elements in a single-precision floating-point strided array `y`.\n"
strided.smskramp.ndarray,"\nstrided.smskramp.ndarray( N:integer, x:Float32Array, sx:integer, ox:integer, \n  m:Float32Array, sm:integer, om:integer, y:Float32Array, sy:integer, \n  oy:integer )\n    Evaluates the ramp function for each element in a single-precision floating-\n    point strided array `x` according to a strided mask array and assigns the\n    results to elements in a single-precision floating-point strided array `y`\n    using alternative indexing semantics.\n"
strided.smskrsqrt,"\nstrided.smskrsqrt( N:integer, x:Float32Array, sx:integer, m:Uint8Array, \n  sm:integer, y:Float32Array, sy:integer )\n    Computes the reciprocal square root for each element in a single-precision\n    floating-point strided array `x` according to a strided mask array and\n    assigns the results to elements in a single-precision floating-point strided\n    array `y`.\n"
strided.smskrsqrt.ndarray,"\nstrided.smskrsqrt.ndarray( N:integer, x:Float32Array, sx:integer, ox:integer, \n  m:Float32Array, sm:integer, om:integer, y:Float32Array, sy:integer, \n  oy:integer )\n    Computes the reciprocal square root for each element in a single-precision\n    floating-point strided array `x` according to a strided mask array and\n    assigns the results to elements in a single-precision floating-point strided\n    array `y` using alternative indexing semantics.\n"
strided.smsksqrt,"\nstrided.smsksqrt( N:integer, x:Float32Array, sx:integer, m:Uint8Array, \n  sm:integer, y:Float32Array, sy:integer )\n    Computes the principal square root for each element in a single-precision\n    floating-point strided array `x` according to a strided mask array and\n    assigns the results to elements in a single-precision floating-point strided\n    array `y`.\n"
strided.smsksqrt.ndarray,"\nstrided.smsksqrt.ndarray( N:integer, x:Float32Array, sx:integer, ox:integer, \n  m:Float32Array, sm:integer, om:integer, y:Float32Array, sy:integer, \n  oy:integer )\n    Computes the principal square root for each element in a single-precision\n    floating-point strided array `x` according to a strided mask array and\n    assigns the results to elements in a single-precision floating-point strided\n    array `y` using alternative indexing semantics.\n"
strided.smsktrunc,"\nstrided.smsktrunc( N:integer, x:Float32Array, sx:integer, m:Uint8Array, \n  sm:integer, y:Float32Array, sy:integer )\n    Rounds each element in a single-precision floating-point strided array `x`\n    toward zero according to a strided mask array and assigns the results to\n    elements in a single-precision floating-point strided array `y`.\n"
strided.smsktrunc.ndarray,"\nstrided.smsktrunc.ndarray( N:integer, x:Float32Array, sx:integer, ox:integer, \n  m:Float32Array, sm:integer, om:integer, y:Float32Array, sy:integer, \n  oy:integer )\n    Rounds each element in a single-precision floating-point strided array `x`\n    toward zero according to a strided mask array and assigns the results to\n    elements in a single-precision floating-point strided array `y` using\n    alternative indexing semantics.\n"
strided.sqrt,"\nstrided.sqrt( N:integer, x:ArrayLikeObject, strideX:integer, y:ArrayLikeObject, \n  strideY:integer )\n    Computes the principal square root of each element in a strided array `x`\n    and assigns the results to elements in a strided array `y`.\n"
strided.sqrt.ndarray,"\nstrided.sqrt.ndarray( N:integer, x:ArrayLikeObject, strideX:integer, \n  offsetX:integer, y:ArrayLikeObject, strideY:integer, offsetY:integer )\n    Computes the principal square root of each element in a strided array `x`\n    and assigns the results to elements in a strided array `y` using alternative\n    indexing semantics.\n"
strided.sramp,"\nstrided.sramp( N:integer, x:Float32Array, strideX:integer, y:Float32Array, \n  strideY:integer )\n    Evaluates the ramp function for each element in a single-precision floating-\n    point strided array `x` and assigns the results to elements in a single-\n    precision floating-point strided array `y`.\n"
strided.sramp.ndarray,"\nstrided.sramp.ndarray( N:integer, x:Float32Array, strideX:integer, \n  offsetX:integer, y:Float32Array, strideY:integer, offsetY:integer )\n    Evaluates the ramp function for each element in a single-precision floating-\n    point strided array `x` and assigns the results to elements in a single-\n    precision floating-point strided array `y` using alternative indexing\n    semantics.\n"
strided.srsqrt,"\nstrided.srsqrt( N:integer, x:Float32Array, strideX:integer, y:Float32Array, \n  strideY:integer )\n    Computes the reciprocal square root for each element in a single-precision\n    floating-point strided array `x` and assigns the results to elements in a\n    single-precision floating-point strided array `y`.\n"
strided.srsqrt.ndarray,"\nstrided.srsqrt.ndarray( N:integer, x:Float32Array, strideX:integer, \n  offsetX:integer, y:Float32Array, strideY:integer, offsetY:integer )\n    Computes the reciprocal square root for each element in a single-precision\n    floating-point strided array `x` and assigns the results to elements in a\n    single-precision floating-point strided array `y` using alternative indexing\n    semantics.\n"
strided.ssqrt,"\nstrided.ssqrt( N:integer, x:Float32Array, strideX:integer, y:Float32Array, \n  strideY:integer )\n    Computes the principal square root for each element in a single-precision\n    floating-point strided array `x` and assigns the results to elements in a\n    single-precision floating-point strided array `y`.\n"
strided.ssqrt.ndarray,"\nstrided.ssqrt.ndarray( N:integer, x:Float32Array, strideX:integer, \n  offsetX:integer, y:Float32Array, strideY:integer, offsetY:integer )\n    Computes the principal square root for each element in a single-precision\n    floating-point strided array `x` and assigns the results to elements in a\n    single-precision floating-point strided array `y` using alternative indexing\n    semantics.\n"
strided.strunc,"\nstrided.strunc( N:integer, x:Float32Array, strideX:integer, y:Float32Array, \n  strideY:integer )\n    Rounds each element in a single-precision floating-point strided array `x`\n    toward zero and assigns the results to elements in a single-precision\n    floating-point strided array `y`.\n"
strided.strunc.ndarray,"\nstrided.strunc.ndarray( N:integer, x:Float32Array, strideX:integer, \n  offsetX:integer, y:Float32Array, strideY:integer, offsetY:integer )\n    Rounds each element in a single-precision floating-point strided array `x`\n    toward zero and assigns the results to elements in a single-precision\n    floating-point strided array `y` using alternative indexing semantics.\n"
strided.trunc,"\nstrided.trunc( N:integer, x:ArrayLikeObject, strideX:integer, \n  y:ArrayLikeObject, strideY:integer )\n    Rounds each element in a strided array `x` toward zero and assigns the\n    results to elements in a strided array `y`.\n"
strided.trunc.ndarray,"\nstrided.trunc.ndarray( N:integer, x:ArrayLikeObject, strideX:integer, \n  offsetX:integer, y:ArrayLikeObject, strideY:integer, offsetY:integer )\n    Rounds each element in a strided array `x` toward zero and assigns the\n    results to elements in a strided array `y` using alternative indexing\n    semantics.\n"
stridedarray2iterator,"\nstridedarray2iterator( N:integer, src:ArrayLikeObject, stride:integer, \n  offset:integer[, mapFcn:Function[, thisArg:any]] )\n    Returns an iterator which iterates over elements of an array-like object\n    according to specified stride parameters.\n"
stridedArrayStream,"\nstridedArrayStream( N:integer, buffer:ArrayLikeObject, stride:integer, \n  offset:integer[, options:Object] )\n    Creates a readable stream from a strided array-like object.\n"
stridedArrayStream.factory,"\nstridedArrayStream.factory( [options:Object] )\n    Returns a function for creating readable streams from array-like objects.\n"
stridedArrayStream.objectMode,"\nstridedArrayStream.objectMode( N:integer, buffer:ArrayLikeObject, \n  stride:integer, offset:integer[, options:Object] )\n    Returns an \"objectMode\" readable stream from a strided array-like object.\n"
string2buffer,"\nstring2buffer( str:string[, encoding:string] )\n    Allocates a buffer containing a provided string.\n"
sub2ind,"\nsub2ind( shape:ArrayLike, ...subscript:integer[, options:Object] )\n    Converts subscripts to a linear index.\n"
SUTHAHARAN_MULTI_HOP_SENSOR_NETWORK,"\nSUTHAHARAN_MULTI_HOP_SENSOR_NETWORK()\n    Returns a dataset consisting of labeled wireless sensor network data set\n    collected from a multi-hop wireless sensor network deployment using TelosB\n    motes.\n"
SUTHAHARAN_SINGLE_HOP_SENSOR_NETWORK,"\nSUTHAHARAN_SINGLE_HOP_SENSOR_NETWORK()\n    Returns a dataset consisting of labeled wireless sensor network data set\n    collected from a simple single-hop wireless sensor network deployment using\n    TelosB motes.\n"
Symbol,"\nSymbol( [description:string] )\n    Returns a symbol.\n"
tabulate,"\ntabulate( collection:Array|TypedArray|Object )\n    Generates a frequency table.\n"
tabulateBy,"\ntabulateBy( collection:Array|TypedArray|Object, [options:Object,] \n  indicator:Function )\n    Generates a frequency table according to an indicator function.\n"
tabulateByAsync,"\ntabulateByAsync( collection:Array|TypedArray|Object, [options:Object,] \n  indicator:Function, done:Function )\n    Generates a frequency table according to an indicator function.\n"
tabulateByAsync.factory,"\ntabulateByAsync.factory( [options:Object,] indicator:Function )\n    Returns a function which generates a frequency table according to an\n    indicator function.\n"
tic,"\ntic()\n    Returns a high-resolution time.\n"
timeit,"\ntimeit( code:string, [options:Object,] clbk:Function )\n    Times a snippet.\n"
tmpdir,"\ntmpdir()\n    Returns the directory for storing temporary files.\n"
toc,"\ntoc( time:Array<integer> )\n    Returns a high-resolution time difference, where `time` is a two-element\n    array with format `[seconds, nanoseconds]`.\n"
tokenize,"\ntokenize( str:string[, keepWhitespace:boolean] )\n    Tokenizes a string.\n"
transformStream,"\ntransformStream( [options:Object] )\n    Returns a transform stream.\n"
transformStream.factory,"\ntransformStream.factory( [options:Object] )\n    Returns a function for creating transform streams.\n"
transformStream.objectMode,"\ntransformStream.objectMode( [options:Object] )\n    Returns an \"objectMode\" transform stream.\n"
transformStream.ctor,"\ntransformStream.ctor( [options:Object] )\n    Returns a custom transform stream constructor.\n"
trim,"\ntrim( str:string )\n    Trims whitespace from the beginning and end of a `string`.\n"
trycatch,"\ntrycatch( x:Function, y:any )\n    If a function does not throw, returns the function return value; otherwise,\n    returns `y`.\n"
trycatchAsync,"\ntrycatchAsync( x:Function, y:any, done:Function )\n    If a function does not return an error, invokes a callback with the function\n    result; otherwise, invokes a callback with a value `y`.\n"
tryFunction,"\ntryFunction( fcn:Function[, thisArg:any] )\n    Wraps a function in a try/catch block.\n"
tryRequire,"\ntryRequire( id:string )\n    Wraps `require` in a `try/catch` block.\n"
trythen,"\ntrythen( x:Function, y:Function )\n    If a function does not throw, returns the function return value; otherwise,\n    returns the value returned by a second function `y`.\n"
trythenAsync,"\ntrythenAsync( x:Function, y:Function, done:Function )\n    If a function does not return an error, invokes a callback with the function\n    result; otherwise, invokes a second function `y`.\n"
ttest,"\nttest( x:Array<number>[, y:Array<number>][, options:Object] )\n    Computes a one-sample or paired Student's t test.\n"
ttest2,"\nttest2( x:Array<number>, y:Array<number>[, options:Object] )\n    Computes a two-sample Student's t test.\n"
TWO_PI,"\nTWO_PI\n    The mathematical constant `π` times `2`.\n"
typedarray,"\ntypedarray( [dtype:string] )\n    Creates a typed array.\n\ntypedarray( length:integer[, dtype:string] )\n    Returns a typed array having a specified length.\n\ntypedarray( typedarray:TypedArray[, dtype:string] )\n    Creates a typed array from another typed array.\n\ntypedarray( obj:Object[, dtype:string] )\n    Creates a typed array from an array-like object or iterable.\n\ntypedarray( buffer:ArrayBuffer[, byteOffset:integer[, length:integer]][, \n  dtype:string] )\n    Returns a typed array view of an ArrayBuffer.\n"
typedarray2json,"\ntypedarray2json( arr:TypedArray )\n    Returns a JSON representation of a typed array.\n"
typedarrayComplexCtors,"\ntypedarrayComplexCtors( dtype:string )\n    Returns a complex typed array constructor.\n"
typedarrayComplexDataTypes,"\ntypedarrayComplexDataTypes()\n    Returns a list of complex typed array data types.\n"
typedarrayCtors,"\ntypedarrayCtors( dtype:string )\n    Returns a typed array constructor.\n"
typedarrayDataTypes,"\ntypedarrayDataTypes()\n    Returns a list of typed array data types.\n"
typedarraypool,"\ntypedarraypool( [dtype:string] )\n    Returns an uninitialized typed array from a typed array memory pool.\n\ntypedarraypool( length:integer[, dtype:string] )\n    Returns an uninitialized typed array having a specified length from a typed\n    array memory pool.\n\ntypedarraypool( typedarray:TypedArray[, dtype:string] )\n    Creates a pooled typed array from another typed array.\n\ntypedarraypool( obj:Object[, dtype:string] )\n    Creates a pooled typed array from an array-like object.\n"
typedarraypool.malloc,"\ntypedarraypool.malloc( [dtype:string] )\n    Returns an uninitialized typed array from a typed array memory pool.\n\ntypedarraypool.malloc( length:integer[, dtype:string] )\n    Returns a typed array having a specified length from a typed array memory\n    pool.\n\ntypedarraypool.malloc( typedarray:TypedArray[, dtype:string] )\n    Creates a pooled typed array from another typed array.\n\ntypedarraypool.malloc( obj:Object[, dtype:string] )\n    Creates a pooled typed array from an array-like object.\n"
typedarraypool.calloc,"\ntypedarraypool.calloc( [dtype:string] )\n    Returns a zero-initialized typed array from a typed array memory pool.\n\ntypedarraypool.calloc( length:integer[, dtype:string] )\n    Returns a zero-initialized typed array having a specified length from a\n    typed array memory pool.\n"
typedarraypool.free,"\ntypedarraypool.free( buf:TypedArray|ArrayBuffer )\n    Frees a typed array or typed array buffer for use in a future allocation.\n"
typedarraypool.clear,"\ntypedarraypool.clear()\n    Clears the typed array pool allowing garbage collection of previously\n    allocated (and currently free) array buffers.\n"
typedarraypool.highWaterMark,"\ntypedarraypool.highWaterMark\n    Read-only property returning the pool's high water mark.\n"
typedarraypool.nbytes,"\ntypedarraypool.nbytes\n    Read-only property returning the total number of allocated bytes.\n"
typedarraypool.factory,"\ntypedarraypool.factory( [options:Object] )\n    Creates a typed array pool.\n"
typemax,"\ntypemax( dtype:string )\n    Returns the maximum value of a specified numeric type.\n"
typemin,"\ntypemin( dtype:string )\n    Returns the minimum value of a specified numeric type.\n"
typeOf,"\ntypeOf( value:any )\n    Determines a value's type.\n"
UINT8_MAX,"\nUINT8_MAX\n    Maximum unsigned 8-bit integer.\n"
UINT8_NUM_BYTES,"\nUINT8_NUM_BYTES\n    Size (in bytes) of an 8-bit unsigned integer.\n"
Uint8Array,"\nUint8Array()\n    A typed array constructor which returns a typed array representing an array\n    of 8-bit unsigned integers in the platform byte order.\n\nUint8Array( length:integer )\n    Returns a typed array having a specified length.\n\nUint8Array( typedarray:TypedArray )\n    Creates a typed array from another typed array.\n\nUint8Array( obj:Object )\n    Creates a typed array from an array-like object or iterable.\n\nUint8Array( buffer:ArrayBuffer[, byteOffset:integer[, length:integer]] )\n    Returns a typed array view of an ArrayBuffer.\n"
Uint8Array.from,"\nUint8Array.from( src:ArrayLike|Iterable[, map:Function[, thisArg:Any]] )\n    Creates a new typed array from an array-like object or an iterable.\n"
Uint8Array.of,"\nUint8Array.of( element0:number[, element1:number[, ...elementN:number]] )\n    Creates a new typed array from a variable number of arguments.\n"
Uint8Array.BYTES_PER_ELEMENT,"\nUint8Array.BYTES_PER_ELEMENT\n    Number of bytes per view element.\n"
Uint8Array.name,"\nUint8Array.name\n    Typed array constructor name.\n"
Uint8Array.prototype.buffer,"\nUint8Array.prototype.buffer\n    Read-only property which returns the ArrayBuffer referenced by the typed\n    array.\n"
Uint8Array.prototype.byteLength,"\nUint8Array.prototype.byteLength\n    Read-only property which returns the length (in bytes) of the typed array.\n"
Uint8Array.prototype.byteOffset,"\nUint8Array.prototype.byteOffset\n    Read-only property which returns the offset (in bytes) of the typed array\n    from the start of its ArrayBuffer.\n"
Uint8Array.prototype.BYTES_PER_ELEMENT,"\nUint8Array.prototype.BYTES_PER_ELEMENT\n    Number of bytes per view element.\n"
Uint8Array.prototype.length,"\nUint8Array.prototype.length\n    Read-only property which returns the number of view elements.\n"
Uint8Array.prototype.copyWithin,"\nUint8Array.prototype.copyWithin( target:integer, start:integer[, end:integer] )\n    Copies a sequence of elements within the array starting at `start` and\n    ending at `end` (non-inclusive) to the position starting at `target`.\n"
Uint8Array.prototype.entries,"\nUint8Array.prototype.entries()\n    Returns an iterator for iterating over array key-value pairs.\n"
Uint8Array.prototype.every,"\nUint8Array.prototype.every( predicate:Function[, thisArg:Any] )\n    Tests whether all array elements pass a test implemented by a predicate\n    function.\n"
Uint8Array.prototype.fill,"\nUint8Array.prototype.fill( value:number[, start:integer[, end:integer]] )\n    Fills an array from a start index to an end index (non-inclusive) with a\n    provided value.\n"
Uint8Array.prototype.filter,"\nUint8Array.prototype.filter( predicate:Function[, thisArg:Any] )\n    Creates a new array which includes those elements for which a predicate\n    function returns a truthy value.\n"
Uint8Array.prototype.find,"\nUint8Array.prototype.find( predicate:Function[, thisArg:Any] )\n    Returns the first array element for which a provided predicate function\n    returns a truthy value.\n"
Uint8Array.prototype.findIndex,"\nUint8Array.prototype.findIndex( predicate:Function[, thisArg:Any] )\n    Returns the index of the first array element for which a provided predicate\n    function returns a truthy value.\n"
Uint8Array.prototype.forEach,"\nUint8Array.prototype.forEach( fcn:Function[, thisArg:Any] )\n    Invokes a callback for each array element.\n"
Uint8Array.prototype.includes,"\nUint8Array.prototype.includes( searchElement:number[, fromIndex:integer] )\n    Returns a boolean indicating whether an array includes a search element.\n"
Uint8Array.prototype.indexOf,"\nUint8Array.prototype.indexOf( searchElement:number[, fromIndex:integer] )\n    Returns the index of the first array element strictly equal to a search\n    element.\n"
Uint8Array.prototype.join,"\nUint8Array.prototype.join( [separator:string] )\n    Serializes an array by joining all array elements as a string.\n"
Uint8Array.prototype.keys,"\nUint8Array.prototype.keys()\n    Returns an iterator for iterating over array keys.\n"
Uint8Array.prototype.lastIndexOf,"\nUint8Array.prototype.lastIndexOf( searchElement:number[, fromIndex:integer] )\n    Returns the index of the last array element strictly equal to a search\n    element.\n"
Uint8Array.prototype.map,"\nUint8Array.prototype.map( fcn:Function[, thisArg:Any] )\n    Maps each array element to an element in a new typed array.\n"
Uint8Array.prototype.reduce,"\nUint8Array.prototype.reduce( fcn:Function[, initialValue:Any] )\n    Applies a function against an accumulator and each element in an array and\n    returns the accumulated result.\n"
Uint8Array.prototype.reduceRight,"\nUint8Array.prototype.reduceRight( fcn:Function[, initialValue:Any] )\n    Applies a function against an accumulator and each element in an array and\n    returns the accumulated result, iterating from right to left.\n"
Uint8Array.prototype.reverse,"\nUint8Array.prototype.reverse()\n    Reverses an array *in-place*.\n"
Uint8Array.prototype.set,"\nUint8Array.prototype.set( arr:ArrayLike[, offset:integer] )\n    Sets array elements.\n"
Uint8Array.prototype.slice,"\nUint8Array.prototype.slice( [begin:integer[, end:integer]] )\n    Copies array elements to a new array with the same underlying data type as\n    the host array.\n"
Uint8Array.prototype.some,"\nUint8Array.prototype.some( predicate:Function[, thisArg:Any] )\n    Tests whether at least one array element passes a test implemented by a\n    predicate function.\n"
Uint8Array.prototype.sort,"\nUint8Array.prototype.sort( [compareFunction:Function] )\n    Sorts an array *in-place*.\n"
Uint8Array.prototype.subarray,"\nUint8Array.prototype.subarray( [begin:integer[, end:integer]] )\n    Creates a new typed array over the same underlying ArrayBuffer and with the\n    same underlying data type as the host array.\n"
Uint8Array.prototype.toLocaleString,"\nUint8Array.prototype.toLocaleString( [locales:string|Array[, options:Object]] )\n    Serializes an array as a locale-specific string.\n"
Uint8Array.prototype.toString,"\nUint8Array.prototype.toString()\n    Serializes an array as a string.\n"
Uint8Array.prototype.values,"\nUint8Array.prototype.values()\n    Returns an iterator for iterating over array elements.\n"
Uint8ClampedArray,"\nUint8ClampedArray()\n    A typed array constructor which returns a typed array representing an array\n    of 8-bit unsigned integers in the platform byte order clamped to 0-255.\n\nUint8ClampedArray( length:integer )\n    Returns a typed array having a specified length.\n\nUint8ClampedArray( typedarray:TypedArray )\n    Creates a typed array from another typed array.\n\nUint8ClampedArray( obj:Object )\n    Creates a typed array from an array-like object or iterable.\n\nUint8ClampedArray( buffer:ArrayBuffer[, byteOffset:integer[, length:integer]] )\n    Returns a typed array view of an ArrayBuffer.\n"
Uint8ClampedArray.from,"\nUint8ClampedArray.from( src:ArrayLike|Iterable[, map:Function[, thisArg:Any]] )\n    Creates a new typed array from an array-like object or an iterable.\n"
Uint8ClampedArray.of,"\nUint8ClampedArray.of( element0:number[, element1:number[, ...elementN:number]] )\n    Creates a new typed array from a variable number of arguments.\n"
Uint8ClampedArray.BYTES_PER_ELEMENT,"\nUint8ClampedArray.BYTES_PER_ELEMENT\n    Number of bytes per view element.\n"
Uint8ClampedArray.name,"\nUint8ClampedArray.name\n    Typed array constructor name.\n"
Uint8ClampedArray.prototype.buffer,"\nUint8ClampedArray.prototype.buffer\n    Read-only property which returns the ArrayBuffer referenced by the typed\n    array.\n"
Uint8ClampedArray.prototype.byteLength,"\nUint8ClampedArray.prototype.byteLength\n    Read-only property which returns the length (in bytes) of the typed array.\n"
Uint8ClampedArray.prototype.byteOffset,"\nUint8ClampedArray.prototype.byteOffset\n    Read-only property which returns the offset (in bytes) of the typed array\n    from the start of its ArrayBuffer.\n"
Uint8ClampedArray.prototype.BYTES_PER_ELEMENT,"\nUint8ClampedArray.prototype.BYTES_PER_ELEMENT\n    Number of bytes per view element.\n"
Uint8ClampedArray.prototype.length,"\nUint8ClampedArray.prototype.length\n    Read-only property which returns the number of view elements.\n"
Uint8ClampedArray.prototype.copyWithin,"\nUint8ClampedArray.prototype.copyWithin( target:integer, start:integer[, \n  end:integer] )\n    Copies a sequence of elements within the array starting at `start` and\n    ending at `end` (non-inclusive) to the position starting at `target`.\n"
Uint8ClampedArray.prototype.entries,"\nUint8ClampedArray.prototype.entries()\n    Returns an iterator for iterating over array key-value pairs.\n"
Uint8ClampedArray.prototype.every,"\nUint8ClampedArray.prototype.every( predicate:Function[, thisArg:Any] )\n    Tests whether all array elements pass a test implemented by a predicate\n    function.\n"
Uint8ClampedArray.prototype.fill,"\nUint8ClampedArray.prototype.fill( value:number[, start:integer[, end:integer]] )\n    Fills an array from a start index to an end index (non-inclusive) with a\n    provided value.\n"
Uint8ClampedArray.prototype.filter,"\nUint8ClampedArray.prototype.filter( predicate:Function[, thisArg:Any] )\n    Creates a new array which includes those elements for which a predicate\n    function returns a truthy value.\n"
Uint8ClampedArray.prototype.find,"\nUint8ClampedArray.prototype.find( predicate:Function[, thisArg:Any] )\n    Returns the first array element for which a provided predicate function\n    returns a truthy value.\n"
Uint8ClampedArray.prototype.findIndex,"\nUint8ClampedArray.prototype.findIndex( predicate:Function[, thisArg:Any] )\n    Returns the index of the first array element for which a provided predicate\n    function returns a truthy value.\n"
Uint8ClampedArray.prototype.forEach,"\nUint8ClampedArray.prototype.forEach( fcn:Function[, thisArg:Any] )\n    Invokes a callback for each array element.\n"
Uint8ClampedArray.prototype.includes,"\nUint8ClampedArray.prototype.includes( searchElement:number[, \n  fromIndex:integer] )\n    Returns a boolean indicating whether an array includes a search element.\n"
Uint8ClampedArray.prototype.indexOf,"\nUint8ClampedArray.prototype.indexOf( searchElement:number[, fromIndex:integer] )\n    Returns the index of the first array element strictly equal to a search\n    element.\n"
Uint8ClampedArray.prototype.join,"\nUint8ClampedArray.prototype.join( [separator:string] )\n    Serializes an array by joining all array elements as a string.\n"
Uint8ClampedArray.prototype.keys,"\nUint8ClampedArray.prototype.keys()\n    Returns an iterator for iterating over array keys.\n"
Uint8ClampedArray.prototype.lastIndexOf,"\nUint8ClampedArray.prototype.lastIndexOf( searchElement:number[, \n  fromIndex:integer] )\n    Returns the index of the last array element strictly equal to a search\n    element.\n"
Uint8ClampedArray.prototype.map,"\nUint8ClampedArray.prototype.map( fcn:Function[, thisArg:Any] )\n    Maps each array element to an element in a new typed array.\n"
Uint8ClampedArray.prototype.reduce,"\nUint8ClampedArray.prototype.reduce( fcn:Function[, initialValue:Any] )\n    Applies a function against an accumulator and each element in an array and\n    returns the accumulated result.\n"
Uint8ClampedArray.prototype.reduceRight,"\nUint8ClampedArray.prototype.reduceRight( fcn:Function[, initialValue:Any] )\n    Applies a function against an accumulator and each element in an array and\n    returns the accumulated result, iterating from right to left.\n"
Uint8ClampedArray.prototype.reverse,"\nUint8ClampedArray.prototype.reverse()\n    Reverses an array *in-place*.\n"
Uint8ClampedArray.prototype.set,"\nUint8ClampedArray.prototype.set( arr:ArrayLike[, offset:integer] )\n    Sets array elements.\n"
Uint8ClampedArray.prototype.slice,"\nUint8ClampedArray.prototype.slice( [begin:integer[, end:integer]] )\n    Copies array elements to a new array with the same underlying data type as\n    the host array.\n"
Uint8ClampedArray.prototype.some,"\nUint8ClampedArray.prototype.some( predicate:Function[, thisArg:Any] )\n    Tests whether at least one array element passes a test implemented by a\n    predicate function.\n"
Uint8ClampedArray.prototype.sort,"\nUint8ClampedArray.prototype.sort( [compareFunction:Function] )\n    Sorts an array *in-place*.\n"
Uint8ClampedArray.prototype.subarray,"\nUint8ClampedArray.prototype.subarray( [begin:integer[, end:integer]] )\n    Creates a new typed array over the same underlying ArrayBuffer and with the\n    same underlying data type as the host array.\n"
Uint8ClampedArray.prototype.toLocaleString,"\nUint8ClampedArray.prototype.toLocaleString( [locales:string|Array[, \n  options:Object]] )\n    Serializes an array as a locale-specific string.\n"
Uint8ClampedArray.prototype.toString,"\nUint8ClampedArray.prototype.toString()\n    Serializes an array as a string.\n"
Uint8ClampedArray.prototype.values,"\nUint8ClampedArray.prototype.values()\n    Returns an iterator for iterating over array elements.\n"
UINT16_MAX,"\nUINT16_MAX\n    Maximum unsigned 16-bit integer.\n"
UINT16_NUM_BYTES,"\nUINT16_NUM_BYTES\n    Size (in bytes) of a 16-bit unsigned integer.\n"
Uint16Array,"\nUint16Array()\n    A typed array constructor which returns a typed array representing an array\n    of 16-bit unsigned integers in the platform byte order.\n\nUint16Array( length:integer )\n    Returns a typed array having a specified length.\n\nUint16Array( typedarray:TypedArray )\n    Creates a typed array from another typed array.\n\nUint16Array( obj:Object )\n    Creates a typed array from an array-like object or iterable.\n\nUint16Array( buffer:ArrayBuffer[, byteOffset:integer[, length:integer]] )\n    Returns a typed array view of an ArrayBuffer.\n"
Uint16Array.from,"\nUint16Array.from( src:ArrayLike|Iterable[, map:Function[, thisArg:Any]] )\n    Creates a new typed array from an array-like object or an iterable.\n"
Uint16Array.of,"\nUint16Array.of( element0:number[, element1:number[, ...elementN:number]] )\n    Creates a new typed array from a variable number of arguments.\n"
Uint16Array.BYTES_PER_ELEMENT,"\nUint16Array.BYTES_PER_ELEMENT\n    Number of bytes per view element.\n"
Uint16Array.name,"\nUint16Array.name\n    Typed array constructor name.\n"
Uint16Array.prototype.buffer,"\nUint16Array.prototype.buffer\n    Read-only property which returns the ArrayBuffer referenced by the typed\n    array.\n"
Uint16Array.prototype.byteLength,"\nUint16Array.prototype.byteLength\n    Read-only property which returns the length (in bytes) of the typed array.\n"
Uint16Array.prototype.byteOffset,"\nUint16Array.prototype.byteOffset\n    Read-only property which returns the offset (in bytes) of the typed array\n    from the start of its ArrayBuffer.\n"
Uint16Array.prototype.BYTES_PER_ELEMENT,"\nUint16Array.prototype.BYTES_PER_ELEMENT\n    Number of bytes per view element.\n"
Uint16Array.prototype.length,"\nUint16Array.prototype.length\n    Read-only property which returns the number of view elements.\n"
Uint16Array.prototype.copyWithin,"\nUint16Array.prototype.copyWithin( target:integer, start:integer[, end:integer] )\n    Copies a sequence of elements within the array starting at `start` and\n    ending at `end` (non-inclusive) to the position starting at `target`.\n"
Uint16Array.prototype.entries,"\nUint16Array.prototype.entries()\n    Returns an iterator for iterating over array key-value pairs.\n"
Uint16Array.prototype.every,"\nUint16Array.prototype.every( predicate:Function[, thisArg:Any] )\n    Tests whether all array elements pass a test implemented by a predicate\n    function.\n"
Uint16Array.prototype.fill,"\nUint16Array.prototype.fill( value:number[, start:integer[, end:integer]] )\n    Fills an array from a start index to an end index (non-inclusive) with a\n    provided value.\n"
Uint16Array.prototype.filter,"\nUint16Array.prototype.filter( predicate:Function[, thisArg:Any] )\n    Creates a new array which includes those elements for which a predicate\n    function returns a truthy value.\n"
Uint16Array.prototype.find,"\nUint16Array.prototype.find( predicate:Function[, thisArg:Any] )\n    Returns the first array element for which a provided predicate function\n    returns a truthy value.\n"
Uint16Array.prototype.findIndex,"\nUint16Array.prototype.findIndex( predicate:Function[, thisArg:Any] )\n    Returns the index of the first array element for which a provided predicate\n    function returns a truthy value.\n"
Uint16Array.prototype.forEach,"\nUint16Array.prototype.forEach( fcn:Function[, thisArg:Any] )\n    Invokes a callback for each array element.\n"
Uint16Array.prototype.includes,"\nUint16Array.prototype.includes( searchElement:number[, fromIndex:integer] )\n    Returns a boolean indicating whether an array includes a search element.\n"
Uint16Array.prototype.indexOf,"\nUint16Array.prototype.indexOf( searchElement:number[, fromIndex:integer] )\n    Returns the index of the first array element strictly equal to a search\n    element.\n"
Uint16Array.prototype.join,"\nUint16Array.prototype.join( [separator:string] )\n    Serializes an array by joining all array elements as a string.\n"
Uint16Array.prototype.keys,"\nUint16Array.prototype.keys()\n    Returns an iterator for iterating over array keys.\n"
Uint16Array.prototype.lastIndexOf,"\nUint16Array.prototype.lastIndexOf( searchElement:number[, fromIndex:integer] )\n    Returns the index of the last array element strictly equal to a search\n    element.\n"
Uint16Array.prototype.map,"\nUint16Array.prototype.map( fcn:Function[, thisArg:Any] )\n    Maps each array element to an element in a new typed array.\n"
Uint16Array.prototype.reduce,"\nUint16Array.prototype.reduce( fcn:Function[, initialValue:Any] )\n    Applies a function against an accumulator and each element in an array and\n    returns the accumulated result.\n"
Uint16Array.prototype.reduceRight,"\nUint16Array.prototype.reduceRight( fcn:Function[, initialValue:Any] )\n    Applies a function against an accumulator and each element in an array and\n    returns the accumulated result, iterating from right to left.\n"
Uint16Array.prototype.reverse,"\nUint16Array.prototype.reverse()\n    Reverses an array *in-place*.\n"
Uint16Array.prototype.set,"\nUint16Array.prototype.set( arr:ArrayLike[, offset:integer] )\n    Sets array elements.\n"
Uint16Array.prototype.slice,"\nUint16Array.prototype.slice( [begin:integer[, end:integer]] )\n    Copies array elements to a new array with the same underlying data type as\n    the host array.\n"
Uint16Array.prototype.some,"\nUint16Array.prototype.some( predicate:Function[, thisArg:Any] )\n    Tests whether at least one array element passes a test implemented by a\n    predicate function.\n"
Uint16Array.prototype.sort,"\nUint16Array.prototype.sort( [compareFunction:Function] )\n    Sorts an array *in-place*.\n"
Uint16Array.prototype.subarray,"\nUint16Array.prototype.subarray( [begin:integer[, end:integer]] )\n    Creates a new typed array over the same underlying ArrayBuffer and with the\n    same underlying data type as the host array.\n"
Uint16Array.prototype.toLocaleString,"\nUint16Array.prototype.toLocaleString( [locales:string|Array[, options:Object]] )\n    Serializes an array as a locale-specific string.\n"
Uint16Array.prototype.toString,"\nUint16Array.prototype.toString()\n    Serializes an array as a string.\n"
Uint16Array.prototype.values,"\nUint16Array.prototype.values()\n    Returns an iterator for iterating over array elements.\n"
UINT32_MAX,"\nUINT32_MAX\n    Maximum unsigned 32-bit integer.\n"
UINT32_NUM_BYTES,"\nUINT32_NUM_BYTES\n    Size (in bytes) of a 32-bit unsigned integer.\n"
Uint32Array,"\nUint32Array()\n    A typed array constructor which returns a typed array representing an array\n    of 32-bit unsigned integers in the platform byte order.\n\nUint32Array( length:integer )\n    Returns a typed array having a specified length.\n\nUint32Array( typedarray:TypedArray )\n    Creates a typed array from another typed array.\n\nUint32Array( obj:Object )\n    Creates a typed array from an array-like object or iterable.\n\nUint32Array( buffer:ArrayBuffer[, byteOffset:integer[, length:integer]] )\n    Returns a typed array view of an ArrayBuffer.\n"
Uint32Array.from,"\nUint32Array.from( src:ArrayLike|Iterable[, map:Function[, thisArg:Any]] )\n    Creates a new typed array from an array-like object or an iterable.\n"
Uint32Array.of,"\nUint32Array.of( element0:number[, element1:number[, ...elementN:number]] )\n    Creates a new typed array from a variable number of arguments.\n"
Uint32Array.BYTES_PER_ELEMENT,"\nUint32Array.BYTES_PER_ELEMENT\n    Number of bytes per view element.\n"
Uint32Array.name,"\nUint32Array.name\n    Typed array constructor name.\n"
Uint32Array.prototype.buffer,"\nUint32Array.prototype.buffer\n    Read-only property which returns the ArrayBuffer referenced by the typed\n    array.\n"
Uint32Array.prototype.byteLength,"\nUint32Array.prototype.byteLength\n    Read-only property which returns the length (in bytes) of the typed array.\n"
Uint32Array.prototype.byteOffset,"\nUint32Array.prototype.byteOffset\n    Read-only property which returns the offset (in bytes) of the typed array\n    from the start of its ArrayBuffer.\n"
Uint32Array.prototype.BYTES_PER_ELEMENT,"\nUint32Array.prototype.BYTES_PER_ELEMENT\n    Number of bytes per view element.\n"
Uint32Array.prototype.length,"\nUint32Array.prototype.length\n    Read-only property which returns the number of view elements.\n"
Uint32Array.prototype.copyWithin,"\nUint32Array.prototype.copyWithin( target:integer, start:integer[, end:integer] )\n    Copies a sequence of elements within the array starting at `start` and\n    ending at `end` (non-inclusive) to the position starting at `target`.\n"
Uint32Array.prototype.entries,"\nUint32Array.prototype.entries()\n    Returns an iterator for iterating over array key-value pairs.\n"
Uint32Array.prototype.every,"\nUint32Array.prototype.every( predicate:Function[, thisArg:Any] )\n    Tests whether all array elements pass a test implemented by a predicate\n    function.\n"
Uint32Array.prototype.fill,"\nUint32Array.prototype.fill( value:number[, start:integer[, end:integer]] )\n    Fills an array from a start index to an end index (non-inclusive) with a\n    provided value.\n"
Uint32Array.prototype.filter,"\nUint32Array.prototype.filter( predicate:Function[, thisArg:Any] )\n    Creates a new array which includes those elements for which a predicate\n    function returns a truthy value.\n"
Uint32Array.prototype.find,"\nUint32Array.prototype.find( predicate:Function[, thisArg:Any] )\n    Returns the first array element for which a provided predicate function\n    returns a truthy value.\n"
Uint32Array.prototype.findIndex,"\nUint32Array.prototype.findIndex( predicate:Function[, thisArg:Any] )\n    Returns the index of the first array element for which a provided predicate\n    function returns a truthy value.\n"
Uint32Array.prototype.forEach,"\nUint32Array.prototype.forEach( fcn:Function[, thisArg:Any] )\n    Invokes a callback for each array element.\n"
Uint32Array.prototype.includes,"\nUint32Array.prototype.includes( searchElement:number[, fromIndex:integer] )\n    Returns a boolean indicating whether an array includes a search element.\n"
Uint32Array.prototype.indexOf,"\nUint32Array.prototype.indexOf( searchElement:number[, fromIndex:integer] )\n    Returns the index of the first array element strictly equal to a search\n    element.\n"
Uint32Array.prototype.join,"\nUint32Array.prototype.join( [separator:string] )\n    Serializes an array by joining all array elements as a string.\n"
Uint32Array.prototype.keys,"\nUint32Array.prototype.keys()\n    Returns an iterator for iterating over array keys.\n"
Uint32Array.prototype.lastIndexOf,"\nUint32Array.prototype.lastIndexOf( searchElement:number[, fromIndex:integer] )\n    Returns the index of the last array element strictly equal to a search\n    element.\n"
Uint32Array.prototype.map,"\nUint32Array.prototype.map( fcn:Function[, thisArg:Any] )\n    Maps each array element to an element in a new typed array.\n"
Uint32Array.prototype.reduce,"\nUint32Array.prototype.reduce( fcn:Function[, initialValue:Any] )\n    Applies a function against an accumulator and each element in an array and\n    returns the accumulated result.\n"
Uint32Array.prototype.reduceRight,"\nUint32Array.prototype.reduceRight( fcn:Function[, initialValue:Any] )\n    Applies a function against an accumulator and each element in an array and\n    returns the accumulated result, iterating from right to left.\n"
Uint32Array.prototype.reverse,"\nUint32Array.prototype.reverse()\n    Reverses an array *in-place*.\n"
Uint32Array.prototype.set,"\nUint32Array.prototype.set( arr:ArrayLike[, offset:integer] )\n    Sets array elements.\n"
Uint32Array.prototype.slice,"\nUint32Array.prototype.slice( [begin:integer[, end:integer]] )\n    Copies array elements to a new array with the same underlying data type as\n    the host array.\n"
Uint32Array.prototype.some,"\nUint32Array.prototype.some( predicate:Function[, thisArg:Any] )\n    Tests whether at least one array element passes a test implemented by a\n    predicate function.\n"
Uint32Array.prototype.sort,"\nUint32Array.prototype.sort( [compareFunction:Function] )\n    Sorts an array *in-place*.\n"
Uint32Array.prototype.subarray,"\nUint32Array.prototype.subarray( [begin:integer[, end:integer]] )\n    Creates a new typed array over the same underlying ArrayBuffer and with the\n    same underlying data type as the host array.\n"
Uint32Array.prototype.toLocaleString,"\nUint32Array.prototype.toLocaleString( [locales:string|Array[, options:Object]] )\n    Serializes an array as a locale-specific string.\n"
Uint32Array.prototype.toString,"\nUint32Array.prototype.toString()\n    Serializes an array as a string.\n"
Uint32Array.prototype.values,"\nUint32Array.prototype.values()\n    Returns an iterator for iterating over array elements.\n"
umask,"\numask( [mask:integer|string,] [options:Object] )\n    Returns the current process mask, if not provided a mask; otherwise, sets\n    the process mask and returns the previous mask.\n"
uncapitalize,"\nuncapitalize( str:string )\n    Lowercases the first character of a `string`.\n"
uncapitalizeKeys,"\nuncapitalizeKeys( obj:Object )\n    Converts the first letter of each object key to lowercase.\n"
uncurry,"\nuncurry( fcn:Function[, arity:integer, ][thisArg:any] )\n    Transforms a curried function into a function invoked with multiple\n    arguments.\n"
uncurryRight,"\nuncurryRight( fcn:Function[, arity:integer, ][thisArg:any] )\n    Transforms a curried function into a function invoked with multiple\n    arguments.\n"
UNICODE_MAX,"\nUNICODE_MAX\n    Maximum Unicode code point.\n"
UNICODE_MAX_BMP,"\nUNICODE_MAX_BMP\n    Maximum Unicode code point in the Basic Multilingual Plane (BMP).\n"
UnicodeColumnChartSparkline,"\nUnicodeColumnChartSparkline( [data:ArrayLike|ndarray,] [options:Object] )\n    Returns a sparkline column chart instance.\n"
UnicodeLineChartSparkline,"\nUnicodeLineChartSparkline( [data:ArrayLike|ndarray,] [options:Object] )\n    Returns a sparkline line chart instance.\n"
UnicodeSparkline,"\nUnicodeSparkline( [data:ArrayLike|ndarray,] [options:Object] )\n    Returns a Unicode sparkline instance.\n"
UnicodeTristateChartSparkline,"\nUnicodeTristateChartSparkline( [data:ArrayLike|ndarray,] [options:Object] )\n    Returns a sparkline tristate chart instance.\n"
UnicodeUpDownChartSparkline,"\nUnicodeUpDownChartSparkline( [data:ArrayLike|ndarray,] [options:Object] )\n    Returns a sparkline up/down chart instance.\n"
UnicodeWinLossChartSparkline,"\nUnicodeWinLossChartSparkline( [data:ArrayLike|ndarray,] [options:Object] )\n    Returns a sparkline win/loss chart instance.\n"
unlink,"\nunlink( path:string|Buffer|integer, clbk:Function )\n    Asynchronously removes a directory entry.\n"
unlink.sync,"\nunlink.sync( path:string|Buffer|integer )\n    Synchronously removes a directory entry.\n"
unshift,"\nunshift( collection:Array|TypedArray|Object, ...items:any )\n    Adds one or more elements to the beginning of a collection.\n"
until,"\nuntil( predicate:Function, fcn:Function[, thisArg:any] )\n    Invokes a function until a test condition is true.\n"
untilAsync,"\nuntilAsync( predicate:Function, fcn:Function, done:Function[, thisArg:any] )\n    Invokes a function until a test condition is true.\n"
untilEach,"\nuntilEach( collection:Array|TypedArray|Object, predicate:Function, \n  fcn:Function[, thisArg:any] )\n    Until a test condition is true, invokes a function for each element in a\n    collection.\n"
untilEachRight,"\nuntilEachRight( collection:Array|TypedArray|Object, predicate:Function, \n  fcn:Function[, thisArg:any] )\n    Until a test condition is true, invokes a function for each element in a\n    collection, iterating from right to left.\n"
unzip,"\nunzip( arr:Array[, idx:Array<number>] )\n    Unzips a zipped array (i.e., a nested array of tuples).\n"
uppercase,"\nuppercase( str:string )\n    Converts a `string` to uppercase.\n"
uppercaseKeys,"\nuppercaseKeys( obj:Object )\n    Converts each object key to uppercase.\n"
US_STATES_ABBR,"\nUS_STATES_ABBR()\n    Returns a list of US state two-letter abbreviations in alphabetical order\n    according to state name.\n"
US_STATES_CAPITALS,"\nUS_STATES_CAPITALS()\n    Returns a list of US state capitals in alphabetical order according to state\n    name.\n"
US_STATES_CAPITALS_NAMES,"\nUS_STATES_CAPITALS_NAMES()\n    Returns an object mapping US state capitals to state names.\n"
US_STATES_NAMES,"\nUS_STATES_NAMES()\n    Returns a list of US state names in alphabetical order.\n"
US_STATES_NAMES_CAPITALS,"\nUS_STATES_NAMES_CAPITALS()\n    Returns an object mapping US state names to state capitals.\n"
utf16ToUTF8Array,"\nutf16ToUTF8Array( str:string )\n    Converts a UTF-16 encoded string to an array of integers using UTF-8\n    encoding.\n"
vartest,"\nvartest( x:Array<number>, y:Array<number>[, options:Object] )\n    Computes a two-sample F-test for equal variances.\n"
waterfall,"\nwaterfall( fcns:Array<Function>, clbk:Function[, thisArg:any] )\n    Executes functions in series, passing the results of one function as\n    arguments to the next function.\n"
waterfall.factory,"\nwaterfall.factory( fcns:Array<Function>, clbk:Function[, thisArg:any] )\n    Returns a reusable waterfall function.\n"
whileAsync,"\nwhileAsync( predicate:Function, fcn:Function, done:Function[, thisArg:any] )\n    Invokes a function while a test condition is true.\n"
whileEach,"\nwhileEach( collection:Array|TypedArray|Object, predicate:Function, \n  fcn:Function[, thisArg:any] )\n    While a test condition is true, invokes a function for each element in a\n    collection.\n"
whileEachRight,"\nwhileEachRight( collection:Array|TypedArray|Object, predicate:Function, \n  fcn:Function[, thisArg:any] )\n    While a test condition is true, invokes a function for each element in a\n    collection, iterating from right to left.\n"
whilst,"\nwhilst( predicate:Function, fcn:Function[, thisArg:any] )\n    Invokes a function while a test condition is true.\n"
wilcoxon,"\nwilcoxon( x:Array|TypedArray[, y:Array|TypedArray][, options:Object] )\n    Computes a one-sample or paired Wilcoxon signed rank test.\n"
writableProperties,"\nwritableProperties( value:any )\n    Returns an array of an object's own writable property names and symbols.\n"
writablePropertiesIn,"\nwritablePropertiesIn( value:any )\n    Returns an array of an object's own and inherited writable property names\n    and symbols.\n"
writablePropertyNames,"\nwritablePropertyNames( value:any )\n    Returns an array of an object's own writable property names.\n"
writablePropertyNamesIn,"\nwritablePropertyNamesIn( value:any )\n    Returns an array of an object's own and inherited writable property names.\n"
writablePropertySymbols,"\nwritablePropertySymbols( value:any )\n    Returns an array of an object's own writable symbol properties.\n"
writablePropertySymbolsIn,"\nwritablePropertySymbolsIn( value:any )\n    Returns an array of an object's own and inherited writable symbol\n    properties.\n"
writeFile,"\nwriteFile( file:string|Buffer|integer, data:string|Buffer[, \n  options:Object|string], clbk:Function )\n    Asynchronously writes data to a file.\n"
writeFile.sync,"\nwriteFile.sync( file:string|Buffer|integer, data:string|Buffer[, \n  options:Object|string] )\n    Synchronously writes data to a file.\n"
zip,"\nzip( ...arr:Array[, options:Object] )\n    Generates array tuples from input arrays.\n"
ztest,"\nztest( x:Array<number>, sigma:number[, options:Object] )\n    Computes a one-sample z-test.\n"
ztest2,"\nztest2( x:Array<number>, y:Array<number>, sigmax:number, sigmay:number[, \n  options:Object] )\n    Computes a two-sample z-test.\n"