जावास्क्रिप्ट रणनीति डिजाइन में संख्यात्मक गणना सटीकता समस्या का समाधान

जब जावास्क्रिप्ट रणनीतियों को लिखते हैं, तो स्क्रिप्टिंग भाषा की कुछ समस्याओं के कारण, यह अक्सर गणनाओं में संख्यात्मक सटीकता की समस्याओं का कारण बनता है। इसका प्रोग्राम में कुछ गणनाओं और तार्किक निर्णयों पर कुछ प्रभाव पड़ता है। उदाहरण के लिए, गणना करते समय1 - 0.8या0.33 * 1.1, त्रुटि डेटा की गणना की जाएगीः

function main() {
    var a = 1 - 0.8
    Log(a)
   
    var c = 0.33 * 1.1
    Log(c) 
}

तो ऐसी समस्याओं को कैसे हल किया जाए? समस्या की जड़ यह हैः

फ्लोटिंग-पॉइंट मानों की अधिकतम प्रगति 17 दशमलव स्थान है, लेकिन संचालन करते समय सटीकता पूर्णांक से बहुत खराब होती है; ऑपरेशन करते समय पूर्णांक को दशमलव में परिवर्तित किया जाता है; और जावा और जावास्क्रिप्ट में दशमलव संचालन की गणना करते समय, दोनों पहले दशमलव दशमलव को संबंधित बाइनरी में परिवर्तित करते हैं, दशमलव का एक हिस्सा पूरी तरह से बाइनरी में परिवर्तित नहीं किया जा सकता है, यहाँ पहली त्रुटि है। दशमलव को बाइनरी में परिवर्तित करने के बाद, बाइनरी परिणाम प्राप्त करने के लिए बाइनरी के बीच ऑपरेशन किया जाता है। फिर बाइनरी परिणाम को दशमलव में परिवर्तित करें, जहां आमतौर पर एक दूसरी त्रुटि होती है।

इस समस्या को हल करने के लिए, मैंने इंटरनेट पर कुछ समाधानों की खोज की, और इस समस्या को हल करने के लिए निम्नलिखित समाधानों का परीक्षण और उपयोग कियाः

function mathService() {
    // addition
    this.add = function(a, b) {
        var c, d, e;
        try {
            c = a.toString().split(".")[1].length;   // Get the decimal length of a
        } catch (f) {
            c = 0;
        }
        try {
            d = b.toString().split(".")[1].length;   // Get the decimal length of b
        } catch (f) {
            d = 0;
        }
        //Find e first, multiply both a and b by e to convert to integer addition, then divide by e to restore
        return e = Math.pow(10, Math.max(c, d)), (this.mul(a, e) + this.mul(b, e)) / e;
    }
    
    // multiplication
    this.mul = function(a, b) {       
        var c = 0,
            d = a.toString(),         // Convert to string 
            e = b.toString();         // ...
        try {
            c += d.split(".")[1].length;      // c Accumulate the fractional digit length of a
        } catch (f) {}
        try {
            c += e.split(".")[1].length;      // c Accumulate the length of decimal places of b
        } catch (f) {}
        // Convert to integer multiplication, then divide by 10^c, move decimal point, restore, use integer multiplication without losing accuracy
        return Number(d.replace(".", "")) * Number(e.replace(".", "")) / Math.pow(10, c);
    }

    // Subtraction
    this.sub = function(a, b) {
        var c, d, e;
        try {
            c = a.toString().split(".")[1].length;  // Get the decimal length of a
        } catch (f) {
            c = 0;
        }
        try {
            d = b.toString().split(".")[1].length;  // Get the decimal length of b
        } catch (f) {
            d = 0;
        }
        // Same as addition
        return e = Math.pow(10, Math.max(c, d)), (this.mul(a, e) - this.mul(b, e)) / e;
    }

    // Division
    this.div = function(a, b) {
        var c, d, e = 0,
            f = 0;
        try {
            e = a.toString().split(".")[1].length;
        } catch (g) {}
        try {
            f = b.toString().split(".")[1].length;
        } catch (g) {}
        // Similarly, convert to integer, after operation, restore
        return c = Number(a.toString().replace(".", "")), d = Number(b.toString().replace(".", "")), this.mul(c / d, Math.pow(10, f - e));
    }
}

function main() {
    var obj = new mathService()
    
    var a = 1 - 0.8
    Log(a)
    
    var b = obj.sub(1, 0.8)
    Log(b)
    
    var c = 0.33 * 1.1
    Log(c)
    
    var d = obj.mul(0.33, 1.1)
    Log(d)
}

सिद्धांत गणना करने के लिए दो ऑपरेंड्स को पूर्णांक में परिवर्तित करना है ताकि सटीकता समस्याओं से बचा जा सके। गणना के बाद (पूर्णांक में परिवर्तित होने पर आवर्धन के अनुसार), सटीक परिणाम प्राप्त करने के लिए गणना परिणाम बहाल किए जाते हैं।

इस तरह, जब हम चाहते हैं कि कार्यक्रम एक आदेश रखने के लिए जब बाजार मूल्य प्लस एक न्यूनतम मूल्य परिशुद्धता, हम संख्यात्मक सटीकता के बारे में चिंता करने की जरूरत नहीं है

function mathService() {
....    // Omitted
}

function main() {
    var obj = new mathService()
    var depth = exchange.GetDepth()
    exchange.Sell(obj.add(depth.Bids[0].Price, 0.0001), depth.Bids[0].Amount, "Buy 1 order:", depth.Bids[0]) 
}

इच्छुक व्यापारी कोड पढ़ सकते हैं, गणना प्रक्रिया को समझ सकते हैं, प्रश्न पूछने के लिए स्वागत है, एक साथ सीख सकते हैं और एक साथ प्रगति कर सकते हैं।