[()] returns view if ndim > 0, else return scalar

scivision · scivision · commit e85262584da9 · 2020-01-26T22:18:51.000-05:00
https://docs.scipy.org/doc/numpy/reference/arrays.indexing.html#detailed-notes
diff --git a/pymap3d/ecef.py b/pymap3d/ecef.py
@@ -74,7 +74,8 @@ def ecef2geodetic(
 ) -> typing.Tuple["ndarray", "ndarray", "ndarray"]:
     if vectorize is not None:
         fun = vectorize(ecef2geodetic_point)
-        return fun(x, y, z, ell, deg)
+        lat, lon, alt = fun(x, y, z, ell, deg)
+        return lat[()], lon[()], alt[()]
     else:
         return ecef2geodetic_point(x, y, z, ell, deg)
 
@@ -102,7 +103,7 @@ def ecef2geodetic_point(x: float, y: float, z: float, ell: Ellipsoid = None, deg
            target geodetic latitude
     lon : float
            target geodetic longitude
-    h : float
+    alt : float
          target altitude above geodetic ellipsoid (meters)
 
     based on:
diff --git a/pymap3d/enu.py b/pymap3d/enu.py
@@ -48,7 +48,8 @@ def enu2aer(e: "ndarray", n: "ndarray", u: "ndarray", deg: bool = True) -> typin
     """
     if vectorize is not None:
         fun = vectorize(enu2aer_point)
-        return fun(e, n, u, deg)
+        az, el, rng = fun(e, n, u, deg)
+        return az[()], el[()], rng[()]
     else:
         return enu2aer_point(e, n, u, deg)
 
@@ -79,7 +80,8 @@ def enu2aer_point(e: "ndarray", n: "ndarray", u: "ndarray", deg: bool = True) ->
 def aer2enu(az: "ndarray", el: "ndarray", srange: "ndarray", deg: bool = True) -> typing.Tuple["ndarray", "ndarray", "ndarray"]:
     if vectorize is not None:
         fun = vectorize(aer2enu_point)
-        return fun(az, el, srange, deg)
+        e, n, u = fun(az, el, srange, deg)
+        return e[()], n[()], u[()]
     else:
         return aer2enu_point(az, el, srange, deg)
 
diff --git a/pymap3d/latitude.py b/pymap3d/latitude.py
@@ -205,7 +205,7 @@ def geodetic2isometric(geodetic_lat: "ndarray", ell: Ellipsoid = None, deg: bool
     """
     if use_numpy:
         fun = vectorize(geodetic2isometric_point)
-        return fun(geodetic_lat, ell, deg)
+        return fun(geodetic_lat, ell, deg)[()]
     else:
         return geodetic2isometric_point(geodetic_lat, ell, deg)
 
@@ -320,7 +320,7 @@ def geodetic2conformal(geodetic_lat: "ndarray", ell: Ellipsoid = None, deg: bool
     """
     if use_numpy:
         fun = vectorize(geodetic2conformal_point)
-        return fun(geodetic_lat, ell, deg)
+        return fun(geodetic_lat, ell, deg)[()]
     else:
         return geodetic2conformal_point(geodetic_lat, ell, deg)
 
diff --git a/pymap3d/los.py b/pymap3d/los.py
@@ -46,9 +46,9 @@ def lookAtSpheroid(
     Results
     -------
 
-    lat0 : "ndarray"
+    lat : "ndarray"
            geodetic latitude where the line-of-sight intersects with the Earth ellipsoid
-    lon0 : "ndarray"
+    lon : "ndarray"
            geodetic longitude where the line-of-sight intersects with the Earth ellipsoid
     d : "ndarray"
         slant range (meters) from starting point to intersect point
@@ -59,7 +59,8 @@ def lookAtSpheroid(
     """
     if vectorize is not None:
         fun = vectorize(lookAtSpheroid_point)
-        return fun(lat0, lon0, h0, az, tilt, ell, deg)
+        lat, lon, d = fun(lat0, lon0, h0, az, tilt, ell, deg)
+        return lat[()], lon[()], d[()]
     else:
         return lookAtSpheroid_point(lat0, lon0, h0, az, tilt, ell, deg)
 
diff --git a/pymap3d/lox.py b/pymap3d/lox.py
@@ -116,7 +116,8 @@ def loxodrome_inverse(
     """
     if vectorize is not None:
         fun = vectorize(loxodrome_inverse_point)
-        return fun(lat1, lon1, lat2, lon2, ell, deg)
+        lox, az = fun(lat1, lon1, lat2, lon2, ell, deg)
+        return lox[()], az[()]
     else:
         return loxodrome_inverse_point(lat1, lon1, lat2, lon2, ell, deg)
 
@@ -179,7 +180,8 @@ def loxodrome_direct(
     """
     if vectorize is not None:
         fun = vectorize(loxodrome_direct_point)
-        return fun(lat1, lon1, rng, a12, ell, deg)
+        lat2, lon2 = fun(lat1, lon1, rng, a12, ell, deg)
+        return lat2[()], lon2[()]
     else:
         return loxodrome_direct_point(lat1, lon1, rng, a12, ell, deg)
 
diff --git a/pymap3d/vincenty.py b/pymap3d/vincenty.py
@@ -96,7 +96,8 @@ def vdist(
     """
     if numpy is not None:
         fun = numpy.vectorize(vdist_point)
-        return fun(Lat1, Lon1, Lat2, Lon2, ell)
+        dist, az = fun(Lat1, Lon1, Lat2, Lon2, ell)
+        return dist[()], az[()]
     else:
         return vdist_point(Lat1, Lon1, Lat2, Lon2, ell)
 
diff --git a/setup.cfg b/setup.cfg
@@ -1,6 +1,6 @@
 [metadata]
 name = pymap3d
-version = 2.2.0
+version = 2.3.0
 author = Michael Hirsch, Ph.D.
 author_email = scivision@users.noreply.github.com
 description = pure Python (no prereqs) coordinate conversions, following convention of several popular Matlab routines.
diff --git a/tests/test_aer.py b/tests/test_aer.py
@@ -46,15 +46,28 @@ def test_ecef2aer(xyz, lla, aer):
 
 @pytest.mark.parametrize("aer,enu", [((33, 70, 1000), (186.2775, 286.8422, 939.6926))])
 def test_aer_enu(aer, enu):
-    assert pm.aer2enu(*aer) == approx(enu)
+    e, n, u = pm.aer2enu(*aer)
+    assert e == approx(enu[0])
+    assert n == approx(enu[1])
+    assert u == approx(enu[2])
+    assert isinstance(e, float)
+    assert isinstance(n, float)
+    assert isinstance(u, float)
 
     raer = (radians(aer[0]), radians(aer[1]), aer[2])
     assert pm.aer2enu(*raer, deg=False) == approx(enu)
 
     with pytest.raises(ValueError):
         pm.aer2enu(aer[0], aer[1], -1)
 
-    assert pm.enu2aer(*enu) == approx(aer)
+    a, e, r = pm.enu2aer(*enu)
+    assert a == approx(aer[0])
+    assert e == approx(aer[1])
+    assert r == approx(aer[2])
+    assert isinstance(a, float)
+    assert isinstance(e, float)
+    assert isinstance(r, float)
+
     assert pm.enu2aer(*enu, deg=False) == approx(raer)
 
 
diff --git a/tests/test_enu.py b/tests/test_enu.py
@@ -37,6 +37,9 @@ def test_enu_ecef(enu, lla, xyz):
     assert x == approx(xyz[0])
     assert y == approx(xyz[1])
     assert z == approx(xyz[2])
+    assert isinstance(x, float)
+    assert isinstance(y, float)
+    assert isinstance(z, float)
 
     rlla = (radians(lla[0]), radians(lla[1]), lla[2])
     assert pm.enu2ecef(*enu, *rlla, deg=False) == approx(xyz)
@@ -45,6 +48,9 @@ def test_enu_ecef(enu, lla, xyz):
     assert e == approx(enu[0])
     assert n == approx(enu[1])
     assert u == approx(enu[2])
+    assert isinstance(e, float)
+    assert isinstance(n, float)
+    assert isinstance(u, float)
 
     e, n, u = pm.ecef2enu(*xyz, *rlla, deg=False)
     assert e == approx(enu[0])
diff --git a/tests/test_geodetic.py b/tests/test_geodetic.py
@@ -146,7 +146,13 @@ def test_ecef2geodetic(xyz, lla):
     [((33, 77, 1000), (42.0016981935, -81.99852, 1174.374035), (42, -82, 200)), ((0, 90, 10000), (0, 0, 10000), (0, 0, 0))],
 )
 def test_aer_geodetic(aer, lla, lla0):
-    assert pm.aer2geodetic(*aer, *lla0) == approx(lla)
+    lat1, lon1, alt1 = pm.aer2geodetic(*aer, *lla0)
+    assert lat1 == approx(lla[0])
+    assert lon1 == approx(lla[1])
+    assert alt1 == approx(lla[2])
+    assert isinstance(lat1, float)
+    assert isinstance(lon1, float)
+    assert isinstance(alt1, float)
 
     raer = (radians(aer[0]), radians(aer[1]), aer[2])
     rlla0 = (radians(lla0[0]), radians(lla0[1]), lla0[2])
diff --git a/tests/test_latitude.py b/tests/test_latitude.py
@@ -39,7 +39,10 @@ def test_numpy_geodetic_geocentric():
     "geodetic_lat, isometric_lat", [(0, 0), (90, inf), (-90, -inf), (45, 50.227466), (-45, -50.227466), (89, 271.275)]
 )
 def test_geodetic_isometric(geodetic_lat, isometric_lat):
-    assert pm.geodetic2isometric(geodetic_lat) == approx(isometric_lat)
+    isolat = pm.geodetic2isometric(geodetic_lat)
+    assert isolat == approx(isometric_lat)
+    assert isinstance(isolat, float)
+
     assert pm.geodetic2isometric(radians(geodetic_lat), deg=False) == approx(radians(isometric_lat))
 
     assert pm.isometric2geodetic(isometric_lat) == approx(geodetic_lat)
@@ -56,7 +59,10 @@ def test_numpy_geodetic_isometric():
     "geodetic_lat,conformal_lat", [(0, 0), (90, 90), (-90, -90), (45, 44.80768406), (-45, -44.80768406), (89, 88.99327)]
 )
 def test_geodetic_conformal(geodetic_lat, conformal_lat):
-    assert pm.geodetic2conformal(geodetic_lat) == approx(conformal_lat)
+    clat = pm.geodetic2conformal(geodetic_lat)
+    assert clat == approx(conformal_lat)
+    assert isinstance(clat, float)
+
     assert pm.geodetic2conformal(radians(geodetic_lat), deg=False) == approx(radians(conformal_lat))
 
     assert pm.conformal2geodetic(conformal_lat) == approx(geodetic_lat)
diff --git a/tests/test_look_spheroid.py b/tests/test_look_spheroid.py
@@ -13,6 +13,9 @@ def test_losint():
     lat, lon, sr = pm.lookAtSpheroid(*lla0, az[1], tilt=0.0)
 
     assert (lat, lon, sr) == approx(lla0)
+    assert isinstance(lat, float)
+    assert isinstance(lon, float)
+    assert isinstance(sr, float)
 
     with pytest.raises(ValueError):
         pm.lookAtSpheroid(lla0[0], lla0[1], -1, az, 0)
diff --git a/tests/test_ned.py b/tests/test_ned.py
@@ -33,22 +33,28 @@ def test_enuv_nedv():
 
 
 def test_ned_geodetic():
-    lla = pm.aer2geodetic(*aer0, *lla0)
+    lat1, lon1, alt1 = pm.aer2geodetic(*aer0, *lla0)
 
-    enu3 = pm.geodetic2enu(*lla, *lla0)
+    enu3 = pm.geodetic2enu(lat1, lon1, alt1, *lla0)
     ned3 = (enu3[1], enu3[0], -enu3[2])
 
-    assert pm.geodetic2ned(*lla, *lla0) == approx(ned3)
+    assert pm.geodetic2ned(lat1, lon1, alt1, *lla0) == approx(ned3)
 
     lat, lon, alt = pm.enu2geodetic(*enu3, *lla0)
-    assert lat == approx(lla[0])
-    assert lon == approx(lla[1])
-    assert alt == approx(lla[2])
+    assert lat == approx(lat1)
+    assert lon == approx(lon1)
+    assert alt == approx(alt1)
+    assert isinstance(lat, float)
+    assert isinstance(lon, float)
+    assert isinstance(alt, float)
 
     lat, lon, alt = pm.ned2geodetic(*ned3, *lla0)
-    assert lat == approx(lla[0])
-    assert lon == approx(lla[1])
-    assert alt == approx(lla[2])
+    assert lat == approx(lat1)
+    assert lon == approx(lon1)
+    assert alt == approx(alt1)
+    assert isinstance(lat, float)
+    assert isinstance(lon, float)
+    assert isinstance(alt, float)
 
 
 if __name__ == "__main__":
diff --git a/tests/test_rhumb.py b/tests/test_rhumb.py
@@ -50,6 +50,8 @@ def test_loxodrome_inverse(lat1, lon1, lat2, lon2, arclen, az):
 
     assert rhdist == approx(arclen)
     assert rhaz == approx(az)
+    assert isinstance(rhdist, float)
+    assert isinstance(rhaz, float)
 
 
 def test_numpy_loxodrome_inverse():
@@ -75,6 +77,8 @@ def test_loxodrome_direct(lat0, lon0, rng, az, lat1, lon1):
     lat2, lon2 = pm.loxodrome_direct(lat0, lon0, rng, az)
     assert lat2 == approx(lat1, abs=1e-6)
     assert lon2 == approx(lon1)
+    assert isinstance(lat2, float)
+    assert isinstance(lon2, float)
 
 
 def test_numpy_loxodrome_direct():
diff --git a/tests/test_vincenty_dist.py b/tests/test_vincenty_dist.py
@@ -27,6 +27,9 @@ def test_unit(lat, lon, lat1, lon1, srange, az):
     assert dist == approx(srange, rel=0.005)
     assert az1 == approx(az)
 
+    assert isinstance(dist, float)
+    assert isinstance(az1, float)
+
 
 def test_vector():
     pytest.importorskip("numpy")
