coodddaaaa 1.4.2__py3-none-any.whl

coodddaaaa/__init__.py

@@ -0,0 +1 @@
+from coodddaaaa.version import __version__

coodddaaaa/butter.py

@@ -0,0 +1,251 @@
+"""
+Modified after sigy 1.5.3, M.L. 21/04/2023
+
+Time / Fourier domain butterworth filter
+warning : the fourier domain filter has a slightly different response that the time domain one
+          comparing both reveals that the time domain filter may include a water-level that do not 
+          not exist with fourier domain, this results in slight differences near the signal edges
+          taper the waveform properly fixes the difference
+TODO : use ba_analog ?
+TODO : use scipy.fft => parallel
+"""
+
+from typing import Optional
+from scipy.signal import butter, sosfilt, sosfiltfilt, sosfreqz
+from scipy.fftpack import fftfreq, fft, ifft, fft2, ifft2
+import numpy as np
+
+
+class ButterworthFilter(object):
+    """
+
+    :param freqmin: lower frequency in Hz, or None for highpass filtering
+    :param freqmax: upper frequency in Hz, or None for lowpass filtering
+    :param sampling_rate: in Hz
+    :param order: of the filter
+    """
+
+    _sos = None
+    _sampling_rate = None
+
+    def __init__(self, 
+        freqmin: Optional[float], 
+        freqmax: Optional[float],
+        sampling_rate: Optional[float], 
+        order: float = 4.):
+
+        nyquist = 0.5 * sampling_rate
+        self._freqmin = freqmin
+        self._freqmax = freqmax
+        self._order = order
+        self._sampling_rate = sampling_rate
+
+        if freqmin is None and freqmax is None:
+            raise ValueError(freqmin, freqmax)
+
+        elif freqmin is not None and freqmax is not None:
+            self._sos = butter(order, [freqmin / nyquist, freqmax / nyquist],
+                               output="sos", btype="band")
+
+        elif freqmin is not None:
+            self._sos = butter(order, [freqmin / nyquist],
+                               output="sos", btype="high")
+
+        elif freqmax is not None:
+            self._sos = butter(order, [freqmax / nyquist],
+                               output="sos", btype="low")
+
+        else:
+            raise ValueError(freqmin, freqmax)
+
+    def timecall(self, data, zerophase=False, axis=-1):
+        if not zerophase:
+            filtered_data = sosfilt(sos=self._sos, x=data, axis=axis)
+            # filtered_data = lfilter(b=self.b, a=self.a, x=data, axis=axis)
+
+        else:
+            filtered_data = sosfiltfilt(sos=self._sos, x=data, axis=axis)
+    
+    
+        return filtered_data
+
+    def response(self, npts, zerophase=False, input_domain="fft", qc=False):
+        """
+        Almost equivalent to timecall
+        the response looks better than timecall, no water level applied
+        """
+
+        if input_domain == "fft":
+            freqs = fftfreq(npts, 1. / self._sampling_rate)
+            # equivalent to (except for freqs (0 to nyquist, no wrapping))
+            # freqs, response = sosfreqz(self._sos, worN=npts, whole=True, fs=self._sampling_rate)
+
+        elif input_domain == "rfft":
+            raise Exception(
+                'warning : the behavior of scipy.fftpack.rfft '
+                'differs from scipy.fft.rfft')
+            freqs = rfftfreq(npts, 1. / self._sampling_rate)
+
+        else:
+            raise NotImplementedError(input_domain)
+
+        _, response = sosfreqz(self._sos, worN=freqs, whole=True, fs=self._sampling_rate)
+
+        if zerophase:
+            response = np.abs(response) ** 2.
+
+        if qc:
+            import matplotlib.pyplot as plt
+            data = np.random.randn(npts)
+            filtered_data = self.timecall(data=data, zerophase=zerophase)
+
+            if input_domain == "fft":
+                # freqs = fftfreq(npts, 1./self._sampling_rate)
+                tfdata = fft(data)
+                filtered_tfdata = fft(filtered_data)
+
+            elif input_domain == "rfft":
+                raise Exception(
+                    'warning : the behavior of scipy.fftpack.rfft '
+                    'differs from scipy.fft.rfft')
+                # freqs = fftfreq(npts, 1. / self._sampling_rate)
+                tfdata = rfft(data)
+                filtered_tfdata = rfft(filtered_data)
+
+            else:
+                raise NotImplementedError(input_domain)
+
+            expected_response = filtered_tfdata / tfdata
+
+            plt.figure()
+            plt.subplot(311, title=f"{zerophase}")
+            plt.plot(freqs, expected_response.real, linewidth=3)
+            plt.plot(freqs, response.real, linewidth=1)
+
+            plt.subplot(312)
+            plt.plot(freqs, expected_response.imag, linewidth=3)
+            plt.plot(freqs, response.imag, linewidth=1)
+
+            plt.subplot(313)
+            plt.loglog(np.abs(freqs), np.abs(expected_response), linewidth=3)
+            plt.loglog(np.abs(freqs), np.abs(response), linewidth=1)
+            plt.show()
+
+        return freqs, response
+
+    def __call__(self, data, zerophase=False, axis=-1, input_domain="time"):
+        """
+        Returns the filtered data
+        can be called on time domain (real or complex) data
+        fft or rfft transformed data (use input_domain)
+
+        :param data:
+        :param zerophase:
+        :param axis:
+        :param input_domain:
+        """
+        if input_domain == "time":
+            return self.timecall(data=data, zerophase=zerophase, axis=axis)
+
+        elif input_domain in ["fft", "rfft"]:
+
+            if input_domain == "rfft" and zerophase is False:
+                raise Exception(
+                    'warning : the behavior of scipy.fftpack.rfft '
+                    'differs from scipy.fft.rfft')
+                raise ValueError(f"{input_domain=}, {zerophase=} => complex => irfft not applicable")
+
+            _, response = self.response(
+                npts=len(data), zerophase=zerophase,
+                input_domain=input_domain, qc=False)
+
+            return data * response
+
+        else:
+            raise ValueError(input_domain)
+
+    def show(self, fig, freqs=None, zerophase=False, **kwargs):
+        freqs, response = sosfreqz(self._sos, worN=freqs, whole=False, fs=self._sampling_rate)
+
+        ax = fig.add_subplot(121)
+        bx = fig.add_subplot(122, sharex=ax)
+
+        if zerophase:
+            response = np.abs(response) ** 2.0
+
+        ax.loglog(freqs, np.abs(response), **kwargs)
+        bx.semilogx(freqs, np.angle(response), **kwargs)
+
+        ax.set_ylabel('response modulus')
+        bx.set_ylabel('response phase')
+
+        for cx in [ax, bx]:
+            ylim = cx.get_ylim()
+            cx.plot(self._freqmin * np.ones(2), ylim, 'r--')
+            cx.plot(self._freqmax * np.ones(2), ylim, 'r--')
+            cx.grid(True, linestyle="--")
+            cx.set_xlabel('frequency (Hz)')
+        fig.suptitle(
+            f'{self._freqmin},{self._freqmax},{self._order},{zerophase}')
+        
+
+class BandpassFilter(ButterworthFilter):
+    """
+    Shortcut for ButterworthFilter for band-pass filtering
+    """
+    def __init__(self, freqmin, freqmax, sampling_rate, order=4):
+        ButterworthFilter.__init__(
+            self, freqmin=freqmin, freqmax=freqmax,
+            sampling_rate=sampling_rate, order=order)
+
+
+class LowpassFilter(ButterworthFilter):
+    """
+    Shortcut for ButterworthFilter for low-pass filtering
+    """
+
+    def __init__(self, freqmax, sampling_rate, order=4):
+        ButterworthFilter.__init__(
+            self, freqmin=None, freqmax=freqmax,
+            sampling_rate=sampling_rate, order=order)
+
+
+class HighpassFilter(ButterworthFilter):
+    """
+    Shortcut for ButterworthFilter for high-pass filtering
+    """
+    def __init__(self, freqmin, sampling_rate, order=4):
+        ButterworthFilter.__init__(
+            self, freqmin=freqmin, freqmax=None,
+            sampling_rate=sampling_rate, order=order)
+
+
+if __name__ == '__main__':
+    import matplotlib.pyplot as plt
+    from scipy.signal.windows import tukey
+
+    npts = 1200
+    sampling_rate = 1.0123456
+    data = 1.0 * np.random.randn(npts)
+    data *= tukey(len(data), 0.2)
+
+    freqmin = 0.03
+    freqmax = 0.08
+    fftfreqs = fftfreq(npts, 1. / sampling_rate)
+
+    bp = BandpassFilter(freqmin=freqmin, freqmax=freqmax, sampling_rate=sampling_rate, order=4)
+
+    bp.show(plt.figure(), zerophase=False)
+    bp.show(plt.figure(), zerophase=True)
+
+    ax = plt.gcf().axes[0]
+    ax.plot([freqmin, freqmin], ax.get_ylim(), 'r--')
+    ax.plot([freqmax, freqmax], ax.get_ylim(), 'r--')
+
+    plt.figure()
+    plt.plot(data, 'k')
+    plt.plot(bp(data, zerophase=True), "b", linewidth=3)
+    plt.plot(ifft(bp(fft(data), zerophase=True, input_domain="fft")).real, "g-")
+    # plt.plot(irfft(bp(rfft(data), zerophase=True, input_domain="rfft")).real, "m--")
+
+    plt.show()

