四舍五入到重要数字 - 缺少零

Question

我目前正在制作一个JavaScript驱动的数学软件包，专注于四舍五入到各种重要数字（SF），但我遇到了一个我正在努力解决的问题。

以后更多关于这个问题，但首先是一些背景知识。

该程序旨在选择给定范围内的完全随机数 ，然后自动计算出该数字的相关有效数字 ; 例如：

随机数： 0.097027 S.Fs： 9, 7, 0, 2, 7

---

这是我为您提供视觉表示的截图：

如您所见，一旦用户选择了他们的号码，他们就有机会点击四个单独的“SF”按钮来查看分别呈现给1,2,3和4个S.F的随机数。

对于每个SF（1-4），随机数向下 舍入，向上 舍 入并四舍五入到X SF ，下面的比例为用户提供更直观的表示，以显示程序选择SF值的原因。

我已经为此编写了绝大多数代码并对其进行了测试，到目前为止，数字正在出现我对它的预期。 差不多......

在我给出的例子中(0.097027) ; 正如您在我所包含的图像中看到的那样，4 SF的数据绝对正确并准确输出。

当我点击3 SF按钮时，我希望看到以下内容：

随机数： 0.097027 3 SF圆形上/下/下： 0.0970

但是，我实际得到的是：

随机数： 0.097027 3 SF 0.097027 上/下/下： 0.097

该程序未显示额外的零。 这是我的程序中以零结尾的数字的完美示例，在这种情况下，零非常重要并且必须显示。

---

