hyhound 1.0.2a1__cp310-cp310-linux_armv6l.whl → 1.0.2a2__cp310-cp310-linux_armv6l.whl

hyhound/__init__.py

@@ -2,7 +2,7 @@
 Hyperbolic Householder transformations for Up- and Downdating Cholesky factorizations.
 """
 
-__version__ = "1.0.2a1"
+__version__ = "1.0.2a2"
 
 from ._hyhound import *  # noqa: F403
 from ._hyhound import __version__ as __c_version__  # noqa: F401

hyhound/_hyhound.pyi

@@ -4,9 +4,9 @@ import numpy
 from numpy.typing import NDArray
 
 
-build_time: str = '2025-10-05T22:30:09Z'
+build_time: str = '2025-10-23T15:57:52Z'
 
-commit_hash: str = 'ab5d1ca1f14486665601ffa9462f4ff7215ae3bc'
+commit_hash: str = '42a4b5c0c28b2ca237982197d54851054b584a80'
 
 @overload
 def update_cholesky_inplace(L: Annotated[NDArray[numpy.float64], dict(shape=(None, None), order='F', device='cpu')], A: Annotated[NDArray[numpy.float64], dict(shape=(None, None), order='F', device='cpu')]) -> None:
@@ -24,8 +24,7 @@ def update_cholesky_inplace(L: Annotated[NDArray[numpy.float64], dict(shape=(Non
     A : (k × m), rectangular, Fortran order
         On entry, the update matrix A.
         On exit, contains the k-n bottom rows of the remaining update matrix Ã
-        (the top n rows of à are implicitly zero).
-        The top n rows of A are overwritten by Householder reflectors and are generally not useful.
+        (the top n rows of à are zero).
     """
 
 @overload
