StableDistributionFeller Type

Constructors

Constructor Description

StableDistributionFeller()

Full Usage: StableDistributionFeller()

Creates a new instance of this distribution with default parameters (alpha=1, beta=0) and the default generator.

StableDistributionFeller(generator)

Full Usage: StableDistributionFeller(generator)

Parameters:
    generator : Generator - Random number generator to be used with this distribution.

Creates a new instance of this distribution with default parameters (alpha=1, beta=0).

generator : Generator

Random number generator to be used with this distribution.

StableDistributionFeller(alpha, gamma)

Full Usage: StableDistributionFeller(alpha, gamma)

Parameters:
    alpha : float - Distribution parameter alpha (broadness exponent).
    gamma : float - Distribution parameter gamma (skew).

Creates a new instance of this distribution with given parameters (alpha, beta) and the default random number generator.

alpha : float

Distribution parameter alpha (broadness exponent).

gamma : float

Distribution parameter gamma (skew).

StableDistributionFeller(alpha, gamma, aga)

Full Usage: StableDistributionFeller(alpha, gamma, aga)

Parameters:
    alpha : float - Distribution parameter alpha (broadness exponent).
    gamma : float - Distribution parameter gamma (skew).
    aga : float - Parameter to specify gamma with higher accuracy around it's limit(s). For an explanation how aga is defined, see StableDistributionFeller.GetAgaFromAlphaGamma.

Creates a new instance of this distribution with given parameters (alpha, beta, abe) and the default random number generator.

alpha : float

Distribution parameter alpha (broadness exponent).

gamma : float

Distribution parameter gamma (skew).

aga : float

Parameter to specify gamma with higher accuracy around it's limit(s). For an explanation how aga is defined, see StableDistributionFeller.GetAgaFromAlphaGamma.

StableDistributionFeller(alpha, gamma, scale, location)

Full Usage: StableDistributionFeller(alpha, gamma, scale, location)

Parameters:
    alpha : float - Distribution parameter alpha (broadness exponent).
    gamma : float - Distribution parameter gamma (skew).
    scale : float - Scaling parameter (broadness of the distribution).
    location : float - Location of the distribution.

Creates a new instance of this distribution with given parameters (alpha, beta, scale, location) and the default random number generator.

alpha : float

Distribution parameter alpha (broadness exponent).

gamma : float

Distribution parameter gamma (skew).

scale : float

Scaling parameter (broadness of the distribution).

location : float

Location of the distribution.

StableDistributionFeller(alpha, gamma, scale, location, generator)

Full Usage: StableDistributionFeller(alpha, gamma, scale, location, generator)

Parameters:
    alpha : float - Distribution parameter alpha (broadness exponent).
    gamma : float - Distribution parameter gamma (skew).
    scale : float - Scaling parameter (broadness of the distribution).
    location : float - Location of the distribution.
    generator : Generator - Random number generator to be used with this distribution.

Creates a new instance of this distribution with given parameters (alpha, beta, scale, location) and the provided random number generator.

alpha : float

Distribution parameter alpha (broadness exponent).

gamma : float

Distribution parameter gamma (skew).

scale : float

Scaling parameter (broadness of the distribution).

location : float

Location of the distribution.

generator : Generator

Random number generator to be used with this distribution.

StableDistributionFeller(alpha, gamma, aga, scale, location)

Full Usage: StableDistributionFeller(alpha, gamma, aga, scale, location)

Parameters:
    alpha : float - Distribution parameter alpha (broadness exponent).
    gamma : float - Distribution parameter gamma (skew).
    aga : float - Parameter to specify gamma with higher accuracy around it's limit(s). For an explanation how aga is defined, see StableDistributionFeller.GetAgaFromAlphaGamma.
    scale : float - Scaling parameter (broadness of the distribution).
    location : float - Location of the distribution.

Creates a new instance of this distribution with given parameters (alpha, beta, abe, scale, location) and the default random number generator.

alpha : float

Distribution parameter alpha (broadness exponent).

gamma : float

Distribution parameter gamma (skew).

aga : float

Parameter to specify gamma with higher accuracy around it's limit(s). For an explanation how aga is defined, see StableDistributionFeller.GetAgaFromAlphaGamma.

scale : float

Scaling parameter (broadness of the distribution).

location : float

Location of the distribution.

StableDistributionFeller(alpha, gamma, aga, scale, location, generator)

Full Usage: StableDistributionFeller(alpha, gamma, aga, scale, location, generator)

Parameters:
    alpha : float - Distribution parameter alpha (broadness exponent).
    gamma : float - Distribution parameter gamma (skew).
    aga : float - Parameter to specify gamma with higher accuracy around it's limit(s). For an explanation how aga is defined, see StableDistributionFeller.GetAgaFromAlphaGamma.
    scale : float - Scaling parameter (broadness of the distribution).
    location : float - Location of the distribution.
    generator : Generator - Random number generator to be used with this distribution.

