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

pygeodesy/fmath.py

@@ -10,8 +10,8 @@ from __future__ import division as _; del _  # noqa: E702 ;
 from pygeodesy.basics import _copysign, copysign0, isbool, isint, isodd, \
                               isscalar, len2, map1, _xiterable,  typename
 from pygeodesy.constants import EPS0, EPS02, EPS1, NAN, PI, PI_2, PI_4, \
-                               _0_0, _0_125, _0_25, _0_5, _1_0, _1_5, \
-                               _copysign_0_0, isfinite, remainder
+                               _0_0, _0_125, _0_25, _1_3rd, _0_5, _2_3rd, \
+                               _1_0, _1_5, _copysign_0_0, isfinite, remainder
 from pygeodesy.errors import _IsnotError, LenError, _TypeError, _ValueError, \
                              _xError, _xkwds, _xkwds_pop2, _xsError
 from pygeodesy.fsums import _2float, Fsum, fsum, _isFsum_2Tuple,  Fmt, unstr
@@ -22,16 +22,14 @@ from pygeodesy.lazily import _ALL_LAZY, _ALL_MODS as _MODS
 from pygeodesy.units import Int_, _isHeight, _isRadius
 
 from math import fabs, sqrt  # pow
-import operator as _operator  # in .datums, .trf, .utm
+import operator as _operator  # in .datums, .elliptic, .trf, .utm
 
 __all__ = _ALL_LAZY.fmath
-__version__ = '25.12.02'
+__version__ = '26.01.06'
 
 # sqrt(2) - 1 <https://WikiPedia.org/wiki/Square_root_of_2>
 _0_4142  =  0.41421356237309504880  # ~ 3_730_904_090_310_553 / 9_007_199_254_740_992
-_1_3rd   = _1_0 / 3
-_1_6th   = _1_0 / 6
-_2_3rd   = _1_3rd * 2
+_1_6th   =  1 / 6
 _h_lt_b_ = 'abs(h) < abs(b)'
 
 
@@ -1049,7 +1047,7 @@ def sqrt3(x):
 
 
 def sqrt_a(h, b):
-    '''Compute C{I{a}} side of a right-angled triangle from
+    '''Compute the C{I{a}} side of a right-angled triangle from
        C{sqrt(B{h}**2 - B{b}**2)}.
 
        @arg h: Hypotenuse or outer annulus radius (C{scalar}).

pygeodesy/formy.py

@@ -11,7 +11,7 @@ from pygeodesy.basics import _copysign, _isin  # _args_kwds_count2
 from pygeodesy.constants import EPS, EPS0, EPS1, PI, PI2, PI3, PI_2, R_M, \
                                _0_0s, float0_, isnon0, remainder, _umod_PI2, \
                                _0_0, _0_125, _0_25, _0_5, _1_0, _2_0, _4_0, \
-                               _90_0, _180_0, _360_0, MANT_DIG as _DIG53
+                               _90_0, _180_0, _360_0
 from pygeodesy.datums import Datum, Ellipsoid, _ellipsoidal_datum, \
                             _mean_radius, _spherical_datum, _WGS84,  _EWGS84
 # from pygeodesy.ellipsoids import Ellipsoid, _EWGS84  # from .datums
@@ -23,7 +23,8 @@ from pygeodesy.fsums import fsumf_,  Fmt, unstr
 # from pygeodesy.internals import typename  # from .named
 from pygeodesy.interns import _delta_, _distant_, _inside_, _SPACE_, _too_
 from pygeodesy.lazily import _ALL_LAZY, _ALL_MODS as _MODS
-from pygeodesy.named import _name__, _name2__, _NamedTuple, _xnamed,  typename
+from pygeodesy.named import _name__, _name2__, _NamedTuple, _xnamed, \
+                             typename
 from pygeodesy.namedTuples import Bearing2Tuple, Distance4Tuple, LatLon2Tuple, \
                                   Intersection3Tuple, PhiLam2Tuple
 # from pygeodesy.streprs import Fmt, unstr  # from .fsums
@@ -42,11 +43,10 @@ from contextlib import contextmanager
 from math import atan, cos, degrees, fabs, radians, sin, sqrt  # pow
 
 __all__ = _ALL_LAZY.formy
-__version__ = '25.12.12'
+__version__ = '26.01.06'
 
 _RADIANS2 =  radians(_1_0)**2  # degree to radians-squared
 _ratio_   = 'ratio'