@@ -47,8 +46,7 @@ def downdate_cholesky_inplace(L: Annotated[NDArray[numpy.float64], dict(shape=(N
     A : (k × m), rectangular, Fortran order
         On entry, the downdate matrix A.
         On exit, contains the k-n bottom rows of the remaining downdate matrix Ã
-        (the top n rows of à are implicitly zero).
-        The top n rows of A are overwritten by Householder reflectors and are generally not useful.
+        (the top n rows of à are zero).
     """
 
 @overload
@@ -71,8 +69,7 @@ def update_cholesky_sign_inplace(L: Annotated[NDArray[numpy.float64], dict(shape
     A : (k × m), rectangular, Fortran order
         On entry, the update matrix A.
         On exit, contains the k-n bottom rows of the remaining update matrix Ã
-        (the top n rows of à are implicitly zero).
-        The top n rows of A are overwritten by Householder reflectors and are generally not useful.
+        (the top n rows of à are zero).
 
     signs : m-vector
         Signs that determine whether a column of A is added (+0) or removed (-0).
@@ -99,8 +96,7 @@ def update_cholesky_diag_inplace(L: Annotated[NDArray[numpy.float64], dict(shape
     A : (k × m), rectangular, Fortran order
         On entry, the update matrix A.
         On exit, contains the k-n bottom rows of the remaining update matrix Ã
-        (the top n rows of à are implicitly zero).
-        The top n rows of A are overwritten by Householder reflectors and are generally not useful.
+        (the top n rows of à are zero).
 
     diag : m-vector
         Scale factors corresponding to the columns of A.
@@ -110,7 +106,7 @@ def update_cholesky_diag_inplace(L: Annotated[NDArray[numpy.float64], dict(shape
 def update_cholesky_diag_inplace(L: Annotated[NDArray[numpy.float32], dict(shape=(None, None), order='F', device='cpu')], A: Annotated[NDArray[numpy.float32], dict(shape=(None, None), order='F', device='cpu')], diag: Annotated[NDArray[numpy.float32], dict(shape=(None,), order='A', device='cpu', writable=False)]) -> None: ...
 
 @overload
-def update_cholesky(L: Annotated[NDArray[numpy.float64], dict(shape=(None, None), device='cpu', writable=False)], A: Annotated[NDArray[numpy.float64], dict(shape=(None, None), device='cpu', writable=False)]) -> tuple:
+def update_cholesky(L: Annotated[NDArray[numpy.float64], dict(shape=(None, None), device='cpu', writable=False)], A: Annotated[NDArray[numpy.float64], dict(shape=(None, None), device='cpu', writable=False)]) -> tuple[Annotated[NDArray[numpy.float64], dict(shape=(None, None), order='F')], Annotated[NDArray[numpy.float64], dict(shape=(None, None), order='F')], Annotated[NDArray[numpy.float64], dict(shape=(None, None), order='F')]]:
     """
     Cholesky factorization update. Returns updated copies.
 
@@ -132,14 +128,20 @@ def update_cholesky(L: Annotated[NDArray[numpy.float64], dict(shape=(None, None)
     A_rem : (k × m)
         Contains the k-n bottom rows of the remaining update matrix Ã.
         The top n rows of à are zero (not stored explicitly).
-        The top n rows of A_rem contain Householder reflectors and are generally not useful.
+        The top n rows of A_rem contain Householder reflectors.
+
+    W : (r × n)
+        The upper triangular Householder representations generated during the
+        Cholesky factorization update. Together with the top n rows of A_rem,
+        this can be used to apply the block Householder transformation to other matrices.
+        The number of rows depends on the block size and is architecture-dependent.
     """
 
 @overload
-def update_cholesky(L: Annotated[NDArray[numpy.float32], dict(shape=(None, None), device='cpu', writable=False)], A: Annotated[NDArray[numpy.float32], dict(shape=(None, None), device='cpu', writable=False)]) -> tuple: ...
+def update_cholesky(L: Annotated[NDArray[numpy.float32], dict(shape=(None, None), device='cpu', writable=False)], A: Annotated[NDArray[numpy.float32], dict(shape=(None, None), device='cpu', writable=False)]) -> tuple[Annotated[NDArray[numpy.float32], dict(shape=(None, None), order='F')], Annotated[NDArray[numpy.float32], dict(shape=(None, None), order='F')], Annotated[NDArray[numpy.float32], dict(shape=(None, None), order='F')]]: ...
 
 @overload
-def downdate_cholesky(L: Annotated[NDArray[numpy.float64], dict(shape=(None, None), device='cpu', writable=False)], A: Annotated[NDArray[numpy.float64], dict(shape=(None, None), device='cpu', writable=False)]) -> tuple:
+def downdate_cholesky(L: Annotated[NDArray[numpy.float64], dict(shape=(None, None), device='cpu', writable=False)], A: Annotated[NDArray[numpy.float64], dict(shape=(None, None), device='cpu', writable=False)]) -> tuple[Annotated[NDArray[numpy.float64], dict(shape=(None, None), order='F')], Annotated[NDArray[numpy.float64], dict(shape=(None, None), order='F')], Annotated[NDArray[numpy.float64], dict(shape=(None, None), order='F')]]:
     """
     Cholesky factorization downdate. Returns updated copies.
 
@@ -161,14 +163,20 @@ def downdate_cholesky(L: Annotated[NDArray[numpy.float64], dict(shape=(None, Non
     A_rem : (k × m)
         Contains the k-n bottom rows of the remaining downdate matrix Ã.
         The top n rows of à are zero (not stored explicitly).
-        The top n rows of A_rem contain Householder reflectors and are generally not useful.
+        The top n rows of A_rem contain Householder reflectors.
+
+    W : (r × n)
+        The upper triangular Householder representations generated during the
+        Cholesky factorization update. Together with the top n rows of A_rem,
+        this can be used to apply the block Householder transformation to other matrices.
+        The number of rows depends on the block size and is architecture-dependent.
     """
 
 @overload
-def downdate_cholesky(L: Annotated[NDArray[numpy.float32], dict(shape=(None, None), device='cpu', writable=False)], A: Annotated[NDArray[numpy.float32], dict(shape=(None, None), device='cpu', writable=False)]) -> tuple: ...
+def downdate_cholesky(L: Annotated[NDArray[numpy.float32], dict(shape=(None, None), device='cpu', writable=False)], A: Annotated[NDArray[numpy.float32], dict(shape=(None, None), device='cpu', writable=False)]) -> tuple[Annotated[NDArray[numpy.float32], dict(shape=(None, None), order='F')], Annotated[NDArray[numpy.float32], dict(shape=(None, None), order='F')], Annotated[NDArray[numpy.float32], dict(shape=(None, None), order='F')]]: ...
 
 @overload
-def update_cholesky_sign(L: Annotated[NDArray[numpy.float64], dict(shape=(None, None), device='cpu', writable=False)], A: Annotated[NDArray[numpy.float64], dict(shape=(None, None), device='cpu', writable=False)], signs: Annotated[NDArray[numpy.float64], dict(shape=(None,), order='A', device='cpu', writable=False)]) -> tuple:
+def update_cholesky_sign(L: Annotated[NDArray[numpy.float64], dict(shape=(None, None), device='cpu', writable=False)], A: Annotated[NDArray[numpy.float64], dict(shape=(None, None), device='cpu', writable=False)], signs: Annotated[NDArray[numpy.float64], dict(shape=(None,), order='A', device='cpu', writable=False)]) -> tuple[Annotated[NDArray[numpy.float64], dict(shape=(None, None), order='F')], Annotated[NDArray[numpy.float64], dict(shape=(None, None), order='F')], Annotated[NDArray[numpy.float64], dict(shape=(None, None), order='F')]]:
     """
     Cholesky factorization update with signed columns. Returns updated copies.
 
@@ -195,14 +203,20 @@ def update_cholesky_sign(L: Annotated[NDArray[numpy.float64], dict(shape=(None,
     A_rem : (k × m)
         Contains the k-n bottom rows of the remaining update matrix Ã.
         The top n rows of à are zero (not stored explicitly).
-        The top n rows of A_rem contain Householder reflectors and are generally not useful.
+        The top n rows of A_rem contain Householder reflectors.
+
+    W : (r × n)
+        The upper triangular Householder representations generated during the
+        Cholesky factorization update. Together with the top n rows of A_rem,
+        this can be used to apply the block Householder transformation to other matrices.
+        The number of rows depends on the block size and is architecture-dependent.
     """
 
 @overload
-def update_cholesky_sign(L: Annotated[NDArray[numpy.float32], dict(shape=(None, None), device='cpu', writable=False)], A: Annotated[NDArray[numpy.float32], dict(shape=(None, None), device='cpu', writable=False)], signs: Annotated[NDArray[numpy.float32], dict(shape=(None,), order='A', device='cpu', writable=False)]) -> tuple: ...
+def update_cholesky_sign(L: Annotated[NDArray[numpy.float32], dict(shape=(None, None), device='cpu', writable=False)], A: Annotated[NDArray[numpy.float32], dict(shape=(None, None), device='cpu', writable=False)], signs: Annotated[NDArray[numpy.float32], dict(shape=(None,), order='A', device='cpu', writable=False)]) -> tuple[Annotated[NDArray[numpy.float32], dict(shape=(None, None), order='F')], Annotated[NDArray[numpy.float32], dict(shape=(None, None), order='F')], Annotated[NDArray[numpy.float32], dict(shape=(None, None), order='F')]]: ...
 
 @overload
-def update_cholesky_diag(L: Annotated[NDArray[numpy.float64], dict(shape=(None, None), device='cpu', writable=False)], A: Annotated[NDArray[numpy.float64], dict(shape=(None, None), device='cpu', writable=False)], diag: Annotated[NDArray[numpy.float64], dict(shape=(None,), order='A', device='cpu', writable=False)]) -> tuple:
+def update_cholesky_diag(L: Annotated[NDArray[numpy.float64], dict(shape=(None, None), device='cpu', writable=False)], A: Annotated[NDArray[numpy.float64], dict(shape=(None, None), device='cpu', writable=False)], diag: Annotated[NDArray[numpy.float64], dict(shape=(None,), order='A', device='cpu', writable=False)]) -> tuple[Annotated[NDArray[numpy.float64], dict(shape=(None, None), order='F')], Annotated[NDArray[numpy.float64], dict(shape=(None, None), order='F')], Annotated[NDArray[numpy.float64], dict(shape=(None, None), order='F')]]:
     """
     Cholesky factorization update with diagonal scaling. Returns updated copies.
 
@@ -228,8 +242,174 @@ def update_cholesky_diag(L: Annotated[NDArray[numpy.float64], dict(shape=(None,
     A_rem : (k × m)
         Contains the k-n bottom rows of the remaining update matrix Ã.
         The top n rows of à are zero (not stored explicitly).
-        The top n rows of A_rem contain Householder reflectors and are generally not useful.
+        The top n rows of A_rem contain Householder reflectors.
+
+    W : (r × n)
+        The upper triangular Householder representations generated during the
+        Cholesky factorization update. Together with the top n rows of A_rem,
+        this can be used to apply the block Householder transformation to other matrices.
+        The number of rows depends on the block size and is architecture-dependent.
+    """
+
+@overload
+def update_cholesky_diag(L: Annotated[NDArray[numpy.float32], dict(shape=(None, None), device='cpu', writable=False)], A: Annotated[NDArray[numpy.float32], dict(shape=(None, None), device='cpu', writable=False)], diag: Annotated[NDArray[numpy.float32], dict(shape=(None,), order='A', device='cpu', writable=False)]) -> tuple[Annotated[NDArray[numpy.float32], dict(shape=(None, None), order='F')], Annotated[NDArray[numpy.float32], dict(shape=(None, None), order='F')], Annotated[NDArray[numpy.float32], dict(shape=(None, None), order='F')]]: ...
+
+@overload
+def update_apply_householder(L: Annotated[NDArray[numpy.float64], dict(shape=(None, None), device='cpu', writable=False)], A: Annotated[NDArray[numpy.float64], dict(shape=(None, None), device='cpu', writable=False)], W: Annotated[NDArray[numpy.float64], dict(shape=(None, None), order='F', device='cpu', writable=False)], B: Annotated[NDArray[numpy.float64], dict(shape=(None, None), order='F', device='cpu', writable=False)]) -> tuple[Annotated[NDArray[numpy.float64], dict(shape=(None, None), order='F')], Annotated[NDArray[numpy.float64], dict(shape=(None, None), order='F')]]:
+    """
+    Apply a block Householder transformation generated during a Cholesky
+    factorization update. Returns updated copies.
+
+    (L̃ Ã) = (L A) Q
+
+    where Q is the block Householder transformation represented by W and B.
+
+    Parameters
+    ----------
+    L : (l × n), rectangular
+        Matrix to apply the transformation to.
+
+    A : (l × m), rectangular
+        Matrix to apply the transformation to.
+
+    W : (r × n)
+        The upper triangular Householder representations generated during the
+        Cholesky factorization update.
+
+    B : (k × m), rectangular
+        The Householder reflector vectors generated during the Cholesky
+        factorization update.
+
+    Returns
+    -------
+    L̃ : (l × n)
+        The updated matrix L.
+
+    Ã : (l × m)
+        The updated matrix A.
+    """
+
+@overload
+def update_apply_householder(L: Annotated[NDArray[numpy.float32], dict(shape=(None, None), device='cpu', writable=False)], A: Annotated[NDArray[numpy.float32], dict(shape=(None, None), device='cpu', writable=False)], W: Annotated[NDArray[numpy.float32], dict(shape=(None, None), order='F', device='cpu', writable=False)], B: Annotated[NDArray[numpy.float32], dict(shape=(None, None), order='F', device='cpu', writable=False)]) -> tuple[Annotated[NDArray[numpy.float32], dict(shape=(None, None), order='F')], Annotated[NDArray[numpy.float32], dict(shape=(None, None), order='F')]]: ...
+
+@overload
+def downdate_apply_householder(L: Annotated[NDArray[numpy.float64], dict(shape=(None, None), device='cpu', writable=False)], A: Annotated[NDArray[numpy.float64], dict(shape=(None, None), device='cpu', writable=False)], W: Annotated[NDArray[numpy.float64], dict(shape=(None, None), order='F', device='cpu', writable=False)], B: Annotated[NDArray[numpy.float64], dict(shape=(None, None), order='F', device='cpu', writable=False)]) -> tuple[Annotated[NDArray[numpy.float64], dict(shape=(None, None), order='F')], Annotated[NDArray[numpy.float64], dict(shape=(None, None), order='F')]]:
+    """
+    Apply a block Householder transformation generated during a Cholesky
+    factorization downdate. Returns updated copies.
+
+    (L̃ Ã) = (L A) Q
+
+    where Q is the block Householder transformation represented by W and B.
+
+    Parameters
+    ----------
+    L : (l × n), rectangular
+        Matrix to apply the transformation to.
+
+    A : (l × m), rectangular
+        Matrix to apply the transformation to.
+
+    W : (r × n)
+        The upper triangular Householder representations generated during the
+        Cholesky factorization downdate.
+
+    B : (k × m), rectangular
+        The Householder reflector vectors generated during the Cholesky
+        factorization downdate.
+
+    Returns
+    -------
+    L̃ : (l × n)
+        The updated matrix L.
+
+    Ã : (l × m)
+        The updated matrix A.
+    """
+
+@overload
+def downdate_apply_householder(L: Annotated[NDArray[numpy.float32], dict(shape=(None, None), device='cpu', writable=False)], A: Annotated[NDArray[numpy.float32], dict(shape=(None, None), device='cpu', writable=False)], W: Annotated[NDArray[numpy.float32], dict(shape=(None, None), order='F', device='cpu', writable=False)], B: Annotated[NDArray[numpy.float32], dict(shape=(None, None), order='F', device='cpu', writable=False)]) -> tuple[Annotated[NDArray[numpy.float32], dict(shape=(None, None), order='F')], Annotated[NDArray[numpy.float32], dict(shape=(None, None), order='F')]]: ...
+
+@overload
+def update_apply_householder_sign(L: Annotated[NDArray[numpy.float64], dict(shape=(None, None), device='cpu', writable=False)], A: Annotated[NDArray[numpy.float64], dict(shape=(None, None), device='cpu', writable=False)], signs: Annotated[NDArray[numpy.float64], dict(shape=(None,), order='A', device='cpu', writable=False)], W: Annotated[NDArray[numpy.float64], dict(shape=(None, None), order='F', device='cpu', writable=False)], B: Annotated[NDArray[numpy.float64], dict(shape=(None, None), order='F', device='cpu', writable=False)]) -> tuple[Annotated[NDArray[numpy.float64], dict(shape=(None, None), order='F')], Annotated[NDArray[numpy.float64], dict(shape=(None, None), order='F')]]:
+    """
+    Apply a block Householder transformation generated during a Cholesky
+    factorization update with signed columns. Returns updated copies.
+
+    (L̃ Ã) = (L A) Q
+
+    where Q is the block Householder transformation represented by W, B and signs.
+
+    Parameters
+    ----------
+    L : (l × n), rectangular
+        Matrix to apply the transformation to.
+
+    A : (l × m), rectangular
+        Matrix to apply the transformation to.
+
+    signs : m-vector
+        Signs that determine whether a column of A was added (+0) or removed (-0).
+        Values other than ±0 are not allowed.
+
+    W : (r × n)
+        The upper triangular Householder representations generated during the
+        Cholesky factorization update.
+
+    B : (k × m), rectangular
+        The Householder reflector vectors generated during the Cholesky
+        factorization update.
+
+    Returns
+    -------
+    L̃ : (l × n)
+        The updated matrix L.
+
+    Ã : (l × m)
+        The updated matrix A.
+    """
+
+@overload
+def update_apply_householder_sign(L: Annotated[NDArray[numpy.float32], dict(shape=(None, None), device='cpu', writable=False)], A: Annotated[NDArray[numpy.float32], dict(shape=(None, None), device='cpu', writable=False)], signs: Annotated[NDArray[numpy.float32], dict(shape=(None,), order='A', device='cpu', writable=False)], W: Annotated[NDArray[numpy.float32], dict(shape=(None, None), order='F', device='cpu', writable=False)], B: Annotated[NDArray[numpy.float32], dict(shape=(None, None), order='F', device='cpu', writable=False)]) -> tuple[Annotated[NDArray[numpy.float32], dict(shape=(None, None), order='F')], Annotated[NDArray[numpy.float32], dict(shape=(None, None), order='F')]]: ...
+
+@overload
+def update_apply_householder_diag(L: Annotated[NDArray[numpy.float64], dict(shape=(None, None), device='cpu', writable=False)], A: Annotated[NDArray[numpy.float64], dict(shape=(None, None), device='cpu', writable=False)], diag: Annotated[NDArray[numpy.float64], dict(shape=(None,), order='A', device='cpu', writable=False)], W: Annotated[NDArray[numpy.float64], dict(shape=(None, None), order='F', device='cpu', writable=False)], B: Annotated[NDArray[numpy.float64], dict(shape=(None, None), order='F', device='cpu', writable=False)]) -> tuple[Annotated[NDArray[numpy.float64], dict(shape=(None, None), order='F')], Annotated[NDArray[numpy.float64], dict(shape=(None, None), order='F')]]:
+    """
+    Apply a block Householder transformation generated during a Cholesky
+    factorization update with diagonal scaling. Returns updated copies.
+
+    (L̃ Ã) = (L A) Q
+
+    where Q is the block Householder transformation represented by W, B and diag.
+
+    Parameters
+    ----------
+    L : (l × n), rectangular
+        Matrix to apply the transformation to.
+
+    A : (l × m), rectangular
+        Matrix to apply the transformation to.
+
+    diag : m-vector
+        Scale factors corresponding to the columns of A used when generating the
+        Householder transformation.
+
+    W : (r × n)
+        The upper triangular Householder representations generated during the
+        Cholesky factorization update.
+
+    B : (k × m), rectangular
+        The Householder reflector vectors generated during the Cholesky
+        factorization update.
+
+    Returns
+    -------
+    L̃ : (l × n)
+        The updated matrix L.
+
+    Ã : (l × m)
+        The updated matrix A.
     """
 
 @overload
-def update_cholesky_diag(L: Annotated[NDArray[numpy.float32], dict(shape=(None, None), device='cpu', writable=False)], A: Annotated[NDArray[numpy.float32], dict(shape=(None, None), device='cpu', writable=False)], diag: Annotated[NDArray[numpy.float32], dict(shape=(None,), order='A', device='cpu', writable=False)]) -> tuple: ...
+def update_apply_householder_diag(L: Annotated[NDArray[numpy.float32], dict(shape=(None, None), device='cpu', writable=False)], A: Annotated[NDArray[numpy.float32], dict(shape=(None, None), device='cpu', writable=False)], diag: Annotated[NDArray[numpy.float32], dict(shape=(None,), order='A', device='cpu', writable=False)], W: Annotated[NDArray[numpy.float32], dict(shape=(None, None), order='F', device='cpu', writable=False)], B: Annotated[NDArray[numpy.float32], dict(shape=(None, None), order='F', device='cpu', writable=False)]) -> tuple[Annotated[NDArray[numpy.float32], dict(shape=(None, None), order='F')], Annotated[NDArray[numpy.float32], dict(shape=(None, None), order='F')]]: ...

{hyhound-1.0.2a1.dist-info → hyhound-1.0.2a2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: hyhound
-Version: 1.0.2a1
+Version: 1.0.2a2
 Summary: Hyperbolic Householder transformations for Up- and Downdating Cholesky factorizations.
 Keywords: linear-algebra,cholesky,update,downdate,matrix
 Author-Email: Pieter P <pieter.p.dev@outlook.com>

hyhound-1.0.2a2.dist-info/RECORD

@@ -0,0 +1,12 @@
+hyhound/__init__.py,sha256=Zaudvv2SHXm3CNeT9lEskzoQIFWCgUxMr-9vtT1D8LE,224
+hyhound/_dispatch.cpython-310-arm-linux-gnueabihf.so,sha256=dxyYZivkFMp_0oSdIoGZ_a2J6ZGOZe6Sw8YIy0bS56o,9620
+hyhound/_hyhound.py,sha256=Qq4QcfETX6JJ8bta2vX4JM2dA9BZtHvfmhOiztQOPWU,446
+hyhound/_hyhound.pyi,sha256=pcMOy75joVVBcf39lHELrqAp49tw2ik7s4RC0a_HNeY,21853
+hyhound/_hyhound_generic.cpython-310-arm-linux-gnueabihf.so,sha256=uuUB4gAuCbFzsOSzDZWim04mN6yMtMkB9-fG-10QTpE,916532
+hyhound/libnanobind-hyhound.so,sha256=4fhyCSDK3lyF7x-lI5y1bNcaTh-3u-PO4L4SnGqrJHI,299664
+hyhound/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+hyhound-1.0.2a2.dist-info/METADATA,sha256=l66nPRJavK2UBz0FbNEdg9yK0LYH7CDq0LsQ3RS3mgI,3745
+hyhound-1.0.2a2.dist-info/WHEEL,sha256=bjGf3-Ep9LM1r6aUkCHLphZ86Eqzbqb1ROGeLbvmdNg,96
+hyhound-1.0.2a2.dist-info/entry_points.txt,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+hyhound-1.0.2a2.dist-info/licenses/LICENSE,sha256=46mU2C5kSwOnkqkw9XQAJlhBL2JAf1_uCD8lVcXyMRg,7652
+hyhound-1.0.2a2.dist-info/RECORD,,

hyhound-1.0.2a1.dist-info/RECORD

@@ -1,12 +0,0 @@
-hyhound/__init__.py,sha256=Tr4dRGgdW-p6XjKI35GhTZs__u4x2W1-MbnGgklHraw,224
-hyhound/_dispatch.cpython-310-arm-linux-gnueabihf.so,sha256=P7355wvpoDxqzPXR1v7PGfFDZ4nK6cka_czQqHuBMbQ,9620
-hyhound/_hyhound.py,sha256=Qq4QcfETX6JJ8bta2vX4JM2dA9BZtHvfmhOiztQOPWU,446
-hyhound/_hyhound.pyi,sha256=FYMsgReExWKPbFNDBpEX_VSVMIwizn8IodQeXIr1txs,10480
-hyhound/_hyhound_generic.cpython-310-arm-linux-gnueabihf.so,sha256=-PXww0UOvfjYQ4fLusuteEP3Lt714-Wf10yg43AEFw4,802864
-hyhound/libnanobind-hyhound.so,sha256=4fhyCSDK3lyF7x-lI5y1bNcaTh-3u-PO4L4SnGqrJHI,299664
-hyhound/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-hyhound-1.0.2a1.dist-info/METADATA,sha256=Vbl_u4t1EIqbSddPclr_MkpGfRZe7fuskdMu55UfVZE,3745
-hyhound-1.0.2a1.dist-info/WHEEL,sha256=bjGf3-Ep9LM1r6aUkCHLphZ86Eqzbqb1ROGeLbvmdNg,96
-hyhound-1.0.2a1.dist-info/entry_points.txt,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-hyhound-1.0.2a1.dist-info/licenses/LICENSE,sha256=46mU2C5kSwOnkqkw9XQAJlhBL2JAf1_uCD8lVcXyMRg,7652
-hyhound-1.0.2a1.dist-info/RECORD,,