pygeodesy 25.12.12__py2.py3-none-any.whl → 26.1.16__py2.py3-none-any.whl

pygeodesy/internals.py

@@ -6,8 +6,8 @@ u'''Mostly INTERNAL functions, except L{machine}, L{print_} and L{printf}.
 # from pygeodesy.basics import isiterablen, ubstr  # _MODS
 # from pygeodesy.errors import _AttributeError, _error_init, _ImmutableError, _UnexpectedError, _xError2  # _MODS
 from pygeodesy.interns import _BAR_, _COLON_, _DASH_, _DMAIN_, _DOT_, _ELLIPSIS_, _NL_, NN, \
-                              _pygeodesy_, _PyPy__, _python_, _QUOTE1_, _QUOTE2_, _s_, _sys, \
-                              _SPACE_, _UNDER_
+                              _NLATvar_, _pygeodesy_, _PyPy__, _python_, _QUOTE1_, _QUOTE2_, \
+                              _s_, _sys, _SPACE_, _UNDER_
 from pygeodesy.interns import _COMMA_, _Python_  # PYCHOK used!
 # from pygeodesy.streprs import anstr, pairs, unstr  # _MODS
 
@@ -459,6 +459,13 @@ def _popen2(cmd, stdin=None):  # in .mgrs, .solveBase, .testMgrs
     return _MODS.basics.ub2str(r).strip(), p.returncode
 
 
+def _pregistry(registry):
+    '''(INTERNAL) Print all items of a C{registry}.
+    '''
+    t = [NN] + registry.toRepr(all=True, asorted=True).split(_NL_)
+    printf(_NLATvar_.join(i.strip(_COMMA_) for i in t))
+
+
 def print_(*args, **nl_nt_prec_prefix__end_file_flush_sep__kwds):  # PYCHOK no cover
     '''Python 3+ C{print}-like formatting and printing.
 
@@ -709,7 +716,7 @@ def _versions(sep=_SPACE_):
 
 
 __all__ = tuple(map(typename, (machine, print_, printf, typename)))
-__version__ = '25.10.26'
+__version__ = '26.01.13'
 
 if __name__ == _DMAIN_:
 

pygeodesy/karney.py

@@ -153,14 +153,14 @@ in C{pygeodesy} are based on I{Karney}'s post U{Area of a spherical polygon
 # make sure int/int division yields float quotient, see .basics
 from __future__ import division as _; del _  # noqa: E702 ;
 
-from pygeodesy.basics import _copysign, _isin, isint, neg, unsigned0, \
-                             _xgeographiclib, _zip
+from pygeodesy.basics import _copysign, _isin, isint, neg, _xgeographiclib, _zip
 from pygeodesy.constants import NAN, _isfinite as _math_isfinite, \
                                _0_0, _1_0, _2_0, _180_0, _N_180_0, _360_0
 # from pygeodesy.deprecated.classes import Rhumb7Tuple  # _MODS
 from pygeodesy.errors import GeodesicError, _ValueError, _xkwds
 # from pygeodesy.geod3Solve import Geod3Solve8Tuple  # _MODS
-from pygeodesy.fmath import cbrt, fremainder, norm2  # Fhorner, Fsum
+from pygeodesy.fmath import cbrt, fhorner, fremainder, norm2
+from pygeodesy.fsums import _Ksum
 from pygeodesy.internals import _getenv, _popen2, _PYGEODESY_ENV, typename, \
                                 _version_info
 from pygeodesy.interns import NN, _a12_, _area_, _azi2_, _azi12_, _composite_, \
@@ -177,7 +177,7 @@ from pygeodesy.utily import atan2d, sincos2d, tand, _unrollon,  fabs
 # from math import fabs  # from .utily
 
 __all__ = _ALL_LAZY.karney
-__version__ = '25.12.12'
+__version__ = '25.12.23'
 
 _1_16th     = _1_0 / 16
 _2_4_       = '2.4'
