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

pygeodesy/heights.py

@@ -78,8 +78,8 @@ from pygeodesy.errors import _AssertionError, LenError, PointsError, \
 #                             cosineLaw, equirectangular4, euclidean, flatLocal, \
 #                             flatPolar, haversine, thomas, vincentys  # _MODS.into
 # from pygeodesy.internals import _version2  # _MODS
-from pygeodesy.interns import NN, _COMMASPACE_, _cubic_, _insufficient_, _linear_, \
-                             _NOTEQUAL_, _PLUS_, _scipy_, _SPACE_, _STAR_
+from pygeodesy.interns import NN, _COMMASPACE_, _insufficient_, _NOTEQUAL_, \
+                             _PLUS_, _scipy_, _SPACE_, _STAR_
 from pygeodesy.lazily import _ALL_DOCS, _ALL_LAZY, _ALL_MODS as _MODS, _FOR_DOCS
 from pygeodesy.named import _name2__, _Named
 from pygeodesy.points import _distanceTo, LatLon_,  Fmt, radians, _Wrap
@@ -91,12 +91,12 @@ from pygeodesy.units import _isDegrees, Float_, Int_
 # from math import radians  # from .points
 
 __all__ = _ALL_LAZY.heights
-__version__ = '24.07.25'
+__version__ = '24.08.24'
 
-_error_     = 'error'
-_formy      = _MODS.into(formy=__name__)
-_llis_      = 'llis'
-_smoothing_ = 'smoothing'
+_error_  = 'error'
+_formy   = _MODS.into(formy=__name__)
+_linear_ = 'linear'
+_llis_   = 'llis'
 
 
 class HeightError(PointsError):
@@ -144,26 +144,11 @@ def _as_llis2(llis, m=1, Error=HeightError):  # in .geoids
         _as = _atuple  # return tuple of interpolated heights
 
     if n < m:
-        raise _insufficientError(m, Error=Error, llis=n)
+        raise _InsufficientError(m, Error=Error, llis=n)
     return _as, llis
 
 
-def _height_called(inst, lats, lons, Error=HeightError, **wrap):  # in .geoids
-    LLis, d = inst._LLis, inst.datum
-    if _isDegrees(lats) and _isDegrees(lons):
-        llis = LLis(lats, lons, datum=d)
-    else:
-        n, lats = len2(lats)
-        m, lons = len2(lons)
-        if n != m:
-            # format a LenError, but raise an Error
-            e = LenError(inst.__class__, lats=n, lons=m, txt=None)
-            raise e if Error is LenError else Error(str(e))
-        llis = [LLis(*t, datum=d) for t in zip(lats, lons)]
-    return inst(llis, **wrap)  # __call__(lli) or __call__(llis)
-
-
-def _insufficientError(need, Error=HeightError, **name_value):  # PYCHOK no cover
+def _InsufficientError(need, Error=HeightError, **name_value):  # PYCHOK no cover
     # create an insufficient Error instance
     t = _COMMASPACE_(_insufficient_, str(need) + _PLUS_)
     return Error(txt=t, **name_value)
@@ -171,39 +156,48 @@ def _insufficientError(need, Error=HeightError, **name_value):  # PYCHOK no cove
 
 def _orderedup(ts, lo=EPS, hi=PI2-EPS):
     # clip, order and remove duplicates
-    # p = 0
-    # for k in sorted(max(lo, min(hi, t)) for t in ts):
-    #     if k > p:
-    #         yield k
-    #         p = k
     return sorted(set(max(lo, min(hi, t)) for t in ts))  # list
 
 
-def _xyhs(wrap=False, **name_lls):
+def _xyhs(wrap=False, _lat=_90_0, _lon=_180_0, **name_lls):
     # map (lat, lon, h) to (x, y, h) in radians, offset
     # x as 0 <= lon <= PI2 and y as 0 <= lat <= PI
     name, lls = _xkwds_item2(name_lls)
-    _0, _90, _180 = _0_0, _90_0,    _180_0
-    _m, _r,  _w   =  max,  radians, _Wrap._latlonop(wrap)
+    _r,  _w   =  radians, _Wrap._latlonop(wrap)
     try:
         for i, ll in enumerate(lls):
             y, x = _w(ll.lat, ll.lon)
