healpix-geo 0.0.4__cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl → 0.0.5__cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl

healpix_geo/nested.py

@@ -10,6 +10,171 @@ def create_empty(depth):
     return RangeMOCIndex.create_empty(depth)
 
 
+def healpix_to_lonlat(ipix, depth, ellipsoid, num_threads=0):
+    r"""Get the longitudes and latitudes of the center of some HEALPix cells.
+
+    Parameters
+    ----------
+    ipix : `numpy.ndarray`
+        The HEALPix cell indexes given as a `np.uint64` numpy array.
+    depth : `numpy.ndarray`
+        The HEALPix cell depth given as a `np.uint8` numpy array.
+    ellipsoid : str, default: "sphere"
+        Reference ellipsoid to evaluate healpix on. If ``"sphere"``, this will return
+        the same result as :py:func:`cdshealpix.nested.healpix_to_lonlat`.
+    num_threads : int, optional
+        Specifies the number of threads to use for the computation. Default to 0 means
+        it will choose the number of threads based on the RAYON_NUM_THREADS environment variable (if set),
+        or the number of logical CPUs (otherwise)
+
+    Returns
+    -------
+    lon, lat : array-like
+        The coordinates of the center of the HEALPix cells given as a longitude, latitude tuple.
+
+    Raises
+    ------
+    ValueError
+        When the HEALPix cell indexes given have values out of :math:`[0, 4^{29 - depth}[`.
+    ValueError
+        When the name of the ellipsoid is unknown.
+
+    Examples
+    --------
+    >>> from healpix_geo.nested import healpix_to_lonlat
+    >>> import numpy as np
+    >>> cell_ids = np.array([42, 6, 10])
+    >>> depth = 3
+    >>> lon, lat = healpix_to_lonlat(ipix, depth, ellipsoid="WGS84")
+    """
+    _check_depth(depth)
+    ipix = np.atleast_1d(ipix)
+    _check_ipixels(data=ipix, depth=depth)
+    ipix = ipix.astype(np.uint64)
+
+    num_threads = np.uint16(num_threads)
+
+    latitude = np.empty_like(ipix, dtype="float64")
+    longitude = np.empty_like(ipix, dtype="float64")
+
+    healpix_geo.nested.healpix_to_lonlat(
+        depth, ipix, ellipsoid, longitude, latitude, num_threads
+    )
+
+    return longitude, latitude
+
+
+def lonlat_to_healpix(longitude, latitude, depth, ellipsoid="sphere", num_threads=0):
+    r"""Get the HEALPix indexes that contains specific points.
+
+    Parameters
+    ----------
+    lon : array-like
+        The longitudes of the input points, in degrees.
+    lat : array-like
+        The latitudes of the input points, in degrees.
+    depth : int or array-like of int
+        The HEALPix cell depth given as a `np.uint8` numpy array.
+    ellipsoid : str, default: "sphere"
+        Reference ellipsoid to evaluate healpix on. If ``"sphere"``, this will return
+        the same result as :py:func:`cdshealpix.nested.lonlat_to_healpix`.
+    num_threads : int, optional
+        Specifies the number of threads to use for the computation. Default to 0 means
+        it will choose the number of threads based on the RAYON_NUM_THREADS environment variable (if set),
+        or the number of logical CPUs (otherwise)
+
+    Returns
+    -------
+    ipix : `numpy.ndarray`
+        A numpy array containing all the HEALPix cell indexes stored as `np.uint64`.
+
+    Raises
+    ------
+    ValueError
+        When the number of longitudes and latitudes given do not match.
+    ValueError
+        When the name of the ellipsoid is unknown.
+
+    Examples
+    --------
+    >>> from cdshealpix.ring import lonlat_to_healpix
+    >>> import numpy as np
+    >>> lon = np.array([0, 50, 25], dtype="float64")
+    >>> lat = np.array([6, -12, 45], dtype="float64")
+    >>> depth = 3
+    >>> ipix = lonlat_to_healpix(lon, lat, depth, ellipsoid="WGS84")
+    """
+    _check_depth(depth)
+    longitude = np.atleast_1d(longitude).astype("float64")
+    latitude = np.atleast_1d(latitude).astype("float64")
+
+    num_threads = np.uint16(num_threads)
+
+    ipix = np.empty_like(longitude, dtype="uint64")
+
+    healpix_geo.nested.lonlat_to_healpix(
+        depth, longitude, latitude, ellipsoid, ipix, num_threads
+    )
+
+    return ipix
+
+
+def vertices(ipix, depth, ellipsoid, num_threads=0):
+    """Get the longitudes and latitudes of the vertices of some HEALPix cells at a given depth.
+
+    This method returns the 4 vertices of each cell in `ipix`.
+
+    Parameters
+    ----------
+    ipix : `numpy.ndarray`
+        The HEALPix cell indexes given as a `np.uint64` numpy array.
+    depth : int, or `numpy.ndarray`
+        The depth of the HEALPix cells. If given as an array, should have the same shape than ipix
+    ellipsoid : str, default: "sphere"
+        Reference ellipsoid to evaluate healpix on. If ``"sphere"``, this will return
+        the same result as :py:func:`cdshealpix.nested.vertices`.
+    num_threads : int, optional
+        Specifies the number of threads to use for the computation. Default to 0 means
+        it will choose the number of threads based on the RAYON_NUM_THREADS environment variable (if set),
+        or the number of logical CPUs (otherwise)
+
+    Returns
+    -------
+    longitude, latitude : array-like
+        The sky coordinates of the 4 vertices of the HEALPix cells.
+        `lon` and `lat` are of shape :math:`N` x :math:`4` numpy arrays where N is the number of HEALPix cell given in `ipix`.
+
+    Raises
+    ------
+    ValueError
+        When the HEALPix cell indexes given have values out of :math:`[0, 4^{29 - depth}[`.
+
+    Examples
+    --------
+    >>> from healpix_geo.nested import vertices
+    >>> import numpy as np
+    >>> ipix = np.array([42, 6, 10])
+    >>> depth = 12
+    >>> lon, lat = vertices(ipix, depth, ellipsoid="sphere")
+    """
+    _check_depth(depth)
+    ipix = np.atleast_1d(ipix)
+    _check_ipixels(data=ipix, depth=depth)
+    ipix = ipix.astype(np.uint64)
+
+    num_threads = np.uint16(num_threads)
+
+    shape = ipix.shape + (4,)
+    longitude = np.empty(shape=shape, dtype="float64")
+    latitude = np.empty(shape=shape, dtype="float64")
+
+    healpix_geo.nested.vertices(
+        depth, ipix, ellipsoid, longitude, latitude, num_threads
+    )
+
+    return longitude, latitude
+
+
 def kth_neighbourhood(ipix, depth, ring, num_threads=0):
     """Get the kth ring neighbouring cells of some HEALPix cells at a given depth.
 

healpix_geo/ring.py

@@ -4,6 +4,169 @@ from healpix_geo import healpix_geo
 from healpix_geo.utils import _check_depth, _check_ipixels, _check_ring
 
 
+def healpix_to_lonlat(ipix, depth, ellipsoid="sphere", num_threads=0):
+    r"""Get the longitudes and latitudes of the center of some HEALPix cells.
+
+    Parameters
+    ----------
+    ipix : `numpy.ndarray`
+        The HEALPix cell indexes given as a `np.uint64` numpy array.
+    depth : `numpy.ndarray`
+        The HEALPix cell depth given as a `np.uint8` numpy array.
+    ellipsoid : str, default: "sphere"
+        Reference ellipsoid to evaluate healpix on. If ``"sphere"``, this will return
+        the same result as :py:func:`cdshealpix.ring.healpix_to_lonlat`.
+    num_threads : int, optional
+        Specifies the number of threads to use for the computation. Default to 0 means
+        it will choose the number of threads based on the RAYON_NUM_THREADS environment variable (if set),
+        or the number of logical CPUs (otherwise)
+
+    Returns
+    -------
+    lon, lat : array-like
+        The coordinates of the center of the HEALPix cells given as a longitude, latitude tuple.
+
+    Raises
+    ------
+    ValueError
+        When the HEALPix cell indexes given have values out of :math:`[0, 4^{29 - depth}[`.
+    ValueError
+        When the name of the ellipsoid is unknown.
+
+    Examples
+    --------
+    >>> from healpix_geo.ring import healpix_to_lonlat
+    >>> import numpy as np
+    >>> cell_ids = np.array([42, 6, 10])
+    >>> depth = 3
+    >>> lon, lat = healpix_to_lonlat(ipix, depth, ellipsoid="WGS84")
+    """
+    _check_depth(depth)
+    ipix = np.atleast_1d(ipix)
+    _check_ipixels(data=ipix, depth=depth)
+    ipix = ipix.astype(np.uint64)
+
+    num_threads = np.uint16(num_threads)
+
+    latitude = np.empty_like(ipix, dtype="float64")
+    longitude = np.empty_like(ipix, dtype="float64")
+
+    healpix_geo.ring.healpix_to_lonlat(
+        depth, ipix, ellipsoid, longitude, latitude, num_threads
+    )
+
+    return longitude, latitude
+
+
+def lonlat_to_healpix(longitude, latitude, depth, ellipsoid="sphere", num_threads=0):
+    r"""Get the HEALPix indexes that contains specific points.
+
+    Parameters
+    ----------
+    lon : array-like
+        The longitudes of the input points, in degrees.
+    lat : array-like
+        The latitudes of the input points, in degrees.
+    depth : int or array-like of int
+        The HEALPix cell depth given as a `np.uint8` numpy array.
+    ellipsoid : str, default: "sphere"
+        Reference ellipsoid to evaluate healpix on. If ``"sphere"``, this will return
+        the same result as :py:func:`cdshealpix.ring.lonlat_to_healpix`.
+    num_threads : int, optional
+        Specifies the number of threads to use for the computation. Default to 0 means
+        it will choose the number of threads based on the RAYON_NUM_THREADS environment variable (if set),
+        or the number of logical CPUs (otherwise)
+
+    Returns
+    -------
+    ipix : `numpy.ndarray`
+        A numpy array containing all the HEALPix cell indexes stored as `np.uint64`.
+
+    Raises
+    ------
+    ValueError
+        When the number of longitudes and latitudes given do not match.
+    ValueError
+        When the name of the ellipsoid is unknown.
+
+    Examples
+    --------
+    >>> from cdshealpix.ring import lonlat_to_healpix
+    >>> import numpy as np
+    >>> lon = np.array([0, 50, 25], dtype="float64")
+    >>> lat = np.array([6, -12, 45], dtype="float64")
+    >>> depth = 3
+    >>> ipix = lonlat_to_healpix(lon, lat, depth, ellipsoid="WGS84")
+    """
+    _check_depth(depth)
+    longitude = np.atleast_1d(longitude).astype("float64")
+    latitude = np.atleast_1d(latitude).astype("float64")
+
+    num_threads = np.uint16(num_threads)
+
+    ipix = np.empty_like(longitude, dtype="uint64")
+
+    healpix_geo.ring.lonlat_to_healpix(
+        depth, longitude, latitude, ellipsoid, ipix, num_threads
+    )
+
+    return ipix
+
+
+def vertices(ipix, depth, ellipsoid, num_threads=0):
+    """Get the longitudes and latitudes of the vertices of some HEALPix cells at a given depth.
+
+    This method returns the 4 vertices of each cell in `ipix`.
+
+    Parameters
+    ----------
+    ipix : `numpy.ndarray`
+        The HEALPix cell indexes given as a `np.uint64` numpy array.
+    depth : int, or `numpy.ndarray`
+        The depth of the HEALPix cells. If given as an array, should have the same shape than ipix
+    ellipsoid : str, default: "sphere"
+        Reference ellipsoid to evaluate healpix on. If ``"sphere"``, this will return
+        the same result as :py:func:`cdshealpix.ring.vertices`.
+    num_threads : int, optional
+        Specifies the number of threads to use for the computation. Default to 0 means
+        it will choose the number of threads based on the RAYON_NUM_THREADS environment variable (if set),
+        or the number of logical CPUs (otherwise)
+
+    Returns
+    -------
+    longitude, latitude : array-like
+        The sky coordinates of the 4 vertices of the HEALPix cells.
+        `lon` and `lat` are of shape :math:`N` x :math:`4` numpy arrays where N is the number of HEALPix cell given in `ipix`.
+
+    Raises
+    ------
+    ValueError
+        When the HEALPix cell indexes given have values out of :math:`[0, 4^{29 - depth}[`.
+
+    Examples
+    --------
+    >>> from healpix_geo.ring import vertices
+    >>> import numpy as np
+    >>> ipix = np.array([42, 6, 10])
+    >>> depth = 12
+    >>> lon, lat = vertices(ipix, depth, ellipsoid="sphere")
+    """
+    _check_depth(depth)
+    ipix = np.atleast_1d(ipix)
+    _check_ipixels(data=ipix, depth=depth)
+    ipix = ipix.astype(np.uint64)
+
+    num_threads = np.uint16(num_threads)
+
+    shape = ipix.shape + (4,)
+    longitude = np.empty(shape=shape, dtype="float64")
+    latitude = np.empty(shape=shape, dtype="float64")
+
+    healpix_geo.ring.vertices(depth, ipix, ellipsoid, longitude, latitude, num_threads)
+
+    return longitude, latitude
+
+
 def kth_neighbourhood(ipix, depth, ring, num_threads=0):
     """Get the kth ring neighbouring cells of some HEALPix cells at a given depth.
 

