(diff) ← Older revision | Latest revision (diff) | Newer revision → (diff)

 Round () `round ()` Category Operator Type Reporter

The Round () block is an Operators block and a Reporter block. The block rounds the given number to the nearest integer. It follows the standard rules of rounding; decimals that are .5 or higher are rounded up, whereas decimals less than .5 are rounded down.

## Example Uses

In projects that handle decimal numbers, they may have to be rounded—this block will do the job.

Some common uses for the Round () block are below:

• Calculators that will let users round numbers
```define calculate
set [answer v] to ((value1) + (value2))
end
if <(operator) = [round]> then
set [answer v] to (round (value))
end
...

when this sprite clicked //calculator equivalent to the "=" button
calculate
```
• Checking if numbers are approximately equal to each other
```set [close? v] to <([abs v] of ((round (value1)) - (round (value2)))) < (2)> //one of many methods
```
• Rounding a score to the nearest whole number in games
`set [score v] to (round (score))`
• Removing the decimal from a score, without rounding up
`set [score v] to (round ((score) - (0.5)))//any number minus 0.5 will round to the lower integer`
• Rounding the value to be put in the Repeat () block, since the value must be a whole number
```repeat (round (2.3840462816))
...
end
```
```when gf clicked
forever
go to x: ((round ((mouse x) / (25))) * (25)) y: ((round ((mouse y) / (25))) * (25))
```

## Workaround

Main article: List of Block Workarounds

One can use the "Ceil" and "Floor" operations in Scratch 2.0 to accurately round a number:

```([floor v] of ((number) + (0.5))) //round a number
```

The mathematical functions "floor" and "ceiling" can also be replicated using modular arithmetic:

```((number) - ((number) mod (1))) //round down (floor)
((number) + ((1) - ((number) mod (1)))) //round up (ceiling)
```

or

```if <(n) > (0)> then
set [rounded v] to (((n) + (0.5)) - (((n) + (0.5)) mod (1)))
else
set [rounded v] to ((((n) - (0.5)) - (((n) - (0.5)) mod (1))) + (1))
end
```

Another way to replicate the block is to use the letter () of () and join () () operator blocks.

```set [report v] to [ ]
set [count v] to 
repeat until <<(letter (count) of (num)) = [.]> or <(count) = (length of (num))>>
set [report v] to (join (report) (letter (count) of (num)))
change [count v] by (1)
end
if <<(letter (count) of (num)) = [.]> and <(letter ((count) + (1)) of (num)) > >> then
change [report v] by (1)
end
```

## Suggestions

Some Scratchers want a reporter block which rounds to a certain number-place. The block would make all of the above uses more accurate. It would look like this:

`(round (number) to the nearest (base) ::operators)`

It can be replicated by shifting the number over (multiplying or dividing by 10), rounding, and then reversing the original operation.

`((round ((number) * ([10^ v] of (number of places):: operators))) / ([10^ v] of (number of places):: operators))`

or even this:

`((round ((round what) / (to the nearest))) * (to the nearest))`

Some Scratchers have suggested to update the (round ()) block as a function. It would look like this:

`([round v] of ():: operators)`