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

pygeodesy/frechet.py

@@ -84,12 +84,13 @@ than the well-known C{Hausdorff} distance, see the L{hausdorff} module.
 # from pygeodesy.basics import isscalar  # from .points
 from pygeodesy.constants import EPS, EPS1, INF, NINF
 from pygeodesy.datums import _ellipsoidal_datum, _WGS84
-from pygeodesy.errors import PointsError, _xattr, _xcallable, _xkwds, _xkwds_get
+from pygeodesy.errors import PointsError, _xattr, _xcallable, _xkwds, \
+                            _xkwds_get
 import pygeodesy.formy as _formy
 from pygeodesy.interns import NN, _DOT_, _n_, _units_
 # from pygeodesy.iters import points2 as _points2  # from .points
 from pygeodesy.lazily import _ALL_LAZY, _FOR_DOCS
-from pygeodesy.named import _Named, _NamedTuple, _Pass
+from pygeodesy.named import _name2__, _Named, _NamedTuple, _Pass
 # from pygeodesy.namedTuples import PhiLam2Tuple  # from .points
 from pygeodesy.points import _distanceTo, _fractional,  isscalar, \
                               PhiLam2Tuple, points2 as _points2, radians
@@ -102,7 +103,7 @@ from collections import defaultdict as _defaultdict
 # from math import radians  # from .points
 
 __all__ = _ALL_LAZY.frechet
-__version__ = '24.04.07'
+__version__ = '24.05.24'
 
 
 def _fraction(fraction, n):
@@ -128,36 +129,37 @@ class Frechet(_Named):
        be overloaded.
     '''
     _datum = _WGS84
-    _func  =  None  # formy function
+    _func  =  None  # formy function/property
     _f1    =  1
     _kwds  = {}     # func_ options
     _n1    =  0
     _ps1   =  None
     _units = _Str_NN  # XXX Str to _Pass and for backward compatibility
 
-    def __init__(self, point1s, fraction=None, name=NN, units=NN, **kwds):
+    def __init__(self, point1s, fraction=None, units=NN, **name__kwds):
         '''New C{Frechet...} calculator/interpolator.
 
            @arg point1s: First set of points (C{LatLon}[], L{Numpy2LatLon}[],
                          L{Tuple2LatLon}[] or C{other}[]).
            @kwarg fraction: Index fraction (C{float} in L{EPS}..L{EPS1}) to
-                            interpolate intermediate B{C{point1s}} or use
-                            C{None}, C{0} or C{1} for no intermediate
-                            B{C{point1s}} and no I{fractional} indices.
-           @kwarg name: Optional calculator/interpolator name (C{str}).
+                            interpolate intermediate B{C{point1s}} or use C{None},
+                            C{0} or C{1} for no intermediate B{C{point1s}} and no
+                            I{fractional} indices.
            @kwarg units: Optional distance units (C{Unit} or C{str}).
-           @kwarg kwds: Optional keyword argument for distance function,
+           @kwarg name__kwds: Optional C{B{name}=NN} for this calculator/interpolator
+                        (C{str}) and any keyword arguments for the distance function,
                         retrievable with property C{kwds}.
 
-           @raise FrechetError: Insufficient number of B{C{point1s}} or
-                                an invalid B{C{point1}}, B{C{fraction}}
-                                or B{C{units}}.
+           @raise FrechetError: Insufficient number of B{C{point1s}} or an invalid
+                                B{C{point1}}, B{C{fraction}} or B{C{units}}.
         '''
+        name, kwds = _name2__(**name__kwds)  # name__=self.__class__
+        if name:
+            self.name = name
+
         self._n1, self._ps1 = self._points2(point1s)
         if fraction:
             self.fraction = fraction
-        if name:
-            self.name = name
         if units:  # and not self.units:
             self.units = units
         if kwds:
@@ -246,9 +248,18 @@ class Frechet(_Named):
         '''
         self._f1 = _fraction(fraction, self._n1)
 
