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

pygeodesy/ellipsoidalBase.py

@@ -24,8 +24,9 @@ from pygeodesy.errors import _incompatible, _IsnotError, RangeError, _TypeError,
 # from pygeodesy.fmath import favg  # _MODS
 from pygeodesy.interns import NN, _COMMA_, _ellipsoidal_
 from pygeodesy.latlonBase import LatLonBase, _trilaterate5,  fabs, _Wrap
-from pygeodesy.lazily import _ALL_DOCS, _ALL_LAZY, _ALL_MODS as _MODS
+# from pygeodesy.lazily import _ALL_DOCS, _ALL_LAZY, _ALL_MODS as _MODS  # from .named
 # from pygeodesy.lcc import toLcc  # _MODS
+from pygeodesy.named import _name1__,  _ALL_DOCS, _ALL_LAZY, _MODS
 # from pygeodesy.namedTuples import Vector3Tuple  # _MODS
 from pygeodesy.props import deprecated_method, deprecated_property_RO, \
                             Property_RO, property_doc_, property_RO, _update_all
@@ -36,7 +37,7 @@ from pygeodesy.units import Epoch, _isDegrees, Radius_, _1mm as _TOL_M
 # from math import fabs  # from .latlonBase
 
 __all__ = _ALL_LAZY.ellipsoidalBase
-__version__ = '24.04.07'
+__version__ = '24.05.21'
 
 
 class CartesianEllipsoidalBase(CartesianBase):
@@ -46,8 +47,8 @@ class CartesianEllipsoidalBase(CartesianBase):
     _epoch   =  None   # overriding .reframe.epoch (C{float})
     _reframe =  None   # reference frame (L{RefFrame})
 
-    def __init__(self, x_xyz, y=None, z=None, datum=None, reframe=None,
-                                              epoch=None, ll=None, name=NN):
+    def __init__(self, x_xyz, y=None, z=None, reframe=None, epoch=None,
+                                                       **datum_ll_name):
         '''New ellispoidal C{Cartesian...}.
 
            @kwarg reframe: Optional reference frame (L{RefFrame}).
@@ -61,9 +62,9 @@ class CartesianEllipsoidalBase(CartesianBase):
                              not a L{Datum}, B{C{reframe}} is not a L{RefFrame} or
                              B{C{epoch}} is not C{scalar} non-zero.
 
-           @see: Super-class L{CartesianBase<CartesianBase.__init__>} for more details.
+           @see: Class L{CartesianBase<CartesianBase.__init__>} for more details.
         '''
-        CartesianBase.__init__(self, x_xyz, y=y, z=z, datum=datum, ll=ll, name=name)
+        CartesianBase.__init__(self, x_xyz, y=y, z=z, **datum_ll_name)
         if reframe:
             self.reframe = reframe
             self.epoch = epoch
@@ -171,7 +172,7 @@ class CartesianEllipsoidalBase(CartesianBase):
             kwds = _xkwds(kwds, reframe=self.reframe, epoch=self.epoch)
         return CartesianBase.toLatLon(self, datum=datum, height=height, **kwds)
 
-    def toRefFrame(self, reframe2, reframe=None, epoch=None, epoch2=None, name=NN):
+    def toRefFrame(self, reframe2, reframe=None, epoch=None, epoch2=None, **name):
         '''Convert this point to an other reference frame and epoch.
 
            @arg reframe2: Reference frame to convert I{to} (L{RefFrame}).
@@ -181,7 +182,7 @@ class CartesianEllipsoidalBase(CartesianBase):
                          this point's C{epoch or B{reframe}.epoch}.
            @kwarg epoch2: Optional epoch to observe for the converted point (L{Epoch},
                           C{scalar} or C{str}), otherwise B{C{epoch}}.
-           @kwarg name: Optional name (C{str}), C{B{reframe2}.name} iff converted.
+           @kwarg name: Optional C{B{name}=NN} (C{str}), overriding C{B{reframe2}.name}.
 
            @return: The converted point (ellipsoidal C{Cartesian}) or if conversion
                     C{isunity}, this point or a copy of this point if the B{C{name}}
@@ -194,7 +195,7 @@ class CartesianEllipsoidalBase(CartesianBase):
            @raise TypeError: B{C{reframe2}} or B{C{reframe}} not a L{RefFrame}.
         '''
         return _MODS.trf._toRefFrame(self, reframe2, reframe=reframe, epoch=epoch,
-                                                      epoch2=epoch2, name=name)
+                                                     epoch2=epoch2, **name)
 
     @deprecated_method
     def toTransforms_(self, *transforms, **datum):  # PYCHOK no cover