-            yield _m(_0, _r(x + _180)), \
-                  _m(_0, _r(y +  _90)), ll.height
+            yield max(_0_0, _r(x + _lon)), \
+                  max(_0_0, _r(y + _lat)), ll.height
     except Exception as e:
         i = Fmt.INDEX(name, i)
         raise HeightError(i, ll, cause=e)
 
 
-class _HeightBase(_Named):  # in .geoids
+class _HeightNamed(_Named):  # in .geoids
     '''(INTERNAL) Interpolator base class.
     '''
     _datum = _WGS84    # default
+    _Error =  HeightError
     _kmin  =  2        # min number of knots
+
     _LLis  =  LatLon_  # ._height class
     _np_sp =  None     # (numpy, scipy)
     _wrap  =  None     # wrap knots and llis
 
+    def _as_lls(self, lats, lons):  # in .geoids
+        LLis, d = self._LLis, self.datum
+        if _isDegrees(lats) and _isDegrees(lons):
+            llis = LLis(lats, lons, datum=d)
+        else:
+            n, lats = len2(lats)
+            m, lons = len2(lons)
+            if n != m:  # format a LenError, but raise self._Error
+                e = LenError(self.__class__, lats=n, lons=m, txt=None)
+                raise self._Error(str(e))
+            llis = [LLis(*t, datum=d) for t in zip(lats, lons)]
+        return llis
+
     @property_RO
     def datum(self):
         '''Get the C{datum} setting or the default (L{Datum}).
@@ -223,9 +217,14 @@ class _HeightBase(_Named):  # in .geoids
         return self._wrap
 
 
-class _HeightsBase(_HeightBase):  # in .geoids
+class _HeightBase(_HeightNamed):  # in .geoids
     '''(INTERNAL) Interpolator base class.
     '''
+    _k2interp2d = {-1: _linear_,  # in .geoids._GeoidBase.__init__
+                   -2: _linear_,  # for backward compatibility
+                   -3: 'cubic',
+                   -5: 'quintic'}
+
     def __call__(self, *llis, **wrap):  # PYCHOK no cover
         '''Interpolate the height for one or several locations.  I{Must be overloaded}.
 
@@ -259,12 +258,29 @@ class _HeightsBase(_HeightBase):  # in .geoids
         '''(INTERNAL) I{Must be overloaded}.'''
         self._notOverloaded(*args)
 
-    def _eval(self, llis, **wrap):  # XXX single arg, not *args
+    def _evalls(self, llis, **wrap):  # XXX single arg, not *args
         _as, xis, yis, _ = self._as_xyllis4(llis, **wrap)
         try:  # SciPy .ev signature: y first, then x!
             return _as(self._ev(yis, xis))
         except Exception as x:
-            raise _SciPyIssue(x)
+            raise _SciPyIssue(x, self._ev_name)
+
+    def _ev2d(self, x, y):  # PYCHOK no cover
+        '''(INTERNAL) I{Must be overloaded}.'''
+        self._notOverloaded(x, y)
+
+    @property_RO
+    def _ev_name(self):
+        '''(INTERNAL) Get the name of the C{.ev} method.
+        '''
+        _ev = str(self._ev)
+        if _scipy_ not in _ev:
+            _ev = str(self._ev2d)
+        # '<scipy.interpolate._interpolate.interp2d object at ...>
+        # '<function _HeightBase._interp2d.<locals>._bisplev at ...>
+        # '<bound method BivariateSpline.ev of ... object at ...>
+        _ev = _ev[1:].split(None, 4)
+        return Fmt.PAREN(_ev['sfb'.index(_ev[0][0])])
 
     def height(self, lats, lons, **wrap):  # PYCHOK no cover
         '''Interpolate the height for one or several lat-/longitudes.  I{Must be overloaded}.
@@ -285,7 +301,35 @@ class _HeightsBase(_HeightBase):  # in .geoids
 
            @raise SciPyWarning: A C{scipy} warning as exception.
         '''
