119 lines
5.4 KiB
Python
119 lines
5.4 KiB
Python
import math
|
|
|
|
|
|
def formatAmount(val, prec=3, lowest=0, highest=0, currency=False, forceSign=False):
|
|
"""
|
|
Add suffix to value, transform value to match new suffix and round it.
|
|
|
|
Keyword arguments:
|
|
val -- value to process
|
|
prec -- precision of final number (number of significant positions to show)
|
|
lowest -- lowest order for suffixizing for numbers 0 < |num| < 1
|
|
highest -- highest order for suffixizing for numbers |num| > 1
|
|
currency -- if currency, billion suffix will be B instead of G
|
|
forceSign -- if True, positive numbers are signed too
|
|
"""
|
|
if val is None:
|
|
return ""
|
|
# Define suffix maps
|
|
posSuffixMap = {3: "k", 6: "M", 9: "B" if currency is True else "G"}
|
|
negSuffixMap = {-6: '\u03bc', -3: "m"}
|
|
# Define tuple of the map keys
|
|
# As we're going to go from the biggest order of abs(key), sort
|
|
# them differently due to one set of values being negative
|
|
# and other positive
|
|
posOrders = tuple(sorted(iter(posSuffixMap.keys()), reverse=True))
|
|
negOrders = tuple(sorted(iter(negSuffixMap.keys()), reverse=False))
|
|
# Find the least abs(key)
|
|
posLowest = min(posOrders)
|
|
negHighest = max(negOrders)
|
|
# By default, mantissa takes just value and no suffix
|
|
mantissa, suffix = val, ""
|
|
# Positive suffixes
|
|
if abs(val) > 1 and highest >= posLowest:
|
|
# Start from highest possible suffix
|
|
for key in posOrders:
|
|
# Find first suitable suffix and check if it's not above highest order
|
|
if abs(val) >= 10 ** key and key <= highest:
|
|
mantissa, suffix = val / float(10 ** key), posSuffixMap[key]
|
|
# Do additional step to eliminate results like 999999 => 1000k
|
|
# If we're already using our greatest order, we can't do anything useful
|
|
if posOrders.index(key) == 0:
|
|
break
|
|
else:
|
|
# Get order greater than current
|
|
prevKey = posOrders[posOrders.index(key) - 1]
|
|
# Check if the key to which we potentially can change is greater
|
|
# than our highest boundary
|
|
if prevKey > highest:
|
|
# If it is, bail - we already have acceptable results
|
|
break
|
|
# Find multiplier to get from one order to another
|
|
orderDiff = 10 ** (prevKey - key)
|
|
# If rounded mantissa according to our specifications is greater than
|
|
# or equal to multiplier
|
|
if roundToPrec(mantissa, prec) >= orderDiff:
|
|
# Divide mantissa and use suffix of greater order
|
|
mantissa, suffix = mantissa / orderDiff, posSuffixMap[prevKey]
|
|
# Otherwise consider current results as acceptable
|
|
break
|
|
# Take numbers between 0 and 1, and matching/below highest possible negative suffix
|
|
elif abs(val) < 1 and val != 0 and lowest <= negHighest:
|
|
# Start from lowest possible suffix
|
|
for key in negOrders:
|
|
# Get next order
|
|
try:
|
|
nextKey = negOrders[negOrders.index(key) + 1]
|
|
except IndexError:
|
|
nextKey = 0
|
|
# Check if mantissa with next suffix is in range [1, 1000)
|
|
if abs(val) < 10 ** nextKey and key >= lowest:
|
|
mantissa, suffix = val / float(10 ** key), negSuffixMap[key]
|
|
# Do additional step to eliminate results like 0.9999 => 1000m
|
|
# Check if the key we're potentially switching to is greater than our
|
|
# upper boundary
|
|
if nextKey > highest:
|
|
# If it is, leave loop with results we already have
|
|
break
|
|
# Find the multiplier between current and next order
|
|
orderDiff = 10 ** (nextKey - key)
|
|
# If rounded mantissa according to our specifications is greater than
|
|
# or equal to multiplier
|
|
if roundToPrec(mantissa, prec) >= orderDiff:
|
|
# Divide mantissa and use suffix of greater order
|
|
# Use special handling of zero key as it's not on the map
|
|
mantissa, suffix = mantissa / orderDiff, posSuffixMap[nextKey] if nextKey != 0 else ""
|
|
# Otherwise consider current results as acceptable
|
|
break
|
|
# Round mantissa according to our prec variable
|
|
mantissa = roundToPrec(mantissa, prec)
|
|
sign = "+" if forceSign is True and mantissa > 0 else ""
|
|
# Round mantissa and add suffix
|
|
result = "{0}{1}{2}".format(sign, mantissa, suffix)
|
|
return result
|
|
|
|
|
|
def roundToPrec(val, prec):
|
|
# We're not rounding integers anyway
|
|
# Also make sure that we do not ask to calculate logarithm of zero
|
|
if int(val) == val:
|
|
return int(val)
|
|
# Find round factor, taking into consideration that we want to keep at least prec
|
|
# positions for fractions with zero integer part (e.g. 0.0000354 for prec=3)
|
|
roundFactor = int(prec - math.ceil(math.log10(abs(val))))
|
|
# But we don't want to round integers
|
|
if roundFactor < 0:
|
|
roundFactor = 0
|
|
# Do actual rounding
|
|
val = round(val, roundFactor)
|
|
# Make sure numbers with .0 part designating float don't get through
|
|
if int(val) == val:
|
|
val = int(val)
|
|
return val
|
|
|
|
|
|
def roundDec(val, prec):
|
|
if int(val) == val:
|
|
return int(val)
|
|
return round(val, prec)
|