@@ -217,8 +218,8 @@ class LatLonEllipsoidalBase(LatLonBase):
     _scale          =  None   # UTM/UPS scale factor (C{float})
     _toLLEB_args    = ()      # Etm/Utm/Ups._toLLEB arguments
 
-    def __init__(self, latlonh, lon=None, height=0, datum=None, reframe=None,
-                                          epoch=None, wrap=False, name=NN):
+    def __init__(self, latlonh, lon=None, height=0, datum=_WGS84, reframe=None,
+                                          epoch=None, wrap=False, **name):
         '''Create an ellipsoidal C{LatLon} point from the given lat-, longitude
            and height on the given datum, reference frame and epoch.
 
@@ -236,7 +237,7 @@ class LatLonEllipsoidalBase(LatLonBase):
                          if C{B{reframe}=None}.
            @kwarg wrap: If C{True}, wrap or I{normalize} B{C{lat}} and B{C{lon}}
                         (C{bool}).
-           @kwarg name: Optional name (C{str}).
+           @kwarg name: Optional C{B{name}=NN} (C{str}).
 
            @raise RangeError: Value of C{lat} or B{C{lon}} outside the valid
                               range and L{rangerrors} set to C{True}.
@@ -247,9 +248,9 @@ class LatLonEllipsoidalBase(LatLonBase):
 
            @raise UnitError: Invalid B{C{lat}}, B{C{lon}} or B{C{height}}.
         '''
-        LatLonBase.__init__(self, latlonh, lon=lon, height=height, wrap=wrap, name=name)
+        LatLonBase.__init__(self, latlonh, lon=lon, height=height, wrap=wrap, **name)
         if datum not in (None, self._datum, _EWGS84):
-            self.datum = _ellipsoidal_datum(datum, name=name)
+            self.datum = _ellipsoidal_datum(datum, name=self.name)
         if reframe:
             self.reframe = reframe
             self.epoch = epoch
@@ -736,7 +737,7 @@ class LatLonEllipsoidalBase(LatLonBase):
         return _MODS.osgr.toOsgr(self, kTM=True, name=self.name)  # datum=self.datum
 
     def parse(self, strllh, height=0, datum=None, epoch=None, reframe=None,
-                                        sep=_COMMA_, wrap=False, name=NN):
+                                        sep=_COMMA_, wrap=False, **name):
         '''Parse a string consisting of C{"lat, lon[, height]"},
            representing a similar, ellipsoidal C{LatLon} point.
 
@@ -753,7 +754,7 @@ class LatLonEllipsoidalBase(LatLonBase):
            @kwarg sep: Optional separator (C{str}).
            @kwarg wrap: If C{True}, wrap or I{normalize} the lat-
                         and longitude (C{bool}).
-           @kwarg name: Optional instance name (C{str}), overriding
+           @kwarg name: Optional C{B{name}=NN} (C{str}), overriding
                         this name.
 
            @return: The similar point (ellipsoidal C{LatLon}).
@@ -768,7 +769,7 @@ class LatLonEllipsoidalBase(LatLonBase):
             r.epoch = epoch
         if reframe not in (None, self.reframe):
             r.reframe = reframe
-        return self._xnamed(r, name=name, force=True) if name else r
+        return self._xnamed(r, force=True, **name) if name else r
 
     def _Radjust2(self, adjust, datum, meter_text2):
         '''(INTERNAL) Adjust an C{elevation} or C{geoidHeight} with