-_TOL53    =  sqrt(pow(_0_5, _DIG53))  # elliperim
 _xline_   = 'xline'
 
 
@@ -368,107 +368,6 @@ def _dS(fun_, radius, wrap, *lls, **adjust):
     return r * radius
 
 
-def elliperim(a, b):
-    '''Compute the perimeter of an ellipse with semi-axes C{a} and C{b} using U{SciPy's
-       ellipe<https://www.JohnDCook.com/perimeter_ellipse.html>} function or the U{AGM
-       <https://PaulBourke.net/geometry/ellipsecirc>} (Arithmetic Geometric Mean) method.
-
-       @return: The perimeter (C{scalar}, same units as C{a} and C{b}).
-    '''
-    if a < b:
-        a, b = b, a
-    if 0 < b < a:
-        try:
-            from scipy.special import ellipe
-            a *= float(ellipe(_1_0 - (b / a)**2)) * _4_0
-        except (AttributeError, ImportError):
-            # relative accuracy is about _TOL53**2
-            if (b * _DIG53) > (a * _TOL53):
-                c = a + b
-                d = a - b
-                m, s = -1, [c**2]
-                _s = s.append
-                while d > (b * _TOL53) and len(s) < 32:  # 4..5 trips
-                    b  = sqrt(a * b)
-                    a  = c * _0_5
-                    c  = a + b
-                    d  = a - b
-                    m *= 2
-                    _s(m * d**2)
-                a = fsumf_(*s) * PI / c
-            else:  # near flat
-                a *= _4_0
-    elif b < 0:
-        raise _ValueError(unstr(elliperim, a, b))
-    else:  # circle or flat
-        a *= PI2 if b else _4_0
-    return a
-
-
-# def elliperimR2(a, b):
-#     '''Compute the perimeter of an ellipse with semi-axes C{a} and C{b} using
-#        Ramanujan's U{2nd approximation<https://PaulBourke.net/geometry/ellipsecirc>}.
-#     '''
-#     if a < 0 or b < 0:
-#         raise ValueError(unstr(elliperimR2, a, b))
-#     p = a + b
-#     if p:
-#         t  = ((a - b) / p)**2 * _3_0
-#         t  = t / (_10_0 + sqrt(_4_0 - t)) + _1_0
-#         p *= t * PI
-#     return p
-
-
-# def elliperim4arc3(a, b):
-#     '''Compute the perimeter of an ellipse with semi-axes C{a} and C{b} using
-#        the U{4 arc approximation<https://PaulBourke.net/geometry/ellipsecirc>}.
-#
-#        @return: 3-Tuple C{(p, ra, rb)} with perimeter C{p}, arc radius C{ra}
-#                 at the major and arc radius C{rb} at the minor semi-axes.
-#     '''
-#     _r = a < b
-#     if _r:
-#         a, b = b, a
-#     if 0 < b < a:
-#         h = hypot(a, b)
-#         L = (h - b) * _0_5
-#         p = atan2(b, a)
-#         s, c = sincos2(p)
-#         ra =  L / c
-#         rb = (h - L) / s
-#         p  = rb * p + ra * (PI_2 - p)
-#     elif b < 0:
-#         raise ValueError(unstr(elliperim4arc3, a, b))
-#     elif b == a:
-#         ra = rb = a
-#         p = a * PI_2
-#     else:  # b == 0
-#         ra, rb = _0_0, a
-#         p = a
-#     p *= _4_0
-#     if _r:
-#         ra, rb = rb, ra
-#     return p, ra, rb
-
-
-# def elliperimGKS(a, b):
-#     '''Compute the perimeter of an ellipse with semi-axes C{a} and C{b} using the U{Gauss-Kummer
-#        Series<https://www.JohnDCook.com/blog/2023/05/28/approximate-ellipse-perimeter/>}.
-#     '''
-#     if a < b:
-#         a, b = b, a
-#     if b < 0:
-#         raise ValueError(unstr(elliperimGKS, a, b))
-#     if b:
-#         p  =  a + b
-#         h  = (a - b) / p
-#         h *=  h
-#         p *= (1 + h * (1 / 4 + h * (1 / 64 + h * (1 / 256 + h * (25 / 16384 + h * (49 / 65536)))))) * PI
-#     else:
-#         p  = _4_0 * a
-#     return p
-
-
 def _ellipsoidal(earth, where):
     '''(INTERNAL) Helper for distances.
     '''
