signal-processing-ai999x: offline, verified signal processing solver with step-by-step answers

Desktop app & command line · Compute in your browser · Install (Python) · Guides · Evaluation · AI999X on Hugging Face · Website · Support: Buy Me a Coffee

License: Apache-2.0 · Author: Ibnul Jaif Farabi (creator and engineer) · Organization: AI999X · Version 1.5.0

Field: Engineering · Tasks: Question Answering

signal-processing-ai999x is an offline, deterministic signal processing solver written in Rust: a desktop app, a command-line program, a browser module and a Python package. It answers signal processing questions with verified results from 74 certified capabilities, gives 334 documented answers identically on Windows and Linux, and refuses rather than guesses when an answer cannot be verified.

signal-processing-ai999x reads a question in plain English (or a typed call), picks a certified signal processing capability, computes the answer exactly, checks it, and returns the result with its steps, units, LaTeX and assumptions, or a refusal that says what is missing. It runs fully offline on any CPU, needs no GPU, no API key and no internet, and is built to give zero wrong answers: when it is not sure, it refuses instead of guessing.

Buy me a coffee License Python Offline Rust

Run it your way. signal-processing-ai999x comes as the AI999X desktop app and as the command-line program signal-processing for Windows and Linux, runs in your browser as WebAssembly, and installs as a Python package. The desktop app, the command line and the browser run the same compiled Rust program on your own device: offline, no Python needed.

Get it

Way to run it For Get it
AI999X Signal Processing desktop app 1.5.0 Windows, Linux. This model in its own app: search, ask in words, forms, live figures, explanations, offline Windows (x86-64) · Linux (x86-64)
AI999X desktop app 1.5.0 Windows, Linux. Every AI999X model in one app: search, ask in words, forms, live figures, explanations, offline Windows (x86-64) · Linux (x86-64)
Command line (signal-processing) Windows, Linux. One program per model, offline, no Python Windows (x86-64) · Linux (x86-64)
In your browser any device. Nothing to install Compute on the model page
Python Python 3.10+ pip install signal-processing-ai999x

Checksums: SHA256SUMS · every version: https://downloads.ai999x.com/desktop/latest/ · install guide: desktop & command line

Quick start

Desktop app

Download AI999X Signal Processing for your system (above), unpack it and start it; type a question in words or pick a capability, fill in the form and press Compute. Figures and an explanation of the answer appear beside it. The AI999X desktop app has the same, with Signal Processing among all AI999X models.

Linux, from a terminal:

curl -LO https://downloads.ai999x.com/desktop/1.5.0/ai999x-signal-processing-1.5.0-linux-x86_64.tar.gz
curl -LO https://downloads.ai999x.com/desktop/1.5.0/SHA256SUMS
sha256sum -c --ignore-missing SHA256SUMS
tar xzf ai999x-signal-processing-1.5.0-linux-x86_64.tar.gz
./ai999x-signal-processing-1.5.0-linux-x86_64/ai999x-signal-processing

Command line

Linux:

curl -LO https://downloads.ai999x.com/desktop/1.5.0/ai999x-cli-1.5.0-linux-x86_64.tar.gz
curl -LO https://downloads.ai999x.com/desktop/1.5.0/SHA256SUMS
sha256sum -c --ignore-missing SHA256SUMS
mkdir -p ~/.local/share && tar xzf ai999x-cli-1.5.0-linux-x86_64.tar.gz -C ~/.local/share
echo 'export PATH="$HOME/.local/share/ai999x-cli-1.5.0-linux-x86_64:$PATH"' >> ~/.bashrc && source ~/.bashrc
signal-processing --version

Windows (PowerShell):

$F = "ai999x-cli-1.5.0-windows-x86_64.zip"
Invoke-WebRequest "https://downloads.ai999x.com/desktop/1.5.0/$F" -OutFile $F
Invoke-WebRequest "https://downloads.ai999x.com/desktop/1.5.0/SHA256SUMS" -OutFile SHA256SUMS
(Get-FileHash $F -Algorithm SHA256).Hash.ToLower() -eq ((Select-String -SimpleMatch $F SHA256SUMS).Line -split ' ')[0]
Expand-Archive $F -DestinationPath "$env:LOCALAPPDATA\AI999X" -Force
$D = "$env:LOCALAPPDATA\AI999X\ai999x-cli-1.5.0-windows-x86_64"; $env:Path += ";$D"
[Environment]::SetEnvironmentVariable("Path", [Environment]::GetEnvironmentVariable("Path", "User") + ";$D", "User")
signal-processing --version

Every command below was run as shown; the text under it is what the program printed.

Ask in words: Write the question as you would say it: the program reads the quantities and their units, picks the capability and answers.

$ signal-processing ask "What is the Nyquist rate for a signal with a maximum frequency of 4 kHz?"
Read as: Nyquist rate
fs_min = 8000 Hz
Ts_max = 0.000125 s
  by: Nyquist rate  (sampling theorem: fs >= 2 fmax)
  fmax = 4000 Hz
  assumes: fmax > 0; a baseband (lowpass) signal

What a capability needs: The equation or method, every input and output with its SI unit. Read this before solve: it tells you the input names.

$ signal-processing info reflection_coefficient
Reflection coefficient, VSWR and return loss of a load
  Gamma = (ZL - Z0)/(ZL + Z0); VSWR = (1 + |Gamma|)/(1 - |Gamma|)
  in   RL       load resistance [ohm]
  in   Z0       characteristic impedance of the line [ohm]
  in   XL       load reactance (0 if not given) [ohm]
  out  gamma_mag |Gamma| []
  out  gamma_angle_deg angle of Gamma in degrees []
  out  gamma_re real part of Gamma []
  out  gamma_im imaginary part of Gamma []
  out  vswr     voltage standing wave ratio []
  out  return_loss_db return loss in dB []
  out  mismatch_loss_db mismatch loss in dB []