Creates a new instance of this distribution with given parameters (alpha, beta, abe, scale, location) and the provided random number generator.

alpha : float

Distribution parameter alpha (broadness exponent).

gamma : float

Distribution parameter gamma (skew).

aga : float

Parameter to specify gamma with higher accuracy around it's limit(s). For an explanation how aga is defined, see StableDistributionFeller.GetAgaFromAlphaGamma.

scale : float

Scaling parameter (broadness of the distribution).

location : float

Location of the distribution.

generator : Generator

Random number generator to be used with this distribution.

Instance members

Instance member Description

this.Initialize

Full Usage: this.Initialize

Parameters:
    alpha : float - Distribution parameter alpha (broadness exponent).
    gamma : float - Distribution parameter gamma (skew).
    aga : float - Parameter to specify gamma with higher accuracy around it's limit(s). For an explanation how aga is defined, see StableDistributionFeller.GetAgaFromAlphaGamma.
    scale : float - Scaling parameter (broadness of the distribution).
    location : float - Location of the distribution.

Initializes this instance of the distribution with the distribution parameters.

alpha : float

Distribution parameter alpha (broadness exponent).

gamma : float

Distribution parameter gamma (skew).

aga : float

Parameter to specify gamma with higher accuracy around it's limit(s). For an explanation how aga is defined, see StableDistributionFeller.GetAgaFromAlphaGamma.

scale : float

Scaling parameter (broadness of the distribution).

location : float

Location of the distribution.

this.Maximum

Full Usage: this.Maximum

Returns: float
Modifiers: abstract

Returns: float

this.Mean

Full Usage: this.Mean

Returns: float
Modifiers: abstract

Returns: float

this.Median

Full Usage: this.Median

Returns: float
Modifiers: abstract

Returns: float

this.Minimum

Full Usage: this.Minimum

Returns: float
Modifiers: abstract

Returns: float

this.Mode

Full Usage: this.Mode

Returns: float[]
Modifiers: abstract

Returns: float[]

this.NextDouble

Full Usage: this.NextDouble

Returns: float
Modifiers: abstract

Returns: float

this.PDF

Full Usage: this.PDF

Parameters:
    x : float

Returns: float
Modifiers: abstract

x : float
Returns: float

this.Variance

Full Usage: this.Variance

Returns: float
Modifiers: abstract

Returns: float

Static members

Static member Description

StableDistributionFeller.CCDF(x, alpha, gamma)

Full Usage: StableDistributionFeller.CCDF(x, alpha, gamma)

Parameters:
    x : float
    alpha : float
    gamma : float

Returns: float

x : float
alpha : float
gamma : float
Returns: float

StableDistributionFeller.CCDF(x, alpha, gamma, aga)

Full Usage: StableDistributionFeller.CCDF(x, alpha, gamma, aga)

Parameters:
    x : float
    alpha : float
    gamma : float
    aga : float

Returns: float

x : float
alpha : float
gamma : float
aga : float
Returns: float

StableDistributionFeller.CCDF(x, alpha, gamma, aga, tempStorage, precision)

Full Usage: StableDistributionFeller.CCDF(x, alpha, gamma, aga, tempStorage, precision)

Parameters:
    x : float
    alpha : float
    gamma : float
    aga : float
    tempStorage : byref<obj>
    precision : float

Returns: float

x : float
alpha : float
gamma : float
aga : float
tempStorage : byref<obj>
precision : float
Returns: float

StableDistributionFeller.CDF(x, alpha, gamma)

Full Usage: StableDistributionFeller.CDF(x, alpha, gamma)

Parameters:
    x : float
    alpha : float
    gamma : float

Returns: float

x : float
alpha : float
gamma : float
Returns: float

StableDistributionFeller.CDF(x, alpha, gamma, aga)

Full Usage: StableDistributionFeller.CDF(x, alpha, gamma, aga)

Parameters:
    x : float
    alpha : float
    gamma : float
    aga : float

Returns: float

x : float
alpha : float
gamma : float
aga : float
Returns: float

StableDistributionFeller.CDF(x, alpha, gamma, tempStorage, precision)

Full Usage: StableDistributionFeller.CDF(x, alpha, gamma, tempStorage, precision)

Parameters:
    x : float
    alpha : float
    gamma : float
    tempStorage : byref<obj>
    precision : float

Returns: float

x : float
alpha : float
gamma : float
tempStorage : byref<obj>
precision : float
Returns: float

StableDistributionFeller.CDF(x, alpha, gamma, aga, tempStorage, precision)

