pygeodesy 24.5.8__py2.py3-none-any.whl → 24.5.15__py2.py3-none-any.whl

pygeodesy/constants.py

@@ -9,12 +9,13 @@ L{pygeodesy.isnon0} and L{pygeodesy.remainder}.
 # make sure int/int division yields float quotient, see .basics
 from __future__ import division as _; del _  # PYCHOK semicolon
 
-from pygeodesy.basics import _0_0, _copysign, isbool, iscomplex, isint,  _ALL_LAZY
+from pygeodesy.basics import _copysign, isbool, iscomplex, isint,  _0_0
 from pygeodesy.errors import _xError, _xError2, _xkwds_get, _xkwds_item2
+# from pygeodesy.internals import _0_0  # from .basics
 from pygeodesy.interns import _INF_, _NAN_, _UNDER_
-# from pygeodesy.lazily import _ALL_LAZY  # from .basics
+# from pygeodesy.lazily import _ALL_LAZY  # from .unitsBase
 # from pygeodesy.streprs import Fmt  # from .unitsBase
-from pygeodesy.unitsBase import Float, Int, Radius,  Fmt
+from pygeodesy.unitsBase import Float, Int, Radius,  _ALL_LAZY, Fmt
 
 from math import fabs, isinf, isnan, pi as _PI, sqrt
 try:
@@ -23,7 +24,7 @@ except ImportError:  # Python 2-
     _inf, _nan = float(_INF_), float(_NAN_)
 
 __all__ = _ALL_LAZY.constants
-__version__ = '24.04.23'
+__version__ = '24.05.14'
 
 
 def _copysign_0_0(y):
