ldivide — Element-wise left division A .\ B (computes B ./ A) with MATLAB-compatible broadcasting, complex support, and GPU fallbacks.

ldivide(A, B) (operator form A .\ B) divides each element of B by the corresponding element of A, delivering MATLAB-compatible left-division semantics. It is equivalent to B ./ A but keeps argument order consistent with MATLAB source code and operator precedence.

How ldivide works

• Supports real, complex, logical, and character inputs; logical and character data are promoted to double precision before division.
• Implicit expansion follows MATLAB rules: singleton dimensions expand automatically, while mismatched non-singleton extents raise MATLAB-compatible size errors.
• Complex operands use the analytic continuation B ./ A, propagating NaN and Inf exactly as MATLAB does.
• Empty shapes propagate cleanly—if the broadcasted output has a zero dimension, the result is empty with the expected shape.
• Integer inputs promote to double precision, mirroring MATLAB’s numeric tower.
• The optional 'like' prototype makes the result adopt the residency (host or GPU) and numeric flavour of the prototype. Complex prototypes are honoured on the host today; real gpuArray prototypes keep the result on the device.

How RunMat runs ldivide on the GPU

When a gpuArray provider is active:

1. If both operands are gpuArrays with identical shapes, RunMat calls the provider’s elem_div hook with (B, A) so the division runs entirely on the GPU. 2. If the divisor A is scalar (host or device) and the numerator B is a gpuArray, the runtime uses scalar_div to evaluate B ./ a on device memory. 3. If the numerator B is scalar and the divisor A is a gpuArray, scalar_rdiv performs b ./ A without leaving the GPU. 4. When shapes require implicit expansion—or the provider lacks the necessary kernels—RunMat gathers to the host, computes the MATLAB-accurate result, then reapplies 'like' residency rules (including re-uploading to a gpuArray when requested). 5. The fusion planner treats ldivide as a fusible elementwise node, so adjacent elementwise producers and consumers can execute inside a single GPU pipeline or WGSL kernel, minimising redundant host↔device transfers.

GPU memory and residency

You usually do not need to call gpuArray manually. RunMat’s auto-offload planner keeps tensors on the GPU whenever provider kernels cover the operation. Explicit gpuArray / gather calls remain available for MATLAB compatibility; when a provider fallback happens, the runtime gathers to host, computes the MATLAB-accurate answer, and reapplies 'like' residency requests automatically.

Examples

Left-dividing a vector by a scalar

A = 2;
B = [4 6 8];
Q = ldivide(A, B)

Expected output:

Q = [2 3 4]

Broadcasting between column divisors and row numerators

A = (1:3)';         % column of divisors
B = [10 20 40];     % row of numerators
M = ldivide(A, B);  % implicit expansion

Expected output:

M =
   10.0000   20.0000   40.0000
    5.0000   10.0000   20.0000
    3.3333    6.6667   13.3333

Element-wise left division of complex values

A = [1+2i, 3-4i];
B = [2-1i, -1+1i];
Z = ldivide(A, B)

Expected output:

Z =
   0.0000 - 1.0000i   -0.2800 - 0.0400i

Dividing character codes by a scalar

A = 'ABC';
B = 2;
codes = ldivide(A, B)

Expected output:

codes = [0.0308 0.0303 0.0301]

Computing reciprocals with ldivide

A = [1 2 4 8];
B = 1;
R = ldivide(A, B);   % equivalent to 1 ./ A

Expected output:

R = [1 0.5 0.25 0.125]

Keeping results on the GPU with 'like'

proto = gpuArray.zeros(1, 1);
A = gpuArray([2 4 8 16]);
B = gpuArray([4 8 16 32]);
deviceResult = ldivide(A, B, 'like', proto);
hostCheck = gather(deviceResult)

Expected output:

deviceResult =
  1x4 gpuArray
    2  2  2  2
hostCheck = [2 2 2 2]

FAQ

Related Math functions

Open-source implementation

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

• View ldivide.rs on GitHub
• Learn how the 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 — faster, on any GPU, with no license required.

• Simulations that took hours now take minutes. RunMat automatically optimizes your math for GPU execution on Apple, Nvidia, and AMD hardware. No code changes needed.
• Start running code in seconds. Open the browser sandbox or download a single binary. No license server, no IT ticket, no setup.
• A full development environment. GPU-accelerated 2D and 3D plotting, automatic versioning on every save, and a browser IDE you can share with a link.

Getting started · Benchmarks · Pricing