sum — Sum array elements along dimensions with MATLAB-compatible normalization and option handling.

sum(X) adds elements across arrays, defaulting to the first non-singleton dimension when no dimension is specified. It supports MATLAB-compatible dimension, 'all', and type-control options.

Syntax

S = sum(A)
S = sum(A, dim)
S = sum(A, "all")
S = sum(A, nanflag)
S = sum(A, outtype)
S = sum(A, dim, nanflag)

S = sum(A)
S = sum(A, dim)
S = sum(A, "all")
S = sum(A, nanflag)
S = sum(A, outtype)
S = sum(A, dim, nanflag)
S = sum(A, nanflag, dim)
S = sum(A, "like", prototype)
S = sum(A, vecdim)

Inputs

Returns

Errors

How sum works

• sum(X) on an m × n matrix returns a row vector (1 × n) with column sums.
• sum(X, 2) returns a column vector (m × 1) containing row sums.
• sum(X, dims) accepts a vector of dimensions (e.g., [1 3]) and collapses each listed axis while leaving the others untouched.
• sum(X, 'all') flattens every dimension into a single scalar sum.
• Logical inputs are promoted to double precision (true → 1.0, false → 0.0).
• sum(___, 'omitnan') ignores NaN values; if every element in the slice is NaN, the result becomes 0.
• sum(___, 'includenan') (default) propagates NaN when any element in the slice is NaN.
• sum(___, outtype) accepts 'double', 'default', or 'native' to control the output class.
• sum(___, 'like', prototype) matches the numeric class and residency of prototype when supported by the active provider.
• Empty inputs or reductions along dimensions with size 0 return zeros that follow MATLAB shape semantics.

Does RunMat run sum on the GPU?

RunMat Accelerate keeps tensors on the GPU whenever a provider is active:

1. If a tensor already resides on the device, the runtime calls the provider’s reduce_sum_dim (or reduce_sum for whole-array reductions). Successful hooks return a new GPU handle so downstream consumers stay on device. 2. Cases that require extra bookkeeping—such as 'omitnan', multi-axis reductions, or 'like'/'native' class coercions—fall back to the host implementation. The runtime gathers the data, computes the correct MATLAB result, and re-uploads it only when a 'like' prototype demands GPU residency. 3. The fusion planner keeps surrounding elementwise producers and consumers on the GPU, so manual gpuArray / gather calls are optional unless you want to force residency for interoperability with legacy MATLAB workflows.

GPU memory and residency

You usually do not need to call gpuArray yourself. The fusion planner keeps tensors on the GPU whenever the provider exposes the required kernels. To mirror MATLAB, RunMat still accepts and respects explicit gpuArray / gather usage and the 'like' option to control residency explicitly.

Examples

Summing the elements of a matrix

A = [1 2 3; 4 5 6];
colSums = sum(A);
rowSums = sum(A, 2)

Expected output:

colSums = [5 7 9];
rowSums = [6; 15]

Summing across multiple dimensions

B = reshape(1:24, [3 4 2]);
collapse = sum(B, [1 3])

Expected output:

collapse = [48 66 84 102]

Summing with NaN values ignored

values = [1 NaN 3];
total = sum(values, 'omitnan')

Expected output:

total = 4

Summing on the GPU and matching an existing prototype

proto = gpuArray.zeros(1, 1, 'single');
result = sum(gpuArray([1 2 3]), 'all', 'like', proto)

Expected output:

result =
  1x1 gpuArray  single
     6

Summing all elements of an array into a scalar

C = [1 2 3; 4 5 6];
grandTotal = sum(C, 'all')

Expected output:

grandTotal = 21

Summing with native output type

ints = int32([100 200 300]);
total = sum(ints, 'native')

Expected output:

total = int32(600)

Using sum with coding agents

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

FAQ

Related Math functions

Open-source implementation

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

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