-        self._notOverloaded(lats, lons, **wrap)
+        lls = self._as_lls(lats, lons)
+        return self(lls, **wrap)  # __call__(ll) or __call__(lls)
+
+    def _interp2d(self, xs, ys, hs, kind=-3):
+        '''Create a C{scipy.interpolate.interp2d} or C{-.bisplrep/-ev}
+           interpolator before, respectively since C{SciPy} version 1.14.
+        '''
+        try:
+            spi = self.scipy_interpolate
+            if self._scipy_version() < (1, 14) and kind in self._k2interp2d:
+                # SciPy.interpolate.interp2d kind 'linear', 'cubic' or 'quintic'
+                # DEPRECATED since scipy 1.10, removed altogether in 1.14
+                self._ev2d = spi.interp2d(xs, ys, hs, kind=self._k2interp2d[kind])
+
+            else:  # <https://scipy.GitHub.io/devdocs/tutorial/interpolate/interp_transition_guide.html>
+                k = self._kxky(abs(kind))
+                # spi.RectBivariateSpline needs strictly ordered xs and ys
+                r = spi.bisplrep(xs, ys, hs.T, kx=k, ky=k)
+
+                def _bisplev(x, y):
+                    return spi.bisplev(x, y, r)  # .T
+
+                self._ev2d = _bisplev
+
+        except Exception as x:
+            raise _SciPyIssue(x, self._ev_name)
+
+    def _kxky(self, kind):
+        return Int_(kind=kind, low=1, high=5, Error=self._Error)
 
     def _np_sp2(self, throwarnings=False):  # PYCHOK no cover
         '''(INTERNAL) Import C{numpy} and C{scipy}, once.
@@ -329,85 +373,60 @@ class _HeightsBase(_HeightBase):  # in .geoids
         xs, ys, hs = zip(*_xyhs(knots=knots, wrap=wrap))  # PYCHOK yield
         n = len(hs)
         if n < self.kmin:
-            raise _insufficientError(self.kmin, knots=n)
+            raise _InsufficientError(self.kmin, knots=n)
         if name:
             self.name = name
         return map1(self.numpy.array, xs, ys, hs)
 
 
-class HeightCubic(_HeightsBase):
+class HeightCubic(_HeightBase):
     '''Height interpolator based on C{SciPy} U{interp2d<https://docs.SciPy.org/
        doc/scipy/reference/generated/scipy.interpolate.interp2d.html>}
-       C{kind='cubic'}.
+       C{kind='cubic'} or U{bisplrep/-ev<https://docs.SciPy.org/doc/scipy/
+       reference/generated/scipy.interpolate.interp2d.html>} C{kx=ky=3}.
     '''
-    _interp2d =  None
-    _kind     = _cubic_
-    _kmin     =  16
+    _kind = -3
+    _kmin =  16
 
     def __init__(self, knots, **name_wrap):
         '''New L{HeightCubic} interpolator.
 
            @arg knots: The points with known height (C{LatLon}s).
-           @kwarg name_wrap: Optional C{B{name}=NN} for this height interpolator
-                       (C{str}) and keyword argument C{b{wrap}=False} to wrap or
-                       I{normalize} all B{C{knots}} and B{C{llis}} locations iff
-                       C{True} (C{bool}).
+           @kwarg name_wrap: Optional C{B{name}=NN} for this height interpolator (C{str})
+                       and keyword argument C{b{wrap}=False} to wrap or I{normalize} all
+                       B{C{knots}} and B{C{llis}} locations iff C{True} (C{bool}).
 
-           @raise HeightError: Insufficient number of B{C{knots}} or
-                               invalid B{C{knot}}.
+           @raise HeightError: Insufficient number of B{C{knots}} or invalid B{C{knot}}.
 
-           @raise ImportError: Package C{numpy} or C{scipy} not found
-                               or not installed.
+           @raise ImportError: Package C{numpy} or C{scipy} not found or not installed.
 
-           @raise SciPyError: A C{scipy.interpolate.interp2d} issue.
+           @raise SciPyError: A C{scipy} issue.
 
-           @raise SciPyWarning: A C{scipy.interpolate.interp2d} warning
-                                as exception.
+           @raise SciPyWarning: A C{scipy} warning as exception.
         '''
-        spi = self.scipy_interpolate
-
-        xs, ys, hs = self._xyhs3(knots, **name_wrap)
-        try:  # SciPy.interpolate.interp2d kind 'linear' or 'cubic'
-            self._interp2d = spi.interp2d(xs, ys, hs, kind=self._kind)
-        except Exception as x:
-            raise _SciPyIssue(x)
+        xs_yx_hs = self._xyhs3(knots, **name_wrap)
+        self._interp2d(*xs_yx_hs, kind=self._kind)
 
     def __call__(self, *llis, **wrap):
         '''Interpolate the height for one or several locations.
 