coodddaaaa/fftoversamp.py

@@ -0,0 +1,117 @@
+"""
+Modified after sigy 1.5.3, M.L. 20/08/2023
+
+Fourier domain oversampling, for the sake of simplicity, 
+this program can increase the number of samples only by 2**n, where n is an integer.
+
+The oversampling is performed in the Fourier domain, 
+- for optimal use, it is preferred to use the fft_oversamp
+  if the signal is already in Fourier domain
+- make sure the signal is properly detrended and tapered at its edges prior to FFT
+  otherwise, you might observe wiggles at the edges of the signal after oversampling.
+  (remember that fft assume a periodization of the signal in time)
+
+"""
+
+import numpy as np
+from scipy.fftpack import fft, ifft
+
+
+def oversamp(t0: float, dt: float, data: np.ndarray,
+             npow2: int, axis: int = -1, demean: bool = False) \
+        -> (np.ndarray, np.ndarray):
+    """
+    Time domain version of fft_oversamp
+
+    :param t0: start time, sec
+    :param dt: sampling interval, sec
+    :param data: time domain data array (1d or more)
+    :param npow2: oversamp by 2 ** npow2
+    :param axis: axis along which to oversample the signal
+    :return to: the new time vector
+    :return datao: the oversample data
+
+    """
+    nt = data.shape[axis]
+    t_over = t0 + np.arange(nt * 2 ** npow2) * (dt / (2 ** npow2))
+    if demean:
+        m = data.mean(axis=axis)
+    else:
+        m = 0.
+
+    # factor = exp(npow2 * log(2))
+    # npow2 = log(factor) / log(2)
+    data_over = ifft(
+        fft_oversamp(
+            fft(data - m, axis=axis),
+            npow2=npow2,
+            axis=axis),
+        axis=axis).real + m
+    return t_over, data_over
+
+
+def fft_oversamp(fft_data: np.ndarray, npow2: int = 1, axis: int = -1) -> np.ndarray:
+    """
+    Oversamp a signal by padding it with zeros in the FFT domain
+    the number of sample is multiplied by 2 ** npow2 (default 2**1)
+
+    :param fft_data: output of fft
+    :param npow2: oversampling rate expressed as a power of 2
+    :param axis: the axis along which to perform oversampling
+    :return: oversample data in fft domain
+    """
+
+    n = 2 ** npow2
+
+    npts = fft_data.shape[axis]
+
+    i_first_negative_freq = npts // 2 + npts % 2
+    n_positive_freqs = i_first_negative_freq
+    n_negative_freqs = npts - n_positive_freqs
+
+    new_shape = list(fft_data.shape)
+    new_shape[axis] = n * npts
+    new_fft_data = np.zeros(new_shape, complex)
+
+    view = fft_data.swapaxes(0, axis)
+    new_view = new_fft_data.swapaxes(0, axis)
+
+    new_view[:n_positive_freqs, ...] = n * view[:i_first_negative_freq, ...]
+    new_view[-n_negative_freqs:, ...] = n * view[i_first_negative_freq:, ...]
+
+    return new_fft_data
+
+
+if __name__ == '__main__':
+
+    from scipy.signal import butter, sosfiltfilt
+    from scipy.signal.windows import tukey
+    import matplotlib.pyplot as plt
+
+    nt = 127  # number of samples
+    dt = 0.1  # sampling interval in sec
+    t0 = -10.012351503  # starttime in sec
+
+    t = t0 + np.arange(nt) * dt
+    # ny = 0.5 / dt  # nyquist, Hz
+
+    # prepare bandpass filter and time taper
+    sos = butter(4.0,  # order
+            [0.1, 0.5],  # fmin, fmax relative to nyquist
+            output="sos", btype="band")
+    taper = tukey(nt, 0.1)
+
+    # generate random signal
+    y = np.random.randn(nt)
+
+    # bandpass / taper
+    y = sosfiltfilt(sos=sos, x=y)
+    y *= taper  
+
+    # oversamp
+    t1, y1 = oversamp(t0=t0, dt=dt, data=y, npow2=4, axis=-1, demean=True)
+
+    plt.figure()
+    plt.plot(t, y, 'ko-')
+    plt.plot(t1, y1, 'r')
+    plt.show()

