# doc-cache created by Octave 11.2.0
# name: cache
# type: cell
# rows: 3
# columns: 176
# name: <cell-element>
# type: sq_string
# elements: 1
# length: 7
betacdf


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 997
statistics: p = betacdf ( x , a , b )
statistics: p = betacdf ( x , a , b , 'upper' )

Beta cumulative distribution function (CDF).

For each element of x , compute the cumulative distribution function of
the Beta distribution with shape parameters a and b . The size of
p is the common size of x , a , and b . A scalar input
functions as a constant matrix of the same size as the other inputs.

p = betacdf ( x , a , b , "upper") computes the
upper tail probability of the Beta distribution with parameters a and
b , at the values in x .

Further information about the Beta distribution can be found at
https://en.wikipedia.org/wiki/Beta_distribution

Input arguments must be double or single ; integer, logical,
and character arrays are rejected. MATLAB accepts a character array and
evaluates it at the character codes, which Octave deliberately does not,
since a character array is an integer type and integers are refused too.

See also:
betainv,
betapdf,
betarnd,
betafit,
betalike,
betastat


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 44
Beta cumulative distribution function (CDF).



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 7
betainv


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 802
statistics: x = betainv ( p , a , b )

Inverse of the Beta distribution (iCDF).

For each element of p , compute the quantile (the inverse of the CDF)
of the Beta distribution with shape parameters a and b . The size
of x is the common size of x , a , and b . A scalar
input functions as a constant matrix of the same size as the other inputs.

Further information about the Beta distribution can be found at
https://en.wikipedia.org/wiki/Beta_distribution

Input arguments must be double or single ; integer, logical,
and character arrays are rejected. MATLAB accepts a character array and
evaluates it at the character codes, which Octave deliberately does not,
since a character array is an integer type and integers are refused too.

See also:
betacdf,
betapdf,
betarnd,
betafit,
betalike,
betastat


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 40
Inverse of the Beta distribution (iCDF).



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 7
betapdf


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 803
statistics: y = betapdf ( x , a , b )

Beta probability density function (PDF).

For each element of x , compute the probability density function (PDF)
of the Beta distribution with shape parameters a and b . The size
of y is the common size of x , a , and b . A scalar
input functions as a constant matrix of the same size as the other inputs.

Further information about the Beta distribution can be found at
https://en.wikipedia.org/wiki/Beta_distribution

Input arguments must be double or single ; integer, logical,
and character arrays are rejected. MATLAB accepts a character array and
evaluates it at the character codes, which Octave deliberately does not,
since a character array is an integer type and integers are refused too.

See also:
betacdf,
betainv,
betarnd,
betafit,
betalike,
betastat


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 40
Beta probability density function (PDF).



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 7
betarnd


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1003
statistics: r = betarnd ( a , b )
statistics: r = betarnd ( a , b , rows )
statistics: r = betarnd ( a , b , rows , cols , &hellip;)
statistics: r = betarnd ( a , b , [ sz ])

Random arrays from the Beta distribution.

r = betarnd ( a , b ) returns an array of random
numbers chosen from the Beta distribution with shape parameters a and
b . The size of r is the common size of a and b .
A scalar input functions as a constant matrix of the same size as the other
inputs.

When called with a single size argument, betarnd returns a square
matrix with the dimension specified. When called with more than one scalar
argument, the first two arguments are taken as the number of rows and columns
and any further arguments specify additional matrix dimensions. The size may
also be specified with a row vector of dimensions, sz .

Further information about the Beta distribution can be found at
https://en.wikipedia.org/wiki/Beta_distribution

See also:
betacdf,
betainv,
betapdf,
betafit,
betalike,
betastat


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 41
Random arrays from the Beta distribution.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 7
binocdf


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1171
statistics: p = binocdf ( x , n , ps )
statistics: p = binocdf ( x , n , ps , 'upper' )

Binomial cumulative distribution function (CDF).

For each element of x , compute the cumulative distribution function
(CDF) of the binomial distribution with parameters n and ps ,
where n is the number of trials and ps is the probability of
success. The size of p is the common size of x , n , and
ps . A scalar input functions as a constant matrix of the same size as
the other inputs.

p = binocdf ( x , n , ps , "upper") computes the
upper tail probability of the binomial distribution with parameters
n and ps , at the values in x .

Further information about the binomial distribution can be found at
https://en.wikipedia.org/wiki/Binomial_distribution

Input arguments must be double , single , or an integer type;
logical and character arrays are rejected. Integer input is promoted to
double , so the result is always a probability. MATLAB is
inconsistent here: for several of the discrete distributions it returns the
result in the integer class of the input, truncating a probability to
0 or 1 .

See also:
binoinv,
binopdf,
binornd,
binofit,
binolike,
binostat,
binotest


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 48
Binomial cumulative distribution function (CDF).



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 7
binoinv


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 915
statistics: x = binoinv ( p , n , ps )

Inverse of the Binomial cumulative distribution function (iCDF).

For each element of p , compute the quantile (the inverse of the CDF) of
the binomial distribution with parameters n and ps , where n
is the number of trials and ps is the probability of success. The size
of x is the common size of p , n , and ps . A scalar
input functions as a constant matrix of the same size as the other inputs.

Further information about the binomial distribution can be found at
https://en.wikipedia.org/wiki/Binomial_distribution

Input arguments must be double or single ; integer, logical,
and character arrays are rejected. MATLAB accepts a character array and
evaluates it at the character codes, which Octave deliberately does not,
since a character array is an integer type and integers are refused too.

See also:
binocdf,
binopdf,
binornd,
binofit,
binolike,
binostat,
binotest


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 64
Inverse of the Binomial cumulative distribution function (iCDF).



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 7
binopdf


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1176
statistics: y = binopdf ( x , n , ps )

Binomial probability density function (PDF).

For each element of x , compute the probability density function (PDF)
of the binomial distribution with parameters n and ps , where
n is the number of trials and ps is the probability of success.
The size of y is the common size of x , n , and ps . A
scalar input functions as a constant matrix of the same size as the other
inputs.

Matlab incompatibility: Octave&rsquo;s binopdf does not allow complex
input values. Matlab 2021b returns values for complex inputs despite the
documentation indicates integer and real value inputs are required.

Further information about the binomial distribution can be found at
https://en.wikipedia.org/wiki/Binomial_distribution

Input arguments must be double , single , or an integer type;
logical and character arrays are rejected. Integer input is promoted to
double , so the result is always a probability. MATLAB is
inconsistent here: for several of the discrete distributions it returns the
result in the integer class of the input, truncating a probability to
0 or 1 .

See also:
binocdf,
binoinv,
binornd,
binofit,
binolike,
binostat,
binotest


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 44
Binomial probability density function (PDF).



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 7
binornd


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1093
statistics: r = binornd ( n , ps )
statistics: r = binornd ( n , ps , rows )
statistics: r = binornd ( n , ps , rows , cols , &hellip;)
statistics: r = binornd ( n , ps , [ sz ])

Random arrays from the Binomial distribution.

r = binornd ( n , ps ) returns a matrix of random
samples from the binomial distribution with parameters n and ps ,
where n is the number of trials and ps is the probability of
success. The size of r is the common size of n and ps .
A scalar input functions as a constant matrix of the same size as the other
inputs.

When called with a single size argument, binornd returns a square
matrix with the dimension specified. When called with more than one scalar
argument, the first two arguments are taken as the number of rows and columns
and any further arguments specify additional matrix dimensions. The size may
also be specified with a row vector of dimensions, sz .

Further information about the binomial distribution can be found at
https://en.wikipedia.org/wiki/Binomial_distribution

See also:
binocdf,
binoinv,
binopdf,
binofit,
binolike,
binostat,
binotest


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 45
Random arrays from the Binomial distribution.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 7
bisacdf


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1131
statistics: p = bisacdf ( x , beta , gamma )
statistics: p = bisacdf ( x , beta , gamma , 'upper' )

Birnbaum-Saunders cumulative distribution function (CDF).

For each element of x , compute the cumulative distribution function
(CDF) of the Birnbaum-Saunders distribution with scale parameter beta
and shape parameter gamma . The size of p is the common size of
x , beta and gamma . A scalar input functions as a constant
matrix of the same size as the other inputs.

p = bisacdf ( x , beta , gamma , "upper")
computes the upper tail probability of the Birnbaum-Saunders distribution
with parameters beta and gamma , at the values in x .

Further information about the Birnbaum-Saunders distribution can be found at
https://en.wikipedia.org/wiki/Birnbaum%E2%80%93Saunders_distribution

Input arguments must be double or single ; integer, logical,
and character arrays are rejected. MATLAB accepts a character array and
evaluates it at the character codes, which Octave deliberately does not,
since a character array is an integer type and integers are refused too.

See also:
bisainv,
bisapdf,
bisarnd,
bisafit,
bisalike,
bisastat


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 57
Birnbaum-Saunders cumulative distribution function (CDF).



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 7
bisainv


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 918
statistics: x = bisainv ( p , beta , gamma )

Inverse of the Birnbaum-Saunders cumulative distribution function (iCDF).

For each element of p , compute the quantile (the inverse of the CDF) of
the Birnbaum-Saunders distribution with scale parameter beta and shape
parameter gamma . The size of x is the common size of p ,
beta , and gamma . A scalar input functions as a constant matrix
of the same size as the other inputs.

Further information about the Birnbaum-Saunders distribution can be found at
https://en.wikipedia.org/wiki/Birnbaum%E2%80%93Saunders_distribution

Input arguments must be double or single ; integer, logical,
and character arrays are rejected. MATLAB accepts a character array and
evaluates it at the character codes, which Octave deliberately does not,
since a character array is an integer type and integers are refused too.

See also:
bisacdf,
bisapdf,
bisarnd,
bisafit,
bisalike,
bisastat


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 73
Inverse of the Birnbaum-Saunders cumulative distribution function (iCDF).



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 7
bisapdf


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 899
statistics: y = bisapdf ( x , beta , gamma )

Birnbaum-Saunders probability density function (PDF).

For each element of x , compute the probability density function (PDF)
of the Birnbaum-Saunders distribution with scale parameter beta and
shape parameter gamma . The size of y is the common size of
x , beta , and gamma . A scalar input functions as a constant
matrix of the same size as the other inputs.

Further information about the Birnbaum-Saunders distribution can be found at
https://en.wikipedia.org/wiki/Birnbaum%E2%80%93Saunders_distribution

Input arguments must be double or single ; integer, logical,
and character arrays are rejected. MATLAB accepts a character array and
evaluates it at the character codes, which Octave deliberately does not,
since a character array is an integer type and integers are refused too.

See also:
bisacdf,
bisainv,
bisarnd,
bisafit,
bisalike,
bisastat


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 53
Birnbaum-Saunders probability density function (PDF).



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 7
bisarnd


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1127
statistics: r = bisarnd ( beta , gamma )
statistics: r = bisarnd ( beta , gamma , rows )
statistics: r = bisarnd ( beta , gamma , rows , cols , &hellip;)
statistics: r = bisarnd ( beta , gamma , [ sz ])

Random arrays from the Birnbaum-Saunders distribution.

r = bisarnd ( beta , gamma ) returns an array of
random numbers chosen from the Birnbaum-Saunders distribution with scale
parameter beta and shape parameter gamma . The size of r is
the common size of beta and gamma . A scalar input functions as a
constant matrix of the same size as the other inputs.

When called with a single size argument, bisarnd returns a square
matrix with the dimension specified. When called with more than one scalar
argument, the first two arguments are taken as the number of rows and columns
and any further arguments specify additional matrix dimensions. The size may
also be specified with a row vector of dimensions, sz .

Further information about the Birnbaum-Saunders distribution can be found at
https://en.wikipedia.org/wiki/Birnbaum%E2%80%93Saunders_distribution

See also:
bisacdf,
bisainv,
bisapdf,
bisafit,
bisalike,
bisastat


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 54
Random arrays from the Birnbaum-Saunders distribution.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 7
burrcdf


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1130
statistics: p = burrcdf ( x , lambda , c , k )
statistics: p = burrcdf ( x , lambda , c , k , 'upper' )

Burr type XII cumulative distribution function (CDF).

For each element of x , compute the cumulative distribution function
(CDF) of the Burr type XII distribution with scale parameter lambda ,
first shape parameter c , and second shape parameter k . The size
of p is the common size of x , lambda , c , and k .
A scalar input functions as a constant matrix of the same size as the other
inputs.

p = burrcdf ( x , lambda , c , k , "upper")
computes the upper tail probability of the Burr type XII distribution with
parameters lambda , c and k , at the values in x .

Further information about the Burr distribution can be found at
https://en.wikipedia.org/wiki/Burr_distribution

Input arguments must be double or single ; integer, logical,
and character arrays are rejected. MATLAB accepts a character array and
evaluates it at the character codes, which Octave deliberately does not,
since a character array is an integer type and integers are refused too.

See also:
burrinv,
burrpdf,
burrrnd,
burrfit,
burrlike,
burrstat


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 53
Burr type XII cumulative distribution function (CDF).



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 7
burrinv


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 913
statistics: x = burrinv ( p , lambda , c , k )

Inverse of the Burr type XII cumulative distribution function (iCDF).

For each element of p , compute the quantile (the inverse of the CDF) of
the Burr type XII distribution with scale parameter lambda , first shape
parameter c , and second shape parameter k . The size of x
is the common size of p , lambda , c , and k . A scalar
input functions as a constant matrix of the same size as the other inputs.

Further information about the Burr distribution can be found at
https://en.wikipedia.org/wiki/Burr_distribution

Input arguments must be double or single ; integer, logical,
and character arrays are rejected. MATLAB accepts a character array and
evaluates it at the character codes, which Octave deliberately does not,
since a character array is an integer type and integers are refused too.

See also:
burrcdf,
burrpdf,
burrrnd,
burrfit,
burrlike,
burrstat


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 69
Inverse of the Burr type XII cumulative distribution function (iCDF).



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 7
burrpdf


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 894
statistics: y = burrpdf ( x , lambda , c , k )

Burr type XII probability density function (PDF).

For each element of x , compute the probability density function (PDF)
of the Burr type XII distribution with scale parameter lambda , first
shape parameter c , and second shape parameter k . The size of
y is the common size of x , lambda , c , and k .
A scalar input functions as a constant matrix of the same size as the other
inputs.

Further information about the Burr distribution can be found at
https://en.wikipedia.org/wiki/Burr_distribution

Input arguments must be double or single ; integer, logical,
and character arrays are rejected. MATLAB accepts a character array and
evaluates it at the character codes, which Octave deliberately does not,
since a character array is an integer type and integers are refused too.

See also:
burrcdf,
burrinv,
burrrnd,
burrfit,
burrlike,
burrstat


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 49
Burr type XII probability density function (PDF).



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 7
burrrnd


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1137
statistics: r = burrrnd ( lambda , c , k )
statistics: r = burrrnd ( lambda , c , k , rows )
statistics: r = burrrnd ( lambda , c , k , rows , cols , &hellip;)
statistics: r = burrrnd ( lambda , c , k , [ sz ])

Random arrays from the Burr type XII distribution.

r = burrrnd ( lambda , c , k ) returns an array of
random numbers chosen from the Burr type XII distribution with scale
parameter lambda , first shape parameter c , and second shape
parameter k . The size of r is the common size of lambda ,
c , and k . LAMBDA scalar input functions as a constant matrix of
the same size as the other inputs.

When called with a single size argument, burrrnd returns a square
matrix with the dimension specified. When called with more than one scalar
argument, the first two arguments are taken as the number of rows and columns
and any further arguments specify additional matrix dimensions. The size may
also be specified with a row vector of dimensions, sz .

Further information about the Burr distribution can be found at
https://en.wikipedia.org/wiki/Burr_distribution

See also:
burrcdf,
burrinv,
burrpdf,
burrfit,
burrlike,
burrstat


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 50
Random arrays from the Burr type XII distribution.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 6
bvncdf


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 918
statistics: p = bvncdf ( x , mu , sigma )
statistics: p = bvncdf ( x , [], sigma )

Bivariate normal cumulative distribution function (CDF).

p = bvncdf ( x , mu , sigma ) will compute the
bivariate normal cumulative distribution function of x given a mean
parameter mu and a scale parameter sigma .

x must be an N&times;2 matrix with each variable as a column
vector.
mu can be either a scalar (common mean) or a two-element row
vector (each element corresponds to a variable). If empty, a zero mean is
assumed.
sigma can be a scalar (common variance) or a 2&times;2
covariance matrix, which must be positive definite.

Input arguments must be double or single ; integer, logical,
and character arrays are rejected. MATLAB accepts a character array and
evaluates it at the character codes, which Octave deliberately does not,
since a character array is an integer type and integers are refused too.

See also:
mvncdf


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 56
Bivariate normal cumulative distribution function (CDF).



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 6
bvtcdf


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 842
statistics: p = bvtcdf ( x , rho , df )
statistics: p = bvtcdf ( x , rho , df , Tol )

Bivariate Student&rsquo;s t cumulative distribution function (CDF).

p = bvtcdf ( x , rho , df ) will compute the
bivariate student&rsquo;s t cumulative distribution function of x , which must
be an N&times;2 matrix, given a correlation coefficient rho , which
must be a scalar, and df degrees of freedom, which can be a scalar or a
vector of positive numbers commensurate with x .

Tol is the tolerance for numerical integration and by default
Tol = 1e-8 .

Input arguments must be double or single ; integer, logical,
and character arrays are rejected. MATLAB accepts a character array and
evaluates it at the character codes, which Octave deliberately does not,
since a character array is an integer type and integers are refused too.

See also:
mvtcdf


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 61
Bivariate Student's t cumulative distribution function (CDF).



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 9
cauchycdf


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1044
statistics: p = cauchycdf ( x , x0 , gamma )
statistics: p = cauchycdf ( x , x0 , gamma , 'upper' )

Cauchy cumulative distribution function (CDF).

For each element of x , compute the cumulative distribution function
(CDF) of the Cauchy distribution with location parameter x0 and scale
parameter gamma . The size of p is the common size of x ,
x0 , and gamma . A scalar input functions as a constant matrix of
the same size as the other inputs.

p = cauchycdf ( x , x0 , gamma , "upper") computes
the upper tail probability of the Cauchy distribution with parameters
x0 and gamma , at the values in x .

Further information about the Cauchy distribution can be found at
https://en.wikipedia.org/wiki/Cauchy_distribution

Input arguments must be double or single ; integer, logical,
and character arrays are rejected. MATLAB accepts a character array and
evaluates it at the character codes, which Octave deliberately does not,
since a character array is an integer type and integers are refused too.

See also:
cauchyinv,
cauchypdf,
cauchyrnd


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 46
Cauchy cumulative distribution function (CDF).



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 9
cauchyinv


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 842
statistics: x = cauchyinv ( p , x0 , gamma )

Inverse of the Cauchy cumulative distribution function (iCDF).

For each element of p , compute the quantile (the inverse of the CDF) of
the Cauchy distribution with location parameter x0 and scale parameter
gamma . The size of x is the common size of p , x0 ,
and gamma . A scalar input functions as a constant matrix of the same
size as the other inputs.

Further information about the Cauchy distribution can be found at
https://en.wikipedia.org/wiki/Cauchy_distribution

Input arguments must be double or single ; integer, logical,
and character arrays are rejected. MATLAB accepts a character array and
evaluates it at the character codes, which Octave deliberately does not,
since a character array is an integer type and integers are refused too.

See also:
cauchycdf,
cauchypdf,
cauchyrnd


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 62
Inverse of the Cauchy cumulative distribution function (iCDF).



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 9
cauchypdf


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 823
statistics: y = cauchypdf ( x , x0 , gamma )

Cauchy probability density function (PDF).

For each element of x , compute the probability density function (PDF)
of the Cauchy distribution with location parameter x0 and scale
parameter gamma . The size of y is the common size of x ,
x0 , and gamma . A scalar input functions as a constant matrix of
the same size as the other inputs.

Further information about the Cauchy distribution can be found at
https://en.wikipedia.org/wiki/Cauchy_distribution

Input arguments must be double or single ; integer, logical,
and character arrays are rejected. MATLAB accepts a character array and
evaluates it at the character codes, which Octave deliberately does not,
since a character array is an integer type and integers are refused too.

See also:
cauchycdf,
cauchyinv,
cauchyrnd


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 42
Cauchy probability density function (PDF).



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 9
cauchyrnd


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1053
statistics: r = cauchyrnd ( x0 , gamma )
statistics: r = cauchyrnd ( x0 , gamma , rows )
statistics: r = cauchyrnd ( x0 , gamma , rows , cols , &hellip;)
statistics: r = cauchyrnd ( x0 , gamma , [ sz ])

Random arrays from the Cauchy distribution.

r = cauchyrnd ( x0 , gamma ) returns an array of
random numbers chosen from the Cauchy distribution with location parameter
x0 and scale parameter gamma . The size of r is the common
size of x0 and gamma . A scalar input functions as a constant
matrix of the same size as the other inputs.

When called with a single size argument, cauchyrnd returns a square
matrix with the dimension specified. When called with more than one scalar
argument, the first two arguments are taken as the number of rows and columns
and any further arguments specify additional matrix dimensions. The size may
also be specified with a row vector of dimensions, sz .

Further information about the Cauchy distribution can be found at
https://en.wikipedia.org/wiki/Cauchy_distribution

See also:
cauchycdf,
cauchyinv,
cauchypdf


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 43
Random arrays from the Cauchy distribution.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 7
chi2cdf


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1133
statistics: p = chi2cdf ( x , df )
statistics: p = chi2cdf ( x , df , 'upper' )

Chi-squared cumulative distribution function (CDF).

For each element of x , compute the cumulative distribution function
(CDF) of the chi-squared distribution with df degrees of freedom. The
chi-squared density function with df degrees of freedom is the same as
a gamma density function with parameters df /2 and 2 .

The size of p is the common size of x and df . A scalar
input functions as a constant matrix of the same size as the other input.

p = chi2cdf ( x , df , "upper") computes the upper tail
probability of the chi-squared distribution with df degrees of freedom,
at the values in x .

Further information about the chi-squared distribution can be found at
https://en.wikipedia.org/wiki/Chi-squared_distribution

Input arguments must be double or single ; integer, logical,
and character arrays are rejected. MATLAB accepts a character array and
evaluates it at the character codes, which Octave deliberately does not,
since a character array is an integer type and integers are refused too.

See also:
chi2inv,
chi2pdf,
chi2rnd,
chi2stat


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 51
Chi-squared cumulative distribution function (CDF).



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 7
chi2inv


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 819
statistics: x = chi2inv ( p , df )

Inverse of the chi-squared cumulative distribution function (iCDF).

For each element of p , compute the quantile (the inverse of the CDF) of
the chi-squared distribution with df degrees of freedom. The size of
x is the common size of p and df . A scalar input functions
as a constant matrix of the same size as the other inputs.

Further information about the chi-squared distribution can be found at
https://en.wikipedia.org/wiki/Chi-squared_distribution

Input arguments must be double or single ; integer, logical,
and character arrays are rejected. MATLAB accepts a character array and
evaluates it at the character codes, which Octave deliberately does not,
since a character array is an integer type and integers are refused too.

See also:
chi2cdf,
chi2pdf,
chi2rnd,
chi2stat


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 67
Inverse of the chi-squared cumulative distribution function (iCDF).



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 7
chi2pdf


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 800
statistics: y = chi2pdf ( x , df )

Chi-squared probability density function (PDF).

For each element of x , compute the probability density function (PDF)
of the chi-squared distribution with df degrees of freedom. The size
of y is the common size of x and df . A scalar input
functions as a constant matrix of the same size as the other inputs.

Further information about the chi-squared distribution can be found at
https://en.wikipedia.org/wiki/Chi-squared_distribution

Input arguments must be double or single ; integer, logical,
and character arrays are rejected. MATLAB accepts a character array and
evaluates it at the character codes, which Octave deliberately does not,
since a character array is an integer type and integers are refused too.

See also:
chi2cdf,
chi2inv,
chi2rnd,
chi2stat


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 47
Chi-squared probability density function (PDF).



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 7
chi2rnd


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 897
statistics: r = chi2rnd ( df )
statistics: r = chi2rnd ( df , rows )
statistics: r = chi2rnd ( df , rows , cols , &hellip;)
statistics: r = chi2rnd ( df , [ sz ])

Random arrays from the chi-squared distribution.

r = chi2rnd ( df ) returns an array of random numbers chosen
from the chi-squared distribution with df degrees of freedom. The size
of r is the size of df .

When called with a single size argument, chi2rnd returns a square
matrix with the dimension specified. When called with more than one scalar
argument, the first two arguments are taken as the number of rows and columns
and any further arguments specify additional matrix dimensions. The size may
also be specified with a row vector of dimensions, sz .

Further information about the chi-squared distribution can be found at
https://en.wikipedia.org/wiki/Chi-squared_distribution

See also:
chi2cdf,
chi2inv,
chi2pdf,
chi2stat


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 48
Random arrays from the chi-squared distribution.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 9
copulacdf


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 2092
statistics: p = copulacdf ( family , x , theta )
statistics: p = copulacdf (&rsquo;t&rsquo;, x , theta , df )

Copula family cumulative distribution functions (CDF).

Arguments

family is the copula family name. Currently, family can
be 'Gaussian' for the Gaussian family, 't' for the
Student&rsquo;s t family, 'Clayton' for the Clayton family,
'Gumbel' for the Gumbel-Hougaard family, 'Frank' for
the Frank family, 'AMH' for the Ali-Mikhail-Haq family, or
'FGM' for the Farlie-Gumbel-Morgenstern family.

x is the support where each row corresponds to an observation.

theta is the parameter of the copula. For the Gaussian and
Student&rsquo;s t copula, theta must be a correlation matrix. For
bivariate copulas theta can also be a correlation coefficient.
For the Clayton family, the Gumbel-Hougaard family, the Frank family,
and the Ali-Mikhail-Haq family, theta must be a vector with the
same number of elements as observations in x or be scalar. For
the Farlie-Gumbel-Morgenstern family, theta must be a matrix of
coefficients for the Farlie-Gumbel-Morgenstern polynomial where each
row corresponds to one set of coefficients for an observation in
x . A single row is expanded. The coefficients are in binary
order.

df is the degrees of freedom for the Student&rsquo;s t family.
df must be a vector with the same number of elements as
observations in x or be scalar.

Return values

p is the cumulative distribution of the copula at each row of
x and corresponding parameter theta .

Examples

x = [0.2:0.2:0.6; 0.2:0.2:0.6];
theta = [1; 2];
p = copulacdf ("Clayton", x, theta)