-    def _func(self, *args, **kwds):  # PYCHOK no cover
+#   def _func(self, *args, **kwds):  # PYCHOK no cover
+#       '''(INTERNAL) I{Must be overloaded}.'''
+#       self._notOverloaded(*args, **kwds)
+
+    @property
+    def _func(self):
         '''(INTERNAL) I{Must be overloaded}.'''
-        self._notOverloaded(*args, **kwds)
+        return _formy._Propy(self, 0, _func=None)
+
+    @_func.setter  # PYCHOK setter!
+    def _func(self, func):
+        _formy._Propy(self, 4, _func=func)
 
     @property_RO
     def kwds(self):
@@ -371,26 +382,31 @@ class _FrechetMeterRadians(Frechet):
         '''
         return self._discrete(point2s, fraction, _formy._radistance(self))
 
-    def _func_(self, *args, **kwds):  # PYCHOK no cover
+    @property
+    def _func_(self):
         '''(INTERNAL) I{Must be overloaded}.'''
-        self._notOverloaded(*args, **kwds)
+        return _formy._Propy(self, 0, _func_=None)
+
+    @_func_.setter  # PYCHOK setter!
+    def _func_(self, func):
+        _formy._Propy(self, 3, _func_=func)
 
 
 class FrechetCosineAndoyerLambert(_FrechetMeterRadians):
     '''Compute the C{Frechet} distance based on the I{angular} distance
        in C{radians} from function L{pygeodesy.cosineAndoyerLambert}.
     '''
-    def __init__(self, point1s, fraction=None, name=NN, **datum_wrap):
+    def __init__(self, point1s, **fraction_name__datum_wrap):
         '''New L{FrechetCosineAndoyerLambert} calculator/interpolator.
 
-           @kwarg datum_wrap: Optional keyword arguments for function
-                              L{pygeodesy.cosineAndoyerLambert}.
+           @kwarg fraction_name__datum_wrap: Optional C{B{fraction}=None}
+                                 and C{B{name}=NN} and keyword arguments for
+                                 function L{pygeodesy.cosineAndoyerLambert}.
 
            @see: L{Frechet.__init__} for details about B{C{point1s}},
                  B{C{fraction}}, B{C{name}} and other exceptions.
         '''
-        Frechet.__init__(self, point1s, fraction=fraction, name=name,
-                                      **datum_wrap)
+        Frechet.__init__(self, point1s, **fraction_name__datum_wrap)
         self._func  = _formy.cosineAndoyerLambert
         self._func_ = _formy.cosineAndoyerLambert_
 
@@ -402,17 +418,17 @@ class FrechetCosineForsytheAndoyerLambert(_FrechetMeterRadians):
     '''Compute the C{Frechet} distance based on the I{angular} distance
        in C{radians} from function L{pygeodesy.cosineForsytheAndoyerLambert}.
     '''
-    def __init__(self, point1s, fraction=None, name=NN, **datum_wrap):
+    def __init__(self, point1s, **fraction_name__datum_wrap):
         '''New L{FrechetCosineForsytheAndoyerLambert} calculator/interpolator.
 
-           @kwarg datum_wrap: Optional keyword arguments for function
-                              L{pygeodesy.cosineAndoyerLambert}.
+           @kwarg fraction_name__datum_wrap: Optional C{B{fraction}=None} and
+                                 C{B{name}=NN} and keyword arguments for function
+                                 L{pygeodesy.cosineForsytheAndoyerLambert}.
 
            @see: L{Frechet.__init__} for details about B{C{point1s}},
                  B{C{fraction}}, B{C{name}} and other exceptions.
         '''
-        Frechet.__init__(self, point1s, fraction=fraction, name=name,
-                                      **datum_wrap)
+        Frechet.__init__(self, point1s, **fraction_name__datum_wrap)
         self._func  = _formy.cosineForsytheAndoyerLambert
         self._func_ = _formy.cosineForsytheAndoyerLambert_
 
@@ -426,17 +442,17 @@ class FrechetCosineLaw(_FrechetMeterRadians):
 
        @note: See note at function L{pygeodesy.vincentys_}.
     '''
