```
DocTestFilters = [
r"\@ ContinuousWavelets .*",
r"[ +-][0-9]\.[0-9]{3,5}e-1[5-9]",
r"[ +-][0-9]\.[0-9]{3,5}e-[2-9][0-9]",
r"im {2,7}",
]
```

# ContinuousWavelets

This package is an offshoot of Wavelets.jl for the continuous wavelets. Thanks to Felix Gerick for the initial implementation there, with extension and further adaptation by David Weber and any other contributors listed on the right. Currently, it implements 1D continuous wavelet transforms with the following mother wavelets:

Which covers several standard continuous wavelet families, both real and analytic, as well as continuous versions of the orthogonal wavelet transforms implemented in Wavelets.jl.

## Basic Usage

Install via the package manager and load with `using`

```
julia> Pkg.add("ContinuousWavelets")
julia> using ContinuousWavelets
```

Basic usage example on a doppler test function.

```
julia> using Random
julia> Random.seed!(1234);
julia> using ContinuousWavelets, Wavelets
julia> n = 2047;
julia> t = range(0, n / 1000, length=n); # 1kHz sampling rate
julia> f = testfunction(n, "Doppler");
julia> c = wavelet(Morlet(π), β=2);
julia> res = cwt(f, c)
┌ Warning: the lowest frequency wavelet has more than 1% its max at zero, so it may not be analytic. Think carefully
│ lowAprxAnalyt = 0.061863
└ @ ContinuousWavelets ~/work/ContinuousWavelets.jl/ContinuousWavelets.jl/src/sanityChecks.jl:7
2047×31 Matrix{ComplexF64}:
-1.48637e-6+3.8241e-19im … 0.000109978+9.67834e-5im
-1.48602e-6+5.15534e-19im -8.24922e-5+0.000130656im
⋮ ⋱ ⋮
0.000435175+2.30636e-19im … -2.47195e-6-1.97048e-8im
0.000435027-8.28725e-19im -2.63499e-6+4.62331e-8im
```

As the cwt frame is redundant, there are many choices of dual/inverse frames. There are three available in this package, `NaiveDelta()`

, `PenroseDelta()`

, and `DualFrames()`

. As a toy example, lets knock out the middle time of the bumps function and apply a high pass filter:

```
using ContinuousWavelets, Wavelets
f = testfunction(n, "Bumps");
c = wavelet(dog2, β = 2)
res = cwt(f, c)
# output
2047×27 Matrix{Float64}:
0.000926575 -0.00150445 … -3.1189e-8 -2.84589e-8
0.000926735 -0.00150491 -2.27135e-8 -1.96595e-8
⋮ ⋱ ⋮
0.000250708 -2.53146e-6 … -3.11406e-9 -2.69593e-9
0.000250698 -2.52694e-6 -4.29947e-9 -3.92694e-9
```

```
using ContinuousWavelets, Wavelets
f = testfunction(n, "Bumps");
c = wavelet(dog2, β = 2)
res = cwt(f, c)
# dropping the middle peaks
res[620:1100, :] .= 0
# and smoothing the remaining peaks
res[:, 10:end] .= 0
freqs = getMeanFreq(length(f), c)
dropped = icwt(res, c, DualFrames())
round.(dropped,sigdigits=12)
# output
┌ Warning: the canonical dual frame is off by 3.81e6, consider using one of the delta dual frames
└ @ ContinuousWavelets ~/work/ContinuousWavelets.jl/ContinuousWavelets.jl/src/sanityChecks.jl:41
2047-element Vector{Float64}:
0.0069417253841
0.00694223965946
⋮
0.00268854944484
0.00268852311536
```

It can also handle collections of examples at the same time, should you need to do a batch of transforms:

```
julia> using Wavelets
julia> exs = cat(testfunction(n, "Doppler"), testfunction(n, "Blocks"), testfunction(n, "Bumps"), testfunction(n, "HeaviSine"), dims=2);
julia> c = wavelet(cDb2, β=2, extraOctaves=-0);
julia> res = circshift(cwt(exs, c), (0, 1, 0))
┌ Warning: the highest frequency wavelet has more than 1% its max at the end, so it may not be analytic. Think carefully
│ highAprxAnalyt = 0.26778
└ @ ContinuousWavelets ~/work/ContinuousWavelets.jl/ContinuousWavelets.jl/src/sanityChecks.jl:12
2047×32×4 Array{Float64, 3}:
[:, :, 1] =
1.89367e-5 0.000266033 … 4.6727e-5 2.99983e-6
8.33321e-5 0.000266913 1.56557e-5 -4.46419e-5
⋮ ⋱ ⋮
2.24677e-6 0.00198709 … 4.24042e-6 3.80685e-6
2.63848e-6 0.00198004 4.3791e-6 3.47575e-6
[:, :, 2] =
7.81007e-18 0.0226754 0.00955729 … 3.68809e-18
-3.47114e-18 0.022684 0.00950443 -3.47114e-18
⋮ ⋱
-9.29595e-18 0.0341512 0.0108039 … -3.84208e-19
1.27592e-18 0.0342157 0.0107729 -1.7043e-18
[:, :, 3] =
-4.2736e-7 0.0059687 … 4.47839e-8 1.86209e-8
-4.39691e-7 0.00596762 3.30771e-8 7.78201e-9
⋮ ⋱ ⋮
-9.41123e-8 0.00339924 … 8.01012e-9 4.78652e-9
-9.36079e-8 0.0034061 8.3188e-9 4.24252e-9
[:, :, 4] =
0.000307454 -0.0150898 -0.00391724 … 0.000301757
6.05948e-5 -0.0152536 -0.00405883 8.45503e-5
⋮ ⋱
-0.000307094 -0.00755439 -0.00156729 … -0.000594673
-0.000378125 -0.00746687 -0.00146262 -0.00051676
```

And the plot of these:

There are also several boundary conditions, depending on the kind of data given; the default `SymBoundary()`

symmetrizes the data, while `PerBoundary()`

assumes it is periodic, and `ZPBoundary`

pads with zeros. All wavelets are stored in the Fourier domain, and all transforms consist of performing an fft (possibly an rfft if the data is real) of the input, pointwise multiplication (equivalent to convolution in the time domain), and then returning to the time domain.

Perhaps somewhat unusually, the averaging function, or father wavelet, is included as an option (the bottom row for the figure above). This can be either the paired averaging function or uniform in frequency (the `Dirac`

averaging). The frequency coverage of the wavelets can be adjusted both in total frequency range both below by the `averagingLength`

or above by the `extraOctaves`

(caveat emptor with how well they will be defined in that case). The frequency density can be adjusted both in terms of the quality/scale factor `Q`

, as well as how quickly this density falls off as the frequency goes to zero via `β`

. Finally, depending on what kind of norm you want to preserve, `p`

determines the norm preserved in the frequency domain (so `p=1`

maintains the 1-norm in frequency, while `p=Inf`

maintains the 1-norm in time).

## Possible extensions

- Higher dimensional wavelets have yet to be implemented.
- A DCT implementation of the symmetric boundary to halve the space and computational costs.