Adding utils and peak_finding. Fixing window errors in CI

python/cusignal/__init__.py

@@ -78,19 +78,9 @@
 )
 from cusignal.waveforms.waveforms import square, gausspulse, chirp, unit_impulse
 from cusignal.wavelets.wavelets import qmf, morlet, ricker, cwt
-from cusignal._peak_finding import argrelmin, argrelmax, argrelextrema
+from cusignal.peak_finding.peak_finding import argrelmin, argrelmax, argrelextrema
 from cusignal._upfirdn import upfirdn
-from cusignal._arraytools import (
-    get_shared_array,
-    get_shared_mem,
-    axis_slice,
-    axis_reverse,
-    odd_ext,
-    even_ext,
-    const_ext,
-    zero_ext,
-    as_strided
-)
+from cusignal.utils.arraytools import get_shared_array, get_shared_mem
 from cusignal.cupy_helper import polyval, toeplitz, hankel
 
 # Versioneer

python/cusignal/peak_finding/__init__.py

@@ -0,0 +1,14 @@
+# Copyright (c) 2019-2020, NVIDIA CORPORATION.
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from cusignal.peak_finding.peak_finding import argrelmin, argrelmax, argrelextrema

python/cusignal/_peak_finding.py → python/cusignal/peak_finding/peak_finding.py

@@ -45,13 +45,6 @@ def _boolrelextrema(data, comparator, axis=0, order=1):
     See also
     --------
     argrelmax, argrelmin
-
-    Examples
-    --------
-    >>> testdata = np.array([1,2,3,2,1])
-    >>> _boolrelextrema(testdata, np.greater, axis=0)
-    array([False, False,  True, False, False], dtype=bool)
-
     """
     data = cp.asarray(data)
     if((int(order) != order) or (order < 1)):
@@ -106,15 +99,14 @@ def argrelmin(data, axis=0, order=1):
     detect all local minima, including flat ones, by calling it with negated
     `data`.
 
-    .. versionadded:: 0.11.0
-
     Examples
     --------
-    >>> from scipy.signal import argrelmin
-    >>> x = np.array([2, 1, 2, 3, 2, 0, 1, 0])
+    >>> from cusignal import argrelmin
+    >>> import cupy as cp
+    >>> x = cp.array([2, 1, 2, 3, 2, 0, 1, 0])
     >>> argrelmin(x)
     (array([1, 5]),)
-    >>> y = np.array([[1, 2, 1, 2],
+    >>> y = cp.array([[1, 2, 1, 2],
     ...               [2, 2, 0, 0],
     ...               [5, 3, 4, 4]])
     ...
@@ -159,15 +151,14 @@ def argrelmax(data, axis=0, order=1):
     detected. In case of one-dimensional `data` `find_peaks` can be used to
     detect all local maxima, including flat ones.
 
-    .. versionadded:: 0.11.0
-
     Examples
     --------
-    >>> from scipy.signal import argrelmax
-    >>> x = np.array([2, 1, 2, 3, 2, 0, 1, 0])
+    >>> from cusignal import argrelmax
+    >>> import cupy as cp
+    >>> x = cp.array([2, 1, 2, 3, 2, 0, 1, 0])
     >>> argrelmax(x)
     (array([3, 6]),)
-    >>> y = np.array([[1, 2, 1, 2],
+    >>> y = cp.array([[1, 2, 1, 2],
     ...               [2, 2, 0, 0],
     ...               [5, 3, 4, 4]])
     ...
@@ -206,22 +197,18 @@ def argrelextrema(data, comparator, axis=0, order=1):
     --------
     argrelmin, argrelmax
 
-    Notes
-    -----
-
-    .. versionadded:: 0.11.0
-
     Examples
     --------
-    >>> from scipy.signal import argrelextrema
-    >>> x = np.array([2, 1, 2, 3, 2, 0, 1, 0])
+    >>> from cusignal import argrelextrema
+    >>> import cupy as cp
+    >>> x = cp.array([2, 1, 2, 3, 2, 0, 1, 0])
     >>> argrelextrema(x, np.greater)
     (array([3, 6]),)
-    >>> y = np.array([[1, 2, 1, 2],
+    >>> y = cp.array([[1, 2, 1, 2],
     ...               [2, 2, 0, 0],
     ...               [5, 3, 4, 4]])
     ...
-    >>> argrelextrema(y, np.less, axis=1)
+    >>> argrelextrema(y, cp.less, axis=1)
     (array([0, 2]), array([2, 1]))
 
     """

python/cusignal/spectral.py

@@ -18,7 +18,8 @@
 import numpy as np
 
 from .window_functions.windows import get_window
-from ._arraytools import even_ext, odd_ext, const_ext, zero_ext, as_strided
+from .utils.arraytools import _even_ext, _odd_ext, _const_ext, \
+    _zero_ext, _as_strided
 from . import signaltools
 from ._spectral import _lombscargle
 
