// https://stackoverflow.com/questions/5971830/need-code-for-inverse-error-function func erfinv(y float64) float64 { if y < -1.0 || y > 1.0 { panic("invalid input") } var ( a = [4]float64{0.886226899, -1.645349621, 0.914624893, -0.140543331} b = [4]float64{-2.118377725, 1.442710462, -0.329097515, 0.012229801} c = [4]float64{-1.970840454, -1.624906493, 3.429567803, 1.641345311} d = [2]float64{3.543889200, 1.637067800} ) const y0 = 0.7 var x, z float64 if math.Abs(y) == 1.0 { x = -y * math.Log(0.0) } else if y < -y0 { z = math.Sqrt(-math.Log((1.0 + y) / 2.0)) x = -(((c[3]*z+c[2])*z+c[1])*z + c[0]) / ((d[1]*z+d[0])*z + 1.0) } else { if y < y0 { z = y * y x = y * (((a[3]*z+a[2])*z+a[1])*z + a[0]) / ((((b[3]*z+b[3])*z+b[1])*z+b[0])*z + 1.0) } else { z = math.Sqrt(-math.Log((1.0 - y) / 2.0)) x = (((c[3]*z+c[2])*z+c[1])*z + c[0]) / ((d[1]*z+d[0])*z + 1.0) } x = x - (math.Erf(x)-y)/(2.0/math.SqrtPi*math.Exp(-x*x)) x = x - (math.Erf(x)-y)/(2.0/math.SqrtPi*math.Exp(-x*x)) } return x }
// Black-Scholes (European put and call options) // C Theoretical call premium (non-dividend paying stock) // c = sn(d1) - ke^(-rt)N(d2) // d1 = ln(s/k) + (r + s^2/2)t // d2 = d1- st^1/2 // v = stock value // k = Stock strike price // s = Spot price // t = time to expire in years // r = risk free rate // v = volitilaty (sigma) // e math.E 2.7183 // putcall = "c" for a call or "p" for a put func BS(s, k, t, r, v float64, putcall string) float64 { d1 := (math.Log(s/k) + ((r + (math.Pow(v, 2) / 2)) * t)) / (v * math.Sqrt(t)) d2 := d1 - (v * math.Sqrt(t)) if putcall == call { return math.Erf(d1)*s - (math.Erf(d2) * k * math.Pow(math.E, (-1*r*t))) } if putcall == put { return k*math.Pow(math.E, (-1*r*t)) - s + ((math.Erf(-1*d2) * k * math.Pow(math.E, (-1*r*t))) - (math.Erf(-1*d1) * s)) } panic(NOOR) }
func Test_2dinteg02(tst *testing.T) { //verbose() chk.PrintTitle("2dinteg02. bidimensional integral") // Γ(1/4, 1) gamma_1div4_1 := 0.2462555291934987088744974330686081384629028737277219 x := utl.LinSpace(0, 1, 11) y := utl.LinSpace(0, 1, 11) m, n := len(x), len(y) f := la.MatAlloc(m, n) for i := 0; i < m; i++ { for j := 0; j < n; j++ { f[i][j] = 8.0 * math.Exp(-math.Pow(x[i], 2)-math.Pow(y[j], 4)) } } dx, dy := x[1]-x[0], y[1]-y[0] Vt := Trapz2D(dx, dy, f) Vs := Simps2D(dx, dy, f) Vc := math.Sqrt(math.Pi) * math.Erf(1) * (math.Gamma(1.0/4.0) - gamma_1div4_1) io.Pforan("Vt = %v\n", Vt) io.Pforan("Vs = %v\n", Vs) io.Pfgreen("Vc = %v\n", Vc) chk.Scalar(tst, "Vt", 0.0114830435645548, Vt, Vc) chk.Scalar(tst, "Vs", 1e-4, Vs, Vc) }
func main() { for true { r := bufio.NewReader(os.Stdin) s, err := r.ReadString('\n') if err == os.EOF { break } s = strings.TrimRight(s, "\n") a := strings.Split(s, " ") f := a[0] x, err := strconv.Atof64(a[1]) switch f { case "erf": fmt.Println(math.Erf(x)) case "expm1": fmt.Println(math.Expm1(x)) case "phi": fmt.Println(phi.Phi(x)) case "NormalCDFInverse": fmt.Println(normal_cdf_inverse.NormalCDFInverse(x)) case "Gamma": fmt.Println(math.Gamma(x)) case "LogGamma": r, _ := math.Lgamma(x) fmt.Println(r) case "LogFactorial": fmt.Println(log_factorial.LogFactorial(int(x))) default: fmt.Println("Unknown function: " + f) return } } }
func avalancheTest1(t *testing.T, k Key) { const REP = 100000 r := rand.New(rand.NewSource(1234)) n := k.bits() // grid[i][j] is a count of whether flipping // input bit i affects output bit j. grid := make([][hashSize]int, n) for z := 0; z < REP; z++ { // pick a random key, hash it k.random(r) h := k.hash() // flip each bit, hash & compare the results for i := 0; i < n; i++ { k.flipBit(i) d := h ^ k.hash() k.flipBit(i) // record the effects of that bit flip g := &grid[i] for j := 0; j < hashSize; j++ { g[j] += int(d & 1) d >>= 1 } } } // Each entry in the grid should be about REP/2. // More precisely, we did N = k.bits() * hashSize experiments where // each is the sum of REP coin flips. We want to find bounds on the // sum of coin flips such that a truly random experiment would have // all sums inside those bounds with 99% probability. N := n * hashSize var c float64 // find c such that Prob(mean-c*stddev < x < mean+c*stddev)^N > .99 for c = 0.0; math.Pow(math.Erf(c/math.Sqrt(2)), float64(N)) < .99; c += .1 { } c *= 2.0 // allowed slack - we don't need to be perfectly random mean := .5 * REP stddev := .5 * math.Sqrt(REP) low := int(mean - c*stddev) high := int(mean + c*stddev) for i := 0; i < n; i++ { for j := 0; j < hashSize; j++ { x := grid[i][j] if x < low || x > high { t.Errorf("bad bias for %s bit %d -> bit %d: %d/%d\n", k.name(), i, j, x, REP) } } } }
func pValueFromNormalDifferences(correct []float64, estimate []float64) ([]float64, error) { if len(correct) != len(estimate) { return nil, fmt.Errorf("p-value calculation requires two lists of equal size") } deviations := []float64{} for i := range correct { if math.IsInf(correct[i], 0) || math.IsNaN(correct[i]) { continue } if math.IsInf(estimate[i], 0) || math.IsNaN(estimate[i]) { continue } deviations = append(deviations, estimate[i]-correct[i]) } meandev := 0.0 for _, dev := range deviations { meandev += dev } meandev /= float64(len(deviations)) stddev := 0.0 for _, dev := range deviations { stddev += (meandev - dev) * (meandev - dev) } stddev /= float64(len(deviations)) - 1 stddev = math.Sqrt(stddev) // Now we have a good estimate for the population standard deviation. pvalues := make([]float64, len(estimate)) for i := range pvalues { if math.IsInf(correct[i], 0) || math.IsNaN(correct[i]) { pvalues[i] = math.NaN() continue } if math.IsInf(estimate[i], 0) || math.IsNaN(estimate[i]) { pvalues[i] = math.NaN() continue } difference := estimate[i] - correct[i] tvalue := (difference - meandev) / stddev pvalue := 1 - math.Erf(math.Abs(tvalue)/math.Sqrt2) pvalues[i] = pvalue } return pvalues, nil }
//calculates the attempt frequency of a particle func attemptf2(p *particle) float64 { volume := cube(p.r) * 4 / 3. * math.Pi hk := 2. * Ku1 / (p.msat * mu0) gprime := Alpha * gamma0 * mu0 / (1. + (Alpha * Alpha)) delta := Ku1 * volume / (kb * Temp) bx, by, bz := B_ext(T) bextvector := vector{bx / mu0, by / mu0, bz / mu0} hoverhk := math.Abs(bextvector.dot(p.u_anis)) / hk if math.Signbit(bextvector.dot(p.m)) { hoverhk *= -1. } postpostfactor := 1. / (math.Erf(math.Sqrt(delta) * (1 - hoverhk))) return gprime * hk / math.Sqrt(delta*math.Pi) * postpostfactor * math.Exp(-delta) }
// CDF calculates the cumulative distribution function for any standard // distribution. func CDF(x, mu, sigma float64) float64 { return 0.5 * (1 + math.Erf((x-mu)/(sigma*math.Sqrt2))) }
//Unit Normal CDF func (u *UnitNormal) CDF(x float64) float64 { return 0.5 * (1.0 + math.Erf(x/(math.Sqrt2))) }
func (n *Normal) CalcCDF(x float64) (float64, error) { return 0.5 * (1.0 + math.Erf((x-n.Mean)/(n.StdDev*math.Sqrt2))), nil }
// Cumulative Distribution Function for the Normal distribution func Normal_CDF(μ, σ float64) func(x float64) float64 { return func(x float64) float64 { return ((1.0 / 2.0) * (1 + math.Erf((x-μ)/(σ*math.Sqrt2)))) } }
// CDF computes the value of the cumulative density function at x. func (n Normal) CDF(x float64) float64 { return 0.5 * (1 + math.Erf((x-n.Mu)/(n.Sigma*math.Sqrt2))) }
func GaussCumulativeTo(x float64) float64 { return math.Erf(x/math.Sqrt2)/2 + 0.5 }
/* Cumulative Distribution Function for the Normal distribution */ func Normal_CDF(mu, sigma float64) func(x float64) float64 { return func(x float64) float64 { return (0.5 * (1 - math.Erf((mu-x)/(sigma*math.Sqrt2)))) } }
// Cdf computes the cumulative probability function @ x func (o DistLogNormal) Cdf(x float64) float64 { if x < TOLMINLOG { return 0 } return (1.0 + math.Erf((math.Log(x)-o.M)/(o.S*math.Sqrt2))) / 2.0 }
// ExpectedObservationsLessThan returns the number of observations that should // have a value less than or equal to the given value, given a normal // distribution of observations described by Count, Mean, and Stdev. func ExpectedObservationsLessThan(bucket int64) int64 { // https://code.google.com/p/gostat/source/browse/stat/normal.go cdf := ((1.0 / 2.0) * (1 + math.Erf((float64(bucket)-float64(Mean))/(float64(Stdev)*math.Sqrt2)))) return int64(cdf * float64(Count)) }
// Cdf computes the cumulative probability function @ x func (o DistLogNormal) Cdf(x float64) float64 { if x < ZERO { return 0 } return (1.0 + math.Erf((math.Log(x)-o.N)/(o.Z*math.Sqrt2))) / 2.0 }
// Cdf computes the cumulative probability function @ x func (o DistNormal) Cdf(x float64) float64 { return (1.0 + math.Erf((x-o.Mu)/(o.Sig*math.Sqrt2))) / 2.0 }
// StdPhi implements Φ(x), the standard cumulative distribution function func StdPhi(x float64) float64 { return (1.0 + math.Erf(x/math.Sqrt2)) / 2.0 }
// Survival returns the survival function (complementary CDF) at x. func (l LogNormal) Survival(x float64) float64 { return 0.5 * (1 - math.Erf((math.Log(x)-l.Mu)/(math.Sqrt2*l.Sigma))) }
//Normal Distribution CDF func (n *Normal) CDF(x float64) float64 { return 0.5 * (1.0 + math.Erf((x-n.mean)/(math.Sqrt2*n.sigma))) }
// CDF computes the value of the cumulative density function at x. func (l LogNormal) CDF(x float64) float64 { return 0.5 + 0.5*math.Erf((math.Log(x)-l.Mu)/(math.Sqrt2*l.Sigma)) }
// Survival returns the survival function (complementary CDF) at x. func (n Normal) Survival(x float64) float64 { return 0.5 * (1 - math.Erf((x-n.Mu)/(n.Sigma*math.Sqrt2))) }
func cdf(mean, stddev, x float64) float64 { return 0.5 + 0.5*math.Erf((x-mean)/(stddev*math.Sqrt2)) }
// CDF returns the cumulative distribution function if the given // normal function, for the given value. func cdf(μ, σ, v float64) float64 { return ((1.0 / 2.0) * (1 + math.Erf((v-μ)/(σ*math.Sqrt2)))) }
// float32 version of math.Erff func Erf(x float32) float32 { return float32(math.Erf(float64(x))) }
// https://code.google.com/p/gostat/source/browse/stat/normal.go func observationsLessThan(mean, stdev int64, x float64, total int) int { cdf := ((1.0 / 2.0) * (1 + math.Erf((x-float64(mean))/(float64(stdev)*math.Sqrt2)))) return int(cdf * float64(total)) }