def fEinv(self, x):
'''The inverse of the incomplete integral of the second kind.
@arg x: Argument (C{float}).
@return: φ = 1 / E(B{C{x}}, k), such that E(φ, k) = B{C{x}}
(C{float}).
@raise EllipticError: No convergence.
'''
E2 = self.cE * 2.0
n = floor(x / E2 + 0.5)
x -= E2 * n # x now in [-ec, ec)
# linear approximation
phi = PI * x / E2 # phi in [-pi/2, pi/2)
Phi = Fsum(phi)
# first order correction
phi = Phi.fsum_(-self.eps * sin(2 * phi) * 0.5)
# For kp2 close to zero use asin(x/.cE) or J. P. Boyd,
# Applied Math. and Computation 218, 7005-7013 (2012)
# <https://DOI.org/10.1016/j.amc.2011.12.021>
for _ in range(self._trips_): # GEOGRAPHICLIB_PANIC
sn, cn, dn = self._sncndn3(phi)
phi, e = Phi.fsum2_((x - self.fE(sn, cn, dn)) / dn)
if abs(e) < _TolJAC:
return n * PI + phi
raise _convergenceError(self.fEinv, x)
def _D2atanhee(self, x, y):
'''(INTERNAL) Function M{D2atanhee(x, y)}, defined as
M{(Datanhee(1, y) - Datanhee(1, x)) / (y - x)}.
'''
e2 = self.datum.ellipsoid.e2
if (abs(x) + abs(y)) * e2 < _0_5:
e = z = _1_0
k = 1
C = Fsum()
S = Fsum()
T = Fsum() # Taylor expansion
for _ in range(_TERMS):
T *= y
p = T.fsum_(z)
z *= x # PYCHOK ;
T *= y
t = T.fsum_(z)
z *= x # PYCHOK ;
e *= e2
k += 2
s, d = S.fsum2_(e * C.fsum_(p, t) / k)
if not d:
break
elif (_1_0 - x):
s = (self._Datanhee(_1_0, y) - self._Datanhee(x, y)) / (_1_0 - x)
else:
raise AlbersError(x=x, y=y, txt=_AlbersBase._D2atanhee.__name__)
return s
def _zetaInv(self, taup, lam):
'''Invert C{zeta} using Newton's method.
@return: 2-Tuple C{(u, v)}.
@see: C{void TMExact::zetainv(real taup, real lam,
real &u, real &v)}.
@raise EllipticError: No convergence.
'''
psi = asinh(taup)
sca = 1.0 / hypot1(taup)
u, v, trip = self._zetaInv0(psi, lam)
if not trip:
stol2 = _TOL_10 / max(psi, 1.0)**2
U, V = Fsum(u), Fsum(v)
# min iterations = 2, max = 6, mean = 4.0
for _ in range(self._trips_): # GEOGRAPHICLIB_PANIC
snu, cnu, dnu = self._Eu.sncndn(u)
snv, cnv, dnv = self._Ev.sncndn(v)
T, L, _ = self._zeta3( snu, cnu, dnu, snv, cnv, dnv)
dw, dv = self._zetaDwd(snu, cnu, dnu, snv, cnv, dnv)
T = (taup - T) * sca
L -= lam
u, du = U.fsum2_(T * dw, L * dv)
v, dv = V.fsum2_(T * dv, -L * dw)
if trip:
break
trip = (du**2 + dv**2) < stol2
else:
raise EllipticError('no %s convergence' % ('zetaInv',))
return u, v
def _sigmaInv(self, xi, eta):
'''Invert C{sigma} using Newton's method.
@return: 2-Tuple C{(u, v)}.
@see: C{void TMExact::sigmainv(real xi, real eta,
real &u, real &v)}.
@raise EllipticError: No convergence.
'''
u, v, trip = self._sigmaInv0(xi, eta)
if not trip:
U, V = Fsum(u), Fsum(v)
# min iterations = 2, max = 7, mean = 3.9
for _ in range(self._trips_): # GEOGRAPHICLIB_PANIC
snu, cnu, dnu = self._Eu.sncndn(u)
snv, cnv, dnv = self._Ev.sncndn(v)
X, E, _ = self._sigma3(v, snu, cnu, dnu, snv, cnv, dnv)
dw, dv = self._sigmaDwd( snu, cnu, dnu, snv, cnv, dnv)
X = xi - X
E -= eta
u, du = U.fsum2_(X * dw, E * dv)
v, dv = V.fsum2_(X * dv, -E * dw)
if trip:
break
trip = (du**2 + dv**2) < _TOL_10
else:
raise EllipticError('no %s convergence' % ('sigmaInv',))
return u, v
def _zetaInv(self, taup, lam):
'''(INTERNAL) Invert C{zeta} using Newton's method.
@return: 2-Tuple C{(u, v)}.
@see: C{void TMExact::zetainv(real taup, real lam,
real &u, real &v)}.
@raise EllipticError: No convergence.
'''
psi = asinh(taup)
sca = 1.0 / hypot1(taup)
u, v, trip = self._zetaInv0(psi, lam)
if trip:
self._iteration = 0
else:
stol2 = _TOL_10 / max(psi**2, 1.0)
U, V = Fsum(u), Fsum(v)
# min iterations = 2, max = 6, mean = 4.0
for self._iteration in range(1, _TRIPS): # GEOGRAPHICLIB_PANIC
sncndn6 = self._sncndn6(u, v)
T, L, _ = self._zeta3( *sncndn6)
dw, dv = self._zetaDwd(*sncndn6)
T = (taup - T) * sca
L -= lam
u, du = U.fsum2_(T * dw, L * dv)
v, dv = V.fsum2_(T * dv, -L * dw)
if trip:
break
trip = hypot2(du, dv) < stol2
else:
t = unstr(self._zetaInv.__name__, taup, lam)
raise EllipticError(_no_convergence_, txt=t)
return u, v
def _sigmaInv(self, xi, eta):
'''(INTERNAL) Invert C{sigma} using Newton's method.
@return: 2-Tuple C{(u, v)}.
@see: C{void TMExact::sigmainv(real xi, real eta,
real &u, real &v)}.
@raise EllipticError: No convergence.
'''
u, v, trip = self._sigmaInv0(xi, eta)
if trip:
self._iteration = 0
else:
U, V = Fsum(u), Fsum(v)
# min iterations = 2, max = 7, mean = 3.9
for self._iteration in range(1, _TRIPS): # GEOGRAPHICLIB_PANIC
sncndn6 = self._sncndn6(u, v)
X, E, _ = self._sigma3(v, *sncndn6)
dw, dv = self._sigmaDwd( *sncndn6)
X = xi - X
E -= eta
u, du = U.fsum2_(X * dw, E * dv)
v, dv = V.fsum2_(X * dv, -E * dw)
if trip:
break
trip = hypot2(du, dv) < _TOL_10
else:
t = unstr(self._sigmaInv.__name__, xi, eta)
raise EllipticError(_no_convergence_, txt=t)
return u, v
def _sigmaInv(self, xi, eta):
'''(INTERNAL) Invert C{sigma} using Newton's method.
@return: 2-Tuple C{(u, v)}.
@see: C{void TMExact::sigmainv(real xi, real eta,
real &u, real &v)}.
@raise EllipticError: No convergence.
'''
u, v, trip = self._sigmaInv0(xi, eta)
if not trip:
U, V = Fsum(u), Fsum(v)
# min iterations = 2, max = 7, mean = 3.9
for _ in range(self._trips_): # GEOGRAPHICLIB_PANIC
sncndn6 = self._sncndn6(u, v)
X, E, _ = self._sigma3(v, *sncndn6)
dw, dv = self._sigmaDwd( *sncndn6)
X = xi - X
E -= eta
u, du = U.fsum2_(X * dw, E * dv)
v, dv = V.fsum2_(X * dv, -E * dw)
if trip:
break
trip = hypot2(du, dv) < _TOL_10
else:
raise EllipticError('no %s%r convergence' %
('_sigmaInv', (xi, eta)))
return u, v
def reverse(self, x, y, name=NN, LatLon=None, **LatLon_kwds):
'''Convert an azimuthal gnomonic location to (ellipsoidal) geodetic lat- and longitude.
@arg x: Easting of the location (C{meter}).
@arg y: Northing of the location (C{meter}).
@kwarg name: Optional name for the location (C{str}).
@kwarg LatLon: Class to use (C{LatLon}) or C{None}.
@kwarg LatLon_kwds: Optional, additional B{C{LatLon}} keyword
arguments, ignored if C{B{LatLon}=None}.
@return: The geodetic (C{LatLon}) or if B{C{LatLon}} is C{None} an
L{Azimuthal7Tuple}C{(x, y, lat, lon, azimuth, scale, datum)}.
@raise AzimuthalError: No convergence.
@note: The C{lat} will be in the range C{[-90..90] degrees} and C{lon}
in the range C{[-180..180] degrees}. The C{azimuth} is clockwise
from true North. The scale is C{1 / reciprocal**2} in C{radial}
direction and C{1 / reciprocal} in the direction perpendicular
to this.
'''
x = Scalar(x=x)
y = Scalar(y=y)
z = atan2d(x, y) # (x, y) for azimuth from true North
q = hypot(x, y)
d = e = self.equatoradius
s = e * atan(q / e)
if q > e:
def _d(r, q):
return (r.M12 - q * r.m12) * r.m12 # negated
q = 1 / q
else: # little == True
def _d(r, q): # PYCHOK _d
return (q * r.M12 - r.m12) * r.M12 # negated
e *= _Karney_eps
S = Fsum(s)
g = self.geodesic.Line(self.lat0, self.lon0, z, self._mask)
for self._iteration in range(1, _TRIPS):
r = g.Position(s, self._mask)
if abs(d) < e:
break
s, d = S.fsum2_(_d(r, q))
else:
raise AzimuthalError(x=x, y=y, txt=_no_(Fmt.convergence(e)))
t = self._7Tuple(x, y, r, r.M12) if LatLon is None else \
self._toLatLon(r.lat2, r.lon2, LatLon, LatLon_kwds)
t._iteration = self._iteration
return self._xnamed(t, name=name)
def _atanhx1(self, x):
'''(INTERNAL) Function M{atanh(sqrt(x)) / sqrt(x) - 1}.
'''
s = abs(x)
if s < _0_5: # for typical ...
# x < E.e^2 = 2 * E.f use ...
# x / 3 + x^2 / 5 + x^3 / 7 + ...
y, k = x, 3
S = Fsum(y / k)
for _ in range(_TERMS):
y *= x # x**n
k += 2 # 2*n + 1
s, d = S.fsum2_(y / k)
if not d:
break
else:
s = sqrt(s)
s = (atanh(s) if x > 0 else atan(s)) / s - _1_0
return s
def _tanf(self, txi): # called from .Ellipsoid.auxAuthalic
'''(INTERNAL) Function M{tan-phi from tan-xi}.
'''
tol = _tol(_TOL, txi)
e2 = self.datum.ellipsoid.e2
qx = self._qx
ta = txi
Ta = Fsum(ta)
for self._iteration in range(1, _NUMIT): # max 2, mean 1.99
# dtxi/dta = (scxi / sca)^3 * 2 * (1 - e^2) / (qZ * (1 - e^2 * sa^2)^2)
ta2 = ta**2
sca2 = 1 + ta2
txia = self._txif(ta)
s3qx = sqrt3(sca2 / (1 + txia**2)) * qx
ta, d = Ta.fsum2_((txi - txia) * s3qx * (1 - e2 * ta2 / sca2)**2)
if abs(d) < tol:
return ta
raise AlbersError(iteration=_NUMIT, txt=_no_convergence_fmt_ % (tol, ))
def toLatLon(self, LatLon=None, eps=EPS, unfalse=True, **LatLon_kwds):
'''Convert this UTM coordinate to an (ellipsoidal) geodetic point.
@kwarg LatLon: Optional, ellipsoidal class to return the
geodetic point (C{LatLon}) or C{None}.
@kwarg eps: Optional convergence limit, L{EPS} or above
(C{float}).
@kwarg unfalse: Unfalse B{C{easting}} and B{C{northing}}
if falsed (C{bool}).
@kwarg LatLon_kwds: Optional, additional B{C{LatLon}} keyword
arguments, ignored if B{C{LatLon=None}}.
@return: This UTM coordinate (B{C{LatLon}}) or if B{C{LatLon}}
is C{None}, a L{LatLonDatum5Tuple}C{(lat, lon, datum,
convergence, scale)}.
@raise TypeError: If B{C{LatLon}} is not ellipsoidal.
@raise UTMError: Invalid meridional radius or H-value.
@example:
>>> u = Utm(31, 'N', 448251.795, 5411932.678)
>>> from pygeodesy import ellipsoidalVincenty as eV
>>> ll = u.toLatLon(eV.LatLon) # 48°51′29.52″N, 002°17′40.20″E
'''
if eps < EPS:
eps = EPS # less doesn't converge
if self._latlon and self._latlon_args == (eps, unfalse):
return self._latlon5(LatLon)
E = self.datum.ellipsoid # XXX vs LatLon.datum.ellipsoid
x, y = self.to2en(falsed=not unfalse)
# from Karney 2011 Eq 15-22, 36
A0 = self.scale0 * E.A
if A0 < EPS:
raise self._Error(meridional=A0)
x /= A0 # η eta
y /= A0 # ξ ksi
K = _Kseries(E.BetaKs, x, y) # Krüger series
y = -K.ys(-y) # ξ'
x = -K.xs(-x) # η'
shx = sinh(x)
sy, cy = sincos2(y)
H = hypot(shx, cy)
if H < EPS:
raise self._Error(H=H)
T = t0 = sy / H # τʹ
S = Fsum(T)
q = 1.0 / E.e12
P = 7 # -/+ toggle trips
d = 1.0 + eps
while abs(d) > eps and P > 0:
p = -d # previous d, toggled
h = hypot1(T)
s = sinh(E.e * atanh(E.e * T / h))
t = T * hypot1(s) - s * h
d = (t0 - t) / hypot1(t) * ((q + T**2) / h)
T, d = S.fsum2_(d) # τi, (τi - τi-1)
if d == p: # catch -/+ toggling of d
P -= 1
# else:
# P = 0
a = atan(T) # lat
b = atan2(shx, cy)
if unfalse and self.falsed:
b += radians(_cmlon(self.zone))
ll = _LLEB(degrees90(a), degrees180(b), datum=self.datum, name=self.name)
# convergence: Karney 2011 Eq 26, 27
p = -K.ps(-1)
q = K.qs(0)
ll._convergence = degrees(atan(tan(y) * tanh(x)) + atan2(q, p))
# scale: Karney 2011 Eq 28
ll._scale = E.e2s(sin(a)) * hypot1(T) * H * (A0 / E.a / hypot(p, q))
self._latlon_to(ll, eps, unfalse)
return self._latlon5(LatLon, **LatLon_kwds)
def __init__(self, sa1, ca1, sa2, ca2, k, datum, name):
'''(INTERNAL) New C{AlbersEqualArea...} instance.
'''
if datum not in (None, self._datum):
self._datum = _ellipsoidal_datum(datum, name=name)
if name:
self.name = name
E = self.datum.ellipsoid
b_a = E.b_a # fm = 1 - E.f
e2 = E.e2
e12 = E.e12 # e2m = 1 - E.e2
self._qZ = qZ = _1_0 + e12 * self._atanhee(1)
self._qZa2 = qZ * E.a2
self._qx = qZ / (_2_0 * e12)
c = min(ca1, ca2)
if c < 0:
raise AlbersError(clat1=ca1, clat2=ca2)
polar = c < _EPS__2 # == 0
# determine hemisphere of tangent latitude
if sa1 < 0: # and sa2 < 0:
self._sign = -1
# internally, tangent latitude positive
sa1, sa2 = -sa1, neg(sa2)
if sa1 > sa2: # make phi1 < phi2
sa1, sa2 = sa2, sa1
ca1, ca2 = ca2, ca1
if sa1 < 0: # or sa2 < 0:
raise AlbersError(slat1=sa1, slat2=sa2)
# avoid singularities at poles
ca1, ca2 = max(_EPS__2, ca1), max(_EPS__2, ca2)
ta1, ta2 = sa1 / ca1, sa2 / ca2
par1 = abs(ta1 - ta2) < _EPS__4 # ta1 == ta2
if par1 or polar:
C, ta0 = _1_0, ta2
else:
s1_qZ, C = self._s1_qZ_C2(ca1, sa1, ta1, ca2, sa2, ta2)
ta0 = (ta2 + ta1) * _0_5
Ta0 = Fsum(ta0)
tol = _tol(_TOL0, ta0)
for self._iteration in range(1, _NUMIT0):
ta02 = ta0**2
sca02 = ta02 + _1_0
sca0 = sqrt(sca02)
sa0 = ta0 / sca0
sa01 = sa0 + _1_0
sa02 = sa0**2
# sa0m = 1 - sa0 = 1 / (sec(a0) * (tan(a0) + sec(a0)))
sa0m = _1_0 / (sca0 * (ta0 + sca0)) # scb0^2 * sa0
g = (_1_0 + (b_a * ta0)**2) * sa0
dg = e12 * sca02 * (_1_0 + 2 * ta02) + e2
D = sa0m * (_1_0 - e2 *
(_1_0 + sa01 * 2 * sa0)) / (e12 * sa01) # dD/dsa0
dD = -2 * (_1_0 - e2 * sa02 *
(_3_0 + 2 * sa0)) / (e12 * sa01**2)
sa02_ = _1_0 - e2 * sa02
sa0m_ = sa0m / (_1_0 - e2 * sa0)
BA = sa0m_ * (self._atanhx1(e2 * sa0m_**2) * e12 - e2 * sa0m) \
- sa0m**2 * e2 * (2 + (_1_0 + e2) * sa0) / (e12 * sa02_) # == B + A
dAB = 2 * e2 * (2 - e2 *
(_1_0 + sa02)) / (e12 * sa02_**2 * sca02)
u_du = fsum_(s1_qZ * g, -D, g * BA) \
/ fsum_(s1_qZ * dg, -dD, dg * BA, g * dAB) # == u/du
ta0, d = Ta0.fsum2_(-u_du * (sca0 * sca02))
if abs(d) < tol:
break
else:
raise AlbersError(iteration=_NUMIT0,
txt=_no_(Fmt.convergence(tol)))
self._txi0 = txi0 = self._txif(ta0)
self._scxi0 = hypot1(txi0)
self._sxi0 = sxi0 = txi0 / self._scxi0
self._m02 = m02 = _1_0 / (_1_0 + (b_a * ta0)**2)
self._n0 = n0 = ta0 / hypot1(ta0)
if polar:
self._polar = True
self._nrho0 = self._m0 = _0_0
else:
self._m0 = sqrt(m02) # == nrho0 / E.a
self._nrho0 = E.a * self._m0 # == E.a * sqrt(m02)
self._k0_(_1_0 if par1 else (k * sqrt(C / (m02 + n0 * qZ * sxi0))))
self._lat0 = _Lat(lat0=self._sign * atand(ta0))
