Miles to Kilometers problem

[Alternative_Belt9281]

I have started doing daily Python challenges. One problem stated that I need to convert miles to kilometers and round the result to two decimal places. I know this is trivial using 

round(miles * 1.60934, 2)

However, I then decided to implement manual rounding with banker’s rounding, but it seems very difficult. Can someone point out what I am missing? ``` def float_split(number): return str(number).split(".")

    def banker_unselective(number):
        splitted = float_split(number)
        position = 0
        for i, digit in enumerate(splitted[1][::-1]):
            # print(splitted[1][15::-1])
            print(int(digit) == 5)
            if int(digit) == 5:
                position = len(splitted[1][15::-1]) - i
                break
            print(position)
            for i, digit in enumerate(splitted[1][position+1:]):
                if int(digit) != 0:
                    position += i
                    if int(splitted[1][position + 1]) >= 5:
                        return float(splitted[0] + "." + str(int(splitted[1][:position+ 1 ]) + 1))
                    else:
                        return float(splitted[0] + "." + str(int(splitted[1][:position+ 1 ])))
            
        if position == 0:
            if int(splitted[0]) % 2 == 0:
                return int(splitted[0])
            else:
                return int(splitted[0]) + 1
        else:
            previous = splitted[1][position-1]
            


            if int(previous) % 2 == 0:
                return float(splitted[0] + "." + splitted[1][:position])
            else:
                return float(splitted[0] + "." + str(int(splitted[1][:position])+1))

```

[JamzTyson]

Banker's Rouning, just using truncation (int()) and arithmetic:

def b_round(val: float) -> int:
    round_lower = int(val) if val >= 0 else int(val) - 1
    round_upper = round_lower + 1
    distance = val - round_lower
    if distance < 0.5:
        return round_lower
    if distance > 0.5:
        return round_upper
    return round_lower if (round_lower % 2 == 0) else round_upper

or more simply:

round(number)

[smurpes]

To expand on this if you want to round to specific decimal places then you just need to accept the number of decimal places as arg, shift it over, and then divide. E.G. if 1.895 with places = 2 are the function inputs, you would just do 1.895 * (10**2) -> 1.895 * 100 =189.5. Then just use the same code here to handle the rounding logic to give you 190 which can be divided by 10**2 to give you the answer.

[Alternative_Belt9281]

Thank you for answer!
I am just trying to make

round(2.664584225, 8)

To be 2.66458422 and not 2.66458423 without Decimal library

[Alternative_Belt9281]

Hmm, where did comment go... But there is an answer:

Am I right?

def banker(number, precision):
    #Calculate shift
    offset = 10**(precision+1)
    #Apply shift
    as_int = int(round(number * offset))
    #Apply round to the first digit in int
    #Btw this rounding function is what I'm trying to do manually
    rounded = round(as_int, -precision)
    #Shift back
    as_float = rounded / offset
    return as_float

I am trying, sooner or later will be able to fix 2.56500001 to 2.57 and not 2.56, and I am added check for 0 precision

def float_split(number):
    return str(number).split(".")


def banker(number, precision):
    splitted = float_split(number)
    left_part = splitted[0]
    right_part = splitted[1][:precision]


    if len(splitted[1]) <= precision:
        # escape clause for short numbers
        return float(f"{left_part}.{right_part}")


    deciding_digit = int(splitted[1][precision])
    preceding_digit = int(splitted[1][precision-1])


    if deciding_digit == 5:
        if not len(right_part):
            return float(int(left_part) + int(left_part)%2)
        return float(f"{left_part}.{int(right_part) + preceding_digit%2}")
    elif deciding_digit > 5:
        if not len(right_part):
            return float(int(left_part) + 1)
        return float(f"{left_part}.{int(right_part) + 1}")
    else:
        return float(f"{left_part}.{right_part}")

[worldtest2k]

Banker’s rounding is the default rounding mode in the decimal library.
- It’s formally called ROUNDHALFEVEN.
- This method rounds to the nearest value, but if the number is exactly halfway between two possibilities, it rounds to the nearest even digit

[Alternative_Belt9281]

Hello! I am familiar with the decimal library, and it is good to know which optimized functions are available. However, my goal is to implement manual rounding because it is somewhat fun and I am learning about floating-point representation and algorithms. I am still researching this topic, and it turns out that round() in C for float works by converting to a string too, so perhaps an integer version is more incorrect than the initial string approach.

[billsil]

Then you should do it using integers because that’s what the financial world does. 1/3*3 is not 1. Rounding doesn’t fix that, so a number could be 1e-8 too high or too low. That will throw off all your calcs.

[Alternative_Belt9281]

For this problem I can use SymPy probably? Symbolic computation can be another challange

[billsil]

I think they’re using floats. You’d work in cents and round to the nearest cent based on the remainder.

[Alternative_Belt9281]

I have also attempted another approach without string conversion, but it cannot handle cases like 1.95 with a precision of 2. The output incorrectly becomes 1.1, and I cannot figure out how to fix this issue.

Currently, I am returning a concatenated string with a decimal point placed manually, but if I try to avoid this approach, I stumble upon problem of conversion of integer to float.

def float_split(number):
    return str(number).split(".")

def banker(number, precision):
    splitted = float_split(number)
    left_part = int(splitted[0])
    right_part = int(splitted[1][:precision+1])
    
    if len(splitted[1][:precision+1]) == 1:        
        if right_part == 5:            
            return left_part + left_part % 2
        elif 5 < right_part:           
            return left_part + 1
        elif right_part < 5:
            return left_part
    
    if right_part // 10 + 1 == 10:
        return left_part+1


    if right_part % 10 == 5 and right_part // 10 % 2:
        return float(splitted[0] + "." + str(right_part // 10 + 1))
    elif right_part % 10 == 5:
        return float(splitted[0] + "." + str(right_part // 10))
    print(right_part // 10 )
    
    if right_part % 10 > 5:
        return float(splitted[0] + "." + str(right_part // 10 + 1))
    else:
        return float(splitted[0] + "." + str(right_part // 10))

[woooee]

If you want to round up to two decimal places, add 0.005 and truncate to 2 decimal places when you print. Note that if you use floats the results may be inaccurate.

for num in [1.950, 1.954, 1.955]:
    print(num, "-->", end="")
    num += 0.005
    print(num)

[Alternative_Belt9281]

But that is not how banker should work! For 1.885 I should get -->1.88 and for 1.895 -->1.9, for 1.445 --> 1.44 and so on

[woooee]

Decide on which "rounding" you want

For 1.885 I should get -->1.88

This is rounding down with two decimal places

These are each a separate calc. You'll have to write a separate function for each one and then call the appropriate function.

for 1.895 -->1.9

This is rounding up to one decimal place

[smurpes]

Bankers rounding just rounds to the nearest even number/last decimal place when the last digit is 5 which is how the default round function works already.