floor — Round values toward negative infinity in MATLAB and RunMat.
floor(X) rounds each element of X toward negative infinity, returning the greatest integer less than or equal to each input value. Optional forms support decimal-place and significant-digit rounding, with 'like' residency/type behavior following MATLAB semantics.
Syntax
Y = floor(X)
Y = floor(X, N)
Y = floor(X, N, mode)
Y = floor(X, "like", prototype)Inputs
| Name | Type | Required | Default | Description |
|---|---|---|---|---|
X | Any | Yes | — | Numeric, logical, char, or complex input. |
N | NumericScalar | No | 0 | Digits for decimal-place rounding. |
N | NumericScalar | Yes | — | Digits argument. |
mode | StringScalar | Yes | "decimals" | Rounding mode ('decimals' or 'significant'). |
likeKeyword | StringScalar | Yes | "like" | Output-template keyword. |
prototype | LikePrototype | Yes | — | Output prototype (numeric or gpuArray). |
Returns
| Name | Type | Description |
|---|---|---|
Y | NumericArray | Rounded output values. |
Errors
| Identifier | When | Message |
|---|---|---|
RunMat:floor:InvalidInput | Input cannot be interpreted as numeric, logical, char, or complex data. | floor: invalid input |
RunMat:floor:InvalidArgument | Argument count does not match supported floor invocation forms. | floor: invalid argument |
RunMat:floor:InvalidDigits | N is not an integer scalar or violates significant-digit constraints. | floor: invalid digits argument |
RunMat:floor:InvalidMode | mode is not a supported text token. | floor: invalid mode |
RunMat:floor:InvalidLike | like/prototype arguments are invalid or unsupported. | floor: invalid like prototype |
RunMat:floor:Internal | Internal tensor conversion/allocation/provider interaction failed. | floor: internal error |
How floor works
- Works on scalars, vectors, matrices, and higher-dimensional tensors with MATLAB broadcasting semantics.
floor(X, N)rounds toward negative infinity withNdecimal digits (positiveN) or powers of ten (negativeN).floor(X, N, 'significant')rounds toNsignificant digits;Nmust 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', prototypeforces the result to match the residency ofprototype(CPU or GPU). Currently prototypes must be numeric.
Does RunMat run floor 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]Using floor with coding agents
Open a RunMat example with live inputs, then ask the agent to explain how floor changes the result.
Run a small floor example, explain the result, then change one input and compare the output.
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 Math functions
Elementwise
abs · angle · complex · conj · double · exp · expm1 · factorial · gamma · hypot · imag · ldivide · log · log10 · log1p · log2 · minus · nextpow2 · plus · pow2 · power · rdivide · real · sign · single · sqrt · times
Trigonometry
acos · acosh · asin · asinh · atan · atan2 · atanh · cos · cosd · cosh · deg2rad · rad2deg · sin · sind · sinh · tan · tand · tanh
Reduction
all · any · cummax · cummin · cumprod · cumsum · cumtrapz · diff · gradient · max · mean · median · min · nnz · prod · std · sum · trapz · var
Structure
Open-source implementation
Unlike proprietary runtimes, every RunMat function is open-source. Read exactly how floor is executed, line by line, in Rust.
- View the source for floor 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.