/*
* When adding modules to the namespace, ensure that they are added in alphabetical order according to module name.
*/

/* This is a generated file. Do not edit directly. */

/* eslint-disable no-restricted-syntax, no-invalid-this */

/* harmony default export */

/* harmony import */

/*#__PURE__*/

/**
	* Constant function.
	*
	* @private
	* @returns {*} constant value
	*/

/**
	* Evaluates the cumulative distribution function (CDF) for a lognormal distribution.
	*
	* @private
	* @param {number} x - input value
	* @returns {Probability} evaluated CDF
	*
	* @example
	* var y = cdf( 2.0 );
	* // returns <number>
	*/

/**
	* Evaluates the natural logarithm of the probability density function (PDF) for a lognormal distribution.
	*
	* @private
	* @param {number} x - input value
	* @returns {number} evaluated logPDF
	*
	* @example
	* var y = logpdf( 2.5 );
	* // returns <number>
	*/

/**
	* Evaluates the probability density function (PDF) for a lognormal distribution.
	*
	* @private
	* @param {number} x - input value
	* @returns {number} evaluated PDF
	*
	* @example
	* var y = pdf( 2.5 );
	* // returns <number>
	*/

/**
	* Evaluates the quantile function for a lognormal distribution.
	*
	* @private
	* @param {Probability} p - input value
	* @returns {number} evaluated quantile function
	*
	* @example
	* var y = quantile( 0.3 );
	* // returns <number>
	*/

/**
	* If provided a value, the accumulator function returns an updated mean. If not provided a value, the accumulator function returns the current mean.
	*
	* @private
	* @param {number} [x] - new value
	* @returns {(number|null)} mean value or null
	*/

/**
* @license Apache-2.0
*
* Copyright (c) 2018 The Stdlib Authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
*    http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
*
* ## Notice
*
* The following copyright, license, and long comment were part of the original implementation available as part of [FreeBSD]{@link https://svnweb.freebsd.org/base/release/9.3.0/lib/msun/src/e_exp.c}. The implementation follows the original, but has been modified for JavaScript.
*
* ```text
* Copyright (C) 2004 by Sun Microsystems, Inc. All rights reserved.
*
* Developed at SunPro, a Sun Microsystems, Inc. business.
* Permission to use, copy, modify, and distribute this
* software is freely granted, provided that this notice
* is preserved.
* ```
*/

/**
* @license Apache-2.0
*
* Copyright (c) 2018 The Stdlib Authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
*    http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/

/**
* @name LogNormal
* @memberof lognormal
* @readonly
* @type {Function}
* @see {@link module:@stdlib/stats/base/dists/lognormal/ctor}
*/

/**
* @name cdf
* @memberof lognormal
* @readonly
* @type {Function}
* @see {@link module:@stdlib/stats/base/dists/lognormal/cdf}
*/

/**
* @name entropy
* @memberof lognormal
* @readonly
* @type {Function}
* @see {@link module:@stdlib/stats/base/dists/lognormal/entropy}
*/

/**
* @name kurtosis
* @memberof lognormal
* @readonly
* @type {Function}
* @see {@link module:@stdlib/stats/base/dists/lognormal/kurtosis}
*/

/**
* @name logpdf
* @memberof lognormal
* @readonly
* @type {Function}
* @see {@link module:@stdlib/stats/base/dists/lognormal/logpdf}
*/

/**
* @name mean
* @memberof lognormal
* @readonly
* @type {Function}
* @see {@link module:@stdlib/stats/base/dists/lognormal/mean}
*/

/**
* @name median
* @memberof lognormal
* @readonly
* @type {Function}
* @see {@link module:@stdlib/stats/base/dists/lognormal/median}
*/

/**
* @name mode
* @memberof lognormal
* @readonly
* @type {Function}
* @see {@link module:@stdlib/stats/base/dists/lognormal/mode}
*/

/**
* @name pdf
* @memberof lognormal
* @readonly
* @type {Function}
* @see {@link module:@stdlib/stats/base/dists/lognormal/pdf}
*/

/**
* @name quantile
* @memberof lognormal
* @readonly
* @type {Function}
* @see {@link module:@stdlib/stats/base/dists/lognormal/quantile}
*/

/**
* @name skewness
* @memberof lognormal
* @readonly
* @type {Function}
* @see {@link module:@stdlib/stats/base/dists/lognormal/skewness}
*/

/**
* @name stdev
* @memberof lognormal
* @readonly
* @type {Function}
* @see {@link module:@stdlib/stats/base/dists/lognormal/stdev}
*/

/**
* @name variance
* @memberof lognormal
* @readonly
* @type {Function}
* @see {@link module:@stdlib/stats/base/dists/lognormal/variance}
*/

/**
* Compute an arithmetic mean incrementally.
*
* @module @stdlib/stats/incr/mean
*
* @example
* var incrmean = require( '@stdlib/stats/incr/mean' );
*
* var accumulator = incrmean();
*
* var mu = accumulator();
* // returns null
*
* mu = accumulator( 2.0 );
* // returns 2.0
*
* mu = accumulator( -5.0 );
* // returns -1.5
*
* mu = accumulator();
* // returns -1.5
*/