@@ -1028,7 +927,8 @@ def hartzell(pov, los=False, earth=_WGS84, **name_LatLon_and_kwds):
     n, kwds = _name2__(name_LatLon_and_kwds, name__=hartzell)
     try:
         D = _spherical_datum(earth, name__=hartzell)
-        r, h, i = _MODS.triaxials.triaxial5._hartzell3(pov, los, D.ellipsoid._triaxial)
+        m = _MODS._triaxials_triaxial5
+        r, h, i = m._hartzell3(pov, los, D.ellipsoid._triaxial)
 
         C = _MODS.cartesianBase.CartesianBase
         if kwds:

pygeodesy/fsums.py

@@ -5,16 +5,16 @@ u'''Class L{Fsum} for precision floating point summation similar to
 Python's C{math.fsum}, but enhanced with I{precision running} summation
 plus optionally, accurate I{TwoProduct} multiplication.
 
-Accurate multiplication is based on the C{math.fma} function from
-Python 3.13 and newer or an equivalent C{fma} implementation for
-Python 3.12 and older.  To enable accurate multiplication, set env
-variable C{PYGEODESY_FSUM_F2PRODUCT} to C{"std"} or any non-empty
-string or invoke function C{pygeodesy.f2product(True)} or set.  With
-C{"std"} the C{fma} implemention follows the C{math.fma} function,
-otherwise the C{PyGeodesy 24.09.09} release.
+Accurate multiplication is based on the C{math.fma} function from Python
+3.13 and newer or an equivalent C{fma} implementation for Python 3.12 and
+older.  Set env variable C{PYGEODESY_FSUM_F2PRODUCT} to C{"std"} or any
+non-empty string or invoke function C{pygeodesy.f2product(True)} to enable
+accurate multiplication.  With C{"std"} the C{fma} implemention follows
+the C{math.fma} function, otherwise the implementation of the C{PyGeodesy
+24.09.09} release.
 
 Generally, an L{Fsum} instance is considered a C{float} plus a small or
-zero C{residue} aka C{residual} value, see property L{Fsum.residual}.
+zero C{residue} aka C{residual}, see property L{Fsum.residual}.
 
 Set env variable C{PYGEODESY_FSUM_RESIDUAL} to a C{float} string greater
 than C{"0.0"} as the threshold to throw a L{ResidualError} for a division,
@@ -28,7 +28,7 @@ L{Fsum.fint2} and L{Fsum.is_integer}.  Also, L{Fsum} methods L{Fsum.pow},
 L{Fsum.__ipow__}, L{Fsum.__pow__} and L{Fsum.__rpow__} return a (very long)
 C{int} if invoked with optional argument C{mod} set to C{None}.  The
 C{residual} of an C{integer} L{Fsum} is between C{-1.0} and C{+1.0} and
-will be C{INT0} if that is considered to be I{exact}.
+will be C{INT0} if that L{Fsum} is an I{exact float} or I{exact integer}.
 
 Set env variable C{PYGEODESY_FSUM_NONFINITES} to C{"std"} or use function
 C{pygeodesy.nonfiniterrors(False)} to allow I{non-finite} C{float}s like
@@ -62,7 +62,7 @@ from math import fabs, isinf, isnan, \
                  ceil as _ceil, floor as _floor  # PYCHOK used! .ltp
 
 __all__ = _ALL_LAZY.fsums
-__version__ = '25.06.03'
+__version__ = '26.01.16'
 
 from pygeodesy.interns import (
   _PLUS_     as _add_op_,  # in .auxilats.auxAngle
@@ -321,8 +321,8 @@ def nonfiniterrors(raiser=None):
     '''
     d = Fsum._isfine
     if raiser is not None:
