RunMat
GitHub

View all functions

CategoryMath: Reduction
GPUYes

What does the prod function do in MATLAB / RunMat?

prod(X) multiplies the elements of scalars, vectors, matrices, and higher-dimensional tensors. When no dimension is supplied, the reduction runs along the first non-singleton dimension.

How does the prod function behave in MATLAB / RunMat?

  • prod(X) on an m × n matrix returns a row vector (1 × n) with column-wise products.
  • prod(X, 2) returns a column vector (m × 1) containing row-wise products.
  • prod(X, dims) accepts a vector of dimensions (for example [1 3]) and collapses each listed axis while leaving the others untouched.
  • prod(X, 'all') flattens every dimension into a single scalar product.
  • Logical inputs are promoted to double precision (true → 1.0, false → 0.0) unless you request 'native' or 'like' output classes.
  • prod(___, 'omitnan') ignores NaN values; if every element in the slice is NaN, the result becomes 1, the multiplicative identity.
  • prod(___, 'includenan') (default) propagates NaN whenever a NaN appears in that slice.
  • prod(___, outtype) accepts 'double', 'default', or 'native' to control the output class.
  • prod(___, '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 ones that follow MATLAB shape semantics.

prod Function GPU Execution Behaviour

When RunMat Accelerate is active, tensors that already reside on the GPU remain on the device. The runtime calls reduce_prod_dim (or reduce_prod for whole-array products) on the active provider when available. Requests that require 'omitnan', multi-axis reductions, or class coercions fall back to the host implementation, compute the correct MATLAB result, and re-upload only when a 'like' prototype demands GPU residency.

Examples of using the prod function in MATLAB / RunMat

Multiplying the elements of a matrix

A = [1 2 3; 4 5 6];
colProd = prod(A);
rowProd = prod(A, 2);

Expected output:

colProd = [4 10 18];
rowProd = [6; 120];

Multiplying across multiple dimensions

B = reshape(1:24, [3 4 2]);
prod13 = prod(B, [1 3]);

Expected output:

prod13 =
     16380   587520  4021920  16030080

Multiplying with NaN values ignored

values = [2 NaN 4];
cleanProd = prod(values, 'omitnan');

Expected output:

cleanProd = 8;

Multiplying on the GPU and matching an existing prototype

G = gpuArray(ones(1024, 1024) + 0.01);
proto = gpuArray(zeros(1, 1));
gpuResult = prod(G, 'like', proto);
result = gather(gpuResult);

The planner keeps residency on the GPU when provider hooks are available. Otherwise, RunMat gathers the tensor to the host, computes the product, and re-uploads to honour the 'like' request.

Multiplying all elements of an array into a scalar

P = prod(1:10, 'all');

Expected output:

P = 3628800;

Multiplying with native output type

ints = int16([2 3 4]);
nativeProd = prod(ints, 'native');

Expected output:

nativeProd = int16(24);

GPU residency in RunMat (Do I need gpuArray?)

You usually do not need to call gpuArray yourself in RunMat. The fusion planner keeps residency on the GPU for fused expressions, and reduction kernels execute on the device whenever the provider exposes the necessary hooks. To match MathWorks MATLAB behaviour—or to bootstrap GPU residency explicitly—you can still create GPU arrays manually.

FAQ

When should I use the prod function?

Use prod whenever you need multiplicative reductions: geometric means, determinant-like products, or scaling chains of factors.

Does prod produce double arrays by default?

Yes. Unless you request 'native' or provide a 'like' prototype, the result is a dense double-precision array on the host.

What does prod(A) return?

If you call prod(A) where A is an array, the result is a new array of the same shape as A with products taken along the first non-singleton dimension.

How do I compute the product of a specific dimension?

Pass the dimension as the second argument (prod(A, 2) for row-wise products) or provide a dimension vector (prod(A, [1 3])) to collapse multiple axes at once.

What happens if all elements are NaN and I request 'omitnan'?

The result becomes 1, matching MATLAB's multiplicative identity semantics for empty slices.

Does prod preserve integer classes?

Only when you explicitly request 'native' or 'like'. Otherwise, integers are promoted to double precision so you do not have to manage overflow manually.

See Also

sum, mean, cumprod, gpuArray, gather

Source & Feedback