/**
* Computes \\(e^{r} 2^k\\) where \\(r = \mathrm{hi} - \mathrm{lo}\\) and \\(|r| \leq \ln(2)/2\\).
*
* @private
* @param {number} hi - upper bound
* @param {number} lo - lower bound
* @param {integer} k - power of 2
* @returns {number} function value
*/

/**
* Create a constant function.
*
* @module @stdlib/utils/constant-function
*
* @example
* var constantFunction = require( '@stdlib/utils/constant-function' );
*
* var fcn = constantFunction( 3.14 );
*
* var v = fcn();
* // returns 3.14
*
* v = fcn();
* // returns 3.14
*
* v = fcn();
* // returns 3.14
*/

/**
* Creates a function which always returns the same value.
*
* @param {*} [value] - value to always return
* @returns {Function} constant function
*
* @example
* var fcn = wrap( 3.14 );
*
* var v = fcn();
* // returns 3.14
*
* v = fcn();
* // returns 3.14
*
* v = fcn();
* // returns 3.14
*/

/**
* Define a read-only property.
*
* @module @stdlib/utils/define-read-only-property
*
* @example
* var setReadOnly = require( '@stdlib/utils/define-read-only-property' );
*
* var obj = {};
*
* setReadOnly( obj, 'foo', 'bar' );
*
* try {
*     obj.foo = 'boop';
* } catch ( err ) {
*     console.error( err.message );
* }
*/

/**
* Defines a read-only property.
*
* @param {Object} obj - object on which to define the property
* @param {(string|symbol)} prop - property name
* @param {*} value - value to set
*
* @example
* var obj = {};
*
* setReadOnly( obj, 'foo', 'bar' );
*
* try {
*     obj.foo = 'boop';
* } catch ( err ) {
*     console.error( err.message );
* }
*/

/**
* Evaluate the lognormal distribution cumulative distribution function (CDF).
*
* @module @stdlib/stats/base/dists/lognormal/cdf
*
* @example
* var cdf = require( '@stdlib/stats/base/dists/lognormal/cdf' );
*
* var y = cdf( 2.0, 0.0, 1.0 );
* // returns ~0.756
*
* y = cdf( 5.0, 10.0, 3.0 );
* // returns ~0.003
*
* var mycdf = cdf.factory( 3.0, 1.5 );
*
* y = mycdf( 1.0 );
* // returns ~0.023
*
* y = mycdf( 4.0 );
* // returns ~0.141
*/

/**
* Evaluate the natural exponential function.
*
* @module @stdlib/math/base/special/exp
*
* @example
* var exp = require( '@stdlib/math/base/special/exp' );
*
* var v = exp( 4.0 );
* // returns ~54.5982
*
* v = exp( -9.0 );
* // returns ~1.234e-4
*
* v = exp( 0.0 );
* // returns 1.0
*
* v = exp( NaN );
* // returns NaN
*/

/**
* Evaluate the natural logarithm of the probability density function (PDF) for a lognormal distribution.
*
* @module @stdlib/stats/base/dists/lognormal/logpdf
*
* @example
* var logpdf = require( '@stdlib/stats/base/dists/lognormal/logpdf' );
*
* var y = logpdf( 2.0, 0.0, 1.0 );
* // returns ~-1.852
*
* y = logpdf( 1.0, 0.0, 1.0 );
* // returns ~-0.919
*
* y = logpdf( 1.0, 3.0, 1.0 );
* // returns ~-5.419
*
* var mylogpdf = logpdf.factory( 4.0, 2.0 );
* y = mylogpdf( 10.0 );
* // returns ~-4.269
*
* y = mylogpdf( 2.0 );
* // returns ~-3.689
*/

/**
* Evaluate the probability density function (PDF) for a lognormal distribution.
*
* @module @stdlib/stats/base/dists/lognormal/pdf
*
* @example
* var pdf = require( '@stdlib/stats/base/dists/lognormal/pdf' );
*
* var y = pdf( 2.0, 0.0, 1.0 );
* // returns ~0.157
*
* y = pdf( 1.0, 0.0, 1.0 );
* // returns ~0.399
*
* y = pdf( 1.0, 3.0, 1.0 );
* // returns ~0.004
*
* var mypdf = pdf.factory( 4.0, 2.0 );
* y = mypdf( 10.0 );
* // returns ~0.014
*
* y = mypdf( 2.0 );
* // returns ~0.025
*/

/**
* Evaluate the quantile function for a lognormal distribution.
*
* @module @stdlib/stats/base/dists/lognormal/quantile
*
* @example
* var quantile = require( '@stdlib/stats/base/dists/lognormal/quantile' );
*
* var y = quantile( 0.8, 0.0, 1.0 );
* // returns ~2.32
*
* y = quantile( 0.5, 4.0, 2.0 );
* // returns ~54.598
*
* var myquantile = quantile.factory( 4.0, 2.0 );
*
* y = myquantile( 0.2 );
* // returns ~10.143
*
* y = myquantile( 0.8 );
* // returns ~293.901
*/

/**
* Evaluates a polynomial.
*
* ## Notes
*
* -   The implementation uses [Horner's rule][horners-method] for efficient computation.
*
* [horners-method]: https://en.wikipedia.org/wiki/Horner%27s_method
*
*
* @private
* @param {number} x - value at which to evaluate the polynomial
* @returns {number} evaluated polynomial
*/

