deconv — Compute one-dimensional deconvolution in MATLAB and RunMat.

deconv(b, a) performs one-dimensional polynomial long division and returns quotient q plus remainder r. Coefficients use MATLAB/RunMat polynomial ordering (highest-order term first), with support for real and complex inputs.

Syntax

Q = deconv(numerator, denominator)
[Q, R] = deconv(numerator, denominator)

Inputs

Returns

Returned values from deconv depend on how many outputs the caller requests.

Errors

How deconv works

• Inputs must be scalars, row vectors, or column vectors. Multi-dimensional tensors are rejected.
• Leading zeros are ignored during division, matching MATLAB’s behaviour. The outputs include just enough coefficients to represent the resulting polynomials (with at least one element for the zero polynomial).
• When length(b) < length(a), the quotient is zero and the remainder equals b.
• Logical inputs are promoted to double precision prior to division (TRUE → 1.0, FALSE → 0.0).
• Complex coefficients are handled exactly; the quotient and remainder retain complex values.
• Empty denominators and all-zero denominators raise MATLAB-compatible errors.

Does RunMat run deconv on the GPU?

When either input resides on the GPU (gpuArray values), RunMat first checks whether the active acceleration provider exposes a dedicated deconvolution hook. The current providers (in-process and WGPU) do not yet offer this kernel, so the runtime always:

1. Gathers the device operands into host memory. 2. Performs the polynomial long division on the CPU. 3. Re-uploads real-valued results to the provider so downstream fused kernels can remain device-resident (complex outputs stay on the host until providers add complex buffer uploads).

This fallback keeps behaviour identical to MATLAB. Gather the outputs explicitly only when you need them on the host.

Examples

Recovering a factor from a polynomial product

p = conv([1 2], [1 -3 2]);   % Multiply two polynomials
[q, r] = deconv(p, [1 2])   % Divide by the first factor

Expected output:

q = [1 -3 2];
r = 0

Obtaining a non-zero remainder

[q, r] = deconv([1 4 7], [1 2])

Expected output:

q = [1 2];
r = [3]

Dividing by a longer sequence

[q, r] = deconv([3 5], [1 0 2])

Expected output:

q = 0;
r = [3 5]

Handling leading zeros explicitly

b = [0 0 1 2];
a = [0 1 1];
[q, r] = deconv(b, a)

Expected output:

q = [1];
r = [1]

Complex polynomial division

b = [1+2i 3-4i 2];
a = [1-i 2+i];
[q, r] = deconv(b, a)

Expected output:

q = [-0.5+1.5i 6-0.5i];
r = [-10.5-5i]

GPU inputs with automatic host fallback

b = gpuArray([1 3 3 1]);
a = gpuArray([1 1]);
[q, r] = deconv(b, a); % Quotient stays on the GPU when possible
r = gather(r);         % Explicitly gather the remainder if needed on the host

Using deconv with coding agents

Open a RunMat example with live inputs, then ask the agent to explain how deconv changes the result.

FAQ

Related Math functions

Open-source implementation

Unlike proprietary runtimes, every RunMat function is open-source. Read exactly how deconv is executed, line by line, in Rust.

• View the source for deconv in Rust on GitHub
• Learn how the RunMat runtime works
• Found a bug? Open an issue with a minimal reproduction.

About RunMat

RunMat is an open-source runtime that executes MATLAB-syntax code blazing on any GPU. It is licensed under the Apache 2.0 license.

• RunMat automatically optimizes your math for GPU execution on Apple, Nvidia, and AMD hardware. No code changes needed. Simulations that took hours now take minutes.
• Start running code in seconds. RunMat runs in the browser, on the desktop, or from the CLI. No license server, no IT ticket.

Getting started · Benchmarks · Pricing