healpix_geo/tests/test_index.py

@@ -102,7 +102,15 @@ class TestRangeMOCIndex:
         ),
     )
     @pytest.mark.parametrize(
-        "indexer", [slice(None), slice(None, 4), slice(2, None), slice(3, 7)]
+        "indexer",
+        [
+            slice(None),
+            slice(None, 4),
+            slice(2, None),
+            slice(3, 7),
+            np.arange(5, dtype="uint64"),
+            np.array([1, 2, 4, 6, 8], dtype="uint64"),
+        ],
     )
     def test_isel(self, level, cell_ids, indexer):
         expected = cell_ids[indexer]

healpix_geo/tests/test_inference.py

@@ -0,0 +1,185 @@
+import cdshealpix
+import numpy as np
+import pytest
+from astropy.coordinates import Latitude, Longitude
+
+import healpix_geo
+
+
+class TestHealpixToGeographic:
+    @pytest.mark.parametrize(
+        ["cell_ids", "depth", "indexing_scheme"],
+        (
+            pytest.param(np.array([0, 4, 5, 7, 9]), 0, "ring", id="level0-ring"),
+            pytest.param(np.array([1, 2, 3, 8]), 0, "nested", id="level0-nested"),
+            pytest.param(
+                np.array([3, 19, 54, 63, 104, 127]), 4, "ring", id="level4-ring"
+            ),
+            pytest.param(
+                np.array([22, 89, 134, 154, 190]), 4, "nested", id="level4-nested"
+            ),
+        ),
+    )
+    def test_spherical(self, cell_ids, depth, indexing_scheme):
+        if indexing_scheme == "ring":
+            param_cds = 2**depth
+            hg_healpix_to_lonlat = healpix_geo.ring.healpix_to_lonlat
+            cds_healpix_to_lonlat = cdshealpix.ring.healpix_to_lonlat
+        else:
+            param_cds = depth
+            hg_healpix_to_lonlat = healpix_geo.nested.healpix_to_lonlat
+            cds_healpix_to_lonlat = cdshealpix.nested.healpix_to_lonlat
+
+        actual_lon, actual_lat = hg_healpix_to_lonlat(
+            cell_ids, depth, ellipsoid="sphere"
+        )
+        expected_lon_, expected_lat_ = cds_healpix_to_lonlat(cell_ids, param_cds)
+        expected_lon = np.asarray(expected_lon_.to("degree"))
+        expected_lat = np.asarray(expected_lat_.to("degree"))
+
+        np.testing.assert_allclose(actual_lon, expected_lon)
+        np.testing.assert_allclose(actual_lat, expected_lat)
+
+    @pytest.mark.parametrize("ellipsoid", ["unitsphere", "sphere", "WGS84", "bessel"])
+    @pytest.mark.parametrize("depth", [0, 1, 9])
+    @pytest.mark.parametrize("indexing_scheme", ["ring", "nested"])
+    def test_ellipsoidal(self, depth, indexing_scheme, ellipsoid):
+        cell_ids = np.arange(12)
+        if indexing_scheme == "ring":
+            param_cds = 2**depth
+            hg_healpix_to_lonlat = healpix_geo.ring.healpix_to_lonlat
+            cds_healpix_to_lonlat = cdshealpix.ring.healpix_to_lonlat
+        else:
+            param_cds = depth
+            hg_healpix_to_lonlat = healpix_geo.nested.healpix_to_lonlat
+            cds_healpix_to_lonlat = cdshealpix.nested.healpix_to_lonlat
+
+        actual_lon, actual_lat = hg_healpix_to_lonlat(
+            cell_ids, depth, ellipsoid=ellipsoid
+        )
+        expected_lon_, expected_lat_ = cds_healpix_to_lonlat(cell_ids, param_cds)
+        expected_lon = np.asarray(expected_lon_.to("degree"))
+        expected_lat = np.asarray(expected_lat_.to("degree"))
+
+        np.testing.assert_allclose(actual_lon, expected_lon)
+
+        diff_lat = actual_lat - expected_lat
+        assert np.all(abs(diff_lat) < 0.3)
+
+        signs = np.array([-1, 1])
+        actual = signs[(actual_lat >= 0).astype(int)]
+        expected_ = np.sign(diff_lat)
+        expected = np.where(expected_ == 0, 1, expected_)
+        assert np.all(diff_lat == 0) or np.all(actual == expected)
+
+
+class TestGeographicToHealpix:
+    @pytest.mark.parametrize(
+        ["lon", "lat", "depth", "indexing_scheme"],
+        (
+            pytest.param(
+                np.array([-170.0, 10.0, 30.0, 124.0, 174.0]),
+                np.array([-48.0, -30.0, -5.0, 15.0, 30.0]),
+                0,
+                "ring",
+                id="level0-ring",
+            ),
+            pytest.param(
+                np.array([-170.0, 10.0, 30.0, 124.0, 174.0]),
+                np.array([-48.0, -30.0, -5.0, 15.0, 30.0]),
+                0,
+                "nested",
+                id="level0-nested",
+            ),
+            pytest.param(
+                np.array([-70.0, 135.0, 150.0]),
+                np.array([-65.0, 0.0, 65.0]),
+                4,
+                "ring",
+                id="level4-ring",
+            ),
+            pytest.param(
+                np.array([-70.0, 135.0, 150.0]),
+                np.array([-65.0, 0.0, 65.0]),
+                4,
+                "nested",
+                id="level4-nested",
+            ),
+        ),
+    )
+    def test_spherical(self, lon, lat, depth, indexing_scheme):
+        if indexing_scheme == "ring":
+            param_cds = 2**depth
+            hg_lonlat_to_healpix = healpix_geo.ring.lonlat_to_healpix
+            cds_lonlat_to_healpix = cdshealpix.ring.lonlat_to_healpix
+        else:
+            param_cds = depth
+            hg_lonlat_to_healpix = healpix_geo.nested.lonlat_to_healpix
+            cds_lonlat_to_healpix = cdshealpix.nested.lonlat_to_healpix
+
+        actual = hg_lonlat_to_healpix(lon, lat, depth, ellipsoid="sphere")
+        lon_ = Longitude(lon, unit="degree")
+        lat_ = Latitude(lat, unit="degree")
+        expected = cds_lonlat_to_healpix(lon_, lat_, param_cds)
+
+        np.testing.assert_equal(actual, expected)
+
+    @pytest.mark.parametrize("ellipsoid", ["unitsphere", "sphere", "WGS84", "bessel"])
+    @pytest.mark.parametrize("depth", [0, 1, 9])
+    @pytest.mark.parametrize("indexing_scheme", ["ring", "nested"])
+    def test_ellipsoidal(self, ellipsoid, depth, indexing_scheme):
+        lat = np.linspace(-90, 90, 50)
+        lon = np.full_like(lat, fill_value=45.0)
+
+        if indexing_scheme == "ring":
+            param_cds = 2**depth
+            hg = healpix_geo.ring.lonlat_to_healpix
+            cds = cdshealpix.ring.lonlat_to_healpix
+        else:
+            param_cds = depth
+            hg = healpix_geo.nested.lonlat_to_healpix
+            cds = cdshealpix.nested.lonlat_to_healpix
+
+        actual = hg(lon, lat, depth, ellipsoid=ellipsoid)
+
+        lon_ = Longitude(lon, unit="degree")
+        lat_ = Latitude(lat, unit="degree")
+        expected = cds(lon_, lat_, param_cds)
+
+        assert actual.dtype == "uint64"
+        assert expected.dtype == "uint64"
+
+        # TODO: this is currently a smoke check, try more thorough checks
+
+
+class TestVertices:
+    @pytest.mark.parametrize(
+        ["cell_ids", "depth", "indexing_scheme"],
+        (
+            pytest.param(np.array([0, 4, 5, 7, 9]), 0, "ring", id="level0-ring"),
+            pytest.param(np.array([1, 2, 3, 8]), 0, "nested", id="level0-nested"),
+            pytest.param(
+                np.array([3, 19, 54, 63, 104, 127]), 4, "ring", id="level4-ring"
+            ),
+            pytest.param(
+                np.array([22, 89, 134, 154, 190]), 4, "nested", id="level4-nested"
+            ),
+        ),
+    )
+    def test_spherical(self, cell_ids, depth, indexing_scheme):
+        if indexing_scheme == "ring":
+            param_cds = 2**depth
+            hg_vertices = healpix_geo.ring.vertices
+            cds_vertices = cdshealpix.ring.vertices
+        else:
+            param_cds = depth
+            hg_vertices = healpix_geo.nested.vertices
+            cds_vertices = cdshealpix.nested.vertices
+
+        actual_lon, actual_lat = hg_vertices(cell_ids, depth, ellipsoid="sphere")
+        expected_lon_, expected_lat_ = cds_vertices(cell_ids, param_cds)
+        expected_lon = np.asarray(expected_lon_.to("degree"))
+        expected_lat = np.asarray(expected_lat_.to("degree"))
+
+        np.testing.assert_allclose(actual_lon, expected_lon)
+        np.testing.assert_allclose(actual_lat, expected_lat)