@@ -834,15 +835,15 @@ class LatLonEllipsoidalBase(LatLonBase):
            @see: Function L{pygeodesy.toCss}.
         '''
         return self._css if not toCss_kwds else _MODS.css.toCss(
-               self, **_xkwds(toCss_kwds, name=self.name))
+               self, **_name1__(toCss_kwds, _or_nameof=self))
 
-    def toDatum(self, datum2, height=None, name=NN):
+    def toDatum(self, datum2, height=None, **name):
         '''Convert this point to an other datum.
 
            @arg datum2: Datum to convert I{to} (L{Datum}).
            @kwarg height: Optional height, overriding the
                           converted height (C{meter}).
-           @kwarg name: Optional name (C{str}), iff converted.
+           @kwarg name: Optional C{B{name}=NN} (C{str}).
 
            @return: The converted point (ellipsoidal C{LatLon})
                     or a copy of this point if B{C{datum2}}
@@ -850,10 +851,10 @@ class LatLonEllipsoidalBase(LatLonBase):
 
            @raise TypeError: Invalid B{C{datum2}}.
         '''
-        n  =  name or self.name
+        n  =  self._name__(name)
         d2 = _ellipsoidal_datum(datum2, name=n)
         if self.datum == d2:
-            r = self.copy(name=name)
+            r = self.copy(name=n)
         else:
             kwds = _xkwds_not(None, LatLon=self.classof, name=n,
                                     epoch=self.epoch, reframe=self.reframe)
@@ -871,7 +872,7 @@ class LatLonEllipsoidalBase(LatLonBase):
            @see: Function L{pygeodesy.toEtm8}.
         '''
         return self._etm if not toEtm8_kwds else _MODS.etm.toEtm8(
-               self, **_xkwds(toEtm8_kwds, name=self.name))
+               self, **_name1__(toEtm8_kwds, _or_nameof=self))
 
     def toLcc(self, **toLcc_kwds):
         '''Convert this C{LatLon} point to a Lambert location.
@@ -883,7 +884,7 @@ class LatLonEllipsoidalBase(LatLonBase):
            @see: Function L{pygeodesy.toLcc}.
         '''
         return self._lcc if not toLcc_kwds else _MODS.lcc.toLcc(
-               self, **_xkwds(toLcc_kwds, name=self.name))
+               self, **_name1__(toLcc_kwds, _or_nameof=self))
 
     def toMgrs(self, center=False, pole=NN):
         '''Convert this C{LatLon} point to an MGRS coordinate.
@@ -918,7 +919,7 @@ class LatLonEllipsoidalBase(LatLonBase):
             r =  self._osgrTM if kTM else self._osgr
         return r
 
-    def toRefFrame(self, reframe2, reframe=None, epoch=None, epoch2=None, height=None, name=NN):
+    def toRefFrame(self, reframe2, reframe=None, epoch=None, epoch2=None, height=None, **name):
         '''Convert this point to an other reference frame and epoch.
 
            @arg reframe2: Reference frame to convert I{to} (L{RefFrame}).
@@ -929,7 +930,7 @@ class LatLonEllipsoidalBase(LatLonBase):
            @kwarg epoch2: Optional epoch to observe for the converted point (L{Epoch},
                           C{scalar} or C{str}), otherwise B{C{epoch}}.
            @kwarg height: Optional height, overriding the converted height (C{meter}).
-           @kwarg name: Optional name (C{str}), C{B{reframe2}.name} iff converted.
+           @kwarg name: Optional C{B{name}=NN} (C{str}), overriding C{B{reframe2}.name}.
 
            @return: The converted point (ellipsoidal C{LatLon}) or if conversion
                     C{isunity}, this point or a copy of this point if the B{C{name}}
@@ -942,7 +943,7 @@ class LatLonEllipsoidalBase(LatLonBase):
            @raise TypeError: B{C{reframe2}} or B{C{reframe}} not a L{RefFrame}.
         '''
         return _MODS.trf._toRefFrame(self, reframe2, reframe=reframe, epoch=epoch,
-                                           epoch2=epoch2, name=name, height=height)
+                                           epoch2=epoch2, height=height, **name)
 
     def toTransform(self, transform, inverse=False, datum=None, **LatLon_kwds):
         '''Apply a Helmert transform to this geodetic point.

