I am working on a JavaScript function that takes two values: precision of a decimal value & scale of a decimal value.

This function should calculate the maximum value that can be stored in a decimal of that size.

For example: a decimal with a precision of 5 and a scale of 3 would have a maximum value of 99.999.

What I have does the job, but it's not elegant. Can anyone think of something more clever?

Also, please forgive the use of this weird version of Hungarian notation.

function maxDecimalValue(pintPrecision, pintScale) {
    /* the maximum integers for a decimal is equal to the precision - the scale.
        The maximum number of decimal places is equal to the scale.
        For example, a decimal(5,3) would have a max value of 99.999
    */
    // There's got to be a more elegant way to do this...
    var intMaxInts = (pintPrecision- pintScale);
    var intMaxDecs = pintScale;

    var intCount;
    var strMaxValue = "";

    // build the max number.  Start with the integers.
    if (intMaxInts == 0) strMaxValue = "0";    
    for (intCount = 1; intCount <= intMaxInts; intCount++) {
        strMaxValue += "9";
    }

    // add the values in the decimal place
    if (intMaxDecs > 0) {
        strMaxValue += ".";
        for (intCount = 1; intCount <= intMaxDecs; intCount++) {
            strMaxValue += "9";
        }
    }
    return parseFloat(strMaxValue);
}

I am working on a JavaScript function that takes two values: precision of a decimal value & scale of a decimal value.

This function should calculate the maximum value that can be stored in a decimal of that size.

For example: a decimal with a precision of 5 and a scale of 3 would have a maximum value of 99.999.

What I have does the job, but it's not elegant. Can anyone think of something more clever?

Also, please forgive the use of this weird version of Hungarian notation.

function maxDecimalValue(pintPrecision, pintScale) {
    /* the maximum integers for a decimal is equal to the precision - the scale.
        The maximum number of decimal places is equal to the scale.
        For example, a decimal(5,3) would have a max value of 99.999
    */
    // There's got to be a more elegant way to do this...
    var intMaxInts = (pintPrecision- pintScale);
    var intMaxDecs = pintScale;

    var intCount;
    var strMaxValue = "";

    // build the max number.  Start with the integers.
    if (intMaxInts == 0) strMaxValue = "0";    
    for (intCount = 1; intCount <= intMaxInts; intCount++) {
        strMaxValue += "9";
    }

    // add the values in the decimal place
    if (intMaxDecs > 0) {
        strMaxValue += ".";
        for (intCount = 1; intCount <= intMaxDecs; intCount++) {
            strMaxValue += "9";
        }
    }
    return parseFloat(strMaxValue);
}

• javascript
• math
• decimal

5 Answers 5

Haven't tested it:

function maxDecimalValue(precision, scale) {
    return Math.pow(10,precision-scale) - Math.pow(10,-scale);
}

precision must be positive

maxDecimalValue(5,3) = 10^(5-3) - 10^-3 = 100 - 1/1000 = 99.999
maxDecimalValue(1,0) = 10^1 - 10^0 = 10 - 1 = 9
maxDecimalValue(1,-1) = 10^(1+1) - 10^1 = 100 - 10 = 90
maxDecimalValue(2,-3) = 10^(2+3) - 10^3 = 100000 - 1000 = 99000

What about

function maxDecimalValue(pintPrecision, pintScale)
{
    var result = "";
    for(var i = 0; i < pintPrecision; ++i)
    {
        if(i == (pintPrecision - pintScale)
        {
            result += ".";
        }
        result += "9";
    }
    return parseFloat(result);
}

Check it out here

Although pow(10,precision-scale) - pow(10,-scale) is the right formula, you will need to calculate it with decimal type instead of float.

For example, if precision=4 and scale=5, you will get 0.09999000000000001 if it's calculated with float.

Therefore, in Python, you can do something like:

from decimal import Decimal

def calculate_decimal_range(precision: int, scale: int) -> Decimal:    
    precision, scale = Decimal(precision), Decimal(scale)
    return 10**(precision-scale) - 10**-scale

I would do something along the lines of ((10 * pintPrecision) - 1) + "." + ((10 * pintScale) - 1)

As Guangyang Li pointed out in his answer, mathimatical soulutions with calculations in javascript might cause floating point inaccuracy issues because javascript does not have the consept of decimal type.

Instead you should handle this using string mechanisms just like your original attempt.
Here is a shorter and more efficient method of duplicate the nine's to build up the result:

function maxDecimalValue(precision, scale) {
    if (precision < 0 || scale < 0) throw new Error('precision and scale must be positive numbers!');

    if (precision < scale) throw new Error('scale can not be larger than precision!');
    var strMaxValue = new Array(precision - scale + 1).join('9') + '.' +  new Array(scale + 1).join('9');
    return parseFloat(strMaxValue);
}

console.log(5, 2, maxDecimalValue(5,2)); 
console.log(7, 5, maxDecimalValue(7,5)); 
console.log(7, 7, maxDecimalValue(7,7));
console.log(5, 7, maxDecimalValue(5,7));

Inspired by this answer on a question about duplicating character