// AsinH function returns the inverse hyperbolic sine. Therefore: ASINH( SINH( z ) ) = z
func AsinH(number float64) (float64, error) {

	if math.IsNaN(number) {
		return 0.0, errors.New("#VALUE!	-	Occurred because the supplied number argument is non-numeric")
	}

	return math.Asinh(number), nil
}
Ejemplo n.º 2
0
func TestMathAsinh(t *testing.T) {
	// This is just an interface to Go's function, so just a quick simple test
	ctx := runtime.NewCtx(nil, nil)
	mm := new(MathMod)
	mm.SetCtx(ctx)
	val := 0.12
	ret := mm.math_Asinh(runtime.Number(val))
	exp := math.Asinh(val)
	if ret.Float() != exp {
		t.Errorf("expected %f, got %f", exp, ret.Float())
	}
}
Ejemplo n.º 3
0
// Asinh returns the inverse hyperbolic sine of x.
func Asinh(x complex128) complex128 {
	// TODO check range
	if imag(x) == 0 {
		if math.Fabs(real(x)) > 1 {
			return cmplx(math.Pi/2, 0) // DOMAIN error
		}
		return cmplx(math.Asinh(real(x)), 0)
	}
	xx := x * x
	x1 := cmplx(1+real(xx), imag(xx)) // 1 + x*x
	return Log(x + Sqrt(x1))          // log(x + sqrt(1 + x*x))
}
Ejemplo n.º 4
0
Archivo: voice.go Proyecto: acshi/acshi
// Chebyshev biquad (2-poles) recursive coefficients
// Adapted from The Scientist and Engineer's Guide to Digital Signal Processing, Steven W. Smith
// poleIndex = [0, poleCount)
// percentRipple in the pass band can range from 0 for a butterworth to about 0.29. Something like 0.005 is a good trade-off.
func chebyshevBiquad(freq, percentRipple float64, poleIndex, poleCount int, highpass bool) (stageAs, stageBs []float64) {
	// We start off by designing a low-pass filter with unity cut-off frequency

	// Location of pole on unit circle, real and imaginary parts
	// The maximally flat butterworth filter positions the poles so that
	// they form a semi-circle on the left side of the s-plane (sigma < 0)
	// The half offset keeps the poles evenly spaced and off of the sigma=0 line
	// s-plane s = sigma + i * omega = poleR + i * poleI
	poleI, poleR := math.Sincos((float64(poleIndex) + 0.5) * math.Pi / float64(poleCount))
	poleR = -poleR

	// The chebyshev filter uses an ellipse to move all of the poles closer to the sigma=0 line
	// This causes pass-band ripple and sharpens the drop off
	// Warp coordinates from being on a circle to an ellipse
	if percentRipple != 0.0 {
		e := math.Sqrt(1/((1-percentRipple)*(1-percentRipple)) - 1)
		v := math.Asinh(1/e) / float64(poleCount)
		k := math.Acosh(1/e) / float64(poleCount)

		k = math.Cosh(k)

		poleR = poleR * math.Sinh(v) / k
		poleI = poleI * math.Cosh(v) / k
	}

	// bilinear s-domain to z-domain transformation
	t := 2 * math.Tan(0.5)
	w := 2 * math.Pi * freq
	m := poleR*poleR + poleI*poleI
	d := 4 - 4*poleR*t + m*t*t
	x0 := t * t / d
	x1 := 2 * t * t / d
	x2 := t * t / d
	y1 := (8 - 2*m*t*t) / d
	y2 := (-4 - 4*poleR*t - m*t*t) / d

	// We now have the coefficients of a low-pass filter with a cutoff frequency of 1 (2 times the nyquist)...
	// We must now apply our desired frequency and convert to a high-pass filter if necessary
	// as with the bilinear tranform, these are the results of a substitution in the transfer function...

	var k float64
	if highpass {
		k = -math.Cos(w/2+0.5) / math.Cos(w/2-0.5)
	} else {
		k = math.Sin(0.5-w/2) / math.Sin(0.5+w/2)
	}

	d = 1 + (y1*k - y2*k*k)
	a0 := (x0 - x1*k + x2*k*k) / d
	a1 := (-2*x0*k + x1 + (x1*k*k - 2*x2*k)) / d
	a2 := (x0*k*k - x1*k + x2) / d
	b1 := (2*k + y1 + y1*k*k - 2*y2*k) / d
	b2 := (-k*k - y1*k + y2) / d
	if highpass {
		a1, b1 = -a1, -b1
	}

	// we now have the desired coefficients of our low/high pass filter with the desired cutoff frequency
	// however, the gain has not been normalized, if that is desired...

	stageAs = []float64{a0, a1, a2}
	stageBs = []float64{0, b1, b2}
	return
}
Ejemplo n.º 5
0
func Gps2webmerc(lng, lat float64) (float64, float64) {
	lat_rad := lat * math.Pi / 180
	return lng, math.Asinh(math.Tan(lat_rad)) * 180 / math.Pi
}
Ejemplo n.º 6
0
// Inverse transverse mercator projection: Projection of an cylinder onto the surface of
// of an ellipsoid. Also known as reverse Gauss-Krüger projection. Input parameters:
//
//	pt *GeoPoint: Easting(Y) and Northing(X) of map point to be projected; in meters
//	latO, longO: Shifted origin of latitude and longitude in decimal degrees
//	fe, fn: False easting and northing respectively in meters
//	scale: Projection scaling; Dimensionless, typically 1 or little bellow
//
// This algorithm uses the algorithm described by Redfearn
// http://en.wikipedia.org/wiki/Transverse_Mercator:_Redfearn_series
//
// Taken from "OGP Publication 373-7-2 – Surveying and Positioning Guidance Note number 7, part 2 – November 2010",
// pp. 48 - 51
//
// More accurate, iterative but slower algorithmic implementation
func InverseTransverseMercator(pt *GeoPoint, latO, longO, scale, fe, fn float64) *PolarCoord {

	var gc PolarCoord

	el := pt.El

	latOrad := degtorad(latO)
	longOrad := degtorad(longO)

	f := 1 - el.b/el.a
	esq := math.Sqrt(2.0*f - f*f)

	n := f / (2.0 - f)
	B := (el.a / (1 + n)) * (1 + n*n/4.0 + n*n*n*n/64.0)

	var SO float64

	if latOrad != 0.0 {

		h1 := n/2.0 - (2.0/3.0)*n*n + (5.0/16.0)*n*n*n + (41.0/180.0)*n*n*n*n
		h2 := (13.0/48.0)*n*n - (3.0/5.0)*n*n*n + (557.0/1440.0)*n*n*n*n
		h3 := (61.0/240.0)*n*n*n - (103.0/140.0)*n*n*n*n
		h4 := (49561.0 / 161280.0) * n * n * n * n

		QO := math.Asinh(math.Tan(latOrad)) - (esq * math.Atanh(esq*math.Sin(latOrad)))
		bO := math.Atan(math.Sinh(QO))
		xiO0 := bO // math.Asin(math.Sin(bO))

		xiO1 := h1 * math.Sin(2.0*xiO0)
		xiO2 := h2 * math.Sin(4.0*xiO0)
		xiO3 := h3 * math.Sin(6.0*xiO0)
		xiO4 := h4 * math.Sin(8.0*xiO0)

		xiO := xiO0 + xiO1 + xiO2 + xiO3 + xiO4

		SO = B * xiO
	}

	h1i := n/2.0 - (2.0/3.0)*n*n + (37.0/96.0)*n*n*n - (1.0/360.0)*n*n*n*n
	h2i := (1.0/48.0)*n*n + (1.0/15.0)*n*n*n - (437.0/1440.0)*n*n*n*n
	h3i := (17.0/480.0)*n*n*n - (37.0/840.0)*n*n*n*n
	h4i := (4397.0 / 161280.0) * n * n * n * n

	etai := (pt.X - fe) / (B * scale)
	xii := ((pt.Y - fn) + scale*SO) / (B * scale)

	xi1i := h1i * math.Sin(2*xii) * math.Cosh(2*etai)
	xi2i := h2i * math.Sin(4*xii) * math.Cosh(4*etai)
	xi3i := h3i * math.Sin(6*xii) * math.Cosh(6*etai)
	xi4i := h4i * math.Sin(8*xii) * math.Cosh(8*etai)

	eta1i := h1i * math.Cos(2*xii) * math.Sinh(2*etai)
	eta2i := h2i * math.Cos(4*xii) * math.Sinh(4*etai)
	eta3i := h3i * math.Cos(6*xii) * math.Sinh(6*etai)
	eta4i := h4i * math.Cos(8*xii) * math.Sinh(8*etai)

	xi0i := xii - (xi1i + xi2i + xi3i + xi4i)
	eta0i := etai - (eta1i + eta2i + eta3i + eta4i)

	bi := math.Asin(math.Sin(xi0i) / math.Cosh(eta0i))

	Qi := math.Asinh(math.Tan(bi))
	Qiiold := Qi + (esq * math.Atanh(esq*math.Tanh(Qi)))
	Qii := Qi + (esq * math.Atanh(esq*math.Tanh(Qiiold)))

	for math.Abs(Qiiold-Qii) > 1e-12 {
		Qiiold = Qii
		Qii = Qi + (esq * math.Atanh(esq*math.Tanh(Qiiold)))
	}

	gc.Latitude = radtodeg(math.Atan(math.Sinh(Qii)))
	gc.Longitude = radtodeg(longOrad + math.Asin(math.Tanh(eta0i)/math.Cos(bi)))

	gc.El = el

	return &gc
}
Ejemplo n.º 7
0
// Direct transverse mercator projection: Projection of an ellipsoid onto the surface of
// of a cylinder. Also known as Gauss-Krüger projection. Input parameters:
//
//	gc *PolarCoord: Latitude and Longitude or point to be projected; in decimal degrees
//	latO, longO: Shifted origin of latitude and longitude in decimal degrees
//	fe, fn: False easting and northing respectively in meters
//	scale: Projection scaling; Dimensionless, typically 1 or little bellow
//
// This algorithm uses the algorithm described by Redfearn
// http://en.wikipedia.org/wiki/Transverse_Mercator:_Redfearn_series
//
// Taken from "OGP Publication 373-7-2 – Surveying and Positioning Guidance Note number 7, part 2 – November 2010",
// pp. 48 - 51
func DirectTransverseMercator(gc *PolarCoord, latO, longO, scale, fe, fn float64) *GeoPoint {

	var pt GeoPoint

	el := gc.El

	latOrad := degtorad(latO)
	longOrad := degtorad(longO)

	latrad := degtorad(gc.Latitude)
	longrad := degtorad(gc.Longitude)

	f := 1 - el.b/el.a
	esq := math.Sqrt(2.0*f - f*f)

	n := f / (2.0 - f)
	B := (el.a / (1 + n)) * (1 + n*n/4.0 + n*n*n*n/64.0)

	h1 := n/2.0 - (2.0/3.0)*(n*n) + (5.0/16.0)*(n*n*n) + (41.0/180.0)*(n*n*n*n)
	h2 := (13.0/48.0)*(n*n) - (3.0/5.0)*(n*n*n) + (557.0/1440.0)*(n*n*n*n)
	h3 := (61.0/240.0)*(n*n*n) - (103.0/140.0)*(n*n*n*n)
	h4 := (49561.0 / 161280.0) * (n * n * n * n)

	var SO float64

	if latOrad != 0.0 {
		QO := math.Asinh(math.Tan(latOrad)) - (esq * math.Atanh(esq*math.Sin(latOrad)))
		bO := math.Atan(math.Sinh(QO))
		xiO0 := bO // math.Asin(math.Sin(bO))

		xiO1 := h1 * math.Sin(2.0*xiO0)
		xiO2 := h2 * math.Sin(4.0*xiO0)
		xiO3 := h3 * math.Sin(6.0*xiO0)
		xiO4 := h4 * math.Sin(8.0*xiO0)

		xiO := xiO0 + xiO1 + xiO2 + xiO3 + xiO4

		SO = B * xiO
	}

	Q := math.Asinh(math.Tan(latrad)) - (esq * math.Atanh(esq*math.Sin(latrad)))
	b := math.Atan(math.Sinh(Q))

	eta0 := math.Atanh(math.Cos(b) * math.Sin(longrad-longOrad))
	xi0 := math.Asin(math.Sin(b) * math.Cosh(eta0))

	xi1 := h1 * math.Sin(2*xi0) * math.Cosh(2*eta0)
	xi2 := h2 * math.Sin(4*xi0) * math.Cosh(4*eta0)
	xi3 := h3 * math.Sin(6*xi0) * math.Cosh(6*eta0)
	xi4 := h4 * math.Sin(8*xi0) * math.Cosh(8*eta0)
	xi := xi0 + xi1 + xi2 + xi3 + xi4

	eta1 := h1 * math.Cos(2*xi0) * math.Sinh(2*eta0)
	eta2 := h2 * math.Cos(4*xi0) * math.Sinh(4*eta0)
	eta3 := h3 * math.Cos(6*xi0) * math.Sinh(6*eta0)
	eta4 := h4 * math.Cos(8*xi0) * math.Sinh(8*eta0)
	eta := eta0 + eta1 + eta2 + eta3 + eta4

	pt.X = fe + scale*B*eta
	pt.Y = fn + scale*(B*xi-SO)

	pt.El = el

	return &pt
}
Ejemplo n.º 8
0
// Asinh returns the inverse hyperbolic sine of x.
//
// Special cases are:
//	Asinh(±0) = ±0
//	Asinh(±Inf) = ±Inf
//	Asinh(NaN) = NaN
func Asinh(x float32) float32 {
	return float32(math.Asinh(float64(x)))
}
Ejemplo n.º 9
0
func (m *MathMod) math_Asinh(args ...runtime.Val) runtime.Val {
	runtime.ExpectAtLeastNArgs(1, args)
	return runtime.Number(math.Asinh(args[0].Float()))
}
Ejemplo n.º 10
0
func FunctionVal(f Function, x float64) float64 {
	//
	switch f {
	case Floor:
		i, _ := math.Modf(x)
		return i
	case Fract:
		_, f := math.Modf(x)
		return f
	case Chs:
		return -x
	case Rec:
		if x == 0 { // TODO
			return math.NaN()
		}
		return 1 / x
	case Sqr:
		return x * x
	case Sqrt:
		return math.Sqrt(x)
	case Exp:
		return math.Exp(x)
	case Exp10:
		return math.Exp(x * math.Ln10)
	case Exp2:
		return math.Exp(x * math.Ln2)
	case Log:
		return math.Log(x)
	case Lg:
		return math.Log10(x)
	case Ld:
		return math.Log2(x)
	case Sin:
		return math.Sin(x)
	case Cos:
		return math.Cos(x)
	case Tan:
		return math.Tan(x)
	case Cot:
		return 1 / math.Tan(x)
	case Arcsin:
		return math.Asin(x)
	case Arccos:
		return math.Acos(x)
	case Arctan:
		return math.Atan(x)
	case Arccot:
		return math.Atan(x)
	case Sinh:
		return math.Sinh(x)
	case Cosh:
		return (math.Exp(x) + math.Exp(-x)) / 2
	case Tanh:
		return math.Tanh(x)
	case Coth:
		return (math.Exp(x) + math.Exp(-x)) / (math.Exp(x) - math.Exp(-x))
	case Arsinh:
		return math.Asinh(x)
	case Arcosh:
		return math.Log(x + math.Sqrt(x*x-1))
	case Artanh:
		return math.Atanh(x)
	case Arcoth:
		return math.Log((x+1)/(x-1)) / 2
	case Gamma:
		return math.Gamma(x)
	}
	return math.NaN()
}