floor — Round scalars, vectors, matrices, or N-D tensors toward negative infinity or to specified digits.

floor(X) rounds each element of X toward negative infinity, returning the greatest integer less than or equal to the input. Optional arguments match MATLAB's extended syntax for rounding to fixed decimal places, significant digits, and prototype-based residency.

How floor works in RunMat

• Works on scalars, vectors, matrices, and higher-dimensional tensors with MATLAB broadcasting semantics.
• floor(X, N) rounds toward negative infinity with N decimal digits (positive N) or powers of ten (negative N).
• floor(X, N, 'significant') rounds to N significant digits; N must be a positive integer.
• Logical inputs are promoted to doubles (false → 0, true → 1) before flooring.
• Character arrays are interpreted numerically (their Unicode code points) and return dense double tensors.
• Complex inputs are floored component-wise: floor(a + bi) = floor(a) + i·floor(b).
• Non-finite values (NaN, Inf, -Inf) propagate unchanged.
• Empty arrays return empty arrays of the appropriate shape.
• Appending 'like', prototype forces the result to match the residency of prototype (CPU or GPU). Currently prototypes must be numeric.

How floor runs on the GPU

When tensors already reside on the GPU, RunMat consults the active acceleration provider. If the provider implements the unary_floor hook, floor(X) executes entirely on the device and keeps tensors resident. When decimal or significant-digit rounding is requested—or when the provider lacks unary_floor—RunMat gathers the tensor to host memory, applies the CPU implementation, and honours any 'like' GPU prototype by uploading the result back to the device. This keeps semantics consistent even when specialised kernels are unavailable.

GPU memory and residency

A = [1.8 -0.2; 2.7 3.4];
proto = gpuArray(0);
G = floor(A, 'like', proto);   % Result remains on the GPU
result = gather(G);

Expected output:

result =
    [ 1 -1;
      2  3]

Examples

Flooring positive and negative scalars

x = [-2.7, -0.3, 0, 0.8, 3.9];
y = floor(x)

Expected output:

y = [-3, -1, 0, 0, 3]

Flooring every element of a matrix

A = [1.2 4.7; -3.4 5.0];
B = floor(A)

Expected output:

B = [1 4; -4 5]

Flooring fractions stored in a tensor

t = reshape([-1.8, -0.2, 0.4, 1.9, 2.1, 3.6], [3, 2]);
floored = floor(t)

Expected output:

floored =
    [-2  1;
     -1  2;
      0  3]

Flooring values to a fixed number of decimal places

temps = [21.456 19.995 22.501];
floored = floor(temps, 2)

Expected output:

floored = [21.45 19.99 22.50]

Flooring to significant digits

measurements = [0.001234 12.3456 98765];
sig2 = floor(measurements, 2, 'significant')

Expected output:

sig2 = [0.0012 12.0 98000]

Flooring complex numbers component-wise

z = [1.7 + 2.1i, -0.2 - 3.9i];
result = floor(z)

Expected output:

result = [1 + 2i, -1 - 4i]

Keeping GPU data on device when the provider supports unary_floor

G = gpuArray([1.8 -0.2 0.0; -1.1 2.5 -3.4]);
floored = floor(G);
H = gather(floored)

Expected output:

H =
    [ 1 -1  0;
     -2  2 -4]

Forcing GPU residency with a 'like' prototype

A = [1.8 -0.2; 2.7 3.4];
proto = gpuArray(0);
G = floor(A, 'like', proto);   % Result remains on the GPU
result = gather(G)

Expected output:

result =
    [ 1 -1;
      2  3]

FAQ

Does floor always round toward negative infinity?

Yes—positive values round down toward zero, while negative values round to the more negative integer (e.g., floor(-0.1) = -1).

How are complex numbers handled?

The real and imaginary parts are floored independently, matching MATLAB's component-wise definition.

Can I round to decimal digits or significant digits?

Yes. Use floor(X, N) for decimal digits or floor(X, N, 'significant') for significant digits. Negative N values round to powers of ten.

What happens with logical arrays?

Logical values promote to doubles (0 or 1) before flooring, so the outputs remain 0 or 1.

Can I pass character arrays to floor?

Yes. Character data is treated as its numeric code points, producing a double tensor of the same size.

Do NaN and Inf values change?

No. Non-finite inputs propagate unchanged.

Will GPU execution change floating-point results?

No. Providers implement IEEE-compliant flooring; when a provider lacks unary_floor, RunMat falls back to the CPU to preserve MATLAB-compatible behaviour.

Does 'like' work with floor?

Yes. Append 'like', prototype to request output that matches the prototype's residency. Currently prototypes must be numeric (scalars or dense tensors, host or GPU).

Can fusion keep floor on the GPU?

Yes. floor participates in elementwise fusion, so fused graphs can stay resident on the device when supported.

What does floor do in MATLAB?

floor(X) rounds each element of X toward negative infinity. For example, floor(2.7) returns 2 and floor(-2.3) returns -3.

What is the difference between floor and fix in MATLAB?

floor rounds toward negative infinity, while fix rounds toward zero. For positive numbers the result is the same, but for negative numbers they differ: floor(-2.7) returns -3, while fix(-2.7) returns -2.

Does floor work with GPU arrays in RunMat?

Yes. RunMat automatically accelerates floor on the GPU with elementwise fusion support. Supported precisions include f32 and f64 with MATLAB-compatible broadcasting.

Related functions to explore

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

ceil, round, fix, gpuArray, gather, mod, rem

Open-source implementation

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

• View floor.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