In *|R2014b|*, the *|round|* function now supports rounding to a specific number of digits: minval = 0.4410; maxval = 0.8450; r1_minval = round(minval, 1); r1_maxval = round(maxval, 1); If you don’t have *|R2014b|*, this works: diground = @(x,d) round(x*10^d)/10^d; r2_minval = diground(minval,1); r2_maxval = diground(maxval,1);

Hi, I think you are looking for: in = [1373.698 1385.024 1394.82 1400.436 1396.532]; %round up up = floor(in) + ceil( (in-floor(in))/0.25) * 0.25 %round down down = floor(in) + floor( (in-floor(in))/0.25) * 0.25

You are probably getting that error because somehow you have created a variable called "round". What do you get if you type >> which round

Wikipedia knows:

round(X): round to nearest integer, trailing 5 rounds to the nearest integer away from zero. For example, round(2.5) returns 3; round(-2.5) returns -3.

There's a little more information on this scheme (Round half away from zero), and many others, in the article on rounding.

x=14.5613; xRound = ceil(x/10)*10;

round( x / 5 ) * 5;

>> V=148.559; >> 5*floor(V/5) ans = 145 >> 5*ceil(V/5) ans = 150

x=0.147; floor(x*100)/100

A = [pi exp(1) 1/7] Ndecimals = 2 f = 10.^Ndecimals A = round(f*A)/f

v=(4/3)*pi*r^3; >> format long g >> v v = 4188.79020478639 >> round(v*100)/100 ans = 4188.79 >>

Round-off errors demonstrates a fundamental problem with the way computers deal with fractional numbers. Some numbers (in fact, "most" of them) cannot be represented exactly in binary form -- specifically, fractional numbers that are not powers of two. This will occur in any computer program using ANSI/IEEE standard math. MATLAB uses the ANSI/IEEE Standard 754, double precision, for Binary Floating-Point Arithmetic so any non-zero number is written in the following form with "0<=f<1" and integer "e": +or- (1+f)*2^e The quantity "f" is the fraction, or less officially, the mantissa. The quantity "e" is the exponent. Both "f" and "e" must have finite expansions in base 2. The finite nature of "f" means that numbers have a limited accuracy and so arithmetic may involve roundoff error. The finite nature of "e" means that numbers have a limited range and so arithmetic may involve under-flow and overflow. As a result, you will sometimes get roundoff errors that will be noticeable, but usually not significant. For example, most of the numbers you are dealing with may be near 1.0e-01, whereas your error is around 1.0e-16. If you would like to get a closer look at the way the computer sees these numbers, try using the following command: >> format hex You will see that numbers like 1/10 have repeating digits. This demonstrates inaccuracy the same way 0.333... represents 1/3. Numbers like 1/8, however, are accurate, as indicated by the zeros in the mantissa. Most problems caused by roundoff error can be resolved by avoiding direct comparisons between numbers. For example, if you have a test for equality that fails due to roundoff error, you should instead compare the difference of the operands and check against a tolerance. Instead of: A == B try this: abs(A-B) < 1e-12*ones(size(A)) With MATLAB R2024b, a new function, “isapprox”, has been introduced to determine approximate equality. This function encapsulates the logic of defining tolerances, allowing you to specify different levels of absolute and relative tolerances to efficiently address round-off errors. The function can be called as follows:  >> isapprox(A,B) For more information on this function, you may refer to the documentation below: https://www.mathworks.com/help/matlab/ref/isapprox.html Furthermore, whenever you run any mathematical software, including MATLAB, the software does various computations. These computations are done by calling low level math libraries like *, +, and ^, not to mention sin, cos, sqrt. The math libraries are supplied with the system's compiler and are therefore system dependent. Thus, you could get different answers on an HP than on a Sun just doing multiplication, but you are unlikely to notice since it will just change one digit, if any. However, after doing a series of computations these differences add up and then you would notice a difference. As stated above, these differences are due to the underlying math libraries, compilers, architecture and how they are implemented. If you need more precision than MATLAB's standard double-precision arithmetic provides, you can use the Symbolic Math Toolbox to perform calculations symbolically in infinite precision arithmetic. However, the symbolic calculations will be slower than the standard double-precision operations, and not all functions will accept symbolic objects. For more information on the Symbolic Math Toolbox, see: https://www.mathworks.com/products/symbolic.html For more information on troubleshooting these types of problems, see the section "Avoiding Common Problems with Floating-Point Arithmetic" at the following documentation page: https://www.mathworks.com/help/matlab/matlab_prog/floating-point-numbers.html If you're interested in more information on double-precision arithmetic in MATLAB, there's an excellent Cleve's Corner article that discusses these issues. Check out the Fall 1996 MATLAB News and Notes, found at: https://www.mathworks.com/content/dam/mathworks/mathworks-dot-com/company/newsletters/news_notes/pdf/Fall96Cleve.pdf