-    def __init__(self, point1s, fraction=None, name=NN, **radius_wrap):
+    def __init__(self, point1s, **fraction_name__radius_wrap):
         '''New L{FrechetCosineLaw} calculator/interpolator.
 
-           @kwarg radius_wrap: Optional keyword arguments for function
-                               L{pygeodesy.cosineLaw}.
+           @kwarg fraction_name__radius_wrap: Optional C{B{fraction}=None}
+                                 and C{B{name}=NN} and keyword arguments
+                                 for function L{pygeodesy.cosineLaw}.
 
            @see: L{Frechet.__init__} for details about B{C{point1s}},
                  B{C{fraction}}, B{C{name}} and other exceptions.
         '''
-        Frechet.__init__(self, point1s, fraction=fraction, name=name,
-                                      **radius_wrap)
+        Frechet.__init__(self, point1s, **fraction_name__radius_wrap)
         self._func  = _formy.cosineLaw
         self._func_ = _formy.cosineLaw_
 
@@ -450,21 +466,20 @@ class FrechetDistanceTo(Frechet):  # FrechetMeter
     '''
     _units = _Str_meter
 
-    def __init__(self, point1s, fraction=None, name=NN, **distanceTo_kwds):
+    def __init__(self, point1s, **fraction_name__distanceTo_kwds):
         '''New L{FrechetDistanceTo} calculator/interpolator.
 
-           @kwarg distanceTo_kwds: Optional keyword arguments for each
-                                   B{C{point1s}}' C{LatLon.distanceTo}
-                                   method.
+           @kwarg fraction_name__distanceTo_kwds: Optional C{B{fraction}=None}
+                                 and C{B{name}=NN} and keyword arguments for
+                                 each B{C{point1s}}' C{LatLon.distanceTo} method.
 
-           @see: L{Frechet.__init__} for details about B{C{point1s}},
-                 B{C{fraction}}, B{C{name}} and other exceptions.
+           @see: L{Frechet.__init__} for details about B{C{point1s}}, B{C{fraction}},
+                 B{C{name}} and other exceptions.
 
-           @note: All B{C{point1s}} I{must} be instances of the same
-                  ellipsoidal or spherical C{LatLon} class.
+           @note: All B{C{point1s}} I{must} be instances of the same ellipsoidal
+                  or spherical C{LatLon} class.
         '''
-        Frechet.__init__(self, point1s, fraction=fraction, name=name,
-                                      **distanceTo_kwds)
+        Frechet.__init__(self, point1s, **fraction_name__distanceTo_kwds)
 
     if _FOR_DOCS:
         discrete = Frechet.discrete
@@ -487,19 +502,19 @@ class FrechetEquirectangular(Frechet):
     '''
     _units = _Str_radians2
 
-    def __init__(self, point1s, fraction=None, name=NN, **adjust_limit_wrap):
+    def __init__(self, point1s, **fraction_name__adjust_limit_wrap):
         '''New L{FrechetEquirectangular} calculator/interpolator.
 
-           @kwarg adjust_limit_wrap: Optional keyword arguments for function
-                               L{pygeodesy.equirectangular_} I{with default}
-                               C{B{limit}=0} for I{backward compatibility}.
+           @kwarg fraction_name__adjust_limit_wrap: Optional C{B{fraction}=None}
+                                 and C{B{name}=NN} and keyword arguments for
+                                 function L{pygeodesy.equirectangular_} I{with
+                                 default} C{B{limit}=0} for I{backward compatibility}.
 
-           @see: L{Frechet.__init__} for details about B{C{point1s}},
-                 B{C{fraction}}, B{C{name}} and other exceptions.
+           @see: L{Frechet.__init__} for details about B{C{point1s}}, B{C{fraction}},
+                 B{C{name}} and other exceptions.
         '''