@@ -1306,10 +1307,10 @@ def _spectral_helper(
         )
 
     boundary_funcs = {
-        "even": even_ext,
-        "odd": odd_ext,
-        "constant": const_ext,
-        "zeros": zero_ext,
+        "even": _even_ext,
+        "odd": _odd_ext,
+        "constant": _const_ext,
+        "zeros": _zero_ext,
         None: None,
     }
 
@@ -1551,7 +1552,7 @@ def _fft_helper(x, win, detrend_func, nperseg, noverlap, nfft, sides):
         shape = x.shape[:-1] + ((x.shape[-1] - noverlap) // step, nperseg)
         strides = x.strides[:-1] + (step * x.strides[-1], x.strides[-1])
         # Need to optimize this in cuSignal
-        result = as_strided(x, shape=shape, strides=strides)
+        result = _as_strided(x, shape=shape, strides=strides)
 
     # Detrend each data segment individually
     result = detrend_func(result)

python/cusignal/test/test_signaltools.py

@@ -94,7 +94,7 @@ def test_convolve(num_samps, num_taps, mode, method):
     cpu_win = signal.windows.hann(num_taps)
 
     gpu_sig = cp.asarray(cpu_sig)
-    gpu_win = cusignal.windows.hann(num_taps)
+    gpu_win = cusignal.window_functions.windows.hann(num_taps)
 
     cpu_conv = signal.convolve(cpu_sig, cpu_win, mode=mode, method=method)
     gpu_conv = cp.asnumpy(

python/cusignal/test/test_windows.py

@@ -15,95 +15,95 @@
 import pytest
 from scipy import signal
 
-import cusignal
 from cusignal.test.utils import array_equal
+import cusignal.window_functions.windows as cuwindows
 
 
 @pytest.mark.parametrize("num_samps", [2 ** 15])
 def test_general_cosine(num_samps):
     HFT90D = [1, 1.942604, 1.340318, 0.440811, 0.043097]
     cpu_window = signal.windows.general_cosine(num_samps, HFT90D, sym=False)
     gpu_window = cp.asnumpy(
-        cusignal.windows.general_cosine(num_samps, HFT90D, sym=False)
+        cuwindows.general_cosine(num_samps, HFT90D, sym=False)
     )
     assert array_equal(cpu_window, gpu_window)
 
 
 @pytest.mark.parametrize("num_samps", [2 ** 15])
 def test_boxcar(num_samps):
     cpu_window = signal.windows.boxcar(num_samps)
-    gpu_window = cp.asnumpy(cusignal.windows.boxcar(num_samps))
+    gpu_window = cp.asnumpy(cuwindows.boxcar(num_samps))
     assert array_equal(cpu_window, gpu_window)
 
 
 @pytest.mark.parametrize("num_samps", [2 ** 15])
 def test_triang(num_samps):
     cpu_window = signal.windows.triang(num_samps)
-    gpu_window = cp.asnumpy(cusignal.windows.triang(num_samps))
+    gpu_window = cp.asnumpy(cuwindows.triang(num_samps))
     assert array_equal(cpu_window, gpu_window)
 
 
 @pytest.mark.parametrize("num_samps", [2 ** 15])
 def test_bohman(num_samps):
     cpu_window = signal.windows.bohman(num_samps)
-    gpu_window = cp.asnumpy(cusignal.windows.bohman(num_samps))
+    gpu_window = cp.asnumpy(cuwindows.bohman(num_samps))
     assert array_equal(cpu_window, gpu_window)
 
 
 @pytest.mark.parametrize("num_samps", [2 ** 15])
 def test_blackman(num_samps):
     cpu_window = signal.windows.blackman(num_samps)
-    gpu_window = cp.asnumpy(cusignal.windows.blackman(num_samps))
+    gpu_window = cp.asnumpy(cuwindows.blackman(num_samps))
     assert array_equal(cpu_window, gpu_window)
 
 
 @pytest.mark.parametrize("num_samps", [2 ** 15])
 def test_nuttall(num_samps):
     cpu_window = signal.windows.nuttall(num_samps)
-    gpu_window = cp.asnumpy(cusignal.windows.nuttall(num_samps))
+    gpu_window = cp.asnumpy(cuwindows.nuttall(num_samps))
     assert array_equal(cpu_window, gpu_window)
 
 
 @pytest.mark.parametrize("num_samps", [2 ** 15])
 def test_blackmanharris(num_samps):
     cpu_window = signal.windows.blackmanharris(num_samps)
-    gpu_window = cp.asnumpy(cusignal.windows.blackmanharris(num_samps))
+    gpu_window = cp.asnumpy(cuwindows.blackmanharris(num_samps))
     assert array_equal(cpu_window, gpu_window)
 
 
 @pytest.mark.parametrize("num_samps", [2 ** 15])
 def test_flattop(num_samps):
     cpu_window = signal.windows.flattop(num_samps)
-    gpu_window = cp.asnumpy(cusignal.windows.flattop(num_samps))
+    gpu_window = cp.asnumpy(cuwindows.flattop(num_samps))
     assert array_equal(cpu_window, gpu_window)
 
 
 @pytest.mark.parametrize("num_samps", [2 ** 15])
 def test_barlett(num_samps):
     cpu_window = signal.windows.bartlett(num_samps)
-    gpu_window = cp.asnumpy(cusignal.windows.bartlett(num_samps))
+    gpu_window = cp.asnumpy(cuwindows.bartlett(num_samps))
     assert array_equal(cpu_window, gpu_window)
 
 
 @pytest.mark.parametrize("num_samps", [2 ** 15])
 def test_hann(num_samps):
     cpu_window = signal.windows.hann(num_samps)
-    gpu_window = cp.asnumpy(cusignal.windows.hann(num_samps))
+    gpu_window = cp.asnumpy(cuwindows.hann(num_samps))
     assert array_equal(cpu_window, gpu_window)
 
 
 @pytest.mark.parametrize("num_samps", [2 ** 15])
 @pytest.mark.parametrize("alpha", [0.25, 0.5])
 def test_tukey(num_samps, alpha):
     cpu_window = signal.windows.tukey(num_samps, alpha, sym=True)
-    gpu_window = cp.asnumpy(cusignal.windows.tukey(num_samps, alpha, sym=True))
+    gpu_window = cp.asnumpy(cuwindows.tukey(num_samps, alpha, sym=True))
     assert array_equal(cpu_window, gpu_window)
 
 
 @pytest.mark.parametrize("num_samps", [2 ** 15])
 def test_barthann(num_samps):
     cpu_window = signal.windows.barthann(num_samps)
-    gpu_window = cp.asnumpy(cusignal.windows.barthann(num_samps))
+    gpu_window = cp.asnumpy(cuwindows.barthann(num_samps))
     assert array_equal(cpu_window, gpu_window)
 
 
@@ -112,31 +112,31 @@ def test_barthann(num_samps):
 def test_general_hamming(num_samps, alpha):
     cpu_window = signal.windows.general_hamming(num_samps, alpha, sym=True)
     gpu_window = cp.asnumpy(
-        cusignal.windows.general_hamming(num_samps, alpha, sym=True)
+        cuwindows.general_hamming(num_samps, alpha, sym=True)
     )
     assert array_equal(cpu_window, gpu_window)
 
 
 @pytest.mark.parametrize("num_samps", [2 ** 15])
 def test_hamming(num_samps):
     cpu_window = signal.windows.hamming(num_samps)
-    gpu_window = cp.asnumpy(cusignal.windows.hamming(num_samps))
+    gpu_window = cp.asnumpy(cuwindows.hamming(num_samps))
     assert array_equal(cpu_window, gpu_window)
 
 
 @pytest.mark.parametrize("num_samps", [2 ** 15])
 @pytest.mark.parametrize("beta", [0.25, 0.5])
 def test_kaiser(num_samps, beta):
     cpu_window = signal.windows.kaiser(num_samps, beta, sym=True)
-    gpu_window = cp.asnumpy(cusignal.windows.kaiser(num_samps, beta, sym=True))
+    gpu_window = cp.asnumpy(cuwindows.kaiser(num_samps, beta, sym=True))
     assert array_equal(cpu_window, gpu_window)
 
 
 @pytest.mark.parametrize("num_samps", [2 ** 15])
 @pytest.mark.parametrize("std", [3, 7])
 def test_gaussian(num_samps, std):
     cpu_window = signal.windows.gaussian(num_samps, std)
-    gpu_window = cp.asnumpy(cusignal.windows.gaussian(num_samps, std))
+    gpu_window = cp.asnumpy(cuwindows.gaussian(num_samps, std))
     assert array_equal(cpu_window, gpu_window)
 
 
@@ -146,21 +146,21 @@ def test_gaussian(num_samps, std):
 def test_general_gaussian(num_samps, p, std):
     cpu_window = signal.windows.general_gaussian(num_samps, p, std)
     gpu_window = cp.asnumpy(
-        cusignal.windows.general_gaussian(num_samps, p, std)
+        cuwindows.general_gaussian(num_samps, p, std)
     )
     assert array_equal(cpu_window, gpu_window)
 
 
 @pytest.mark.parametrize("num_samps", [2 ** 15])
 def test_cosine(num_samps):
     cpu_window = signal.windows.cosine(num_samps)
-    gpu_window = cp.asnumpy(cusignal.windows.cosine(num_samps))
+    gpu_window = cp.asnumpy(cuwindows.cosine(num_samps))
     assert array_equal(cpu_window, gpu_window)
 
 
 @pytest.mark.parametrize("num_samps", [2 ** 15])
 @pytest.mark.parametrize("tau", [1.5, 3.0])
 def test_exponential(num_samps, tau):
     cpu_window = signal.windows.exponential(num_samps, tau=tau)
-    gpu_window = cp.asnumpy(cusignal.windows.exponential(num_samps, tau=tau))
+    gpu_window = cp.asnumpy(cuwindows.exponential(num_samps, tau=tau))
     assert array_equal(cpu_window, gpu_window)

python/cusignal/utils/__init__.py

@@ -0,0 +1,14 @@
+# Copyright (c) 2019-2020, NVIDIA CORPORATION.
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from cusignal.utils.arraytools import get_shared_array, get_shared_mem