{healpix_geo-0.0.4.dist-info → healpix_geo-0.0.5.dist-info}/METADATA

@@ -1,12 +1,21 @@
 Metadata-Version: 2.4
 Name: healpix-geo
-Version: 0.0.4
+Version: 0.0.5
 Classifier: Programming Language :: Rust
 Classifier: Programming Language :: Python :: Implementation :: CPython
 Classifier: Programming Language :: Python :: Implementation :: PyPy
 Requires-Dist: numpy
 Requires-Dist: pytest ; extra == 'tests'
+Requires-Dist: sphinx ; extra == 'docs'
+Requires-Dist: pydata-sphinx-theme ; extra == 'docs'
+Requires-Dist: myst-parser ; extra == 'docs'
+Requires-Dist: jupyter-sphinx ; extra == 'docs'
+Requires-Dist: matplotlib ; extra == 'docs'
+Requires-Dist: sphinx-autobuild ; extra == 'docs'
+Requires-Dist: markdown ; extra == 'docs'
+Requires-Dist: tabulate ; extra == 'docs'
 Provides-Extra: tests
+Provides-Extra: docs
 License-File: LICENSE
 License: Apache-2.0
 Requires-Python: >=3.10

healpix_geo-0.0.5.dist-info/RECORD

@@ -0,0 +1,14 @@
+healpix_geo-0.0.5.dist-info/METADATA,sha256=KuNwbByTsOnRPEjEG3bh_3Nqu3xavZ6T3zaLUVSrLB0,987
+healpix_geo-0.0.5.dist-info/WHEEL,sha256=UKPJmnqbrldw3qLUm4kdufiI75aeJ3JWht2xyRp0WIM,131
+healpix_geo-0.0.5.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+healpix_geo/__init__.py,sha256=5F9gFVhnatVc8JSUwXCNCwU1S3Cq6AmJiOE41BuXpWc,67
+healpix_geo/healpix_geo.cpython-313-aarch64-linux-gnu.so,sha256=S8DaVhh0wIID1xm3iJd_qZ4vASgIMz-fv63MosyNH7U,1689680
+healpix_geo/nested.py,sha256=j10mOG6-tYnwA_ITvOFu1MUbe3pOXQdq2MoeRaeAxUY,12613
+healpix_geo/ring.py,sha256=twROKO2DobvBZLPdudAOwXIZEK5Hitb0kYGmdUFFxj0,10315
+healpix_geo/tests/test_distances.py,sha256=2_0sya91zXHNskfgcyVl6baVtQFnAngff71IhzmxKKY,2502
+healpix_geo/tests/test_index.py,sha256=oeIhp-bRgJhyV13-wIGrGWxoxiWctAR6BqcInUOASZg,4725
+healpix_geo/tests/test_inference.py,sha256=OJ06XHO26_ZKD8DUgRB7NjO4u3CsGmY09ixexm0wQDQ,7182
+healpix_geo/tests/test_neighbours.py,sha256=r4P8KE_B4Yp5yXWCUiEHIE0PUqD6PyQqoqHaEHtpsYs,1187
+healpix_geo/tests/test_zoom.py,sha256=lua0ylP7kr_YlB_-H38P4toMXsPR-BgnwxJD-Dvoulk,2263
+healpix_geo/utils.py,sha256=ZBJaXk-asV4ivdWKan65PiEUK3WWYIBuGWARW43rEj8,721
+healpix_geo-0.0.5.dist-info/RECORD,,

