std — Compute sample or population standard deviation with MATLAB-compatible normalization and dimension options.

std(x) measures spread using standard deviation along the first non-singleton dimension by default. It follows MATLAB-compatible normalization, NaN-handling, and explicit-dimension option behavior.

Syntax

S = std(A)
S = std(A, w)
S = std(A, w, dim)
S = std(A, w, vecdim)
S = std(A, w, "all")
S = std(A, nanflag)

S = std(A)
S = std(A, w)
S = std(A, w, dim)
S = std(A, w, vecdim)
S = std(A, w, "all")
S = std(A, nanflag)
S = std(A, w, nanflag)
S = std(A, w, dim, nanflag)
S = std(A, w, nanflag, dim)
S = std(A, outtype)
S = std(A, w, outtype)
S = std(A, w, dim, outtype)
S = std(A, w, vecdim, outtype)
S = std(A, w, "all", outtype)
S = std(A, w, nanflag, outtype)
S = std(A, w, dim, nanflag, outtype)
S = std(A, w, nanflag, dim, outtype)
S = std(A, "like", prototype)
S = std(A, w, [], nanflag)

Inputs

Returns

Errors

How std works

• std(X) on an m × n matrix returns a 1 × n row vector with the sample standard deviation of each column.
• std(X, 1) switches to population normalisation (n in the denominator). Use std(X, 0) or std(X, []) to keep the default sample behaviour.
• std(X, flag, dim) lets you pick both the normalisation (flag = 0 sample, 1 population, or []) and the dimension to reduce. std(X, flag, 'all') collapses every dimension, while std(X, flag, vecdim) accepts a dimension vector such as [1 3] and reduces all listed axes in a single call. Multi-axis reductions execute on the host today when the active GPU provider cannot fuse them.
• Strings like 'omitnan' and 'includenan' decide whether NaN values are skipped or propagated.
• Optional out-type arguments ('double', 'default', 'native', or 'like', prototype) mirror MATLAB behaviour. 'native' rounds scalar integer results back to their original class; 'like' mirrors both the numeric class and device residency of prototype (complex prototypes yield complex outputs with zero imaginary parts).
• Logical inputs are promoted to double precision before reduction so that results follow MATLAB’s numeric rules.
• Empty slices return NaN with MATLAB-compatible shapes. Scalars return 0, regardless of the normalisation mode.
• Dimensions greater than ndims(X) leave the input untouched.
• Weighted standard deviations (flag as a vector) are not implemented yet; RunMat reports a descriptive error when they are requested. Complex tensors are not currently supported; convert them to real magnitudes manually before calling std.

Does RunMat run std on the GPU?

When RunMat Accelerate is active, device-resident tensors remain on the GPU whenever the provider implements the relevant hooks. Providers that expose reduce_std_dim/reduce_std execute the reduction in-place on the device; the default WGPU backend currently supports two-dimensional inputs, single-axis reductions, and 'includenan' only. Whenever 'omitnan', multi-axis reductions, or unsupported shapes are requested, RunMat transparently gathers the data to the host, computes the result there, and then applies the requested output template ('native', 'like') before returning.

GPU memory and residency

Usually you do not need to call gpuArray manually. The fusion planner keeps tensors on the GPU across fused expressions and gathers them only when necessary. For explicit control or MATLAB compatibility, you can still call gpuArray/gather yourself.

Examples

Sample standard deviation of a vector

x = [1 2 3 4 5];
s = std(x);                 % uses flag = 0 (sample) by default

Expected output:

s = 1.5811

Population standard deviation of each column

A = [1 3 5; 2 4 6];
spop = std(A, 1);           % divide by n instead of n-1

Expected output:

spop = [0.5 0.5 0.5]

Collapsing every dimension at once

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

Expected output:

overall = 3.6056

Reducing across multiple dimensions

C = cat(3, [1 2; 3 4], [5 6; 7 8]);
sliceStd = std(C, [], [1 3]);   % keep columns, reduce rows & pages

Expected output:

sliceStd = [2.5820 2.5820]

Ignoring NaN values

D = [1 NaN 3; 2 4 NaN];
rowStd = std(D, 0, 2, 'omitnan')

Expected output:

rowStd = [1.4142; 1.4142]

Matching a prototype using 'like'

proto = gpuArray(single(42));
G = gpuArray(rand(1024, 512));
spread = std(G, 1, 'all', 'like', proto);
answer = gather(spread)

Preserving default behaviour with an empty normalisation flag

C = [1 2; 3 4];
rowStd = std(C, [], 2)

Expected output:

rowStd = [0.7071; 0.7071]

How RunMat validates std

std uses the shared reduction infrastructure in runmat-runtime, which implements a two-pass Welford-style algorithm on the CPU and a matching reduction kernel on the GPU. The reduction-parity test suite runs the same inputs through both paths and asserts agreement within tolerance on every merge.

• Implementation: crates/runmat-runtime/src/builtins/math/reduction/std.rs
• Parity test: reduction_parity.rs
• Tolerance: 1e-9 (f64), 1e-3 (f32)

See Correctness & Trust for the full methodology and coverage table.

Using std with coding agents

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

FAQ

Related Math functions

Open-source implementation

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

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