Solve: Inputs as name=value, each with any unit of the right kind. The answer lists every output, the method used, each input converted to SI, and the conditions the answer assumes.

$ signal-processing solve reflection_coefficient "RL=75 ohm" "XL=25 ohm" "Z0=50 ohm"
gamma_mag = 0.2773500981
gamma_angle_deg = 33.69006753
gamma_re = 0.2307692308
gamma_im = 0.1538461538
vswr = 1.767591879
return_loss_db = 11.13943352
mismatch_loss_db = 0.3476210626
  by: Reflection coefficient, VSWR and return loss of a load  (Gamma = (ZL - Z0)/(ZL + Z0); VSWR = (1 + |Gamma|)/(1 - |Gamma|))
  RL = 75 ohm
  XL = 25 ohm
  Z0 = 50 ohm
  assumes: RL > 0; Z0 real (lossless line)

Many questions at once: One JSON request per line in, one JSON answer per line out, in order: for scripts, notebooks and agents (the program starts once). In PowerShell: Get-Content cases.jsonl | signal-processing batch

cases.jsonl:

{"key": "reflection_coefficient", "inputs": {"RL": "75 ohm", "XL": "25 ohm", "Z0": "50 ohm"}}
{"key": "nyquist_rate", "inputs": {"fmax": "4 kHz"}}
$ signal-processing batch < cases.jsonl
{"outcome":"SOLVED","message":"","value":0.2773500981126146,"unit":"","solved_for":"gamma_mag","si":[["RL",75.0],["XL",25.0],["Z0",50.0]],"values":[["gamma_mag",0.2773500981126146,""],["gamma_angle_deg",33.690067525979785,""],["gamma_re",0.23076923076923078,""],["gamma_im",0.15384615384615385,""],["vswr",1.7675918792439984,""],["return_loss_db",11.139433523068368,""],["mismatch_loss_db",0.34762106259211917,""]],"target":"gamma_mag","phrase":"|Gamma|","assumptions":["RL > 0","Z0 real (lossless line)"],"name":"Reflection coefficient, VSWR and return loss of a load","equation":"Gamma = (ZL - Z0)/(ZL + Z0); VSWR = (1 + |Gamma|)/(1 - |Gamma|)"}
{"outcome":"SOLVED","message":"","value":8000.0,"unit":"Hz","solved_for":"fs_min","si":[["fmax",4000.0]],"values":[["fs_min",8000.0,"Hz"],["Ts_max",0.000125,"s"]],"target":"fs_min","phrase":"Nyquist rate (minimum sampling rate)","assumptions":["fmax > 0","a baseband (lowpass) signal"],"name":"Nyquist rate","equation":"sampling theorem: fs >= 2 fmax"}

In your browser

Open Signal Processing on ai999x.com, choose a capability and press Compute: the model runs on your own device as WebAssembly; nothing is sent anywhere. Change any input (any unit of the right kind) and the answer, its explanation and the figures follow.

