Python四舍五入问题需要将每一位数字四舍五入

Question

I am not sure if anyone has any bright ideas about scenarios like the following:

import math
from decimal import *

def apply_precision_scale(value, precision, scale):
    # supported formats:
    # time: precision: 7, scale 4
    # amplitude: precision: 7, scale: 5
    getcontext().rounding = ROUND_HALF_UP
    
    value_int = math.trunc(value)
    rounded_input = None

    # supports negative numbers
    if precision == 7 and scale == 5:
        if (value_int >= 0 and value_int <= 99) or \
           (value_int >= -99 and value_int < 0):
             places = scale
        elif (value_int >= 100 and value_int <= 999) or \
             (value_int <= -100 and value_int >= -999):
             places = scale - 1
        elif (value_int >= 1000 and value_int <= 9999) or \
             (value_int >= -1000 and value_int >= -9999):
             places = scale - 2
        elif (value_int >= 10000 and value_int <= 99999) or \
             (value_int >= -10000 and value_int >= -99999):
             places = scale - 3          
        elif (value_int >= 100000 and value_int <= 999999) or \
             (value_int >= -100000 and value_int >= -999999):
             places = scale - 4           
        elif (value_int >= 1000000 and value_int <= 9999999) or \
             (value_int >= -1000000 and value_int >= -9999999):
             places = scale - 5
        else:
            print("Error: The value exceeds allowed precision")
            return None
    elif precision == 7 and scale == 4:
        if (value_int >= 0 and value_int <= 999) or \
           (value_int <= -100 and value_int >= -999):
             places = scale
        elif (value_int >= 1000 and value_int <= 9999) or \
             (value_int >= -1000 and value_int >= -9999):            
             places = scale - 1
        elif (value_int >= 10000 and value_int <= 99999) or \
             (value_int >= -10000 and value_int >= -99999):
             places = scale - 2
        elif (value_int >= 100000 and value_int <= 999999) or \
             (value_int >= -100000 and value_int >= -999999):
             places = scale - 3
        elif (value_int >= 1000000 and value_int <= 9999999) or \
             (value_int >= -1000000 and value_int >= -9999999):
             places = scale - 4
        else:
            print("Error: The value exceeds allowed precision")
            return None
    else:
        print("Error: Unrecognized precision and scale format")
        return None

    return float(round(Decimal(value), places))

def verify_time_increments(voltages):
    i = 2
    failures = 0
    keys = list(voltages)
    increment = 0.001953125
    increment_list = [(apply_precision_scale(increment * i, 7, 4)) for i in range(len(keys) + 1) if i != 0]
    
    for index, time in enumerate(voltages):
        try:
            expected_time = increment_list[index]
            i += 1
        except IndexError: # mismatch between number of voltages and values in increment list
            print(index)
            print(len(increment_list))

The data comes in the following format and continues until the time data points end:

Voltages is a dictionary in the following format [0.002:-34.54, 0.0039:-35.65, etc]

For some reason I am getting errors on large numbers like this: Expected: 64.0605 Actual: 64.0606 Expected: 64.123 Actual: 64.1231

In the first example, the value I am dealing with is 64.060546875 and the second case is 64.123046785. I am trying to cut them down to 4 significant digits but to round every digit up, meaning 46875 portion would be rounded to 50000, so 64.060546875 would be rounded to 64.0606.

Sample input file: https://controlc.com/d4a3d3ba

Answer 1

if anyone has any bright ideas

How about this one? Mathematically, you're actually doing the wrong thing, trying to round individual digits well past the rounding point.

There's a reason why rounding only checks the digit immediately after the last one you want in the answer.

The idea is to minimise the error, and choose the closest value based on how many digits you want. The closest four-decimal-place value to 64.060546875 is 64.0605 , as shown in the following table:

Value:   64.050546875   64.050546875
Round:   64.0505        64.0506
Error:    0.000046875    0.000053125

Hence the 64.0505 rounded value is a better approximation to the actual value.

Answer 2

I guess nobody understood that I was trying to do a ROUND_UP instead of ROUND_HALF_UP. This would have fixed my issue.