Full Usage: StableDistributionFeller.CDF(x, alpha, gamma, aga, tempStorage, precision)

Parameters:
    x : float
    alpha : float
    gamma : float
    aga : float
    tempStorage : byref<obj>
    precision : float

Returns: float

x : float
alpha : float
gamma : float
aga : float
tempStorage : byref<obj>
precision : float
Returns: float

StableDistributionFeller.CDFMethodForPositiveX(x, alpha, gamma, aga, tempStorage, precision, integFromXZero, integFromXInfinity, offs)

Full Usage: StableDistributionFeller.CDFMethodForPositiveX(x, alpha, gamma, aga, tempStorage, precision, integFromXZero, integFromXInfinity, offs)

Parameters:
    x : float
    alpha : float
    gamma : float
    aga : float
    tempStorage : byref<obj>
    precision : float
    integFromXZero : byref<float>
    integFromXInfinity : byref<float>
    offs : byref<float>

x : float
alpha : float
gamma : float
aga : float
tempStorage : byref<obj>
precision : float
integFromXZero : byref<float>
integFromXInfinity : byref<float>
offs : byref<float>

StableDistributionFeller.GetAgaFromAlphaGamma(alpha, gamma)

Full Usage: StableDistributionFeller.GetAgaFromAlphaGamma(alpha, gamma)

Parameters:
    alpha : float - Distribution parameter alpha (broadness exponent).
    gamma : float - Distribution parameter gamma (skew).

Returns: float The parameter aga.

Aga is defined as follows: For alpha <=1, it is (alpha-gamma)/alpha (for gamma >=0) or (alpha+gamma)/alpha (for gamma <0). For alpha >1 it is 2-alpha-gamma (for gamma >=0) or 2-alpha+gamma (for gamma <0). This function calculates aga from alpha and gamma.

alpha : float

Distribution parameter alpha (broadness exponent).

gamma : float

Distribution parameter gamma (skew).

Returns: float

The parameter aga.

StableDistributionFeller.GetAgt1GnParameterByGamma(x, alpha, gamma, aga, factorp, factorw, dev, logPrefactor)

Full Usage: StableDistributionFeller.GetAgt1GnParameterByGamma(x, alpha, gamma, aga, factorp, factorw, dev, logPrefactor)

Parameters:
    x : float
    alpha : float
    gamma : float
    aga : float
    factorp : byref<float>
    factorw : byref<float>
    dev : byref<float>
    logPrefactor : byref<float>

x : float
alpha : float
gamma : float
aga : float
factorp : byref<float>
factorw : byref<float>
dev : byref<float>
logPrefactor : byref<float>

StableDistributionFeller.GetAlt1GnParameterByGamma(x, alpha, gamma, aga, factorp, facdiv, dev, logPdfPrefactor)

Full Usage: StableDistributionFeller.GetAlt1GnParameterByGamma(x, alpha, gamma, aga, factorp, facdiv, dev, logPdfPrefactor)

Parameters:
    x : float
    alpha : float
    gamma : float
    aga : float
    factorp : byref<float>
    facdiv : byref<float>
    dev : byref<float>
    logPdfPrefactor : byref<float>

x : float
alpha : float
gamma : float
aga : float
factorp : byref<float>
facdiv : byref<float>
dev : byref<float>
logPdfPrefactor : byref<float>

StableDistributionFeller.GetAlt1GpParameterByGamma(x, alpha, gamma, aga, factorp, facdiv, dev, logPdfPrefactor)

Full Usage: StableDistributionFeller.GetAlt1GpParameterByGamma(x, alpha, gamma, aga, factorp, facdiv, dev, logPdfPrefactor)

Parameters:
    x : float
    alpha : float
    gamma : float
    aga : float
    factorp : byref<float>
    facdiv : byref<float>
    dev : byref<float>
    logPdfPrefactor : byref<float>

x : float
alpha : float
gamma : float
aga : float
factorp : byref<float>
facdiv : byref<float>
dev : byref<float>
logPdfPrefactor : byref<float>

StableDistributionFeller.GetGammaFromAlphaAga(alpha, aga, isGammaNegative)

Full Usage: StableDistributionFeller.GetGammaFromAlphaAga(alpha, aga, isGammaNegative)

Parameters:
    alpha : float - Distribution parameter alpha (broadness exponent).
    aga : float - Aga is defined as follows: For alpha <=1, it is (alpha-gamma)/alpha (for gamma >=0) or (alpha+gamma)/alpha (for gamma <0). For alpha >1 it is 2-alpha-gamma (for gamma >=0) or 2-alpha+gamma (for gamma <0).
    isGammaNegative : bool - Because gamma is not defined by aga alone, you have to specify if gamma should be positive or negative.

