संसाधन लोड हो रहा है... लोड करना...
  1. पचाना
  2. मूल
  3. सी++ का उपयोग करके ओकेएक्स वायदा अनुबंध हेजिंग रणनीति

सी++ का उपयोग करके ओकेएक्स वायदा अनुबंध हेजिंग रणनीति

लेखक:अच्छाई, बनाया गयाः 2020-08-05 09:54:32, अद्यतनः 2024-12-17 20:50:25

img

हेजिंग रणनीतियों की बात करें तो विभिन्न बाजारों में विभिन्न प्रकार, विविध संयोजन और विविध विचार हैं। हम सबसे क्लासिक अंतःकालिक हेजिंग से हेजिंग रणनीति के डिजाइन विचारों और अवधारणाओं का पता लगाते हैं। आज, क्रिप्टो मुद्रा बाजार शुरुआत की तुलना में बहुत अधिक सक्रिय है, और कई वायदा अनुबंध एक्सचेंज भी हैं जो मध्यस्थता हेजिंग के लिए बहुत सारे अवसर प्रदान करते हैं। स्पॉट क्रॉस-मार्केट आर्बिट्रेज, कैश हेजिंग आर्बिट्रेज, वायदा अंतःकालिक मध्यस्थता, वायदा क्रॉस-मार्केट मध्यस्थता, आदि, क्रिप्टो मात्रात्मक ट्रेडिंग रणनीतियां एक के बाद एक उभरती हैं। आइए एक नज़र डालते हैं हार्डकोर C ++ में लिखी गई अंतःकालिक हेजिंग रणनीति और OKEX FM एक्सचेंज पर व्यापार। रणनीति QuantZ मात्रात्मक ट्रेडिंग प्लेटफॉर्म पर आधारित है।

रणनीति का सिद्धांत

रणनीति कुछ हद तक हार्डकोर क्यों है क्योंकि रणनीति C ++ में लिखी गई है और रणनीति पढ़ना थोड़ा अधिक कठिन है। लेकिन यह पाठकों को इस रणनीति डिजाइन और विचारों के सार को सीखने से नहीं रोकता है। रणनीति तर्क अपेक्षाकृत सरल है, कोड लंबाई मध्यम है, केवल 500 पंक्तियां। बाजार डेटा अधिग्रहण के मामले में, अन्य रणनीतियों के विपरीत जो rest इंटरफ़ेस का उपयोग करते हैं। यह रणनीति एक्सचेंज बाजार उद्धरण स्वीकार करने के लिए websocket इंटरफ़ेस का उपयोग करती है।

डिजाइन के मामले में, रणनीति संरचना उचित है, कोड युग्मन की डिग्री बहुत कम है, और इसे विस्तार या अनुकूलित करना सुविधाजनक है। तर्क स्पष्ट है, और इस तरह का डिज़ाइन न केवल समझना आसान है। एक शिक्षण सामग्री के रूप में, इस रणनीति का डिजाइन सीखना भी एक अच्छा उदाहरण है। इस रणनीति का सिद्धांत अपेक्षाकृत सरल है, अर्थात, क्या वायदा अनुबंध और हाल के अनुबंध का प्रसार सकारात्मक या नकारात्मक है? मूल सिद्धांत कमोडिटी वायदा के अंतःकालिक हेजिंग के अनुरूप है।

- पॉजिटिव स्प्रेड, शॉर्ट फोरवर्ड कॉन्ट्रैक्ट्स बेचना, लंबे हालिया कॉन्ट्रैक्ट्स खरीदना। - नकारात्मक स्प्रेड, लंबे वायदा अनुबंध खरीदना, हाल के अनुबंधों को कम करना।

मूल सिद्धांतों को समझने के बाद, शेष यह है कि रणनीति हेज की शुरुआती स्थिति को कैसे ट्रिगर करती है, स्थिति को कैसे बंद करती है, पदों को कैसे जोड़ती है, कुल स्थिति नियंत्रण विधि और अन्य रणनीति विवरण प्रसंस्करण।

हेजिंग रणनीति मुख्य रूप से विषय मूल्य अंतर (स्प्रेड) के उतार-चढ़ाव और इसके प्रतिगमन से संबंधित है। हालांकि, अंतर में मामूली उतार-चढ़ाव होने की संभावना है, या तेज उतार-चढ़ाव या एक दिशा में।