-        adjust_limit_wrap = _xkwds(adjust_limit_wrap, limit=0)
-        Frechet.__init__(self, point1s, fraction=fraction, name=name,
-                                      **adjust_limit_wrap)
+        Frechet.__init__(self, point1s, **_xkwds(fraction_name__adjust_limit_wrap,
+                                                 limit=0))
         self._func = _formy._equirectangular  # helper
 
     if _FOR_DOCS:
@@ -510,17 +525,17 @@ class FrechetEuclidean(_FrechetMeterRadians):
     '''Compute the C{Frechet} distance based on the I{Euclidean}
        distance in C{radians} from function L{pygeodesy.euclidean}.
     '''
-    def __init__(self, point1s, fraction=None, name=NN, **adjust_radius_wrap):  # was=True
+    def __init__(self, point1s, **fraction_name__adjust_radius_wrap):  # was=True
         '''New L{FrechetEuclidean} calculator/interpolator.
 
-           @kwarg adjust_radius_wrap: Optional keyword arguments for
-                                function L{pygeodesy.euclidean}.
+           @kwarg fraction_name__adjust_radius_wrap: Optional C{B{fraction}=None}
+                                 and C{B{name}=NN} and keyword arguments for
+                                 function L{pygeodesy.euclidean}.
 
-           @see: L{Frechet.__init__} for details about B{C{point1s}},
-                 B{C{fraction}}, B{C{name}} and other exceptions.
+           @see: L{Frechet.__init__} for details about B{C{point1s}}, B{C{fraction}},
+                 B{C{name}} and other exceptions.
         '''
-        Frechet.__init__(self, point1s, fraction=fraction, name=name,
-                                      **adjust_radius_wrap)
+        Frechet.__init__(self, point1s, **fraction_name__adjust_radius_wrap)
         self._func  = _formy.euclidean
         self._func_ = _formy.euclidean_
 
@@ -534,22 +549,22 @@ class FrechetExact(Frechet):
     '''
     _units = _Str_degrees
 
-    def __init__(self, point1s, fraction=None, name=NN, datum=None, **wrap):
+    def __init__(self, point1s, datum=None, **fraction_name__wrap):
         '''New L{FrechetExact} calculator/interpolator.
 
-           @kwarg datum: Datum to override the default C{Datums.WGS84} and
-                         first B{C{point1s}}' datum (L{Datum}, L{Ellipsoid},
-                         L{Ellipsoid2} or L{a_f2Tuple}).
-           @kwarg wrap: Optional keyword argument for method C{Inverse1}
-                        of class L{geodesicx.GeodesicExact}.
+           @kwarg datum: Datum to override the default C{Datums.WGS84} and first
+                         B{C{point1s}}' datum (L{Datum}, L{Ellipsoid}, L{Ellipsoid2}
+                         or L{a_f2Tuple}).
+           @kwarg fraction_name__wrap: Optional C{B{fraction}=None} and C{B{name}=NN}
+                                 and keyword argument for method C{Inverse1} of class
+                                 L{geodesicx.GeodesicExact}.
 
            @raise TypeError: Invalid B{C{datum}}.
 
-           @see: L{Frechet.__init__} for details about B{C{point1s}},
-                 B{C{fraction}}, B{C{name}} and other exceptions.
+           @see: L{Frechet.__init__} for details about B{C{point1s}}, B{C{fraction}},
+                 B{C{name}} and other exceptions.
         '''
-        Frechet.__init__(self, point1s, fraction=fraction, name=name,
-                                      **wrap)
+        Frechet.__init__(self, point1s, **fraction_name__wrap)
         self._datum_setter(datum)
         self._func = self.datum.ellipsoid.geodesicx.Inverse1  # note -x
 
@@ -563,19 +578,19 @@ class FrechetFlatLocal(_FrechetMeterRadians):
     '''
     _units_ = _Str_radians2  # see L{flatLocal_}
 