x = [0.2:0.2:0.6; 0.2:0.1:0.4];
theta = [0.2, 0.1, 0.1, 0.05];
p = copulacdf ("FGM", x, theta)

References

Roger B. Nelsen. An Introduction to Copulas . Springer,
New York, second edition, 2006.

Input arguments must be double or single ; integer, logical,
and character arrays are rejected. MATLAB accepts a character array and
evaluates it at the character codes, which Octave deliberately does not,
since a character array is an integer type and integers are refused too.

See also:
copulapdf,
copularnd


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 54
Copula family cumulative distribution functions (CDF).



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 9
copulapdf


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 2317
statistics: y = copulapdf ( family , x , theta )
statistics: y = copulapdf (&rsquo;t&rsquo;, x , theta , df )

Copula family probability density functions (PDF).

Arguments

family is the copula family name. Currently, family can
be 'Gaussian' for the Gaussian family, 't' for the
Student&rsquo;s t family, 'Clayton' for the Clayton family,
'Gumbel' for the Gumbel-Hougaard family, 'Frank' for the
Frank family, 'AMH' for the Ali-Mikhail-Haq family, or
'FGM' for the Farlie-Gumbel-Morgenstern family. The last two are
Octave extensions that MATLAB does not provide.

x is the support where each row corresponds to an observation.

theta is the parameter of the copula. For the Gaussian and
Student&rsquo;s t families it is the linear correlation matrix, and a scalar
is expanded to a bivariate one. For the remaining families the elements
of theta must be greater than or equal to -1 for the
Clayton family, greater than or equal to 1 for the
Gumbel-Hougaard family, arbitrary for the Frank family, and greater
than or equal to -1 and lower than 1 for the
Ali-Mikhail-Haq family. Moreover, theta must be non-negative
for dimensions greater than 2 . theta must be a column
vector with the same number of rows as x or be scalar. The
Farlie-Gumbel-Morgenstern family instead takes one parameter for every
subset of the variables of order two or more, so theta is a row
vector of length 2^d-d-1 or a matrix with one such row per
observation; parameter sets violating the family&rsquo;s linear constraints
give NaN .

df is the degrees of freedom of the Student&rsquo;s t family, and is
required by it. It must be a vector with the same number of rows as
x or be scalar.

Return values

y is the probability density of the copula at each row of
x and corresponding parameter theta .

Examples

x = [0.2:0.2:0.6; 0.2:0.2:0.6];
theta = [1; 2];
y = copulapdf ("Clayton", x, theta)

y = copulapdf ("Gumbel", x, 2)

References

Roger B. Nelsen. An Introduction to Copulas . Springer,
New York, second edition, 2006.

Input arguments must be double or single ; integer, logical,
and character arrays are rejected. MATLAB accepts a character array and
evaluates it at the character codes, which Octave deliberately does not,
since a character array is an integer type and integers are refused too.

See also:
copulacdf,
copularnd


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 50
Copula family probability density functions (PDF).



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 9
copularnd


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 2132
statistics: r = copularnd ( family , theta , n )
statistics: r = copularnd ( family , theta , n , d )
statistics: r = copularnd (&rsquo;t&rsquo;, theta , df , n )

Random arrays from the copula family distributions.

Arguments

family is the copula family name. Currently, family can be
'Gaussian' for the Gaussian family, 't' for the Student&rsquo;s t
family, 'Clayton' for the Clayton family, 'Frank' for the
Frank family, 'Gumbel' for the Gumbel-Hougaard family, 'AMH'
for the Ali-Mikhail-Haq family, or 'FGM' for the
Farlie-Gumbel-Morgenstern family. The last two are Octave extensions that
MATLAB does not provide. Every family but Clayton is generated as
bivariate only.

theta is the parameter of the copula. For the Gaussian and Student&rsquo;s t
copula, theta must be a correlation matrix. For bivariate copulas
theta can also be a correlation coefficient. For the Clayton, Frank
and Gumbel-Hougaard families, theta must be a vector with the same
number of elements as samples to be generated or be scalar. Values outside
a family&rsquo;s range give NaN rows: at or above 1 for the
Gumbel-Hougaard family, at or above -1 for the bivariate Clayton
family, and any finite value for the Frank family. The Ali-Mikhail-Haq
family takes theta in [-1, 1) and the
Farlie-Gumbel-Morgenstern family in [-1, 1] .

df is the degrees of freedom for the Student&rsquo;s t family. df must
be a vector with the same number of elements as samples to be generated or
be scalar.

n is the number of rows of the matrix to be generated. n must be
a non-negative integer and corresponds to the number of samples to be
generated.

d is the number of columns of the matrix to be generated. d must
be a positive integer and corresponds to the dimension of the copula.

Return values

r is a matrix of random samples from the copula with n samples
of distribution dimension d .

Examples

theta = 0.5;
r = copularnd ("Gaussian", theta);

theta = 0.5;
df = 2;
r = copularnd ("t", theta, df);

theta = 0.5;
n = 2;
r = copularnd ("Clayton", theta, n);

References

Roger B. Nelsen. An Introduction to Copulas . Springer, New York,
second edition, 2006.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 51
Random arrays from the copula family distributions.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 5
evcdf


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 2204
statistics: p = evcdf ( x )
statistics: p = evcdf ( x , mu )
statistics: p = evcdf ( x , mu , sigma )
statistics: p = evcdf (&hellip;, 'upper' )
statistics: [ p , plo , pup ] = evcdf ( x , mu , sigma , pcov )
statistics: [ p , plo , pup ] = evcdf ( x , mu , sigma , pcov , alpha )
statistics: [ p , plo , pup ] = evcdf (&hellip;, 'upper' )

Extreme value cumulative distribution function (CDF).

For each element of x , compute the cumulative distribution function
(CDF) of the extreme value distribution (also known as the Gumbel or the type
I generalized extreme value distribution) at the values in x with
location parameter mu and scale parameter sigma . The size of
p is the common size of x , mu and sigma . A scalar
input functions as a constant matrix of the same size as the other inputs.

Default values are mu = 0 and sigma = 1.

When called with three output arguments, i.e. [ p , plo ,
pup ] , evcdf computes the confidence bounds for p when the
input parameters mu and sigma are estimates. In such case,
pcov , a 2&times;2 matrix containing the covariance matrix of the
estimated parameters, is necessary. Optionally, alpha , which has a
default value of 0.05, specifies the 100 * (1 - alpha ) percent
confidence bounds. plo and pup are arrays of the same size as
p containing the lower and upper confidence bounds.

[&hellip;] = evcdf (&hellip;, "upper") computes the upper tail
probability of the extreme value distribution with parameters x0 and
gamma , at the values in x .

The Gumbel distribution is used to model the distribution of the maximum (or
the minimum) of a number of samples of various distributions. This version
is suitable for modeling minima. For modeling maxima, use the alternative
Gumbel CDF, gumbelcdf .

Further information about the Gumbel distribution can be found at
https://en.wikipedia.org/wiki/Gumbel_distribution

Input arguments must be double or single ; integer, logical,
and character arrays are rejected. MATLAB accepts a character array and
evaluates it at the character codes, which Octave deliberately does not,
since a character array is an integer type and integers are refused too.

See also:
evinv,
evpdf,
evrnd,
evfit,
evlike,
evstat,
gumbelcdf


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 53
Extreme value cumulative distribution function (CDF).



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 5
evinv


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1933
statistics: x = evinv ( p )
statistics: x = evinv ( p , mu )
statistics: x = evinv ( p , mu , sigma )
statistics: [ x , xlo , xup ] = evinv ( p , mu , sigma , pcov )
statistics: [ x , xlo , xup ] = evinv ( p , mu , sigma , pcov , alpha )

Inverse of the extreme value cumulative distribution function (iCDF).

For each element of p , compute the quantile (the inverse of the CDF) of
the extreme value distribution (also known as the Gumbel or the type I
generalized extreme value distribution) with location parameter mu and
scale parameter sigma . The size of x is the common size of
p , mu and sigma . A scalar input functions as a constant
matrix of the same size as the other inputs.

Default values are mu = 0 and sigma = 1.

When called with three output arguments, i.e. [ x , xlo ,
xup ] , evinv computes the confidence bounds for x when the
input parameters mu and sigma are estimates. In such case,
pcov , a 2&times;2 matrix containing the covariance matrix of the
estimated parameters, is necessary. Optionally, alpha , which has a
default value of 0.05, specifies the 100 * (1 - alpha ) percent
confidence bounds. xlo and xup are arrays of the same size as
x containing the lower and upper confidence bounds.

The Gumbel distribution is used to model the distribution of the maximum (or
the minimum) of a number of samples of various distributions. This version
is suitable for modeling minima. For modeling maxima, use the alternative
Gumbel iCDF, gumbelinv .

Further information about the Gumbel distribution can be found at
https://en.wikipedia.org/wiki/Gumbel_distribution

Input arguments must be double or single ; integer, logical,
and character arrays are rejected. MATLAB accepts a character array and
evaluates it at the character codes, which Octave deliberately does not,
since a character array is an integer type and integers are refused too.

See also:
evcdf,
evpdf,
evrnd,
evfit,
evlike,
evstat,
gumbelinv


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 69
Inverse of the extreme value cumulative distribution function (iCDF).



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 5
evpdf


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1288
statistics: y = evpdf ( x )
statistics: y = evpdf ( x , mu )
statistics: y = evpdf ( x , mu , sigma )

Extreme value probability density function (PDF).

For each element of x , compute the probability density function (PDF)
of the extreme value distribution (also known as the Gumbel or the type I
generalized extreme value distribution) with location parameter mu and
scale parameter sigma . The size of y is the common size of
x , mu and sigma . A scalar input functions as a constant
matrix of the same size as the other inputs.

Default values are mu = 0 and sigma = 1.

The Gumbel distribution is used to model the distribution of the maximum (or
the minimum) of a number of samples of various distributions. This version
is suitable for modeling minima. For modeling maxima, use the alternative
Gumbel iCDF, gumbelinv .

Further information about the Gumbel distribution can be found at
https://en.wikipedia.org/wiki/Gumbel_distribution

Input arguments must be double or single ; integer, logical,
and character arrays are rejected. MATLAB accepts a character array and
evaluates it at the character codes, which Octave deliberately does not,
since a character array is an integer type and integers are refused too.

See also:
evcdf,
evinv,
evrnd,
evfit,
evlike,
evstat,
gumbelpdf


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 49
Extreme value probability density function (PDF).



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 5
evrnd


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1386
statistics: r = evrnd ( mu , sigma )
statistics: r = evrnd ( mu , sigma , rows )
statistics: r = evrnd ( mu , sigma , rows , cols , &hellip;)
statistics: r = evrnd ( mu , sigma , [ sz ])

Random arrays from the extreme value distribution.

r = evrnd ( mu , sigma ) returns an array of random
numbers chosen from the extreme value distribution (also known as the Gumbel
or the type I generalized extreme value distribution) with location
parameter mu and scale parameter sigma . The size of r is
the common size of mu and sigma . A scalar input functions as a
constant matrix of the same size as the other inputs.

When called with a single size argument, evrnd returns a square
matrix with the dimension specified. When called with more than one scalar
argument, the first two arguments are taken as the number of rows and columns
and any further arguments specify additional matrix dimensions. The size may
also be specified with a row vector of dimensions, sz .

The Gumbel distribution is used to model the distribution of the maximum (or
the minimum) of a number of samples of various distributions. This version
is suitable for modeling minima. For modeling maxima, use the alternative
Gumbel iCDF, gumbelinv .

Further information about the Gumbel distribution can be found at
https://en.wikipedia.org/wiki/Gumbel_distribution

See also:
evcdf,
evinv,
evpdf,
evfit,
evlike,
evstat


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 50
Random arrays from the extreme value distribution.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 6
expcdf


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1993
statistics: p = expcdf ( x )
statistics: p = expcdf ( x , mu )
statistics: p = expcdf (&hellip;, 'upper' )
statistics: [ p , plo , pup ] = expcdf ( x , mu , pcov )
statistics: [ p , plo , pup ] = expcdf ( x , mu , pcov , alpha )
statistics: [ p , plo , pup ] = expcdf (&hellip;, 'upper' )

Exponential cumulative distribution function (CDF).

For each element of x , compute the cumulative distribution function
(CDF) of the exponential distribution with mean parameter mu . The size
of p is the common size of x and mu . A scalar input
functions as a constant matrix of the same size as the other inputs.

Default value is mu = 1.

A common alternative parameterization of the exponential distribution is to
use the parameter λ defined as the mean number of events in an
interval as opposed to the parameter μ , which is the mean wait time
for an event to occur. λ and μ are reciprocals,
i.e. μ = 1 / λ .

When called with three output arguments, i.e. [ p , plo ,
pup ] , expcdf computes the confidence bounds for p when
the input parameter mu is an estimate. In such case, pcov , a
scalar value with the variance of the estimated parameter mu , is
necessary. Optionally, alpha , which has a default value of 0.05,
specifies the 100 * (1 - alpha ) percent confidence bounds.
plo and pup are arrays of the same size as p containing the
lower and upper confidence bounds.

[&hellip;] = expcdf (&hellip;, "upper") computes the upper tail
probability of the exponential distribution with parameter mu , at the
values in x .

Further information about the exponential distribution can be found at
https://en.wikipedia.org/wiki/Exponential_distribution

Input arguments must be double or single ; integer, logical,
and character arrays are rejected. MATLAB accepts a character array and
evaluates it at the character codes, which Octave deliberately does not,
since a character array is an integer type and integers are refused too.

See also:
expinv,
exppdf,
exprnd,
expfit,
explike,
expstat


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 51
Exponential cumulative distribution function (CDF).



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 6
expinv


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1740
statistics: x = expinv ( p )
statistics: x = expinv ( p , mu )
statistics: [ x , xlo , xup ] = expinv ( p , mu , pcov )
statistics: [ x , xlo , xup ] = expinv ( p , mu , pcov , alpha )

Inverse of the exponential cumulative distribution function (iCDF).

For each element of p , compute the quantile (the inverse of the CDF) of
the exponential distribution with mean mu . The size of x is the
common size of p and mu . A scalar input functions as a constant
matrix of the same size as the other inputs.

Default value is mu = 1.

A common alternative parameterization of the exponential distribution is to
use the parameter λ defined as the mean number of events in an
interval as opposed to the parameter μ , which is the mean wait time
for an event to occur. λ and μ are reciprocals,
i.e. μ = 1 / λ .

When called with three output arguments, i.e. [ x , xlo ,
xup ] , expinv computes the confidence bounds for x when
the input parameter mu is an estimate. In such case, pcov , a
scalar value with the variance of the estimated parameter mu , is
necessary. Optionally, alpha , which has a default value of 0.05,
specifies the 100 * (1 - alpha ) percent confidence bounds.
xlo and xup are arrays of the same size as x containing the
lower and upper confidence bounds.

Further information about the exponential distribution can be found at
https://en.wikipedia.org/wiki/Exponential_distribution

Input arguments must be double or single ; integer, logical,
and character arrays are rejected. MATLAB accepts a character array and
evaluates it at the character codes, which Octave deliberately does not,
since a character array is an integer type and integers are refused too.

See also:
expcdf,
exppdf,
exprnd,
expfit,
explike,
expstat


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 67
Inverse of the exponential cumulative distribution function (iCDF).



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 6
exppdf


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1145
statistics: y = exppdf ( x )
statistics: y = exppdf ( x , mu )

Exponential probability density function (PDF).

For each element of x , compute the probability density function (PDF)
of the exponential distribution with mean parameter mu . The size of
y is the common size of x and mu . A scalar input functions
as a constant matrix of the same size as the other inputs.

Default value for mu = 1.

A common alternative parameterization of the exponential distribution is to
use the parameter λ defined as the mean number of events in an
interval as opposed to the parameter μ , which is the mean wait time
for an event to occur. λ and μ are reciprocals,
i.e. μ = 1 / λ .

Further information about the exponential distribution can be found at
https://en.wikipedia.org/wiki/Exponential_distribution

Input arguments must be double or single ; integer, logical,
and character arrays are rejected. MATLAB accepts a character array and
evaluates it at the character codes, which Octave deliberately does not,
since a character array is an integer type and integers are refused too.

See also:
expcdf,
expinv,
exprnd,
expfit,
explike,
expstat


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 47
Exponential probability density function (PDF).



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 6
exprnd


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1181
statistics: r = exprnd ( mu )
statistics: r = exprnd ( mu , rows )
statistics: r = exprnd ( mu , rows , cols , &hellip;)
statistics: r = exprnd ( mu , [ sz ])

Random arrays from the exponential distribution.

r = exprnd ( mu ) returns an array of random numbers chosen
from the exponential distribution with mean parameter mu . The size of
r is the size of mu .

When called with a single size argument, exprnd returns a square
matrix with the dimension specified. When called with more than one scalar
argument, the first two arguments are taken as the number of rows and columns
and any further arguments specify additional matrix dimensions. The size may
also be specified with a row vector of dimensions, sz .

A common alternative parameterization of the exponential distribution is to
use the parameter λ defined as the mean number of events in an
interval as opposed to the parameter μ , which is the mean wait time
for an event to occur. λ and μ are reciprocals,
i.e. μ = 1 / λ .

Further information about the exponential distribution can be found at
https://en.wikipedia.org/wiki/Exponential_distribution

See also:
expcdf,
expinv,
exppdf,
expfit,
explike,
expstat


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 48
Random arrays from the exponential distribution.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 4
fcdf


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 984
statistics: p = fcdf ( x , df1 , df2 )
statistics: p = fcdf ( x , df1 , df2 , 'upper' )

F -cumulative distribution function (CDF).

For each element of x , compute the cumulative distribution function
(CDF) of the F -distribution with df1 and df2 degrees of
freedom. The size of p is the common size of x , df1 , and
df2 . A scalar input functions as a constant matrix of the same size as
the other inputs.

p = fcdf ( x , df1 , df2 , "upper") computes the
upper tail probability of the F -distribution with df1 and
df2 degrees of freedom, at the values in x .

Further information about the F -distribution can be found at
https://en.wikipedia.org/wiki/F-distribution

Input arguments must be double or single ; integer, logical,
and character arrays are rejected. MATLAB accepts a character array and
evaluates it at the character codes, which Octave deliberately does not,
since a character array is an integer type and integers are refused too.

See also:
finv,
fpdf,
frnd,
fstat


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 41
F-cumulative distribution function (CDF).



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 4
finv


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 792
statistics: x = finv ( p , df1 , df2 )

Inverse of the F -cumulative distribution function (iCDF).

For each element of p , compute the quantile (the inverse of the CDF) of
the F -distribution with df1 and df2 degrees of freedom.
The size of x is the common size of p , df1 , and df2 .
A scalar input functions as a constant matrix of the same size as the other
inputs.

Further information about the F -distribution can be found at
https://en.wikipedia.org/wiki/F-distribution

Input arguments must be double or single ; integer, logical,
and character arrays are rejected. MATLAB accepts a character array and
evaluates it at the character codes, which Octave deliberately does not,
since a character array is an integer type and integers are refused too.

See also:
fcdf,
fpdf,
frnd,
fstat


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 57
Inverse of the F-cumulative distribution function (iCDF).



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 4
fpdf


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 773
statistics: y = fpdf ( x , df1 , df2 )

F -probability density function (PDF).

For each element of x , compute the probability density function (PDF)
of the F -distribution with df1 and df2 degrees of freedom.
The size of y is the common size of x , df1 , and df2 .
A scalar input functions as a constant matrix of the same size as the other
inputs.

Further information about the F -distribution can be found at
https://en.wikipedia.org/wiki/F-distribution

Input arguments must be double or single ; integer, logical,
and character arrays are rejected. MATLAB accepts a character array and
evaluates it at the character codes, which Octave deliberately does not,
since a character array is an integer type and integers are refused too.

See also:
fcdf,
finv,
frnd,
fstat


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 37
F-probability density function (PDF).



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 4
frnd


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 974
statistics: r = frnd ( df1 , df2 )
statistics: r = frnd ( df1 , df2 , rows )
statistics: r = frnd ( df1 , df2 , rows , cols , &hellip;)
statistics: r = frnd ( df1 , df2 , [ sz ])

Random arrays from the F -distribution.

r = frnd ( df1 , df2 ) returns an array of random
numbers chosen from the F -distribution with df1 and df2
degrees of freedom. The size of r is the common size of df1 and
df2 . A scalar input functions as a constant matrix of the same size as
the other inputs.

When called with a single size argument, frnd returns a square
matrix with the dimension specified. When called with more than one scalar
argument, the first two arguments are taken as the number of rows and columns
and any further arguments specify additional matrix dimensions. The size may
also be specified with a row vector of dimensions, sz .

Further information about the F -distribution can be found at
https://en.wikipedia.org/wiki/F-distribution

See also:
fcdf,
finv,
fpdf,
fstat


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 38
Random arrays from the F-distribution.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 6
gamcdf


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 2180
statistics: p = gamcdf ( x , a )
statistics: p = gamcdf ( x , a , b )
statistics: p = gamcdf (&hellip;, 'upper' )
statistics: [ p , plo , pup ] = gamcdf ( x , a , b , pcov )
statistics: [ p , plo , pup ] = gamcdf ( x , a , b , pcov , alpha )
statistics: [ p , plo , pup ] = gamcdf (&hellip;, 'upper' )

Gamma cumulative distribution function (CDF).

For each element of x , compute the cumulative distribution function
(CDF) of the Gamma distribution with shape parameter a and scale
parameter b . When called with only one parameter, then b
defaults to 1. The size of p is the common size of x , a ,
and b . A scalar input functions as a constant matrix of the same
size as the other inputs.

When called with three output arguments, i.e. [ p , plo ,
pup ] , gamcdf computes the confidence bounds for p when
the input parameters a and b are estimates. In such case,
pcov , a 2&times;2 matrix containing the covariance matrix of the
estimated parameters, is necessary. Optionally, alpha , which has a
default value of 0.05, specifies the 100 * (1 - alpha ) percent
confidence bounds. plo and pup are arrays of the same size as
p containing the lower and upper confidence bounds.

[&hellip;] = gamcdf (&hellip;, "upper") computes the upper tail
probability of the Gamma distribution with parameters a and
b , at the values in x .

OCTAVE/MATLAB use the alternative parameterization given by the pair
α, β , i.e. shape a and scale b . In Wikipedia, the two
common parameterizations use the pairs k, θ , as shape and scale, and
α, β , as shape and rate, respectively. The parameter names a
and b used here (for MATLAB compatibility) correspond to the parameter
notation k, θ instead of the α, β as reported in Wikipedia.

Further information about the Gamma distribution can be found at
https://en.wikipedia.org/wiki/Gamma_distribution

Input arguments must be double or single ; integer, logical,
and character arrays are rejected. MATLAB accepts a character array and
evaluates it at the character codes, which Octave deliberately does not,
since a character array is an integer type and integers are refused too.

See also:
gaminv,
gampdf,
gamrnd,
gamfit,
gamlike,
gamstat


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 45
Gamma cumulative distribution function (CDF).



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 6
gaminv


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1231
statistics: x = gaminv ( p , a , b )

Inverse of the Gamma cumulative distribution function (iCDF).

For each element of p , compute the quantile (the inverse of the CDF) of
the Gamma distribution with shape parameter a and scale parameter
b . The size of x is the common size of p , a ,
and b . A scalar input functions as a constant matrix of the same
size as the other inputs.

OCTAVE/MATLAB use the alternative parameterization given by the pair
α, β , i.e. shape a and scale b . In Wikipedia, the two
common parameterizations use the pairs k, θ , as shape and scale, and
α, β , as shape and rate, respectively. The parameter names a
and b used here (for MATLAB compatibility) correspond to the parameter
notation k, θ instead of the α, β as reported in Wikipedia.

Further information about the Gamma distribution can be found at
https://en.wikipedia.org/wiki/Gamma_distribution

Input arguments must be double or single ; integer, logical,
and character arrays are rejected. MATLAB accepts a character array and
evaluates it at the character codes, which Octave deliberately does not,
since a character array is an integer type and integers are refused too.

See also:
gamcdf,
gampdf,
gamrnd,
gamfit,
gamlike,
gamstat


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 61
Inverse of the Gamma cumulative distribution function (iCDF).



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 6
gampdf


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1210
statistics: y = gampdf ( x , a , b )

Gamma probability density function (PDF).

For each element of x , compute the probability density function (PDF)
of the Gamma distribution with shape parameter a and scale parameter
b . The size of y is the common size of x , a and
b . A scalar input functions as a constant matrix of the same size
as the other inputs.

OCTAVE/MATLAB use the alternative parameterization given by the pair
α, β , i.e. shape a and scale b . In Wikipedia, the two
common parameterizations use the pairs k, θ , as shape and scale, and
α, β , as shape and rate, respectively. The parameter names a
and b used here (for MATLAB compatibility) correspond to the parameter
notation k, θ instead of the α, β as reported in Wikipedia.

Further information about the Gamma distribution can be found at
https://en.wikipedia.org/wiki/Gamma_distribution

Input arguments must be double or single ; integer, logical,
and character arrays are rejected. MATLAB accepts a character array and
evaluates it at the character codes, which Octave deliberately does not,
since a character array is an integer type and integers are refused too.

See also:
gamcdf,
gaminv,
gamrnd,
gamfit,
gamlike,
gamstat


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 41
Gamma probability density function (PDF).



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 6
gamrnd


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1407
statistics: r = gamrnd ( a , b )
statistics: r = gamrnd ( a , b , rows )
statistics: r = gamrnd ( a , b , rows , cols , &hellip;)
statistics: r = gamrnd ( a , b , [ sz ])

Random arrays from the Gamma distribution.

r = gamrnd ( a , b ) returns an array of random
numbers chosen from the Gamma distribution with shape parameter a and
scale parameter b . The size of r is the common size of
a and b . A scalar input functions as a constant matrix of
the same size as the other inputs.

When called with a single size argument, gamrnd returns a square
matrix with the dimension specified. When called with more than one scalar
argument, the first two arguments are taken as the number of rows and columns
and any further arguments specify additional matrix dimensions. The size may
also be specified with a row vector of dimensions, sz .

OCTAVE/MATLAB use the alternative parameterization given by the pair
α, β , i.e. shape a and scale b . In Wikipedia, the two
common parameterizations use the pairs k, θ , as shape and scale, and
α, β , as shape and rate, respectively. The parameter names a
and b used here (for MATLAB compatibility) correspond to the parameter
notation k, θ instead of the α, β as reported in Wikipedia.

Further information about the Gamma distribution can be found at
https://en.wikipedia.org/wiki/Gamma_distribution

See also:
gamcdf,
gaminv,
gampdf,
gamfit,
gamlike,
gamstat


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 42
Random arrays from the Gamma distribution.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 6
geocdf


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1200
statistics: p = geocdf ( x , ps )
statistics: p = geocdf ( x , ps , 'upper' )

