package cephes

import "gonum.org/v1/gonum/mathext/internal/cephes"

Package cephes implements functions originally in the Netlib code by Stephen Mosher.

Index ¶

• Variables
• func Igam(a, x float64) float64
• func IgamC(a, x float64) float64
• func IgamI(a, p float64) float64
• func Incbet(aa, bb, xx float64) float64
• func Incbi(aa, bb, yy0 float64) float64
• func Ndtri(y0 float64) float64
• func Zeta(x, q float64) float64

Variables ¶

var P0 = [5]float64{
	-5.99633501014107895267e1,
	9.80010754185999661536e1,
	-5.66762857469070293439e1,
	1.39312609387279679503e1,
	-1.23916583867381258016e0,
}

approximation for 0 <= |y - 0.5| <= 3/8

var P1 = [9]float64{
	4.05544892305962419923e0,
	3.15251094599893866154e1,
	5.71628192246421288162e1,
	4.40805073893200834700e1,
	1.46849561928858024014e1,
	2.18663306850790267539e0,
	-1.40256079171354495875e-1,
	-3.50424626827848203418e-2,
	-8.57456785154685413611e-4,
}

Approximation for interval z = math.Sqrt(-2 log y ) between 2 and 8 i.e., y between exp(-2) = .135 and exp(-32) = 1.27e-14.

var P2 = [9]float64{
	3.23774891776946035970e0,
	6.91522889068984211695e0,
	3.93881025292474443415e0,
	1.33303460815807542389e0,
	2.01485389549179081538e-1,
	1.23716634817820021358e-2,
	3.01581553508235416007e-4,
	2.65806974686737550832e-6,
	6.23974539184983293730e-9,
}

Approximation for interval z = math.Sqrt(-2 log y ) between 8 and 64 i.e., y between exp(-32) = 1.27e-14 and exp(-2048) = 3.67e-890.

var Q0 = [8]float64{

	1.95448858338141759834e0,
	4.67627912898881538453e0,
	8.63602421390890590575e1,
	-2.25462687854119370527e2,
	2.00260212380060660359e2,
	-8.20372256168333339912e1,
	1.59056225126211695515e1,
	-1.18331621121330003142e0,
}

var Q1 = [8]float64{

	1.57799883256466749731e1,
	4.53907635128879210584e1,
	4.13172038254672030440e1,
	1.50425385692907503408e1,
	2.50464946208309415979e0,
	-1.42182922854787788574e-1,
	-3.80806407691578277194e-2,
	-9.33259480895457427372e-4,
}

var Q2 = [8]float64{

	6.02427039364742014255e0,
	3.67983563856160859403e0,
	1.37702099489081330271e0,
	2.16236993594496635890e-1,
	1.34204006088543189037e-2,
	3.28014464682127739104e-4,
	2.89247864745380683936e-6,
	6.79019408009981274425e-9,
}

Functions ¶

func Igam ¶

func Igam(a, x float64) float64

Igam computes the incomplete Gamma integral.

Igam(a,x) = (1/ Γ(a)) \int_0^x e^{-t} t^{a-1} dt

The input argument a must be positive and x must be non-negative or Igam will panic.

func IgamC ¶

func IgamC(a, x float64) float64

IgamC computes the complemented incomplete Gamma integral.

IgamC(a,x) = 1 - Igam(a,x)
           = (1/ Γ(a)) \int_0^\infty e^{-t} t^{a-1} dt

The input argument a must be positive and x must be non-negative or IgamC will panic.

func IgamI ¶

func IgamI(a, p float64) float64

IgamI computes the inverse of the incomplete Gamma function. That is, it returns the x such that:

IgamC(a, x) = p

The input argument a must be positive and p must be between 0 and 1 inclusive or IgamI will panic. IgamI should return a positive number, but can return 0 even with non-zero y due to underflow.

func Incbet ¶

func Incbet(aa, bb, xx float64) float64

Incbet computes the regularized incomplete beta function.

func Incbi ¶

func Incbi(aa, bb, yy0 float64) float64

Incbi computes the inverse of the regularized incomplete beta integral.

func Ndtri ¶

func Ndtri(y0 float64) float64

Ndtri returns the argument, x, for which the area under the Gaussian probability density function (integrated from minus infinity to x) is equal to y.

func Zeta ¶

func Zeta(x, q float64) float64

Zeta computes the Riemann zeta function of two arguments.

Zeta(x,q) = \sum_{k=0}^{\infty} (k+q)^{-x}

Note that Zeta returns +Inf if x is 1 and will panic if x is less than 1, q is either zero or a negative integer, or q is negative and x is not an integer.

Note that:

zeta(x,1) = zetac(x) + 1

Source Files ¶

cephes.go doc.go igam.go igami.go incbeta.go incbi.go lanczos.go ndtri.go polevl.go unity.go zeta.go