pywavelet 0.0.1b0__py3-none-any.whl

pywavelet/__init__.py

@@ -0,0 +1,5 @@
+"""
+WDM Wavelet transform
+"""
+
+__version__ = "0.0.1"

pywavelet/_version.py

@@ -0,0 +1,16 @@
+# file generated by setuptools_scm
+# don't change, don't track in version control
+TYPE_CHECKING = False
+if TYPE_CHECKING:
+    from typing import Tuple, Union
+    VERSION_TUPLE = Tuple[Union[int, str], ...]
+else:
+    VERSION_TUPLE = object
+
+version: str
+__version__: str
+__version_tuple__: VERSION_TUPLE
+version_tuple: VERSION_TUPLE
+
+__version__ = version = '0.0.1b0'
+__version_tuple__ = version_tuple = (0, 0, 1)

pywavelet/fft_funcs.py

@@ -0,0 +1,16 @@
+"""helper to make sure available fft functions are consistent across modules depending on install
+mkl-fft is faster so it is the default, but numpy fft is probably more commonly installed to it is the fallback"""
+try:
+    import mkl_fft
+
+    rfft = mkl_fft.rfft_numpy
+    irfft = mkl_fft.irfft_numpy
+    fft = mkl_fft.fft
+    ifft = mkl_fft.ifft
+except ImportError:
+    import numpy
+
+    rfft = numpy.fft.rfft
+    irfft = numpy.fft.irfft
+    fft = numpy.fft.fft
+    ifft = numpy.fft.ifft

pywavelet/likelihood/likelihood_base.py

@@ -0,0 +1,9 @@
+from abc import ABC, abstractmethod
+
+
+class LikelihoodBase(ABC):
+    def __init__(self):
+        pass
+
+    def log_likelihood(self, data, model):
+        pass

pywavelet/likelihood/whittle.py

@@ -0,0 +1,24 @@
+"""Whittle Likelihood (in the wavelet domain)
+See eq 18, Cornish 2020 "Time-Frequency Analysis of Gravitational Wave Data"
+
+LnL(d|h) = -1/2 * Sum_{ti,fi} [ ln(2pi) + ln(PSD[ti,fi]) + (d[ti,fi]-h[ti,fi])^2/PSD[ti,fi]]
+
+where
+- d[ti,fi] is the data in the wavelet domain,
+- h[ti,fi] is the model in the wavelet domain,
+- PSD[ti,fi] is the _evolutionary_ power spectral density in the wavelet domain.
+
+For stationary noise:
+PSD[ti,fi] = PSD[fi * Nt/2] Delta_f,
+where
+- fi * Nt/2 is the frequency index in the wavelet domain,
+- Delta_f is the frequency bin width in the wavelet domain.
+
+
+"""
+
+from .likelihood_base import LikelihoodBase
+
+
+class WhittleLikelihood(LikelihoodBase):
+    pass

pywavelet/logger.py

@@ -0,0 +1,15 @@
+import sys
+import warnings
+
+from loguru import logger
+
+logger.add(
+    sys.stderr,
+    format="|<blue>pywavelet</>|{time:DD/MM HH:mm:ss}|{level}| {message} ",
+    colorize=True,
+    level="INFO",
+)
+
+
+warnings.filterwarnings("ignore", category=RuntimeWarning)
+warnings.filterwarnings("ignore", category=UserWarning)

pywavelet/transforms/__init__.py

@@ -0,0 +1,10 @@
+from .from_wavelets import (
+    from_wavelet_to_freq,
+    from_wavelet_to_freq_to_time,
+    from_wavelet_to_time,
+)
+from .to_wavelets import (
+    from_freq_to_wavelet,
+    from_time_to_freq_to_wavelet,
+    from_time_to_wavelet,
+)

pywavelet/transforms/common.py