Geometric cumulative distribution function (CDF).

For each element of x , compute the cumulative distribution function
(CDF) of the geometric distribution with probability of success parameter
ps . The size of p is the common size of x and ps .
A scalar input functions as a constant matrix of the same size as the other
inputs.

p = geocdf ( x , ps , "upper") computes the upper tail
probability of the geometric distribution with parameter ps , at the
values in x .

The geometric distribution models the number of failures ( x ) of a
Bernoulli trial with probability ps before the first success.

Further information about the geometric distribution can be found at
https://en.wikipedia.org/wiki/Geometric_distribution

Input arguments must be double , single , or an integer type;
logical and character arrays are rejected. Integer input is promoted to
double , so the result is always a probability. MATLAB is
inconsistent here: for several of the discrete distributions it returns the
result in the integer class of the input, truncating a probability to
0 or 1 .

See also:
geoinv,
geopdf,
geornd,
geofit,
geostat


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 49
Geometric cumulative distribution function (CDF).



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 6
geoinv


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 960
statistics: x = geoinv ( p , ps )

Inverse of the geometric cumulative distribution function (iCDF).

For each element of p , compute the quantile (the inverse of the CDF) of
the geometric distribution with probability of success parameter ps .
The size of x is the common size of p and ps . A scalar
input functions as a constant matrix of the same size as the other inputs.

The geometric distribution models the number of failures ( p ) of a
Bernoulli trial with probability ps before the first success.

Further information about the geometric distribution can be found at
https://en.wikipedia.org/wiki/Geometric_distribution

Input arguments must be double or single ; integer, logical,
and character arrays are rejected. MATLAB accepts a character array and
evaluates it at the character codes, which Octave deliberately does not,
since a character array is an integer type and integers are refused too.

See also:
geocdf,
geopdf,
geornd,
geofit,
geostat


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 65
Inverse of the geometric cumulative distribution function (iCDF).



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 6
geopdf


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1009
statistics: y = geopdf ( x , ps )

Geometric probability density function (PDF).

For each element of x , compute the probability density function (PDF)
of the geometric distribution with probability of success parameter ps .
The size of y is the common size of x and ps . A scalar
input functions as a constant matrix of the same size as the other inputs.

The geometric distribution models the number of failures ( x ) of a
Bernoulli trial with probability ps before the first success.

Further information about the geometric distribution can be found at
https://en.wikipedia.org/wiki/Geometric_distribution

Input arguments must be double , single , or an integer type;
logical and character arrays are rejected. Integer input is promoted to
double , so the result is always a probability. MATLAB is
inconsistent here: for several of the discrete distributions it returns the
result in the integer class of the input, truncating a probability to
0 or 1 .

See also:
geocdf,
geoinv,
geornd,
geofit,
geostat


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 45
Geometric probability density function (PDF).



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 6
geornd


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1041
statistics: r = geornd ( ps )
statistics: r = geornd ( ps , rows )
statistics: r = geornd ( ps , rows , cols , &hellip;)
statistics: r = geornd ( ps , [ sz ])

Random arrays from the geometric distribution.

r = geornd ( ps ) returns an array of random numbers chosen
from the Birnbaum-Saunders distribution with probability of success parameter
ps . The size of r is the size of ps .

When called with a single size argument, geornd returns a square
matrix with the dimension specified. When called with more than one scalar
argument, the first two arguments are taken as the number of rows and columns
and any further arguments specify additional matrix dimensions. The size may
also be specified with a row vector of dimensions, sz .

The geometric distribution models the number of failures ( x ) of a
Bernoulli trial with probability ps before the first success.

Further information about the geometric distribution can be found at
https://en.wikipedia.org/wiki/Geometric_distribution

See also:
geocdf,
geoinv,
geopdf,
geofit,
geostat


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 46
Random arrays from the geometric distribution.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 6
gevcdf


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1837
statistics: p = gevcdf ( x , k , sigma , mu )
statistics: p = gevcdf ( x , k , sigma , mu , 'upper' )

Generalized extreme value (GEV) cumulative distribution function (CDF).

For each element of x , compute the cumulative distribution function
(CDF) of the GEV distribution with shape parameter k , scale parameter
sigma , and location parameter mu . The size of p is the
common size of x , k , sigma , and mu . A scalar input
functions as a constant matrix of the same size as the other inputs.

[&hellip;] = gevcdf ( x , k , sigma , mu , "upper")
computes the upper tail probability of the GEV distribution with parameters
k , sigma , and mu , at the values in x .

When k < 0 , the GEV is the type III extreme value distribution.
When k > 0 , the GEV distribution is the type II, or Frechet,
extreme value distribution. If W has a Weibull distribution as
computed by the wblcdf function, then - W has a type III
extreme value distribution and 1/ W has a type II extreme value
distribution. In the limit as k approaches 0 , the GEV is the
mirror image of the type I extreme value distribution as computed by the
evcdf function.

The mean of the GEV distribution is not finite when k >= 1 , and
the variance is not finite when k >= 1/2 . The GEV distribution
has positive density only for values of x such that
k * ( x - mu ) / sigma > -1 .

Further information about the generalized extreme value distribution can be
found at
https://en.wikipedia.org/wiki/Generalized_extreme_value_distribution

Input arguments must be double or single ; integer, logical,
and character arrays are rejected. MATLAB accepts a character array and
evaluates it at the character codes, which Octave deliberately does not,
since a character array is an integer type and integers are refused too.

See also:
gevinv,
gevpdf,
gevrnd,
gevfit,
gevlike,
gevstat


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 71
Generalized extreme value (GEV) cumulative distribution function (CDF).



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 6
gevinv


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1621
statistics: x = gevinv ( p , k , sigma , mu )

Inverse of the generalized extreme value (GEV) cumulative distribution
function (iCDF).

For each element of p , compute the quantile (the inverse of the CDF) of
the GEV distribution with shape parameter k , scale parameter
sigma , and location parameter mu . The size of p is the
common size of x , k , sigma , and mu . A scalar input
functions as a constant matrix of the same size as the other inputs.

When k < 0 , the GEV is the type III extreme value distribution.
When k > 0 , the GEV distribution is the type II, or Frechet,
extreme value distribution. If W has a Weibull distribution as
computed by the wblcdf function, then - W has a type III
extreme value distribution and 1/ W has a type II extreme value
distribution. In the limit as k approaches 0 , the GEV is the
mirror image of the type I extreme value distribution as computed by the
evcdf function.

The mean of the GEV distribution is not finite when k >= 1 , and
the variance is not finite when k >= 1/2 . The GEV distribution
has positive density only for values of x such that
k * ( x - mu ) / sigma > -1 .

Further information about the generalized extreme value distribution can be
found at
https://en.wikipedia.org/wiki/Generalized_extreme_value_distribution

Input arguments must be double or single ; integer, logical,
and character arrays are rejected. MATLAB accepts a character array and
evaluates it at the character codes, which Octave deliberately does not,
since a character array is an integer type and integers are refused too.

See also:
gevcdf,
gevpdf,
gevrnd,
gevfit,
gevlike,
gevstat


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 87
Inverse of the generalized extreme value (GEV) cumulative distribution function (iCDF).



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 6
gevpdf


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1602
statistics: y = gevpdf ( x , k , sigma , mu )

Generalized extreme value (GEV) probability density function (PDF).

For each element of x , compute the probability density function (PDF)
of the GEV distribution with shape parameter k , scale parameter
sigma , and location parameter mu . The size of y is the
common size of x , k , sigma , and mu . A scalar input
functions as a constant matrix of the same size as the other inputs.

When k < 0 , the GEV is the type III extreme value distribution.
When k > 0 , the GEV distribution is the type II, or Frechet,
extreme value distribution. If W has a Weibull distribution as
computed by the wblcdf function, then - W has a type III
extreme value distribution and 1/ W has a type II extreme value
distribution. In the limit as k approaches 0 , the GEV is the
mirror image of the type I extreme value distribution as computed by the
evcdf function.

The mean of the GEV distribution is not finite when k >= 1 , and
the variance is not finite when k >= 1/2 . The GEV distribution
has positive density only for values of x such that
k * ( x - mu ) / sigma > -1 .

Further information about the generalized extreme value distribution can be
found at
https://en.wikipedia.org/wiki/Generalized_extreme_value_distribution

Input arguments must be double or single ; integer, logical,
and character arrays are rejected. MATLAB accepts a character array and
evaluates it at the character codes, which Octave deliberately does not,
since a character array is an integer type and integers are refused too.

See also:
gevcdf,
gevinv,
gevrnd,
gevfit,
gevlike,
gevstat


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 67
Generalized extreme value (GEV) probability density function (PDF).



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 6
gevrnd


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1833
statistics: r = gevrnd ( k , sigma , mu )
statistics: r = gevrnd ( k , sigma , mu , rows )
statistics: r = gevrnd ( k , sigma , mu , rows , cols , &hellip;)
statistics: r = gevrnd ( k , sigma , mu , [ sz ])

Random arrays from the generalized extreme value (GEV) distribution.

