rdivide — Divide arrays element-wise with MATLAB-compatible implicit expansion, including complex and GPU-backed inputs.

rdivide(A, B) (or A ./ B) divides corresponding elements of A and B using MATLAB-compatible implicit expansion, so scalars and singleton dimensions broadcast automatically.

Syntax

C = rdivide(A, B)
C = rdivide(A, B, "like", prototype)

Inputs

Returns

Errors

How rdivide works

• Supports real, complex, logical, and character inputs; logical and character data are promoted to double precision before division.
• Implicit expansion works across any dimension, provided the non-singleton extents match. Size mismatches raise the standard MATLAB-compatible error.
• Complex operands follow the analytic rule (a + ib) ./ (c + id) = ((ac + bd) + i(bc - ad)) / (c^2 + d^2), matching MATLAB's behaviour for infinities and NaNs.
• Empty dimensions propagate naturally—if the broadcasted shape contains a zero extent, the result is empty with that shape.
• Integer division preserves the integer class. The other operand must use the same integer class or be scalar double; quotients round to the nearest integer with half ties away from zero, overflow saturates, and 64-bit integer/scalar-double arithmetic uses the extended-precision compatibility path.
• In RunMat compatibility mode, the RunMat-only optional 'like' prototype adopts the prototype's residency and complexity. MATLAB-compatible mode rejects this extension before dispatch; complex gpuArray prototypes are not yet supported.

Does RunMat run rdivide on the GPU?

When a gpuArray provider is active:

1. If both operands are gpuArrays with identical shapes, RunMat dispatches to the provider's elem_div hook so the entire computation stays on device memory, including for complex-interleaved resident handles. 2. If one operand is a real scalar and the other is a gpuArray, the runtime calls scalar_div (tensor ./ scalar) or scalar_rdiv (scalar ./ tensor) accordingly. 3. For shape-compatible implicit expansion, RunMat first expands gpuArray operands on device with repmat and then dispatches elem_div. 4. The fusion planner treats rdivide as a fusible elementwise node, so adjacent elementwise producers or consumers can execute inside a single WGSL kernel or provider-optimised pipeline, reducing host↔device transfers. 5. Unsupported shapes or operand kinds gather transparently to host memory, compute the result with full MATLAB semantics, and return a host tensor. When you request 'like' with a complex prototype, RunMat gathers to the host, performs the conversion, and returns a complex host value so downstream code still sees MATLAB-compatible types.

GPU memory and residency

RunMat's auto-offload planner keeps tensors on the GPU whenever fused expressions benefit from device execution. Explicit gpuArray / gather calls are still supported for MATLAB code that manages residency manually. When the active provider lacks the kernels needed for a particular call (for example, implicit expansion between gpuArrays of different shapes), RunMat gathers back to the host, computes the MATLAB-accurate result, and resumes execution seamlessly.

Examples

Divide two matrices element-wise

A = [8 12 18; 2 10 18];
B = [2 3 6; 2 5 9];
Q = rdivide(A, B)

Expected output:

Q =
    4     4     3
    1     2     2

Divide a matrix by a scalar

A = magic(3);
scaled = rdivide(A, 2)

Expected output:

scaled =
    4.5    0.5    3.5
    1.5    5.0    9.0
    8.0    6.5    2.0

Use implicit expansion between a column and row vector

col = (1:3)';
row = [10 20 30];
ratio = rdivide(col, row)

Expected output:

ratio =
    0.1    0.05    0.0333
    0.2    0.10    0.0667
    0.3    0.15    0.1000

Divide complex inputs element-wise

z1 = [1+2i, 3-4i];
z2 = [2-1i, -1+1i];
quot = rdivide(z1, z2)

Expected output:

quot =
    0.0 + 1.0i   -3.5 + 0.5i

Divide character codes by a numeric scalar

letters = 'ABC';
codes = rdivide(letters, 2)

Expected output:

codes = [32.5 33 33.5]

Execute rdivide directly on gpuArray inputs

G1 = gpuArray([10 20 30]);
G2 = gpuArray([2 5 10]);
deviceQuot = rdivide(G1, G2);
result = gather(deviceQuot)

Expected output:

deviceQuot =
  1x3 gpuArray
     5     4     3
result =
     5     4     3

Keep the result on the GPU with a 'like' prototype

proto = gpuArray.zeros(1, 1);
A = [1 2 3];
B = [2 4 6];
C = rdivide(A, B, 'like', proto);  % stays on the GPU for downstream work

Expected output:

C =
  1x3 gpuArray
      0.5    0.5    0.5

Using rdivide with coding agents

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

FAQ

Related Math functions

Open-source implementation

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

• View the source for rdivide 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