funi 0.0.0__tar.gz

funi-0.0.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 tataratat
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

funi-0.0.0/PKG-INFO

@@ -0,0 +1,66 @@
+Metadata-Version: 2.1
+Name: funi
+Version: 0.0.0
+Summary: Find unique float arrays
+Home-page: https://github.com/tataratat/funi
+Author: Jaewook Lee
+Author-email: jaewooklee042@gmail.com
+License: MIT
+Classifier: Development Status :: 2 - Pre-Alpha
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3.6
+Classifier: Programming Language :: Python :: 3.7
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Natural Language :: English
+Classifier: Topic :: Scientific/Engineering
+Description-Content-Type: text/markdown
+License-File: LICENSE
+
+# funi
+Find UNIque float array rows.
+[numpy.unique](https://numpy.org/doc/stable/reference/generated/numpy.unique.html) is an awesome function that alleviates headaches, fast.
+Haven you wished that it'd be applicable for 2D float arrays?
+`funi` is here to help!
+
+## Install
+```bash
+pip install funi
+```
+
+## Quick Start
+```python
+import funi
+import numpy as np
+
+# create a random array with duplicating entries
+arr = np.random.random((10000, 3))
+arr = np.vstack((arr, arr, arr))
+np.random.shuffle(arr)
+
+# specify tolerance and
+# tolerance is used to compare entries in column-wise.
+# consider it as bounding-box edge length for duplicate identification
+# with stable_sort + sorted_index unique_id will start from 0
+unique_data, unique_ids, inverse = funi.unique_rows(
+    arr,
+    tolerance=1e-11,
+    return_unique=True,
+    return_index=True,
+    sorted_index=True,
+    return_inverse=True,
+    stable_sort=True,
+)
+
+# use ids to extract unique_data from the original array
+assert np.allclose(unique_data, arr[unique_ids])
+
+# use inverse to map unique_data back to the original array
+assert np.allclose(arr, unique_data[inverse])
+
+# sorted_index=True gives you sorted unique_ids and corresponding inverse
+assert np.alltrue(np.sort(unique_ids) == unique_ids)
+```

funi-0.0.0/README.md

@@ -0,0 +1,44 @@
+# funi
+Find UNIque float array rows.
+[numpy.unique](https://numpy.org/doc/stable/reference/generated/numpy.unique.html) is an awesome function that alleviates headaches, fast.
+Haven you wished that it'd be applicable for 2D float arrays?
+`funi` is here to help!
+
+## Install
+```bash
+pip install funi
+```
+
+## Quick Start
+```python
+import funi
+import numpy as np
+
+# create a random array with duplicating entries
+arr = np.random.random((10000, 3))
+arr = np.vstack((arr, arr, arr))
+np.random.shuffle(arr)
+
+# specify tolerance and
+# tolerance is used to compare entries in column-wise.
+# consider it as bounding-box edge length for duplicate identification
+# with stable_sort + sorted_index unique_id will start from 0
+unique_data, unique_ids, inverse = funi.unique_rows(
+    arr,
+    tolerance=1e-11,
+    return_unique=True,
+    return_index=True,
+    sorted_index=True,
+    return_inverse=True,
+    stable_sort=True,
+)
+
+# use ids to extract unique_data from the original array
+assert np.allclose(unique_data, arr[unique_ids])
+
+# use inverse to map unique_data back to the original array
+assert np.allclose(arr, unique_data[inverse])
+
+# sorted_index=True gives you sorted unique_ids and corresponding inverse
+assert np.alltrue(np.sort(unique_ids) == unique_ids)
+```

funi-0.0.0/funi.egg-info/PKG-INFO

@@ -0,0 +1,66 @@
+Metadata-Version: 2.1
+Name: funi
+Version: 0.0.0
+Summary: Find unique float arrays
+Home-page: https://github.com/tataratat/funi
+Author: Jaewook Lee
+Author-email: jaewooklee042@gmail.com
+License: MIT
+Classifier: Development Status :: 2 - Pre-Alpha
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3.6
+Classifier: Programming Language :: Python :: 3.7
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Natural Language :: English
+Classifier: Topic :: Scientific/Engineering
+Description-Content-Type: text/markdown
+License-File: LICENSE
+
+# funi
+Find UNIque float array rows.
+[numpy.unique](https://numpy.org/doc/stable/reference/generated/numpy.unique.html) is an awesome function that alleviates headaches, fast.
+Haven you wished that it'd be applicable for 2D float arrays?
+`funi` is here to help!
+
+## Install
+```bash
+pip install funi
+```
+
+## Quick Start
+```python
+import funi
+import numpy as np
+
+# create a random array with duplicating entries
+arr = np.random.random((10000, 3))
+arr = np.vstack((arr, arr, arr))
+np.random.shuffle(arr)
+
+# specify tolerance and
+# tolerance is used to compare entries in column-wise.
+# consider it as bounding-box edge length for duplicate identification
+# with stable_sort + sorted_index unique_id will start from 0
+unique_data, unique_ids, inverse = funi.unique_rows(
+    arr,
+    tolerance=1e-11,
+    return_unique=True,
+    return_index=True,
+    sorted_index=True,
+    return_inverse=True,
+    stable_sort=True,
+)
+
+# use ids to extract unique_data from the original array
+assert np.allclose(unique_data, arr[unique_ids])
+
+# use inverse to map unique_data back to the original array
+assert np.allclose(arr, unique_data[inverse])
+
+# sorted_index=True gives you sorted unique_ids and corresponding inverse
+assert np.alltrue(np.sort(unique_ids) == unique_ids)
+```

funi-0.0.0/funi.egg-info/SOURCES.txt

@@ -0,0 +1,12 @@
+LICENSE
+README.md
+pyproject.toml
+setup.py
+funi.egg-info/PKG-INFO
+funi.egg-info/SOURCES.txt
+funi.egg-info/dependency_links.txt
+funi.egg-info/not-zip-safe
+funi.egg-info/requires.txt
+funi.egg-info/top_level.txt
+src/pyfuni.cpp
+tests/test_funi.py

funi-0.0.0/funi.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

funi-0.0.0/funi.egg-info/not-zip-safe

@@ -0,0 +1 @@
+

funi-0.0.0/funi.egg-info/requires.txt

@@ -0,0 +1 @@
+numpy

funi-0.0.0/funi.egg-info/top_level.txt

@@ -0,0 +1 @@
+funi

funi-0.0.0/pyproject.toml

@@ -0,0 +1,18 @@
+[build-system]
+requires = [
+    "setuptools>=42",
+    "wheel",
+    "pybind11",
+]
+
+build-backend = "setuptools.build_meta"
+
+[tool.cibuildwheel]
+test-command = "python {project}/tests/test_funi.py"
+
+[tool.cibuildwheel.macos]
+archs = ["x86_64", "arm64"]
+test-skip = ["*arm64"]
+
+[tool.cibuildwheel.windows]
+skip = "pp*"

funi-0.0.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

funi-0.0.0/setup.py

@@ -0,0 +1,49 @@
+from pybind11.setup_helpers import Pybind11Extension, build_ext
+from setuptools import setup
+
+with open("README.md") as f:
+    readme = f.read()
+
+__version__ = "0.0.0"
+
+ext_modules = [
+    Pybind11Extension(
+        "funi",
+        ["src/pyfuni.cpp"],
+        include_dirs=["src"],
+        extra_compile_args=["-O3"],
+        cxx_std=17,
+    )
+]
+
+setup(
+    name="funi",
+    version=__version__,
+    description="Find unique float arrays",
+    long_description=readme,
+    long_description_content_type="text/markdown",
+    author="Jaewook Lee",
+    author_email="jaewooklee042@gmail.com",
+    url="https://github.com/tataratat/funi",
+    ext_modules=ext_modules,
+    cmdclass={"build_ext": build_ext},
+    package_data={"src": ["*.hpp"]},
+    classifiers=[
+        "Development Status :: 2 - Pre-Alpha",
+        "License :: OSI Approved :: MIT License",
+        "Programming Language :: Python",
+        "Programming Language :: Python :: 3.6",
+        "Programming Language :: Python :: 3.7",
+        "Programming Language :: Python :: 3.8",
+        "Programming Language :: Python :: 3.9",
+        "Programming Language :: Python :: 3.10",
+        "Programming Language :: Python :: 3.11",
+        "Natural Language :: English",
+        "Topic :: Scientific/Engineering",
+    ],
+    install_requires=[
+        "numpy",
+    ],
+    zip_safe=False,
+    license="MIT",
+)

funi-0.0.0/src/pyfuni.cpp

@@ -0,0 +1,10 @@
+#include <pybind11/numpy.h>
+#include <pybind11/pybind11.h>
+
+#include <pyfuni.hpp>
+
+PYBIND11_MODULE(funi, m) {
+  m.def("unique_float32", &funi::Unique<float>);
+  m.def("unique_float64", &funi::Unique<double>);
+  m.def("unique_rows", &funi::UniqueRows);
+}

funi-0.0.0/tests/test_funi.py

@@ -0,0 +1,80 @@
+import unittest
+
+import numpy as np
+
+import funi
+
+
+class FuniTest(unittest.TestCase):
+    def setUp(self):
+        # stack 100 x 3 arrays 3 times then shuffle
+        q = np.random.rand(100, 3)
+        self.q = np.vstack((q, q, q))
+        np.random.shuffle(self.q)
+
+    def test_all_return(self):
+        tol = 1e-10
+
+        # sorted indices
+        unique_s, ids_s, inv_s = funi.unique_float64(
+            self.q, tol, True, True, True, True, True
+        )
+
+        # mapping check
+        assert np.allclose(self.q[ids_s], unique_s)
+        assert np.allclose(self.q, unique_s[inv_s])
+
+        # sortedness check
+        assert ~np.all(np.diff(ids_s) < 0)
+
+        # not sorted
+        # sorted indices
+        unique_ns, ids_ns, inv_ns = funi.unique_float64(
+            self.q, tol, True, True, False, True, True
+        )
+
+        # mapping check
+        assert np.allclose(self.q[ids_ns], unique_ns)
+        assert np.allclose(self.q, unique_ns[inv_ns])
+
+        # no unique return - sorted
+        unique, ids, inv = funi.unique_float64(
+            self.q, tol, False, True, True, True, True
+        )
+
+        assert unique.size == 0
+        assert np.allclose(self.q, self.q[ids][inv])
+        assert np.allclose(ids, ids_s)
+        assert np.allclose(inv, inv_s)
+
+        # no unique return - not sorted
+        unique, ids, inv = funi.unique_float64(
+            self.q, tol, False, True, False, True, True
+        )
+
+        assert unique.size == 0
+        assert np.allclose(self.q, self.q[ids][inv])
+        assert np.allclose(ids, ids_ns)
+        assert np.allclose(inv, inv_ns)
+
+        # no inverse - sorted
+        unique, ids, inv = funi.unique_float64(
+            self.q, tol, True, True, True, False, True
+        )
+
+        assert inv.size == 0
+        assert np.allclose(unique, self.q[ids])
+        assert np.allclose(ids, ids_s)
+
+        # no invese - not sorted
+        unique, ids, inv = funi.unique_float64(
+            self.q, tol, True, True, False, False, True
+        )
+
+        assert inv.size == 0
+        assert np.allclose(unique, self.q[ids])
+        assert np.allclose(ids, ids_ns)
+
+
+if __name__ == "__main__":
+    unittest.main()