पेनी जंप कमोडिटी वायदा उच्च आवृत्ति ट्रेडिंग रणनीति सी ++ द्वारा लिखित

सारांश

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

उच्च आवृत्ति रणनीति वर्गीकरण

उच्च आवृत्ति व्यापार में, दो मुख्य प्रकार की रणनीतियाँ हैं। खरीदार पक्ष की रणनीति और विक्रेता पक्ष की रणनीति। विक्रेता पक्ष की रणनीति आमतौर पर एक बाजार बनाने की रणनीति है, और इन दोनों पक्षों की रणनीतियाँ विरोधी हैं। उदाहरण के लिए, उच्च आवृत्ति मध्यस्थता खरीदार की रणनीति बाजार में सभी अनुचित घटनाओं को सबसे तेज गति से चिकना करने की है, कीमत पर जल्दी से हमला करने की पहल करना, या अन्य बाजार निर्माताओं की गलत कीमत खाना।

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

पेनी जंप रणनीति क्या है?

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

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

पेनी जंप रणनीति सिद्धांत

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

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

इस विशाल आदेश के कारण, यह बाजार में असंगत लग रहा है, कभी कभी हम इसे कहते हैं हाथी आदेश. उदाहरण के लिए वर्तमान बाजार दिखा रहा हैः

Selling Price 400.3, Order volume 50; buying price 400.1, Order volume 10. 

अचानक यह बोझिल हाथी बाजार में कूद गया, और बोली मूल्य 400.1 की कीमत पर भेजा गया था। इस समय बाजार बन जाता हैः

Selling Price 400.3, Order volume 50; Buying price 400.1, Order volume 510.