-           @raise SciPyError: A C{scipy.interpolate.interp2d} issue.
-
-           @raise SciPyWarning: A C{scipy.interpolate.interp2d} warning
-                                as exception.
-
-           @see: L{Here<_HeightsBase.__call__>} for further details.
+           @see: L{Here<_HeightBase.__call__>} for further details.
         '''
-        return _HeightsBase._eval(self, llis, **wrap)
+        return self._evalls(llis, **wrap)
 
-    def _ev(self, yis, xis):  # PYCHOK expected
-        # to make SciPy .interp2d signature(x, y), single (x, y)
+    def _ev(self, yis, xis):  # PYCHOK overwritten with .RectBivariateSpline.ev
+        # to make SciPy .interp2d single (x, y) signature
         # match SciPy .ev signature(ys, xs), flipped multiples
-        return map(self._interp2d, xis, yis)
-
-    def height(self, lats, lons, **wrap):
-        '''Interpolate the height for one or several lat-/longitudes.
-
-           @raise SciPyError: A C{scipy.interpolate.interp2d} issue.
-
-           @raise SciPyWarning: A C{scipy.interpolate.interp2d} warning
-                                as exception.
-
-           @see: L{Here<_HeightsBase.height>} for further details.
-        '''
-        return _height_called(self, lats, lons, **wrap)
+        return map(self._ev2d, xis, yis)
 
 
 class HeightLinear(HeightCubic):
     '''Height interpolator based on C{SciPy} U{interp2d<https://docs.SciPy.org/
        doc/scipy/reference/generated/scipy.interpolate.interp2d.html>}
-       C{kind='linear'}.
+       C{kind='linear'} or U{bisplrep/-ev<https://docs.SciPy.org/doc/scipy/
+       reference/generated/scipy.interpolate.interp2d.html>} C{kx=ky=1}.
     '''
-    _kind = _linear_
+    _kind = -1
     _kmin =  2
 
     def __init__(self, knots, **name_wrap):
@@ -422,7 +441,7 @@ class HeightLinear(HeightCubic):
         height   = HeightCubic.height
 
 
-class HeightLSQBiSpline(_HeightsBase):
+class HeightLSQBiSpline(_HeightBase):
     '''Height interpolator using C{SciPy} U{LSQSphereBivariateSpline
        <https://docs.SciPy.org/doc/scipy/reference/generated/scipy.
        interpolate.LSQSphereBivariateSpline.html>}.
@@ -446,13 +465,12 @@ class HeightLSQBiSpline(_HeightsBase):
 
            @raise LenError: Unequal number of B{C{knots}} and B{C{weight}}s.
 
-           @raise ImportError: Package C{numpy} or C{scipy} not found or
-                               not installed.
+           @raise ImportError: Package C{numpy} or C{scipy} not found or not
+                               installed.
 
-           @raise SciPyError: A C{scipy} C{LSQSphereBivariateSpline} issue.
+           @raise SciPyError: A C{scipy} issue.
 
-           @raise SciPyWarning: A C{scipy} C{LSQSphereBivariateSpline}
-                                warning as exception.
+           @raise SciPyWarning: A C{scipy} warning as exception.
         '''
         np  = self.numpy
         spi = self.scipy_interpolate
@@ -465,7 +483,7 @@ class HeightLSQBiSpline(_HeightsBase):
             w = float(w)
             if w <= 0:
                 raise HeightError(weight=w)
-            w = [w] * n
+            w = (w,) * n
         elif w is not None:
             m, w = len2(w)
             if m != n:
@@ -483,34 +501,17 @@ class HeightLSQBiSpline(_HeightsBase):
             self._ev = spi.LSQSphereBivariateSpline(ys, xs, hs,
                                                     ts, ps, eps=EPS, w=w).ev
         except Exception as x:
-            raise _SciPyIssue(x)
+            raise _SciPyIssue(x, self._ev_name)
 
     def __call__(self, *llis, **wrap):
         '''Interpolate the height for one or several locations.
 
