mean — Compute arithmetic means in MATLAB and RunMat.

mean(X) computes arithmetic means along a dimension or across all elements. Default dimension selection and NaN/weighting options follow MATLAB semantics.

Syntax

M = mean(A)
M = mean(A, dim)
M = mean(A, "all")
M = mean(A, nanflag)
M = mean(A, outtype)
M = mean(A, dim, nanflag)

M = mean(A)
M = mean(A, dim)
M = mean(A, "all")
M = mean(A, nanflag)
M = mean(A, outtype)
M = mean(A, dim, nanflag)
M = mean(A, nanflag, dim)
M = mean(A, "like", prototype)
M = mean(A, vecdim)

Inputs

Returns

Errors

How mean works

• mean(X) on an m × n matrix returns a row vector (1 × n) with column averages.
• mean(X, 2) returns a column vector (m × 1) containing row averages.
• mean(X, 'all') collapses every dimension and returns a scalar average of all elements.
• mean(X, vecdim) accepts a vector of dimensions (e.g., [1 3]) and reduces each listed axis in one call while preserving the others.
• Complex inputs are supported and follow MATLAB's rule mean(a + bi) = mean(real(a + bi)) + i·mean(imag(a + bi)), propagating NaN through either component.
• Logical inputs are promoted to double precision (true → 1.0, false → 0.0).
• mean(..., 'omitnan') ignores NaN values; if every element in the slice is NaN, the result is NaN.
• mean(..., 'includenan') (default) propagates NaN when any element in the slice is NaN.
• mean(___, outtype) accepts 'double', 'default', or 'native' to control the output numeric class. Integer outputs round to the nearest integer, matching MATLAB.
• mean(___, 'like', prototype) matches the numeric class and residency of prototype, including GPU tensors and complex arrays.
• Empty slices produce NaN outputs that follow MATLAB's shape semantics.
• Dimensions larger than ndims(X) leave the input unchanged.

Does RunMat run mean on the GPU?

When the input tensor lives on the GPU, RunMat first asks the active acceleration provider for a device-side result via reduce_mean_dim or (when the entire tensor collapses) reduce_mean. If the provider lacks those hooks or the call specifies 'omitnan', RunMat gathers the data back to the host and evaluates the mean with the CPU reference implementation. Output templates are then applied: 'native' restores integer classes, and 'like' mirrors both the numeric class and residency—re-uploading to the GPU when the prototype is device-resident.

GPU memory and residency

You usually do NOT need to call gpuArray yourself in RunMat (unlike MATLAB).

In RunMat, the fusion planner keeps residency on GPU in branches of fused expressions. As such, in the above example, the result of the mean call will already be on the GPU when the fusion planner has detected a net benefit to operating the fused expression it is part of on the GPU.

To preserve backwards compatibility with MathWorks MATLAB, and for when you want to explicitly bootstrap GPU residency, you can call gpuArray explicitly to move data to the GPU if you want to be explicit about the residency.

Since MathWorks MATLAB does not have a fusion planner, and they kept their parallel execution toolbox separate from the core language, as their toolbox is a separate commercial product, MathWorks MATLAB users need to call gpuArray to move data to the GPU manually whereas RunMat users can rely on the fusion planner to keep data on the GPU automatically.

Examples

Computing the mean of a matrix

A = [1 2 3; 4 5 6];
colMeans = mean(A);      % column averages
rowMeans = mean(A, 2);   % row averages

Expected output:

colMeans = [2.5 3.5 4.5];
rowMeans = [2; 5]

Computing the mean of a vector with NaN values

values = [1 NaN 3];
avg = mean(values, 'omitnan')

Expected output:

avg = 2

Computing the overall mean across all elements

B = reshape(1:12, [3 4]);
overall = mean(B, 'all')

Expected output:

overall = 6.5

Reducing across multiple dimensions at once

C = cat(3, [1 2; 3 4], [5 6; 7 8]);
slice_means = mean(C, [1 3]);   % reduce rows and pages, keep columns

Expected output:

slice_means = [4 5]

Matching a prototype with 'like'

G = gpuArray(single([1 3; 5 7]));
mu = mean(G, 'all', 'like', G);
result = gather(mu)

Expected output:

result = single(4)

Computing the mean of a matrix on a GPU

G = gpuArray([1 2 NaN; 3 4 5]);
means = mean(G, 2, 'omitnan');
result = gather(means)

Expected output:

result = [1.5; 4]

Using mean with coding agents

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

FAQ

Related Math functions

Open-source implementation

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

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