find — Locate nonzero indices and values in MATLAB and RunMat.

find(X) returns indices of nonzero elements in X. With one output it returns 1-based linear indices; with multiple outputs it returns row/column subscripts (and optionally values). Count limits and search-direction options follow MATLAB semantics.

Syntax

idx = find(X)
idx = find(X, K)
idx = find(X, K, direction)
[row, col] = find(X)
[row, col] = find(X, K, direction)
[row, col, v] = find(X)
[row, col, v] = find(X, K, direction)

Inputs

Returns

Returned values from find depend on how many outputs the caller requests.

Errors

How find works

• find(X) scans in column-major order and returns a column vector of linear indices.
• find(X, K) limits the result to the first K matches; K = 0 yields an empty result.
• find(X, K, 'first') (default) scans from the start, while 'last' scans from the end.
• find(X, 'last') is equivalent to find(X, 1, 'last') and returns the final nonzero index.
• [row, col] = find(X) returns per-element row and column subscripts for 2-D or N-D inputs (higher dimensions are flattened into the column index, matching MATLAB semantics).
• [row, col, val] = find(X) also returns the corresponding values; complex inputs preserve their complex values.
• Logical, char, integer, and double inputs are all supported. Empty inputs return empty outputs with MATLAB-compatible shapes.

Does RunMat run find on the GPU?

When the input already resides on the GPU (i.e., a gpuArray), RunMat gathers it if the active provider does not implement a dedicated find kernel, performs the computation on the host, and then uploads the results back to the provider. This preserves residency so downstream fused kernels can continue on the device without an explicit gather. Providers may implement a custom hook in the future to run find entirely on the GPU; until then, the automatic gather/upload path maintains correctness with a small one-off cost.

GPU memory and residency

Usually you do not need to move data with gpuArray manually. If a provider backs find directly, the entire operation stays on the GPU. Otherwise, RunMat gathers once, computes on the host, and then uploads results back to the active provider so subsequent kernels remain device-resident. This means GPU pipelines continue seamlessly without additional gather/gpuArray calls from user code.

Examples

Finding linear indices of nonzero elements

A = [0 4 0; 7 0 9];
k = find(A)

Expected output:

k =
     2
     4
     6

Limiting the number of matches

A = [0 3 5 0 8];
first_two = find(A, 2)

Expected output:

first_two =
     2
     3

Locating the last nonzero element

A = [1 0 0 6 0 2];
last_index = find(A, 'last')

Expected output:

last_index =
     6

Retrieving row and column subscripts

A = [0 4 0; 7 0 9];
[rows, cols] = find(A)

Expected output:

rows =
     2
     1
     2

cols =
     1
     2
     3

Capturing values alongside indices (including complex inputs)

Z = [0 1+2i; 0 0; 3-4i 0];
[r, c, v] = find(Z)

Expected output:

r =
     1
     3

c =
     1
     1

v =
   1.0000 + 2.0000i
   3.0000 - 4.0000i

Using find with coding agents

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

FAQ

Related Array functions

Open-source implementation

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

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