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

"want something that will suit not only 100, but any desiried number" You can do round(val./d).*d where val is the original number(s) and d is the number(s) you want the result(s) to be a multiple of. Examples: % round 1100 to the nearest multiple of 3: val = 1100; d = 3; result = round(val./d).*d % round 102 to the nearest multiple of 7: val = 102; d = 7; result = round(val./d).*d % round 10 to the nearest multiple of 3.7: val = 10; d = 3.7; result = round(val./d).*d % round 10:10:100 to the nearest multiple of 9: val = 10:10:100; d = 9; result = round(val./d).*d % round 11 to the nearest multiple of 7, round 12 to the nearest multiple of 5, round 13 to the nearest multiple of 6: val = [11 12 13]; d = [7 5 6]; result = round(val./d).*d

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

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.

Divide by 100, then floor() or fix() (depending on how you want to handle negative numbers), then multiply by 100. x = 568; floor(x/100)*100 fix(x/100)*100 x = -568; floor(x/100)*100 fix(x/100)*100

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);

In MATLAB, round, fix, floor, and ceil are all functions used for rounding numbers, but they differ in their behavior: round: rounds to the nearest integer. If the fractional part is exactly 0.5, it rounds to the nearest even integer. For example: round(3.5) % Output: 4 round(2.3) % Output: 2 fix: simply truncates the decimal part of the number, essentially removing it and keeping only the integer part. For example: fix(3.5) % Output: 3 fix(-3.5) % Output: -3 floor: always rounds down towards the nearest integer. For example: floor(3.5) % Output: 3 floor(2.1) % Output: 2 floor(-2.1) % Output: -3 ceil: always rounds up towards the nearest integer. For example: ceil(3.5) % Output: 4 ceil(2.1) % Output: 3 ceil(-2.1) % Output: -2 for negative values, the results appear a bit different for floor and ceil as floor (-2.1) will result in -3 instead of -2 (because -3 is smaller than -2), and ceil(-2.1) will result in -2 instead of -3 (because -2 is greater than -3). In simple words, one gives you the upper conversion of the number, and the other gives you the lower conversion of the number. Hopefully that will clear your confusion...

Pass 4 into round(): >> r=rand r = 0.383306318625529 >> r4 = round(r, 4) r4 = 0.3833

Yes, there are several other ways of achieving this. I'll show you one way using the fix() function:

function [intLow , intHigh]  = boundingIntegers(num)

intLow  = fix(num) ;
intHigh = intLow + 1*sign(intLow) ;

fix() will round toward zero, regardless of the next digit value (so 1.1 and 1.9 would both be rounded to 1.

Once you have this lower value, the next higher integer is obtained by simply adding 1.

In the code the multiplication by sign(intLow) is used so this also works for negative number.

---

You could also find these two bounding integers by using the function:

• ceil - Round toward positive infinity, and/or
• floor - Round toward negative infinity

The principle would be the same, just adapt the gymnastic for dealing with negative numbers if they are part of your possible inputs.