-    def __init__(self, point1s, fraction=None, name=NN, **datum_scaled_wrap):
+    def __init__(self, point1s, **fraction_name__datum_scaled_wrap):
         '''New L{FrechetFlatLocal}/L{FrechetHubeny} calculator/interpolator.
 
-           @kwarg datum_scaled_wrap: Optional keyword arguments for
-                                     function L{pygeodesy.flatLocal}.
+           @kwarg fraction_name__datum_scaled_wrap: Optional C{B{fraction}=None}
+                                 and C{B{name}=NN} and keyword arguments for
+                                 function L{pygeodesy.flatLocal}.
 
-           @see: L{Frechet.__init__} for details about B{C{point1s}},
-                 B{C{fraction}}, B{C{name}} and other exceptions.
+           @see: L{Frechet.__init__} for details about B{C{point1s}}, B{C{fraction}},
+                 B{C{name}} and other exceptions.
 
            @note: The distance C{units} are C{radians squared}, not C{radians}.
         '''
-        Frechet.__init__(self, point1s, fraction=fraction, name=name,
-                                      **datum_scaled_wrap)
+        Frechet.__init__(self, point1s, **fraction_name__datum_scaled_wrap)
         self._func  = _formy.flatLocal
         self._func_ =  self.datum.ellipsoid._hubeny_2
 
@@ -587,17 +602,17 @@ class FrechetFlatPolar(_FrechetMeterRadians):
     '''Compute the C{Frechet} distance based on the I{angular} distance
        in C{radians} from function L{flatPolar_}.
     '''
-    def __init__(self, point1s, fraction=None, name=NN, **radius_wrap):
+    def __init__(self, point1s, **fraction_name__radius_wrap):
         '''New L{FrechetFlatPolar} calculator/interpolator.
 
-           @kwarg radius_wrap: Optional keyword arguments for function
-                               L{pygeodesy.flatPolar}.
+           @kwarg fraction_name__radius_wrap: Optional C{B{fraction}=None}
+                                 and C{B{name}=NN} and keyword arguments
+                                 for function L{pygeodesy.flatPolar}.
 
            @see: L{Frechet.__init__} for details about B{C{point1s}},
                  B{C{fraction}}, B{C{name}} and other exceptions.
        '''
-        Frechet.__init__(self, point1s, fraction=fraction, name=name,
-                                      **radius_wrap)
+        Frechet.__init__(self, point1s, **fraction_name__radius_wrap)
         self._func  = _formy.flatPolar
         self._func_ = _formy.flatPolar_
 
@@ -611,17 +626,17 @@ class FrechetHaversine(_FrechetMeterRadians):
 
        @note: See note at function L{pygeodesy.vincentys_}.
     '''
-    def __init__(self, point1s, fraction=None, name=NN, **radius_wrap):
+    def __init__(self, point1s, **fraction_name__radius_wrap):
         '''New L{FrechetHaversine} calculator/interpolator.
 
-           @kwarg radius_wrap: Optional keyword arguments for function
-                               L{pygeodesy.haversine}.
+           @kwarg fraction_name__radius_wrap: Optional C{B{fraction}=None}
+                                 and C{B{name}=NN} and keyword arguments
+                                 for function L{pygeodesy.haversine}.
 
            @see: L{Frechet.__init__} for details about B{C{point1s}},
                  B{C{fraction}}, B{C{name}} and other exceptions.
         '''
-        Frechet.__init__(self, point1s, fraction=fraction, name=name,
-                                      **radius_wrap)
+        Frechet.__init__(self, point1s, **fraction_name__radius_wrap)
         self._func  = _formy.haversine
         self._func_ = _formy.haversine_
 
@@ -646,14 +661,15 @@ class FrechetKarney(Frechet):
     '''
     _units = _Str_degrees
 
