आविष्कारक के मात्रात्मक सिमुलेशन स्तर बैकटेस्टिंग तंत्र का विवरण

• 1। संरचना का परीक्षण

  आविष्कारक की मात्रात्मक प्रतिक्रिया में रणनीति प्रक्रिया एक पूर्ण नियंत्रण प्रक्रिया है, प्रक्रिया एक निश्चित आवृत्ति के अनुसार निरंतर सर्वेक्षण में है। प्रत्येक स्थिति, लेनदेन एपीआई द्वारा लौटाए गए डेटा वास्तविक संचालन के समय के अनुसार भी है। यह onTick स्तर का है, न कि अन्य प्रतिक्रिया प्रणाली के onBar स्तर का।

• 2। एनोमिक स्तर की प्रतिक्रिया और फिक्स्ड डिस्क स्तर की प्रतिक्रिया के बीच अंतर

  • एनोमिक स्तर पर प्रतिक्रिया

    एनालॉग स्तर का पता लगाना एक एनालॉगिंग सिस्टम के निचले K लाइन डेटा के अनुसार है, जो किसी दिए गए निचले K लाइन बार के उच्चतम मूल्य, निम्नतम मूल्य, खोलने और बंद करने के मूल्य के संख्यात्मक ढांचे के भीतर एक निश्चित एल्गोरिथ्म के अनुसार है, जो इस बार के समय अनुक्रम में टिकर डेटा को सम्मिलित करता है।

  • रीयल-डिस्क स्तर पर प्रतिक्रिया

    रीयल-डिस्क स्तर की प्रतिक्रिया वास्तविक है, जो कि Bar की समय-सीमा में टिकर-स्तरीय डेटा है। रीयल-डिस्क स्तर की प्रतिक्रिया का उपयोग वास्तविकता के करीब है, जो कि टिकर-स्तरीय डेटा पर आधारित रणनीतियों के लिए है।
    रीयल-डिस्क स्तर पर, टिकर वास्तविक रिकॉर्ड किए गए डेटा हैं, न कि सिमुलेशन से उत्पन्न।

• 3। एनोमिक स्तर प्रतिक्रिया तंत्र - निचला K लाइन

  फिक्स्ड डिस्क स्तर की प्रतिक्रिया के लिए कोई अंतर्निहित K-लाइन विकल्प नहीं है (क्योंकि टिकर डेटा वास्तविक है, उपरोक्त K-लाइन का उपयोग न करने के लिए अनुकरण उत्पन्न करें) ।
  अनुकरण स्तर पर प्रतिक्रिया में, K-लाइन डेटा के आधार पर उत्पन्न किया गया टिकर। यह K-लाइन डेटा अंतर्निहित K-लाइन है। वास्तविक उपयोग में, अंतर्निहित K-लाइन अवधि को रणनीति चलाने के दौरान K-लाइन प्राप्त करने के लिए एपीआई को कॉल करने की अवधि से कम होना चाहिए। अन्यथा, अंतर्निहित K-लाइन अवधि बड़ी होने के कारण, उत्पन्न टिकर की संख्या कम है, जब एपीआई को निर्दिष्ट अवधि के K-लाइन प्राप्त करने के लिए बुलाया जाता है, तो डेटा गलत हो जाएगा। बड़े चक्र K-लाइन प्रतिक्रिया का उपयोग करते समय, बड़े स्तर के K-लाइन अवधि को उचित रूप से समायोजित किया जा सकता है।

• 4। नीचे के-लाइन कैसे टिकर डेटा उत्पन्न करता है

  आधारभूत K लाइन एमटी 4 के समान ही है।

  
  
  
  

• 5. टाइकर डेटा उत्पन्न करने के लिए एल्गोरिथ्म कोड

  एक विशिष्ट एल्गोरिथ्म के लिए एक आधार K-लाइन डेटा का अनुकरण करेंः

            
            
            
function recordsToTicks(period, num_digits, records) {
    if (records.length == 0) {
        return []
    }
    var ticks = []
    var steps = [0, 2, 4, 6, 10, 12, 16, 18, 23, 25, 27, 29]
    var pown = Math.pow(10, num_digits)

    function pushTick(t, price, vol) {
        ticks.push([Math.floor(t), Math.floor(price * pown) / pown, vol])
    }

    for (var i = 0; i < records.length; i++) {
        var T = records[i][0]
        var O = records[i][1]
        var H = records[i][2]
        var L = records[i][3]
        var C = records[i][4]
        var V = records[i][5]
        if (V > 1) {
            V = V - 1
        }
        if ((O == H) && (L == C) && (H == L)) {
            pushTick(T, O, V)
        } else if (((O == H) && (L == C)) || ((O == L) && (H == C))) {
            pushTick(T, O, V)
        } else if ((O == C) && ((O == L) || (O == H))) {
            pushTick(T, O, V / 2)
            pushTick(T + (period / 2), (O == L ? H : L), V / 2)
        } else if ((C == H) || (C == L)) {
            pushTick(T, O, V / 2)
            pushTick(T + (period * 0.382), (C == L ? H : L), V / 2)
        } else if ((O == H) || (O == L)) {
            pushTick(T, O, V / 2)
            pushTick(T + (period * 0.618), (O == L ? H : L), V / 2)
        } else {
            var dots = []
            var amount = V / 11
            pushTick(T, O, amount)
            if (C > O) {
                dots = [
                    O - (O - L) * 0.75,
                    O - (O - L) * 0.5,
                    L,
                    L + (H - L) / 3.0,
                    L + (H - L) * (4 / 15.0),
                    H - (H - L) / 3.0,
                    H - (H - L) * (6 / 15.0),
                    H,
                    H - (H - C) * 0.75,
                    H - (H - C) * 0.5,
                ]
            } else {
                dots = [
                    O + (H - O) * 0.75,
                    O + (H - O) * 0.5,
                    H,
                    H - (H - L) / 3.0,
                    H - (H - L) * (4 / 15.0),
                    H - (H - L) * (2 / 3.0),
                    H - (H - L) * (9 / 15.0),
                    L,
                    L + (C - L) * 0.75,
                    L + (C - L) * 0.5,
                ]
            }
            for (var j = 0; j < dots.length; j++) {
                pushTick(T + period * (steps[j + 1] / 30.0), dots[j], amount)
            }
        }
        pushTick(T + (period * 0.98), C, 1)
    }
    return ticks
}

इसलिए, एमुलेटर-स्तरीय रिट्रेसिंग का उपयोग करते समय समयरेखा पर मूल्य में उतार-चढ़ाव होता है।