pygeodesy 24.8.4__py2.py3-none-any.whl → 24.9.9__py2.py3-none-any.whl

pygeodesy/auxilats/_CX_Rs.py

@@ -0,0 +1,222 @@
+
+# -*- coding: utf-8 -*-
+
+u'''(INTERNAL) Classes C{_Rcoeffs}, C{_Rdict} and C{_Rtuple} to store the deferred
+Python versions of coefficients from I{Karney}'s C++ class U{AuxLatitude
+<https://GeographicLib.SourceForge.io/C++/doc/classGeographicLib_1_1AuxLatitude.html>}.
+
+Copyright (C) Charles Karney (2022-2024) Karney@Alum.MIT.edu> and licensed under the
+MIT/X11 License.  For more information, see <https:#GeographicLib.SourceForge.io>.
+'''
+# make sure int/int division yields float quotient, see .basics
+from __future__ import division as _; del _  # PYCHOK semicolon
+
+from pygeodesy.constants import _floats
+from pygeodesy.errors import _AssertionError,  _MODS
+from pygeodesy.interns import NN, MISSING, _COMMA_, _duplicate_, _NL_, \
+                             _QUOTE3_, _SLASH_,  _ELLIPSIS4_  # PYCHOK used!
+# from pygeodesy.lazily import _ALL_MODS as _MODS  # from .errors
+from pygeodesy.named import ADict,  Property_RO
+# from pygeodesy.props import Property_RO  # from .named
+
+__all__ = ()
+__version__ = '24.09.04'
+
+
+class _Rcoeffs(ADict):
+    '''(INTERNAL) With string-ified C{keys}.
+    '''
+    def __init__(self, ALorder, coeffs):
+        '''New C{_Rcoeffs} from a C{coeffs} dict.
+        '''
+        try:
+            if not isinstance(coeffs, dict):
+                raise _RdictError(coeffs=type(coeffs))
+            n = 0
+            for k, d in coeffs.items():
+                if not isinstance(d, _Rdict):
+                    raise _RdictError(k=k, d=type(d))
+                n += d.n
+
+            ADict.__init__(self, coeffs)
+            self.set_(ALorder=ALorder, n=n)  # in .validate
+        except Exception as x:
+            raise _RdictError(ALorder=ALorder, cause=x)
+
+    def bnuz4(self):  # in .auxilats.__main__  # PYCHOK no cover
+        # get C{(strB, number, unique, floatB)} rationals
+        b = n = u = z = 0
+        _zB = _MODS.internals._sizeof
+        for R in self._Rtuples():
+            _, _, rs = R.k_n_rs
+            b += _zB(rs)
+            t  =  R._tuple
+            z += _zB(t)  # Float
+            # assert R.Rdict is None
+            n += len(t)
+            u += sum(1 for f in t if f in _floats)
+        return b, n, (n - u), z
+
+    def items(self):  # string-ify keys  # PYCHOK no cover
+        for n, v in ADict.items(self):
+            yield str(n), v
+
+    def _Rtuples(self):  # PYCHOK no cover
+        for d in self.values():
+            if isinstance(d, _Rdict):
+                # yield from d.values()
+                for R in d.values():
+                    yield R
+
+    def _validate(self, aL, lenAux):
+        # in .auxily.Aux._CXcoeffs(al, Aux.len(aL))
+        a, n = self.ALorder, self.n  # PYCHOK Adict!
+#       for R in self._Rtuples():
+#           assert isinstance(R, _Rtuple)
+        if aL != a or lenAux != n:
+            raise _RdictError(aL=aL, ALorder=a, lenAux=lenAux, n=n)
+        return self
+
+
+class _Rdict(dict):  # in ._CX_#, .auxLat, .rhumb.aux_
+    '''(INTERNAL) Dict of C{_Rtuple}s.
+    '''
+    n = 0  # sum(R.k_n_k[1] for r in Rtuples)
+
+    def __init__(self, nt, *Rtuples):
+        '''New C{_Rdict}.
+        '''
+        if not Rtuples:
+            raise _RdictError(Rtuples=MISSING)
+
+        for R in Rtuples:
+            if not isinstance(R, _Rtuple):
+                raise _RdictError(R, R=type(R))
+            k, n, _ = R.k_n_rs
+            if k in self:
+                raise _RdictError(_duplicate_, k=k)
+            R.Rdict = self
+            self[k] = R  # overwritten in self._floatuple
+            self.n += n
+        if self.n != nt:
+            raise _RdictError(n=n, nt=nt)
+
+    def _floats(self, rs):
+        # yield floats from a string of comma-separated rationals
+        def _p_q(p=NN, q=1, *x):
+            return (NN if x else p), q
+
+        _get = _floats.get
+        for r in NN(*rs.split()).split(_COMMA_):
+            p, q = _p_q(*r.split(_SLASH_))
+            if p:
+                f = int(p) / int(q)  # fractions.Fraction?
+                if not isinstance(f, float):
+                    raise _RdictError(rs, f=f, p=p, q=q, r=r)
+                yield _get(f, f)  # from .constants?
+            else:
+                raise _RdictError(rs, r=r)
+
+    def _floatuple(self, Rtuple):
+        # return a tuple of floats from an C{_Rtuple}
+        k, n, rs = Rtuple.k_n_rs
+        t = tuple(f for m in map(self._floats, rs)
+                        for f in m)  # ... yield f
+        # @see: <https://StackOverflow.com/questions/10632839/>
+        #       and <https://realPython.com/python-flatten-list/>
+        if len(t) != n:
+            raise _RdictError(*rs, len=len(t), n=n)
+        self[k] = t
+        return t
+
+
+class _RdictError(_AssertionError):
+    '''(INTERNAL) For C{_Rdict} issues.
+    '''
+    def __init__(self, *rs, **kwds_cause):  # PYCHOK no cover
+        if rs:
+            if len(rs) > 1:
+                t = _NL_(NN, *rs)
+                t =  NN(_QUOTE3_, t, _QUOTE3_)
+            else:  # single rs
+                t =  repr(rs[0])
+            kwds_cause.update(txt=t)
+        _AssertionError.__init__(self, **kwds_cause)
+
+
+class _Rtuple(list):  # MUST be list, NOT tuple!
+    '''(INTERNAL) I{Pseudo-tuple} of float rationals used in C{_Rdict}s.
+    '''
+    Rdict  = None
+    k_n_rs = None, 0, ()
+
+    def __init__(self, k, n, *rs):
+        '''New C{_Rtuple} with key C{k}, number of floats C{n} and with
+           each C{rs} a C{str} of comma-separated rationals C{"p/q, ..."}
+           where C{p} and C{q} are C{int} digits only.
+        '''
+        try:
+            if not rs:
+                raise _RdictError(rs=MISSING)
+            for t in rs:
+                if not isinstance(t, str):
+                    raise _RdictError(rs=type(t))
+            if not (isinstance(n, int) and n > 0):
+                raise _RdictError(n=type(n))
+            self.k_n_rs = k, n, rs
+        except Exception as x:
+            raise _RdictError(*rs, k=k, n=n, cause=x)
+
+    def __getitem__(self, i):
+        return self._tuple[i]
+
+    def __iter__(self):
+        return iter(self._tuple)
+
+    def __len__(self):
+        return len(self._tuple)
+
+    @Property_RO
+    def _tuple(self):
+        # build the C{tuple} once, replace C{_Rdict}
+        # item at C{key} with the C{tuple} and fill
+        # this C{_Rlist} with the C{tuple} values
+        # for the initial __getitem__ retrieval[s]
+        try:
+            k, n, rs = self.k_n_rs
+            t = self.Rdict._floatuple(self)
+            self[:] = t  # MUST copy into self!
+        except Exception as x:
+            if len(rs) > 1 and _QUOTE3_ in str(x):
+                rs = rs[0], _ELLIPSIS4_
+            raise _RdictError(k=k, n=n, rs=rs, cause=x)
+        del self.Rdict, self.k_n_rs  # trash refs
+        return t
+
+    def append(self, arg):
+        raise _RdictError(append=arg)
+
+    def extend(self, arg):
+        raise _RdictError(extend=arg)
+
+# **) MIT License
+#
+# Copyright (C) 2024-2024 -- mrJean1 at Gmail -- All Rights Reserved.
+#
+# Permission is hereby granted, free of charge, to any person obtaining a
+# copy of this software and associated documentation files (the "Software"),
+# to deal in the Software without restriction, including without limitation
+# the rights to use, copy, modify, merge, publish, distribute, sublicense,
+# and/or sell copies of the Software, and to permit persons to whom the
+# Software is furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included
+# in all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+# OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+# THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
+# OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
+# ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+# OTHER DEALINGS IN THE SOFTWARE.