-        Fsum._isfine = {} if bool(raiser) else Fsum._nonfinites_isfine_kwds[True]
-    return (False if d is Fsum._nonfinites_isfine_kwds[True] else
+        Fsum._isfine = {} if bool(raiser) else _nonfinites_isfine_kwds[True]
+    return (False if d is _nonfinites_isfine_kwds[True] else
          _xkwds_get1(d, _isfine=_isfinite) is _isfinite) if d else True
 
 
@@ -370,7 +370,7 @@ def _Psum(ps, **name_f2product_nonfinites_RESIDUAL):
     return F
 
 
-def _Psum_(*ps, **name_f2product_nonfinites_RESIDUAL):  # in .fmath
+def _Psum_(*ps, **name_f2product_nonfinites_RESIDUAL):
     '''(INTERNAL) Return an C{Fsum} from I{known scalar} C{ps}.
     '''
     return _Psum(ps, **name_f2product_nonfinites_RESIDUAL)
@@ -486,7 +486,7 @@ class Fsum(_Named):  # sync __methods__ with .vector3dBase.Vector3dBase, .fstats
 
        @note: Handling of I{non-finites} as C{inf}, C{INF}, C{NINF}, C{nan} and C{NAN} is
               determined by function L{nonfiniterrors<fsums.nonfiniterrors>} for the default
-              and by method L{nonfinites<Fsum.nonfinites>} for individual C{Fsum} instances,
+              or by method L{nonfinites<Fsum.nonfinites>} for individual C{Fsum} instances,
               overruling the default.  For backward compatibility, I{non-finites} raise
               exceptions by default.
 
@@ -829,7 +829,7 @@ class Fsum(_Named):  # sync __methods__ with .vector3dBase.Vector3dBase, .fstats
         return self._cmp_0(other, _lt_op_ + _fset_op_) <= 0
 
     def __len__(self):
-        '''Return the number of values accumulated (C{int}).
+        '''Return the number of (non-zero) values accumulated (C{int}).
         '''
         return self._n
 
@@ -1447,7 +1447,13 @@ class Fsum(_Named):  # sync __methods__ with .vector3dBase.Vector3dBase, .fstats
            @arg other2: Addend (C{scalar}, an L{Fsum} or L{Fsum2Tuple}).
            @kwarg nonfinites: Use C{B{nonfinites}=True} or C{False}, to
                               override L{nonfinites<Fsum.nonfinites>} and
-                              L{nonfiniterrors} default (C{bool}).
+                              the L{nonfiniterrors} default (C{bool}).
+        '''
+        f = self._fma(other1, other2, **nonfinites)
+        return self._fset(f)
+
+    def _fma(self, other1, other2, **nonfinites):  # in .elliptic
+        '''(INTERNAL) Return C{self * B{other1} + B{other2}}.
         '''
         op  = typename(self.fma)
         _fs = self._ps_other
@@ -1459,7 +1465,7 @@ class Fsum(_Named):  # sync __methods__ with .vector3dBase.Vector3dBase, .fstats
             elif _residue(other1) or _residue(other2):
                 fs = _2split3s(_fs(op, other1))
                 fs = _2products(s, fs, *_fs(op, other2))
-                f  = _Psum(self._ps_acc([], fs, up=False), name=op)
+                f  =  Fsum(fs, name=op, **nonfinites)
             else:
                 f  = _fma(s, other1, other2)
                 f  = _2finite(f, **self._isfine)
@@ -1469,7 +1475,7 @@ class Fsum(_Named):  # sync __methods__ with .vector3dBase.Vector3dBase, .fstats
             f  = self._mul_reduce(s, other1)  # INF, NAN, NINF
             f += sum(_fs(op, other2))
             f  = self._nonfiniteX(X, op, f, **nonfinites)
-        return self._fset(f)
+        return f
 
     def fma_(self, *xys, **nonfinites):
         '''Fused-multiply-accumulate C{for i in range(0, len(xys), B{2}):
@@ -1479,7 +1485,7 @@ class Fsum(_Named):  # sync __methods__ with .vector3dBase.Vector3dBase, .fstats
                      an L{Fsum} or L{Fsum2Tuple}), all positional.
            @kwarg nonfinites: Use C{B{nonfinites}=True} or C{False}, to
                               override L{nonfinites<Fsum.nonfinites>} and
-                              L{nonfiniterrors} default (C{bool}).
+                              the L{nonfiniterrors} default (C{bool}).
 
            @note: Equivalent to L{fdot_<pygeodesy.fmath.fdot_>}C{(*xys,
                   start=self)}.
@@ -1615,8 +1621,7 @@ class Fsum(_Named):  # sync __methods__ with .vector3dBase.Vector3dBase, .fstats
         '''
         if two:  # delattrof(self, _f2product=None)
             t = _xkwds_pop(self.__dict__, _f2product=None)
-            if two[0] is not None:
-                self._f2product = bool(two[0])
+            self._optionals(f2product=two[0])
         else:  # getattrof(self, _f2product=None)
             t = _xkwds_get(self.__dict__, _f2product=None)
         return t
@@ -2070,25 +2075,21 @@ class Fsum(_Named):  # sync __methods__ with .vector3dBase.Vector3dBase, .fstats
            @see: Function L{nonfiniterrors<fsums.nonfiniterrors>}.
 
            @note: Use property L{nonfinitesOK<Fsum.nonfinitesOK>} to determine
-                  whether I{non-finites} are C{OK} for this L{Fsum} and by the
+                  whether I{non-finites} are C{OK} for this L{Fsum} or by the
                   L{nonfiniterrors} default.
         '''
-        _ks = Fsum._nonfinites_isfine_kwds
         if OK:  # delattrof(self, _isfine=None)
             k = _xkwds_pop(self.__dict__, _isfine=None)
-            if OK[0] is not None:
-                self._isfine = _ks[bool(OK[0])]
+            self._optionals(nonfinites=OK[0])
             self._update()
         else:  # getattrof(self, _isfine=None)
             k = _xkwds_get(self.__dict__, _isfine=None)
+        _ks = _nonfinites_isfine_kwds
         # dict(map(reversed, _ks.items())).get(k, None)
         # raises a TypeError: unhashable type: 'dict'
         return True  if k is _ks[True]  else (
                False if k is _ks[False] else None)
 
-    _nonfinites_isfine_kwds = {True:  dict(_isfine=_isOK),
-                               False: dict(_isfine=_isfinite)}
-
     @property_RO
     def nonfinitesOK(self):
         '''Are I{non-finites} C{OK} for this L{Fsum} or by default? (C{bool}).
@@ -2111,9 +2112,9 @@ class Fsum(_Named):  # sync __methods__ with .vector3dBase.Vector3dBase, .fstats
         '''(INTERNAL) Re/set options from keyword arguments.
         '''
         if f2product is not None:
-            self.f2product(f2product)
+            self._f2product = bool(f2product)
         if nonfinites is not None:
-            self.nonfinites(nonfinites)
+            self._isfine = _nonfinites_isfine_kwds[bool(nonfinites)]
         if name_RESIDUAL:  # MUST be last
             n, kwds = _name2__(**name_RESIDUAL)
             if kwds:
@@ -2535,6 +2536,8 @@ class Fsum(_Named):  # sync __methods__ with .vector3dBase.Vector3dBase, .fstats
 
 _ROs = _allPropertiesOf_n(3, Fsum, Property_RO)  # PYCHOK see Fsum._update
 
+_nonfinites_isfine_kwds = {True:  dict(_isfine=_isOK),
+                           False: dict(_isfine=_isfinite)}
 if _NONFINITES == _std_:  # PYCHOK no cover
     _ = nonfiniterrors(False)
 
@@ -2685,6 +2688,21 @@ class Fsum2Tuple(_NamedTuple):  # in .fstats
 _Fsum_2Tuple_types = Fsum, Fsum2Tuple  # PYCHOK lines
 
 
+class _Ksum(Fsum):
+    '''(INTERNAL) For C{.karney._sum3}, specifically and only.
+    '''
+    _isfine = _nonfinites_isfine_kwds[True]
+
+    def __init__(self, s, t, *xs):
+        ps = [t, s] if t else [s]
+        self._ps = self._ps_acc(ps, xs, up=False)
+
+    @property_RO
+    def _s_t_n3(self):
+        s, t = self._fprs2
+        return s, t, self._n
+
+
 class ResidualError(_ValueError):
     '''Error raised for a division, power or root operation of
        an L{Fsum} instance with a C{residual} I{ratio} exceeding

pygeodesy/geod3solve.py

@@ -5,13 +5,14 @@ u'''Wrapper to invoke I{Karney}'s U{Geod3Solve
 <https://GeographicLib.SourceForge.io/C++/doc/Geod3Solve.1.html>} utility
 as a C{triaxial} geodesic, but intended I{mainly for testing purposes}.
 
-Set env variable C{PYGEODESY_GEOD3SOLVE} to the (fully qualified) path
-of the C{Geod3Solve} executable.
+Set env variable C{PYGEODESY_GEOD3SOLVE} to the (fully qualified) path of
+the C{Geod3Solve} executable or use property L{Geodesic3Solve.Geod3Solve
+<geod3solve._Geodesic3SolveBase.Geod3Solve>}.
 '''
 
 from pygeodesy.angles import Ang, Deg, isAng,  hypot
 from pygeodesy.basics import _xinstanceof  # typename
-from pygeodesy.constants import _0_0, _0_5, _360_0
+from pygeodesy.constants import _0_0, _0_5, _360_0, _over
 from pygeodesy.errors import GeodesicError, _xkwds_get
 # from pygeodesy.fmath import hypot  # from .angles
 # from pygeodesy.geodesicx import GeodesicAreaExact  # _MODS
@@ -25,7 +26,7 @@ from pygeodesy.units import Degrees, Meter
 # from pygeodesy.utily import sincos2d  # from .karney
 
 __all__ = _ALL_LAZY.geod3solve
-__version__ = '25.12.12'
+__version__ = '26.01.04'
 
 _Triaxial3_WGS84 = Triaxial3s.WGS84_3r  # a=6378172, b=6378102, c=6356752
 
@@ -39,24 +40,39 @@ class Geodesic3Error(GeodesicError):
 class Geod3Solve8Tuple(_GTuple):
     '''8-Tuple C{(bet1, omg1, alp1, bet2, omg2, alp2, s12, a12)} with C{ellipsoidal}
        latitudes C{bet1} and C{bet2}, C{ellipsoidal} longitudes C{omg1} and C{omg2},
-       forward azimuths C{alp1} and C{alp2} in bearings from North, distanc C{s12} in
-       C{meter}, conventionally and I{approximate} arc length {a12} in degrees, see
+       forward azimuths C{alp1} and C{alp2} in bearings from North, distance C{s12} in
+       C{meter}, conventionally and I{approximate} arc length C{a12} in degrees, see
        U{Geod3Solve<https://GeographicLib.SourceForge.io/C++/doc/Geod3Solve.1.html>}.
     '''
     # from Geod3Solve --help option -f ... bet1 omg1 alp1 bet2 omg2 alp2 s12
     _Names_ = ('bet1', 'omg1', 'alp1', 'bet2', 'omg2', 'alp2', _s12_, _a12_)
     _Units_ = ( Deg,    Deg,    Deg,    Deg,    Deg,    Deg,    Meter, Deg)
 
+#   @Property_RO
+#   def A12(self):
+#       '''Approximate arc C{A12} as C{Deg}.
+#       '''
+#       t = self
+#       d = t.s12 or _0_0
+#       if d:
+#           a = hypot(Deg(t.bet2 - t.bet1).degrees,
+#                     Deg(t.omg2 - t.omg1).degrees)
+#           d = (-a) if d < 0 else a
+#       return Deg(d)
+
 
 class _Geodesic3SolveBase(_Solve3Base):
     '''(INTERNAL) Base class for L{Geodesic3Solve} and L{GeodesicLine3Solve}.
     '''
+    _a12x          =  Geod3Solve8Tuple._Names_.index(_a12_)  # last
     _Error         =  Geodesic3Error
     _Names_Direct  = _Names_Distance = \
-    _Names_Inverse =  Geod3Solve8Tuple._Names_[:7]  # 7 only, always
+    _Names_Inverse =  Geod3Solve8Tuple._Names_[:_a12x]  # 7 only, always
     _triaxial3     = _Triaxial3_WGS84
     _Xable_name    = _Xables.Geod3Solve.__name__  # typename
     _Xable_path    = _Xables.Geod3Solve()
+#   assert _a12x  ==  len(Geod3Solve8Tuple._Names_) - 1
+    del _a12x
 
     @Property_RO
     def a(self):
@@ -161,11 +177,11 @@ class Geodesic3Solve(_Geodesic3SolveBase):
         '''
         a = r.s12 or _0_0
         if a:
+            t =  self.triaxial3
             z = _toAzi(r.alp1) + _toAzi(r.alp2)
             s, c = sincos2d(z * _0_5)
-            t  = self.triaxial3
-            a *= hypot(s / t._ab_elliperim,  # azimuth!
-                       c / t._bc_elliperim) * _360_0
+            a *= hypot(_over(s, t.perimeter4ab),  # azimuth!
+                       _over(c, t.perimeter4bc)) * _360_0
         r[_a12_] = a
         return r
 

pygeodesy/geodesici.py

@@ -7,10 +7,11 @@ Class L{Intersector} is a pure Python version of I{Karney}'s C++ class U{Interse
 <https://GeographicLib.SourceForge.io/C++/doc/classGeographicLib_1_1Intersect.html>}.
 
 Class L{Intersectool} is a wrapper to invoke I{Karney}'s U{IntersectTool
-<https://GeographicLib.SourceForge.io/C++/doc/IntersectTool.1.html>} utility, but intended I{for testing purposes only}.
+<https://GeographicLib.SourceForge.io/C++/doc/IntersectTool.1.html>} utility, mainly intended I{for testing purposes}.
 
-Set env variable C{PYGEODESY_INTERSECTTOOL} to the (fully qualified) path of the C{IntersectTool} executable.  For usage
-and some examples run C{"env PYGEODESY_INTERSECTTOOL=<IntersectTool-path> python3 -m pygeodesy.geodesici --help"}.
+Set env variable C{PYGEODESY_INTERSECTTOOL} to the (fully qualified) path of the C{IntersectTool} executable or use
+property L{Intersectool.IntersectTool}.  For usage and some examples run C{"env PYGEODESY_INTERSECTTOOL=<IntersectTool-path>
+python3 -m pygeodesy.geodesici --help"}.
 
 Both L{Intersectool} and L{Intersector} provide methods C{All}, C{Closest}, C{Next} and C{Segment} and produce
 L{XDict} instances with 4 or more items.  Adjacent methods C{All5}, C{Closest5}, C{Next5} and C{Segment} return
@@ -57,7 +58,7 @@ from pygeodesy.utily import atan2, sincos2,  fabs, radians
 # from math import ceil as _ceil, fabs, radians  # .fsums, .utily
 
 __all__ = _ALL_LAZY.geodesici
-__version__ = '25.06.02'
+__version__ = '25.12.31'
 
 _0t     =  0,  # int
 _1_1t   = -1, +1

pygeodesy/geodesicx/__init__.py

@@ -23,7 +23,7 @@ from pygeodesy.karney import Caps, GeodesicError
 from pygeodesy.lazily import _ALL_DOCS, _ALL_LAZY
 
 __all__ = _ALL_LAZY.geodesicx + _ALL_DOCS(Caps, GeodesicError)
-__version__ = '25.09.02'
+__version__ = '25.12.23'
 
 # **) MIT License
 #

pygeodesy/geodesicx/gxarea.py

@@ -19,19 +19,20 @@ from __future__ import division as _; del _  # noqa: E702 ;
 
 from pygeodesy.basics import _copysign, isodd, unsigned0
 from pygeodesy.constants import NAN, _0_0, _0_5, _720_0
+from pygeodesy.fmath import _fma
 from pygeodesy.internals import printf, typename
 # from pygeodesy.interns import _COMMASPACE_  # from .lazily
 from pygeodesy.karney import Area3Tuple, _diff182, GeodesicError, \
-                            _norm180, _remainder, _sum3
+                            _norm180, _remainder, _sum2
 from pygeodesy.lazily import _ALL_DOCS,  _COMMASPACE_
 from pygeodesy.named import ADict, callername, _NamedBase,  pairs
 from pygeodesy.props import Property, Property_RO, property_RO
 # from pygeodesy.streprs import pairs  # from .named
 
-from math import fmod as _fmod
+from math import fabs, fmod as _fmod
 
 __all__ = ()
-__version__ = '25.09.16'
+__version__ = '25.12.23'
 
 
 class GeodesicAreaExact(_NamedBase):
@@ -427,30 +428,39 @@ class _Accumulator(_NamedBase):
            @kwarg y: Initial value (C{scalar}).
            @kwarg name: Optional C{B{name}=NN} (C{str}).
         '''
-        if isinstance(y, _Accumulator):
-            self._s, self._t, self._n = y._s, y._t, 1
-        elif y:
-            self._s, self._n = float(y), 1
+        self._s_t(*_s_t2(y))
+        self._n = 1
         if name:
             self.name = name
 
-    def Add(self, y):
-        '''Add a value.
+    def Add(self, *ys):
+        '''Add one or more scalars or L{_Accumulator}s.
 
            @return: Current C{sum}.
-        '''
-        self._n += 1
-        self._s, self._t, _ = _sum3(self._s, self._t, y)
-        return self._s  # current .Sum()
+
+           @see: C++ U{Accumulator.Add<https://GeographicLib.sourceforge.io/C++/doc/Accumulator_8hpp_source.html>}
+                 for more details about Karney's and Shewchuk's addition.
+        '''
+        # _Accumulator().Add(1, 1e20, 2, 100, 5000, -1e20) ... 5103.0
+        s, t = self._s, self._t
+        for y in ys:
+            for y in _s_t2(y):
+                if y:
+                    t, u = _sum2(t, y)
+                    s, t = _sum2(s, t)
+                    if s:  # accumlate u in t
+                        t += u
+                    else:  # s == 0 implies t == 0
+                        s  = u
+                    self._n += 1
+        return self._s_t(s, t)
 
     def Negate(self):
         '''Negate sum.
 
            @return: Current C{sum}.
         '''
-        self._s = s = -self._s
-        self._t =     -self._t
-        return s  # current .Sum()
+        return self._s_t(-self._s, -self._t)
 
     @property_RO
     def num(self):
@@ -459,22 +469,27 @@ class _Accumulator(_NamedBase):
         return self._n
 
     def Remainder(self, y):
-        '''Remainder on division by B{C{y}}.
+        '''Remainder of division by B{C{y}}.
 
            @return: Remainder of C{sum} / B{C{y}}.
         '''
-        self._s = _remainder(self._s, y)
-#       self._t = _remainder(self._t, y)
-        self._n = -1
-        return self.Add(_0_0)
+        return self._s_t(_remainder(self._s, y),
+                         _remainder(self._t, y))
 
     def Reset(self, y=0):
-        '''Set value from argument.
+        '''Reset from scalar or L{_Accumulator}.
         '''
-        self._n, self._s, self._t = 0, float(y), _0_0
+        self._s_t(*_s_t2(y))
+        self._n = 0
 
     Set = Reset
 
+    def _s_t(self, s, t=0):
+        if t and fabs(s) < fabs(t):
+            s, t = t, s
+        self._s, self._t = s, t
+        return s
+
     def Sum(self, y=0):
         '''Return C{sum + B{y}}.
 
@@ -488,6 +503,17 @@ class _Accumulator(_NamedBase):
             s = self
         return s._s
 
+    def Times(self, y):
+        '''Multiply by a scalar.
+
+           @return: Current C{sum}.
+        '''
+        s  = d = self._s
+        s *= y
+        d = _fma(y, d, -s)
+        t = _fma(y, self._t, d)
+        return self._s_t(s, t)  # current .Sum()
+
     def toStr(self, prec=6, sep=_COMMASPACE_, **unused):  # PYCHOK signature
         '''Return this C{_Accumulator} as string.
 
@@ -502,6 +528,10 @@ class _Accumulator(_NamedBase):
         return sep.join(pairs(d, prec=prec))
 
 
+def _s_t2(y):
+    return (y._s, y._t) if isinstance(y, _Accumulator) else (float(y),)  # PYCHOK OK
+
+
 __all__ += _ALL_DOCS(GeodesicAreaExact, PolygonArea)
 
 # **) MIT License

pygeodesy/geodsolve.py

@@ -5,8 +5,9 @@ u'''Wrapper to invoke I{Karney}'s U{GeodSolve
 <https://GeographicLib.SourceForge.io/C++/doc/GeodSolve.1.html>} utility
 as an (exact) geodesic, but intended I{mainly for testing purposes}.
 
-Set env variable C{PYGEODESY_GEODSOLVE} to the (fully qualified) path
-of the C{GeodSolve} executable.
+Set env variable C{PYGEODESY_GEODSOLVE} to the (fully qualified) path of
+the C{GeodSolve} executable or use property L{GeodesicSolve.GeodSolve
+<geodsolve._GeodesicSolveBase.GeodSolve>}.
 '''
 
 from pygeodesy.basics import _xinstanceof  # typename
@@ -28,7 +29,7 @@ from pygeodesy.solveBase import _SolveGDictBase, _SolveGDictLineBase
 from pygeodesy.utily import _unrollon, _Wrap, wrap360
 
 __all__ = _ALL_LAZY.geodsolve
-__version__ = '25.12.06'
+__version__ = '25.12.31'
 
 
 class GeodSolve12Tuple(_GTuple):