-    def __init__(self, point1s, fraction=None, name=NN, datum=None, **wrap):
+    def __init__(self, point1s, datum=None, **fraction_name__wrap):
         '''New L{FrechetKarney} calculator/interpolator.
 
            @kwarg datum: Datum to override the default C{Datums.WGS84} and
                          first B{C{knots}}' datum (L{Datum}, L{Ellipsoid},
                          L{Ellipsoid2} or L{a_f2Tuple}).
-           @kwarg wrap: Optional keyword argument for method C{Inverse1}
-                        of class L{geodesicw.Geodesic}.
+           @kwarg fraction_name__wrap: Optional C{B{fraction}=None} and
+                                 C{B{name}=NN} and keyword arguments for
+                                 method C{Inverse1} of class L{geodesicw.Geodesic}.
 
            @raise ImportError: Package U{geographiclib
                   <https://PyPI.org/project/geographiclib>} missing.
@@ -663,8 +679,7 @@ class FrechetKarney(Frechet):
            @see: L{Frechet.__init__} for details about B{C{point1s}},
                  B{C{fraction}}, B{C{name}} and other exceptions.
         '''
-        Frechet.__init__(self, point1s, fraction=fraction, name=name,
-                                      **wrap)
+        Frechet.__init__(self, point1s, **fraction_name__wrap)
         self._datum_setter(datum)
         self._func = self.datum.ellipsoid.geodesic.Inverse1
 
@@ -676,17 +691,17 @@ class FrechetThomas(_FrechetMeterRadians):
     '''Compute the C{Frechet} distance based on the I{angular} distance
        in C{radians} from function L{pygeodesy.thomas_}.
     '''
-    def __init__(self, point1s, fraction=None, name=NN, **datum_wrap):
+    def __init__(self, point1s, **fraction_name__datum_wrap):
         '''New L{FrechetThomas} calculator/interpolator.
 
-           @kwarg datum_wrap: Optional keyword argument for function
-                              L{pygeodesy.thomas}.
+           @kwarg fraction_name__datum_wrap: Optional C{B{fraction}=None}
+                                 and C{B{name}=NN} and keyword arguments
+                                 for function L{pygeodesy.thomas}.
 
            @see: L{Frechet.__init__} for details about B{C{point1s}},
                  B{C{fraction}}, B{C{name}} and other exceptions.
         '''
-        Frechet.__init__(self, point1s, fraction=fraction, name=name,
-                                      **datum_wrap)
+        Frechet.__init__(self, point1s, **fraction_name__datum_wrap)
         self._func  = _formy.thomas
         self._func_ = _formy.thomas_
 
@@ -700,17 +715,17 @@ class FrechetVincentys(_FrechetMeterRadians):
 
        @note: See note at function L{pygeodesy.vincentys_}.
     '''
-    def __init__(self, point1s, fraction=None, name=NN, **radius_wrap):
+    def __init__(self, point1s, **fraction_name__radius_wrap):
         '''New L{FrechetVincentys} calculator/interpolator.
 
-           @kwarg radius_wrap: Optional keyword arguments for function
-                               L{pygeodesy.vincentys}.
+           @kwarg fraction_name__radius_wrap: Optional C{B{fraction}=None}
+                                 and C{B{name}=NN} and keyword arguments
+                                 for function L{pygeodesy.vincentys}.
 
            @see: L{Frechet.__init__} for details about B{C{point1s}},
                  B{C{fraction}}, B{C{name}} and other exceptions.
         '''
-        Frechet.__init__(self, point1s, fraction=fraction, name=name,
-                                      **radius_wrap)
+        Frechet.__init__(self, point1s, **fraction_name__radius_wrap)
         self._func  = _formy.vincentys
         self._func_ = _formy.vincentys_
 

pygeodesy/fstats.py

@@ -13,14 +13,15 @@ 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,  Fmt
 from pygeodesy.fsums import _2finite, Fsum, _iadd_op_, _isFsumTuple
-from pygeodesy.interns import NN, _odd_, _SPACE_
+from pygeodesy.interns import _odd_, _SPACE_
 from pygeodesy.lazily import _ALL_DOCS, _ALL_LAZY
-from pygeodesy.named import _Named, _NotImplemented, property_RO
+from pygeodesy.named import _name__, _Named, _NotImplemented, \
+                             property_RO
 # from pygeodesy.props import property_RO  # from .named
 # from pygeodesy.streprs import Fmt  # from .fmath
 
 __all__ = _ALL_LAZY.fstats
-__version__ = '24.05.10'
+__version__ = '24.05.21'
 
 
 def _2Floats(**xs):
@@ -86,10 +87,14 @@ class _FstatsNamed(_Named):
         n = _SPACE_(self.classname, n) if n else self.classname
         return Fmt.SQUARE(n, len(self))
 
-    def copy(self, deep=False, name=NN):
+    def copy(self, deep=False, **name):
         '''Copy this instance, C{shallow} or B{C{deep}}.