यह हेजिंग मुनाफे और घाटे के बारे में अनिश्चितता लाता है, लेकिन जोखिम अभी भी एकतरफा प्रवृत्ति की तुलना में बहुत छोटा है। अंतराल रणनीति के विभिन्न अनुकूलन के लिए, हम स्थिति नियंत्रण स्तर और उद्घाटन और समापन ट्रिगर स्थिति से शुरू करने का विकल्प चुन सकते हैं। उदाहरण के लिए, हम मूल्य उतार-चढ़ाव को निर्धारित करने के लिए क्लासिक बोलिंगर बैंड संकेतक का उपयोग कर सकते हैं। उचित डिजाइन और कम युग्मन डिग्री के कारण, इस रणनीति को आसानी से बोलिंगर सूचकांक अंतराल हेजिंग रणनीति में संशोधित किया जा सकता है

रणनीति कोड का विश्लेषण

पूरे कोड को देखते हुए, आप यह निष्कर्ष निकाल सकते हैं कि कोड मोटे तौर पर चार भागों में विभाजित है।

  1. मान परिभाषाओं को सूचीबद्ध करें, कुछ राज्य मानों को परिभाषित करें, और राज्यों को चिह्नित करने के लिए उपयोग करें। कुछ कार्यात्मक कार्य जो रणनीति से संबंधित नहीं हैं, जैसे कि यूआरएल एन्कोडिंग फ़ंक्शन, समय रूपांतरण फ़ंक्शन, आदि, का रणनीति तर्क से कोई संबंध नहीं है, केवल डेटा प्रसंस्करण के लिए।

  2. K-लाइन डेटा जनरेटर वर्गः यह रणनीति जनरेटर वर्ग वस्तु द्वारा उत्पन्न K-लाइन डेटा द्वारा संचालित होती है।

  3. हेजिंग वर्गः इस वर्ग के ऑब्जेक्ट विशिष्ट ट्रेडिंग लॉजिक, हेजिंग ऑपरेशन और रणनीति के प्रोसेसिंग विवरण कर सकते हैं।

  4. रणनीति का मुख्य कार्य, जो main फ़ंक्शन है। मुख्य फ़ंक्शन रणनीति का प्रवेश फ़ंक्शन है। मुख्य लूप इस फ़ंक्शन के अंदर निष्पादित किया जाता है। इसके अलावा, यह फ़ंक्शन एक महत्वपूर्ण ऑपरेशन भी करता है, अर्थात एक्सचेंज के वेबसॉकेट इंटरफ़ेस तक पहुंचना, और K-लाइन डेटा जनरेटर के रूप में पुश किए गए कच्चे टिक बाजार डेटा प्राप्त करना।

रणनीति कोड की समग्र समझ के माध्यम से, हम धीरे-धीरे रणनीति के विभिन्न पहलुओं को सीख सकते हैं, और फिर रणनीति के डिजाइन, विचारों और कौशल का अध्ययन कर सकते हैं।

  • अंकगणित मूल्य परिभाषा, अन्य कार्य कार्य
  1. सूचीबद्ध प्रकारStateबयान
enum State {                    // Enum type defines some states
    STATE_NA,                   // Abnormal state
    STATE_IDLE,                 // idle
    STATE_HOLD_LONG,            // holding long positions
    STATE_HOLD_SHORT,           // holding short positions
};

क्योंकि कोड में कुछ फ़ंक्शन एक राज्य वापस करते हैं, इन राज्यों को गणना प्रकार में परिभाषित किया जाता हैState.

यह देखते हुए किSTATE_NAकोड में दिखाई देता है असामान्य है, औरSTATE_IDLEनिष्क्रिय है, यानी ऑपरेशन की स्थिति को हेज किया जा सकता है।STATE_HOLD_LONGवह अवस्था है जिसमें सकारात्मक हेजिंग स्थिति रखी जाती है।STATE_HOLD_SHORTवह अवस्था है जिसमें ऋणात्मक हेजिंग स्थिति रखी जाती है।

  1. स्ट्रिंग प्रतिस्थापन, जिसे इस रणनीति में नहीं कहा जाता है, एक वैकल्पिक उपयोगिता फ़ंक्शन है, जो मुख्य रूप से स्ट्रिंग्स से संबंधित है।
