Wavelets are mathematical functions that decompose signals into different frequency components while preserving time information. Unlike Fourier transforms which only tell you what frequencies exist, wavelets tell you both what frequencies exist and when they occur. This makes them ideal for analyzing non-stationary signals like financial time series, audio, and sensor data.

What is the difference between VectorWave and IronWave?

VectorWave is our Java wavelet library (Java 25+) with SIMD acceleration via the Vector API; ideal for JVM-based applications and enterprise systems. IronWave is our Rust wavelet library optimized for ultra-low-latency applications with sub-microsecond performance; perfect for high-frequency trading and embedded systems. Both provide the same core wavelet transforms (DWT, MODWT, SWT, CWT) with production-grade reliability.

When should I use MODWT instead of DWT?

Use MODWT (Maximal Overlap Discrete Wavelet Transform) when you need shift-invariance, which is critical for financial time series analysis, volatility estimation, and any application where the alignment of features matters. MODWT works with any signal length and provides better statistical properties. Use DWT when you need compression or the most compact representation, as it is critically sampled with no redundancy.

Which wavelet should I use for financial analysis?

For financial time series, Daubechies Db4 with MODWT is the most common choice, offering a good balance of time and frequency localization. Use Haar for jump detection and microstructure analysis. For smoother trend analysis, consider Symlets (Sym4) which have better phase properties. For volatility clustering detection, Morlet wavelets with CWT provide rich time-frequency information.

How do I get started with wavelet analysis?

Start with our Quick Start guides: for Java applications, see the VectorWave Quick Start at https://docs.morphiqlabs.com/docs/vectorwave/getting-started/quick-start. For Rust applications, see the IronWave Quick Start at https://docs.morphiqlabs.com/docs/ironwave/getting-started/quick-start. Both guides walk you through installation, basic transforms, and common use cases like denoising and multi-scale analysis.

What is wavelet denoising and how does it work?

Wavelet denoising removes noise from signals while preserving important features like edges and trends. It works by transforming the signal into wavelet coefficients, applying a threshold to remove small coefficients (which typically represent noise), and reconstructing the signal. Common thresholding methods include Universal, SURE, Minimax, and BayesShrink. VectorWave and IronWave both provide built-in denoising functions with multiple threshold options.

VectorWave API Reference

Module Structure

VectorWave is organized into three Maven modules:

vectorwave-core

Package: com.morphiqlabs.wavelet

Core wavelet transforms and algorithms
Scalar implementations with cache optimization
Zero runtime dependencies
Works on any Java 25+ platform

vectorwave-extensions

Package: com.morphiqlabs.wavelet.extensions

SIMD optimizations via Vector API
Structured concurrency support
Automatic service discovery
2-5x performance improvement

vectorwave-examples

Package: com.morphiqlabs

Demonstrations and benchmarks
Usage examples
Performance tests

Quick Reference

MODWT Transform (Primary)

// Basic transform - works with ANY signal length
MODWTTransform transform = new MODWTTransform(Daubechies.DB4, PaddingStrategies.PERIODIC);
double[] signal = new double[777]; // Any length!
MODWTResult result = transform.forward(signal);
double[] reconstructed = transform.inverse(result);

// Batch processing with automatic SIMD
double[][] signals = new double[32][1000];
MODWTResult[] results = transform.forwardBatch(signals);

// Multi-level decomposition
MultiLevelMODWTTransform mlTransform = new MultiLevelMODWTTransform(
    wavelet, PaddingStrategies.PERIODIC);
MultiLevelMODWTResult mlResult = mlTransform.decompose(signal, levels);
double[] reconstructed = mlTransform.reconstruct(mlResult);

SWT (Stationary Wavelet Transform)

// SWT adapter with familiar interface
VectorWaveSwtAdapter swt = new VectorWaveSwtAdapter(Daubechies.DB4, PaddingStrategies.PERIODIC);

// Forward transform with mutable results
MutableMultiLevelMODWTResult result = swt.forward(signal, 4);

// Apply thresholding for denoising
swt.applyUniversalThreshold(result, true); // soft thresholding
double[] denoised = swt.inverse(result);

// Convenience denoising method
double[] clean = swt.denoise(noisySignal, 4, -1, true);

// Extract specific frequency bands
double[] highFreq = swt.extractLevel(signal, 4, 1);

CWT Transform

// Basic CWT analysis
CWTTransform cwt = new CWTTransform(new MorletWavelet());
double[] scales = {1.0, 2.0, 4.0, 8.0, 16.0};
CWTResult result = cwt.analyze(signal, scales);

// Complex analysis with phase information
ComplexCWTResult complexResult = cwt.analyzeComplex(signal, scales);
double[][] magnitude = complexResult.getMagnitude();
double[][] phase = complexResult.getPhase();

// Standard (pycwt-style) coefficients for reconstruction and analysis
MorletWavelet morlet = new MorletWavelet();
double[] fineScales = ScaleSpace.logarithmic(0.125, 64.0, 48);
ComplexNumber[][] standard = StandardCWT.computeStandardComplex(signal, fineScales, morlet);