-           @raise SciPyError: A C{scipy} C{LSQSphereBivariateSpline} issue.
-
-           @raise SciPyWarning: A C{scipy} C{LSQSphereBivariateSpline}
-                                warning as exception.
-
-           @see: L{Here<_HeightsBase.__call__>} for further details.
+           @see: L{Here<_HeightBase.__call__>} for further details.
         '''
-        return _HeightsBase._eval(self, llis, **wrap)
-
-    def height(self, lats, lons, **wrap):
-        '''Interpolate the height for one or several lat-/longitudes.
-
-           @raise SciPyError: A C{scipy} C{LSQSphereBivariateSpline} issue.
+        return self._evalls(llis, **wrap)
 
-           @raise SciPyWarning: A C{scipy} C{LSQSphereBivariateSpline}
-                                warning as exception.
 
-           @see: L{Here<_HeightsBase.height>} for further details.
-        '''
-        return _height_called(self, lats, lons, **wrap)
-
-
-class HeightSmoothBiSpline(_HeightsBase):
+class HeightSmoothBiSpline(_HeightBase):
     '''Height interpolator using C{SciPy} U{SmoothSphereBivariateSpline
        <https://docs.SciPy.org/doc/scipy/reference/generated/scipy.
        interpolate.SmoothSphereBivariateSpline.html>}.
@@ -527,54 +528,36 @@ class HeightSmoothBiSpline(_HeightsBase):
                        I{normalize} all B{C{knots}} and B{C{llis}} locations iff
                        C{True} (C{bool}).
 
-           @raise HeightError: Insufficient number of B{C{knots}} or
-                               an invalid B{C{knot}} or B{C{s}}.
+           @raise HeightError: Insufficient number of B{C{knots}} or an invalid
+                               B{C{knot}} or B{C{s}}.
 
            @raise ImportError: Package C{numpy} or C{scipy} not found or not
                                installed.
 
-           @raise SciPyError: A C{scipy} C{SmoothSphereBivariateSpline} issue.
+           @raise SciPyError: A C{scipy} issue.
 
-           @raise SciPyWarning: A C{scipy} C{SmoothSphereBivariateSpline}
-                                warning as exception.
+           @raise SciPyWarning: A C{scipy} warning as exception.
         '''
         spi = self.scipy_interpolate
 
-        s = Float_(s, name=_smoothing_, Error=HeightError, low=4)
+        s = Float_(smoothing=s, Error=HeightError, low=4)
 
         xs, ys, hs = self._xyhs3(knots, **name_wrap)
         try:
             self._ev = spi.SmoothSphereBivariateSpline(ys, xs, hs,
                                                        eps=EPS, s=s).ev
         except Exception as x:
-            raise _SciPyIssue(x)
+            raise _SciPyIssue(x, self._ev_name)
 
     def __call__(self, *llis, **wrap):
         '''Interpolate the height for one or several locations.
 
