pygeodesy 24.5.15__py2.py3-none-any.whl → 24.6.1__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.31'
 
 
 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,25 +737,23 @@ 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.
 
-           @arg strllh: Lat, lon and optional height (C{str}),
-                        see function L{pygeodesy.parse3llh}.
-           @kwarg height: Optional, default height (C{meter} or
-                          C{None}).
-           @kwarg datum: Optional datum (L{Datum}), overriding this
-                         datum I{without conversion}.
-           @kwarg epoch: Optional datum (L{Epoch}), overriding this
-                         epoch I{without conversion}.
-           @kwarg reframe: Optional datum (L{RefFrame}), overriding
-                           this reframe I{without conversion}.
+           @arg strllh: Lat, lon and optional height (C{str}), see function
+                        L{pygeodesy.parse3llh}.
+           @kwarg height: Optional, default height (C{meter} or C{None}).
+           @kwarg datum: Optional datum (L{Datum}), overriding this datum
+                         I{without conversion}.
+           @kwarg epoch: Optional datum (L{Epoch}), overriding this epoch
+                         I{without conversion}.
+           @kwarg reframe: Optional datum (L{RefFrame}), overriding this
+                           reframe I{without conversion}.
            @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
-                        this name.
+           @kwarg wrap: If C{True}, wrap or I{normalize} the lat- and
+                        longitude (C{bool}).
+           @kwarg name: Optional C{B{name}=NN} (C{str}), overriding this name.
 
            @return: The similar point (ellipsoidal C{LatLon}).
 
@@ -768,7 +767,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 +833,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 +849,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 +870,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 +882,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.
@@ -913,12 +912,13 @@ class LatLonEllipsoidalBase(LatLonBase):
            @see: Function L{pygeodesy.toOsgr}.
         '''
         if toOsgr_kwds:
-            r = _MODS.osgr.toOsgr(self, kTM=kTM, **_xkwds(toOsgr_kwds, name=self.name))
+            kwds = _name1__(toOsgr_kwds, _or_nameof=self)
+            r = _MODS.osgr.toOsgr(self, kTM=kTM, **kwds)
         else:
             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 +929,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 +942,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,7 +17,6 @@ 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.internals import _dunder_nameof  # from .lazily
 from pygeodesy.interns import _antipodal_, _concentric_, _ellipsoidal_, \
                               _exceed_PI_radians_, _low_, _near_, \
                               _SPACE_, _too_
@@ -36,7 +35,7 @@ from pygeodesy.utily import m2km, unroll180, _unrollon, _unrollon3, \
 from math import degrees, radians
 
 __all__ = _ALL_LAZY.ellipsoidalBaseDI
-__version__ = '24.05.13'
+__version__ = '24.05.19'
 
 _polar__  = 'polar?'
 _B2END    = _1_5  # _intersect3 bearing to pseudo-end point factor
@@ -400,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/ellipsoidalGeodSolve.py

@@ -24,7 +24,7 @@ from pygeodesy.points import _areaError, ispolar  # PYCHOK exported
 # from math import fabs  # from .karney
 
 __all__ = _ALL_LAZY.ellipsoidalGeodSolve
-__version__ = '24.02.21'
+__version__ = '24.05.25'
 
 
 class Cartesian(CartesianEllipsoidalBase):
@@ -76,7 +76,7 @@ class LatLon(LatLonEllipsoidalBaseDI):
            @kwarg Cartesian_datum_kwds: Optional L{Cartesian}, B{C{datum}}
                   and other keyword arguments, ignored if C{B{Cartesian} is None}.
                   Use C{B{Cartesian}=...} to override this L{Cartesian} class
-                  or set C{B{Cartesian} is None}.
+                  or set C{B{Cartesian}=None}.
 
            @return: The cartesian (ECEF) coordinates (L{Cartesian}) or if
                     B{C{Cartesian}} is C{None}, an L{Ecef9Tuple}C{(x, y, z,

pygeodesy/ellipsoidalKarney.py

@@ -43,7 +43,7 @@ from pygeodesy.props import deprecated_method, Property_RO
 # from math import fabs  # from .karney
 
 __all__ = _ALL_LAZY.ellipsoidalKarney
-__version__ = '24.02.21'
+__version__ = '24.05.25'
 
 
 class Cartesian(CartesianEllipsoidalBase):
@@ -105,8 +105,8 @@ class LatLon(LatLonEllipsoidalBaseDI):
 
            @kwarg Cartesian_datum_kwds: Optional L{Cartesian}, B{C{datum}}
                   and other keyword arguments, ignored if C{B{Cartesian} is None}.
-                  Use C{B{Cartesian}=...} to override this L{Cartesian} class
-                  or set C{B{Cartesian} is None}.
+                  Use C{B{Cartesian}=...} to override this L{Cartesian} class or
+                  set C{B{Cartesian}=None}.
 
            @return: The cartesian (ECEF) coordinates (L{Cartesian}) or if
                     B{C{Cartesian}} is C{None}, an L{Ecef9Tuple}C{(x, y, z,

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,16 +76,16 @@ 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
 from pygeodesy.streprs import Fmt, fstr, instr, strs, unstr
+# from pygeodesy.triaxials import _hartzell3  # _MODS
 from pygeodesy.units import Bearing_, Distance, Float, Float_, Height, Lam_, Lat, Meter, \
                             Meter2, Meter3, Phi, Phi_, Radius, Radius_, Scalar
 from pygeodesy.utily import atan1, atan1d, atan2b, degrees90, m2radians, radians2m, sincos2d
@@ -93,7 +93,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.28'
 
 _f_0_0    = Float(f =_0_0)  # zero flattening
 _f__0_0   = Float(f_=_0_0)  # zero inverse flattening
@@ -136,7 +136,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 +157,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 +217,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 +226,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 +236,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 +271,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 +279,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 +1026,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
@@ -1099,10 +1102,10 @@ class Ellipsoid(_NamedEnumItem):
                  methods L{Ellipsoid.height4} and L{Triaxial.hartzell4}.
         '''
         try:
-            v, d = _MODS.triaxials._hartzell2(pov, los, self._triaxial)
+            v, d, _ = _MODS.triaxials._hartzell3(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 +1166,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 +1495,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
@@ -1642,9 +1644,9 @@ class Ellipsoid(_NamedEnumItem):
             r = self.e2s2(sin(a))
             if r > EPS02:
                 n = self.a / sqrt(r)
-                m = n * self.e21 / r  # PYCHOK attr
+                m = n * self.e21 / r
             else:
-                m = n = _0_0  # PYCHOK attr
+                m = n = _0_0
         else:
             m = n = self.a
         if scaled and a:
@@ -1807,42 +1809,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 +1869,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 +1887,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

@@ -98,7 +98,7 @@ from math import asinh, atan, atan2, ceil, cosh, fabs, floor, \
                  radians, sin, sqrt, tanh
 
 __all__ = _ALL_LAZY.elliptic
-__version__ = '24.05.13'
+__version__ = '24.05.18'
 
 _TolRD  =  zqrt(EPS * 0.002)
 _TolRF  =  zqrt(EPS * 0.030)
@@ -139,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.
 
@@ -152,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