/**
* Evaluates the cumulative distribution function (CDF) for a lognormal distribution with location parameter `mu` and scale parameter `sigma` at a value `x`.
*
* @param {number} x - input value
* @param {number} mu - location parameter
* @param {PositiveNumber} sigma - scale parameter
* @returns {Probability} evaluated CDF
*
* @example
* var y = cdf( 2.0, 0.0, 1.0 );
* // returns ~0.756
*
* @example
* var y = cdf( 5.0, 10.0, 3.0 );
* // returns ~0.003
*
* @example
* var y = cdf( 2.0, 0.0, NaN );
* // returns NaN
*
* @example
* var y = cdf( 2.0, NaN, 1.0 );
* // returns NaN
*
* @example
* var y = cdf( NaN, 0.0, 1.0 );
* // returns NaN
*/

/**
* Evaluates the cumulative distribution function (CDF).
*
* @name cdf
* @memberof LogNormal.prototype
* @type {Function}
* @param {number} x - input value
* @returns {number} evaluated CDF
* @see [cdf]{@link https://en.wikipedia.org/wiki/Cumulative_distribution_function}
*
* @example
* var lognormal = new LogNormal( 2.0, 4.0 );
*
* var v = lognormal.cdf( 0.5 );
* // returns ~0.25
*/

/**
* Evaluates the cumulative distribution function (CDF).
*
* @private
* @param {number} x - input value
* @returns {Probability} evaluated CDF
*/

/**
* Evaluates the natural exponential function.
*
* ## Method
*
* 1.  We reduce \\( x \\) to an \\( r \\) so that \\( |r| \leq 0.5 \cdot \ln(2) \approx 0.34658 \\). Given \\( x \\), we find an \\( r \\) and integer \\( k \\) such that
*
*     ```tex
*     \begin{align*}
*     x &= k \cdot \ln(2) + r \\
*     |r| &\leq 0.5 \cdot \ln(2)
*     \end{align*}
*     ```
*
*     <!-- <note> -->
*
*     \\( r \\) can be represented as \\( r = \mathrm{hi} - \mathrm{lo} \\) for better accuracy.
*
*     <!-- </note> -->
*
* 2.  We approximate of \\( e^{r} \\) by a special rational function on the interval \\(\[0,0.34658]\\):
*
*     ```tex
*     \begin{align*}
*     R\left(r^2\right) &= r \cdot \frac{ e^{r}+1 }{ e^{r}-1 } \\
*     &= 2 + \frac{r^2}{6} - \frac{r^4}{360} + \ldots
*     \end{align*}
*     ```
*
*     We use a special Remes algorithm on \\(\[0,0.34658]\\) to generate a polynomial of degree \\(5\\) to approximate \\(R\\). The maximum error of this polynomial approximation is bounded by \\(2^{-59}\\). In other words,
*
*     ```tex
*     R(z) \sim 2 + P_1 z + P_2 z^2 + P_3 z^3 + P_4 z^4 + P_5 z^5
*     ```
*
*     where \\( z = r^2 \\) and
*
*     ```tex
*     \left|  2 + P_1 z + \ldots + P_5 z^5  - R(z) \right| \leq 2^{-59}
*     ```
*
*     <!-- <note> -->
*
*     The values of \\( P_1 \\) to \\( P_5 \\) are listed in the source code.
*
*     <!-- </note> -->
*
*     The computation of \\( e^{r} \\) thus becomes
*
*     ```tex
*     \begin{align*}
*     e^{r} &= 1 + \frac{2r}{R-r} \\
*           &= 1 + r + \frac{r \cdot R_1(r)}{2 - R_1(r)}\ \text{for better accuracy}
*     \end{align*}
*     ```
*
*     where
*
*     ```tex
*     R_1(r) = r - P_1\ r^2 + P_2\ r^4 + \ldots + P_5\ r^{10}
*     ```
*
* 3.  We scale back to obtain \\( e^{x} \\). From step 1, we have
*
*     ```tex
*     e^{x} = 2^k e^{r}
*     ```
*
*
* ## Special Cases
*
* ```tex
* \begin{align*}
* e^\infty &= \infty \\
* e^{-\infty} &= 0 \\
* e^{\mathrm{NaN}} &= \mathrm{NaN} \\
* e^0 &= 1\ \mathrm{is\ exact\ for\ finite\ argument\ only}
* \end{align*}
* ```
*
* ## Notes
*
* -   According to an error analysis, the error is always less than \\(1\\) ulp (unit in the last place).
*
* -   For an IEEE double,
*
*     -   if \\(x > 7.09782712893383973096\mbox{e+}02\\), then \\(e^{x}\\) overflows
*     -   if \\(x < -7.45133219101941108420\mbox{e+}02\\), then \\(e^{x}\\) underflows
*
* -   The hexadecimal values included in the source code are the intended ones for the used constants. Decimal values may be used, provided that the compiler will convert from decimal to binary accurately enough to produce the intended hexadecimal values.
*
*
* @param {number} x - input value
* @returns {number} function value
*
* @example
* var v = exp( 4.0 );
* // returns ~54.5982
*
* @example
* var v = exp( -9.0 );
* // returns ~1.234e-4
*
* @example
* var v = exp( 0.0 );
* // returns 1.0
*
* @example
* var v = exp( NaN );
* // returns NaN
*/