double[][] real = new double[standard.length][signal.length];
double[][] imag = new double[standard.length][signal.length];
for (int s = 0; s < standard.length; s++) {
    for (int t = 0; t < signal.length; t++) {
        real[s][t] = standard[s][t].real();
        imag[s][t] = standard[s][t].imag();
    }
}

CWTResult standardResult = new CWTResult(new ComplexMatrix(real, imag), null, fineScales, morlet);
double[] reconstructed = new InverseCWT(morlet).reconstruct(standardResult);

Parallel CWT Transform (Extensions)

try (ParallelCWTTransform parallel = new ParallelCWTTransform.Builder()
        .wavelet(new RickerWavelet())
        .cwtConfig(CWTConfig.defaultConfig())
        .parallelConfig(ParallelConfig.auto())
        .build()) {

    double[] scales = ScaleSpace.logarithmic(1.0, 64.0, 48);
    CWTResult parallelResult = parallel.analyze(signal, scales);

    ParallelConfig.ExecutionStats stats = parallel.getStats();
    System.out.println("Parallel runs: " + stats.parallelExecutions());

    ComplexCWTResult complex = parallel.analyzeComplex(signal, scales);
    double[][] magnitude = complex.getMagnitude();
    double[][] phase = complex.getPhase();
}

Streaming Processing

// Real-time streaming with arbitrary block sizes
MODWTStreamingDenoiser denoiser = new MODWTStreamingDenoiser.Builder()
    .wavelet(Daubechies.DB4)
    .bufferSize(480) // 10ms at 48kHz - no padding needed!
    .thresholdMethod(ThresholdMethod.UNIVERSAL)
    .build();

// Process continuous stream
for (double[] chunk : audioStream) {
    double[] denoised = denoiser.denoise(chunk);
}

Wavelet Registry

// Discover available wavelets - type-safe enum approach
Set<WaveletName> available = WaveletRegistry.getAvailableWavelets();
List<WaveletName> orthogonal = WaveletRegistry.getOrthogonalWavelets();
List<WaveletName> continuous = WaveletRegistry.getContinuousWavelets();

// Get wavelets using enum - compile-time type safety!
Wavelet db4 = WaveletRegistry.getWavelet(WaveletName.DB4);
Wavelet morlet = WaveletRegistry.getWavelet(WaveletName.MORLET);
Wavelet haar = WaveletRegistry.getWavelet(WaveletName.HAAR);

// Get wavelets by family
List<WaveletName> daubechies = WaveletRegistry.getDaubechiesWavelets();
List<WaveletName> symlets = WaveletRegistry.getSymletWavelets();
List<WaveletName> coiflets = WaveletRegistry.getCoifletWavelets();

// Type-safe wavelet selection
WaveletName selected = WaveletName.DB4;  // IDE autocomplete shows all options
if (WaveletRegistry.hasWavelet(selected)) {
    Wavelet wavelet = WaveletRegistry.getWavelet(selected);
}

Core Classes

MODWT Package (`com.morphiqlabs.wavelet.modwt`)

MODWTTransform

forward(double[] signal) - Forward transform
inverse(MODWTResult result) - Inverse transform
forwardBatch(double[][] signals) - Batch processing
inverseBatch(MODWTResult[] results) - Batch reconstruction
getPerformanceInfo() - Platform capabilities
estimateProcessingTime(int length) - Performance estimation

MODWTResult

create(double[] approx, double[] detail) - Factory method
approximationCoeffs() - Get approximation coefficients
detailCoeffs() - Get detail coefficients
getSignalLength() - Original signal length
isValid() - Check for finite values

MultiLevelMODWTTransform

decompose(double[] signal) - Automatic max levels
decompose(double[] signal, int levels) - Specify levels
decomposeMutable(double[] signal, int levels) - Returns mutable result
reconstruct(MultiLevelMODWTResult result) - Full reconstruction
reconstructFromLevel(result, int level) - Partial reconstruction
getMaximumLevels(int signalLength) - Calculate max levels

MutableMultiLevelMODWTResult

getMutableDetailCoeffs(int level) - Direct coefficient access
getMutableApproximationCoeffs() - Mutable approximation
applyThreshold(int level, double threshold, boolean soft) - Thresholding
clearCaches() - Clear cached computations after modification
toImmutable() - Create immutable copy
isValid() - Check for NaN/Inf

SWT Package (`com.morphiqlabs.wavelet.swt`)

VectorWaveSwtAdapter

forward(double[] signal) - Max levels decomposition
forward(double[] signal, int levels) - Specified levels
inverse(MutableMultiLevelMODWTResult result) - Reconstruction
applyThreshold(result, level, threshold, soft) - Level thresholding
applyUniversalThreshold(result, soft) - Auto threshold
denoise(signal, levels) - Universal threshold denoising
denoise(signal, levels, threshold, soft) - Custom threshold
extractLevel(signal, levels, targetLevel) - Band extraction

CWT Package (`com.morphiqlabs.wavelet.cwt`)

CWTTransform

analyze(double[] signal, double[] scales) - Basic analysis
analyzeComplex(double[] signal, double[] scales) - Complex analysis