Returns: float Distribution parameter gamma.

Calculates gamma in dependence of alpha and aga.

alpha : float

Distribution parameter alpha (broadness exponent).

aga : float

Aga is defined as follows: For alpha <=1, it is (alpha-gamma)/alpha (for gamma >=0) or (alpha+gamma)/alpha (for gamma <0). For alpha >1 it is 2-alpha-gamma (for gamma >=0) or 2-alpha+gamma (for gamma <0).

isGammaNegative : bool

Because gamma is not defined by aga alone, you have to specify if gamma should be positive or negative.

Returns: float

Distribution parameter gamma.

StableDistributionFeller.GetInvertedAlphaGammaAga(x, alpha, gamma, aga, alphainv, xinv, gammainv, againv)

Full Usage: StableDistributionFeller.GetInvertedAlphaGammaAga(x, alpha, gamma, aga, alphainv, xinv, gammainv, againv)

Parameters:
    x : float
    alpha : float
    gamma : float
    aga : float
    alphainv : byref<float>
    xinv : byref<float>
    gammainv : byref<float>
    againv : byref<float>

x : float
alpha : float
gamma : float
aga : float
alphainv : byref<float>
xinv : byref<float>
gammainv : byref<float>
againv : byref<float>

StableDistributionFeller.IsValidAlpha(alpha)

Full Usage: StableDistributionFeller.IsValidAlpha(alpha)

Parameters:
    alpha : float

Returns: bool

alpha : float
Returns: bool

StableDistributionFeller.IsValidGamma(alpha, gamma)

Full Usage: StableDistributionFeller.IsValidGamma(alpha, gamma)

Parameters:
    alpha : float
    gamma : float

Returns: bool

alpha : float
gamma : float
Returns: bool

StableDistributionFeller.IsValidLocation(location)

Full Usage: StableDistributionFeller.IsValidLocation(location)

Parameters:
    location : float

Returns: bool

location : float
Returns: bool

StableDistributionFeller.IsValidScale(scale)

Full Usage: StableDistributionFeller.IsValidScale(scale)

Parameters:
    scale : float

Returns: bool

scale : float
Returns: bool

StableDistributionFeller.PDF(x, alpha, gamma)

Full Usage: StableDistributionFeller.PDF(x, alpha, gamma)

Parameters:
    x : float
    alpha : float
    gamma : float

Returns: float

x : float
alpha : float
gamma : float
Returns: float

StableDistributionFeller.PDF(x, alpha, gamma, aga)

Full Usage: StableDistributionFeller.PDF(x, alpha, gamma, aga)

Parameters:
    x : float
    alpha : float
    gamma : float
    aga : float

Returns: float

x : float
alpha : float
gamma : float
aga : float
Returns: float

StableDistributionFeller.PDF(x, alpha, gamma, tempStorage, precision)

Full Usage: StableDistributionFeller.PDF(x, alpha, gamma, tempStorage, precision)

Parameters:
    x : float - The argument.
    alpha : float - First parameter of the distribution (StableDistributionFeller).
    gamma : float - Second parameter of the distribution (StableDistributionFeller).
    tempStorage : byref<obj> -
    precision : float - Relative precision goal for the calculation.

Returns: float

Calculates the probability density using either series expansion for small or big arguments, or a integration in the intermediate range.

x : float

The argument.

alpha : float

First parameter of the distribution (StableDistributionFeller).

gamma : float

Second parameter of the distribution (StableDistributionFeller).

tempStorage : byref<obj>

precision : float

Relative precision goal for the calculation.

Returns: float

StableDistributionFeller.PDF(x, alpha, gamma, aga, scale, pos, tempStorage, precision)

Full Usage: StableDistributionFeller.PDF(x, alpha, gamma, aga, scale, pos, tempStorage, precision)

Parameters:
    x : float
    alpha : float
    gamma : float
    aga : float
    scale : float
    pos : float
    tempStorage : byref<obj>
    precision : float

Returns: float

x : float
alpha : float
gamma : float
aga : float
scale : float
pos : float
tempStorage : byref<obj>
precision : float
Returns: float

StableDistributionFeller.PDF(x, alpha, gamma, aga, tempStorage, precision)

Full Usage: StableDistributionFeller.PDF(x, alpha, gamma, aga, tempStorage, precision)

Parameters:
    x : float - The argument.
    alpha : float -
    gamma : float -
    aga : float - For alpha <=1: This is either (alpha-gamma)/alpha for gamma >=0, or (alpha+gamma)/alpha for gamma < 1.
    tempStorage : byref<obj> -
    precision : float -

Returns: float

Calculates the probability density using either series expansion for small or big arguments, or a integration in the intermediate range.

