imops 0.8.2__cp36-cp36m-musllinux_1_1_i686.whl → 0.8.3__cp36-cp36m-musllinux_1_1_i686.whl

imops/src/_numeric.pyx

@@ -8,10 +8,19 @@
 import numpy as np
 
 cimport numpy as np
+from libc.stdint cimport uint16_t
 
 from cython.parallel import prange
 
 
+# https://stackoverflow.com/questions/47421443/using-half-precision-numpy-floats-in-cython
+cdef extern from "numpy/halffloat.h":
+    ctypedef uint16_t npy_half
+
+    float npy_half_to_float(npy_half h) nogil
+    npy_half npy_float_to_half(float f) nogil
+
+
 ctypedef fused NUM:
     short
     int
@@ -20,45 +29,214 @@ ctypedef fused NUM:
     double
 
 
-def _parallel_sum(NUM[:] nums, Py_ssize_t num_threads) -> NUM:
-    cdef NUM res = 0
-    cdef Py_ssize_t i, len_nums = len(nums)
+ctypedef fused NUM_AND_NPY_HALF:
+    NUM
+    npy_half
 
-    for i in prange(len_nums, num_threads=num_threads, nogil=True):
-        res += nums[i]
 
-    return res
-
-
-def _parallel_pointwise_mul(
+# TODO: Generalize code below to n-d
+def _pointwise_add_array_3d(
     NUM[:, :, :] nums1,
     NUM[:, :, :] nums2,
-    Py_ssize_t[:] res_shape,
-    Py_ssize_t num_threads
+    NUM[:, :, :] out,
+    Py_ssize_t num_threads,
 ) -> np.ndarray:
-    cdef NUM[:, :, ::1] contiguous_nums1 = np.ascontiguousarray(nums1), contiguous_nums2 = np.ascontiguousarray(nums2)
-    cdef Py_ssize_t rows = res_shape[0], cols = res_shape[1], dims = res_shape[2]
+    cdef Py_ssize_t rows = out.shape[0], cols = out.shape[1], dims = out.shape[2]
+    cdef Py_ssize_t i, j, k
+
+    for i in prange(rows, nogil=True, num_threads=num_threads):
+        for j in prange(cols):
+            for k in prange(dims):
+                out[i, j, k] = nums1[i, j, k] + nums2[i, j, k]
+
+    return np.asarray(out)
 
-    cdef char[:] broadcast_mask1 = np.array([x == y for x, y in zip(res_shape, nums1.shape)], dtype=np.int8)
-    cdef char[:] broadcast_mask2 = np.array([x == y for x, y in zip(res_shape, nums2.shape)], dtype=np.int8)
 
-    cdef NUM[:, :, ::1] mul = np.empty_like(nums1, shape=res_shape)
+def _pointwise_add_array_4d(
+    NUM[:, :, :, :] nums1,
+    NUM[:, :, :, :] nums2,
+    NUM[:, :, :, :] out,
+    Py_ssize_t num_threads,
+) -> np.ndarray:
+    cdef Py_ssize_t dim1 = out.shape[0], dim2 = out.shape[1], dim3 = out.shape[2], dim4 = out.shape[3]
+    cdef Py_ssize_t i1, i2, i3, i4
+
+    for i1 in prange(dim1, nogil=True, num_threads=num_threads):
+        for i2 in prange(dim2):
+            for i3 in prange(dim3):
+                for i4 in prange(dim4):
+                    out[i1, i2, i3, i4] = nums1[i1, i2, i3, i4] + nums2[i1, i2, i3, i4]
+
+    return np.asarray(out)
+
+
+def _pointwise_add_value_3d(
+    NUM[:, :, :] nums,
+    NUM value,
+    NUM[:, :, :] out,
+    Py_ssize_t num_threads,
+) -> np.ndarray:
+    cdef Py_ssize_t rows = out.shape[0], cols = out.shape[1], dims = out.shape[2]
     cdef Py_ssize_t i, j, k
 
     for i in prange(rows, nogil=True, num_threads=num_threads):
         for j in prange(cols):
             for k in prange(dims):
-                mul[i, j, k] = (
-                    contiguous_nums1[
-                        i * broadcast_mask1[0],
-                        j * broadcast_mask1[1],
-                        k * broadcast_mask1[2]
-                    ] *
-                    contiguous_nums2[
-                        i * broadcast_mask2[0],
-                        j * broadcast_mask2[1],
-                        k * broadcast_mask2[2]
-                    ]
-                )
-
-    return np.asarray(mul)
+                out[i, j, k] = nums[i, j, k] + value
+
+    return np.asarray(out)
+
+
+def _pointwise_add_value_4d(
+    NUM[:, :, :, :] nums,
+    NUM value,
+    NUM[:, :, :, :] out,
+    Py_ssize_t num_threads,
+) -> np.ndarray:
+    cdef Py_ssize_t dim1 = out.shape[0], dim2 = out.shape[1], dim3 = out.shape[2], dim4 = out.shape[3]
+    cdef Py_ssize_t i1, i2, i3, i4
+
+    for i1 in prange(dim1, nogil=True, num_threads=num_threads):
+        for i2 in prange(dim2):
+            for i3 in prange(dim3):
+                for i4 in prange(dim4):
+                    out[i1, i2, i3, i4] = nums[i1, i2, i3, i4] + value
+
+    return np.asarray(out)
+
+
+def _pointwise_add_array_3d_fp16(
+    npy_half[:, :, :] nums1,
+    npy_half[:, :, :] nums2,
+    npy_half[:, :, :] out,
+    Py_ssize_t num_threads,
+) -> np.ndarray:
+    cdef Py_ssize_t rows = out.shape[0], cols = out.shape[1], dims = out.shape[2]
+    cdef Py_ssize_t i, j, k
+
+    for i in prange(rows, nogil=True, num_threads=num_threads):
+        for j in prange(cols):
+            for k in prange(dims):
+                out[i, j, k] = (npy_float_to_half(npy_half_to_float(nums1[i, j, k]) +
+                                npy_half_to_float(nums2[i, j, k])))
+
+    return np.asarray(out)
+
+
+def _pointwise_add_array_4d_fp16(
+    npy_half[:, :, :, :] nums1,
+    npy_half[:, :, :, :] nums2,
+    npy_half[:, :, :, :] out,
+    Py_ssize_t num_threads,
+) -> np.ndarray:
+    cdef Py_ssize_t dim1 = out.shape[0], dim2 = out.shape[1], dim3 = out.shape[2], dim4 = out.shape[3]
+    cdef Py_ssize_t i1, i2, i3, i4
+
+    for i1 in prange(dim1, nogil=True, num_threads=num_threads):
+        for i2 in prange(dim2):
+            for i3 in prange(dim3):
+                for i4 in prange(dim4):
+                    out[i1, i2, i3, i4] = (npy_float_to_half(npy_half_to_float(nums1[i1, i2, i3, i4]) +
+                                           npy_half_to_float(nums2[i1, i2, i3, i4])))
+
+    return np.asarray(out)
+
+
+def _pointwise_add_value_3d_fp16(
+    npy_half[:, :, :] nums,
+    npy_half value,
+    npy_half[:, :, :] out,
+    Py_ssize_t num_threads,
+) -> np.ndarray:
+    cdef Py_ssize_t rows = out.shape[0], cols = out.shape[1], dims = out.shape[2]
+    cdef Py_ssize_t i, j, k
+
+    for i in prange(rows, nogil=True, num_threads=num_threads):
+        for j in prange(cols):
+            for k in prange(dims):
+                out[i, j, k] = npy_float_to_half(npy_half_to_float(nums[i, j, k]) + npy_half_to_float(value))
+
+    return np.asarray(out)
+
+
+def _pointwise_add_value_4d_fp16(
+    npy_half[:, :, :, :] nums,
+    npy_half value,
+    npy_half[:, :, :, :] out,
+    Py_ssize_t num_threads,
+) -> np.ndarray:
+    cdef Py_ssize_t dim1 = out.shape[0], dim2 = out.shape[1], dim3 = out.shape[2], dim4 = out.shape[3]
+    cdef Py_ssize_t i1, i2, i3, i4
+
+    for i1 in prange(dim1, nogil=True, num_threads=num_threads):
+        for i2 in prange(dim2):
+            for i3 in prange(dim3):
+                for i4 in prange(dim4):
+                    out[i1, i2, i3, i4] = (npy_float_to_half(npy_half_to_float(nums[i1, i2, i3, i4]) +
+                                           npy_half_to_float(value)))
+
+    return np.asarray(out)
+
+
+def _fill_3d(NUM_AND_NPY_HALF[:, :, :] nums, NUM_AND_NPY_HALF value, Py_ssize_t num_threads) -> None:
+    cdef Py_ssize_t rows = nums.shape[0], cols = nums.shape[1], dims = nums.shape[2]
+    cdef Py_ssize_t i, j, k
+
+    for i in prange(rows, nogil=True, num_threads=num_threads):
+        for j in prange(cols):
+            for k in prange(dims):
+                nums[i, j, k] = value
+
+
+def _fill_4d(NUM_AND_NPY_HALF[:, :, :, :] nums, NUM_AND_NPY_HALF value, Py_ssize_t num_threads) -> None:
+    cdef Py_ssize_t dim1 = nums.shape[0], dim2 = nums.shape[1], dim3 = nums.shape[2], dim4 = nums.shape[3]
+    cdef Py_ssize_t i1, i2, i3, i4
+
+    for i1 in prange(dim1, nogil=True, num_threads=num_threads):
+        for i2 in prange(dim2):
+            for i3 in prange(dim3):
+                for i4 in prange(dim4):
+                    nums[i1, i2, i3, i4] = value
+
+
+# FIXME: somehow `const NUM_AND_NPY_HALF` is not working
+cpdef void _copy_3d(const NUM[:, :, :] nums1, NUM[:, :, :] nums2, Py_ssize_t num_threads):
+    cdef Py_ssize_t rows = nums1.shape[0], cols = nums1.shape[1], dims = nums1.shape[2]
+    cdef Py_ssize_t i, j, k
+
+    for i in prange(rows, nogil=True, num_threads=num_threads):
+        for j in prange(cols):
+            for k in prange(dims):
+                nums2[i, j, k] = nums1[i, j, k]
+
+
+cpdef void _copy_4d(const NUM[:, :, :, :] nums1, NUM[:, :, :, :] nums2, Py_ssize_t num_threads):
+    cdef Py_ssize_t dim1 = nums1.shape[0], dim2 = nums1.shape[1], dim3 = nums1.shape[2], dim4 = nums1.shape[3]
+    cdef Py_ssize_t i1, i2, i3, i4
+
+    for i1 in prange(dim1, nogil=True, num_threads=num_threads):
+        for i2 in prange(dim2):
+            for i3 in prange(dim3):
+                for i4 in prange(dim4):
+                    nums2[i1, i2, i3, i4] = nums1[i1, i2, i3, i4]
+
+
+cpdef void _copy_3d_fp16(const npy_half[:, :, :] nums1, npy_half[:, :, :] nums2, Py_ssize_t num_threads):
+    cdef Py_ssize_t rows = nums1.shape[0], cols = nums1.shape[1], dims = nums1.shape[2]
+    cdef Py_ssize_t i, j, k
+
+    for i in prange(rows, nogil=True, num_threads=num_threads):
+        for j in prange(cols):
+            for k in prange(dims):
+                nums2[i, j, k] = nums1[i, j, k]
+
+
+cpdef void _copy_4d_fp16(const npy_half[:, :, :, :] nums1, npy_half[:, :, :, :] nums2, Py_ssize_t num_threads):
+    cdef Py_ssize_t dim1 = nums1.shape[0], dim2 = nums1.shape[1], dim3 = nums1.shape[2], dim4 = nums1.shape[3]
+    cdef Py_ssize_t i1, i2, i3, i4
+
+    for i1 in prange(dim1, nogil=True, num_threads=num_threads):
+        for i2 in prange(dim2):
+            for i3 in prange(dim3):
+                for i4 in prange(dim4):
+                    nums2[i1, i2, i3, i4] = nums1[i1, i2, i3, i4]

imops/utils.py

@@ -1,39 +1,92 @@
 import os
+from contextlib import contextmanager
 from itertools import permutations
 from typing import Callable, Optional, Sequence, Tuple, Union
 from warnings import warn
 
 import numpy as np
 
-from .backend import BACKEND2NUM_THREADS_VAR_NAME, SINGLE_THREADED_BACKENDS, Backend
+from .backend import BACKEND_NAME2ENV_NUM_THREADS_VAR_NAME, SINGLE_THREADED_BACKENDS, Backend
 
 
 AxesLike = Union[int, Sequence[int]]
 AxesParams = Union[float, Sequence[float]]
 
 ZOOM_SRC_DIM = 4
+# TODO: define imops-specific environment variable like `OMP_NUM_THREADS`?
+IMOPS_NUM_THREADS = None
 
 
-def normalize_num_threads(num_threads: int, backend: Backend):
+def set_num_threads(num_threads: int) -> int:
+    assert isinstance(num_threads, int) or num_threads is None, 'Number of threads must be int value or None.'
+    global IMOPS_NUM_THREADS
+    current = IMOPS_NUM_THREADS
+    IMOPS_NUM_THREADS = num_threads
+    return current
+
+
+@contextmanager
+def imops_num_threads(num_threads: int):
+    previous = set_num_threads(num_threads)
+    try:
+        yield
+    finally:
+        set_num_threads(previous)
+
+
+def normalize_num_threads(num_threads: int, backend: Backend, warn_stacklevel: int = 1) -> int:
+    """Calculate the effective number of threads"""
+
+    global IMOPS_NUM_THREADS
     if backend.name in SINGLE_THREADED_BACKENDS:
         if num_threads != -1:
-            warn(f'"{backend.name}" backend is single-threaded. Setting `num_threads` has no effect.')
+            warn(
+                f'"{backend.name}" backend is single-threaded. Setting `num_threads` has no effect.',
+                stacklevel=warn_stacklevel,
+            )
         return 1
+
+    env_num_threads_var_name = BACKEND_NAME2ENV_NUM_THREADS_VAR_NAME[backend.name]
+    # here we also handle the case `env_num_threads_var_name`=" " gracefully
+    env_num_threads = os.environ.get(env_num_threads_var_name, '').strip()
+    env_num_threads = int(env_num_threads) if env_num_threads else None
+    # TODO: maybe let user set the absolute maximum number of threads?
+    num_available_cpus = len(os.sched_getaffinity(0))
+
+    max_num_threads = min(filter(bool, [IMOPS_NUM_THREADS, env_num_threads, num_available_cpus]))
+
     if num_threads >= 0:
         # FIXME
         if backend.name == 'Numba':
             warn(
                 'Setting `num_threads` has no effect with "Numba" backend. '
-                'Use `NUMBA_NUM_THREADS` environment variable.'
+                'Use `NUMBA_NUM_THREADS` environment variable.',
+                stacklevel=warn_stacklevel,
             )
-        return num_threads
-
-    num_threads_var_name = BACKEND2NUM_THREADS_VAR_NAME[backend.name]
-    # here we also handle the case `num_threads_var`=" " gracefully
-    env_num_threads = os.environ.get(num_threads_var_name, '').strip()
-    max_threads = int(env_num_threads) if env_num_threads else len(os.sched_getaffinity(0))
-
-    return max_threads + num_threads + 1
+            return num_threads
+
+        if num_threads > max_num_threads:
+            if max_num_threads == IMOPS_NUM_THREADS:
+                warn(
+                    f'Required number of threads ({num_threads}) is greater than `IMOPS_NUM_THREADS` '
+                    f'({IMOPS_NUM_THREADS}). Using {IMOPS_NUM_THREADS} threads.',
+                    stacklevel=warn_stacklevel,
+                )
+            elif max_num_threads == env_num_threads:
+                warn(
+                    f'Required number of threads ({num_threads}) is greater than `{env_num_threads_var_name}` '
+                    f'({env_num_threads}). Using {env_num_threads} threads.',
+                    stacklevel=warn_stacklevel,
+                )
+            else:
+                warn(
+                    f'Required number of threads ({num_threads}) is greater than number of available CPU-s '
+                    f'({num_available_cpus}). Using {num_available_cpus} threads.',
+                    stacklevel=warn_stacklevel,
+                )
+        return min(num_threads, max_num_threads)
+
+    return max_num_threads + num_threads + 1
 
 
 def get_c_contiguous_permutaion(array: np.ndarray) -> Optional[np.ndarray]:

imops/zoom.py

@@ -208,7 +208,7 @@ def _zoom(
 
     See `https://docs.scipy.org/doc/scipy/reference/generated/scipy.ndimage.zoom.html`
     """
-    backend = resolve_backend(backend)
+    backend = resolve_backend(backend, warn_stacklevel=4)
     if backend.name not in ('Scipy', 'Numba', 'Cython'):
         raise ValueError(f'Unsupported backend "{backend.name}".')
 
@@ -216,7 +216,7 @@ def _zoom(
     dtype = input.dtype
     cval = np.dtype(dtype).type(cval)
     zoom = fill_by_indices(np.ones(input.ndim, 'float64'), zoom, range(input.ndim))
-    num_threads = normalize_num_threads(num_threads, backend)
+    num_threads = normalize_num_threads(num_threads, backend, warn_stacklevel=4)
 
     if backend.name == 'Scipy':
         return scipy_zoom(

{imops-0.8.2.dist-info → imops-0.8.3.dist-info}/METADATA

@@ -1,12 +1,12 @@
 Metadata-Version: 2.1
 Name: imops
-Version: 0.8.2
+Version: 0.8.3
 Summary: Efficient parallelizable algorithms for multidimensional arrays to speed up your data pipelines
 Home-page: https://github.com/neuro-ml/imops
 Author: maxme1, vovaf709, talgat
 Author-email: maxs987@gmail.com, vovaf709@yandex.ru, saparov2130@gmail.com
 License: MIT
-Download-URL: https://github.com/neuro-ml/imops/archive/v0.8.2.tar.gz
+Download-URL: https://github.com/neuro-ml/imops/archive/v0.8.3.tar.gz
 Keywords: image processing,fast,ndarray,data pipelines
 Platform: UNKNOWN
 Classifier: Development Status :: 5 - Production/Stable
@@ -21,6 +21,7 @@ Requires-Python: >=3.6
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: scipy (<2.0.0,>=1.0)
+Requires-Dist: scikit-image
 Requires-Dist: connected-components-3d
 Requires-Dist: fastremap
 Requires-Dist: dataclasses ; python_version < "3.7"

imops-0.8.3.dist-info/RECORD

@@ -0,0 +1,47 @@
+imops-0.8.3.dist-info/METADATA,sha256=NdA1fnC5rCLIg-kvfInPxqlWIckur-inz1uUF89mft0,7391
+imops-0.8.3.dist-info/LICENSE,sha256=s4td51soCfOr_HP5fF2gTARksncu_DD1TgugcUGTBQ0,1064
+imops-0.8.3.dist-info/WHEEL,sha256=vKL5TyPvBaqrVS_wrd1wwVcCEkHcF1Y5mT8I1AQaxRA,110
+imops-0.8.3.dist-info/RECORD,,
+imops-0.8.3.dist-info/top_level.txt,sha256=kEVHvrc8A4lkLQP8xew2pWdYcyQAMvAwqnlZXtoWwnc,6
+imops.libs/libgomp-41890ef0.so.1.0.0,sha256=v1S9wI3pI7LI5wKB6AvV6AdAUscM_zZ95LWxXvmoAN8,195208
+imops/morphology.py,sha256=rIzE7HXyBE91NWMR9rR1di4s0QccRnPMxivA3PnlM1M,12376
+imops/backend.py,sha256=9kJtdd4-66SOP7MEXF-o9-aFImLtvpaqTKe1ttNb0hk,2503
+imops/__version__.py,sha256=LokQdkRCwhhLh0zOp7jizhyDgbtAU-IWRIObrz2zLjA,22
+imops/radon.py,sha256=bygHhDe_SD7sjubcGBsXtTa3z4-z1JiOXpkIRSt8xpw,8968
+imops/crop.py,sha256=PSOOlJUb_R8Hj3P18aRicwFXil19Q6a1QrwLmZZfZkQ,3945
+imops/utils.py,sha256=X6dYRExW4nnpgO1z5-DcHhmReIvzaOBdBNKd5TeUbjg,6684
+imops/measure.py,sha256=ehJ1F4DJK6FTS0XsuKzzxQnFX78Fo4eShinYYrbItu8,8433
+imops/pad.py,sha256=AjgLCQVgGOwVNxYY7xMMyX7YO82uObxEroApuQxZE34,9069
+imops/_configs.py,sha256=PoPlwnmmCz-Z8GmKYIqR8xsqcWHPKiYSGWldbQX9GU0,705
+imops/zoom.py,sha256=cHKuXrKY5GmBDLMat1_ElIBuZGd8Mk5MXHtVD5WtEQk,9664
+imops/__init__.py,sha256=FUVB4d2PQlM4PJUSIjyz9oRlWaqU6RSskyyrX56-RrY,504
+imops/numeric.py,sha256=OUu-aXg2ZsULvBxwxFd3pbeFzIhlTlt5fO2Koje7wPo,13274
+imops/box.py,sha256=3WrOdpUigoGKNnWhLLgX5NX_D9WzgwDKIWf75baTK-Y,1794
+imops/interp1d.py,sha256=FUVvEIldoIf4_-RbRcZHrbNZ6UoW9cpRfW4flWCxdyI,8195
+imops/testing.py,sha256=JgUWoD7fzshdaVrrgmf9y9jpl3EHgmoYYmHHGCFI4Ws,1650
+imops/src/_numeric.pyx,sha256=05GbyyFzdill8M_L9KYA9hfYP7ULiAnvMpWyBATl7vQ,7979
+imops/src/_radon.pyx,sha256=ztXVnOfUjsRY5R22-7LbodG_FAbUoBemTnaIDZsPeI4,2896
+imops/src/_zoom.cpython-36m-i386-linux-gnu.so,sha256=5ZHv7Qp5-8Kuj2SVHJgijJvLFO03Mb9g3SN8XvcWv3s,2705820
+imops/src/_morphology.cpython-36m-i386-linux-gnu.so,sha256=CyUwzySEqPsUAeQNb24QVYg_im3luw0L7uzRdohSyK4,997184
+imops/src/_fast_radon.cpython-36m-i386-linux-gnu.so,sha256=rI2jqfqf-8AmxsBGqgmRlXHS0hwzDGvBEVc-JknORVE,1403312
+imops/src/_fast_radon.pyx,sha256=ztXVnOfUjsRY5R22-7LbodG_FAbUoBemTnaIDZsPeI4,2896
+imops/src/_fast_morphology.cpython-36m-i386-linux-gnu.so,sha256=qcyftg7hEBkk3VyQYd9e66d1E8X2WOeWoY-FJp5kvJU,1001292
+imops/src/_fast_measure.pyx,sha256=pKFBt8ITxy1QsO5wFkRrhdYMfT2ENCA7yPZ-ZJRCh44,2650
+imops/src/_fast_morphology.pyx,sha256=X96ad1iadGPelOipNjXNd9s77x95LCVFBTAs0gr4iXE,9209
+imops/src/_morphology.pyx,sha256=X96ad1iadGPelOipNjXNd9s77x95LCVFBTAs0gr4iXE,9209
+imops/src/_measure.cpython-36m-i386-linux-gnu.so,sha256=VSUfpKZnfH9m_vC3St0RBbsh8vUm6aPHlLMgargFb8E,1530424
+imops/src/_fast_zoom.cpython-36m-i386-linux-gnu.so,sha256=J95uGErxll9HspJeWn3OgRpI9q4f-jsLXvIkh9k8HSc,2714024
+imops/src/_numeric.cpython-36m-i386-linux-gnu.so,sha256=7PnAFhQv07WK5nBm8lOndlHFIZ4uKMA_jtM5lVgJxVY,2512784
+imops/src/_numba_zoom.py,sha256=NH1u-64xExw0b_l6GQJ7ICOoWVsGOH8ztuS1LFvsiz0,16354
+imops/src/_measure.pyx,sha256=pKFBt8ITxy1QsO5wFkRrhdYMfT2ENCA7yPZ-ZJRCh44,2650
+imops/src/_fast_measure.cpython-36m-i386-linux-gnu.so,sha256=p7PF-YP6bKH3h1vimhSkxE9BdFmR8fmIcxuZJFNESGw,1530432
+imops/src/_backprojection.pyx,sha256=RMB_GS2mbOS8mQWeo640p9FdeHHFjmjW3qrlEGGoL0s,2645
+imops/src/_fast_numeric.pyx,sha256=05GbyyFzdill8M_L9KYA9hfYP7ULiAnvMpWyBATl7vQ,7979
+imops/src/_fast_numeric.cpython-36m-i386-linux-gnu.so,sha256=r6FAEOzngxFuLy9Mqbwc3zC8FOBCKRHF2zRCYZXNonQ,2520984
+imops/src/_radon.cpython-36m-i386-linux-gnu.so,sha256=jG-Z4Yll41PNMRfuxFKwK7PZd857-eQVO5PJy58VLho,1403300
+imops/src/_fast_zoom.pyx,sha256=_7cPgowHRuFuc7WFuqSnbr_gVzsQi2Bu1nhwoi_yDmw,22566
+imops/src/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+imops/src/_backprojection.cpython-36m-i386-linux-gnu.so,sha256=9kiPSNl27lvXmG8yhlZ-Ti0CmU7SH_tHo53wPn_Is_Y,1157552
+imops/src/_fast_backprojection.cpython-36m-i386-linux-gnu.so,sha256=PVJgqh5M2WGkZyqIG4GAO5RmbR21Mn6CpuVh-aIRVGM,1157564
+imops/src/_fast_backprojection.pyx,sha256=RMB_GS2mbOS8mQWeo640p9FdeHHFjmjW3qrlEGGoL0s,2645
+imops/src/_zoom.pyx,sha256=_7cPgowHRuFuc7WFuqSnbr_gVzsQi2Bu1nhwoi_yDmw,22566

imops/_numeric.py

@@ -1,124 +0,0 @@
-from warnings import warn
-
-import numpy as np
-
-from .backend import BackendLike, resolve_backend
-from .src._fast_numeric import (
-    _parallel_pointwise_mul as cython_fast_parallel_pointwise_mul,
-    _parallel_sum as cython_fast_parallel_sum,
-)
-from .src._numeric import _parallel_pointwise_mul as cython_parallel_pointwise_mul, _parallel_sum as cython_parallel_sum
-from .utils import normalize_num_threads
-
-
-def _sum(nums: np.ndarray, num_threads: int = -1, backend: BackendLike = None) -> float:
-    """
-    Parallel sum of flat numpy array
-
-    Parameters
-    ----------
-    nums: np.ndarray
-        1-dimensional array
-    num_threads: int
-        the number of threads to use for computation. Default = the cpu count. If negative value passed
-        cpu count + num_threads + 1 threads will be used
-    backend: BackendLike
-        which backend to use. `cython` and `scipy` (primarly for benchmarking) are available,
-        `cython` is used by default
-
-    Returns
-    -------
-    sum: float
-
-    Examples
-    --------
-    >>> s = _sum(x, num_threads=1)
-    >>> s = _sum(x, num_threads=8, backend=Cython(fast=True))  # ffast-math compiled version
-    """
-    ndim = nums.ndim
-
-    if ndim != 1:
-        raise ValueError(f'Input must be 1-dimensional instead of {ndim}-dimensional.')
-
-    backend = resolve_backend(backend)
-    if backend.name not in ('Cython', 'Scipy'):
-        raise ValueError(f'Unsupported backend "{backend.name}"')
-
-    num_threads = normalize_num_threads(num_threads, backend)
-
-    if backend.name == 'Scipy':
-        return nums.sum()
-
-    if backend.name == 'Cython':
-        src_parallel_sum = cython_fast_parallel_sum if backend.fast else cython_parallel_sum
-
-    return src_parallel_sum(nums, num_threads)
-
-
-def _mul(nums1: np.ndarray, nums2: np.ndarray, num_threads: int = -1, backend: BackendLike = None) -> np.ndarray:
-    """
-    Parallel pointwise multiplication of 2 numpy arrays (aka x * y). Works faster only for ndim <= 3.
-
-    Parameters
-    ----------
-    nums1: np.ndarray
-    nums2: np.ndarray
-    num_threads: int
-        the number of threads to use for computation. Default = the cpu count. If negative value passed
-        cpu count + num_threads + 1 threads will be used
-    backend: BackendLike
-        which backend to use. `cython` and `scipy` (primarly for benchmarking) are available,
-        `cython` is used by default
-
-    Returns
-    -------
-    multiplied: np.ndarray
-        result of nums1 * nums2
-
-    Examples
-    --------
-    >>> mul = _mul(nums1, nums2, num_threads=8)
-    >>> mul = _mul(np.ones((2, 3)), np.ones((1, 3)))  # broadcasting, mul.shape == (2, 3)
-    >>> mul = _mul(nums1, nums2, backend=Cython(fast=True))  # ffast-math compiled version
-    """
-    if not nums1.size and not nums2.size:
-        return np.array([], dtype=nums1.dtype)
-    if bool(nums1.size) ^ bool(nums2.size):
-        raise ValueError('One of the arrays is empty, hence pointwise multiplication cannot be performed.')
-    if len(nums1.shape) != len(nums2.shape):
-        raise ValueError('Both arrays must have the same number of dimensions for pointwise multiplication.')
-    for dim1, dim2 in zip(nums1.shape, nums2.shape):
-        if dim1 != dim2 and dim1 != 1 and dim2 != 1:
-            raise ValueError(f'Arrays of shapes {nums1.shape} and {nums2.shape} are not broadcastable.')
-
-    if nums1.ndim > 3:
-        warn('Parallel pointwise multiplication is only supported for ndim<=3. Falling back to naive x * y.')
-
-        return nums1 * nums2
-
-    backend = resolve_backend(backend)
-    if backend.name not in ('Cython', 'Scipy'):
-        raise ValueError(f'Unsupported backend "{backend.name}"')
-
-    num_threads = normalize_num_threads(num_threads, backend)
-
-    if backend.name == 'Scipy':
-        return nums1 * nums2
-
-    if backend.name == 'Cython':
-        src_parallel_pointwise_mul = (
-            cython_fast_parallel_pointwise_mul if backend.fast else cython_parallel_pointwise_mul
-        )
-
-    n_dummy = 3 - nums1.ndim
-
-    if n_dummy:
-        nums1 = nums1[(None,) * n_dummy]
-        nums2 = nums2[(None,) * n_dummy]
-
-    out = src_parallel_pointwise_mul(nums1, nums2, np.maximum(nums1.shape, nums2.shape), num_threads)
-
-    if n_dummy:
-        out = out[(0,) * n_dummy]
-
-    return out

imops-0.8.2.dist-info/RECORD

@@ -1,47 +0,0 @@
-imops/measure.py,sha256=CtR6Qx8oU_FX3XbC1HIqOV0kMr_E0qq3wwg646FTXV4,8351
-imops/pad.py,sha256=FBRsooy11j3XJbrTeewgVS_qpKvkMnc_0J-tGJ061DI,7238
-imops/crop.py,sha256=26dS16ryTDlizCzPQFjN9E-_dUgRR4XHZZwow2nJ4UU,3352
-imops/box.py,sha256=3WrOdpUigoGKNnWhLLgX5NX_D9WzgwDKIWf75baTK-Y,1794
-imops/radon.py,sha256=LjIrcDmhLc17vVbHERMNlrxsh8_kMXrPDlvZUJtqe64,8767
-imops/_numeric.py,sha256=gb217xV7z3dcH9sE4UFatinIVH9r_7WSRgoveZ7Neno,4259
-imops/_configs.py,sha256=PoPlwnmmCz-Z8GmKYIqR8xsqcWHPKiYSGWldbQX9GU0,705
-imops/utils.py,sha256=8pcn53Rw8LOyO-2vnazlNLrcJ9cEsGgQFQN8X-EYfCQ,4567
-imops/morphology.py,sha256=c_UJvHXsZEgz6b1PgHXkhMII7u7S8-WEJQTjo58045o,12279
-imops/testing.py,sha256=JgUWoD7fzshdaVrrgmf9y9jpl3EHgmoYYmHHGCFI4Ws,1650
-imops/backend.py,sha256=D1TJ1WB7lmzCwjT7KA9axbjC3B6rWRDQP1veTNwFqKI,2277
-imops/interp1d.py,sha256=lLnthTOIB7j7k638174se8omGIKehtNleTtFRIaPACk,7981
-imops/__version__.py,sha256=K2rsUy8S7UHe3tStL6NCs5z92apbvbkrpGIEjcCNCNs,22
-imops/zoom.py,sha256=9JrgjSzedETxCCfhsOrMz9XOQuTi4OtgeC4jFmEVRLE,9626
-imops/__init__.py,sha256=qWjreqFvwVqyxDdV1_ylx-FxsLt9f0vRtgmMt3ZhHjg,450
-imops/src/_fast_backprojection.pyx,sha256=RMB_GS2mbOS8mQWeo640p9FdeHHFjmjW3qrlEGGoL0s,2645
-imops/src/_fast_zoom.pyx,sha256=_7cPgowHRuFuc7WFuqSnbr_gVzsQi2Bu1nhwoi_yDmw,22566
-imops/src/_backprojection.cpython-36m-i386-linux-gnu.so,sha256=R7ai58PmMbl4na-wIZ-1ha8Nusd9ze5B0hJc3zPpDLc,1157552
-imops/src/_zoom.cpython-36m-i386-linux-gnu.so,sha256=ak_r7_B10L7mi7xmgguBzVeRrSw76BDM6UWwaoZyyXQ,2705820
-imops/src/_fast_zoom.cpython-36m-i386-linux-gnu.so,sha256=0fuL7uCLJ3CF6NFjlD3XkGMj10ybuzSwjzW9YMDR9Ps,2673036
-imops/src/_zoom.pyx,sha256=_7cPgowHRuFuc7WFuqSnbr_gVzsQi2Bu1nhwoi_yDmw,22566
-imops/src/_fast_measure.cpython-36m-i386-linux-gnu.so,sha256=_dc5dIVXieewd3FUCJBq31UHX858V4r8TskFBWuvuUA,1534544
-imops/src/_fast_backprojection.cpython-36m-i386-linux-gnu.so,sha256=NNSYmFjCP0JsxQ2G-2BWcPkDtHfYk7xayQW0XZPQiFM,1157532
-imops/src/_morphology.pyx,sha256=X96ad1iadGPelOipNjXNd9s77x95LCVFBTAs0gr4iXE,9209
-imops/src/_backprojection.pyx,sha256=RMB_GS2mbOS8mQWeo640p9FdeHHFjmjW3qrlEGGoL0s,2645
-imops/src/_fast_measure.pyx,sha256=pKFBt8ITxy1QsO5wFkRrhdYMfT2ENCA7yPZ-ZJRCh44,2650
-imops/src/_numeric.pyx,sha256=OHFH0W02-gwB_nW6A5GgVw-70Eb__tiRZnOY1igtqAE,1855
-imops/src/_fast_numeric.cpython-36m-i386-linux-gnu.so,sha256=JeRipp9urmmmcPI3kVFIdA88I5nGKtYRYy3JRKSnoMs,1616236
-imops/src/_numba_zoom.py,sha256=NH1u-64xExw0b_l6GQJ7ICOoWVsGOH8ztuS1LFvsiz0,16354
-imops/src/_radon.cpython-36m-i386-linux-gnu.so,sha256=umxBSCUbfx5oQ-7H6tP-NoqR5AwEC_b4rEqpS3mC7A4,1403300
-imops/src/_fast_morphology.cpython-36m-i386-linux-gnu.so,sha256=lsfWPuExwKJF96fQfdvo3Yl-_Yi0AmuTK4hgm0jmpzY,1001308
-imops/src/_fast_numeric.pyx,sha256=OHFH0W02-gwB_nW6A5GgVw-70Eb__tiRZnOY1igtqAE,1855
-imops/src/_fast_morphology.pyx,sha256=X96ad1iadGPelOipNjXNd9s77x95LCVFBTAs0gr4iXE,9209
-imops/src/_radon.pyx,sha256=ztXVnOfUjsRY5R22-7LbodG_FAbUoBemTnaIDZsPeI4,2896
-imops/src/_fast_radon.cpython-36m-i386-linux-gnu.so,sha256=Vs2JPaN1YszKP3VMQw_8dIYbW4dfF71rMOSPY6f0aUI,1399144
-imops/src/_measure.cpython-36m-i386-linux-gnu.so,sha256=71f6p-uVWwsob49empcSAA8VaNNHP1lQXW0Wrct4XY0,1530424
-imops/src/_measure.pyx,sha256=pKFBt8ITxy1QsO5wFkRrhdYMfT2ENCA7yPZ-ZJRCh44,2650
-imops/src/_numeric.cpython-36m-i386-linux-gnu.so,sha256=z1HVzs-BJ1Zv-JxFO5OZPlUcUDWl8x-A0fz6f1MANMA,1612112
-imops/src/_fast_radon.pyx,sha256=ztXVnOfUjsRY5R22-7LbodG_FAbUoBemTnaIDZsPeI4,2896
-imops/src/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-imops/src/_morphology.cpython-36m-i386-linux-gnu.so,sha256=_DJZrHy_dKDmCuTkY3VhetuEpnQRrEkq5D-8yYFHsY4,997184
-imops.libs/libgomp-41890ef0.so.1.0.0,sha256=v1S9wI3pI7LI5wKB6AvV6AdAUscM_zZ95LWxXvmoAN8,195208
-imops-0.8.2.dist-info/LICENSE,sha256=s4td51soCfOr_HP5fF2gTARksncu_DD1TgugcUGTBQ0,1064
-imops-0.8.2.dist-info/RECORD,,
-imops-0.8.2.dist-info/top_level.txt,sha256=kEVHvrc8A4lkLQP8xew2pWdYcyQAMvAwqnlZXtoWwnc,6
-imops-0.8.2.dist-info/METADATA,sha256=B9oMqoxEC0eeetqk0bQqDGbKTN8qxq3vGrp0sXIq9tg,7363
-imops-0.8.2.dist-info/WHEEL,sha256=vKL5TyPvBaqrVS_wrd1wwVcCEkHcF1Y5mT8I1AQaxRA,110