string replace(string s, const string from, const string& to)
  1. हेक्साडेसिमल वर्णों में परिवर्तित करने के लिए एक कार्यtoHex
inline unsigned char toHex(unsigned char x)
  1. यूआरएल एन्कोडेड फ़ंक्शंस को संभालना
std::string urlencode(const std::string& str)
  1. एक समय रूपांतरण फ़ंक्शन जो स्ट्रिंग प्रारूप में समय को टाइमस्टैम्प में परिवर्तित करता है.
uint64_t _Time(string &s)
  • के लाइन डेटा जनरेटर वर्ग
Class BarFeeder { // K line data generator class
    Public:
        BarFeeder(int period) : _period(period) { // constructor with argument "period" period, initialized in initialization list
            _rs.Valid = true; // Initialize the "Valid" property of the K-line data in the constructor body.
        }

        Void feed(double price, Chart *c=nullptr, int chartIdx=0) { // input data, "nullptr" null pointer type, "chartIdx" index default parameter is 0
            Uint64_t epoch = uint64_t(Unix() / _period) * _period * 1000; // The second-level timestamp removes the incomplete time period (incomplete _period seconds) and is converted to a millisecond timestamp.
            Bool newBar = false; // mark the tag variable of the new K line Bar
            If (_rs.size() == 0 || _rs[_rs.size()-1].Time < epoch) { // If the K line data is 0 in length. Or the last bar's timestamp is less than epoch (the last bar of the K line is more than the current most recent cycle timestamp)
                Record r; // declare a K line bar structure
                r.Time = epoch; // Construct the K line bar of the current cycle
                r.Open = r.High = r.Low = r.Close = price; // Initialize the property
                _rs.push_back(r); // K line bar is pressed into the K line data structure
                If (_rs.size() > 2000) { // If the K-line data structure length exceeds 2000, the oldest data is removed.
                    _rs.erase(_rs.begin());
                }
                newBar = true; // tag
            } else { // In other cases, it is not the case of a new bar.
                Record &r = _rs[_rs.size() - 1]; // Reference the data of the last bar in the data.
                r.High = max(r.High, price); // The highest price update operation for the referenced data.
                r.Low = min(r.Low, price); // The lowest price update operation for the referenced data.
                r.Close = price; // Update the closing price of the referenced data.
            }
    
            Auto bar = _rs[_rs.size()-1]; // Take the last column data and assign it to the bar variable
            Json point = {bar.Time, bar.Open, bar.High, bar.Low, bar.Close}; // Construct a json type data
            If (c != nullptr) { // The chart object pointer is not equal to the null pointer, do the following.
               If (newBar) { // judge if the new Bar appears
                    C->add(chartIdx, point); // Call the chart object member function add to insert data into the chart object (new k line bar)
                    C->reset(1000); // retain only 1000 bar of data
                } else {
                    C->add(chartIdx, point, -1); // Otherwise update (not new bar), this point (update this bar).
                }
            }
        }
        Records & get() { // member function, method for getting K line data.
            Return _rs; // Returns the object's private variable _rs . (ie generated K-line data)
        }
    Private:
        Int _period;
        Records _rs;
};

यह वर्ग मुख्य रूप से रणनीति हेजिंग तर्क को चलाने के लिए एक अंतर K रेखा में प्राप्त टिक डेटा को संसाधित करने के लिए जिम्मेदार है।

कुछ पाठकों के पास सवाल हो सकते हैं, टिक डेटा का उपयोग क्यों करें? इस तरह के के-लाइन डेटा जनरेटर का निर्माण क्यों करें? क्या सीधे के-लाइन डेटा का उपयोग करना अच्छा नहीं है? इस तरह का सवाल तीन विस्फोटों में जारी किया गया है। जब मैंने कुछ हेजिंग रणनीतियों को लिखा, तो मैंने हलचल भी की। जब मैंने बोलिंगर हेज रणनीति लिखी तो मुझे जवाब मिला। चूंकि एक एकल अनुबंध के लिए के-लाइन डेटा एक निश्चित अवधि में इस अनुबंध के लिए मूल्य परिवर्तन के आंकड़े हैं।

