Skip to main content

How to Round a Number in Batch Script

A common mathematical need is to round a number to the nearest whole integer. However, this presents a significant challenge in batch scripting because its only built-in math engine, SET /A, is strictly integer-only. It does not support decimals and, when it performs division, it truncates (chops off the decimal part) rather than rounding.

This guide will teach you the clever mathematical trick used to simulate rounding for integer division in a pure batch script. It will also cover the far more powerful and flexible modern method of using PowerShell for rounding true decimal numbers, which is the recommended approach for any non-trivial calculation.

The Core Problem: SET /A Truncates, It Doesn't Round​

The fundamental issue is that SET /A discards fractional results entirely.

  • 10 / 3 should be 3.33..., which rounds to 3.
  • 11 / 3 should be 3.66..., which rounds to 4.

Let's see what SET /A actually does:

@ECHO OFF
SET /A "Result1 = 10 / 3"
SET /A "Result2 = 11 / 3"

ECHO 10 / 3 truncates to: %Result1%
ECHO 11 / 3 truncates to: %Result2%

Output:

10 / 3 truncates to: 3
11 / 3 truncates to: 3

In both cases, the result is 3. The second calculation is mathematically incorrect for rounding.

The Pure Batch Method: The Integer Rounding Trick​

To simulate rounding with integer math, we can use a clever formula that adds half of the denominator to the numerator before the division occurs. This effectively pushes any result with a remainder of 0.5 or greater up to the next whole number before the truncation happens.

The Formula: SET /A "Result = (Numerator + (Denominator / 2)) / Denominator"

This works reliably for positive integers.

The Script (Pure Batch): Simulating Rounding​

This script uses the integer trick to correctly round the results of our previous examples.

@ECHO OFF
SET "Numerator1=10"
SET "Numerator2=11"
SET "Denominator=3"

ECHO --- Simulating Rounding for Integer Division ---
ECHO.

REM --- Test Case 1: 10 / 3 (should round down to 3) ---
SET /A "Rounded1 = (%Numerator1% + (%Denominator% / 2)) / %Denominator%"
ECHO 10 / 3 rounds to: %Rounded1%

REM --- Test Case 2: 11 / 3 (should round up to 4) ---
SET /A "Rounded2 = (%Numerator2% + (%Denominator% / 2)) / %Denominator%"
ECHO 11 / 3 rounds to: %Rounded2%

Output:

--- Simulating Rounding for Integer Division ---

10 / 3 rounds to: 3
11 / 3 rounds to: 4

The results are now correctly rounded.

How the Integer Trick Works​

Let's trace the second calculation: (11 + (3 / 2)) / 3

  1. The inner parentheses are calculated first: 3 / 2. In integer math, this truncates to 1.
  2. The formula becomes: (11 + 1) / 3.
  3. The addition is performed: 12 / 3.
  4. The final division is performed: 12 / 3 = 4.

This works because adding half the denominator effectively implements the "add 0.5 and truncate" rule of rounding.

The integer trick is clever, but it's limited. It can't round a number that is already a decimal (e.g., 98.6). For this, you must use a more powerful tool. The best built-in solution is PowerShell, which has a proper math library.

Syntax: powershell -Command "[math]::Round(your-number-here)"

For example, this script correctly rounds a decimal value stored in a batch variable.

@ECHO OFF
SET "DecimalValue=98.6"
SET "RoundedValue="

FOR /F %%R IN (
    'powershell -Command "[math]::Round(%DecimalValue%)"'
) DO (
    SET "RoundedValue=%%R"
)

ECHO The number %DecimalValue% rounds to: %RoundedValue%

Output:

The number 98.6 rounds to: 99
note

This method is simpler, more readable, and works for all number types. It is the recommended approach for any serious rounding task.

Common Pitfalls and How to Solve Them​

  • Division by Zero: The pure batch method will crash with a "Divide by zero error" if the Denominator is 0. Solution: Always check your denominator with an IF statement before performing the calculation.
  • Negative Numbers: The pure batch integer trick does not work correctly for negative numbers. It effectively rounds them towards zero (e.g., -2.66 becomes -2), which is mathematically incorrect. Solution: For any math involving negative numbers, you must use the PowerShell method.
  • Performance: For a huge number of calculations in a loop, repeatedly calling PowerShell can have a small performance overhead. However, for most scripts, the reliability and correctness are far more important.

Practical Example: Calculating Average File Size​

This script scans a folder, counts the files, gets their total size, and then uses the integer rounding trick to calculate the average file size.

@ECHO OFF
SETLOCAL ENABLEDELAYEDEXPANSION

SET "TARGET_FOLDER=C:\Windows\System32"
SET "TotalSize=0"
SET "FileCount=0"

ECHO --- Calculating Average File Size in "%TARGET_FOLDER%" ---
ECHO This may take a moment...

FOR /F "delims=" %%F IN ('DIR "%TARGET_FOLDER%" /S /A-D /B 2^>NUL') DO (
    SET /A "FileCount+=1"
    SET /A "TotalSize+=%%~zF"
)

IF %FileCount% EQU 0 (
    ECHO No files found.
) ELSE (
    REM --- Use the integer rounding trick for the average ---
    SET /A "AverageSize = (!TotalSize! + (!FileCount! / 2)) / !FileCount!"
    
    ECHO Total Files: !FileCount!
    ECHO Total Size: !TotalSize! bytes
    ECHO Rounded Average Size: !AverageSize! bytes
)

ENDLOCAL

Conclusion​

Rounding in batch script requires you to choose the right tool for the job based on the type of numbers you are working with.

  • For rounding the result of an integer division of positive numbers, the pure-batch formula Result = (Num + (Den / 2)) / Den is a clever and effective trick.
  • For all other cases, especially when dealing with decimal numbers or negative numbers, the PowerShell [math]::Round() method is the superior and only recommended solution. It is more powerful, more accurate, and less prone to edge-case errors.

Table of Contents