@@ -355,8 +356,9 @@ def isint0(obj, both=False):
        @return: C{True} if B{C{obj}} is L{INT0}, C{int(0)} or
                 C{float(0)}, C{False} otherwise.
     '''
-    return (obj is INT0 or obj is int(0) or bool(both and
-       (not obj) and isint(obj, both=True))) and not isbool(obj)
+    return (obj is INT0 or obj is int(0) or
+            bool(both and (not obj) and isint(obj, both=True))) and \
+            not isbool(obj)
 
 
 def isnear0(x, eps0=EPS0):

pygeodesy/datums.py

@@ -67,7 +67,7 @@ datum, q.v. U{"A Guide to Coordinate Systems in Great Britain", Section 6
 # make sure int/int division yields float quotient, see .basics
 from __future__ import division as _; del _  # PYCHOK semicolon
 
-from pygeodesy.basics import islistuple, map2, neg, _passarg, _xinstanceof, _zip
+from pygeodesy.basics import islistuple, map2, neg, _xinstanceof, _zip
 from pygeodesy.constants import R_M, _float as _F, _0_0, _1_0, _2_0, _8_0, _3600_0
 # from pygeodesy.ellipsoidalBase import CartesianEllipsoidalBase as _CEB, \
 #                                          LatLonEllipsoidalBase as _LLEB  # MODS
@@ -76,12 +76,13 @@ from pygeodesy.ellipsoids import a_f2Tuple, Ellipsoid, Ellipsoid2, Ellipsoids, _
 from pygeodesy.errors import _IsnotError, _TypeError, _xattr, _xellipsoidall, _xkwds, \
                              _xkwds_pop2
 from pygeodesy.fmath import fdot, fmean,  Fmt, _operator
+from pygeodesy.internals import _passarg, _under
 from pygeodesy.interns import NN, _a_, _Airy1830_, _AiryModified_, _BAR_, _Bessel1841_, \
-                             _Clarke1866_, _Clarke1880IGN_, _COMMASPACE_, _DOT_, \
-                             _earth_, _ellipsoid_, _ellipsoidal_, _GRS80_, _Intl1924_, \
-                             _MINUS_, _Krassovski1940_, _Krassowsky1940_, _NAD27_, \
-                             _NAD83_, _PLUS_, _s_, _Sphere_, _spherical_, _transform_, \
-                             _UNDER_, _WGS72_, _WGS84_, _under
+                             _Clarke1866_, _Clarke1880IGN_, _COMMASPACE_, _DOT_, _earth_, \
+                             _ellipsoid_, _ellipsoidal_, _GRS80_, _Intl1924_, _MINUS_, \
+                             _Krassovski1940_, _Krassowsky1940_, _NAD27_, _NAD83_, _s_, \
+                             _PLUS_, _Sphere_, _spherical_, _transform_, _UNDER_, \
+                             _WGS72_, _WGS84_
 from pygeodesy.lazily import _ALL_LAZY, _ALL_MODS as _MODS
 from pygeodesy.named import _NamedEnum, _NamedEnumItem, _lazyNamedEnumItem as _lazy
 # from pygeodesy.namedTuples import Vector3Tuple  # from .ellipsoids
@@ -93,7 +94,7 @@ from pygeodesy.units import _isRadius, Radius_,  radians
 # import operator as _operator  # from .fmath
 
 __all__ = _ALL_LAZY.datums
-__version__ = '24.03.07'
+__version__ = '24.05.14'
 
 _a_ellipsoid_ = _UNDER_(_a_, _ellipsoid_)
 _BD72_        = 'BD72'
@@ -722,7 +723,7 @@ assert _WGS84.ellipsoid is _EWGS84
 if __name__ == '__main__':
 
     from pygeodesy.interns import _COMMA_, _NL_, _NLATvar_
-    from pygeodesy.lazily import printf
+    from pygeodesy import printf
 
     # __doc__ of this file, force all into registery
     for r in (Datums, Transforms):

pygeodesy/ecef.py

@@ -86,7 +86,7 @@ from pygeodesy.utily import atan1, atan1d, atan2d, degrees90, degrees180, \
 from math import atan2, cos, degrees, fabs, radians, sqrt
 
 __all__ = _ALL_LAZY.ecef
-__version__ = '24.05.04'
+__version__ = '24.05.10'
 
 _Ecef_    = 'Ecef'
 _prolate_ = 'prolate'
@@ -646,7 +646,7 @@ class EcefSudano(_EcefBase):
 
         _a  = fabs
         lat = atan1d(z, R * E.e21)
-        sa, ca = sincos2d(fabs(lat))
+        sa, ca = sincos2d(_a(lat))
         # Sudano's Eq (A-6) and (A-7) refactored/reduced,
         # replacing Rn from Eq (A-4) with n = E.a / ca:
         # N = ca**2 * ((z + E.e2 * n * sa) * ca - R * sa)
@@ -656,17 +656,18 @@ class EcefSudano(_EcefBase):
         #   = ca**2 * (E.e2 * E.a / E.e2s2(sa) - R / ca**2)
         # N / D = (z * ca + (E.e2 * E.a - R) * sa) /
         #         (E.e2 * E.a / E.e2s2(sa) - R / ca**2)
+        _E  = EPS_2
         tol = self.tolerance
         _S2 = Fsum(sa).fsum2f_
         _rt = sqrt
         for i in range(1, _TRIPS):
             ca2 = _1_0 - sa**2
-            if ca2 < EPS_2:  # PYCHOK no cover
+            if ca2 < _E:  # PYCHOK no cover
                 ca = _0_0
                 break
             ca = _rt(ca2)
             r = e / E.e2s2(sa) - R / ca2
-            if _a(r) < EPS_2:
+            if _a(r) < _E:
                 break
             lat = None
             sa, r = _S2(-z * ca / r, -d * sa / r)

pygeodesy/elevations.py

@@ -34,7 +34,7 @@ from pygeodesy.units import Lat, Lon, Meter, Scalar, Str
 # from math import fabs  # from .karney
 
 __all__ = _ALL_LAZY.elevations
-__version__ = '23.05.26'
+__version__ = '24.05.13'
 
 try:
     from urllib2 import urlopen  # quote, urlcleanup
@@ -245,7 +245,7 @@ def geoidHeight2(lat, lon, model=0, timeout=2.0):
 
 if __name__ == '__main__':
 
-    from pygeodesy.lazily import printf
+    from pygeodesy import printf
     # <https://WikiPedia.org/wiki/Mount_Diablo>
     for f in (elevation2,     # (1173.79, '3DEP 1/3 arc-second')
               geoidHeight2):  # (-31.699, u'GEOID12B')

pygeodesy/ellipsoidalBaseDI.py

@@ -17,10 +17,12 @@ from pygeodesy.errors import _AssertionError, IntersectionError, _IsnotError, \
 from pygeodesy.fmath import favg, fmean_
 from pygeodesy.fsums import Fmt, fsumf_
 from pygeodesy.formy import _isequalTo, opposing, _radical2
-from pygeodesy.interns import _antipodal_, _concentric_, _dunder_nameof, \
-                              _ellipsoidal_, _exceed_PI_radians_, _low_, \
-                              _near_, _SPACE_, _too_
-from pygeodesy.lazily import _ALL_DOCS, _ALL_LAZY, _ALL_MODS as _MODS
+# from pygeodesy.internals import _dunder_nameof  # from .lazily
+from pygeodesy.interns import _antipodal_, _concentric_, _ellipsoidal_, \
+                              _exceed_PI_radians_, _low_, _near_, \
+                              _SPACE_, _too_
+from pygeodesy.lazily import _ALL_DOCS, _ALL_LAZY, _ALL_MODS as _MODS, \
+                             _dunder_nameof
 from pygeodesy.namedTuples import Bearing2Tuple, Destination2Tuple, \
                                   Intersection3Tuple, NearestOn2Tuple, \
                                   NearestOn8Tuple, _LL4Tuple
@@ -34,7 +36,7 @@ from pygeodesy.utily import m2km, unroll180, _unrollon, _unrollon3, \
 from math import degrees, radians
 
 __all__ = _ALL_LAZY.ellipsoidalBaseDI
-__version__ = '24.02.14'
+__version__ = '24.05.13'
 
 _polar__  = 'polar?'
 _B2END    = _1_5  # _intersect3 bearing to pseudo-end point factor

pygeodesy/elliptic.py

@@ -82,11 +82,12 @@ from pygeodesy.constants import EPS, INF, NAN, PI, PI_2, PI_4, \
                                _360_0, _over
 # from pygeodesy.errors import _ValueError  # from .fmath
 from pygeodesy.fmath import fdot, hypot1, zqrt,  _ValueError
-from pygeodesy.fsums import Fsum, _sum,  _ALL_LAZY
-from pygeodesy.interns import NN, _delta_, _DOT_, _dunder_nameof, _f_, \
-                             _invalid_, _invokation_, _negative_, _SPACE_
+from pygeodesy.fsums import Fsum, _sum
+# from pygeodesy.internals import _dunder_nameof  # from .lazily
+from pygeodesy.interns import NN, _delta_, _DOT_, _f_, _invalid_, \
+                             _invokation_, _negative_, _SPACE_
 from pygeodesy.karney import _K_2_0, _norm180, _signBit, _sincos2
-# from pygeodesy.lazily import _ALL_LAZY  # from .fsums
+from pygeodesy.lazily import _ALL_LAZY,  _dunder_nameof
 from pygeodesy.named import _Named, _NamedTuple,  Fmt, unstr
 from pygeodesy.props import _allPropertiesOf_n, Property_RO, _update_all
 # from pygeodesy.streprs import Fmt, unstr  # from .named
@@ -97,7 +98,7 @@ from math import asinh, atan, atan2, ceil, cosh, fabs, floor, \
                  radians, sin, sqrt, tanh
 
 __all__ = _ALL_LAZY.elliptic
-__version__ = '24.04.14'
+__version__ = '24.05.13'
 
 _TolRD  =  zqrt(EPS * 0.002)
 _TolRF  =  zqrt(EPS * 0.030)
@@ -402,10 +403,12 @@ class Elliptic(_Named):
         Phi = Fsum(phi)
         # first order correction
         phi = Phi.fsum_(self.eps * sin(phi * _2_0) / _N_2_0)
+        self._iteration = 0
         # For kp2 close to zero use asin(r / cE) or J. P. Boyd,
         # Applied Math. and Computation 218, 7005-7013 (2012)
         # <https://DOI.org/10.1016/j.amc.2011.12.021>
-        _Phi2, self._iteration = Phi.fsum2f_, 0  # aggregate
+        _Phi2 = Phi.fsum2f_  # aggregate
+        _abs  = fabs
         for i in range(1, _TRIPS):  # GEOGRAPHICLIB_PANIC
             sn, cn, dn = self._sncndn3(phi)
             if dn:
@@ -413,7 +416,7 @@ class Elliptic(_Named):
                 phi, d = _Phi2((r - sn) / dn)
             else:  # PYCHOK no cover
                 d = _0_0  # XXX continue?
-            if fabs(d) < _TolJAC:  # 3-4 trips
+            if _abs(d) < _TolJAC:  # 3-4 trips
                 _iterations(self, i)
                 break
         else:  # PYCHOK no cover

pygeodesy/errors.py

@@ -14,18 +14,18 @@ C{PYGEODESY_EXCEPTION_CHAINING=std} or to any non-empty string.
 # from pygeodesy.basics import isint, isodd, issubclassof, itemsorted, _xinstanceof, _zip  # _MODS
 # from pygeodesy.ellipsoidalBase import CartesianEllipsoidalBase, LatLonEllipsoidalBase  # _MODS
 # from pygeodesy import errors  # _MODS, _MODS.getattr
-from pygeodesy.interns import MISSING, NN, _a_, _an_, _and_, _clip_, _COLON_, \
-                             _COLONSPACE_, _COMMASPACE_, _datum_, _ellipsoidal_, \
-                             _incompatible_, _invalid_, _len_, _not_, _or_, _SPACE_, \
-                             _specified_, _UNDER_, _vs_, _with_, _tailof
-from pygeodesy.lazily import _ALL_LAZY, _ALL_MODS as _MODS, _getenv, _PYTHON_X_DEV
+# from pygeodesy.internals import _tailof  # from .lazily
+from pygeodesy.interns import MISSING, NN, _a_, _an_, _and_, _clip_, _COLON_, _COLONSPACE_, \
+                             _COMMASPACE_, _datum_, _ellipsoidal_, _incompatible_, _invalid_, \
+                             _len_, _not_, _or_, _SPACE_, _specified_, _UNDER_, _vs_, _with_
+from pygeodesy.lazily import _ALL_LAZY, _ALL_MODS as _MODS, _getenv, _PYTHON_X_DEV,  _tailof
 # from pygeodesy.streprs import Fmt, unstr  # _MODS
 # from pygeodesy.vector3dBase import Vector3dBase  # _MODS
 
 from copy import copy as _copy
 
 __all__ = _ALL_LAZY.errors  # _ALL_DOCS('_InvalidError', '_IsnotError')  _under
-__version__ = '24.05.06'
+__version__ = '24.05.15'
 
 _box_        = 'box'
 _limiterrors =  True  # in .formy

pygeodesy/etm.py

@@ -74,7 +74,7 @@ from pygeodesy.elliptic import _ALL_LAZY, Elliptic
 from pygeodesy.fmath import cbrt, hypot, hypot1, hypot2
 from pygeodesy.fsums import Fsum, fsum1f_
 from pygeodesy.interns import NN, _COMMASPACE_, _DASH_, _near_, _SPACE_, \
-                             _spherical_, _usage
+                             _spherical_
 from pygeodesy.karney import _copyBit, _diff182, _fix90, _norm2, _norm180, \
                              _tand, _unsigned2
 # from pygeodesy.lazily import _ALL_LAZY  # from .elliptic
@@ -92,7 +92,7 @@ from pygeodesy.utm import _cmlon, _LLEB, _parseUTM5, _toBand, _toXtm8, \
 from math import asinh, atan2, degrees, radians, sinh, sqrt
 
 __all__ = _ALL_LAZY.etm
-__version__ = '24.04.07'
+__version__ = '24.05.13'
 
 _OVERFLOW = _1_EPS**2  # about 2e+31
 _TAYTOL   =  pow(EPS, 0.6)
@@ -1109,6 +1109,7 @@ def toEtm8(latlon, lon=None, datum=None, Etm=Etm, falsed=True,
 
 if __name__ == '__main__':  # MCCABE 13
 
+    from pygeodesy.internals import _usage
     from pygeodesy import fstr, KTransverseMercator, printf
     from sys import argv, exit as _exit
 

pygeodesy/fmath.py

@@ -7,7 +7,7 @@ u'''Utilities using precision floating point summation.
 from __future__ import division as _; del _  # PYCHOK semicolon
 
 from pygeodesy.basics import _copysign, copysign0, isbool, isint, isscalar, \