x : float

The argument.

alpha : float

gamma : float

aga : float

For alpha <=1: This is either (alpha-gamma)/alpha for gamma >=0, or (alpha+gamma)/alpha for gamma < 1.

tempStorage : byref<obj>

precision : float

Returns: float

StableDistributionFeller.PDFAlphaBetween01And02(x, alpha, gamma, aga, tempStorage, precision)

Full Usage: StableDistributionFeller.PDFAlphaBetween01And02(x, alpha, gamma, aga, tempStorage, precision)

Parameters:
    x : float -
    alpha : float -
    gamma : float -
    aga : float -
    tempStorage : byref<obj> -
    precision : float -

Returns: float

Calculation of the PDF if alpha is inbetween 0.1 and 0.2. For small x (1E-16), the accuracy at alpha=0.1 is only 1E-7.

x : float

alpha : float

gamma : float

aga : float

tempStorage : byref<obj>

precision : float

Returns: float

StableDistributionFeller.PDFAlphaBetween02And099(x, alpha, gamma, aga, tempStorage, precision)

Full Usage: StableDistributionFeller.PDFAlphaBetween02And099(x, alpha, gamma, aga, tempStorage, precision)

Parameters:
    x : float -
    alpha : float -
    gamma : float -
    aga : float -
    tempStorage : byref<obj> -
    precision : float -

Returns: float

Calculation of the PDF if alpha is inbetween 0.2 and 0.99. For small x (1E-8), the accuracy at alpha=0.2 is only 1E-7.

x : float

alpha : float

gamma : float

aga : float

tempStorage : byref<obj>

precision : float

Returns: float

StableDistributionFeller.PDFAlphaBetween099And101(x, alpha, gamma, aga, tempStorage, precision)

Full Usage: StableDistributionFeller.PDFAlphaBetween099And101(x, alpha, gamma, aga, tempStorage, precision)

Parameters:
    x : float -
    alpha : float -
    gamma : float -
    aga : float -
    tempStorage : byref<obj> -
    precision : float -

Returns: float

Calculation of the PDF if alpha is inbetween 0.99 and 1.01.

x : float

alpha : float

gamma : float

aga : float

tempStorage : byref<obj>

precision : float

Returns: float

StableDistributionFeller.PDFAlphaBetween0And01(x, alpha, gamma, aga, tempStorage, precision)

Full Usage: StableDistributionFeller.PDFAlphaBetween0And01(x, alpha, gamma, aga, tempStorage, precision)

Parameters:
    x : float -
    alpha : float -
    gamma : float -
    aga : float -
    tempStorage : byref<obj> -
    precision : float -

Returns: float

Calculation of the PDF if alpha is inbetween 0.0 and 0.1.

x : float

alpha : float

gamma : float

aga : float

tempStorage : byref<obj>

precision : float

Returns: float

StableDistributionFeller.PDFAlphaBetween101And199999(x, alpha, gamma, aga, tempStorage, precision)

Full Usage: StableDistributionFeller.PDFAlphaBetween101And199999(x, alpha, gamma, aga, tempStorage, precision)

Parameters:
    x : float -
    alpha : float -
    gamma : float -
    aga : float -
    tempStorage : byref<obj> -
    precision : float -

Returns: float

Calculation of the PDF if alpha is inbetween 1.01 and 1.99999.

x : float

alpha : float

gamma : float

aga : float

tempStorage : byref<obj>

precision : float

Returns: float

StableDistributionFeller.PDFAlphaBetween199999And2(x, alpha, gamma, aga, tempStorage, precision)

Full Usage: StableDistributionFeller.PDFAlphaBetween199999And2(x, alpha, gamma, aga, tempStorage, precision)

Parameters:
    x : float -
    alpha : float -
    gamma : float -
    aga : float -
    tempStorage : byref<obj> -
    precision : float -

Returns: float

Calculation of the PDF if alpha is inbetween 1.99999 and 2. For small x ( max 7), the asymptotic expansion is used. For big x, the maximum value resulting from direct integration and series expansion w.r.t. alpha is used.

x : float

alpha : float

gamma : float

aga : float

tempStorage : byref<obj>

precision : float

Returns: float

StableDistributionFeller.PDFAlphaEqualOne(x, alpha, gamma, aga)

Full Usage: StableDistributionFeller.PDFAlphaEqualOne(x, alpha, gamma, aga)

Parameters:
    x : float
    alpha : float
    gamma : float
    aga : float

Returns: float

x : float
alpha : float
gamma : float
aga : float
Returns: float

StableDistributionFeller.PDFIntegral(x, alpha, gamma, aga, temp, precision)

Full Usage: StableDistributionFeller.PDFIntegral(x, alpha, gamma, aga, temp, precision)

