KO | EN

GitLite

Minimalist Open Source Repository Search Engine

gitlite — search

#dsh #dsh-plugin #typescript #ai-agent #developer-tools #claude-code #codex #deepseek-harness #ai-agents #react #mcp #rust

jscipy

★ 23 Open GitHub ↗

Java Scientific Computing Library - Signal Processing, FFT, Filters, PSD, DCT, SciPy-like APIs for JVM & Android used in Machine Learning and Data Science.

// repository documentation

Was this content helpful?

★ 0 (0 ratings)

<div align="center">
  <picture>
    <source media="(prefers-color-scheme: dark)" srcset="docs/logo_landscape_dark.jpg">
    <source media="(prefers-color-scheme: light)" srcset="docs/logo_landscape.jpg">
    <img alt="jSciPy Logo" src="docs/logo_landscape.jpg" width="500">
  </picture>
  <h1>jSciPy: Java Scientific Computing Library</h1>

![Build Status](https://github.com/hissain/jscipy/actions/workflows/android.yml/badge.svg)
  [![](https://jitpack.io/v/hissain/jscipy.svg)](https://jitpack.io/#hissain/jscipy)
  [![](https://jitpack.io/v/hissain/jscipy/javadoc.svg)](https://jitpack.io/com/github/hissain/jscipy/latest/javadoc/)
  [![Javadoc](https://img.shields.io/badge/Javadoc-GitHub%20Pages-blue)](https://hissain.github.io/jscipy)
  [![Maven Central](https://img.shields.io/maven-central/v/io.github.hissain/jscipy?color=blue)](https://central.sonatype.com/artifact/io.github.hissain/jscipy)
  [![Discord](https://img.shields.io/discord/1335503063523098674?logo=discord&label=discord)](https://discord.gg/ZfAEWc84J)
  [![codecov](https://codecov.io/gh/hissain/jscipy/branch/main/graph/badge.svg)](https://codecov.io/gh/hissain/jscipy)
  ![License](https://img.shields.io/github/license/hissain/jscipy?color=blue)
</div>

**jSciPy** is a comprehensive **Java Scientific Computing and Signal Processing Library** designed for **Machine Learning** on the JVM and Android. Inspired by Python's **SciPy**, it provides high-performance implementations of essential algorithms.

It currently includes modules for:
*   **Signal Processing**: Butterworth, Chebyshev, Elliptic, Bessel, and FIR (`firwin`) filters, Window Functions, 2D Convolution, 2D Cross-Correlation, Savitzky-Golay smoothing, Peak detection, Detrending, Median Filter.
*   **Waveform Generation**: Chirp (linear, quadratic, logarithmic, hyperbolic), Square wave, Sawtooth wave, Gaussian pulse (`gausspulse`), Unit impulse.
*   **Transformations**: FFT (Fast Fourier Transform), Hilbert Transform, Welch PSD, Spectrogram, Periodogram, Convolution, DCT/IDCT.
*   **Math & Analysis**: RK4 ODE Solver, Interpolation (Linear, Cubic Spline, Quadratic, B-Spline), Resampling, Polynomial fitting.

In modern machine learning workflows, most signal processing tasks rely on Python's SciPy utilities. However, there is no Java library that replicates SciPy's behavior with comparable completeness and consistency. This creates a significant gap for teams building ML or signal processing pipelines on the JVM. jSciPy aims to fill this gap, and the demand for such a library is higher than ever.

## Table of Contents

- [Why jSciPy?](#why-jscipy)
- [Features](#features)
- [Accuracy & Precision](#accuracy--precision)
- [Documentation](#documentation)
- [Getting Started](#getting-started)
- [How to Include as a Dependency](#how-to-include-as-a-dependency)
- [Demo Android Application](#demo-android-application)
- [Comparison Graphs](#comparison-graphs)
  - [Butterworth Filter](#butterworth-filter-comparison)
  - [Chebyshev Filter](#chebyshev-filter-comparison)
  - [Elliptic Filter](#elliptic-filter-comparison)
  - [Bessel Filter](#bessel-filter-comparison)
  - [RK4 Solver](#rk4-solver-comparison)
  - [FindPeaks](#findpeaks-comparison)
  - [Interpolation](#interpolation-comparison)
  - [FFT](#fft-comparison)
  - [Welch's Method](#welchs-method-comparison)
  - [Spectrogram](#spectrogram-comparison)
  - [STFT/ISTFT](#stftistft-comparison)
  - [Periodogram](#periodogram-comparison)
  - [Resample](#resample-comparison)
  - [Savitzky-Golay](#savitzky-golay-comparison)
  - [Detrend](#detrend-comparison)
  - [MedFilt](#medfilt-comparison)
  - [1D Convolve](#1d-convolve-comparison)
  - [2D Convolve](#2d-convolve-comparison)
  - [Cross-Correlation](#cross-correlation-comparison)
  - [2D Cross-Correlation](#2d-cross-correlation-comparison)
  - [DCT](#dct-comparison)
  - [Polynomial Fit](#polynomial-fit-comparison)
  - [2D FFT](#2d-fft-comparison)
  - [Hilbert Transform](#hilbert-transform-comparison)
  - [SOS Filtering](#sos-filtering-comparison)
  - [Window Functions](#window-functions-comparison)
  - [Waveform Generation](#waveform-generation-comparison)
- [Usage Examples](#usage-examples)
- [Contributing](#contributing)
- [License](#license)

## Why jSciPy?

The table below compares jSciPy’s signal processing and scientific computing features with several other popular Java libraries, highlighting areas where jSciPy provides more comprehensive functionality.

<p align="center">
  <a href="python/figs/comparison_summary_light.png">View full size (light)</a> &nbsp;|&nbsp; <a href="python/figs/comparison_summary_dark.png">View full size (dark)</a>
</p>

## Features

*   **Advanced Filtering**: Butterworth, Chebyshev, Elliptic, Bessel, **FIR Design (`firwin`)**. Supports **zero-phase (`filtfilt`)**, causal (`lfilter`), and **Second-Order Sections (`sosfilt`)** modes.
*   **2D Processing**: `convolve2d`, `correlate2d` (Full/Same/Valid), `fft2`, `ifft2`.
*   **Transforms**: standard 1D `fft` / `ifft`, real-optimized `rfft` / `irfft`, `dct` / `idct` (Discrete Cosine Transform), `stft` / `istft`, `hilbert` transform.
*   **Smoothing & Analysis**: Savitzky-Golay, `medfilt` (Median Filter), `find_peaks`, **`peakProminences`**, **`peakWidths`**, Welch's PSD, `spectrogram`, `detrend`, `resample`.
*   **Waveform Generation**: `chirp` (linear/quadratic/logarithmic/hyperbolic), `square`, `sawtooth`, `gausspulse`, `unit_impulse`.
*   **Correlation & Convolution**: `correlate`, `convolve` (Cross-Correlation and convolution with FULL/SAME/VALID modes).
*   **Polynomials**: `polyfit`, `polyval`, `polyder`.
*   **Window Functions**: Hamming, Hanning, Blackman, Kaiser, Bartlett, Flat-top, Parzen, Bohman, Triangle.
*   **Numerical Methods**: Interpolation (Linear, Quadratic, Cubic Spline, B-Spline), RK4 ODE Solver.

## Accuracy & Precision

jSciPy is rigorously tested against Python's SciPy using a "Golden Master" approach. Below is a summary of the precision (RMSE) achieved across various modules:

<p align="center">
  <a href="python/figs/accuracy_summary_light.png">View full size (light)</a> &nbsp;|&nbsp; <a href="python/figs/accuracy_summary_dark.png">View full size (dark)</a>
</p>

## Documentation

You can access full documentation javadoc of the jscipy library [HERE](https://hissain.github.io/jscipy).

## Getting Started

No prerequisites needed to use jSciPy in your project - just add the dependency below.

For contributing to jSciPy development, see [CONTRIBUTING.md](CONTRIBUTING.md).

## How to Include as a Dependency

### Maven Central (Recommended)

jSciPy is published to **Maven Central** for stable releases. Simply add the dependency to your `build.gradle`:

```gradle
dependencies {
    implementation 'io.github.hissain:jscipy:3.2.0'
}
```

Maven Central is automatically included in Gradle projects, so no additional repository configuration is needed.

### JitPack (Alternative for Latest Commits)

If you need **bleeding-edge features** or the latest unreleased commits, use JitPack:

```gradle
// Add JitPack repository
repositories {
    maven { url 'https://jitpack.io' }
}

dependencies {
    implementation 'com.github.hissain:jscipy:3.2.0'  // Note: com.github for JitPack
}
```

**Note:** JitPack uses `com.github.<username>`, while Maven Central uses `io.github.<username>`. Choose one based on your needs.

## Demo Android Application

A seperate demo android application is built on this library that might be helpful to understand how to consume this library. The application can be accessed [here](https://github.com/hissain/jscipy-android).

## Comparison Graphs

### Butterworth Filter Comparison

### Chebyshev Filter Comparison

**Type I:**

**Type II:**

### Elliptic Filter Comparison

### Bessel Filter Comparison

### RK4 Solver Comparison

### FindPeaks Comparison

### Interpolation Comparison

### FFT Comparison

### Welch's Method Comparison

### Spectrogram Comparison

### STFT/ISTFT Comparison

### Periodogram Comparison

### Resample Comparison

### Savitzky-Golay Comparison

**Smoothing:**

**Differentiation:**

### Detrend Comparison

### MedFilt Comparison

### 1D Convolve Comparison

### 2D Convolve Comparison

### Cross-Correlation Comparison

### 2D Cross-Correlation Comparison

### DCT Comparison

</picture>

### FIR Filter Design

### Polynomial Fit Comparison

### 2D FFT Comparison

### Hilbert Transform Comparison

### SOS Filtering Comparison

### Window Functions Comparison

### Waveform Generation Comparison

## Usage Examples

### Waveform Generation
Generate standard test and analysis signals.

```java
import com.hissain.jscipy.Signal;

public class WaveformExample {
    public static void main(String[] args) {
        // Time array: 1 second at 1000 Hz
        double fs = 1000.0;
        double[] t = new double[1000];
        for (int i = 0; i < t.length; i++) t[i] = i / fs;

// 1. Chirp (linear: 1 Hz -> 100 Hz over 1 second)
        double[] linear  = Signal.chirp(t, 1.0, 1.0, 100.0, "linear");
        double[] logChirp = Signal.chirp(t, 1.0, 1.0, 100.0, "logarithmic");
        double[] hypChirp = Signal.chirp(t, 1.0, 1.0, 100.0, "hyperbolic");

// 2. Square wave (period = 2*pi radians)
        double[] tRad = new double[600];
        for (int i = 0; i < tRad.length; i++) tRad[i] = 2 * Math.PI * i / 200.0;
        double[] square   = Signal.square(tRad, 0.5);   // 50% duty cycle
        double[] sawtooth = Signal.sawtooth(tRad, 1.0); // pure sawtooth
        double[] triangle = Signal.sawtooth(tRad, 0.5); // triangle wave

// 3. Gaussian pulse (fc=1000 Hz, bw=0.5)
        double[] tGauss = new double[200];
        for (int i = 0; i < tGauss.length; i++) tGauss[i] = -1.0 + 2.0 * i / 200.0;
        double[] pulse = Signal.gausspulse(tGauss, 1000.0, 0.5);

// 4. Unit impulse
        double[] impulse = Signal.unitImpulse(100, 0);   // at index 0
        double[] centred = Signal.unitImpulse(100, -1);  // at centre (index 50)
    }
}
```

### Digital Filters
All standard IIR filters (Butterworth, Chebyshev I/II, Elliptic, Bessel) are supported with consistent APIs.

```java
import com.hissain.jscipy.Signal;

public class FilterExample {
    public static void main(String[] args) {
        double[] signal = {/*... input data ...*/};
        double fs = 100.0;
        double fc = 10.0;
        int order = 4;

// 1. Butterworth: Zero-phase vs Causal
        double[] zeroPhase = Signal.filtfilt(signal, fs, fc, order);
        double[] causal = Signal.lfilter(signal, fs, fc, order);

// 2. Chebyshev Type I (Ripple 1dB) & Type II (Stopband 20dB)
        double[] cheby1 = Signal.cheby1_filtfilt(signal, fs, fc, order, 1.0);
        double[] cheby2 = Signal.cheby2_filtfilt(signal, fs, fc, order, 20.0);

// 3. Elliptic (Ripple 1dB, Stopband 40dB)
        double[] ellip = Signal.ellip_filtfilt(signal, fs, fc, order, 1.0, 40.0);
        
        // 4. Bessel (Linear Phase)
        double[] bessel = Signal.bessel_filtfilt(signal, fs, fc, order);

// Filter Modes: High-pass, Band-pass, Band-stop
        // Available for all filter types (suffix: _highpass, _bandpass, _bandstop)
        double[] bandPass = Signal.filtfilt_bandpass(signal, fs, 8.0, 4.0, order); // Center=10, Width=4

// 5. Second-Order Sections (SOS) Filtering
        // If you have SOS coefficients (e.g., from Python/SciPy)
        double[][] sos = { /* ... 6 coefficients per section ... */ };
        double[] sosFiltered = Signal.sosfilt(signal, sos);
    }
}
```

### Correlation & Polynomials
Cross-correlation and polynomial fitting/evaluation.

```java
import com.hissain.jscipy.Signal;
import com.hissain.jscipy.Math;
import com.hissain.jscipy.signal.ConvolutionMode;

public class MathSignalExample {
    public static void main(String[] args) {
        // 1. Cross-Correlation
        double[] x = {1, 2, 3};
        double[] target = {0, 1, 0.5};
        // equivalent to convolve(x, reverse(target), mode)
        double[] corr = Signal.correlate(x, target, ConvolutionMode.FULL);
        
        // 2. Discrete Cosine Transform (DCT Type-II)
        double[] dct = Signal.dct(x);             // Standard
        double[] dctOrtho = Signal.dct(x, true);  // Ortho-normalized
        
        // 3. Polynomials
        // Fit a 2nd degree polynomial to (x, y) points
        double[] xPoints = {0, 1, 2, 3};
        double[] yPoints = {1, 2, 5, 10}; // roughly x^2 + 1
        
        // Coefficients: [1.0, 0.0, 1.0] (for x^2 + 1)
        double[] coeffs = Math.polyfit(xPoints, yPoints, 2);
        
        // Evaluate polynomial at new points
        double[] val = Math.polyval(coeffs, new double[]{4, 5}); 
        
        // Compute derivative: [2.0, 0.0] (2x)
        double[] deriv = Math.polyder(coeffs);
    }
}
```

### Spectral Analysis & Transforms
Includes 1D/2D FFT, DCT/IDCT, STFT/ISTFT, Welch's Method, Periodogram, spectrogram, and Hilbert Transform.

```java
import com.hissain.jscipy.Signal;
import com.hissain.jscipy.signal.JComplex;
import com.hissain.jscipy.signal.fft.Welch;
import com.hissain.jscipy.signal.fft.Spectrogram;
import com.hissain.jscipy.signal.fft.Hilbert;

public class SpectralExample {
    public static void main(String[] args) {
        double[] signal = {/*... input data ...*/};
        double fs = 1000.0;

// 1. FFT / IFFT
        JComplex[] fft = Signal.fft(signal);
        JComplex[] ifft = Signal.ifft(fft);
        
        // 2. Real-optimized FFT (RFFT)
        JComplex[] rfft = Signal.rfft(signal);
        
        // 3. Welch's Method (PSD)
        Welch.WelchResult psd = Signal.welch(signal, fs, 256);
        // Access: psd.f (frequencies), psd.Pxx (power spectrum)

// 4. Spectrogram
        Spectrogram.SpectrogramResult spec = Signal.spectrogram(signal, fs);
        // Access: spec.frequencies, spec.times, spec.Sxx

// 5. Hilbert Transform (Analytic Signal)
        Hilbert h = new Hilbert();
        JComplex[] analytic = h.hilbert(signal);

// 6. Short-Time Fourier Transform (STFT)
        JComplex[][] stft = Signal.stft(signal); // Uses default nperseg=256, noverlap=128
        
        // 7. Inverse STFT
        double[] reconstructed = Signal.istft(stft);
    }
}
```

### Smoothing & Signal Operations
Common operations for signal conditioning and feature extraction.

```java
import com.hissain.jscipy.Signal;
import com.hissain.jscipy.signal.filter.SavitzkyGolay;
import com.hissain.jscipy.signal.filter.MedFilt;

public class OperationsExample {
    public static void main(String[] args) {
        double[] signal = {/*... data ...*/};

// 1. Savitzky-Golay Smoothing
        SavitzkyGolay sg = new SavitzkyGolay();
        double[] smoothed = sg.savgol_filter(signal, 5, 2); // Window=5, PolyOrder=2
        double[] deriv = sg.savgol_filter(signal, 5, 2, 1, 1.0); // 1st Derivative

// 2. Peak Detection
        // Min Height=0.5, Min Distance=10, Min Prominence=0.2
        int[] peaks = Signal.find_peaks(signal, 0.5, 10, 0.2);

// 3. Median Filter
        double[] med = new MedFilt().medfilt(signal, 3); // Kernel=3

// 4. Convolution (Mode: SAME, FULL, VALID)
        double[] window = {0.25, 0.5, 0.25};
        double[] conv = Signal.convolve(signal, window, ConvolutionMode.SAME);
        
        // 5. Detrending (Linear)
        double[] detrended = Signal.detrend(signal, DetrendType.LINEAR);
        
        // 6. Resampling (Up/Down sampling)
        // Note: Resampling is part of the Math module
        double[] resampled = com.hissain.jscipy.Math.resample(signal, NEW_LENGTH);
    }
}
```

### Math & Interpolation
General-purpose numerical utilities.

```java
import com.hissain.jscipy.math.RK4Solver;
import com.hissain.jscipy.Math;

public class MathExample {
    public static void main(String[] args) {
        // 1. Interpolation (Linear & Cubic)
        double[] x = {0, 1, 2}, y = {0, 1, 4};
        double[] query = {0.5, 1.5};
        
        double[] lin = Math.interp1d_linear(x, y, query);
        double[] quad = Math.interp1d_quadratic(x, y, query);
        double[] cub = Math.interp1d_cubic(x, y, query);
        double[] bspline = Math.interp1d_bspline(x, y, query, 3); // B-spline with degree k=3

// 2. RK4 ODE Solver (dy/dt = -y)
        RK4Solver solver = new RK4Solver();
        RK4Solver.Solution sol = solver.solve((t, y) -> -y, y0, t0, tf, step);
    }
}
```

## Contributing

Contributions are welcome! Please read our [Contribution Guidelines](CONTRIBUTING.md) for details on our workflow and coding standards. Feel free to submit issues or pull requests.

### Areas for Contribution (Help Wanted)

We are actively looking for contributors to help with:
1.  **Performance Benchmarking**: Creating benchmarks for large datasets to compare Java's performance vs NumPy/SciPy.
2.  **Feature Expansion**: Implementing missing window functions or additional filter types.
3.  **Edge Case Robustness**: Improving handling of `NaN`, `Infinity`, and edge cases in signal processing algorithms.
4.  **Documentation**: Adding more usage examples and javadocs.

Want to join in community discord? click [here](https://discord.com/channels/1464079471790395404/1464079472407089313)

## License

This project is licensed under the [MIT License](LICENSE).

jscipy

Explore Similar Repositories

Was this content helpful?

Recent Feedback

Download README