सी++ द्वारा लिखित कमोडिटी वायदा उच्च आवृत्ति ट्रेडिंग रणनीति
लेखक:अच्छाई, बनाया गयाः 2020-05-22 15:28:11, अद्यतन किया गयाः 2023-11-02 19:54:28
सारांश
बाजार एक युद्धक्षेत्र है, खरीदार और विक्रेता हमेशा खेल में होते हैं, जो ट्रेडिंग व्यवसाय का शाश्वत विषय भी है। आज साझा की जाने वाली पेनी जंप रणनीति उच्च आवृत्ति वाली रणनीतियों में से एक है, जो मूल रूप से अंतर-बैंक विदेशी मुद्रा बाजार से ली गई है, और अक्सर मुख्यधारा के फैट मुद्रा जोड़े में उपयोग की जाती है।
उच्च आवृत्ति रणनीति वर्गीकरण
उच्च आवृत्ति व्यापार में, दो मुख्य प्रकार की रणनीतियाँ हैं। खरीदार पक्ष की रणनीति और विक्रेता पक्ष की रणनीति। विक्रेता पक्ष की रणनीति आमतौर पर एक बाजार बनाने की रणनीति है, और इन दोनों पक्षों की रणनीतियाँ विरोधी हैं। उदाहरण के लिए, उच्च आवृत्ति मध्यस्थता खरीदार की रणनीति बाजार में सभी अनुचित घटनाओं को सबसे तेज गति से चिकना करने की है, कीमत पर जल्दी से हमला करने की पहल करना, या अन्य बाजार निर्माताओं की गलत कीमत खाना।
बाजार के ऐतिहासिक डेटा या ऑर्डर करने के नियमों का विश्लेषण करने का भी एक तरीका है, जो लंबित ऑर्डर को अनुचित मूल्य पर अग्रिम में भेजता है, और बाजार मूल्य के तेजी से परिवर्तन के साथ निकासी के आदेश भेजता है। ऐसी रणनीतियाँ निष्क्रिय बाजार बनाने में आम हैं, एक बार लंबित ऑर्डर निष्पादित हो जाने के बाद, और एक निश्चित लाभ के बाद या स्टॉप-लॉस की स्थिति तक पहुंचने के बाद, स्थिति बंद हो जाएगी। निष्क्रिय बाजार बनाने की रणनीतियों के लिए आमतौर पर बहुत अधिक गति की आवश्यकता नहीं होती है, लेकिन इसके लिए एक मजबूत रणनीति तर्क और संरचना की आवश्यकता होती है।
पेनी जंप रणनीति क्या है?
पेनी जंप का अंग्रेजी में अनुवाद सूक्ष्म मूल्य वृद्धि का अर्थ है। सिद्धांत बाजार के खरीद मूल्य और बिक्री मूल्य को ट्रैक करना है। फिर, बाजार की कीमत के अनुसार, प्लस या माइनस ट्रैकिंग मूल्य की सूक्ष्म मूल्य वृद्धि, यह स्पष्ट है कि यह एक निष्क्रिय ट्रेडिंग रणनीति है, यह विक्रेता पक्ष की बाजार बनाने की रणनीति से संबंधित है। इसका व्यावसायिक मॉडल और तर्क तरलता प्रदान करने के लिए एक्सचेंज-लिस्टेड सीमा आदेशों पर द्विपक्षीय लेनदेन करना है।
बाजार बनाने की रणनीति के लिए हाथ में एक निश्चित मात्रा में इन्वेंट्री की आवश्यकता होती है, और फिर खरीदार और विक्रेता दोनों पक्षों पर व्यापार होता है। इस रणनीति की मुख्य आय एक्सचेंज द्वारा प्रदान की जाने वाली कमीशन शुल्क वापसी है, साथ ही कम खरीदने और उच्च बेचने से अर्जित मूल्य अंतर है। लेकिन कई उच्च आवृत्ति वाले व्यापारियों के लिए जो बाजार बनाना चाहते हैं, एक बोली-मांग स्प्रेड अर्जित करना एक अच्छी बात है, लेकिन यह लाभ का एक पूर्ण साधन नहीं है।
पेनी जंप रणनीति सिद्धांत
हम जानते हैं कि ट्रेडिंग बाजार में बहुत से खुदरा निवेशक हैं, और कई बड़े निवेशक भी हैं, जैसेः
यदि कोई बड़ा निवेशक 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.
व्यापारी सभी जानते हैं कि यदि किसी निश्चित मूल्य पर बड़ी मात्रा में लंबित ऑर्डर हैं, तो यह मूल्य एक मजबूत समर्थन ((या प्रतिरोध) का गठन करेगा। इसके अलावा, उच्च आवृत्ति वाले व्यापारी भी जानते हैं, यदि वे ऑर्डर बुक गहराई में
Selling Price 400.3, Order volume 50; Buying price 400.2, Order volume 1,
ऑर्डर बुक की गहराई में कीमत 400.1
पेनी जंप रणनीति का कार्यान्वयन
सबसे पहले, बाजार की बहुत कम संभावना के साथ ट्रेडिंग के अवसरों का निरीक्षण करें, और ट्रेडिंग तर्क के अनुसार संबंधित रणनीतियाँ बनाएं। यदि तर्क जटिल है, तो आपको मौजूदा गणितीय ज्ञान का उपयोग करने की आवश्यकता है, मॉडल का उपयोग करने के लिए तर्कहीन घटना की प्रकृति का वर्णन करने के लिए जितना संभव हो सके, और ओवरफिटिंग को कम से कम करें। इसके अलावा, इसे एक बैकटेस्ट इंजन द्वारा सत्यापित किया जाना चाहिए जो
इसके अलावा, कुछ पाठकों को यह पता चल सकता है कि पेनी जंप रणनीति के लिए बाजार में व्यापार के अवसरों की आवश्यकता होती है, यानी बाजार की जरूरत में कम से कम दो
दो
इसके बाद, हम पिछले
रणनीति कोड
व्यापार तर्क को साफ करने के बाद, हम इसे प्राप्त करने के लिए कोड का उपयोग कर सकते हैं। चूंकि एफएमजेड क्वांट प्लेटफॉर्म सी ++ लेखन रणनीति का उपयोग करता है उदाहरण बहुत कम हैं, यहां हम इस रणनीति को लिखने के लिए सी ++ का उपयोग करते हैं, जो सभी के लिए सीखने के लिए सुविधाजनक है, और विविधता कमोडिटी वायदा है। पहले खुलाः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 से अधिक हॉप्स हैं।
इसके बाद, हमें
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
}
आगे, हम बात करेंगे कि लंबी स्थिति को कैसे बंद किया जाए, पहले वर्तमान स्थिति की स्थिति के अनुसार ऑर्डर प्रकार सेट करें, और फिर
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;
}
}
अंत में, आइए देखें कि शॉर्ट पोजीशन को कैसे बंद किया जाए। सिद्धांत उपर्युक्त बंद करने वाली लंबी पोजीशन के विपरीत है। सबसे पहले, वर्तमान पोजीशन की स्थिति के अनुसार, ऑर्डर प्रकार सेट करें, और फिर
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 पर सेट किया गया है, जिससे एक सरल तेज़ गति तर्क होता है। यदि आप वास्तविक बाजार में लाभप्रदता प्राप्त करने के लिए लेनदेन शुल्क को कवर करना चाहते हैं। अधिक अनुकूलन की आवश्यकता है। जैसे कि ऑर्डर स्ट्रीम का उपयोग जीत दर में सुधार के लिए अल्पकालिक पूर्वानुमान करने के लिए करना, प्लस विनिमय शुल्क वापसी, एक स्थायी लाभदायक रणनीति प्राप्त करने के लिए, उच्च आवृत्ति व्यापार पर कई किताबें हैं। मुझे उम्मीद है कि हर कोई अधिक सोच सकता है और केवल सिद्धांत पर रहने के बजाय वास्तविक बाजार में जा सकता है।
हमारे बारे में
एफएमजेड क्वांट एक विशुद्ध रूप से प्रौद्योगिकी-संचालित टीम है जो मात्रात्मक ट्रेडिंग उत्साही लोगों के लिए एक अत्यधिक कुशल उपलब्ध बैकटेस्ट तंत्र प्रदान करती है। हमारा बैकटेस्ट तंत्र एक साधारण मूल्य मैच के बजाय एक वास्तविक एक्सचेंज का अनुकरण कर रहा है। हमें उम्मीद है कि उपयोगकर्ता अपनी क्षमताओं को बेहतर ढंग से खेलने के लिए मंच का लाभ उठा सकते हैं।
- एफएमजेड क्वांट की नई विशेषताः आसानी से HTTP सेवाएँ बनाने के लिए _Serve फ़ंक्शन का प्रयोग करें
- आविष्कारकों ने नई सुविधाओं को मापाः _Serve फ़ंक्शन का उपयोग करके आसानी से HTTP सेवाएं बनाएं
- FMZ क्वांट ट्रेडिंग प्लेटफॉर्म कस्टम प्रोटोकॉल एक्सेस गाइड
- एफएमजेड फंडिंग रेट अधिग्रहण और निगरानी रणनीति
- एफएमजेड के लिए धनराशि प्राप्त करने और निगरानी के लिए रणनीति
- एक रणनीति टेम्पलेट आपको वेबसॉकेट मार्केट का उपयोग करने की अनुमति देता है
- एक नीति टेम्पलेट जो आपको वेबसॉकेट के क्षेत्र का उपयोग करने के लिए अनुमति देता है
- आविष्कारकों के लिए क्वांटिफाइड ट्रेडिंग प्लेटफॉर्म के लिए सामान्य प्रोटोकॉल एक्सेस गाइड
- एफएमजेड उन्नयन के बाद एक सार्वभौमिक बहु-मुद्रा व्यापार रणनीति कैसे बनाएं
- एफएमजेड के उन्नयन के बाद एक सार्वभौमिक बहु-मुद्रा व्यापार रणनीति बनाने के लिए तेजी से कैसे?
- डीसीए ट्रेडिंगः एक व्यापक रूप से प्रयुक्त मात्रात्मक रणनीति