Wavelets

MorletWavelet - Time-frequency analysis
PaulWavelet(int order) - Financial crash detection
GaussianDerivativeWavelet(int derivative) - Edge detection

Wavelet Families

Orthogonal Wavelets

new Haar()                    // Simplest wavelet
Daubechies.DB2                // 2 vanishing moments
Daubechies.DB4                // 4 vanishing moments (popular)
Daubechies.DB8                // 8 vanishing moments
Symlet.SYM4                   // Nearly symmetric
Coiflet.COIF2                 // Both functions have vanishing moments

Biorthogonal Wavelets

BiorthogonalSpline.BIOR1_3    // CDF 1,3 wavelet

Continuous Wavelets

new MorletWavelet()           // Complex Morlet
new PaulWavelet(4)            // Paul order 4
new GaussianDerivativeWavelet(2)  // Mexican Hat (2nd derivative)

Performance Features

Automatic Optimization

SIMD Detection: Automatically uses Vector API when available
Platform Adaptive: x86 (AVX2/AVX512), ARM (NEON)
Scalar Fallback: Graceful degradation on unsupported platforms
Batch Optimization: 2-4x speedup for multiple signals

Performance Monitoring

// Check platform capabilities
WaveletOperations.PerformanceInfo info = WaveletOperations.getPerformanceInfo();
System.out.println(info.description());
// Output: "Vectorized operations enabled on aarch64 with S_128_BIT"

// Estimate processing time
MODWTTransform.ProcessingEstimate estimate = transform.estimateProcessingTime(signalLength);
System.out.println(estimate.description());

Configuration

Padding Strategies

PaddingStrategies.PERIODIC - Circular/periodic boundary (recommended for MODWT)
PaddingStrategies.ZERO - Zero padding at boundaries (CWT always uses zero padding to stay aligned with the PyWavelets reference implementation.)

Streaming Configuration

MODWTStreamingDenoiser.Builder()
    .wavelet(Daubechies.DB4)
    .paddingStrategy(PaddingStrategies.PERIODIC)
    .bufferSize(1024)  // Any size - no power-of-2 restriction
    .thresholdMethod(ThresholdMethod.UNIVERSAL)
    .thresholdType(ThresholdType.SOFT)
    .build();

Error Handling

Exception Types

InvalidSignalException - Invalid input signals
InvalidArgumentException - Invalid parameters
InvalidConfigurationException - Invalid configuration
WaveletTransformException - Transform-specific errors

Common Patterns

try {
    MODWTResult result = transform.forward(signal);
} catch (InvalidSignalException e) {
    // Handle invalid signal (NaN, Infinity, empty)
    ErrorContext context = e.getErrorContext();
    System.err.println("Signal error: " + context.getDescription());
}

Key Differences from Standard Wavelet Libraries

No Power-of-2 Restriction: MODWT works with signals of any length
Shift Invariance: MODWT provides translation-invariant analysis
Automatic SIMD: Platform-specific optimizations without manual configuration
Modern Java: Java 25+ with optional Vector API integration (Java 25 preview)

Requirements

Core Module

Java 25+ - Required for modern language features
No runtime dependencies - Pure Java implementation
Maven: Add vectorwave-core dependency

Extensions Module (Optional)

Java 25+ with Vector API support
Compilation: --add-modules jdk.incubator.vector --enable-preview
Runtime: Automatic detection and fallback
Maven: Add vectorwave-extensions as runtime dependency

Recommended Setup

<dependencies>
    <dependency>
        <groupId>com.morphiqlabs</groupId>
        <artifactId>vectorwave-core</artifactId>
        <version>1.0.0-SNAPSHOT</version>
    </dependency>
    <dependency>
        <groupId>com.morphiqlabs</groupId>
        <artifactId>vectorwave-extensions</artifactId>
        <version>1.0.0</version>
        <scope>runtime</scope>
    </dependency>
</dependencies>

Module Structure​

vectorwave-core​

vectorwave-extensions​

vectorwave-examples​

Quick Reference​

MODWT Transform (Primary)​

SWT (Stationary Wavelet Transform)​

CWT Transform​

Parallel CWT Transform (Extensions)​

Streaming Processing​

Wavelet Registry​

Core Classes​

MODWT Package (com.morphiqlabs.wavelet.modwt)​

MODWTTransform​

MODWTResult​

MultiLevelMODWTTransform​

MutableMultiLevelMODWTResult​

SWT Package (com.morphiqlabs.wavelet.swt)​

VectorWaveSwtAdapter​

CWT Package (com.morphiqlabs.wavelet.cwt)​

CWTTransform​

Wavelets​

Wavelet Families​

Orthogonal Wavelets​

Biorthogonal Wavelets​

Continuous Wavelets​

Performance Features​

Automatic Optimization​

Performance Monitoring​

Configuration​

Padding Strategies​

Streaming Configuration​

Error Handling​

Exception Types​

Common Patterns​

Key Differences from Standard Wavelet Libraries​

Requirements​

Core Module​

Extensions Module (Optional)​

Recommended Setup​