दो अनुबंधों के बीच अंतर के के-लाइन डेटा एक निश्चित अवधि में अंतर मूल्य परिवर्तन आँकड़े हैं। इसलिए, घटाने के लिए दो अनुबंधों में से प्रत्येक के के-लाइन डेटा को लेना और प्रत्येक के-लाइन बार पर प्रत्येक डेटा के अंतर की गणना करना संभव नहीं है। सबसे स्पष्ट गलती, उदाहरण के लिए, दो अनुबंधों की उच्चतम कीमत और सबसे कम कीमत है, जरूरी नहीं कि एक ही समय में। इसलिए घटाया गया मूल्य बहुत समझ में नहीं आता है।

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

  • हेजिंग वर्ग
Class Hedge { // Hedging class, the main logic of the strategy.
  Public:
    Hedge() { // constructor
        ...
    };
    
    State getState(string &symbolA, Depth &depthA, string &symbolB, Depth &depthB) { // Get state, parameters: contract A name, contract A depth data, contract B name, contract B depth data
        
        ...
    }
    Bool Loop(string &symbolA, Depth &depthA, string &symbolB, Depth &depthB, string extra="") { // Opening and closing position main logic
        
        ...
    }

  Private:
    Vector<double> _addArr; // Hedging adding position list
    String _state_desc[4] = {"NA", "IDLE", "LONG", "SHORT"}; // Status value Description
    Int _countOpen = 0; // number of opening positions
    Int _countCover = 0; // number of closing positions
    Int _lastCache = 0; //
    Int _hedgeCount = 0; // number of hedging
    Int _loopCount = 0; // loop count (cycle count)
    Double _holdPrice = 0; // holding position price
    BarFeeder _feederA = BarFeeder(DPeriod); // A contract Quote K line generator
    BarFeeder _feederB = BarFeeder(DPeriod); // B contract Quote K line generator
    State _st = STATE_NA; // Hedging type Object Hedging position status
    String _cfgStr; // chart configuration string
    Double _holdAmount = 0; // holding position amount
    Bool _isCover = false; // the tag of whether to close the position
    Bool _needCheckOrder = true; // Set whether to check the order
    Chart _c = Chart(""); // chart object and initialize
};

क्योंकि कोड अपेक्षाकृत लंबा है, कुछ भागों को छोड़ दिया गया है, यह मुख्य रूप से इस हेज वर्ग की संरचना दिखा रहा है, कंस्ट्रक्टर हेज फ़ंक्शन को छोड़ दिया गया है, मुख्य रूप से उद्देश्य के लिए ऑब्जेक्ट आरंभ। इसके बाद, हम दो मुख्य function फ़ंक्शन पेश करते हैं।

getState

यह कार्य मुख्य रूप से आदेश निरीक्षण, आदेश रद्द करने, स्थिति का पता लगाने, स्थिति संतुलन आदि से संबंधित है। क्योंकि हेजिंग लेनदेन की प्रक्रिया में, एक एकल पैर से बचना असंभव है (यानी, एक अनुबंध निष्पादित किया जाता है, दूसरा नहीं होता है), यदि परीक्षा प्लेसिंग ऑर्डर लॉजिक में की जाती है, और फिर ऑर्डर ऑपरेशन को फिर से भेजने या स्थिति ऑपरेशन को बंद करने का प्रसंस्करण, रणनीति लॉजिक अराजक होगा।

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

लूप

रणनीति का व्यापारिक तर्क इस कार्य में समाहित है, जिसमेंgetStateइस चार्ट के लिए कुछ डेटा अपडेट ऑपरेशन भी हैं। चार्ट के लिए कुछ डेटा अपडेट ऑपरेशन भी हैं।

  • रणनीति का मुख्य कार्य
