Rule Statement

The rule for rounding to n significant figures is straightforward: identify the first n significant digits (non-zero digits, with leading zeros ignored) and round the number to that place value. If the digit immediately after the n-th significant digit is less than 5, truncate; if it is 5 or greater, round up. However, the handling of the digit 5 itself is subject to convention—some methods round half up, others round half to even (banker’s rounding), and some round half down. In Python, the built-in round() function uses banker’s rounding (round half to even) for binary floating-point numbers, which often surprises users.

For example, rounding 3.14159 to 3 significant figures yields 3.14, because the fourth significant digit is 1 (less than 5). Rounding 2.675 to 3 significant figures might be expected to give 2.68, but due to binary representation, round(2.675, 2) returns 2.67—a classic pitfall. To round to significant figures, one must first determine the position of the last significant digit and then apply the chosen rounding rule.

Worked Examples

Let’s explore practical Python code for rounding to a given number of significant figures. We’ll use the Decimal module for exact decimal arithmetic and a custom function for floating-point numbers.

Using the Decimal Module

The decimal module provides exact decimal representation and supports rounding modes like ROUND_HALF_UP and ROUND_HALF_EVEN. Here’s a function that rounds a float to n significant figures using Decimal:

from decimal import Decimal, getcontext

def round_sig_decimal(value, sig_figs):
    if value == 0:
        return Decimal(0)
    d = Decimal(str(value))
    # Find the exponent of the first significant digit
    exponent = d.adjusted() - sig_figs + 1
    quant = Decimal(1).scaleb(exponent)
    return d.quantize(quant, rounding=ROUND_HALF_UP)

For example, round_sig_decimal(3.14159, 3) returns Decimal('3.14'), and round_sig_decimal(2.675, 3) returns Decimal('2.68') because the decimal string representation preserves the intended value.

Using Floating-Point Arithmetic

For floating-point numbers, we can use round() after scaling. The following function works but is susceptible to binary rounding errors:

def round_sig_float(value, sig_figs):
    if value == 0:
        return 0.0
    import math
    exponent = math.floor(math.log10(abs(value))) - sig_figs + 1
    factor = 10 ** exponent
    return round(value / factor) * factor

This method often works for values with exact binary representations, but fails for others. For instance, round_sig_float(2.675, 3) returns 2.67 due to the binary representation of 2.675 as 2.6749999999999998. The Decimal approach is recommended for critical applications.

Counter-Examples

Common errors arise from misunderstanding Python’s rounding behavior and floating-point representation.

• Counter-Example 1: Using round(2.675, 2) expecting 2.68. Python returns 2.67 because 2.675 is stored as 2.6749999999999998, and the nearest representable value to the halfway point is slightly less.
• Counter-Example 2: Using round(2.5) expecting 3. Python’s banker’s rounding returns 2, because it rounds to the nearest even integer.
• Counter-Example 3: Rounding to significant figures by first rounding to a fixed number of decimal places. For example, rounding 0.0001234 to 2 significant figures by round(0.0001234, 4) gives 0.0001, which is wrong; the correct result is 0.00012.
• Counter-Example 4: Using format(value, '.2e') to round to 2 significant figures. This gives scientific notation, but the rounding is half-even as well, and the output is a string, not a numeric value.

Convention Comparison Table

Different rounding conventions are used across disciplines. The table below compares the most common methods for the digit 5.

Python’s round() uses half-even for floats, while the Decimal module allows explicit selection. Many scientific standards, such as ASTM E29, specify half-up for test data conformance, but ISO 80000-1 permits half-up or half-even depending on the context.

Standards Citation

Several international standards govern rounding and significant figures:

• ASTM E29-22 – Standard Practice for Using Significant Digits in Test Data to Determine Conformance with Specifications. Section 6.2 describes the rounding method for test data, typically rounding half up.
• ISO 80000-1:2009 – Quantities and units – Part 1: General. Clause 7.3.4 discusses rounding of numerical values, recommending that when the digit to be discarded is exactly 5, the preceding digit should be rounded to an even number (half-even) to avoid bias in statistical calculations.
• NIST SP 811 – Guide for the Use of the International System of Units (SI). Section 7.2.5 provides guidance on rounding values to a specified number of digits, aligning with ISO 80000.
• JCGM 100:2008 (GUM) – Evaluation of measurement data – Guide to the expression of uncertainty in measurement. Clause 7.2.6 recommends rounding uncertainty values to one or two significant figures, with specific rules for rounding.

When implementing rounding in Python, it is essential to know which standard applies to your field. For general scientific work, half-even is often preferred to reduce systematic error.

Common Mistakes

1. Assuming round() rounds half up. Python’s round() uses banker’s rounding, which is not taught in many introductory courses.
2. Ignoring binary floating-point representation. Values like 2.675 are not exact; always use Decimal or string conversion for critical rounding.
3. Mixing decimal places with significant figures. Rounding to 2 decimal places is not the same as rounding to 2 significant figures, especially for numbers with different magnitudes.
4. Using format() or f-strings for rounding. These produce strings and may use half-even; they are not suitable for further numeric calculations.
5. Forgetting to handle zero and negative numbers. The exponent calculation must account for zero and sign.
6. Applying rounding multiple times. Double rounding can introduce errors. Always round directly from the original value.

Practice Problems

Test your understanding with these exercises. Use the Decimal approach for accurate results.

1. Round 1234.5678 to 4 significant figures.
2. Round 0.0004567 to 2 significant figures.
3. Round -9876.5 to 3 significant figures using half-up.
4. Round 2.5 to 1 significant figure using half-even.
5. Round 100.0 to 2 significant figures.

Answers: 1. 1235, 2. 0.00046, 3. -9880, 4. 2, 5. 1.0 × 10² (or 100 with two significant figures, but ambiguous without scientific notation).

Software Behavior Note

Python’s built-in round() is not suitable for significant-figure rounding due to its banker’s rounding and binary floating-point issues. The decimal module is the recommended tool for precise rounding. Additionally, third-party libraries like numpy offer np.round() which also uses half-even. For scientific computing, consider using scipy or pandas with custom functions. The format() specifier '.*g' can round to significant figures but returns a string and uses half-even. For example, format(2.675, '.3g') returns ‘2.67’. To achieve half-up rounding, you must use Decimal with ROUND_HALF_UP. Always be aware of the underlying representation and rounding mode to avoid subtle errors.

Quick Reference Table

Here are common values rounded to 3 significant figures using different methods:

Note that for values without exact binary representation, Python’s round() may differ from decimal-based rounding.

Sources & Further Reading

For deeper understanding, consult the following resources:

• ASTM E29-22: Standard Practice for Using Significant Digits in Test Data to Determine Conformance with Specifications.
• ISO 80000-1:2009: Quantities and units – Part 1: General.
• NIST SP 811: Guide for the Use of the International System of Units (SI).
• JCGM 100:2008: Evaluation of measurement data – Guide to the expression of uncertainty in measurement (GUM).
• Python documentation on decimal module and floating-point arithmetic.

This article is part of our comprehensive precision and rounding reference. Explore related topics like Banker’s Rounding, Significant Figures in Scientific Notation, and Rounding vs Significant Figures.

The post Rounding to Significant Figures in Python: Precision, Pitfalls, and Best Practices appeared first on SignificantFiguresCalculator.