-                              len2, map1
+                              len2, map1, _xiterable
 from pygeodesy.constants import EPS0, EPS02, EPS1, NAN, PI, PI_2, PI_4, \
                                _0_0, _0_125, _1_6th, _0_25, _1_3rd, _0_5, _1_0, \
                                _N_1_0, _1_5, _copysign_0_0, _isfinite, remainder
@@ -24,7 +24,7 @@ from math import fabs, sqrt  # pow
 import operator as _operator  # in .datums, .trf, .utm
 
 __all__ = _ALL_LAZY.fmath
-__version__ = '24.05.07'
+__version__ = '24.05.10'
 
 # sqrt(2) <https://WikiPedia.org/wiki/Square_root_of_2>
 _0_4142  =  0.41421356237309504880  # ... sqrt(2) - 1
@@ -521,17 +521,18 @@ def fidw(xs, ds, beta=2):
                 _F =  Fsum
                 W  = _F()
                 X  = _F()
-                for i, d in enumerate(ds):
+                for i, d in enumerate(_xiterable(ds)):
                     x = xs[i]
-                    if d < EPS0:
-                        if d < 0:
+                    D = _F(d)
+                    if D < EPS0:
+                        if D < 0:
                             raise ValueError(_negative_)
                         x = float(x)
                         i = n
                         break