coodddaaaa/hypermax.py

@@ -0,0 +1,60 @@
+"""
+Copyright (c) 2023 maximilien.lehujeur
+
+Finds the maximum of a random array with subsample precision
+by looking for the zero crossing of the
+first order finite difference derivative
+"""
+from typing import Optional
+import numpy as np
+from matplotlib.axes import Axes
+
+
+def hypermax(time_array: np.ndarray, function_array: np.ndarray, axqc: Optional[Axes] = None, assume_t_growing: bool = False):
+    """
+    :param time_array: time array
+    :param function_array: function array
+    :param axqc: matplotlib ax or None for visual qc
+    :param assume_t_growing:
+    """
+    if not assume_t_growing:
+        assert (time_array[1:] > time_array[:-1]).all(), "t must be strictly growing"
+
+    imax = np.argmax(function_array)
+    tmax, fmax = time_array[imax], function_array[imax]
+    
+    if imax == 0:
+        return time_array[0]
+
+    elif imax == len(time_array) - 1:
+        return time_array[-1]
+
+    tt = (0.5 * (time_array[imax: imax + 2] + time_array[imax - 1: imax + 1]))
+    ff = (function_array[imax: imax + 2] - function_array[imax - 1: imax + 1]) / (time_array[imax: imax + 2] - time_array[imax - 1: imax + 1])
+
+    ip = np.argsort(ff)
+    thypermax = np.interp(0., xp=ff[ip], fp=tt[ip])
+
+    if axqc is not None:
+        axqc.plot(time_array, function_array, "k+-", alpha = 0.4)
+        axqc.plot(tmax, fmax, 'ko')
+        # axqc.plot(dt, df, "r+-", alpha = 0.4)
+        axqc.plot(tt, ff, "r", alpha = 1.0)
+        axqc.plot(thypermax, 0, "r*", alpha = 1.0)
+        axqc.plot(thypermax * np.ones(2), axqc.get_ylim(), 'r')
+        axqc.grid(True)
+
+    return thypermax
+
+
+if __name__ == "__main__":
+    import matplotlib.pyplot as plt
+    t = np.unique(np.random.randn(50))
+    f = np.sinc(t)
+
+    tmax = hypermax(t, f, axqc=plt.gca())
+
+    print('true max : ', 0.)
+    print('max : ', t[np.argmax(f)])
+    print('hypermax : ',  tmax)
+    plt.show()

coodddaaaa/interp1d.py