In your own page: signal_processing_ai999x.wasm and the loader ax-wasm.js (https://www.ai999x.com/compute/rust/ax-wasm.js).

Python

pip install signal-processing-ai999x

Worked examples in every form

The same worked example from the command line, from Python and in the browser. Each command-line output is what the program printed.

Magnitude of an analog Butterworth low-pass response

|H(f)| = 1/sqrt(1 + (f/fc)^(2N)) of an N-th order Butterworth low-pass filter, and the attenuation in dB.

Command line:

$ signal-processing solve butterworth_magnitude N=4 "fc=1 kHz" "f=2 kHz"
magnitude = 0.06237828616
attenuation_db = 24.09933123
  by: Magnitude of an analog Butterworth low-pass response  (the Butterworth magnitude-squared function)
  fc = 1000 Hz
  f = 2000 Hz
  assumes: N >= 1; fc > 0; f >= 0

Python:

import signal_processing_ai999x as m

a = m.solve("butterworth_magnitude", N="4", fc="1 kHz", f="2 kHz")
print(a.values or (a.value, a.unit))

Browser: open this capability on the model page and press Compute in your browser.

What this means: This calculation determines the magnitude response of an analog Butterworth low-pass filter. Using the filter order 4, the cutoff frequency 1 kHz, and the specific input frequency 2 kHz, the model computes the normalized gain 0.0623783. This value represents the ratio of output amplitude to input amplitude at that frequency. The corresponding attenuation in decibels, 24.0993, indicates how much signal strength is lost relative to the passband. A lower magnitude signifies greater attenuation, which is typical for frequencies above the cutoff point.

Minimum order of a analog Butterworth filter

The smallest order meeting a passband edge with at most Rp dB attenuation and a stopband edge with at least As dB.

Command line:

$ signal-processing solve butterworth_order_analog "fp=1 kHz" "fstop=2 kHz" Rp=1 As=40
order = 8
type = lowpass
  by: Minimum order of a analog Butterworth filter  (N = ceil( log10((10^(As/10)-1)/(10^(Rp/10)-1)) / (2 log10(ws/wp)) ))
  fp = 1000 Hz
  fstop = 2000 Hz
  Rp = 1
  As = 40
  assumes: 0 < Rp < As; fp != fstop

Python:

import signal_processing_ai999x as m

a = m.solve("butterworth_order_analog", fp="1 kHz", fstop="2 kHz", Rp="1", As="40")
print(a.values or (a.value, a.unit))

Browser: open this capability on the model page and press Compute in your browser.

What this means: This calculation determines the smallest integer order N required for an analog Butterworth filter to meet specific passband and stopband attenuation constraints. Given a maximum passband ripple of 1 dB at the passband edge frequency 1 kHz Hz and a minimum stopband attenuation of 40 dB at the stopband edge frequency 2 kHz Hz, the resulting minimum filter order is 8. This ensures the filter provides a maximally flat magnitude response in the passband while achieving the necessary signal rejection in the stopband.

Minimum order of a analog Chebyshev type I filter

The smallest order meeting a passband edge with at most Rp dB attenuation and a stopband edge with at least As dB.

Command line:

$ signal-processing solve chebyshev1_order_analog "fp=1 kHz" "fstop=2 kHz" Rp=1 As=40
order = 5
type = lowpass
  by: Minimum order of a analog Chebyshev type I filter  (N = ceil( acosh(sqrt((10^(As/10)-1)/(10^(Rp/10)-1))) / acosh(ws/wp) ))
  fp = 1000 Hz
  fstop = 2000 Hz
  Rp = 1
  As = 40
  assumes: 0 < Rp < As; fp != fstop

Python:

import signal_processing_ai999x as m

a = m.solve("chebyshev1_order_analog", fp="1 kHz", fstop="2 kHz", Rp="1", As="40")
print(a.values or (a.value, a.unit))

Browser: open this capability on the model page and press Compute in your browser.

What this means: This calculation determines the smallest integer order required for an analog Chebyshev Type I filter to meet specific attenuation constraints. By analyzing the passband edge frequency of 1 kHz, the stopband edge frequency of 2 kHz, the maximum passband ripple of 1, and the minimum stopband attenuation of 40, the algorithm computes that a filter of order 5 is necessary. This result indicates the complexity needed to achieve the desired transition band sharpness while maintaining the specified ripple characteristics, identifying the filter type as lowpass.

Gain of a parabolic dish (aperture) antenna

The gain eta (pi D / lambda)^2 of a circular aperture antenna of diameter D and aperture efficiency eta, in dBi, and its effective aperture.

Command line:

$ signal-processing solve dish_antenna_gain "D=3 m" "f=10 GHz" eta=0.55
G_dbi = 47.35263538
G = 54358.00866
Ae = 3.887720909 m^2
  by: Gain of a parabolic dish (aperture) antenna  (G = eta (pi D / lambda)^2 = 4 pi Ae / lambda^2)
  D = 3 m
  f = 1e+10 Hz
  eta = 0.55
  assumes: 0 < eta <= 1; D >= one wavelength

Python:

import signal_processing_ai999x as m

a = m.solve("dish_antenna_gain", D="3 m", f="10 GHz", eta="0.55")
print(a.values or (a.value, a.unit))

Browser: open this capability on the model page and press Compute in your browser.

What this means: This calculation determines the directional gain of a parabolic dish antenna using its diameter and operating frequency. Given a dish diameter of 3 m and a frequency of 10 GHz, combined with an aperture efficiency of 0.55, the resulting gain expressed as a ratio is 54358. This translates to 47.3526 in decibels relative to an isotropic source. The effective aperture, which represents the area that captures power from the incoming wave, is calculated as 3.88772 m^2. Higher gain values indicate a narrower beamwidth and greater ability to focus energy in a specific direction.

Documentation

Highlights

  • Verified, not generated. Every answer is computed by a certified signal processing capability and checked (substituted back, dimension-checked or compared with an independent computation) before it is returned.
  • Zero wrong answers by design. Seven explicit outcomes (SOLVED, NEEDS_INPUT, AMBIGUOUS, INVALID_INPUT, OUT_OF_SCOPE, UNRECOGNIZED_FORMAT, INTERNAL_ERROR), never a silent guess. Every one of its 334 documented answers is reproduced exactly on every tested platform.
  • Plain-English questions and a guaranteed typed interface. ask() reads documented question forms; solve(capability_id, **inputs) always solves a supported task with valid inputs.
  • Explains itself. Steps, formulas in LaTeX, units, assumptions and the model used, ready for notebooks, tutoring apps and homework checkers.
  • Native and in the browser. Every capability also computes natively in Rust: the desktop app and the signal-processing command line for Windows and Linux, and WebAssembly on the model page, no Python, no network.
  • Small and portable. Pure Python (sympy, mpmath); identical answers on Windows and Linux (Python 3.10, 3.11, 3.12, 3.13, 3.14).
  • Coverage: sampling, Fourier series and transforms, the DFT and FFT, filters, convolution, z-transforms, modulation, communication links, RF transmission lines and radar.

Model overview

Property Value
Package signal-processing-ai999x 1.5.0 (import signal_processing_ai999x)
Type Deterministic neuro-symbolic signal processing engine (rule-based reading + certified symbolic capabilities)
Capabilities 74 certified procedures
Knowledge pack version 1.0.0
Golden answers 334 documented answers, identical on every tested platform
Platforms tested Windows (Python 3.13), Linux x86-64 (Python 3.10, 3.11, 3.12, 3.13, 3.14)
Runtime CPU only, offline; no GPU, no network, no API key
License Apache-2.0
Creator / engineer Ibnul Jaif Farabi
Organization AI999X

Python quick start

pip install signal-processing-ai999x
# or straight from this repository:
pip install https://huggingface.co/AI999X/signal-processing-ai999x/resolve/main/dist/signal_processing_ai999x-1.5.0-py3-none-any.whl
import signal_processing_ai999x as signal_processing

signal_processing.ask("What is the Nyquist rate for a signal with a maximum frequency of 4 kHz?").show()
# -> SOLVED — fs_min = 8000, Ts_max = 0.000125  (nyquist_rate)
signal_processing.ask("Compute the DFT of x = [1, 2, 3, 4].").show()
# -> SOLVED — peak_magnitude = 10, peak_bin = 0, magnitude = [10.0, 2.8284271247461903, 2.0, 2.8284271247461903], phase = [0.0, 2.356194490192345, 3.141592653589793, -2.356194490192345]  (dft_spectrum)
signal_processing.ask("What is the bit error rate of BPSK at Eb/N0 = 8 dB?").show()
# -> SOLVED — ber = 0.000190908, ber_bfsk = 0.00600439  (bpsk_ber)
signal_processing.ask("A 50 ohm line is terminated in a load of 75 + j25 ohm. Find the reflection coefficient and the VSWR.").show()
# -> SOLVED — gamma_mag = 0.27735, gamma_angle_deg = 33.6901, gamma_re = 0.230769, gamma_im = 0.153846  (reflection_coefficient)
signal_processing.solve("butterworth_design", N=2, fc="1 kHz", fs="8 kHz", btype="lowpass").show()
# -> SOLVED — b = [0.0976310729378, 0.195262145876, 0.0976310729378], a = [1.0, -0.942809041582, 0.333333333333]  (butterworth_design)
signal_processing.ask("Who created you?").message
# -> signal-processing-ai999x was created and engineered by Ibnul Jaif Farabi at AI999X.

The Python package also installs a Python command, signal-processing-ai999x "<question>"; for the native program use signal-processing (above). The outputs above were produced by running this exact code on signal-processing-ai999x 1.5.0.

How every answer is verified

  1. Reading: the question is turned into typed quantities (value, unit, kind, role) and one asked quantity; every stated number must be used or the question is refused.
  2. Planning: only certified capabilities may answer; a capability applies only under the conditions the wording states (for example a pendulum, a liquid at rest, boiling).
  3. Computing: exact symbolic or high-precision numeric evaluation.
  4. Checking: dimensions, substitution back into the defining equation, and agreement between independent readings; any disagreement becomes a refusal, never a number.

Capabilities are certified before they ship: each must reproduce hand-worked reference cases, reject a deliberately wrong variant (a control), and leave every benchmark answer unchanged.

Python worked examples, with their steps

Each question was put to signal-processing-ai999x; the answer is the one it returned, with the steps it took.

Nyquist rate · Sampling and signal basics

What is the Nyquist rate for a signal with a maximum frequency of 4 kHz?

→ fs_min = 8000 Hz, Ts_max = 0.000125 s

Steps
  • Nyquist rate: fmax = 4 kHz → fs_min = 8000 Hz, Ts_max = 0.000125 s

DFT spectrum of a sequence (FFT) · DFT and FFT

Compute the DFT of x = [1, 2, 3, 4].

→ peak_magnitude = 10, peak_bin = 0, magnitude = [10, 2.828427125, 2, 2.828427125], phase = [0, 2.35619449, 3.141592654, -2.35619449], real = [10, -2, -2, -2], imag = [0, 2, 0, -2]

Steps
  • DFT spectrum of a sequence (FFT): x = [1, 2, 3, 4] → peak_magnitude = 10, peak_bin = 0, magnitude = [10, 2.828427125, 2, 2.828427125], phase = [0, 2.35619449, 3.141592654, -2.35619449], real = [10, -2, -2, -2], imag = [0, 2, 0, -2]

Bit error rate of BPSK (and coherent BFSK) in AWGN · Digital communication

What is the bit error rate of BPSK at Eb/N0 = 8 dB?

→ ber = 0.0001909077741, ber_bfsk = 0.0060043864

Steps
  • Bit error rate of BPSK (and coherent BFSK) in AWGN: ebn0_db = 8 → ber = 0.0001909077741, ber_bfsk = 0.0060043864

Reflection coefficient, VSWR and return loss of a load · Transmission lines

A 50 ohm line is terminated in a load of 75 + j25 ohm. Find the reflection coefficient and the VSWR.

→ gamma_mag = 0.2773500981, gamma_angle_deg = 33.69006753, gamma_re = 0.2307692308, gamma_im = 0.1538461538, vswr = 1.767591879, return_loss_db = 11.13943352, mismatch_loss_db = 0.3476210626

Steps
  • Reflection coefficient, VSWR and return loss of a load: RL = 75 ohm, XL = 25 ohm, Z0 = 50 ohm → gamma_mag = 0.2773500981, gamma_angle_deg = 33.69006753, gamma_re = 0.2307692308, gamma_im = 0.1538461538, vswr = 1.767591879, return_loss_db = 11.13943352, mismatch_loss_db = 0.3476210626

Digital Butterworth filter design (bilinear transform) · Filter design

m.solve("butterworth_design", N=2, fc="1 kHz", fs="8 kHz", btype="lowpass")

→ b = [0.09763107294, 0.1952621459, 0.09763107294], a = [1, -0.9428090416, 0.3333333333]

Steps
  • Digital Butterworth filter design (bilinear transform): N = 2, fc = 1 kHz, fs = 8 kHz, btype = lowpass → b = [0.09763107294, 0.1952621459, 0.09763107294], a = [1, -0.9428090416, 0.3333333333]

Magnitude of an analog Butterworth low-pass response · Analog filters

What is the magnitude response of a 4th-order Butterworth low-pass filter with a cutoff frequency of 1 kHz at 2 kHz?

→ magnitude = 0.06237828616, attenuation_db = 24.09933123

Steps
  • Magnitude of an analog Butterworth low-pass response: N = 4, fc = 1 kHz, f = 2 kHz → magnitude = 0.06237828616, attenuation_db = 24.09933123

Figures

Every point was computed by signal-processing-ai999x.

DFT magnitude spectrum of a two-tone signal

DFT magnitude spectrum of a two-tone signal, computed by signal-processing-ai999x

Magnitude of the 32-point DFT returned by the package for x[n] = sin(2π·3n/32) + 0.5 sin(2π·7n/32), n = 0…31 (bins 0–16 shown; the rest mirror them). The two tones appear at bins 3 and 7; marked: |X[3]| = 16, |X[7]| = 8.

Butterworth low-pass responses of four orders

Butterworth low-pass responses of four orders, computed by signal-processing-ai999x

Gain of Butterworth low-pass filters of order N = 1, 2, 4 and 8 with cutoff fc = 1000 Hz (each curve 81 frequencies computed by the package, 0.1 fc to 10 fc on a log axis); every order is 3 dB down at fc and falls by 20N dB per decade. Marked: f = 2000 Hz, N = 4, gain = −24.0993 dB.

A designed digital filter: impulse and step response

A designed digital filter: impulse and step response, computed by signal-processing-ai999x

Impulse response (stems) and step response (line) of the order-4 Butterworth low-pass filter designed by the package for fc = 1000 Hz at fs = 8000 Hz (b = [0.01021, 0.04084, 0.06126, 0.04084, 0.01021], a = [1, -1.968, 1.736, -0.7245, 0.1204]), 30 samples each computed by the package; the step response settles at the DC gain 1 after overshooting to 1.11966. Marked: the largest impulse sample h[4] = 0.289522.

Poles and zeros of a digital low-pass filter

Poles and zeros of a digital low-pass filter, computed by signal-processing-ai999x

Poles and zeros returned by the package for the order-4 Butterworth low-pass filter (fc = 1000 Hz, fs = 8000 Hz) designed by it: 4 poles, largest radius 0.757669 (inside the unit circle: stable), and 4 zeros clustered at z = −1 (each within 0.000351186 of it).

Filtering a signal: input and FIR low-pass output

Filtering a signal: input and FIR low-pass output, computed by signal-processing-ai999x

A sampled signal (fs = 8000 Hz; a 166.7 Hz tone plus a 3000 Hz tone of amplitude 0.4) and the output of the 21-tap Hamming-window FIR low-pass filter (fc = 1000 Hz) designed by the package, the output computed by it sample by sample: the 3000 Hz component is removed and the slow tone passes, delayed by 10 samples (1.25 ms).

Capabilities

74 certified procedures. A few of them:

  • Procedures: AM modulation index from the envelope; Alias (apparent) frequency after sampling; Amplitude (voltage) ratio to decibels; Analytic signal, Hilbert transform and envelope; Bilinear transform of a first-order low-pass filter; Bit and symbol error rates of QPSK in AWGN; Bit error rate of BPSK (and coherent BFSK) in AWGN; Bit error rates of DPSK and noncoherent BFSK; Characteristic impedance of a coaxial line; Circular (cyclic) convolution; Coefficients of a window function; Cross-correlation and the lag of its peak; DC gain of a digital filter; DFT spectrum of a sequence (FFT); Decibels to amplitude (voltage) ratio; Decibels to power ratio; Digital Butterworth filter design (bilinear transform); Doppler shift of a radar echo; FIR filter output; FIR low-pass filter design by the window method; FM spectrum: Carson bandwidth and Bessel sideband amplitudes; Fourier transform of a decaying exponential; Fourier transform of a rectangular pulse; Free-space path loss …

signal_processing_ai999x.templates() lists every question form ask() reads; the capability guide (PDF, every example executed) is included in this repository.

All 74 formulas

Show every formula, by topic

DFT and FFT

DFT spectrum of a sequence (FFT)

X[k]=∑n=0N−1x[n] e−j2πkn/N, k=0,…,N−1 X[k] = \sum_{n=0}^{N-1} x[n]\,e^{-j2\pi kn/N},\ k = 0,\dots,N-1

Frequency of a DFT bin

fk=k fsN f_k = \frac{k\,f_s}{N}

Frequency resolution of an N-point DFT

Δf=fsN \Delta f = \frac{f_s}{N}

Inverse discrete Fourier transform

x[n]=1N∑k=0N−1X[k] ej2πkn/N x[n] = \frac{1}{N}\sum_{k=0}^{N-1} X[k]\,e^{j2\pi kn/N}

One bin of the discrete Fourier transform

X[k]=∑n=0N−1x[n] e−j2πkn/N X[k] = \sum_{n=0}^{N-1} x[n]\,e^{-j2\pi kn/N}

Fourier series and transforms

Analytic signal, Hilbert transform and envelope

xa[n]=IDFT{X[k] h[k]},envelope=∣xa[n]∣ x_a[n] = \mathrm{IDFT}\{X[k]\,h[k]\},\quad \text{envelope} = \vert x_a[n]\vert

Fourier transform of a decaying exponential

X(f)=Aτ1+j2πfτ X(f) = \frac{A\tau}{1 + j2\pi f\tau}

Fourier transform of a rectangular pulse

X(f)=Aτ sinc(fτ)=Aτsin⁡(πfτ)πfτ X(f) = A\tau\,\mathrm{sinc}(f\tau) = A\tau\frac{\sin(\pi f\tau)}{\pi f\tau}

Harmonic amplitude of a square, triangle or sawtooth wave

cnsq=4Anπ, cntri=8Aπ2n2 (n odd),cnsaw=2Anπ c_n^{\mathrm{sq}} = \frac{4A}{n\pi},\ c_n^{\mathrm{tri}} = \frac{8A}{\pi^2 n^2}\ (n\ \text{odd}),\quad c_n^{\mathrm{saw}} = \frac{2A}{n\pi}

Total harmonic distortion

THD=∑n≥2Vn2V1 \mathrm{THD} = \frac{\sqrt{\sum_{n\ge 2} V_n^2}}{V_1}

Analog filters

Magnitude of an analog Butterworth low-pass response

∣H(f)∣=11+(f/fc)2N \vert H(f)\vert = \frac{1}{\sqrt{1 + (f/f_c)^{2N}}}

Minimum order of a analog Butterworth filter

N≥log⁡1010As/10−110Rp/10−12log⁡10(ωs/ωp) N \ge \frac{\log_{10}\frac{10^{A_s/10}-1}{10^{R_p/10}-1}}{2\log_{10}(\omega_s/\omega_p)}

Minimum order of a analog Chebyshev type I filter

N≥cosh⁡−110As/10−110Rp/10−1cosh⁡−1(ωs/ωp) N \ge \frac{\cosh^{-1}\sqrt{\frac{10^{A_s/10}-1}{10^{R_p/10}-1}}}{\cosh^{-1}(\omega_s/\omega_p)}

Antennas

Gain of a parabolic dish (aperture) antenna

G=η(πDλ)2 G = \eta\left(\frac{\pi D}{\lambda}\right)^2

Communication links

Minimum SNR for a data rate (Shannon limit)

SNRmin⁡=2C/B−1,(EbN0)min⁡=2C/B−1C/B \mathrm{SNR}_{\min} = 2^{C/B} - 1,\quad \left(\tfrac{E_b}{N_0}\right)_{\min} = \frac{2^{C/B}-1}{C/B}

Shannon capacity of an AWGN channel

C=Blog⁡2(1+SNR) C = B\log_2(1 + \mathrm{SNR})

Convolution and correlation

Circular (cyclic) convolution

y[n]=∑k=0N−1x[k] h[(n−k)  N] y[n] = \sum_{k=0}^{N-1} x[k]\,h[(n-k)\bmod N]

Cross-correlation and the lag of its peak

rxy[ℓ]=∑nx[n+ℓ] y[n] r_{xy}[\ell] = \sum_n x[n+\ell]\,y[n]

Linear convolution of two sequences

y[n]=∑kx[k] h[n−k] y[n] = \sum_k x[k]\,h[n-k]

Decibels and levels

Amplitude (voltage) ratio to decibels

L=20log⁡10V2V1 dB L = 20\log_{10}\frac{V_2}{V_1}\ \mathrm{dB}

Decibels to amplitude (voltage) ratio

V2V1=10L/20 \frac{V_2}{V_1} = 10^{L/20}

Decibels to power ratio

P2P1=10L/10 \frac{P_2}{P_1} = 10^{L/10}

Power in watts to dBm and dBW

PdBm=10log⁡10P1 mW P_{\mathrm{dBm}} = 10\log_{10}\frac{P}{1\,\mathrm{mW}}

Power level in dBm to watts

P=1 mW⋅10PdBm/10 P = 1\,\mathrm{mW}\cdot 10^{P_{\mathrm{dBm}}/10}

Power ratio to decibels

L=10log⁡10P2P1 dB L = 10\log_{10}\frac{P_2}{P_1}\ \mathrm{dB}

Signal-to-noise ratio from signal and noise powers

SNRdB=10log⁡10PsPn \mathrm{SNR}_{\mathrm{dB}} = 10\log_{10}\frac{P_s}{P_n}

Total power of several signals given in dBm

Ptot=10log⁡10∑i10Pi/10 dBm P_{\mathrm{tot}} = 10\log_{10}\sum_i 10^{P_i/10}\ \mathrm{dBm}

Digital communication

Bit and symbol error rates of QPSK in AWGN

Pb=Q ⁣(2Eb/N0),Ps=2Q−Q2 P_b = Q\!\left(\sqrt{2E_b/N_0}\right),\quad P_s = 2Q - Q^2

Bit error rate of BPSK (and coherent BFSK) in AWGN

Pb=Q ⁣(2Eb/N0)=12 erfcEb/N0 P_b = Q\!\left(\sqrt{2E_b/N_0}\right) = \tfrac12\,\mathrm{erfc}\sqrt{E_b/N_0}

Bit error rates of DPSK and noncoherent BFSK

PbDPSK=12e−Eb/N0,PbNCFSK=12e−Eb/2N0 P_b^{\mathrm{DPSK}} = \tfrac12 e^{-E_b/N_0},\quad P_b^{\mathrm{NCFSK}} = \tfrac12 e^{-E_b/2N_0}

Symbol error rate of M-PSK in AWGN

Ps=1π∫0(M−1)π/Mexp⁡ ⁣(−EsN0sin⁡2(π/M)sin⁡2θ)dθ P_s = \frac{1}{\pi}\int_0^{(M-1)\pi/M} \exp\!\left(-\frac{E_s}{N_0}\frac{\sin^2(\pi/M)}{\sin^2\theta}\right)d\theta

Symbol error rate of square M-QAM in AWGN

Ps=1−[1−2(1−1M)Q ⁣(3Es(M−1)N0)]2 P_s = 1 - \left[1 - 2\left(1 - \tfrac{1}{\sqrt M}\right)Q\!\left(\sqrt{\tfrac{3E_s}{(M-1)N_0}}\right)\right]^2

Digital filters

Bilinear transform of a first-order low-pass filter

H(z)=ωc(1+z−1)(ωc+2fs)+(ωc−2fs)z−1 H(z) = \frac{\omega_c (1 + z^{-1})}{(\omega_c + 2f_s) + (\omega_c - 2f_s) z^{-1}}

DC gain of a digital filter

H(1)=∑kbk∑kak H(1) = \frac{\sum_k b_k}{\sum_k a_k}

FIR filter output

y[n]=∑k=0Mbk x[n−k] y[n] = \sum_{k=0}^{M} b_k\,x[n-k]

Frequency response of a digital filter at one frequency

H(ejω)=∑kbke−jωk∑kake−jωk, ω=2πf/fs H(e^{j\omega}) = \frac{\sum_k b_k e^{-j\omega k}}{\sum_k a_k e^{-j\omega k}},\ \omega = 2\pi f/f_s

Group delay of a digital filter

τg(ω)=−d∠H(ejω)dω=Re∑kbke−jωk∑bke−jωk−Re∑kake−jωk∑ake−jωk \tau_g(\omega) = -\frac{d\angle H(e^{j\omega})}{d\omega} = \mathrm{Re}\frac{\sum k b_k e^{-j\omega k}}{\sum b_k e^{-j\omega k}} - \mathrm{Re}\frac{\sum k a_k e^{-j\omega k}}{\sum a_k e^{-j\omega k}}

IIR filter output (difference equation)

a0y[n]=∑kbkx[n−k]−∑k≥1aky[n−k] a_0 y[n] = \sum_k b_k x[n-k] - \sum_{k\ge 1} a_k y[n-k]

Impulse response of a digital filter

h[n]=Z−1{B(z)/A(z)} h[n] = \mathcal{Z}^{-1}\{B(z)/A(z)\}

Minimum order of a digital (bilinear) Butterworth filter

N≥log⁡1010As/10−110Rp/10−12log⁡10(ωs/ωp) N \ge \frac{\log_{10}\frac{10^{A_s/10}-1}{10^{R_p/10}-1}}{2\log_{10}(\omega_s/\omega_p)}

Moving-average filter output

y[n]=1M∑i=0M−1x[n−i] y[n] = \frac{1}{M}\sum_{i=0}^{M-1} x[n-i]

Step response of a digital filter

s[n]=∑m=0nh[m] s[n] = \sum_{m=0}^{n} h[m]

Filter design

Digital Butterworth filter design (bilinear transform)

s=2fs1−z−11+z−1,ωc=2fstan⁡πfcfs s = 2f_s\frac{1 - z^{-1}}{1 + z^{-1}},\quad \omega_c = 2f_s\tan\frac{\pi f_c}{f_s}

FIR low-pass filter design by the window method

h[n]∝2fcfs sinc ⁣(2fcfs(n−N−12))w[n] h[n] \propto \frac{2f_c}{f_s}\,\mathrm{sinc}\!\left(\frac{2f_c}{f_s}\left(n - \tfrac{N-1}{2}\right)\right) w[n]

Second-order IIR notch filter design

H(z)=g 1−2cos⁡ω0z−1+z−21−2gcos⁡ω0z−1+(2g−1)z−2, g=11+tan⁡(ω0/2Q) H(z) = g\,\frac{1 - 2\cos\omega_0 z^{-1} + z^{-2}}{1 - 2g\cos\omega_0 z^{-1} + (2g - 1)z^{-2}},\ g = \frac{1}{1 + \tan(\omega_0/2Q)}

Modulation

AM modulation index from the envelope

m=Vmax⁡−Vmin⁡Vmax⁡+Vmin⁡ m = \frac{V_{\max} - V_{\min}}{V_{\max} + V_{\min}}

FM spectrum: Carson bandwidth and Bessel sideband amplitudes

BC=2(Δf+fm),s(t)=A∑nJn(β)cos⁡[2π(fc+nfm)t] B_C = 2(\Delta f + f_m),\quad s(t) = A\sum_n J_n(\beta)\cos[2\pi(f_c + n f_m)t]

Power in an AM (DSB full-carrier) signal

Pt=Pc(1+m22) P_t = P_c\left(1 + \frac{m^2}{2}\right)

Noise and link budgets

Free-space path loss

Lfs=(4πdfc)2 L_{\mathrm{fs}} = \left(\frac{4\pi d f}{c}\right)^2

Noise figure of cascaded stages (Friis formula)

F=F1+F2−1G1+F3−1G1G2+⋯ F = F_1 + \frac{F_2 - 1}{G_1} + \frac{F_3 - 1}{G_1 G_2} + \cdots

Received power of a radio link (Friis transmission equation)

Pr=PtGtGr(λ4πd)2 P_r = P_t G_t G_r \left(\frac{\lambda}{4\pi d}\right)^2

Radar

Doppler shift of a radar echo

fd=2vfc−v≈2vλ f_d = \frac{2vf}{c - v} \approx \frac{2v}{\lambda}

Maximum detection range of a radar

Rmax⁡=(PtG2λ2σ(4π)3Smin⁡)1/4 R_{\max} = \left(\frac{P_t G^2 \lambda^2 \sigma}{(4\pi)^3 S_{\min}}\right)^{1/4}

Received echo power (radar range equation)

Pr=PtG2λ2σ(4π)3R4 P_r = \frac{P_t G^2 \lambda^2 \sigma}{(4\pi)^3 R^4}

Sampling and signal basics

Alias (apparent) frequency after sampling

fa=∣f−fs round(f/fs)∣ f_a = \left\vert f - f_s\,\mathrm{round}(f/f_s) \right\vert

Frequency and angular frequency from period

f=1T,ω=2πT f = \frac{1}{T},\quad \omega = \frac{2\pi}{T}

Mean, RMS, energy and average power of a sampled signal

E=∑n∣x[n]∣2,P=EN,xrms=P E = \sum_n \vert x[n]\vert ^2,\quad P = \frac{E}{N},\quad x_{\mathrm{rms}} = \sqrt{P}

Nyquist rate

fs,min⁡=2fmax⁡ f_{s,\min} = 2 f_{\max}

Period and angular frequency from frequency

T=1f,ω=2πf T = \frac{1}{f},\quad \omega = 2\pi f

RMS, peak-to-peak and rectified average of a sine wave

Vrms=Vp2 V_{\mathrm{rms}} = \frac{V_p}{\sqrt{2}}

Signal-to-quantization-noise ratio of an ideal ADC

SQNR=10log⁡10 ⁣(32 22N)≈6.02N+1.76 dB \mathrm{SQNR} = 10\log_{10}\!\left(\tfrac{3}{2}\,2^{2N}\right) \approx 6.02N + 1.76\ \mathrm{dB}

Transmission lines

Characteristic impedance of a coaxial line

Z0=η02πεrln⁡Dd Z_0 = \frac{\eta_0}{2\pi\sqrt{\varepsilon_r}}\ln\frac{D}{d}

Input impedance of a terminated lossless line

Zin=Z0ZL+jZ0tan⁡βlZ0+jZLtan⁡βl Z_{in} = Z_0\frac{Z_L + jZ_0\tan\beta l}{Z_0 + jZ_L\tan\beta l}

Quarter-wave impedance transformer

Zt=RLZ0,ℓ=vf c4f Z_t = \sqrt{R_L Z_0},\quad \ell = \frac{v_f\,c}{4f}

Reflection coefficient and return loss from the VSWR

∣Γ∣=VSWR−1VSWR+1 \vert \Gamma\vert = \frac{\mathrm{VSWR} - 1}{\mathrm{VSWR} + 1}

Reflection coefficient, VSWR and return loss of a load

Γ=ZL−Z0ZL+Z0,VSWR=1+∣Γ∣1−∣Γ∣ \Gamma = \frac{Z_L - Z_0}{Z_L + Z_0},\quad \mathrm{VSWR} = \frac{1 + \vert \Gamma\vert }{1 - \vert \Gamma\vert }

VSWR and return loss from the reflection coefficient

VSWR=1+∣Γ∣1−∣Γ∣ \mathrm{VSWR} = \frac{1 + \vert \Gamma\vert }{1 - \vert \Gamma\vert }

Wavelets

Haar discrete wavelet transform

cA[k]=x[2k]+x[2k+1]2,cD[k]=x[2k]−x[2k+1]2 c_A[k] = \frac{x[2k] + x[2k+1]}{\sqrt 2},\quad c_D[k] = \frac{x[2k] - x[2k+1]}{\sqrt 2}

Inverse Haar wavelet transform (one level)

x[2k]=cA[k]+cD[k]2,x[2k+1]=cA[k]−cD[k]2 x[2k] = \frac{c_A[k] + c_D[k]}{\sqrt 2},\quad x[2k+1] = \frac{c_A[k] - c_D[k]}{\sqrt 2}

Windows and spectral analysis

Coefficients of a window function

w[n]=∑k(−1)kakcos⁡2πknM w[n] = \sum_k (-1)^k a_k \cos\frac{2\pi k n}{M}

Main-lobe width of a spectral window

ΔfML=k fsN, k=2 (rect), 4 (Hann, Hamming), 6 (Blackman) \Delta f_{\mathrm{ML}} = k\,\frac{f_s}{N},\ k = 2\ (\text{rect}),\ 4\ (\text{Hann, Hamming}),\ 6\ (\text{Blackman})

Periodogram (power spectral density estimate)

P[k]=2 ∣X[k]∣2fsN (0<k<N/2) P[k] = \frac{2\,\vert X[k]\vert ^2}{f_s N}\ (0 < k < N/2)

Z-transform and stability

Poles and stability of a second-order all-pole system

z2+a1z+a2=0,stable  ⟺  ∣pi∣<1 z^2 + a_1 z + a_2 = 0,\quad \text{stable} \iff \vert p_i\vert < 1

Poles, zeros and stability of a digital filter

H(z)=∑kbkz−k∑kakz−k=b0∏(1−ziz−1)a0∏(1−piz−1) H(z) = \frac{\sum_k b_k z^{-k}}{\sum_k a_k z^{-k}} = \frac{b_0\prod(1 - z_i z^{-1})}{a_0\prod(1 - p_i z^{-1})}

Out of scope

  • Open-ended explanation, essay writing or tutoring dialogue: it is a solver, not a chatbot.
  • Questions outside its certified signal processing capabilities, and any question whose stated numbers it cannot all use: it refuses with the reason instead.
  • High-stakes engineering, medical or legal decisions without independent review.

Limitations

  • It answers what its certified capabilities cover (sampling, Fourier series and transforms, the DFT and FFT, filters, convolution, z-transforms, modulation, communication links, RF transmission lines and radar); anything else is refused with a reason.
  • ask() reads documented question forms and common phrasings; unusual wording may be refused; use solve() for guaranteed results.
  • Results are as correct as the certified relations and their stated conditions; a certified relation is a checked model, not a claim about every physical situation.

Citation

@software{signal_processing_ai999x_1_5_0,
  title  = {signal-processing-ai999x: an offline, verified signal processing solver},
  author = {Farabi, Ibnul Jaif}, organization = {AI999X},
  year   = {2026}, version = {1.5.0},
  url    = {https://huggingface.co/AI999X/signal-processing-ai999x}
}

Contact

Questions, bug reports and requests: open a discussion on https://huggingface.co/AI999X/signal-processing-ai999x/discussions or visit https://ai999x.com.

Support the project

signal-processing-ai999x is free and open source. If it helps you, you can support further development on Buy Me a Coffee.

Created and engineered by Ibnul Jaif Farabi · AI999X · ai999x.com

Downloads last month
165
Inference Providers NEW
This model isn't deployed by any Inference Provider. 🙋 Ask for provider support

Collections including AI999X/signal-processing-ai999x

Evaluation results

  • identical on every platform on Golden answers (334 documented questions, Windows + Linux Python 3.10-3.14)
    self-reported
    1.000