-                    D = _F(d).fpow(b)
-                    W += D
-                    X += D.fmul(x)
+                    if D.fpow(b):
+                        W += D
+                        X += D.fmul(x)
                 else:
                     x  = X.fover(W, raiser=False)
                     i += 1  # len(xs) >= len(ds)
@@ -630,12 +631,12 @@ except ImportError:
     def fprod(xs, start=1):
         '''Iterable product, like C{math.prod} or C{numpy.prod}.
 
-           @arg xs: Terms to be multiplied, an iterable, list,
-                    tuple, etc. (C{scalar}s).
-           @kwarg start: Initial term, also the value returned
+           @arg xs: Iterable of values to be multiplied (each
+                    C{scalar} or an L{Fsum}).
+           @kwarg start: Initial value, also the value returned
                          for an empty B{C{xs}} (C{scalar}).
 
-           @return: The product (C{float}).
+           @return: The product (C{float} or an L{Fsum}).
 
            @see: U{NumPy.prod<https://docs.SciPy.org/doc/
                  numpy/reference/generated/numpy.prod.html>}.

pygeodesy/fstats.py

@@ -11,17 +11,16 @@ from pygeodesy.basics import isscalar, isodd, _xinstanceof, \
                             _xiterable, _xsubclassof, _zip
 from pygeodesy.constants import _0_0, _1_0, _2_0, _3_0, _4_0, _6_0
 from pygeodesy.errors import _AssertionError, _ValueError, _xError
-from pygeodesy.fmath import Fsqrt
-from pygeodesy.fsums import _2finite, _Float, Fsum, _iadd_op_, \
-                            _isAn, _isFsumTuple, _Tuple,  Fmt
+from pygeodesy.fmath import Fsqrt,  Fmt
+from pygeodesy.fsums import _2finite, Fsum, _iadd_op_, _isFsumTuple
 from pygeodesy.interns import NN, _odd_, _SPACE_
 from pygeodesy.lazily import _ALL_DOCS, _ALL_LAZY
 from pygeodesy.named import _Named, _NotImplemented, property_RO
 # from pygeodesy.props import property_RO  # from .named
-# from pygeodesy.streprs import Fmt  # from .fsums
+# from pygeodesy.streprs import Fmt  # from .fmath
 
 __all__ = _ALL_LAZY.fstats
-__version__ = '24.05.08'
+__version__ = '24.05.10'
 
 
 def _2Floats(**xs):
@@ -33,11 +32,12 @@ def _2Floats(**xs):
         raise _AssertionError(xs=xs, cause=X)
 
     try:
-        i, x = 0, None
-        for i, x in enumerate(xs):  # don't unravel Fsums
+        i = None
+        for i, x in enumerate(_xiterable(xs)):  # don't unravel Fsums
             yield x._Fsum if _isFsumTuple(x) else _2finite(x)
     except Exception as X:
-        raise _xError(X, Fmt.INDEX(name, i), x)
+        raise _xError(X, name, xs) if i is None else \
+              _xError(X, Fmt.INDEX(name, i), x)
 
 
 def _sampled(n, sample):
@@ -105,8 +105,8 @@ class _FstatsBase(_FstatsNamed):
         '''(INTERNAL) Copy C{B{c} = B{s}}.
         '''
         _xinstanceof(self.__class__, d=d, s=s)
-        d._Ms = _Tuple(M.copy() for M in s._Ms)  # deep=False
-        d._n  =                          s._n
+        d._Ms = tuple(M.copy() for M in s._Ms)  # deep=False
+        d._n  =                         s._n
         return d
 
     def fadd(self, xs, sample=False):  # PYCHOK no cover
@@ -130,7 +130,7 @@ class _FstatsBase(_FstatsNamed):
 
            @see: Method C{fadd}.
         '''