/**
* Evaluates the natural logarithm of the probability density function (PDF) for a lognormal distribution with location parameter `mu` and scale parameter `sigma` at a value `x`.
*
* @param {number} x - input value
* @param {number} mu - location parameter
* @param {PositiveNumber} sigma - scale parameter
* @returns {number} evaluated logPDF
*
* @example
* var y = logpdf( 2.0, 0.0, 1.0 );
* // returns ~-1.852
*
* @example
* var y = logpdf( 1.0, 0.0, 1.0 );
* // returns ~-0.919
*
* @example
* var y = logpdf( 1.0, 3.0, 1.0 );
* // returns ~-5.419
*
* @example
* var y = logpdf( -1.0, 4.0, 2.0 );
* // returns -Infinity
*
* @example
* var y = logpdf( NaN, 0.0, 1.0 );
* // returns NaN
*
* @example
* var y = logpdf( 0.0, NaN, 1.0 );
* // returns NaN
*
* @example
* var y = logpdf( 0.0, 0.0, NaN );
* // returns NaN
*
* @example
* // Negative scale parameter:
* var y = logpdf( 2.0, 0.0, -1.0 );
* // returns NaN
*/

/**
* Evaluates the natural logarithm of the probability density function (PDF).
*
* @name logpdf
* @memberof LogNormal.prototype
* @type {Function}
* @param {number} x - input value
* @returns {number} evaluated PDF
* @see [pdf]{@link https://en.wikipedia.org/wiki/Probability_density_function}
*
* @example
* var lognormal = new LogNormal( 2.0, 4.0 );
*
* var v = lognormal.logpdf( 0.8 );
* // returns ~-2.237
*/

/**
* Evaluates the natural logarithm of the probability density function (PDF).
*
* @private
* @param {number} x - input value
* @returns {number} evaluated PDF
*/

/**
* Evaluates the probability density function (PDF) for a lognormal distribution with location parameter `mu` and scale parameter `sigma` at a value `x`.
*
* @param {number} x - input value
* @param {number} mu - location parameter
* @param {PositiveNumber} sigma - scale parameter
* @returns {number} evaluated PDF
*
* @example
* var y = pdf( 2.0, 0.0, 1.0 );
* // returns ~0.157
*
* @example
* var y = pdf( 1.0, 0.0, 1.0 );
* // returns ~0.399
*
* @example
* var y = pdf( 1.0, 3.0, 1.0 );
* // returns ~0.004
*
* @example
* var y = pdf( -1.0, 4.0, 2.0 );
* // returns 0.0
*
* @example
* var y = pdf( NaN, 0.0, 1.0 );
* // returns NaN
*
* @example
* var y = pdf( 0.0, NaN, 1.0 );
* // returns NaN
*
* @example
* var y = pdf( 0.0, 0.0, NaN );
* // returns NaN
*
* @example
* // Negative scale parameter:
* var y = pdf( 2.0, 0.0, -1.0 );
* // returns NaN
*/

/**
* Evaluates the probability density function (PDF).
*
* @name pdf
* @memberof LogNormal.prototype
* @type {Function}
* @param {number} x - input value
* @returns {number} evaluated PDF
* @see [pdf]{@link https://en.wikipedia.org/wiki/Probability_density_function}
*
* @example
* var lognormal = new LogNormal( 2.0, 4.0 );
*
* var v = lognormal.pdf( 0.8 );
* // returns ~0.107
*/

/**
* Evaluates the probability density function (PDF).
*
* @private
* @param {number} x - input value
* @returns {number} evaluated PDF
*/

/**
* Evaluates the quantile function for a lognormal distribution with location parameter `mu` and scale parameter `sigma` at a probability `p`.
*
* @param {Probability} p - input value
* @param {number} mu - location parameter
* @param {PositiveNumber} sigma - scale parameter
* @returns {number} evaluated quantile function
*
* @example
* var y = quantile( 0.8, 0.0, 1.0 );
* // returns ~2.32
*
* @example
* var y = quantile( 0.5, 4.0, 2.0 );
* // returns ~54.598
*
* @example
* var y = quantile( 1.1, 0.0, 1.0 );
* // returns NaN
*
* @example
* var y = quantile( -0.2, 0.0, 1.0 );
* // returns NaN
*
* @example
* var y = quantile( NaN, 0.0, 1.0 );
* // returns NaN
*
* @example
* var y = quantile( 0.0, NaN, 1.0 );
* // returns NaN
*
* @example
* var y = quantile( 0.0, 0.0, NaN );
* // returns NaN
*
* @example
* // Negative scale parameter:
* var y = quantile( 0.5, 0.0, -1.0 );
* // returns NaN
*/

/**
* Evaluates the quantile function.
*
* @name quantile
* @memberof LogNormal.prototype
* @type {Function}
* @param {Probability} p - input probability
* @returns {number} evaluated quantile function
* @see [quantile function]{@link https://en.wikipedia.org/wiki/Quantile_function}
*
* @example
* var lognormal = new LogNormal( 2.0, 4.0 );
*
* var v = lognormal.quantile( 0.5 );
* // returns ~7.389
*/

/**
* Evaluates the quantile function.
*
* @private
* @param {Probability} p - input probability
* @returns {number} evaluated quantile function
*/

/**
* Generate a linearly spaced numeric array.
*
* @module @stdlib/math/utils/linspace
*
* @example
* var linspace = require( '@stdlib/math/utils/linspace' );
*
* var arr = linspace( 0, 100, 6 );
* // returns [ 0, 20, 40, 60, 80, 100 ]
*/

