round — Round values to nearest integers, decimal places, or significant digits with MATLAB-compatible modes.
round(X) rounds numeric values to the nearest integers using MATLAB-compatible half-away-from-zero behavior. Additional forms support rounding to decimal places or significant digits.
Syntax
Y = round(X)
Y = round(X, N)
Y = round(X, N, mode)Inputs
| Name | Type | Required | Default | Description |
|---|---|---|---|---|
X | Any | Yes | — | Numeric, logical, or complex input values. |
N | NumericScalar | No | 0 | Digits for decimal-place rounding. |
N | NumericScalar | Yes | — | Digits argument. |
mode | StringScalar | Yes | "decimals" | Rounding mode ('decimals' or 'significant'). |
Returns
| Name | Type | Description |
|---|---|---|
Y | NumericArray | Rounded output values. |
Errors
| Identifier | When | Message |
|---|---|---|
RunMat:round:InvalidInput | Input X cannot be interpreted as numeric/logical/complex data. | round: invalid input |
RunMat:round:InvalidArgument | Argument count does not match supported call forms. | round: invalid argument |
RunMat:round:InvalidDigits | N is not an integer scalar or violates mode constraints. | round: invalid digits argument |
RunMat:round:InvalidMode | mode is not a supported text token. | round: invalid mode |
RunMat:round:Internal | Internal tensor conversion/allocation failed. | round: internal error |
How round works
round(X)rounds each element ofXto the nearest integer; ties (e.g.,±0.5) round away from zero.round(X, N)rounds toNdecimal digits whenNis positive and to powers of ten whenNis negative.round(X, N, 'significant')rounds toNsignificant digits.Nmust be a positive integer.- Logical inputs are promoted to double before rounding;
round(true)returns1. - Complex inputs are rounded component-wise (
round(a + bi) = round(a) + i·round(b)), matching MATLAB. - Non-finite values (
NaN,Inf,-Inf) propagate unchanged regardless of precision arguments. - Character arrays are treated as their numeric code points and return double tensors of the same size.
Does RunMat run round on the GPU?
When a tensor already resides on the GPU, RunMat checks whether the active acceleration provider implements a specialised unary_round kernel. If available, round(X) executes entirely on the device. Advanced modes (round(X, N) and round(X, N, 'significant')) currently gather tensors to the host before rounding to keep semantics aligned with MATLAB. Providers that add digit-aware kernels can extend this path in the future.
GPU memory and residency
You usually do not need to call gpuArray manually. RunMat's planner keeps tensors on the GPU when the provider exposes the required kernels and it is profitable to do so. round takes advantage of this mechanism for the plain round(X) form. When you specify digits or the 'significant' option, RunMat currently gathers data to the host to match MATLAB exactly. Future providers can extend unary_round or add digit-aware kernels to keep those workloads on the device.
Examples
Rounding values to the nearest integers
X = [-3.5 -2.2 -0.5 0 0.5 1.7];
Y = round(X)Expected output:
Y = [-4 -2 -1 0 1 2]Rounding to a fixed number of decimal places
temps = [21.456 19.995 22.501];
rounded = round(temps, 2)Expected output:
rounded = [21.46 20.00 22.50]Rounding to negative powers of ten
counts = [1234 5678 91011];
rounded = round(counts, -2)Expected output:
rounded = [1200 5700 91000]Rounding to significant digits
measurements = [0.001234 12.3456 98765];
sig3 = round(measurements, 3, 'significant')Expected output:
sig3 = [0.00123 12.3 98800]Rounding GPU tensors and gathering the results
G = gpuArray(linspace(-2.5, 2.5, 6));
rounded = round(G);
hostValues = gather(rounded)Expected output:
hostValues = [-3 -2 -1 1 2 3]Using round with coding agents
Open a RunMat example with live inputs, then ask the agent to explain how round changes the result.
Run a small round example, explain the result, then change one input and compare the output.
FAQ
Does round always round half values away from zero?⌄
Yes. MATLAB and RunMat both use half-away-from-zero semantics, so round(0.5) returns 1 and round(-0.5) returns -1.
Can I round to decimal places and significant digits?⌄
Yes. Use round(X, N) for decimal places and round(X, N, 'significant') for significant digits. Negative N values round to tens, hundreds, and so on.
What happens if I pass a non-integer N?⌄
N must be an integer scalar. RunMat raises a MATLAB-compatible error when N is not an integer or is non-finite.
How are complex numbers handled?⌄
RunMat rounds the real and imaginary components independently, matching MATLAB's component-wise behaviour.
Do NaN or Inf values change when rounded?⌄
No. Non-finite values propagate unchanged for every rounding mode, just like MATLAB.
Will rounding stay on the GPU?⌄
round(X) stays on the GPU when the provider implements unary_round. Rounding with digit arguments currently gathers to the host; providers can override this by adding specialised kernels.
Can I round logical or character arrays?⌄
Yes. Logical values are converted to doubles (0 or 1) and characters are rounded as their numeric code points, returning dense double tensors.
What does round do in MATLAB?⌄
round(X) rounds each element of X to the nearest integer. round(X, N) rounds to N decimal places. Ties (e.g., 2.5) round away from zero.
What is the difference between round, floor, and ceil in MATLAB?⌄
round rounds to the nearest integer, floor rounds toward negative infinity, and ceil rounds toward positive infinity. For 2.5: round returns 3, floor returns 2, ceil returns 3.
Does round support GPU acceleration in RunMat?⌄
Yes. round runs on the GPU with elementwise fusion support. It accepts f32 and f64 precisions and supports MATLAB-compatible broadcasting.
Does MATLAB's round use banker's rounding?⌄
— No. MATLAB (and RunMat) round halves *away from zero*, not to even. So round(0.5) returns 1, round(-0.5) returns -1, round(2.5) returns 3, and round(3.5) returns 4. This differs from Python's built-in round and IEEE 754 default rounding, which both use banker's rounding (round-half-to-even). NumPy's np.round also uses banker's rounding, so ported code may give different results on .5 cases — use round(x) in MATLAB/RunMat when you specifically want half-away-from-zero.
How do I round to N decimal places?⌄
— Use round(X, N). Positive N rounds to digits to the right of the decimal point; negative N rounds to digits to the left. For example, round(pi, 3) returns 3.1416 and round(12345, -3) returns 12000. Use round(X, N, 'significant') when you want N significant digits instead of decimal places.
Related Math functions
Elementwise
abs · angle · complex · conj · double · exp · expm1 · factorial · gamma · heaviside · 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 round is executed, line by line, in Rust.
- View the source for round 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.