Parameters:
    x : float
    alpha : float
    gamma : float
    aga : float
    temp : byref<obj>
    precision : float

Returns: float

x : float
alpha : float
gamma : float
aga : float
temp : byref<obj>
precision : float
Returns: float

StableDistributionFeller.PDFIntegralA1(x, alpha, gamma, aga, temp, precision)

Full Usage: StableDistributionFeller.PDFIntegralA1(x, alpha, gamma, aga, temp, precision)

Parameters:
    x : float -
    alpha : float -
    gamma : float -
    aga : float -
    temp : byref<obj> -
    precision : float -

Returns: float

Special version of the PDF-Integral for 0.99>=alpha<1.

x : float

alpha : float

gamma : float

aga : float

temp : byref<obj>

precision : float

Returns: float

StableDistributionFeller.PDFIntegralAgt1Gn(x, alpha, gamma, aga, temp, precision)

Full Usage: StableDistributionFeller.PDFIntegralAgt1Gn(x, alpha, gamma, aga, temp, precision)

Parameters:
    x : float -
    alpha : float -
    gamma : float -
    aga : float -
    temp : byref<obj> -
    precision : float -

Returns: float

Special case for alpha>1 and gamma near to alpha-2 (i.e. gamma at the negative border).

x : float

alpha : float

gamma : float

aga : float

temp : byref<obj>

precision : float

Returns: float

StableDistributionFeller.PDFIntegralAgt1GnD(x, alpha, gamma, aga, temp, precision)

Full Usage: StableDistributionFeller.PDFIntegralAgt1GnD(x, alpha, gamma, aga, temp, precision)

Parameters:
    x : float -
    alpha : float -
    gamma : float -
    aga : float -
    temp : byref<obj> -
    precision : float -

Returns: float

Special case for alpha>1 and gamma near to alpha-2 (i.e. gamma at the negative border).

x : float

alpha : float

gamma : float

aga : float

temp : byref<obj>

precision : float

Returns: float

StableDistributionFeller.PDFIntegralAgt1GnI(x, alpha, gamma, aga, temp, precision)

Full Usage: StableDistributionFeller.PDFIntegralAgt1GnI(x, alpha, gamma, aga, temp, precision)

Parameters:
    x : float -
    alpha : float -
    gamma : float -
    aga : float -
    temp : byref<obj> -
    precision : float -

Returns: float

Special case for alpha>1 and gamma near to alpha-2 (i.e. gamma at the negative border).

x : float

alpha : float

gamma : float

aga : float

temp : byref<obj>

precision : float

Returns: float

StableDistributionFeller.PDFIntegralAlt1Gn(x, alpha, gamma, aga, temp, precision)

Full Usage: StableDistributionFeller.PDFIntegralAlt1Gn(x, alpha, gamma, aga, temp, precision)

Parameters:
    x : float -
    alpha : float -
    gamma : float -
    aga : float -
    temp : byref<obj> -
    precision : float -

Returns: float

Special case for alpha < 1 and gamma near to -alpha (i.e. gamma at the negative border). Here gamma was set to -alpha*(1-dev*2/Pi).

x : float

alpha : float

gamma : float

aga : float

temp : byref<obj>

precision : float

Returns: float

StableDistributionFeller.PDFIntegralAlt1GnD(x, alpha, gamma, aga, temp, precision)

Full Usage: StableDistributionFeller.PDFIntegralAlt1GnD(x, alpha, gamma, aga, temp, precision)

Parameters:
    x : float -
    alpha : float -
    gamma : float -
    aga : float -
    temp : byref<obj> -
    precision : float -

Returns: float

Special case for alpha < 1 and gamma near to -alpha (i.e. gamma at the negative border). Here gamma was set to -alpha*(1-dev*2/Pi). The core function is decreasing.

x : float

alpha : float

gamma : float

aga : float

temp : byref<obj>

precision : float

Returns: float

StableDistributionFeller.PDFIntegralAlt1GnI(x, alpha, gamma, aga, temp, precision)

Full Usage: StableDistributionFeller.PDFIntegralAlt1GnI(x, alpha, gamma, aga, temp, precision)

Parameters:
    x : float -
    alpha : float -
    gamma : float -
    aga : float -
    temp : byref<obj> -
    precision : float -

Returns: float

Special case for alpha < 1 and gamma near to -alpha (i.e. gamma at the negative border). Here gamma was set to -alpha*(1-dev*2/Pi).

x : float

alpha : float

gamma : float

aga : float

temp : byref<obj>

precision : float

Returns: float

StableDistributionFeller.PDFIntegralAlt1Gp(x, alpha, gamma, aga, temp, precision)