/**
* Generates a linearly spaced numeric array.
*
* @param {number} x1 - first array value
* @param {number} x2 - last array value
* @param {NonNegativeInteger} [len=100] - length of output array
* @throws {TypeError} first argument must be numeric
* @throws {TypeError} second argument must be numeric
* @throws {TypeError} third argument must be a nonnegative integer
* @returns {Array} linearly spaced numeric array
*
* @example
* var arr = linspace( 0, 100, 6 );
* // returns [ 0, 20, 40, 60, 80, 100 ]
*/

/**
* Lognormal distribution constructor.
*
* @constructor
* @param {number} [mu=0.0] - location parameter
* @param {PositiveNumber} [sigma=1.0] - scale parameter
* @throws {TypeError} `sigma` must be a positive number
* @returns {LogNormal} distribution instance
*
* @example
* var lognormal = new LogNormal( 1.0, 1.0 );
*
* var y = lognormal.cdf( 1.5 );
* // returns ~0.276
*
* var v = lognormal.mean;
* // returns ~4.482
*/

/**
* Lognormal distribution constructor.
*
* @module @stdlib/stats/base/dists/lognormal/ctor
*
* @example
* var LogNormal = require( '@stdlib/stats/base/dists/lognormal/ctor' );
*
* var lognormal = new LogNormal( 1.0, 1.0 );
*
* var y = lognormal.cdf( 1.5 );
* // returns ~0.276
*
* var mean = lognormal.mean;
* // returns ~4.482
*/

/**
* Lognormal distribution differential entropy.
*
* @name entropy
* @memberof LogNormal.prototype
* @type {number}
* @see [differential entropy]{@link https://en.wikipedia.org/wiki/Entropy_%28information_theory%29}
*
* @example
* var lognormal = new LogNormal( 4.0, 12.0 );
*
* var v = lognormal.entropy;
* // returns ~7.904
*/

/**
* Lognormal distribution entropy.
*
* @module @stdlib/stats/base/dists/lognormal/entropy
*
* @example
* var entropy = require( '@stdlib/stats/base/dists/lognormal/entropy' );
*
* var y = entropy( 0.0, 1.0 );
* // returns ~1.419
*
* y = entropy( 4.0, 2.0 );
* // returns ~6.112
*/

/**
* Lognormal distribution excess kurtosis.
*
* @module @stdlib/stats/base/dists/lognormal/kurtosis
*
* @example
* var kurtosis = require( '@stdlib/stats/base/dists/lognormal/kurtosis' );
*
* var y = kurtosis( 0.0, 1.0 );
* // returns ~110.936
*
* y = kurtosis( 4.0, 2.0 );
* // returns ~9220556.977
*/

/**
* Lognormal distribution excess kurtosis.
*
* @name kurtosis
* @memberof LogNormal.prototype
* @type {number}
* @see [kurtosis]{@link https://en.wikipedia.org/wiki/Kurtosis}
*
* @example
* var lognormal = new LogNormal( 4.0, 12.0 );
*
* var v = lognormal.kurtosis;
* // returns 1.4243659274306933e+250
*/

/**
* Lognormal distribution expected value.
*
* @module @stdlib/stats/base/dists/lognormal/mean
*
* @example
* var mean = require( '@stdlib/stats/base/dists/lognormal/mean' );
*
* var y = mean( 0.0, 1.0 );
* // returns ~1.649
*
* y = mean( 4.0, 2.0 );
* // returns ~403.429
*/

/**
* Lognormal distribution expected value.
*
* @name mean
* @memberof LogNormal.prototype
* @type {number}
* @see [expected value]{@link https://en.wikipedia.org/wiki/Expected_value}
*
* @example
* var lognormal = new LogNormal( 4.0, 12.0 );
*
* var v = lognormal.mean;
* // returns 1.0148003881138887e+33
*/

/**
* Lognormal distribution median.
*
* @module @stdlib/stats/base/dists/lognormal/median
*
* @example
* var median = require( '@stdlib/stats/base/dists/lognormal/median' );
*
* var y = median( 0.0, 1.0 );
* // returns 1.0
*
* y = median( 4.0, 2.0 );
* // returns ~54.598
*/

/**
* Lognormal distribution median.
*
* @name median
* @memberof LogNormal.prototype
* @type {number}
* @see [median]{@link https://en.wikipedia.org/wiki/Median}
*
* @example
* var lognormal = new LogNormal( 4.0, 12.0 );
*
* var v = lognormal.median;
* // returns ~54.598
*/

/**
* Lognormal distribution mode.
*
* @module @stdlib/stats/base/dists/lognormal/mode
*
* @example
* var mode = require( '@stdlib/stats/base/dists/lognormal/mode' );
*
* var y = mode( 0.0, 1.0 );
* // returns ~0.368
*
* y = mode( 4.0, 2.0 );
* // returns 1.0
*/

/**
* Lognormal distribution mode.
*
* @name mode
* @memberof LogNormal.prototype
* @type {number}
* @see [mode]{@link https://en.wikipedia.org/wiki/Mode_%28statistics%29}
*
* @example
* var lognormal = new LogNormal( 4.0, 12.0 );
*
* var v = lognormal.mode;
* // returns 1.580420060273613e-61
*/