@@ -0,0 +1,77 @@
+import numpy as np
+import scipy
+
+from .. import fft_funcs as fft
+
+PI = np.pi
+
+
+def phitilde_vec(om: np.ndarray, Nf: int, nx=4.0) -> np.ndarray:
+    """compute phitilde, om i array, nx is filter steepness, defaults to 4."""
+    # Note: Pi is Nyquist angular frequency
+    DOM = PI / Nf  # 2 pi times DF
+    insDOM = 1.0 / np.sqrt(DOM)
+    B = PI / (2 * Nf)
+    A = (DOM - B) / 2
+    z = np.zeros(om.size)
+
+    mask = (np.abs(om) >= A) & (np.abs(om) < A + B)
+
+    x = (np.abs(om[mask]) - A) / B
+    y = scipy.special.betainc(nx, nx, x)
+    z[mask] = insDOM * np.cos(PI / 2.0 * y)
+
+    z[np.abs(om) < A] = insDOM
+    return z
+
+
+def phitilde_vec_norm(Nf: int, Nt: int, nx: int) -> np.ndarray:
+    """Normalize phitilde for inverse frequency domain transform."""
+
+    # Calculate the frequency values
+    ND = Nf * Nt
+    omegas = 2 * np.pi / ND * np.arange(0, Nt // 2 + 1)
+
+    # Calculate the unnormalized phitilde (u_phit)
+    u_phit = phitilde_vec(omegas, Nf, nx)
+
+    # Normalize the phitilde
+    nrm_fctor = np.sqrt(
+        (2 * np.sum(u_phit[1:] ** 2) + u_phit[0] ** 2) * 2 * PI / ND
+    )
+    nrm_fctor /= PI ** (3 / 2) / PI
+
+    return u_phit / nrm_fctor
+
+
+def phi_vec(Nf: int, nx: int = 4.0, mult: int = 16) -> np.ndarray:
+    """get time domain phi as fourier transform of phitilde_vec"""
+    insDOM = 1.0 / np.sqrt(PI / Nf)
+    K = mult * 2 * Nf
+    half_K = mult * Nf  # np.int64(K/2)
+
+    dom = 2 * PI / K  # max frequency is K/2*dom = pi/dt = OM
+
+    DX = np.zeros(K, dtype=np.complex128)
+
+    # zero frequency
+    DX[0] = insDOM
+
+    DX = DX.copy()
+    # postive frequencies
+    DX[1 : half_K + 1] = phitilde_vec(dom * np.arange(1, half_K + 1), Nf, nx)
+    # negative frequencies
+    DX[half_K + 1 :] = phitilde_vec(
+        -dom * np.arange(half_K - 1, 0, -1), Nf, nx
+    )
+    DX = K * fft.ifft(DX, K)
+
+    phi = np.zeros(K)
+    phi[0:half_K] = np.real(DX[half_K:K])
+    phi[half_K:] = np.real(DX[0:half_K])
+
+    nrm = np.sqrt(K / dom)  # *np.linalg.norm(phi)
+
+    fac = np.sqrt(2.0) / nrm
+    phi *= fac
+    return phi

pywavelet/transforms/from_wavelets/__init__.py

@@ -0,0 +1,25 @@
+from pywavelet import fft_funcs as fft
+from pywavelet.transforms.common import phi_vec, phitilde_vec_norm
+
+from .inverse_wavelet_freq_funcs import inverse_wavelet_freq_helper_fast
+from .inverse_wavelet_time_funcs import inverse_wavelet_time_helper_fast
+
+
+def from_wavelet_to_time(wave_in, Nf, Nt, nx=4.0, mult=32):
+    """fast inverse wavelet transform to time domain"""
+    mult = min(mult, Nt // 2)  # make sure K isn't bigger than ND
+    phi = phi_vec(Nf, nx=nx, mult=mult) / 2
+
+    return inverse_wavelet_time_helper_fast(wave_in, phi, Nf, Nt, mult)
+
+
+def from_wavelet_to_freq_to_time(wave_in, Nf, Nt, nx=4.0):
+    """inverse wavlet transform to time domain via fourier transform of frequency domain"""
+    res_f = from_wavelet_to_freq(wave_in, Nf, Nt, nx)
+    return fft.irfft(res_f)
+
+
+def from_wavelet_to_freq(wave_in, Nf, Nt, nx=4.0):
+    """inverse wavelet transform to freq domain signal"""
+    phif = phitilde_vec_norm(Nf, Nt, nx)
+    return inverse_wavelet_freq_helper_fast(wave_in, phif, Nf, Nt)

pywavelet/transforms/from_wavelets/inverse_wavelet_freq_funcs.py

@@ -0,0 +1,76 @@
+"""functions for computing the inverse wavelet transforms"""
+import numpy as np
+from numba import njit
+
+from ... import fft_funcs as fft
+
+
+# @njit()
+def inverse_wavelet_freq_helper_fast(wave_in, phif, Nf, Nt):
+    """jit compatible loop for inverse_wavelet_freq"""
+    ND = Nf * Nt
+
+    prefactor2s = np.zeros(Nt, np.complex128)
+    res = np.zeros(ND // 2 + 1, dtype=np.complex128)
+
+    for m in range(0, Nf + 1):
+        pack_wave_inverse(m, Nt, Nf, prefactor2s, wave_in)
+        # with numba.objmode(fft_prefactor2s="complex128[:]"):
+        fft_prefactor2s = fft.fft(prefactor2s)
+        unpack_wave_inverse(m, Nt, Nf, phif, fft_prefactor2s, res)
+
+    return res
+
+
+@njit()
+def unpack_wave_inverse(m, Nt, Nf, phif, fft_prefactor2s, res):
+    """helper for unpacking results of frequency domain inverse transform"""
+
+    if m == 0 or m == Nf:
+        for i_ind in range(0, Nt // 2):
+            i = np.abs(m * Nt // 2 - i_ind)  # i_off+i_min2
+            ind3 = (2 * i) % Nt
+            res[i] += fft_prefactor2s[ind3] * phif[i_ind]
+        if m == Nf:
+            i_ind = Nt // 2
+            i = np.abs(m * Nt // 2 - i_ind)  # i_off+i_min2
+            ind3 = 0
+            res[i] += fft_prefactor2s[ind3] * phif[i_ind]
+    else:
+        ind31 = (Nt // 2 * m) % Nt
+        ind32 = (Nt // 2 * m) % Nt
+        for i_ind in range(0, Nt // 2):
+            i1 = Nt // 2 * m - i_ind
+            i2 = Nt // 2 * m + i_ind
+            # assert ind31 == i1%Nt
+            # assert ind32 == i2%Nt
+            res[i1] += fft_prefactor2s[ind31] * phif[i_ind]
+            res[i2] += fft_prefactor2s[ind32] * phif[i_ind]
+            ind31 -= 1
+            ind32 += 1
+            if ind31 < 0:
+                ind31 = Nt - 1
+            if ind32 == Nt:
+                ind32 = 0
+
+        res[Nt // 2 * m] = fft_prefactor2s[(Nt // 2 * m) % Nt] * phif[0]
+
+
+@njit()
+def pack_wave_inverse(m, Nt, Nf, prefactor2s, wave_in):
+    """helper for fast frequency domain inverse transform to prepare for fourier transform"""
+    if m == 0:
+        for n in range(0, Nt):
+            prefactor2s[n] = 1 / np.sqrt(2) * wave_in[(2 * n) % Nt, 0]
+    elif m == Nf:
+        for n in range(0, Nt):
+            prefactor2s[n] = 1 / np.sqrt(2) * wave_in[(2 * n) % Nt + 1, 0]
+    else:
+        for n in range(0, Nt):
+            val = wave_in[n, m]
+            if (n + m) % 2:
+                mult2 = -1j
+            else:
+                mult2 = 1
+
+            prefactor2s[n] = mult2 * val

pywavelet/transforms/from_wavelets/inverse_wavelet_time_funcs.py

@@ -0,0 +1,133 @@
+"""functions for computing the inverse wavelet transforms"""
+import numpy as np
+from numba import njit
+
+from ... import fft_funcs as fft
+
+
+def inverse_wavelet_time_helper_fast(wave_in, phi, Nf, Nt, mult):
+    """helper loop for fast inverse wavelet transform"""
+    ND = Nf * Nt
+    K = mult * 2 * Nf
+    # res = np.zeros(ND)
+
+    # extend this array, we can use wrapping boundary conditions at end
+    res = np.zeros(ND + K + Nf)
+
+    afins = np.zeros(2 * Nf, dtype=np.complex128)
+
+    for n in range(0, Nt):
+        if n % 2 == 0:
+            pack_wave_time_helper_compact(n, Nf, Nt, wave_in, afins)
+            ffts_fin = fft.fft(afins)
+            unpack_time_wave_helper_compact(n, Nf, Nt, K, phi, ffts_fin, res)
+
+    # wrap boundary conditions
+    res[: min(K + Nf, ND)] += res[ND : min(ND + K + Nf, 2 * ND)]
+    if K + Nf > ND:
+        res[: K + Nf - ND] += res[2 * ND : ND + K * Nf]
+
+    res = res[:ND]
+
+    return res
+
+
+@njit()
+def unpack_time_wave_helper(n, Nf, Nt, K, phis, fft_fin_real, res):
+    """helper for time domain wavelet transform to unpack wavelet domain coefficients"""
+    ND = Nf * Nt
+
+    idxf = (-K // 2 + n * Nf + ND) % (2 * Nf)
+    k = (-K // 2 + n * Nf) % ND
+
+    for k_ind in range(0, K):
+        res_loc = fft_fin_real[idxf]
+        res[k] += phis[k_ind] * res_loc
+        idxf += 1
+        k += 1
+
+        if idxf == 2 * Nf:
+            idxf = 0
+        if k == ND:
+            k = 0
+
+
+@njit()
+def unpack_time_wave_helper_compact(n, Nf, Nt, K, phis, fft_fin, res):
+    """helper for time domain wavelet transform to unpack wavelet domain coefficients
+    in compact representation where cosine and sine parts are real and imaginary parts
+    """
+    ND = Nf * Nt
+    fft_fin_real = np.zeros(4 * Nf)
+    fft_fin_imag = np.zeros(4 * Nf)
+    for itrf in range(0, 2 * Nf):
+        fft_fin_real[itrf] = np.real(fft_fin[itrf])
+        fft_fin_real[itrf + 2 * Nf] = fft_fin_real[itrf]
+        fft_fin_imag[itrf] = np.imag(fft_fin[(itrf + Nf) % (2 * Nf)])
+        fft_fin_imag[itrf + 2 * Nf] = fft_fin_imag[itrf]
+
+    idxf1_base = (-K // 2 + n * Nf + ND) % (2 * Nf)
+    k1_base = (-K // 2 + n * Nf) % ND
+    for k_ind in range(0, K, 2 * Nf):
+        for idxf1_add in range(0, 2 * Nf):
+            idxf1 = idxf1_base + idxf1_add  # k_ind%(2*Nf)
+            k_ind_loc = k_ind + idxf1_add
+            k1 = k1_base + k_ind_loc
+
+            res[k1] += phis[k_ind_loc] * fft_fin_real[idxf1]
+            res[k1 + Nf] += phis[k_ind_loc] * fft_fin_imag[idxf1]
+
+
+@njit()
+def pack_wave_time_helper(n, Nf, Nt, wave_in, afins):
+    """helper for time domain transform to pack wavelet domain coefficients"""
+    if n % 2 == 0:
+        # assign highest and lowest bin correctly
+        afins[0] = np.sqrt(2) * wave_in[n, 0]
+        if n + 1 < Nt:
+            afins[Nf] = np.sqrt(2) * wave_in[n + 1, 0]
+    else:
+        afins[0] = 0.0
+        afins[Nf] = 0.0
+
+    for idxm in range(0, Nf // 2 - 1):
+        if n % 2:
+            afins[2 * idxm + 2] = 1j * wave_in[n, 2 * idxm + 2]
+            afins[2 * Nf - 2 * idxm - 2] = -1j * wave_in[n, 2 * idxm + 2]
+        else:
+            afins[2 * idxm + 2] = 1 * wave_in[n, 2 * idxm + 2]
+            afins[2 * Nf - 2 * idxm - 2] = 1 * wave_in[n, 2 * idxm + 2]
+
+    for idxm in range(0, Nf // 2):
+        if n % 2:
+            afins[2 * idxm + 1] = -1 * wave_in[n, 2 * idxm + 1]
+            afins[2 * Nf - 2 * idxm - 1] = -1 * wave_in[n, 2 * idxm + 1]
+        else:
+            afins[2 * idxm + 1] = 1j * wave_in[n, 2 * idxm + 1]
+            afins[2 * Nf - 2 * idxm - 1] = -1j * wave_in[n, 2 * idxm + 1]
+
+
+@njit()
+def pack_wave_time_helper_compact(n, Nf, Nt, wave_in, afins):
+    """helper for time domain transform to pack wavelet domain coefficients
+    in packed representation with odd and even coefficients in real and imaginary pars
+    """
+    afins[0] = np.sqrt(2) * wave_in[n, 0]
+    if n + 1 < Nt:
+        afins[Nf] = np.sqrt(2) * wave_in[n + 1, 0]
+
+    for idxm in range(0, Nf - 2, 2):
+        afins[idxm + 2] = wave_in[n, idxm + 2] - wave_in[n + 1, idxm + 2]
+        afins[2 * Nf - idxm - 2] = (
+            wave_in[n, idxm + 2] + wave_in[n + 1, idxm + 2]
+        )
+
+        afins[idxm + 1] = 1j * (
+            wave_in[n, idxm + 1] - wave_in[n + 1, idxm + 1]
+        )
+        afins[2 * Nf - idxm - 1] = -1j * (
+            wave_in[n, idxm + 1] + wave_in[n + 1, idxm + 1]
+        )
+
+    afins[Nf - 1] = 1j * (wave_in[n, Nf - 1] - wave_in[n + 1, Nf - 1])
+    afins[Nf + 1] = -1j * (wave_in[n, Nf - 1] + wave_in[n + 1, Nf - 1])

pywavelet/transforms/to_wavelets/__init__.py

@@ -0,0 +1,52 @@
+import numpy as np
+
+from ... import fft_funcs as fft
+from ...logger import logger
+from ..common import phi_vec, phitilde_vec_norm
+from .transform_freq_funcs import transform_wavelet_freq_helper
+from .transform_time_funcs import transform_wavelet_time_helper
+
+
+def from_time_to_wavelet(data, Nf, Nt, nx=4.0, mult=32):
+    """From time domain data to wavelet domain
+
+    Warning: there can be significant leakage if mult is too small and the
+    transform is only approximately exact if mult=Nt/2
+
+    Parameters
+    ----------
+    data : array_like
+        Time domain data
+    Nf : int
+        Number of frequency bins
+    Nt : int
+        Number of time bins
+    nx : float, optional
+        Number of standard deviations for the gaussian wavelet, by default 4.
+    mult : int, optional
+        Number of time bins to use for the wavelet transform, by default 32
+    """
+
+    if mult > Nt / 2:
+        logger.warning(
+            f"mult={mult} is too large for Nt={Nt}. This may lead to bogus results."
+        )
+
+    mult = min(mult, Nt // 2)  # make sure K isn't bigger than ND
+    phi = phi_vec(Nf, nx, mult)
+    wave = transform_wavelet_time_helper(data, Nf, Nt, phi, mult)
+
+    return wave
+
+
+def from_time_to_freq_to_wavelet(data, Nf, Nt, nx=4.0):
+    """transform time domain data into wavelet domain via fft and then frequency transform"""
+    data_fft = fft.rfft(data)
+
+    return from_freq_to_wavelet(data_fft, Nf, Nt, nx)
+
+
+def from_freq_to_wavelet(data, Nf, Nt, nx=4.0):
+    """do the wavelet transform using the fast wavelet domain transform"""
+    phif = 2 / Nf * phitilde_vec_norm(Nf, Nt, nx)
+    return transform_wavelet_freq_helper(data, Nf, Nt, phif)

pywavelet/transforms/to_wavelets/transform_freq_funcs.py

@@ -0,0 +1,84 @@
+"""helper functions for transform_freq"""
+import numpy as np
+from numba import njit
+
+from pywavelet import fft_funcs as fft
+
+
+@njit()
+def tukey(data, alpha, N):
+    """apply tukey window function to data"""
+    imin = np.int64(alpha * (N - 1) / 2)
+    imax = np.int64((N - 1) * (1 - alpha / 2))
+    Nwin = N - imax
+
+    for i in range(0, N):
+        f_mult = 1.0
+        if i < imin:
+            f_mult = 0.5 * (1.0 + np.cos(np.pi * (i / imin - 1.0)))
+        if i > imax:
+            f_mult = 0.5 * (1.0 + np.cos(np.pi / Nwin * (i - imax)))
+        data[i] *= f_mult
+
+
+def transform_wavelet_freq_helper(data, Nf, Nt, phif):
+    """helper to do the wavelet transform using the fast wavelet domain transform"""
+    wave = np.zeros((Nt, Nf))  # wavelet wavepacket transform of the signal
+
+    DX = np.zeros(Nt, dtype=np.complex128)
+    for m in range(0, Nf + 1):
+        DX_assign_loop(m, Nt, Nf, DX, data, phif)
+        DX_trans = fft.ifft(DX, Nt)
+        DX_unpack_loop(m, Nt, Nf, DX_trans, wave)
+    return wave
+
+
+@njit()
+def DX_assign_loop(m, Nt, Nf, DX, data, phif):
+    """helper for assigning DX in the main loop"""
+    i_base = Nt // 2
+    jj_base = m * Nt // 2
+
+    if m == 0 or m == Nf:
+        # NOTE this term appears to be needed to recover correct constant (at least for m=0), but was previously missing
+        DX[Nt // 2] = phif[0] * data[m * Nt // 2] / 2.0
+        DX[Nt // 2] = phif[0] * data[m * Nt // 2] / 2.0
+    else:
+        DX[Nt // 2] = phif[0] * data[m * Nt // 2]
+        DX[Nt // 2] = phif[0] * data[m * Nt // 2]
+
+    for jj in range(jj_base + 1 - Nt // 2, jj_base + Nt // 2):
+        j = np.abs(jj - jj_base)
+        i = i_base - jj_base + jj
+        if m == Nf and jj > jj_base:
+            DX[i] = 0.0
+        elif m == 0 and jj < jj_base:
+            DX[i] = 0.0
+        elif j == 0:
+            continue
+        else:
+            DX[i] = phif[j] * data[jj]
+
+
+@njit()
+def DX_unpack_loop(m, Nt, Nf, DX_trans, wave):
+    """helper for unpacking fftd DX in main loop"""
+    if m == 0:
+        # half of lowest and highest frequency bin pixels are redundant, so store them in even and odd components of m=0 respectively
+        for n in range(0, Nt, 2):
+            wave[n, 0] = np.real(DX_trans[n] * np.sqrt(2))
+    elif m == Nf:
+        for n in range(0, Nt, 2):
+            wave[n + 1, 0] = np.real(DX_trans[n] * np.sqrt(2))
+    else:
+        for n in range(0, Nt):
+            if m % 2:
+                if (n + m) % 2:
+                    wave[n, m] = -np.imag(DX_trans[n])
+                else:
+                    wave[n, m] = np.real(DX_trans[n])
+            else:
+                if (n + m) % 2:
+                    wave[n, m] = np.imag(DX_trans[n])
+                else:
+                    wave[n, m] = np.real(DX_trans[n])

pywavelet/transforms/to_wavelets/transform_time_funcs.py

@@ -0,0 +1,63 @@
+"""helper functions for transform_time.py"""
+import numpy as np
+from numba import njit
+
+from ... import fft_funcs as fft
+
+
+def transform_wavelet_time_helper(
+    data, Nf: int, Nt: int, phi, mult: int
+) -> np.ndarray:
+    """helper function to do the wavelet transform in the time domain"""
+    # the time domain data stream
+    ND = Nf * Nt
+
+    K = mult * 2 * Nf
+
+    assert len(data) == ND, f"len(data)={len(data)} != Nf*Nt={ND}"
+
+    # windowed data packets
+    wdata = np.zeros(K)
+    wave = np.zeros((Nt, Nf))  # wavelet wavepacket transform of the signal
+    data_pad = np.concatenate((data, data[:K]))
+
+    for i in range(0, Nt):
+        assign_wdata(i, K, ND, Nf, wdata, data_pad, phi)
+        wdata_trans = fft.rfft(wdata, K)
+        pack_wave(i, mult, Nf, wdata_trans, wave)
+
+    return wave
+
+
+@njit()
+def assign_wdata(
+    i: int,
+    K: int,
+    ND: int,
+    Nf: int,
+    wdata: np.ndarray,
+    data_pad: np.ndarray,
+    phi: np.ndarray,
+):
+    """Assign wdata to be FFT'd in a loop with K extra values on the right to loop."""
+    jj = (i * Nf - K // 2) % ND  # Periodically wrap the data
+    for j in range(K):
+        wdata[j] = data_pad[jj] * phi[j]  # Apply the window
+        jj = (jj + 1) % ND  # Periodically wrap the data
+
+
+@njit()
+def pack_wave(
+    i: int, mult: int, Nf: int, wdata_trans: np.ndarray, wave: np.ndarray
+):
+    """pack fftd wdata into wave array"""
+    if i % 2 == 0 and i < wave.shape[0] - 1:
+        # m=0 value at even Nt and
+        wave[i, 0] = np.real(wdata_trans[0]) / np.sqrt(2)
+        wave[i + 1, 0] = np.real(wdata_trans[Nf * mult]) / np.sqrt(2)
+
+    for j in range(1, Nf):
+        if (i + j) % 2:
+            wave[i, j] = -np.imag(wdata_trans[j * mult])
+        else:
+            wave[i, j] = np.real(wdata_trans[j * mult])

pywavelet/utils/fisher_matrix.py

@@ -0,0 +1,6 @@
+""" Fisher information matrix in the wavelet domain:
+
+F[ij] = Sum_{i,j}  h_hat[ti, fi][i] h_hat[ti, fi][j] / PSD[ti, fi]
+
+
+"""

pywavelet/utils/snr.py

@@ -0,0 +1,37 @@
+"""Wavelet domain SNR
+
+SNR(h) = Sum_{ti,fi} [ h_hat[ti,fi] d[ti,fi] / PSD[ti,fi] ],
+
+where h_hat[ti,fi] is the unit normalized wavelet transform of the model:
+h_hat[ti,fi] = h[ti,fi] / sqrt(<h[ti,fi] | h[ti,fi] >)
+
+NOTE: to maximize over masses and spins we require some additional steps....
+
+
+"""
+
+import numpy as np
+
+
+def compute_snr(h: np.ndarray, d: np.ndarray, PSD: np.ndarray) -> float:
+    """Compute the SNR of a model h[ti,fi] given data d[ti,fi] and PSD[ti,fi].
+
+    SNR(h) = Sum_{ti,fi} [ h_hat[ti,fi] d[ti,fi] / PSD[ti,fi]
+
+    Parameters
+    ----------
+    h : np.ndarray
+        The model in the wavelet domain (binned in [ti,fi]).
+    d : np.ndarray
+        The data in the wavelet domain (binned in [ti,fi]).
+    PSD : np.ndarray
+        The PSD in the wavelet domain (binned in [ti,fi]).
+
+    Returns
+    -------
+    float
+        The SNR of the model h given data d and PSD.
+
+    """
+    h_hat = h / np.sqrt(np.tensordot(h.T, h))
+    return np.tensordot(h_hat.T, d / PSD)

pywavelet/waveform_generator/generators/__init__.py

@@ -0,0 +1,2 @@
+from .functional_waveform_generator import FunctionalWaveformGenerator
+from .lookuptable_waveform_generator import LookupTableWaveformGenerator

pywavelet/waveform_generator/generators/functional_waveform_generator.py

@@ -0,0 +1,33 @@
+import numpy as np
+
+from ...transforms import from_time_to_wavelet
+from ..waveform_generator import WaveformGenerator
+
+
+class FunctionalWaveformGenerator(WaveformGenerator):
+    def __init__(self, func, Nf=1024, Nt=1024, mult=32):
+        super().__init__("Functional")
+        self.func = func
+        self.Nf = Nf
+        self.Nt = Nt
+        self.mult = mult
+
+    def __call__(self, **params) -> np.ndarray:
+        """
+        Generate a waveform from a functional form.
+
+        Parameters
+        ----------
+        params: dict
+            A dictionary of parameters to pass to the functional form.
+
+        Returns
+        -------
+        wavelet_signal: np.ndarray
+            The waveform in the wavelet domain matrix of (Nt, Nf).
+        """
+        ht = self.func(**params)
+        wavelet_signal = from_time_to_wavelet(
+            ht, Nf=self.Nf, Nt=self.Nt, mult=self.mult
+        )
+        return wavelet_signal

pywavelet/waveform_generator/generators/lookuptable_waveform_generator.py

@@ -0,0 +1,15 @@
+from ...transforms import from_time_to_wavelet
+from ..waveform_generator import WaveformGenerator
+
+
+class LookupTableWaveformGenerator(WaveformGenerator):
+    def __init__(self, name, func, Nf=1024, Nt=1024):
+        super().__init__(name)
+        self.func = func
+        self.Nf = Nf
+        self.Nt = Nt
+
+    def __call__(self, **params):
+        time_signal = self.func(**params)
+        wavelet_signal = from_time_to_wavelet(time_signal, Nf=1024, Nt=1024)
+        return wavelet_signal

pywavelet/waveform_generator/waveform_generator.py

@@ -0,0 +1,14 @@
+from abc import ABC, abstractmethod
+
+
+class WaveformGenerator(ABC):
+    def __init__(self, name):
+        self.name = name
+
+    @abstractmethod
+    def __call__(self, **params):
+        """Call the waveform generator (using the lookup table) with the given parameters."""
+        pass
+
+    def __repr__(self):
+        return f"{self.__class__.__name__}(name={self.name})"

pywavelet-0.0.1b0.dist-info/METADATA

@@ -0,0 +1,35 @@
+Metadata-Version: 2.1
+Name: pywavelet
+Version: 0.0.1b0
+Summary: WDM wavelet transform your timeseries!
+Author-email: Pywavelet Team <pywavelet@gmail.com>
+Project-URL: Homepage, https://github.com/pypa/pywavelet
+Project-URL: Bug Reports, https://github.com/pypa/pywavelet/issues
+Project-URL: Funding, https://donate.pypi.org
+Project-URL: Say Thanks!, http://saythanks.io/to/example
+Project-URL: Source, https://github.com/pypa/pywavelet/
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3.8
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Requires-Dist: numpy
+Requires-Dist: numba
+Requires-Dist: matplotlib
+Requires-Dist: tqdm
+Requires-Dist: loguru
+Requires-Dist: bilby
+Provides-Extra: dev
+Requires-Dist: pytest >=6.0 ; extra == 'dev'
+Requires-Dist: pytest-cov >=4.1.0 ; extra == 'dev'
+Requires-Dist: pre-commit ; extra == 'dev'
+Requires-Dist: flake8 >=5.0.4 ; extra == 'dev'
+Requires-Dist: black >=22.12.0 ; extra == 'dev'
+Requires-Dist: isort ; extra == 'dev'
+Requires-Dist: mypy ; extra == 'dev'
+Requires-Dist: pycbc ; extra == 'dev'
+Requires-Dist: bilby ; extra == 'dev'
+Requires-Dist: jupyter-book ; extra == 'dev'
+

pywavelet-0.0.1b0.dist-info/RECORD

@@ -0,0 +1,29 @@
+pywavelet/__init__.py,sha256=k153Uh9uMwWTbdIUTBwDQ8okniciXJrIMXbVrQUA05A,53
+pywavelet/_version.py,sha256=8kGCB5GtL1bKeIoFN7UDyb7dIVhe1uN9mad-aDiInQs,413
+pywavelet/fft_funcs.py,sha256=5Vwugv4iGnHAy2gQwiHRsKby0Ml7HEidrCh5raKs0LE,488
+pywavelet/logger.py,sha256=1kOyFvC86npJZUF2sajymxnSF2CrBjWiqsKP858_1xs,315
+pywavelet/likelihood/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pywavelet/likelihood/likelihood_base.py,sha256=8IA7CV6SuVmTRiYfGmujLQoaUNqpWn_c9EDpMT3sVHQ,159
+pywavelet/likelihood/whittle.py,sha256=cEMA1CxiNv3p-InTLJoKXJIesqoZgcTitlOMZFeqceY,685
+pywavelet/transforms/__init__.py,sha256=xOvUrH1d0zWzZlxr713_ONwXGJ0JUt1qkUGjfQgG8nc,232
+pywavelet/transforms/common.py,sha256=EXJZEwADzhMKFYgSpCYlup3zHbM75_35jc0cIqTPrEw,2034
+pywavelet/transforms/from_wavelets/__init__.py,sha256=crkC_i_Rr_lnuK26D9_4j0VIc5fCB0RrZN7qboCIVSE,1008
+pywavelet/transforms/from_wavelets/inverse_wavelet_freq_funcs.py,sha256=oMWe7YM6o98NBEgoJuolkwzSotDp-8flg5KLqVeUNLo,2454
+pywavelet/transforms/from_wavelets/inverse_wavelet_time_funcs.py,sha256=yrKTcETVzX3BAGovtSSTrMR8BL-bePCeugAf3mpqdYA,4493
+pywavelet/transforms/to_wavelets/__init__.py,sha256=pmGgx6zOMKmZBRcpznqoBKkiw6cgLp91X0k7Q8eemVQ,1669
+pywavelet/transforms/to_wavelets/transform_freq_funcs.py,sha256=PsFV6wJedJmbZIZ40-47igPxzkxEp0o5aSgQl0pMosA,2759
+pywavelet/transforms/to_wavelets/transform_time_funcs.py,sha256=Ijb_od_daKJ3TO2GkfABGnHNhVVkUZfo2RaDIRGQmzw,1775
+pywavelet/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pywavelet/utils/fisher_matrix.py,sha256=QYYlr1K-NR_MWVAfRm1gNVq5iun49ZQ0fNns-PkLEnY,127
+pywavelet/utils/snr.py,sha256=qgKu0BgW1MKA5UkI352r_kHFdoOQoLVdmacoc9Ewaoo,990
+pywavelet/waveform_generator/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pywavelet/waveform_generator/build_lookup_table.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pywavelet/waveform_generator/waveform_generator.py,sha256=IDicy9-IM6u4z60EbAU7tTDDdNk2yty6PU_simFsyJc,372
+pywavelet/waveform_generator/generators/__init__.py,sha256=sUuWkQMsJ-cydLioiKUkIG1S0OhJsFTMwIdOJwDF0yo,144
+pywavelet/waveform_generator/generators/functional_waveform_generator.py,sha256=1Yte9aWEvZENh8u7XrlAFq5ghJVbSgjAxJgjUhy2nM8,928
+pywavelet/waveform_generator/generators/lookuptable_waveform_generator.py,sha256=HC1bJuDa33clb52xu1MM7DFnHwb0qdv0uJM-r0uTxgk,491
+pywavelet/waveform_generator/generators/rom_waveform_generator.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pywavelet-0.0.1b0.dist-info/METADATA,sha256=akrtZZGTKNkBolvoJp1JWxJQmb1tE-yHQla32Fubp2A,1324
+pywavelet-0.0.1b0.dist-info/WHEEL,sha256=yQN5g4mg4AybRjkgi-9yy4iQEFibGQmlz78Pik5Or-A,92
+pywavelet-0.0.1b0.dist-info/top_level.txt,sha256=g0Ezt0Rg0X-nrd-a0pAXKVRkuWNsF2M9Ynsjb9b2UYQ,10
+pywavelet-0.0.1b0.dist-info/RECORD,,

pywavelet-0.0.1b0.dist-info/WHEEL

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

pywavelet-0.0.1b0.dist-info/top_level.txt

@@ -0,0 +1 @@
+pywavelet