r = gevrnd ( k , sigma , mu returns an array of
random numbers chosen from the GEV distribution with shape parameter k ,
scale parameter sigma , and location parameter mu . The size of
r is the common size of k , sigma , and mu . A scalar
input functions as a constant matrix of the same size as the other inputs.

When called with a single size argument, gevrnd returns a square
matrix with the dimension specified. When called with more than one scalar
argument, the first two arguments are taken as the number of rows and columns
and any further arguments specify additional matrix dimensions. The size may
also be specified with a row vector of dimensions, sz .

When k < 0 , the GEV is the type III extreme value distribution.
When k > 0 , the GEV distribution is the type II, or Frechet,
extreme value distribution. If W has a Weibull distribution as
computed by the wblcdf function, then - W has a type III
extreme value distribution and 1/ W has a type II extreme value
distribution. In the limit as k approaches 0 , the GEV is the
mirror image of the type I extreme value distribution as computed by the
evcdf function.

The mean of the GEV distribution is not finite when k >= 1 , and
the variance is not finite when k >= 1/2 . The GEV distribution
has positive density only for values of x such that
k * ( x - mu ) / sigma > -1 .

Further information about the generalized extreme value distribution can be
found at
https://en.wikipedia.org/wiki/Generalized_extreme_value_distribution

See also:
gevcdf,
gevinv,
gevpdf,
gevfit,
gevlike,
gevstat


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 68
Random arrays from the generalized extreme value (GEV) distribution.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 5
gpcdf


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1613
statistics: p = gpcdf ( x , k , sigma , theta )
statistics: p = gpcdf ( x , k , sigma , theta , 'upper' )

Generalized Pareto cumulative distribution function (CDF).

For each element of x , compute the cumulative distribution function
(CDF) of the generalized Pareto distribution with shape parameter k ,
scale parameter sigma , and location parameter theta . The size of
p is the common size of x , k , sigma , and theta .
A scalar input functions as a constant matrix of the same size as the other
inputs.

[&hellip;] = gpcdf( x , k , sigma , theta , "upper")
computes the upper tail probability of the generalized Pareto distribution
with parameters k , sigma , and theta , at the values in
x .

When k = 0 and theta = 0 , the Generalized Pareto
is equivalent to the exponential distribution. When k > 0 and
theta = k / k the Generalized Pareto is equivalent
τπ the Pareto distribution. The mean of the Generalized Pareto is not finite
when k >= 1 and the variance is not finite when
k >= 1/2 . When k >= 0 , the Generalized Pareto
has positive density for x > theta , or, when
theta < 0 , for
0 <= ( x - theta ) / sigma <= -1 / k .

Further information about the generalized Pareto distribution can be found at
https://en.wikipedia.org/wiki/Generalized_Pareto_distribution

Input arguments must be double or single ; integer, logical,
and character arrays are rejected. MATLAB accepts a character array and
evaluates it at the character codes, which Octave deliberately does not,
since a character array is an integer type and integers are refused too.

See also:
gpinv,
gppdf,
gprnd,
gpfit,
gplike,
gpstat


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 58
Generalized Pareto cumulative distribution function (CDF).



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 5
gpinv


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1374
statistics: x = gpinv ( p , k , sigma , theta )

Inverse of the generalized Pareto cumulative distribution function (iCDF).

For each element of p , compute the quantile (the inverse of the CDF) of
the generalized Pareto distribution with shape parameter k , scale
parameter sigma , and location parameter theta . The size of
x is the common size of p , k , sigma , and theta .
A scalar input functions as a constant matrix of the same size as the other
inputs.

When k = 0 and theta = 0 , the Generalized Pareto
is equivalent to the exponential distribution. When k > 0 and
theta = k / k the Generalized Pareto is equivalent
to the Pareto distribution. The mean of the Generalized Pareto is not finite
when k >= 1 and the variance is not finite when
k >= 1/2 . When k >= 0 , the Generalized Pareto
has positive density for x > theta , or, when
theta < 0 , for
0 <= ( x - theta ) / sigma <= -1 / k .

Further information about the generalized Pareto distribution can be found at
https://en.wikipedia.org/wiki/Generalized_Pareto_distribution

Input arguments must be double or single ; integer, logical,
and character arrays are rejected. MATLAB accepts a character array and
evaluates it at the character codes, which Octave deliberately does not,
since a character array is an integer type and integers are refused too.

See also:
gpcdf,
gppdf,
gprnd,
gpfit,
gplike,
gpstat


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 74
Inverse of the generalized Pareto cumulative distribution function (iCDF).



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 5
gppdf


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1921
statistics: y = gppdf ( x , k , sigma , theta )

Generalized Pareto probability density function (PDF).

For each element of x , compute the probability density function (PDF)
of the generalized Pareto distribution with shape parameter k , scale
parameter sigma , and location parameter theta . The size of
y is the common size of p , k , sigma , and theta .
A scalar input functions as a constant matrix of the same size as the other
inputs.

When k = 0 and theta = 0 , the Generalized Pareto
is equivalent to the exponential distribution. When k > 0 and
theta = k / k the Generalized Pareto is equivalent
to the Pareto distribution. The mean of the Generalized Pareto is not finite
when k >= 1 and the variance is not finite when
k >= 1/2 . When k >= 0 , the Generalized Pareto
has positive density for x > theta , or, when
theta < 0 , for
0 <= ( x - theta ) / sigma <= -1 / k .

Further information about the generalized Pareto distribution can be found at
https://en.wikipedia.org/wiki/Generalized_Pareto_distribution

Input arguments must be double or single ; integer, logical,
and character arrays are rejected. MATLAB accepts a character array and
evaluates it at the character codes, which Octave deliberately does not,
since a character array is an integer type and integers are refused too.

With a negative shape parameter the support is the closed interval
[ theta , theta - sigma / k ] , and the density at
its upper endpoint follows the limit of the density there: 0 for
-1 < k < 0 , 1/ sigma at k = -1 , and
unbounded for k < -1 . MATLAB returns 0 at that endpoint
whatever the shape, which contradicts its own unifpdf : the
generalized Pareto with k = -1 is the uniform
distribution on [ theta , theta + sigma ] , for which
MATLAB&rsquo;s unifpdf returns 1/ sigma at the same point. This
implementation returns the limit, and so agrees with unifpdf .

See also:
gpcdf,
gpinv,
gprnd,
gpfit,
gplike,
gpstat


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 54
Generalized Pareto probability density function (PDF).



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 5
gprnd


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1595
statistics: r = gprnd ( k , sigma , theta )
statistics: r = gprnd ( k , sigma , theta , rows )
statistics: r = gprnd ( k , sigma , theta , rows , cols , &hellip;)
statistics: r = gprnd ( k , sigma , theta , [ sz ])

Random arrays from the generalized Pareto distribution.

r = gprnd ( k , sigma , theta ) returns an array
of random numbers chosen from the generalized Pareto distribution with shape
parameter k , scale parameter sigma , and location parameter
theta . The size of r is the common size of k , sigma ,
and theta . A scalar input functions as a constant matrix of the same
size as the other inputs.

When called with a single size argument, gprnd returns a square
matrix with the dimension specified. When called with more than one scalar
argument, the first two arguments are taken as the number of rows and columns
and any further arguments specify additional matrix dimensions. The size may
also be specified with a row vector of dimensions, sz .

When k = 0 and theta = 0 , the Generalized Pareto
is equivalent to the exponential distribution. When k > 0 and
theta = k / k the Generalized Pareto is equivalent
to the Pareto distribution. The mean of the Generalized Pareto is not finite
when k >= 1 and the variance is not finite when
k >= 1/2 . When k >= 0 , the Generalized Pareto
has positive density for x > theta , or, when
theta < 0 , for
0 <= ( x - theta ) / sigma <= -1 / k .

Further information about the generalized Pareto distribution can be found at
https://en.wikipedia.org/wiki/Generalized_Pareto_distribution

See also:
gpcdf,
gpinv,
gppdf,
gpfit,
gplike,
gpstat


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 55
Random arrays from the generalized Pareto distribution.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 9
gumbelcdf


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 2346
statistics: p = gumbelcdf ( x )
statistics: p = gumbelcdf ( x , mu )
statistics: p = gumbelcdf ( x , mu , beta )
statistics: p = gumbelcdf (&hellip;, 'upper' )
statistics: [ p , plo , pup ] = gumbelcdf ( x , mu , beta , pcov )
statistics: [ p , plo , pup ] = gumbelcdf ( x , mu , beta , pcov , alpha )
statistics: [ p , plo , pup ] = gumbelcdf (&hellip;, 'upper' )

Gumbel cumulative distribution function (CDF).

For each element of x , compute the cumulative distribution function
(CDF) of the Gumbel distribution (also known as the extreme value or the type
I generalized extreme value distribution) with location parameter mu
and scale parameter beta . The size of p is the common size of
x , mu and beta . A scalar input functions as a constant
matrix of the same size as the other inputs.

Default values are mu = 0 and beta = 1.

When called with three output arguments, i.e. [ p , plo ,
pup ] , gumbelcdf computes the confidence bounds for p when
the input parameters mu and beta are estimates. In such case,
pcov , a 2&times;2 matrix containing the covariance matrix of the
estimated parameters, is necessary. Optionally, alpha , which has a
default value of 0.05, specifies the 100 * (1 - alpha ) percent
confidence bounds. plo and pup are arrays of the same size as
p containing the lower and upper confidence bounds.

[&hellip;] = gumbelcdf (&hellip;, "upper") computes the upper tail
probability of the Gumbel distribution with parameters mu and
beta , at the values in x .

The Gumbel distribution is used to model the distribution of the maximum (or
the minimum) of a number of samples of various distributions. This version
is suitable for modeling maxima. For modeling minima, use the alternative
extreme value CDF, evcdf .

[&hellip;] = gumbelcdf (&hellip;, "upper") computes the upper tail
probability of the extreme value (Gumbel) distribution.

Further information about the Gumbel distribution can be found at
https://en.wikipedia.org/wiki/Gumbel_distribution

Input arguments must be double or single ; integer, logical,
and character arrays are rejected. MATLAB accepts a character array and
evaluates it at the character codes, which Octave deliberately does not,
since a character array is an integer type and integers are refused too.

See also:
gumbelinv,
gumbelpdf,
gumbelrnd,
gumbelfit,
gumbellike,
gumbelstat,
evcdf


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 46
Gumbel cumulative distribution function (CDF).



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 9
gumbelinv


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1966
statistics: x = gumbelinv ( p )
statistics: x = gumbelinv ( p , mu )
statistics: x = gumbelinv ( p , mu , beta )
statistics: [ x , xlo , xup ] = gumbelinv ( p , mu , beta , pcov )
statistics: [ x , xlo , xup ] = gumbelinv ( p , mu , beta , pcov , alpha )

Inverse of the Gumbel cumulative distribution function (iCDF).

For each element of p , compute the quantile (the inverse of the CDF) of
the Gumbel distribution (also known as the extreme value or the type I
generalized extreme value distribution) with location parameter mu and
scale parameter beta . The size of x is the common size of
p , mu and beta . A scalar input functions as a constant
matrix of the same size as the other inputs.

Default values are mu = 0 and beta = 1.

When called with three output arguments, i.e. [ x , xlo ,
xup ] , gumbelinv computes the confidence bounds for x when
the input parameters mu and beta are estimates. In such case,
pcov , a 2&times;2 matrix containing the covariance matrix of the
estimated parameters, is necessary. Optionally, alpha , which has a
default value of 0.05, specifies the 100 * (1 - alpha ) percent
confidence bounds. xlo and xup are arrays of the same size as
x containing the lower and upper confidence bounds.

The Gumbel distribution is used to model the distribution of the maximum (or
the minimum) of a number of samples of various distributions. This version
is suitable for modeling maxima. For modeling minima, use the alternative
extreme value iCDF, evinv .

Further information about the Gumbel distribution can be found at
https://en.wikipedia.org/wiki/Gumbel_distribution

Input arguments must be double or single ; integer, logical,
and character arrays are rejected. MATLAB accepts a character array and
evaluates it at the character codes, which Octave deliberately does not,
since a character array is an integer type and integers are refused too.

See also:
gumbelcdf,
gumbelpdf,
gumbelrnd,
gumbelfit,
gumbellike,
gumbelstat,
evinv


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 62
Inverse of the Gumbel cumulative distribution function (iCDF).



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 9
gumbelpdf


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1312
statistics: y = gumbelpdf ( x )
statistics: y = gumbelpdf ( x , mu )
statistics: y = gumbelpdf ( x , mu , beta )

Gumbel probability density function (PDF).

For each element of x , compute the probability density function (PDF)
of the Gumbel distribution (also known as the extreme value or the type I
generalized extreme value distribution) with location parameter mu and
scale parameter beta . The size of y is the common size of
x , mu and beta . A scalar input functions as a constant
matrix of the same size as the other inputs.

Default values are mu = 0 and beta = 1.

The Gumbel distribution is used to model the distribution of the maximum (or
the minimum) of a number of samples of various distributions. This version
is suitable for modeling maxima. For modeling minima, use the alternative
extreme value iCDF, evpdf .

Further information about the Gumbel distribution can be found at
https://en.wikipedia.org/wiki/Gumbel_distribution

Input arguments must be double or single ; integer, logical,
and character arrays are rejected. MATLAB accepts a character array and
evaluates it at the character codes, which Octave deliberately does not,
since a character array is an integer type and integers are refused too.

See also:
gumbelcdf,
gumbelinv,
gumbelrnd,
gumbelfit,
gumbellike,
gumbelstat,
evpdf


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 42
Gumbel probability density function (PDF).



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 9
gumbelrnd


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1430
statistics: r = gumbelrnd ( mu , beta )
statistics: r = gumbelrnd ( mu , beta , rows )
statistics: r = gumbelrnd ( mu , beta , rows , cols , &hellip;)
statistics: r = gumbelrnd ( mu , beta , [ sz ])

Random arrays from the Gumbel distribution.

r = gumbelrnd ( mu , beta ) returns an array of random
numbers chosen from the Gumbel distribution (also known as the extreme value
or the type I generalized extreme value distribution) with location
parameter mu and scale parameter beta . The size of r is
the common size of mu and beta . A scalar input functions as a
constant matrix of the same size as the other inputs.

When called with a single size argument, gumbelrnd returns a square
matrix with the dimension specified. When called with more than one scalar
argument, the first two arguments are taken as the number of rows and columns
and any further arguments specify additional matrix dimensions. The size may
also be specified with a row vector of dimensions, sz .

The Gumbel distribution is used to model the distribution of the maximum (or
the minimum) of a number of samples of various distributions. This version
is suitable for modeling maxima. For modeling minima, use the alternative
extreme value iCDF, evinv .

Further information about the Gumbel distribution can be found at
https://en.wikipedia.org/wiki/Gumbel_distribution

See also:
gumbelcdf,
gumbelinv,
gumbelpdf,
gumbelfit,
gumbellike,
gumbelstat,
evrnd


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 43
Random arrays from the Gumbel distribution.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 5
hncdf


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1126
statistics: p = hncdf ( x , mu , sigma )
statistics: p = hncdf ( x , mu , sigma , 'upper' )

Half-normal cumulative distribution function (CDF).

For each element of x , compute the cumulative distribution function
(CDF) of the half-normal distribution with location parameter mu and
scale parameter sigma . The size of p is the common size of
x , mu and sigma . A scalar input functions as a constant
matrix of the same size as the other inputs.

[&hellip;] = hncdf ( x , mu , sigma , "upper") computes
the upper tail probability of the half-normal distribution with parameters
mu and sigma , at the values in x .

The half-normal CDF is only defined for x >= mu .

Further information about the half-normal distribution can be found at
https://en.wikipedia.org/wiki/Half-normal_distribution

Input arguments must be double or single ; integer, logical,
and character arrays are rejected. MATLAB accepts a character array and
evaluates it at the character codes, which Octave deliberately does not,
since a character array is an integer type and integers are refused too.

See also:
hninv,
hnpdf,
hnrnd,
hnfit,
hnlike,
hnstat


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 51
Half-normal cumulative distribution function (CDF).



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 5
hninv


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 869
statistics: x = hninv ( p , mu , sigma )

Inverse of the half-normal cumulative distribution function (iCDF).

For each element of p , compute the quantile (the inverse of the CDF) of
the half-normal distribution with location parameter mu and scale
parameter sigma . The size of x is the common size of p ,
mu , and sigma . A scalar input functions as a constant matrix of
the same size as the other inputs.

Further information about the half-normal distribution can be found at
https://en.wikipedia.org/wiki/Half-normal_distribution

Input arguments must be double or single ; integer, logical,
and character arrays are rejected. MATLAB accepts a character array and
evaluates it at the character codes, which Octave deliberately does not,
since a character array is an integer type and integers are refused too.

See also:
hncdf,
hnpdf,
hnrnd,
hnfit,
hnlike,
hnstat


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 67
Inverse of the half-normal cumulative distribution function (iCDF).



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 5
hnpdf


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 901
statistics: y = hnpdf ( x , mu , sigma )

Half-normal probability density function (PDF).

For each element of x , compute the probability density function (PDF)
of the half-normal distribution with location parameter mu and scale
parameter sigma . The size of y is the common size of x ,
mu , and sigma . A scalar input functions as a constant matrix of
the same size as the other inputs.

The half-normal CDF is only defined for x >= mu .

Further information about the half-normal distribution can be found at
https://en.wikipedia.org/wiki/Half-normal_distribution

Input arguments must be double or single ; integer, logical,
and character arrays are rejected. MATLAB accepts a character array and
evaluates it at the character codes, which Octave deliberately does not,
since a character array is an integer type and integers are refused too.

See also:
hncdf,
hninv,
hnrnd,
hnfit,
hnlike,
hnstat


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 47
Half-normal probability density function (PDF).



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 5
hnrnd


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1060
statistics: r = hnrnd ( mu , sigma )
statistics: r = hnrnd ( mu , sigma , rows )
statistics: r = hnrnd ( mu , sigma , rows , cols , &hellip;)
statistics: r = hnrnd ( mu , sigma , [ sz ])

Random arrays from the half-normal distribution.

r = hnrnd ( mu , sigma ) returns an array of random
numbers chosen from the half-normal distribution with location parameter
mu and scale parameter sigma . The size of r is the common
size of mu and sigma . A scalar input functions as a constant
matrix of the same size as the other inputs.

When called with a single size argument, hnrnd returns a square
matrix with the dimension specified. When called with more than one scalar
argument, the first two arguments are taken as the number of rows and columns
and any further arguments specify additional matrix dimensions. The size may
also be specified with a row vector of dimensions, sz .

Further information about the half-normal distribution can be found at
https://en.wikipedia.org/wiki/Half-normal_distribution

See also:
hncdf,
hninv,
hnpdf,
hnfit,
hnlike,
hnstat


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 48
Random arrays from the half-normal distribution.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 7
hygecdf


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1422
statistics: p = hygecdf ( x , m , k , n )
statistics: p = hygecdf ( x , m , k , n , 'upper' )

Hypergeometric cumulative distribution function (CDF).

For each element of x , compute the cumulative distribution function
(CDF) of the hypergeometric distribution with parameters m , k ,
and n . The size of p is the common size of x , m ,
k , and n . A scalar input functions as a constant matrix of the
same size as the other inputs.

This is the cumulative probability of obtaining not more than x marked
items when randomly drawing a sample of size n without replacement from
a population of total size m containing k marked items. The
parameters m , k , and n must be positive integers with
k and n not greater than m .

[&hellip;] = hygecdf ( x , m , k , n , "upper")
computes the upper tail probability of the hypergeometric distribution with
parameters m , k , and n , at the values in x .

Further information about the hypergeometric distribution can be found at
https://en.wikipedia.org/wiki/Hypergeometric_distribution

Input arguments must be double , single , or an integer type;
logical and character arrays are rejected. Integer input is promoted to
double , so the result is always a probability. MATLAB is
inconsistent here: for several of the discrete distributions it returns the
result in the integer class of the input, truncating a probability to
0 or 1 .

See also:
hygeinv,
hygepdf,
hygernd,
hygestat


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 54
Hypergeometric cumulative distribution function (CDF).



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 7
hygeinv


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1130
statistics: x = hygeinv ( p , m , k , n )

Inverse of the hypergeometric cumulative distribution function (iCDF).

For each element of p , compute the quantile (the inverse of the CDF) of
the hypergeometric distribution with parameters m , k , and
n . The size of x is the common size of p , m , k ,
and
n . A scalar input functions as a constant matrix of the same size as
the other inputs.

This is the number of drawn marked items x given a probability p ,
when randomly drawing a sample of size n without replacement from a
population of total size m containing k marked items. The
parameters m , k , and n must be positive integers with
k and n not greater than m .

Further information about the hypergeometric distribution can be found at
https://en.wikipedia.org/wiki/Hypergeometric_distribution

Input arguments must be double or single ; integer, logical,
and character arrays are rejected. MATLAB accepts a character array and
evaluates it at the character codes, which Octave deliberately does not,
since a character array is an integer type and integers are refused too.

See also:
hygecdf,
hygepdf,
hygernd,
hygestat


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 70
Inverse of the hypergeometric cumulative distribution function (iCDF).



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 7
hygepdf


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1581
statistics: y = hygepdf ( x , m , k , n )
statistics: y = hygepdf (&hellip;, 'vectorexpand' )

Hypergeometric probability density function (PDF).

For each element of x , compute the probability density function (PDF)
of the hypergeometric distribution with parameters m , k , and
n . The size of y is the common size of x , m ,
k , and n . A scalar input functions as a constant matrix of the
same size as the other inputs.

This is the probability of obtaining x marked items when randomly
drawing a sample of size n without replacement from a population of
total size m containing k marked items. The parameters m ,
k , and n must be positive integers with k and n not
greater than m .

If the optional parameter vectorexpand is provided, x may be an
array with size different from parameters m , k , and n
(which must still be of a common size or scalar). Each element of x
will be evaluated against each set of parameters m , k , and
n in columnwise order. The output y will be an array of size
r x s , where r = numel ( m ) , and
s = numel ( x ) .

Further information about the hypergeometric distribution can be found at
https://en.wikipedia.org/wiki/Hypergeometric_distribution

Input arguments must be double , single , or an integer type;
logical and character arrays are rejected. Integer input is promoted to
double , so the result is always a probability. MATLAB is
inconsistent here: for several of the discrete distributions it returns the
result in the integer class of the input, truncating a probability to
0 or 1 .

See also:
hygecdf,
hygeinv,
hygernd,
hygestat


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 50
Hypergeometric probability density function (PDF).



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 7
hygernd


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1139
statistics: r = hygernd ( m , k , n )
statistics: r = hygernd ( m , k , n , rows )
statistics: r = hygernd ( m , k , n , rows , cols , &hellip;)
statistics: r = hygernd ( m , k , n , [ sz ])

Random arrays from the hypergeometric distribution.

r = hygernd (( m , k , n returns an array of
random numbers chosen from the hypergeometric distribution with parameters
m , k , and n . The size of r is the common size of
m , k , and n . A scalar input functions as a constant matrix
of the same size as the other inputs.

The parameters m , k , and n must be positive integers
with k and n not greater than m .

When called with a single size argument, hygernd returns a square
matrix with the dimension specified. When called with more than one scalar
argument, the first two arguments are taken as the number of rows and columns
and any further arguments specify additional matrix dimensions. The size may
also be specified with a row vector of dimensions, sz .

Further information about the hypergeometric distribution can be found at
https://en.wikipedia.org/wiki/Hypergeometric_distribution

See also:
hygecdf,
hygeinv,
hygepdf,
hygestat


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 51
Random arrays from the hypergeometric distribution.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 7
invgcdf


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1182
statistics: p = invgcdf ( x , mu , lambda )
statistics: p = invgcdf ( x , mu , lambda , 'upper' )

Inverse Gaussian cumulative distribution function (CDF).

For each element of x , compute the cumulative distribution function
(CDF) of the inverse Gaussian distribution with scale parameter mu and
shape parameter lambda . The size of p is the common size of
x , mu and lambda . A scalar input functions as a constant
matrix of the same size as the other inputs.

p = invgcdf ( x , mu , lambda , "upper") computes
the upper tail probability of the inverse Gaussian distribution with
parameters mu and lambda , at the values in x .

The inverse Gaussian CDF is only defined for mu > 0 and
lambda > 0 .

Further information about the inverse Gaussian distribution can be found at
https://en.wikipedia.org/wiki/Inverse_Gaussian_distribution

Input arguments must be double or single ; integer, logical,
and character arrays are rejected. MATLAB accepts a character array and
evaluates it at the character codes, which Octave deliberately does not,
since a character array is an integer type and integers are refused too.

See also:
invginv,
invgpdf,
invgrnd,
invgfit,
invglike,
invgstat


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 56
Inverse Gaussian cumulative distribution function (CDF).



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 7
invginv


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 973
statistics: x = invginv ( p , mu , lambda )

Inverse of the inverse Gaussian cumulative distribution function (iCDF).

For each element of p , compute the quantile (the inverse of the CDF) of
the inverse Gaussian distribution with scale parameter mu and shape
parameter lambda . The size of x is the common size of p ,
mu , and lambda . A scalar input functions as a constant matrix of
the same size as the other inputs.

The inverse Gaussian CDF is only defined for mu > 0 and
lambda > 0 .

Further information about the inverse Gaussian distribution can be found at
https://en.wikipedia.org/wiki/Inverse_Gaussian_distribution

Input arguments must be double or single ; integer, logical,
and character arrays are rejected. MATLAB accepts a character array and
evaluates it at the character codes, which Octave deliberately does not,
since a character array is an integer type and integers are refused too.

See also:
invgcdf,
invgpdf,
invgrnd,
invgfit,
invglike,
invgstat


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 72
Inverse of the inverse Gaussian cumulative distribution function (iCDF).



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 7
invgpdf


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 954
statistics: y = invgpdf ( x , mu , lambda )

Inverse Gaussian probability density function (PDF).

For each element of x , compute the probability density function (PDF)
of the inverse Gaussian distribution with scale parameter mu and shape
parameter lambda . The size of y is the common size of x ,
mu , and lambda . A scalar input functions as a constant matrix of
the same size as the other inputs.

The inverse Gaussian CDF is only defined for mu > 0 and
lambda > 0 .

Further information about the inverse Gaussian distribution can be found at
https://en.wikipedia.org/wiki/Inverse_Gaussian_distribution

Input arguments must be double or single ; integer, logical,
and character arrays are rejected. MATLAB accepts a character array and
evaluates it at the character codes, which Octave deliberately does not,
since a character array is an integer type and integers are refused too.

See also:
invgcdf,
invginv,
invgrnd,
invgfit,
invglike,
invgstat


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 52
Inverse Gaussian probability density function (PDF).



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 7
invgrnd


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1181
statistics: r = invgrnd ( mu , lambda )
statistics: r = invgrnd ( mu , lambda , rows )
statistics: r = invgrnd ( mu , lambda , rows , cols , &hellip;)
statistics: r = invgrnd ( mu , lambda , [ sz ])

Random arrays from the inverse Gaussian distribution.

r = invgrnd ( mu , lambda ) returns an array of random
numbers chosen from the inverse Gaussian distribution with location parameter
mu and scale parameter lambda . The size of r is the common
size of mu and lambda . A scalar input functions as a constant
matrix of the same size as the other inputs.

When called with a single size argument, invgrnd returns a square
matrix with the dimension specified. When called with more than one scalar
argument, the first two arguments are taken as the number of rows and columns
and any further arguments specify additional matrix dimensions. The size may
also be specified with a row vector of dimensions, sz .

The inverse Gaussian CDF is only defined for mu > 0 and
lambda > 0 .

Further information about the inverse Gaussian distribution can be found at
https://en.wikipedia.org/wiki/Inverse_Gaussian_distribution

See also:
invgcdf,
invginv,
invgpdf,
invgfit,
invglike,
invgstat


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 53
Random arrays from the inverse Gaussian distribution.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 8
iwishpdf


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 914
statistics: y = iwishpdf ( W , Tau , df , log_y =false)

Compute the probability density function of the inverse Wishart distribution.

Inputs: A p x p matrix W where to find the PDF and the
p x p positive definite scale matrix Tau and scalar degrees
of freedom parameter df characterizing the inverse Wishart
distribution. (For the density to be finite, need df > ( p - 1).)
If the flag log_y is set, return the log probability density &ndash; this
helps avoid underflow when the numerical value of the density is very small.

Output: y is the probability density of Wishart( Sigma , df )
at W .

Input arguments must be double or single ; integer, logical,
and character arrays are rejected. MATLAB accepts a character array and
evaluates it at the character codes, which Octave deliberately does not,
since a character array is an integer type and integers are refused too.

See also:
iwishrnd,
wishpdf,
wishrnd


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 77
Compute the probability density function of the inverse Wishart distribution.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 8
iwishrnd


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 974
statistics: [ W , DI ] = iwishrnd ( Tau , df , DI , n =1)

Return a random matrix sampled from the inverse Wishart distribution with
given parameters.

Inputs: the p &times; p positive definite matrix Tau and scalar
degrees of freedom parameter df (and optionally the transposed Cholesky
factor DI of Sigma = inv(Tau) ).

df can be non-integer as long as df > d

Output: a random p &times; p matrix W from the inverse
Wishart( Tau , df ) distribution. ( inv(W) is from the
Wishart( inv(Tau) , df ) distribution.) If n > 1,
then W is p x p x n and holds n such random
matrices. (Optionally, the transposed Cholesky factor DI of Sigma
is also returned.)

Averaged across many samples, the mean of W should approach
Tau / ( df - p - 1).

References

Yu-Cheng Ku and Peter Bloomfield (2010), Generating Random Wishart Matrices
with Fractional Degrees of Freedom in OX,
http://www.gwu.edu/~forcpgm/YuChengKu-030510final-WishartYu-ChengKu.pdf

See also:
iwishpdf,
wishpdf,
wishrnd


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 91
Return a random matrix sampled from the inverse Wishart distribution with given parameters.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 6
jsucdf


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 819
statistics: p = jsucdf ( x )
statistics: p = jsucdf ( x , alpha1 )
statistics: p = jsucdf ( x , alpha1 , alpha2 )

Johnson SU cumulative distribution function (CDF).

For each element of x , return the cumulative distribution functions
(CDF) at x of the Johnson SU distribution with shape parameters
alpha1 and alpha2 . The size of p is the common size of the
input arguments x , alpha1 , and alpha2 . A scalar input
functions as a constant matrix of the same size as the other

Default values are alpha1 = 1, alpha2 = 1.

Input arguments must be double or single ; integer, logical,
and character arrays are rejected. MATLAB accepts a character array and
evaluates it at the character codes, which Octave deliberately does not,
since a character array is an integer type and integers are refused too.

See also:
jsupdf


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 50
Johnson SU cumulative distribution function (CDF).



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 6
jsupdf


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 811
statistics: y = jsupdf ( x )
statistics: y = jsupdf ( x , alpha1 )
statistics: y = jsupdf ( x , alpha1 , alpha2 )

Johnson SU probability density function (PDF).

For each element of x , compute the probability density function (PDF)
at x of the Johnson SU distribution with shape parameters alpha1
and alpha2 . The size of p is the common size of the input
arguments x , alpha1 , and alpha2 . A scalar input functions
as a constant matrix of the same size as the other

Default values are alpha1 = 1, alpha2 = 1.

Input arguments must be double or single ; integer, logical,
and character arrays are rejected. MATLAB accepts a character array and
evaluates it at the character codes, which Octave deliberately does not,
since a character array is an integer type and integers are refused too.

See also:
jsucdf


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 46
Johnson SU probability density function (PDF).



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 10
laplacecdf


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1147
statistics: p = laplacecdf ( x , mu , beta )
statistics: p = laplacecdf ( x , mu , beta , 'upper' )

Laplace cumulative distribution function (CDF).

For each element of x , compute the cumulative distribution function
(CDF) of the Laplace distribution with location parameter mu and scale
parameter (i.e. "diversity") beta . The size of p is the common
size of x , mu , and beta . A scalar input functions as a
constant matrix of the same size as the other inputs.

Both parameters must be reals and beta > 0 .
For beta <= 0 , NaN is returned.

p = laplacecdf ( x , mu , beta , "upper") computes
the upper tail probability of the Laplace distribution with parameters
mu and beta , at the values in x .

Further information about the Laplace distribution can be found at
https://en.wikipedia.org/wiki/Laplace_distribution

Input arguments must be double or single ; integer, logical,
and character arrays are rejected. MATLAB accepts a character array and
evaluates it at the character codes, which Octave deliberately does not,
since a character array is an integer type and integers are refused too.

See also:
laplaceinv,
laplacepdf,
laplacernd


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 47
Laplace cumulative distribution function (CDF).



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 10
laplaceinv


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 945
statistics: x = laplaceinv ( p , mu , beta )

Inverse of the Laplace cumulative distribution function (iCDF).

For each element of p , compute the quantile (the inverse of the CDF) of
the Laplace distribution with location parameter mu and scale parameter
(i.e. "diversity") beta . The size of x is the common size of
p , mu , and beta . A scalar input functions as a constant
matrix of the same size as the other inputs.

Both parameters must be reals and beta > 0 .
For beta <= 0 , NaN is returned.

Further information about the Laplace distribution can be found at
https://en.wikipedia.org/wiki/Laplace_distribution

Input arguments must be double or single ; integer, logical,
and character arrays are rejected. MATLAB accepts a character array and
evaluates it at the character codes, which Octave deliberately does not,
since a character array is an integer type and integers are refused too.

See also:
laplacecdf,
laplacepdf,
laplacernd


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 63
Inverse of the Laplace cumulative distribution function (iCDF).



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 10
laplacepdf


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 926
statistics: y = laplacepdf ( x , mu , beta )

Laplace probability density function (PDF).

For each element of x , compute the probability density function (PDF)
of the Laplace distribution with location parameter mu and scale
parameter (i.e. "diversity") beta . The size of y is the common
size of x , mu , and beta . A scalar input functions as a
constant matrix of the same size as the other inputs.

Both parameters must be reals and beta > 0 .
For beta <= 0 , NaN is returned.

Further information about the Laplace distribution can be found at
https://en.wikipedia.org/wiki/Laplace_distribution

Input arguments must be double or single ; integer, logical,
and character arrays are rejected. MATLAB accepts a character array and
evaluates it at the character codes, which Octave deliberately does not,
since a character array is an integer type and integers are refused too.

See also:
laplacecdf,
laplaceinv,
laplacernd


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 43
Laplace probability density function (PDF).



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 10
laplacernd


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1138
statistics: r = laplacernd ( mu , beta )
statistics: r = laplacernd ( mu , beta , rows )
statistics: r = laplacernd ( mu , beta , rows , cols , &hellip;)
statistics: r = laplacernd ( mu , beta , [ sz ])

Random arrays from the Laplace distribution.

r = laplacernd ( mu , beta ) returns an array of
random numbers chosen from the Laplace distribution with location parameter
mu and scale parameter beta . The size of r is the common
size of mu and beta . A scalar input functions as a constant
matrix of the same size as the other inputs.

Both parameters must be reals and beta > 0 .
For beta <= 0 , NaN is returned.

When called with a single size argument, laplacernd returns a square
matrix with the dimension specified. When called with more than one scalar
argument, the first two arguments are taken as the number of rows and columns
and any further arguments specify additional matrix dimensions. The size may
also be specified with a row vector of dimensions, sz .

Further information about the Laplace distribution can be found at
https://en.wikipedia.org/wiki/Laplace_distribution

See also:
laplacecdf,
laplaceinv,
laplacepdf


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 44
Random arrays from the Laplace distribution.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 7
logicdf


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1152
statistics: p = logicdf ( x , mu , sigma )
statistics: p = logicdf ( x , mu , sigma , 'upper' )

Logistic cumulative distribution function (CDF).

For each element of x , compute the cumulative distribution function
(CDF) of the logistic distribution with location parameter mu and scale
parameter sigma . The size of p is the common size of x ,
mu , and sigma . A scalar input functions as a constant matrix of
the same size as the other inputs.

Both parameters must be reals and sigma > 0 .
For sigma <= 0 , NaN is returned.

p = logicdf ( x , mu , sigma , "upper") computes
the upper tail probability of the logistic distribution with parameters
mu and sigma , at the values in x .

Further information about the logistic distribution can be found at
https://en.wikipedia.org/wiki/Logistic_distribution

Input arguments must be double or single ; integer, logical,
and character arrays are rejected. MATLAB accepts a character array and
evaluates it at the character codes, which Octave deliberately does not,
since a character array is an integer type and integers are refused too.

See also:
logiinv,
logipdf,
logirnd,
logifit,
logilike,
logistat


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 48
Logistic cumulative distribution function (CDF).



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 7
logiinv


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 952
statistics: x = logiinv ( p , mu , sigma )

Inverse of the logistic cumulative distribution function (iCDF).

For each element of p , compute the quantile (the inverse of the CDF) of
the logistic distribution with location parameter mu and scale
parameter sigma . The size of p is the common size of x ,
mu , and sigma . A scalar input functions as a constant matrix of
the same size as the other inputs.

Both parameters must be reals and sigma > 0 .
For sigma <= 0 , NaN is returned.

Further information about the logistic distribution can be found at
https://en.wikipedia.org/wiki/Logistic_distribution

Input arguments must be double or single ; integer, logical,
and character arrays are rejected. MATLAB accepts a character array and
evaluates it at the character codes, which Octave deliberately does not,
since a character array is an integer type and integers are refused too.

See also:
logicdf,
logipdf,
logirnd,
logifit,
logilike,
logistat


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 64
Inverse of the logistic cumulative distribution function (iCDF).



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 7
logipdf


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 933
statistics: y = logipdf ( x , mu , sigma )

Logistic probability density function (PDF).

For each element of x , compute the probability density function (PDF)
of the logistic distribution with location parameter mu and scale
parameter sigma . The size of p is the common size of x ,
mu , and sigma . A scalar input functions as a constant matrix of
the same size as the other inputs.

Both parameters must be reals and sigma > 0 .
For sigma <= 0 , NaN is returned.

Further information about the logistic distribution can be found at
https://en.wikipedia.org/wiki/Logistic_distribution

Input arguments must be double or single ; integer, logical,
and character arrays are rejected. MATLAB accepts a character array and
evaluates it at the character codes, which Octave deliberately does not,
since a character array is an integer type and integers are refused too.

See also:
logicdf,
logiinv,
logirnd,
logifit,
logilike,
logistat


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 44
Logistic probability density function (PDF).



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 7
logirnd


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1152
statistics: r = logirnd ( mu , sigma )
statistics: r = logirnd ( mu , sigma , rows )
statistics: r = logirnd ( mu , sigma , rows , cols , &hellip;)
statistics: r = logirnd ( mu , sigma , [ sz ])

Random arrays from the logistic distribution.

r = logirnd ( mu , sigma ) returns an array of
random numbers chosen from the logistic distribution with location parameter
mu and scale parameter sigma . The size of r is the common
size
of mu and sigma . A scalar input functions as a constant matrix of
the same size as the other inputs.

Both parameters must be reals and sigma > 0 .
For sigma <= 0 , NaN is returned.

When called with a single size argument, logirnd returns a square
matrix with the dimension specified. When called with more than one scalar
argument, the first two arguments are taken as the number of rows and columns
and any further arguments specify additional matrix dimensions. The size may
also be specified with a row vector of dimensions, sz .

Further information about the logistic distribution can be found at
https://en.wikipedia.org/wiki/Logistic_distribution

See also:
logcdf,
logiinv,
logipdf,
logifit,
logilike,
logistat


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 45
Random arrays from the logistic distribution.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 7
loglcdf


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1541
statistics: p = loglcdf ( x , mu , sigma )
statistics: p = loglcdf ( x , mu , sigma , 'upper' )

Loglogistic cumulative distribution function (CDF).

For each element of x , compute the cumulative distribution function
(CDF) of the loglogistic distribution with mean parameter mu and scale
parameter sigma . The size of p is the common size of x ,
mu , and sigma . A scalar input functions as a constant matrix of
the same size as the other inputs.

Mean of logarithmic values mu must be a non-negative real value, scale
parameter of logarithmic values sigma must be a positive real value and
x is supported in the range [0,Inf) , otherwise NaN is
returned.

p = loglcdf ( x , mu , sigma , "upper") computes
the upper tail probability of the log-logistic distribution with parameters
mu and sigma , at the values in x .

Further information about the loglogistic distribution can be found at
https://en.wikipedia.org/wiki/Log-logistic_distribution

OCTAVE/MATLAB use an alternative parameterization given by the pair
μ, σ , i.e. mu and sigma , in analogy with the logistic
distribution. Their relation to the α and b parameters used
in Wikipedia are given below:

mu = log ( a )
sigma = 1 / a

Input arguments must be double or single ; integer, logical,
and character arrays are rejected. MATLAB accepts a character array and
evaluates it at the character codes, which Octave deliberately does not,
since a character array is an integer type and integers are refused too.

See also:
loglinv,
loglpdf,
loglrnd,
loglfit,
logllike,
loglstat


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 51
Loglogistic cumulative distribution function (CDF).



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 7
loglinv


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1337
statistics: x = loglinv ( p , mu , sigma )

Inverse of the log-logistic cumulative distribution function (iCDF).

For each element of p , compute the quantile (the inverse of the CDF) of
the log-logistic distribution with mean parameter mu and scale
parameter sigma . The size of x is the common size of p ,
mu , and sigma . A scalar input functions as a constant matrix of
the same size as the other inputs.

Mean of logarithmic values mu must be a non-negative real value, scale
parameter of logarithmic values sigma must be a positive real value and
p is supported in the range [0,1] , otherwise NaN is
returned.

Further information about the loglogistic distribution can be found at
https://en.wikipedia.org/wiki/Log-logistic_distribution

OCTAVE/MATLAB use an alternative parameterization given by the pair
μ, σ , i.e. mu and sigma , in analogy with the logistic
distribution. Their relation to the α and b parameters used
in Wikipedia are given below:

mu = log ( a )
sigma = 1 / a

Input arguments must be double or single ; integer, logical,
and character arrays are rejected. MATLAB accepts a character array and
evaluates it at the character codes, which Octave deliberately does not,
since a character array is an integer type and integers are refused too.

See also:
loglcdf,
loglpdf,
loglrnd,
loglfit,
logllike,
loglstat


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 68
Inverse of the log-logistic cumulative distribution function (iCDF).



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 7
loglpdf


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1316
statistics: y = loglpdf ( x , mu , sigma )

Loglogistic probability density function (PDF).

For each element of x , compute the probability density function (PDF)
of the loglogistic distribution with mean parameter mu and scale
parameter sigma . The size of y is the common size of x ,
mu , and sigma . A scalar input functions as a constant matrix of
the same size as the other inputs.

Mean of logarithmic values mu must be a non-negative real value, scale
parameter of logarithmic values sigma must be a positive real value and
x is supported in the range [0,Inf) , otherwise 0 is returned.

Further information about the loglogistic distribution can be found at
https://en.wikipedia.org/wiki/Log-logistic_distribution

OCTAVE/MATLAB use an alternative parameterization given by the pair
μ, σ , i.e. mu and sigma , in analogy with the logistic
distribution. Their relation to the α and b parameters used
in Wikipedia are given below:

mu = log ( a )
sigma = 1 / a

Input arguments must be double or single ; integer, logical,
and character arrays are rejected. MATLAB accepts a character array and
evaluates it at the character codes, which Octave deliberately does not,
since a character array is an integer type and integers are refused too.

See also:
loglcdf,
loglinv,
loglrnd,
loglfit,
logllike,
loglstat


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 47
Loglogistic probability density function (PDF).



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 7
loglrnd


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1476
statistics: r = loglrnd ( mu , sigma )
statistics: r = loglrnd ( mu , sigma , rows )
statistics: r = loglrnd ( mu , sigma , rows , cols , &hellip;)
statistics: r = loglrnd ( mu , sigma , [ sz ])

Random arrays from the loglogistic distribution.

r = loglrnd ( mu , sigma ) returns an array of random
numbers chosen from the loglogistic distribution with mean parameter mu
and scale parameter sigma . The size of r is the common size of
mu and sigma . A scalar input functions as a constant matrix of
the same size as the other inputs.

Mean of logarithmic values mu must be a non-negative real value and
scale parameter of logarithmic values sigma must be a positive real
value.

When called with mu single size argument, loglrnd returns mu square
matrix with the dimension specified. When called with more than one scalar
argument, the first two arguments are taken as the number of rows and columns
and any further arguments specify additional matrix dimensions. The size may
also be specified with mu row vector of dimensions, sz .

Further information about the loglogistic distribution can be found at
https://en.wikipedia.org/wiki/Log-logistic_distribution

OCTAVE/MATLAB use an alternative parameterization given by the pair
μ, σ , i.e. mu and sigma , in analogy with the logistic
distribution. Their relation to the α and b parameters used
in Wikipedia are given below:

mu = log ( a )
sigma = 1 / a

See also:
loglcdf,
loglinv,
loglpdf,
loglfit,
logllike,
loglstat


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 48
Random arrays from the loglogistic distribution.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 7
logncdf


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 2160
statistics: p = logncdf ( x )
statistics: p = logncdf ( x , mu )
statistics: p = logncdf ( x , mu , sigma )
statistics: p = logncdf (&hellip;, 'upper' )
statistics: [ p , plo , pup ] = logncdf ( x , mu , sigma , pcov )
statistics: [ p , plo , pup ] = logncdf ( x , mu , sigma , pcov , alpha )
statistics: [ p , plo , pup ] = logncdf (&hellip;, 'upper' )

Lognormal cumulative distribution function (CDF).

For each element of x , compute the cumulative distribution function
(CDF) of the lognormal distribution with mean parameter mu and
standard deviation parameter sigma , each corresponding to the
associated normal distribution. The size of p is the common size of
x , mu , and sigma . A scalar input functions as a constant
matrix of the same size as the other inputs.

If a random variable follows this distribution, its logarithm is normally
distributed with mean mu and standard deviation sigma .

Default parameter values are mu = 0 and
sigma = 1 . Both parameters must be reals and
sigma > 0 . For sigma <= 0 , NaN is
returned.

When called with three output arguments, i.e. [ p , plo ,
pup ] , logncdf computes the confidence bounds for p when
the input parameters mu and sigma are estimates. In such case,
pcov , a 2&times;2 matrix containing the covariance matrix of the
estimated parameters, is necessary. Optionally, alpha , which has a
default value of 0.05, specifies the 100 * (1 - alpha ) percent
confidence bounds. plo and pup are arrays of the same size as
p containing the lower and upper confidence bounds.

[&hellip;] = logncdf (&hellip;, "upper") computes the upper tail
probability of the log-normal distribution with parameters mu and
sigma , at the values in x .

Further information about the lognormal distribution can be found at
https://en.wikipedia.org/wiki/Log-normal_distribution

Input arguments must be double or single ; integer, logical,
and character arrays are rejected. MATLAB accepts a character array and
evaluates it at the character codes, which Octave deliberately does not,
since a character array is an integer type and integers are refused too.

See also:
logninv,
lognpdf,
lognrnd,
lognfit,
lognlike,
lognstat


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 49
Lognormal cumulative distribution function (CDF).



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 7
logninv


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1272
statistics: x = logninv ( p )
statistics: x = logninv ( p , mu )
statistics: x = logninv ( p , mu , sigma )

Inverse of the lognormal cumulative distribution function (iCDF).

For each element of p , compute the quantile (the inverse of the CDF) of
the lognormal distribution with mean parameter mu and standard
deviation parameter sigma , each corresponding to the associated normal
distribution. The size of x is the common size of p , mu ,
and sigma . A scalar input functions as a constant matrix of the same
size as the other inputs.

If a random variable follows this distribution, its logarithm is normally
distributed with mean mu and standard deviation sigma .

Default parameter values are mu = 0 and
sigma = 1 . Both parameters must be reals and
sigma > 0 . For sigma <= 0 , NaN is
returned.

Further information about the lognormal distribution can be found at
https://en.wikipedia.org/wiki/Log-normal_distribution

Input arguments must be double or single ; integer, logical,
and character arrays are rejected. MATLAB accepts a character array and
evaluates it at the character codes, which Octave deliberately does not,
since a character array is an integer type and integers are refused too.

See also:
logncdf,
lognpdf,
lognrnd,
lognfit,
lognlike,
lognstat


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 65
Inverse of the lognormal cumulative distribution function (iCDF).



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 7
lognpdf


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1253
statistics: y = lognpdf ( x )
statistics: y = lognpdf ( x , mu )
statistics: y = lognpdf ( x , mu , sigma )

Lognormal probability density function (PDF).

For each element of x , compute the probability density function (PDF)
of the lognormal distribution with mean parameter mu and standard
deviation parameter sigma , each corresponding to the associated normal
distribution. The size of y is the common size of p , mu ,
and sigma . A scalar input functions as a constant matrix of the same
size as the other inputs.

If a random variable follows this distribution, its logarithm is normally
distributed with mean mu and standard deviation sigma .

Default parameter values are mu = 0 and
sigma = 1 . Both parameters must be reals and
sigma > 0 . For sigma <= 0 , NaN is
returned.

Further information about the lognormal distribution can be found at
https://en.wikipedia.org/wiki/Log-normal_distribution

Input arguments must be double or single ; integer, logical,
and character arrays are rejected. MATLAB accepts a character array and
evaluates it at the character codes, which Octave deliberately does not,
since a character array is an integer type and integers are refused too.

See also:
logncdf,
logninv,
lognrnd,
lognfit,
lognlike,
lognstat


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 45
Lognormal probability density function (PDF).



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 7
lognrnd


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1307
statistics: r = lognrnd ( mu , sigma )
statistics: r = lognrnd ( mu , sigma , rows )
statistics: r = lognrnd ( mu , sigma , rows , cols , &hellip;)
statistics: r = lognrnd ( mu , sigma , [ sz ])

Random arrays from the lognormal distribution.

r = lognrnd ( mu , sigma ) returns an array of random
numbers chosen from the lognormal distribution with mean parameter mu
and standard deviation parameter sigma , each corresponding to the
associated normal distribution. The size of r is the common size of
mu , and sigma . A scalar input functions as a constant matrix of
the same size as the other inputs. Both parameters must be reals and
sigma > 0 . For sigma <= 0 , NaN is
returned.

Both parameters must be reals and sigma > 0 .
For sigma <= 0 , NaN is returned.

When called with a single size argument, lognrnd returns a square
matrix with the dimension specified. When called with more than one scalar
argument, the first two arguments are taken as the number of rows and columns
and any further arguments specify additional matrix dimensions. The size may
also be specified with a row vector of dimensions, sz .

Further information about the lognormal distribution can be found at
https://en.wikipedia.org/wiki/Log-normal_distribution

See also:
logncdf,
logninv,
lognpdf,
lognfit,
lognlike,
lognstat


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 46
Random arrays from the lognormal distribution.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 5
mnpdf


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1672
statistics: y = mnpdf ( x , pk )

Multinomial probability density function (PDF).

Arguments

x is vector with a single sample of a multinomial distribution with
parameter pk or a matrix of random samples from multinomial
distributions. In the latter case, each row of x is a sample from a
multinomial distribution with the corresponding row of pk being its
parameter.

pk is a vector with the probabilities of the categories or a matrix
with each row containing the probabilities of a multinomial sample.

Return values

y is a vector of probabilities of the random samples x from the
multinomial distribution with corresponding parameter pk . The parameter
n of the multinomial distribution is the sum of the elements of each
row of x . The length of y is the number of columns of x .
If a row of pk does not sum to 1 , then the corresponding element
of y will be NaN .

Examples

x = [1, 4, 2];
pk = [0.2, 0.5, 0.3];
y = mnpdf (x, pk);

x = [1, 4, 2; 1, 0, 9];
pk = [0.2, 0.5, 0.3; 0.1, 0.1, 0.8];
y = mnpdf (x, pk);

References

Wendy L. Martinez and Angel R. Martinez. Computational Statistics
Handbook with MATLAB . Appendix E, pages 547-557, Chapman & Hall/CRC, 2001.

Merran Evans, Nicholas Hastings and Brian Peacock. Statistical
Distributions . pages 134-136, Wiley, New York, third edition, 2000.

Input arguments must be double , single , or an integer type;
logical and character arrays are rejected. Integer input is promoted to
double , so the result is always a probability. MATLAB is
inconsistent here: for several of the discrete distributions it returns the
result in the integer class of the input, truncating a probability to
0 or 1 .

See also:
mnrnd


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 47
Multinomial probability density function (PDF).



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 5
mnrnd


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1778
statistics: r = mnrnd ( n , pk )
statistics: r = mnrnd ( n , pk , s )

Random arrays from the multinomial distribution.

Arguments

n is the first parameter of the multinomial distribution. n can
be scalar or a vector containing the number of trials of each multinomial
sample. The elements of n must be non-negative integers.

pk is the second parameter of the multinomial distribution. pk
can be a vector with the probabilities of the categories or a matrix with
each row containing the probabilities of a multinomial sample. If pk
has more than one row and n is non-scalar, then the number of rows of
pk must match the number of elements of n .

s is the number of multinomial samples to be generated. s must
be a non-negative integer. If s is specified, then n must be
scalar and pk must be a vector.

Return values

r is a matrix of random samples from the multinomial distribution with
corresponding parameters n and pk . Each row corresponds to one
multinomial sample. The number of columns, therefore, corresponds to the
number of columns of pk . If s is not specified, then the number
of rows of r is the maximum of the number of elements of n and
the number of rows of pk . If a row of pk does not sum to
1 , then the corresponding row of r will contain only NaN
values.

Examples

n = 10;
pk = [0.2, 0.5, 0.3];
r = mnrnd (n, pk);

n = 10 * ones (3, 1);
pk = [0.2, 0.5, 0.3];
r = mnrnd (n, pk);

n = (1:2)';
pk = [0.2, 0.5, 0.3; 0.1, 0.1, 0.8];
r = mnrnd (n, pk);

References

Wendy L. Martinez and Angel R. Martinez. Computational Statistics
Handbook with MATLAB . Appendix E, pages 547-557, Chapman & Hall/CRC, 2001.

Merran Evans, Nicholas Hastings and Brian Peacock. Statistical
Distributions . pages 134-136, Wiley, New York, third edition, 2000.

See also:
mnpdf


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 48
Random arrays from the multinomial distribution.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 6
mvncdf


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 2831
statistics: p = mvncdf ( x )
statistics: p = mvncdf ( x , mu , sigma )
statistics: p = mvncdf ( x_lo , x_up , mu , sigma )
statistics: p = mvncdf (&hellip;, options )
statistics: [ p , err ] = mvncdf (&hellip;)

Multivariate normal cumulative distribution function (CDF).

p = mvncdf ( x ) returns the cumulative probability of the
multivariate normal distribution evaluated at each row of x with zero
mean and an identity covariance matrix. The rows of matrix x
correspond to observations and its columns to variables. The return argument
p is a column vector with the same number of rows as in x .

p = mvncdf ( x , mu , sigma ) returns cumulative
probability of the multivariate normal distribution evaluated at each row of
x with mean mu and a covariance matrix sigma . mu can
be either a scalar (the same of every variable) or a row vector with the same
number of elements as the number of variables in x . sigma
covariance matrix may be specified a row vector if it only contains variances
along its diagonal and zero covariances of the diagonal. In such a case, the
diagonal vector sigma must have the same number of elements as the
number of variables (columns) in x . If you only want to specify sigma,
you can pass an empty matrix for mu .

The multivariate normal cumulative probability at x is defined as the
probability that a random vector V , distributed as multivariate
normal, will fall within the semi-infinite rectangle with upper limits
defined by x .

Pr{V(1)<=X(1), V(2)<=X(2), ... V(D)<=X(D)} .

p = mvncdf ( x_lo , x_hi , mu , sigma )
returns the multivariate normal cumulative probability evaluated over the
rectangle (hyper-rectangle for multivariate data in x ) with lower and
upper limits defined by x_lo and x_hi , respectively.

[ p , err ] = mvncdf (&hellip;) also returns an error estimate
err in p .

p = mvncdf (&hellip;, options ) specifies the structure,
which controls specific parameters for the numerical integration used to
compute p . The required fields are:

'TolFun' Maximum absolute error tolerance. Default
is 1e-8 for D < 4, or 1e-4 for D >= 4. Note that for bivariate normal cdf,
the Octave implementation has a precision of more than 1e-10.
'MaxFunEvals' Maximum number of integrand
evaluations. Default is 1e7 for D > 4.
'Display' Display options. Choices are 'off'
(default), 'iter' , which shows the probability and estimated error at
each repetition, and 'final' , which shows the final probability and
related error after the integrand has converged successfully.

Input arguments must be double or single ; integer, logical,
and character arrays are rejected. MATLAB accepts a character array and
evaluates it at the character codes, which Octave deliberately does not,
since a character array is an integer type and integers are refused too.

See also:
bvncdf,
mvnpdf,
mvnrnd


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 59
Multivariate normal cumulative distribution function (CDF).



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 6
mvnpdf


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1879
statistics: y = mvnpdf ( x , mu , sigma )

Multivariate normal probability density function (PDF).

y = mvnpdf ( x ) returns the probability density of the
multivariate normal distribution with zero mean and identity covariance
matrix, evaluated at each row of x . Rows of the N-by-D matrix x
correspond to observations orpoints, and columns correspond to variables or
coordinates. y is an N-by-1 vector.

y = mvnpdf ( x , mu ) returns the density of the
multivariate normal distribution with mean MU and identity covariance matrix,
evaluated at each row of x . mu is a 1-by-D vector, or an N-by-D
matrix, in which case the density is evaluated for each row of x with
the corresponding row of mu . mu can also be a scalar value,
which MVNPDF replicates to match the size of x .

y = mvnpdf ( x , mu , sigma ) returns the density
of the multivariate normal distribution with mean mu and covariance
sigma , evaluated at each row of x . sigma is a D-by-D
matrix, or an D-by-D-by-N array, in which case the density is evaluated for
each row of x with the corresponding page of sigma , i.e.,
mvnpdf computes y(i) using x(i,:) and sigma(:,:,i) .
If the covariance matrix is diagonal, containing variances along the diagonal
and zero covariances off the diagonal, sigma may also be specified as a
1-by-D matrix or a 1-by-D-by-N array, containing just the diagonal. Pass in
the empty matrix for mu to use its default value when you want to only
specify sigma .

If x is a 1-by-D vector, mvnpdf replicates it to match the
leading dimension of mu or the trailing dimension of sigma .

Input arguments must be double or single ; integer, logical,
and character arrays are rejected. MATLAB accepts a character array and
evaluates it at the character codes, which Octave deliberately does not,
since a character array is an integer type and integers are refused too.

See also:
mvncdf,
mvnrnd


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 55
Multivariate normal probability density function (PDF).



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 6
mvnrnd


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1693
statistics: r = mvnrnd ( mu , sigma )
statistics: r = mvnrnd ( mu , sigma , n )
statistics: r = mvnrnd ( mu , sigma , n , T )
statistics: [ r , T ] = mvnrnd (&hellip;)

Random vectors from the multivariate normal distribution.

r = mvnrnd ( mu , sigma ) returns an N-by-D matrix
r of random vectors chosen from the multivariate normal distribution
with mean vector mu and covariance matrix sigma . mu is an
N-by-D matrix, and mvnrnd generates each N of r using the
corresponding N of mu . sigma is a D-by-D symmetric positive
semi-definite matrix, or a D-by-D-by-N array. If sigma is an array,
mvnrnd generates each N of r using the corresponding page of
sigma , i.e., mvnrnd computes r(i,:) using mu(i,:)
and sigma(:,:,i) . If the covariance matrix is diagonal, containing
variances along the diagonal and zero covariances off the diagonal,
sigma may also be specified as a 1-by-D matrix or a 1-by-D-by-N array,
containing just the diagonal. If mu is a 1-by-D vector, mvnrnd
replicates it to match the trailing dimension of SIGMA.

r = mvnrnd ( mu , sigma , n ) returns a N-by-D
matrix R of random vectors chosen from the multivariate normal distribution
with 1-by-D mean vector mu , and D-by-D covariance matrix sigma .

r = mvnrnd ( mu , sigma , n , T ) supplies
the Cholesky factor T of sigma , so that sigma(:,:,J) ==
T(:,:,J) &rsquo;* T(:,:,J) if sigma is a 3D array or sigma ==
T &rsquo;* T if sigma is a matrix. No error checking is done on
T .

[ r , T ] = mvnrnd (&hellip;) returns the Cholesky factor
T , so it can be re-used to make later calls more efficient, although
there are greater efficiency gains when SIGMA can be specified as a diagonal
instead.

See also:
mvncdf,
mvnpdf


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 57
Random vectors from the multivariate normal distribution.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 6
mvtcdf


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 2625
statistics: p = mvtcdf ( x , rho , df )
statistics: p = mvncdf ( x_lo , x_up , rho , df )
statistics: p = mvncdf (&hellip;, options )
statistics: [ p , err ] = mvncdf (&hellip;)

Multivariate Student&rsquo;s t cumulative distribution function (CDF).

p = mvtcdf ( x , rho , df ) returns the cumulative
probability of the multivariate student&rsquo;s t distribution with correlation
parameters rho and degrees of freedom df , evaluated at each row
of x . The rows of the N&times;D matrix x correspond to sample
observations and its columns correspond to variables or coordinates. The
return argument p is a column vector with the same number of rows as in
x .

rho is a symmetric, positive definite, D&times;D correlation matrix.
dF is a scalar or a vector with N elements.

Note: mvtcdf computes the CDF for the standard multivariate Student&rsquo;s
t distribution, centered at the origin, with no scale parameters. If
rho is a covariance matrix, i.e. diag( rho ) is not all
ones, mvtcdf rescales rho to transform it to a correlation
matrix. mvtcdf does not rescale x , though.

The multivariate Student&rsquo;s t cumulative probability at x is defined as
the probability that a random vector T, distributed as multivariate normal,
will fall within the semi-infinite rectangle with upper limits defined by
x .

Pr{T(1)<=X(1), T(2)<=X(2), ... T(D)<=X(D)} .

p = mvtcdf ( x_lo , x_hi , rho , df ) returns
the multivariate Student&rsquo;s t cumulative probability evaluated over the
rectangle (hyper-rectangle for multivariate data in x ) with lower and
upper limits defined by x_lo and x_hi , respectively.

[ p , err ] = mvtcdf (&hellip;) also returns an error estimate
err in p .

p = mvtcdf (&hellip;, options ) specifies the structure,
which controls specific parameters for the numerical integration used to
compute p . The required fields are:

'TolFun' Maximum absolute error tolerance. Default
is 1e-8 for D < 4, or 1e-4 for D >= 4.
'MaxFunEvals' Maximum number of integrand evaluations
when D >= 4 . Default is 1e7. Ignored when D < 4 .
'Display' Display options. Choices are 'off'
(default), 'iter' , which shows the probability and estimated error at
each repetition, and 'final' , which shows the final probability and
related error after the integrand has converged successfully. Ignored when
D < 4 .

Input arguments must be double or single ; integer, logical,
and character arrays are rejected. MATLAB accepts a character array and
evaluates it at the character codes, which Octave deliberately does not,
since a character array is an integer type and integers are refused too.

See also:
bvtcdf,
mvtpdf,
mvtrnd


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 64
Multivariate Student's t cumulative distribution function (CDF).



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 6
mvtpdf


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1085
statistics: y = mvtpdf ( x , rho , df )

Multivariate Student&rsquo;s t probability density function (PDF).

Arguments

x are the points at which to find the probability, where each row
corresponds to an observation. ( N&times;D matrix)

rho is the correlation matrix. ( D&times;D symmetric positive
definite matrix)

df is the degrees of freedom. (scalar or vector of length N )

The distribution is assumed to be centered (zero mean).

Return values

y is the probability density for each row of x .
( N&times;1 vector)

Examples

x = [1 2];
rho = [1.0 0.5; 0.5 1.0];
df = 4;
y = mvtpdf (x, rho, df)

References

Michael Roth, On the Multivariate t Distribution, Technical report from
Automatic Control at Linkoepings universitet,
http://users.isy.liu.se/en/rt/roth/student.pdf

Input arguments must be double or single ; integer, logical,
and character arrays are rejected. MATLAB accepts a character array and
evaluates it at the character codes, which Octave deliberately does not,
since a character array is an integer type and integers are refused too.

See also:
mvtcdf,
mvtrnd


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 60
Multivariate Student's t probability density function (PDF).



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 6
mvtrnd


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1630
statistics: r = mvtrnd ( rho , df )
statistics: r = mvtrnd ( rho , df , n )

Random vectors from the multivariate Student&rsquo;s t distribution.

Arguments

rho is the matrix of correlation coefficients. If there are any
non-unit diagonal elements then rho will be normalized, so that the
resulting covariance of the obtained samples r follows:
cov (r) = df/(df-2) * rho ./ (sqrt (diag (rho) * diag (rho))) .
In order to obtain samples distributed according to a standard multivariate
student&rsquo;s t-distribution, rho must be equal to the identity matrix. To
generate multivariate student&rsquo;s t-distribution samples r with arbitrary
covariance matrix rho , the following scaling might be used:
r = mvtrnd (rho, df, n) * diag (sqrt (diag (rho))) .

df is the degrees of freedom for the multivariate t-distribution.
df must be a vector with the same number of elements as samples to be
generated or be scalar.

n is the number of rows of the matrix to be generated. n must be
a non-negative integer and corresponds to the number of samples to be
generated.

Return values

r is a matrix of random samples from the multivariate t-distribution
with n row samples.

Examples

rho = [1, 0.5; 0.5, 1];
df = 3;
n = 10;
r = mvtrnd (rho, df, n);

rho = [1, 0.5; 0.5, 1];
df = [2; 3];
n = 2;
r = mvtrnd (rho, df, 2);

References

Wendy L. Martinez and Angel R. Martinez. Computational Statistics
Handbook with MATLAB . Appendix E, pages 547-557, Chapman & Hall/CRC, 2001.

Samuel Kotz and Saralees Nadarajah. Multivariate t Distributions and
Their Applications . Cambridge University Press, Cambridge, 2004.

See also:
mvtcdf,
mvtpdf


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 62
Random vectors from the multivariate Student's t distribution.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 7
nakacdf


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1170
statistics: p = nakacdf ( x , mu , omega )
statistics: p = nakacdf ( x , mu , omega , 'upper' )

Nakagami cumulative distribution function (CDF).

For each element of x , compute the cumulative distribution function
(CDF) of the Nakagami distribution with shape parameter mu and spread
parameter omega . The size of p is the common size of x ,
mu , and omega . A scalar input functions as a constant matrix of
the same size as the other inputs.

Both parameters must be positive reals and mu >= 0.5 . For
mu < 0.5 or omega <= 0 , NaN is returned.

p = nakacdf ( x , mu , omega , "upper") computes
the upper tail probability of the Nakagami distribution with parameters
mu and beta , at the values in x .

Further information about the Nakagami distribution can be found at
https://en.wikipedia.org/wiki/Nakagami_distribution

Input arguments must be double or single ; integer, logical,
and character arrays are rejected. MATLAB accepts a character array and
evaluates it at the character codes, which Octave deliberately does not,
since a character array is an integer type and integers are refused too.

See also:
nakainv,
nakapdf,
nakarnd,
nakafit,
nakalike,
nakastat


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 48
Nakagami cumulative distribution function (CDF).



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 7
nakainv


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 971
statistics: x = nakacdf ( x , mu , omega )

Inverse of the Nakagami cumulative distribution function (iCDF).

For each element of p , compute the quantile (the inverse of the CDF) of
the Nakagami distribution with shape parameter mu and spread parameter
omega . The size of x is the common size of x , mu ,
and omega . A scalar input functions as a constant matrix of the same
size as the other inputs.

Both parameters must be positive reals and mu >= 0.5 . For
mu < 0.5 or omega <= 0 , NaN is returned.

Further information about the Nakagami distribution can be found at
https://en.wikipedia.org/wiki/Nakagami_distribution

Input arguments must be double or single ; integer, logical,
and character arrays are rejected. MATLAB accepts a character array and
evaluates it at the character codes, which Octave deliberately does not,
since a character array is an integer type and integers are refused too.

See also:
nakacdf,
nakapdf,
nakarnd,
nakafit,
nakalike,
nakastat


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 64
Inverse of the Nakagami cumulative distribution function (iCDF).



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 7
nakapdf


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 952
statistics: y = nakapdf ( x , mu , omega )

Nakagami probability density function (PDF).

For each element of x , compute the probability density function (PDF)
of the Nakagami distribution with shape parameter mu and spread
parameter omega . The size of y is the common size of x ,
mu , and omega . A scalar input functions as a constant matrix of
the same size as the other inputs.

Both parameters must be positive reals and mu >= 0.5 . For
mu < 0.5 or omega <= 0 , NaN is returned.

Further information about the Nakagami distribution can be found at
https://en.wikipedia.org/wiki/Nakagami_distribution

Input arguments must be double or single ; integer, logical,
and character arrays are rejected. MATLAB accepts a character array and
evaluates it at the character codes, which Octave deliberately does not,
since a character array is an integer type and integers are refused too.

See also:
nakacdf,
nakainv,
nakarnd,
nakafit,
nakalike,
nakastat


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 44
Nakagami probability density function (PDF).



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 7
nakarnd


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1172
statistics: r = nakarnd ( mu , omega )
statistics: r = nakarnd ( mu , omega , rows )
statistics: r = nakarnd ( mu , omega , rows , cols , &hellip;)
statistics: r = nakarnd ( mu , omega , [ sz ])

Random arrays from the Nakagami distribution.

r = nakarnd ( mu , omega ) returns an array of random
numbers chosen from the Nakagami distribution with shape parameter mu
and spread parameter omega . The size of r is the common size of
mu and omega . A scalar input functions as a constant matrix of
the same size as the other inputs.

Both parameters must be positive reals and mu >= 0.5 . For
mu < 0.5 or omega <= 0 , NaN is returned.

When called with a single size argument, nakarnd returns a square
matrix with the dimension specified. When called with more than one scalar
argument, the first two arguments are taken as the number of rows and columns
and any further arguments specify additional matrix dimensions. The size may
also be specified with a row vector of dimensions, sz .

Further information about the Nakagami distribution can be found at
https://en.wikipedia.org/wiki/Nakagami_distribution

See also:
nakacdf,
nakainv,
nakapdf,
nakafit,
nakalike,
nakastat


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 45
Random arrays from the Nakagami distribution.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 7
nbincdf


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 2466
statistics: p = nbincdf ( x , r , ps )
statistics: p = nbincdf ( x , r , ps , 'upper' )

Negative binomial cumulative distribution function (CDF).

For each element of x , compute the cumulative distribution function
(CDF) of the negative binomial distribution with parameters r and
ps , where r is the number of successes until the experiment is
stopped and ps is the probability of success in each experiment, given
the number of failures in x . The size of p is the common size of
x , r , and ps . A scalar input functions as a constant
matrix of the same size as the other inputs.

The algorithm uses the cumulative sums of the binomial masses.

p = nbincdf ( x , r , ps , "upper") computes the
upper tail probability of the negative binomial distribution with parameters
r and ps , at the values in x .

When r is an integer, the negative binomial distribution is also known
as the Pascal distribution and it models the number of failures in x
before a specified number of successes is reached in a series of independent,
identical trials. Its parameters are the probability of success in a single
trial, ps , and the number of successes, r . A special case of the
negative binomial distribution, when r = 1 , is the geometric
distribution, which models the number of failures before the first success.

r can also have non-integer positive values, in which form the negative
binomial distribution, also known as the Polya distribution, has no
interpretation in terms of repeated trials, but, like the Poisson
distribution, it is useful in modeling count data. The negative binomial
distribution is more general than the Poisson distribution because it has a
variance that is greater than its mean, making it suitable for count data
that do not meet the assumptions of the Poisson distribution. In the limit,
as r increases to infinity, the negative binomial distribution
approaches the Poisson distribution.

Further information about the negative binomial distribution can be found at
https://en.wikipedia.org/wiki/Negative_binomial_distribution

Input arguments must be double , single , or an integer type;
logical and character arrays are rejected. Integer input is promoted to
double , so the result is always a probability. MATLAB is
inconsistent here: for several of the discrete distributions it returns the
result in the integer class of the input, truncating a probability to
0 or 1 .

See also:
nbininv,
nbinpdf,
nbinrnd,
nbinfit,
nbinlike,
nbinstat


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 57
Negative binomial cumulative distribution function (CDF).



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 7
nbininv


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 2130
statistics: x = nbininv ( p , r , ps )

Inverse of the negative binomial cumulative distribution function (iCDF).

For each element of p , compute the quantile (the inverse of the CDF) of
the negative binomial distribution with parameters r and ps ,
where r is the number of successes until the experiment is stopped and
ps is the probability of success in each experiment, given the
probability in p . The size of x is the common size of p ,
r , and ps . A scalar input functions as a constant matrix of the
same size as the other inputs.

When r is an integer, the negative binomial distribution is also known
as the Pascal distribution and it models the number of failures in x
before a specified number of successes is reached in a series of independent,
identical trials. Its parameters are the probability of success in a single
trial, ps , and the number of successes, r . A special case of the
negative binomial distribution, when r = 1 , is the geometric
distribution, which models the number of failures before the first success.

r can also have non-integer positive values, in which form the negative
binomial distribution, also known as the Polya distribution, has no
interpretation in terms of repeated trials, but, like the Poisson
distribution, it is useful in modeling count data. The negative binomial
distribution is more general than the Poisson distribution because it has a
variance that is greater than its mean, making it suitable for count data
that do not meet the assumptions of the Poisson distribution. In the limit,
as r increases to infinity, the negative binomial distribution
approaches the Poisson distribution.

Further information about the negative binomial distribution can be found at
https://en.wikipedia.org/wiki/Negative_binomial_distribution

Input arguments must be double or single ; integer, logical,
and character arrays are rejected. MATLAB accepts a character array and
evaluates it at the character codes, which Octave deliberately does not,
since a character array is an integer type and integers are refused too.

See also:
nbincdf,
nbinpdf,
nbinrnd,
nbinfit,
nbinlike,
nbinstat


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 73
Inverse of the negative binomial cumulative distribution function (iCDF).



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 7
nbinpdf


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 2191
statistics: y = nbinpdf ( x , r , ps )

Negative binomial probability density function (PDF).

For each element of x , compute the probability density function (PDF)
at x of the negative binomial distribution with parameters r and
ps , where r is the number of successes until the experiment is
stopped and ps is the probability of success in each experiment, given
the number of failures in x . The size of y is the common size of
x , r , and ps . A scalar input functions as a constant
matrix of the same size as the other inputs.

When r is an integer, the negative binomial distribution is also known
as the Pascal distribution and it models the number of failures in x
before a specified number of successes is reached in a series of independent,
identical trials. Its parameters are the probability of success in a single
trial, ps , and the number of successes, r . A special case of the
negative binomial distribution, when r = 1 , is the geometric
distribution, which models the number of failures before the first success.

r can also have non-integer positive values, in which form the negative
binomial distribution, also known as the Polya distribution, has no
interpretation in terms of repeated trials, but, like the Poisson
distribution, it is useful in modeling count data. The negative binomial
distribution is more general than the Poisson distribution because it has a
variance that is greater than its mean, making it suitable for count data
that do not meet the assumptions of the Poisson distribution. In the limit,
as r increases to infinity, the negative binomial distribution
approaches the Poisson distribution.

Further information about the negative binomial distribution can be found at
https://en.wikipedia.org/wiki/Negative_binomial_distribution

Input arguments must be double , single , or an integer type;
logical and character arrays are rejected. Integer input is promoted to
double , so the result is always a probability. MATLAB is
inconsistent here: for several of the discrete distributions it returns the
result in the integer class of the input, truncating a probability to
0 or 1 .

See also:
nbincdf,
nbininv,
nbinrnd,
nbinfit,
nbinlike,
nbinstat


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 53
Negative binomial probability density function (PDF).



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 7
nbinrnd


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 2319
statistics: rnd = nbinrnd ( r , ps )
statistics: rnd = nbinrnd ( r , ps , rows )
statistics: rnd = nbinrnd ( r , ps , rows , cols , &hellip;)
statistics: rnd = nbinrnd ( r , ps , [ sz ])

Random arrays from the negative binomial distribution.

rnd = nbinrnd ( r , ps ) returns an array of random
numbers chosen from the negative binomial distribution with parameters
r and ps , where r is the number of successes until the
experiment is stopped and ps is the probability of success in each
experiment, given the number of failures in x . The size of rnd
is the common size of r and ps . A scalar input functions as a
constant matrix of the same size as the other inputs.

When called with a single size argument, return a square matrix with
the dimension specified. When called with more than one scalar argument the
first two arguments are taken as the number of rows and columns and any
further arguments specify additional matrix dimensions. The size may also
be specified with a vector of dimensions sz .

When r is an integer, the negative binomial distribution is also known
as the Pascal distribution and it models the number of failures in x
before a specified number of successes is reached in a series of independent,
identical trials. Its parameters are the probability of success in a single
trial, ps , and the number of successes, r . A special case of the
negative binomial distribution, when r = 1 , is the geometric
distribution, which models the number of failures before the first success.

r can also have non-integer positive values, in which form the negative
binomial distribution, also known as the Polya distribution, has no
interpretation in terms of repeated trials, but, like the Poisson
distribution, it is useful in modeling count data. The negative binomial
distribution is more general than the Poisson distribution because it has a
variance that is greater than its mean, making it suitable for count data
that do not meet the assumptions of the Poisson distribution. In the limit,
as r increases to infinity, the negative binomial distribution
approaches the Poisson distribution.

Further information about the negative binomial distribution can be found at
https://en.wikipedia.org/wiki/Negative_binomial_distribution

See also:
nbincdf,
nbininv,
nbinpdf,
nbinfit,
nbinlike,
nbinstat


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 54
Random arrays from the negative binomial distribution.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 6
ncfcdf


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1135
statistics: p = ncfcdf ( x , df1 , df2 , lambda )
statistics: p = ncfcdf ( x , df1 , df2 , lambda , 'upper' )

Noncentral F -cumulative distribution function (CDF).

For each element of x , compute the cumulative distribution function
(CDF) of the noncentral F -distribution with df1 and df2
degrees of freedom and noncentrality parameter lambda . The size of
p is the common size of x , df1 , df2 , and
lambda . A scalar input functions as a constant matrix of the same size
as the other inputs.

p = ncfcdf ( x , df1 , df2 , lambda ,
"upper")
computes the upper tail probability of the noncentral F -distribution
with parameters df1 , df2 , and lambda , at the values in
x .

Further information about the noncentral F -distribution can be found
at https://en.wikipedia.org/wiki/Noncentral_F-distribution

Input arguments must be double or single ; integer, logical,
and character arrays are rejected. MATLAB accepts a character array and
evaluates it at the character codes, which Octave deliberately does not,
since a character array is an integer type and integers are refused too.

See also:
ncfinv,
ncfpdf,
ncfrnd,
ncfstat,
fcdf


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 52
Noncentral F-cumulative distribution function (CDF).



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 6
ncfinv


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 970
statistics: x = ncfinv ( p , df1 , df2 , lambda )

Inverse of the noncentral F -cumulative distribution function (iCDF).

For each element of p , compute the quantile (the inverse of the CDF) of
the noncentral F -distribution with df1 and df2 degrees of
freedom and noncentrality parameter lambda . The size of x is the
common size of p , df1 , df2 , and lambda . A scalar
input functions as a constant matrix of the same size as the other inputs.

ncfinv uses Newton&rsquo;s method to converge to the solution.

Further information about the noncentral F -distribution can be found
at https://en.wikipedia.org/wiki/Noncentral_F-distribution

Input arguments must be double or single ; integer, logical,
and character arrays are rejected. MATLAB accepts a character array and
evaluates it at the character codes, which Octave deliberately does not,
since a character array is an integer type and integers are refused too.

See also:
ncfcdf,
ncfpdf,
ncfrnd,
ncfstat,
finv


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 68
Inverse of the noncentral F-cumulative distribution function (iCDF).



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 6
ncfpdf


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 887
statistics: y = ncfpdf ( x , df1 , df2 , lambda )

Noncentral F -probability density function (PDF).

For each element of x , compute the probability density function (PDF)
of the noncentral F -distribution with df1 and df2 degrees
of freedom and noncentrality parameter lambda . The size of y is
the common size of x , df1 , df2 , and lambda . A scalar
input functions as a constant matrix of the same size as the other inputs.

Further information about the noncentral F -distribution can be found
at https://en.wikipedia.org/wiki/Noncentral_F-distribution

Input arguments must be double or single ; integer, logical,
and character arrays are rejected. MATLAB accepts a character array and
evaluates it at the character codes, which Octave deliberately does not,
since a character array is an integer type and integers are refused too.

See also:
ncfcdf,
ncfinv,
ncfrnd,
ncfstat,
fpdf


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 48
Noncentral F-probability density function (PDF).



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 6
ncfrnd


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1281
statistics: r = ncfrnd ( df1 , df2 , lambda )
statistics: r = ncfrnd ( df1 , df2 , lambda , rows , cols , &hellip;)
statistics: r = ncfrnd ( df1 , df2 , lambda , [ sz ])

Random arrays from the noncentral F -distribution.

x = ncfrnd ( p , df1 , df2 , lambda ) returns
an array of random numbers chosen from the noncentral F -distribution
with
df1 and df2 degrees of freedom and noncentrality parameter
lambda . The size of r is the common size of df1 ,
df2 , and lambda . A scalar input functions as a constant matrix
of the same size as the other input.

ncfrnd generates values using the definition of a noncentral F
random variable, as the ratio of a noncentral chi-squared distribution and a
(central) chi-squared distribution.

When called with a single size argument, ncfrnd returns a square
matrix with the dimension specified. When called with more than one scalar
argument, the first two arguments are taken as the number of rows and columns
and any further arguments specify additional matrix dimensions. The size may
also be specified with a row vector of dimensions, sz .

Further information about the noncentral F -distribution can be found
at https://en.wikipedia.org/wiki/Noncentral_F-distribution

See also:
ncfcdf,
ncfinv,
ncfpdf,
ncfstat,
frnd,
ncx2rnd,
chi2rnd


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 49
Random arrays from the noncentral F-distribution.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 6
nctcdf


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1065
statistics: p = nctcdf ( x , df , mu )
statistics: p = nctcdf ( x , df , mu , 'upper' )

Noncentral t -cumulative distribution function (CDF).

For each element of x , compute the cumulative distribution function
(CDF) of the noncentral t -distribution with df degrees of
freedom and noncentrality parameter mu . The size of p is the
common size of x , df , and mu . A scalar input functions
as a constant matrix of the same size as the other inputs.

p = nctcdf ( x , df , mu , "upper") computes
the upper tail probability of the noncentral t -distribution with
parameters df and mu , at the values in x .

Further information about the noncentral t -distribution can be found
at https://en.wikipedia.org/wiki/Noncentral_t-distribution

Input arguments must be double or single ; integer, logical,
and character arrays are rejected. MATLAB accepts a character array and
evaluates it at the character codes, which Octave deliberately does not,
since a character array is an integer type and integers are refused too.

See also:
nctinv,
nctpdf,
nctrnd,
nctstat,
tcdf


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 52
Noncentral t-cumulative distribution function (CDF).



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 6
nctinv


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 937
statistics: x = ncx2inv ( p , df , mu )

Inverse of the non-central t -cumulative distribution function (iCDF).

For each element of p , compute the quantile (the inverse of the CDF) of
the noncentral t -distribution with df degrees of freedom and
noncentrality parameter mu . The size of x is the common size
of p , df , and mu . A scalar input functions as a
constant matrix of the same size as the other inputs.

nctinv uses Newton&rsquo;s method to converge to the solution.

Further information about the noncentral t -distribution can be found
at https://en.wikipedia.org/wiki/Noncentral_t-distribution

Input arguments must be double or single ; integer, logical,
and character arrays are rejected. MATLAB accepts a character array and
evaluates it at the character codes, which Octave deliberately does not,
since a character array is an integer type and integers are refused too.

See also:
nctcdf,
nctpdf,
nctrnd,
nctstat,
tinv


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 69
Inverse of the non-central t-cumulative distribution function (iCDF).



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 6
nctpdf


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 852
statistics: y = nctpdf ( x , df , mu )

Noncentral t -probability density function (PDF).

For each element of x , compute the probability density function (PDF)
of the noncentral t -distribution with df degrees of freedom and
noncentrality parameter mu . The size of y is the common size
of x , df , and mu . A scalar input functions as a
constant matrix of the same size as the other inputs.

Further information about the noncentral t -distribution can be found
at https://en.wikipedia.org/wiki/Noncentral_t-distribution

Input arguments must be double or single ; integer, logical,
and character arrays are rejected. MATLAB accepts a character array and
evaluates it at the character codes, which Octave deliberately does not,
since a character array is an integer type and integers are refused too.

See also:
nctcdf,
nctinv,
nctrnd,
nctstat,
tpdf


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 48
Noncentral t-probability density function (PDF).



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 6
nctrnd


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1216
statistics: r = nctrnd ( df , mu )
statistics: r = nctrnd ( df , mu , rows , cols , &hellip;)
statistics: r = nctrnd ( df , mu , [ sz ])

Random arrays from the noncentral t -distribution.

x = nctrnd ( p , df , mu ) returns an array of
random numbers chosen from the noncentral t -distribution with df
degrees of freedom and noncentrality parameter mu . The size of
r is the common size of df and mu . A scalar input
functions as a constant matrix of the same size as the other input.

nctrnd generates values using the definition of a noncentral t
random variable, as the ratio of a normal distribution with non-zero mean and
the sqrt of a chi-squared distribution.

When called with a single size argument, nctrnd returns a square
matrix with the dimension specified. When called with more than one scalar
argument, the first two arguments are taken as the number of rows and columns
and any further arguments specify additional matrix dimensions. The size may
also be specified with a row vector of dimensions, sz .

Further information about the noncentral t -distribution can be found
at https://en.wikipedia.org/wiki/Noncentral_t-distribution

See also:
nctcdf,
nctinv,
nctpdf,
nctstat,
trnd,
normrnd,
chi2rnd


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 49
Random arrays from the noncentral t-distribution.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 7
ncx2cdf


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1145
statistics: p = ncx2cdf ( x , df , lambda )
statistics: p = ncx2cdf ( x , df , lambda , 'upper' )

Noncentral chi-squared cumulative distribution function (CDF).

For each element of x , compute the cumulative distribution function
(CDF) of the noncentral chi-squared distribution with df degrees of
freedom and noncentrality parameter lambda . The size of p is the
common size of x , df , and lambda . A scalar input functions
as a constant matrix of the same size as the other inputs.

p = ncx2cdf ( x , df , lambda , "upper") computes
the upper tail probability of the noncentral chi-squared distribution with
parameters df and lambda , at the values in x .

Further information about the noncentral chi-squared distribution can be
found at
https://en.wikipedia.org/wiki/Noncentral_chi-squared_distribution

Input arguments must be double or single ; integer, logical,
and character arrays are rejected. MATLAB accepts a character array and
evaluates it at the character codes, which Octave deliberately does not,
since a character array is an integer type and integers are refused too.

See also:
ncx2inv,
ncx2pdf,
ncx2rnd,
ncx2stat,
chi2cdf


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 62
Noncentral chi-squared cumulative distribution function (CDF).



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 7
ncx2inv


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 985
statistics: x = ncx2inv ( p , df , lambda )

Inverse of the noncentral chi-squared cumulative distribution function
(iCDF).

For each element of p , compute the quantile (the inverse of the CDF) of
the noncentral chi-squared distribution with df degrees of freedom and
noncentrality parameter mu . The size of x is the common size of
p , df , and mu . A scalar input functions as a constant
matrix of the same size as the other inputs.

ncx2inv uses Newton&rsquo;s method to converge to the solution.

Further information about the noncentral chi-squared distribution can be
found at
https://en.wikipedia.org/wiki/Noncentral_chi-squared_distribution

Input arguments must be double or single ; integer, logical,
and character arrays are rejected. MATLAB accepts a character array and
evaluates it at the character codes, which Octave deliberately does not,
since a character array is an integer type and integers are refused too.

See also:
ncx2cdf,
ncx2pdf,
ncx2rnd,
ncx2stat,
chi2inv


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 78
Inverse of the noncentral chi-squared cumulative distribution function (iCDF).



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 7
ncx2pdf


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 914
statistics: y = ncx2pdf ( x , df , lambda )

Noncentral chi-squared probability distribution function (PDF).

For each element of x , compute the probability density function (PDF)
of the noncentral chi-squared distribution with df degrees of freedom
and noncentrality parameter lambda . The size of y is the common
size of x , df , and lambda . A scalar input functions as a
constant matrix of the same size as the other inputs.

Further information about the noncentral chi-squared distribution can be
found at
https://en.wikipedia.org/wiki/Noncentral_chi-squared_distribution

Input arguments must be double or single ; integer, logical,
and character arrays are rejected. MATLAB accepts a character array and
evaluates it at the character codes, which Octave deliberately does not,
since a character array is an integer type and integers are refused too.

See also:
ncx2cdf,
ncx2inv,
ncx2rnd,
ncx2stat,
chi2pdf


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 63
Noncentral chi-squared probability distribution function (PDF).



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 7
ncx2rnd


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1076
statistics: r = ncx2rnd ( df , lambda )
statistics: r = ncx2rnd ( df , lambda , rows , cols , &hellip;)
statistics: r = ncx2rnd ( df , lambda , [ sz ])

Random arrays from the noncentral chi-squared distribution.

r = ncx2rnd ( df , lambda ) returns an array of random
numbers chosen from the noncentral chi-squared distribution with df
degrees of freedom and noncentrality parameter lambda . The size of
r is the common size of df and lambda . A scalar input
functions as a constant matrix of the same size as the other input.

When called with a single size argument, ncx2rnd returns a square
matrix with the dimension specified. When called with more than one scalar
argument, the first two arguments are taken as the number of rows and columns
and any further arguments specify additional matrix dimensions. The size may
also be specified with a row vector of dimensions, sz .

Further information about the noncentral chi-squared distribution can be
found at
https://en.wikipedia.org/wiki/Noncentral_chi-squared_distribution

See also:
ncx2cdf,
ncx2inv,
ncx2pdf,
ncx2stat


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 59
Random arrays from the noncentral chi-squared distribution.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 7
normcdf


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1967
statistics: p = normcdf ( x )
statistics: p = normcdf ( x , mu )
statistics: p = normcdf ( x , mu , sigma )
statistics: p = normcdf (&hellip;, 'upper' )
statistics: [ p , plo , pup ] = normcdf ( x , mu , sigma , pcov )
statistics: [ p , plo , pup ] = normcdf ( x , mu , sigma , pcov , alpha )
statistics: [ p , plo , pup ] = normcdf (&hellip;, 'upper' )

Normal cumulative distribution function (CDF).

For each element of x , compute the cumulative distribution function
(CDF) of the normal distribution with mean mu and standard deviation
sigma . The size of p is the common size of x , mu and
sigma . A scalar input functions as a constant matrix of the same size
as the other inputs.

Default values are mu = 0, sigma = 1.

When called with three output arguments, i.e. [ p , plo ,
pup ] , normcdf computes the confidence bounds for p when
the input parameters mu and sigma are estimates. In such case,
pcov , a 2&times;2 matrix containing the covariance matrix of the
estimated parameters, is necessary. Optionally, alpha , which has a
default value of 0.05, specifies the 100 * (1 - alpha ) percent
confidence bounds. plo and pup are arrays of the same size as
p containing the lower and upper confidence bounds.

[&hellip;] = normcdf (&hellip;, "upper") computes the upper tail
probability of the normal distribution with parameters mu and
sigma , at the values in x . This can be used to compute a
right-tailed p-value. To compute a two-tailed p-value, use
2 * normcdf (-abs ( x ), mu , sigma ) .

Further information about the normal distribution can be found at
https://en.wikipedia.org/wiki/Normal_distribution

Input arguments must be double or single ; integer, logical,
and character arrays are rejected. MATLAB accepts a character array and
evaluates it at the character codes, which Octave deliberately does not,
since a character array is an integer type and integers are refused too.

See also:
norminv,
normpdf,
normrnd,
normfit,
normlike,
normstat


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 46
Normal cumulative distribution function (CDF).



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 7
norminv


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1170
statistics: x = norminv ( p )
statistics: x = norminv ( p , mu )
statistics: x = norminv ( p , mu , sigma )

Inverse of the normal cumulative distribution function (iCDF).

For each element of p , compute the quantile (the inverse of the CDF) of
the normal distribution with mean mu and standard deviation
sigma . The size of p is the common size of p , mu and
sigma . A scalar input functions as a constant matrix of the same size
as the other inputs.

Default values are mu = 0, sigma = 1.

The default values correspond to the standard normal distribution and
computing its quantile function is also possible with the probit
function, which is faster but it does not perform any input validation.

Further information about the normal distribution can be found at
https://en.wikipedia.org/wiki/Normal_distribution

Input arguments must be double or single ; integer, logical,
and character arrays are rejected. MATLAB accepts a character array and
evaluates it at the character codes, which Octave deliberately does not,
since a character array is an integer type and integers are refused too.

See also:
normcdf,
normpdf,
normrnd,
normfit,
normlike,
normstat,
probit


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 62
Inverse of the normal cumulative distribution function (iCDF).



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 7
normpdf


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 935
statistics: y = normpdf ( x )
statistics: y = normpdf ( x , mu )
statistics: y = normpdf ( x , mu , sigma )

Normal probability density function (PDF).

For each element of x , compute the probability density function (PDF)
of the normal distribution with mean mu and standard deviation
sigma . The size of y is the common size of p , mu and
sigma . A scalar input functions as a constant matrix of the same size
as the other inputs.

Default values are mu = 0, sigma = 1.

Further information about the normal distribution can be found at
https://en.wikipedia.org/wiki/Normal_distribution

Input arguments must be double or single ; integer, logical,
and character arrays are rejected. MATLAB accepts a character array and
evaluates it at the character codes, which Octave deliberately does not,
since a character array is an integer type and integers are refused too.

See also:
normcdf,
norminv,
normrnd,
normfit,
normlike,
normstat


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 42
Normal probability density function (PDF).



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 7
normrnd


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1139
statistics: r = normrnd ( mu , sigma )
statistics: r = normrnd ( mu , sigma , rows )
statistics: r = normrnd ( mu , sigma , rows , cols , &hellip;)
statistics: r = normrnd ( mu , sigma , [ sz ])

Random arrays from the normal distribution.

r = normrnd ( mu , sigma ) returns an array of random
numbers chosen from the normal distribution with mean mu and standard
deviation sigma . The size of r is the common size of mu
and sigma . A scalar input functions as a constant matrix of the same
size as the other inputs. Both parameters must be finite real numbers and
sigma > 0, otherwise NaN is returned.

When called with a single size argument, normrnd returns a square
matrix with the dimension specified. When called with more than one scalar
argument, the first two arguments are taken as the number of rows and columns
and any further arguments specify additional matrix dimensions. The size may
also be specified with a row vector of dimensions, sz .

Further information about the normal distribution can be found at
https://en.wikipedia.org/wiki/Normal_distribution

See also:
normcdf,
norminv,
normpdf,
normfit,
normlike,
normstat


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 43
Random arrays from the normal distribution.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 5
plcdf


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1114
statistics: p = plcdf ( data , x , Fx )
statistics: p = plcdf ( data , x , Fx , 'upper' )

Piecewise linear cumulative distribution function (CDF).

For each element of data , compute the cumulative distribution function
(CDF) of the piecewise linear distribution with a vector of x values at
which the CDF changes slope and a vector of CDF values Fx that
correspond to each value in x . Both x and Fx must be
vectors of the same size and at least 2-elements long. The size of p
is the same as data .

p = plcdf ( data , x , Fx , "upper") computes
the upper tail probability of the piecewise linear distribution with
parameters x and Fx , at the values in data .

Further information about the piecewise linear distribution can be found at
https://en.wikipedia.org/wiki/Piecewise_linear_function

Input arguments must be double or single ; integer, logical,
and character arrays are rejected. MATLAB accepts a character array and
evaluates it at the character codes, which Octave deliberately does not,
since a character array is an integer type and integers are refused too.

See also:
plinv,
plpdf,
plrnd,
plstat


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 56
Piecewise linear cumulative distribution function (CDF).



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 5
plinv


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 895
statistics: data = plinv ( p , x , Fx )

Inverse of the piecewise linear distribution (iCDF).

For each element of p , compute the quantile (the inverse of the CDF)
of the piecewise linear distribution with a vector of x values at
which the CDF changes slope and a vector of CDF values Fx that
correspond to each value in x . Both x and Fx must be
vectors of the same_p size and at least 2-elements long.. The size of
data is the same_p as p .

Further information about the piecewise linear distribution can be found at
https://en.wikipedia.org/wiki/Piecewise_linear_function

Input arguments must be double or single ; integer, logical,
and character arrays are rejected. MATLAB accepts a character array and
evaluates it at the character codes, which Octave deliberately does not,
since a character array is an integer type and integers are refused too.

See also:
plcdf,
plpdf,
plrnd,
plstat


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 52
Inverse of the piecewise linear distribution (iCDF).



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 5
plpdf


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1062
statistics: y = plpdf ( data , x , Fx )

Piecewise linear probability density function (PDF).

For each element of data , compute the probability density function
(PDF) of the piecewise linear distribution with a vector of x values at
which the CDF changes slope and a vector of CDF values Fx that
correspond to each value in x . Both x and Fx must be
vectors of the same size and at least 2-elements long. The size of p
is the same as data .

Further information about the piecewise linear distribution can be found at
https://en.wikipedia.org/wiki/Piecewise_linear_function

Input arguments must be double or single ; integer, logical,
and character arrays are rejected. MATLAB accepts a character array and
evaluates it at the character codes, which Octave deliberately does not,
since a character array is an integer type and integers are refused too.

MATLAB also accepts integer input here, returning the result in the integer
class of the input; Octave rejects it, as it does for every other continuous
distribution.

See also:
plcdf,
plinv,
plrnd,
plstat


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 52
Piecewise linear probability density function (PDF).



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 5
plrnd


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1041
statistics: r = plrnd ( x , Fx )
statistics: r = plrnd ( x , Fx , rows )
statistics: r = plrnd ( x , Fx , rows , cols , &hellip;)
statistics: r = plrnd ( x , Fx , [ sz ])

Random arrays from the piecewise linear distribution.

r = plrnd ( x , Fx ) returns a random number chosen
from the piecewise linear distribution with a vector of x values at
which the CDF changes slope and a vector of CDF values Fx that
correspond to each value in x . Both x and Fx must be
vectors of the same size and at least 2-elements long.

When called with a single size argument, plrnd returns a square
matrix with the dimension specified. When called with more than one scalar
argument, the first two arguments are taken as the number of rows and columns
and any further arguments specify additional matrix dimensions. The size may
also be specified with a row vector of dimensions, sz .

Further information about the piecewise linear distribution can be found at
https://en.wikipedia.org/wiki/Piecewise_linear_function

See also:
plcdf,
plinv,
plpdf,
plstat


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 53
Random arrays from the piecewise linear distribution.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 8
poisscdf


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1091
statistics: p = poisscdf ( x , lambda )
statistics: p = poisscdf ( x , lambda , 'upper' )

Poisson cumulative distribution function (CDF).

For each element of x , compute the cumulative distribution function
(CDF) of the Poisson distribution with rate parameter lambda . The
size of p is the common size of x and lambda . A scalar
input functions as a constant matrix of the same size as the other inputs.

p = poisscdf ( x , lambda , "upper") computes the
upper tail probability of the Poisson distribution with parameter
lambda , at the values in x .

Further information about the Poisson distribution can be found at
https://en.wikipedia.org/wiki/Poisson_distribution

Input arguments must be double , single , or an integer type;
logical and character arrays are rejected. Integer input is promoted to
double , so the result is always a probability. MATLAB is
inconsistent here: for several of the discrete distributions it returns the
result in the integer class of the input, truncating a probability to
0 or 1 .

See also:
poissinv,
poisspdf,
poissrnd,
poissfit,
poisslike,
poisstat


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 47
Poisson cumulative distribution function (CDF).



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 8
poissinv


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 837
statistics: x = poissinv ( p , lambda )

Inverse of the Poisson cumulative distribution function (iCDF).

For each element of p , compute the quantile (the inverse of the CDF) of
the Poisson distribution with rate parameter lambda . The size of
x is the common size of p and lambda . A scalar input
functions as a constant matrix of the same size as the other inputs.

Further information about the Poisson distribution can be found at
https://en.wikipedia.org/wiki/Poisson_distribution

Input arguments must be double or single ; integer, logical,
and character arrays are rejected. MATLAB accepts a character array and
evaluates it at the character codes, which Octave deliberately does not,
since a character array is an integer type and integers are refused too.

See also:
poisscdf,
poisspdf,
poissrnd,
poissfit,
poisslike,
poisstat


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 63
Inverse of the Poisson cumulative distribution function (iCDF).



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 8
poisspdf


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1175
statistics: y = poisspdf ( x , lambda )

Poisson probability density function (PDF).

For each element of x , compute the probability density function (PDF)
of the Poisson distribution with rate parameter lambda . The size of
y is the common size of x and lambda . A scalar input
functions as a constant matrix of the same size as the other inputs.

Further information about the Poisson distribution can be found at
https://en.wikipedia.org/wiki/Poisson_distribution

Input arguments must be double , single , or an integer type;
logical and character arrays are rejected. Integer input is promoted to
double , so the result is always a probability. MATLAB is
inconsistent here: for several of the discrete distributions it returns the
result in the integer class of the input, truncating a probability to
0 or 1 .

The density at an infinite abscissa is 0 , no proper distribution
placing mass there. MATLAB returns NaN here, as it does for
raylpdf and for no other density, which is an inconsistency there rather
than a convention: it returns 0 at Inf for every other
distribution of the same support.

See also:
poisscdf,
poissinv,
poissrnd,
poissfit,
poisslike,
poisstat


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 43
Poisson probability density function (PDF).



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 8
poissrnd


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1116
statistics: r = poissrnd ( lambda )
statistics: r = poissrnd ( lambda , rows )
statistics: r = poissrnd ( lambda , rows , cols , &hellip;)
statistics: r = poissrnd ( lambda , [ sz ])

Random arrays from the Poisson distribution.

r = normrnd ( lambda ) returns an array of random numbers
chosen from the Poisson distribution with rate parameter lambda . The
size of r is the common size of lambda . A scalar input functions
as a constant matrix of the same size as the other inputs. lambda must
be a finite real number and greater or equal to 0, otherwise NaN is
returned.

When called with a single size argument, poissrnd returns a square
matrix with the dimension specified. When called with more than one scalar
argument, the first two arguments are taken as the number of rows and columns
and any further arguments specify additional matrix dimensions. The size may
also be specified with a row vector of dimensions, sz .

Further information about the Poisson distribution can be found at
https://en.wikipedia.org/wiki/Poisson_distribution

See also:
poisscdf,
poissinv,
poisspdf,
poissfit,
poisslike,
poisstat


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 44
Random arrays from the Poisson distribution.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 7
raylcdf


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1096
statistics: p = raylcdf ( x , sigma )
statistics: p = raylcdf ( x , sigma , 'upper' )

Rayleigh cumulative distribution function (CDF).

For each element of x , compute the cumulative distribution function
(CDF) of the Rayleigh distribution with scale parameter sigma . The
size of p is the common size of x and sigma . A scalar
input functions as a constant matrix of the same size as the other inputs.

p = raylcdf ( x , sigma , "upper") computes the upper
tail probability of the Rayleigh distribution with parameter sigma , at
the values in x .

Further information about the Rayleigh distribution can be found at
https://en.wikipedia.org/wiki/Rayleigh_distribution

Input arguments must be double or single ; integer, logical,
and character arrays are rejected. MATLAB accepts a character array and
evaluates it at the character codes, which Octave deliberately does not,
since a character array is an integer type and integers are refused too.

The prob.RayleighDistribution class names this same parameter
B , after MATLAB.

See also:
raylinv,
raylpdf,
raylrnd,
raylfit,
rayllike,
raylstat


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 48
Rayleigh cumulative distribution function (CDF).



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 7
raylinv


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 914
statistics: x = raylinv ( p , sigma )

Inverse of the Rayleigh cumulative distribution function (iCDF).

For each element of p , compute the quantile (the inverse of the CDF) of
the Rayleigh distribution with scale parameter sigma . The size of
x is the common size of p and sigma . A scalar input
functions as a constant matrix of the same size as the other inputs.

Further information about the Rayleigh distribution can be found at
https://en.wikipedia.org/wiki/Rayleigh_distribution

Input arguments must be double or single ; integer, logical,
and character arrays are rejected. MATLAB accepts a character array and
evaluates it at the character codes, which Octave deliberately does not,
since a character array is an integer type and integers are refused too.

The prob.RayleighDistribution class names this same parameter
B , after MATLAB.

See also:
raylcdf,
raylpdf,
raylrnd,
raylfit,
rayllike,
raylstat


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 64
Inverse of the Rayleigh cumulative distribution function (iCDF).



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 7
raylpdf


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1185
statistics: y = raylpdf ( x , sigma )

Rayleigh probability density function (PDF).

For each element of x , compute the probability density function (PDF)
of the Rayleigh distribution with scale parameter sigma . The size of
p is the common size of x and sigma . A scalar input
functions as a constant matrix of the same size as the other inputs.

Further information about the Rayleigh distribution can be found at
https://en.wikipedia.org/wiki/Rayleigh_distribution

Input arguments must be double or single ; integer, logical,
and character arrays are rejected. MATLAB accepts a character array and
evaluates it at the character codes, which Octave deliberately does not,
since a character array is an integer type and integers are refused too.

The density at an infinite abscissa is 0 , no proper distribution
placing mass there. MATLAB returns NaN here, as it does for
poisspdf and for no other density, which is an inconsistency there rather
than a convention: it returns 0 at Inf for every other
distribution of the same support.

The prob.RayleighDistribution class names this same parameter
B , after MATLAB.

See also:
raylcdf,
raylinv,
raylrnd,
raylfit,
rayllike,
raylstat


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 44
Rayleigh probability density function (PDF).



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 7
raylrnd


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1166
statistics: r = raylrnd ( sigma )
statistics: r = raylrnd ( sigma , rows )
statistics: r = raylrnd ( sigma , rows , cols , &hellip;)
statistics: r = raylrnd ( sigma , [ sz ])

Random arrays from the Rayleigh distribution.

r = raylrnd ( sigma ) returns an array of random numbers
chosen from the Rayleigh distribution with scale parameter sigma . The
size of r is the size of sigma . A scalar input functions as a
constant matrix of the same size as the other inputs. sigma must be a
finite real number greater than 0, otherwise NaN is returned.

When called with a single size argument, raylrnd returns a square
matrix with the dimension specified. When called with more than one scalar
argument, the first two arguments are taken as the number of rows and columns
and any further arguments specify additional matrix dimensions. The size may
also be specified with a row vector of dimensions, sz .

Further information about the Rayleigh distribution can be found at
https://en.wikipedia.org/wiki/Rayleigh_distribution

The prob.RayleighDistribution class names this same parameter
B , after MATLAB.

See also:
raylcdf,
raylinv,
raylpdf,
raylfit,
rayllike,
raylstat


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 45
Random arrays from the Rayleigh distribution.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 7
ricecdf


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1070
statistics: p = ricecdf ( x , s , sigma )
statistics: p = ricecdf ( x , s , sigma , 'upper' )

Rician cumulative distribution function (CDF).

For each element of x , compute the cumulative distribution function
(CDF) of the Rician distribution with non-centrality (distance) parameter
s and scale parameter sigma . The size of p is the common
size of x , s , and sigma . A scalar input functions as a
constant matrix of the same size as the other inputs.

p = ricecdf ( x , s , sigma , "upper") computes
the upper tail probability of the Rician distribution with parameters
s and sigma , at the values in x .

Further information about the Rician distribution can be found at
https://en.wikipedia.org/wiki/Rice_distribution

Input arguments must be double or single ; integer, logical,
and character arrays are rejected. MATLAB accepts a character array and
evaluates it at the character codes, which Octave deliberately does not,
since a character array is an integer type and integers are refused too.

See also:
riceinv,
ricepdf,
ricernd,
ricefit,
ricelike,
ricestat


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 46
Rician cumulative distribution function (CDF).



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 7
riceinv


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 855
statistics: x = riceinv ( p , s , sigma )

Inverse of the Rician distribution (iCDF).

For each element of p , compute the quantile (the inverse of the CDF)
of the Rician distribution with non-centrality (distance) parameter s
and scale parameter sigma . The size of x is the common size of
x , s , and sigma . A scalar input functions as a constant
matrix of the same size as the other inputs.

Further information about the Rician distribution can be found at
https://en.wikipedia.org/wiki/Rice_distribution

Input arguments must be double or single ; integer, logical,
and character arrays are rejected. MATLAB accepts a character array and
evaluates it at the character codes, which Octave deliberately does not,
since a character array is an integer type and integers are refused too.

See also:
ricecdf,
ricepdf,
ricernd,
ricefit,
ricelike,
ricestat


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 42
Inverse of the Rician distribution (iCDF).



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 7
ricepdf


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 856
statistics: y = ricepdf ( x , s , sigma )

Rician probability density function (PDF).

For each element of x , compute the probability density function (PDF)
of the Rician distribution with non-centrality (distance) parameter s
and scale parameter sigma . The size of y is the common size of
x , s , and sigma . A scalar input functions as a constant
matrix of the same size as the other inputs.

Further information about the Rician distribution can be found at
https://en.wikipedia.org/wiki/Rice_distribution

Input arguments must be double or single ; integer, logical,
and character arrays are rejected. MATLAB accepts a character array and
evaluates it at the character codes, which Octave deliberately does not,
since a character array is an integer type and integers are refused too.

See also:
ricecdf,
riceinv,
ricernd,
ricefit,
ricelike,
ricestat


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 42
Rician probability density function (PDF).



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 7
ricernd


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1060
statistics: r = ricernd ( s , sigma )
statistics: r = ricernd ( s , sigma , rows )
statistics: r = ricernd ( s , sigma , rows , cols , &hellip;)
statistics: r = ricernd ( s , sigma , [ sz ])

Random arrays from the Rician distribution.

r = ricernd ( s , sigma ) returns an array of random
numbers chosen from the Rician distribution with noncentrality parameter
s and scale parameter sigma . The size of r is the common
size of s and sigma . A scalar input functions as a constant
matrix of the same size as the other inputs.

When called with a single size argument, ricernd returns a square
matrix with the dimension specified. When called with more than one scalar
argument, the first two arguments are taken as the number of rows and columns
and any further arguments specify additional matrix dimensions. The size may
also be specified with a row vector of dimensions, sz .

Further information about the Rician distribution can be found at
https://en.wikipedia.org/wiki/Rice_distribution

See also:
ricecdf,
riceinv,
ricepdf,
ricefit,
ricelike,
ricestat


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 43
Random arrays from the Rician distribution.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 7
stblcdf


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1084
statistics: p = stblcdf ( x , alpha , beta , gam , delta )

Stable cumulative distribution function (CDF).

For each element of x , compute the cumulative distribution function
(CDF) of the stable distribution with tail index (first shape parameter)
alpha , skewness (second shape parameter) beta , scale parameter
gam , and location parameter delta , in the Nolan S0
parameterization. The size of p is the size of x .

alpha must be in the range (0, 2] , beta in [-1, 1] ,
gam positive, and delta real. The parameters must be scalars.

The cumulative probability has a closed form for alpha equal to
2 (normal) and for 1 with beta equal to 0
(Cauchy); otherwise it is computed by numerical inversion of the
characteristic function (the Gil-Pelaez formula).

Input arguments must be double or single ; integer, logical,
and character arrays are rejected. MATLAB accepts a character array and
evaluates it at the character codes, which Octave deliberately does not,
since a character array is an integer type and integers are refused too.

See also:
stblpdf,
stblinv,
stblrnd,
makedist


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 46
Stable cumulative distribution function (CDF).



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 7
stblinv


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1034
statistics: x = stblinv ( p , alpha , beta , gam , delta )

Inverse of the stable cumulative distribution function (iCDF).

For each element of p , compute the quantile (the inverse of the CDF) of
the stable distribution with tail index (first shape parameter) alpha ,
skewness (second shape parameter) beta , scale parameter gam , and
location parameter delta , in the Nolan S0 parameterization.
The size of x is the size of p .

alpha must be in the range (0, 2] , beta in [-1, 1] ,
gam positive, and delta real. The parameters must be scalars.

The quantile has a closed form for alpha equal to 2 (normal) and
for 1 with beta equal to 0 (Cauchy); otherwise it is
found by numerical inversion of stblcdf .

Input arguments must be double or single ; integer, logical,
and character arrays are rejected. MATLAB accepts a character array and
evaluates it at the character codes, which Octave deliberately does not,
since a character array is an integer type and integers are refused too.

See also:
stblcdf,
stblpdf,
stblrnd,
makedist


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 62
Inverse of the stable cumulative distribution function (iCDF).



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 7
stblpdf


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1036
statistics: y = stblpdf ( x , alpha , beta , gam , delta )

Stable probability density function (PDF).

For each element of x , compute the probability density function (PDF)
of the stable distribution with tail index (first shape parameter)
alpha , skewness (second shape parameter) beta , scale parameter
gam , and location parameter delta , in the Nolan S0
parameterization. The size of y is the size of x .

alpha must be in the range (0, 2] , beta in [-1, 1] ,
gam positive, and delta real. The parameters must be scalars.

The density has a closed form for alpha equal to 2 (normal) and
for 1 with beta equal to 0 (Cauchy); otherwise it is
computed by numerical inversion of the characteristic function.

Input arguments must be double or single ; integer, logical,
and character arrays are rejected. MATLAB accepts a character array and
evaluates it at the character codes, which Octave deliberately does not,
since a character array is an integer type and integers are refused too.

See also:
stblcdf,
stblinv,
stblrnd,
makedist


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 42
Stable probability density function (PDF).



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 7
stblrnd


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 997
statistics: r = stblrnd ( alpha , beta , gam , delta )
statistics: r = stblrnd ( alpha , beta , gam , delta , m )
statistics: r = stblrnd ( alpha , beta , gam , delta , m , n , &hellip;)
statistics: r = stblrnd ( alpha , beta , gam , delta , [ m , n , &hellip;])

Random arrays from the stable distribution.

r = stblrnd ( alpha , beta , gam , delta )
returns a random value drawn from the stable distribution with tail index
(first shape parameter) alpha , skewness (second shape parameter)
beta , scale parameter gam , and location parameter delta , in
the Nolan S0 parameterization.

alpha must be in the range (0, 2] , beta in [-1, 1] ,
gam positive, and delta real. The parameters must be scalars.

stblrnd ( alpha , beta , gam , delta , m ,
n , &hellip;) or stblrnd (&hellip;, [ m , n , &hellip;])
returns an m -by- n -by-&hellip; array, following the size
conventions of rand .

The values are generated with the Chambers-Mallows-Stuck method.

See also:
stblpdf,
stblcdf,
stblinv,
makedist


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 43
Random arrays from the stable distribution.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 4
tcdf


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1007
statistics: p = tcdf ( x , df )
statistics: p = tcdf ( x , df , 'upper' )

Student&rsquo;s T cumulative distribution function (CDF).

For each element of x , compute the cumulative distribution function
(CDF) of the Student&rsquo;s T distribution with df degrees of freedom. The
size of p is the common size of x and df . A scalar input
functions as a constant matrix of the same size as the other input.

p = tcdf ( x , df , "upper") computes the upper tail
probability of the Student&rsquo;s T distribution with df degrees of freedom,
at the values in x .

Further information about the Student&rsquo;s T distribution can be found at
https://en.wikipedia.org/wiki/Student%27s_t-distribution

Input arguments must be double or single ; integer, logical,
and character arrays are rejected. MATLAB accepts a character array and
evaluates it at the character codes, which Octave deliberately does not,
since a character array is an integer type and integers are refused too.

See also:
tinv,
tpdf,
trnd,
tstat


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 51
Student's T cumulative distribution function (CDF).



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 4
tinv


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1007
statistics: x = tinv ( p , df )

Inverse of the Student&rsquo;s T cumulative distribution function (iCDF).

For each element of p , compute the quantile (the inverse of the CDF) of
the Student&rsquo;s T distribution with df degrees of freedom. The size of
x is the common size of x and df . A scalar input functions
as a constant matrix of the same size as the other input.

This function is analogous to looking in a table for the t-value of a
single-tailed distribution. For very large df (>10000), the inverse of
the standard normal distribution is used.

Further information about the Student&rsquo;s T distribution can be found at
https://en.wikipedia.org/wiki/Student%27s_t-distribution

Input arguments must be double or single ; integer, logical,
and character arrays are rejected. MATLAB accepts a character array and
evaluates it at the character codes, which Octave deliberately does not,
since a character array is an integer type and integers are refused too.

See also:
tcdf,
tpdf,
trnd,
tstat


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 67
Inverse of the Student's T cumulative distribution function (iCDF).



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 6
tlscdf


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1245
statistics: p = tlscdf ( x , mu , sigma , nu )
statistics: p = tlscdf ( x , mu , sigma , nu , 'upper' )

Location-scale Student&rsquo;s T cumulative distribution function (CDF).

For each element of x , compute the cumulative distribution function
(CDF) of the location-scale Student&rsquo;s T distribution with location parameter
mu , scale parameter sigma , and nu degrees of freedom. The
size of p is the common size of x , mu , sigma , and
nu . A scalar input functions as a constant matrix of the same size as
the other inputs.

p = tlscdf ( x , mu , sigma , nu , "upper")
computes the upper tail probability of the location-scale Student&rsquo;s T
distribution with parameters mu , sigma , and nu , at the
values in x .

Further information about the location-scale Student&rsquo;s T distribution can be
found at
https://en.wikipedia.org/wiki/Student%27s_t-distribution#Location-scale_t_distribution

Input arguments must be double or single ; integer, logical,
and character arrays are rejected. MATLAB accepts a character array and
evaluates it at the character codes, which Octave deliberately does not,
since a character array is an integer type and integers are refused too.

See also:
tlsinv,
tlspdf,
tlsrnd,
tlsfit,
tlslike,
tlsstat


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 66
Location-scale Student's T cumulative distribution function (CDF).



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 6
tlsinv


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1006
statistics: x = tlsinv ( p , mu , sigma , nu )

Inverse of the location-scale Student&rsquo;s T cumulative distribution function
(iCDF).

For each element of p , compute the quantile (the inverse of the CDF) of
the location-scale Student&rsquo;s T distribution with location parameter mu ,
scale parameter sigma , and nu degrees of freedom. The size of
x is the common size of p , mu , sigma , and nu .
A scalar input functions as a constant matrix of the same size as the other
inputs.

Further information about the location-scale Student&rsquo;s T distribution can be
found at
https://en.wikipedia.org/wiki/Student%27s_t-distribution#Location-scale_t_distribution

Input arguments must be double or single ; integer, logical,
and character arrays are rejected. MATLAB accepts a character array and
evaluates it at the character codes, which Octave deliberately does not,
since a character array is an integer type and integers are refused too.

See also:
tlscdf,
tlspdf,
tlsrnd,
tlsfit,
tlslike,
tlsstat


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 82
Inverse of the location-scale Student's T cumulative distribution function (iCDF).



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 6
tlspdf


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 987
statistics: p = tlspdf ( x , mu , sigma , nu )

Location-scale Student&rsquo;s T probability density function (PDF).

For each element of x , compute the probability density function (PDF)
of the location-scale Student&rsquo;s T distribution with location parameter
mu , scale parameter sigma , and nu degrees of freedom. The
size of y is the common size of x , mu , sigma , and
nu . A scalar input functions as a constant matrix of the same size as
the other inputs.

Further information about the location-scale Student&rsquo;s T distribution can be
found at
https://en.wikipedia.org/wiki/Student%27s_t-distribution#Location-scale_t_distribution

Input arguments must be double or single ; integer, logical,
and character arrays are rejected. MATLAB accepts a character array and
evaluates it at the character codes, which Octave deliberately does not,
since a character array is an integer type and integers are refused too.

See also:
tlscdf,
tlsinv,
tlsrnd,
tlsfit,
tlslike,
tlsstat


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 62
Location-scale Student's T probability density function (PDF).



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 6
tlsrnd


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1381
statistics: r = tlsrnd ( mu , sigma , nu )
statistics: r = tlsrnd ( mu , sigma , nu , rows )
statistics: r = tlsrnd ( mu , sigma , nu , rows , cols , &hellip;)
statistics: r = tlsrnd ( mu , sigma , nu , [ sz ])

Random arrays from the location-scale Student&rsquo;s T distribution.

Return a matrix of random samples from the location-scale Student&rsquo;s T
distribution with location parameter mu , scale parameter sigma ,
and nu degrees of freedom.

r = tlsrnd ( nu ) returns an array of random numbers chosen
from the location-scale Student&rsquo;s T distribution with location parameter
mu , scale parameter sigma , and nu degrees of freedom. The
size of r is the common size of mu , sigma , and nu . A
scalar input functions as a constant matrix of the same size as the other
inputs.

When called with a single size argument, tlsrnd returns a square
matrix with the dimension specified. When called with more than one scalar
argument, the first two arguments are taken as the number of rows and columns
and any further arguments specify additional matrix dimensions. The size may
also be specified with a row vector of dimensions, sz .

Further information about the location-scale Student&rsquo;s T distribution can be
found at
https://en.wikipedia.org/wiki/Student%27s_t-distribution#Location-scale_t_distribution

See also:
tlscdf,
tlsinv,
tlspdf,
tlsfit,
tlslike,
tlsstat


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 63
Random arrays from the location-scale Student's T distribution.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 4
tpdf


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 804
statistics: p = tpdf ( x , df )

Student&rsquo;s T probability density function (PDF).

For each element of x , compute the probability density function (PDF)
of the Student&rsquo;s T distribution with df degrees of freedom. The size
of y is the common size of x and df . A scalar input
functions as a constant matrix of the same size as the other input.

Further information about the Student&rsquo;s T distribution can be found at
https://en.wikipedia.org/wiki/Student%27s_t-distribution

Input arguments must be double or single ; integer, logical,
and character arrays are rejected. MATLAB accepts a character array and
evaluates it at the character codes, which Octave deliberately does not,
since a character array is an integer type and integers are refused too.

See also:
tcdf,
tinv,
trnd,
tstat


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 47
Student's T probability density function (PDF).



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 6
tricdf


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1725
statistics: p = tricdf ( x , a , b , c )
statistics: p = tricdf ( x , a , b , c , 'upper' )

Triangular cumulative distribution function (CDF).

For each element of x , compute the cumulative distribution function
(CDF) of the triangular distribution with lower limit parameter a , peak
location (mode) parameter b , and upper limit parameter c . The
size of p is the common size of the input arguments. A scalar input
functions as a constant matrix of the same size as the other inputs.

p = tricdf ( x , a , b , c , "upper")
computes the upper tail probability of the triangular distribution with
parameters a , b , and c , at the values in x .

Note that the order of the parameter input arguments has been changed after
statistics version 1.6.3 in order to be MATLAB compatible with the parameters
used in the TriangularDistribution probability distribution object. More
specifically, the positions of the parameters b and c have been
swapped. As a result, the naming conventions no longer coincide with those
used in Wikipedia, in which b denotes the upper limit and c
denotes the mode or peak parameter.

Further information about the triangular distribution can be found at
https://en.wikipedia.org/wiki/Triangular_distribution

Input arguments must be double or single ; integer, logical,
and character arrays are rejected. MATLAB accepts a character array and
evaluates it at the character codes, which Octave deliberately does not,
since a character array is an integer type and integers are refused too.

MATLAB also accepts integer input here, returning the result in the integer
class of the input; Octave rejects it, as it does for every other continuous
distribution.

See also:
triinv,
tripdf,
trirnd,
tristat


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 50
Triangular cumulative distribution function (CDF).



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 6
triinv


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1358
statistics: x = triinv ( p , a , b , c )

Inverse of the triangular cumulative distribution function (iCDF).

For each element of p , compute the quantile (the inverse of the CDF) of
the triangular distribution with lower limit parameter a , peak
location (mode) parameter b , and upper limit parameter c . The
size of x is the common size of the input arguments. A scalar input
functions as a constant matrix of the same size as the other inputs.

Note that the order of the parameter input arguments has been changed after
statistics version 1.6.3 in order to be MATLAB compatible with the parameters
used in the TriangularDistribution probability distribution object. More
specifically, the positions of the parameters b and c have been
swapped. As a result, the naming conventions no longer coincide with those
used in Wikipedia, in which b denotes the upper limit and c
denotes the mode or peak parameter.

Further information about the triangular distribution can be found at
https://en.wikipedia.org/wiki/Triangular_distribution

Input arguments must be double or single ; integer, logical,
and character arrays are rejected. MATLAB accepts a character array and
evaluates it at the character codes, which Octave deliberately does not,
since a character array is an integer type and integers are refused too.

See also:
tricdf,
tripdf,
trirnd,
tristat


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 66
Inverse of the triangular cumulative distribution function (iCDF).



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 6
tripdf


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1507
statistics: y = tripdf ( x , a , b , c )

Triangular probability density function (PDF).

For each element of x , compute the probability density function (PDF)
of the triangular distribution with lower limit parameter a , peak
location (mode) parameter b , and upper limit parameter c . The
size of y is the common size of the input arguments. A scalar input
functions as a constant matrix of the same size as the other inputs.

Note that the order of the parameter input arguments has been changed after
statistics version 1.6.3 in order to be MATLAB compatible with the parameters
used in the TriangularDistribution probability distribution object. More
specifically, the positions of the parameters b and c have been
swapped. As a result, the naming conventions no longer coincide with those
used in Wikipedia, in which b denotes the upper limit and c
denotes the mode or peak parameter.

Further information about the triangular distribution can be found at
https://en.wikipedia.org/wiki/Triangular_distribution

Input arguments must be double or single ; integer, logical,
and character arrays are rejected. MATLAB accepts a character array and
evaluates it at the character codes, which Octave deliberately does not,
since a character array is an integer type and integers are refused too.

MATLAB also accepts integer input here, returning the result in the integer
class of the input; Octave rejects it, as it does for every other continuous
distribution.

See also:
tricdf,
triinv,
trirnd,
tristat


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 46
Triangular probability density function (PDF).



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 6
trirnd


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1547
statistics: r = trirnd ( a , b , c )
statistics: r = trirnd ( a , b , c , rows )
statistics: r = trirnd ( a , b , c , rows , cols , &hellip;)
statistics: r = trirnd ( a , b , c , [ sz ])

Random arrays from the triangular distribution.

r = trirnd ( sigma ) returns an array of random numbers
chosen from the triangular distribution with lower limit parameter a ,
peak location (mode) parameter b , and upper limit parameter c .
The size of r is the common size of a , b , and c . A
scalar input functions as a constant matrix of the same size as the other
inputs.

When called with a single size argument, trirnd returns a square
matrix with the dimension specified. When called with more than one scalar
argument, the first two arguments are taken as the number of rows and columns
and any further arguments specify additional matrix dimensions. The size may
also be specified with a row vector of dimensions, sz .

Note that the order of the parameter input arguments has been changed after
statistics version 1.6.3 in order to be MATLAB compatible with the parameters
used in the TriangularDistribution probability distribution object. More
specifically, the positions of the parameters b and c have been
swapped. As a result, the naming conventions no longer coincide with those
used in Wikipedia, in which b denotes the upper limit and c
denotes the mode or peak parameter.

Further information about the triangular distribution can be found at
https://en.wikipedia.org/wiki/Triangular_distribution

See also:
tricdf,
triinv,
tripdf,
tristat


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 47
Random arrays from the triangular distribution.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 4
trnd


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1150
statistics: r = trnd ( df )
statistics: r = trnd ( df , rows )
statistics: r = trnd ( df , rows , cols , &hellip;)
statistics: r = trnd ( df , [ sz ])

Random arrays from the Student&rsquo;s T distribution.

Return a matrix of random samples from the Students&rsquo;s T distribution with
df degrees of freedom.

r = trnd ( df ) returns an array of random numbers chosen
from the Student&rsquo;s T distribution with df degrees of freedom. The size
of r is the size of df . A scalar input functions as a constant
matrix of the same size as the other inputs. df must be a finite real
number greater than 0, otherwise NaN is returned.

When called with a single size argument, trnd returns a square matrix
with the dimension specified. When called with more than one scalar
argument, the first two arguments are taken as the number of rows and columns
and any further arguments specify additional matrix dimensions. The size may
also be specified with a row vector of dimensions, sz .

Further information about the Student&rsquo;s T distribution can be found at
https://en.wikipedia.org/wiki/Student%27s_t-distribution

See also:
tcdf,
tinv,
tpdf,
tstat


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 48
Random arrays from the Student's T distribution.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 7
unidcdf


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1471
statistics: p = unidcdf ( x , N )
statistics: p = unidcdf ( x , N , 'upper' )

Discrete uniform cumulative distribution function (CDF).

For each element of x , compute the cumulative distribution function
(CDF) of a discrete uniform distribution with parameter N , which
corresponds to the maximum observable value. unidcdf assumes the
integer values in the range [1,N] with equal probability. The size of
p is the common size of x and N . A scalar input functions
as a constant matrix of the same size as the other inputs.

The maximum observable values in N must be positive integers, otherwise
NaN is returned.

[&hellip;] = unidcdf ( x , N , "upper") computes the upper
tail probability of the discrete uniform distribution with maximum observable
value N , at the values in x .

Warning: The underlying implementation uses the double class and will only
be accurate for N < flintmax ( 2^{53} on
IEEE 754 compatible systems).

Further information about the discrete uniform distribution can be found at
https://en.wikipedia.org/wiki/Discrete_uniform_distribution

Input arguments must be double , single , or an integer type;
logical and character arrays are rejected. Integer input is promoted to
double , so the result is always a probability. MATLAB is
inconsistent here: for several of the discrete distributions it returns the
result in the integer class of the input, truncating a probability to
0 or 1 .

See also:
unidinv,
unidpdf,
unidrnd,
unidfit,
unidstat


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 56
Discrete uniform cumulative distribution function (CDF).



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 7
unidinv


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1203
statistics: x = unidinv ( p , N )

Inverse of the discrete uniform cumulative distribution function (iCDF).

For each element of p , compute the quantile (the inverse of the CDF) of
the discrete uniform distribution with parameter N , which corresponds
to the maximum observable value. unidinv assumes the integer values
in the range [1,N] with equal probability. The size of x is the
common size of p and N . A scalar input functions as a constant
matrix of the same size as the other inputs.

The maximum observable values in N must be positive integers, otherwise
NaN is returned.

Warning: The underlying implementation uses the double class and will only
be accurate for N < flintmax ( 2^{53} on
IEEE 754 compatible systems).

Further information about the discrete uniform distribution can be found at
https://en.wikipedia.org/wiki/Discrete_uniform_distribution

Input arguments must be double or single ; integer, logical,
and character arrays are rejected. MATLAB accepts a character array and
evaluates it at the character codes, which Octave deliberately does not,
since a character array is an integer type and integers are refused too.

See also:
unidcdf,
unidpdf,
unidrnd,
unidfit,
unidstat


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 72
Inverse of the discrete uniform cumulative distribution function (iCDF).



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 7
unidpdf


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1252
statistics: y = unidpdf ( x , N )

Discrete uniform probability density function (PDF).

For each element of x , compute the probability density function (PDF)
of the discrete uniform distribution with parameter N , which
corresponds to the maximum observable value. unidpdf assumes the
integer values in the range [1,N] with equal probability. The size of
x is the common size of p and N . A scalar input functions
as a constant matrix of the same size as the other inputs.

The maximum observable values in N must be positive integers, otherwise
NaN is returned.

Warning: The underlying implementation uses the double class and will only
be accurate for N < flintmax ( 2^{53} on
IEEE 754 compatible systems).

Further information about the discrete uniform distribution can be found at
https://en.wikipedia.org/wiki/Discrete_uniform_distribution

Input arguments must be double , single , or an integer type;
logical and character arrays are rejected. Integer input is promoted to
double , so the result is always a probability. MATLAB is
inconsistent here: for several of the discrete distributions it returns the
result in the integer class of the input, truncating a probability to
0 or 1 .

See also:
unidcdf,
unidinv,
unidrnd,
unidfit,
unidstat


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 52
Discrete uniform probability density function (PDF).



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 7
unidrnd


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1361
statistics: r = unidrnd ( N )
statistics: r = unidrnd ( N , rows )
statistics: r = unidrnd ( N , rows , cols , &hellip;)
statistics: r = unidrnd ( N , [ sz ])

Random arrays from the discrete uniform distribution.

r = unidrnd ( N ) returns an array of random numbers chosen
from the discrete uniform distribution with parameter N , which
corresponds to the maximum observable value. unidrnd assumes the
integer values in the range [1,N] with equal probability. The size of
r is the size of N . A scalar input functions as a constant
matrix of the same size as the other inputs.

The maximum observable values in N must be positive integers, otherwise
NaN is returned.

When called with a single size argument, unidrnd returns a square
matrix with the dimension specified. When called with more than one scalar
argument, the first two arguments are taken as the number of rows and columns
and any further arguments specify additional matrix dimensions. The size may
also be specified with a row vector of dimensions, sz .

Warning: The underlying implementation uses the double class and will only
be accurate for N < flintmax ( 2^{53} on
IEEE 754 compatible systems).

Further information about the discrete uniform distribution can be found at
https://en.wikipedia.org/wiki/Discrete_uniform_distribution

See also:
unidcdf,
unidinv,
unidpdf,
unidfit,
unidstat


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 53
Random arrays from the discrete uniform distribution.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 7
unifcdf


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1303
statistics: p = unifcdf ( x , a , b )
statistics: p = unifcdf ( x , a , b , 'upper' )

Continuous uniform cumulative distribution function (CDF).

For each element of x , compute the cumulative distribution function
(CDF) of the continuous uniform distribution with parameters a and
b , which define the lower and upper bounds of the interval
[ a , b ] . The size of p is the common size of
x , a , and b . A scalar input functions as a constant matrix
of the same size as the other inputs.

[&hellip;] = unifcdf ( x , a , b , "upper") computes the
upper tail probability of the continuous uniform distribution with parameters
a , and b , at the values in x .

Further information about the continuous uniform distribution can be found at
https://en.wikipedia.org/wiki/Continuous_uniform_distribution

Input arguments must be double or single ; integer, logical,
and character arrays are rejected. MATLAB accepts a character array and
evaluates it at the character codes, which Octave deliberately does not,
since a character array is an integer type and integers are refused too.

MATLAB also accepts integer input here, returning the result in the integer
class of the input; Octave rejects it, as it does for every other continuous
distribution.

See also:
unifinv,
unifpdf,
unifrnd,
unifit,
unifstat


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 58
Continuous uniform cumulative distribution function (CDF).



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 7
unifinv


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 929
statistics: x = unifinv ( p , a , b )

Inverse of the continuous uniform cumulative distribution function (iCDF).

For each element of p , compute the quantile (the inverse of the CDF) of
the continuous uniform distribution with parameters a and b ,
which define the lower and upper bounds of the interval
[ a , b ] . The size of x is the common size of
p , a , and b . A scalar input functions as a constant matrix
of the same size as the other inputs.

Further information about the continuous uniform distribution can be found at
https://en.wikipedia.org/wiki/Continuous_uniform_distribution

Input arguments must be double or single ; integer, logical,
and character arrays are rejected. MATLAB accepts a character array and
evaluates it at the character codes, which Octave deliberately does not,
since a character array is an integer type and integers are refused too.

See also:
unifcdf,
unifpdf,
unifrnd,
unifit,
unifstat


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 74
Inverse of the continuous uniform cumulative distribution function (iCDF).



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 7
unifpdf


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1078
statistics: y = unifpdf ( x , a , b )

Continuous uniform probability density function (PDF).

For each element of x , compute the probability density function (PDF)
of the continuous uniform distribution with parameters a and b ,
which define the lower and upper bounds of the interval
[ a , b ] . The size of y is the common size of
x , a , and b . A scalar input functions as a constant matrix
of the same size as the other inputs.

Further information about the continuous uniform distribution can be found at
https://en.wikipedia.org/wiki/Continuous_uniform_distribution

Input arguments must be double or single ; integer, logical,
and character arrays are rejected. MATLAB accepts a character array and
evaluates it at the character codes, which Octave deliberately does not,
since a character array is an integer type and integers are refused too.

MATLAB also accepts integer input here, returning the result in the integer
class of the input; Octave rejects it, as it does for every other continuous
distribution.

See also:
unifcdf,
unifinv,
unifrnd,
unifit,
unifstat


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 54
Continuous uniform probability density function (PDF).



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 7
unifrnd


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1110
statistics: r = unifrnd ( a , b )
statistics: r = unifrnd ( a , b , rows )
statistics: r = unifrnd ( a , b , rows , cols , &hellip;)
statistics: r = unifrnd ( a , b , [ sz ])

Random arrays from the continuous uniform distribution.

r = unifrnd ( a , b ) returns an array of random
numbers chosen from the continuous uniform distribution with parameters
a and b , which define the lower and upper bounds of the interval
[ a , b ] . The size of r is the common size of
a and b . A scalar input functions as a constant matrix of the
same size as the other inputs.

When called with a single size argument, unifrnd returns a square
matrix with the dimension specified. When called with more than one scalar
argument, the first two arguments are taken as the number of rows and columns
and any further arguments specify additional matrix dimensions. The size may
also be specified with a row vector of dimensions, sz .

Further information about the continuous uniform distribution can be found at
https://en.wikipedia.org/wiki/Continuous_uniform_distribution

See also:
unifcdf,
unifinv,
unifpdf,
unifit,
unifstat


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 55
Random arrays from the continuous uniform distribution.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 5
vmcdf


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1390
statistics: p = vmcdf ( x , mu , k )
statistics: p = vmcdf ( x , mu , k , 'upper' )

Von Mises probability density function (PDF).

For each element of x , compute the cumulative distribution function
(CDF) of the von Mises distribution with location parameter mu and
concentration parameter k on the interval [-pi,pi] . The size of
p is the common size of x , mu , and k . A scalar input
functions as a constant matrix of the same same size as the other inputs.

p = vmcdf ( x , mu , k , "upper") computes the
upper tail probability of the von Mises distribution with parameters mu
and k , at the values in x .

Note: the CDF of the von Mises distribution is not analytic. Hence, it is
calculated by integrating its probability density which is expressed as a
series of Bessel functions. Balancing between performance and accuracy, the
integration uses a step of 1e-5 on the interval [-pi,pi] ,
which results to an accuracy of about 10 significant digits.

Further information about the von Mises distribution can be found at
https://en.wikipedia.org/wiki/Von_Mises_distribution

Input arguments must be double or single ; integer, logical,
and character arrays are rejected. MATLAB accepts a character array and
evaluates it at the character codes, which Octave deliberately does not,
since a character array is an integer type and integers are refused too.

See also:
vminv,
vmpdf,
vmrnd


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 45
Von Mises probability density function (PDF).



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 5
vminv


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1193
statistics: x = vminv ( p , mu , k )

Inverse of the von Mises cumulative distribution function (iCDF).

For each element of p , compute the quantile (the inverse of the CDF) of
the von Mises distribution with location parameter mu and concentration
parameter k on the interval [-pi,pi] . The size of x is
the common size of p , mu , and k . A scalar input functions
as a constant matrix of the same size as the other inputs.

Note: the quantile of the von Mises distribution is not analytic. Hence, it
is approximated by a custom searching algorithm using its CDF until it
converges up to a tolerance of 1e-5 or 100 iterations. As a result,
balancing between performance and accuracy, the accuracy is about
5e-5 for k = 1 and it drops to 5e-5 as k
increases.

Further information about the von Mises distribution can be found at
https://en.wikipedia.org/wiki/Von_Mises_distribution

Input arguments must be double or single ; integer, logical,
and character arrays are rejected. MATLAB accepts a character array and
evaluates it at the character codes, which Octave deliberately does not,
since a character array is an integer type and integers are refused too.

See also:
vmcdf,
vmpdf,
vmrnd


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 65
Inverse of the von Mises cumulative distribution function (iCDF).



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 5
vmpdf


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 840
statistics: y = vmpdf ( x , mu , k )

Von Mises probability density function (PDF).

For each element of x , compute the probability density function (PDF)
of the von Mises distribution with location parameter mu and
concentration parameter k on the interval [-pi, pi]. The size of
y is the common size of x , mu , and k . A scalar input
functions as a constant matrix of the same size as the other inputs.

Further information about the von Mises distribution can be found at
https://en.wikipedia.org/wiki/Von_Mises_distribution

Input arguments must be double or single ; integer, logical,
and character arrays are rejected. MATLAB accepts a character array and
evaluates it at the character codes, which Octave deliberately does not,
since a character array is an integer type and integers are refused too.

See also:
vmcdf,
vminv,
vmrnd


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 45
Von Mises probability density function (PDF).



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 5
vmrnd


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1113
statistics: r = vmrnd ( mu , k )
statistics: r = vmrnd ( mu , k , rows )
statistics: r = vmrnd ( mu , k , rows , cols , &hellip;)
statistics: r = vmrnd ( mu , k , [ sz ])

Random arrays from the von Mises distribution.

r = vmrnd ( mu , k ) returns an array of random angles
chosen from a von Mises distribution with location parameter mu and
concentration parameter k on the interval [-pi, pi]. The size of
r is the common size of mu and k . A scalar input functions
as a constant matrix of the same size as the other inputs. Both parameters
must be finite real numbers and k > 0, otherwise NaN is returned.

When called with a single size argument, vmrnd returns a square
matrix with the dimension specified. When called with more than one scalar
argument, the first two arguments are taken as the number of rows and columns
and any further arguments specify additional matrix dimensions. The size may
also be specified with a row vector of dimensions, sz .

Further information about the von Mises distribution can be found at
https://en.wikipedia.org/wiki/Von_Mises_distribution

See also:
vmcdf,
vminv,
vmpdf


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 46
Random arrays from the von Mises distribution.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 6
wblcdf


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1879
statistics: p = wblcdf ( x )
statistics: p = wblcdf ( x , lambda )
statistics: p = wblcdf ( x , lambda , k )
statistics: p = wblcdf (&hellip;, 'upper' )
statistics: [ p , plo , pup ] = wblcdf ( x , lambda , k , pcov )
statistics: [ p , plo , pup ] = wblcdf ( x , lambda , k , pcov , alpha )
statistics: [ p , plo , pup ] = wblcdf (&hellip;, 'upper' )

Weibull cumulative distribution function (CDF).

For each element of x , compute the cumulative distribution function
(CDF) of the Weibull distribution with scale parameter lambda and shape
parameter k . The size of p is the common size of x ,
lambda and k . A scalar input functions as a constant matrix of
the same size as the other inputs.

Default values are lambda = 1, k = 1.

When called with three output arguments, [ p , plo ,
pup ] it computes the confidence bounds for p when the input
parameters lambda and k are estimates. In such case, pcov ,
a 2-by-2 matrix containing the covariance matrix of the estimated parameters,
is necessary. Optionally, alpha has a default value of 0.05, and
specifies 100 * (1 - alpha )% confidence bounds. plo and pup
are arrays of the same size as p containing the lower and upper
confidence bounds.

[&hellip;] = wblcdf (&hellip;, "upper") computes the upper tail
probability of the lognormal distribution.

Further information about the Weibull distribution can be found at
https://en.wikipedia.org/wiki/Weibull_distribution

Input arguments must be double or single ; integer, logical,
and character arrays are rejected. MATLAB accepts a character array and
evaluates it at the character codes, which Octave deliberately does not,
since a character array is an integer type and integers are refused too.

The prob.WeibullDistribution class names these same two parameters
A and B , after MATLAB. lambda is its A and
k is its B .

See also:
wblinv,
wblpdf,
wblrnd,
wblstat,
wblplot


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 47
Weibull cumulative distribution function (CDF).



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 6
wblinv


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1080
statistics: x = wblinv ( p )
statistics: x = wblinv ( p , lambda )
statistics: x = wblinv ( p , lambda , k )

Inverse of the Weibull cumulative distribution function (iCDF).

For each element of p , compute the quantile (the inverse of the CDF)
of the Weibull distribution with scale parameter lambda and shape
parameter k . The size of x is the common size of p ,
lambda , and k . A scalar input functions as a constant matrix of
the same size as the other inputs.

Default values are lambda = 1, k = 1.

Further information about the Weibull distribution can be found at
https://en.wikipedia.org/wiki/Weibull_distribution

Input arguments must be double or single ; integer, logical,
and character arrays are rejected. MATLAB accepts a character array and
evaluates it at the character codes, which Octave deliberately does not,
since a character array is an integer type and integers are refused too.

The prob.WeibullDistribution class names these same two parameters
A and B , after MATLAB. lambda is its A and
k is its B .

See also:
wblcdf,
wblpdf,
wblrnd,
wblstat,
wblplot


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 63
Inverse of the Weibull cumulative distribution function (iCDF).



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 6
wblpdf


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1078
statistics: y = wblpdf ( x )
statistics: y = wblpdf ( x , lambda )
statistics: y = wblpdf ( x , lambda , k )

Weibull probability density function (PDF).

For each element of x , compute the probability density function (PDF)
of the Weibull distribution with scale parameter lambda and shape
parameter k . The size of y is the common size of x ,
lambda , and k . A scalar input functions as a constant matrix of
the same size as the other inputs.

Default values are lambda = 1, k = 1.

Further information about the Weibull distribution can be found at
https://en.wikipedia.org/wiki/Weibull_distribution

Input arguments must be double or single ; integer, logical,
and character arrays are rejected. MATLAB accepts a character array and
evaluates it at the character codes, which Octave deliberately does not,
since a character array is an integer type and integers are refused too.

The prob.WeibullDistribution class names these same two parameters
A and B , after MATLAB. lambda is its A and
k is its B .

See also:
wblcdf,
wblinv,
wblrnd,
wblfit,
wbllike,
wblstat,
wblplot


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 43
Weibull probability density function (PDF).



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 6
wblrnd


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1227
statistics: r = wblrnd ( lambda , k )
statistics: r = wblrnd ( lambda , k , rows )
statistics: r = wblrnd ( lambda , k , rows , cols , &hellip;)
statistics: r = wblrnd ( lambda , k , [ sz ])

Random arrays from the Weibull distribution.

r = wblrnd ( lambda , k ) returns an array of random
numbers chosen from the Weibull distribution with scale parameter
lambda and shape parameter k . The size of r is the common
size of lambda and k . A scalar input functions as a constant
matrix of the same size as the other inputs. Both parameters must be
positive reals.

When called with a single size argument, wblrnd returns a square
matrix with the dimension specified. When called with more than one scalar
argument, the first two arguments are taken as the number of rows and columns
and any further arguments specify additional matrix dimensions. The size may
also be specified with a row vector of dimensions, sz .

Further information about the Weibull distribution can be found at
https://en.wikipedia.org/wiki/Weibull_distribution

The prob.WeibullDistribution class names these same two parameters
A and B , after MATLAB. lambda is its A and
k is its B .

See also:
wblcdf,
wblinv,
wblpdf,
wblfit,
wbllike,
wblstat,
wblplot


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 44
Random arrays from the Weibull distribution.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 7
wienrnd


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 421
statistics: r = wienrnd ( t , d , n )

Return a simulated realization of the d -dimensional Wiener Process
on the interval [0, t ].

If d is omitted, d = 1 is used. The first column of the
return matrix contains time, the remaining columns contain the Wiener
process.

The optional parameter n defines the number of summands used for
simulating the process over an interval of length 1. If n is
omitted, n = 1000 is used.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 90
Return a simulated realization of the d-dimensional Wiener Process on the interval [0, t].



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 7
wishpdf


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 892
statistics: y = wishpdf ( W , Sigma , df , log_y =false)

Compute the probability density function of the Wishart distribution

Inputs: A p x p matrix W where to find the PDF. The p
x p positive definite matrix Sigma and scalar degrees of freedom
parameter df characterizing the Wishart distribution. (For the density
to be finite, need df > ( p - 1).)

If the flag log_y is set, return the log probability density &ndash; this
helps avoid underflow when the numerical value of the density is very small

Output: y is the probability density of Wishart( Sigma , df )
at W .

Input arguments must be double or single ; integer, logical,
and character arrays are rejected. MATLAB accepts a character array and
evaluates it at the character codes, which Octave deliberately does not,
since a character array is an integer type and integers are refused too.

See also:
wishrnd,
iwishpdf,
iwishrnd


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 68
Compute the probability density function of the Wishart distribution



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 7
wishrnd


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 981
statistics: [ W , D ] = wishrnd ( Sigma , df , D , n =1)

Return a random matrix sampled from the Wishart distribution with given
parameters

Inputs: the p &times; p positive definite matrix Sigma (or the
lower-triangular Cholesky factor D of Sigma ) and scalar degrees
of freedom parameter df .

df can be non-integer as long as df > p - 1

Output: a random p &times; p matrix W from the
Wishart( Sigma , df ) distribution. If n > 1, then W is
p x p x n and holds n such random matrices.
(Optionally, the lower-triangular Cholesky factor D of Sigma is
also returned.)

Averaged across many samples, the mean of W should approach
df * Sigma , and the variance of each element W _ij should
approach df *( Sigma _ij^2 + Sigma _ii* Sigma _jj)

References

Yu-Cheng Ku and Peter Bloomfield (2010), Generating Random Wishart Matrices
with Fractional Degrees of Freedom in OX,
http://www.gwu.edu/~forcpgm/YuChengKu-030510final-WishartYu-ChengKu.pdf

See also:
wishpdf,
iwishpdf,
iwishrnd


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 82
Return a random matrix sampled from the Wishart distribution with given parameters