/**
* Lognormal distribution skewness.
*
* @module @stdlib/stats/base/dists/lognormal/skewness
*
* @example
* var skewness = require( '@stdlib/stats/base/dists/lognormal/skewness' );
*
* var y = skewness( 0.0, 1.0 );
* // returns ~6.185
*
* y = skewness( 4.0, 2.0 );
* // returns ~414.359
*/

/**
* Lognormal distribution skewness.
*
* @name skewness
* @memberof LogNormal.prototype
* @type {number}
* @see [skewness]{@link https://en.wikipedia.org/wiki/Skewness}
*
* @example
* var lognormal = new LogNormal( 4.0, 12.0 );
*
* var v = lognormal.skewness;
* // returns 6.421080152185613e+93
*/

/**
* Lognormal distribution standard deviation.
*
* @module @stdlib/stats/base/dists/lognormal/stdev
*
* @example
* var stdev = require( '@stdlib/stats/base/dists/lognormal/stdev' );
*
* var y = stdev( 0.0, 1.0 );
* // returns ~2.161
*
* y = stdev( 4.0, 2.0 );
* // returns ~2953.533
*/

/**
* Lognormal distribution standard deviation.
*
* @name stdev
* @memberof LogNormal.prototype
* @type {NonNegativeNumber}
* @see [standard deviation]{@link https://en.wikipedia.org/wiki/Standard_deviation}
*
* @example
* var lognormal = new LogNormal( 4.0, 12.0 );
*
* var v = lognormal.stdev;
* // returns 1.886180808490652e+64
*/

/**
* Lognormal distribution variance.
*
* @module @stdlib/stats/base/dists/lognormal/variance
*
* @example
* var variance = require( '@stdlib/stats/base/dists/lognormal/variance' );
*
* var y = variance( 0.0, 1.0 );
* // returns ~4.671
*
* y = variance( 4.0, 2.0 );
* // returns ~8723355.729
*/

/**
* Lognormal distribution variance.
*
* @name variance
* @memberof LogNormal.prototype
* @type {NonNegativeNumber}
* @see [variance]{@link https://en.wikipedia.org/wiki/Variance}
*
* @example
* var lognormal = new LogNormal( 4.0, 12.0 );
*
* var v = lognormal.variance;
* // returns 3.55767804231845e+128
*/

/**
* Returns a function for evaluating the cumulative distribution function (CDF) for a lognormal distribution with location parameter `mu` and scale parameter `sigma`.
*
* @param {number} mu - location parameter
* @param {PositiveNumber} sigma - scale parameter
* @returns {Function} CDF
*
* @example
* var cdf = factory( 3.0, 1.5 );
*
* var y = cdf( 1.0 );
* // returns ~0.023
*
* y = cdf( 4.0 );
* // returns ~0.141
*/

/**
* Returns a function for evaluating the natural logarithm of the probability density function (PDF) for a lognormal distribution with location parameter `mu` and scale parameter `sigma`.
*
* @param {number} mu - location parameter
* @param {PositiveNumber} sigma - scale parameter
* @returns {Function} logPDF
*
* @example
* var logpdf = factory( 4.0, 2.0 );
* var y = logpdf( 10.0 );
* // returns ~-4.275
*
* y = logpdf( 2.0 );
* // returns ~-3.672
*/

/**
* Returns a function for evaluating the probability density function (PDF) for a lognormal distribution with location parameter `mu` and scale parameter `sigma`.
*
* @param {number} mu - location parameter
* @param {PositiveNumber} sigma - scale parameter
* @returns {Function} PDF
*
* @example
* var pdf = factory( 4.0, 2.0 );
* var y = pdf( 10.0 );
* // returns ~0.014
*
* y = pdf( 2.0 );
* // returns ~0.025
*/

/**
* Returns a function for evaluating the quantile function for a lognormal distribution with location parameter `mu` and scale parameter `sigma`.
*
* @param {number} mu - location parameter
* @param {PositiveNumber} sigma - scale parameter
* @returns {Function} quantile function
*
* @example
* var quantile = factory( 4.0, 2.0 );
* var y = quantile( 0.5 );
* // returns ~54.598
*
* y = quantile( 0.8 );
* // returns ~293.901
*/

/**
* Returns an accumulator function which incrementally computes an arithmetic mean.
*
* ## Method
*
* -   This implementation uses [Welford's method][algorithms-variance] for efficient computation, which can be derived as follows
*
*     ```tex
*     \begin{align*}
*     \mu_n &= \frac{1}{n} \sum_{i=0}^{n-1} x_i \\
*           &= \frac{1}{n} \biggl(x_{n-1} + \sum_{i=0}^{n-2} x_i \biggr) \\
*           &= \frac{1}{n} (x_{n-1} + (n-1)\mu_{n-1}) \\
*           &= \mu_{n-1} + \frac{1}{n} (x_{n-1} - \mu_{n-1})
*     \end{align*}
*     ```
*
* [algorithms-variance]: https://en.wikipedia.org/wiki/Algorithms_for_calculating_variance
*
* @returns {Function} accumulator function
*
* @example
* var accumulator = incrmean();
*
* var mu = accumulator();
* // returns null
*
* mu = accumulator( 2.0 );
* // returns 2.0
*
* mu = accumulator( -5.0 );
* // returns -1.5
*
* mu = accumulator();
* // returns -1.5
*/