-        return _Float(self._Mean(xs))
+        return float(self._Mean(xs))
 
     def fmean_(self, *xs):
         '''Accumulate and return the current mean.
@@ -151,7 +151,7 @@ class _FstatsBase(_FstatsNamed):
 
            @see: Method C{fadd}.
         '''
-        return _Float(self._Stdev(xs, **sample))
+        return float(self._Stdev(xs, **sample))
 
     def fstdev_(self, *xs, **sample):
         '''Accumulate and return the current standard deviation.
@@ -172,7 +172,7 @@ class _FstatsBase(_FstatsNamed):
 
            @see: Method C{fadd}.
         '''
-        return _Float(self._Variance(xs, **sample))
+        return float(self._Variance(xs, **sample))
 
     def fvariance_(self, *xs, **sample):
         '''Accumulate and return the current variance.
@@ -189,12 +189,11 @@ class _FstatsBase(_FstatsNamed):
                 self.fadd_(other._Fsum)
             elif isscalar(other):
                 self.fadd_(_2finite(other))
-            else:  # iterable?
-                _xiterable(other)
+            elif _xiterable(other):
                 self.fadd(other)
-        except Exception as x:
+        except Exception as X:
             t = _SPACE_(self, _iadd_op_, repr(other))
-            raise _xError(x, t)
+            raise _xError(X, t)
 
     @property_RO
     def _M1(self):
@@ -244,7 +243,7 @@ class Fcook(_FstatsBase):
 
            @see: Method L{Fcook.fadd}.
         '''