数据通常是正确的，但似乎在正确的时间输出重要的零值存在问题。 我已经研究了toFixed(x)方法，如果我分配给固定toFixed(4)我得到了正确的所需输出，但因为我的数字每次都是随机生成的，所以它们的长度可以是5个数字，例如89.404到> 10，例如`0.000020615。

所以看起来 toFixed 方法需要灵活/动态，例如 toFixed(n) 预先运行一个函数来确定需要多少尾随零？

以下是我当前解决方案的一些关键摘录供您考虑：

function generateNum() {

do {
        genNumber = Math.random() * Math.pow (10, randomRange(-5, 5));

        //Round
        genNumber = roundToNSF(genNumber, 5, 0);

        // This number must contain >1 digit which is 1 to 9 inclusive otherwise we may have e.g. 100. Rounding 100
    } 

while (!countNonZero(genNumber) || genNumber < 1E-05 || genNumber == 0);

    //Round
    genNumber = roundToNSF(genNumber, 5, 0);


    genNumber = String(genNumber);
    genNumber = Number(genNumber);
}

//----------------------------------------------------------------------------

function randomRange(min, max) {

/**
 * Returns a random integer between min (inclusive) and max (inclusive)
 * Using Math.round() will give you a non-uniform distribution!
 */

return Math.floor(Math.random() * (max - min + 1)) + min;

} 

//---------------------------------------------------------------------------
//Click SF3 Button to reveal the data
function showSF3() {

//Remove any CSS properties on the buttons from previous use
removeButtonCSS();

document.getElementById('SFRounded').style.display = "block";
document.getElementById('scale').style.display = "block";
document.getElementById("SF3").className = document.getElementById("SF3").className + "buttonClick";  // this removes the blue border class

//Clear text
deleteRounded();
deleteScale();

//Run calculation
calculateAnswer();

//alert(genNumber.toFixed(4));

for (i = 3; i < 4; i++)

    {
         //Add The new data
         sfRoundedTextBlock = document.getElementById('SFRounded');

         //alert(downArray[i].toFixed(4));

         //Data output to HTML.

         sfRoundedTextBlock.innerHTML = sfRoundedTextBlock.innerHTML + '<p><strong>Number: </strong></br>' + String(genNumber) + 
         '</br>' + '<strong>Rounded down to ' + i + ' SF:</br></strong>' + downArray[i] + '</br>' + 
         '<strong>Rounded up to ' + i + ' SF:</br></strong>' + upArray[i] + '</br><strong>Rounded off to ' + i + ' SF:</br></strong>' 
         + roundedArray[i] + '</br>' + '(See the scale below for why we choose <strong>' + roundedArray[i] + '</strong> as the rounded off value.)</p>';

    }

}

//----------------------------------------------------------------------

var roundedArray = [];
var upArray = [];
var downArray = [];
var temp;

function calculateAnswer() {
//Clear Arrays
roundedArray = [];
upArray = [];
downArray = [];

// Work out the answer:
for (i = 0; i < 4; i++) {

    var nSF = i + 1;
    // Round OFF ...
    temp = roundToNSF(genNumber, nSF, 0);
    // We actually have to do this twice ...
    roundedArray[nSF] = roundToNSF(temp, nSF, 0);

    // Round UP ...
    upArray[nSF] = roundToNSF(genNumber, nSF, 1);

    // Round DOWN ...
    downArray[nSF] = roundToNSF(genNumber, nSF, -1);
    // e.g. x = 0.0098 rounded to 1SF is 0.010 initially (take the log of 0.0098 and try it!).
};  
};


//-------------------------------------------------------------------------

//Globals
var aNumber;
var digits;
var way;

function roundToNSF(aNumber, digits, way){
// Round a number to n significant figures (can use roundToNDP provided we know how many decimal places):
    if (way == undefined) { way = 0; }; // default is round off

if (aNumber !=0) {

    if (aNumber > 0)
        { 
            z = log10(aNumber); 
        } 
        else 
            { 
                z = log10(-aNumber); 
            };

    z = Math.floor(z);

    var nDP = digits - z - 1; // Rounding to nDP decimal places is equivalent to rounding to digits significant figures ...

    var roundedNumber = roundToNDP(aNumber, nDP, way);

} 
else {

    roundedNumber = aNumber; // Number is zero ...
};

return Number(roundedNumber);
};

//---------------------------------------------------------------------------------

---

更新：

我仍在继续尝试找到解决此问题的方法，我最近采用的方法是将我随机生成的数字转换为可搜索的字符串变量，然后使用indexOf(".")命令查找该位置。 小数点（dp） 。

然后我搜索了我的数字，从dp的位置开始，找到一个重要的非零数字[1-9]的第一个实例。

var genNumber =  0.097027;
var rString = String(genNumber);
var positionofDP = rString.indexOf(".");
var regexp = /[1-9]/;
var positionofNonZero = Number(rString.search(regexp, positionofDP));  // Output would be '5'

然后我能够进一步定位我的搜索，以确定我的第一个有效数字是否在其后面的数字中有任何“有问题”的零。

如果有，那么我将布尔变量设置为'true'，然后在一个单独的函数中创建我的舍入/关闭/向上舍入数字的更多文本字符串，这样我就可以实际选择将“0”添加到结束现有的数字字符。

在单独的情况下，这种方法对我有用，但随着我的随机数长度从5到12位不等，它仍然没有处理所有情况。

也许我需要创建一个动态的toFixed(i)函数？ 任何想法都会受到欢迎。

Answer 1

您可以直接管理字符串，而不是使用Int上的固定点。

这是一个小小提琴的链接： http ： //jsfiddle.net/5rw5G/4/

这不是为了完全/准确地解决您的问题，但可能会帮助您看到另一种解决方案。

function getRoundedSFs(num, SFCount) {    
    // Match every "leading zeros" before and after the .
    var matches = num.toString().match(/^-?(0+)\.(0*)/);

    // starting with "0."
    if (matches) { 
        var firstIndex = matches[0].length;
        var prefix = matches[0];

        sf = Number(num.toString().substring(firstIndex, firstIndex + SFCount + 1));
        sf = Math.round(sf / 10);
        sf = prefix + sf.toString();
        return Number(sf).toFixed(matches[2].length+SFCount);
    } 

    // starting with something else like -5.574487436097115
    else { 
        matches = num.toString().match(/^(-?(\d+))\.(\d+)/);
        var decimalShift = SFCount - matches[2].length;        
        var rounded = Math.round(num * Math.pow(10, decimalShift));       
        rounded /= Math.pow(10, decimalShift);
        return rounded.toFixed(decimalShift);
    }
}

Answer 2

我已经离开了，我想我现在终于解决了我最初的问题。

关于何时使用toFixed和toPrecision ，我有一定程度的困惑。 我之前尝试将我的向上，向下和向下的数字转换成字符串，然后搜索每一个以找到小数点(".") ，然后计算出尾随数字的数量，以便然后生成正确toFixed点。

然而，考虑到我的随机数可能达到12位数，这非常受欢迎，所以我现在所做的就是恰当地利用toPrecision 。 对于每个“SF按钮”（1-4），我使用了相应的toPrecision点，例如SF1：

    sfRoundedTextBlock.innerHTML = sfRoundedTextBlock.innerHTML + '<p><strong>Number: </strong></br>' + String(genNumber) + 
    '</br>' + '<strong>Rounded down to ' + i + ' SF:</br></strong>' + downArray[i].toPrecision(1) + '</br>' + 
    '<strong>Rounded up to ' + i + ' SF:</br></strong>' + upArray[i].toPrecision(1) + '</br><strong>Rounded off to ' + i + ' SF:</br></strong>' 
    + roundedArray[i].toPrecision(1) + '</br>' + '(See the scale below for why we choose <strong>' + roundedArray[i].toPrecision(1) + '</strong> as the rounded off value.)</p>';

    //Add The new scale data (Rounded Down)
    downTextBlock = document.getElementById('down');
    document.getElementById("down").innerHTML = String(downArray[i].toPrecision(1));

    //Add The new scale data (Rounded Up)
    upTextBlock = document.getElementById('up');
    document.getElementById("up").innerHTML = String(upArray[i].toPrecision(1));

现在每次都给我准确的结果，但仍然有一个障碍要跳。 偶尔我会得到一个随机的场景， 科学记数法必须包括在我的输出答案中，例如21819向下舍入到1 SF，将读出2e+4而不是20000 。

为了解决这个问题，我将我的向上和向下的数字设置为可搜索的字符串，然后查看这些字符以查找任何非法/科学字符[az]。 如果我找到了，我执行了一个稍微不同的输出版本，它使用了parseFloat ，它删除了科学记数法并显示了正确的数字：

//Convert Up, Down and Rounded into Strings based on their precision
        var upString = String(upArray[i].toPrecision(1));
        var downString = String(downArray[i].toPrecision(1));
        var roundedString = String(roundedArray[i].toPrecision(1));
        //Set up a regexp to search for characters [a-z], i.e. non-numeric
        var regexp = /[a-z]/g; 
        //Search the up, down and rounded strings for non-numeric characters
        var upResult = upString.match(regexp);
        var downResult = downString.match(regexp);
        var roundedResult = roundedString.match(regexp);
        //If any of these strings contain a letter (non-numeric) we need to add in parseFloat to strip away the scientific notation included.
        var containsChar = false;

        if (upResult != null || downResult != null || roundedResult != null)

            {
                containsChar = true;
                //alert("There is SN included here");
            }

         //Add The new data
         sfRoundedTextBlock = document.getElementById('SFRounded');

        if (containsChar == true)

        {
            sfRoundedTextBlock.innerHTML = sfRoundedTextBlock.innerHTML + '<p><strong>Number: </strong></br>' + String(genNumber) + 
            '</br>' + '<strong>Rounded down to ' + i + ' SF:</br></strong>' + parseFloat(downArray[i].toPrecision(1)) + '</br>' + 
            '<strong>Rounded up to ' + i + ' SF:</br></strong>' + parseFloat(upArray[i].toPrecision(1)) + '</br><strong>Rounded off to ' + i + ' SF:</br></strong>' 
            + parseFloat(roundedArray[i].toPrecision(1)) + '</br>' + '(See the scale below for why we choose <strong>' + parseFloat(roundedArray[i].toPrecision(1)) + '</strong> as the rounded off value.)</p>';

            //Add The new scale data (Rounded Down)
            downTextBlock = document.getElementById('down');
            document.getElementById("down").innerHTML = String(parseFloat(downArray[i].toPrecision(1)));

            //Add The new scale data (Rounded Up)
            upTextBlock = document.getElementById('up');
            document.getElementById("up").innerHTML = String(parseFloat(upArray[i].toPrecision(1)));
        }  

经过广泛测试后，它似乎正如希望的那样工作。