/**
* Returns the differential entropy for a lognormal distribution with location `mu` and scale `sigma`.
*
* @param {number} mu - location parameter
* @param {PositiveNumber} sigma - scale parameter
* @returns {number} entropy
*
* @example
* var y = entropy( 0.0, 1.0 );
* // returns ~1.419
*
* @example
* var y = entropy( 5.0, 2.0 );
* // returns ~7.112
*
* @example
* var y = entropy( NaN, 1.0 );
* // returns NaN
*
* @example
* var y = entropy( 0.0, NaN );
* // returns NaN
*
* @example
* var y = entropy( 0.0, 0.0 );
* // returns NaN
*/

/**
* Returns the excess kurtosis for a lognormal distribution with location `mu` and scale `sigma`.
*
* @param {number} mu - location parameter
* @param {PositiveNumber} sigma - scale parameter
* @returns {number} excess kurtosis
*
* @example
* var y = kurtosis( 0.0, 1.0 );
* // returns ~110.936
*
* @example
* var y = kurtosis( 5.0, 2.0 );
* // returns ~9220556.977
*
* @example
* var y = kurtosis( NaN, 1.0 );
* // returns NaN
*
* @example
* var y = kurtosis( 0.0, NaN );
* // returns NaN
*
* @example
* var y = kurtosis( 0.0, 0.0 );
* // returns NaN
*/

/**
* Returns the expected value for a lognormal distribution with location `mu` and scale `sigma`.
*
* @param {number} mu - location parameter
* @param {PositiveNumber} sigma - scale parameter
* @returns {NonNegativeNumber} expected value
*
* @example
* var y = mean( 0.0, 1.0 );
* // returns ~1.649
*
* @example
* var y = mean( 5.0, 2.0 );
* // returns ~1096.633
*
* @example
* var y = mean( NaN, 1.0 );
* // returns NaN
*
* @example
* var y = mean( 0.0, NaN );
* // returns NaN
*
* @example
* var y = mean( 0.0, 0.0 );
* // returns NaN
*/

/**
* Returns the median for a lognormal distribution with location `mu` and scale `sigma`.
*
* @param {number} mu - location parameter
* @param {PositiveNumber} sigma - scale parameter
* @returns {NonNegativeNumber} median
*
* @example
* var y = median( 0.0, 1.0 );
* // returns 1.0
*
* @example
* var y = median( 5.0, 2.0 );
* // returns ~148.413
*
* @example
* var y = median( NaN, 1.0 );
* // returns NaN
*
* @example
* var y = median( 0.0, NaN );
* // returns NaN
*
* @example
* var y = median( 0.0, 0.0 );
* // returns NaN
*/

/**
* Returns the mode for a lognormal distribution with location `mu` and scale `sigma`.
*
* @param {number} mu - location parameter
* @param {PositiveNumber} sigma - scale parameter
* @returns {NonNegativeNumber} mode
*
* @example
* var y = mode( 0.0, 1.0 );
* // returns ~0.368
*
* @example
* var y = mode( 5.0, 2.0 );
* // returns ~2.718
*
* @example
* var y = mode( NaN, 1.0 );
* // returns NaN
*
* @example
* var y = mode( 0.0, NaN );
* // returns NaN
*
* @example
* var y = mode( 0.0, 0.0 );
* // returns NaN
*/

/**
* Returns the skewness for a lognormal distribution with location `mu` and scale `sigma`.
*
* @param {number} mu - location parameter
* @param {PositiveNumber} sigma - scale parameter
* @returns {NonNegativeNumber} skewness
*
* @example
* var y = skewness( 0.0, 1.0 );
* // returns ~6.185
*
* @example
* var y = skewness( 5.0, 2.0 );
* // returns ~414.359
*
* @example
* var y = skewness( NaN, 1.0 );
* // returns NaN
*
* @example
* var y = skewness( 0.0, NaN );
* // returns NaN
*
* @example
* var y = skewness( 0.0, 0.0 );
* // returns NaN
*/

/**
* Returns the standard deviation for a lognormal distribution with location `mu` and scale `sigma`.
*
* @param {number} mu - location parameter
* @param {PositiveNumber} sigma - scale parameter
* @returns {NonNegativeNumber} standard deviation
*
* @example
* var y = stdev( 0.0, 1.0 );
* // returns ~2.161
*
* @example
* var y = stdev( 5.0, 2.0 );
* // returns ~8028.534
*
* @example
* var y = stdev( NaN, 1.0 );
* // returns NaN
*
* @example
* var y = stdev( 0.0, NaN );
* // returns NaN
*
* @example
* var y = stdev( 0.0, 0.0 );
* // returns NaN
*/

/**
* Returns the variance for a lognormal distribution with location `mu` and scale `sigma`.
*
* @param {number} mu - location parameter
* @param {PositiveNumber} sigma - scale parameter
* @returns {NonNegativeNumber} variance
*
* @example
* var y = variance( 0.0, 1.0 );
* // returns ~4.671
*
* @example
* var y = variance( 5.0, 2.0 );
* // returns ~64457364.853
*
* @example
* var y = variance( NaN, 1.0 );
* // returns NaN
*
* @example
* var y = variance( 0.0, NaN );
* // returns NaN
*
* @example
* var y = variance( 0.0, 0.0 );
* // returns NaN
*/