Void main() {

    ...
    
    String realSymbolA = exchange.SetContractType(symbolA)["instrument"]; // Get the A contract (this_week / next_week / quarter ), the real contract ID corresponding to the week, next week, and quarter of the OKEX futures contract.
    String realSymbolB = exchange.SetContractType(symbolB)["instrument"]; // ...
    
    String qs = urlencode(json({{"op", "subscribe"}, {"args", {"futures/depth5:" + realSymbolA, "futures/depth5:" + realSymbolB}}}).dump()) ; // JSON encoding, url encoding for the parameters to be passed on the ws interface
    Log("try connect to websocket"); // Print the information of the connection WS interface.
    Auto ws = Dial("wss://real.okex.com:10442/ws/v3|compress=gzip_raw&mode=recv&reconnect=true&payload="+qs); // Call the FMZ API "Dial" function to access the WS interface of OKEX Futures
    Log("connect to websocket success");
    
    Depth depthA, depthB; // Declare two variables of the depth data structure to store the depth data of the A contract and the B contract
    Auto fillDepth = [](json &data, Depth &d) { // Construct the code for the Depth data with the json data returned by the interface.
        d.Valid = true;
        d.Asks.clear();
        d.Asks.push_back({atof(string(data["asks"][0][0]).c_str()), atof(string(data["asks"][0][1]).c_str( ))});
        d.Bids.clear();
        d.Bids.push_back({atof(string(data["bids"][0][0]).c_str()), atof(string(data["bids"][0][1]).c_str( ))});
    };
    String timeA; // time string A
    String timeB; // time string B
    While (true) {
        Auto buf = ws.read(); // Read the data pushed by the WS interface
        
        ...
        
}

रणनीति शुरू होने के बाद, इसे मुख्य फ़ंक्शन से निष्पादित किया जाता है। मुख्य फ़ंक्शन के आरंभ में, रणनीति वेबसॉकेट इंटरफ़ेस के टिक बाजार की सदस्यता लेती है। मुख्य फ़ंक्शन का मुख्य कार्य एक मुख्य लूप का निर्माण करना है जो एक्सचेंज के वेबसॉकेट इंटरफ़ेस द्वारा धकेल दिए गए टिक उद्धरणों को लगातार प्राप्त करता है, और फिर हेज वर्ग ऑब्जेक्ट के सदस्य फ़ंक्शन को कॉल करता हैः लूप फ़ंक्शन। लूप फ़ंक्शन में ट्रेडिंग तर्क बाजार डेटा द्वारा संचालित होता है।

एक बात ध्यान देने योग्य है कि ऊपर उल्लिखित टिक मार्केट वास्तव में सब्सक्रिप्शन ऑर्डर पतली गहराई डेटा इंटरफ़ेस है, जो प्रत्येक फ़ाइल के लिए ऑर्डर बुक डेटा है। हालांकि, रणनीति केवल डेटा की पहली फ़ाइल का उपयोग करती है, वास्तव में, यह लगभग टिक बाजार डेटा के समान है। रणनीति अन्य फ़ाइलों के डेटा का उपयोग नहीं करती है, न ही यह पहली फ़ाइल के ऑर्डर मान का उपयोग करती है।

वेबसॉकेट इंटरफेस के डेटा को कैसे सब्सक्राइब करता है और इसे कैसे सेट किया जाता है, इस पर अधिक बारीकी से नज़र डालें।

string qs = urlencode(json({{"op", "subscribe"}, {"args", {"futures/depth5:" + realSymbolA, "futures/depth5:" + realSymbolB}}}).dump());    
Log("try connect to websocket");                                                                                                            
auto ws = Dial("wss://real.okex.com:10442/ws/v3|compress=gzip_raw&mode=recv&reconnect=true&payload="+qs);     
Log("connect to websocket success");

सबसे पहले, सदस्यता संदेश के यूआरएल एन्कोडिंग json पैरामीटर सदस्यता इंटरफेस द्वारा पारित, यानी मूल्य कीpayloadफिर एक महत्वपूर्ण कदम एफएमजेड क्वांट मंचs एपीआई इंटरफ़ेस समारोह कॉल करने के लिए हैDialकार्य।Dialयहाँ हम कुछ सेटिंग्स करते हैं, वेबसॉकेट कनेक्शन नियंत्रण ऑब्जेक्ट ws बनाने के लिए स्वचालित पुनः कनेक्शन या डिस्कनेक्शन (सब्सक्राइब संदेश अभी भी मान का उपयोग करता है)qsस्ट्रिंग काpayloadपैरामीटर), इस समारोह को प्राप्त करने के लिए, आप पैरामीटर स्ट्रिंग में विन्यास जोड़ने की जरूरत हैDial function.

की शुरुआतDialकार्य पैरामीटर निम्नानुसार है:

wss://real.okex.com:10442/ws/v3