pygeodesy/ellipsoidalBaseDI.py

@@ -17,10 +17,11 @@ 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.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 +35,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.19'
 
 _polar__  = 'polar?'
 _B2END    = _1_5  # _intersect3 bearing to pseudo-end point factor
@@ -398,12 +399,12 @@ class LatLonEllipsoidalBaseDI(LatLonEllipsoidalBase):
 
         f, j = _fi_j2(f, len(Ps))  # like .vector3d.nearestOn6
 
-        n = self.nearestOn8.__name__
+        n = self.nearestOn8.__name__  # _dunder_nameof
         c.rename(n)
         if s is not c:
             s = s.copy(name=n)
         if e is not c:
-            e = e.copy(name=n)
+            e = e.copy(name=n)  # name__=self.nearestOn8
         return NearestOn8Tuple(c, c3.distance, f, j, s, e, c3.initial, c3.final,
                                iteration=m)  # ._iteration for tests
 

pygeodesy/ellipsoidalNvector.py

@@ -31,8 +31,7 @@ from pygeodesy.ellipsoidalBase import CartesianEllipsoidalBase, \
                                      _TOL_M,  _Wrap
 from pygeodesy.errors import _IsnotError, _xkwds, _xkwds_pop2
 # from pygeodesy.fmath import fdot  # from .nvectorBase
-from pygeodesy.interns import NN, _Nv00_, _COMMASPACE_
-from pygeodesy.interns import _down_, _east_, _north_, _pole_  # PYCHOK used!
+from pygeodesy.interns import _Nv00_, _COMMASPACE_,  _pole_  # PYCHOK used!
 from pygeodesy.lazily import _ALL_LAZY, _ALL_MODS as _MODS, _ALL_OTHER
 # from pygeodesy.ltp import Ltp  # _MODS
 from pygeodesy.ltpTuples import Aer as _Aer, Ned as _Ned, Ned4Tuple, \
@@ -49,15 +48,15 @@ from pygeodesy.units import Bearing, Distance, Height, Scalar
 # from math import fabs  # from .nvectorBase
 
 __all__ = _ALL_LAZY.ellipsoidalNvector
-__version__ = '24.02.18'
+__version__ = '24.05.19'
 
 
 class Ned(_Ned):
     '''DEPRECATED on 2024.02.04, use class L{pygeodesy.Ned}.'''
 
-    def __init__(self, north, east, down, name=NN):
+    def __init__(self, north, east, down, **name):
         deprecated_class(self.__class__)
-        _Ned.__init__(self, north, east, down, name=name)
+        _Ned.__init__(self, north, east, down, **name)
 
     @deprecated_method  # PYCHOK expected
     def toRepr(self, prec=None, fmt=Fmt.SQUARE, sep=_COMMASPACE_, **unused):
@@ -434,7 +433,7 @@ class Nvector(NvectorBase):
     '''
     _datum = _WGS84  # default datum (L{Datum})
 
-    def __init__(self, x_xyz, y=None, z=None, h=0, datum=None, ll=None, name=NN):
+    def __init__(self, x_xyz, y=None, z=None, h=0, datum=None, ll=None, **name):
         '''New n-vector normal to the earth's surface.
 
            @arg x_xyz: X component of vector (C{scalar}) or (3-D) vector
@@ -449,13 +448,13 @@ class Nvector(NvectorBase):
                          (L{Datum}, L{Ellipsoid}, L{Ellipsoid2} or
                          L{a_f2Tuple}).
            @kwarg ll: Optional, original latlon (C{LatLon}).