+
+           @kwarg name: Optional, overriding C{B{name}="copy"} (C{str}).
+
+           @return: The copy instance.
         '''
-        n =  name or self.copy.__name__
+        n = _name__(name, name__=self.copy)
         f = _Named.copy(self, deep=deep, name=n)
         return self._copy(f, self)  # PYCHOK expected
 
@@ -234,12 +239,12 @@ class Fcook(_FstatsBase):
        @see: L{Fwelford} and U{Higher-order statistics<https://
              WikiPedia.org/wiki/Algorithms_for_calculating_variance>}.
     '''
-    def __init__(self, xs=None, name=NN):
+    def __init__(self, xs=None, **name):
         '''New L{Fcook} stats accumulator.
 
            @arg xs: Iterable of additional values (each C{scalar} or
                     an L{Fsum} or L{Fsum2Tuple} instance).
-           @kwarg name: Optional name (C{str}).
+           @kwarg name: Optional C{B{name}=NN} (C{str}).
 
            @see: Method L{Fcook.fadd}.
         '''
@@ -505,10 +510,12 @@ class Fcook(_FstatsBase):
                     S *= (n + 1) / (n - 1)
         return S
 
-    def toFwelford(self, name=NN):
-        '''Return an L{Fwelford} equivalent.
+    def toFwelford(self, **name):
+        '''Return a L{Fwelford} equivalent.
+
+           @kwarg name: Optional C{B{name}=NN} (C{str}).
         '''
-        f = Fwelford(name=name or self.name)
+        f = Fwelford(name=self._name__(name))
         f._Ms = self._M1.copy(), self._M2.copy()  # deep=False
         f._n  = self._n
         return f
@@ -520,12 +527,12 @@ class Fwelford(_FstatsBase):
 
        @see: U{Cook<https://www.JohnDCook.com/blog/standard_deviation/>} and L{Fcook}.
     '''
-    def __init__(self, xs=None, name=NN):
+    def __init__(self, xs=None, **name):
         '''New L{Fwelford} stats accumulator.
 
            @arg xs: Iterable of initial values (each C{scalar} or an
                     L{Fsum} or L{Fsum2Tuple} instance).
-           @kwarg name: Optional name (C{str}).
+           @kwarg name: Optional C{B{name}=NN} (C{str}).
 
            @see: Method L{Fwelford.fadd}.
         '''
@@ -619,7 +626,7 @@ class Flinear(_FstatsNamed):
        C{RunningRegression} computing the running slope, intercept
        and correlation of a linear regression.
     '''
-    def __init__(self, xs=None, ys=None, Fstats=Fwelford, name=NN):
+    def __init__(self, xs=None, ys=None, Fstats=Fwelford, **name):
         '''New L{Flinear} regression accumulator.
 
            @kwarg xs: Iterable of initial C{x} values (each C{scalar} or
@@ -628,7 +635,7 @@ class Flinear(_FstatsNamed):
                       an L{Fsum} or L{Fsum2Tuple} instance).
            @kwarg Fstats: Class for C{xs} and C{ys} values (L{Fcook} or
                           L{Fwelford}).
-           @kwarg name: Optional name (C{str}).
+           @kwarg name: Optional C{B{name}=NN} (C{str}).
 
            @raise TypeError: B{C{Fstats}} not L{Fcook} or L{Fwelford}.