-           @raise SciPyError: A C{scipy} C{SmoothSphereBivariateSpline} issue.
-
-           @raise SciPyWarning: A C{scipy} C{SmoothSphereBivariateSpline}
-                                warning as exception.
-
-           @see: L{Here<_HeightsBase.__call__>} for further details.
-        '''
-        return _HeightsBase._eval(self, llis, **wrap)
-
-    def height(self, lats, lons, **wrap):
-        '''Interpolate the height for one or several lat-/longitudes.
-
-           @raise SciPyError: A C{scipy} C{SmoothSphereBivariateSpline} issue.
-
-           @raise SciPyWarning: A C{scipy} C{SmoothSphereBivariateSpline}
-                                warning as exception.
-
-           @see: L{Here<_HeightsBase.height>} for further details.
+           @see: L{Here<_HeightBase.__call__>} for further details.
         '''
-        return _height_called(self, lats, lons, **wrap)
+        return self._evalls(llis, **wrap)
 
 
-class _HeightIDW(_HeightBase):
+class _HeightIDW(_HeightNamed):
     '''(INTERNAL) Base class for U{Inverse Distance Weighting
        <https://WikiPedia.org/wiki/Inverse_distance_weighting>} (IDW) height
        interpolators.
@@ -608,7 +591,7 @@ class _HeightIDW(_HeightBase):
 
         n, self._knots = len2(knots)
         if n < self.kmin:
-            raise _insufficientError(self.kmin, knots=n)
+            raise _InsufficientError(self.kmin, knots=n)
         self.beta  = beta
         self._kwds = kwds or {}
 
@@ -684,6 +667,16 @@ class _HeightIDW(_HeightBase):
             i = Fmt.INDEX(knots=i)
             raise HeightError(i, k, cause=e)
 
+    def _distancesTo(self, _To):
+        '''(INTERNAL) Yield distances C{_To}.
+        '''
+        try:
+            for i, k in enumerate(self._knots):
+                yield _To(k)
+        except Exception as e:
+            i = Fmt.INDEX(knots=i)
+            raise HeightError(i, k, cause=e)
+
     def height(self, lats, lons, **wrap):
         '''Interpolate the height for one or several lat-/longitudes.
 
@@ -698,7 +691,8 @@ class _HeightIDW(_HeightBase):
            @raise HeightError: Insufficient or non-matching number of B{C{lats}}
                                and B{C{lons}} or a L{pygeodesy.fidw} issue.
         '''
-        return _height_called(self, lats, lons, **wrap)
+        lls = self._as_lls(lats, lons)
+        return self(lls, **wrap)  # __call__(ll) or __call__(lls)
 
     @Property_RO
     def _heights(self):
@@ -851,7 +845,7 @@ class HeightIDWdistanceTo(_HeightIDW):
         _HeightIDW.__init__(self, knots, beta=beta, **name__distanceTo_kwds)
         ks0 = _distanceTo(HeightError, knots=self._knots)[0]
         # use knots[0] class and datum to create compatible points
-        # in _height_called instead of class LatLon_ and datum None
+        # in ._as_lls instead of class LatLon_ and datum None
         self._datum = ks0.datum
         self._LLis  = ks0.classof  # type(ks0)
 
@@ -859,12 +853,11 @@ class HeightIDWdistanceTo(_HeightIDW):
         '''(INTERNAL) Yield distances to C{(x, y)}.
         '''
         kwds, ll = self._kwds, self._LLis(y, x)
-        try:
-            for i, k in enumerate(self._knots):
-                yield k.distanceTo(ll, **kwds)
-        except Exception as e:
-            i = Fmt.INDEX(knots=i)
-            raise HeightError(i, k, cause=e)
+
+        def _To(k):
+            return k.distanceTo(ll, **kwds)
+
+        return self._distancesTo(_To)
 
     if _FOR_DOCS:
         __call__ = _HeightIDW.__call__
@@ -892,12 +885,11 @@ class HeightIDWequirectangular(_HeightIDW):
         '''(INTERNAL) Yield distances to C{(x, y)}.
         '''
         _f, kwds = _formy.equirectangular4, self._kwds
-        try:
-            for i, k in enumerate(self._knots):
-                yield _f(y, x, k.lat, k.lon, **kwds).distance2
-        except Exception as e:
-            i = Fmt.INDEX(knots=i)
-            raise HeightError(i, k, cause=e)
+
+        def _To(k):
+            return _f(y, x, k.lat, k.lon, **kwds).distance2
+
+        return self._distancesTo(_To)
 
     if _FOR_DOCS:
         __call__ = _HeightIDW.__call__
@@ -1114,7 +1106,7 @@ class HeightIDWvincentys(_HeightIDW):
         height   = _HeightIDW.height
 
 
-__all__ += _ALL_DOCS(_HeightBase, _HeightIDW, _HeightsBase)
+__all__ += _ALL_DOCS(_HeightBase, _HeightIDW, _HeightNamed)
 
 # **) MIT License
 #

pygeodesy/internals.py

@@ -18,6 +18,7 @@ _0_0      =  0.0  # PYCHOK in .basics, .constants
 _arm64_   = 'arm64'
 _iOS_     = 'iOS'
 _macOS_   = 'macOS'
+_SIsecs   = 'fs', 'ps', 'ns', 'us', 'ms', 'sec'  # reversed
 _Windows_ = 'Windows'
 
 
@@ -206,6 +207,13 @@ class _MODS_Base(object):
             l3.insert(0, pypy)
         return l3
 
+    @_Property_RO
+    def _Str_Bytes(self):
+        '''Get all C{str} and C{bytes} types.
+        '''
+        import pygeodesy.basics as m
+        return m._Strs + m._Bytes  # + (range, map)
+
     @_Property_RO
     def streprs(self):
         '''Get module C{pygeodesy.streprs}, I{once}.
@@ -253,6 +261,12 @@ def _enquote(strs, quote=_QUOTE2_, white=NN):  # in .basics, .solveBase
     return strs
 
 
+def _fper(p, q, per=100.0, prec=1):
+    '''Format a percentage C{B{p} * B{per} / B{q}} (C{str}).
+    '''
+    return '%.*f%%' % (prec, (float(p) * per / float(q)))
+
+
 def _headof(name):
     '''(INTERNAL) Get the head name of qualified C{name} or the C{name}.
     '''
@@ -291,6 +305,13 @@ def _isNix():  # in test/bases.py
     return _MODS.nix2[0]
 
 
+def _isPyChecker():
+    '''(INTERNAL) Is C{PyChecker} running? (C{bool}).
+    '''
+    # .../pychecker/checker.py --limit 0 --stdlib pygeodesy/<mod>/<name>.py
+    return _sys.argv[0].endswith('/pychecker/checker.py')
+
+
 def _isPyPy():  # in test/bases.py
     '''(INTERNAL) Is this C{PyPy}? (C{bool})
     '''
@@ -342,12 +363,30 @@ def machine():
     return _MODS.bits_machine2[1]
 
 
+def _Math_K_2():
+    '''(INTERNAL) Return the I{Karney} Math setting.
+    '''
+    return _MODS.karney._wrapped.Math_K_2
+
+
 def _name_version(pkg):
     '''(INTERNAL) Return C{pskg.__name__ + ' ' + .__version__}.
     '''
     return _SPACE_(pkg.__name__, pkg.__version__)
 
 
+def _name_binary(path):
+    '''(INTERNAL) Return C{(basename + ' ' + version)} of an executable.
+    '''
+    if path:
+        try:
+            _, r = _MODS.solveBase._popen2((path, '--version'))
+            return _SPACE_(_os_path.basename(path), r.split()[-1])
+        except (IndexError, IOError, OSError):
+            pass
+    return NN
+
+
 def _osversion2(sep=NN):  # in .lazily, test/bases.versions
     '''(INTERNAL) Get the O/S name and release as C{2-list} or C{str}.
     '''
@@ -443,15 +482,36 @@ def _Pythonarchine(sep=NN):  # in .lazily, test/bases.py versions
     return sep.join(l3) if sep else l3  # 3- or 4-list
 
 
-def _sizeof(obj):
+def _secs2str(secs):  # in .geoids, ../test/bases.py
+    '''Convert a time in C{secs} to C{str}.
+    '''
+    if secs < _MODS.constants._100_0:
+        unit = len(_SIsecs) - 1
+        while 0 < secs < 1 and unit > 0:
+            secs *= 1e3  # _1000_0
+            unit -= 1
+        t = '%.3f %s' % (secs, _SIsecs[unit])
+    else:
+        m, s = divmod(secs, 60)
+        if m < 60:
+            t = '%d:%06.3f' % (int(m), s)
+        else:
+            h, m = divmod(int(m), 60)
+            t = '%d:%02d:%06.3f' % (h, m, s)
+    return t
+
+
+def _sizeof(obj, deep=True):
     '''(INTERNAL) Recursively size an C{obj}ect.
 
-       @return: The C{obj} size in bytes (C{int}),
-                ignoring class attributes and
-                counting duplicates only once or
-                C{None}.
+       @kwarg deep: If C{True}, include the size of all
+                    C{.__dict__.values()} (C{bool}).
 
-       @note: With C{PyPy}, the size is always C{None}.
+       @return: The C{obj} size in bytes (C{int}), ignoring
+                class attributes and counting instances only
+                once or C{None}.
+
+       @note: With C{PyPy}, the returned size is always C{None}.
     '''
     try:
         _zB = _sys.getsizeof
@@ -471,9 +531,10 @@ def _sizeof(obj):
                 if isinstance(o, dict):
                     z += _zR(s, o.keys())
                     z += _zR(s, o.values())
-                elif _isiterablen(o):  # not map, ...
+                elif _isiterablen(o) and not \
+                      isinstance(o, _MODS._Str_Bytes):
                     z += _zR(s, o)
-                else:
+                elif deep:
                     try:  # size instance' attr values only
                         z += _zR(s, o.__dict__.values())
                     except AttributeError:  # None, int, etc.
@@ -591,7 +652,7 @@ def _versions(sep=_SPACE_):
 
 
 __all__ = tuple(map(_dunder_nameof, (machine, print_, printf)))
-__version__ = '24.08.01'
+__version__ = '24.09.04'
 
 if _dunder_ismain(__name__):  # PYCHOK no cover