// 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 }
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()) } }
// 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)) }
// 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 }
func Gps2webmerc(lng, lat float64) (float64, float64) { lat_rad := lat * math.Pi / 180 return lng, math.Asinh(math.Tan(lat_rad)) * 180 / math.Pi }
// 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 }
// 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 }
// 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))) }
func (m *MathMod) math_Asinh(args ...runtime.Val) runtime.Val { runtime.ExpectAtLeastNArgs(1, args) return runtime.Number(math.Asinh(args[0].Float())) }
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() }