Full Usage: StableDistributionFeller.PDFIntegralAlt1Gp(x, alpha, gamma, aga, temp, precision)

Parameters:
    x : float -
    alpha : float -
    gamma : float -
    aga : float -
    temp : byref<obj> -
    precision : float -

Returns: float

Special case for alpha < 1 and gamma near to +alpha (i.e. gamma at the positive border). Here gamma was set to alpha*(1-dev*2/Pi).

x : float

alpha : float

gamma : float

aga : float

temp : byref<obj>

precision : float

Returns: float

StableDistributionFeller.PDFIntegralAlt1GpD(x, alpha, gamma, aga, temp, precision)

Full Usage: StableDistributionFeller.PDFIntegralAlt1GpD(x, alpha, gamma, aga, temp, precision)

Parameters:
    x : float -
    alpha : float -
    gamma : float -
    aga : float -
    temp : byref<obj> -
    precision : float -

Returns: float

Special case for alpha < 1 and gamma near to +alpha (i.e. gamma at the positive border). Here gamma was set to alpha*(1-dev*2/Pi).

x : float

alpha : float

gamma : float

aga : float

temp : byref<obj>

precision : float

Returns: float

StableDistributionFeller.PDFIntegralAlt1GpI(x, alpha, gamma, aga, temp, precision)

Full Usage: StableDistributionFeller.PDFIntegralAlt1GpI(x, alpha, gamma, aga, temp, precision)

Parameters:
    x : float -
    alpha : float -
    gamma : float -
    aga : float -
    temp : byref<obj> -
    precision : float -

Returns: float

Special case for alpha < 1 and gamma near to +alpha (i.e. gamma at the positive border). Here gamma was set to alpha*(1-dev*2/Pi).

x : float

alpha : float

gamma : float

aga : float

temp : byref<obj>

precision : float

Returns: float

StableDistributionFeller.PDFSeriesBigXFeller(z, alpha, gamma, aga)

Full Usage: StableDistributionFeller.PDFSeriesBigXFeller(z, alpha, gamma, aga)

Parameters:
    z : float -
    alpha : float -
    gamma : float -
    aga : float -

Returns: float

Series expansion for big x, Feller parametrization. x should be > 0.

z : float

alpha : float

gamma : float

aga : float

Returns: float

StableDistributionFeller.PDFSeriesSmallXFeller(z, alpha, gamma, aga)

Full Usage: StableDistributionFeller.PDFSeriesSmallXFeller(z, alpha, gamma, aga)

Parameters:
    z : float - Circular frequency.
    alpha : float - Beta parameter.
    gamma : float -
    aga : float -

Returns: float Imaginary part of the Fourier transformed derivative of the Kohlrausch function for high frequencies, or double.NaN if the series not converges.

Imaginary part of the Fourier transformed derivative of the Kohlrausch function for low frequencies.

This is the imaginary part of the Fourier transform (in Mathematica notation): Im[Integrate[D[Exp[-t^beta],t]*Exp[-I w t],{t, 0, Infinity}]]. The sign of the return value here is positive!.

z : float

Circular frequency.

alpha : float

Beta parameter.

gamma : float

aga : float

Returns: float

Imaginary part of the Fourier transformed derivative of the Kohlrausch function for high frequencies, or double.NaN if the series not converges.

StableDistributionFeller.PDFTaylorExpansionAroundAlphaOne(x, alpha, gamma, aga)

Full Usage: StableDistributionFeller.PDFTaylorExpansionAroundAlphaOne(x, alpha, gamma, aga)

Parameters:
    x : float
    alpha : float
    gamma : float
    aga : float

Returns: float

x : float
alpha : float
gamma : float
aga : float
Returns: float

StableDistributionFeller.PDFforPositiveX(x, alpha, gamma, aga, tempStorage, precision)

Full Usage: StableDistributionFeller.PDFforPositiveX(x, alpha, gamma, aga, tempStorage, precision)

Parameters:
    x : float - The argument.
    alpha : float -
    gamma : float - The gamma value.
    aga : float - For alpha <=1: This is either (alpha-gamma)/alpha for gamma >=0, or (alpha+gamma)/alpha for gamma < 1. For alpha >1, this is either (alpha-gamma) for gamma > (alpha-1), or (2-alpha+gamma) for gamma < (alpha-1).
    tempStorage : byref<obj> - Object that can be used to speed up subsequent calculations of the function. At first use, provide an object initialized with and then provide this object in subsequent calls of this function.
    precision : float - Relative precision goal.

Returns: float

Calculates the probability density using either series expansion for small or big arguments, or a integration in the intermediate range.

x : float

The argument.

alpha : float

gamma : float

The gamma value.

aga : float