-        self._Ms = _Tuple(Fsum() for _ in range(4))  # 1st, 2nd ... Moment
+        self._Ms = tuple(Fsum() for _ in range(4))  # 1st, 2nd ... Moment
         if name:
             self.name = name
         if xs:
@@ -265,7 +264,7 @@ class Fcook(_FstatsBase):
 
            @see: Method L{Fcook.fadd}.
         '''
-        if _isAn(other, Fcook):
+        if isinstance(other, Fcook):
             nb = len(other)
             if nb > 0:
                 na = len(self)
@@ -374,7 +373,7 @@ class Fcook(_FstatsBase):
 
            @see: Method L{Fcook.fadd}.
         '''
-        return _Float(self._JarqueBera(xs, excess, sample=sample))
+        return float(self._JarqueBera(xs, excess, sample=sample))
 
     def fjb_(self, *xs, **sample_excess):
         '''Accumulate and compute the current U{Jarque-Bera
@@ -401,7 +400,7 @@ class Fcook(_FstatsBase):
            @see: Method L{Fcook.fadd}.
         '''
         n = self.fadd(xs, **sample)
-        return _Float(self._Kurtosis(n, excess, **sample))
+        return float(self._Kurtosis(n, excess, **sample))
 
     def fkurtosis_(self, *xs, **excess_sample):
         '''Accumulate and return the current kurtosis.
@@ -423,7 +422,7 @@ class Fcook(_FstatsBase):
                  https://TowardsDataScience.com/skewness-kurtosis-simplified-1338e094fc85>}
                  and method L{Fcook.fadd}.
         '''