यह वेबसॉकेट इंटरफेस का पता है जिसे एक्सेस करने की आवश्यकता है, और इसे तुम से अलग किया गया है.

Compress=gzip_raw&mode=recv&reconnect=true&payload="+qsसभी विन्यास पैरामीटर हैं।

पैरामीटर का नाम वर्णन
संपीड़ना संपीड़न संपीड़न मोड है, OKEX वेबसॉकेट इंटरफ़ेस इस तरह से gzip_raw का उपयोग करता है, इसलिए यह gzip_raw पर सेट है
मोड मोड मोड है, वैकल्पिक दोहरी, तीन प्रकार के भेजें और पुनः प्राप्त करें। दोहरी द्विदिशात्मक है, संपीड़ित डेटा भेजने और संपीड़ित डेटा प्राप्त करने के लिए। भेजें संपीड़ित डेटा भेजने के लिए है। Recv संपीड़ित डेटा प्राप्त करता है और इसे स्थानीय रूप से डीकॉम्प्रेस करता है।
फिर से जोड़ना पुनः कनेक्ट करने के लिए रीकनेक्ट सेट किया गया है, पुनः कनेक्ट करने के लिए reconnect=true सक्षम करें, कोई डिफ़ॉल्ट रीकनेक्ट नहीं किया गया है.
पेलोड पेलोड एक सब्सक्रिप्शन संदेश है जिसे ws को फिर से कनेक्ट करने पर भेजने की आवश्यकता होती है।

इस सेटिंग के बाद, भले ही वेबसॉकेट कनेक्शन डिस्कनेक्ट हो जाए, लेकिन FMZ Quant ट्रेडिंग प्लेटफॉर्म की डॉकर सिस्टम की अंतर्निहित प्रणाली स्वचालित रूप से पुनः कनेक्ट हो जाएगी और समय पर नवीनतम बाजार डेटा प्राप्त करेगी।

प्रत्येक मूल्य उतार-चढ़ाव को पकड़ें और सही हेज को जल्दी से पकड़ें।

  • स्थिति नियंत्रण

बोफिनाची श्रृंखला के समान हेजिंग पदों के अनुपात का उपयोग करके स्थिति नियंत्रण नियंत्रित किया जाता है।

For (int i = 0; i < AddMax + 1; i++) { // Construct a data structure that controls the number of scalping, similar to the ratio of the Bofinac sequence to the number of hedges.
     If (_addArr.size() < 2) { // The first two added positions are changed as: Double the number of hedges
         _addArr.push_back((i+1)*OpenAmount);
     }
     _addArr.push_back(_addArr[_addArr.size()-1] + _addArr[_addArr.size()-2]); // The last two adding positions are added together, and the current position quantity is calculated and stored in the "_addArr" data structure.
}

यह देखा जा सकता है कि प्रत्येक बार जोड़े जाने वाले अतिरिक्त पदों की संख्या पिछले दो पदों का योग है।

इस प्रकार की स्थिति नियंत्रण अंतर बड़ा, मध्यस्थता हेज की सापेक्ष वृद्धि, और स्थिति के फैलाव का एहसास कर सकते हैं, ताकि छोटे मूल्य उतार-चढ़ाव की छोटी स्थिति को पकड़ने के लिए, और बड़ी मूल्य उतार-चढ़ाव स्थिति उचित रूप से बढ़ाया जाता है।

  • समापन स्थितिः स्टॉप लॉस और लाभ लें

फिक्स्ड स्टॉप लॉस स्प्रेड और ले लाभ स्प्रेड।

जब स्थिति अंतर लाभ लेने की स्थिति और स्टॉप लॉस की स्थिति तक पहुँच जाता है, तो लाभ लेने और स्टॉप लॉस किया जाता है।

  • बाजार में प्रवेश करने और बाजार से बाहर निकलने की योजना

पैरामीटर की अवधिNPeriodनियंत्रण रणनीति के उद्घाटन और समापन की स्थिति पर कुछ गतिशील नियंत्रण प्रदान करता है।

  • रणनीति चार्ट

रणनीति स्वचालित रूप से प्रासंगिक लेनदेन जानकारी को चिह्नित करने के लिए एक फैलाव K-लाइन चार्ट उत्पन्न करती है।