For alpha <=1: This is either (alpha-gamma)/alpha for gamma >=0, or (alpha+gamma)/alpha for gamma < 1. For alpha >1, this is either (alpha-gamma) for gamma > (alpha-1), or (2-alpha+gamma) for gamma < (alpha-1).

tempStorage : byref<obj>

Object that can be used to speed up subsequent calculations of the function. At first use, provide an object initialized with and then provide this object in subsequent calls of this function.

precision : float

Relative precision goal.

Returns: float

StableDistributionFeller.PDFforXZero(alpha, gamma, aga)

Full Usage: StableDistributionFeller.PDFforXZero(alpha, gamma, aga)

Parameters:
    alpha : float - Characteristic exponent of the distibution.
    gamma : float - Skewness parameter gamma.
    aga : float - 'Alternative gamma' value to specify gamma with enhanced accuracy. For an explanation how it is defined, see StableDistributionFeller.GetAgaFromAlphaGamma.

Returns: float Probability density value at x=0 for the stable distribution in Feller's parametrization.

Calculates the probability density at x=0 for the stable distribution in Feller's parametrization.

alpha : float

Characteristic exponent of the distibution.

gamma : float

Skewness parameter gamma.

aga : float

'Alternative gamma' value to specify gamma with enhanced accuracy. For an explanation how it is defined, see StableDistributionFeller.GetAgaFromAlphaGamma.

Returns: float

Probability density value at x=0 for the stable distribution in Feller's parametrization.

StableDistributionFeller.Quantile(p, alpha, gamma)

Full Usage: StableDistributionFeller.Quantile(p, alpha, gamma)

Parameters:
    p : float
    alpha : float
    gamma : float

Returns: float

p : float
alpha : float
gamma : float
Returns: float

StableDistributionFeller.Quantile(p, alpha, gamma, aga)

Full Usage: StableDistributionFeller.Quantile(p, alpha, gamma, aga)

Parameters:
    p : float
    alpha : float
    gamma : float
    aga : float

Returns: float

p : float
alpha : float
gamma : float
aga : float
Returns: float

StableDistributionFeller.Quantile(p, alpha, gamma, aga, tempStorage, precision)

Full Usage: StableDistributionFeller.Quantile(p, alpha, gamma, aga, tempStorage, precision)

Parameters:
    p : float
    alpha : float
    gamma : float
    aga : float
    tempStorage : byref<obj>
    precision : float

Returns: float

p : float
alpha : float
gamma : float
aga : float
tempStorage : byref<obj>
precision : float
Returns: float

StableDistributionFeller.QuantileCCDF(p, alpha, gamma)

Full Usage: StableDistributionFeller.QuantileCCDF(p, alpha, gamma)

Parameters:
    p : float
    alpha : float
    gamma : float

Returns: float

p : float
alpha : float
gamma : float
Returns: float

StableDistributionFeller.QuantileCCDF(p, alpha, gamma, aga)

Full Usage: StableDistributionFeller.QuantileCCDF(p, alpha, gamma, aga)

Parameters:
    p : float
    alpha : float
    gamma : float
    aga : float

Returns: float

p : float
alpha : float
gamma : float
aga : float
Returns: float

StableDistributionFeller.QuantileCCDF(q, alpha, gamma, aga, tempStorage, precision)

Full Usage: StableDistributionFeller.QuantileCCDF(q, alpha, gamma, aga, tempStorage, precision)

Parameters:
    q : float
    alpha : float
    gamma : float
    aga : float
    tempStorage : byref<obj>
    precision : float

Returns: float

q : float
alpha : float
gamma : float
aga : float
tempStorage : byref<obj>
precision : float
Returns: float

StableDistributionFeller.XZCDF(x, alpha, gamma)

Full Usage: StableDistributionFeller.XZCDF(x, alpha, gamma)

Parameters:
    x : float
    alpha : float
    gamma : float

Returns: float

x : float
alpha : float
gamma : float
Returns: float

StableDistributionFeller.XZCDF(x, alpha, gamma, aga)

Full Usage: StableDistributionFeller.XZCDF(x, alpha, gamma, aga)

Parameters:
    x : float
    alpha : float
    gamma : float
    aga : float

Returns: float

x : float
alpha : float
gamma : float
aga : float
Returns: float

StableDistributionFeller.XZCDF(x, alpha, gamma, aga, tempStorage, precision)

Full Usage: StableDistributionFeller.XZCDF(x, alpha, gamma, aga, tempStorage, precision)

Parameters:
    x : float
    alpha : float
    gamma : float
    aga : float
    tempStorage : byref<obj>
    precision : float

Returns: float

x : float
alpha : float
gamma : float
aga : float
tempStorage : byref<obj>
precision : float
Returns: float