PlayState.formatCompactNumber lua recreation (now with correct unit names based on the wiki for large numbers!)

[nate902011]

formatCompactNumber = function (number)
    local suffixes1 = {
        '',
        'mi',
        'bi',
        'tri',
        'quadri',
        'quinti',
        'sexti',
        'septi',
        'octi',
        'noni'
    }
    local tenSuffixes = {
        {'', '', ''},
        {'deci', 'n', ''},
        {'viginti', 'm', 's'},
        {'trigenti', 'n', 's'},
        {'quadraginti', 'n', 's'},
        {'quinquaginti', 'n', 's'},
        {'sexaginti', 'n', ''},
        {'septuaginti', 'n', ''},
        {'octoginti', 'm', 'x'},
        {'nonaginti', '', ''}
    }
    local decSuffixes = {
        {'', false},
        {'un', false},
        {'duo', false},
        {'tre', true},
        {'quattuor', false},
        {'quin', false},
        {'se', true},
        {'septe', true},
        {'octo', false},
        {'nove', true}
    }
    local centiSuffixes = {
        {'', '', ''},
        {'centi', 'n', 'x'},
        {'ducenti', 'n', ''},
        {'trecenti', 'n', 's'},
        {'quadringenti', 'n', 's'},
        {'quingenti', 'n', 's'},
        {'sescenti', 'n', ''},
        {'septingenti', 'n', ''},
        {'octingenti', 'm', 'x'},
        {'nongenti', '', ''}
    }

    -- Should work fine for non negative amounts
    local magnitude = -1
    local num = number

    while num >= 1000.0 do
        num = num / 1000.0
        magnitude = magnitude + 1
    end

    -- Determine which suffixes to use
    local unitIndex = math.floor(magnitude % 10) + 1
    local tenIndex = math.floor((magnitude / 10) % 10) + 1
    local centiIndex = math.floor(magnitude / 100) + 1

    local unitSuffix = suffixes1[unitIndex]
    local tenSuffix = tenSuffixes[tenIndex][1]
    local centiSuffix = centiSuffixes[centiIndex][1]
    if magnitude > 10 then
        unitSuffix = decSuffixes[unitIndex][1]
        if decSuffixes[unitIndex][2] then
            if tenIndex == 1 and centiIndex > 1 then
                if unitIndex ~= 4 or unitIndex ~= 7 then
                    unitSuffix = unitSuffix .. centiSuffixes[centiIndex][2]
                else
                    if unitIndex == 4 and centiSuffixes[centiIndex][3] == 'x' then
                        unitSuffix = unitSuffix .. 's'
                    else
                        unitSuffix = unitSuffix .. centiSuffixes[centiIndex][3]
                    end
                end
            elseif tenIndex > 1 then
                if unitIndex ~= 4 and unitIndex ~= 7 then
                    unitSuffix = unitSuffix .. tenSuffixes[tenIndex][2]
                else
                    if unitIndex == 4 and tenSuffixes[tenIndex][3] == 'x' then
                        unitSuffix = unitSuffix .. 's'
                    else
                        unitSuffix = unitSuffix .. tenSuffixes[tenIndex][3]
                    end
                end
            end
        end
    end

    local finalSuffix = unitSuffix .. tenSuffix .. centiSuffix
    local compactValue = math.floor(num * 100) / 100 -- Use the floor value for the compact representation

    if compactValue <= 0.001 then
        return '0' -- Return 0 if compactValue = nil
    else
        local illionRepresentation = (magnitude > -1 and finalSuffix or '') .. (magnitude > 0 and 'llion' or '')
        return compactValue .. (magnitude ~= -1 and ' ' or '') .. (magnitude == 0 and 'thousand' or illionRepresentation)
    end
end

examples would be:

print(formatCompactNumber(1234567890)) -- output: 1.23 billion
print(formatCompactNumber(75 * 1e102)) -- output: 75.0 trestrigentillion
print(formatCompactNumber(1e303)) -- output: 999.99 novenonagintillion (because of double-float inaccuracies, off by ~10^300 or about a factor of 1000)

[nate902011]

the names get inaccurate at very high float values, but thats lua's fault (and double-float/64 bit floats too), not mine!