times — Multiply arrays element-wise (A .* B) with MATLAB-compatible implicit expansion and complex support.

times(A, B) (or A .* B) multiplies corresponding elements of A and B using MATLAB-compatible implicit expansion, so scalars and singleton dimensions broadcast automatically.

Syntax

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

Inputs

Returns

Errors

How times works

• Supports real, complex, logical, and character inputs; logical and character data are promoted to double precision before multiplication.
• 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(ad + bc).
• Empty dimensions propagate naturally—if either operand has a zero-sized dimension after broadcasting, the result is empty with the broadcasted shape.
• Integer multiplication preserves the integer class. The other operand must use the same integer class or be scalar double; fractional results round, overflow saturates, and 64-bit integer/scalar-double arithmetic uses the extended-precision compatibility path.
• Sparse real matrices interoperate with sparse, dense, logical, character, scalar, and complex operands. Sparse-sparse, sparse-scalar, and same-shape dense products preserve real sparse storage; complex products return full complex storage because RunMat does not yet have a complex sparse storage class.
• In RunMat compatibility mode, the RunMat-only optional 'like' prototype makes the output adopt the residency and complexity characteristics of the prototype. MATLAB-compatible mode rejects this extension before dispatch.

Does RunMat run times 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_mul hook, including for complex-interleaved resident handles. 2. If one operand is a real scalar and the other is a gpuArray, the runtime calls scalar_mul to keep the result on the device. 3. For shape-compatible implicit expansion, RunMat first expands gpuArray operands on device with repmat and then dispatches elem_mul. 4. The fusion planner treats times as a fusible elementwise node, so adjacent elementwise producers/consumers can execute inside a single WGSL kernel or provider-optimised pipeline, avoiding spurious 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. The documentation callouts below flag this fallback behaviour explicitly.

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

Multiply two matrices element-wise

A = [1 2 3; 4 5 6];
B = [7 8 9; 1 2 3];
P = times(A, B)

Expected output:

P =
    7   16   27
    4   10   18

Scale a matrix by a scalar

A = magic(3);
scaled = times(A, 0.5)

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];
m = times(col, row)

Expected output:

m =
    10    20    30
    20    40    60
    30    60    90

Multiply complex inputs element-wise

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

Expected output:

prod =
    4 + 3i   1 + 7i

Multiply character codes by a numeric scalar

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

Expected output:

codes = [130 132 134]

Execute times directly on gpuArray inputs

G1 = gpuArray([1 2 3]);
G2 = gpuArray([4 5 6]);
deviceProd = times(G1, G2);
result = gather(deviceProd)

Expected output:

deviceProd =
  1x3 gpuArray
     4     10     18
result =
     4    10    18

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

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

Expected output:

C =
  1x3 gpuArray
      4     10     18

Using times with coding agents

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

FAQ

Related Math functions

Open-source implementation

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

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