{healpix_geo-0.0.4.dist-info → healpix_geo-0.0.5.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: maturin (1.8.7)
+Generator: maturin (1.9.0)
 Root-Is-Purelib: false
 Tag: cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64

healpix_geo-0.0.4.dist-info/RECORD

@@ -1,13 +0,0 @@
-healpix_geo-0.0.4.dist-info/METADATA,sha256=IpcpPXnLELUyEOoHz_pWk6ctyFBa4qqN5uOUN2f8nCw,602
-healpix_geo-0.0.4.dist-info/WHEEL,sha256=T9di0PMmgWlFwXPjZHqGr_DRLhstyG3P0gQtvMbyU3o,131
-healpix_geo-0.0.4.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-healpix_geo/__init__.py,sha256=5F9gFVhnatVc8JSUwXCNCwU1S3Cq6AmJiOE41BuXpWc,67
-healpix_geo/healpix_geo.cpython-313-aarch64-linux-gnu.so,sha256=3XDij8W4uwxCGuYGZV-Ew2UMb_WxMxbofTXZFyESKtk,1409096
-healpix_geo/nested.py,sha256=2sh7oP2a2JblgZ0g6j3fdy5qUy_Ox_uNhxFM5fWoEZI,6845
-healpix_geo/ring.py,sha256=4cmopmqpUHdewFjQhetRB10rZrbiY0Ndd_VZBKHGmTk,4568
-healpix_geo/tests/test_distances.py,sha256=2_0sya91zXHNskfgcyVl6baVtQFnAngff71IhzmxKKY,2502
-healpix_geo/tests/test_index.py,sha256=409ulgEgs53EuYNZYJb0aiSmG4e2mtUEMPbJJetUPpQ,4560
-healpix_geo/tests/test_neighbours.py,sha256=r4P8KE_B4Yp5yXWCUiEHIE0PUqD6PyQqoqHaEHtpsYs,1187
-healpix_geo/tests/test_zoom.py,sha256=lua0ylP7kr_YlB_-H38P4toMXsPR-BgnwxJD-Dvoulk,2263
-healpix_geo/utils.py,sha256=ZBJaXk-asV4ivdWKan65PiEUK3WWYIBuGWARW43rEj8,721
-healpix_geo-0.0.4.dist-info/RECORD,,