@@ -913,20 +913,18 @@ try:
 
 except ImportError:  # Python 3.12-
 
-    def _poly_fma(x, s, *cs):  # PYCHOK redef
-        t = _0_0
-        for c in cs:
-            s, t, _ = _sum3(s * x, t * x, c)
-        return s + t
+    def _poly_fma(x, *cs):  # PYCHOK redef
+        return fhorner(x, *cs, incx=False)
 
 #   def _poly_fma(x, s, *cs):
-#       S  = Fhorner(x, *cs, incx=False)
-#       S += s
-#       return float(S)
+#       t = _0_0
+#       for c in cs:
+#           s, t, _ = _sum3(s * x, t * x, c)
+#       return s + t
 
 def _polynomial(x, cs, i, j):  # PYCHOK shared
-    '''(INTERNAL) Like C++ C{GeographicLib.Math.hpp.polyval} but with a
-       signature and cascaded summation different from C{karney._sum3}.
+    '''(INTERNAL) Like C++ C{GeographicLib.Math.hpp.polyval} but
+       with a different signature and cascaded summation.
 
        @return: M{sum(x**(j - k - 1) * cs[k] for k in range(i, j)}
     '''
@@ -1007,18 +1005,18 @@ def _sum2(a, b):  # mimick geomath.Math.sum, actually sum2
         r = s - b
         t = s - r
         # elif C_CPP:  # Math::sum C/C++
-        #   r -= a; t -= b; t += r; t = -t
-        # else:
-        t = (a - r) + (b - t)
+        #   r -= a; t -= b; t += r; t = (-t) if s else s
+        # else:  # if s == 0: t = _copysign_0_0(s)
+        t = ((a - r) + (b - t)) if s else s
         # assert fabs(s) >= fabs(t)
         return s, t
 
 
 def _sum3(s, t, *xs):
-    '''Accumulate any B{C{xs}} into a previous C{_sum2(s, t)}.
+    '''Accumulate all B{C{xs}} scalars into a previous C{_sum2(s, t)}.
 
        @return: 3-Tuple C{(s, t, n)} where C{s} is the sum of B{s}, B{t} and all
-                B{xs}, C{t} the residual and C{n} the number of zero C{xs}.
+                B{xs}, C{t} the residual and C{n} the number of non-zero C{xs}.
 
        @see: I{Karney's} C++ U{Accumulator<https://GeographicLib.SourceForge.io/
              C++/doc/Accumulator_8hpp_source.html>} comments for more details and
@@ -1026,23 +1024,10 @@ def _sum3(s, t, *xs):
 
        @note: Not "error-free", see C{pygeodesy.test/testKarney.py}.
     '''
-    z = 0
-    for x in xs:
-        if x:
-            t, r = _sum2(t, x)  # start at the least-
-            if s:
-                s, t = _sum2(s, t)  # -significant end
-                if s:
-                    t += r  # accumulate r into t
-                else:
-                    # assert t == 0  # s == 0 implies t == 0
-                    s = unsigned0(r)  # result is r, t = 0
-            else:
-                s, t = unsigned0(t), r
-        else:
-            z += 1
-    # assert fabs(s) >= fabs(t)
-    return s, t, z
+    return _Ksum(s, t, *xs)._s_t_n3 if xs else (s, t, 0)
+    # previous _sum3 in .geodesicx.gxarea._Accumulator.Add
+    # which fails .fmath.frandoms tests, but does pass
+    # _sum3(1e20, 1, 2, 100, 5000, -1e20) ... 5103.0, 0.0, 4
 
 
 def _tand(x):

pygeodesy/lazily.py

@@ -30,8 +30,8 @@ and line number.
 from pygeodesy import internals as _internals, interns as _interns, \
                      _isfrozen  # DON'T _lazy_import2
 # from pygeodesy.errors import _error_init, _ImmutableError, _xkwds_item2  # _ALL_MODS
-from pygeodesy.internals import _caller3, _envPYGEODESY, _headof, printf, _tailof, \
-                                 typename, _versions  # _getenv, _PYGEODESY_ENV, \
+from pygeodesy.internals import _caller3, _envPYGEODESY, _headof, printf, _Property_RO, \
+                                _tailof, typename, _versions  # _getenv, _PYGEODESY_ENV, \
 #                               _MODS_Base, _MODS.sys_version_info2
 from pygeodesy.interns import _attribute_, _by_, _COLONSPACE_, _COMMASPACE_, _DALL_, \
                               _DMAIN_, _doesn_t_exist_, _DOT_, _EQUALSPACED_, _from_, \
@@ -234,7 +234,8 @@ _ALL_LAZY = _NamedEnum_RO(_name='_ALL_LAZY',
                                    'a_f2b', 'a_f_2b', 'b_f2a', 'b_f_2a',
                                    'e2f', 'e22f',
                                    'f2e2', 'f2e22', 'f2e32', 'f_2f', 'f2f_', 'f2f2', 'f2n', 'n2e2', 'n2f', 'n2f_'),
-                       elliptic=_a('Elliptic', 'EllipticError', 'Elliptic3Tuple'),
+                       elliptic=_a('Elliperim', 'Elliptic', 'EllipticError', 'Elliptic3Tuple',
+                                   'elliperim', 'elliperim_'),
                            epsg=_a('Epsg', 'EPSGError'),
                          errors=_a('AuxError', 'ClipError', 'CrossError', 'GeodesicError', 'IntersectionError',
                                    'NumPyError', 'LenError', 'LimitError', 'MGRSError',
@@ -253,7 +254,7 @@ _ALL_LAZY = _NamedEnum_RO(_name='_ALL_LAZY',
                           formy=_a('Radical2Tuple',
                                    'angle2chord', 'antipode', 'antipode_', 'bearing', 'bearing_',
                                    'chord2angle', 'compassAngle', 'cosineLaw', 'cosineLaw_',
-                                   'elliperim', 'equirectangular', 'equirectangular4', 'euclidean', 'euclidean_',
+                                   'equirectangular', 'equirectangular4', 'euclidean', 'euclidean_',
                                    'excessAbc_', 'excessCagnoli_', 'excessGirard_', 'excessLHuilier_',
                                    'excessKarney', 'excessKarney_', 'excessQuad', 'excessQuad_',
                                    'flatLocal', 'flatLocal_', 'flatPolar', 'flatPolar_',
@@ -517,10 +518,16 @@ class _ALL_MODS(_internals._MODS_Base):
             if _headof(n) == _pygeodesy_:
                 yield n, m
 
+    @_Property_RO
+    def _triaxials_triaxial5(self):
+        '''(INTERNAL) Get module C{triaxial.triaxials}.
+        '''
+        return self.triaxials.triaxial5
+
 _internals._MODS = _ALL_MODS = _ALL_MODS()  # PYCHOK singleton
 
 __all__ = _ALL_LAZY.lazily
-__version__ = '25.12.12'
+__version__ = '26.01.06'
 
 
 def _ALL_OTHER(*objs):

pygeodesy/lcc.py

@@ -651,13 +651,9 @@ def toLcc(latlon, conic=Conics.WRF_Lb, height=None, Lcc=Lcc,
 
 
 if __name__ == _DMAIN_:
-
-    from pygeodesy.interns import _NL_, _NLATvar_
-    from pygeodesy.lazily import printf
-
-    # __doc__ of this file, force all into registery
-    t = _NL_ + Conics.toRepr(all=True, asorted=True)
-    printf(_NLATvar_.join(t.split(_NL_)))
+    # __doc__ of this file, force all into registry
+    from pygeodesy.internals import _pregistry
+    _pregistry(Conics)
 
 # **) MIT License
 #

pygeodesy/named.py

@@ -35,7 +35,7 @@ from pygeodesy.streprs import attrs, Fmt, lrstrip, pairs, reprs, unstr
 # from pygeodesy.units import _toUnit  # _MODS
 
 __all__ = _ALL_LAZY.named
-__version__ = '25.11.29'
+__version__ = '26.01.14'
 
 _COMMANL_           = _COMMA_ + _NL_
 _COMMASPACEDOT_     = _COMMASPACE_ + _DOT_
@@ -658,18 +658,24 @@ class _NamedEnum(_NamedDict):
         '''(INTERNAL) Check attribute name against given, registered name.
         '''
         pypy = _isPyPy()
-        _isa =  isinstance
         for n, v in kwds.items():
-            if _isa(v, _LazyNamedEnumItem):  # property
+            if isinstance(v, _LazyNamedEnumItem):  # property
                 assert (n == v.name) if pypy else (n is v.name)
                 # assert not hasattr(self.__class__, n)
                 setattr(self.__class__, n, v)
-            elif _isa(v, self._item_Classes):  # PYCHOK no cover
+            elif isinstance(v, self._item_Classes):  # PYCHOK no cover
                 assert self[n] is v and getattr(self, n) \
                                     and self.find(v) == n
             else:
                 raise _TypeError(v, name=n)
 
+    def _asserts(self):  # in .triaxials.triaxial3
+        '''(INTERNAL) Yield all asserted items.
+        '''
+        for n, p in tuple(type(self).__dict__.items()):
+            if isinstance(p, _LazyNamedEnumItem):
+                yield n, p
+
     def find(self, item, dflt=None, all=False):
         '''Find a registered item.
 
@@ -707,10 +713,8 @@ class _NamedEnum(_NamedDict):
                            case-insensitive} order (C{bool}).
         '''
         if all:  # instantiate any remaining L{_LazyNamedEnumItem}
-            _isa = isinstance
-            for n, p in tuple(type(self).__dict__.items()):
-                if _isa(p, _LazyNamedEnumItem):
-                    _ = getattr(self, n)
+            for n, _ in self._asserts():
+                _ = getattr(self, n)
         return itemsorted(self) if asorted else ADict.items(self)
 
     def keys(self, **all_asorted):
@@ -857,7 +861,7 @@ def _lazyNamedEnumItem(name, *args, **kwds):
 
 
 class _NamedEnumItem(_NamedBase):
-    '''(INTERNAL) Base class for items in a C{_NamedEnum} registery.
+    '''(INTERNAL) Base class for items in a C{_NamedEnum} registry.
     '''
     _enum = None
 
@@ -1188,7 +1192,7 @@ def callername(up=1, dflt=NN, source=False, underOK=False):
 
        @return: The callable name (C{str}) or B{C{dflt}} if none found.
     '''
-    try:  # see .lazily._caller3
+    try:  # see .internals._caller3
         for u in range(up, up + 32):
             n, f, s = _caller3(u)
             if n and (underOK or n.startswith(_DUNDER_) or

pygeodesy/props.py

@@ -26,7 +26,7 @@ from pygeodesy.lazily import _ALL_LAZY, _ALL_MODS as _MODS, \
 from functools import wraps as _wraps
 
 __all__ = _ALL_LAZY.props
-__version__ = '25.05.26'
+__version__ = '25.12.31'
 
 _class_       = 'class'
 _DNL_         = _NL_ * 2  # PYCHOK used!
@@ -696,8 +696,10 @@ class DeprecationWarnings(object):
         '''
         return self._Warnings if _WARNINGS_X_DEV else None
 
-DeprecationWarnings = DeprecationWarnings()  # PYCHOK singleton
-_throwarning        = DeprecationWarnings.throw
+if not _FOR_DOCS:  # PYCHOK force epydoc
+    DeprecationWarnings = DeprecationWarnings()  # singleton
+    _throwarning        = DeprecationWarnings.throw
+# del _FOR_DOCS
 
 # **) MIT License
 #

pygeodesy/trf.py

@@ -1,9 +1,7 @@
 
 # -*- coding: utf-8 -*-
 
-u'''I{Veness}' Terrestrial Reference Frames (TRF).
-
-Classes L{RefFrame}, registry L{RefFrames} and L{TRFError}.
+u'''I{Veness}' Terrestrial Reference Frames (TRF), classes L{RefFrame}, registry L{RefFrames} and L{TRFError}.
 
 Transcoded from I{Chris Veness'} (C) 2006-2024 JavaScript originals U{latlon-ellipsoidal-referenceframe.js
 <https://GitHub.com/ChrisVeness/geodesy/blob/master/latlon-ellipsoidal-referenceframe.js>} and
@@ -1756,7 +1754,7 @@ if __name__ == _DMAIN_:
                 t = '%d,%3d,%3d' % t
                 printf('# %s = %s = %s %s', f, e, t, x)
 
-        # __doc__ of this file, force all into registery
+        # __doc__ of this file, force all into registry
         def _RFs():
             yield NN
             for t in RefFrames.toRepr(all=True).split(_NL_):

pygeodesy/triaxials/bases.py

@@ -36,29 +36,31 @@ from __future__ import division as _; del _  # noqa: E702 ;
 
 # from pygeodesy.angles import Ang, isAng  # _MODS
 from pygeodesy.basics import map1, isscalar
-from pygeodesy.constants import EPS, EPS0, EPS02, EPS4, _EPS2e4, INT0, NAN, PI2, PI_3, PI4, \
-                               _isfinite, float0_, _0_0, _1_0, _N_1_0,  _4_0  # PYCHOK used!
-# from pygeodesy.ellipsoids import Ellipsoid  # _MODS
-# from pygeodesy.elliptic import Elliptic  # _MODS
-# from pygeodesy.errors import _ValueError, _xkwds  # from .formy
+from pygeodesy.constants import EPS, EPS0, EPS02, EPS4, _EPS2e4, INT0, \
+                               _isfinite, float0_, NAN, PI2, PI_3, PI4, \
+                               _0_0, _1_0, _N_1_0,  _4_0  # PYCHOK used!
+# from pygeodesy.ellipsoids import Ellipsoid, _EWGS84  # _MODS
+# from pygeodesy.elliptic import elliperim, Elliptic  # _MODS
+# from pygeodesy.errors import _ValueError, _xkwds  # from .utily
 from pygeodesy.fmath import fmean_, hypot, norm2, sqrt0,  fabs, sqrt
-from pygeodesy.formy import elliperim,  _ValueError, _xkwds
 from pygeodesy.fsums import _Fsumf_, fsumf_, fsum1f_
+# from pygeodesy.internals import typename  # _MODS
 from pygeodesy.interns import _a_, _b_, _c_, _inside_, _not_, _NOTEQUAL_, _null_, \
                               _outside_, _scale_, _SPACE_, _spherical_, _x_, _y_, _z_
-from pygeodesy.lazily import _ALL_DOCS, _ALL_LAZY, _ALL_MODS as _MODS
-from pygeodesy.named import _NamedEnumItem, _NamedTuple, _Pass
+from pygeodesy.lazily import _ALL_DOCS, _ALL_LAZY, _ALL_MODS as _MODS, _FOR_DOCS
+from pygeodesy.named import _NamedEnum, _NamedEnumItem, _NamedTuple, _Pass  # _MODS
 from pygeodesy.namedTuples import Vector4Tuple
 from pygeodesy.props import Property_RO, property_doc_, property_RO, property_ROver
+# from pygeodesy.streprs import Fmt  # _MODS
 from pygeodesy.units import Degrees, Easting, Float, Height, Height_, Meter2, Meter3, \
                             Northing, Radius_, Scalar
-from pygeodesy.utily import asin1
+from pygeodesy.utily import asin1, km2m, m2km,  _ValueError, _xkwds
 from pygeodesy.vector3d import _otherV3d, Vector3d
 
 # from math import fabs, sqrt  # from .fmath
 
 __all__ = _ALL_LAZY.triaxials_bases
-__version__ = '25.12.12'
+__version__ = '26.01.14'
 
 _bet_         = 'bet'  # PYCHOK shared
 _llk_         = 'llk'  # PYCHOK shared
@@ -112,21 +114,42 @@ class LLK(object):
     _NOIDAL   = (None, ELLIPSOIDAL)
 #   _XCLUDE   = (CONFORMAL, GEOGRAPHIC, PLANETOCENTRIC, PLANETODETIC)
 
+    def __getitem__(self, name):
+        llk = self.get(name, None)
+        if llk is None:
+            t = _MODS.internals.typename(self)
+            t = _MODS.streprs.Fmt.SQUARE(t, name)
+            raise _ValueError(t, name)
+        return llk
+
+    def get(self, name, dflt=None):
+        '''Get an C{LLK} by C{name}.
+        '''
+        llk = getattr(self, name, None)
+        return llk if isinstance(llk, _LLK) else dflt
+
     def items(self):
+        '''Yield all C{LLK (name, value)} pairs.
+        '''
         for n, llk in LLK.__class__.__dict__.items():
             if isinstance(llk, _LLK):
                 yield n, llk
 
     def keys(self):
+        '''Yield all C{LLK} names.
+        '''
         for n, _ in self.items():
             yield n
 
     def values(self):
+        '''Yield all C{LLK} values.
+        '''
         for _, llk in self.items():
             yield llk
 
-LLK = LLK()  # PYCHOK singleton
-# del _LLK
+if not _FOR_DOCS:  # PYCHOK force epydoc
+    LLK = LLK()  # singleton
+del _FOR_DOCS
 
 
 def _HeightINT0(h):
@@ -212,13 +235,6 @@ class _UnOrderedTriaxialBase(_NamedEnumItem):
         a, b, c = self._abc3
         return self.a2, self.b2, self.c2
 
-    @Property_RO
-    def _ab_elliperim(self):
-        '''(INTERNAL) Get C{ab} ellipse' perimeter.
-        '''
-        a, b, _ = self._abc3
-        return elliperim(a, b)
-
     @Property_RO
     def _a2c2(self):
         '''(INTERNAL) Get C{a**2 - c**2} == E_sub_x**2.
@@ -279,13 +295,6 @@ class _UnOrderedTriaxialBase(_NamedEnumItem):
         d = b - c
         return (d * (b + c)) if d else _0_0
 
-    @Property_RO
-    def _bc_elliperim(self):
-        '''(INTERNAL) Get C{bc} ellipse' perimeter.
-        '''
-        _, b, c = self._abc3
-        return elliperim(b, c)
-
     @Property_RO
     def c(self):
         '''Get the C{smallest, z} semi-axis (C{meter}, same units as B{C{a}}).
@@ -339,13 +348,13 @@ class _UnOrderedTriaxialBase(_NamedEnumItem):
 
     @property_ROver
     def _Ellipsoid(self):
-        '''(INTERNAL) Get class L{Ellipsoid}, I{once}.
+        '''(INTERNAL) Get class C{Ellipsoid}, I{once}.
         '''
         return _MODS.ellipsoids.Ellipsoid  # overwrite property_ROver
 
     @property_ROver
     def _Elliptic(self):
-        '''(INTERNAL) Get class L{Elliptic}, I{once}.
+        '''(INTERNAL) Get class C{Ellipsoid}, I{once}.
         '''
         return _MODS.elliptic.Elliptic  # overwrite property_ROver
 
@@ -355,15 +364,14 @@ class _UnOrderedTriaxialBase(_NamedEnumItem):
 
            @see: Function L{hartzell4<triaxials.triaxial5.hartzell4>} for further details.
         '''
-        return self._triaxials_triaxial5.hartzell4(pov, los=los, tri_biax=self, **name)
+        return _MODS.triaxials.hartzell4(pov, los=los, tri_biax=self, **name)
 
     def height4(self, x_xyz, y=None, z=None, normal=True, eps=EPS, **name):
         '''Compute the projection on and the height above or below this triaxial's surface.
 
            @see: Function L{height4<triaxials.triaxial5.height4>} for further details.
         '''
-        m = self._triaxials_triaxial5
-        return m.height4(x_xyz, y=y, z=z, tri_biax=self, normal=normal, eps=eps, **name)
+        return _MODS.triaxials.height4(x_xyz, y=y, z=z, tri_biax=self, normal=normal, eps=eps, **name)
 
     @Property_RO
     def isOrdered(self):
@@ -513,6 +521,27 @@ class _UnOrderedTriaxialBase(_NamedEnumItem):
         '''
         return self._kji if reverse else self._ijk
 
+    @Property_RO
+    def perimeter4ab(self):
+        '''Get the C{ab} ellipse' perimeter (C{scalar}).
+        '''
+        a, b, _ = self._abc3
+        return Float(perimeter4ab=_MODS.elliptic.elliperim(a, b))
+
+    @Property_RO
+    def perimeter4ac(self):
+        '''Get the C{ac} ellipse' perimeter (C{scalar}).
+        '''
+        a, _, c = self._abc3
+        return Float(perimeter4ac=_MODS.elliptic.elliperim(a, c))
+
+    @Property_RO
+    def perimeter4bc(self):
+        '''Get the C{bc} ellipse' perimeter (C{scalar}).
+        '''
+        _, b, c = self._abc3
+        return Float(perimeter4bc=_MODS.elliptic.elliperim(b, c))
+
     def _radialTo3(self, sbeta, cbeta, somega, comega):
         '''(INTERNAL) I{Unordered} helper for C{.height4}.
         '''
@@ -595,42 +624,24 @@ class _UnOrderedTriaxialBase(_NamedEnumItem):
            @return: This C{Triaxial}'s attributes (C{str}).
         '''
         T = _UnOrderedTriaxialBase
-        C =  self._triaxials_triaxial3.Triaxial3B
+        m = _MODS.triaxials
+        C =  m.Triaxial3B
         if isinstance(self, C):
-            t  =  T.b, C.e2, C.k2, C.kp2
+            t  = T.b, C.e2, C.k2, C.kp2
         else:
-            t  =  T.a,  # props
-            C  =  self._triaxials_triaxial5.ConformalSphere
+            t  = T.a,  # props
+            C  = m.ConformalSphere
             t += (C.ab, C.bc) if isinstance(self, C) else (T.b, T.c)
             C  = _Triaxial3Base
             t += (C.k2, C.kp2) if isinstance(self, C) else \
                  (T.e2ab, T.e2bc, T.e2ac)
-        for C in (self._triaxials_triaxial5.Conformal,
-                  self._triaxials_conformal3.Conformal3):
+        for C in (m.Conformal, m.Conformal3):
             if isinstance(self, C):
                 t += C.xyQ2,
                 break
         t += T.volume, T.area
         return self._instr(area_p=self.area_p(), prec=prec, props=t, **name)
 
-    @property_ROver
-    def _triaxials_conformal3(self):
-        '''(INTERNAL) Get module L{pygeodesy.triaxials.conformal3}, I{once}.
-        '''
-        return _MODS.triaxials.conformal3  # overwrite property_ROver
-
-    @property_ROver
-    def _triaxials_triaxial3(self):
-        '''(INTERNAL) Get module L{pygeodesy.triaxials.triaxial3}, I{once}.
-        '''
-        return _MODS.triaxials.triaxial3  # overwrite property_ROver
-
-    @property_ROver
-    def _triaxials_triaxial5(self):
-        '''(INTERNAL) Get module L{pygeodesy.triaxials.triaxial5}, I{once}.
-        '''
-        return _MODS.triaxials.triaxial5  # overwrite property_ROver
-
     @Property_RO
     def unOrdered(self):
         '''Is this triaxial I{un-ordered} and I{not spherical} (C{bool})?
@@ -693,7 +704,7 @@ class _OrderedTriaxialBase(_UnOrderedTriaxialBase):
                          aE.fF(r) * c2 / s)
             a  = Meter2(area=a * b * PI2)
         else:  # a == b > c
-            a  = self._Ellipsoid(a, b=c).areax
+            a  =  self._Ellipsoid(a, b=c).areax
         return a
 
     @Property_RO
@@ -827,7 +838,8 @@ class _Triaxial3Base(_OrderedTriaxialBase):
     @property_doc_(" longitude of the I{earth}'s major semi-axis C{a}, (L{Ang}), Karney's C{Triaxial_Earth_lon0}.")
     def Lon0(self):
         if self._Lon0 is None:
-            self.Lon0 = -(1493 / 100) if self.name.startswith('WGS84_3') else 0
+            WGS84_3 = self.name.startswith('WGS84_3')
+            self.Lon0 = -(1493 / 100) if WGS84_3 else 0
         return self._Lon0
 
     @Lon0.setter  # PYCHOK setter!
@@ -863,11 +875,52 @@ class _Triaxial3Base(_OrderedTriaxialBase):
 
 
 class TriaxialError(_ValueError):
-    '''Raised for any cartesian or conformal triaxial issues.
+    '''Raised for any triaxial issue.
     '''
     pass  # ...
 
 
+class _TriaxialsBase(_NamedEnum):
+    '''(INTERNAL) C{Triaxial*} registry, I{must} be a sub-class
+       to accommodate the L{_LazyNamedEnumItem} properties.
+    '''
+    _assert_kwds = {}    # like propertyROnce
+    _Triaxial    = None  # must be overloaded
+
+    def _Lazy(self, *abc, **name):
+        '''(INTERNAL) Instantiate the C{self._Triaxial}.
+        '''
+        return self._Triaxial(*abc, **name)
+
+    def _assert(self):  # PYCHOK signature
+        kwds = _TriaxialsBase._assert_kwds
+        if not kwds:
+            _lazy    = _MODS.named._lazyNamedEnumItem
+            EWGS84   = _MODS.ellipsoids._EWGS84
+            abc84_35 =  map1(m2km, EWGS84.a + 35, EWGS84.a - 35, EWGS84.b)
+            # <https://ArxIV.org/pdf/1909.06452.pdf> Table 1 Semi-axes in Km
+            # <https://www.JPS.NASA.gov/education/images/pdf/ss-moons.pdf>
+            # <https://link.Springer.com/article/10.1007/s00190-022-01650-9>
+            # <https://GeographicLib.SourceForge.io/C++/doc/classGeographicLib_1_1Constants.html>
+            for n, abc in dict(  # a (Km)       b (Km)      c (Km)       planet
+                      Amalthea= (125.0,        73.0,       64.0),      # Jupiter
+                      Ariel=    (581.1,       577.9,      577.7),      # Uranus
+                      Earth=   (6378.173435, 6378.1039,  6356.7544),
+                      Enceladus=(256.6,       251.4,      248.3),      # Saturn
+                      Europa=  (1564.13,     1561.23,    1560.93),     # Jupiter
+                      Io=      (1829.4,      1819.3,     1815.7),      # Jupiter
+                      Mars=    (3394.6,      3393.3,     3376.3),
+                      Mimas=    (207.4,       196.8,      190.6),      # Saturn
+                      Miranda=  (240.4,       234.2,      232.9),      # Uranus
+                      Moon=    (1735.55,     1735.324,   1734.898),    # Earth
+                      Tethys=   (535.6,       528.2,      525.8),      # Saturn
+                      WGS84_3= (6378.17136,  6378.10161, 6356.75184),  # C++
+                      WGS84_3r=(6378.172,    6378.102,   6356.752),    # C++, rounded
+                      WGS84_35=abc84_35).items():
+                kwds[n] = _lazy(n, *map(km2m, abc))
+        _NamedEnum._assert(self, **kwds)
+
+
 def _getitems(items, *indices):
     '''(INTERNAL) Get the C{items} at the given I{indices}.