-           @kwarg name: Optional name (C{str}).
+           @kwarg name: Optional C{B{name}=NN} (C{str}).
 
            @raise TypeError: If B{C{datum}} is not a L{Datum}.
         '''
-        NvectorBase.__init__(self, x_xyz, y=y, z=z, h=h, ll=ll, name=name)
+        NvectorBase.__init__(self, x_xyz, y=y, z=z, h=h, ll=ll, **name)
         if datum not in (None, self._datum):
-            self._datum = _ellipsoidal_datum(datum, name=name)
+            self._datum = _ellipsoidal_datum(datum, **name)
 
     @Property_RO
     def datum(self):
@@ -550,7 +549,7 @@ def meanOf(points, datum=_WGS84, height=None, wrap=False,
     # geographic mean
     m = sumOf(p._N_vector for p in Ps.iterate(closed=False))
     kwds = _xkwds(LatLon_and_kwds, height=height, datum=datum,
-                                   LatLon=LatLon, name=meanOf.__name__)
+                                   LatLon=LatLon, name__=meanOf)
     return m.toLatLon(**kwds)
 
 
@@ -618,7 +617,7 @@ def sumOf(nvectors, Vector=Nvector, h=None, **Vector_kwds):
 
 
 @deprecated_function
-def toNed(distance, bearing, elevation, Ned=Ned, name=NN):
+def toNed(distance, bearing, elevation, Ned=Ned, **name):
     '''DEPRECATED, use L{pygeodesy.Aer}C{(bearing, elevation,
        distance).xyzLocal.toNed(B{Ned}, name=B{name})} or
        L{XyzLocal}C{(pygeodesy.Aer(bearing, elevation,
@@ -633,7 +632,7 @@ def toNed(distance, bearing, elevation, Ned=Ned, name=NN):
                        frame horizontal (C{degrees}).
        @kwarg Ned: Optional class to return the NED (C{Ned}) or
                    C{None}.
-       @kwarg name: Optional name (C{str}).
+       @kwarg name: Optional C{B{name}=NN} (C{str}).
 
        @return: An NED vector equivalent to this B{C{distance}},
                 B{C{bearing}} and B{C{elevation}} (DEPRECATED L{Ned})

pygeodesy/ellipsoids.py

@@ -76,12 +76,11 @@ from pygeodesy.fmath import cbrt, cbrt2, fdot, Fhorner, fpowers, hypot, hypot_,
 from pygeodesy.interns import NN, _a_, _Airy1830_, _AiryModified_, _b_, _Bessel1841_, _beta_, \
                              _Clarke1866_, _Clarke1880IGN_, _DOT_, _f_, _GRS80_, _height_, \
                              _Intl1924_, _incompatible_, _invalid_, _Krassovski1940_, \
-                             _Krassowsky1940_, _meridional_, _lat_, _negative_, _not_, \
-                             _not_finite_, _prime_vertical_, _radius_, _Sphere_, _SPACE_, \
-                             _vs_, _WGS72_, _WGS84_
+                             _Krassowsky1940_, _lat_, _meridional_, _negative_, _not_finite_, \
+                             _prime_vertical_, _radius_, _Sphere_, _SPACE_, _vs_, _WGS72_, _WGS84_
 # from pygeodesy.lazily import _ALL_LAZY, _ALL_MODS as _MODS  # from .named
-from pygeodesy.named import _lazyNamedEnumItem as _lazy, _NamedEnum, _NamedEnumItem, \
-                            _NamedTuple, _Pass,  _ALL_LAZY, _MODS
+from pygeodesy.named import _lazyNamedEnumItem as _lazy, _name__, _name2__, _NamedEnum, \
+                                _NamedEnumItem, _NamedTuple, _Pass,  _ALL_LAZY,  _MODS
 from pygeodesy.namedTuples import Distance2Tuple, Vector3Tuple, Vector4Tuple
 from pygeodesy.props import deprecated_Property_RO, Property_RO, property_doc_, \
                             deprecated_property_RO, property_RO
@@ -93,7 +92,7 @@ from pygeodesy.utily import atan1, atan1d, atan2b, degrees90, m2radians, radians
 from math import asinh, atan, atanh, cos, degrees, exp, fabs, radians, sin, sinh, sqrt, tan
 
 __all__ = _ALL_LAZY.ellipsoids
-__version__ = '24.04.14'
+__version__ = '24.05.21'
 
 _f_0_0    = Float(f =_0_0)  # zero flattening
 _f__0_0   = Float(f_=_0_0)  # zero inverse flattening
@@ -136,7 +135,7 @@ class a_f2Tuple(_NamedTuple):
 
            @arg a: Equatorial radius (C{scalar} > 0).
            @arg f: Flattening (C{scalar} < 1, negative for I{prolate}).
-           @kwarg name: Optional name (C{str}).
+           @kwarg name: Optional C{B{name}=NN} (C{str}).
 
            @return: An L{a_f2Tuple}C{(a, f)} instance.
 
@@ -157,13 +156,15 @@ class a_f2Tuple(_NamedTuple):
         '''
         return a_f2b(self.a, self.f)  # PYCHOK .a and .f
 
-    def ellipsoid(self, name=NN):
+    def ellipsoid(self, **name):
         '''Return an L{Ellipsoid} for this 2-tuple C{(a, f)}.
 
+           @kwarg name: Optional C{B{name}=NN} (C{str}).
+
            @raise NameError: A registered C{ellipsoid} with the
                              same B{C{name}} already exists.
         '''
-        return Ellipsoid(self.a, f=self.f, name=name or self.name)  # PYCHOK .a and .f
+        return Ellipsoid(self.a, f=self.f, name=self._name__(name))  # PYCHOK .a and .f
 
     @Property_RO
     def f_(self):
@@ -215,7 +216,7 @@ class Ellipsoid(_NamedEnumItem):
     _KsOrder    =  8  # Krüger series order (4, 6 or 8)
     _rhumbsolve = NN  # means, use PYGEODESY_RHUMBSOLVE
 
-    def __init__(self, a, b=None, f_=None, f=None, name=NN):
+    def __init__(self, a, b=None, f_=None, f=None, **name):
         '''New L{Ellipsoid} from the I{equatorial} radius I{and} either
            the I{polar} radius or I{inverse flattening} or I{flattening}.
 
@@ -224,7 +225,7 @@ class Ellipsoid(_NamedEnumItem):
            @arg f_: Inverse flattening: M{a / (a - b)} (C{float} >>> 1.0).
            @arg f: Flattening: M{(a - b) / a} (C{scalar}, near zero for
                    spherical).
-           @kwarg name: Optional, unique name (C{str}).
+           @kwarg name: Optional, unique C{B{name}=NN} (C{str}).
 
            @raise NameError: Ellipsoid with the same B{C{name}} already exists.
 
@@ -234,7 +235,8 @@ class Ellipsoid(_NamedEnumItem):
            @note: M{abs(f_) > 1 / EPS} or M{abs(1 / f_) < EPS} is forced
                   to M{1 / f_ = 0}, spherical.
         '''
-        ff_ = f, f_  # assertion below
+        ff_ =  f, f_  # assertion below
+        n   = _name__(**name) if name else NN
         try:
             a = Radius_(a=a)  # low=EPS
             if not _isfinite(a):
@@ -268,7 +270,7 @@ class Ellipsoid(_NamedEnumItem):
 
         except (TypeError, ValueError) as x:
             d = _xkwds_not(None, b=b, f_=f_, f=f)
-            t =  instr(self, a=a, name=name, **d)
+            t =  instr(self, a=a, name=n, **d)
             raise _ValueError(t, cause=x)
 
         self._a  = a
@@ -276,7 +278,7 @@ class Ellipsoid(_NamedEnumItem):
         self._f  = f
         self._f_ = f_
 
-        self._register(Ellipsoids, name)
+        self._register(Ellipsoids, n)
 
         if f and f_:  # see .test/testEllipsoidal.py
             d = dict(eps=_TOL)
@@ -1023,7 +1025,7 @@ class Ellipsoid(_NamedEnumItem):
             g =  exact
             E = _xattr(g, ellipsoid=None)
             if not (E is self and isinstance(g, self._Geodesics)):
-                raise _ValueError(exact=g, ellipsoid=E, txt=_not_(self.name))
+                raise _ValueError(exact=g, ellipsoid=E, txt_not_=self.name)
         return g
 
     @property_RO
@@ -1102,7 +1104,7 @@ class Ellipsoid(_NamedEnumItem):
             v, d = _MODS.triaxials._hartzell2(pov, los, self._triaxial)
         except Exception as x:
             raise IntersectionError(pov=pov, los=los, cause=x)
-        return Vector4Tuple(v.x, v.y, v.z, d, name=self.hartzell4.__name__)
+        return Vector4Tuple(v.x, v.y, v.z, d, name__=self.hartzell4)
 
     @Property_RO
     def _hash(self):
@@ -1163,8 +1165,7 @@ class Ellipsoid(_NamedEnumItem):
             v = v.times(t)
             h = r * (_1_0 - t)
 
-        return Vector4Tuple(v.x, v.y, v.z, h, iteration=i,
-                            name=self.height4.__name__)
+        return Vector4Tuple(v.x, v.y, v.z, h, iteration=i, name__=self.height4)
 
     def _hubeny_2(self, phi2, phi1, lam21, scaled=True, squared=True):
         '''(INTERNAL) like function C{pygeodesy.flatLocal_}/C{pygeodesy.hubeny_},
@@ -1493,7 +1494,7 @@ class Ellipsoid(_NamedEnumItem):
             r =  exact
             E = _xattr(r, ellipsoid=None)
             if not (E is self and isinstance(r, self._Rhumbs)):
-                raise _ValueError(exact=r, ellipsosid=E, txt=_not_(self.name))
+                raise _ValueError(exact=r, ellipsosid=E, txt_not_=self.name)
         return r
 
     @property_RO
@@ -1807,42 +1808,45 @@ class Ellipsoid(_NamedEnumItem):
             (sqrt((_3_0 * self.a2_b2 + _1_0) * _0_25) * b) if a < b else a)
         return Radius(Rtriaxial=q)
 
-    def toEllipsoid2(self, name=NN):
+    def toEllipsoid2(self, **name):
         '''Get a copy of this ellipsoid as an L{Ellipsoid2}.
 
-           @kwarg name: Optional, unique name (C{str}).
+           @kwarg name: Optional, unique C{B{name}=NN} (C{str}).
 
            @see: Property C{a_f}.
         '''
-        return Ellipsoid2(self, None, name=name)
+        return Ellipsoid2(self, None, **name)
 
-    def toStr(self, prec=8, terse=0, name=NN, **unused):  # PYCHOK expected
+    def toStr(self, prec=8, terse=0, **name):  # PYCHOK expected
         '''Return this ellipsoid as a text string.
 
            @kwarg prec: Number of decimal digits, unstripped (C{int}).
            @kwarg terse: Limit the number of items (C{int}, 0...18).
-           @kwarg name: Override name (C{str}) or C{None} to exclude
-                        this ellipsoid's name.
+           @kwarg name: Optional C{B{name}=NN} (C{str}) or C{None} to
+                        exclude this ellipsoid's name.
 
            @return: This C{Ellipsoid}'s attributes (C{str}).
         '''
         E = Ellipsoid
-        t = E.a, E.b, E.f_, E.f, E.f2, E.n, E.e, E.e2, E.e21, E.e22, E.e32, \
+        t = E.a, E.b, E.f_, E.f,  E.f2, E.n, E.e,   E.e2, E.e21, E.e22, E.e32, \
             E.A, E.L, E.R1, E.R2, E.R3, E.Rbiaxial, E.Rtriaxial
         if terse:
             t = t[:terse]
-        return self._instr(name, prec, props=t)
+        n, _ = _name2__(**name)  # name=None
+        return self._instr(n, prec, props=t)
 
-    def toTriaxial(self, name=NN):
+    def toTriaxial(self, **name):
         '''Convert this ellipsoid to a L{Triaxial_}.
 
+           @kwarg name: Optional C{B{name}=NN} (C{str}).
+
            @return: A L{Triaxial_} or L{Triaxial} with the C{X} axis
                     pointing east and C{Z} pointing north.
 
            @see: Method L{Triaxial_.toEllipsoid}.
         '''
         T = self._triaxial
-        return T.copy(name=name) if name else T
+        return T.copy(**name) if name else T
 
     @property_RO
     def _triaxial(self):
@@ -1864,12 +1868,14 @@ class Ellipsoid(_NamedEnumItem):
 class Ellipsoid2(Ellipsoid):
     '''An L{Ellipsoid} specified by I{equatorial} radius and I{flattening}.
     '''
-    def __init__(self, a, f, name=NN):
+    def __init__(self, a, f=None, **name):
         '''New L{Ellipsoid2}.
 
-           @arg a: Equatorial radius, semi-axis (C{meter}).
-           @arg f: Flattening: (C{float} < 1.0, negative for I{prolate}).
-           @kwarg name: Optional, unique name (C{str}).
+           @arg a: Equatorial radius, semi-axis (C{meter}) or a previous
+                   L{Ellipsoid} instance.
+           @arg f: Flattening: (C{float} < 1.0, negative for I{prolate}),
+                   if B{C{a}} is in C{meter}.
+           @kwarg name: Optional, unique C{B{name}=NN} (C{str}).
 
            @raise NameError: Ellipsoid with that B{C{name}} already exists.
 
@@ -1880,9 +1886,9 @@ class Ellipsoid2(Ellipsoid):
         '''
         if f is None and isinstance(a, Ellipsoid):
             Ellipsoid.__init__(self, a.a,   f =a.f,
-                                     b=a.b, f_=a.f_, name=name)
+                                     b=a.b, f_=a.f_, **name)
         else:
-            Ellipsoid.__init__(self, a, f=f, name=name)
+            Ellipsoid.__init__(self, a, f=f, **name)
 
 
 def _spherical_a_b(a, b):

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.18'
 
 _TolRD  =  zqrt(EPS * 0.002)
 _TolRF  =  zqrt(EPS * 0.030)
@@ -138,10 +139,10 @@ class Elliptic(_Named):
 #   _k2      = 0
 #   _kp2     = 0
 
-    def __init__(self, k2=0, alpha2=0, kp2=None, alphap2=None, name=NN):
+    def __init__(self, k2=0, alpha2=0, kp2=None, alphap2=None, **name):
         '''Constructor, specifying the C{modulus} and C{parameter}.
 
-           @kwarg name: Optional name (C{str}).
+           @kwarg name: Optional C{B{name}=NN} (C{str}).
 
            @see: Method L{Elliptic.reset} for further details.
 
@@ -151,7 +152,6 @@ class Elliptic(_Named):
                   E(φ, k)} and C{H(φ, 0, k) = F(φ, k) - D(φ, k)}.
         '''
         self.reset(k2=k2, alpha2=alpha2, kp2=kp2, alphap2=alphap2)
-
         if name:
             self.name = name
 
@@ -402,10 +402,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 +415,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/epsg.py

@@ -28,7 +28,7 @@ from pygeodesy.utmupsBase import _to3zBhp, _UPS_ZONE, _UTM_ZONE_MIN, \
                                  _UTM_ZONE_MAX, _UTMUPS_ZONE_INVALID
 
 __all__ = _ALL_LAZY.epsg
-__version__ = '22.09.24'
+__version__ = '24.05.18'
 
 # _EPSG_INVALID = _UTMUPS_ZONE_INVALID
 _EPSG_N_01 = 32601  # EPSG code for UTM zone 01 N
@@ -49,11 +49,12 @@ class Epsg(Int):
     _utmups     =  None
     _zone       = _UTMUPS_ZONE_INVALID
 
-    def __new__(cls, eisu, name=NN):
+    def __new__(cls, eisu, **name):
         '''New L{Epsg} (I{European Petroleum Survey Group}) code from a
            UTM/USP coordinate or other EPSG code.
 
            @arg eisu: Other code (L{Epsg}, C{int}, C{str}, L{Utm} or L{Ups}).
+           @kwarg name: Optional C{B{name}=NN} (C{str}).
 
            @return: New L{Epsg}.
 
@@ -88,7 +89,7 @@ class Epsg(Int):
                 self.name = u.name
 
         if name:
-            self.name = name
+            self.rename(name)
         return self
 
     def __repr__(self):