@@ -0,0 +1,346 @@
+"""
+Copyright (c) 2023 maximilien.lehujeur
+
+Linear and cubic interpolation in 1d using fixed grids
+and sparse operators for cases where one need 
+to interpolate functions on the same grids many times
+
+note I do not use the scipy interpolator
+because I need an interpolator that can be created from the grids only
+and called later on with the function to interpolate
+
+2023.04.07 : P. Mora : Speed up the construction of the sparse matrixes => x20 to x50
+"""
+
+import numpy as np
+import matplotlib.pyplot as plt
+from scipy import sparse as sp
+from scipy.sparse import linalg as splinalg
+from scipy.fftpack import rfft  # NOT scipy.fft.rfft !!!
+
+SPMATRIXFORMAT = {"csc": sp.csc_matrix, "csr": sp.csr_matrix}
+
+
+class LinearInterpolator1d:
+    """
+    Linear interpolation operator
+
+    :param x0: x coordinate of the first sample
+    :param nx: number of samples
+    :param dx: sampling interval
+    :param xi: the points where we need the interpolated values
+        => f(xi) is computed by self.__call__
+    :param format: format to use for the linear operator
+    """
+
+    def __init__(
+            self,
+            x0: float, nx: int, dx: float,
+            xi: np.ndarray,
+            format: str ="csc"):
+        """
+        x is the grid at which the function will be defined (nodes)
+        xi are the points where the function will be interpolated
+        """
+
+        self.x0 = x0
+        self.nx = nx
+        self.dx = dx
+        self.xi = xi
+
+        # nodes
+        x = np.arange(nx) * dx + x0
+
+        self._idx_xi_to_interp, self._idx_x_after_interp_points = \
+            self.find_interp_points_in_grid(x0, nx, dx, xi)
+
+        # nodes before the interpolation points
+        rows1 = self._idx_xi_to_interp
+        cols1 = self._idx_x_after_interp_points - 1
+        dxafter = (x[self._idx_x_after_interp_points] - xi[self._idx_xi_to_interp])
+        vals1 = dxafter / self.dx
+
+        # nodes after the interpolation points
+        rows2 = rows1  # self._idx_xi_to_interp
+        cols2 = self._idx_x_after_interp_points
+        vals2 = 1. - vals1  # dxbefore / self.dx
+
+        rows = np.concatenate((rows1, rows2))
+        cols = np.concatenate((cols1, cols2))
+        vals = np.concatenate((vals1, vals2))
+
+        # assemble
+        self.lininterp_operator = \
+            SPMATRIXFORMAT[format](
+                (vals, (rows, cols)),
+                shape=(len(self.xi), self.nx))
+   
+    def find_interp_points_in_grid(self, x0: float, nx: int, dx: float, xi: np.ndarray):
+
+        # find indexs of x of nodes located after the interp points xi
+        k = np.ceil((xi - x0) / dx).astype(int)
+
+        # find the interp points that occur within the interp bounds
+        m = (k > 0) & (k < nx)  # mask
+        idx_xi_to_interp = np.arange(len(xi))[m]  # to indexs
+
+        # eliminate the interp points out of bounds
+        # => interp will return 0 for these points
+        idx_x_after_interp_points = k[idx_xi_to_interp]
+
+        return idx_xi_to_interp, idx_x_after_interp_points
+
+    def __call__(self, f: np.ndarray):
+        """
+        affect function values at x and return the interpolated values at xi
+        """
+        # assert isinstance(f, np.ndarray)
+        # assert f.ndim == 1
+        # assert len(f) == len(self.x)
+
+        return self.lininterp_operator * f
+
+
+class SecondDerivativeOperatorTypeII:
+    """
+    Second derivative operator order 3 in the internal domain,
+    Implement type II boundary condition after https://en.wikiversity.org/wiki/Cubic_Spline_Interpolation
+    For a regular grid only
+    x is the grid at which the function will be defined (nodes)
+    xi are the points where the function will be interpolated
+
+    :param nx: number of nodes
+    :param dx: sampling interval between nodes
+    :param format: format of the sparse operator
+    """
+
+    def __init__(self, nx: int, dx: float, format: str ="csc"):
+
+        idx2 = dx ** -2.
+        self.operator = sp.diags([1, -2, 1], [-1, 0, 1], shape=(nx, nx), format=format) * idx2
+        # for type II boundary condition => d[0] = 2 * f''0 = 0
+        self.operator[0, 0] = 0
+        self.operator[0, 1] = 0
+        # for type II boundary condition => d[-1] = 2 * f''[-1] = 0
+        self.operator[-1, -1] = 0
+        self.operator[-1, -2] = 0
+
+    def __call__(self, f: np.ndarray):
+        """
+        compute the derivative of f on x
+        """
+        # assert isinstance(f, np.ndarray)
+        # assert f.ndim == 1
+        # assert len(f) == len(self.x)
+
+        return self.operator * f
+
+
+class CubicInterpolator1d(LinearInterpolator1d):
+    """
+    Lagrange Cubic interpolation with boundary type II from https://en.wikiversity.org/wiki/Cubic_Spline_Interpolation
+    Works only on a regular grid for now
+    x is the grid at which the function will be defined (nodes)
+    xi are the points where the function will be interpolated
+    :param x0: x of first sample
+    :param nx: number of samples
+    :param dx: sampling interval
+    :param xi: array of points where to interpolate the function
+    :param format: format of the sparse operator
+    """
+
+    def __init__(
+            self,
+            x0: float, nx: int, dx: float,
+            xi: np.ndarray,
+            format: str ="csc"):
+
+        LinearInterpolator1d.__init__(self, x0=x0, nx=nx, dx=dx, xi=xi, format=format)
+        _sp_matrix = SPMATRIXFORMAT[format]
+
+        # ==== add more internal operators to move to cubic interpolation
+        # multiply by 3 because 6*f[xi-1,xi,xi+1] means 3 * [f(xi+1) - 2 * f(xi) + f(xi-1)] / (hi**2)
+        self.derivator = 3. * SecondDerivativeOperatorTypeII(nx=nx, dx=dx, format=format).operator
+
+        # left term in eq (6) from https://en.wikiversity.org/wiki/Cubic_Spline_Interpolation
+        upper_diag = .5 * np.ones(nx-1, float)  # lambda terms
+        diag = 2 * np.ones(nx, float)   # diagonal terms
+        lower_diag = 0.5 * np.ones(nx-1, float)  # mu terms
+        lower_diag[-1] = upper_diag[0] = 0.  # type II boundary condition
+        a = sp.diags((lower_diag, diag, upper_diag), offsets=(-1, 0, 1), format=format)
+        # inverse_of_a = splinalg.inv(a)  #=> dense
+        self.solver = splinalg.splu(a)  # => time cost is negligible (0.4%)
+
+        # ==== Implement the operator for equation (1), with respect to Mis coefficients
+        #      the missing terms for yi and yi+1 are included in the self.lininterp_operator term
+        x = np.arange(nx) * dx + x0
+
+        # nodes before the interpolation points
+        rows1 = self._idx_xi_to_interp
+        cols1 = self._idx_x_after_interp_points - 1
+        dxafter = (x[self._idx_x_after_interp_points] - xi[self._idx_xi_to_interp])
+        vals1 = dxafter ** 3. / (6. * self.dx) - self.dx * dxafter / 6.
+
+        # nodes after the interpolation points
+        rows2 = self._idx_xi_to_interp
+        cols2 = self._idx_x_after_interp_points
+        dxbefore = (xi[self._idx_xi_to_interp] - x[self._idx_x_after_interp_points-1])
+        vals2 = dxbefore ** 3. / (6. * self.dx) - self.dx * dxbefore / 6.
+
+        rows = np.concatenate((rows1, rows2))  # np.repeat(r_, 2)
+        cols = np.concatenate((cols1, cols2))  # np.array([k_-1, k_]).T.flatten()
+        vals = np.concatenate((vals1, vals2))  # np.array([v1, 1-v1]).T.flatten()
+
+        # assemble
+        self.cubinterp_operator = \
+            SPMATRIXFORMAT[format](
+                (vals, (rows, cols)),
+                shape=(len(self.xi), self.nx))
+
+    def __call__(self, f):
+
+        # assert isinstance(f, np.ndarray)
+        # assert f.ndim == 1
+        # assert len(f) == self.nx
+
+        # 3 * f[xi-1, xi, xi+1], d0=d-1=0 for type II boundary condition
+        d = self.derivator * f
+
+        # solve equation (6) for M
+        m = self.solver.solve(d)
+
+        return self.cubinterp_operator * m + self.lininterp_operator * f
+
+    # TODO : add method to export/reload from npz file
+
+
+class RFFTInterpolator1d:
+    """
+    Fourier Interpolator based on rfft
+
+    :param x0: x of first sample
+    :param nx: number of samples
+    :param dx: sampling interval
+    :param xi: array of points where to interpolate the function
+    :param format: format of the sparse operator
+
+    """
+    def __init__(
+            self, 
+            x0: float, nx: int, dx: float,
+            xi: np.ndarray):
+
+        self.x0 = x0
+        self.nx = nx
+        self.dx = dx
+        self.xi = xi
+
+        npts = nx
+        fnfft = npts
+        two_pi = 2.0 * np.pi
+
+        n = (xi - x0) / ((nx - 1) * dx) * (npts - 1)
+
+        k = np.arange(npts)[:, np.newaxis]
+        b = np.zeros((npts, len(xi)))
+        b[0, :] = 1.0
+
+        if npts % 2:
+            b[1:npts:2] = +2.0 * np.cos(two_pi * n * k[1:(npts - 1) // 2 + 1, :] / fnfft)
+            b[2:npts:2] = -2.0 * np.sin(two_pi * n * k[1:(npts - 1) // 2 + 1, :] / fnfft)
+
+        else:
+            b[1:npts - 1:2] = +2.0 * np.cos(two_pi * n * k[1:npts // 2, :] / fnfft)
+            b[2:npts - 1:2] = -2.0 * np.sin(two_pi * n * k[1:npts // 2, :] / fnfft)
+            b[-1, :] = +1.0 * np.cos(two_pi * n * npts / fnfft / 2.)
+
+        b *= 1.0 / fnfft
+        self._irfft_basis = b
+
+    def __call__(self, f: np.ndarray):
+        """
+        affect function values at x and return the interpolated values at xi
+        """
+        # assert isinstance(f, np.ndarray)
+        # assert f.ndim == 1
+        # assert len(f) == len(self.x)
+
+        return rfft(f, axis=-1).dot(self._irfft_basis)
+
+
+if __name__ == "__main__":
+
+    # ========================= simple interpolation test
+    # build the grids
+    x = np.linspace(0.1, 0.9, 10)  # the nodes
+    xi = np.linspace(-0.1, 1.1, 1000)  # the interpolation points
+
+    # build the linear operators
+    P = LinearInterpolator1d(x0=x[0], nx=len(x), dx=x[1] - x[0], xi=xi)
+    C = CubicInterpolator1d(x0=x[0], nx=len(x), dx=x[1] - x[0], xi=xi)
+    F = RFFTInterpolator1d(x0=x[0], nx=len(x), dx=x[1] - x[0], xi=xi)
+    # pick some random values to attach to the nodes
+    f = np.random.randn(len(x))
+
+    # call the operators for these values
+    pi = P(f)
+    ci = C(f)
+    fi = F(f)
+
+    # compare the output
+    if True:
+        plt.figure()
+        plt.plot(x, f, "ko")
+        plt.plot(xi, pi, 'r-', label='linear')
+        plt.plot(xi, ci, 'g-', label='cubic')
+        plt.plot(xi, fi, 'm-', label='Fourier')
+        plt.gca().legend()
+        plt.show()
+
+    # ========================= interpolation for stretching
+    x = np.linspace(0.1, 0.9, 100)
+    xi = x * (1. + 0.01)
+
+    P = LinearInterpolator1d(x0=x[0], nx=len(x), dx=x[1] - x[0], xi=xi)
+    C = CubicInterpolator1d(x0=x[0], nx=len(x), dx=x[1] - x[0], xi=xi)
+    F = RFFTInterpolator1d(x0=x[0], nx=len(x), dx=x[1] - x[0], xi=xi)
+
+    f = np.sin(2. * np.pi * x / 0.1)
+
+    pi = P(f)
+    ci = C(f)
+    fi = F(f)
+
+    if True:
+        plt.figure()
+        plt.plot(x, f, "k")
+        plt.plot(x, pi, 'r-', label='linear')
+        plt.plot(x, ci, 'g-', label='cubic')
+        plt.plot(x, fi, 'm-', label='Fourier')
+        plt.gca().legend()
+        plt.show()
+
+    # ========================= interpolation of many signals at ones
+    x = np.linspace(0.1, 0.9, 10)  # the nodes
+    xi = np.linspace(-0.1, 1.1, 1000)  # the interpolation points
+
+    P = LinearInterpolator1d(x0=x[0], nx=len(x), dx=x[1] - x[0], xi=xi)
+    C = CubicInterpolator1d(x0=x[0], nx=len(x), dx=x[1] - x[0], xi=xi)
+    F = RFFTInterpolator1d(x0=x[0], nx=len(x), dx=x[1] - x[0], xi=xi)
+
+    f = 0.2 * np.random.randn(10, len(x))
+    pi = P(f.T).T
+    ci = C(f.T).T
+    fi = F(f)   # WARNING : Fourier interp is not built the same way as the two other interpolators
+    print(ci.shape)
+    print(fi.shape)
+
+    if True:
+        plt.figure()
+        for n in range(f.shape[0]):
+            plt.plot(x, f[n, :] + n, "ko")
+            plt.plot(xi, pi[n, :] + n, 'r-', label='linear' if not n else None)
+            plt.plot(xi, ci[n, :] + n, 'g-', label='cubic' if not n else None)
+            plt.plot(xi, fi[n, :] + n, 'm-', label='Fourier' if not n else None)
+        plt.gca().legend()
+        plt.show()

coodddaaaa/stretching.py

@@ -0,0 +1,376 @@
+"""
+Copyright (c) 2023 maximilien.lehujeur
+"""
+
+from typing import Union, Optional, Literal
+import numpy as np
+from coodddaaaa.interp1d import LinearInterpolator1d, CubicInterpolator1d, RFFTInterpolator1d
+from coodddaaaa.hypermax import hypermax
+from scipy.sparse import block_diag
+
+
+class Stretcher:
+    r"""
+    An object to compute stretched signals and to perform stretching correlation as defined in Weaver et al., 2011.
+
+    .. math:: X(\varepsilon) =
+        \frac
+            {\int{y^{ref}(t \times (1 + \varepsilon)) \cdot y(t) dt}}
+            {\sqrt{
+                \int{y^{ref}(t \times (1 + \varepsilon))^2 dt}
+                \int{y(t)^2 dt}
+                }}
+
+
+    The object pre-computes the interpolation operator.
+    The user can pre-compute and store the stretched basis of the reference signal.
+    This basis can then be provided for stretching correlation with a new signal.
+    This object can also compute the stretching between all pairs of signals in a b-scan.
+
+    :param t0: time of first sample
+    :param dt: sampling interval
+    :param nt: number of samples
+    :param eps: epsilon array
+    :param norm: use it to compute normalized correlation.
+                 warning : for stretching only, use norm = False
+    :param interp_kind: which interpolator to use for stretching, among 'linear', "cubic", 'fourier'
+    """
+    def __init__(self,
+                 t0: float, dt: float, nt: int,
+                 eps: np.ndarray,
+                 norm: bool = False,
+                 interp_kind: Literal['linear', "cubic", 'fourier'] = "cubic"):
+        """
+        Initiate the stretcher and the interpolator on a fixed interpolation grid.
+
+        """
+        assert interp_kind in ['linear', 'cubic', 'fourier']
+
+        self.t0, self.nt, self.dt = t0, nt, dt
+        self.eps = eps   # 1d, shape (len(eps), )
+        self.norm = norm
+        self.interp_kind = interp_kind
+
+        # Time array = nodes at which the function to stretch is defined
+        self.t = t0 + np.arange(nt) * dt   # 1d, shape (nt, )
+
+        # Compute the stretching time grid for all values in eps
+        # = points at which to evaluate the function for stretching
+        self.stretch_time = self.t * (1. + self.eps[:, np.newaxis])  # 2d array, shape (len(eps), nt)
+
+        # compute the interpolation operator once for all (based on scipy.sparse matrices)
+        if interp_kind == "linear":
+            self.interpolator = LinearInterpolator1d(
+                x0=t0, nx=nt, dx=dt,  # nodes
+                xi=self.stretch_time.flat[:],  # interpolation points
+                )
+
+        elif interp_kind == "cubic":
+            t0 = self.t[0]
+            nt = len(self.t)
+            dt = self.t[1] - self.t[0]
+            assert ((self.t - (np.arange(nt) * dt + t0)) / dt <= 1e-6) .all()
+
+            self.interpolator = CubicInterpolator1d(
+                x0=t0, nx=nt, dx=dt,  # nodes
+                xi=self.stretch_time.flat[:],  # interpolation points
+                )
+
+        elif interp_kind == "fourier":
+            t0 = self.t[0]
+            nt = len(self.t)
+            dt = self.t[1] - self.t[0]
+            assert ((self.t - (np.arange(nt) * dt + t0)) / dt <= 1e-6) .all()
+
+            self.interpolator = RFFTInterpolator1d(
+                x0=t0, nx=nt, dx=dt,  # nodes
+                xi=self.stretch_time.flat[:],  # interpolation points
+                )
+
+        else:
+            raise ValueError(interp_kind)
+
+    def stretch(self, x: np.ndarray) -> np.ndarray:
+        """
+        Compute the stretched basis functions from a signal x
+
+        :param x: the input signal (reference), np.ndarray, 1d, shape (nt, )
+        :return x_stretched: the stretched version of x for all values in self.eps, np.ndarray 2d, shape (neps, nt)
+        """
+
+        x_stretched = np.zeros_like(self.stretch_time)
+        x_stretched.flat[:] = self.interpolator(x)
+
+        if self.norm:
+            # normalize the stretched function now for efficiency
+            # instead of doing it in the correlation
+            # => WARNING : this will affect the amplitudes of the stretched data
+            #              for stretching only, user must use norm=False
+
+            # norm = np.linalg.norm(x_stretched, axis=1)
+            norm = (x_stretched ** 2).sum(axis=1) ** -0.5
+
+            # NB : I've tried Numba (this ref) => no gain at all
+            # https://stackoverflow.com/questions/30437947/
+            # most-memory-efficient-way-to-compute-abs2-of-complex-numpy-ndarray
+
+            x_stretched *= norm[:, np.newaxis]
+
+        return x_stretched
+
+    def corr(self, x: np.ndarray, x_stretched: np.ndarray) -> np.ndarray:
+        """
+        Stretching correlation of x with a basis of stretched versions of the reference signal
+
+        :param x: signal(s) to be correlated to the reference, np.ndarray,
+            either one single signal, 1d, shape (nt, )
+            or a bscan, 2d, shape (ntraces, nt)
+        :param x_stretched: stretched reference from self.stretch, np.ndarray, 2d, shape (neps, nt, )
+        :return c: correlation function np.ndarray,
+            either 1d, shape (neps, ) if x is 1d
+            or 2d, shape (neps, ntraces) if x is 2d
+        """
+        if x.ndim == 1:
+            assert x.shape == (self.nt, ), \
+                f'Shape Error : x must be 1 trace of shape (nt={self.nt}, )'
+
+        elif x.ndim == 2:
+            assert x.shape[1] == self.nt, \
+                f'Shape Error : x must be a bscan of shape (ntraces, nt={self.nt})'
+
+        else:
+            raise ValueError('Shape Error, x must be 1d (for single signal) or 2d (for a bscan)')
+
+        c = x_stretched.dot(x.T) * self.dt  # np.ndarray, shape (neps, ntraces)
+
+        if self.norm:
+            # the normalization relative to x_stretched
+            # is already done
+            if x.ndim == 1:
+                # faster?
+                c /= x.dot(x) ** 0.5 * self.dt
+            elif x.ndim == 2:
+                c /= (x * x).sum(axis=-1) ** 0.5 * self.dt  # shape (ntraces, )
+            else:
+                raise Exception('programming error')
+        return c
+
+    def corrmax(self, c: np.ndarray) -> (Union[float, np.ndarray], Union[float, np.ndarray]):
+        """
+        Find the maximum of the correlation function with subsample precision
+
+        :param c: correlation function(s) from self.corr
+            1d for a single signal, shape (neps, )
+            2d for a bscan, shape (neps, ntraces)
+        :return emax: best epsilon value, dimensionless, it corresponds to dt/t
+            float if c is 1d
+            1d array, shape (ntraces, ) if c is 2d
+        :return cmax: max correlation, dimensionless, normalized if norm was True in __init__
+            float if c is 1d
+            1d array, shape (ntraces, ) if c is 2d
+        """
+        if c.ndim == 1:
+            epsmax = hypermax(
+                time_array=self.eps,
+                function_array=c,
+                assume_t_growing=True)
+            cmax = c.max()
+
+        elif c.ndim == 2:
+            neps, ntraces = c.shape
+            assert neps == len(self.eps), f"Shape Error, c must be of shape (neps={len(self.eps)}, ntraces)"
+
+            epsmax = np.zeros(ntraces, float)
+            for i in range(ntraces):
+                # TODO : implement 2d version of hypermax to avoid the loop ?
+                epsmax[i] = hypermax(
+                    time_array=self.eps,
+                    function_array=c[:, i],
+                    assume_t_growing=True)
+            cmax = c.max(axis=0)  # one max per trace
+
+        else:
+            raise ValueError(
+                f'Shape Error, c must be 1d (single trace) or 2d (bscan)')
+
+        return epsmax, cmax
+
+    def corr_all_with_all(self, data: np.ndarray) -> (np.ndarray, np.ndarray):
+        """
+        Correlate all possible pairs of signals in a bscan
+
+        :param data: the bscan, one trace per row, same sampling (=self.t), 2d, shape (ntraces, nt)
+        :return c_triu: the max correlation coefficients for all pairs (upper triangle only)
+        :return e_triu: the best stretching coefficients for all pairs (upper triangle only)
+        use self.triu2dence to get the full matrices
+
+        c = Stretcher.triu2dense(c_triu, symetric=True, diag=1.0)
+        e = Stretcher.triu2dense(e_triu, symetric=False, diag=0.0)
+        """
+
+        ntraces, nsamps = data.shape
+
+        c_triu = np.zeros(ntraces * (ntraces - 1) // 2)
+        e_triu = np.zeros(ntraces * (ntraces - 1) // 2)
+        # itriu, jtriu = np.triu_indices(ntraces, 1)
+
+        n = 0
+        for i in range(ntraces - 1):
+            # print(f'{i+1}/{ntraces - 1}')
+            # stretch new reference
+            y = data[i, :]
+            y_stretched = self.stretch(y)
+
+            # correlate all remaining traces to this new reference
+            m = ntraces - i - 1
+            cijs = self.corr(x=data[i + 1:, :], x_stretched=y_stretched)
+            e_triu[n: n+m], c_triu[n: n+m] = self.corrmax(cijs)
+            n += m
+
+        return c_triu, e_triu
+
+    @staticmethod
+    def triu2dense(x_triu: np.ndarray, symetric: bool, diag: float) -> np.ndarray:
+        """
+        Convert upper triangle matrix to square matrix
+
+        :param x_triu: a flat upper triangle without diagonal, 1d, np.ndarray, shape (ntraces * (ntraces - 1) / 2, )
+        :param symetric: to impose symetry (True) or anti-symetry (False)
+        :param diag: the value to put on the diagonal
+        :return x:
+            a square matrix with x_triu on its upper triangle, shape (ntraces, ntraces)
+            diag on its diagonal
+            +-x_triu on its lower triangle
+        """
+        # 2n = (x * (x -1))
+        # 2n = x ** 2 - x
+        # x ** 2 - x - 2n = 0
+        # d = 2 + 8 * n
+        #
+        n = int((1 + np.sqrt(8 * len(x_triu) + 2)) / 2)
+        x = np.eye(n, dtype=float) * diag
+
+        ij = np.triu_indices(n, 1)
+        x[ij] = x_triu
+        if symetric:
+            x.T[ij] = x[ij]
+        else:
+            x.T[ij] = -x[ij]
+        return x
+
+    @staticmethod
+    def stretching_uncertainty(
+            cmax: Union[float, np.ndarray], fmin: float, fmax: float, tmin: float, tmax: float) \
+            -> Union[float, np.ndarray]:
+        """
+        Stretching uncertainty after Weaver et al 2011.
+
+        :param cmax: max correlation coefficient from self.corrmax, either a float or a np.ndarray
+        :param fmin: lower freq Hz, float
+        :param fmax: upper freq Hz, float
+        :param tmin: start coda time in s, float
+        :param tmax: end coda time in s, float
+        :return rmse: uncertainty on epsilon, same type as cmax
+        """
+
+        wc = 2. * np.pi * np.sqrt(fmin * fmax)
+        T = 1. / (fmax - fmin) / (np.pi * np.sqrt(2.))
+        X = cmax
+        rmse = np.sqrt(1 - X ** 2.) / (2 * X)
+        rmse *= np.sqrt((6 * T * np.sqrt(np.pi / 2.)) / (wc ** 2. * (tmax ** 3 - tmin ** 3)))
+
+        return rmse
+
+
+class InverseStretcher:
+    """
+    An object to cancel the effect of the stretching on each trace of a bscan
+    This can be used to align the traces with the reference, and then to refine the reference.
+
+    For example:
+        you have a bscan of 256 traces with n samples each, bscan is a 2d array shapped (256, n)
+        you have an estimate of the stretching history, i.e. 256 epsilon values in an 1D array
+        this object returns the bscan corrected from the estimated stretching values
+            positive epsilon values (i.e. positive dv/v) mean that the trace was compressed relative to its ref, so this operator stretch it
+            negative epsilon values will tend to compress the waveform
+
+    :param t0: time of first sample
+    :param nt: number of samples
+    :param dt: sampling interval
+
+    :param eps_history: epsilon array, one item per trace in the bscan
+    :param interp_kind: which interpolator to use for inverse stretching, among 'linear',
+
+    """
+    def __init__(self, t0: float, nt: int, dt: float, eps_history: np.ndarray, interp_kind: Literal['linear'] = "linear"):
+
+        self.t0 = t0
+        self.nt = nt
+        self.dt = dt
+        self.eps_history = eps_history
+
+        self.time_array = self.t0 + np.arange(self.nt) * self.dt
+        if interp_kind == "linear":
+            block_diagonals = []
+            for eps in eps_history:
+
+                op = LinearInterpolator1d(
+                    x0=self.t0, nx=self.nt, dx=self.dt, xi=self.time_array * (1. + eps))
+
+                op = op.lininterp_operator.T  # transpose to get the inverser interpolator
+
+                block_diagonals.append(op)
+        else:
+            raise NotImplementedError(interp_kind)
+
+        self.interpolator = block_diag(block_diagonals, format="csr")
+
+    def __call__(self, bscan: np.ndarray) -> np.ndarray:
+        if not bscan.shape == (len(self.eps_history), self.nt):
+            raise ValueError(
+                f'shape error, bscan is {bscan.shape}'
+                f'and should be ({len(self.eps_history)=}, {self.nt=})'
+                )
+        ans = np.zeros_like(bscan)
+        ans.flat[:] = self.interpolator * bscan.flat[:]
+        return ans
+
+
+if __name__ == "__main__":
+    from coodddaaaa.utils import Timer, polyspace
+
+    with Timer('constructor'):
+        st = Stretcher(
+            nt=4096,
+            dt=1e-8,
+            t0=0.,
+            eps=polyspace(-0.01, 0.01, 200, pwr=2.0),
+            interp_kind="cubic",
+            )
+
+    x = np.random.randn(st.nt)
+    with Timer('stretch'):
+        x_stretched = st.stretch(x)
+
+    with Timer('corr'):
+        c = st.corr(x, x_stretched)
+
+    with Timer('hypermax'):
+        epsmax, cmax = st.corrmax(c)
+
+    x = np.random.randn(123, st.nt)
+    with Timer('corr_all_with_all'):
+        c_triu, e_triu = st.corr_all_with_all(data=x)
+
+    with Timer('triu2dense x2'):
+        c = st.triu2dense(c_triu, True, 1.0)
+        e = st.triu2dense(e_triu, False, 0.0)
+
+    """
+    Timer[constructor]: 312.93 ms
+    Timer[stretch]: 12.13 ms
+    Timer[corr]: 0.33 ms
+    Timer[hypermax]: 0.10 ms
+    Timer[corr_all_with_all]: 2904.68 ms
+    Timer[triu2dense x2]: 7.41 ms
+    """

coodddaaaa/test_bandpass.py

@@ -0,0 +1,25 @@
+import numpy as np
+import matplotlib.pyplot as plt
+from coodddaaaa.butter import BandpassFilter
+
+npts = 200
+dt = 1e-6
+nyquist = 0.5 / dt
+
+bp = BandpassFilter(
+    freqmin=0.05 * nyquist, 
+    freqmax=0.2 * nyquist, 
+    sampling_rate=1./dt, 
+    order=4)
+
+data = np.zeros(npts)
+data[npts // 2] = 1.0  # Dirac
+
+plt.figure()
+data = np.zeros(npts)
+data[npts//2] = 1.0
+plt.plot(data)
+plt.plot(bp(data, zerophase=False), label="zerophase=False")
+plt.plot(bp(data, zerophase=True), label="zerophase=True")
+plt.gca().legend()
+plt.show()

coodddaaaa/utils.py

@@ -0,0 +1,102 @@
+"""
+Copyright (c) 2023 maximilien.lehujeur
+"""
+
+
+import time
+import numpy as np
+
+
+class Timer:
+    """Counts the execution time under the "with" statement
+
+    :param message:
+    """
+
+    def __init__(self, message: str):
+        self.message = message
+
+    def __enter__(self):
+        self.start = time.perf_counter()
+        return self
+
+    def __exit__(self, *args, **kwargs):
+        end = time.perf_counter()
+        print(f'Timer[{self.message}]: {(end - self.start) * 1000.:.2f} ms')
+
+
+def polyspace(xmin: float, xmax: float, nx: int, pwr: float):
+    """A power-law to refine resolution of a stretching grid search near zero
+
+    :param xmin: min value
+    :param xmax: max value
+    :param nx: number of points
+    :param pwr: power coefficient, increase pwr to refine the resolution near 0
+
+    """
+    assert pwr > 0, ValueError(pwr)
+
+    tmin = np.sign(xmin) * np.abs(xmin) ** (1. / pwr)
+    tmax = np.sign(xmax) * np.abs(xmax) ** (1. / pwr)
+    t = np.linspace(tmin, tmax, nx)
+    return np.sign(t) * np.abs(t) ** pwr
+
+
+class TukeyWindow:
+    """
+    A parameterizable 4 points Tukey function
+    :param t0 ... t3: times of the corners of the Tukey window
+    """
+    def __init__(self, t0:float, t1:float, t2:float, t3:float):
+        """
+
+        """
+        assert t0 <= t1 <= t2 <= t3
+        self.t0 = t0
+        self.t1 = t1
+        self.t2 = t2
+        self.t3 = t3
+
+    def _growing(self, t):
+        return (1. - np.cos(np.pi * (t - self.t0) / (self.t1 - self.t0))) / 2.0
+
+    def _decreasing(self, t):
+        return (1. + np.cos(np.pi * (t - self.t2) / (self.t3 - self.t2))) / 2.0
+
+    def __call__(self, t: np.ndarray):
+        """
+        Evaluate the taper function at t
+
+        :param t: does not need to be sorted or regularly spaced
+        """
+        i = np.argsort(t)
+
+        j0, j1, j2, j3 = \
+            np.searchsorted(
+                a=t[i], v=[self.t0, self.t1, self.t2, self.t3])
+
+        y = np.zeros_like(t)
+        y[i[:j0]] = 0.
+        y[i[j0:j1]] = self._growing(t[i[j0:j1]])
+        y[i[j1:j2]] = 1.
+        y[i[j2:j3]] = self._decreasing(t[i[j2:j3]])
+        y[i[j3:]] = 0.
+        return y
+
+
+if __name__ == "__main__":
+    import matplotlib.pyplot as plt
+
+    x = np.random.randn(10000)
+    with Timer('TukeyWindow'):
+        taper = TukeyWindow(-0.5, -0.25, 0.25, 0.33)
+        y = taper(x)
+
+    plt.figure()
+    plt.plot(x, y, '.')
+
+    with Timer('Polyspace'):
+        x = polyspace(-0.01, 0.03, 100, 2)
+    plt.figure()
+    plt.plot(x)
+    plt.show()

coodddaaaa/version.py

@@ -0,0 +1 @@
+__version__="1.4.2"

coodddaaaa-1.4.2.dist-info/METADATA

@@ -0,0 +1,30 @@
+Metadata-Version: 2.4
+Name: coodddaaaa
+Version: 1.4.2
+Summary: Coda stretching
+Home-page: 
+Author: Maximilien Lehujeur / Pierric Mora
+Author-email: maximilien.lehujeur@univ-eiffel.fr
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Operating System :: Microsoft :: Windows
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy
+Requires-Dist: scipy
+Requires-Dist: matplotlib
+Requires-Dist: jupyter
+Requires-Dist: notebook
+Requires-Dist: sphinx
+Requires-Dist: sphinx-rtd-theme
+Requires-Dist: myst-parser
+Requires-Dist: nbsphinx
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description-content-type
+Dynamic: license-file
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary

coodddaaaa-1.4.2.dist-info/RECORD

@@ -0,0 +1,15 @@
+coodddaaaa/__init__.py,sha256=ztjGTDSWRCSB0JSuhbk_8eFQhwHXjw8v5ADSq6D6EUo,43
+coodddaaaa/butter.py,sha256=el8Cc646zvKuQXEtOH38z-4G8PjbnOwDQG39A_vAGEQ,8525
+coodddaaaa/fftoversamp.py,sha256=RYOGAzY7Hmyv3efVMymXXYavayNL91-lyU3hcdVXqgA,3458
+coodddaaaa/hypermax.py,sha256=ER0Kklm0Gi5OIA9x-iz8wHRobfSUIHZQolQVLF417_U,1864
+coodddaaaa/interp1d.py,sha256=MXZc6eqUkMBcIS9LyfFciAU9jDMb9P4_OEeUzrYZLis,11984
+coodddaaaa/stretching.py,sha256=a_gk-NrmADa6BXIaxpHHSipshwpU1rBsDyegQIksqHk,14100
+coodddaaaa/test_bandpass.py,sha256=pWAKQ54mFytzYMA8GLgS2P9dAG7LutaqqbMM6E37j0c,530
+coodddaaaa/utils.py,sha256=4iVZ9O5SzKDPCkKglZMj30tw7ersY99MhnyWP5gy_i0,2510
+coodddaaaa/version.py,sha256=EMuS0GKgrSjPsGgisChc21Z9T2CQcN7yYulyL1FRLVY,20
+coodddaaaa-1.4.2.dist-info/licenses/LICENSE,sha256=x2VmhAerMbPYCjhZdVF3G581EhOW3R95KswAHn-VlZA,1076
+examples/__init__.py,sha256=iCdfsReTYFyMKAl86iIo8KR90Syb6mv71om0v2yWASo,44
+coodddaaaa-1.4.2.dist-info/METADATA,sha256=Rl_Sbyaxl7UNGiJoOed6181FdJVDCe9RXhnI_UzhlsQ,815
+coodddaaaa-1.4.2.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+coodddaaaa-1.4.2.dist-info/top_level.txt,sha256=2z0RQvnwWKgYoJk5LDOR8KM77oGuMZ8G5slQxenfEiY,20
+coodddaaaa-1.4.2.dist-info/RECORD,,

coodddaaaa-1.4.2.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

coodddaaaa-1.4.2.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 maximilien.lehujeur
+
+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.

coodddaaaa-1.4.2.dist-info/top_level.txt

@@ -0,0 +1,2 @@
+coodddaaaa
+examples

examples/__init__.py

@@ -0,0 +1,2 @@
+from coodddaaaa.version import __version__
+