-        return _Float(self._Median(xs))
+        return float(self._Median(xs))
 
     def fmedian_(self, *xs):
         '''Accumulate and return the current median.
@@ -448,7 +447,7 @@ class Fcook(_FstatsBase):
            @see: Method L{Fcook.fadd}.
         '''
         n = self.fadd(xs, **sample)
-        return _Float(self._Skewness(n, **sample))
+        return float(self._Skewness(n, **sample))
 
     def fskewness_(self, *xs, **sample):
         '''Accumulate and return the current skewness.
@@ -552,7 +551,7 @@ class Fwelford(_FstatsBase):
            @see: Method L{Fwelford.fadd} and U{Parallel algorithm<https//
                  WikiPedia.org/wiki/Algorithms_for_calculating_variance>}.
         '''
-        if _isAn(other, Fwelford):
+        if isinstance(other, Fwelford):
             nb = len(other)
             if nb > 0:
                 na = len(self)
@@ -579,7 +578,7 @@ class Fwelford(_FstatsBase):
                 else:
                     self._copy(self, other)
 
-        elif _isAn(other, Fcook):
+        elif isinstance(other, Fcook):
             self += other.toFwelford()
         else:
             self._iadd_other(other)
@@ -661,7 +660,7 @@ class Flinear(_FstatsNamed):
 
            @see: Method L{Flinear.fadd_}.
         '''
-        if _isAn(other, Flinear):
+        if isinstance(other, Flinear):
             if len(other) > 0:
                 if len(self) > 0:
                     n =  other._n
@@ -676,11 +675,11 @@ class Flinear(_FstatsNamed):
                     self._copy(self, other)
         else:
             try:
-                _xiterable(other)
-                self.fadd_(*other)
-            except Exception as x:
+                if _xiterable(other):
+                    self.fadd_(*other)
+            except Exception as X:
                 op = _SPACE_(self, _iadd_op_, repr(other))
-                raise _xError(x, op)
+                raise _xError(X, op)
         return self
 
     def _copy(self, d, s):
@@ -752,7 +751,7 @@ class Flinear(_FstatsNamed):
            @kwarg sample: Use C{B{sample}=True} for the I{sample} correlation
                           instead of the I{population} correlation (C{bool}).
         '''
-        return _Float(self._Correlation(**sample))
+        return float(self._Correlation(**sample))
 
     def fintercept(self, **sample):
         '''Return the current, running (sample) intercept (C{float}).
@@ -760,7 +759,7 @@ class Flinear(_FstatsNamed):
            @kwarg sample: Use C{B{sample}=True} for the I{sample} intercept
                           instead of the I{population} intercept (C{bool}).
         '''
-        return _Float(self._Intercept(**sample))
+        return float(self._Intercept(**sample))
 
     def fslope(self, **sample):
         '''Return the current, running (sample) slope (C{float}).
@@ -768,7 +767,7 @@ class Flinear(_FstatsNamed):
            @kwarg sample: Use C{B{sample}=True} for the I{sample} slope
                           instead of the I{population} slope (C{bool}).
         '''
-        return _Float(self._Slope(**sample))
+        return float(self._Slope(**sample))
 
     def _Intercept(self, **sample):
         '''(INTERNAL) Return the current (sample) intercept as L{Fsum}.