setdiff — Return values that appear in the first input but not the second, matching MATLAB ordering rules.

setdiff(A, B) returns the set of values (or rows) that appear in A but not in B. Results are unique, and the function can operate in sorted or stable order as well as row mode.

How setdiff works in RunMat

• setdiff(A, B) flattens inputs column-major, removes duplicates, subtracts the values of B from A, and returns the remaining elements **sorted** ascending by default.
• [C, IA] = setdiff(A, B) also returns indices so that C = A(IA).
• setdiff(A, B, 'stable') preserves the first appearance order from A instead of sorting.
• setdiff(A, B, 'rows') treats each row as an element. Inputs must share the same number of columns.
• Character arrays, string arrays, logical arrays, numeric types, and complex values are all supported.
• Legacy flags ('legacy', 'R2012a') are not supported; RunMat always follows modern MATLAB semantics.

How setdiff runs on the GPU

setdiff is registered as a residency sink. When tensors reside on the GPU and the active provider does not yet implement a setdiff hook, RunMat gathers them to host memory, performs the CPU implementation, and materialises host-resident results. Future providers can wire a custom hook to perform the set difference directly on-device without affecting existing callers.

Examples

Finding values exclusive to the first numeric vector

A = [5 7 5 1];
B = [7 1 3];
[C, IA] = setdiff(A, B)

Expected output:

C =
     5
IA =
     1

Preserving input order with 'stable'

A = [4 2 4 1 3];
B = [3 4 5 1];
[C, IA] = setdiff(A, B, 'stable')

Expected output:

C =
     2
IA =
     2

Working with rows of numeric matrices

A = [1 2; 3 4; 1 2];
B = [3 4; 5 6];
[C, IA] = setdiff(A, B, 'rows')

Expected output:

C =
     1     2
IA =
     1

Computing set difference for character data

A = ['m','z'; 'm','a'];
B = ['a','x'; 'm','a'];
[C, IA] = setdiff(A, B)

Expected output:

C =
    m
IA =
     1

Subtracting string arrays by row

A = ["alpha" "beta"; "gamma" "beta"];
B = ["gamma" "beta"; "delta" "beta"];
[C, IA] = setdiff(A, B, 'rows', 'stable')

Expected output:

C =
  1x2 string array
    "alpha"    "beta"
IA =
     1

Using setdiff with GPU arrays

G = gpuArray([10 4 6 4]);
H = gpuArray([6 4 2]);
C = setdiff(G, H)

Expected output:

C =
    10

FAQ

What ordering does setdiff use by default?

Results are sorted ascending. Specify 'stable' to preserve the first appearance order from the first input.

How are the index outputs defined?

IA points to the positions in A that correspond to each element (or row) returned in C, using MATLAB's one-based indexing.

Can I combine 'rows' with 'stable'?

Yes. 'rows' can be paired with either 'sorted' (default) or 'stable'. Other option combinations that conflict (e.g. 'sorted' with 'stable') are rejected.

Does setdiff remove NaN values from A when they exist in B?

Yes. NaN values are considered equal. If B contains NaN, all NaN entries from A are removed.

Are complex numbers supported?

Absolutely. Complex values use MATLAB's ordering rules (magnitude, then real part, then imaginary part) for the sorted output.

Does GPU execution change the results?

No. Until providers supply a device implementation, RunMat gathers GPU inputs and executes the CPU path to guarantee MATLAB-compatible behaviour.

What happens if the inputs have different classes?

RunMat follows MATLAB's rules: both inputs must share the same class (numeric/logical, complex, char, or string). Mixed-class inputs raise descriptive errors.

Can I request 'legacy' behaviour?

No. RunMat implements the modern semantics only. Passing 'legacy' or 'R2012a' results in an error.

Related functions to explore

These functions work well alongside setdiff. Each page has runnable examples you can try in the browser.

unique, union, intersect, ismember, gpuArray, gather, argsort, issorted, sort, sortrows

Open-source implementation

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

• View setdiff.rs on GitHub
• Learn how the 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 — faster, on any GPU, with no license required.

• Simulations that took hours now take minutes. RunMat automatically optimizes your math for GPU execution on Apple, Nvidia, and AMD hardware. No code changes needed.
• Start running code in seconds. Open the browser sandbox or download a single binary. No license server, no IT ticket, no setup.
• A full development environment. GPU-accelerated 2D and 3D plotting, automatic versioning on every save, and a browser IDE you can share with a link.

Getting started · Benchmarks · Pricing