सी ++ रणनीति कस्टम चार्ट ड्राइंग ऑपरेशन भी बहुत सरल है. आप देख सकते हैं कि हेज वर्ग के कंस्ट्रक्टर में, हम लिखित चार्ट विन्यास स्ट्रिंग का उपयोग_cfgStrचार्ट ऑब्जेक्ट को कॉन्फ़िगर करने के लिए_c, _cहैज वर्ग के निजी घटक है. जब निजी सदस्य आरंभ किया जाता है,chartFMZ क्वांट प्लेटफॉर्म कस्टम चार्ट एपीआई इंटरफ़ेस फ़ंक्शन द्वारा निर्मित ऑब्जेक्ट को बुलाया जाता है.

_cfgStr = R"EOF(
[{
"extension": { "layout": "single", "col": 6, "height": "500px"},
"rangeSelector": {"enabled": false},
"tooltip": {"xDateFormat": "%Y-%m-%d %H:%M:%S, %A"},
"plotOptions": {"candlestick": {"color": "#d75442", "upColor": "#6ba583"}},
"chart":{"type":"line"},
"title":{"text":"Spread Long"},
"xAxis":{"title":{"text":"Date"}},
"series":[
    {"type":"candlestick", "name":"Long Spread","data":[], "id":"dataseriesA"},
    {"type":"flags","data":[], "onSeries": "dataseriesA"}
    ]
},
{
"extension": { "layout": "single", "col": 6, "height": "500px"},
"rangeSelector": {"enabled": false},
"tooltip": {"xDateFormat": "%Y-%m-%d %H:%M:%S, %A"},
"plotOptions": {"candlestick": {"color": "#d75442", "upColor": "#6ba583"}},
"chart":{"type":"line"},
"title":{"text":"Spread Short"},
"xAxis":{"title":{"text":"Date"}},
"series":[
    {"type":"candlestick", "name":"Long Spread","data":[], "id":"dataseriesA"},
    {"type":"flags","data":[], "onSeries": "dataseriesA"}
    ]
}
]
)EOF";
_c.update(_cfgStr);                 // Update chart objects with chart configuration
_c.reset();                         // Reset chart data。

Call _c.update(_cfgStr); Use _cfgStr to configure to the chart object.

Call _c.reset(); to reset the chart data.

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

उदाहरण के लिए:

_c.add(chartIdx, {{"x", UnixNano()/1000000}, {"title", action},  {"text", format("diff: %f", opPrice)}, {"color", color}});

आदेश देने के बाद, K रेखा चार्ट को चिह्नित करें।

इस प्रकार, एक के रेखा खींचने पर, चार्ट वस्तु के लिए एक संदर्भ_cसदस्य फ़ंक्शन को कॉल करते समय पैरामीटर के रूप में पारित किया जाता हैfeedकेBarFeeder class.

void feed(double price, Chart *c=nullptr, int chartIdx=0)

यही है, औपचारिक पैरामीटरcकेfeed function.

Json point = {bar.Time, bar.Open, bar.High, bar.Low, bar.Close}; // Construct a json type data
If (c != nullptr) { // The chart object pointer is not equal to the null pointer, do the following.
    If (newBar) { // judge if the new Bar appears
         C->add(chartIdx, point); // Call the chart object member function "add" to insert data into the chart object (new k line bar)
         C->reset(1000); // only keep 1000 bar data
     } else {
         C->add(chartIdx, point, -1); // Otherwise update (not new bar), this point (update this bar).
     }
}

चार्ट में एक नया K-लाइन बार डेटा डालेंaddचार्ट ऑब्जेक्ट का सदस्य फ़ंक्शन_c.

c->add(chartIdx, point);

बैकटेस्ट

img img img

यह रणनीति केवल सीखने और संचार के प्रयोजनों के लिए है। जब इसे वास्तविक बाजार में लागू किया जाता है, तो कृपया बाजार की वास्तविक स्थिति के अनुसार संशोधित और अनुकूलित करें।

रणनीतिक पता:https://www.fmz.com/strategy/163447

अधिक दिलचस्प रणनीतियाँ FMZ क्वांट प्लेटफॉर्म में हैं":https://www.fmz.com

संबंधित
अधिक

2019 FMZ - सभी अधिकार सुरक्षित