pygeodesy/auxilats/__init__.py

@@ -8,7 +8,7 @@ U{DST<https://GeographicLib.SourceForge.io/C++/doc/classGeographicLib_1_1DST.htm
 U{AuxLatitude<https://GeographicLib.SourceForge.io/C++/doc/classGeographicLib_1_1AuxLatitude.html>} all
 in I{GeographicLib version 2.2+}.
 
-Copyright (C) U{Charles Karney<mailto:Karney@Alum.MIT.edu>} (2022-2023) and licensed under the MIT/X11
+Copyright (C) U{Charles Karney<mailto:Karney@Alum.MIT.edu>} (2022-2024) and licensed under the MIT/X11
 License.  For more information, see the U{GeographicLib<https://GeographicLib.SourceForge.io>} documentation.
 
 @note: Class L{AuxDST} requires U{numpy<https://PyPI.org/project/numpy>} to be installed, version 1.16
@@ -29,7 +29,7 @@ from pygeodesy.lazily import _ALL_OTHER
 # no modules: auxAngle, auxDLat, auxDST, auxily, auxLat
 __all__ = _ALL_OTHER(Aux, AuxAngle, AuxDLat, AuxDST, AuxLat,
                      AuxBeta, AuxChi, AuxMu, AuxPhi, AuxTheta, AuxXi)
-__version__ = '24.06.16'
+__version__ = '24.09.04'
 
 # **) MIT License
 #

pygeodesy/auxilats/__main__.py

@@ -5,57 +5,49 @@ u'''Print L{auxilats} version, etc. using C{python -m pygeodesy.auxilats}.
 '''
 
 __all__ = ()
-__version__ = '24.05.31'
+__version__ = '24.09.04'
 
 
-def _CXstats():  # PYCHOK no cover
-    '''(INTERNAL) Get the C{CP} stats.
-    '''
-    from pygeodesy.auxilats import Aux, AuxLat, auxLat
-    from pygeodesy.datums import _WGS84
-
-    A  = AuxLat(_WGS84)
-    ax = A._coeffs(Aux.XI, Aux.CHI)
-    Cx = auxLat._CXcoeffs(A.ALorder)
-    pc = '%.1f%%' % (Cx.u * 100.0 / Cx.n)
-    return dict(ALorder=A.ALorder, CXlen=Cx.n, CXset=Cx.u, CXset_len=pc, CXx=len(ax))
-
-
-def _main():  # PYCHOK no cover
-
-    import os.path as _os_path
+def _main(**ALorder):  # PYCHOK no cover
 
     try:
-        from pygeodesy import auxilats, printf, pygeodesy_abspath
-        from pygeodesy.internals import _name_version, _Pythonarchine, _usage
-        from pygeodesy.interns import _COMMASPACE_, _DOT_, _version_
-        from pygeodesy.streprs import Fmt
-
-        def _dot_attr(name, value):
-            return Fmt.DOT(Fmt.EQUAL(name, value))
-
-        s = tuple(sorted(_CXstats().items()))
-        p = [_dot_attr(*t) for t in (((_version_, auxilats.__version__),) + s)]
-
-        v = _Pythonarchine()
+        from pygeodesy import auxilats
+        from pygeodesy.internals import _fper, _name_version, \
+                                         printf, _versions
+        from pygeodesy.interns import _COMMASPACE_, _EQUAL_
+
+        A  = auxilats.AuxLat(**ALorder)
+        Cx = A._CXcoeffs  # PropertyRO: Adict of _Rdicts
+        b, n, u, z = Cx.bnuz4()
+        p = dict(ALorder=A.ALorder,CXb=b, CXb_z=_fper(b, z),
+                            CXn=n, CXu=u, CXu_n=_fper(u, n))
+        p = list(_EQUAL_(*t) for t in p.items())
         try:
             import geographiclib
-            v.append(_name_version(geographiclib))
+            p.append(_name_version(geographiclib))
         except ImportError:
             pass
 
-        a =  auxilats.__name__
-        x = _os_path.basename(pygeodesy_abspath)
-        if not a.startswith(x):
-            a = _DOT_(x, a)
-        printf('%s%s (%s)', a, _COMMASPACE_.join(p), _COMMASPACE_.join(v))
+        a = _name_version(auxilats)
+        printf('%s: %s (%s)', a, _COMMASPACE_(*p), _versions())
 
     except ImportError:
-        raise
-        printf(_usage(__file__))
+        from pygeodesy.internals import _usage
+        print(_usage(__file__))
+
+
+from sys import argv  # .internals._isPyChecker
+_main(ALorder=int(argv[1])) if len(argv) == 2 and argv[1].isdigit() else _main()
+
+# % python3.12 -m pygeodesy.auxilats 8
+# pygeodesy.auxilats 24.09.04: ALorder=8, CXb=20310, CXb_z=71.5%, CXn=888, CXu=780, CXu_n=87.8%, geographiclib 2.0 (pygeodesy 24.9.9 Python 3.12.5 64bit arm64 macOS 14.6.1)
+
+# % python3.12 -m pygeodesy.auxilats 6
+# pygeodesy.auxilats 24.09.04: ALorder=6, CXb=11099, CXb_z=64.1%, CXn=522, CXu=448, CXu_n=85.8%, geographiclib 2.0 (pygeodesy 24.9.9 Python 3.12.5 64bit arm64 macOS 14.6.1)
 
+# % python3.12 -m pygeodesy.auxilats 4
+# pygeodesy.auxilats 24.09.04: ALorder=4, CXb=5367, CXb_z=58.8%, CXn=252, CXu=203, CXu_n=80.6%, geographiclib 2.0 (pygeodesy 24.9.9 Python 3.12.5 64bit arm64 macOS 14.6.1)
 
-_main()
 
 # **) MIT License
 #

pygeodesy/auxilats/auxDST.py

@@ -24,7 +24,7 @@ from pygeodesy.karney import _2cos2x,  _ALL_DOCS
 from pygeodesy.props import property_RO, property_ROver
 
 __all__ = ()
-__version__ = '24.07.25'
+__version__ = '24.08.13'
 
 
 class AuxDST(object):
@@ -92,7 +92,7 @@ class AuxDST(object):
 
            @arg data: Elements DST-III[0:N+1] or DST-IV[0:N] (C{float}[])
                       with DST_III[0] = 0.
-           @arg cIV: If C{True} DST-IV, otherwise DST-III.
+           @arg cIV: If C{True}, DST-IV, otherwise DST-III.
 
            @return: FFTransforms (C{float}[0:N]).
         '''

pygeodesy/auxilats/auxLat.py

@@ -17,11 +17,12 @@ from __future__ import division as _; del _  # PYCHOK semicolon
 
 from pygeodesy.auxilats.auxAngle import AuxAngle, AuxBeta, AuxChi, _AuxClass, \
                                         AuxMu, AuxPhi, AuxTheta, AuxXi
-from pygeodesy.auxilats.auxily import Aux, _sc, _sn, _Ufloats,  atan1
+from pygeodesy.auxilats.auxily import Aux, _sc, _sn,  atan1
+from pygeodesy.auxilats._CX_Rs import _Rdict, _Rtuple
 from pygeodesy.basics import _reverange, _xinstanceof,  _passarg
 from pygeodesy.constants import INF, MAX_EXP, MIN_EXP, NAN, PI_2, PI_4, _EPSqrt, \
-                               _0_0, _0_0s, _0_1, _0_25, _0_5, _1_0, _2_0, _3_0, \
-                               _360_0, isfinite, isinf, isnan, _log2, _over
+                               _0_0, _0_0s, _0_1, _0_5, _1_0, _2_0, _3_0, _360_0, \
+                               _log2, _over, isfinite, isinf, isnan
 from pygeodesy.datums import _ellipsoidal_datum, _WGS84, \
                               Ellipsoid, _name__, _EWGS84
 # from pygeodesy.ellipsoids import Ellipsoid, _EWGS84  # from .datums
@@ -30,9 +31,9 @@ from pygeodesy.errors import AuxError, _xkwds_not, _xkwds_pop2, _Xorder
 # from pygeodesy.fmath import cbrt  # from .karney
 from pygeodesy.fsums import Fsum, _Fsumf_, _sum
 # from pygeodesy.internals import _passarg  # from .basics
-from pygeodesy.interns import NN, _DOT_, _not_scalar_, _UNDER_
-from pygeodesy.karney import _2cos2x, _polynomial,  _ALL_DOCS, cbrt, _MODS
-# from pygeodesy.lazily import _ALL_DOCS, _ALL_MODS as _MODS  # from .karney
+from pygeodesy.interns import NN, _not_scalar_, _UNDER_
+from pygeodesy.karney import _2cos2x, _polynomial,  _ALL_DOCS, cbrt
+# from pygeodesy.lazily import _ALL_DOCS  # from .karney
 # from pygeodesy.named import _name__  # from .datums
 from pygeodesy.props import Property, Property_RO, _update_all
 from pygeodesy.units import _isDegrees, _isRadius, Degrees, Meter
@@ -47,7 +48,7 @@ except ImportError:  # Python 3.11-
         return pow(_2_0, x)
 
 __all__ = ()
-__version__ = '24.06.16'
+__version__ = '24.09.03'
 
 _TRIPS = 1024  # XXX 2 or 3?
 
@@ -222,9 +223,8 @@ class AuxLat(AuxAngle):
         except KeyError:
             pass
 
-        Cx = _CXcoeffs(aL)
         try:
-            Cx = Cx[auxout][auxin]
+            Cx = self._CXcoeffs[auxout][auxin]  # _Rtuple!
         except KeyError as x:
             raise AuxError(auxout=auxout, auxin=auxin, cause=x)
 
@@ -238,13 +238,12 @@ class AuxLat(AuxAngle):
         else:
             _m = _reverange  # PYCHOK expected
 
-        i  = 0
+        i  =  0
         cs = []
-        _c =  cs.append
         _p = _polynomial
         for m in _m(aL):
             j  = i + m + 1  # order m = j - i - 1
-            _c(_p(x, Cx, i, j) * d)
+            cs.append(_p(x, Cx, i, j) * d)
             d *= n
             i  = j
         # assert i == len(Cx) and len(cs) == aL
@@ -378,6 +377,12 @@ class AuxLat(AuxAngle):
 
         raise AuxError(auxout=auxout, Zeta_d=Zeta_d, exact=exact)
 
+    @Property_RO
+    def _CXcoeffs(self):  # in .auxilats.__main__, .testAuxilats
+        '''(INTERNAL) Get the C{CX_4}, C{_6} or C{_8} coefficients.
+        '''
+        return Aux._CXcoeffs(self.ALorder)
+
     def _Dq(self, tphi):
         # I{Divided Difference} of (q(1) - q(sphi)) / (1 - sphi).
         sphi = _sn(tphi)
@@ -763,19 +768,6 @@ def _Clenshaw(sinp, Zeta, cs, K):
     return x
 
 
-def _CXcoeffs(aL):  # PYCHOK in .auxilats.__main__
-    '''(INTERNAL) Get the C{CX_4}, C{_6} or C{_8} coefficients.
-    '''
-    try:  # from pygeodesy.auxilats._CX_x import _coeffs_x as _coeffs
-        _CX_x   = _DOT_(_MODS.auxilats.__name__, _UNDER_('_CX', aL))
-        _coeffs = _MODS.getattr(_CX_x, _UNDER_('_coeffs', aL))
-    except (AttributeError, ImportError, KeyError, TypeError) as x:
-        raise AuxError(ALorder=aL, cause=x)
-    # assert _coeffs.ALorder == aL
-    # assert _coeffs.n == Aux.len(aL)
-    return _coeffs
-
-
 def _diff_name2(Phi, diff=False, **name):
     '''(INTERNAL) Get C{{Bdiff}=False} and C{B{name}=NN}.
     '''
@@ -836,17 +828,17 @@ def _Newton(tphi, Zeta, _toZeta, **name):
     return Phi
 
 
-_f, _u =  float, _Ufloats()
-_1__f3 = -1 / _f(3)  # XXX +1 / _f(3)
-_AR2Coeffs = {4: _u(4  / _f(315),   4 / _f(105),  4 / _f(15),  _1__f3),
-              6: _u(4  / _f(1287),  4 / _f(693),  4 / _f(315),  4 / _f(105),
-                    4  / _f(15),   _1__f3),
-              8: _u(4  / _f(3315),  4 / _f(2145), 4 / _f(1287), 4 / _f(693),
-                    4  / _f(315),   4 / _f(105),  4 / _f(15),  _1__f3)}
-_RRCoeffs  = {4: _u(1  / _f(64),   _0_25),
-              6: _u(1  / _f(256),   1 / _f(64),  _0_25),
-              8: _u(25 / _f(16384), 1 / _f(256),  1 / _f(64),  _0_25)}  # PYCHOK used!
-del _f, _u, _Ufloats, _1__f3
+_AR2Coeffs = _Rdict(18,
+    _Rtuple(4, 4, '4/315,  4/105,  4/15,  -1/3'),
+    _Rtuple(6, 6, '4/1287, 4/693,  4/15,   4/105, 4/315, -1/3'),
+    _Rtuple(8, 8, '4/3315, 4/2145, 4/1287, 4/693, 4/315,  4/105, 4/15, -1/3'))
+
+_RRCoeffs = _Rdict(9,
+    _Rtuple(4, 2,  '1/64,    1/4'),
+    _Rtuple(6, 3,  '1/256,   1/64,  1/4'),
+    _Rtuple(8, 4, '25/16384, 1/256, 1/64, 1/4'))  # PYCHOK used!
+
+del _Rdict, _Rtuple
 # assert set(_AR2Coeffs.keys()) == set(_RRCoeffs.keys())
 
 # AuxLat._Lmax = max(_AR2Coeffs.keys())  # == max(ALorder)

pygeodesy/auxilats/auxily.py

@@ -14,25 +14,25 @@ under the MIT/X11 License.  For more information, see the U{GeographicLib
 # make sure int/int division yields float quotient, see .basics
 from __future__ import division as _; del _  # PYCHOK semicolon
 
-from pygeodesy.constants import INF, NAN, isinf, isnan, _0_0, _0_5, \
-                               _1_0, _copysign_1_0, _over, _1_over
-from pygeodesy.errors import AuxError,  NN
+# from pygeodesy import auxilats  # _MODS
+from pygeodesy.constants import INF, NAN, isinf, isnan, _0_0, _0_5, _1_0, \
+                               _copysign_1_0, _over, _1_over
+from pygeodesy.errors import AuxError
 from pygeodesy.fmath import hypot1 as _sc, hypot2_
-# from pygeodesy.interns import NN  # from .errors
-from pygeodesy.karney import ADict,  _ALL_DOCS, _MODS  # PYCHOK used!
-# from pygeodesy.lazily import _ALL_DOCS, _ALL_MODS as _MODS  # from .karney
-# from pygeodesy.named import ADict  # from .karney
+from pygeodesy.interns import NN,  _DOT_, _UNDER_  # PYCHOK used!
+from pygeodesy.lazily import _ALL_DOCS,  _ALL_MODS as _MODS  # PYCHOK used!
 from pygeodesy.utily import atan1
 
 from math import asinh, copysign
 
 __all__ = ()
-__version__ = '24.07.12'
+__version__ = '24.09.03'
 
 
 class Aux(object):
     '''Enum-style Aux names.
     '''
+    _coeffs    = {}
     GEOGRAPHIC = PHI   = GEODETIC = 0
     PARAMETRIC = BETA  = REDUCED  = 1
     GEOCENTRIC = THETA = 2  # all ...
@@ -44,18 +44,33 @@ class Aux(object):
 
     def __index__(self, aux):
         # throws KeyError, not IndexError
-        return _MODS.auxilats.auxLat._Aux2Greek[aux]
+        return _Aux2Greek[aux]
 
     def __len__(self):
         return Aux.N
 
+    def _CXcoeffs(self, aL):  # in .auxLat.AuxLat._CXcoeffs
+        '''(INTERNAL) Get the C{_CX_4._coeffs_4}, C{_CX_6._coeffs_6}
+           or C{_CS_8._coeffs_8} coefficients, once.
+        '''
+        try:
+            _coeffs = Aux._coeffs[aL]
+        except KeyError:
+            try:  # from pygeodesy.auxilats._CX_x import _coeffs_x as _coeffs
+                _CX_x   = _DOT_(_MODS.auxilats.__name__, _UNDER_('_CX', aL))
+                _coeffs = _MODS.getattr(_CX_x, _UNDER_('_coeffs', aL))
+            except (AttributeError, ImportError, KeyError, TypeError) as x:
+                raise AuxError(ALorder=aL, cause=x)
+            Aux._coeffs[aL] = _coeffs._validate(aL, Aux.len(aL))
+        return _coeffs
+
     def _1d(self, auxout, auxin):
         '''Get the 1-d index into N^2 coeffs.
         '''
         N = Aux.N
         if 0 <= auxout < N and 0 <= auxin < N:
             return N * auxout + auxin
-        raise AuxError(auxout=auxout, auxin=auxin, N=N)  # == AssertionError
+        raise AuxError(auxout=auxout, auxin=auxin, N=N)
 
     def Greek(self, aux):
         '''Get an angle's name (C{str}).
@@ -65,9 +80,9 @@ class Aux(object):
     def len(self, ALorder):  # PYCHOK no cover
         aL = ALorder  # aka Lmax
         mu = Aux.MU * (Aux.MU + 1)
-        ns = Aux.N2 -  Aux.N
-        return (mu * (aL * (aL + 3) - 2 * (aL // 2)) // 4 +
-               (ns - mu) * (aL * (aL + 1)) // 2)
+        nu = Aux.N2 -  Aux.N - mu
+        return (mu * (aL * (aL + 3) - (aL // 2) * 2) // 4 +
+                nu * (aL * (aL + 1)) // 2)
 
     def power(self, auxout, auxin):
         '''Get the C{convert} exponent (C{int} or C{None}).
@@ -83,21 +98,13 @@ Aux = Aux()  # PYCHOK singleton
 _Aux2Greek = {Aux.AUTHALIC:   'Xi',
               Aux.CONFORMAL:  'Chi',
               Aux.GEOCENTRIC: 'Theta',
-              Aux.GEODETIC:   'Phi',  # == .GEOGRAPHIC
-              Aux.PARAMETRIC: 'Beta',
+              Aux.GEODETIC:   'Phi',   # == .GEOGRAPHIC
+              Aux.PARAMETRIC: 'Beta',  # == .REDUCED
               Aux.RECTIFYING: 'Mu'}
 _Greek2Aux = dict(map(reversed, _Aux2Greek.items()))  # PYCHOK exported
 # _Greek2Aux.update((_g.upper(), _x) for _g, _x in _Greek2Aux.items())
 
 
-class _Coeffs(ADict):
-    '''(INTERNAL) With C{items keys} string-ified.
-    '''
-    def items(self):
-        for n, v in ADict.items(self):
-            yield str(n), v
-
-
 def _Dasinh(x, y):
     d = y - x
     if isinf(d):  # PYCHOK no cover
@@ -220,33 +227,6 @@ def _sn(tx):
     return tx  # preserve signed-0
 
 
-class _Ufloats(dict):  # in .auxilats.auxily
-    '''(INTERNAL) "Uniquify" floats.
-    '''
-    n = 0  # total number of floats
-
-    def __call__(self, *fs):
-        '''Return a tuple of "uniquified" floats.
-        '''
-        self.n += len(fs)
-        _f = self.setdefault
-        return tuple(_f(f, f) for f in map(float, fs))  # PYCHOK as attr
-
-    def _Coeffs(self, ALorder, coeffs):
-        '''Return C{coeffs} (C{_Coeffs}, I{embellished}).
-        '''
-#       if True:
-#           n = 0
-#           for d in coeffs.values():
-#               n += sum(d.values())
-#           assert n == self.n
-        Cx = _Coeffs(coeffs)
-        Cx.set_(ALorder=ALorder,  # used in .auxilats.__main__
-                n=self.n,   # total number of floats
-                u=len(self.keys()))  # unique floats
-        return Cx
-
-
 __all__ += _ALL_DOCS(Aux.__class__)
 
 # **) MIT License

pygeodesy/basics.py

@@ -37,7 +37,7 @@ from math import copysign as _copysign
 import inspect as _inspect
 
 __all__ = _ALL_LAZY.basics
-__version__ = '24.07.06'
+__version__ = '24.09.02'
 
 _below_               = 'below'
 _list_tuple_types     = (list, tuple)
@@ -68,8 +68,8 @@ except ImportError:
     _Seqs     = list, _Sequence  # range for function len2 below
 
 try:
-    _Bytes = unicode, bytearray  # PYCHOK expected
-    _Strs  = basestring, str  # XXX , bytes
+    _Bytes = unicode, bytearray  # PYCHOK in .internals
+    _Strs  = basestring, str  # XXX str == bytes
     str2ub = ub2str = _passarg  # avoids UnicodeDecodeError
 
     def _Xstr(exc):  # PYCHOK no cover
@@ -93,7 +93,7 @@ try:
 except NameError:  # Python 3+
     from pygeodesy.interns import _utf_8_
 
-    _Bytes = bytes, bytearray
+    _Bytes = bytes, bytearray  # in .internals
     _Strs  = str,  # tuple
     _Xstr  = str
 
@@ -166,7 +166,7 @@ def clips(sb, limit=50, white=NN, length=False):
        @arg sb: String (C{str} or C{bytes}).
        @kwarg limit: Length limit (C{int}).
        @kwarg white: Optionally, replace all whitespace (C{str}).
-       @kwarg len: IF C{True} append the original I{[length]} (C{bool}).
+       @kwarg length: If C{True}, append the original I{[length]} (C{bool}).
 
        @return: The clipped or unclipped B{C{sb}}.
     '''
@@ -733,7 +733,7 @@ def _xcopy(obj, deep=False):
     '''(INTERNAL) Copy an object, shallow or deep.
 
        @arg obj: The object to copy (any C{type}).
-       @kwarg deep: If C{True} make a deep, otherwise
+       @kwarg deep: If C{True}, make a deep, otherwise
                     a shallow copy (C{bool}).
 
        @return: The copy of B{C{obj}}.
@@ -741,11 +741,22 @@ def _xcopy(obj, deep=False):
     return _deepcopy(obj) if deep else _copy(obj)
 
 
+def _xcoverage(where, *required):
+    '''(INTERNAL) Import C{coverage} and check required version.
+    '''
+    try:
+        _xpackage(_xcoverage)
+        import coverage
+    except ImportError as x:
+        raise _xImportError(x, where)
+    return _xversion(coverage, where, *required)
+
+
 def _xdup(obj, deep=False, **items):
     '''(INTERNAL) Duplicate an object, replacing some attributes.
 
        @arg obj: The object to copy (any C{type}).
-       @kwarg deep: If C{True} copy deep, otherwise shallow.
+       @kwarg deep: If C{True}, copy deep, otherwise shallow (C{bool}).
        @kwarg items: Attributes to be changed (C{any}).
 
        @return: A duplicate of B{C{obj}} with modified