/**
* Round a numeric value toward positive infinity.
*
* @module @stdlib/math/base/special/ceil
*
* @example
* var ceil = require( '@stdlib/math/base/special/ceil' );
*
* var v = ceil( -4.2 );
* // returns -4.0
*
* v = ceil( 9.99999 );
* // returns 10.0
*
* v = ceil( 0.0 );
* // returns 0.0
*
* v = ceil( NaN );
* // returns NaN
*/

/**
* Round a numeric value toward zero.
*
* @module @stdlib/math/base/special/trunc
*
* @example
* var trunc = require( '@stdlib/math/base/special/trunc' );
*
* var v = trunc( -4.2 );
* // returns -4.0
*
* v = trunc( 9.99999 );
* // returns 9.0
*
* v = trunc( 0.0 );
* // returns 0.0
*
* v = trunc( -0.0 );
* // returns -0.0
*
* v = trunc( NaN );
* // returns NaN
*
* v = trunc( Infinity );
* // returns Infinity
*
* v = trunc( -Infinity );
* // returns -Infinity
*/

/**
* Rounds a numeric value toward positive infinity.
*
* @param {number} x - input value
* @returns {number} rounded value
*
* @example
* var v = ceil( -4.2 );
* // returns -4.0
*
* @example
* var v = ceil( 9.99999 );
* // returns 10.0
*
* @example
* var v = ceil( 0.0 );
* // returns 0.0
*
* @example
* var v = ceil( NaN );
* // returns NaN
*/

/**
* Rounds a numeric value toward zero.
*
* @param {number} x - input value
* @returns {number} rounded value
*
* @example
* var v = trunc( -4.2 );
* // returns -4.0
*
* @example
* var v = trunc( 9.99999 );
* // returns 9.0
*
* @example
* var v = trunc( 0.0 );
* // returns 0.0
*
* @example
* var v = trunc( -0.0 );
* // returns -0.0
*
* @example
* var v = trunc( NaN );
* // returns NaN
*
* @example
* var v = trunc( Infinity );
* // returns Infinity
*
* @example
* var v = trunc( -Infinity );
* // returns -Infinity
*/

/**
* Square root of the mathematical constant `π` times `2`.
*
* @constant
* @type {number}
* @default 2.5066282746310007
* @see [Wikipedia]{@link https://en.wikipedia.org/wiki/Pi}
*/

/**
* Square root of the mathematical constant `π` times `2`.
*
* @module @stdlib/constants/math/float64-sqrt-two-pi
* @type {number}
*
* @example
* var SQRT_TWO_PI = require( '@stdlib/constants/math/float64-sqrt-two-pi' );
* // returns 2.5066282746310007
*/

/**
* Test if a value is a positive number.
*
* @module @stdlib/assert/is-positive-number
*
* @example
* var isPositiveNumber = require( '@stdlib/assert/is-positive-number' );
*
* var bool = isPositiveNumber( 5.0 );
* // returns true
*
* bool = isPositiveNumber( new Number( 5.0 ) );
* // returns true
*
* bool = isPositiveNumber( 3.14 );
* // returns true
*
* bool = isPositiveNumber( -5.0 );
* // returns false
*
* bool = isPositiveNumber( null );
* // returns false
*
* @example
* var isPositiveNumber = require( '@stdlib/assert/is-positive-number' ).isPrimitive;
*
* var bool = isPositiveNumber( 3.0 );
* // returns true
*
* bool = isPositiveNumber( new Number( 3.0 ) );
* // returns false
*
* @example
* var isPositiveNumber = require( '@stdlib/assert/is-positive-number' ).isObject;
*
* var bool = isPositiveNumber( 3.0 );
* // returns false
*
* bool = isPositiveNumber( new Number( 3.0 ) );
* // returns true
*/

/**
* Tests if a value is a number object having a positive value.
*
* @param {*} value - value to test
* @returns {boolean} boolean indicating if a value is a number object having a positive value
*
* @example
* var bool = isPositiveNumber( 3.0 );
* // returns false
*
* @example
* var bool = isPositiveNumber( new Number( 3.0 ) );
* // returns true
*/

/**
* Tests if a value is a number primitive having a positive value.
*
* @param {*} value - value to test
* @returns {boolean} boolean indicating if a value is a number primitive having a positive value
*
* @example
* var bool = isPositiveNumber( 3.0 );
* // returns true
*
* @example
* var bool = isPositiveNumber( new Number( 3.0 ) );
* // returns false
*/

/**
* Tests if a value is a positive number.
*
* @param {*} value - value to test
* @returns {boolean} boolean indicating whether value is a positive number
*
* @example
* var bool = isPositiveNumber( 5.0 );
* // returns true
*
* @example
* var bool = isPositiveNumber( new Number( 5.0 ) );
* // returns true
*
* @example
* var bool = isPositiveNumber( 3.14 );
* // returns true
*
* @example
* var bool = isPositiveNumber( -5.0 );
* // returns false
*
* @example
* var bool = isPositiveNumber( null );
* // returns false
*/

/**
* Top-level namespace.
*
* @namespace lognormal
*/

/***/

// Build the output array...

// Calculate the increment:

// EXPORTS //

// FUNCTIONS //

// MAIN //

// MODULES //

// Reduce and compute `r = hi - lo` for extra precision.

// TODO: implementation (?)

// eslint-disable-line stdlib/no-builtin-math