व्यापारी सभी जानते हैं कि यदि किसी निश्चित मूल्य पर बड़ी मात्रा में लंबित ऑर्डर हैं, तो यह मूल्य एक मजबूत समर्थन ((या प्रतिरोध) का गठन करेगा। इसके अलावा, उच्च आवृत्ति वाले व्यापारी भी जानते हैं, यदि वे ऑर्डर बुक गहराई में Buy 1 मूल्य से ऊपर खरीद ऑर्डर भेजते हैं, तो बाजार बन जाता हैः

Selling Price 400.3, Order volume 50; Buying price 400.2, Order volume 1,

ऑर्डर बुक की गहराई में कीमत 400.1 Buying 2 मूल्य बन जाती है। फिर यदि कीमत 400.3 तक बढ़ जाती है, तो उच्च आवृत्ति व्यापारी 0.1 का लाभ कमाएगा।

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

पेनी जंप रणनीति का कार्यान्वयन

सबसे पहले, बाजार की बहुत कम संभावना के साथ ट्रेडिंग के अवसरों का निरीक्षण करें, और ट्रेडिंग तर्क के अनुसार संबंधित रणनीतियाँ बनाएं। यदि तर्क जटिल है, तो आपको मौजूदा गणितीय ज्ञान का उपयोग करने की आवश्यकता है, मॉडल का उपयोग करने के लिए तर्कहीन घटना की प्रकृति का वर्णन करने के लिए जितना संभव हो सके, और ओवरफिटिंग को कम से कम करें। इसके अलावा, इसे एक बैकटेस्ट इंजन द्वारा सत्यापित किया जाना चाहिए जो Price first then Volume first सिद्धांत को पूरा कर सकता है। सौभाग्य से, हमारे पास FMZ क्वांट प्लेटफॉर्म है जो वर्तमान में इस बैकटेस्टिंग मोड का समर्थन करता है।

Price first then Volume first backtest engine का समर्थन करने का क्या अर्थ है? आप इसे इस तरह समझ सकते हैंः आप खरीदने के लिए 400.1 पर एक लंबित ऑर्डर भेजते हैं, केवल जब ऑर्डर बुक गहराई में बिक्री मूल्य 400.1 या उससे कम हो, तो आपका लंबित ऑर्डर बंद हो सकता है। यह केवल लंबित ऑर्डर के मूल्य डेटा की गणना करता है, और लंबित ऑर्डर के मात्रा डेटा की गणना नहीं करता है, जो केवल एक्सचेंज ऑर्डर मिलान नियमों में मूल्य प्राथमिकता ((मूल्य पहले) को पूरा करता है।

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

इसके अलावा, कुछ पाठकों को यह पता चल सकता है कि पेनी जंप रणनीति के लिए बाजार में व्यापार के अवसरों की आवश्यकता होती है, यानी बाजार की जरूरत में कम से कम दो hop मूल्य अंतराल होते हैं। सामान्य परिस्थितियों में, कमोडिटी वायदा का मुख्य व्यापारिक अनुबंध अपेक्षाकृत व्यस्त होता है। 1 खरीदने और 1 बेचने के बीच का अंतर यह है कि व्यापार का कोई मौका नहीं है। इसलिए हम अपनी ऊर्जा उप-प्राथमिक अनुबंध पर डालते हैं जहां व्यापार बहुत सक्रिय नहीं होता है। इस प्रकार के व्यापारिक अनुबंध में कभी-कभी दो या तीन hop अवसर होते हैं। उदाहरण के लिए, MA (चीनी कमोडिटी वायदा में Methanol कोड) 1909 अनुबंध में, निम्न स्थिति होती हैः

वॉल्यूम 551 के साथ 1 कीमत 2225 बेचना, वॉल्यूम 565 के साथ 1 कीमत 2223 खरीदना, कुछ सेकंड के लिए नीचे देखें। ऐसा होने के बाद, यह कई टिक के बाद गायब हो जाएगा। इस मामले में, हम बाजार को स्व-सुधार के रूप में मानते हैं। हमें जो करना है वह पकड़ना है। बाजार सक्रिय रूप से इसे सुधारने से पहले। यदि हम इसे मैन्युअल रूप से करते हैं, तो यह असंभव होगा, स्वचालित ट्रेडिंग की मदद से, हम इसे संभव बना सकते हैं।

दो हॉप मूल्य अंतर की उपस्थिति की स्थिति बहुत बार होती है, लेकिन तीन हॉप सबसे सुरक्षित हैं, लेकिन तीन हॉप शायद ही कभी होते हैं, जिसके परिणामस्वरूप व्यापारिक आवृत्ति बहुत कम होती है।

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

रणनीति कोड

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

• चरण 1: सबसे पहले रणनीति का फ्रेमवर्क बनाएं, जिसमें एक HFT वर्ग और एक मुख्य फ़ंक्शन परिभाषित है। मुख्य फ़ंक्शन में पहली पंक्ति लॉग को साफ़ करना है। इसका उद्देश्य हर बार रणनीति को पुनरारंभ करने पर पहले से चल रही लॉग जानकारी को साफ़ करना है। दूसरी पंक्ति कुछ त्रुटि संदेशों को फ़िल्टर करना है जो आवश्यक नहीं हैं, जैसे कि नेटवर्क देरी और कुछ सुझाव दिखाई देते हैं, ताकि लॉग केवल महत्वपूर्ण जानकारी रिकॉर्ड करे और अधिक साफ दिखता है; तीसरी पंक्ति Init OK संदेश को प्रिंट करना है, जिसका अर्थ है कि प्रोग्राम शुरू हो गया है। चौथी पंक्ति HFT वर्ग के अनुसार एक ऑब्जेक्ट बनाना है, और ऑब्जेक्ट का नाम hft है; पांचवीं पंक्ति प्रोग्राम जबकि लूप में प्रवेश करता है, और हमेशा hft विधि में ऑब्जेक्ट लूप को निष्पादित करता है, यह देखा जा सकता है कि लूप विधि इस प्रोग्राम का तर्क है। लाइन 6 एक अन्य मूल संदेश है। यदि प्रोग्राम को निष्पादित करने के लिए सामान्य परिस्थितियों में लाइन 6 समाप्त हो गई है, तो प्रोग्राम निष्पादित नहीं होगा।

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

/ / Define the HFT class
Class HFT {
     Public:
         HFT() {
             // Constructor
         }
        
         Int getTradingWeekDay() {
             // Get the current day of the week to determine if it is a new K line
         }
        
         State getState() {
             / / Get order data
         }

         Void stop() {
             // Print orders and positions
         }
        
         Bool Loop() {
             // Strategy logic and placing orders
         }
};

// main function
Void main() {
     LogReset(); // clear the log
     SetErrorFilter("ready|timeout"); // Filter error messages
     Log("Init OK"); // Print the log
     HFT hft; // Create HFT object
     While (hft.Loop()); // enter loop
     Log("Exit"); // Program exits, prints the log
}

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

/ / Define the global enumeration type State
Enum State {
     STATE_NA, // store order status
     STATE_IDLE, // store position status
     STATE_HOLD_LONG, // store long position directions
     STATE_HOLD_SHORT, // store short position direction
};

/ / Define global floating point type variable
Typedef struct {
     Double bidPrice; // store the buying price
     Double bidAmount; // store the buying amount
     Double askPrice; // store the selling price
     Double askAmount; // store the selling amount
} Book;

उपरोक्त वैश्विक चर के साथ, हम hft ऑब्जेक्ट द्वारा गणना किए गए परिणामों को अलग से संग्रहीत कर सकते हैं, जो प्रोग्राम द्वारा बाद की कॉल के लिए सुविधाजनक है। अगला हम HFT वर्ग में प्रत्येक विधि के विशिष्ट कार्यान्वयन के बारे में बात करेंगे। सबसे पहले, पहली HFT विधि एक कंस्ट्रक्टर है जो दूसरी getTradingWeekDay विधि को कॉल करती है और परिणाम को लॉग में प्रिंट करती है। दूसरी getTradingWeekDay विधि यह निर्धारित करने के लिए सप्ताह के वर्तमान दिन को प्राप्त करती है कि क्या यह एक नई K लाइन है। इसे लागू करना भी बहुत सरल है, टाइमस्टैम्प प्राप्त करें, घंटे और सप्ताह की गणना करें, और अंत में हफ्तों की संख्या लौटाएं; तीसरी getState विधि थोड़ी लंबी है, मैं सिर्फ सामान्य विचार का वर्णन करूंगा, विशिष्ट स्पष्टीकरण के लिए, आप निम्नलिखित कोडिंग ब्लॉक में टिप्पणियों को देख सकते हैं।

अगला, चलो पहले सभी आदेशों को प्राप्त करते हैं, परिणाम एक सामान्य सरणी है, फिर इस सरणी को पार करते हैं, क्रम को रद्द करने के लिए एक-एक करके, फिर स्थिति डेटा प्राप्त करते हैं, एक सरणी वापस करते हैं, और फिर इस सरणी को पार करते हैं, विस्तृत स्थिति जानकारी प्राप्त करते हैं, जिसमें शामिल हैंः दिशा, स्थिति, कल या वर्तमान स्थिति, आदि, और अंत में परिणाम वापस करते हैं; चौथा स्टॉप विधि जानकारी प्रिंट करना है; कोड निम्नानुसार हैः

Public:
    // Constructor
    HFT() {
        _tradingDay = getTradingWeekDay();
        Log("current trading weekday", _tradingDay);
    }
    
    // Get the current day of the week to determine if it is a new K line
    Int getTradingWeekDay() {
        Int seconds = Unix() + 28800; // get the timestamp
        Int hour = (seconds/3600)%24; // hour
        Int weekDay = (seconds/(60*60*24))%7+4; // week
        If (hour > 20) {
            weekDay += 1;
        }
        Return weekDay;
    }
    
    / / Get order data
    State getState() {
        Auto orders = exchange.GetOrders(); // Get all orders
        If (!orders.Valid || orders.size() == 2) { // If there is no order or the length of the order data is equal to 2
            Return STATE_NA;
        }
        
        Bool foundCover = false; // Temporary variable used to control the cancellation of all unexecuted orders
        // Traverse the order array and cancel all unexecuted orders
        For (auto &order : orders) {
            If (order.Id == _coverId) {
                If ((order.Type == ORDER_TYPE_BUY && order.Price < _book.bidPrice - _toleratePrice) ||
                    (order.Type == ORDER_TYPE_SELL && order.Price > _book.askPrice + _toleratePrice)) {
                    exchange.CancelOrder(order.Id, "Cancel Cover Order"); // Cancel order based on order ID
                    _countCancel++;
                    _countRetry++;
                } else {
                    foundCover = true;
                }
            } else {
                exchange.CancelOrder(order.Id); // Cancel order based on order ID
                _countCancel++;
            }
        }
        If (foundCover) {
            Return STATE_NA;
        }
        
        // Get position data
        Auto positions = exchange.GetPosition(); // Get position data
        If (!positions.Valid) { // if the position data is empty
            Return STATE_NA;
        }

        // Traverse the position array to get specific position information
        For (auto &pos : positions) {
            If (pos.ContractType == Symbol) {
                _holdPrice = pos.Price;
                _holdAmount = pos.Amount;
                _holdType = pos.Type;
                Return pos.Type == PD_LONG || pos.Type == PD_LONG_YD ? STATE_HOLD_LONG : STATE_HOLD_SHORT;
            }
        }
        Return STATE_IDLE;
    }
    
    // Print orders and positions information
    Void stop() {
        Log(exchange.GetOrders()); // print order
        Log(exchange.GetPosition()); // Print position
        Log("Stop");
    }

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

// Strategy logic and placing order
Bool Loop() {
    If (exchange.IO("status") == 0) { // If the CTP and the quote server are connected
        LogStatus(_D(), "Server not connect ...."); // Print information to the status bar
        Sleep(1000); // Sleep 1 second
        Return true;
    }
    
    If (_initBalance == 0) {
        _initBalance = _C(exchange.GetAccount).Balance; // Get account balance
    }
    
    Auto day = getTradingWeekDay(); // Get the number of weeks
    If (day != _tradingDay) {
        _tradingDay = day;
        _countCancel = 0;
    }
    
    // Set the futures contract type and get the contract specific information
    If (_ct.is_null()) {
        Log(_D(), "subscribe", Symbol); // Print the log
        _ct = exchange.SetContractType(Symbol); // Set futures contract type
        If (!_ct.is_null()) {
            Auto obj = _ct["Commodity"]["CommodityTickSize"];
            Int volumeMultiple = 1;
            If (obj.is_null()) { // CTP
                Obj = _ct["PriceTick"];
                volumeMultiple = _ct["VolumeMultiple"];
                _exchangeId = _ct["ExchangeID"];
            } else { // Esunny
                volumeMultiple = _ct["Commodity"]["ContractSize"];
                _exchangeId = _ct["Commodity"]["ExchangeNo"];
            }
            If (obj.is_null() || obj <= 0) {
                Panic("PriceTick not found");
            }
            If (_priceTick < 1) {
                exchange.SetPrecision(1, 0); // Set the decimal precision of the price and the quantity of the order.
            }
            _priceTick = double(obj);
            _toleratePrice = _priceTick * TolerateTick;
            _ins = _ct["InstrumentID"];
            Log(_ins, _exchangeId, "PriceTick:", _priceTick, "VolumeMultiple:", volumeMultiple); // print the log
        }
        Sleep(1000); // Sleep 1 second
        Return true;
    }
    
    // Check orders and positions to set status
    Auto depth = exchange.GetDepth(); // Get depth data
    If (!depth.Valid) { // if no depth data is obtained
        LogStatus(_D(), "Market not ready"); // Print status information
        Sleep(1000); // Sleep 1 second
        Return true;
    }
    _countTick++;
    _preBook = _book;
    _book.bidPrice = depth.Bids[0].Price; // "Buying 1" price
    _book.bidAmount = depth.Bids[0].Amount; // "Buying 1" amount
    _book.askPrice = depth.Asks[0].Price; // "Selling 1" price
    _book.askAmount = depth.Asks[0].Amount; // "Selling 1" amount
    // Determine the state of the port data assignment
    If (_preBook.bidAmount == 0) {
        Return true;
    }
    Auto st = getState(); // get the order data
    
    // Print the port data to the status bar
    LogStatus(_D(), _ins, "State:", st,
                "Ask:", depth.Asks[0].Price, depth.Asks[0].Amount,
                "Bid:", depth.Bids[0].Price, depth.Bids[0].Amount,
                "Cancel:", _countCancel,
                "Tick:", _countTick);
}

बहुत कुछ करने के बाद, हम अंत में आदेश दे सकते हैं। व्यापार से पहले, हम पहले कार्यक्रम की वर्तमान होल्डिंग स्थिति की स्थिति का न्याय करते हैं (कोई होल्डिंग स्थिति नहीं, लंबी स्थिति के आदेश, छोटी स्थिति के आदेश), यहां हमने यदि...अन्यथा यदि...अन्यथा यदि तर्क नियंत्रण का उपयोग किया है। वे बहुत सरल हैं, यदि कोई होल्डिंग स्थिति नहीं है, तो स्थिति तर्क की स्थिति के अनुसार खोली जाएगी। यदि होल्डिंग स्थिति है, तो स्थिति तर्क की स्थिति के अनुसार बंद हो जाएगी। सभी की समझ को सुविधाजनक बनाने के लिए, हम तर्क को समझाने के लिए तीन पैराग्राफ का उपयोग करते हैं, उद्घाटन स्थिति भाग के लिएः

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

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

Bool forceCover = _countRetry >= _retryMax; // Boolean value used to control the number of closings
If (st == STATE_IDLE) { // if there is no holding position
    If (_holdAmount > 0) {
        If (_countRetry > 0) {
            _countLoss++; // failure count
        } else {
            _countWin++; // success count
        }
        Auto account = exchange.GetAccount(); // Get account information
        If (account.Valid) { // If get account information
            LogProfit(_N(account.Balance+account.FrozenBalance-_initBalance, 2), "Win:", _countWin, "Loss:", _countLoss); // Record profit value
        }
    }
    _countRetry = 0;
    _holdAmount = 0;
    
    // Judging the status of withdrawal
    If (_countCancel > _cancelMax) {
        Log("Cancel Exceed", _countCancel); // Print the log
        Return false;
    }

    Bool canDo = false; // temporary variable
    If (abs(_book.bidPrice - _book.askPrice) > _priceTick * 1) { // If there is more than 2 hops between the current bid and ask price
        canDo = true;
    }
    If (!canDo) {
        Return true;
    }
    
    Auto bidPrice = depth.Bids[0].Price; // Buying 1 price
    Auto askPrice = depth.Asks[0].Price; // Selling 1 price
    Auto bidAmount = 1.0;
    Auto askAmount = 1.0;
    
    If (_preBook.bidPrice > _book.bidPrice && _book.askAmount < _book.bidAmount) { // If the previous buying price is greater than the current buying price and the current selling volume is less than the buying volume
        bidPrice += _priceTick; // Set the opening long position price
        bidAmount = 2; // set the opening long position volume
    } else if (_preBook.askPrice < _book.askPrice && _book.bidAmount < _book.askAmount) { // If the previous selling price is less than the current selling price and the current buying volume is less than the selling volume
        askPrice -= _priceTick; // set the opening short position volume
        askAmount = 2; // set the opening short position volume
    } else {
        Return true;
    }
    Log(_book.bidPrice, _book.bidAmount, _book.askPrice, _book.askAmount); // Print current market data
    exchange.SetDirection("buy"); // Set the order type to buying long
    exchange.Buy(bidPrice, bidAmount); // buying long and open position
    exchange.SetDirection("sell"); // Set the order type to selling short
    exchange.Sell(askPrice, askAmount); // short sell and open position
}

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

Else if (st == STATE_HOLD_LONG) { // if holding long position
     exchange.SetDirection((_holdType == PD_LONG && _exchangeId == "SHFE") ? "closebuy_today" : "closebuy"); // Set the order type, and close position
     Auto sellPrice = depth.Asks[0].Price; // Get "Selling 1" price
     If (sellPrice > _holdPrice) { // If the current "selling 1" price is greater than the long position opening price
         Log(_holdPrice, "Hit #ff0000"); // Print long position opening price 
         sellPrice = _holdPrice + ProfitTick; // Set closing long position price
     } else if (sellPrice < _holdPrice) { // If the current "selling 1" price is less than the long position opening price
         forceCover = true;
     }
     If (forceCover) {
         Log("StopLoss");
     }
     _coverId = exchange.Sell(forceCover ? depth.Bids[0].Price : sellPrice, _holdAmount); // close long position
     If (!_coverId.Valid) {
         Return false;
     }
}

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

Else if (st == STATE_HOLD_SHORT) { // if holding short position
     exchange.SetDirection((_holdType == PD_SHORT && _exchangeId == "SHFE") ? "closesell_today" : "closesell"); // Set the order type, and close position
     Auto buyPrice = depth.Bids[0].Price; // Get "buying 1" price
     If (buyPrice < _holdPrice) { // If the current "buying 1" price is less than the opening short position price
         Log(_holdPrice, "Hit #ff0000"); // Print the log
         buyPrice = _holdPrice - ProfitTick; // Set the close short position price
     } else if (buyPrice > _holdPrice) { // If the current "buying 1" price is greater than the opening short position price
         forceCover = true;
     }
     If (forceCover) {
         Log("StopLoss");
     }
     _coverId = exchange.Buy(forceCover ? depth.Asks[0].Price : buyPrice, _holdAmount); // close short position
     If (!_coverId.Valid) {
         Return false;
     }
}

उपरोक्त इस रणनीति का पूर्ण विश्लेषण है।https://www.fmz.com/strategy/163427) एफएमजेड क्वांट पर बैकटेस्ट वातावरण को कॉन्फ़िगर किए बिना पूरी रणनीति स्रोत कोड की प्रतिलिपि बनाने के लिए।

बैकटेस्ट के परिणाम

व्यापारिक तर्क

रणनीतिक वक्तव्य

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

हमारे बारे में

एफएमजेड क्वांट एक विशुद्ध रूप से प्रौद्योगिकी-संचालित टीम है जो मात्रात्मक ट्रेडिंग उत्साही लोगों के लिए एक अत्यधिक कुशल उपलब्ध बैकटेस्ट तंत्र प्रदान करती है। हमारा बैकटेस्ट तंत्र एक साधारण मूल्य मैच के बजाय एक वास्तविक एक्सचेंज का अनुकरण कर रहा है। हमें उम्मीद है कि उपयोगकर्ता अपनी क्षमताओं को बेहतर ढंग से खेलने के लिए मंच का लाभ उठा सकते हैं।