सिस्टम का वर्तमान संस्करण संख्या लौटाता है.
वर्तमान प्रणाली संस्करण संख्या, जैसे3.6.
स्ट्रिंग
संस्करण
function main() {
Log("version:", Version())
}
def main():
Log("version:", Version())
void main() {
Log("version:", Version());
}
सिस्टम संस्करण संख्या डॉकर के प्रोग्राम का संस्करण संख्या है।
नींद का कार्य, जिससे प्रोग्राम कुछ समय के लिए रुक जाता है।
नींद (मिलीसेकंड)
..millisecondपैरामीटर का उपयोग नींद की अवधि और मिलीसेकंड की संख्या निर्धारित करने के लिए किया जाता है।
मिलीसेकंड
सच
संख्या
function main() {
Sleep(1000 * 10) // Wait for 10 seconds
Log("Waited for 10 seconds")
}
def main():
Sleep(1000 * 10)
Log("Waited for 10 seconds")
void main() {
Sleep(1000 * 10);
Log("Waited for 10 seconds");
}
उदाहरण के लिए,Sleep(1000)यह 1 मिलीसेकंड से कम समय के साथ संचालन का समर्थन करता है, उदाहरण के लिए सेटिंगSleep(0.1). यह न्यूनतम पैरामीटर का समर्थन करता है0.000001, यानी नैनो सेकंड हिबरनेशन, जहां 1 नैनो सेकंड के बराबर है1e-6मिलीसेकंड।
रणनीति लिखने के समयPythonभाषा,Sleep(millisecond)मतदान अंतराल, समय-से-प्रतीक्षा संचालन के लिए उपयोग किया जाना चाहिए।time.sleep(second)कार्यPythonहैtimeपुस्तकालय. यह है क्योंकिtime.sleep(second)एक रणनीति में कार्य रणनीति कार्यक्रम वास्तव में समय की एक अवधि के लिए इंतजार करता है जब बैकटेस्टिंग (बैकटेस्टिंग प्रणाली की समय श्रृंखला पर छोड़ने नहीं), तो यह रणनीति बहुत धीरे-धीरे बैकटेस्ट करने के लिए कारण बनता है।
यह निर्धारित करें कि क्या रणनीति का परिचालन वातावरण बैकटेस्टिंग प्रणाली है।
रणनीति एक वास्तविक मूल्य लौटाता है, उदाहरण के लिएःtrueजब बैकटेस्टिंग सिस्टम वातावरण में चलाया जाता है। रणनीति एक गलत मान लौटाता है, उदाहरण के लिएःfalseजब यह प्रत्यक्ष व्यापारिक वातावरण में चलाया जाता है।
बोल
आभासी है
function main() {
if (IsVirtual()) {
Log("The current backtest system environment.")
} else {
Log("The current live trading environment.")
}
}
def main():
if IsVirtual():
Log("The current backtest system environment.")
else:
Log("The current live trading environment.")
void main() {
if (IsVirtual()) {
Log("The current backtest system environment.");
} else {
Log("The current live trading environment.");
}
}
यह निर्धारित करें कि क्या वर्तमान चल रहे वातावरण एक बैकटेस्टिंग प्रणाली है, जिसका उपयोग बैकटेस्टिंग और लाइव ट्रेडिंग के बीच अंतर के साथ संगत होने के लिए किया जाता है।
एक ईमेल भेजें।
एक सफल ईमेल डिलीवरी एक वास्तविक मूल्य देता है, उदाहरण के लिए,true, और एक असफल वितरण एक गलत मान देता है, उदाहरण के लिए,false.
बोल
मेल ((smtpसर्वर, smtpउपयोगकर्ता नाम, smtpपासवर्ड, मेलTo, शीर्षक, शरीर)
निर्दिष्ट करने के लिए प्रयोग किया जाता हैSMTPईमेल प्रेषक का सेवा पता।
smtpसर्वर
सच
स्ट्रिंग
ईमेल प्रेषक का ईमेल पता निर्दिष्ट करने के लिए प्रयोग किया जाता है.
smtpउपयोगकर्तानाम
सच
स्ट्रिंग
दSMTPई-मेल भेजने वाले के मेलबॉक्स के लिए पासवर्ड।
smtpपासवर्ड
सच
स्ट्रिंग
ईमेल प्राप्तकर्ता का ईमेल पता निर्दिष्ट करने के लिए प्रयोग किया जाता है.
mailTo
सच
स्ट्रिंग
ई-मेल का शीर्षक।
शीर्षक
सच
स्ट्रिंग
ईमेल शरीर.
शरीर
सच
स्ट्रिंग
function main(){
Mail("smtp.163.com", "asdf@163.com", "password", "111@163.com", "title", "body")
}
def main():
Mail("smtp.163.com", "asdf@163.com", "password", "111@163.com", "title", "body")
void main() {
Mail("smtp.163.com", "asdf@163.com", "password", "111@163.com", "title", "body");
}
..smtpPasswordपैरामीटर पासवर्ड सेट करता हैSMTPसेवा, मेल बॉक्स पासवर्ड नहीं।
सेट करते समयsmtpServerपैरामीटर, अगर आप बंदरगाह को बदलने की जरूरत है, आप सीधे पैरामीटर में बंदरगाह संख्या जोड़ सकते हैंsmtpServerउदाहरण के लिएः क्यूक्यू मेलsmtp.qq.com:587, जो परीक्षण के लिए उपलब्ध है।
यदि कोई त्रुटि दर्ज की जाती हैःunencryped connection, आपको संशोधित करने की आवश्यकता हैsmtpServerकेMailपैरामीटर प्रारूप हैःssl://xxx.com:xxxउदाहरण के लिए,sslविधिSMTPक्यूक्यू मेल के लिएःssl://smtp.qq.com:465याsmtp://xxx.com:xxx.
यह बैकटेस्टिंग प्रणाली में काम नहीं करता है।
{@मज़ा/ग्लोबल/मेल_गो मेल_गो}
का असिंक्रोनस संस्करणMail function.
..Mail_Goफ़ंक्शन तुरंत एक समवर्ती वस्तु देता है, और आप उपयोग कर सकते हैंwaitमेल डिलीवरी का परिणाम प्राप्त करने के लिए उस समवर्ती ऑब्जेक्ट की विधि। एक सफल मेल डिलीवरी एक सही मान देता है, उदाहरण के लिए,true, और एक असफल वितरण एक गलत मान देता है, उदाहरण के लिए,false.
वस्तु
Mail_Go ((smtpServer, smtpUsername, smtpPassword, mailTo, शीर्षक, शरीर)
इसका प्रयोग निर्दिष्ट करने के लिए किया जाता हैSMTPई-मेल भेजने वाले का सेवा पता।
smtpसर्वर
सच
स्ट्रिंग
इसका प्रयोग ईमेल भेजने वाले का ईमेल पता निर्दिष्ट करने के लिए किया जाता है।
smtpउपयोगकर्तानाम
सच
स्ट्रिंग
दSMTPईमेल भेजने वाले के मेलबॉक्स के लिए पासवर्ड।
smtpपासवर्ड
सच
स्ट्रिंग
इसका उपयोग ईमेल प्राप्तकर्ता का ईमेल पता निर्दिष्ट करने के लिए किया जाता है।
mailTo
सच
स्ट्रिंग
ई-मेल का शीर्षक।
शीर्षक
सच
स्ट्रिंग
ईमेल शरीर.
शरीर
सच
स्ट्रिंग
function main() {
var r1 = Mail_Go("smtp.163.com", "asdf@163.com", "password", "111@163.com", "title", "body")
var r2 = Mail_Go("smtp.163.com", "asdf@163.com", "password", "111@163.com", "title", "body")
var ret1 = r1.wait()
var ret2 = r2.wait()
Log("ret1:", ret1)
Log("ret2:", ret2)
}
# Not supported.
// Not supported.
यह बैकटेस्टिंग प्रणाली में काम नहीं करता है।
{@मज़ा/ग्लोबल/मेल मेल}
फ़िल्टर त्रुटि लॉग.
SetErrorFilter (फ़िल्टर सेट करें)
नियमित अभिव्यक्ति स्ट्रिंग. फ़िल्टर सच स्ट्रिंग
function main() {
SetErrorFilter("502:|503:|tcp|character|unexpected|network|timeout|WSARecv|Connect|GetAddr|no such|reset|http|received|EOF|reused")
}
def main():
SetErrorFilter("502:|503:|tcp|character|unexpected|network|timeout|WSARecv|Connect|GetAddr|no such|reset|http|received|EOF|reused")
void main() {
SetErrorFilter("502:|503:|tcp|character|unexpected|network|timeout|WSARecv|Connect|GetAddr|no such|reset|http|received|EOF|reused");
}
सामान्य त्रुटियों को फ़िल्टर करना।
function main() {
// A random query for a non-existent order with an id of 123, allowing the interface to report an error deliberately
var order = exchange.GetOrder("123")
Log(order)
// Filter http502 errors, GetOrder interface errors, after setting the error filter, the second call to GetOrder will no longer report errors
SetErrorFilter("502:|GetOrder")
order = exchange.GetOrder("123")
Log(order)
}
def main():
order = exchange.GetOrder("123")
Log(order)
SetErrorFilter("502:|GetOrder")
order = exchange.GetOrder("123")
Log(order)
void main() {
TId orderId;
Order order = exchange.GetOrder(orderId);
Log(order);
SetErrorFilter("502:|GetOrder");
order = exchange.GetOrder(orderId);
Log(order);
}
इंटरफ़ेस त्रुटि संदेश फ़िल्टर करें.
इस नियमित अभिव्यक्ति से मेल खाने वाले त्रुटि लॉग लॉग सिस्टम में अपलोड नहीं किए जाएंगे. आप इसे कई बार (बारों की संख्या पर कोई सीमा नहीं) कई फ़िल्टर स्थितियों को सेट करने के लिए कॉल कर सकते हैं. कई बार सेट नियमित अभिव्यक्ति एकत्रित हो जाएगी और एक ही समय में प्रभावी हो जाएगी. आप त्रुटि लॉग को फ़िल्टर करने के लिए उपयोग की जाने वाली नियमित अभिव्यक्ति को रीसेट करने के लिए एक खाली स्ट्रिंग सेट कर सकते हैंःSetErrorFilter("")फ़िल्टर किए गए लॉग अब डॉकर निर्देशिका में लाइव ट्रेडिंग आईडी के अनुरूप डेटाबेस फ़ाइल में नहीं लिखे जाते हैं ताकि डेटाबेस फ़ाइल को फुलाए जाने से लगातार त्रुटि रिपोर्टिंग को रोका जा सके।
लाइव ट्रेडिंग प्रक्रिया आईडी प्राप्त करें.
लाइव ट्रेडिंग प्रक्रिया आईडी लौटाएँ। स्ट्रिंग
GetPid()
function main(){
var id = GetPid()
Log(id)
}
def main():
id = GetPid()
Log(id)
void main() {
auto id = GetPid();
Log(id);
}
अंतिम त्रुटि संदेश प्राप्त करें.
अंतिम त्रुटि संदेश. स्ट्रिंग
GetLastError() प्राप्त करें
function main(){
// Because the order number 123 does not exist, so there will be an error.
exchange.GetOrder("123")
var error = GetLastError()
Log(error)
}
def main():
exchange.GetOrder("123")
error = GetLastError()
Log(error)
void main() {
// Order ID type: TId, so you can't pass in a string, we place an order that doesn't meet the exchange specification to trigger
exchange.GetOrder(exchange.Buy(1, 1));
auto error = GetLastError();
Log(error);
}
यह बैकटेस्टिंग प्रणाली में काम नहीं करता है।
रणनीति बातचीत कमांड प्राप्त करता है।
लौटा आदेश का स्वरूप हैControlName:Data. ControlNameनियंत्रण का नाम है, औरDataयदि इंटरैक्टिव कंट्रोल में इनपुट बॉक्स, ड्रॉप-डाउन बॉक्स और अन्य घटक नहीं हैं (उदाहरण के लिए इनपुट बॉक्स के बिना बटन कंट्रोल) तो लौटाया गया कमांड प्रारूप हैControlName, जो केवल नियंत्रण नाम लौटाता है.
स्ट्रिंग
कमांड प्राप्त करें()
function main(){
while(true) {
var cmd = GetCommand()
if (cmd) {
Log(cmd)
}
Sleep(1000)
}
}
def main():
while True:
cmd = GetCommand()
if cmd:
Log(cmd)
Sleep(1000)
void main() {
while(true) {
auto cmd = GetCommand();
if(cmd != "") {
Log(cmd);
}
Sleep(1000);
}
}
इंटरैक्शन कमांड का पता लगाता है और उपयोग करता हैLogजब यह पता लगाया जाता है बातचीत आदेश आउटपुट करने के लिए समारोह.
function main() {
while (true) {
LogStatus(_D())
var cmd = GetCommand()
if (cmd) {
Log("cmd:", cmd)
var arr = cmd.split(":")
if (arr[0] == "buy") {
Log("Buy, the control without number")
} else if (arr[0] == "sell") {
Log("Sell, the control with the number of:", arr[1])
} else {
Log("Other controls trigger:", arr)
}
}
Sleep(1000)
}
}
def main():
while True:
LogStatus(_D())
cmd = GetCommand()
if cmd:
Log("cmd:", cmd)
arr = cmd.split(":")
if arr[0] == "buy":
Log("Buy, the control without number")
elif arr[0] == "sell":
Log("Sell, the control with the number of:", arr[1])
else:
Log("Other controls trigger:", arr)
Sleep(1000)
#include <iostream>
#include <sstream>
#include <string>
#include <vector>
using namespace std;
void split(const string& s,vector<string>& sv,const char flag = ' ') {
sv.clear();
istringstream iss(s);
string temp;
while (getline(iss, temp, flag)) {
sv.push_back(temp);
}
return;
}
void main() {
while(true) {
LogStatus(_D());
auto cmd = GetCommand();
if (cmd != "") {
vector<string> arr;
split(cmd, arr, ':');
if(arr[0] == "buy") {
Log("Buy, the control without number");
} else if (arr[0] == "sell") {
Log("Sell, the control with the number of:", arr[1]);
} else {
Log("Other controls trigger:", arr);
}
}
Sleep(1000);
}
}
उदाहरण के लिए, रणनीति इंटरैक्टिव नियंत्रण इनपुट बॉक्स के बिना एक नियंत्रण जोड़ता है, इंटरैक्टिव नियंत्रण का नाम हैःbuy, नियंत्रण विवरण की जानकारी हैःbuy, जो एक बटन नियंत्रण है। एक इनपुट बॉक्स के साथ एक नियंत्रण जोड़कर जारी रखें। इंटरैक्टिव नियंत्रण का नाम हैःsellऔर नियंत्रण विवरण संदेश हैःsell, जो एक इंटरैक्टिव नियंत्रण है जो एक बटन और एक इनपुट बॉक्स का संयोजन है। इंटरैक्शन कोड को विभिन्न इंटरैक्शन नियंत्रणों का जवाब देने के लिए रणनीति में डिज़ाइन किया गया हैः
यह बैकटेस्टिंग प्रणाली में काम नहीं करता है।
रणनीति पंजीकरण कोड उत्पन्न करते समय मेटा का मान लिखें.
Metaडेटा।
स्ट्रिंग
मेटा प्राप्त करें
function main() {
// The maximum asset value of the denominated currency allowed by the strategy.
var maxBaseCurrency = null
// Get the metadata when creating the registration code.
var level = GetMeta()
// Detecting the conditions corresponding to Meta.
if (level == "level1") {
// -1 for unrestricted
maxBaseCurrency = -1
} else if (level == "level2") {
maxBaseCurrency = 10
} else if (level == "level3") {
maxBaseCurrency = 1
} else {
maxBaseCurrency = 0.5
}
while(1) {
Sleep(1000)
var ticker = exchange.GetTicker()
// Detect asset values
var acc = exchange.GetAccount()
if (maxBaseCurrency != -1 && maxBaseCurrency < acc.Stocks + acc.FrozenStocks) {
// Stop executing strategy trading logic
LogStatus(_D(), "level:", level, "Positions exceeding the usage limit of the registration code will no longer execute the strategy trading logic!")
continue
}
// Other trading logic
// Normal output of status bar information
LogStatus(_D(), "level:", level, "The strategy is working properly! ticker data: \n", ticker)
}
}
def main():
maxBaseCurrency = null
level = GetMeta()
if level == "level1":
maxBaseCurrency = -1
elif level == "level2":
maxBaseCurrency = 10
elif level == "level3":
maxBaseCurrency = 1
else:
maxBaseCurrency = 0.5
while True:
Sleep(1000)
ticker = exchange.GetTicker()
acc = exchange.GetAccount()
if maxBaseCurrency != -1 and maxBaseCurrency < acc["Stocks"] + acc["FrozenStocks"]:
LogStatus(_D(), "level:", level, "Positions exceeding the usage limit of the registration code will no longer execute the strategy trading logic!")
continue
# Other trading logic
# Normal output of status bar information
LogStatus(_D(), "level:", level, "The strategy is working properly! ticker data: \n", ticker)
void main() {
auto maxBaseCurrency = 0.0;
auto level = GetMeta();
if (level == "level1") {
maxBaseCurrency = -1;
} else if (level == "level2") {
maxBaseCurrency = 10;
} else if (level == "level3") {
maxBaseCurrency = 1;
} else {
maxBaseCurrency = 0.5;
}
while(1) {
Sleep(1000);
auto ticker = exchange.GetTicker();
auto acc = exchange.GetAccount();
if (maxBaseCurrency != -1 && maxBaseCurrency < acc.Stocks + acc.FrozenStocks) {
// Stop execution strategy trading logic.
LogStatus(_D(), "level:", level, "Positions exceeding the usage limit of the registration code will no longer execute the strategy trading logic!");
continue;
}
// Other trading logic
// Normal output of status bar information
LogStatus(_D(), "level:", level, "The strategy is working properly! ticker data: \n", ticker);
}
}
उदाहरण अनुप्रयोग परिदृश्यः उपयोगMetaरणनीति द्वारा संचालित परिसंपत्तियों की मात्रा को सीमित करना।
आवेदन परिदृश्यः विभिन्न रणनीति किरायेदारों के लिए पूंजी सीमाएं करने की आवश्यकता है।Metaपंजीकरण कोड उत्पन्न करते समय निर्धारित मूल्य 190 वर्णों से अधिक नहीं हो सकता है औरGetMeta()यदि कोई मेटाडेटा नहीं है (Meta) एक रणनीति पंजीकरण कोड उत्पन्न करते समय सेट किया जाता है,GetMeta()यह बैकटेस्टिंग प्रणाली में काम नहीं करता है.
आदिम के लिएSocketपहुँच, समर्थनtcp, udp, tls, unixप्रोटोकॉल. 4 लोकप्रिय संचार प्रोटोकॉल का समर्थनःmqtt, nats, amqp, kafkaडेटाबेस से कनेक्ट करने के लिए समर्थनःsqlite3, mysql, postgres, clickhouse.
..Dial()function null लौटाता है यदि यह समय समाप्त हो जाता है। एक सामान्य कॉल एक कनेक्शन ऑब्जेक्ट लौटाता है जिसमें तीन विधियां होती हैंःread, writeऔरclose.readविधि का उपयोग डेटा को पढ़ने के लिए किया जाता है,writeविधि का उपयोग डेटा भेजने औरcloseविधि का उपयोग कनेक्शन को बंद करने के लिए किया जाता है।
दreadविधि निम्नलिखित मापदंडों का समर्थन करती हैः
ws.read().ws.read(2000)दो सेकंड (2000 मिलीसेकंड) का टाइमआउट निर्दिष्ट करता है।-1इसका मतलब है कि फ़ंक्शन तुरंत संदेशों की उपस्थिति या अनुपस्थिति के बावजूद वापस करता है, उदाहरण के लिएःws.read(-1).
पैरामीटर पास करना-2इसका अर्थ है कि फ़ंक्शन तुरंत संदेश के साथ या बिना संदेश लौटाता है, लेकिन केवल नवीनतम संदेश लौटाया जाता है, और बफर किया गया संदेश त्याग दिया जाता है। उदाहरण के लिए,ws.read(-2).read()फ़ंक्शन बफर का वर्णनः
वेबसॉकेट प्रोटोकॉल द्वारा पुश किए जाने वाले आने वाले डेटा डेटा संचय का कारण बन सकते हैं यदि रणनीति के बीच समय अंतरालread()फ़ंक्शन कॉल बहुत लंबा है. ये डेटा बफर में संग्रहीत होते हैं, जिसमें अधिकतम 2000 के साथ एक कतार की डेटा संरचना होती है। 2000 से अधिक होने के बाद, सबसे नया डेटा बफर में प्रवेश करता है और सबसे पुराना डेटा साफ़ किया जाता है।
| परिदृश्य | कोई पैरामीटर नहीं | पैरामीटरः -1 | पैरामीटरः -2 | पैरामीटरः 2000 मिलीसेकंड में |
|---|---|---|---|---|
| पहले से ही बफर में डेटा | सबसे पुराना डेटा तुरंत लौटाएँ | सबसे पुराना डेटा तुरंत लौटाएँ | नवीनतम डेटा तुरंत लौटाएं | सबसे पुराना डेटा तुरंत लौटाएँ |
| बफर में कोई डेटा नहीं | डेटा पर अवरुद्ध होने पर वापस लौटाएँ | तुरंत शून्य लौटाएँ | तुरंत शून्य लौटाएँ | 2000 एमएस प्रतीक्षा करें, यदि कोई डेटा नहीं है तो शून्य लौटाएं, यदि कोई डेटा है तो शून्य लौटाएं |
| WebSocket कनेक्शन डिस्कनेक्ट या अंतर्निहित द्वारा फिर से कनेक्ट किया जाता है | read() फ़ंक्शन रिक्त स्ट्रिंग देता है, अर्थातः |
वस्तु
डायल करें (पते) डायल (पता, टाइमआउट)
अनुरोध पता। पता सच स्ट्रिंग टाइमआउट सेकंड, टाइमआउट झूठी संख्या
function main(){
// Dial supports tcp://，udp://，tls://，unix://protocol, you can add a parameter to specify the number of seconds for the timeout
var client = Dial("tls://www.baidu.com:443")
if (client) {
// write can be followed by a numeric parameter to specify the timeout, write returns the number of bytes successfully sent
client.write("GET / HTTP/1.1\nConnection: Closed\n\n")
while (true) {
// read can be followed by a numeric parameter specifying the timeout in milliseconds. Returning null indicates an error or timeout or that the socket has been closed
var buf = client.read()
if (!buf) {
break
}
Log(buf)
}
client.close()
}
}
def main():
client = Dial("tls://www.baidu.com:443")
if client:
client.write("GET / HTTP/1.1\nConnection: Closed\n\n")
while True:
buf = client.read()
if not buf:
break
Log(buf)
client.close()
void main() {
auto client = Dial("tls://www.baidu.com:443");
if(client.Valid) {
client.write("GET / HTTP/1.1\nConnection: Closed\n\n");
while(true) {
auto buf = client.read();
if(buf == "") {
break;
}
Log(buf);
}
client.close();
}
}
डायल फ़ंक्शन कॉल का उदाहरणः
function main() {
LogStatus("Connecting...")
// Accessing WebSocket interface of Binance
var client = Dial("wss://stream.binance.com:9443/ws/!ticker@arr")
if (!client) {
Log("Connection failed, program exited")
return
}
while (true) {
// read returns only the data retrieved after the read call
var buf = client.read()
if (!buf) {
break
}
var table = {
type: 'table',
title: 'Ticker Chart',
cols: ['Currency', 'Highest', 'Lowest', 'Buy 1', 'Sell 1', 'Last traded price', 'Volume', 'Update time'],
rows: []
}
var obj = JSON.parse(buf)
_.each(obj, function(ticker) {
table.rows.push([ticker.s, ticker.h, ticker.l, ticker.b, ticker.a, ticker.c, ticker.q, _D(ticker.E)])
})
LogStatus('`' + JSON.stringify(table) + '`')
}
client.close()
}
import json
def main():
LogStatus("Connecting...")
client = Dial("wss://stream.binance.com:9443/ws/!ticker@arr")
if not client:
Log("Connection failed, program exited")
return
while True:
buf = client.read()
if not buf:
break
table = {
"type" : "table",
"title" : "Ticker Chart",
"cols" : ['Currency', 'Highest', 'Lowest', 'Buy 1', 'Sell 1', 'Last traded price', 'Volume', 'Update time'],
"rows" : []
}
obj = json.loads(buf)
for i in range(len(obj)):
table["rows"].append([obj[i]["s"], obj[i]["h"], obj[i]["l"], obj[i]["b"], obj[i]["a"], obj[i]["c"], obj[i]["q"], _D(int(obj[i]["E"]))])
LogStatus('`' + json.dumps(table) + '`')
client.close()
void main() {
LogStatus("Connecting...");
auto client = Dial("wss://stream.binance.com:9443/ws/!ticker@arr");
if(!client.Valid) {
Log("Connection failed, program exited");
return;
}
while(true) {
auto buf = client.read();
if(buf == "") {
break;
}
json table = R"({
"type" : "table",
"title" : "Ticker Chart",
"cols" : ["Currency", "Highest", "Lowest", "Buy 1", "Sell 1", "Last traded price", "Volume", "Update time"],
"rows" : []
})"_json;
json obj = json::parse(buf);
for(auto& ele : obj.items()) {
table["rows"].push_back({ele.value()["s"], ele.value()["h"], ele.value()["l"], ele.value()["b"], ele.value()["a"], ele.value()["c"],
ele.value()["q"], _D(ele.value()["E"])});
}
LogStatus("`" + table.dump() + "`");
}
client.close();
}
बिनेंस के वेबसॉकेट टिकर इंटरफ़ेस तक पहुँचने के लिएः
var ws = null
function main(){
var param = {
"op": "subscribe",
"args": [{
"channel": "tickers",
"instId": "BTC-USDT"
}]
}
// When calling Dial function, specify reconnect=true to set reconnection mode and payload to be the message sent when reconnecting. When the WebSocket connection is disconnected, it will reconnect and send messages automatically.
ws = Dial("wss://ws.okx.com:8443/ws/v5/public|compress=gzip_raw&mode=recv&reconnect=true&payload="+ JSON.stringify(param))
if(ws){
var pingCyc = 1000 * 20
var lastPingTime = new Date().getTime()
while(true){
var nowTime = new Date().getTime()
var ret = ws.read()
Log("ret:", ret)
if(nowTime - lastPingTime > pingCyc){
var retPing = ws.write("ping")
lastPingTime = nowTime
Log("Send : ping", "#FF0000")
}
LogStatus("Current time:", _D())
Sleep(1000)
}
}
}
function onexit() {
ws.close()
Log("exit")
}
import json
import time
ws = None
def main():
global ws
param = {
"op": "subscribe",
"args": [{
"channel": "tickers",
"instId": "BTC-USDT"
}]
}
ws = Dial("wss://ws.okx.com:8443/ws/v5/public|compress=gzip_raw&mode=recv&reconnect=true&payload=" + json.dumps(param))
if ws:
pingCyc = 1000 * 20
lastPingTime = time.time() * 1000
while True:
nowTime = time.time() * 1000
ret = ws.read()
Log("ret:", ret)
if nowTime - lastPingTime > pingCyc:
retPing = ws.write("ping")
lastPingTime = nowTime
Log("Send: ping", "#FF0000")
LogStatus("Current time:", _D())
Sleep(1000)
def onexit():
ws.close()
Log("exit")
auto objWS = Dial("wss://ws.okx.com:8443/ws/v5/public|compress=gzip_raw&mode=recv&reconnect=true");
void main() {
json param = R"({
"op": "subscribe",
"args": [{
"channel": "tickers",
"instId": "BTC-USDT"
}]
})"_json;
objWS.write(param.dump());
if(objWS.Valid) {
uint64_t pingCyc = 1000 * 20;
uint64_t lastPingTime = Unix() * 1000;
while(true) {
uint64_t nowTime = Unix() * 1000;
auto ret = objWS.read();
Log("ret:", ret);
if(nowTime - lastPingTime > pingCyc) {
auto retPing = objWS.write("ping");
lastPingTime = nowTime;
Log("Send: ping", "#FF0000");
}
LogStatus("Current time:", _D());
Sleep(1000);
}
}
}
void onexit() {
objWS.close();
Log("exit");
}
OKX
var ws = null
function main(){
var param = {"sub": "market.btcusdt.detail", "id": "id1"}
ws = Dial("wss://api.huobi.pro/ws|compress=gzip&mode=recv&reconnect=true&payload="+ JSON.stringify(param))
if(ws){
while(1){
var ret = ws.read()
Log("ret:", ret)
// Respond to heartbeat packet operations
try {
var jsonRet = JSON.parse(ret)
if(typeof(jsonRet.ping) == "number") {
var strPong = JSON.stringify({"pong" : jsonRet.ping})
ws.write(strPong)
Log("Respond to ping, send pong:", strPong, "#FF0000")
}
} catch(e) {
Log("e.name:", e.name, "e.stack:", e.stack, "e.message:", e.message)
}
LogStatus("Current time:", _D())
Sleep(1000)
}
}
}
function onexit() {
ws.close()
Log("Execute the ws.close() function")
}
import json
ws = None
def main():
global ws
param = {"sub" : "market.btcusdt.detail", "id" : "id1"}
ws = Dial("wss://api.huobi.pro/ws|compress=gzip&mode=recv&reconnect=true&payload=" + json.dumps(param))
if ws:
while True:
ret = ws.read()
Log("ret:", ret)
# Respond to heartbeat packet operations
try:
jsonRet = json.loads(ret)
if "ping" in jsonRet and type(jsonRet["ping"]) == int:
strPong = json.dumps({"pong" : jsonRet["ping"]})
ws.write(strPong)
Log("Respond to ping, send pong:", strPong, "#FF0000")
except Exception as e:
Log("e:", e)
LogStatus("Current time:", _D())
Sleep(1000)
def onexit():
ws.close()
Log("Execute the ws.close() function")
using namespace std;
void main() {
json param = R"({"sub" : "market.btcusdt.detail", "id" : "id1"})"_json;
auto ws = Dial("wss://api.huobi.pro/ws|compress=gzip&mode=recv&reconnect=true&payload=" + param.dump());
if(ws.Valid) {
while(true) {
auto ret = ws.read();
Log("ret:", ret);
// Respond to heartbeat packet operations
try
{
auto jsonRet = json::parse(ret);
if(jsonRet["ping"].is_number()) {
json pong = R"({"pong" : 0})"_json;
pong["pong"] = jsonRet["ping"];
auto strPong = pong.dump();
ws.write(strPong);
Log("Respond to ping, send pong:", strPong, "#FF0000");
}
} catch(exception &e)
{
Log("e:", e.what());
}
LogStatus("Current time:", _D());
Sleep(1000);
}
}
}
void onexit() {
// ws.close();
Log("Execute the ws.close() function");
}
Huobi
function getLogin(pAccessKey, pSecretKey, pPassphrase) {
// Signature function for login
var ts = (new Date().getTime() / 1000).toString()
var login = {
"op": "login",
"args":[{
"apiKey" : pAccessKey,
"passphrase" : pPassphrase,
"timestamp" : ts,
"sign" : exchange.HMAC("sha256", "base64", ts + "GET" + "/users/self/verify", pSecretKey) // exchange.HMAC has been deprecated and is temporarily supported. Please use the latest exchange.Encode function instead.
}]
}
return login
}
var client_private = null
function main() {
// Because the read function uses a timeout setting, filtering the timeout reports errors that would otherwise be output with redundant errors
SetErrorFilter("timeout")
// Position channel subscription information
var posSubscribe = {
"op": "subscribe",
"args": [{
"channel": "positions",
"instType": "ANY"
}]
}
var accessKey = "xxx"
var secretKey = "xxx"
var passphrase = "xxx"
client_private = Dial("wss://ws.okx.com:8443/ws/v5/private")
client_private.write(JSON.stringify(getLogin(accessKey, secretKey, passphrase)))
Sleep(3000) // When logging in, you cannot subscribe to private channels immediately, you need to wait for server response
client_private.write(JSON.stringify(posSubscribe))
if (client_private) {
var lastPingTS = new Date().getTime()
while (true) {
var buf = client_private.read(-1)
if (buf) {
Log(buf)
}
// Detect disconnection, reconnect
if (buf == "" && client_private.write(JSON.stringify(posSubscribe)) == 0) {
Log("Disconnection detected, close connection, reconnect")
client_private.close()
client_private = Dial("wss://ws.okx.com:8443/ws/v5/private")
client_private.write(JSON.stringify(getLogin(accessKey, secretKey, passphrase)))
Sleep(3000)
client_private.write(JSON.stringify(posSubscribe))
}
// Send heartbeat packets
var nowPingTS = new Date().getTime()
if (nowPingTS - lastPingTS > 10 * 1000) {
client_private.write("ping")
lastPingTS = nowPingTS
}
}
}
}
function onexit() {
var ret = client_private.close()
Log("Close the connection!", ret)
}
import json
import time
def getLogin(pAccessKey, pSecretKey, pPassphrase):
ts = str(time.time())
login = {
"op": "login",
"args":[{
"apiKey" : pAccessKey,
"passphrase" : pPassphrase,
"timestamp" : ts,
"sign" : exchange.HMAC("sha256", "base64", ts + "GET" + "/users/self/verify", pSecretKey)
}]
}
return login
client_private = None
def main():
global client_private
SetErrorFilter("timeout")
posSubscribe = {
"op": "subscribe",
"args": [{
"channel": "positions",
"instType": "ANY"
}]
}
accessKey = "xxx"
secretKey = "xxx"
passphrase = "xxx"
client_private = Dial("wss://ws.okx.com:8443/ws/v5/private")
client_private.write(json.dumps(getLogin(accessKey, secretKey, passphrase)))
Sleep(3000)
client_private.write(json.dumps(posSubscribe))
if client_private:
lastPingTS = time.time() * 1000
while True:
buf = client_private.read(-1)
if buf:
Log(buf)
if buf == "" and client_private.write(json.dumps(posSubscribe)) == 0:
Log("Disconnection detected, close connection, reconnect")
ret = client_private.close()
client_private = Dial("wss://ws.okx.com:8443/ws/v5/private")
client_private.write(json.dumps(getLogin(accessKey, secretKey, passphrase)))
Sleep(3000)
client_private.write(json.dumps(posSubscribe))
nowPingTS = time.time() * 1000
if nowPingTS - lastPingTS > 10 * 1000:
client_private.write("ping")
lastPingTS = nowPingTS
def onexit():
ret = client_private.close()
Log("Close the connection!", ret)
auto client_private = Dial("wss://ws.okx.com:8443/ws/v5/private");
json getLogin(string pAccessKey, string pSecretKey, string pPassphrase) {
auto ts = std::to_string(Unix());
json login = R"({
"op": "login",
"args": [{
"apiKey": "",
"passphrase": "",
"timestamp": "",
"sign": ""
}]
})"_json;
login["args"][0]["apiKey"] = pAccessKey;
login["args"][0]["passphrase"] = pPassphrase;
login["args"][0]["timestamp"] = ts;
login["args"][0]["sign"] = exchange.HMAC("sha256", "base64", ts + "GET" + "/users/self/verify", pSecretKey);
return login;
}
void main() {
SetErrorFilter("timeout");
json posSubscribe = R"({
"op": "subscribe",
"args": [{
"channel": "positions",
"instType": "ANY"
}]
})"_json;
auto accessKey = "xxx";
auto secretKey = "xxx";
auto passphrase = "xxx";
client_private.write(getLogin(accessKey, secretKey, passphrase).dump());
Sleep(3000);
client_private.write(posSubscribe.dump());
if (client_private.Valid) {
uint64_t lastPingTS = Unix() * 1000;
while (true) {
auto buf = client_private.read(-1);
if (buf != "") {
Log(buf);
}
if (buf == "") {
if (client_private.write(posSubscribe.dump()) == 0) {
Log("Disconnection detected, close connection, reconnect");
client_private.close();
client_private = Dial("wss://ws.okx.com:8443/ws/v5/private");
client_private.write(getLogin(accessKey, secretKey, passphrase).dump());
Sleep(3000);
client_private.write(posSubscribe.dump());
}
}
uint64_t nowPingTS = Unix() * 1000;
if (nowPingTS - lastPingTS > 10 * 1000) {
client_private.write("ping");
lastPingTS = nowPingTS;
}
}
}
}
void onexit() {
client_private.close();
Log("exit");
}
OKX
var client = null
function main() {
// client = Dial("sqlite3://:memory:") // Using an in-memory database
client = Dial("sqlite3://test1.db") // Open/connect to the database file in the docker's directory
// record handle
var sqlite3Handle = client.fd()
Log("sqlite3Handle:", sqlite3Handle)
// Querying tables in the database
var ret = client.exec("SELECT name FROM sqlite_master WHERE type='table'")
Log(ret)
}
function onexit() {
Log("Execute client.close()")
client.close()
}
// Not supported
// Not supported
एक डेटाबेस से कनेक्ट करते समय डायल फ़ंक्शन द्वारा लौटाए गए कनेक्शन ऑब्जेक्ट में दो विधि फ़ंक्शन होते हैं जो इसके लिए अद्वितीय होते हैंः
exec(sqlString): SQL कथन को निष्पादित करने के लिए उपयोग किया जाता हैDBExec() function.fd():fd()फ़ंक्शन एक हैंडल (जैसे, हैंडल चर हैडल है) वापस करता है जिसका उपयोग अन्य थ्रेडों द्वारा फिर से कनेक्ट करने के लिए किया जाएगा (भले ही डायल द्वारा बनाई गई ऑब्जेक्ट को पहले ही निष्पादन द्वारा बंद कर दिया गया हो)close()कनेक्शन को बंद करने के लिए कार्य) हैंडल कोDial()उदाहरण के लिए,Dial(handle)पुनः उपयोग कनेक्शन।
निम्नलिखित डायल फ़ंक्शन का एक उदाहरण है जो एकsqlite3 database.विवरणaddressपैरामीटर, द्वारा अलग|सामान्य पते के बाद प्रतीक:wss://ws.okx.com:8443/ws/v5/publicयदि कोई है।|पैरामीटर स्ट्रिंग में वर्ण, तो||विभाजक चिह्न के रूप में प्रयोग किया जाता है. इसके बाद का हिस्सा कुछ समारोह पैरामीटर सेटिंग्स है, और प्रत्येक पैरामीटर के साथ जुड़ा हुआ है&उदाहरण के लिए,ss5प्रॉक्सी और संपीड़न मापदंडों को एक साथ निम्नानुसार सेट किया जा सकता हैःDial("wss://ws.okx.com:8443/ws/v5/public|proxy=socks5://xxx:9999&compress=gzip_raw&mode=recv")
| डायल फ़ंक्शन के पते पैरामीटर द्वारा समर्थित फ़ंक्शन | पैरामीटर का वर्णन |
|---|---|
| वेबसॉकेट प्रोटोकॉल डेटा संपीड़न से संबंधित पैरामीटरः compress=parameter value | compress संपीड़न विधि है, संपीड़न पैरामीटर विकल्प हैंः gzip_raw, gzip, आदि यदि gzip विधि मानक gzip नहीं है, तो आप विस्तारित विधि का उपयोग कर सकते हैंः gzip_raw |
| वेबसॉकेट प्रोटोकॉल डेटा संपीड़न से संबंधित पैरामीटरः मोड=पैरामीटर मान | मोड संपीड़न मोड है, मोड पैरामीटर दोहरी हो सकती है, भेजें, recv. दोहरी दो तरफा संपीड़न है, संपीड़ित डेटा भेजें, संपीड़ित डेटा प्राप्त करें. send संपीड़ित डेटा भेजें है. recv संपीड़ित डेटा प्राप्त करें, स्थानीय decompression है. |
| वेबसॉकेट प्रोटोकॉल अंतर्निहित ऑटो-पुनः कनेक्ट संबंधित पैरामीटर सेट करता हैः reconnect=parameter value | reconnect reconnect सेट करना है, reconnect=true reconnect सक्षम करना है। डिफ़ॉल्ट रूप से यह पैरामीटर सेट नहीं होने पर कोई reconnect नहीं है. |
| वेबसॉकेट प्रोटोकॉल अंतर्निहित ऑटो-पुनः कनेक्ट संबंधित मापदंडों को सेट करता हैः अंतराल=पैरामीटर मान | अंतराल पुनः प्रयास अंतराल है, मिलीसेकंड में, अंतराल=10000 10 सेकंड का पुनः प्रयास अंतराल है, डिफ़ॉल्ट 1 सेकंड है जब यह सेट नहीं है, यानी अंतराल=1000. |
| वेबसॉकेट प्रोटोकॉल अंतर्निहित ऑटो-पुनः कनेक्ट संबंधित मापदंडों को सेट करता हैः पेलोड=पैरामीटर मान | पेलोड वह सब्सक्रिप्शन संदेश है जिसे वेबसॉकेट को फिर से कनेक्ट करने पर भेजना आवश्यक है, उदाहरण के लिएः पेलोड=ओकोकोक. |
| Socks5 प्रॉक्सी से संबंधित पैरामीटर: proxy=पैरामीटर मान | प्रॉक्सी ss5 प्रॉक्सी सेटिंग है, पैरामीटर मान प्रारूपः socks5://name:pwd@192.168.0.1:1080, नाम ss5 सर्वर उपयोगकर्ता नाम है, pwd ss5 सर्वर लॉगिन पासवर्ड है, 1080 ss5 सेवा पोर्ट है. |
..Dial()फ़ंक्शन केवल लाइव ट्रेडिंग के लिए समर्थित है.
डायल फ़ंक्शन का उपयोग करके डेटाबेस से कनेक्ट करते समय, कनेक्शन स्ट्रिंग प्रत्येक डेटाबेस के लिए go भाषा ड्राइवर प्रोजेक्ट के संदर्भ में लिखी जाती है.
| समर्थित डेटाबेस | ड्राइविंग परियोजनाएं | कनेक्शन स्ट्रिंग | टिप्पणी |
|---|---|---|---|
| स्क्लाइट3 | github.com/mattn/go-sqlite3 | sqlite3://file:test.db?cache=shared&mode=memory फ़ाइलःtest.db?cache=shared&mode=memory फ़ाइलःtest.db?cache=shared&mode=memory | ..sqlite3://उपसर्ग इंगित करता है कि एक sqlite3 डेटाबेस का उपयोग किया जा रहा है, उदाहरण कॉलःDial("sqlite3://test1.db") |
| mysql | github.com/go-sql-driver/mysql | mysql://username:yourpassword@tcp(localhost:3306) /आपका डेटाबेस?charset=utf8mb4 | – |
| उपजाऊ | github.com/lib/pq | postgres://user=postgres dbname=yourdatabase sslmode=disable password=yourpassword होस्ट=localhost पोर्ट=5432 | – |
| क्लिकहाउस | github.com/ClickHouse/clickhouse-go | क्लिकहाउस://tcp://host:9000?username=username&password=yourpassword&database=youdatabase | – |
कृपया ध्यान दें कि जबpayloadसामग्री में सेटaddressपैरामीटर में वर्ण होते हैं=या अन्य विशेष वर्ण, यह पार्सिंग को प्रभावित कर सकता हैaddressपैरामीटरDialकार्य, जैसे कि निम्नलिखित उदाहरण।
backPack Exchange वेबसॉकेट निजी इंटरफ़ेस कॉल उदाहरणः
var client = null
function main() {
// Base64-encoded public key of the key pair, i.e. the access key configured on FMZ
var base64ApiKey = "xxx"
var ts = String(new Date().getTime())
var data = "instruction=subscribe×tamp=" + ts + "&window=5000"
// Since signEd25519 returns a base64 encoding, it contains the character "="
var signature = signEd25519(data)
// The payload may contain the character "=" after being encoded by JSON
payload = {
"method": "SUBSCRIBE",
"params": ["account.orderUpdate"],
"signature": [base64ApiKey, signature, ts, "5000"]
}
client = Dial("wss://ws.backpack.exchange")
client.write(JSON.stringify(payload))
if (!client) {
Log("Connection failed, program exited")
return
}
while (true) {
var buf = client.read()
Log(buf)
}
}
function onexit() {
client.close()
}
function signEd25519(data) {
return exchange.Encode("ed25519.seed", "raw", "base64", data, "base64", "{{secretkey}}")
}
कोड में निम्नलिखित कॉल ठीक काम करता हैः
client = Dial("wss://ws.backpack.exchange")
client.write(JSON.stringify(payload))
यदि आप इसे सीधे में लिखते हैंpayload, यह ठीक से काम नहीं करेगा, उदाहरण के लिएः
client = Dial("wss://ws.backpack.exchange|payload=" + JSON.stringify(payload))
वर्तमान में, केवल जावास्क्रिप्ट का उपयोग करने का समर्थन करता हैmqtt, nats, amqp, औरkafkaडायल फ़ंक्शन में संचार प्रोटोकॉल। चार प्रोटोकॉल के उपयोग को दिखाने के लिए जावास्क्रिप्ट भाषा रणनीति कोड का उपयोग एक उदाहरण के रूप में किया जाता हैःmqtt, nats, amqp, औरkafka:
// We need to configure and deploy proxy servers for each protocol first.
// For the sake of demonstration, the subscription (read operation) and publishing (write operation) of the topic test_topic are all performed in the current strategy.
var arrConn = []
var arrName = []
function main() {
LogReset(1)
conn_nats = Dial("nats://admin@127.0.0.1:4222?topic=test_topic")
conn_mqtt = Dial("mqtt://127.0.0.1:1883?topic=test_topic")
conn_amqp = Dial("amqp://q:admin@127.0.0.1:5672/?queue=test_Queue")
conn_kafka = Dial("kafka://localhost:9092/test_topic")
arrConn = [conn_nats, conn_amqp, conn_mqtt, conn_kafka]
arrName = ["nats", "amqp", "mqtt", "kafka"]
while (true) {
for (var i in arrConn) {
var conn = arrConn[i]
var name = arrName[i]
// Write data
conn.write(name + ", time: " + _D() + ", test msg.")
// Read data
var readMsg = conn.read(1000)
Log(name + " readMsg: ", readMsg, "#FF0000")
}
Sleep(1000)
}
}
function onexit() {
for (var i in arrConn) {
arrConn[i].close()
Log("close", arrName[i], "connect")
}
}
विस्तृत प्रलेखन संदर्भःएफएमजेड का अन्वेषण: लाइव ट्रेडिंग रणनीतियों के बीच संचार प्रोटोकॉल का अभ्यास
HTTP अनुरोध भेजें.
अनुरोध के प्रतिक्रिया डेटा को लौटाता है. यदि लौटा मूल्य एक हैJSONस्ट्रिंग, यह द्वारा पार्स किया जा सकता हैJSON.parse()कार्य मेंJavaScriptभाषा रणनीति, औरjson::parse()कार्य मेंC++यदि विकल्प संरचना में डिबग सही पर सेट है, तो रिटर्न मान एक ऑब्जेक्ट (JSON) है; यदि डिबग गलत पर सेट है, तो रिटर्न मान एक स्ट्रिंग है.
स्ट्रिंग, ऑब्जेक्ट
HttpQuery (URL) HttpQuery ((url, विकल्प)
Http अनुरोध यूआरएल. यूआरएल सच स्ट्रिंग उदाहरण के लिए, Http अनुरोध से संबंधित सेटिंग्स को इस प्रकार संरचित किया जा सकता हैः
{
method: "POST",
body: "a=10&b=20&c=30",
charset: "UTF-8",
cookie: "session_id=12345; lang=en",
profile: "chrome_103",
debug: false,
headers: {"TEST-HTTP-QUERY": "123"},
timeout: 1000
}
tlsउंगलियों के निशान.
समर्थित सेटिंग्स में निम्नलिखित विकल्प शामिल हैंः
chrome_:"chrome_103", "chrome_104", "chrome_105", "chrome_106", "chrome_107", "chrome_108", "chrome_109", "chrome_110", "chrome_111", "chrome_112", "chrome_117",
सफारी_:"safari_15_6_1", "safari_16_0", "safari_ipad_15_6", "safari_ios_15_5", "safari_ios_15_6", "safari_ios_16_0",
फ़ायरफ़ॉक्सः"firefox_102", "firefox_104", "firefox_105", "firefox_106", "firefox_108", "firefox_110", "firefox_117",
opera_:"opera_89", "opera_90", "opera_91",
zalando_:"zalando_android_mobile", "zalando_ios_mobile",
नाइकी_:"nike_ios_mobile", "nike_android_mobile",
बादलबिहार:"cloudscraper",
mms_:"mms_ios",
जाल_:"mesh_ios", "mesh_ios_1", "mesh_ios_2", "mesh_android", "mesh_android_1", "mesh_android_2",
पुष्टि_:"confirmed_ios", "confirmed_android",
ठीक है."okhttp4_android_7", "okhttp4_android_8", "okhttp4_android_9", "okhttp4_android_10", "okhttp4_android_11", "okhttp4_android_12", "okhttp4_android_13",true,HttpQueryफ़ंक्शन कॉल पूर्ण उत्तर संदेश लौटाता है.false, केवल डेटाBodyके उत्तर संदेश को वापस कर दिया जाता है।profileक्षेत्र को छोड़ दिया जा सकता है।विकल्प झूठी वस्तु
function main(){
// An example of GET access without parameters
var info = JSON.parse(HttpQuery("https://www.okx.com/api/v5/public/time"))
Log(info)
// An example of GET access with parameters
var ticker = JSON.parse(HttpQuery("https://www.okx.com/api/v5/market/books?instId=BTC-USDT"))
Log(ticker)
}
import json
import urllib.request
def main():
# HttpQuery does not support Python, you can use the urllib/urllib2 library instead
info = json.loads(urllib.request.urlopen("https://www.okx.com/api/v5/public/time").read().decode('utf-8'))
Log(info)
ticker = json.loads(urllib.request.urlopen("https://www.okx.com/api/v5/market/books?instId=BTC-USDT").read().decode('utf-8'))
Log(ticker)
void main() {
auto info = json::parse(HttpQuery("https://www.okx.com/api/v5/public/time"));
Log(info);
auto ticker = json::parse(HttpQuery("https://www.okx.com/api/v5/market/books?instId=BTC-USDT"));
Log(ticker);
}
ओकेएक्स सार्वजनिक टिकर एपीआई इंटरफ़ेस तक पहुँचने का एक उदाहरण।
function main() {
// Setting proxy and sending an http request for this time, no username, no password, this http request will be sent through the proxy
HttpQuery("socks5://127.0.0.1:8889/http://www.baidu.com/")
// Setting proxy and sending an http request for this time, enter the user name and password, only the current call to HttpQuery takes effect, and then call HttpQuery again ("http://www.baidu.com") so that the proxy will not be used.
HttpQuery("socks5://username:password@127.0.0.1:8889/http://www.baidu.com/")
}
# HttpQuery does not support Python, you can use the urllib/urllib2 library instead
void main() {
HttpQuery("socks5://127.0.0.1:8889/http://www.baidu.com/");
HttpQuery("socks5://username:password@127.0.0.1:8889/http://www.baidu.com/");
}
HttpQuery फ़ंक्शन प्रॉक्सी सेटिंग्स का उपयोग करता है.
..HttpQuery()कार्य केवल समर्थन करता हैJavaScript, C++भाषा,Pythonभाषा का उपयोग कर सकते हैंurllibलाइब्रेरी सीधे HTTP अनुरोध भेजने के लिए.HttpQuery()मुख्य रूप से एक्सचेंज के उन इंटरफेस तक पहुंचने के लिए उपयोग किया जाता है जिन्हें हस्ताक्षर की आवश्यकता नहीं होती है, जैसे कि सार्वजनिक इंटरफेस जैसे कि टिकर जानकारी।HttpQuery()अनुरोध भेजने के लिए बैकटेस्टिंग प्रणाली में इस्तेमाल किया जा सकता है (केवलGETडेटा प्राप्त करने के लिए बैकटेस्टिंग 20 विज़िट के उपयोग तक सीमित है।URLs, औरHttpQuery()यात्राओं डेटा कैश होगा.URLदूसरी बार एक्सेस किया जाता है, तोHttpQuery()फ़ंक्शन कैश किए गए डेटा को लौटाता है और कोई और वास्तविक नेटवर्क अनुरोध नहीं होता है।
{@fun/Global/HttpQuery_Go HttpQuery_Go}
एक HTTP अनुरोध भेजता है, जो कि एक असिंक्रोनस संस्करण हैHttpQuery function.
..HttpQuery_Go()फ़ंक्शन तुरंत एक समवर्ती ऑब्जेक्ट लौटाता है जिसका उपयोग HTTP अनुरोध का परिणाम प्राप्त करने के लिए किया जा सकता हैwaitविधि की विधिJSON.parse()फ़ंक्शन का उपयोग किया जा सकता हैJSON.parse()कार्य मेंJavaScriptभाषा की रणनीति।
वस्तु
HttpQuery_Go ((url) HttpQuery_Go ((url, विकल्प)
Http अनुरोध यूआरएल. यूआरएल सच स्ट्रिंग उदाहरण के लिए, Http अनुरोध से संबंधित सेटिंग्स को इस प्रकार संरचित किया जा सकता हैः
{
method: "POST",
body: "a=10&b=20&c=30",
charset: "UTF-8",
cookie: "session_id=12345; lang=en",
// profile: "",
debug: false,
headers: {"TEST-HTTP-QUERY": "123"},
timeout: 1000
}
tls fingerprints.true, यहHttpQuery_Goफ़ंक्शन कॉल पूर्ण उत्तर संदेश लौटाता है.false, केवल डेटाBodyके उत्तर संदेश को वापस कर दिया जाता है।profileक्षेत्र को छोड़ दिया जा सकता है।विकल्प झूठी वस्तु
function main() {
// Create the first asynchronous thread
var r1 = HttpQuery_Go("https://www.okx.com/api/v5/market/tickers?instType=SPOT")
// Create the second asynchronous thread
var r2 = HttpQuery_Go("https://api.huobi.pro/market/tickers")
// Get the return value of the first asynchronous thread call
var tickers1 = r1.wait()
// Get the return value of the second asynchronous thread call
var tickers2 = r2.wait()
// Print results
Log("tickers1:", tickers1)
Log("tickers2:", tickers2)
}
# Not supported
// Not supported
एकत्रित टिकर डेटा के लिए एक्सचेंज के सार्वजनिक इंटरफेस तक असिंक्रोनस पहुंच।
..HttpQuery_Go()कार्य केवल समर्थन करता हैJavaScript,Pythonभाषा का प्रयोगurllibलाइब्रेरी सीधे HTTP अनुरोध भेजने के लिए.HttpQuery_Go()मुख्य रूप से उन इंटरफेस तक पहुंचने के लिए उपयोग किया जाता है जिन्हें एक्सचेंज पर हस्ताक्षर की आवश्यकता नहीं होती है, जैसे कि सार्वजनिक इंटरफेस जैसे कि टिकर जानकारी।HttpQuery_Goकार्य बैकटेस्टिंग प्रणाली में समर्थित नहीं है।
{@fun/Global/HttpQuery HttpQuery}
यह फ़ंक्शन पास किए गए मापदंडों के अनुसार डेटा को कोड करता है।
..Encodeफ़ंक्शन एन्कोडिंग और एन्क्रिप्शन के बाद डेटा लौटाता है.
स्ट्रिंग
एन्कोड (अल्गो, इनपुटफ़ॉर्मेट, आउटपुटफ़ॉर्मेट, डेटा) एन्कोड ((algo, inputFormat, outputFormat, data, keyFormat, key)
पैरामीटरalgoएन्कोडिंग गणना में प्रयुक्त एल्गोरिथ्म है। समर्थन सेटिंग हैःraw(कोई एल्गोरिथ्म उपयोग नहीं किया जाता है), "चिह्न", algoयह भी समर्थन करता हैः algoalgoed25519.seedगणना।
कुछ
सच
स्ट्रिंग
डेटा प्रारूप को निर्दिष्ट करने के लिए प्रयोग किया जाता हैdataपैरामीटर।inputFormatपैरामीटर निम्न में से किसी एक के रूप में सेट किया जा सकता हैःraw, hex, base64, string. hexएन्कोडेड, base64एन्कोडेड है, और outputFormatपैरामीटर निम्न में से किसी एक के रूप में सेट किया जा सकता हैःraw, hex, base64, string. hexएन्कोडेड, base64एन्कोडेड है, और dataसंसाधित किए जाने वाले डेटा हैं।
आंकड़ा
सच
स्ट्रिंग
डेटा प्रारूप को निर्दिष्ट करने के लिए प्रयोग किया जाता हैkeyपैरामीटर।keyपैरामीटर निम्न में से किसी एक के रूप में सेट किया जा सकता हैःraw, hex, base64, string. hexएन्कोडेड, base64एन्कोडेड है, और keyके लिए इस्तेमाल किया गुप्त कुंजी हैHMACएन्क्रिप्शन. पैरामीटरkeyआवश्यक है जब पैरामीटरalgoपर सेट हैsignयाsignTx.keyपैरामीटर का उपयोग नहीं किया जाता हैHMACएन्क्रिप्शनalgoपैरामीटर
function main() {
Log(Encode("raw", "raw", "hex", "example", "raw", "123")) // 6578616d706c65
Log(Encode("raw", "raw", "hex", "example")) // 6578616d706c65
Log(Encode("sha256", "raw", "hex", "example", "raw", "123")) // 698d54f0494528a759f19c8e87a9f99e75a5881b9267ee3926bcf62c992d84ba
Log(Encode("sha256", "raw", "hex", "example", "", "123")) // 50d858e0985ecc7f60418aaf0cc5ab587f42c2570a884095a9e8ccacd0f6545c
Log(Encode("sha256", "raw", "hex", "example", null, "123")) // 50d858e0985ecc7f60418aaf0cc5ab587f42c2570a884095a9e8ccacd0f6545c
Log(Encode("sha256", "raw", "hex", "example", "string", "123")) // 698d54f0494528a759f19c8e87a9f99e75a5881b9267ee3926bcf62c992d84ba
Log(Encode("raw", "raw", "hex", "123")) // 313233
Log(Encode("raw", "raw", "base64", "123")) // MTIz
Log(Encode("sha256", "raw", "hex", "example", "hex", "313233")) // 698d54f0494528a759f19c8e87a9f99e75a5881b9267ee3926bcf62c992d84ba
Log(Encode("sha256", "raw", "hex", "example", "base64", "MTIz")) // 698d54f0494528a759f19c8e87a9f99e75a5881b9267ee3926bcf62c992d84ba
}
def main():
Log(Encode("raw", "raw", "hex", "example", "raw", "123")) # 6578616d706c65
Log(Encode("raw", "raw", "hex", "example", "", "")) # 6578616d706c65
Log(Encode("sha256", "raw", "hex", "example", "raw", "123")) # 698d54f0494528a759f19c8e87a9f99e75a5881b9267ee3926bcf62c992d84ba
Log(Encode("sha256", "raw", "hex", "example", "", "123")) # 50d858e0985ecc7f60418aaf0cc5ab587f42c2570a884095a9e8ccacd0f6545c
Log(Encode("sha256", "raw", "hex", "example", "string", "123")) # 698d54f0494528a759f19c8e87a9f99e75a5881b9267ee3926bcf62c992d84ba
Log(Encode("raw", "raw", "hex", "123", "", "")) # 313233
Log(Encode("raw", "raw", "base64", "123", "", "")) # MTIz
Log(Encode("sha256", "raw", "hex", "example", "hex", "313233")) # 698d54f0494528a759f19c8e87a9f99e75a5881b9267ee3926bcf62c992d84ba
Log(Encode("sha256", "raw", "hex", "example", "base64", "MTIz")) # 698d54f0494528a759f19c8e87a9f99e75a5881b9267ee3926bcf62c992d84ba
void main() {
Log(Encode("raw", "raw", "hex", "example", "raw", "123")); // 6578616d706c65
Log(Encode("raw", "raw", "hex", "example")); // 6578616d706c65
Log(Encode("sha256", "raw", "hex", "example", "raw", "123")); // 698d54f0494528a759f19c8e87a9f99e75a5881b9267ee3926bcf62c992d84ba
Log(Encode("sha256", "raw", "hex", "example", "", "123")); // 50d858e0985ecc7f60418aaf0cc5ab587f42c2570a884095a9e8ccacd0f6545c
Log(Encode("sha256", "raw", "hex", "example", "string", "123")); // 698d54f0494528a759f19c8e87a9f99e75a5881b9267ee3926bcf62c992d84ba
Log(Encode("raw", "raw", "hex", "123")); // 313233
Log(Encode("raw", "raw", "base64", "123")); // MTIz
Log(Encode("sha256", "raw", "hex", "example", "hex", "313233")); // 698d54f0494528a759f19c8e87a9f99e75a5881b9267ee3926bcf62c992d84ba
Log(Encode("sha256", "raw", "hex", "example", "base64", "MTIz")); // 698d54f0494528a759f19c8e87a9f99e75a5881b9267ee3926bcf62c992d84ba
}
एन्कोड फ़ंक्शन कॉल का उदाहरण.
function main(){
var ret1 = Encode("text.encoder.utf8", "raw", "hex", "hello") // e4bda0e5a5bd
Log(ret1)
var ret2 = Encode("text.decoder.utf8", "hex", "string", ret1)
Log(ret2)
var ret3 = Encode("text.encoder.gbk", "raw", "hex", "hello") // c4e3bac3
Log(ret3)
var ret4 = Encode("text.decoder.gbk", "hex", "string", ret3)
Log(ret4)
}
def main():
ret1 = Encode("text.encoder.utf8", "raw", "hex", "hello", "", "") # e4bda0e5a5bd
Log(ret1)
ret2 = Encode("text.decoder.utf8", "hex", "string", ret1, "", "")
Log(ret2)
ret3 = Encode("text.encoder.gbk", "raw", "hex", "hello", "", "") # c4e3bac3
Log(ret3)
ret4 = Encode("text.decoder.gbk", "hex", "string", ret3, "", "")
Log(ret4)
void main(){
auto ret1 = Encode("text.encoder.utf8", "raw", "hex", "hello"); // e4bda0e5a5bd
Log(ret1);
auto ret2 = Encode("text.decoder.utf8", "hex", "string", ret1);
Log(ret2);
auto ret3 = Encode("text.encoder.gbk", "raw", "hex", "hello"); // c4e3bac3
Log(ret3);
auto ret4 = Encode("text.decoder.gbk", "hex", "string", ret3);
Log(ret4);
}
पैरामीटरalgoस्ट्रिंग को एन्कोड और डिकोड करने के लिए
..Encode()फ़ंक्शन केवल लाइव ट्रेडिंग के लिए समर्थित है.keyऔरkeyFormatमापदंडों पारित नहीं कर रहे हैं, तोkeyएन्क्रिप्शन का प्रयोग नहीं किया जाता है।
वर्तमान क्षण का नैनो सेकंड टाइमस्टैम्प प्राप्त करें।
..UnixNano()फ़ंक्शन नैनो सेकंड टाइमस्टैम्प लौटाता है.
संख्या
यूनिक्स नैनो
function main() {
var time = UnixNano() / 1000000
Log(_N(time, 0))
}
def main():
time = UnixNano()
Log(time)
void main() {
auto time = UnixNano();
Log(time);
}
यदि आपको मिलीसेकंड के टाइमस्टैम्प प्राप्त करने की आवश्यकता है, तो आप निम्न कोड का उपयोग कर सकते हैंः
{@fun/Global/Unix यूनिक्स}
दूसरे स्तर पर वर्तमान क्षण का समय प्राप्त करें।
दूसरे स्तर का समय मुहर लौटाता है. संख्या
यूनिक्स
function main() {
var t = Unix()
Log(t)
}
def main():
t = Unix()
Log(t)
void main() {
auto t = Unix();
Log(t);
}
{@fun/Global/UnixNano यूनिक्स नैनो}
डिवाइस की सिस्टम जानकारी प्राप्त करें जहां डॉकर स्थित है.
प्रणाली की जानकारी। स्ट्रिंग
GetOS()
function main() {
Log("GetOS:", GetOS())
}
def main():
Log("GetOS:", GetOS())
void main() {
Log("GetOS:", GetOS());
}
उदाहरण के लिए,GetOS()एक डॉकर के लिए कार्यमैक ओएसऑपरेटिंग सिस्टम वापस आ सकता हैःdarwin/amd64. क्योंकि एप्पल कंप्यूटर में कई हार्डवेयर आर्किटेक्चर हैं.darwinका नाम हैमैक ओएस system.
पैरामीटर के एमडी5 हैश की गणना करता हैdata.
एमडी5 हैश मान. स्ट्रिंग
MD5 (डेटा)
MD5 गणना की आवश्यकता है कि डेटा. आंकड़ा सच स्ट्रिंग
function main() {
Log("MD5", MD5("hello world"))
}
def main():
Log("MD5", MD5("hello world"))
void main() {
Log("MD5", MD5("hello world"));
}
बुला रहा हैMD5("hello world")फ़ंक्शन, रिटर्न मान हैः5eb63bbbe01eeed093cb22bb8f5acdc3.
{@fun/Global/EncodeEncode} {@fun/Global/EncodeEncode} {@fun/Global/EncodeEncode}
डेटाबेस इंटरफ़ेस कार्य।
एक वस्तु जिसमें एक निष्पादन का परिणाम होता हैस्क्वायरबयान, उदाहरण के लिएः
{"columns":["TS","HIGH","OPEN","LOW","CLOSE","VOLUME"],"values":[[1518970320000,100,99.1,90,100,12345.6]]}
वस्तु
DBExec ((sql)
स्क्वायरकथन स्ट्रिंग. स्क्वायर सच स्ट्रिंग
function main() {
var strSql = [
":CREATE TABLE TEST_TABLE(",
"TS INT PRIMARY KEY NOT NULL,",
"HIGH REAL NOT NULL,",
"OPEN REAL NOT NULL,",
"LOW REAL NOT NULL,",
"CLOSE REAL NOT NULL,",
"VOLUME REAL NOT NULL)"
].join("")
var ret = DBExec(strSql)
Log(ret)
// Add a piece of data
Log(DBExec(":INSERT INTO TEST_TABLE (TS, HIGH, OPEN, LOW, CLOSE, VOLUME) VALUES (1518970320000, 100, 99.1, 90, 100, 12345.6);"))
// Query data
Log(DBExec(":SELECT * FROM TEST_TABLE;"))
}
def main():
arr = [
":CREATE TABLE TEST_TABLE(",
"TS INT PRIMARY KEY NOT NULL,",
"HIGH REAL NOT NULL,",
"OPEN REAL NOT NULL,",
"LOW REAL NOT NULL,",
"CLOSE REAL NOT NULL,",
"VOLUME REAL NOT NULL)"
]
strSql = ""
for i in range(len(arr)):
strSql += arr[i]
ret = DBExec(strSql)
Log(ret)
# Add a piece of data
Log(DBExec(":INSERT INTO TEST_TABLE (TS, HIGH, OPEN, LOW, CLOSE, VOLUME) VALUES (1518970320000, 100, 99.1, 90, 100, 12345.6);"))
# Query data
Log(DBExec(":SELECT * FROM TEST_TABLE;"))
void main() {
string strSql = ":CREATE TABLE TEST_TABLE(\
TS INT PRIMARY KEY NOT NULL,\
HIGH REAL NOT NULL,\
OPEN REAL NOT NULL,\
LOW REAL NOT NULL,\
CLOSE REAL NOT NULL,\
VOLUME REAL NOT NULL)";
auto ret = DBExec(strSql);
Log(ret);
// Add a piece of data
Log(DBExec(":INSERT INTO TEST_TABLE (TS, HIGH, OPEN, LOW, CLOSE, VOLUME) VALUES (1518970320000, 100, 99.1, 90, 100, 12345.6);"));
// Query data
Log(DBExec(":SELECT * FROM TEST_TABLE;"));
}
स्मृति में डेटाबेस का समर्थन, के लिएDBExecकार्य पैरामीटर, यदिस्क्वायरकथन के साथ शुरू होता है:तब इन-मेमोरी डेटाबेस में ऑपरेट करें, यह फ़ाइलों को लिखने के बिना तेज़ होगा। यह डेटाबेस संचालन के लिए उपयुक्त है जिन्हें लगातार सहेजने की आवश्यकता नहीं है, उदाहरण के लिएः
function main() {
var strSql = [
"CREATE TABLE TEST_TABLE(",
"TS INT PRIMARY KEY NOT NULL,",
"HIGH REAL NOT NULL,",
"OPEN REAL NOT NULL,",
"LOW REAL NOT NULL,",
"CLOSE REAL NOT NULL,",
"VOLUME REAL NOT NULL)"
].join("")
var ret = DBExec(strSql)
Log(ret)
}
def main():
arr = [
"CREATE TABLE TEST_TABLE(",
"TS INT PRIMARY KEY NOT NULL,",
"HIGH REAL NOT NULL,",
"OPEN REAL NOT NULL,",
"LOW REAL NOT NULL,",
"CLOSE REAL NOT NULL,",
"VOLUME REAL NOT NULL)"
]
strSql = ""
for i in range(len(arr)):
strSql += arr[i]
ret = DBExec(strSql)
Log(ret)
void main() {
string strSql = "CREATE TABLE TEST_TABLE(\
TS INT PRIMARY KEY NOT NULL,\
HIGH REAL NOT NULL,\
OPEN REAL NOT NULL,\
LOW REAL NOT NULL,\
CLOSE REAL NOT NULL,\
VOLUME REAL NOT NULL)";
auto ret = DBExec(strSql);
Log(ret);
}
एक मेज बनाओ।
function main() {
var strSql = [
"CREATE TABLE TEST_TABLE(",
"TS INT PRIMARY KEY NOT NULL,",
"HIGH REAL NOT NULL,",
"OPEN REAL NOT NULL,",
"LOW REAL NOT NULL,",
"CLOSE REAL NOT NULL,",
"VOLUME REAL NOT NULL)"
].join("")
Log(DBExec(strSql))
// Add a piece of data
Log(DBExec("INSERT INTO TEST_TABLE (TS, HIGH, OPEN, LOW, CLOSE, VOLUME) VALUES (1518970320000, 100, 99.1, 90, 100, 12345.6);"))
// Query data
Log(DBExec("SELECT * FROM TEST_TABLE;"))
// Modify data
Log(DBExec("UPDATE TEST_TABLE SET HIGH=? WHERE TS=?", 110, 1518970320000))
// Delete data
Log(DBExec("DELETE FROM TEST_TABLE WHERE HIGH=?", 110))
}
def main():
arr = [
"CREATE TABLE TEST_TABLE(",
"TS INT PRIMARY KEY NOT NULL,",
"HIGH REAL NOT NULL,",
"OPEN REAL NOT NULL,",
"LOW REAL NOT NULL,",
"CLOSE REAL NOT NULL,",
"VOLUME REAL NOT NULL)"
]
strSql = ""
for i in range(len(arr)):
strSql += arr[i]
Log(DBExec(strSql))
# Add a piece of data
Log(DBExec("INSERT INTO TEST_TABLE (TS, HIGH, OPEN, LOW, CLOSE, VOLUME) VALUES (1518970320000, 100, 99.1, 90, 100, 12345.6);"))
# Query data
Log(DBExec("SELECT * FROM TEST_TABLE;"))
# Modify data
Log(DBExec("UPDATE TEST_TABLE SET HIGH=? WHERE TS=?", 110, 1518970320000))
# Delete data
Log(DBExec("DELETE FROM TEST_TABLE WHERE HIGH=?", 110))
void main() {
string strSql = "CREATE TABLE TEST_TABLE(\
TS INT PRIMARY KEY NOT NULL,\
HIGH REAL NOT NULL,\
OPEN REAL NOT NULL,\
LOW REAL NOT NULL,\
CLOSE REAL NOT NULL,\
VOLUME REAL NOT NULL)";
Log(DBExec(strSql));
// Add a piece of data
Log(DBExec("INSERT INTO TEST_TABLE (TS, HIGH, OPEN, LOW, CLOSE, VOLUME) VALUES (1518970320000, 100, 99.1, 90, 100, 12345.6);"));
// Query data
Log(DBExec("SELECT * FROM TEST_TABLE;"));
// Modify data
Log(DBExec("UPDATE TEST_TABLE SET HIGH=? WHERE TS=?", 110, 1518970320000));
// Delete data
Log(DBExec("DELETE FROM TEST_TABLE WHERE HIGH=?", 110));
}
तालिका में रिकॉर्ड जोड़ें, हटाएं, जांचें और बदलें.
कार्यDBExec()लाइव ट्रेडिंग डेटाबेस (SQLite डेटाबेस) को पैरामीटर पास करके संचालित कर सकते हैं। लाइव ट्रेडिंग डेटाबेस में डेटा जोड़ने, हटाने, जांचने और बदलने के संचालन को महसूस कर सकते हैं,एसक्यूलाइटव्याकरण. प्रणाली लाइव ट्रेडिंग डेटाबेस में आरक्षित तालिकाओंःkvdb, cfg, log, profit, chart, इन टेबलों पर काम न करें।लेनदेनसमर्थित नहीं हैं और इस तरह के कार्यों को करने की अनुशंसा नहीं की जाती है, जो सिस्टम में संघर्ष का कारण बन सकता है।DBExec()यह फ़ंक्शन केवल लाइव ट्रेडिंग के लिए समर्थित है.
{@fun/Global/_G _G}
एक UUID बनाएँ.
32-बिट UUID. स्ट्रिंग
UUID (()
function main() {
var uuid1 = UUID()
var uuid2 = UUID()
Log(uuid1, uuid2)
}
def main():
uuid1 = UUID()
uuid2 = UUID()
Log(uuid1, uuid2)
void main() {
auto uuid1 = UUID();
auto uuid2 = UUID();
Log(uuid1, uuid2);
}
..UUID()फ़ंक्शन केवल लाइव ट्रेडिंग का समर्थन करता है।
घटनाओं के लिए सुनने के लिए, यह वापस आता है जब कोई हैWebSocketपठनीय डेटा या समवर्ती कार्य, जैसेexchange.Go(), HttpQuery_Go(), आदि पूर्ण हो गए हैं।
यदि लौटी वस्तु शून्य मूल्य नहीं है, तोEventरिटर्न सामग्री में निहित घटना ट्रिगर प्रकार है। उदाहरण के लिए निम्न रिटर्न मान संरचनाः
{"Seq":1,"Event":"Exchange_GetTrades","ThreadId":0,"Index":3,"Nano":1682068771309583400}
वस्तु
इवेंट लूप घटना लूप (टाइमआउट)
पैरामीटरtimeoutमिलीसेकंड में टाइमआउट सेटिंग है। पैरामीटरtimeoutयदि यह 0 पर सेट किया गया है तो वापस आने से पहले किसी घटना के होने की प्रतीक्षा करता है, यदि यह 0 से अधिक है, तो यह घटना को टाइमआउट की प्रतीक्षा करने के लिए सेट करता है, और यदि यह 0 से कम है तो सबसे हालिया घटना को तुरंत लौटाता है।
टाइमआउट
झूठी
संख्या
function main() {
var routine_getTicker = exchange.Go("GetTicker")
var routine_getDepth = exchange.Go("GetDepth")
var routine_getTrades = exchange.Go("GetTrades")
// Sleep(2000), if the Sleep statement is used here, it will cause the subsequent EventLoop function to miss the previous events, because after waiting for 2 seconds, the concurrent function has received the data, and the subsequent EventLoop listening mechanism started, it misses these events.
// These events will not be missed unless EventLoop(-1) is called at the beginning of the first line of code to first initialize the EventLoop's listening mechanism.
// Log("GetDepth:", routine_getDepth.wait()) If the wait function is called in advance to retrieve the result of a concurrent call to the GetDepth function, the event that the GetDepth function receives the result of the request will not be returned in the EventLoop function.
var ts1 = new Date().getTime()
var ret1 = EventLoop(0)
var ts2 = new Date().getTime()
var ret2 = EventLoop(0)
var ts3 = new Date().getTime()
var ret3 = EventLoop(0)
Log("The first concurrent task completed was:", _D(ts1), ret1)
Log("The second concurrent task completed was:", _D(ts2), ret2)
Log("The third concurrent task completed was:", _D(ts3), ret3)
Log("GetTicker:", routine_getTicker.wait())
Log("GetDepth:", routine_getDepth.wait())
Log("GetTrades:", routine_getTrades.wait())
}
import time
def main():
routine_getTicker = exchange.Go("GetTicker")
routine_getDepth = exchange.Go("GetDepth")
routine_getTrades = exchange.Go("GetTrades")
ts1 = time.time()
ret1 = EventLoop(0)
ts2 = time.time()
ret2 = EventLoop(0)
ts3 = time.time()
ret3 = EventLoop(0)
Log("The first concurrent task completed was:", _D(ts1), ret1)
Log("The second concurrent task completed was:", _D(ts2), ret2)
Log("The third concurrent task completed was:", _D(ts3), ret3)
Log("GetTicker:", routine_getTicker.wait())
Log("GetDepth:", routine_getDepth.wait())
Log("GetTrades:", routine_getTrades.wait())
void main() {
auto routine_getTicker = exchange.Go("GetTicker");
auto routine_getDepth = exchange.Go("GetDepth");
auto routine_getTrades = exchange.Go("GetTrades");
auto ts1 = Unix() * 1000;
auto ret1 = EventLoop(0);
auto ts2 = Unix() * 1000;
auto ret2 = EventLoop(0);
auto ts3 = Unix() * 1000;
auto ret3 = EventLoop(0);
Log("The first concurrent task completed was:", _D(ts1), ret1);
Log("The second concurrent task completed was:", _D(ts2), ret2);
Log("The third concurrent task completed was:", _D(ts3), ret3);
Ticker ticker;
Depth depth;
Trades trades;
routine_getTicker.wait(ticker);
routine_getDepth.wait(depth);
routine_getTrades.wait(trades);
Log("GetTicker:", ticker);
Log("GetDepth:", depth);
Log("GetTrades:", trades);
}
पहली कॉलEventLoop()कोड में फ़ंक्शन उस सुनी घटना के लिए तंत्र आरंभ करता है, और अगर पहलीEventLoop()कॉल घटना callback के बाद शुरू होता है, यह पिछली घटनाओं को याद करेगा. अंतर्निहित प्रणाली एक कतार संरचना को लपेटती है जो अधिकतम 500 घटना callbacks कैश करती है. यदिEventLoop()समारोह को समय में नहीं बुलाया जाता है उन्हें कार्यक्रम निष्पादन के दौरान बाहर ले जाने के लिए, बाद में घटना 500 कैश के बाहर callbacks खो जाएगा.EventLoop()कार्य अंतर्निहित प्रणाली वेबसॉकेट के कैश कतार या समवर्ती कार्यों के कैश को प्रभावित नहीं करता है जैसे किexchange.Go(). इन कैश के लिए, अभी भी डेटा पुनर्प्राप्त करने के लिए संबंधित विधियों का उपयोग करना आवश्यक है।EventLoop()फ़ंक्शन के लिए डेटा है कि पहले प्राप्त किया गया हैEventLoop()मुख्य उद्देश्यEventLoop()कार्य रणनीति परत को सूचित करना है कि नए नेटवर्क डेटा को अंतर्निहित प्रणाली द्वारा प्राप्त किया गया है। पूरी रणनीति घटनाओं से प्रेरित है।EventLoop()फ़ंक्शन एक घटना लौटाता है, बस सभी डेटा स्रोतों को पार करता है. उदाहरण के लिए, वेबसॉकेट कनेक्शन, द्वारा बनाई गई वस्तुओंexchange.Go()डेटा प्राप्त करने की कोशिश करें।EventLoop()फ़ंक्शन केवल लाइव ट्रेडिंग का समर्थन करता है।
मुख्य फ़ंक्शन से बुलाए जाने पर मुख्य थ्रेड में घटनाओं के लिए सुनेंmain(). में लिखी रणनीतियों मेंJavaScriptभाषा,threading.Thread()फ़ंक्शन एक थ्रेड बनाता है, जिसे वर्तमान थ्रेड में घटनाओं के लिए सुनने के लिए थ्रेड
{@fun/Global/Dial Dial}, {@fun/Trade/exchange.Go exchange.Go}, {@fun/Global/HttpQuery_Go HttpQuery_Go}
..__Servefunction का उपयोग Http सेवा, TCP सेवा और Websocket सेवा (Http प्रोटोकॉल पर आधारित) बनाने के लिए किया जाता है।
एक स्ट्रिंग लौटाता है जो बनाई गई सेवा के आईपी पते और पोर्ट को रिकॉर्ड करता है. उदाहरण के लिएः127.0.0.1:8088, [::]:8089.
स्ट्रिंग
__Serve ((serveURI, हैंडलर) __Serve ((serveURI, हैंडलर,...args)
..serveURIपैरामीटर का उपयोग प्रोटोकॉल, आईपी पते, पोर्ट और सेवा बाध्यता की अन्य सेटिंग्स को कॉन्फ़िगर करने के लिए किया जाता है, जैसे किhttp://0.0.0.0:8088?gzip=true, यानी,http://:8088?gzip=true.
serveURIपैरामीटर सेटिंग, जैसेtcp://127.0.0.1:6666?tls=true; आप प्रमाणपत्र और निजी कुंजी जोड़ सकते हैं, जैसे किtls=true&cert_pem=xxxx&cert_key_pem=xxxx.serveURIपैरामीटर सेटिंग्स, जैसेhttp://127.0.0.1:6666?gzip=true; आप संपीड़न सेटिंग्स सेट कर सकते हैंःgzip=true.
दserveURIपैरामीटर Https के लिए प्रयोग किया जाता है, जैसे किhttps://127.0.0.1:6666?tls=true&gzip=true; आप जोड़ सकते हैंcert_pemऔरcert_key_pemप्रमाणपत्र को लोड करने के लिए पैरामीटर।serveURI
सच
स्ट्रिंग
दhandlerपैरामीटर का प्रयोग रूटिंग प्रोसेसिंग फंक्शन (Http प्रोटोकॉल), मैसेज प्रोसेसिंग फंक्शन (TCP प्रोटोकॉल), और स्ट्रीम प्रोसेसिंग फंक्शन (वेबसोकेट) में पास करने के लिए किया जाता है।
पैरामीटर द्वारा पास किया गया कॉलबैक फ़ंक्शनhandlerकई मापदंडों को परिभाषित कर सकते हैं, पहला मापदंड ctx ऑब्जेक्ट (संदर्भ ऑब्जेक्ट) है।
संचालक
सच
कार्य
कॉलबैक फ़ंक्शन का वास्तविक पैरामीटर पैरामीटर के रूप में पारित कियाhandler. कई मापदंड हो सकते हैंargउदाहरण के लिए:
__Serve("http://:8088", function(ctx, a, b, c) {
Log(`ctx.host():`, ctx.host(), ", a=", a, ", b=", b, ", c=", c)
}, 1, 2, 3)
मापदंड1, 2, 3में पारित किया जब कॉल__Serve()समारोह पैरामीटर के अनुरूपa, b, cकॉलबैक फ़ंक्शन में पारित किया।
आर्ग झूठी string, number, bool, object, array, function, null value और सिस्टम द्वारा समर्थित अन्य प्रकार
function main() {
let httpServer = __Serve("http://:8088?gzip=true", function (ctx) {
Log("http connect from: ", ctx.remoteAddr(), "->", ctx.localAddr())
let path = ctx.path()
if (path == "/") {
ctx.write(JSON.stringify({
path: ctx.path(),
method: ctx.method(),
headers: ctx.headers(),
cookie: ctx.header("Cookie"),
remote: ctx.remoteAddr(),
query: ctx.rawQuery()
}))
} else if (path == "/tickers") {
let ret = exchange.GetTickers()
if (!ret) {
ctx.setStatus(500)
ctx.write(GetLastError())
} else {
ctx.write(JSON.stringify(ret))
}
} else if (path == "/wss") {
if (ctx.upgrade("websocket")) { // upgrade to websocket
while (true) {
let r = ctx.read(10)
if (r == "") {
break
} else if (r) {
if (r == "ticker") {
ctx.write(JSON.stringify(exchange.GetTicker()))
} else {
ctx.write("not support")
}
}
}
Log("websocket closed", ctx.remoteAddr())
}
} else {
ctx.setStatus(404)
}
})
let echoServer = __Serve("tcp://:8089", function (ctx) {
Log("tcp connect from: ", ctx.remoteAddr(), "->", ctx.localAddr())
while (true) {
let d = ctx.read()
if (!d) {
break
}
ctx.write(d)
}
Log("connect closed")
})
Log("http serve on", httpServer, "tcp serve on", echoServer)
for (var i = 0; i < 5; i++) {
if (i == 2) {
// test Http
var retHttp = HttpQuery("http://127.0.0.1:8088?num=123&limit=100", {"debug": true})
Log("retHttp:", retHttp)
} else if (i == 3) {
// test TCP
var tcpConn = Dial("tcp://127.0.0.1:8089")
tcpConn.write("Hello TCP Server")
var retTCP = tcpConn.read()
Log("retTCP:", retTCP)
} else if (i == 4) {
// test Websocket
var wsConn = Dial("ws://127.0.0.1:8088/wss|compress=gzip")
wsConn.write("ticker")
var retWS = wsConn.read(1000)
Log("retWS:", retWS)
// no depth
wsConn.write("depth")
retWS = wsConn.read(1000)
Log("retWS:", retWS)
}
Sleep(1000)
}
}
# Unsupported
// Unsupported
Websocketसेवा HTTP प्रोटोकॉल के आधार पर लागू किया जाता है. आप पथ में एक रूटिंग शाखा सेट कर सकते हैं और के लिए कार्यान्वयन कोड डिजाइनWebsocketआप इस अनुभाग में नमूने कोड का संदर्भ ले सकते हैं।पैरामीटर द्वारा पास किया गया कॉलबैक फ़ंक्शनhandlerप्राप्त करता हैctxपैरामीटर।ctxपैरामीटर एक संदर्भ वस्तु है जिसका उपयोग डेटा प्राप्त करने और लिखने के लिए किया जाता है, निम्नलिखित विधियों के साथः
HTTP/1.1, tcp.http://127.0.0.1:8088?num=123, और पैरामीटर द्वारा पारित कॉलबैक प्रसंस्करण समारोहhandlerरिटर्न"123"कबctx.query("num")कहा जाता है।User-Agentवर्तमान अनुरोध के शीर्षकों मेंःctx.header("User-Agent").GET, POSTआदि।ctxवेबसॉकेट प्रोटोकॉल के लिए संदर्भ वस्तु; यदि स्विच सफल होता है तो एक बूलियन मान (सही) और यदि यह विफल होता है तो एक बूलियन मान (गलत) लौटाता है।readविधि साधारण HTTP प्रोटोकॉल में समर्थित नहीं है. आप समय सीमा पैरामीटर निर्दिष्ट कर सकते हैंtimeout_msमिलीसेकंड में।JSON.stringify()JSON ऑब्जेक्ट को एक स्ट्रिंग में एन्कोड करने के लिए और फिर इसे लिखने के लिए.WebSocketप्रोटोकॉल, आप क्लाइंट को एन्कोडेड स्ट्रिंग पास करने के लिए इस विधि का उपयोग कर सकते हैं.{@fun/Global/HttpQuery HttpQuery}, {@fun/Global/HttpQuery_Go HttpQuery_Go}
लगातार डेटा सहेजें, फ़ंक्शन एक वैश्विक शब्दकोश फ़ंक्शन को लागू करता है जिसे सहेजा जा सकता है। डेटा संरचना एक KV तालिका है जिसे स्थायी रूप से डॉकर की स्थानीय डेटाबेस फ़ाइल में सहेजा जाता है।
में स्थायी रूप से सहेजे गए कुंजी-मूल्य डेटाk-vकुंजी-मूल्य जोड़े।
स्ट्रिंग, संख्या, बूल, ऑब्जेक्ट, सरणी, शून्य मान
_G() _G(k) _G(k, v)
पैरामीटरkसहेजे गए कुंजी-मूल्य जोड़ी में कुंजी का नाम है, और यह केस-सेंसिटिव नहीं है।
क
झूठी
स्ट्रिंग, शून्य मान
पैरामीटरvसहेजे गए कुंजी-मूल्य जोड़ी में कुंजी मान है, जो किसी भी डेटा हो सकता है कि किया जा सकता हैJSONश्रृंखलाबद्ध।
v
झूठी
स्ट्रिंग, संख्या, बूल, ऑब्जेक्ट, सरणी, शून्य मान
function main(){
// Set a global variable num with a value of 1
_G("num", 1)
// Change a global variable num to the value of the string ok
_G("num", "ok")
// Delete the global variable num
_G("num", null)
// Returns the value of the global variable num
Log(_G("num"))
// Delete all global variables
_G(null)
// Return to live trading ID
var robotId = _G()
}
def main():
_G("num", 1)
_G("num", "ok")
_G("num", None)
Log(_G("num"))
_G(None)
robotId = _G()
void main() {
_G("num", 1);
_G("num", "ok");
_G("num", NULL);
Log(_G("num"));
_G(NULL);
// Not support auto robotId = _G();
}
प्रत्येक प्रत्यक्ष व्यापार के लिए एक अलग डेटाबेस,_G()यदि रणनीति को फिर से शुरू किया जाता है या डॉकर चलाना बंद कर देता है तो फ़ंक्शन हमेशा मौजूद रहेगा। यदि बैकटेस्टिंग समाप्त हो जाती है, तो बैकटेस्टिंग सिस्टम में सहेजे गए डेटा को डॉकर द्वारा हटा दिया जाता है।_G()कार्य को साफ़ कर दिया जाएगा।_G()सहेजे गए डेटा को बनाए रखने के लिए, इसका उपयोग हार्डवेयर डिवाइस की मेमोरी और हार्ड डिस्क स्थान के अनुसार उचित रूप से किया जाना चाहिए, और इसका दुरुपयोग नहीं किया जाना चाहिए।
जब कॉल_G()एक लाइव व्यापार में कार्य और कोई पैरामीटर पारित कर रहे हैं,_G()फ़ंक्शन रिटर्नIdवर्तमान लाइव ट्रेडिंग के._G()कार्य, पैरामीटरvशून्य के रूप में पारित किया जाता हैk-vकुंजी-मूल्य जोड़ी._G()फ़ंक्शन, केवल पैरामीटरkस्ट्रिंग में पारित किया जाता है, और_G()फ़ंक्शन सहेजे गए पैरामीटर के अनुरूप कुंजी मान देता हैk._G()फ़ंक्शन, केवल पैरामीटरkशून्य मान में पारित किया जाता है, यह दर्शाता है कि सभी रिकॉर्डk-vकुंजी-मूल्य जोड़ी हटाया जाता है.k-vकुंजी-मूल्य जोड़े लगातार सहेजे गए हैं,_G()फ़ंक्शन को फिर से बुलाया जाता है, जो कि पैरामीटर के रूप में लगातार सहेजी गई कुंजी के नाम में गुजरता हैk. पैरामीटर के रूप में नया कुंजी मान पास करनाvअद्यतन करेगा किk-vकुंजी-मूल्य जोड़ी।
{@fun/Global/DBExec DBExec}
मिलीसेकंड टाइमस्टैम्प याDateसमय स्ट्रिंग्स के लिए वस्तुओं.
समय स्ट्रिंग। स्ट्रिंग
_D() _D (समय) _D ((समयमुद्रण, fmt)
मिलीसेकंड का टाइमस्टैम्प याDateवस्तु।
समय-छाप
झूठी
संख्या, उद्देश्य
स्वरूपण स्ट्रिंग,JavaScriptभाषा का डिफ़ॉल्ट प्रारूपःyyyy-MM-dd hh:mm:ss; Pythonभाषा का डिफ़ॉल्ट प्रारूपः%Y-%m-%d %H:%M:%S; C++भाषा का डिफ़ॉल्ट प्रारूपः%Y-%m-%d %H:%M:%S.
fmt
झूठी
स्ट्रिंग
function main(){
var time = _D()
Log(time)
}
def main():
strTime = _D()
Log(strTime)
void main() {
auto strTime = _D();
Log(strTime);
}
वर्तमान समय स्ट्रिंग प्राप्त करें और प्रिंट करें:
function main() {
Log(_D(1574993606000))
}
def main():
# Running this code on a server in Beijing time: 2019-11-29 10:13:26 , a docker on another server in another region results in: 2019-11-29 02:13:26
Log(_D(1574993606))
void main() {
Log(_D(1574993606000));
}
समय-स्टैम्प 1574993606000 है, कोड रूपांतरण का उपयोग करकेः
function main() {
Log(_D(1574993606000, "yyyy--MM--dd hh--mm--ss")) // 2019--11--29 10--13--26
}
def main():
# 1574993606 is timestamped in seconds.
Log(_D(1574993606, "%Y--%m--%d %H--%M--%S")) # 2019--11--29 10--13--26
void main() {
Log(_D(1574993606000, "%Y--%m--%d %H--%M--%S")); // 2019--11--29 10--13--26
}
पैरामीटर के साथ स्वरूपणfmtके लिए अलग हैJavaScript, Python, औरC++भाषाओं, जैसा कि निम्नलिखित उदाहरणों में दिखाया गया हैः
किसी भी पैरामीटर को पारित किए बिना वर्तमान समय स्ट्रिंग लौटाता है._D()कार्य मेंPythonरणनीति, आपको पता होना चाहिए कि पारित मापदंडों दूसरे स्तर के टाइमस्टैम्प हैं (जावास्क्रिप्ट और सी ++ रणनीतियों में मिलीसेकंड स्तर के टाइमस्टैम्प, जहां 1 सेकंड 1000 मिलीसेकंड के बराबर है) ।_D()लाइव ट्रेडिंग में पठनीय टाइमस्टैम्प के साथ एक समय स्ट्रिंग को पार्स करने के लिए, आपको ऑपरेटिंग सिस्टम के समय क्षेत्र और समय सेटिंग पर ध्यान देने की आवश्यकता है जहां डॉकर प्रोग्राम स्थित है।_D()फ़ंक्शन डॉकर
{@fun/Global/UnixNano UnixNano}, {@fun/Global/Unix Unix}
एक फ्लोटिंग पॉइंट नंबर प्रारूपित करें.
परिशुद्धता सेटिंग के अनुसार प्रारूपित फ्लोटिंग कॉमन नंबर। संख्या
_N() _N(num) _N ((num, सटीकता)
फ्लोटिंग कॉमन नंबर जिसे स्वरूपित किया जाना है.
संख्या
सच
संख्या
स्वरूपण के लिए परिशुद्धता सेटिंग, पैरामीटरprecisionएक पूर्णांक है, और पैरामीटरprecisionडिफ़ॉल्ट 4 पर सेट करता है।
परिशुद्धता
झूठी
संख्या
function main(){
var i = 3.1415
Log(i)
var ii = _N(i, 2)
Log(ii)
}
def main():
i = 3.1415
Log(i)
ii = _N(i, 2)
Log(ii)
void main() {
auto i = 3.1415;
Log(i);
auto ii = _N(i, 2);
Log(ii);
}
उदाहरण के लिए,_N(3.1415, 2)के बाद मान को मिटा देगा3.1415दो दशमलव स्थानों और समारोह लौटाता है3.14.
function main(){
var i = 1300
Log(i)
var ii = _N(i, -3)
// Check the logs and see that it is 1000
Log(ii)
}
def main():
i = 1300
Log(i)
ii = _N(i, -3)
Log(ii)
void main() {
auto i = 1300;
Log(i);
auto ii = _N(i, -3);
Log(ii);
}
यदि आपको दशमलव बिंदु के बाईं ओर सभी एन अंकों को 0 में बदलने की आवश्यकता है, तो आप इसे इस तरह लिख सकते हैंः
पैरामीटरprecisionएक सकारात्मक पूर्णांक, नकारात्मक पूर्णांक हो सकता है.
{@fun/Trade/exchange.SetPrecision exchange.SetPrecision} {@fun/Trade/exchange.SetPrecision exchange.SetPrecision} {@trade/exchange.SetPrecision exchange.SetPrecision} {@fun/Trade.
इंटरफ़ेस दोष सहिष्णुता के लिए पुनः प्रयास करें।
कॉलबैक फ़ंक्शन का रिटर्न वैल्यू जब यह निष्पादित किया जाता है। सभी प्रकार सिस्टिम द्वारा समर्थित हैं सिवायतार्किक झूठा मानऔरशून्य मान.
_C(pfn) _C ((pfn,...args)
पैरामीटरpfnएक फ़ंक्शन संदर्भ है, जो एक हैकॉलबैक फ़ंक्शन.
पीएफएन
सच
कार्य
पैरामीटरकॉलबैक फ़ंक्शन, एक से अधिक पैरामीटर हो सकते हैंarg. मापदंडों का प्रकार और संख्याargपर निर्भर करता हैकॉलबैक फ़ंक्शन.
आर्ग
झूठी
string, number, bool, object, array, function, सभी प्रकार सिस्टम द्वारा समर्थित हैं, जैसे शून्य मान
function main(){
var ticker = _C(exchange.GetTicker)
// Adjust _C() function retry interval to 2 seconds
_CDelay(2000)
var depth = _C(exchange.GetDepth)
Log(ticker)
Log(depth)
}
def main():
ticker = _C(exchange.GetTicker)
_CDelay(2000)
depth = _C(exchange.GetDepth)
Log(ticker)
Log(depth)
void main() {
auto ticker = _C(exchange.GetTicker);
_CDelay(2000);
auto depth = _C(exchange.GetDepth);
Log(ticker);
Log(depth);
}
पैरामीटर के बिना त्रुटि-सहिष्णुता कार्यों के लिएः
function main(){
var records = _C(exchange.GetRecords, PERIOD_D1)
Log(records)
}
def main():
records = _C(exchange.GetRecords, PERIOD_D1)
Log(records)
void main() {
auto records = _C(exchange.GetRecords, PERIOD_D1);
Log(records);
}
परिमाणों के साथ कार्यों के लिए जो त्रुटि सहिष्णु हैंः
var test = function(a, b){
var time = new Date().getTime() / 1000
if(time % b == 3){
Log("Eligible!", "#FF0000")
return true
}
Log("Retry!", "#FF0000")
return false
}
function main(){
var ret = _C(test, 1, 5)
Log(ret)
}
import time
def test(a, b):
ts = time.time()
if ts % b == 3:
Log("Eligible!", "#FF0000")
return True
Log("Retry!", "#FF0000")
return False
def main():
ret = _C(test, 1, 5)
Log(ret)
// C++ does not support fault tolerance for custom functions in this way
यह कस्टम कार्यों के दोष सहिष्णुता के लिए भी इस्तेमाल किया जा सकता हैः
.._C()function निर्दिष्ट फ़ंक्शन को तब तक कॉल करता रहेगा जब तक कि यह सफलतापूर्वक वापस न आ जाए (पैरामीटर द्वारा संदर्भित फ़ंक्शनpfnरिटर्नशून्ययाझूठीजब बुलाया जाता है तो फिर से कॉल करने का प्रयास करेगाpfn) उदाहरण के लिए_C(exchange.GetTicker). डिफ़ॉल्ट पुनः प्रयास अंतराल 3 सेकंड है, आप कॉल कर सकते हैं_CDelay()पुनः प्रयास अंतराल सेट करने के लिए समारोह. उदाहरण के लिए,_CDelay(1000)के पुनः प्रयास के अंतराल को बदलने का साधन है_C()1 सेकंड के लिए कार्य।
दोष सहिष्णुता निम्नलिखित कार्यों के लिए की जा सकती है, लेकिन यह सीमित नहीं है:
exchange.GetTicker()exchange.GetDepth()exchange.GetTrades()exchange.GetRecords()exchange.GetAccount()exchange.GetOrders()exchange.GetOrder()exchange.GetPositions()सभी को बुलाया जा सकता है_C()दोष सहिष्णुता के लिए कार्य।_C()समारोह उपरोक्त सूचीबद्ध समारोह दोष सहिष्णुता तक सीमित नहीं है, पैरामीटरpfnएक फ़ंक्शन कॉल के बजाय एक फ़ंक्शन संदर्भ है.
ध्यान दें कि यह है_C(exchange.GetTicker), नहीं_C(exchange.GetTicker()).सरणी के प्रतिच्छेदन काल की संख्या देता हैarr1और सरणीarr2.
सरणी के क्रॉस पीरियड्स की संख्याarr1और सरणीarr2.
संख्या
_क्रॉस ((arr1, arr2)
तत्व प्रकार के सरणी हैंnumber.
arr1
सच
सरणी
तत्व प्रकार के सरणी हैंnumber.
arr2
सच
सरणी
// Fast line indicator
var arr1 = [1,2,3,4,5,6,8,8,9]
// Slow line indicator
var arr2 = [2,3,4,5,6,7,7,7,7]
function main(){
Log("_Cross(arr1, arr2) : ", _Cross(arr1, arr2))
Log("_Cross(arr2, arr1) : ", _Cross(arr2, arr1))
}
arr1 = [1,2,3,4,5,6,8,8,9]
arr2 = [2,3,4,5,6,7,7,7,7]
def main():
Log("_Cross(arr1, arr2) : ", _Cross(arr1, arr2))
Log("_Cross(arr2, arr1) : ", _Cross(arr2, arr1))
void main() {
vector<double> arr1 = {1,2,3,4,5,6,8,8,9};
vector<double> arr2 = {2,3,4,5,6,7,7,7,7};
Log("_Cross(arr1, arr2) : ", _Cross(arr1, arr2));
Log("_Cross(arr2, arr1) : ", _Cross(arr2, arr1));
}
_Cross ((Arr1, Arr2) फ़ंक्शन का परीक्षण करने के लिए डेटा का एक सेट सिमुलेट किया जा सकता हैः
यदि रिटर्न मान_Cross()यदि फलन एक सकारात्मक संख्या है, तो यह ऊपर की ओर प्रवेश करने की अवधि को दर्शाता है, यदि यह एक नकारात्मक संख्या है, तो यह नीचे की ओर प्रवेश करने की अवधि को दर्शाता है, 0 का अर्थ वर्तमान मूल्य के समान है। उपयोग के लिए विशिष्ट निर्देशःअंतर्निहित कार्य के बारे में विश्लेषण और उपयोग के निर्देश _क्रॉस.
कार्यJSONParse()पार्स करने के लिए प्रयोग किया जाता हैJSON strings.
JSONवस्तु।
वस्तु
JSONParse ((s)
JSONस्ट्रिंग।
s
सच
स्ट्रिंग
function main() {
let s1 = '{"num": 8754613216564987646512354656874651651358}'
Log("JSON.parse:", JSON.parse(s1)) // JSON.parse: {"num":8.754613216564988e+39}
Log("JSONParse:", JSONParse(s1)) // JSONParse: {"num":"8754613216564987646512354656874651651358"}
let s2 = '{"num": 123}'
Log("JSON.parse:", JSON.parse(s2)) // JSON.parse: {"num":123}
Log("JSONParse:", JSONParse(s2)) // JSONParse: {"num":123}
}
import json
def main():
s1 = '{"num": 8754613216564987646512354656874651651358}'
Log("json.loads:", json.loads(s1)) # json.loads: map[num:8.754613216564987e+39]
Log("JSONParse:", JSONParse(s1)) # JSONParse: map[num:8754613216564987646512354656874651651358]
s2 = '{"num": 123}'
Log("json.loads:", json.loads(s2)) # json.loads: map[num:123]
Log("JSONParse:", JSONParse(s2)) # JSONParse: map[num:123]
void main() {
auto s1 = "{\"num\":8754613216564987646512354656874651651358}";
Log("json::parse:", json::parse(s1));
// Log("JSONParse:", JSONParse(s1)); // The function is not supported.
auto s2 = "{\"num\":123}";
Log("json::parse:", json::parse(s2));
// Log("JSONParse:", JSONParse(s2)); // The function is not supported.
}
बड़े मानों के साथ JSON स्ट्रिंग्स को सही ढंग से पार्स किया जा सकता है, और यह स्ट्रिंग प्रकार के रूप में बड़े मानों को पार्स करेगा.JSONParse()कार्य बैकटेस्ट प्रणाली में समर्थित नहीं है।
आउटपुट लॉग।
लॉग ((...msgs)
पैरामीटरmsgआउटपुट की सामग्री है, और पैरामीटरmsgएक से अधिक पारित किया जा सकता है।
msg
झूठी
स्ट्रिंग, संख्या, बोल, ऑब्जेक्ट, सरणी, सिस्टम द्वारा समर्थित कोई भी प्रकार जैसे शून्य।
function main() {
Log("msg1", "msg2", "msg3")
}
def main():
Log("msg1", "msg2", "msg3")
void main() {
Log("msg1", "msg2", "msg3");
}
अनेकmsgमापदंडों को पारित किया जा सकता हैः
function main() {
Log("Hello, FMZ Quant!@")
Sleep(1000 * 5)
// Add #ff0000 to the string to print the log in red and push the message
Log("Hello, #ff0000@")
}
def main():
Log("Hello, FMZ Quant!@")
Sleep(1000 * 5)
Log("Hello, #ff0000@")
void main() {
Log("Hello, FMZ Quant!@");
Sleep(1000 * 5);
Log("Hello, #ff0000@");
}
यह आउटपुट संदेश का रंग सेट करने का समर्थन करता है, अगर हम एक ही समय में रंग सेटिंग और धक्का का उपयोग, हम पहले रंग सेट करने की जरूरत है और उपयोग@अंतिम धक्का सेट करने के लिए चरित्र.
function main() {
Log("`data:image/png;base64,AAAA`")
}
def main():
Log("`data:image/png;base64,AAAA`")
void main() {
Log("`data:image/png;base64,AAAA`");
}
..Log()कार्य मुद्रण का समर्थन करता हैbase64एन्कोडेड छवियों, के साथ शुरू`और इसके साथ समाप्त होता है`उदाहरण के लिए:
import matplotlib.pyplot as plt
def main():
plt.plot([3,6,2,4,7,1])
Log(plt)
..Log()कार्य प्रत्यक्ष मुद्रण का समर्थन करता हैPythonहैmatplotlib.pyplotजब तक वस्तु मेंsavefigविधि, यह सीधे प्रिंट किया जा सकता हैLogकार्य, उदाहरण के लिएः
function main() {
Log("[trans]中文|abc[/trans]")
}
def main():
Log("[trans]中文|abc[/trans]")
void main() {
Log("[trans]中文|abc[/trans]");
}
..Log()भाषा स्विचिंग का समर्थन करता है।Log()फ़ंक्शन आउटपुट टेक्स्ट जो प्लेटफ़ॉर्म पृष्ठ पर भाषा सेटिंग के आधार पर स्वचालित रूप से संबंधित भाषा में स्विच करेगा, उदाहरण के लिएः
..Log()कार्य लाइव ट्रेडिंग या बैकटेस्टिंग प्रणाली के लॉग क्षेत्र में एक लॉग संदेश आउटपुट करता है, और लाइव ट्रेडिंग चल रहा है जब लाइव ट्रेडिंग डेटाबेस में लॉग सहेजा जाता है।Log()फ़ंक्शन एक लॉग संदेश के साथ समाप्त होता है@अक्षर, तो इस लॉग संदेश पुश कतार में प्रवेश करेगा. ईमेल पते, वेबहूक पते, आदि में विन्यस्त करने के लिए पुशसेटिंग्स दबाएँवर्तमान एफएमजेड क्वांट ट्रेडिंग प्लेटफॉर्म खाते का संदेश पुशिंग समर्थित नहीं हैडिबगिंग उपकरण, बैकटेस्टिंग सिस्टम. संदेश पुश के लिए एक आवृत्ति सीमा है। विशिष्ट प्रतिबंध नियम इस प्रकार हैंः लाइव ट्रेडिंग के 20 सेकंड के चक्र के भीतर, केवल अंतिम पुश संदेश को बनाए रखा जाएगा और पुश किया जाएगा, और अन्य संदेशों को फ़िल्टर किया जाएगा और पुश नहीं किया जाएगा (लॉग फ़ंक्शन द्वारा पुश लॉग आउटपुट को लॉग क्षेत्र में मुद्रित और प्रदर्शित किया जाएगा) ।
के लिएWebHookधक्का, आप द्वारा लिखित सेवा कार्यक्रम का उपयोग कर सकते हैंGolang:
package main
import (
"fmt"
"net/http"
)
func Handle (w http.ResponseWriter, r *http.Request) {
defer func() {
fmt.Println("req:", *r)
}()
}
func main () {
fmt.Println("listen http://localhost:9090")
http.HandleFunc("/data", Handle)
http.ListenAndServe(":9090", nil)
}
सेटWebHookमेंसेटिंग्स दबाएँ: http://XXX.XX.XXX.XX:9090/data?data=Hello_FMZ.
लिखित चलाने के बादGolangसेवा कार्यक्रम, हम रणनीति लाइव व्यापार चलाने के लिए शुरू करते हैं, निम्नलिखित में लिखा रणनीति हैJavaScriptभाषा, रणनीति को निष्पादित करके चलाया जाता हैLog()कार्य और संदेश धक्काः
function main() {
Log("msg", "@")
}
एक सेवा कार्यक्रमGolangभाषा धक्का प्राप्त करता है और सेवा कार्यक्रम संदेश मुद्रित करता हैः
listen http://localhost:9090
req: {GET /data?data=Hello_FMZ HTTP/1.1 1 1 map[User-Agent:[Mozilla/5.0 (Macintosh; Intel Mac OS X 10_9_3) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/xx.x.xxxx.xxx Safari/537.36] Accept-Encoding:[gzip]] {} <nil> 0 [] false 1XX.XX.X.XX:9090 map[] map[] <nil> map[] XXX.XX.XXX.XX:4xxx2 /data?data=Hello_FMZ <nil> <nil> <nil> 0xc420056300
{@fun/Log/LogReset LogReset}, {@fun/Log/LogVacuum LogVacuum}
P&L मान दर्ज करें, P&L मान प्रिंट करें और P&L मान के आधार पर रिटर्न वक्र को प्लॉट करें।
LogProfit (लाभ) LogProfit ((लाभ,... args)
पैरामीटरprofitराजस्व डेटा है, जो रणनीति में डिजाइन एल्गोरिथ्म और गणना द्वारा दिया जाता है।
लाभ
सच
संख्या
राजस्व लॉग के लिए आकस्मिक जानकारी आउटपुट करने के लिए विस्तारित पैरामीटर,argपैरामीटर एक से अधिक पारित किया जा सकता है।
आर्ग
झूठी
स्ट्रिंग, संख्या, बोल, ऑब्जेक्ट, सरणी, सिस्टम द्वारा समर्थित कोई भी प्रकार जैसे शून्य।
function main() {
// Print 30 points on the earnings chart
for(var i = 0; i < 30; i++) {
LogProfit(i, '&')
Sleep(500)
}
}
def main():
for i in range(30):
LogProfit(i, '&')
Sleep(500)
void main() {
for(int i = 0; i < 30; i++) {
LogProfit(i, '&');
Sleep(500);
}
}
..LogProfitfunction, यदि यह अक्षर के साथ समाप्त होता है&, केवल राजस्व चार्ट तैयार करता है और राजस्व लॉग नहीं प्रिंट करता है। उदाहरण के लिएः
{@fun/Log/LogProfitReset LogProfitReset} {@fun/Log/LogProfitReset} {@fun/Log/LogProfitReset} {@logProfitReset} {@logProfitReset} {@logProfitReset} {@logProfitReset} {@logProfitReset}
सभी राजस्व लॉग, राजस्व चार्ट साफ़ करें।
लॉगप्रॉफ़िट रीसेट करें (() लॉगप्रॉफिट रीसेट (अभी तक)
..remainपैरामीटर का उपयोग लॉग प्रविष्टियों (पूर्णांक मान) की संख्या को निर्दिष्ट करने के लिए किया जाता है।
रहना
झूठी
संख्या
function main() {
// Print 30 points on the revenue chart, then reset and keep only the last 10 points
for(var i = 0; i < 30; i++) {
LogProfit(i)
Sleep(500)
}
LogProfitReset(10)
}
def main():
for i in range(30):
LogProfit(i)
Sleep(500)
LogProfitReset(10)
void main() {
for(int i = 0; i < 30; i++) {
LogProfit(i);
Sleep(500);
}
LogProfitReset(10);
}
{@fun/Log/LogProfit लॉगप्रॉफिट}
बैकटेस्टिंग प्रणाली या लाइव ट्रेडिंग पेज के स्टेटस बार में आउटपुट जानकारी।
लॉगस्टेटस ((...msgs)
पैरामीटरmsgआउटपुट की सामग्री है, और पैरामीटरmsgएक से अधिक पारित किया जा सकता है।
msg
झूठी
स्ट्रिंग, संख्या, बोल, ऑब्जेक्ट, सरणी, सिस्टम द्वारा समर्थित कोई भी प्रकार जैसे शून्य।
function main() {
LogStatus('This is a general status alert')
LogStatus('This is a status alert in red font #ff0000')
LogStatus('This is a multi-line status message \n I am the second line')
}
def main():
LogStatus('This is a general status alert')
LogStatus('This is a status alert in red font #ff0000')
LogStatus('This is a multi-line status message \n I am the second line')
void main() {
LogStatus("This is a general status alert");
LogStatus("This is a status alert in red font #ff0000");
LogStatus("This is a multi-line status message \n I am the second line");
}
यह आउटपुट सामग्री का रंग सेट करने का समर्थन करता हैः
function main() {
var table = {type: 'table', title: 'Position information', cols: ['Column 1', 'Column 2'], rows: [ ['abc', 'def'], ['ABC', 'support color #ff0000']]}
// JSON serialization with the ` character on both sides, as a complex message format (support tables currently)
LogStatus('`' + JSON.stringify(table) + '`')
// Table information can also appear in multiple rows
LogStatus('First line of message\n`' + JSON.stringify(table) + '`\n third line of message')
// It supports multiple tables at the same time, will be displayed in a group with TAB
LogStatus('`' + JSON.stringify([table, table]) + '`')
// You can also construct a button in the form, and use the GetCommand strategy to receive the contents of the cmd attribute
var table = {
type: 'table',
title: 'Position operations',
cols: ['Column 1', 'Column 2', 'Action'],
rows: [
['abc', 'def', {'type':'button', 'cmd': 'coverAll', 'name': 'Close out positions'}]
]
}
LogStatus('`' + JSON.stringify(table) + '`')
// Or construct a separate button
LogStatus('`' + JSON.stringify({'type':'button', 'cmd': 'coverAll', 'name': 'Close out positions'}) + '`')
// Customizable button style (bootstrap's button attribute)
LogStatus('`' + JSON.stringify({'type':'button', 'class': 'btn btn-xs btn-danger', 'cmd': 'coverAll', 'name': 'Close out positions'}) + '`')
}
import json
def main():
table = {"type": "table", "title": "Position information", "cols": ["Column 1", "Column 2"], "rows": [["abc", "def"], ["ABC", "support color #ff0000"]]}
LogStatus('`' + json.dumps(table) + '`')
LogStatus('First line of message\n`' + json.dumps(table) + '`\n third line of message')
LogStatus('`' + json.dumps([table, table]) + '`')
table = {
"type" : "table",
"title" : "Position operations",
"cols" : ["Column 1", "Column 2", "Action"],
"rows" : [
["abc", "def", {"type": "button", "cmd": "coverAll", "name": "Close out positions"}]
]
}
LogStatus('`' + json.dumps(table) + '`')
LogStatus('`' + json.dumps({"type": "button", "cmd": "coverAll", "name": "Close out positions"}) + '`')
LogStatus('`' + json.dumps({"type": "button", "class": "btn btn-xs btn-danger", "cmd": "coverAll", "name": "Close out positions"}) + '`')
void main() {
json table = R"({"type": "table", "title": "Position information", "cols": ["Column 1", "Column 2"], "rows": [["abc", "def"], ["ABC", "support color #ff0000"]]})"_json;
LogStatus("`" + table.dump() + "`");
LogStatus("First line of message\n`" + table.dump() + "`\n third line of message");
json arr = R"([])"_json;
arr.push_back(table);
arr.push_back(table);
LogStatus("`" + arr.dump() + "`");
table = R"({
"type" : "table",
"title" : "Position operations",
"cols" : ["Column 1", "Column 2", "Action"],
"rows" : [
["abc", "def", {"type": "button", "cmd": "coverAll", "name": "Close out positions"}]
]
})"_json;
LogStatus("`" + table.dump() + "`");
LogStatus("`" + R"({"type": "button", "cmd": "coverAll", "name": "Close out positions"})"_json.dump() + "`");
LogStatus("`" + R"({"type": "button", "class": "btn btn-xs btn-danger", "cmd": "coverAll", "name": "Close out positions"})"_json.dump() + "`");
}
स्थिति पट्टी में डेटा आउटपुट का उदाहरणः
function main() {
var table = {
type: "table",
title: "status bar button style",
cols: ["default", "original", "success", "info", "warning", "danger"],
rows: [
[
{"type":"button", "class": "btn btn-xs btn-default", "name": "default"},
{"type":"button", "class": "btn btn-xs btn-primary", "name": "original"},
{"type":"button", "class": "btn btn-xs btn-success", "name": "success"},
{"type":"button", "class": "btn btn-xs btn-info", "name": "info"},
{"type":"button", "class": "btn btn-xs btn-warning", "name": "warning"},
{"type":"button", "class": "btn btn-xs btn-danger", "name": "danger"}
]
]
}
LogStatus("`" + JSON.stringify(table) + "`")
}
import json
def main():
table = {
"type": "table",
"title": "status bar button style",
"cols": ["default", "original", "success", "info", "warning", "danger"],
"rows": [
[
{"type":"button", "class": "btn btn-xs btn-default", "name": "default"},
{"type":"button", "class": "btn btn-xs btn-primary", "name": "original"},
{"type":"button", "class": "btn btn-xs btn-success", "name": "success"},
{"type":"button", "class": "btn btn-xs btn-info", "name": "info"},
{"type":"button", "class": "btn btn-xs btn-warning", "name": "warning"},
{"type":"button", "class": "btn btn-xs btn-danger", "name": "danger"}
]
]
}
LogStatus("`" + json.dumps(table) + "`")
void main() {
json table = R"({
"type": "table",
"title": "status bar button style",
"cols": ["default", "original", "success", "info", "warning", "danger"],
"rows": [
[
{"type":"button", "class": "btn btn-xs btn-default", "name": "default"},
{"type":"button", "class": "btn btn-xs btn-primary", "name": "original"},
{"type":"button", "class": "btn btn-xs btn-success", "name": "success"},
{"type":"button", "class": "btn btn-xs btn-info", "name": "info"},
{"type":"button", "class": "btn btn-xs btn-warning", "name": "warning"},
{"type":"button", "class": "btn btn-xs btn-danger", "name": "danger"}
]
]
})"_json;
LogStatus("`" + table.dump() + "`");
}
यह स्थिति पट्टी (पुराने बटन संरचना) में बटन नियंत्रणों को डिजाइन करने के लिए समर्थन करता हैः
function main() {
var table = {
type: "table",
title: "Status bar button disable, description function test",
cols: ["Column 1", "Column 2", "Column 3"],
rows: []
}
var button1 = {"type": "button", "name": "button1", "cmd": "button1", "description": "This is the first button"}
var button2 = {"type": "button", "name": "button2", "cmd": "button2", "description": "This is the second button, set to disabled", "disabled": true}
var button3 = {"type": "button", "name": "button3", "cmd": "button3", "description": "This is the third button, set to enable", "disabled": false}
table.rows.push([button1, button2, button3])
LogStatus("`" + JSON.stringify(table) + "`")
}
import json
def main():
table = {
"type": "table",
"title": "Status bar button disable, description function test",
"cols": ["Column 1", "Column 2", "Column 3"],
"rows": []
}
button1 = {"type": "button", "name": "button1", "cmd": "button1", "description": "This is the first button"}
button2 = {"type": "button", "name": "button2", "cmd": "button2", "description": "This is the second button, set to disabled", "disabled": True}
button3 = {"type": "button", "name": "button3", "cmd": "button3", "description": "This is the third button, set to enable", "disabled": False}
table["rows"].append([button1, button2, button3])
LogStatus("`" + json.dumps(table) + "`")
void main() {
json table = R"({
"type": "table",
"title": "Status bar button disable, description function test",
"cols": ["Column 1", "Column 2", "Column 3"],
"rows": []
})"_json;
json button1 = R"({"type": "button", "name": "button1", "cmd": "button1", "description": "This is the first button"})"_json;
json button2 = R"({"type": "button", "name": "button2", "cmd": "button2", "description": "This is the second button, set to disabled", "disabled": true})"_json;
json button3 = R"({"type": "button", "name": "button3", "cmd": "button3", "description": "This is the third button, set to enable", "disabled": false})"_json;
json arr = R"([])"_json;
arr.push_back(button1);
arr.push_back(button2);
arr.push_back(button3);
table["rows"].push_back(arr);
LogStatus("`" + table.dump() + "`");
}
स्थिति पट्टी बटन (पुराना बटन संरचना) के अक्षम, विवरण फ़ंक्शन सेट करेंः
function test1() {
Log("Calling custom functions")
}
function main() {
while (true) {
var table = {
type: 'table',
title: 'operation',
cols: ['column1', 'column2', 'Action'],
rows: [
['a', '1', {
'type': 'button',
'cmd': "CoverAll",
'name': 'Close out positions'
}],
['b', '1', {
'type': 'button',
'cmd': 10,
'name': 'Send values'
}],
['c', '1', {
'type': 'button',
'cmd': _D(),
'name': 'Calling functions'
}],
['d', '1', {
'type': 'button',
'cmd': 'test1',
'name': 'Calling custom functions'
}]
]
}
LogStatus(_D(), "\n", '`' + JSON.stringify(table) + '`')
var str_cmd = GetCommand()
if (str_cmd) {
Log("Received interaction data str_cmd:", "type:", typeof(str_cmd), "value:", str_cmd)
if(str_cmd == "test1") {
test1()
}
}
Sleep(500)
}
}
import json
def test1():
Log("Calling custom functions")
def main():
while True:
table = {
"type": "table",
"title": "operation",
"cols": ["column1", "column2", "Action"],
"rows": [
["a", "1", {
"type": "button",
"cmd": "CoverAll",
"name": "Close out positions"
}],
["b", "1", {
"type": "button",
"cmd": 10,
"name": "Send values"
}],
["c", "1", {
"type": "button",
"cmd": _D(),
"name": "Calling functions"
}],
["d", "1", {
"type": "button",
"cmd": "test1",
"name": "Calling custom functions"
}]
]
}
LogStatus(_D(), "\n", "`" + json.dumps(table) + "`")
str_cmd = GetCommand()
if str_cmd:
Log("Received interaction data str_cmd:", "type:", typeof(str_cmd), "value:", str_cmd)
if str_cmd == "test1":
test1()
Sleep(500)
void test1() {
Log("Calling custom functions");
}
void main() {
while(true) {
json table = R"({
"type": "table",
"title": "operation",
"cols": ["column1", "column2", "Action"],
"rows": [
["a", "1", {
"type": "button",
"cmd": "CoverAll",
"name": "Close out positions"
}],
["b", "1", {
"type": "button",
"cmd": 10,
"name": "Send values"
}],
["c", "1", {
"type": "button",
"cmd": "",
"name": "Calling functions"
}],
["d", "1", {
"type": "button",
"cmd": "test1",
"name": "Calling custom functions"
}]
]
})"_json;
table["rows"][2][2]["cmd"] = _D();
LogStatus(_D(), "\n", "`" + table.dump() + "`");
auto str_cmd = GetCommand();
if(str_cmd != "") {
Log("Received interaction data str_cmd:", "type:", typeof(str_cmd), "value:", str_cmd);
if(str_cmd == "test1") {
test1();
}
}
Sleep(500);
}
}
के साथ संयोजन मेंGetCommand()फ़ंक्शन, स्थिति पट्टी बटन इंटरैक्शन फ़ंक्शन (पुराना बटन संरचना) का निर्माण करेंः
function main() {
var tbl = {
type: "table",
title: "operation",
cols: ["column1", "column2"],
rows: [
["Open position operation", {"type": "button", "cmd": "open", "name": "open position", "input": {"name": "number of open positions", "type": "number", "defValue": 1}}],
["Close position operation", {"type": "button", "cmd": "coverAll", "name": "close all positions"}]
]
}
LogStatus(_D(), "\n", "`" + JSON.stringify(tbl) + "`")
while (true) {
var cmd = GetCommand()
if (cmd) {
Log("cmd:", cmd)
}
Sleep(1000)
}
}
import json
def main():
tbl = {
"type": "table",
"title": "operation",
"cols": ["column1", "column2"],
"rows": [
["Open position operation", {"type": "button", "cmd": "open", "name": "open position", "input": {"name": "number of open positions", "type": "number", "defValue": 1}}],
["Close position operation", {"type": "button", "cmd": "coverAll", "name": "close all positions"}]
]
}
LogStatus(_D(), "\n", "`" + json.dumps(tbl) + "`")
while True:
cmd = GetCommand()
if cmd:
Log("cmd:", cmd)
Sleep(1000)
void main() {
json tbl = R"({
"type": "table",
"title": "operation",
"cols": ["column1", "column2"],
"rows": [
["Open position operation", {"type": "button", "cmd": "open", "name": "open position", "input": {"name": "number of open positions", "type": "number", "defValue": 1}}],
["Close position operation", {"type": "button", "cmd": "coverAll", "name": "close all positions"}]
]
})"_json;
LogStatus(_D(), "\n", "`" + tbl.dump() + "`");
while(true) {
auto cmd = GetCommand();
if(cmd != "") {
Log("cmd:", cmd);
}
Sleep(1000);
}
}
इनपुट डेटा को इंटरैक्शन के लिए स्टेटस बार बटन बनाने के समय भी सपोर्ट किया जाता है और इंटरैक्शन कमांड कोGetCommand()कार्य अंततः. जोड़ेंinputवस्तुओं (पुराने बटन संरचना) स्थिति पट्टी में बटन नियंत्रण के डेटा संरचना के लिए, उदाहरण के लिए जोड़ने"input": {"name": "number of open positions", "type": "number", "defValue": 1}तक{"type": "button", "cmd": "open", "name": "open position"}जब बटन क्लिक किया जाता है तो इनपुट बॉक्स नियंत्रण के साथ एक पॉपअप दिखाई देगा (इनपुट बॉक्स में डिफ़ॉल्ट मान 1 है, जो कि डेटा द्वारा सेट किया गया हैdefValue) आप बटन कमांड के साथ भेजने के लिए एक डेटा दर्ज कर सकते हैं। उदाहरण के लिए, जब निम्न परीक्षण कोड चलाया जाता है, "ओपन पोजीशनGetCommand()फ़ंक्शन तब संदेश कैप्चर करेगाःopen:111.
function main() {
var tbl = {
type: "table",
title: "Demonstrate grouping button control",
cols: ["operation"],
rows: []
}
// Creating a grouping button control structure
var groupBtn = {
type: "button",
cmd: "open",
name: "open positions",
group: [
{"name": "orderType", "description": "下单方式|order type", "type": "selected", "defValue": "market order|pending order"},
{"name": "tradePrice@orderType==1", "description": "交易价格|trade price", "type": "number", "defValue": 100},
{"name": "orderAmount", "description": "委托数量|order amount", "type": "string", "defValue": 100},
{"name": "boolean", "description": "yes/no|boolean", "type": "boolean", "defValue": true}
]
}
// test button 1
var testBtn1 = {"type": "button", "name": "button1", "cmd": "button1", "description": "This is the first button."}
var testBtn2 = {"type": "button", "name": "button2", "cmd": "button2", "description": "This is the second button.", "input": {"name": "number of positions opened", "type": "number", "defValue": 1}}
// Add groupBtn to tbl
tbl.rows.push([groupBtn])
// It supports multiple buttons in a cell of a status bar table, i.e. the data in a cell is an array of button structures: [testBtn1, testBtn2].
tbl.rows.push([[testBtn1, testBtn2]])
while (true) {
LogStatus("`" + JSON.stringify(tbl) + "`", "\n", "The grouping button control can also be set directly on the status bar in addition to being set on the status bar form:", "`" + JSON.stringify(groupBtn) + "`")
var cmd = GetCommand()
if (cmd) {
Log("cmd:", cmd)
}
Sleep(5000)
}
}
import json
def main():
tbl = {
"type": "table",
"title": "Demonstrate grouping button control",
"cols": ["operation"],
"rows": []
}
groupBtn = {
"type": "button",
"cmd": "open",
"name": "open positions",
"group": [
{"name": "orderType", "description": "下单方式|order type", "type": "selected", "defValue": "market order|pending order"},
{"name": "tradePrice@orderType==1", "description": "交易价格|trade price", "type": "number", "defValue": 100},
{"name": "orderAmount", "description": "委托数量|order amount", "type": "string", "defValue": 100},
{"name": "boolean", "description": "yes/no|boolean", "type": "boolean", "defValue": True}
]
}
testBtn1 = {"type": "button", "name": "button1", "cmd": "button1", "description": "This is the first button."}
testBtn2 = {"type": "button", "name": "button2", "cmd": "button2", "description": "This is the second button.", "input": {"name": "number of positions opened", "type": "number", "defValue": 1}}
tbl["rows"].append([groupBtn])
tbl["rows"].append([[testBtn1, testBtn2]])
while True:
LogStatus("`" + json.dumps(tbl) + "`", "\n", "The grouping button control can also be set directly on the status bar in addition to being set on the status bar form:", "`" + json.dumps(groupBtn) + "`")
cmd = GetCommand()
if cmd:
Log("cmd:", cmd)
Sleep(5000)
void main() {
json tbl = R"({
"type": "table",
"title": "Demonstrate grouping button control",
"cols": ["operation"],
"rows": []
})"_json;
json groupBtn = R"({
"type": "button",
"name": "open positions",
"cmd": "open",
"group": [
{"name": "orderType", "description": "下单方式|order type", "type": "selected", "defValue": "market order|pending order"},
{"name": "tradePrice@orderType==1", "description": "交易价格|trade price", "type": "number", "defValue": 100},
{"name": "orderAmount", "description": "委托数量|order amount", "type": "string", "defValue": 100},
{"name": "boolean", "description": "yes/no|boolean", "type": "boolean", "defValue": true}
]})"_json;
json testBtn1 = R"({"type": "button", "name": "button1", "cmd": "button1", "description": "This is the first button."})"_json;
json testBtn2 = R"({"type": "button", "name": "button2", "cmd": "button2", "description": "This is the second button.", "input": {"name": "number of positions opened", "type": "number", "defValue": 1}})"_json;
tbl["rows"].push_back({groupBtn});
tbl["rows"].push_back({{testBtn1, testBtn2}});
while(true) {
LogStatus("`" + tbl.dump() + "`", "\n", "The grouping button control can also be set directly on the status bar in addition to being set on the status bar form:", "`" + groupBtn.dump() + "`");
auto cmd = GetCommand();
if(cmd != "") {
Log("cmd:", cmd);
}
Sleep(5000);
}
}
यह समूहित बटन नियंत्रणों (पुराने बटन संरचना) के लिए समर्थन करता है, कार्यात्मक रूप से संगतस्थिति पट्टी बटन जो डेटा प्रविष्टि का समर्थन करते हैंअंततः इंटरैक्टिव कमांड को कंप्यूटर द्वारा कैप्चर किया जाता है।GetCommand()फ़ंक्शन। अंतर यह है कि"group"फ़ील्ड सेटिंग, जब बटन पर क्लिक किया जाता है बातचीत को ट्रिगर करने के लिए, संवाद पृष्ठ पर पॉप अप होता है के एक सेट होता हैसमूहइनपुट नियंत्रणों के एक बार में डेटा के एक समूह में प्रवेश करने के लिए स्थापित.
कुछ बिंदुओं को ध्यान में रखना चाहिए"group"स्थिति पट्टी बटन नियंत्रण और समूह बटन नियंत्रण की संरचना में फ़ील्डः
typeसमूह में संपत्ति केवल निम्नलिखित चार प्रकार का समर्थन करता है, औरdefValueproperty डिफ़ॉल्ट मान है.
|एक ड्रॉपडाउन बॉक्स में प्रत्येक विकल्प को अलग करने के लिए प्रतीक के रूप में यह सेट किया गया है.
"name": "tradePrice@orderType==1"सेटिंग, जो बनाता हैव्यापार मूल्यइनपुट नियंत्रण केवल उपलब्ध है जबआदेशप्रकारड्रॉप-डाउन नियंत्रण के रूप में चयनित हैलंबित आदेश.|चीनी और अंग्रेजी में विवरण की सामग्री को अलग करने के लिए प्रतीक।name, descriptionसमूह में औरname, descriptionबटन संरचना में एक ही परिभाषा नहीं है, भले ही वे एक ही क्षेत्र नाम है.
परिभाषाnameसमूह में भी परिभाषा से अलग हैnameइनपुट में।Log("cmd:", cmd)निम्नलिखित उदाहरण परीक्षण में कथनःcmd: open:{"orderType":1,"tradePrice":99,"orderAmount":"99","boolean":true}, अर्थात, जो कि द्वारा लौटाया जाता हैGetCommand()कार्य जब एक बातचीत होती हैःopen:{"orderType":1,"tradePrice":99,"orderAmount":"99","boolean":true}.typeबटन नियंत्रण की संपत्ति केवल समर्थन करता हैः"button".
बटन नियंत्रण जो इनपुट डेटा का समर्थन करते हैं, अर्थात नियंत्रणinputगुण सेट,typeसंरचना की जानकारी में संपत्तिinputफ़ील्ड कई नियंत्रण प्रकारों का समर्थन करता है.
निम्नलिखित उदाहरण देखें:function main() {
// Status bar button control (set input field to implement) testBtn1 button triggered by the page in the drop-down box control using the options field to set options, using the defValue field to set the default options. This is different from the other examples in this chapter, which use defValue to set the options directly.
var testBtn1 = {
type: "button",
name: "testBtn1",
cmd: "cmdTestBtn1",
input: {name: "testBtn1ComboBox", type: "selected", options: ["A", "B"], defValue: 1}
}
/*
Status bar button control (set input field implementation) testBtn2 button triggered by the page in the drop-down box control using the options field to set the options, options field in the options field not only supports the string,
the use of the ```{text: "description", value: "value"}``` structure is also supported. Use the defValue field to set the default option, which can be multiple choice (multiple choice via array structure). Multiple choice requires setting the additional field multiple to a true value.
*/
var testBtn2 = {
type: "button",
name: "testBtn2",
cmd: "cmdTestBtn2",
input: {
name: "testBtn2MultiComboBox",
type: "selected",
description: "Implementing dropdown box multi-selection",
options: [{text: "Option A", value: "A"}, {text: "Option B", value: "B"}, {text: "Option C", value: "C"}],
defValue: ["A", "C"],
multiple: true
}
}
// Status bar grouping button control (set group field implementation) testBtn3 button triggered by the page in the drop-down box control using the options field to set options, also supports the direct use of defValue set options.
var testBtn3 = {
type: "button",
name: "testBtn3",
cmd: "cmdTestBtn3",
group: [
{name: "comboBox1", label: "labelComboBox1", description: "Dropdown box 1", type: "selected", defValue: 1, options: ["A", "B"]},
{name: "comboBox2", label: "labelComboBox2", description: "Dropdown box 2", type: "selected", defValue: "A|B"},
{name: "comboBox3", label: "labelComboBox3", description: "Dropdown box 3", type: "selected", defValue: [0, 2], multiple: true, options: ["A", "B", "C"]},
{
name: "comboBox4",
label: "labelComboBox4",
description: "Dropdown box 4",
type: "selected",
defValue: ["A", "C"],
multiple: true,
options: [{text: "Option A", value: "A"}, {text: "Option B", value: "B"}, {text: "Option C", value: "C"}, {text: "Option D", value: "D"}]
}
]
}
while (true) {
LogStatus("`" + JSON.stringify(testBtn1) + "`\n", "`" + JSON.stringify(testBtn2) + "`\n", "`" + JSON.stringify(testBtn3) + "`\n")
var cmd = GetCommand()
if (cmd) {
Log(cmd)
}
Sleep(5000)
}
}
import json
def main():
testBtn1 = {
"type": "button",
"name": "testBtn1",
"cmd": "cmdTestBtn1",
"input": {"name": "testBtn1ComboBox", "type": "selected", "options": ["A", "B"], "defValue": 1}
}
testBtn2 = {
"type": "button",
"name": "testBtn2",
"cmd": "cmdTestBtn2",
"input": {
"name": "testBtn2MultiComboBox",
"type": "selected",
"description": "Implementing dropdown box multi-selection",
"options": [{"text": "Option A", "value": "A"}, {"text": "Option B", "value": "B"}, {"text": "Option C", "value": "C"}],
"defValue": ["A", "C"],
"multiple": True
}
}
testBtn3 = {
"type": "button",
"name": "testBtn3",
"cmd": "cmdTestBtn3",
"group": [
{"name": "comboBox1", "label": "labelComboBox1", "description": "Dropdown box 1", "type": "selected", "defValue": 1, "options": ["A", "B"]},
{"name": "comboBox2", "label": "labelComboBox2", "description": "Dropdown box 2", "type": "selected", "defValue": "A|B"},
{"name": "comboBox3", "label": "labelComboBox3", "description": "Dropdown box 3", "type": "selected", "defValue": [0, 2], "multiple": True, "options": ["A", "B", "C"]},
{
"name": "comboBox4",
"label": "labelComboBox4",
"description": "Dropdown box 4",
"type": "selected",
"defValue": ["A", "C"],
"multiple": True,
"options": [{"text": "Option A", "value": "A"}, {"text": "Option B", "value": "B"}, {"text": "Option C", "value": "C"}, {"text": "Option D", "value": "D"}]
}
]
}
while True:
LogStatus("`" + json.dumps(testBtn1) + "`\n", "`" + json.dumps(testBtn2) + "`\n", "`" + json.dumps(testBtn3) + "`\n")
cmd = GetCommand()
if cmd:
Log(cmd)
Sleep(5000)
void main() {
json testBtn1 = R"({
"type": "button",
"name": "testBtn1",
"cmd": "cmdTestBtn1",
"input": {"name": "testBtn1ComboBox", "type": "selected", "options": ["A", "B"], "defValue": 1}
})"_json;
json testBtn2 = R"({
"type": "button",
"name": "testBtn2",
"cmd": "cmdTestBtn2",
"input": {
"name": "testBtn2MultiComboBox",
"type": "selected",
"description": "Implementing dropdown box multi-selection",
"options": [{"text": "Option A", "value": "A"}, {"text": "Option B", "value": "B"}, {"text": "Option C", "value": "C"}],
"defValue": ["A", "C"],
"multiple": true
}
})"_json;
json testBtn3 = R"({
"type": "button",
"name": "testBtn3",
"cmd": "cmdTestBtn3",
"group": [
{"name": "comboBox1", "label": "labelComboBox1", "description": "Dropdown box 1", "type": "selected", "defValue": 1, "options": ["A", "B"]},
{"name": "comboBox2", "label": "labelComboBox2", "description": "Dropdown box 2", "type": "selected", "defValue": "A|B"},
{"name": "comboBox3", "label": "labelComboBox3", "description": "Dropdown box 3", "type": "selected", "defValue": [0, 2], "multiple": true, "options": ["A", "B", "C"]},
{
"name": "comboBox4",
"label": "labelComboBox4",
"description": "Dropdown box 4",
"type": "selected",
"defValue": ["A", "C"],
"multiple": true,
"options": [{"text": "Option A", "value": "A"}, {"text": "Option B", "value": "B"}, {"text": "Option C", "value": "C"}, {"text": "Option D", "value": "D"}]
}
]
})"_json;
while (true) {
LogStatus("`" + testBtn1.dump() + "`\n", "`" + testBtn2.dump() + "`\n", "`" + testBtn3.dump() + "`\n");
auto cmd = GetCommand();
if (cmd != "") {
Log(cmd);
}
Sleep(5000);
}
}
जब स्थिति पट्टी समूह बटन नियंत्रण (सेटिंग द्वारा लागूgroupफ़ील्ड) और स्थिति पट्टी बटन नियंत्रण (सेटिंग द्वारा लागूinputफ़ील्ड) पर क्लिक किया जाता है ताकि बातचीत शुरू हो सके (पुराना बटन संरचना), पृष्ठ पर पॉप अप होने वाले संवाद बॉक्स में ड्रॉप-डाउन बॉक्स नियंत्रण भी कई चयनों का समर्थन करता है। निम्नलिखित उदाहरण दर्शाता है कि कई चयन विकल्पों के साथ एक ड्रॉप-डाउन बॉक्स नियंत्रण कैसे डिज़ाइन किया जाए:
var symbols = ["BTC_USDT.swap", "ETH_USDT.swap", "LTC_USDT.swap", "BNB_USDT.swap", "SOL_USDT.swap"]
function createBtn(tmp, group) {
var btn = JSON.parse(JSON.stringify(tmp))
_.each(group, function(eleByGroup) {
btn["group"].unshift(eleByGroup)
})
return btn
}
function main() {
var arrManager = []
_.each(symbols, function(symbol) {
arrManager.push({
"symbol": symbol,
})
})
// Btn
var tmpBtnOpen = {
"type": "button",
"cmd": "open",
"name": "Open a position and place an order",
"group": [{
"type": "selected",
"name": "tradeType",
"label": "Order type",
"description": "Market order, limit order",
"default": 0,
"group": "Trading setup",
"settings": {
"options": ["Market order", "Limit order"],
"required": true,
}
}, {
"type": "selected",
"name": "direction",
"label": "Trading direction",
"description": "Buy, sell",
"default": "buy",
"group": "Trading setup",
"settings": {
"render": "segment",
"required": true,
"options": [{"name": "buy", "value": "buy"}, {"name": "sell", "value": "sell"}],
}
}, {
"type": "number",
"name": "price",
"label": "price",
"description": "The price of the order",
"group": "Trading setup",
"filter": "tradeType==1",
"settings": {
"required": true,
}
}, {
"type": "number",
"name": "amount",
"label": "Order quantity",
"description": "Order quantity",
"group": "Trading setup",
"settings": {
"required": true,
}
}],
}
while (true) {
var tbl = {"type": "table", "title": "dashboard", "cols": ["symbol", "actionOpen"], "rows": []}
_.each(arrManager, function(m) {
var btnOpen = createBtn(tmpBtnOpen, [{"type": "string", "name": "symbol", "label": "Trading instruments", "default": m["symbol"], "settings": {"required": true}}])
tbl["rows"].push([m["symbol"], btnOpen])
})
var cmd = GetCommand()
if (cmd) {
Log("Receive interaction:", cmd)
// Parsing interaction messages: open:{"symbol":"LTC_USDT.swap","tradeType":0,"direction":"buy","amount":111}
// According to the first colon: the previous instruction determines which button template triggers the message
var arrCmd = cmd.split(":", 2)
if (arrCmd[0] == "open") {
var msg = JSON.parse(cmd.slice(5))
Log("Trading instruments:", msg["symbol"], ", Trading direction:", msg["direction"], ", Order type:", msg["tradeType"] == 0 ? "Market order" : "Limit order", msg["tradeType"] == 0 ? ", Order price: current market price" : ", Order price:" + msg["price"], ", Order quantity:", msg["amount"])
}
}
LogStatus(_D(), "\n", "`" + JSON.stringify(tbl) + "`")
Sleep(1000)
}
}
import json
symbols = ["BTC_USDT.swap", "ETH_USDT.swap", "LTC_USDT.swap", "BNB_USDT.swap", "SOL_USDT.swap"]
def createBtn(tmp, group):
btn = json.loads(json.dumps(tmp))
for eleByGroup in group:
btn["group"].insert(0, eleByGroup)
return btn
def main():
arrManager = []
for symbol in symbols:
arrManager.append({"symbol": symbol})
# Btn
tmpBtnOpen = {
"type": "button",
"cmd": "open",
"name": "Open a position and place an order",
"group": [{
"type": "selected",
"name": "tradeType",
"label": "Order type",
"description": "Market order, limit order",
"default": 0,
"group": "Trading setup",
"settings": {
"options": ["Market order", "Limit order"],
"required": True,
}
}, {
"type": "selected",
"name": "direction",
"label": "Trading direction",
"description": "Buy, sell",
"default": "buy",
"group": "Trading Setup",
"settings": {
"render": "segment",
"required": True,
"options": [{"name": "买入", "value": "buy"}, {"name": "卖出", "value": "sell"}],
}
}, {
"type": "number",
"name": "price",
"label": "price",
"description": "The price of the order",
"group": "Trading Setup",
"filter": "tradeType==1",
"settings": {
"required": True,
}
}, {
"type": "number",
"name": "amount",
"label": "Order quantity",
"description": "Order quantity",
"group": "Trading Setup",
"settings": {
"required": True,
}
}],
}
while True:
tbl = {"type": "table", "title": "dashboard", "cols": ["symbol", "actionOpen"], "rows": []}
for m in arrManager:
btnOpen = createBtn(tmpBtnOpen, [{"type": "string", "name": "symbol", "label": "交易品种", "default": m["symbol"], "settings": {"required": True}}])
tbl["rows"].append([m["symbol"], btnOpen])
cmd = GetCommand()
if cmd != "" and cmd != None:
Log("Receive interaction:", cmd)
# Parsing interaction messages: open:{"symbol":"LTC_USDT.swap","tradeType":0,"direction":"buy","amount":111}
# According to the first colon: the previous instruction determines which button template triggers the message
arrCmd = cmd.split(":")
if arrCmd[0] == "open":
msg = json.loads(cmd[5:])
Log("Trading instruments:", msg["symbol"], ", Trading direction:", msg["direction"], ", Order type:", "Market order" if msg["tradeType"] == 0 else "Limit order", ", Order price: current market price" if msg["tradeType"] == 0 else ", Order price:" + str(msg["price"]), ", Order quantity:", msg["amount"])
# Output status bar information
LogStatus(_D(), "\n", "`" + json.dumps(tbl) + "`")
Sleep(1000)
// Omit...
स्थिति पट्टी तालिका में बटन बनाने के लिए नवीनतम बटन संरचना का उपयोग करें. बातचीत को ट्रिगर करने के लिए बटन पर क्लिक करने पर, एक बहु-नियंत्रण पॉप-अप विंडो पॉप अप होगी. अधिक जानकारी के लिए, कृपया देखेंःउपयोगकर्ता गाइड - स्थिति पट्टी में इंटरैक्टिव नियंत्रण.
function main() {
var table = {
type: 'table',
title: 'position operation',
cols: ['column1', 'column2', 'Action'],
rows: [
['abc', 'def', {'type':'button', 'cmd': 'coverAll', 'name': 'close positions'}]
]
}
var ticker = exchange.GetTicker()
// Add a row of data, merge the first and second cells, and output the ticker variable in the merged cell
table.rows.push([{body : JSON.stringify(ticker), colspan : 2}, "abc"])
LogStatus('`' + JSON.stringify(table) + '`')
}
import json
def main():
table = {
"type" : "table",
"title" : "position operation",
"cols" : ["column1", "column2", "Action"],
"rows" : [
["abc", "def", {"type": "button", "cmd": "coverAll", "name": "close positions"}]
]
}
ticker = exchange.GetTicker()
table["rows"].append([{"body": json.dumps(ticker), "colspan": 2}, "abc"])
LogStatus("`" + json.dumps(table) + "`")
void main() {
json table = R"({
"type" : "table",
"title" : "position operation",
"cols" : ["column1", "column2", "Action"],
"rows" : [
["abc", "def", {"type": "button", "cmd": "coverAll", "name": "close positions"}]
]
})"_json;
auto ticker = exchange.GetTicker();
json jsonTicker = R"({"Buy": 0, "Sell": 0, "High": 0, "Low": 0, "Volume": 0, "Last": 0, "Time": 0})"_json;
jsonTicker["Buy"] = ticker.Buy;
jsonTicker["Sell"] = ticker.Sell;
jsonTicker["Last"] = ticker.Last;
jsonTicker["Volume"] = ticker.Volume;
jsonTicker["Time"] = ticker.Time;
jsonTicker["High"] = ticker.High;
jsonTicker["Low"] = ticker.Low;
json arr = R"([{"body": {}, "colspan": 2}, "abc"])"_json;
arr[0]["body"] = jsonTicker;
table["rows"].push_back(arr);
LogStatus("`" + table.dump() + "`");
}
तालिका के भीतर कक्षों का क्षैतिज विलयLogStatus()कार्य:
function main() {
var table = {
type: 'table',
title: 'table demo',
cols: ['columnA', 'columnB', 'columnC'],
rows: [
['A1', 'B1', {'type':'button', 'cmd': 'coverAll', 'name': 'C1'}]
]
}
var ticker = exchange.GetTicker()
var name = exchange.GetName()
table.rows.push([{body : "A2 + B2:" + JSON.stringify(ticker), colspan : 2}, "C2"])
table.rows.push([{body : "A3 + A4 + A5:" + name, rowspan : 3}, "B3", "C3"])
// A3 is merged by the first cell in the previous row
table.rows.push(["B4", "C4"])
// A2 is merged by the first cell of the previous row
table.rows.push(["B5", "C5"])
table.rows.push(["A6", "B6", "C6"])
LogStatus('`' + JSON.stringify(table) + '`')
}
import json
def main():
table = {
"type" : "table",
"title" : "table demo",
"cols" : ["columnA", "columnB", "columnC"],
"rows" : [
["A1", "B1", {"type": "button", "cmd": "coverAll", "name": "C1"}]
]
}
ticker = exchange.GetTicker()
name = exchange.GetName()
table["rows"].append([{"body": "A2 + B2:" + json.dumps(ticker), "colspan": 2}, "C2"])
table["rows"].append([{"body": "A3 + A4 + A5:" + name, "rowspan": 3}, "B3", "C3"])
table["rows"].append(["B4", "C4"])
table["rows"].append(["B5", "C5"])
table["rows"].append(["A6", "B6", "C6"])
LogStatus("`" + json.dumps(table) + "`")
void main() {
json table = R"({
"type" : "table",
"title" : "table demo",
"cols" : ["columnA", "columnB", "columnC"],
"rows" : [
["A1", "B1", {"type": "button", "cmd": "coverAll", "name": "C1"}]
]
})"_json;
// For testing purposes, the code is short and easy to read, and the constructed data is used here
json jsonTicker = R"({"High": 0, "Low": 0, "Buy": 0, "Sell": 0, "Last": 0, "Time": 0, "Volume": 0})"_json;
auto name = exchange.GetName();
json arr1 = R"([{"body": "", "colspan": 2}, "C2"])"_json;
arr1[0]["body"] = "A2 + B2:" + jsonTicker.dump();
json arr2 = R"([{"body": "", "rowspan": 3}, "B3", "C3"])"_json;
arr2[0]["body"] = "A3 + A4 + A5:" + name;
table["rows"].push_back(arr1);
table["rows"].push_back(arr2);
table["rows"].push_back(R"(["B4", "C4"])"_json);
table["rows"].push_back(R"(["B5", "C5"])"_json);
table["rows"].push_back(R"(["A6", "B6", "C6"])"_json);
LogStatus("`" + table.dump() + "`");
}
ऊर्ध्वाधर रूप से तालिका में कोशिकाओं को विलय करेंLogStatus()कार्य:
function main() {
var table1 = {type: 'table', title: 'table1', cols: ['column1', 'column2'], rows: [ ['abc', 'def'], ['ABC', 'support color #ff0000']]}
var table2 = {type: 'table', title: 'table2', cols: ['column1', 'column2'], rows: [ ['abc', 'def'], ['ABC', 'support color #ff0000']]}
LogStatus('`' + JSON.stringify([table1, table2]) + '`')
}
import json
def main():
table1 = {"type": "table", "title": "table1", "cols": ["column1", "column2"], "rows": [ ["abc", "def"], ["ABC", "support color #ff0000"]]}
table2 = {"type": "table", "title": "table2", "cols": ["column1", "column2"], "rows": [ ["abc", "def"], ["ABC", "support color #ff0000"]]}
LogStatus("`" + json.dumps([table1, table2]) + "`")
void main() {
json table1 = R"({"type": "table", "title": "table1", "cols": ["column1", "column2"], "rows": [ ["abc", "def"], ["ABC", "support color #ff0000"]]})"_json;
json table2 = R"({"type": "table", "title": "table2", "cols": ["column1", "column2"], "rows": [ ["abc", "def"], ["ABC", "support color #ff0000"]]})"_json;
json arr = R"([])"_json;
arr.push_back(table1);
arr.push_back(table2);
LogStatus("`" + arr.dump() + "`");
}
स्थिति पट्टी तालिका पृष्ठीकरण प्रदर्शित करें:
function main(){
var tab1 = {
type : "table",
title : "table1",
cols : ["1", "2"],
rows : []
}
var tab2 = {
type : "table",
title : "table2",
cols : ["1", "2", "3"],
rows : []
}
var tab3 = {
type : "table",
title : "table3",
cols : ["A", "B", "C"],
rows : []
}
tab1.rows.push(["jack", "lucy"])
tab2.rows.push(["A", "B", "C"])
tab3.rows.push(["A", "B", "C"])
LogStatus('`' + JSON.stringify(tab1) + '`\n' +
'`' + JSON.stringify(tab2) + '`\n' +
'`' + JSON.stringify(tab3) + '`')
Log("exit")
}
import json
def main():
tab1 = {
"type": "table",
"title": "table1",
"cols": ["1", "2"],
"rows": []
}
tab2 = {
"type": "table",
"title": "table2",
"cols": ["1", "2", "3"],
"rows": []
}
tab3 = {
"type": "table",
"title": "table3",
"cols": ["A", "B", "C"],
"rows": []
}
tab1["rows"].append(["jack", "lucy"])
tab2["rows"].append(["A", "B", "C"])
tab3["rows"].append(["A", "B", "C"])
LogStatus("`" + json.dumps(tab1) + "`\n" +
"`" + json.dumps(tab2) + "`\n" +
"`" + json.dumps(tab3) + "`")
void main() {
json tab1 = R"({
"type": "table",
"title": "table1",
"cols": ["1", "2"],
"rows": []
})"_json;
json tab2 = R"({
"type": "table",
"title": "table2",
"cols": ["1", "2", "3"],
"rows": []
})"_json;
json tab3 = R"({
"type": "table",
"title": "table3",
"cols": ["A", "B", "C"],
"rows": []
})"_json;
tab1["rows"].push_back(R"(["jack", "lucy"])"_json);
tab2["rows"].push_back(R"(["A", "B", "C"])"_json);
tab3["rows"].push_back(R"(["A", "B", "C"])"_json);
LogStatus("`" + tab1.dump() + "`\n" +
"`" + tab2.dump() + "`\n" +
"`" + tab3.dump() + "`");
}
तालिकाओं को पृष्ठों में प्रदर्शित करने के अलावा, कई तालिकाओं को ऊपर से नीचे के क्रम में भी प्रदर्शित किया जा सकता हैः
function main() {
var tbl = {
type : "table",
title : "test scroll",
scroll : "auto",
cols : ["col 0", "col 1", "col 2", "col 3", "col 4", "col 5", "col 6", "col 7", "col 8", "col 9", "col 10",
"col 11", "col 12", "col 13", "col 14", "col 15", "col 16", "col 17", "col 18", "col 19", "col 20"],
rows : []
}
for (var i = 1 ; i < 100 ; i++) {
tbl.rows.push([i, "1," + i, "2," + i, "3," + i, "4," + i, "5," + i, "6," + i, "7," + i, "8," + i, "9," + i, "10," + i,
"11," + i, "12," + i, "13," + i, "14," + i, "15," + i, "16," + i, "17," + i, "18," + i, "19," + i, "20," + i])
}
LogStatus("`" + JSON.stringify(tbl) + "`")
}
import json
def main():
tbl = {
"type" : "table",
"title" : "test scroll",
"scroll" : "auto",
"cols" : ["col 0", "col 1", "col 2", "col 3", "col 4", "col 5", "col 6", "col 7", "col 8", "col 9", "col 10",
"col 11", "col 12", "col 13", "col 14", "col 15", "col 16", "col 17", "col 18", "col 19", "col 20"],
"rows" : []
}
for index in range(1, 100):
i = str(index)
tbl["rows"].append([i, "1," + i, "2," + i, "3," + i, "4," + i, "5," + i, "6," + i, "7," + i, "8," + i, "9," + i, "10," + i,
"11," + i, "12," + i, "13," + i, "14," + i, "15," + i, "16," + i, "17," + i, "18," + i, "19," + i, "20," + i])
LogStatus("`" + json.dumps(tbl) + "`")
void main() {
json table = R"({
"type" : "table",
"title" : "test scroll",
"scroll" : "auto",
"cols" : ["col 0", "col 1", "col 2", "col 3", "col 4", "col 5", "col 6", "col 7", "col 8", "col 9", "col 10",
"col 11", "col 12", "col 13", "col 14", "col 15", "col 16", "col 17", "col 18", "col 19", "col 20"],
"rows" : []
})"_json;
for (int index = 1; index < 100; ++index) {
std::string i = std::to_string(index);
table["rows"].push_back({i, "1," + i, "2," + i, "3," + i, "4," + i, "5," + i, "6," + i, "7," + i, "8," + i, "9," + i, "10," + i,
"11," + i, "12," + i, "13," + i, "14," + i, "15," + i, "16," + i, "17," + i, "18," + i, "19," + i, "20," + i});
}
LogStatus("`" + table.dump() + "`");
}
स्थिति पट्टी तालिका के क्षैतिज और ऊर्ध्वाधर स्क्रॉल मोड को सेट करने के लिए समर्थन।scrollविशेषता"auto", जब स्थिति पट्टी तालिका की ऊर्ध्वाधर पंक्तियों की संख्या 20 पंक्तियों से अधिक हो, तो सामग्री स्क्रॉल की जाएगी।scrollविशेषता का उपयोग लाइव ट्रेडिंग के दौरान स्थिति पट्टी में बड़ी मात्रा में डेटा लिखने की समस्या को कम करने के लिए किया जा सकता है। निम्नलिखित परीक्षण उदाहरण देखेंः
सूचना आउटपुटLogStatus()जब लाइव ट्रेडिंग चल रही है तो यह फ़ंक्शन लाइव ट्रेडिंग डेटाबेस में सहेजा नहीं जाता है, लेकिन यह केवल वर्तमान लाइव ट्रेडिंग की स्थिति पट्टी सामग्री को अपडेट करता है।
दLogStatus()कार्य मुद्रण का समर्थन करता हैbase64एन्कोडेड छवियों, के साथ शुरू`और इसके साथ समाप्त होता है`उदाहरण के लिए:LogStatus("`data:image/png;base64,AAAA`").
दLogStatus()फंक्शन पासिंग का समर्थन करता हैmatplotlib.pyplotवस्तुओं को सीधेPython, जब तक कि वस्तु मेंsavefigविधि, यह एक पैरामीटर के रूप में पारित किया जा सकता हैLogStatus()कार्य, उदाहरण के लिएः
import matplotlib.pyplot as plt
def main():
plt.plot([3,6,2,4,7,1])
LogStatus(plt)
जब रणनीति लाइव ट्रेडिंग चल रही है, यदि आप लाइव ट्रेडिंग पृष्ठ पर इतिहास के माध्यम से जाते हैं, तो स्थिति पट्टी सो जाएगी और अद्यतन करना बंद कर देगी। लॉग पहले पृष्ठ पर होने पर केवल स्थिति पट्टी डेटा को ताज़ा किया जाएगा। यह आउटपुट का समर्थन करता हैbase64स्थिति पट्टी में एन्कोडेड छवियों, और यह भी आउटपुट का समर्थन करता हैbase64स्थिति पट्टी में प्रदर्शित तालिका में एन्कोडेड छवियां। चूंकि एन्कोडेड छवियों के स्ट्रिंग डेटा आम तौर पर बहुत लंबे होते हैं, इसलिए नमूना कोड नहीं दिखाया जाता है।
{@fun/Global/GetCommand GetCommand} {@fun/Global/GetCommand GetCommand}
आदेश सूचनाओं का लॉगिंग चालू या बंद करें.
enableLog (सक्षम करें)
यदिenableपैरामीटर एक गलत मान पर सेट है, उदाहरण के लिएfalse, ऑर्डर लॉग (यानी फंक्शन जैसेexchange.Buy()) मुद्रित नहीं किया जाता है और लाइव ट्रेडिंग के डेटाबेस में नहीं लिखा जाता है।
सक्षम करना
सच
बोल
function main() {
EnableLog(false)
}
def main():
EnableLog(False)
void main() {
EnableLog(false);
}
{@fun/Trade/exchange.Buy exchange.Buy}, {@fun/Trade/exchange.Sell exchange.Sell}, {@fun/Trade/exchange.CancelOrder exchange.CancelOrder}, {@fun/Trade/exchange.CancelOrder exchange.CancelOrder}, {@fun/Trade/exchange.Buy exchange.Buy}, {@fun/Trade/exchange.Buy.Exchange.Buy}, {@fun/Trade/exchange.Buy.Exchange.Buy}, {@fun/Trade/exchange.Sell exchange.Sell}, {@fun/Trade/exchange.Order exchange.CancelOrder}, {@fun/Trade/exchange.CancelOrder exchange.CancelOrder}, {@fun/Trade/Exchange.
चार्ट ड्राइंग फ़ंक्शन को अनुकूलित करें.
चार्ट वस्तु। वस्तु
चार्ट (विकल्प)
..optionsपैरामीटर चार्ट विन्यास है।Chart()कार्य पैरामीटरoptionsहैJSONक्रमबद्ध करने योग्यHighStocksपैरामीटर के लिएHighcharts.StockChart. एक अतिरिक्त__isStockविशेषता मूल पैरामीटर पर जोड़ा जाता है, और अगर__isStock:falseनिर्दिष्ट है, यह एक सामान्य चार्ट के रूप में प्रदर्शित किया जाता है।__isStockविशेषता गलत मान पर सेट है, उदाहरण के लिएfalse, यानी इस्तेमाल किया गया चार्ट एकHighchartsचार्ट।__isStockविशेषता एक सही मान पर सेट है, उदाहरण के लिएtrue, यानी इस्तेमाल किया गया चार्ट एकHighstocksचार्ट (डिफ़ॉल्ट रूप से)__isStockसच है जैसेtrue) से पूछ सकते हैं।हाईस्टॉक्स चार्ट लाइब्रेरी.
विकल्प
सच
वस्तु, वस्तु सरणी
function main() {
var cfgA = {
extension: {
layout: 'single', // No grouping, display separately, default to group 'group'
height: 300, // Specify the height
},
title: {
text: 'handicap chart'
},
xAxis: {
type: 'datetime'
},
series: [{
name: 'buy one',
data: [],
}, {
name: 'sell one',
data: [],
}]
}
var cfgB = {
title: {
text: 'spread chart'
},
xAxis: {
type: 'datetime'
},
series: [{
name: 'spread',
type: 'column',
data: [],
}]
}
var cfgC = {
__isStock: false,
title: {
text: 'pie chart'
},
series: [{
type: 'pie',
name: 'one',
data: [
["A", 25],
["B", 25],
["C", 25],
["D", 25],
] // Instead of updating the initial data with the add function, the sequence can be updated by changing the chart configuration directly.
}]
};
var cfgD = {
extension: {
layout: 'single',
col: 8, // Specify the cell value for the width, the total value is 12
height: '300px',
},
title: {
text: 'handicap chart'
},
xAxis: {
type: 'datetime'
},
series: [{
name: 'buy one',
data: [],
}, {
name: 'sell one',
data: [],
}]
}
var cfgE = {
__isStock: false,
extension: {
layout: 'single',
col: 4,
height: '300px',
},
title: {
text: 'pie chart2'
},
series: [{
type: 'pie',
name: 'one',
data: [
["A", 25],
["B", 25],
["C", 25],
["D", 25],
]
}]
};
var chart = Chart([cfgA, cfgB, cfgC, cfgD, cfgE]);
chart.reset()
// Add a number of points to the pie chart, add can only update the data points added by add, built-in data points cannot be updated later.
chart.add(3, {
name: "ZZ",
y: Math.random() * 100
});
while (true) {
Sleep(1000)
var ticker = exchange.GetTicker()
if (!ticker) {
continue;
}
var diff = ticker.Sell - ticker.Buy
cfgA.subtitle = {
text: 'buy one ' + ticker.Buy + ', sell one ' + ticker.Sell,
};
cfgB.subtitle = {
text: 'spread ' + diff,
};
chart.add([0, [new Date().getTime(), ticker.Buy]]);
chart.add([1, [new Date().getTime(), ticker.Sell]]);
// Equivalent to updating the first data series of the second chart
chart.add([2, [new Date().getTime(), diff]]);
chart.add(4, [new Date().getTime(), ticker.Buy]);
chart.add(5, [new Date().getTime(), ticker.Buy]);
cfgC.series[0].data[0][1] = Math.random() * 100;
cfgE.series[0].data[0][1] = Math.random() * 100;
// update is actually the same as resetting the chart's configuration
chart.update([cfgA, cfgB, cfgC, cfgD, cfgE]);
}
}
import random
import time
def main():
cfgA = {
"extension" : {
"layout" : "single",
"height" : 300,
"col" : 8
},
"title" : {
"text" : "handicap chart"
},
"xAxis" : {
"type" : "datetime"
},
"series" : [{
"name" : "buy one",
"data" : []
}, {
"name" : "sell one",
"data" : []
}]
}
cfgB = {
"title" : {
"text" : "spread chart"
},
"xAxis" : {
"type" : "datetime",
},
"series" : [{
"name" : "spread",
"type" : "column",
"data" : []
}]
}
cfgC = {
"__isStock" : False,
"title" : {
"text" : "pie chart"
},
"series" : [{
"type" : "pie",
"name" : "one",
"data" : [
["A", 25],
["B", 25],
["C", 25],
["D", 25],
]
}]
}
cfgD = {
"extension" : {
"layout" : "single",
"col" : 8,
"height" : "300px"
},
"title" : {
"text" : "handicap chart"
},
"series" : [{
"name" : "buy one",
"data" : []
}, {
"name" : "sell one",
"data" : []
}]
}
cfgE = {
"__isStock" : False,
"extension" : {
"layout" : "single",
"col" : 4,
"height" : "300px"
},
"title" : {
"text" : "pie chart2"
},
"series" : [{
"type" : "pie",
"name" : "one",
"data" : [
["A", 25],
["B", 25],
["C", 25],
["D", 25]
]
}]
}
chart = Chart([cfgA, cfgB, cfgC, cfgD, cfgE])
chart.reset()
chart.add(3, {
"name" : "ZZ",
"y" : random.random() * 100
})
while True:
Sleep(1000)
ticker = exchange.GetTicker()
if not ticker :
continue
diff = ticker["Sell"] - ticker["Buy"]
cfgA["subtitle"] = {
"text" : "buy one" + str(ticker["Buy"]) + "sell one" + str(ticker["Sell"])
}
cfgB["subtitle"] = {
"text" : "spread " + str(diff)
}
chart.add(0, [time.time() * 1000, ticker["Buy"]])
chart.add(1, [time.time() * 1000, ticker["Sell"]])
chart.add(2, [time.time() * 1000, diff])
chart.add(4, [time.time() * 1000, ticker["Buy"]])
chart.add(5, [time.time() * 1000, ticker["Buy"]])
cfgC["series"][0]["data"][0][1] = random.random() * 100
cfgE["series"][0]["data"][0][1] = random.random() * 100
void main() {
json cfgA = R"({
"extension" : {
"layout" : "single",
"height" : 300,
"col" : 8
},
"title" : {
"text" : "handicap chart"
},
"xAxis" : {
"type" : "datetime"
},
"series" : [{
"name" : "buy one",
"data" : []
}, {
"name" : "sell one",
"data" : []
}]
})"_json;
json cfgB = R"({
"title" : {
"text" : "spread chart"
},
"xAxis" : {
"type" : "datetime"
},
"series" : [{
"name" : "spread",
"type" : "column",
"data" : []
}]
})"_json;
json cfgC = R"({
"__isStock" : false,
"title" : {
"text" : "pie chart"
},
"series" : [{
"type" : "pie",
"name" : "one",
"data" : [
["A", 25],
["B", 25],
["C", 25],
["D", 25]
]
}]
})"_json;
json cfgD = R"({
"extension" : {
"layout" : "single",
"col" : 8,
"height" : "300px"
},
"title" : {
"text" : "handicap chart"
},
"series" : [{
"name" : "buy one",
"data" : []
}, {
"name" : "sell one",
"data" : []
}]
})"_json;
json cfgE = R"({
"__isStock" : false,
"extension" : {
"layout" : "single",
"col" : 4,
"height" : "300px"
},
"title" : {
"text" : "pie chart2"
},
"series" : [{
"type" : "pie",
"name" : "one",
"data" : [
["A", 25],
["B", 25],
["C", 25],
["D", 25]
]
}]
})"_json;
auto chart = Chart({cfgA, cfgB, cfgC, cfgD, cfgE});
chart.reset();
json zz = R"({
"name" : "ZZ",
"y" : 0
})"_json;
zz["y"] = rand() % 100;
chart.add(3, zz);
while(true) {
Sleep(1000);
auto ticker = exchange.GetTicker();
if(!ticker.Valid) {
continue;
}
auto diff = ticker.Sell - ticker.Buy;
json cfgASubTitle = R"({"text" : ""})"_json;
cfgASubTitle["text"] = format("buy one %f , sell one %f", ticker.Buy, ticker.Sell);
cfgA["subtitle"] = cfgASubTitle;
json cfgBSubTitle = R"({"text" : ""})"_json;
cfgBSubTitle["text"] = format("spread %f", diff);
cfgB["subtitle"] = cfgBSubTitle;
chart.add(0, {Unix() * 1000, ticker.Buy});
chart.add(1, {Unix() * 1000, ticker.Sell});
chart.add(2, {Unix() * 1000, diff});
chart.add(4, {Unix() * 1000, ticker.Buy});
chart.add(5, {Unix() * 1000, ticker.Buy});
cfgC["series"][0]["data"][0][1] = rand() % 100;
cfgE["series"][0]["data"][0][1] = rand() % 100;
chart.update({cfgA, cfgB, cfgC, cfgD, cfgE});
}
}
बहु-चार्ट ड्राइंग कॉन्फ़िगरेशनः
extension.layoutविशेषता
यदि विशेषता को extension.heightविशेषता
विशेषता का उपयोग चार्ट की ऊंचाई को सेट करने के लिए किया जाता है, या तो एक संख्यात्मक मान के रूप में, या extension.colविशेषता
विशेषता का उपयोग चार्ट की चौड़ाई निर्धारित करने के लिए किया जाता है, पृष्ठ की चौड़ाई 12 कक्षों में विभाजित है, सेट 8,यानी, चार्ट 8 कक्षों की चौड़ाई पर कब्जा कर लेता है।// This chart is an object in the JavaScript language, and before using the Chart function, we need to declare an object variable chart to configure the chart. var chart = {
// This field marks whether the chart is a general chart or not, if you are interested, you can change it to false and run it.
__isStock: true,
// Scaling tool
tooltip: {xDateFormat: '%Y-%m-%d %H:%M:%S, %A'},
// title
title : { text : 'spread analysis chart'},
// selection range
rangeSelector: {
buttons: [{type: 'hour',count: 1, text: '1h'}, {type: 'hour',count: 3, text: '3h'}, {type: 'hour', count: 8, text: '8h'}, {type: 'all',text: 'All'}],
selected: 0,
inputEnabled: false
},
// Coordinate axis horizontal axis that is: x-axis, the current setting type is: time
xAxis: { type: 'datetime'},
// Coordinate axis vertical axis that is: y-axis, default value adjusted with the size of the data
yAxis : {
// title
title: {text: 'spread'},
// Whether to enable the right vertical axis
opposite: false
},
// Data series, this sttribute holds the individual data series (lines, K-charts, labels, etc...)
series : [
// The index is 0, and the data array holds the data of the index series
{name : "line1", id : "line1,buy1Price", data : []},
// Index is 1, set dashStyle:'shortdash' i.e.: set the dashed line
{name : "line2", id : "line2,lastPrice", dashStyle : 'shortdash', data : []}
]
} function main(){
// Call the Chart function to initialize the chart
var ObjChart = Chart(chart)
// Clear out
ObjChart.reset()
while(true){
// Gets the timestamp of this poll, i.e. a millisecond timestamp. It's used to determine the position of the X-axis written to the chart.
var nowTime = new Date().getTime()
// Get the ticker data
var ticker = _C(exchange.GetTicker)
// Get buy one price from the return value of the ticker data
var buy1Price = ticker.Buy
// To obtain the final transaction price, we add 1 in order not to overlap the 2 lines
var lastPrice = ticker.Last + 1
// Data sequence with timestamp as X-value and buy one price as Y-value passed into index 0
ObjChart.add(0, [nowTime, buy1Price])
// ditto
ObjChart.add(1, [nowTime, lastPrice])
Sleep(2000)
}
}```
```python
import time
chart = {
"__isStock" : True,
"tooltip" : {"xDateFormat" : "%Y-%m-%d %H:%M:%S, %A"},
"title" : {"text" : "spread analysis chart"},
"rangeSelector" : {
"buttons" : [{"type": "count", "count": 1, "text": "1h"}, {"type": "hour", "count": 3, "text": "3h"}, {"type": "hour", "count": 8, "text": "8h"}, {"type": "all", "text": "All"}],
"selected": 0,
"inputEnabled": False
},
"xAxis": {"type": "datetime"},
"yAxis": {
"title": {"text": "spread"},
"opposite": False
},
"series": [{
"name": "line1", "id": "line1,buy1Price", "data": []
}, {
"name": "line2", "id": "line2,lastPrice", "dashStyle": "shortdash", "data": []
}]
}
def main():
ObjChart = Chart(chart)
ObjChart.reset()
while True:
nowTime = time.time() * 1000
ticker = exchange.GetTicker()
buy1Price = ticker["Buy"]
lastPrice = ticker["Last"] + 1
ObjChart.add(0, [nowTime, buy1Price])
ObjChart.add(1, [nowTime, lastPrice])
Sleep(2000)
void main() {
// When writing strategies in C++, try not to declare global variables that are not of the base type, so the chart configuration object is declared inside the main function.
json chart = R"({
"__isStock" : true,
"tooltip" : {"xDateFormat" : "%Y-%m-%d %H:%M:%S, %A"},
"title" : {"text" : "spread analysis chart"},
"rangeSelector" : {
"buttons" : [{"type": "count", "count": 1, "text": "1h"}, {"type": "hour", "count": 3, "text": "3h"}, {"type": "hour", "count": 8, "text": "8h"}, {"type": "all", "text": "All"}],
"selected": 0,
"inputEnabled": false
},
"xAxis": {"type": "datetime"},
"yAxis": {
"title": {"text": "spread"},
"opposite": false
},
"series": [{
"name": "line1", "id": "line1,buy1Price", "data": []
}, {
"name": "line2", "id": "line2,lastPrice", "dashStyle": "shortdash", "data": []
}]
})"_json;
auto ObjChart = Chart(chart);
ObjChart.reset();
while(true) {
auto nowTime = Unix() * 1000;
auto ticker = exchange.GetTicker();
auto buy1Price = ticker.Buy;
auto lastPrice = ticker.Last + 1.0;
ObjChart.add(0, {nowTime, buy1Price});
ObjChart.add(1, {nowTime, lastPrice});
Sleep(2000);
}
}
सरल चित्र का उदाहरण:
// Objects used to initialize the chart
var chart = {
// Chart title
title: {text: "line value triggers the plotLines value"},
// Y-axis related settings
yAxis: {
// A horizontal line perpendicular to the Y-axis, used as a trigger line, is a structural array that can set multiple trigger lines
plotLines: [{
// The value of the trigger line, how much it set, this line will be displayed in the corresponding value position
value: 0,
// Set the color of the trigger line
color: 'red',
// Width
width: 2,
// Displaying labels
label: {
// Label text
text: 'Trigger value',
// Centered label position
align: 'center'
}
}]
},
// X-axis related settings, here the setting type is time axis
xAxis: {type: "datetime"},
series: [
{name: "sin", type: "spline", data: []},
// This is an important data series, you can set multiple data series, according to the array index control
{name: "cos", type: "spline", data: []}
]
}
function main(){
// Circumference
var pi = 3.1415926535897
// Variables for recording timestamps
var time = 0
// Angle
var angle = 0
// Coordinate y values for receiving sine and cosine values
var y = 0
// Call the API interface to initialize the chart with the chart object
var objChart = Chart(chart)
// Initially, clear the chart
objChart.reset()
// Set the value of the trigger line to 1
chart.yAxis.plotLines[0].value = 1
// Loop
while(true){
// Get the timestamp of the current moment
time = new Date().getTime()
// Angle increases by 5 degrees every 500ms and calculates the sine value
y = Math.sin(angle * 2 * pi / 360)
// Write the calculated y value to the data series of the corresponding index of the chart, the first parameter of the add function is the specified data series index
objChart.add(0, [time, y])
// Calculate the cosine value
y = Math.cos(angle * 2 * pi / 360)
objChart.add(1, [time, y])
// Increase by 5 degrees
angle += 5
// Pause for 5 seconds to avoid drawing too often and growing data too fast
Sleep(5000)
}
}
import math
import time
chart = {
"title": {"text": "line value triggers the plotLines value"},
"yAxis": {
"plotLines": [{
"value": 0,
"color": "red",
"width": 2,
"label": {
"text": "trigger value",
"align": "center"
}
}]
},
"xAxis": {"type": "datetime"},
"series": [{"name": "sin", "type": "spline", "data": []},
{"name": "cos", "type": "spline", "data": []}]
}
def main():
pi = 3.1415926535897
ts = 0
angle = 0
y = 0
objChart = Chart(chart)
objChart.reset()
chart["yAxis"]["plotLines"][0]["value"] = 1
while True:
ts = time.time() * 1000
y = math.sin(angle * 2 * pi / 360)
objChart.add(0, [ts, y])
y = math.cos(angle * 2 * pi / 360)
objChart.add(1, [ts, y])
angle += 5
Sleep(5000)
void main() {
json chart = R"({
"title": {"text": "line value triggers the plotLines value"},
"yAxis": {
"plotLines": [{
"value": 0,
"color": "red",
"width": 2,
"label": {
"text": "trigger value",
"align": "center"
}
}]
},
"xAxis": {"type": "datetime"},
"series": [{"name": "sin", "type": "spline", "data": []},
{"name": "cos", "type": "spline", "data": []}]
})"_json;
auto pi = 3.1415926535897;
auto ts = 0;
auto angle = 0.0;
auto y = 0.0;
auto objChart = Chart(chart);
objChart.reset();
chart["yAxis"]["plotLines"][0]["value"] = 1;
while(true) {
ts = Unix() * 1000;
y = sin(angle * 2 * pi / 360);
objChart.add(0, {ts, y});
y = cos(angle * 2 * pi / 360);
objChart.add(1, {ts, y});
angle += 5;
Sleep(5000);
}
}
त्रिकोणमितीय वक्र चित्रण का उदाहरण:
/*backtest
start: 2020-03-11 00:00:00
end: 2020-04-09 23:59:00
period: 1d
exchanges: [{"eid":"Bitfinex","currency":"BTC_USD"}]
*/
var chartCfg = {
subtitle: {
text: "subtitle",
},
yAxis: [{
height: "40%",
lineWidth: 2,
title: {
text: 'PnL',
},
tickPixelInterval: 20,
minorGridLineWidth: 1,
minorTickWidth: 0,
opposite: true,
labels: {
align: "right",
x: -3,
}
}, {
title: {
text: 'Profit',
},
top: "42%",
height: "18%",
offset: 0,
lineWidth: 2
}, {
title: {
text: 'Vol',
},
top: '62%',
height: '18%',
offset: 0,
lineWidth: 2
}, {
title: {
text: 'Asset',
},
top: '82%',
height: '18%',
offset: 0,
lineWidth: 2
}],
series: [{
name: 'PnL',
data: [],
id: 'primary',
tooltip: {
xDateFormat: '%Y-%m-%d %H:%M:%S'
},
yAxis: 0
}, {
type: 'column',
lineWidth: 2,
name: 'Profit',
data: [],
yAxis: 1,
}, {
type: 'column',
name: 'Trade',
data: [],
yAxis: 2
}, {
type: 'area',
step: true,
lineWidth: 0,
name: 'Long',
data: [],
yAxis: 2
}, {
type: 'area',
step: true,
lineWidth: 0,
name: 'Short',
data: [],
yAxis: 2
}, {
type: 'line',
step: true,
color: '#5b4b00',
name: 'Asset',
data: [],
yAxis: 3
}, {
type: 'pie',
innerSize: '70%',
name: 'Random',
data: [],
center: ['3%', '6%'],
size: '15%',
dataLabels: {
enabled: false
},
startAngle: -90,
endAngle: 90,
}],
};
function main() {
let c = Chart(chartCfg);
let preTicker = null;
while (true) {
let t = exchange.GetTicker();
c.add(0, [t.Time, t.Last]); // PnL
c.add(1, [t.Time, preTicker ? t.Last - preTicker.Last : 0]); // profit
let r = Math.random();
var pos = parseInt(t.Time/86400);
c.add(2, [t.Time, pos/2]); // Vol
c.add(3, [t.Time, r > 0.8 ? pos : null]); // Long
c.add(4, [t.Time, r < 0.8 ? -pos : null]); // Short
c.add(5, [t.Time, Math.random() * 100]); // Asset
// update pie
chartCfg.series[chartCfg.series.length-1].data = [
["A", Math.random()*100],
["B", Math.random()*100],
];
c.update(chartCfg)
preTicker = t;
}
}
'''backtest
start: 2020-03-11 00:00:00
end: 2020-04-09 23:59:00
period: 1d
exchanges: [{"eid":"Bitfinex","currency":"BTC_USD"}]
'''
import random
chartCfg = {
"subtitle": {
"text": "subtitle"
},
"yAxis": [{
"height": "40%",
"lineWidth": 2,
"title": {
"text": 'PnL'
},
"tickPixelInterval": 20,
"minorGridLineWidth": 1,
"minorTickWidth": 0,
"opposite": True,
"labels": {
"align": "right",
"x": -3
}
}, {
"title": {
"text": 'Profit'
},
"top": "42%",
"height": "18%",
"offset": 0,
"lineWidth": 2
}, {
"title": {
"text": 'Vol'
},
"top": '62%',
"height": '18%',
"offset": 0,
"lineWidth": 2
}, {
"title": {
"text": 'Asset'
},
"top": '82%',
"height": '18%',
"offset": 0,
"lineWidth": 2
}],
"series": [{
"name": 'PnL',
"data": [],
"id": 'primary',
"tooltip": {
"xDateFormat": '%Y-%m-%d %H:%M:%S'
},
"yAxis": 0
}, {
"type": 'column',
"lineWidth": 2,
"name": 'Profit',
"data": [],
"yAxis": 1
}, {
"type": 'column',
"name": 'Trade',
"data": [],
"yAxis": 2
}, {
"type": 'area',
"step": True,
"lineWidth": 0,
"name": 'Long',
"data": [],
"yAxis": 2
}, {
"type": 'area',
"step": True,
"lineWidth": 0,
"name": 'Short',
"data": [],
"yAxis": 2
}, {
"type": 'line',
"step": True,
"color": '#5b4b00',
"name": 'Asset',
"data": [],
"yAxis": 3
}, {
"type": 'pie',
"innerSize": '70%',
"name": 'Random',
"data": [],
"center": ['3%', '6%'],
"size": '15%',
"dataLabels": {
"enabled": False
},
"startAngle": -90,
"endAngle": 90
}]
}
def main():
c = Chart(chartCfg)
preTicker = None
while True:
t = exchange.GetTicker()
c.add(0, [t["Time"], t["Last"]])
profit = t["Last"] - preTicker["Last"] if preTicker else 0
c.add(1, [t["Time"], profit])
r = random.random()
pos = t["Time"] / 86400
c.add(2, [t["Time"], pos / 2])
long = pos if r > 0.8 else None
c.add(3, [t["Time"], long])
short = -pos if r < 0.8 else None
c.add(4, [t["Time"], short])
c.add(5, [t["Time"], random.random() * 100])
# update pie
chartCfg["series"][len(chartCfg["series"]) - 1]["data"] = [
["A", random.random() * 100],
["B", random.random() * 100]
]
c.update(chartCfg)
preTicker = t
/*backtest
start: 2020-03-11 00:00:00
end: 2020-04-09 23:59:00
period: 1d
exchanges: [{"eid":"Bitfinex","currency":"BTC_USD"}]
*/
void main() {
json chartCfg = R"({
"subtitle": {
"text": "subtitle"
},
"yAxis": [{
"height": "40%",
"lineWidth": 2,
"title": {
"text": "PnL"
},
"tickPixelInterval": 20,
"minorGridLineWidth": 1,
"minorTickWidth": 0,
"opposite": true,
"labels": {
"align": "right",
"x": -3
}
}, {
"title": {
"text": "Profit"
},
"top": "42%",
"height": "18%",
"offset": 0,
"lineWidth": 2
}, {
"title": {
"text": "Vol"
},
"top": "62%",
"height": "18%",
"offset": 0,
"lineWidth": 2
}, {
"title": {
"text": "Asset"
},
"top": "82%",
"height": "18%",
"offset": 0,
"lineWidth": 2
}],
"series": [{
"name": "PnL",
"data": [],
"id": "primary",
"tooltip": {
"xDateFormat": "%Y-%m-%d %H:%M:%S"
},
"yAxis": 0
}, {
"type": "column",
"lineWidth": 2,
"name": "Profit",
"data": [],
"yAxis": 1
}, {
"type": "column",
"name": "Trade",
"data": [],
"yAxis": 2
}, {
"type": "area",
"step": true,
"lineWidth": 0,
"name": "Long",
"data": [],
"yAxis": 2
}, {
"type": "area",
"step": true,
"lineWidth": 0,
"name": "Short",
"data": [],
"yAxis": 2
}, {
"type": "line",
"step": true,
"color": "#5b4b00",
"name": "Asset",
"data": [],
"yAxis": 3
}, {
"type": "pie",
"innerSize": "70%",
"name": "Random",
"data": [],
"center": ["3%", "6%"],
"size": "15%",
"dataLabels": {
"enabled": false
},
"startAngle": -90,
"endAngle": 90
}]
})"_json;
Chart c = Chart(chartCfg);
Ticker preTicker;
while(true) {
auto t = exchange.GetTicker();
c.add(0, {t.Time, t.Last});
auto profit = preTicker.Valid ? t.Last - preTicker.Last : 0;
c.add(1, {t.Time, profit});
auto r = rand() % 100;
auto pos = t.Time / 86400.0;
c.add(2, {t.Time, pos / 2.0});
auto longPos = r > 0.8 ? pos : NULL;
c.add(3, {t.Time, longPos});
auto shortPos = r < 0.8 ? -pos : NULL;
c.add(4, {t.Time, shortPos});
c.add(5, {t.Time, rand() % 100});
// update pie
json pie = R"([["A", 0], ["B", 0]])"_json;
pie[0][1] = rand() % 100;
pie[1][1] = rand() % 100;
chartCfg["series"][chartCfg["series"].size() - 1]["data"] = pie;
c.update(chartCfg);
preTicker = t;
}
}
हाइब्रिड चार्ट के प्रयोग के जटिल उदाहरण:
// update pie
chartCfg.series[chartCfg.series.length-1].data = [
["A", Math.random()*100],
["B", Math.random()*100],
];
c.update(chartCfg)
# update pie
chartCfg["series"][len(chartCfg["series"]) - 1]["data"] = [
["A", random.random() * 100],
["B", random.random() * 100]
]
c.update(chartCfg)
// update pie
json pie = R"([["A", 0], ["B", 0]])"_json;
pie[0][1] = rand() % 100;
pie[1][1] = rand() % 100;
chartCfg["series"][chartCfg["series"].size() - 1]["data"] = pie;
c.update(chartCfg);
प्रकार के चार्टpieएक समयरेखा के बिना चार्ट हैं, और आप डेटा अद्यतन करते समय सीधे चार्ट विन्यास अद्यतन करने की जरूरत है. उदाहरण के लिए ऊपर उदाहरण में कोड का उपयोग कर चार्ट अद्यतन करता हैc.update(chartCfg)डेटा को अद्यतन करने के बाद, इस प्रकारः
..Chart()फ़ंक्शन चार्ट ऑब्जेक्ट को लौटाता है जिसमें 4 विधियां हैंःadd(), reset(), update(), del().
update()विधि:
दupdate()विधि चार्ट कॉन्फ़िगरेशन जानकारी को अपडेट कर सकती है। इस विधि का पैरामीटर चार्ट कॉन्फ़िगरेशन ऑब्जेक्ट (JSON) है।del()विधि:
दdel()विधि पारित श्रृंखला पैरामीटर के आधार पर निर्दिष्ट सूचकांक की डेटा श्रृंखला को हटा सकती है.add()विधि:
दadd()विधि चार्ट में निम्नलिखित मापदंडों के क्रम में डेटा लिख सकती है:series: डेटा श्रृंखला सूचकांक सेट करने के लिए प्रयोग किया जाता है, जो एक पूर्णांक है।data: लिखने के लिए विशिष्ट डेटा सेट करने के लिए प्रयोग किया जाता है, यह एक सरणी है।index(वैकल्पिक): डेटा सूचकांक सेट करने के लिए उपयोग किया जाता है, यह एक पूर्णांक है। संशोधित डेटा की विशिष्ट सूचकांक स्थिति निर्दिष्ट करें, और यह नकारात्मक संख्याओं का समर्थन करता है, सेटिंग है-1डेटा सेट के अंतिम डेटा को संदर्भित करता है।
उदाहरण के लिए, एक रेखा खींचते समय, रेखा के अंतिम बिंदु पर डेटा को संशोधित करेंःchart.add(0, [1574993606000, 13.5], -1), यानी, चार्ट के अंतिम से पहले बिंदु पर डेटा बदलseries[0].data.
दindexपैरामीटर सेट नहीं किया गया है, जिसका अर्थ है कि डेटा वर्तमान डेटा श्रृंखला के अंतिम बिंदु में जोड़ा जाता है।reset()विधि:
दreset()चार्ट डेटा को खाली करने के लिए विधि का प्रयोग किया जाता है।reset()विधि एक पैरामीटर ले सकता हैremainरखने के लिए प्रविष्टियों की संख्या निर्दिष्ट करने के लिए कोई पैरामीटरremainसभी डेटा को साफ़ करने के लिए पारित किया जाता है।{@मज़ा/लॉग/KLineChart KLineChart}
इस फ़ंक्शन का उपयोग रणनीति रनटाइम पर कस्टम ड्राइंग के लिए किया जाता हैPine language.
चार्ट ऑब्जेक्ट।KLineChart()फ़ंक्शन कई तरीकों के साथ एक चार्ट ऑब्जेक्ट लौटाता है, जिनमें से आपको ध्यान देने की आवश्यकता हैbegin()औरclose(). आरेखण के कार्य को एकbegin()फ़ंक्शन कॉल और एक के साथ अंतclose()फ़ंक्शन कॉल जब ड्राइंग ऑपरेशन करने के लिए KLine डेटा पर क्रॉसिंग।
वस्तु
KLineChart (विकल्प)
..optionsपैरामीटर चार्ट कॉन्फ़िगरेशन है।
विकल्प
सच
वस्तु, वस्तु सरणी
function main() {
// Call the KLineChart function to create a chart control object c
let c = KLineChart({
overlay: true
})
// Use the Spot Exchange object test to get K-line data. If you use the futures exchange object test, you need to set up the contract first.
let bars = exchange.GetRecords()
if (!bars) {
return
}
// Execute the drawing operation by traversing over the K-line data. The drawing operation must start with the ```c.begin(bar)``` function call and end with the ```c.close()``` function call.
bars.forEach(function(bar, index) {
c.begin(bar)
c.barcolor(bar.Close > bar.Open ? 'rgba(255, 0, 0, 0.2)' : 'rgba(0, 0, 0, 0.2)')
if (bar.Close > bar.Open) {
c.bgcolor('rgba(0, 255, 0, 0.5)')
}
let h = c.plot(bar.High, 'high')
let l = c.plot(bar.Low, 'low')
c.fill(h, l, {
color: bar.Close > bar.Open ? 'rgba(255, 0, 0, 0.2)' : 'rgba(255, 0, 0, 0.2)'
})
c.hline(bar.High)
c.plotarrow(bar.Close - bar.Open)
c.plotshape(bar.Low, {
style: 'diamond'
})
c.plotchar(bar.Close, {
char: 'X'
})
c.plotcandle(bar.Open*0.9, bar.High*0.9, bar.Low*0.9, bar.Close*0.9)
if (bar.Close > bar.Open) {
// long/short/closelong/closeshort
c.signal("long", bar.High, 1.5)
} else if (bar.Close < bar.Open) {
c.signal("closelong", bar.Low, 1.5)
}
c.close()
})
}
def main():
# Call the KLineChart function to create a chart control object c
c = KLineChart({
"overlay": True
})
# Use the Spot Exchange object test to get K-line data. If you use the futures exchange object test, you need to set up the contract first.
bars = exchange.GetRecords()
if not bars:
return
for bar in bars:
c.begin(bar)
c.barcolor('rgba(255, 0, 0, 0.2)' if bar.Close > bar.Open else 'rgba(0, 0, 0, 0.2)')
if bar.Close > bar.Open:
c.bgcolor('rgba(0, 255, 0, 0.5)')
h = c.plot(bar.High, 'high')
l = c.plot(bar.Low, 'low')
c.fill(h, l, 'rgba(255, 0, 0, 0.2)' if bar.Close > bar.Open else 'rgba(255, 0, 0, 0.2)')
c.hline(bar.High)
c.plotarrow(bar.Close - bar.Open)
c.plotshape(bar.Low, style = 'diamond')
c.plotchar(bar.Close, char = 'X')
c.plotcandle(bar.Open*0.9, bar.High*0.9, bar.Low*0.9, bar.Close*0.9)
if bar.Close > bar.Open:
# long/short/closelong/closeshort
c.signal("long", bar.High, 1.5)
elif bar.Close < bar.Open:
c.signal("closelong", bar.Low, 1.5)
c.close()
// Not supported for now
यदि रणनीति कस्टम ड्राइंग क्षेत्र में ड्राइंग करने के लिए एक चार्ट नियंत्रण वस्तु की आवश्यकता है,KLineChart()ऑब्जेक्ट बनाने के लिए समारोह। पैरामीटर के लिएKLineChart()फ़ंक्शन एक चार्ट कॉन्फ़िगरेशन संरचना है, संदर्भ कोड में इस्तेमाल किया एक सरल हैः{overlay: true}. यह चार्ट विन्यास संरचना केवल मुख्य चार्ट पर आउटपुट करने के लिए ड्राइंग सामग्री सेट करता है. यदिoverlayएक गलत मान पर सेट है, उदाहरण के लिएfalse, चार्ट पर सामग्री माध्यमिक चार्ट पर आउटपुट है। यदि आप मुख्य चार्ट पर आकर्षित करने के लिए एक ड्राइंग समारोह निर्दिष्ट करने की जरूरत है, तो आप भी पैरामीटर निर्दिष्ट कर सकते हैंoverlayविशिष्ट फ़ंक्शन कॉल में एक वास्तविक मान के रूप में, उदाहरण के लिएःtrue.
c.barcolor(bar.Close > bar.Open ? 'rgba(255, 0, 0, 0.2)' : 'rgba(0, 0, 0, 0.2)') // Use the example illustrated in the reference code in this example, without further ado
c.barcolor('rgba(255, 0, 0, 0.2)' if bar.Close > bar.Open else 'rgba(0, 0, 0, 0.2)')
// Not supported for now
रेखाचित्र इंटरफ़ेस के कार्यPineरेखांकन क्रिया में समर्थित भाषाएं हैंःbarcolor, जो के-लाइन रंग सेट करता है।
barcolor ((रंग, ऑफसेट, संपादन योग्य, show_last, शीर्षक, प्रदर्शन) प्रदर्शन पैरामीटर वैकल्पिक हैंः
कोई नहीं , सभी
c.bgcolor('rgba(0, 255, 0, 0.5)')
c.bgcolor('rgba(0, 255, 0, 0.5)')
// Not supported for now
bgcolor, निर्दिष्ट रंग के साथ K-लाइन की पृष्ठभूमि को भरता है।
bgcolor ((रंग, ऑफसेट, संपादन योग्य, show_last, शीर्षक, प्रदर्शन, ओवरले) प्रदर्शन पैरामीटर वैकल्पिक हैंः
कोई नहीं , सभी
c.plot(bar.High, 'high')
c.plot(bar.Open < bar.Close ? NaN : bar.Close, "Close", {style: "linebr"}) // Support for drawing discontinuous data lines
h = c.plot(bar.High, 'high')
h = c.plot(None if bar.Open < bar.Close else bar.Close, "Close", style = "linebr") # Support for drawing discontinuous data lines
// Not supported for now
plot, एक चार्ट पर डेटा की एक श्रृंखला को प्लॉट करें।
plot ((श्रृंखला, शीर्षक, रंग, लाइनविड्थ, शैली, ट्रैकप्राइस, हिस्टबेस, ऑफसेट, ज्वाइन, संपादन योग्य, show_last, display) शैली पैरामीटर वैकल्पिक हैंः
stepline_diamond , stepline , cross , areabr , area , circles , columns , histogram , linebr , line प्रदर्शन पैरामीटर वैकल्पिक हैंः कोई नहीं , सभी
let h = c.plot(bar.High, 'high')
let l = c.plot(bar.Low, 'low')
c.fill(h, l, {color: bar.Close > bar.Open ? 'rgba(255, 0, 0, 0.2)' : 'rgba(255, 0, 0, 0.2)'})
h = c.plot(bar.High, 'high')
l = c.plot(bar.Low, 'low')
c.fill(h, l, color = 'rgba(255, 0, 0, 0.2)' if bar.Close > bar.Open else 'rgba(255, 0, 0, 0.2)'})
// Not supported for now
fill, दो प्लॉट के बीच की पृष्ठभूमि भरें याhlineप्रदान किए गए रंगों के साथ।
fill ((hline1, hline2, रंग, शीर्षक, संपादन योग्य, fillgaps, प्रदर्शित) प्रदर्शन पैरामीटर वैकल्पिक हैंः
कोई नहीं , सभी
के बाद सेJavaScriptभाषा फ़ंक्शन के नाम के आधार पर इनकमिंग पैरामीटर निर्दिष्ट नहीं कर सकते औपचारिक पैरामीटर, इस समस्या को हल करने के लिए, आप एक का उपयोग कर सकते हैं{key: value}एक निश्चित औपचारिक पैरामीटर नाम को पारित करने के लिए मापदंडों को निर्दिष्ट करने के लिए संरचना।
उदाहरण के लिए, संदर्भ कोड का उपयोग करता है{color: bar.Close > bar.Open ? 'rgba(255, 0, 0, 0, 0.2)' : 'rgba(255, 0, 0, 0, 0.2)'}निर्दिष्ट करता हैcolorपैरामीटरfillकार्य।
यदि आप लगातार फार्म पैरामीटर नाम के साथ कई मापदंडों को निर्दिष्ट करने की आवश्यकता है, तो आप उपयोग कर सकते हैं{key1: value1, key2: value2, key3: value3}.
उदाहरण के लिए, इस उदाहरण में, एक अतिरिक्तtitleपैरामीटर निर्दिष्ट किया गया हैः{color: bar.Close > bar.Open ? 'rgba(255, 0, 0, 0, 0.2)' : 'rgba(255, 0, 0, 0, 0.2)', title: 'fill'}.
रंग मूल्य के लिए, आप इसे के साथ सेट कर सकते हैं'rgba(255, 0, 0, 0, 0.2)'या के साथ'#FF0000'.
c.hline(bar.High)
c.hline(bar.High)
// Not supported for now
hline, क्षैतिज रेखा एक निश्चित निश्चित मूल्य स्तर पर प्रस्तुत की जाती है।
line ((मूल्य, शीर्षक, रंग, लाइन शैली, लाइन चौड़ाई, संपादन योग्य, प्रदर्शन) पंक्ति शैली पैरामीटर वैकल्पिक हैंः
डैशेड , डॉटेड , सॉलिड प्रदर्शन पैरामीटर वैकल्पिक हैंः कोई नहीं , सभी
c.plotarrow(bar.Close - bar.Open)
c.plotarrow(bar.Close - bar.Open)
// Not supported for now
plotarrow, चार्ट पर ऊपर और नीचे के तीरों को चित्रित करें।
plotrow ((सीरीज़, शीर्षक, रंग, रंग, ऑफसेट, minheight, maxheight, संपादन योग्य, show_last, display) प्रदर्शन पैरामीटर वैकल्पिक हैंः
कोई नहीं , सभी
c.plotshape(bar.Low, {style: 'diamond'})
c.plotshape(bar.Low, style = 'diamond')
// Not supported for now
plotshape, चार्ट पर दृश्य आकृतियां बनाएं।
plotshape ((श्रृंखला, शीर्षक, शैली, स्थान, रंग, ऑफसेट, पाठ, textcolor, संपादन योग्य, आकार, show_last, प्रदर्शन) शैली पैरामीटर वैकल्पिक हैंः
diamond size.autoआकार है.छोटा. प्रदर्शन पैरामीटर वैकल्पिक हैंः, square , label_down , label_up , arrow_down , arrow_up , circle , flag , triangle_down , triangle_up , cross , xcross स्थान पैरामीटर वैकल्पिक हैंः abovebar , belowbar , top , bottom , absolute आकार पैरामीटर वैकल्पिक हैंः 10px , 14px , 20px , 40px , 80px , तुलनात्मक आकार.टिनी, आकार.छोटा, आकार.सामान्य, आकार.बड़ा, आकार.विशाल पाइन भाषा में। कोई नहीं , सभी
c.plotchar(bar.Close, {char: 'X'})
c.plotchar(bar.Close, char = 'X')
// Not supported for now
plotchar, किसी भी दिए गए यूनिकोड वर्ण का उपयोग करके चार्ट पर दृश्य आकृतियों को आकर्षित करें।
plotchar ((श्रृंखला, शीर्षक, चार, स्थान, रंग, ऑफसेट, पाठ, textcolor, संपादन योग्य, आकार, show_last, प्रदर्शन) स्थान पैरामीटर वैकल्पिक हैंः
abovebar size.autoआकार है.छोटा. प्रदर्शन पैरामीटर वैकल्पिक हैंः, belowbar , top , bottom , absolute आकार पैरामीटर वैकल्पिक हैंः 10px , 14px , 20px , 40px , 80px , तुलनात्मक आकार.टिनी, आकार.छोटा, आकार.सामान्य, आकार.बड़ा, आकार.विशाल पाइन भाषा में। कोई नहीं , सभी
c.plotcandle(bar.Open*0.9, bar.High*0.9, bar.Low*0.9, bar.Close*0.9)
c.plotcandle(bar.Open*0.9, bar.High*0.9, bar.Low*0.9, bar.Close*0.9)
// Not supported for now
plotcandle, एक चार्ट पर एक K-लाइन चार्ट प्लॉट।
plotcandle ((खुला, उच्च, निम्न, बंद, शीर्षक, रंग, wickcolor, संपादन योग्य, show_last, bordercolor, display) प्रदर्शन पैरामीटर वैकल्पिक हैंः
कोई नहीं , सभी
c.signal("long", bar.High, 1.5)
c.signal("long", bar.High, 1.5)
// Not supported for now
signal, पाइन भाषा में उपलब्ध नहीं है एक समारोह, यहाँ खरीदने और बेचने के संकेत आकर्षित करने के लिए प्रयोग किया जाता है।
संकेत ((दिशा, कीमत, मात्रा, आईडी) पैरामीटर
long लेनदेन की दिशा इंगित करने के लिए पारित किया जाता है, आप long , closelong , short , closeshort चुन सकते हैं। पैरामीटर bar.Highमार्कर सिग्नल की Y-अक्ष स्थिति है। पास किया गया पैरामीटर 1.5 संकेत के लेनदेन की संख्या दर्शाता है। चौथा पैरामीटर तैयार किए गए डिफ़ॉल्ट पाठ सामग्री को बदलने के लिए पारित किया जा सकता है, और तैयार किए गए संकेत मार्कर का डिफ़ॉल्ट पाठ लेनदेन की दिशा है, उदाहरण के लिएcloselong ।
c.reset()
c.reset()
// Not supported for now
reset, जो पाइन भाषा में उपलब्ध नहीं है, का उपयोग चार्ट डेटा को खाली करने के लिए किया जाता है।
रीसेट करना (अभी तक) द
reset()विधि एक पैरामीटर ले सकती है,remain, रखने के लिए डेटा की संख्या निर्दिष्ट करने के लिए।remainइसका मतलब है सभी डेटा को साफ़ करना।
रणनीति कस्टम ड्राइंग का उपयोग कर सकते हैं केवल एक ही तरीके सेKLineChart()कार्य याChart()कुछ रंग और शैली सेटिंग्स के लिएKLineChart()फ़ंक्शन कॉल, कृपया देखेंरणनीति ड्राइंग डिजाइन को आसान बनाने के लिए KLineChart फ़ंक्शन का उपयोग करें.
{@मज़ा/लॉग/चार्ट चार्ट}
लॉग को साफ करो।
लॉग रीसेट करें (अभी तक)
..remainपैरामीटर का उपयोग हाल के लॉग प्रविष्टियों की संख्या को रखने के लिए किया जाता है।
रहना
झूठी
संख्या
function main() {
// Keep the last 10 logs and clear the rest
LogReset(10)
}
def main():
LogReset(10)
void main() {
LogReset(10);
}
रणनीति के प्रत्येक प्रारंभ के लिए स्टार्टअप लॉग लाइव ट्रेडिंग एक के रूप में गिना जाता है, इसलिए यदि कोई पैरामीटर पारित नहीं किया जाता है और रणनीति की शुरुआत में कोई लॉग आउटपुट नहीं है, तो कोई लॉग प्रदर्शित नहीं किया जाएगा, डॉकर लॉग की वापसी की प्रतीक्षा कर रहा है (एक अपवाद नहीं) ।
{@fun/Log Log}, {@fun/Log/LogVacuum LogVacuum}
भंडारण स्थान पर कब्जा करने के लिए इस्तेमाल कियाएसक्यूलाइटजब डेटा को कॉल करने के बाद हटाया जाता हैLogReset()लॉग को साफ़ करने के लिए फ़ंक्शन।
लॉगवैक्यूम
function main() {
LogReset()
LogVacuum()
}
def main():
LogReset()
LogVacuum()
void main() {
LogReset()
LogVacuum()
}
इसका कारण यह है किSQLiteडेटा हटाने पर कब्जा की जगह वापस नहीं लेता है, और यह निष्पादित करने की जरूरत हैVACUUMतालिका को साफ करने और स्थान मुक्त करने के लिए. फ़ाइल स्थानांतरण ऑपरेशन जब इस फ़ंक्शन को बुलाया जाता है, और देरी बड़ी है, इसलिए यह एक उपयुक्त समय अंतराल पर कॉल करने की सिफारिश की है।
{@fun/Log/LogReset लॉग रीसेट}
इसका उपयोग लाइव ट्रेडिंग पृष्ठ में 123456,console.logसमारोह आउटपुटों को लाइव ट्रेडिंग पृष्ठ पर जानकारी डिबगिंग, और एक ही समय में, विस्तार के साथ एक लॉग फ़ाइल बनाने.logऔर में डिबगिंग जानकारी लिखें/logs/storage/123456/उस डॉकर की डायरेक्टरी में जिसमें लाइव ट्रेडिंग है, जिसमें फाइलनाम उपसर्ग हैstdout_.
कंसोल.लॉग ((...msgs)
पैरामीटरmsgआउटपुट की सामग्री है, और पैरामीटरmsgएक से अधिक पारित किया जा सकता है।
msg
झूठी
स्ट्रिंग, संख्या, बोल, ऑब्जेक्ट, सरणी, शून्य और अन्य प्रकार जो सिस्टम द्वारा समर्थित हैं।
function main() {
console.log("test console.log")
}
# Not supported
// Not supported
JavaScriptभाषा इस कार्य का समर्थन करती है।[object Object], इसलिए जितना संभव हो उतना पठनीय जानकारी आउटपुट करने का प्रयास करें।{@fun/Log/console.error console.error} {@fun/Log/console.error} {@fun/Log/console.error} {@fun/Log/console.error} {@error.console.error} {@error.console.error} {@error.console.error} {@error.console.error}
लाइव ट्रेडिंग पृष्ठ पर 123456,console.errorfunction विस्तार के साथ लॉग फ़ाइल बनाता है.logमें/logs/storage/123456/डॉकर की निर्देशिका जहां लाइव व्यापार से संबंधित है, और उपसर्ग के साथ त्रुटि आउटपुट लिखता हैstderr_.
कंसोल.त्रुटि ((...msgs)
पैरामीटरmsgआउटपुट की सामग्री है, और पैरामीटरmsgएक से अधिक पारित किया जा सकता है।
msg
झूठी
स्ट्रिंग, संख्या, बोल, ऑब्जेक्ट, सरणी, शून्य और अन्य प्रकार जो सिस्टम द्वारा समर्थित हैं।
function main() {
console.error("test console.error")
}
# Not supported
// Not supported
JavaScriptभाषा इस कार्य का समर्थन करती है।[object Object], इसलिए जितना संभव हो उतना पठनीय जानकारी आउटपुट करने का प्रयास करें।{@fun/Log/console.log कंसोल.log}
वर्तमान में सेट ट्रेडिंग जोड़ी, अनुबंध कोड, यानी टिकर डेटा के अनुरूप स्पॉट या अनुबंध की {@struct/Ticker Ticker} संरचना प्राप्त करें।GetTicker ()फ़ंक्शन एक्सचेंज ऑब्जेक्ट {@var/EXCHANGE exchange} का सदस्य फ़ंक्शन है,exchangeऑब्जेक्ट सदस्य फ़ंक्शन (विधि) केवल संबंधित हैंexchange, और यह दस्तावेज़ में दोहराया नहीं जाएगा।
..exchange.GetTicker()फ़ंक्शन {@struct/Ticker Ticker} संरचना देता है जब डेटा के लिए अनुरोध सफल होता है, और शून्य मान देता है जब डेटा के लिए अनुरोध विफल होता है.
{@struct/Ticker Ticker}, शून्य मान
विनिमय.GetTicker() विनिमय.GetTicker ((प्रतीक)
पैरामीटरsymbol{@struct/Ticker Ticker} डेटा के अनुरूप विशिष्ट ट्रेडिंग जोड़ी और अनुबंध कोड निर्दिष्ट करने के लिए प्रयोग किया जाता है। यदि यह पैरामीटर पारित नहीं किया जाता है, तो वर्तमान में सेट ट्रेडिंग जोड़ी और अनुबंध कोड के बाजार डेटा को डिफ़ॉल्ट रूप से अनुरोध किया जाएगा।
जब कॉलexchange.GetTicker(symbol)कार्य,exchangeयदि आपको USDT के रूप में मुद्रा और BTC के रूप में ट्रेडिंग मुद्रा के साथ बाजार डेटा का अनुरोध करने की आवश्यकता है, तो पैरामीटरsymbolहै:"BTC_USDT", और प्रारूप एफएमजेड प्लेटफॉर्म द्वारा परिभाषित ट्रेडिंग जोड़ी प्रारूप है।
जब कॉलexchange.GetTicker(symbol)कार्य,exchangeहै वायदा विनिमय वस्तु. यदि आप BTCsymbolहै:"BTC_USDT.swap", और प्रारूपव्यापारिक जोड़ीऔरअनुबंध कोडएफएमजेड प्लेटफॉर्म द्वारा परिभाषित किया गया है, जिसे exchange.GetTicker(symbol)कार्य,exchangeवायदा विनिमय वस्तु है. यदि आप BTCsymbolहै:"BTC_USDT.BTC-240108-40000-C"(उदाहरण के लिए बिनेंस विकल्प BTC-240108-40000-C लेते हुए), प्रारूपव्यापारिक जोड़ीएफएमजेड प्लेटफॉर्म द्वारा परिभाषित और एक्सचेंज द्वारा परिभाषित विशिष्ट विकल्प अनुबंध कोड, जो वर्ण
चिह्न झूठी स्ट्रिंग
function main(){
// If it is a futures exchange object, set the contract code first, e.g. set it as a perpetual contract
// exchange.SetContractType("swap")
var ticker = exchange.GetTicker()
/*
The exchange interface may not be accessible due to network reasons (even if the docker program's device can open the exchange website, the API interface may not be accessible).
At this point, the ticker is null, and it will cause an error when accessing ticker.High, so when testing this code, make sure that the exchange interface can be accessed.
*/
Log("Symbol:", ticker.Symbol, "High:", ticker.High, "Low:", ticker.Low, "Sell:", ticker.Sell, "Buy:", ticker.Buy, "Last:", ticker.Last, "Open:", ticker.Open, "Volume:", ticker.Volume)
}
def main():
ticker = exchange.GetTicker()
Log("Symbol:", ticker["Symbol"], "High:", ticker["High"], "Low:", ticker["Low"], "Sell:", ticker["Sell"], "Buy:", ticker["Buy"], "Last:", ticker["Last"], "Open:", ticker.Open, "Volume:", ticker["Volume"])
void main() {
auto ticker = exchange.GetTicker();
Log("Symbol:", ticker.Symbol, "High:", ticker.High, "Low:", ticker.Low, "Sell:", ticker.Sell, "Buy:", ticker.Buy, "Last:", ticker.Last, "Open:", ticker.Open, "Volume:", ticker.Volume);
}
वायदा विनिमय वस्तुओं के लिए (यानीexchangeयाexchanges[0]), आपको अनुबंध कोड को सेट करने की आवश्यकता हैexchange.SetContractType()टिकर फंक्शन को बुलाने से पहले, जो दोहराया नहीं जाएगा।
function main() {
var ticker = exchange.GetTicker("BTC_USDT")
Log(ticker)
}
def main():
ticker = exchange.GetTicker("BTC_USDT")
Log(ticker)
void main() {
auto ticker = exchange.GetTicker("BTC_USDT");
Log(ticker);
}
उपयोग करेंsymbolएक विशिष्ट प्रतीक के लिए बाजार डेटा का अनुरोध करने के लिए पैरामीटर (स्पॉट प्रतीक) ।
..Tickerद्वारा लौटाए गए डेटाexchange.GetTicker()बैकटेस्टिंग प्रणाली में कार्य करता है।HighऔरLowमूल्य का अनुकरण किया जाता है, जो उस समय बाजार में एक बेचने और एक खरीदने से लिया जाता है।Tickerद्वारा लौटाए गए डेटाexchange.GetTicker()वास्तविक बाजार में कार्य करते हैं।HighऔरLowमूल्यों को कैप्सुलेटेड एक्सचेंज द्वारा लौटाए गए डेटा पर आधारित हैंTickइंटरफेस, जिसमें एक निश्चित अवधि (आमतौर पर 24 घंटे की अवधि) के भीतर उच्चतम और निम्नतम मूल्य शामिल हैं।
एक्सचेंजों जो समर्थन नहीं करते हैंexchange.GetTicker()कार्य:
| फ़ंक्शन का नाम | असमर्थित स्पॉट एक्सचेंज | बिना समर्थन वाले फ्यूचर्स एक्सचेंज |
|---|---|---|
| GetTicker | – | फ्यूचर्स_एवो |
{@fun/Market/exchange.GetDepth exchange.GetDepth}, {@fun/Market/exchange.GetTrades exchange.GetTrades}, {@fun/Market/exchange.GetRecords exchange.GetRecords}, {@fun/Market/exchange.GetTickers exchange.GetTickers}, {@fun/Market/exchange.GetTickers exchange.GetTickers}, {@fun/Market/exchange.GetTickers exchange.GetTickers}, {@fun/Market/exchange.GetTickers exchange.GetTickers}, {@fun/Market/exchange.GetTickers exchange.GetTickers}, {@fun/Market/exchange.GetTickers exchange.GetTickers}, {@fun/Market/exchange.GetTickers exchange.GetTickers}, {@fun/Market/exchange.GetTickers exchange.GetTickers exchange.GetTickers}, {@fun/Market/exchange
वर्तमान में सेट ट्रेडिंग जोड़ी, अनुबंध कोड, यानी ऑर्डर बुक डेटा के अनुरूप स्पॉट या अनुबंध की {@struct/Depth Depth} संरचना प्राप्त करें।
..exchange.GetDepth()function {@struct/Depth Depth} संरचना को लौटाता है यदि डेटा के लिए अनुरोध सफल होता है, और यदि डेटा के लिए अनुरोध विफल होता है तो यह शून्य लौटाता है.
{@struct/Depth Depth}, शून्य मान
विनिमय.GetDepth() आदान-प्रदान.GetDepth ((प्रतीक)
पैरामीटरsymbol{@struct/Depth Depth} डेटा के अनुरूप विशिष्ट ट्रेडिंग जोड़ी और अनुबंध कोड निर्दिष्ट करने के लिए प्रयोग किया जाता है। यदि यह पैरामीटर पारित नहीं किया जाता है, तो वर्तमान में सेट ट्रेडिंग जोड़ी और अनुबंध कोड के ऑर्डर बुक डेटा का डिफ़ॉल्ट रूप से अनुरोध किया जाएगा।exchange.GetDepth(symbol)कार्य,exchangeयदि आपको USDT के रूप में मुद्रा और BTC के रूप में लेनदेन मुद्रा के साथ ऑर्डर बुक डेटा प्राप्त करने के लिए अनुरोध करने की आवश्यकता है, तो पैरामीटरsymbolहै:"BTC_USDT", और प्रारूप एफएमजेड प्लेटफॉर्म द्वारा परिभाषित ट्रेडिंग जोड़ी प्रारूप है।exchange.GetDepth(symbol)कार्य,exchangeवायदा विनिमय वस्तु है. यदि आप BTCsymbolहै:"BTC_USDT.swap", और प्रारूपव्यापारिक जोड़ीऔरअनुबंध कोडFMZ प्लेटफॉर्म द्वारा परिभाषित, वर्ण द्वारा अलग exchange.GetDepth(symbol)कार्य,exchangeवायदा विनिमय वस्तु है. यदि आप BTCsymbolहै:"BTC_USDT.BTC-240108-40000-C"(उदाहरण के लिए बिनेंस विकल्प BTC-240108-40000-C लेते हुए), प्रारूपव्यापारिक जोड़ीएफएमजेड प्लेटफॉर्म द्वारा परिभाषित और एक्सचेंज द्वारा परिभाषित विशिष्ट विकल्प अनुबंध कोड, जो वर्ण
function main(){
var depth = exchange.GetDepth()
/*
The exchange interface may not be accessible due to network reasons (even if the docker program's device can open the exchange website, the API interface may not be accessible).
At this point, the depth is null, which will cause an error when accessing depth.Asks[1].Price, so make sure you can access the exchange interface when testing the code.
*/
var price = depth.Asks[1].Price
Log("Sell 2 price is:", price)
}
def main():
depth = exchange.GetDepth()
price = depth["Asks"][1]["Price"]
Log("Sell 2 price is:", price)
void main() {
auto depth = exchange.GetDepth();
auto price = depth.Asks[1].Price;
Log("Sell 2 price is:", price);
}
परीक्षणexchange.GetDepth()कार्य:
function main() {
// BTC U-based perpetual contract
var depth = exchange.GetDepth("BTC_USDT.swap")
Log(depth)
}
def main():
depth = exchange.GetDepth("BTC_USDT.swap")
Log(depth)
void main() {
auto depth = exchange.GetDepth("BTC_USDT.swap");
Log(depth);
}
जब विन्यस्तexchangeवस्तु एक वायदा विनिमय वस्तु है, का उपयोग करेंsymbolएक विशिष्ट प्रतीक (फ्यूचर्स प्रतीक) के ऑर्डर बुक डेटा की मांग करने के लिए पैरामीटर।
बैकटेस्टिंग प्रणाली में, प्रत्येक ग्रेड के लिए डेटाexchange.GetDepth()कार्य करते समयटिक का अनुकरण करेंbacktesting सभी अनुकरणीय मान हैं।exchange.GetDepth()कार्य करते समयअसली टिकबैकटेस्टिंग एक दूसरे स्तर की गहरी झलक है।
{@fun/Market/exchange.GetTicker exchange.GetTicker}, {@fun/Market/exchange.GetTrades exchange.GetTrades}, {@fun/Market/exchange.GetRecords exchange.GetRecords}
{@struct/Trade Trade} स्ट्रक्चर सरणी प्राप्त करें जो वर्तमान में सेट ट्रेडिंग जोड़ी, अनुबंध कोड, अर्थात बाजार लेनदेन डेटा के अनुरूप स्पॉट या अनुबंध है।
..exchange.GetTrades()फ़ंक्शन {@struct/Trade Trade} संरचनाओं की एक सरणी लौटाता है यदि डेटा के लिए अनुरोध सफल होता है, और यदि डेटा के लिए अनुरोध विफल होता है तो यह शून्य मान लौटाता है.
{@struct/Trade Trade} सरणी, शून्य मान
विनिमय.GetTrades ((() exchange.GetTrades (प्रतीक)
पैरामीटरsymbol{@struct/Trade Trade} सरणी डेटा के अनुरूप विशिष्ट ट्रेडिंग जोड़ी और अनुबंध कोड निर्दिष्ट करने के लिए प्रयोग किया जाता है। यदि यह पैरामीटर पारित नहीं किया जाता है, तो वर्तमान में सेट ट्रेडिंग जोड़ी और अनुबंध कोड के नवीनतम लेनदेन रिकॉर्ड डेटा को डिफ़ॉल्ट रूप से अनुरोध किया जाएगा।exchange.GetTrades(symbol)कार्य,exchangeयदि आपको USDT के रूप में मुद्रा और BTC के रूप में ट्रेडिंग मुद्रा के साथ ऑर्डर बुक डेटा प्राप्त करने का अनुरोध करने की आवश्यकता है, तो पैरामीटरsymbolहै:"BTC_USDT", और प्रारूप एफएमजेड प्लेटफॉर्म द्वारा परिभाषित ट्रेडिंग जोड़ी प्रारूप है।exchange.GetTrades(symbol)कार्य,exchangeवायदा विनिमय वस्तु है. यदि आप BTCsymbolहै:"BTC_USDT.swap", और प्रारूपव्यापारिक जोड़ीऔरअनुबंध कोडFMZ प्लेटफॉर्म द्वारा परिभाषित, वर्ण द्वारा अलग exchange.GetTrades(symbol)कार्य,exchangeवायदा विनिमय वस्तु है. यदि आप BTCsymbolहै:"BTC_USDT.BTC-240108-40000-C"(उदाहरण के लिए बिनेंस विकल्प BTC-240108-40000-C लेते हुए), प्रारूपव्यापारिक जोड़ीएफएमजेड प्लेटफॉर्म द्वारा परिभाषित और एक्सचेंज द्वारा परिभाषित विशिष्ट विकल्प अनुबंध कोड, जो वर्ण
function main(){
var trades = exchange.GetTrades()
/*
The exchange interface may not be accessible due to network reasons (even if the docker program's device can open the exchange website, the API interface may not be accessible).
At this point, trade is null. When accessing trade[0].Id, it will cause an error. Therefore, when testing this code, ensure that you can access the exchange interface.
*/
Log("id:", trades[0].Id, "time:", trades[0].Time, "Price:", trades[0].Price, "Amount:", trades[0].Amount, "type:", trades[0].Type)
}
def main():
trades = exchange.GetTrades()
Log("id:", trades[0]["Id"], "time:", trades[0]["Time"], "Price:", trades[0]["Price"], "Amount:", trades[0]["Amount"], "type:", trades[0]["Type"])
void main() {
auto trades = exchange.GetTrades();
Log("id:", trades[0].Id, "time:", trades[0].Time, "Price:", trades[0].Price, "Amount:", trades[0].Amount, "type:", trades[0].Type);
}
परीक्षण करेंexchange.GetTrades()कार्य:
function main() {
// BTC's U-based perpetual contract
var trades = exchange.GetTrades("BTC_USDT.swap")
Log(trades)
}
def main():
trades = exchange.GetTrades("BTC_USDT.swap")
Log(trades)
void main() {
auto trades = exchange.GetTrades("BTC_USDT.swap");
Log(trades);
}
जब विन्यस्तexchangeवस्तु एक वायदा विनिमय वस्तु है, का उपयोग करेंsymbolएक विशिष्ट प्रतीक (फ्यूचर्स प्रतीक) के लिए बाजार लेनदेन रिकॉर्ड डेटा का अनुरोध करने के लिए पैरामीटर।
exchange.GetTrades()वर्तमान ट्रेडिंग जोड़े, बाजार के लेनदेन इतिहास (अपने स्वयं के नहीं) अनुबंधों के अनुरूप प्राप्त करने के लिए कार्य। कुछ एक्सचेंजों इस समारोह का समर्थन नहीं करते हैं, और विशिष्ट डेटा लौटाया जाता है कि लेनदेन रिकॉर्ड की सीमा का कितना हिस्सा एक्सचेंज पर निर्भर करता है और विशिष्ट स्थिति के अनुसार संभालने की आवश्यकता होती है। रिटर्न डेटा एक सरणी है, जहां कालानुक्रमिक क्रम का प्रत्येक तत्व औरexchange.GetRecords ()फ़ंक्शन डेटा का एक ही क्रम लौटाता है, अर्थात, सरणी का अंतिम तत्व वर्तमान समय के निकटतम डेटा है।
दexchange.GetTrades()function का उपयोग करते समय एक खाली सरणी लौटाता हैटिक का अनुकरण करेंबैकटेस्टिंग प्रणाली में बैकटेस्टिंग।exchange.GetTrades()उपयोग करते समय कार्यअसली टिकबैकटेस्टिंग प्रणाली में बैकटेस्टिंग ऑर्डर फ्लो स्नैपशॉट डेटा है, अर्थात {@struct/Trade Trade} संरचना सरणी।
एक्सचेंजों जो समर्थन नहीं करते हैंexchange.GetTrades()कार्य:
| फ़ंक्शन का नाम | असमर्थित स्पॉट एक्सचेंज | बिना समर्थन वाले फ्यूचर्स एक्सचेंज |
|---|---|---|
| GetTrades | – | फ्यूचर्स_बिटमार्ट / फ्यूचर्स_बिबॉक्स |
{@मज़ा/बाजार/विनिमय.GetTicker विनिमय.GetTicker}, {@मज़ा/बाजार/विनिमय.GetDepth विनिमय.GetDepth}, {@मज़ा/बाजार/विनिमय.GetRecords विनिमय.GetRecords}
वर्तमान में सेट ट्रेडिंग जोड़ी, अनुबंध कोड, यानी के-लाइन डेटा के अनुरूप स्पॉट या अनुबंध की {@struct/Record Record} संरचना सरणी प्राप्त करें.
..exchange.GetRecords()function {@struct/Record Record} संरचनाओं की एक सरणी लौटाता है जब डेटा के लिए अनुरोध सफल होता है, और यह डेटा के लिए अनुरोध विफल होने पर शून्य मान लौटाता है.
{@struct/Record Record} सरणी, शून्य मान
विनिमय.GetRecords() विनिमय.GetRecords ((प्रतीक) exchange.GetRecords ((प्रतीक, बिंदु) exchange.GetRecords ((प्रतीक, अवधि, सीमा) विनिमय.GetRecords (अवधि) exchange.GetRecords (अवधि, सीमा)
पैरामीटरsymbol{@struct/Record Record} सरणी डेटा के अनुरूप विशिष्ट ट्रेडिंग जोड़ी और अनुबंध कोड निर्दिष्ट करने के लिए प्रयोग किया जाता है। यदि यह पैरामीटर पारित नहीं किया जाता है, तो वर्तमान में सेट ट्रेडिंग जोड़ी और अनुबंध कोड के के-लाइन डेटा का डिफ़ॉल्ट रूप से अनुरोध किया जाएगा।exchange.GetRecords(symbol)कार्य,exchangeस्पॉट एक्सचेंज ऑब्जेक्ट है। यदि आपको USDT के रूप में मुद्रा और BTC के रूप में लेनदेन मुद्रा के साथ डेटा प्राप्त करने के लिए अनुरोध करने की आवश्यकता है, तो पैरामीटरsymbolहै:"BTC_USDT", और प्रारूप एफएमजेड प्लेटफॉर्म द्वारा परिभाषित ट्रेडिंग जोड़ी प्रारूप है।exchange.GetRecords(symbol)कार्य,exchangeवायदा विनिमय वस्तु है. यदि आप BTCsymbolहै:"BTC_USDT.swap", और प्रारूपव्यापारिक जोड़ीऔरअनुबंध कोडFMZ प्लेटफॉर्म द्वारा परिभाषित, वर्ण द्वारा अलग exchange.GetRecords(symbol)कार्य,exchangeवायदा विनिमय वस्तु है. यदि आप BTCsymbolहै:"BTC_USDT.BTC-240108-40000-C"(उदाहरण के लिए बिनेंस विकल्प BTC-240108-40000-C लेते हुए), प्रारूपव्यापारिक जोड़ीएफएमजेड प्लेटफॉर्म द्वारा परिभाषित और एक्सचेंज द्वारा परिभाषित विशिष्ट विकल्प अनुबंध कोड, जो वर्ण periodअनुरोधित K-लाइन डेटा की अवधि निर्दिष्ट करता है, उदाहरण के लिएः {@var/PERIOD/PERIOD_M1 PERIOD_M1}, {@var/PERIOD/PERIOD_M5 PERIOD_M5}, {@var/PERIOD/PERIOD_M15 PERIOD_M15} आदि। पैरामीटर का मानperiodपरिभाषित मानक अवधि को ही नहीं, बल्कि सेकंड में पूर्णांक मानों को भी पारित किया जा सकता है। यदि यह पैरामीटर पारित नहीं किया जाता है, तो डिफ़ॉल्ट रूप से अनुरोधित K-लाइन डेटा की अवधि वर्तमान रणनीति वास्तविक समय/बैकटेस्ट कॉन्फ़िगरेशन की डिफ़ॉल्ट K-लाइन अवधि है।
अवधि
झूठी
संख्या
पैरामीटरlimitअनुरोधित के-लाइन डेटा की लंबाई निर्दिष्ट करने के लिए प्रयोग किया जाता है. यदि यह पैरामीटर पारित नहीं किया जाता है, तो डिफ़ॉल्ट अनुरोध लंबाई एक्सचेंज के-लाइन इंटरफ़ेस के समय अनुरोधित के-लाइन बार की अधिकतम संख्या है. यह पैरामीटर एक्सचेंज के-लाइन डेटा से पूछताछ करने के लिए पेजिंग का कारण बन सकता है, और पेजिंग क्वेरी के दौरान फ़ंक्शन कॉल की समय खपत बढ़ जाएगी.
सीमा
झूठी
संख्या
function main() {
// Print K-line data with a K-line period of 120 seconds (2 minutes)
Log(exchange.GetRecords(60 * 2))
// Print K-line data with a K-line period of 5 minutes
Log(exchange.GetRecords(PERIOD_M5))
}
def main():
Log(exchange.GetRecords(60 * 2))
Log(exchange.GetRecords(PERIOD_M5))
void main() {
Log(exchange.GetRecords(60 * 2)[0]);
Log(exchange.GetRecords(PERIOD_M5)[0]);
}
कस्टम अवधि के लिए के-लाइन डेटा प्राप्त करें।
function main() {
var records = exchange.GetRecords(PERIOD_H1)
/*
The exchange interface may not be accessible due to network reasons (even if the docker program's device can open the exchange website, the API interface may not be accessible).
At this point, records is null. When accessing records[0].Time, it will cause an error. Therefore, when testing this code, ensure that you can access the exchange interface.
*/
Log("The first k-line data is Time:", records[0].Time, "Open:", records[0].Open, "High:", records[0].High)
Log("The second k-line data is Time:", records[1].Time ,"Close:", records[1].Close)
Log("Current K-line (latest)", records[records.length-1], "Previous K-line", records[records.length-2])
}
def main():
records = exchange.GetRecords(PERIOD_H1)
Log("The first k-line data is Time:", records[0]["Time"], "Open:", records[0]["Open"], "High:", records[0]["High"])
Log("The second k-line data Time:", records[1]["Time"], "Close:", records[1]["Close"])
Log("Current K-line (latest)", records[-1], "Previous K-line", records[-2])
void main() {
auto records = exchange.GetRecords(PERIOD_H1);
Log("The first k-line data is Time:", records[0].Time, "Open:", records[0].Open, "High:", records[0].High);
Log("The second k-line data Time:", records[1].Time, "Close:", records[1].Close);
Log("Current K-line (latest)", records[records.size() - 1], "Previous K-line", records[records.size() - 2]);
}
आउटपुट K-लाइन बार डेटाः
function main() {
var records = exchange.GetRecords("BTC_USDT.swap", 60, 100)
Log(records)
}
def main():
records = exchange.GetRecords("BTC_USDT.swap", 60, 100)
Log(records)
void main() {
auto records = exchange.GetRecords("BTC_USDT.swap", 60, 100);
Log(records);
}
जब विन्यस्तexchangeवस्तु एक वायदा विनिमय वस्तु है, का उपयोग करेंsymbol, period, औरlimitकिसी विशिष्ट उत्पाद (भविष्य के उत्पाद) के के-लाइन डेटा की मांग करने के लिए मापदंड।
डिफ़ॉल्ट के-लाइन अवधि बैकटेस्ट और वास्तविक व्यापार पृष्ठों में सेट किया जा सकता है.exchange.GetRecords()फ़ंक्शन, उस पैरामीटर अवधि के अनुरूप K-लाइन डेटा प्राप्त किया जाएगा. यदि कोई पैरामीटर फ़ंक्शन बुलाया जाता है जब निर्दिष्ट नहीं है, संबंधित K-लाइन डेटा बैकटेस्ट और वास्तविक बाजार मापदंडों में सेट K-लाइन अवधि के अनुसार लौटाया जाएगा.
रिटर्न मान के एक सरणी हैRecordसंरचनाओं, लौटाए गए K-लाइन डेटा समय के साथ जमा हो जाएगा, संचित K-लाइन सलाखों की ऊपरी सीमाexchange.SetMaxBarLen()फ़ंक्शन सेटिंग. डिफ़ॉल्ट सीमा 5000 बार है जब यह सेट नहीं है. जब K-लाइन डेटा K-लाइन बार संचय सीमा तक पहुंचता है, तो इसे K-लाइन बार जोड़कर और सबसे पहले K-लाइन बार (जैसे कतार में / बाहर) को हटाकर अपडेट किया जाएगा। कुछ एक्सचेंजों में K-लाइन इंटरफ़ेस प्रदान नहीं किया जाता है, इसलिए डॉकर बाजार लेनदेन रिकॉर्ड डेटा एकत्र करता है (Tradeसंरचित सरणी) वास्तविक समय में K-रेखा उत्पन्न करने के लिए।
यदि एक्सचेंज के के-लाइन इंटरफ़ेस पेजिंग क्वेरी का समर्थन करता है, तो कई एपीआई अनुरोध किए जाएंगे जब कॉल किया जाएगाexchange.SetMaxBarLen()एक बड़ी K-लाइन लंबाई सेट करने के लिए समारोह.
जबexchange.GetRecords()यदि प्रारंभ में फ़ंक्शन को बुलाया जाता है, तो प्राप्त K-लाइन बार की संख्या बैकटेस्टिंग और वास्तविक ट्रेडिंग के बीच भिन्न होती हैः - बैकटेस्टिंग सिस्टम बैकटेस्टिंग समय सीमा की शुरुआत से पहले एक निश्चित संख्या में K-लाइन बार प्राप्त करेगा (डिफ़ॉल्ट 5000 है, बैकटेस्टिंग सिस्टम की सेटिंग्स और डेटा की मात्रा अंतिम संख्या को प्रभावित करेगी), प्रारंभिक K-लाइन डेटा के रूप में। - वास्तविक ट्रेडिंग के दौरान प्राप्त K-लाइन बार की संख्या एक्सचेंज के K-लाइन इंटरफ़ेस से प्राप्त किए जा सकने वाले डेटा की अधिकतम मात्रा पर आधारित है।
दperiodपैरामीटर 5 पर सेट है, जो 5 सेकंड की अवधि के साथ K-लाइन डेटा प्राप्त करने के लिए एक अनुरोध है।periodपैरामीटर 60 से विभाजित नहीं है (यानी, प्रतिनिधित्व की गई अवधि मिनटों से विभाजित नहीं है) ।exchange.GetTrades()लेन-देन रिकॉर्ड डेटा प्राप्त करने और आवश्यक के-लाइन डेटा को संश्लेषित करने के लिए।periodपैरामीटर 60 से विभाजित है, तो आवश्यक K-लाइन डेटा कम से कम 1 मिनट के K-लाइन डेटा का उपयोग करके संश्लेषित किया जाता है (यदि संभव हो, तो आवश्यक K-लाइन डेटा को एक बड़ी अवधि का उपयोग करके संश्लेषित किया जाता है) ।
बैकटेस्टिंग प्रणाली में अनुकरणीय स्तर बैकटेस्टिंग के लिए अंतर्निहित के-लाइन अवधि की सेटिंग की आवश्यकता होती है (जब बैकटेस्टिंग प्रणाली स्तर बैकटेस्टिंग का अनुकरण करती है, तो संबंधित के-लाइन डेटा का उपयोग सेट अंतर्निहित के-लाइन अवधि के अनुसार टिक डेटा उत्पन्न करने के लिए किया जाता है) । यह ध्यान दिया जाना चाहिए कि रणनीति में प्राप्त के-लाइन डेटा की अवधि अंतर्निहित के-लाइन अवधि से कम नहीं होनी चाहिए। क्योंकि सिमुलेशन स्तर बैकटेस्टिंग में, बैकटेस्टिंग प्रणाली में प्रत्येक अवधि के के-लाइन डेटा को अंतर्निहित के-लाइन अवधि के के-लाइन डेटा से संश्लेषित किया जाता है।
दC++भाषा में निम्न कोड उदाहरण है यदि आपको अपने स्वयं के K-लाइन डेटा का निर्माण करने की आवश्यकता है:
#include <sstream>
void main() {
Records r;
r.Valid = true;
for (auto i = 0; i < 10; i++) {
Record ele;
ele.Time = i * 100000;
ele.High = i * 10000;
ele.Low = i * 1000;
ele.Close = i * 100;
ele.Open = i * 10;
ele.Volume = i * 1;
r.push_back(ele);
}
// Output display: Records[10]
Log(r);
auto ma = TA.MA(r,10);
// Output display: [nan,nan,nan,nan,nan,nan,nan,nan,nan,450]
Log(ma);
}
एक्सचेंजों जो समर्थन नहीं करते हैंexchange.GetRecords()कार्य:
| फ़ंक्शन का नाम | असमर्थित स्पॉट एक्सचेंज | बिना समर्थन वाले फ्यूचर्स एक्सचेंज |
|---|---|---|
| GetRecords | Zaif / Coincheck / BitFlyer | फ्यूचर्स_एवो |
{@fun/Market/exchange.GetTicker exchange.GetTicker}, {@fun/Market/exchange.GetDepth exchange.GetDepth}, {@fun/Market/exchange.GetTrades exchange.GetTrades}, {@fun/Market/exchange.SetMaxBarLen exchange.SetMaxBarLen}
एफएमजेड क्वांट ट्रेडिंग प्लेटफॉर्म वेबसाइट पेज पर सेट की गई के-लाइन अवधि प्राप्त करें जब बैकटेस्टिंग और लाइव ट्रेडिंग में रणनीति चल रही है, अर्थात डिफ़ॉल्ट के-लाइन अवधि का उपयोग जब कॉल किया जाता हैexchange.GetRecords()पैरामीटर पास किए बिना कार्य करता है।
सेकंड में के-लाइन अवधि, सेकंड में पूर्णांक मान। संख्या
विनिमय.GetPeriod (()
function main() {
// For example, the K-line period set on the website page of the FMZ Quant Trading platform during backtesting and live trading is 1 hour.
var period = exchange.GetPeriod()
Log("K-line period:", period / (60 * 60), "hours")
}
def main():
period = exchange.GetPeriod()
Log("K-line period:", period / (60 * 60), "hours")
void main() {
auto period = exchange.GetPeriod();
Log("K-line period:", period / (60 * 60.0), "hours");
}
{@मज़ा/बाजार/विनिमय.GetRecordsविनिमय.GetRecords}
के-लाइन की अधिकतम लंबाई सेट करें.
विनिमय.SetMaxBarLen ((n)
पैरामीटरnअधिकतम के-लाइन लंबाई निर्दिष्ट करने के लिए प्रयोग किया जाता है।
n
सच
संख्या
function main() {
exchange.SetMaxBarLen(50)
var records = exchange.GetRecords()
Log(records.length, records)
}
def main():
exchange.SetMaxBarLen(50)
r = exchange.GetRecords()
Log(len(r), r)
void main() {
exchange.SetMaxBarLen(50);
auto r = exchange.GetRecords();
Log(r.size(), r[0]);
}
..exchange.SetMaxBarLen()यह क्रिया क्रिप्टोक्यूरेंसी रणनीति रनटाइम के दो पहलुओं को प्रभावित करती हैः
{@मज़ा/बाजार/विनिमय.GetRecordsविनिमय.GetRecords}
मूल सामग्री को अंतिम समय तक लौटाएंrestवर्तमान विनिमय वस्तु के लिए अनुरोध ({@var/EXCHANGE exchange}, {@var/EXCHANGE/exchanges exchanges}).
उत्तर के आंकड़ेrestअनुरोध।
स्ट्रिंग
विनिमय.GetRawJSON()
function main(){
exchange.GetAccount();
var obj = JSON.parse(exchange.GetRawJSON());
Log(obj);
}
import json
def main():
exchange.GetAccount()
obj = json.loads(exchange.GetRawJSON())
Log(obj)
void main() {
auto obj = exchange.GetAccount();
// C++ does not support the GetRawJSON function
Log(obj);
}
..exchange.GetRawJSON()यह फ़ंक्शन केवल वास्तविक ट्रेडिंग के लिए समर्थित है।C++ language.
{@var/EXCHANGE विनिमय}
विनिमय वस्तु के लिए वर्तमान में सेट विनिमय दर प्राप्त करें.
विनिमय वस्तु की विनिमय दर का वर्तमान मूल्य। संख्या
विनिमय.GetRate()
function main(){
Log(exchange.GetTicker())
// Set up exchange rate conversion
exchange.SetRate(7)
Log(exchange.GetTicker())
Log("Current exchange rate:", exchange.GetRate())
}
def main():
Log(exchange.GetTicker())
exchange.SetRate(7)
Log(exchange.GetTicker())
Log("Current exchange rate:", exchange.GetRate())
void main() {
Log(exchange.GetTicker());
exchange.SetRate(7);
Log(exchange.GetTicker());
Log("Current exchange rate:", exchange.GetRate());
}
यदिexchange.SetRate()विनिमय दर निर्धारित करने के लिए नहीं बुलाया गया है,exchange.GetRate()फ़ंक्शन 1 का एक डिफ़ॉल्ट दर मान देता है, यानी वर्तमान में प्रदर्शित मुद्रा (quoteCurrency) से संबंधित डेटा परिवर्तित नहीं किया गया है.
यदि विनिमय दर का मूल्य विनिमय दर का उपयोग करके निर्धारित किया गया हैexchange.SetRate()उदाहरण के लिए,exchange.SetRate(7). फिर सभी मूल्य जानकारी, जैसे उद्धरण, गहराई, और आदेश कीमतों के माध्यम से प्राप्तexchangeविनिमय वस्तु को सेट विनिमय दर से गुणा करके परिवर्तित किया जाएगा7.
यदिexchangeकॉल करने के बाद मुद्रा के रूप में USD के साथ एक विनिमय के अनुरूप हैexchange.SetRate(7), लाइव बाजार में सभी कीमतों को सीएनवाई के करीब मूल्य में गुणा करके परिवर्तित किया जाएगा7इस बिंदु पर, विनिमय दर मूल्य का उपयोग करके प्राप्तexchange.GetRate()है7.
{@fun/Trade/exchange.SetRate exchange.SetRate}
..exchange.SetData()फ़ंक्शन का उपयोग रणनीति चल रही है जब लोड डेटा सेट करने के लिए किया जाता है.
पैरामीटर के बाद स्ट्रिंग की लंबाईvalueJSON एन्कोडिंग.
संख्या
exchange.SetData ((कुंजी, मान)
डेटा संग्रह का नाम।
कुंजी
सच
स्ट्रिंग
डेटा को लोड करने के लिएexchange.SetData()फ़ंक्शन के पास एक सरणी का डेटा संरचना है। डेटा संरचना उसी डेटा प्रारूप के समान है जिसे फ़ंक्शन द्वारा अनुरोध किया गया है।exchange.GetData()बाह्य डेटा का अनुरोध करते समय कार्य, अर्थातः"schema": ["time", "data"].
मूल्य
सच
सरणी
/*backtest
start: 2020-01-21 00:00:00
end: 2020-02-12 00:00:00
period: 1d
basePeriod: 1d
exchanges: [{"eid":"Bitfinex","currency":"BTC_USD"}]
*/
function main() {
var data = [
[1579536000000, "abc"],
[1579622400000, 123],
[1579708800000, {"price": 123}],
[1579795200000, ["abc", 123, {"price": 123}]]
]
exchange.SetData("test", data)
while(true) {
Log(exchange.GetData("test"))
Sleep(1000)
}
}
'''backtest
start: 2020-01-21 00:00:00
end: 2020-02-12 00:00:00
period: 1d
basePeriod: 1d
exchanges: [{"eid":"Bitfinex","currency":"BTC_USD"}]
'''
def main():
data = [
[1579536000000, "abc"],
[1579622400000, 123],
[1579708800000, {"price": 123}],
[1579795200000, ["abc", 123, {"price": 123}]]
]
exchange.SetData("test", data)
while True:
Log(exchange.GetData("test"))
Sleep(1000)
/*backtest
start: 2020-01-21 00:00:00
end: 2020-02-12 00:00:00
period: 1d
basePeriod: 1d
exchanges: [{"eid":"Bitfinex","currency":"BTC_USD"}]
*/
void main() {
json data = R"([
[1579536000000, "abc"],
[1579622400000, 123],
[1579708800000, {"price": 123}],
[1579795200000, ["abc", 123, {"price": 123}]]
])"_json;
exchange.SetData("test", data);
while(true) {
Log(exchange.GetData("test"));
Sleep(1000);
}
}
यह आवश्यक है कि पैरामीटर के लिए डेटाvalueएक ही प्रारूप में होना चाहिएdataआप देख सकते हैं कि समयस्टैम्प1579622400000समय से मेल खाती है2020-01-22 00:00:00, और जब रणनीति कार्यक्रम इस समय के बाद चलाया जाता है, कॉलexchange.GetData()अगले डेटा टाइमस्टैम्प से पहले डेटा प्राप्त करने के लिए समारोह1579708800000, यानी समय2020-01-23 00:00:00. क्या आप प्राप्त कर रहे हैं[1579622400000, 123]उस डेटा की सामग्री, के रूप में कार्यक्रम चल रहा है, समय बदल जाता है, और इतने पर आइटम द्वारा डेटा आइटम प्राप्त करने के लिए. निम्नलिखित उदाहरण में, रनटाइम (बैकटेस्टिंग या लाइव ट्रेडिंग) में, वर्तमान क्षण तक पहुँचता है या समय से अधिक है1579795200000,exchange.GetData()फ़ंक्शन बुलाया जाता है और रिटर्न मान हैः{"Time":1579795200000,"Data":["abc", 123,{"price":123}]}. "Time":1579795200000से मेल खाती है1579795200000आंकड़ों में[1579795200000, ["abc", 123, {"price": 123}]]. "Data":["abc", 123, {"price": 123}]डेटा से मेल खाता है["abc", 123, {"price": 123}]]में[1579795200000, ["abc", 123, {"price": 123}]].
लोड किए गए डेटा किसी भी आर्थिक संकेतक, उद्योग के डेटा, प्रासंगिक संकेतक आदि हो सकते हैं, जिनका उपयोग सभी परिमाणात्मक जानकारी के रणनीतिक मात्रात्मक मूल्यांकन के लिए किया जाता है।
{@मज़ा/बाजार/विनिमय.GetData विनिमय.GetData}
..exchange.GetData()फ़ंक्शन का उपयोग डेटा लोड करने के लिए किया जाता हैexchange.SetData()कार्य या एक बाहरी लिंक द्वारा प्रदान की जाती है।
डेटा संग्रह में रिकॉर्ड। वस्तु
विनिमय.GetData(की) विनिमय.GetData ((कुंजी, टाइमआउट)
डेटा संग्रह का नाम। कुंजी सच स्ट्रिंग लाइव ट्रेडिंग के लिए डिफ़ॉल्ट रूप से एक मिनट केश टाइमआउट पर सेट किया जाता है. टाइमआउट झूठी संख्या
/*backtest
start: 2020-01-21 00:00:00
end: 2020-02-12 00:00:00
period: 1d
basePeriod: 1d
exchanges: [{"eid":"Bitfinex","currency":"BTC_USD"}]
*/
function main() {
exchange.SetData("test", [[1579536000000, _D(1579536000000)], [1579622400000, _D(1579622400000)], [1579708800000, _D(1579708800000)]])
while(true) {
Log(exchange.GetData("test"))
Sleep(1000 * 60 * 60 * 24)
}
}
'''backtest
start: 2020-01-21 00:00:00
end: 2020-02-12 00:00:00
period: 1d
basePeriod: 1d
exchanges: [{"eid":"Bitfinex","currency":"BTC_USD"}]
'''
def main():
exchange.SetData("test", [[1579536000000, _D(1579536000000/1000)], [1579622400000, _D(1579622400000/1000)], [1579708800000, _D(1579708800000/1000)]])
while True:
Log(exchange.GetData("test"))
Sleep(1000 * 60 * 60 * 24)
/*backtest
start: 2020-01-21 00:00:00
end: 2020-02-12 00:00:00
period: 1d
basePeriod: 1d
exchanges: [{"eid":"Bitfinex","currency":"BTC_USD"}]
*/
void main() {
json arr = R"([[1579536000000, ""], [1579622400000, ""], [1579708800000, ""]])"_json;
arr[0][1] = _D(1579536000000);
arr[1][1] = _D(1579622400000);
arr[2][1] = _D(1579708800000);
exchange.SetData("test", arr);
while(true) {
Log(exchange.GetData("test"));
Sleep(1000 * 60 * 60 * 24);
}
}
सीधे डेटा लिखने के लिए कॉल।
/*backtest
start: 2020-01-21 00:00:00
end: 2020-02-12 00:00:00
period: 1d
basePeriod: 1d
exchanges: [{"eid":"Bitfinex","currency":"BTC_USD"}]
*/
function main() {
while(true) {
Log(exchange.GetData("http://xxx.xx.x.xx:9090/data"))
Sleep(1000)
}
}
'''backtest
start: 2020-01-21 00:00:00
end: 2020-02-12 00:00:00
period: 1d
basePeriod: 1d
exchanges: [{"eid":"Bitfinex","currency":"BTC_USD"}]
'''
def main():
while True:
Log(exchange.GetData("http://xxx.xx.x.xx:9090/data"))
Sleep(1000)
/*backtest
start: 2020-01-21 00:00:00
end: 2020-02-12 00:00:00
period: 1d
basePeriod: 1d
exchanges: [{"eid":"Bitfinex","currency":"BTC_USD"}]
*/
void main() {
while(true) {
Log(exchange.GetData("http://xxx.xx.x.xx:9090/data"));
Sleep(1000);
}
}
यह बाहरी लिंक के माध्यम से डेटा का अनुरोध करने के लिए समर्थन करता है, अनुरोधित डेटा का प्रारूपः
{
"schema":["time","data"],
"data":[
[1579536000000, "abc"],
[1579622400000, 123],
[1579708800000, {"price": 123}],
[1579795200000, ["abc", 123, {"price": 123}]]
]
}
कहाँschemaलोड किए गए डेटा के शरीर में प्रत्येक रिकॉर्ड के लिए डेटा प्रारूप है, जो["time", "data"]जिसमें प्रविष्टि-दर-प्रविष्टि डेटा के प्रारूप के अनुरूपdataविशेषता।
क्या संग्रहीत हैdataविशेषता डेटा का शरीर है, जिसमें प्रत्येक प्रविष्टि में एक मिलीसेकंड स्तर का टाइमस्टैम्प और डेटा सामग्री होती है (जो कोई भी JSON- एन्कोडेबल डेटा हो सकती है) ।
परीक्षण के लिए सेवा कार्यक्रम, गो में लिखा गयाः
package main
import (
"fmt"
"net/http"
"encoding/json"
)
func Handle (w http.ResponseWriter, r *http.Request) {
defer func() {
fmt.Println("req:", *r)
ret := map[string]interface{}{
"schema": []string{"time","data"},
"data": []interface{}{
[]interface{}{1579536000000, "abc"},
[]interface{}{1579622400000, 123},
[]interface{}{1579708800000, map[string]interface{}{"price":123}},
[]interface{}{1579795200000, []interface{}{"abc", 123, map[string]interface{}{"price":123}}},
},
}
b, _ := json.Marshal(ret)
w.Write(b)
}()
}
func main () {
fmt.Println("listen http://localhost:9090")
http.HandleFunc("/data", Handle)
http.ListenAndServe(":9090", nil)
}
अनुरोध प्राप्त होने पर कार्यक्रम के प्रतिक्रिया डेटाः
{
"schema":["time","data"],
"data":[
[1579536000000, "abc"],
[1579622400000, 123],
[1579708800000, {"price": 123}],
[1579795200000, ["abc", 123, {"price": 123}]]
]
}
परीक्षण रणनीति कोडः
function main() {
Log(exchange.GetData("http://xxx.xx.x.xx:9090/data"))
Log(exchange.GetData("https://www.fmz.com/upload/asset/32bf73a69fc12d36e76.json"))
}
def main():
Log(exchange.GetData("http://xxx.xx.x.xx:9090/data"))
Log(exchange.GetData("https://www.fmz.com/upload/asset/32bf73a69fc12d36e76.json"))
void main() {
Log(exchange.GetData("http://xxx.xx.x.xx:9090/data"));
Log(exchange.GetData("https://www.fmz.com/upload/asset/32bf73a69fc12d36e76.json"));
}
बाहरी लिंक के डेटा प्राप्त करने के लिए कॉल विधि।
function main() {
Log(exchange.GetData("https://www.datadata.com/api/v1/query/xxx/data")) // The xxx part of the link is the code of the query data, here xxx is an example.
}
def main():
Log(exchange.GetData("https://www.datadata.com/api/v1/query/xxx/data"))
void main() {
Log(exchange.GetData("https://www.datadata.com/api/v1/query/xxx/data"));
}
प्लेटफ़ॉर्म पर बनाई गई क्वेरी के लिए अनुरोध डेटाडाटाडेटा, अनुरोध है कि उत्तर के डेटा प्रारूप हो (समय होना चाहिए, डेटा क्षेत्रों में वर्णित स्कीमा):
{
"data": [],
"schema": ["time", "data"]
}
exchange.GetData()फ़ंक्शन बुलाया जाता है, एक JSON ऑब्जेक्ट लौटाया जाता है, उदाहरण के लिएः{"Time":1579795200000, "Data":"..."}.
बैकटेस्टिंग के लिए एक बार में डेटा प्राप्त करें और लाइव ट्रेडिंग के लिए एक मिनट के डेटा को कैश करें। बैकटेस्टिंग प्रणाली में, एक्सेस इंटरफ़ेस का उपयोग करके डेटा का अनुरोध करते समय, बैकटेस्टिंग प्रणाली स्वचालित रूप से जोड़ती हैfrom(सेकंडों में समय मुहर लगाकर),to(सेकंड में समय-स्टैम्प) अनुरोध के लिए, पैरामीटर जैसेperiod(आधारभूत के-लाइन अवधि, मिलीसेकंड में समय-स्टैम्प) का उपयोग उस समय-सीमा को निर्धारित करने के लिए किया जाता है जिस पर डेटा प्राप्त किया जाना है।
{@मज़ा/बाजार/विनिमय.सेटडेटा विनिमय.सेटडेटा}
..exchange.GetMarkets()कार्य का उपयोग विनिमय बाजार की जानकारी प्राप्त करने के लिए किया जाता है।
शब्दकोश में {@struct/Market Market} संरचना शामिल है। वस्तु
विनिमय.GetMarkets()
function main() {
var markets = exchange.GetMarkets()
var currency = exchange.GetCurrency()
// Get the current contract code can also use exchange.GetContractType() function
var ct = "swap"
var key = currency + "." + ct
Log(key, ":", markets[key])
}
def main():
markets = exchange.GetMarkets()
currency = exchange.GetCurrency()
ct = "swap"
key = currency + "." + ct
Log(key, ":", markets[key])
void main() {
auto markets = exchange.GetMarkets();
auto currency = exchange.GetCurrency();
auto ct = "swap";
auto key = currency + "." + ct;
Log(key, ":", markets[key]);
}
फ्यूचर्स एक्सचेंज ऑब्जेक्ट पर कॉल का उदाहरणः
/*backtest
start: 2023-05-10 00:00:00
end: 2023-05-20 00:00:00
period: 1m
basePeriod: 1m
exchanges: [{"eid":"Futures_Binance","currency":"BTC_USDT"}]
*/
function main() {
var arrSymbol = ["SOL_USDT.swap", "BTC_USDT.quarter", "ETH_USDT.swap", "ETH_USDT.quarter"]
var tbl1 = {
type: "table",
title: "markets1",
cols: ["key", "Symbol", "BaseAsset", "QuoteAsset", "TickSize", "AmountSize", "PricePrecision", "AmountPrecision", "MinQty", "MaxQty", "MinNotional", "MaxNotional", "CtVal"],
rows: []
}
var markets1 = exchange.GetMarkets()
for (var key in markets1) {
var market = markets1[key]
tbl1.rows.push([key, market.Symbol, market.BaseAsset, market.QuoteAsset, market.TickSize, market.AmountSize, market.PricePrecision, market.AmountPrecision, market.MinQty, market.MaxQty, market.MinNotional, market.MaxNotional, market.CtVal])
}
for (var symbol of arrSymbol) {
exchange.GetTicker(symbol)
}
var tbl2 = {
type: "table",
title: "markets2",
cols: ["key", "Symbol", "BaseAsset", "QuoteAsset", "TickSize", "AmountSize", "PricePrecision", "AmountPrecision", "MinQty", "MaxQty", "MinNotional", "MaxNotional", "CtVal"],
rows: []
}
var markets2 = exchange.GetMarkets()
for (var key in markets2) {
var market = markets2[key]
tbl2.rows.push([key, market.Symbol, market.BaseAsset, market.QuoteAsset, market.TickSize, market.AmountSize, market.PricePrecision, market.AmountPrecision, market.MinQty, market.MaxQty, market.MinNotional, market.MaxNotional, market.CtVal])
}
LogStatus("`" + JSON.stringify([tbl1, tbl2]) + "`")
}
'''backtest
start: 2023-05-10 00:00:00
end: 2023-05-20 00:00:00
period: 1m
basePeriod: 1m
exchanges: [{"eid":"Futures_Binance","currency":"BTC_USDT"}]
'''
import json
def main():
arrSymbol = ["SOL_USDT.swap", "BTC_USDT.quarter", "ETH_USDT.swap", "ETH_USDT.quarter"]
tbl1 = {
"type": "table",
"title": "markets1",
"cols": ["key", "Symbol", "BaseAsset", "QuoteAsset", "TickSize", "AmountSize", "PricePrecision", "AmountPrecision", "MinQty", "MaxQty", "MinNotional", "MaxNotional", "CtVal"],
"rows": []
}
markets1 = exchange.GetMarkets()
for key in markets1:
market = markets1[key]
tbl1["rows"].append([key, market["Symbol"], market["BaseAsset"], market["QuoteAsset"], market["TickSize"], market["AmountSize"], market["PricePrecision"], market["AmountPrecision"], market["MinQty"], market["MaxQty"], market["MinNotional"], market["MaxNotional"], market["CtVal"]])
for symbol in arrSymbol:
exchange.GetTicker(symbol)
tbl2 = {
"type": "table",
"title": "markets2",
"cols": ["key", "Symbol", "BaseAsset", "QuoteAsset", "TickSize", "AmountSize", "PricePrecision", "AmountPrecision", "MinQty", "MaxQty", "MinNotional", "MaxNotional", "CtVal"],
"rows": []
}
markets2 = exchange.GetMarkets()
for key in markets2:
market = markets2[key]
tbl2["rows"].append([key, market["Symbol"], market["BaseAsset"], market["QuoteAsset"], market["TickSize"], market["AmountSize"], market["PricePrecision"], market["AmountPrecision"], market["MinQty"], market["MaxQty"], market["MinNotional"], market["MaxNotional"], market["CtVal"]])
LogStatus("`" + json.dumps([tbl1, tbl2]) + "`")
/*backtest
start: 2023-05-10 00:00:00
end: 2023-05-20 00:00:00
period: 1m
basePeriod: 1m
exchanges: [{"eid":"Futures_Binance","currency":"BTC_USDT"}]
*/
void main() {
auto arrSymbol = {"SOL_USDT.swap", "BTC_USDT.quarter", "ETH_USDT.swap", "ETH_USDT.quarter"};
json tbl1 = R"({
"type": "table",
"title": "markets1",
"cols": ["key", "Symbol", "BaseAsset", "QuoteAsset", "TickSize", "AmountSize", "PricePrecision", "AmountPrecision", "MinQty", "MaxQty", "MinNotional", "MaxNotional", "CtVal"],
"rows": []
})"_json;
auto markets1 = exchange.GetMarkets();
for (auto& [key, market] : markets1.items()) {
json arrJson = {key, market["Symbol"], market["BaseAsset"], market["QuoteAsset"], market["TickSize"], market["AmountSize"], market["PricePrecision"], market["AmountPrecision"], market["MinQty"], market["MaxQty"], market["MinNotional"], market["MaxNotional"], market["CtVal"]};
tbl1["rows"].push_back(arrJson);
}
for (const auto& symbol : arrSymbol) {
exchange.GetTicker(symbol);
}
json tbl2 = R"({
"type": "table",
"title": "markets2",
"cols": ["key", "Symbol", "BaseAsset", "QuoteAsset", "TickSize", "AmountSize", "PricePrecision", "AmountPrecision", "MinQty", "MaxQty", "MinNotional", "MaxNotional", "CtVal"],
"rows": []
})"_json;
auto markets2 = exchange.GetMarkets();
for (auto& [key, market] : markets2.items()) {
json arrJson = {key, market["Symbol"], market["BaseAsset"], market["QuoteAsset"], market["TickSize"], market["AmountSize"], market["PricePrecision"], market["AmountPrecision"], market["MinQty"], market["MaxQty"], market["MinNotional"], market["MaxNotional"], market["CtVal"]};
tbl2["rows"].push_back(arrJson);
}
json tbls = R"([])"_json;
tbls.push_back(tbl1);
tbls.push_back(tbl2);
LogStatus("`" + tbls.dump() + "`");
}
फ्यूचर्स एक्सचेंज ऑब्जेक्ट का उपयोग करेंexchange.GetMarkets()function in the backtesting system. किसी भी बाजार फ़ंक्शन को कॉल करने से पहले, GetMarkets केवल वर्तमान डिफ़ॉल्ट ट्रेडिंग जोड़ी के बाजार डेटा को लौटाता है. बाजार फ़ंक्शन को कॉल करने के बाद, यह सभी अनुरोधित किस्मों के बाजार डेटा को लौटाता है. आप निम्नलिखित परीक्षण उदाहरण का संदर्भ ले सकते हैंः
..exchange.GetMarkets()फ़ंक्शन ट्रेडिंग किस्म के नाम से एक कुंजी के साथ एक शब्दकोश लौटाता है, और एक ट्रेडिंग जोड़ी के रूप में स्वरूपित स्पॉट फिक्स के लिए, उदाहरण के लिएः
{
"BTC_USDT" : {...}, // The key value is the Market structure
"LTC_USDT" : {...},
...
}
फ्यूचर्स कॉन्ट्रैक्ट एक्सचेंजों के लिए, क्योंकि एक ही किस्म के लिए कई कॉन्ट्रैक्ट हो सकते हैं, जैसेBTC_USDTव्यापारिक जोड़े, वहाँ स्थायी अनुबंध, त्रैमासिक अनुबंध, और इतने पर कर रहे हैं।exchange.GetMarkets()फ़ंक्शन अनुबंध कोड के साथ संयुक्त जोड़ी के कुंजी नाम के साथ एक शब्दकोश लौटाता है, उदाहरण के लिएः
{
"BTC_USDT.swap" : {...}, // The key value is the Market structure
"BTC_USDT.quarter" : {...},
"LTC_USDT.swap" : {...},
...
}
exchange.GetMarkets()कार्य लाइव ट्रेडिंग, बैकटेस्टिंग प्रणाली का समर्थन करता है।exchange.GetMarkets()यह फ़ंक्शन केवल उन किस्मों के लिए बाजार की जानकारी देता है जिनसे ऑनलाइन व्यापार किया जाता है।exchange.GetMarkets()कार्य विकल्प अनुबंधों का समर्थन नहीं करता है.एक्सचेंजों जो समर्थन नहीं करते हैंexchange.GetMarkets()कार्य:
| फ़ंक्शन का नाम | असमर्थित स्पॉट एक्सचेंज | बिना समर्थन वाले फ्यूचर्स एक्सचेंज |
|---|---|---|
| GetMarkets | कॉइनचेक / बिथम्ब / बिटफ्लायर | – |
{@struct/मार्केट मार्केट}
..exchange.GetTickers()function का प्रयोग एक्सचेंज एग्रीगेटेड टिकर डेटा ({@struct/Ticker Ticker} संरचना की सरणी) प्राप्त करने के लिए किया जाता है।exchangeसभी ट्रेडिंग जोड़े के लिए टिकर डेटा लौटाता है जब यह एक स्पॉट एक्सचेंज ऑब्जेक्ट है;exchangeसभी अनुबंधों के लिए टिकर डेटा लौटाता है जब यह वायदा विनिमय वस्तु है।
..exchange.GetTickers()फ़ंक्शन {@struct/Ticker Ticker} संरचनाओं की एक सरणी लौटाता है जब यह डेटा का अनुरोध करने में सफल होता है, और शून्य जब यह विफल होता है।
{@struct/Ticker Ticker} सरणी, शून्य मान
विनिमय.GetTickers()
function main() {
var tickers = exchange.GetTickers()
if (tickers && tickers.length > 0) {
Log("Number of tradable items on the exchange:", tickers.length)
}
}
def main():
tickers = exchange.GetTickers()
if tickers and len(tickers) > 0:
Log("Number of tradable items on the exchange:", len(tickers))
void main() {
auto tickers = exchange.GetTickers();
if (tickers.Valid && tickers.size() > 0) {
Log("Number of tradable items on the exchange:", tickers.size());
}
}
कॉल करेंexchange.GetTickers()संकलित बाजार डेटा प्राप्त करने के लिए कार्य।
/*backtest
start: 2024-05-21 00:00:00
end: 2024-09-05 00:00:00
period: 5m
basePeriod: 1m
exchanges: [{"eid":"Binance","currency":"BTC_USDT"}]
*/
function main() {
var arrSymbol = ["ADA_USDT", "LTC_USDT", "ETH_USDT", "SOL_USDT"]
// Before requesting other trading pair market data, call Get Tickers
var tickers1 = exchange.GetTickers()
var tbl1 = {type: "table", title: "tickers1", cols: ["Symbol", "High", "Open", "Low", "Last", "Buy", "Sell", "Time", "Volume"], rows: []}
for (var ticker of tickers1) {
tbl1.rows.push([ticker.Symbol, ticker.High, ticker.Open, ticker.Low, ticker.Last, ticker.Buy, ticker.Sell, ticker.Time, ticker.Volume])
}
// Request market data for other trading pairs
for (var symbol of arrSymbol) {
exchange.GetTicker(symbol)
}
// Call GetTickers again
var tickers2 = exchange.GetTickers()
var tbl2 = {type: "table", title: "tickers2", cols: ["Symbol", "High", "Open", "Low", "Last", "Buy", "Sell", "Time", "Volume"], rows: []}
for (var ticker of tickers2) {
tbl2.rows.push([ticker.Symbol, ticker.High, ticker.Open, ticker.Low, ticker.Last, ticker.Buy, ticker.Sell, ticker.Time, ticker.Volume])
}
LogStatus("`" + JSON.stringify([tbl1, tbl2]) + "`")
}
'''backtest
start: 2024-05-21 00:00:00
end: 2024-09-05 00:00:00
period: 5m
basePeriod: 1m
exchanges: [{"eid":"Binance","currency":"BTC_USDT"}]
'''
import json
def main():
arrSymbol = ["ADA_USDT", "LTC_USDT", "ETH_USDT", "SOL_USDT"]
tickers1 = exchange.GetTickers()
tbl1 = {"type": "table", "title": "tickers1", "cols": ["Symbol", "High", "Open", "Low", "Last", "Buy", "Sell", "Time", "Volume"], "rows": []}
for ticker in tickers1:
tbl1["rows"].append([ticker["Symbol"], ticker["High"], ticker["Open"], ticker["Low"], ticker["Last"], ticker["Buy"], ticker["Sell"], ticker["Time"], ticker["Volume"]])
for symbol in arrSymbol:
exchange.GetTicker(symbol)
tickers2 = exchange.GetTickers()
tbl2 = {"type": "table", "title": "tickers2", "cols": ["Symbol", "High", "Open", "Low", "Last", "Buy", "Sell", "Time", "Volume"], "rows": []}
for ticker in tickers2:
tbl2["rows"].append([ticker["Symbol"], ticker["High"], ticker["Open"], ticker["Low"], ticker["Last"], ticker["Buy"], ticker["Sell"], ticker["Time"], ticker["Volume"]])
LogStatus("`" + json.dumps([tbl1, tbl2]) + "`")
/*backtest
start: 2024-05-21 00:00:00
end: 2024-09-05 00:00:00
period: 5m
basePeriod: 1m
exchanges: [{"eid":"Binance","currency":"BTC_USDT"}]
*/
json tickerToJson(const Ticker& ticker) {
json arrJson;
arrJson.push_back(ticker.Symbol);
arrJson.push_back(ticker.High);
arrJson.push_back(ticker.Open);
arrJson.push_back(ticker.Low);
arrJson.push_back(ticker.Last);
arrJson.push_back(ticker.Buy);
arrJson.push_back(ticker.Sell);
arrJson.push_back(ticker.Time);
arrJson.push_back(ticker.Volume);
return arrJson;
}
void main() {
std::string arrSymbol[] = {"ADA_USDT", "LTC_USDT", "ETH_USDT", "SOL_USDT"};
auto tickers1 = exchange.GetTickers();
json tbl1 = R"({
"type": "table",
"cols": ["Symbol", "High", "Open", "Low", "Last", "Buy", "Sell", "Time", "Volume"],
"rows": []
})"_json;
tbl1["title"] = "tickers1";
for (const auto& ticker : tickers1) {
json arrJson = tickerToJson(ticker);
tbl1["rows"].push_back(arrJson);
}
for (const std::string& symbol : arrSymbol) {
exchange.GetTicker(symbol);
}
auto tickers2 = exchange.GetTickers();
json tbl2 = R"({
"type": "table",
"cols": ["Symbol", "High", "Open", "Low", "Last", "Buy", "Sell", "Time", "Volume"],
"rows": []
})"_json;
tbl2["title"] = "tickers2";
for (const auto& ticker : tickers2) {
json arrJson = tickerToJson(ticker);
tbl2["rows"].push_back(arrJson);
}
json tbls = R"([])"_json;
tbls.push_back(tbl1);
tbls.push_back(tbl2);
LogStatus("`" + tbls.dump() + "`");
}
स्पॉट एक्सचेंज ऑब्जेक्ट का उपयोग करें और कॉल करेंexchange.GetTickers()function in the backtest system. किसी भी बाजार फ़ंक्शन को कॉल करने से पहले, GetTickers केवल वर्तमान डिफ़ॉल्ट ट्रेडिंग जोड़ी के टिकर डेटा को लौटाता है. बाजार फ़ंक्शन को कॉल करने के बाद, यह सभी अनुरोधित किस्मों के टिकर डेटा को लौटाता है. आप निम्नलिखित परीक्षण उदाहरण का संदर्भ ले सकते हैंः
एक्सचेंजों जो समर्थन नहीं करते हैंexchange.GetTickers()कार्य:
| फ़ंक्शन का नाम | असमर्थित स्पॉट एक्सचेंज | बिना समर्थन वाले फ्यूचर्स एक्सचेंज |
|---|---|---|
| GetTickers | Zaif / WOO / Gemini / Coincheck / BitFlyer / Bibox | फ्यूचर्स_WOO / फ्यूचर्स_डीवाईडीएक्स / फ्यूचर्स_डेरबिट / फ्यूचर्स_बिबॉक्स / फ्यूचर्स_एवो |
{@struct/TickerTicker}, {@fun/Market/exchange.GetTicker एक्सचेंज.GetTicker}
..exchange.Buy()खरीद आदेश देने के लिए उपयोग किया जाता है।Buy()फ़ंक्शन एक्सचेंज ऑब्जेक्ट {@var/EXCHANGE exchange} का सदस्य फ़ंक्शन है।Buy()विनिमय वस्तु से बंधे विनिमय खाते पर कार्य करता हैexchange. सदस्य कार्यों का उद्देश्य (प्रणाली)exchangeऑब्जेक्ट केवल संबंधित हैexchange, और यह प्रलेखन के बाद दोहराया नहीं जाएगा।
एक सफल आदेश आदेश आईडी देता है, एक असफल आदेश शून्य मान देता है.
विशेषताIdएफएमजेड प्लेटफॉर्म के आदेश {@struct/Order Order} संरचना में एक्सचेंज उत्पाद कोड और एक्सचेंज मूल आदेश आईडी शामिल है, जिन्हें अंग्रेजी अल्पविराम से अलग किया गया है। उदाहरण के लिए, विशेषताIdस्पॉट ट्रेडिंग जोड़ी का प्रारूपETH_USDTओकेएक्स एक्सचेंज का क्रम हैःETH-USDT,1547130415509278720.
जब फोन करते हैंexchange.Buy()ऑर्डर देने के लिए फ़ंक्शन, रिटर्न वैल्यू ऑर्डरIdके अनुरूप हैIdआदेश {@struct/Order Order} संरचना की विशेषता।
स्ट्रिंग, शून्य मान
विनिमय.खरीदें ((मूल्य, राशि) विनिमय.खरीदें ((मूल्य, राशि,... args)
..priceपैरामीटर का उपयोग आदेश मूल्य निर्धारित करने के लिए किया जाता है।
मूल्य
सच
संख्या
दamountपैरामीटर का उपयोग आदेश राशि को सेट करने के लिए किया जाता है।
राशि
सच
संख्या
विस्तारित मापदंड जो इस ऑर्डर लॉग के लिए सहायक जानकारी आउटपुट कर सकते हैं,argपैरामीटर एक से अधिक पारित किया जा सकता है।
आर्ग
झूठी
string, number, bool, object, array, null और सिस्टम द्वारा समर्थित कोई अन्य प्रकार
function main() {
var id = exchange.Buy(100, 1);
Log("id:", id);
}
def main():
id = exchange.Buy(100, 1)
Log("id:", id)
void main() {
auto id = exchange.Buy(100, 1);
Log("id:", id);
}
द्वारा लौटाया गया क्रमांकexchange.Buy()आदेश की जानकारी पूछने और आदेश को रद्द करने के लिए इस्तेमाल किया जा सकता है।
// The following is an error call
function main() {
exchange.SetContractType("quarter")
// Set the shorting direction
exchange.SetDirection("sell")
// If you place a buy order, an error will be reported, and shorting can only be sold
var id = exchange.Buy(50, 1)
// Set the long direction
exchange.SetDirection("buy")
// If you place a sell order, it will report an error, go long, only buy
var id2 = exchange.Sell(60, 1)
// Set direction to close long positions
exchange.SetDirection("closebuy")
// If you place a buy order, it will report an error, close long, only sell
var id3 = exchange.Buy(-1, 1)
// Set direction to close short positions
exchange.SetDirection("closesell")
// If you place a sell order, it will report an error, close short, only buy
var id4 = exchange.Sell(-1, 1)
}
# The following is an error call
def main():
exchange.SetContractType("quarter")
exchange.SetDirection("sell")
id = exchange.Buy(50, 1)
exchange.SetDirection("buy")
id2 = exchange.Sell(60, 1)
exchange.SetDirection("closebuy")
id3 = exchange.Buy(-1, 1)
exchange.SetDirection("closesell")
id4 = exchange.Sell(-1, 1)
// The following is an error call
void main() {
exchange.SetContractType("quarter");
exchange.SetDirection("sell");
auto id = exchange.Buy(50, 1);
exchange.SetDirection("buy");
auto id2 = exchange.Sell(60, 1);
exchange.SetDirection("closebuy");
auto id3 = exchange.Buy(-1, 1);
exchange.SetDirection("closesell");
auto id4 = exchange.Sell(-1, 1);
}
क्रिप्टोक्यूरेंसी वायदा अनुबंध के लिए ऑर्डर देते समय, यह सुनिश्चित करने के लिए सावधानी बरती जानी चाहिए कि ट्रेड दिशा सही ढंग से सेट हो, क्योंकि ट्रेड दिशा और ट्रेड फ़ंक्शन के बीच असंगतता के परिणामस्वरूप त्रुटि होगीः
direction is sell, invalid order type Buy
direction is buy, invalid order type Sell
direction is closebuy, invalid order type Buy
direction is closesell, invalid order type Sell
// For example, the trading pair: ETH_BTC, place a buy order at the market price
function main() {
// Place a buy order at the market price and buy ETH coins with a value of 0.1 BTC (denominated currency)
exchange.Buy(-1, 0.1)
}
def main():
exchange.Buy(-1, 0.1)
void main() {
exchange.Buy(-1, 0.1);
}
स्पॉट मार्केट ऑर्डर।
फ्यूचर्स कॉन्ट्रैक्ट के लिए ऑर्डर देते समय, आपको इस बात पर ध्यान देना चाहिए कि क्या ट्रेड दिशा सही ढंग से सेट की गई है, क्योंकि यदि ट्रेड दिशा और ट्रेड फ़ंक्शन मेल नहीं खाते हैं तो त्रुटि की सूचना दी जाएगी। क्रिप्टोक्यूरेंसी फ्यूचर्स कॉन्ट्रैक्ट के लिए ऑर्डर का आकार अनुबंधों की संख्या है यदि निर्दिष्ट नहीं है।
पैरामीटरpriceपर सेट है-1बाजार के आदेशों को रखने के लिए, जिसके लिए एक्सचेंज के ऑर्डर प्लेसमेंट इंटरफ़ेस को बाजार के आदेशों का समर्थन करने की आवश्यकता होती है। क्रिप्टोक्यूरेंसी स्पॉट अनुबंधों के लिए बाजार के आदेशों को रखने पर, पैरामीटरamountआदेश की मुद्रा में पैसे की राशि है। जब क्रिप्टोक्यूरेंसी वायदा अनुबंधों के लिए बाजार के आदेश रखने, राशि पैरामीटरamountअनुबंधों की संख्या है. कुछ क्रिप्टोक्यूरेंसी एक्सचेंजों हैं जो लाइव ट्रेडिंग के दौरान बाजार ऑर्डर इंटरफ़ेस का समर्थन नहीं करते हैं. कुछ स्पॉट एक्सचेंजों पर बाजार खरीद ऑर्डर के लिए ऑर्डर मात्रा ट्रेडिंग सिक्कों की संख्या है. कृपया देखेंआदान-प्रदान के लिए विशेष निर्देशIdकेexchange.Buy()कार्य आदेश के वापसी मूल्य से अलग हो सकता हैIdवर्तमान दस्तावेज में वर्णित है।
{@fun/Trade/exchange.Sell exchange.Sell}, {@fun/Futures/exchange.SetContractType exchange.SetContractType}, {@fun/Futures/exchange.SetDirection exchange.SetDirection}, {@fun/Trade/exchange.Sell exchange.Sell}, {@fun/Futures/exchange.Sell exchange.Sell}, {@fun/Futures/exchange.SetContractType exchange.SetContractType}, {@fun/Futures/exchange.SetDirection exchange.SetDirection}
..exchange.Sell()विक्रय आदेश देने के लिए उपयोग किया जाता है।
एक सफल आदेश आदेश आईडी देता है, एक असफल आदेश शून्य मान देता है।Idएफएमजेड प्लेटफॉर्म के आदेश {@struct/Order Order} संरचना में एक्सचेंज उत्पाद कोड और एक्सचेंज मूल आदेश आईडी शामिल है, जिन्हें अंग्रेजी अल्पविराम से अलग किया गया है। उदाहरण के लिए, विशेषताIdस्पॉट ट्रेडिंग जोड़ी का प्रारूपETH_USDTओकेएक्स एक्सचेंज का क्रम हैःETH-USDT,1547130415509278720.exchange.Sell()ऑर्डर देने के लिए फ़ंक्शन, रिटर्न वैल्यू ऑर्डरIdके अनुरूप हैIdआदेश {@struct/Order Order} संरचना की विशेषता।
स्ट्रिंग, शून्य मान
विनिमय.बिक्री (मूल्य, राशि) विनिमय.बिक्री ((मूल्य, राशि,... args)
..priceपैरामीटर का उपयोग आदेश मूल्य निर्धारित करने के लिए किया जाता है।
मूल्य
सच
संख्या
दamountपैरामीटर का उपयोग आदेश राशि को सेट करने के लिए किया जाता है।
राशि
सच
संख्या
विस्तारित मापदंड जो इस ऑर्डर लॉग के लिए सहायक जानकारी आउटपुट कर सकते हैं,argपैरामीटर एक से अधिक पारित किया जा सकता है।
आर्ग
झूठी
string, number, bool, object, array, null और सिस्टम द्वारा समर्थित कोई अन्य प्रकार
function main(){
var id = exchange.Sell(100, 1)
Log("id:", id)
}
def main():
id = exchange.Sell(100, 1)
Log("id:", id)
void main() {
auto id = exchange.Sell(100, 1);
Log("id:", id);
}
द्वारा लौटाया गया क्रमांकexchange.Sell()आदेश सूचनाओं को क्वेरी करने और आदेशों को रद्द करने के लिए इस्तेमाल किया जा सकता है।
// The following is an error call
function main() {
exchange.SetContractType("quarter")
// Set the shorting direction
exchange.SetDirection("sell")
// If you place a buy order, an error will be reported, and shorting can only be sold
var id = exchange.Buy(50, 1)
// Set the long direction
exchange.SetDirection("buy")
// If you place a sell order, it will report an error, go long, only buy
var id2 = exchange.Sell(60, 1)
// Set direction to close long positions
exchange.SetDirection("closebuy")
// If you place a buy order, it will report an error, close long, only sell
var id3 = exchange.Buy(-1, 1)
// Set direction to close short positions
exchange.SetDirection("closesell")
// If you place a sell order, it will report an error, close short, only buy
var id4 = exchange.Sell(-1, 1)
}
# The following is an error call
def main():
exchange.SetContractType("quarter")
exchange.SetDirection("sell")
id = exchange.Buy(50, 1)
exchange.SetDirection("buy")
id2 = exchange.Sell(60, 1)
exchange.SetDirection("closebuy")
id3 = exchange.Buy(-1, 1)
exchange.SetDirection("closesell")
id4 = exchange.Sell(-1, 1)
// The following is an error call
void main() {
exchange.SetContractType("quarter");
exchange.SetDirection("sell");
auto id = exchange.Buy(50, 1);
exchange.SetDirection("buy");
auto id2 = exchange.Sell(60, 1);
exchange.SetDirection("closebuy");
auto id3 = exchange.Buy(-1, 1);
exchange.SetDirection("closesell");
auto id4 = exchange.Sell(-1, 1);
}
क्रिप्टोक्यूरेंसी वायदा अनुबंध के लिए ऑर्डर देते समय, यह सुनिश्चित करने के लिए सावधानी बरती जानी चाहिए कि ट्रेड दिशा सही ढंग से सेट हो, क्योंकि ट्रेड दिशा और ट्रेड फ़ंक्शन के बीच असंगतता के परिणामस्वरूप त्रुटि होगीः
direction is sell, invalid order type Buy
direction is buy, invalid order type Sell
direction is closebuy, invalid order type Buy
direction is closesell, invalid order type Sell
// For example, the trading pair: ETH_BTC, place a sell order at the market price
function main() {
// Note: place a market order to sell, sell 0.2 ETH
exchange.Sell(-1, 0.2)
}
def main():
exchange.Sell(-1, 0.2)
void main() {
exchange.Sell(-1, 0.2);
}
स्पॉट मार्केट ऑर्डर।
फ्यूचर्स कॉन्ट्रैक्ट के लिए ऑर्डर देते समय, आपको इस बात पर ध्यान देना चाहिए कि क्या ट्रेड दिशा सही ढंग से सेट की गई है, क्योंकि यदि ट्रेड दिशा और ट्रेड फ़ंक्शन मेल नहीं खाते हैं तो त्रुटि की सूचना दी जाएगी। क्रिप्टोक्यूरेंसी फ्यूचर्स कॉन्ट्रैक्ट के लिए ऑर्डर राशि अनुबंधों की संख्या है यदि निर्दिष्ट नहीं है।
पैरामीटरpriceपर सेट है-1बाजार के आदेशों को रखने के लिए, जिसके लिए बाजार के आदेशों का समर्थन करने के लिए एक्सचेंज के ऑर्डर प्लेसमेंट इंटरफ़ेस की आवश्यकता होती है। क्रिप्टोक्यूरेंसी स्पॉट अनुबंधों के लिए बाजार के आदेशों को रखने के लिए, राशि पैरामीटरamountव्यापार मुद्रा में राशि है। क्रिप्टोक्यूरेंसी वायदा अनुबंधों के लिए बाजार आदेश रखने पर, राशि पैरामीटरamountअनुबंधों की संख्या है. कुछ क्रिप्टोक्यूरेंसी एक्सचेंज हैं जो लाइव ट्रेडिंग के दौरान मार्केट ऑर्डर इंटरफ़ेस का समर्थन नहीं करते हैं.
यदि आप डॉकर के पुराने संस्करण का उपयोग कर रहे हैं, आदेश का मूल्य वापसIdकेexchange.Sell()कार्य आदेश के वापसी मूल्य से अलग हो सकता हैIdवर्तमान दस्तावेज में वर्णित है।
{@fun/Trade/exchange.Buy exchange.Buy}, {@fun/Futures/exchange.SetContractType exchange.SetContractType}, {@fun/Futures/exchange.SetDirection exchange.SetDirection}, {@fun/Trade/exchange.Buy exchange.Buy}, {@fun/Futures/exchange.Buy exchange.Buy}, {@fun/Futures/exchange.SetContractType exchange.SetContractType}, {@fun/Futures/exchange.SetDirection exchange.SetDirection}, {@fun/Futures/exchange.SetDirection exchange.SetDirection}, {@fun/Trade/exchange.Buy exchange.Buy}, {@fun/Futures/Futures/exchange.
..exchange.CreateOrder()ऑर्डर देने के लिए फ़ंक्शन का प्रयोग किया जाता है।
यदि आदेश सफलतापूर्वक रखा जाता है, तो आदेश आईडी लौटाया जाता है; यदि आदेश विफल हो जाता है, तो शून्य मान लौटाया जाता है।Idएफएमजेड प्लेटफॉर्म के आदेश {@struct/Order Order} संरचना में एक्सचेंज उत्पाद कोड और एक्सचेंज मूल आदेश आईडी शामिल है, जिन्हें अंग्रेजी अल्पविराम से अलग किया गया है। उदाहरण के लिए, विशेषताIdस्पॉट ट्रेडिंग जोड़ी के ऑर्डर का प्रारूपETH_USDTओकेएक्स एक्सचेंज का मूल्य हैःETH-USDT,1547130415509278720.exchange.CreateOrder(symbol, side, price, amount)ऑर्डर देने के लिए फ़ंक्शन, ऑर्डर का रिटर्न मानIdके अनुरूप हैIdआदेश {@struct/Order Order} संरचना की संपत्ति।
स्ट्रिंग, शून्य मान
exchange.CreateOrder ((प्रतीक, पक्ष, मूल्य, राशि) exchange.CreateOrder ((प्रतीक, पक्ष, मूल्य, राशि,... args)
पैरामीटरsymbolआदेश के विशिष्ट व्यापारिक जोड़े और अनुबंध कोड को निर्दिष्ट करने के लिए प्रयोग किया जाता है।exchange.CreateOrder(symbol, side, price, amount)ऑर्डर देने की कार्यक्षमता,exchangeस्पॉट एक्सचेंज ऑब्जेक्ट है। यदि ऑर्डर की मुद्रा USDT है और ट्रेडिंग मुद्रा BTC है, तो पैरामीटरsymbolहै:"BTC_USDT", एफएमजेड प्लेटफॉर्म द्वारा परिभाषित ट्रेडिंग जोड़ी के प्रारूप में।exchange.CreateOrder(symbol, side, price, amount)ऑर्डर देने की कार्यक्षमता,exchangeवायदा विनिमय वस्तु है। यदि आदेश एक BTCsymbolहै:"BTC_USDT.swap", और प्रारूपव्यापारिक जोड़ीऔरअनुबंध कोडFMZ प्लेटफॉर्म द्वारा परिभाषित, वर्ण द्वारा अलग exchange.CreateOrder(symbol, side, price, amount)ऑर्डर देने की कार्यक्षमता,exchangeफ्यूचर्स एक्सचेंज ऑब्जेक्ट है। यदि ऑर्डर BTCsymbolहै:"BTC_USDT.BTC-240108-40000-C"(उदाहरण के लिए बिनेंस विकल्प BTC-240108-40000-C लेते हुए), और प्रारूपव्यापारिक जोड़ीएफएमजेड प्लेटफॉर्म द्वारा परिभाषित और एक्सचेंज द्वारा परिभाषित विशिष्ट विकल्प अनुबंध कोड, जो वर्ण sideपैरामीटर का प्रयोग आदेश की ट्रेडिंग दिशा निर्दिष्ट करने के लिए किया जाता है।
स्पॉट एक्सचेंज ऑब्जेक्ट्स के लिए, वैकल्पिक मानsideपैरामीटर हैंःbuy, sell. buyखरीदना है, औरsellबेचने का मतलब है।
वायदा विनिमय वस्तुओं के लिए, वैकल्पिक मूल्यsideपैरामीटर हैंःbuy, closebuy, sell, closesell. buyएक लंबी स्थिति खोलने का अर्थ है,closebuyएक लंबी स्थिति को बंद करने का अर्थ है,sellशॉर्ट पोजीशन खोलना, औरclosesellमतलब शॉर्ट पोजीशन बंद करना।
पक्ष
सच
स्ट्रिंग
पैरामीटरpriceआदेश की कीमत निर्धारित करने के लिए प्रयोग किया जाता है। -1 की कीमत इंगित करती है कि आदेश एक बाजार आदेश है।
मूल्य
सच
संख्या
पैरामीटरamountआदेश मात्रा निर्धारित करने के लिए प्रयोग किया जाता है। कृपया ध्यान दें कि जब आदेश एक बाजार खरीद आदेश है, आदेश मात्रा खरीद राशि है; कुछ स्पॉट एक्सचेंजों के बाजार खरीद आदेश के आदेश मात्रा व्यापार सिक्कों की संख्या है। विवरण के लिए, कृपया देखेंआदान-प्रदान के लिए विशेष निर्देशargमापदंडों को पारित किया जा सकता है।
आर्ग
झूठी
सिस्टम द्वारा समर्थित कोई भी प्रकार, जैसे स्ट्रिंग, संख्या, बूल, ऑब्जेक्ट, सरणी, शून्य मान आदि।
function main() {
var id = exchange.CreateOrder("BTC_USDT", "buy", 60000, 0.01) // Spot exchange objects place orders for currency-to-currency transactions BTC_USDT trading pairs
// var id = exchange.CreateOrder("BTC_USDT.swap", "buy", 60000, 0.01) // Futures exchange objects place orders for BTC's U-standard perpetual contracts
Log("Order Id:", id)
}
def main():
id = exchange.CreateOrder("BTC_USDT", "buy", 60000, 0.01) # Spot exchange objects place orders for currency-to-currency transactions BTC_USDT trading pairs
# id = exchange.CreateOrder("BTC_USDT.swap", "buy", 60000, 0.01) # Futures exchange objects place orders for BTC's U-standard perpetual contracts
Log("Order Id:", id)
void main() {
auto id = exchange.CreateOrder("BTC_USDT", "buy", 60000, 0.01); // Spot exchange objects place orders for currency-to-currency transactions BTC_USDT trading pairs
// auto id = exchange.CreateOrder("BTC_USDT.swap", "buy", 60000, 0.01); // Futures exchange objects place orders for BTC's U-standard perpetual contracts
Log("Order Id:", id);
}
स्पॉट एक्सचेंज ऑब्जेक्ट्स और फ्यूचर्स एक्सचेंज ऑब्जेक्ट्स कोexchange.CreateOrder()आदेश देने के लिए कार्य।
{@fun/Trade/exchange.Buy exchange.Buy}, {@fun/Trade/exchange.Sell exchange.Sell}
..exchange.CancelOrder()ऑर्डर रद्द करने के लिए फ़ंक्शन का प्रयोग किया जाता है.
विशेषताIdएफएमजेड प्लेटफॉर्म के आदेश {@struct/Order Order} संरचना में एक्सचेंज उत्पाद कोड और एक्सचेंज मूल आदेश आईडी शामिल है, जिन्हें अंग्रेजी अल्पविराम से अलग किया गया है। उदाहरण के लिए, विशेषताIdस्पॉट ट्रेडिंग जोड़ी के ऑर्डर का प्रारूपETH_USDTओकेएक्स एक्सचेंज का मूल्य हैःETH-USDT,1547130415509278720.
पैरामीटरorderIdमें पारित किया जब कॉलexchange.CancelOrder()एक आदेश रद्द करने के लिए समारोह के साथ संगत हैIdआदेश {@struct/Order Order} संरचना की संपत्ति।
..exchange.CancelOrder()फ़ंक्शन एक सही मान देता है, उदाहरण के लिएtrueका मतलब है कि रद्द आदेश अनुरोध सफलतापूर्वक भेजा गया था. यदि यह एक गलत मान देता है, जैसे किfalse, का मतलब है कि रद्द आदेश अनुरोध भेजने में विफल रहा है। रिटर्न मान केवल यह निर्धारित करने के लिए भेजा अनुरोध की सफलता या विफलता का प्रतिनिधित्व करता है कि क्या एक्सचेंज आदेश रद्द करता है। आप कॉल कर सकते हैंexchange.GetOrders()यह निर्धारित करने के लिए कि आदेश रद्द किया गया है या नहीं।
बोल
विनिमय.ऑर्डर रद्द करें (ऑर्डर आईडी) विनिमय.ऑर्डर रद्द करें (ऑर्डर आईडी,... args)
..orderIdपैरामीटर का प्रयोग रद्द किए जाने वाले आदेश को निर्दिष्ट करने के लिए किया जाता है।
आदेशित
सच
संख्या, स्ट्रिंग
विस्तारित पैरामीटर, आप इस निकासी लॉग के लिए संलग्न जानकारी आउटपुट कर सकते हैं,argपैरामीटर एक से अधिक पारित किया जा सकता है।
आर्ग
झूठी
string, number, bool, object, array, null और सिस्टम द्वारा समर्थित कोई अन्य प्रकार
function main(){
var id = exchange.Sell(99999, 1)
exchange.CancelOrder(id)
}
def main():
id = exchange.Sell(99999, 1)
exchange.CancelOrder(id)
void main() {
auto id = exchange.Sell(99999, 1);
exchange.CancelOrder(id);
}
आदेश रद्द करो।
function main() {
if (exchange.GetName().includes("Futures_")) {
Log("Set the contract as: perpetual contract, set the trade direction as: open long position.")
exchange.SetContractType("swap")
exchange.SetDirection("buy")
}
var ticker = exchange.GetTicker()
exchange.Buy(ticker.Last * 0.5, 0.1)
var orders = exchange.GetOrders()
for (var i = 0 ; i < orders.length ; i++) {
exchange.CancelOrder(orders[i].Id, "Cancelled orders:", orders[i])
Sleep(500)
}
}
def main():
if exchange.GetName().find("Futures_") != -1:
Log("Set the contract as: perpetual contract, set the trade direction as: open long position.")
exchange.SetContractType("swap")
exchange.SetDirection("buy")
ticker = exchange.GetTicker()
exchange.Buy(ticker["Last"] * 0.5, 0.1)
orders = exchange.GetOrders()
for i in range(len(orders)):
exchange.CancelOrder(orders[i]["Id"], "Cancelled orders:", orders[i])
Sleep(500)
void main() {
if (exchange.GetName().find("Futures_") != std::string::npos) {
Log("Set the contract as: perpetual contract, set the trade direction as: open long position.");
exchange.SetContractType("swap");
exchange.SetDirection("buy");
}
auto ticker = exchange.GetTicker();
exchange.Buy(ticker.Last * 0.5, 0.1);
auto orders = exchange.GetOrders();
for (int i = 0 ; i < orders.size() ; i++) {
exchange.CancelOrder(orders[i].Id, "Cancelled orders:", orders[i]);
Sleep(500);
}
}
एफएमजेड एपीआई फ़ंक्शन जो लॉग आउटपुट फ़ंक्शन जैसेःLog(), exchange.Buy(), exchange.CancelOrder()आवश्यक मापदंडों के बाद कुछ सहायक आउटपुट मापदंडों का अनुसरण किया जा सकता है। उदाहरण के लिएःexchange.CancelOrder(orders[i].Id, orders[i]), ताकि आदेश रद्द करते समय जिसका आईडी हैorders[i].Id, आदेश की जानकारी इसके साथ आउटपुट की जाती है।orders[i].
यदि आप डॉकर के पुराने संस्करण का उपयोग कर रहे हैं, तो exchange.CancelOrder() फ़ंक्शन का orderId पैरामीटर वर्तमान दस्तावेज़ में वर्णित orderId से भिन्न हो सकता है.
{@fun/Trade/exchange.Buy exchange.Buy}, {@fun/Trade/exchange.Sell exchange.Sell}, {@fun/Trade/exchange.GetOrders exchange.GetOrders}, {@fun/Trade/exchange.GetOrders exchange.GetOrders}, {@fun/Trade/exchange.GetOrders exchange.GetOrders}, {@fun/Trade/exchange.GetOrders exchange.GetOrders}, {@fun/Trade/exchange.GetOrders exchange.GetOrders}, {@fun/Trade/exchange.GetOrders exchange.GetOrders}, {@fun/Trade/exchange.GetOrders exchange.GetOrders}, {@fun/Trade/exchange.GetOrders exchange.GetOrders}, {@fun/Trade/exchange.
..exchange.GetOrder()आदेश की जानकारी प्राप्त करने के लिए फ़ंक्शन का उपयोग किया जाता है.
आदेश संख्या के अनुसार आदेश विवरण की क्वेरी करें, और यदि क्वेरी सफल होती है तो {@struct/Order Order} संरचना लौटाएं, या यदि क्वेरी विफल होती है तो शून्य लौटाएं. {@struct/Order Order}, शून्य मान
विनिमय.GetOrder ((orderId)
..orderIdपैरामीटर का उपयोग क्वेरी करने के क्रम को निर्दिष्ट करने के लिए किया जाता है.
विशेषताIdएफएमजेड प्लेटफॉर्म के आदेश {@struct/Order Order} संरचना में एक्सचेंज उत्पाद कोड और एक्सचेंज मूल आदेश आईडी शामिल है, जिन्हें अंग्रेजी अल्पविराम से अलग किया गया है। उदाहरण के लिए, विशेषताIdस्पॉट ट्रेडिंग जोड़ी के ऑर्डर का प्रारूपETH_USDTओकेएक्स एक्सचेंज का मूल्य हैःETH-USDT,1547130415509278720.
पैरामीटरorderIdमें पारित किया जब कॉलexchange.GetOrder()एक आदेश की क्वेरी करने के लिए समारोह के साथ संगत हैIdआदेश {@struct/Order Order} संरचना की संपत्ति।
आदेशित सच स्ट्रिंग
function main(){
var id = exchange.Sell(1000, 1)
// Parameter id is the order number, you need to fill in the number of the order you want to query
var order = exchange.GetOrder(id)
Log("Id:", order.Id, "Price:", order.Price, "Amount:", order.Amount, "DealAmount:",
order.DealAmount, "Status:", order.Status, "Type:", order.Type)
}
def main():
id = exchange.Sell(1000, 1)
order = exchange.GetOrder(id)
Log("Id:", order["Id"], "Price:", order["Price"], "Amount:", order["Amount"], "DealAmount:",
order["DealAmount"], "Status:", order["Status"], "Type:", order["Type"])
void main() {
auto id = exchange.Sell(1000, 1);
auto order = exchange.GetOrder(id);
Log("Id:", order.Id, "Price:", order.Price, "Amount:", order.Amount, "DealAmount:",
order.DealAmount, "Status:", order.Status, "Type:", order.Type);
}
..exchange.GetOrder()कार्य कुछ एक्सचेंजों द्वारा समर्थित नहीं है।AvgPrice{@struct/Order Order} संरचना में रिटर्न मान की विशेषता लेनदेन की औसत कीमत है। कुछ एक्सचेंजों इस क्षेत्र का समर्थन नहीं करते हैं, और यदि वे नहीं करते हैं, तो यह 0 पर सेट है।
यदि आप डॉकर के पुराने संस्करण का उपयोग कर रहे हैं, तोorderIdपैरामीटरexchange.GetOrder()कार्य से भिन्न हो सकता हैorderIdवर्तमान प्रलेखन में वर्णित है।
एक्सचेंजों जो समर्थन नहीं करते हैंexchange.GetOrder()कार्य:
| फ़ंक्शन का नाम | असमर्थित स्पॉट एक्सचेंज | बिना समर्थन वाले फ्यूचर्स एक्सचेंज |
|---|---|---|
| प्राप्त करेंआदेश | Zaif/Coincheck/बिटस्टैम्प | – |
{@struct/Order Order}, {@fun/Trade/exchange.GetOrders exchange.GetOrders}, {@fun/Trade/exchange.GetHistoryOrders exchange.GetHistoryOrders}, {@struct/Trade/Order Order}, {@fun/Trade/exchange.GetOrders exchange.GetHistoryOrders}, {@fun/Trade/exchange.GetOrders exchange.GetOrders}, {@fun/Trade/exchange.GetHistoryOrders exchange.GetHistoryOrders}, {@fun/Trade/exchange.GetHistoryOrders exchange.GetHistoryOrders}, {@fun/Trade/exchange.GetHistoryOrders exchange.GetHistoryOrders}, {@fun/Trade/Exchange.GetOrders exchange.GetOrders exchange.GetOrders}, {@fun/Trade/exchange.GetOrders exchange.GetOrders exchange.GetOrders exchange.GetOrders}, {@fun/Trade/Trade/exchange
..exchange.GetOrders()कार्य का उपयोग बकाया आदेश प्राप्त करने के लिए किया जाता है।
..exchange.GetOrders()function {@struct/Order Order} संरचनाओं की एक सरणी लौटाता है यदि डेटा के लिए अनुरोध सफल होता है, और यदि डेटा के लिए अनुरोध विफल होता है तो यह शून्य मान लौटाता है.
{@struct/Order Order} सरणी, शून्य मान
विनिमय.GetOrders ((() विनिमय.GetOrders ((प्रतीक)
पैरामीटरsymbolसेट करने के लिए प्रयोग किया जाता हैलेनदेन चिह्नयालेन-देन प्रतीक श्रेणीपूछताछ की जाए।
स्पॉट एक्सचेंज ऑब्जेक्ट्स के लिए, यदिsymbolपैरामीटर पारित नहीं किया जाता है, सभी स्पॉट उत्पादों के अधूरे आदेश डेटा का अनुरोध किया जाएगा।
वायदा विनिमय वस्तुओं के लिए, यदिsymbolपैरामीटर पारित नहीं किया जाता है, डिफ़ॉल्ट रूप से वर्तमान ट्रेडिंग जोड़ी और अनुबंध कोड के आयाम सीमा में सभी किस्मों के अधूरे आदेश डेटा का अनुरोध करना है।
चिह्न झूठी स्ट्रिंग
/*backtest
start: 2024-05-21 00:00:00
end: 2024-09-05 00:00:00
period: 5m
basePeriod: 1m
exchanges: [{"eid":"Binance","currency":"BTC_USDT"}]
*/
function main() {
var arrSymbol = ["ETH_USDT", "BTC_USDT", "LTC_USDT", "SOL_USDT"]
for (var symbol of arrSymbol) {
var t = exchange.GetTicker(symbol)
exchange.CreateOrder(symbol, "buy", t.Last / 2, 0.01)
}
var spotOrders = exchange.GetOrders()
var tbls = []
for (var orders of [spotOrders]) {
var tbl = {type: "table", title: "test GetOrders", cols: ["Symbol", "Id", "Price", "Amount", "DealAmount", "AvgPrice", "Status", "Type", "Offset", "ContractType"], rows: []}
for (var order of orders) {
tbl.rows.push([order.Symbol, order.Id, order.Price, order.Amount, order.DealAmount, order.AvgPrice, order.Status, order.Type, order.Offset, order.ContractType])
}
tbls.push(tbl)
}
LogStatus("`" + JSON.stringify(tbls) + "`")
// Print out the information once and then return to prevent the order from being executed during the subsequent backtest and affecting data observation
return
}
'''backtest
start: 2024-05-21 00:00:00
end: 2024-09-05 00:00:00
period: 5m
basePeriod: 1m
exchanges: [{"eid":"Binance","currency":"BTC_USDT"}]
'''
import json
def main():
arrSymbol = ["ETH_USDT", "BTC_USDT", "LTC_USDT", "SOL_USDT"]
for symbol in arrSymbol:
t = exchange.GetTicker(symbol)
exchange.CreateOrder(symbol, "buy", t["Last"] / 2, 0.01)
spotOrders = exchange.GetOrders()
tbls = []
for orders in [spotOrders]:
tbl = {"type": "table", "title": "test GetOrders", "cols": ["Symbol", "Id", "Price", "Amount", "DealAmount", "AvgPrice", "Status", "Type", "Offset", "ContractType"], "rows": []}
for order in orders:
tbl["rows"].append([order.Symbol, order.Id, order.Price, order.Amount, order.DealAmount, order.AvgPrice, order.Status, order.Type, order.Offset, order.ContractType])
tbls.append(tbl)
LogStatus("`" + json.dumps(tbls) + "`")
return
/*backtest
start: 2024-05-21 00:00:00
end: 2024-09-05 00:00:00
period: 5m
basePeriod: 1m
exchanges: [{"eid":"Binance","currency":"BTC_USDT"}]
*/
void main() {
auto arrSymbol = {"ETH_USDT", "BTC_USDT", "LTC_USDT", "SOL_USDT"};
for (const auto& symbol : arrSymbol) {
auto t = exchange.GetTicker(symbol);
exchange.CreateOrder(symbol, "buy", t.Last / 2, 0.01);
}
auto spotOrders = exchange.GetOrders();
json tbls = R"([])"_json;
std::vector<std::vector<Order>> arr = {spotOrders};
for (const auto& orders : arr) {
json tbl = R"({
"type": "table",
"title": "test GetOrders",
"cols": ["Symbol", "Id", "Price", "Amount", "DealAmount", "AvgPrice", "Status", "Type", "Offset", "ContractType"],
"rows": []
})"_json;
for (const auto& order : orders) {
json arrJson = R"([])"_json;
arrJson.push_back("Symbol");
arrJson.push_back("Id");
arrJson.push_back(order.Price);
arrJson.push_back(order.Amount);
arrJson.push_back(order.DealAmount);
arrJson.push_back(order.AvgPrice);
arrJson.push_back(order.Status);
arrJson.push_back(order.Type);
arrJson.push_back(order.Offset);
arrJson.push_back(order.ContractType);
tbl["rows"].push_back(arrJson);
}
tbls.push_back(tbl);
}
LogStatus(_D(), "\n", "`" + tbls.dump() + "`");
return;
}
स्पॉट एक्सचेंज ऑब्जेक्ट का उपयोग करें वर्तमान मूल्य के आधे मूल्य पर कई अलग-अलग ट्रेडिंग जोड़े के लिए खरीद ऑर्डर रखने के लिए, और फिर बकाया ऑर्डर जानकारी की क्वेरी करें।
/*backtest
start: 2024-05-21 00:00:00
end: 2024-09-05 00:00:00
period: 5m
basePeriod: 1m
exchanges: [{"eid":"Futures_Binance","currency":"BTC_USDT"}]
*/
function main() {
var arrSymbol = ["BTC_USDT.swap", "BTC_USDT.quarter", "ETH_USDT.swap", "ETH_USDT.quarter"]
for (var symbol of arrSymbol) {
var t = exchange.GetTicker(symbol)
exchange.CreateOrder(symbol, "buy", t.Last / 2, 1)
exchange.CreateOrder(symbol, "sell", t.Last * 2, 1)
}
var defaultOrders = exchange.GetOrders()
var swapOrders = exchange.GetOrders("USDT.swap")
var futuresOrders = exchange.GetOrders("USDT.futures")
var btcUsdtSwapOrders = exchange.GetOrders("BTC_USDT.swap")
var tbls = []
var arr = [defaultOrders, swapOrders, futuresOrders, btcUsdtSwapOrders]
var tblDesc = ["defaultOrders", "swapOrders", "futuresOrders", "btcUsdtSwapOrders"]
for (var index in arr) {
var orders = arr[index]
var tbl = {type: "table", title: tblDesc[index], cols: ["Symbol", "Id", "Price", "Amount", "DealAmount", "AvgPrice", "Status", "Type", "Offset", "ContractType"], rows: []}
for (var order of orders) {
tbl.rows.push([order.Symbol, order.Id, order.Price, order.Amount, order.DealAmount, order.AvgPrice, order.Status, order.Type, order.Offset, order.ContractType])
}
tbls.push(tbl)
}
LogStatus("`" + JSON.stringify(tbls) + "`")
// Print out the information once and then return to prevent the order from being executed during the subsequent backtest and affecting data observation
return
}
'''backtest
start: 2024-05-21 00:00:00
end: 2024-09-05 00:00:00
period: 5m
basePeriod: 1m
exchanges: [{"eid":"Futures_Binance","currency":"BTC_USDT"}]
'''
import json
def main():
arrSymbol = ["BTC_USDT.swap", "BTC_USDT.quarter", "ETH_USDT.swap", "ETH_USDT.quarter"]
for symbol in arrSymbol:
t = exchange.GetTicker(symbol)
exchange.CreateOrder(symbol, "buy", t["Last"] / 2, 1)
exchange.CreateOrder(symbol, "sell", t["Last"] * 2, 1)
defaultOrders = exchange.GetOrders()
swapOrders = exchange.GetOrders("USDT.swap")
futuresOrders = exchange.GetOrders("USDT.futures")
btcUsdtSwapOrders = exchange.GetOrders("BTC_USDT.swap")
tbls = []
arr = [defaultOrders, swapOrders, futuresOrders, btcUsdtSwapOrders]
tblDesc = ["defaultOrders", "swapOrders", "futuresOrders", "btcUsdtSwapOrders"]
for index in range(len(arr)):
orders = arr[index]
tbl = {"type": "table", "title": tblDesc[index], "cols": ["Symbol", "Id", "Price", "Amount", "DealAmount", "AvgPrice", "Status", "Type", "Offset", "ContractType"], "rows": []}
for order in orders:
tbl["rows"].append([order["Symbol"], order["Id"], order["Price"], order["Amount"], order["DealAmount"], order["AvgPrice"], order["Status"], order["Type"], order["Offset"], order["ContractType"]])
tbls.append(tbl)
LogStatus("`" + json.dumps(tbls) + "`")
return
/*backtest
start: 2024-05-21 00:00:00
end: 2024-09-05 00:00:00
period: 5m
basePeriod: 1m
exchanges: [{"eid":"Futures_Binance","currency":"BTC_USDT"}]
*/
void main() {
auto arrSymbol = {"BTC_USDT.swap", "BTC_USDT.quarter", "ETH_USDT.swap", "ETH_USDT.quarter"};
for (const auto& symbol : arrSymbol) {
auto t = exchange.GetTicker(symbol);
exchange.CreateOrder(symbol, "buy", t.Last / 2, 1);
exchange.CreateOrder(symbol, "sell", t.Last * 2, 1);
}
auto defaultOrders = exchange.GetOrders();
auto swapOrders = exchange.GetOrders("USDT.swap");
auto futuresOrders = exchange.GetOrders("USDT.futures");
auto btcUsdtSwapOrders = exchange.GetOrders("BTC_USDT.swap");
json tbls = R"([])"_json;
std::vector<std::vector<Order>> arr = {defaultOrders, swapOrders, futuresOrders, btcUsdtSwapOrders};
std::string tblDesc[] = {"defaultOrders", "swapOrders", "futuresOrders", "btcUsdtSwapOrders"};
for (int index = 0; index < arr.size(); index++) {
auto orders = arr[index];
json tbl = R"({
"type": "table",
"cols": ["Symbol", "Id", "Price", "Amount", "DealAmount", "AvgPrice", "Status", "Type", "Offset", "ContractType"],
"rows": []
})"_json;
tbl["title"] = tblDesc[index];
for (const auto& order : orders) {
json arrJson = R"([])"_json;
arrJson.push_back(order.Symbol);
arrJson.push_back(to_string(order.Id)); // The Id attribute type in the Order structure is TId, which is encoded using a C++ function to_string built into the FMZ platform.
arrJson.push_back(order.Price);
arrJson.push_back(order.Amount);
arrJson.push_back(order.DealAmount);
arrJson.push_back(order.AvgPrice);
arrJson.push_back(order.Status);
arrJson.push_back(order.Type);
arrJson.push_back(order.Offset);
arrJson.push_back(order.ContractType);
tbl["rows"].push_back(arrJson);
}
tbls.push_back(tbl);
}
LogStatus(_D(), "\n", "`" + tbls.dump() + "`");
return;
}
कई अलग-अलग ट्रेडिंग जोड़े और अनुबंध कोडों के लिए ऑर्डर देने के लिए वायदा विनिमय वस्तुओं का उपयोग करें। प्रतिपक्ष मूल्य से दूर की कीमतों पर ऑर्डर दें, एक अपूर्ण स्थिति में ऑर्डर रखें, और कई तरीकों से क्वेरी ऑर्डर करें।
function main() {
var orders = exchange.GetOrders("BTC_USDT") // Examples of spot products
// var orders = exchange.GetOrders("BTC_USDT.swap") // Examples of futures products
Log("orders:", orders)
}
def main():
orders = exchange.GetOrders("BTC_USDT") # Examples of spot products
# orders = exchange.GetOrders("BTC_USDT.swap") # Examples of futures products
Log("orders:", orders)
void main() {
auto orders = exchange.GetOrders("BTC_USDT"); // Examples of spot products
// auto orders = exchange.GetOrders("BTC_USDT.swap"); // Examples of futures products
Log("orders:", orders);
}
जब कॉलexchange.GetOrders()कार्य, में पारितSymbolएक विशिष्ट ट्रेडिंग जोड़ी और अनुबंध कोड के लिए ऑर्डर डेटा का अनुरोध करने के लिए पैरामीटर।
मेंGetOrdersफंक्शन, प्रतीक पैरामीटर के उपयोग के परिदृश्यों को इस प्रकार संक्षेप में प्रस्तुत किया गया हैः
| एक्सचेंज ऑब्जेक्ट वर्गीकरण | प्रतीक पैरामीटर | क्वेरी का दायरा | टिप्पणियाँ |
|---|---|---|---|
| स्पॉट | प्रतीक पैरामीटर पास न करें | सभी स्पॉट ट्रेडिंग जोड़े की क्वेरी करें | सभी कॉल परिदृश्यों के लिए, यदि एक्सचेंज इंटरफ़ेस इसका समर्थन नहीं करता है, तो एक त्रुटि की सूचना दी जाएगी और एक शून्य मान लौटाया जाएगा। कोई और स्पष्टीकरण नहीं दिया जाएगा। |
| स्पॉट | व्यापार प्रकार निर्दिष्ट करें, प्रतीक पैरामीटर हैः |
निर्दिष्ट BTC_USDT ट्रेडिंग जोड़ी की क्वेरी करें | स्पॉट एक्सचेंज ऑब्जेक्ट्स के लिए प्रतीक पैरामीटर प्रारूप हैः |
| वायदा | प्रतीक पैरामीटर पास न करें | वर्तमान ट्रेडिंग जोड़ी और अनुबंध कोड आयाम सीमा के भीतर सभी ट्रेडिंग उत्पादों को क्वेरी करें | यदि वर्तमान ट्रेडिंग जोड़ी BTC_USDT है और अनुबंध कोड स्वैप है, तो सभी USDT-मार्जिन वाले स्थायी अनुबंधों को क्वेरी किया जाएगा। यह कॉल करने के बराबर हैGetOrders("USDT.swap") |
| वायदा | व्यापार प्रकार निर्दिष्ट करें, प्रतीक पैरामीटर हैः |
एक निर्दिष्ट बीटीसी के लिए यूएसडीटी आधारित स्थायी अनुबंध की क्वेरी करें | वायदा विनिमय वस्तुओं के लिए पैरामीटर प्रतीक प्रारूप हैःव्यापारिक जोड़ीऔरअनुबंध कोडएफएमजेड प्लेटफॉर्म द्वारा परिभाषित, अक्षरों से अलग".. |
| वायदा | ट्रेडिंग उत्पादों की श्रेणी निर्दिष्ट करें, प्रतीक पैरामीटर हैः |
सभी USDT आधारित स्थायी अनुबंधों की क्वेरी करें | - |
| विकल्पों का समर्थन करने वाले फ्यूचर्स एक्सचेंज | प्रतीक पैरामीटर पास न करें | वर्तमान ट्रेडिंग जोड़ी आयाम सीमा के भीतर सभी विकल्प अनुबंध पूछताछ करें | यदि वर्तमान ट्रेडिंग जोड़ी BTC_USDT है, तो अनुबंध एक विकल्प अनुबंध पर सेट किया जाता है, उदाहरण के लिए, Binance विकल्प अनुबंधः BTC-240108-40000-C |
| विकल्पों का समर्थन करने वाले फ्यूचर्स एक्सचेंज | विशिष्ट व्यापारिक उत्पाद निर्दिष्ट करें | निर्दिष्ट विकल्प अनुबंध की क्वेरी करें | उदाहरण के लिए Binance Futures Exchange के लिए, प्रतीक पैरामीटर हैः BTC_USDT.BTC-240108-40000-C |
| विकल्पों का समर्थन करने वाले फ्यूचर्स एक्सचेंज | ट्रेडिंग उत्पादों की श्रेणी निर्दिष्ट करें, प्रतीक पैरामीटर हैः |
सभी USDT आधारित विकल्प अनुबंधों की खोज करें | - |
मेंGetOrdersफ्यूचर्स एक्सचेंज ऑब्जेक्ट क्वेरी
आयाम सीमा का सार इस प्रकार हैः
| प्रतीक पैरामीटर | अनुरोध सीमा परिभाषा | टिप्पणियाँ |
|---|---|---|
| USDT.swap | यूएसडीटी आधारित स्थायी अनुबंध सीमा। | के लिए |
आयाम जो एक्सचेंज एपीआई इंटरफ़ेस द्वारा समर्थित नहीं हैं, एक त्रुटि की सूचना दी जाएगी और शून्य मान लौटाया जाएगा जब बुला रहा है. ∙ ∙ USDT.futures ∙ ∙ USDT आधारित वितरण अनुबंध रेंज ∙ ∙ ∙ ∙ USD.swap ∙ मुद्रा आधारित स्थायी की सीमा अनुबंध। ∙ ∙ USD.futures ∙ मुद्रा आधारित वितरण की सीमा अनुबंध। ∙ ∙ USDT.option ∙ ∙ ∙ USDT आधारित विकल्प अनुबंध रेंज ∙ ∙ ∙ ∙ ∙ USD.option ∙ मुद्रा आधारित विकल्प अनुबंध रेंज ∙ USDT.futures_combo CFD संयोजनों की एक श्रृंखला। फ्यूचर्स_डेरिबिट एक्सचेंज USD.futures_ff मिश्रित मार्जिन वितरण अनुबंधों की एक श्रृंखला। फ्यूचर्स_क्रैकेन एक्सचेंज USD.swap_pf. मिश्रित मार्जिन स्थायी अनुबंधों की एक श्रृंखला। ∙∙ फ्यूचर्स_क्रैकेन एक्सचेंज
जब विनिमय वस्तु द्वारा दर्शाया गया खाताexchangeके भीतर कोई लंबित आदेश नहीं हैक्वेरी सीमायाविनिर्दिष्ट व्यापारिक साधन(अपूर्ति न हुई स्थिति में सक्रिय आदेश), इस फ़ंक्शन को कॉल करने से खाली सरणी लौटती है, अर्थातः[].
निम्नलिखित एक्सचेंजों को वर्तमान में अधूरे आदेशों की क्वेरी करते समय उपकरण को उपकरण पैरामीटर में पास करने की आवश्यकता होती है। इन एक्सचेंजों के साथ GetOrders फ़ंक्शन को कॉल करते समय, यदि उपकरण पैरामीटर पास नहीं किया जाता है, तो केवल वर्तमान उपकरण के अधूरे आदेशों का अनुरोध किया जाता है, सभी उपकरणों के अधूरे आदेशों का नहीं (क्योंकि एक्सचेंज इंटरफ़ेस इसका समर्थन नहीं करता है) ।
Zaif, MEXC, LBank, Korbit, Coinw, BitMart, Bithumb, BitFlyer, BigONE
एक्सचेंजों जो समर्थन नहीं करते हैंexchange.GetOrders()कार्य:
| फ़ंक्शन का नाम | असमर्थित स्पॉट एक्सचेंज | बिना समर्थन वाले फ्यूचर्स एक्सचेंज |
|---|---|---|
| GetOrders प्राप्त करें | – | वायदा_बिबॉक्स |
{@struct/Order Order}, {@fun/Trade/exchange.GetOrder exchange.GetOrder}, {@fun/Trade/exchange.GetHistoryOrders exchange.GetHistoryOrders}, {@struct/Trade/Order Order}, {@fun/Trade/exchange.GetOrder exchange.GetOrder}, {@fun/Trade/exchange.GetHistoryOrders exchange.GetHistoryOrders}, {@fun/Trade/exchange.GetOrder exchange.GetOrder}, {@fun/Trade/exchange.GetHistoryOrders exchange.GetHistoryOrders}, {@fun/Trade/exchange.GetOrder exchange.GetOrder exchange.GetOrder}, {@fun/Trade/exchange.GetHistoryOrders exchange.GetHistoryOrders}, {@fun/Trade/exchange.GetOrder exchange.GetOrder exchange.GetOrder exchange.GetOrder}, {@fun/Trade/exchange.GetHistoryOr
..exchange.GetHistoryOrders()वर्तमान व्यापारिक जोड़ी, अनुबंधों के लिए ऐतिहासिक आदेश प्राप्त करने के लिए कार्य का उपयोग किया जाता है; यह विशिष्ट व्यापारिक किस्मों के विनिर्देश का समर्थन करता है।
..exchange.GetHistoryOrders()function {@struct/Order Order} संरचनाओं की एक सरणी लौटाता है यदि डेटा के लिए अनुरोध सफल होता है, और शून्य यदि अनुरोध विफल होता है.
{@struct/Order Order} सरणी, शून्य मान
विनिमय.GetHistoryOrders() exchange.GetHistoryOrders (प्रतीक) exchange.GetHistoryOrders ((प्रतीक, के बाद से) exchange.GetHistoryOrders ((प्रतीक, के बाद से, सीमा) विनिमय.GetHistoryOrders ((के बाद से) exchange.GetHistoryOrders ((जबसे, सीमा)
..symbolपैरामीटर का उपयोग व्यापार चिह्न को निर्दिष्ट करने के लिए किया जाता है।BTC_USDTव्यापारिक जोड़ी, उदाहरण के लिए, जबexchangeएक स्पॉट एक्सचेंज ऑब्जेक्ट है, पैरामीटर प्रारूप के लिएsymbolहैBTC_USDTयदि यह एक वायदा विनिमय वस्तु है, उदाहरण के लिए स्थायी अनुबंध लेते हुए, पैरामीटर प्रारूप के लिएsymbolहै:BTC_USDT.swap.
यदि आप विकल्प अनुबंधों के आदेश डेटा पूछ रहे हैं, पैरामीटर सेट करेंsymbolतक"BTC_USDT.BTC-240108-40000-C"(उदाहरण के लिए बिनेंस विकल्प BTC-240108-40000-C लेते हुए) प्रारूपव्यापारिक जोड़ीएफएमजेड प्लेटफॉर्म द्वारा परिभाषित और एक्सचेंज द्वारा परिभाषित विशिष्ट विकल्प अनुबंध कोड, जो वर्ण
चिह्न
झूठी
स्ट्रिंग
दsinceपैरामीटर का उपयोग मिलीसेकंड में क्वेरी के प्रारंभ समयस्टैम्प को निर्दिष्ट करने के लिए किया जाता है.
के बाद से
झूठी
संख्या
दlimitपैरामीटर का उपयोग क्वेरी करने के आदेशों की संख्या निर्दिष्ट करने के लिए किया जाता है.
सीमा
झूठी
संख्या
function main() {
var historyOrders = exchange.GetHistoryOrders()
Log(historyOrders)
}
def main():
historyOrders = exchange.GetHistoryOrders()
Log(historyOrders)
void main() {
auto historyOrders = exchange.GetHistoryOrders();
Log(historyOrders);
}
symbol, since, limitपैरामीटर निर्दिष्ट नहीं हैं, डिफ़ॉल्ट क्वेरी वर्तमान ट्रेडिंग जोड़ी, अनुबंध के ऐतिहासिक आदेश है। वर्तमान समय के निकटतम एक निश्चित सीमा के भीतर ऐतिहासिक आदेशों को क्वेरी करता है, क्वेरी रेंज एक्सचेंज इंटरफ़ेस की एकल क्वेरी रेंज पर निर्भर करती है।symbolपैरामीटर निर्दिष्ट है, सेट व्यापार प्रकार के लिए आदेशों के इतिहास की क्वेरी।sinceपैरामीटर निर्दिष्ट है, वर्तमान समय की दिशा में क्वेरीsinceप्रारंभ समय के रूप में टाइमस्टैम्प।limitपैरामीटर निर्दिष्ट है, क्वेरी प्रविष्टियों की पर्याप्त संख्या के बाद लौटाया जाता है.एक्सचेंजों जो समर्थन नहीं करते हैंexchange.GetHistoryOrders()कार्य:
| फ़ंक्शन का नाम | असमर्थित स्पॉट एक्सचेंज | बिना समर्थन वाले फ्यूचर्स एक्सचेंज |
|---|---|---|
| GetHistoryOrders प्राप्त करें | Zaif / Upbit / Coincheck / Bitstamp / Bithumb / BitFlyer / BigONE | फ्यूचर्स_डीवाईडीएक्स / फ्यूचर्स_बिबॉक्स / फ्यूचर्स_अपोलोएक्स |
{@struct/Order Order}, {@fun/Trade/exchange.GetOrder exchange.GetOrder}, {@fun/Trade/exchange.GetOrders exchange.GetOrders}, {@struct/Trade/Order Order}, {@fun/Trade/exchange.GetOrders exchange.GetOrders}, {@fun/Trade/Trade.GetOrders exchange.GetOrders}, {@fun/Trade/exchange.GetOrders exchange.GetOrders}, {@fun/Trade/exchange.GetOrders exchange.GetOrders}, {@fun/Trade/exchange.GetOrders exchange.GetOrders}, {@fun/Trade/exchange.GetOrders exchange.GetOrders}, {@fun/Trade/Exchange.GetOrders exchange.GetOrders}, {@fun/Trade/exchange.GetOrders exchange.GetOrders exchange.GetOrders}, {@fun/Trade/exchange.GetOrder exchange.GetOrder exchange.GetOrder exchange.GetOrder exchange
exchange.SetPrecision()समारोह की सटीकता को सेट करने के लिए प्रयोग किया जाता हैexchangeविनिमय वस्तुमूल्यऔरआदेश राशि, सेट करने के बाद, सिस्टम स्वचालित रूप से अतिरिक्त डेटा को अनदेखा करेगा।
exchange.SetPrecision ((मूल्यPrecision, राशिPrecision)
..pricePrecisionपैरामीटर का उपयोग मूल्य डेटा की सटीकता को नियंत्रित करने के लिए किया जाता है।
मूल्य सटीकता
सच
संख्या
दamountPrecisionपैरामीटर का उपयोग आदेश देने के लिए डेटा की मात्रा की सटीकता को नियंत्रित करने के लिए किया जाता है।
राशि सटीकता
सच
संख्या
function main(){
// Set the decimal precision of price to 2 bits, and the decimal precision of variety order amount to 3 bits
exchange.SetPrecision(2, 3)
}
def main():
exchange.SetPrecision(2, 3)
void main() {
exchange.SetPrecision(2, 3);
}
बैकटेस्टिंग प्रणाली इस फ़ंक्शन का समर्थन नहीं करती है, और बैकटेस्टिंग प्रणाली की संख्यात्मक सटीकता स्वचालित रूप से संभाली जाती है।
{@fun/Trade/exchange.Buy exchange.Buy}, {@fun/Trade/exchange.Sell exchange.Sell}
विनिमय वस्तु की वर्तमान विनिमय दर सेट करें.
exchange.SetRate (दर)
..rateरूपांतरण विनिमय दर को निर्दिष्ट करने के लिए पैरामीटर का प्रयोग किया जाता है।
दर
सच
संख्या
function main(){
Log(exchange.GetTicker())
// Set exchange rate conversion
exchange.SetRate(7)
Log(exchange.GetTicker())
// Set to 1, no conversion
exchange.SetRate(1)
}
def main():
Log(exchange.GetTicker())
exchange.SetRate(7)
Log(exchange.GetTicker())
exchange.SetRate(1)
void main() {
Log(exchange.GetTicker());
exchange.SetRate(7);
Log(exchange.GetTicker());
exchange.SetRate(1);
}
यदि विनिमय दर का मूल्य विनिमय दर के आधार पर निर्धारित किया गया हैexchange.SetRate()7. तब सभी मूल्य जानकारी जैसे कि टिकर्स, गहराई, आदेश मूल्य, आदि के लिए विनिमय वर्तमान द्वारा दर्शाया जाता हैexchangeविनिमय वस्तु को 7 की निर्धारित विनिमय दर से गुणा करके परिवर्तित किया जाएगा। उदाहरण के लिए,exchangeमुद्रा के रूप में अमेरिकी डॉलर के साथ एक विनिमय है। निष्पादन के बादexchange.SetRate(7), लाइव बाजार पर सभी कीमतों को मूल्य के करीब परिवर्तित किया जाएगाCNY7 से गुणा करके मूल्यवर्ग
{@मज़ा/बाजार/विनिमय.GetRate विनिमय.GetRate}
..exchange.IO()फ़ंक्शन का उपयोग एक्सचेंज ऑब्जेक्ट से संबंधित अन्य इंटरफेस कॉल के लिए किया जाता है.
..exchange.IO()फ़ंक्शन एक्सचेंज ऑब्जेक्ट से संबंधित अन्य इंटरफेस को कॉल करता है, एक सफल कॉल पर अनुरोधित प्रतिक्रिया डेटा लौटाता है और यह एक असफल कॉल पर शून्य लौटाता है।
string, number, bool, object, array, null, और कोई अन्य प्रकार जो सिस्टम द्वारा समर्थित है
exchange.IO(k,... args)
..kपैरामीटर का उपयोग कॉल प्रकार सेट करने के लिए किया जाता है, वैकल्पिक मानों के साथ"api", "currency", "base", "trade_margin", "trade_normal", "public_base", "mbase", selfTradePreventionMode, simulate, cross, dual, unifiedऔर इसी तरह।
क
सच
स्ट्रिंग
विस्तारित पैरामीटर, विशिष्ट कॉल परिदृश्य के अनुसार पारित,argपैरामीटर एक से अधिक पारित किया जा सकता है।exchange.IO()कार्य, विभिन्न पैरामीटर सेटिंग्स विभिन्न कार्यों के अनुरूप हैं।exchange.IO()कार्य अनिश्चित हैं।
आर्ग
सच
string, number, bool, object, array, null और सिस्टम द्वारा समर्थित कोई अन्य प्रकार
function main() {
var arrOrders = [
{"instId":"BTC-USDT-SWAP","tdMode":"cross","side":"buy","ordType":"limit","px":"16000","sz":"1","posSide":"long"},
{"instId":"BTC-USDT-SWAP","tdMode":"cross","side":"buy","ordType":"limit","px":"16000","sz":"2","posSide":"long"}
]
// Call exchange.IO to access the exchange's bulk order interface directly
var ret = exchange.IO("api", "POST", "/api/v5/trade/batch-orders", "", JSON.stringify(arrOrders))
Log(ret)
}
import json
def main():
arrOrders = [
{"instId":"BTC-USDT-SWAP","tdMode":"cross","side":"buy","ordType":"limit","px":"16000","sz":"1","posSide":"long"},
{"instId":"BTC-USDT-SWAP","tdMode":"cross","side":"buy","ordType":"limit","px":"16000","sz":"2","posSide":"long"}
]
ret = exchange.IO("api", "POST", "/api/v5/trade/batch-orders", "", json.dumps(arrOrders))
Log(ret)
void main() {
json arrOrders = R"([
{"instId":"BTC-USDT-SWAP","tdMode":"cross","side":"buy","ordType":"limit","px":"16000","sz":"1","posSide":"long"},
{"instId":"BTC-USDT-SWAP","tdMode":"cross","side":"buy","ordType":"limit","px":"16000","sz":"2","posSide":"long"}
])"_json;
auto ret = exchange.IO("api", "POST", "/api/v5/trade/batch-orders", "", arrOrders.dump());
Log(ret);
}
का उपयोग करनाexchange.IO("api", httpMethod, resource, params, raw)आमंत्रणexchange.IO()कार्यक्षमता, यह आवश्यक है समझने के लिए एपीआई इंटरफेस के विनिमय और जाँच प्रासंगिक प्रलेखन पहले. यह आप विस्तार करने के लिए अनुमति देगा कार्यक्षमता है कि नहीं है में जोड़ा गया है एफएमजेड मंच.POSTअनुरोध आपको एन्क्रिप्शन, हस्ताक्षर, या पैरामीटर सत्यापित करने के बारे में चिंता करने की आवश्यकता नहीं है, जो पहले से ही नीचे एफएमजेड द्वारा संभाला जाता है, जब तक आप संबंधित पैरामीटर भरते हैं। आप के बैच आदेश उदाहरण का संदर्भ ले सकते हैंओकेएक्स एक्सचेंजवायदा अनुबंध, और पैरामीटर का उपयोगrawआदेश मापदंडों को पारित करने के लिएः
var amount = 1
var price = 10
var basecurrency = "ltc"
function main () {
// Note that both amount.toString() and price.toString() have a ' character on the left and right side
var message = "symbol=" + basecurrency + "&amount='" + amount.toString() + "'&price='" + price.toString() + "'&side=buy" + "&type=limit"
var id = exchange.IO("api", "POST", "/v1/order/new", message)
}
amount = 1
price = 10
basecurrency = "ltc"
def main():
message = "symbol=" + basecurrency + "&amount='" + str(amount) + "'&price='" + str(price) + "'&side=buy" + "&type=limit"
id = exchange.IO("api", "POST", "/v1/order/new", message)
void main() {
auto amount = 1.0;
auto price = 10.0;
auto basecurrency = "ltc";
string message = format("symbol=%s&amount=\"%.1f\"&price=\"%.1f\"&side=buy&type=limit", basecurrency, amount, price);
auto id = exchange.IO("api", "POST", "/v1/order/new", message);
}
यदि कुंजी मानparamsपैरामीटर (यानी, Http अनुरोध पैरामीटर) एक स्ट्रिंग है, यह पैरामीटर मूल्य को लपेटने के लिए पैरामीटर मूल्य के चारों ओर एकल उद्धरण (यानी, प्रतीक ') में लिखा जाना चाहिए।
function main() {
var ret = exchange.IO("api", "GET", "https://www.okx.com/api/v5/account/max-withdrawal", "ccy=BTC")
Log(ret)
}
def main():
ret = exchange.IO("api", "GET", "https://www.okx.com/api/v5/account/max-withdrawal", "ccy=BTC")
Log(ret)
void main() {
auto ret = exchange.IO("api", "GET", "https://www.okx.com/api/v5/account/max-withdrawal", "ccy=BTC");
Log(ret);
}
यह पूर्ण यूआरएल पैरामीटर में पारित करने का समर्थन करता है, जो आधार पते को स्विच करने के संचालन को छोड़ सकता हैexchange.SetBase()कार्य) ।
function main(){
var ret = exchange.IO("api", "GET", "/api/v5/trade/orders-pending", "instType=SPOT")
Log(ret)
}
def main():
ret = exchange.IO("api", "GET", "/api/v5/trade/orders-pending", "instType=SPOT")
Log(ret)
void main() {
auto ret = exchange.IO("api", "GET", "/api/v5/trade/orders-pending", "instType=SPOT");
Log(ret);
}
पैरामीटर के बिना कॉल का उदाहरणraw:
function main() {
// For example, if you set the current trading pair of the exchange object to BTC_USDT at the beginning of the live trading, print the current trading pair tickers
Log(exchange.GetTicker())
// Switch the trading pair to LTC_BTC
exchange.IO("currency", "LTC_BTC")
Log(exchange.GetTicker())
}
def main():
Log(exchange.GetTicker())
exchange.IO("currency", "LTC_BTC")
Log(exchange.GetTicker())
void main() {
Log(exchange.GetTicker());
exchange.IO("currency", "LTC_BTC");
Log(exchange.GetTicker());
}
वर्तमान विनिमय की व्यापार जोड़ी स्विच करें, ताकि यह कोड द्वारा विन्यस्त व्यापार जोड़ी स्विच करेगालाइव ट्रेडिंग सृजन परयाबैकटेस्ट में.
function main () {
// exchanges[0] is the first exchange object added when the live trading is created
exchanges[0].IO("base", "https://api.huobi.pro")
}
def main():
exchanges[0].IO("base", "https://api.huobi.pro")
void main() {
exchanges[0].IO("base", "https://api.huobi.pro");
}```
For example, the default base address when the exchange object is wrapped is ```https://api.huobipro.com```, and when you need to switch to ```https://api.huobi.pro```, use the following code to switch:
```javascript
function main() {
exchange.SetBase("https://api.bitfinex.com")
exchange.IO("mbase", "https://api-pub.bitfinex.com")
}
def main():
exchange.SetBase("https://api.bitfinex.com")
exchange.IO("mbase", "https://api-pub.bitfinex.com")
void main() {
exchange.SetBase("https://api.bitfinex.com");
exchange.IO("mbase", "https://api-pub.bitfinex.com");
}
उदाहरण के लिए, टिकर इंटरफेस और ट्रेडिंग इंटरफेस के लिए अलग-अलग आधार पते वाले एक्सचेंजों के लिए, बिटकॉइन फ्यूचर्स में दो पते हैं, एक टिकर इंटरफेस के लिए और दूसरा ट्रेडिंग इंटरफेस के लिए। बिटकॉइन फ्यूचर्स निजी इंटरफ़ेस आधार पते का उपयोग करके स्विच करते हैंexchange.SetBase("xxx"). Bitfinex वायदा का उपयोग कर सार्वजनिक इंटरफ़ेस आधार पते स्विचexchange.IO("mbase", "xxx").
क्रिप्टोक्यूरेंसी-केंद्रित एक्सचेंजों के लिए अन्य एपीआई इंटरफेस कॉल जो समान रूप से कैप्सुलेट नहीं हैं, पैरामीटर के साथkसेट करना"api":
exchange.IO("api", httpMethod, resource, params, raw)
POST, GETआदि।URL...exchange.IO("api", httpMethod, resource, params, raw)फ़ंक्शन कॉल एक्सचेंज इंटरफेस तक पहुंच जाएगा और यदि कॉल विफल हो जाती है और त्रुटि होती है तो शून्य लौटाएगा.
केवल वास्तविक व्यापार का समर्थन करता हैexchange.IO("api", httpMethod, resource, params, raw) function.
II. व्यापारिक जोड़े बदलने के लिए, पैरामीटरkपर सेट है"currency":
exchange.IO("currency", currency)
मुद्राः पैरामीटर एक समान अपरकेस प्रारूप के साथ एक स्ट्रिंग प्रकार है, जो अलग करने के लिए एक रेखांकन का उपयोग करता हैbaseCurrencyसेquoteCurrency, जैसेBTC_USDT.
ETH_BTCकेवल पर स्विच कर सकते हैंLTC_BTC, नहीं करनाLTC_USDT.exchange.IO("currency", currency)व्यापारिक जोड़े बदलने के लिए।क्रिप्टोक्यूरेंसी स्पॉट एक्सचेंज ऑब्जेक्ट लीवरेज्ड अकाउंट मोड को स्विच करने के लिए प्रयोग किया जाता हैः
kपर सेट है"trade_margin"स्पॉट लीवरेज अकाउंट मोड पर स्विच करने के लिए। ऑर्डर देने और खाता परिसंपत्तियों को प्राप्त करने के लिए एक्सचेंज के स्पॉट लीवरेज इंटरफेस तक पहुंच होगी।
यदि एक्सचेंज स्पॉट लीवरेज में पूर्ण मार्जिन और अलग-थलग मार्जिन के बीच अंतर करता है, तो उपयोग करेंःexchange.IO("trade_super_margin")लीवरेज्ड खाते के लिए पूर्ण मार्जिन पर स्विच करना औरexchange.IO("trade_margin")लीवरेज्ड खाते के लिए अलग-थलग मार्जिन पर स्विच करने के लिए।kपर सेट है"trade_normal"सामान्य स्पॉट खाता मोड पर लौटने के लिए।ऐसे स्पॉट एक्सचेंज जो लाभप्रद खाता मॉडल के बीच स्विचिंग का समर्थन करते हैंः
| आदान-प्रदान | विशेष टिप्पणी |
|---|---|
| ओकेएक्स | लीवरेज्ड अकाउंट मोड में ट्रेडिंग जोड़े सामान्य से भिन्न होते हैं, कुछ ट्रेडिंग जोड़े में वे नहीं हो सकते हैं।exchange.IO("trade_super_margin")लीवरेज्ड खातों के लिए पूर्ण स्थिति पर स्विच करने और उपयोग करने के लिएexchange.IO("trade_margin")स्थिति से स्थिति में स्विच करने के लिए।trade_normalसामान्य स्पॉट मोड पर स्विच करने के लिए।exchange.IO("tdMode", "cross")सीधे लीवरेज मोड को निर्दिष्ट करने के लिए। |
| हुओबी | लीवरेज्ड अकाउंट मोड ट्रेडिंग जोड़े सामान्य से भिन्न होते हैं, कुछ ट्रेडिंग जोड़े में वे नहीं हो सकते हैं। Huobi लीवरेज्ड खातों में पूर्ण पद और स्थिति-दर-स्थिति हैं। उपयोग करेंtrade_marginलेनदेन खाते की स्थिति के अनुसार लेनदेन पर स्विच करने के लिए,trade_super_marginलीवरेज खाते की पूर्ण स्थिति पर स्विच करने के लिए।trade_normalसामान्य मुद्रा-मुद्रा मोड पर स्विच करने के लिए। |
| बाइनेंस | लीवरेज्ड खाता मोड को स्थिति के अनुसार स्थिति और पूर्ण स्थिति, उपयोग में विभाजित किया गया है।trade_marginस्थिति से स्थिति में स्विच करने के लिए, उपयोगtrade_super_marginपूर्ण स्थिति में स्विच करने के लिए, उपयोगtrade_normalसामान्य मुद्रा-मुद्रा मोड पर स्विच करने के लिए। |
| द्वार | लीवरेज्ड खाता मोड को स्थिति के अनुसार स्थिति और पूर्ण स्थिति, उपयोग में विभाजित किया गया है।trade_marginस्थिति से स्थिति में स्विच करने के लिए, उपयोगtrade_super_marginपूर्ण स्थिति में स्विच करने के लिए, उपयोगtrade_normalसामान्य मुद्रा-मुद्रा मोड पर स्विच करने के लिए। |
| AscendEx | प्रयोगexchange.IO("trade_margin")लीवरेज खाते के मोड पर स्विच करने के लिए औरexchange.IO("trade_normal")सामान्य खाता मोड पर वापस स्विच करने के लिए। |
| वू | प्रयोगexchange.IO("trade_margin")लीवरेज खाते के मोड पर स्विच करने के लिए औरexchange.IO("trade_normal")सामान्य खाता मोड पर वापस स्विच करने के लिए। |
| CoinEx | प्रयोगexchange.IO("trade_margin")लीवरेज्ड खाता मोड पर स्विच करने के लिए औरexchange.IO("trade_normal")सामान्य खाता मोड पर वापस स्विच करने के लिए। |
अन्य स्विचिंग कार्य:देखोexchange.IO()कार्य के लिएअन्य स्विचिंग फ़ंक्शनउपयोगकर्ता गाइड में।
{@fun/NetSettings/exchange.SetBase exchange.SetBase}, {@fun/Account/exchange.SetCurrency exchange.SetCurrency}, {@var EXCHANGE_OP_IO_CONTROL}
..exchange.Log()function का उपयोग लॉग कॉलम क्षेत्र में ऑर्डर प्लेसमेंट और निकासी के लॉग को आउटपुट करने के लिए किया जाता है। जब कॉल किया जाता है, तो कोई ऑर्डर नहीं किया जाता है, केवल लेनदेन लॉग आउटपुट और रिकॉर्ड किया जाता है।
विनिमय.लॉग (ऑर्डर) प्रकार, मूल्य, राशि विनिमय.लॉग ((ऑर्डरप्रकार, कीमत, राशि,... args)
..orderTypeपैरामीटर का उपयोग आउटपुट लॉग प्रकार सेट करने के लिए किया जाता है, वैकल्पिक मान हैं {@var/LOG_TYPE/LOG_TYPE_BUY LOG_TYPE_BUY}, {@var/LOG_TYPE/LOG_TYPE_SELL LOG_TYPE_SELL}, {@var/LOG_TYPE/LOG_TYPE_CANCEL LOG_TYPE_CANCEL}.
आदेशप्रकार
सच
संख्या
दpriceपैरामीटर का उपयोग आउटपुट लॉग में प्रदर्शित मूल्य को सेट करने के लिए किया जाता है।
मूल्य
सच
संख्या
दamountपैरामीटर का उपयोग आउटपुट लॉग में प्रदर्शित किए गए ऑर्डर की मात्रा को सेट करने के लिए किया जाता है।
राशि
सच
संख्या
विस्तारित मापदंड जो इस लॉग के लिए संगत जानकारी आउटपुट कर सकते हैं,argपैरामीटर एक से अधिक पारित किया जा सकता है।
आर्ग
झूठी
string, number, bool, object, array, null और सिस्टम द्वारा समर्थित कोई अन्य प्रकार
var id = 123
function main() {
// Order type buy, price 999, amount 0.1
exchange.Log(LOG_TYPE_BUY, 999, 0.1)
// Cancel the order
exchange.Log(LOG_TYPE_CANCEL, id)
}
id = 123
def main():
exchange.Log(LOG_TYPE_BUY, 999, 0.1)
exchange.Log(LOG_TYPE_CANCEL, id)
void main() {
auto id = 123;
exchange.Log(LOG_TYPE_BUY, 999, 0.1);
exchange.Log(LOG_TYPE_CANCEL, id);
}
प्रयोग करनाexchange.Log(orderType, price, amount)परीक्षणों के बाद लाइव ट्रेडिंग ऑर्डर के लिए इस्तेमाल किया जा सकता है, अनुकरणीय ऑर्डर प्लेसमेंट, और यह लॉगिंग ऑर्डर प्लेसमेंट में सहायता कर सकता है। सबसे आम परिदृश्यों में से एक {@fun/Trade/exchange.IO का उपयोग करना हैexchange.IO} फ़ंक्शन को विनिमयexchange.IO()कार्य लाइव ट्रेडिंग लॉग रिकॉर्ड में लेनदेन लॉग जानकारी आउटपुट नहीं करता है।exchange.Log()ऑर्डर की जानकारी दर्ज करने के लिए आउटपुट लॉग को पूरक करने के लिए कार्य का उपयोग किया जा सकता है और ऑर्डर निकालने के संचालन के लिए भी यही सच है।
जबorderTypeपैरामीटर हैLOG_TYPE_CANCEL,priceपैरामीटर वापस लिए गए ऑर्डर का ऑर्डर आईडी है जिसका उपयोग वापस लेने के लॉग को प्रिंट करने के लिए किया जाता है जब ऑर्डर को सीधेexchange.IO()कार्य।exchange.Log()फ़ंक्शन {@var/EXCHANGE exchange} विनिमय वस्तु का सदस्य फ़ंक्शन है, जैसा कि वैश्विक फ़ंक्शन {@fun/Log Log} से अलग है।
{@fun/Log Log}, {@var/EXCHANGE exchange}, {@var/LOG_TYPE/LOG_TYPE_BUY LOG_TYPE_BUY}, {@var/LOG_TYPE/LOG_TYPE_SELL LOG_TYPE_SELL}, {@var/LOG_TYPE/LOG_TYPE_CANCEL LOG_TYPE_CANCEL}
..exchange.Encode()हस्ताक्षर एन्क्रिप्शन की गणना के लिए फ़ंक्शन का प्रयोग किया जाता है.
..exchange.Encode()फ़ंक्शन गणना की गई हैश मान एन्कोडिंग लौटाता है.
स्ट्रिंग
exchange.Encode ((algo, inputFormat, outputFormat, data) exchange.Encode ((algo, inputFormat, outputFormat, data, keyफॉर्मेट, कुंजी)
पैरामीटरalgoalgoयह भी समर्थन करता हैः algoयह विभिन्न हैश एल्गोरिदम के उपयोग का समर्थन करता है, उदाहरण के लिए पैरामीटरalgoed25519.seedगणना।
कुछ
सच
स्ट्रिंग
डेटा प्रारूप को निर्दिष्ट करने के लिए प्रयोग किया जाता हैdataपैरामीटर।inputFormatपैरामीटर में से किसी एक पर सेट किया जा सकता हैः hexएन्कोडेड, base64एन्कोडेड है, और outputFormatपैरामीटर निम्नलिखित सेटिंग्स का समर्थन करता हैः hexएन्कोडेड, base64एन्कोडेड है, और dataसंसाधित किए जाने वाले डेटा हैं।
आंकड़ा
सच
स्ट्रिंग
डेटा प्रारूप को निर्दिष्ट करने के लिए प्रयोग किया जाता हैkeyपैरामीटर।keyपैरामीटर में से किसी एक पर सेट किया जा सकता हैः hexएन्कोडेड, base64एन्कोडेड है, और keyपैरामीटर हस्ताक्षर गणना में इस्तेमाल कुंजी निर्दिष्ट करने के लिए प्रयोग किया जाता है, और यह एक सादे पाठ स्ट्रिंग के रूप में इस्तेमाल किया जा सकता है. आप भी उपयोग कर सकते हैं"{{accesskey}}", "{{secretkey}}"संदर्भित करने के लिएaccessKeyऔरsecretKey{@var/EXCHANGE exchange} एक्सचेंज ऑब्जेक्ट में कॉन्फ़िगर किया गया है.
कुंजी
झूठी
स्ट्रिंग
function main() {
var APIKEY = "your Access Key(Bitmex API ID)"
var expires = parseInt(Date.now() / 1000) + 10
var signature = exchange.Encode("sha256", "string", "hex", "GET/realtime" + expires, "hex", "{{secretkey}}")
var client = Dial("wss://www.bitmex.com/realtime", 60)
var auth = JSON.stringify({args: [APIKEY, expires, signature], op: "authKeyExpires"})
var pos = 0
client.write(auth)
client.write('{"op": "subscribe", "args": "position"}')
while (true) {
bitmexData = client.read()
if(bitmexData.table == 'position' && pos != parseInt(bitmexData.data[0].currentQty)){
Log('position change', pos, parseInt(bitmexData.data[0].currentQty), '@')
pos = parseInt(bitmexData.data[0].currentQty)
}
}
}
import time
def main():
APIKEY = "your Access Key(Bitmex API ID)"
expires = int(time.time() + 10)
signature = exchange.Encode("sha256", "string", "hex", "GET/realtime" + expires, "hex", "{{secretkey}}")
client = Dial("wss://www.bitmex.com/realtime", 60)
auth = json.dumps({"args": [APIKEY, expires, signature], "op": "authKeyExpires"})
pos = 0
client.write(auth)
client.write('{"op": "subscribe", "args": "position"}')
while True:
bitmexData = json.loads(client.read())
if "table" in bitmexData and bitmexData["table"] == "position" and len(bitmexData["data"]) != 0 and pos != bitmexData["data"][0]["currentQty"]:
Log("position change", pos, bitmexData["data"][0]["currentQty"], "@")
pos = bitmexData["data"][0]["currentQty"]
void main() {
auto APIKEY = "your Access Key(Bitmex API ID)";
auto expires = Unix() + 10;
auto signature = exchange.Encode("sha256", "string", "hex", format("GET/realtime%d", expires), "hex", "{{secretkey}}");
auto client = Dial("wss://www.bitmex.com/realtime", 60);
json auth = R"({"args": [], "op": "authKeyExpires"})"_json;
auth["args"].push_back(APIKEY);
auth["args"].push_back(expires);
auth["args"].push_back(signature);
auto pos = 0;
client.write(auth.dump());
client.write("{\"op\": \"subscribe\", \"args\": \"position\"}");
while(true) {
auto bitmexData = json::parse(client.read());
if(bitmexData["table"] == "position" && bitmexData["data"][0].find("currentQty") != bitmexData["data"][0].end() && pos != bitmexData["data"][0]["currentQty"]) {
Log("test");
Log("position change", pos, bitmexData["data"][0]["currentQty"], "@");
pos = bitmexData["data"][0]["currentQty"];
}
}
}
BitMEX स्थिति परिवर्तन पुश (wss प्रोटोकॉल) का उदाहरणः
केवल वास्तविक व्यापार का समर्थन करता हैexchange.Encode()कार्य।"{{accesskey}}", "{{secretkey}}"संदर्भ केवल तभी मान्य होते हैं जबexchange.Encode()फ़ंक्शन का प्रयोग किया जाता है।
{@var/EXCHANGE exchange}, {@fun/Global/Encode Encode}
मल्टी-थ्रेडेड असिंक्रोनस सपोर्ट फंक्शन सभी सपोर्ट किए गए फंक्शन के ऑपरेशन को असिंक्रोनस समवर्ती निष्पादन में बदल सकते हैं।
..exchange.Go()फ़ंक्शन तुरंत एक समवर्ती वस्तु देता है, और आप उपयोग कर सकते हैंwait()समवर्ती अनुरोध का परिणाम प्राप्त करने के लिए उस समवर्ती वस्तु की विधि.
वस्तु
विनिमय.जाओ ((प्रक्रिया) आदान-प्रदान.जाओ ((प्रक्रिया,... args)
..methodपैरामीटर का उपयोग समवर्ती फ़ंक्शन का नाम निर्दिष्ट करने के लिए किया जाता है. ध्यान दें कि पैरामीटर फ़ंक्शन नाम स्ट्रिंग है, फ़ंक्शन संदर्भ नहीं।
विधि
सच
स्ट्रिंग
पैरामीटरसमवर्ती रूप से कार्य निष्पादित करना, एक से अधिक पैरामीटर हो सकते हैंarg. पैरामीटर का प्रकार और संख्याargपर निर्भर करता हैसमवर्ती निष्पादन कार्य.
आर्ग
झूठी
string, number, bool, object, array, function, null, और अन्य सभी प्रकार सिस्टम द्वारा समर्थित
function main(){
// The following four operations are concurrently executed asynchronously by multiple threads and do not take time and return immediately
var a = exchange.Go("GetTicker")
var b = exchange.Go("GetDepth")
var c = exchange.Go("Buy", 1000, 0.1)
var d = exchange.Go("GetRecords", PERIOD_H1)
// Call the wait method to wait for the return of the ticker results asynchronously
var ticker = a.wait()
// Returns the depth, or null if it fails
var depth = b.wait()
// return order number, limited to 1 second timeout, if timeout, returns undefined, the object can continue to call wait if the last wait timeout
var orderId = c.wait(1000)
if(typeof(orderId) == "undefined") {
// Timeout, reacquire
orderId = c.wait()
}
var records = d.wait()
}
def main():
a = exchange.Go("GetTicker")
b = exchange.Go("GetDepth")
c = exchange.Go("Buy", 1000, 0.1)
d = exchange.Go("GetRecords", PERIOD_H1)
ticker, ok = a.wait()
depth, ok = b.wait()
orderId, ok = c.wait(1000)
if ok == False:
orderId, ok = c.wait()
records, ok = d.wait()
void main() {
auto a = exchange.Go("GetTicker");
auto b = exchange.Go("GetDepth");
auto c = exchange.Go("Buy", 1000, 0.1);
auto d = exchange.Go("GetRecords", PERIOD_H1);
Ticker ticker;
Depth depth;
Records records;
TId orderId;
a.wait(ticker);
b.wait(depth);
if(!c.wait(orderId, 300)) {
c.wait(orderId);
}
d.wait(records);
}
Exchange.Go()फ़ंक्शन उपयोग उदाहरण, निर्धारित करने के लिएundefinedप्रयोग करने के लिएtypeof(xx) === "undefined", क्योंकिnull == undefinedजावास्क्रिप्ट में मान्य है.
function main() {
var d = exchange.Go("GetRecords", PERIOD_H1)
// Waiting for K-line results
var records = d.wait()
// Here waits an asynchronous operation that has been waited and finished, it will return null, and log the error message
var ret = d.wait()
}
def main():
d = exchange.Go("GetRecords", PERIOD_H1)
records, ok = d.wait()
ret, ok = d.wait()
void main() {
auto d = exchange.Go("GetRecords", PERIOD_H1);
Records records;
d.wait(records);
Records ret;
d.wait(ret);
}
बुला रहा हैwait()एक समवर्ती ऑब्जेक्ट पर विधि जो जारी किया गया है एक त्रुटि रिपोर्ट करेगाः
function main() {
while(true) {
var beginTS = new Date().getTime()
var arrRoutine = []
var arrTicker = []
var arrName = []
for(var i = 0; i < exchanges.length; i++) {
arrRoutine.push(exchanges[i].Go("GetTicker"))
arrName.push(exchanges[i].GetName())
}
for(var i = 0; i < arrRoutine.length; i++) {
arrTicker.push(arrRoutine[i].wait())
}
var endTS = new Date().getTime()
var tbl = {
type: "table",
title: "ticker",
cols: ["index", "name", "latest-deal-price"],
rows: []
}
for(var i = 0; i < arrTicker.length; i++) {
tbl.rows.push([i, arrName[i], arrTicker[i].Last])
}
LogStatus(_D(), "Total time taken to obtain tickers from multiple exchanges concurrently:", endTS - beginTS, "millisecond", "\n", "`" + JSON.stringify(tbl) + "`")
Sleep(500)
}
}
import time
import json
def main():
while True:
beginTS = time.time()
arrRoutine = []
arrTicker = []
arrName = []
for i in range(len(exchanges)):
arrRoutine.append(exchanges[i].Go("GetTicker"))
arrName.append(exchanges[i].GetName())
for i in range(len(exchanges)):
ticker, ok = arrRoutine[i].wait()
arrTicker.append(ticker)
endTS = time.time()
tbl = {
"type": "table",
"title": "ticker",
"cols": ["index", "name", "latest-deal-price"],
"rows": []
}
for i in range(len(arrTicker)):
tbl["rows"].append([i, arrName[i], arrTicker[i]["Last"]])
LogStatus(_D(), "Total time taken to obtain tickers from multiple exchanges concurrently:", endTS - beginTS, "second", "\n", "`" + json.dumps(tbl) + "`")
Sleep(500)
void main() {
while(true) {
int length = exchanges.size();
auto beginTS = UnixNano() / 1000000;
Ticker arrTicker[length] = {};
string arrName[length] = {};
// Note that to add several exchange objects, several exchanges[n].Go functions have to be executed here, this example is to add four exchange objects, the details can be modified
auto r0 = exchanges[0].Go("GetTicker");
auto r1 = exchanges[1].Go("GetTicker");
auto r2 = exchanges[2].Go("GetTicker");
auto r3 = exchanges[3].Go("GetTicker");
GoObj *arrRoutine[length] = {&r0, &r1, &r2, &r3};
for(int i = 0; i < length; i++) {
arrName[i] = exchanges[i].GetName();
}
for(int i = 0; i < length; i++) {
Ticker ticker;
arrRoutine[i]->wait(ticker);
arrTicker[i] = ticker;
}
auto endTS = UnixNano() / 1000000;
json tbl = R"({
"type": "table",
"title": "ticker",
"cols": ["index", "name", "latest-deal-price"],
"rows": []
})"_json;
for(int i = 0; i < length; i++) {
json arr = R"(["", "", ""])"_json;
arr[0] = format("%d", i);
arr[1] = arrName[i];
arr[2] = format("%f", arrTicker[i].Last);
tbl["rows"].push_back(arr);
}
LogStatus(_D(), "Total time taken to obtain tickers from multiple exchanges concurrently:", format("%d", endTS - beginTS), "millisecond", "\n", "`" + tbl.dump() + "`");
Sleep(500);
}
}
एकाधिक विनिमय टिकरों तक एक साथ पहुँचः
function main() {
/*
Testing with OKX futures order interface
POST /api/v5/trade/order
*/
var beginTS = new Date().getTime()
var param = {"instId":"BTC-USDT-SWAP","tdMode":"cross","side":"buy","ordType":"limit","px":"16000","sz":"1","posSide":"long"}
var ret1 = exchange.Go("IO", "api", "POST", "/api/v5/trade/order", "", JSON.stringify(param))
var ret2 = exchange.Go("IO", "api", "POST", "/api/v5/trade/order", "", JSON.stringify(param))
var ret3 = exchange.Go("IO", "api", "POST", "/api/v5/trade/order", "", JSON.stringify(param))
var id1 = ret1.wait()
var id2 = ret2.wait()
var id3 = ret3.wait()
var endTS = new Date().getTime()
Log("id1:", id1)
Log("id2:", id2)
Log("id3:", id3)
Log("Concurrent order placement time consumption:", endTS - beginTS, "millisecond")
}
import time
import json
def main():
beginTS = time.time()
param = {"instId":"BTC-USDT-SWAP","tdMode":"cross","side":"buy","ordType":"limit","px":"16000","sz":"1","posSide":"long"}
ret1 = exchange.Go("IO", "api", "POST", "/api/v5/trade/order", "", json.dumps(param))
ret2 = exchange.Go("IO", "api", "POST", "/api/v5/trade/order", "", json.dumps(param))
ret3 = exchange.Go("IO", "api", "POST", "/api/v5/trade/order", "", json.dumps(param))
id1, ok1 = ret1.wait()
id2, ok2 = ret2.wait()
id3, ok3 = ret3.wait()
endTS = time.time()
Log("id1:", id1)
Log("id2:", id2)
Log("id3:", id3)
Log("Concurrent order placement time consumption:", endTS - beginTS, "second")
void main() {
auto beginTS = UnixNano() / 1000000;
json param = R"({"instId":"BTC-USDT-SWAP","tdMode":"cross","side":"buy","ordType":"limit","px":"16000","sz":"1","posSide":"long"})"_json;
auto ret1 = exchange.Go("IO", "api", "POST", "/api/v5/trade/order", "", param.dump());
auto ret2 = exchange.Go("IO", "api", "POST", "/api/v5/trade/order", "", param.dump());
auto ret3 = exchange.Go("IO", "api", "POST", "/api/v5/trade/order", "", param.dump());
json id1 = R"({})"_json;
json id2 = R"({})"_json;
json id3 = R"({})"_json;
ret1.wait(id1);
ret2.wait(id2);
ret3.wait(id3);
auto endTS = UnixNano() / 1000000;
Log("id1:", id1);
Log("id2:", id2);
Log("id3:", id3);
Log("Concurrent order placement time consumption:", endTS - beginTS, "millisecond");
}
समवर्ती आमंत्रणexchange.IO("api", ...)कार्य:
यह फ़ंक्शन केवल वास्तविक ट्रेडिंग में चलने पर बहु-थ्रेडेड निष्पादन कार्य बनाता है, बैकटेस्टिंग बहु-थ्रेडेड समवर्ती कार्य निष्पादन का समर्थन नहीं करता है (बैकटेस्टिंग उपलब्ध है, लेकिन फिर भी क्रमिक रूप से निष्पादित किया जाता है) ।
के बादexchange.Go()फ़ंक्शन एक ऑब्जेक्ट देता है, इसकेwait()फ़ंक्शन उस ऑब्जेक्ट के माध्यम से कहा जाता है धागे द्वारा लौटाए गए डेटा प्राप्त करने के लिए.wait()कार्य स्वचालित रूप से जारी किया जाएगा इससे पहले कि धागा डेटा प्राप्त करने के लिए बुलाया जाना चाहिए.wait()function निर्दिष्ट है, तो थ्रेड स्वचालित रूप से रिलीज़ नहीं होगा, भले ही टाइमआउट हो। थ्रेड का परिणाम स्वचालित रूप से रिलीज़ होने से पहले प्राप्त किया जाना चाहिए (समानकालिक पहुंच के लिए इंटरफ़ेस कॉल की सफलता या विफलता के बावजूद) । सरल शब्दों में, अनुरोधित थ्रेड को प्राप्त किया जाना चाहिएwait()कार्य चाहे निष्पादन सफल हो या असफल, और धागे के संसाधन द्वारा अनुरोध किया द्वाराexchange.Go()कार्य को डॉकर द्वारा स्वचालित रूप से जारी किया जाना चाहिए।
दwait()विधि एक टाइमआउट पैरामीटर का समर्थन करती हैः
एक समय सीमा पैरामीटर के बिना, कि है,wait(), या एक समय सीमा पैरामीटर 0 के साथ, यानी,wait(0).wait()फ़ंक्शन ब्लॉक करता है और तब तक प्रतीक्षा करता है जब तक समवर्ती थ्रेड समाप्त नहीं हो जाता है, समवर्ती थ्रेडwait(-1).wait()फ़ंक्शन तुरंत रिटर्न करता है, विभिन्न प्रोग्रामिंग भाषाओं के लिए अलग-अलग रिटर्न मानों के साथ, एक उदाहरण कॉल के लिए इस उपखंड को देखें।
विशिष्ट टाइमआउट पैरामीटर सेट करें,wait(300), औरwait()कार्य वापस जाने से पहले अधिकतम 300 मिलीसेकंड का इंतजार करेगा।
यदि अंतिम परिणाम लौटायाwait()कार्य प्राप्त नहीं होता है, धागा संसाधन स्वचालित रूप से जारी नहीं किया जाएगा, जो अनुरोधित धागे के संचय का कारण होगा और 2000 से अधिक एक त्रुटि की रिपोर्ट करेगाः"too many routine wait, max is 2000".
समर्थित कार्यःGetTicker, GetDepth, GetTrades, GetRecords, GetAccount, GetOrders, GetOrder, CancelOrder, Buy, Sell, GetPositions, IO. इन सभी कार्यों को वर्तमान {@var/EXCHANGE exchange} विनिमय वस्तु के आधार पर निष्पादित किया जाता है जब समवर्ती रूप से बुलाया जाता है.
पायथन भाषा और जावास्क्रिप्ट भाषा के बीच अंतर यह है किwait()पायथन भाषा में समवर्ती ऑब्जेक्ट्स का फ़ंक्शन दो पैरामीटर लौटाता है। पहला पैरामीटर एक असिंक्रोनस एपीआई कॉल द्वारा लौटाया गया परिणाम है, और दूसरा पैरामीटर इंगित करता है कि क्या असिंक्रोनस कॉल पूरा हो गया है।
def main():
d = exchange.Go("GetRecords", PERIOD_D1)
# ok will return True definitely, unless the strategy is stopped
ret, ok = d.wait()
# If the wait times out, or if it waits for an instance that has already ended, ok returns False
ret, ok = d.wait(100)
{@fun/Global/Mail_Go Mail_Go}, {@fun/Global/HttpQuery_Go HttpQuery_Go}, {@fun/Global/EventLoop EventLoop}
..exchange.GetAccount()विनिमय खाते की जानकारी का अनुरोध करने के लिए उपयोग किया जाता है।GetAccount()function exchange object {@var/EXCHANGE exchange} का सदस्य फलन है।exchangeऑब्जेक्ट केवल संबंधित हैexchange, और यह प्रलेखन के बाद दोहराया नहीं जाएगा।
खाता परिसंपत्ति जानकारी पूछताछ और {@struct/Account Account} संरचना वापस यदि क्वेरी सफल या शून्य अगर यह विफल रहता है। {@struct/खाता खाता}, शून्य मान
विनिमय.GetAccount()
function main(){
// Switching trading pairs
exchange.IO("currency", "BTC_USDT")
// Take OKX futures as an example, set the contract as the current week's contract, the current trading pair is BTC_USDT, so the current contract is BTC's U-nominal current week contract
exchange.SetContractType("this_week")
// Get current account asset data
var account = exchange.GetAccount()
// Available balance of USDT as margin
Log(account.Balance)
// USDT freeze amount as margin
Log(account.FrozenBalance)
// Current asset equity
Log(account.Equity)
// The unrealized profit and loss of all positions held with the current asset as margin
Log(account.UPnL)
}
def main():
exchange.IO("currency", "BTC_USDT")
exchange.SetContractType("this_week")
account = exchange.GetAccount()
Log(account["Balance"])
Log(account["FrozenBalance"])
Log(account["Equity"])
Log(account["UPnL"])
void main() {
exchange.IO("currency", "BTC_USDT");
exchange.SetContractType("this_week");
auto account = exchange.GetAccount();
Log(account.Balance);
Log(account.FrozenBalance);
Log(account["Equity"])
Log(account["UPnL"])
}
ट्रेडिंग जोड़े सेट, अनुबंध कोड, और चालू खाता जानकारी प्राप्त.
यदि विनिमय वस्तु एक क्रिप्टोक्यूरेंसी वायदा अनुबंध विनिमय के लिए सेट है, और एक अनुबंध के साथ स्विचUSDTमार्जिन के रूप में (देखें {@fun/Account/exchange.SetCurrency exchange.SetCurrency}, {@fun/Futures/exchange.SetContractType exchange.SetContractType} कैसे स्विच करने के लिए कार्य करता है) । संपत्ति हैUSDTमार्जिन के रूप में दर्ज किया जाता है।Balance, FrozenBalance{@struct/Account Account} संरचना के गुण।
यदि विनिमय वस्तु को क्रिप्टोक्यूरेंसी वायदा अनुबंध विनिमय पर सेट किया जाता है, और मुद्रा-आधारित अनुबंध पर स्विच किया जाता है, तो परिसंपत्ति मुद्रा में मार्जिन के रूप में होती है और यह खाता में दर्ज की जाती हैStocks, FrozenStocks{@struct/Account Account} संरचना के गुण।
Binance वायदा एकीकृत खाते का उपयोग करते समय, जबexchange.GetAccount()खाते की जानकारी का अनुरोध करने के लिए कार्य, कैप्सुलेट डेटा सभी परिसंपत्तियों में परिवर्तित की राशि हैयूएसडी. यह प्रदर्शित किया गया हैBalance{@struct/Account Account} संरचना के क्षेत्र में. यदि आपको अन्य परिसंपत्तियों की रूपांतरण राशि की गणना करने की आवश्यकता है, तो आप इसे गणना करने के लिए USD रूपांतरण राशि को सूचकांक मूल्य (परिवर्तित होने वाली परिसंपत्ति की) से विभाजित और फिर प्रतिभूति दर (परिवर्तित होने वाली परिसंपत्ति की) से विभाजित कर सकते हैं.
{@struct/Account Account}, {@fun/Account/exchange.SetCurrency exchange.SetCurrency}, {@fun/Futures/exchange.SetContractType exchange.SetContractType}, {@struct/Account Account}, {@fun/Account/exchange.SetCurrency exchange.SetCurrency},
..exchange.GetAssetsविनिमय खाता परिसंपत्ति की जानकारी का अनुरोध करने के लिए कार्य का प्रयोग किया जाता है।
..exchange.GetAssets()function {@struct/Asset Asset} संरचनाओं की एक सरणी लौटाता है यदि डेटा के लिए अनुरोध सफल होता है, या शून्य यदि अनुरोध विफल होता है.
{@struct/Asset Asset} सरणी, शून्य मान
विनिमय.GetAssets()
function main() {
// exchange.SetCurrency("BTC_USDT") // You can set up trading pairs
// exchange.SetContractType("swap") // You can set up contracts
var assets = exchange.GetAssets()
Log(assets)
}
def main():
# exchange.SetCurrency("BTC_USDT") # You can set up trading pairs
# exchange.SetContractType("swap") # You can set up contracts
assets = exchange.GetAssets()
Log(assets)
void main() {
// exchange.SetCurrency("BTC_USDT"); // You can set up trading pairs
// exchange.SetContractType("swap"); // You can set up contracts
auto assets = exchange.GetAssets();
Log(assets);
}
विनिमय खाते की संपत्ति के बारे में जानकारी प्राप्त करें,exchange.GetAssets()संपत्ति संरचना के तत्वों के साथ एक सरणी लौटाता है.
..GetAssets()फ्यूचर्स एक्सचेंज ऑब्जेक्ट की फ़ंक्शन वर्तमान ट्रेडिंग जोड़ी (मुद्रा आधारित, USDT आधारित, USDC आधारित, आदि) के अंतर्गत मार्जिन परिसंपत्तियों को लौटाता है।
{@struct/Asset Asset}
..exchange.GetName()फ़ंक्शन का उपयोग उस एक्सचेंज का नाम प्राप्त करने के लिए किया जाता है जिसके लिए वर्तमान एक्सचेंज ऑब्जेक्ट बंधा हुआ है।
..exchange.GetName()फ़ंक्शन FMZ क्वांट ट्रेडिंग प्लेटफॉर्म द्वारा परिभाषित एक्सचेंज का नाम लौटाता है.
स्ट्रिंग
exchange.GetName ((()
function main() {
Log("The exchange object exchange is judged to be Binance spot, and the result is judged to be:", exchange.GetName() == "Binance")
}
def main():
Log("The exchange object exchange is judged to be Binance spot, and the result is judged to be:", exchange.GetName() == "Binance")
void main() {
Log("The exchange object exchange is judged to be Binance spot, and the result is judged to be:", exchange.GetName() == "Binance");
}
..exchange.GetName()कार्य आम तौर पर विनिमय वस्तुओं की पहचान करने के लिए प्रयोग किया जाता है, जैसे किexchangeयाexchanges[1], exchanges[2]रणनीति कोड में क्रिप्टोक्यूरेंसी वायदा अनुबंध एक्सचेंजों के नामों में फिक्स्ड उपसर्ग हैFutures_.
{@मज़ा/खाता/विनिमय.GetLabelविनिमय.GetLabel}
..exchange.GetLabel()function का उपयोग कस्टम लेबल प्राप्त करने के लिए किया जाता है जो विनिमय वस्तु को कॉन्फ़िगर करते समय सेट किया गया था.
..exchange.GetLabel()function उस कस्टम लेबल को लौटाता है जो विनिमय वस्तु को कॉन्फ़िगर करते समय सेट किया गया था.
स्ट्रिंग
विनिमय.GetLabel()
function main() {
Log("exchange label:", exchange.GetLabel())
}
def main():
Log("exchange label:", exchange.GetLabel())
void main() {
Log("exchange label:", exchange.GetLabel());
}
विनिमय वस्तुएं जैसेexchangeयाexchanges[1], exchanges[2]रणनीति कोड में सेट टैग द्वारा पहचाने जाते हैं।
{@var/EXCHANGE विनिमय}
..exchange.GetCurrency()फ़ंक्शन का उपयोग वर्तमान में सेट ट्रेडिंग जोड़ी प्राप्त करने के लिए किया जाता है।
..exchange.GetCurrency()फ़ंक्शन वर्तमान {@var/EXCHANGE exchange} एक्सचेंज ऑब्जेक्ट द्वारा सेट ट्रेडिंग जोड़ी लौटाता है.
स्ट्रिंग
विनिमय.GetCurrency()
function main() {
Log("the current trading pair of exchange is:", exchange.GetCurrency())
}
def main():
Log("the current trading pair of exchange is:", exchange.GetCurrency())
void main() {
Log("the current trading pair of exchange is:", exchange.GetCurrency());
}
व्यापारिक जोड़ी का प्रारूप बड़े अक्षरों में समान रूप से है, जिसमें अलग करने के लिए रेखांकन का उपयोग किया जाता हैbaseCurrencyऔरquoteCurrency, जैसेBTC_USDT.
{@मज़ा/खाता/विनिमय.सेट करेंसी विनिमय.सेट करेंसी}
..exchange.SetCurrency()विनिमय वस्तु {@var/EXCHANGE exchange} की वर्तमान ट्रेडिंग जोड़ी को स्विच करने के लिए फ़ंक्शन का प्रयोग किया जाता है।
विनिमय.सेट करेंसी (मुद्रा)
..currencyव्यापारिक जोड़ी प्रारूप बड़े अक्षरों में समान रूप से है, एक रेखांकन का उपयोग करके अलग करने के लिएbaseCurrencyसेquoteCurrency, जैसेBTC_USDT.
मुद्रा
सच
स्ट्रिंग
function main() {
var ticker = exchange.GetTicker()
Log(ticker)
Log(exchange.GetAccount())
// Switching trading pairs, pay attention to the changes of ticker data and account information after switching
exchange.SetCurrency("LTC_USDT")
Log("Switch to LTC_USDT")
ticker = exchange.GetTicker()
Log(ticker)
Log(exchange.GetAccount())
}
def main():
ticker = exchange.GetTicker()
Log(ticker)
Log(exchange.GetAccount())
exchange.SetCurrency("LTC_USDT")
Log("Switch to LTC_USDT")
ticker = exchange.GetTicker()
Log(ticker)
Log(exchange.GetAccount())
void main() {
auto ticker = exchange.GetTicker();
Log(ticker);
Log(exchange.GetAccount());
exchange.SetCurrency("LTC_USDT");
Log("Switch to LTC_USDT");
ticker = exchange.GetTicker();
Log(ticker);
Log(exchange.GetAccount());
}
exchange.IO("currency", "BTC_USDT")स्विचिंग विधि, कृपया {@funexcahnge.IO}.BTC_USDTपर स्विच किया जा सकता हैLTC_USDT, नहीं करनाLTC_BTC.BTC_USDT, की संख्याBTCहै 3, की संख्याUSDTइस समय, पर स्विच करेंLTC_USDTतुरंत, व्यापारिक मुद्राओं की संख्या 0 है स्विच के बाद, यानीLTC_USDTखाते में शून्य है, यानी, की संख्याLTCखाते में 0 है और स्विच की गई ट्रेडिंग जोड़ी मेंUSDT, जो 10000 है।{@मज़ा/खाता/विनिमय.GetCurrency विनिमय.GetCurrency}
..exchange.GetQuoteCurrency()फलन का उपयोग वर्तमान व्यापारिक जोड़ी की मुद्रा का नाम प्राप्त करने के लिए किया जाता है, अर्थातquoteCurrency.
..exchange.GetQuoteCurrency()फ़ंक्शन वर्तमान ट्रेडिंग जोड़ी की मुद्रा का नाम लौटाता है.
स्ट्रिंग
विनिमय.GetQuoteCurrency()
function main() {
exchange.SetCurrency("BTC_USDT")
Log("BTC_USDT denominated currency name:", exchange.GetQuoteCurrency())
// exchange.SetCurrency("ETH_BTC")
// Log("ETH_BTC denominated currency name:", exchange.GetQuoteCurrency())
}
def main():
exchange.SetCurrency("BTC_USDT")
Log("BTC_USDT denominated currency name:", exchange.GetQuoteCurrency())
# exchange.SetCurrency("ETH_BTC")
# Log("ETH_BTC denominated currency name:", exchange.GetQuoteCurrency())
void main() {
exchange.SetCurrency("BTC_USDT");
Log("BTC_USDT denominated currency name:", exchange.GetQuoteCurrency());
// exchange.SetCurrency("ETH_BTC")
// Log("ETH_BTC denominated currency name:", exchange.GetQuoteCurrency())
}
उदाहरण के लिएः {@var/EXCHANGE exchange} exchange objectBTC_USDT,exchange.GetQuoteCurrency()फ़ंक्शन लौटाता हैUSDTयदि वर्तमान व्यापारिक जोड़ीETH_BTC,exchange.GetQuoteCurrency()फ़ंक्शन लौटाता हैBTC.
{@fun/Account/exchange.GetCurrency exchange.GetCurrency}, {@fun/Account/exchange.SetCurrency exchange.SetCurrency}, {@fun/Account/exchange.SetCurrency exchange.SetCurrency}, {@fun/Account/exchange.SetCurrency.GetCurrency.GetCurrency.GetCurrency}, {@fun/Account/exchange.SetCurrency.SetCurrency.GetCurrency.GetCurrency.GetCurrency.GetCurrency}, {@fun/Account/exchange.SetCurrency.SetCurrency.GetCurrency.GetCurrency.GetCurrency.GetCurrency}, {@fun/Account/exchange.SetCurrency.SetCurrency.SetCurrency.GetCurrency.GetCurrency.GetCurrency}, {@fun/Account/Account/exchange.GetCurrency.GetCurrency.GetCurrency.GetCurrency.GetC
..exchange.GetPositions()स्थिति की जानकारी प्राप्त करने के लिए कार्य का उपयोग किया जाता है;GetPositions()फ़ंक्शन एक्सचेंज ऑब्जेक्ट {@var/EXCHANGE exchange} का सदस्य फ़ंक्शन है।GetPositions()कार्य विनिमय वस्तु से बंधे विनिमय खाते की स्थिति की जानकारी प्राप्त करता हैexchange. सदस्य कार्यों का उद्देश्य (प्रणाली)exchangeऑब्जेक्ट केवल संबंधित हैexchangeऔर यहाँ दोहराया नहीं जाएगा।
..exchange.GetPositions()फ़ंक्शन {@struct/Position Position} संरचनाओं की एक सरणी लौटाता है यदि डेटा के लिए अनुरोध सफल होता है, और यदि डेटा के लिए अनुरोध विफल होता है तो यह शून्य मान लौटाता है.
{@struct/Position Position} सरणी, शून्य मान
विनिमय.GetPositions ((() exchange.GetPositions (प्रतीक)
पैरामीटरsymbolसेट करने के लिए प्रयोग किया जाता हैव्यापारिक चिह्नयाट्रेडिंग प्रतीक श्रेणीपूछताछ की जाए।
यदिsymbolपैरामीटर पारित नहीं किया जाता है, डिफ़ॉल्ट रूप से वर्तमान ट्रेडिंग जोड़ी और अनुबंध कोड के आयाम सीमा में सभी प्रतीकों के स्थिति डेटा का अनुरोध करना है।
चिह्न झूठी स्ट्रिंग
/*backtest
start: 2024-05-21 00:00:00
end: 2024-09-05 00:00:00
period: 5m
basePeriod: 1m
exchanges: [{"eid":"Futures_Binance","currency":"BTC_USDT"}]
*/
function main() {
var arrSymbol = ["BTC_USDT.swap", "BTC_USDT.quarter", "ETH_USDT.swap", "ETH_USDT.quarter"]
for (var symbol of arrSymbol) {
exchange.CreateOrder(symbol, "buy", -1, 1)
exchange.CreateOrder(symbol, "sell", -1, 1)
}
var defaultPositions = exchange.GetPositions()
var swapPositions = exchange.GetPositions("USDT.swap")
var futuresPositions = exchange.GetPositions("USDT.futures")
var btcUsdtSwapPositions = exchange.GetPositions("BTC_USDT.swap")
var tbls = []
var arr = [defaultPositions, swapPositions, futuresPositions, btcUsdtSwapPositions]
var tblDesc = ["defaultPositions", "swapPositions", "futuresPositions", "btcUsdtSwapPositions"]
for (var index in arr) {
var positions = arr[index]
var tbl = {type: "table", title: tblDesc[index], cols: ["Symbol", "MarginLevel", "Amount", "FrozenAmount", "Price", "Profit", "Type", "ContractType", "Margin"], rows: [] }
for (var pos of positions) {
tbl.rows.push([pos.Symbol, pos.MarginLevel, pos.Amount, pos.FrozenAmount, pos.Price, pos.Profit, pos.Type, pos.ContractType, pos.Margin])
}
tbls.push(tbl)
}
LogStatus("`" + JSON.stringify(tbls) + "`")
// Print out the information once and then return to prevent the order from being executed during the subsequent backtest and affecting data observation
return
}
'''backtest
start: 2024-05-21 00:00:00
end: 2024-09-05 00:00:00
period: 5m
basePeriod: 1m
exchanges: [{"eid":"Futures_Binance","currency":"BTC_USDT"}]
'''
import json
def main():
arrSymbol = ["BTC_USDT.swap", "BTC_USDT.quarter", "ETH_USDT.swap", "ETH_USDT.quarter"]
for symbol in arrSymbol:
exchange.CreateOrder(symbol, "buy", -1, 1)
exchange.CreateOrder(symbol, "sell", -1, 1)
defaultPositions = exchange.GetPositions()
swapPositions = exchange.GetPositions("USDT.swap")
futuresPositions = exchange.GetPositions("USDT.futures")
btcUsdtSwapPositions = exchange.GetPositions("BTC_USDT.swap")
tbls = []
arr = [defaultPositions, swapPositions, futuresPositions, btcUsdtSwapPositions]
tblDesc = ["defaultPositions", "swapPositions", "futuresPositions", "btcUsdtSwapPositions"]
for index in range(len(arr)):
positions = arr[index]
tbl = {"type": "table", "title": tblDesc[index], "cols": ["Symbol", "MarginLevel", "Amount", "FrozenAmount", "Price", "Profit", "Type", "ContractType", "Margin"], "rows": []}
for pos in positions:
tbl["rows"].append([pos["Symbol"], pos["MarginLevel"], pos["Amount"], pos["FrozenAmount"], pos["Price"], pos["Profit"], pos["Type"], pos["ContractType"], pos["Margin"]])
tbls.append(tbl)
LogStatus("`" + json.dumps(tbls) + "`")
return
/*backtest
start: 2024-05-21 00:00:00
end: 2024-09-05 00:00:00
period: 5m
basePeriod: 1m
exchanges: [{"eid":"Futures_Binance","currency":"BTC_USDT"}]
*/
void main() {
auto arrSymbol = {"BTC_USDT.swap", "BTC_USDT.quarter", "ETH_USDT.swap", "ETH_USDT.quarter"};
for (const auto& symbol : arrSymbol) {
exchange.CreateOrder(symbol, "buy", -1, 1);
exchange.CreateOrder(symbol, "sell", -1, 1);
}
auto defaultPositions = exchange.GetPositions();
auto swapPositions = exchange.GetPositions("USDT.swap");
auto futuresPositions = exchange.GetPositions("USDT.futures");
auto btcUsdtSwapPositions = exchange.GetPositions("BTC_USDT.swap");
json tbls = R"([])"_json;
std::vector<std::vector<Position>> arr = {defaultPositions, swapPositions, futuresPositions, btcUsdtSwapPositions};
std::string tblDesc[] = {"defaultPositions", "swapPositions", "futuresPositions", "btcUsdtSwapPositions"};
for (int index = 0; index < arr.size(); index++) {
auto positions = arr[index];
json tbl = R"({
"type": "table",
"cols": ["Symbol", "MarginLevel", "Amount", "FrozenAmount", "Price", "Profit", "Type", "ContractType", "Margin"],
"rows": []
})"_json;
tbl["title"] = tblDesc[index];
for (const auto& pos : positions) {
json arrJson = R"([])"_json;
arrJson.push_back(pos.Symbol);
arrJson.push_back(pos.MarginLevel);
arrJson.push_back(pos.Amount);
arrJson.push_back(pos.FrozenAmount);
arrJson.push_back(pos.Price);
arrJson.push_back(pos.Profit);
arrJson.push_back(pos.Type);
arrJson.push_back(pos.ContractType);
arrJson.push_back(pos.Margin);
tbl["rows"].push_back(arrJson);
}
tbls.push_back(tbl);
}
LogStatus(_D(), "\n", "`" + tbls.dump() + "`");
return;
}
कई अलग-अलग ट्रेडिंग जोड़े और अनुबंध कोडों के लिए बाजार के आदेश रखने के लिए वायदा विनिमय वस्तुओं का उपयोग करें। कई तरीकों से प्रश्न स्थिति।
क्रिप्टोक्यूरेंसी वायदा अनुबंध क्रिप्टोक्यूरेंसी स्पॉट से अलग हैं, जिसमें केवल स्थिति की तार्किक अवधारणा है। एफएमजेड क्वांट ट्रेडिंग प्लेटफॉर्म की प्रणाली में, क्रिप्टोक्यूरेंसी वायदा अनुबंधों के विशिष्ट प्रकारों की पहचान इस प्रकार की जाती हैव्यापारिक जोड़े, अनुबंध कोडकृपया {@fun/Account/exchange.SetCurrency exchange.SetCurrency}, {@fun/Futures/exchange.SetContractType exchange.SetContractType} फ़ंक्शन देखें।
मेंGetPositionsफंक्शन, प्रतीक पैरामीटर के उपयोग के परिदृश्यों को इस प्रकार संक्षेप में प्रस्तुत किया गया हैः
| एक्सचेंज ऑब्जेक्ट वर्गीकरण | प्रतीक पैरामीटर | क्वेरी का दायरा | टिप्पणियाँ |
|---|---|---|---|
| वायदा | प्रतीक पैरामीटर पास न करें | वर्तमान ट्रेडिंग जोड़ी और अनुबंध कोड आयाम सीमा के भीतर सभी ट्रेडिंग उत्पादों को क्वेरी करें | यदि वर्तमान ट्रेडिंग जोड़ी BTC_USDT है और अनुबंध कोड स्वैप है, तो सभी USDT-आधारित स्थायी अनुबंधों को क्वेरी किया जाएगा। यह कॉल करने के बराबर हैGetPositions("USDT.swap") |
| वायदा | ट्रेडिंग उत्पाद निर्दिष्ट करें, प्रतीक पैरामीटर हैः |
किसी निर्दिष्ट बीटीसी के यूएसडीटी आधारित स्थायी अनुबंध की क्वेरी करें | वायदा विनिमय वस्तुओं के लिए पैरामीटर प्रतीक का प्रारूप हैःव्यापारिक जोड़ीऔरअनुबंध कोडएफएमजेड प्लेटफॉर्म द्वारा परिभाषित, अक्षरों से अलग".. |
| वायदा | ट्रेडिंग उत्पादों की श्रेणी निर्दिष्ट करें, प्रतीक पैरामीटर हैः |
सभी USDT आधारित स्थायी अनुबंधों की क्वेरी करें | - |
| विकल्पों का समर्थन करने वाले फ्यूचर्स एक्सचेंज | प्रतीक पैरामीटर पास न करें | वर्तमान ट्रेडिंग जोड़ी आयाम सीमा के भीतर सभी विकल्प अनुबंध पूछताछ करें | यदि वर्तमान ट्रेडिंग जोड़ी BTC_USDT है, तो अनुबंध एक विकल्प अनुबंध पर सेट किया जाता है, उदाहरण के लिए, Binance विकल्प अनुबंधः BTC-240108-40000-C |
| विकल्पों का समर्थन करने वाले फ्यूचर्स एक्सचेंज | विशिष्ट व्यापारिक उत्पाद निर्दिष्ट करें | निर्दिष्ट विकल्प अनुबंध की क्वेरी करें | उदाहरण के लिए Binance Futures Exchange के लिए, प्रतीक पैरामीटर हैः BTC_USDT.BTC-240108-40000-C |
| विकल्पों का समर्थन करने वाले फ्यूचर्स एक्सचेंज | ट्रेडिंग उत्पादों की श्रेणी निर्दिष्ट करें, प्रतीक पैरामीटर हैः |
सभी USDT आधारित विकल्प अनुबंधों की खोज करें | - |
मेंGetPositionsकार्य, वायदा विनिमय वस्तु
क्वेरी आयाम सीमा निम्नानुसार संक्षेप में प्रस्तुत की जाती हैः
| प्रतीक पैरामीटर | अनुरोध दायरे की परिभाषा | टिप्पणियाँ |
|---|---|---|
| USDT.swap | यूएसडीटी आधारित स्थायी अनुबंध सीमा। | के लिए |
आयाम जो एक्सचेंज एपीआई इंटरफ़ेस द्वारा समर्थित नहीं हैं, एक त्रुटि की सूचना दी जाएगी और शून्य मान लौटाया जाएगा जब बुला रहा है.
∙ ∙ USDT.futures ∙ ∙ USDT आधारित वितरण अनुबंध रेंज ∙ ∙
USD.swap. मुद्रा आधारित स्थायी विनिमय का दायरा अनुबंध।
∙ ∙ USD.futures ∙ मुद्रा आधारित वितरण का दायरा अनुबंध।
∙ ∙ USDT.option ∙ ∙ ∙ USDT आधारित विकल्प अनुबंध रेंज ∙ ∙ ∙
USD.option. मुद्रा आधारित विकल्प अनुबंध रेंज.
USDT.futures_combo CFD संयोजनों की एक श्रृंखला। फ्यूचर्स_डेरिबिट एक्सचेंज
USD.futures_ff मिश्रित मार्जिन वितरण अनुबंधों का दायरा। फ्यूचर्स_क्रैकेन एक्सचेंज
USD.swap_pf मिश्रित मार्जिन स्थायी अनुबंध सीमा। फ्यूचर्स_क्रैकेन एक्सचेंज
संगतexchange.GetPosition()कॉल करना,GetPositionके समान ही हैGetPositions.
जब विनिमय वस्तु द्वारा दर्शाया गया खाताexchangeमें कोई पद नहीं हैक्वेरी सीमायाविनिर्दिष्ट व्यापारिक साधन,exchange.GetPositions()फ़ंक्शन एक खाली सरणी लौटाता है, उदाहरण के लिएः[].
{@struct/Position Position}, {@fun/Account/exchange.SetCurrency exchange.SetCurrency}, {@fun/Futures/exchange.SetContractType exchange.SetContractType}, {@struct/Position Position}, {@fun/Account/exchange.SetCurrency exchange.SetCurrency}, {@fun/Futures/exchange.SetContractType exchange.SetContractType}, {@fun/Futures/exchange.SetContractType exchange.SetContractType}, {@fun/Futures/exchange.
..exchange.SetMarginLevel()व्यापारिक जोड़ी या अनुबंध के लिए लाभप्रदता मूल्य निर्धारित करने के लिए उपयोग किया जाता है।symbolपैरामीटर केवल पैरामीटर में पारित करने के साथ संगतmarginLevel{@var/EXCHANGE exchange} एक्सचेंज ऑब्जेक्ट की वर्तमान ट्रेडिंग जोड़ी या अनुबंध के लीवरेज मूल्य को निर्धारित करने के लिए।
exchange.SetMarginLevel ((प्रतीक, मार्जिनलेवल) विनिमय.मार्जिन लेवल सेट करें (मार्जिन लेवल)
..symbolपैरामीटर का उपयोग उस ट्रेडिंग जोड़ी या अनुबंध को निर्दिष्ट करने के लिए किया जाता है जिसके लिए लाभप्रदता मूल्य को समायोजित करने की आवश्यकता होती है।symbolपैरामीटरSetMarginLevel()कार्य के प्रारूप के अनुरूप हैsymbolपैरामीटरGetTicker()कार्य।
चिह्न
झूठी
स्ट्रिंग
दmarginLevelपैरामीटर का उपयोग लीवरेज वैल्यू सेट करने के लिए किया जाता है, जो आमतौर पर एक्सचेंजों के लिए एक पूर्णांक होता है और यह कुछ एक्सचेंजों के लिए फ्लोटिंग पॉइंट लीवरेज वैल्यू सेटिंग्स का भी समर्थन करता है।
मार्जिन स्तर
सच
संख्या
function main() {
exchange.SetMarginLevel(10)
// Set the leverage of BTC’s USDT-margined perpetual contract to 15
exchange.SetMarginLevel("BTC_USDT.swap", 15)
}
def main():
exchange.SetMarginLevel(10)
exchange.SetMarginLevel("BTC_USDT.swap", 15)
void main() {
exchange.SetMarginLevel(10);
exchange.SetMarginLevel("BTC_USDT.swap", 15);
}
..exchange.SetMarginLevel()समारोह केवल क्रिप्टोक्यूरेंसी वायदा अनुबंध विनिमय वस्तुओं का समर्थन करता है.exchange.SetMarginLevel()लीवरेज वैल्यू सेट करने के लिए फ़ंक्शन।
क्रिप्टोक्यूरेंसी वायदा अनुबंधों के लिए, लीवरेज तंत्र क्रिप्टोक्यूरेंसी वायदा अनुबंध एक्सचेंजों के कारण समान नहीं है। कुछ एक्सचेंजों में वायदा अनुबंध का लीवरेज मूल्य ऑर्डर प्लेसमेंट इंटरफेस में एक पैरामीटर है, जब ऑर्डर प्लेसमेंट इंटरफेस को कॉल करते हैं, तो लीवरेज का मूल्य एक पैरामीटर होता है।exchange.SetMarginLevel()फ़ंक्शन नेटवर्क अनुरोध उत्पन्न नहीं करता है, लेकिन केवल अंतर्निहित एफएमजेड प्रणाली में लाभप्रदता चर सेट करता है (ऑर्डर प्लेसमेंट इंटरफ़ेस में मापदंडों को पारित करने के लिए उपयोग किया जाता है) । कुछ एक्सचेंज वायदा अनुबंधों का लाभप्रदता मूल्य एक्सचेंज की एक सेटिंग है, जिसे एक्सचेंज वेबसाइट पृष्ठ पर या एपीआई इंटरफ़ेस का उपयोग करके सेट करने की आवश्यकता है। इस मामले मेंexchange.SetMarginLevel()इस प्रकार, यदि कोई फ़ंक्शन नेटवर्क अनुरोध उत्पन्न करता है और लीवरेज सेट करने में विफल हो सकता है, तो इसके कई कारण हो सकते हैं, उदाहरण के लिएः एक वर्तमान स्थिति या लंबित आदेश है, जो इस ट्रेडिंग जोड़ी या अनुबंध के लिए एक नया लीवरेज मान सेट करना असंभव बनाता है।
एक्सचेंजों जो समर्थन नहीं करते हैंexchange.SetMarginLevel()कार्य:
| फ़ंक्शन का नाम | असमर्थित स्पॉट एक्सचेंज | बिना समर्थन वाले फ्यूचर्स एक्सचेंज |
|---|---|---|
| सीमा स्तर सेट करें | – | फ्यूचर्स_डीवाईडीएक्स / फ्यूचर्स_डेरबिट |
{@var/EXCHANGE विनिमय}
..exchange.SetDirection()फंक्शन {@fun/Trade/exchange.Buy exchange.Buy} फ़ंक्शन, {@fun/Trade/exchange.Sell exchange.Sell} फ़ंक्शन के ऑर्डर दिशा को सेट करने के लिए उपयोग किया जाता है जब वायदा अनुबंधों के लिए ऑर्डर दिए जाते हैं।
विनिमय.निर्देश सेट करें (निर्देश)
..directionपैरामीटर का उपयोग ऑर्डर दिए जाने पर वायदा अनुबंध की दिशा निर्धारित करने के लिए किया जाता है। वैकल्पिक मान हैंः"buy", "closesell", "sell", "closebuy".
दिशा
सच
स्ट्रिंग
function main(){
// For example, set to OKX futures contract of this week
exchange.SetContractType("this_week")
// Set leverage to 5 times
exchange.SetMarginLevel(5)
// Set the order type to long
exchange.SetDirection("buy")
// Place an order for 2 contracts at 10,000
exchange.Buy(10000, 2)
exchange.SetMarginLevel(5)
exchange.SetDirection("closebuy")
exchange.Sell(1000, 2)
}
def main():
exchange.SetContractType("this_week")
exchange.SetMarginLevel(5)
exchange.SetDirection("buy")
exchange.Buy(10000, 2)
exchange.SetMarginLevel(5)
exchange.SetDirection("closebuy")
exchange.Sell(1000, 2)
void main() {
exchange.SetContractType("this_week");
exchange.SetMarginLevel(5);
exchange.SetDirection("buy");
exchange.Buy(10000, 2);
exchange.SetMarginLevel(5);
exchange.SetDirection("closebuy");
exchange.Sell(1000, 2);
}
..exchange.SetDirection()फ्यूचर्स कॉन्ट्रैक्ट लेनदेन की दिशा और ऑर्डर प्लेसमेंट फ़ंक्शन के बीच मेल-जोल निर्धारित करता हैः
| ऑर्डर प्लेसमेंट फ़ंक्शन | SetDirection फ़ंक्शन के मापदंडों द्वारा निर्धारित दिशा | टिप्पणी |
|---|---|---|
| exchange.Buy | लंबी पोजीशन खरीदें और खोलें | |
| exchange.Buy | शॉर्ट पोजीशन खरीदें और बंद करें | |
| exchange.Sell | विक्रय और लघु पदों को खोलना | |
| exchange.Sell | लंबी पोजीशन बेचें और बंद करें |
{@fun/Trade/exchange.Buy exchange.Buy}, {@fun/Trade/exchange.Sell exchange.Sell}
..exchange.SetContractType(){@var/EXCHANGE exchange} एक्सचेंज ऑब्जेक्ट के वर्तमान अनुबंध कोड को सेट करने के लिए फ़ंक्शन का उपयोग किया जाता है.
..exchange.SetContractType()फ़ंक्शन एक संरचना लौटाता है जिसमें एक्सचेंज कॉन्ट्रैक्ट कोड होता है जो वर्तमान कॉन्ट्रैक्ट कोड के अनुरूप होता है। उदाहरण के लिए बिनेंस फ्यूचर्स कॉन्ट्रैक्ट एक्सचेंज के लिए, वर्तमान कॉन्ट्रैक्ट कोड हैquarter, और इस फलन का रिटर्न मान संरचना हैः{"InstrumentID": "BTCUSD_230630", "instrument": "BTCUSD_230630"}.
वस्तु
exchange.SetContractType ((प्रतीक)
..symbolपैरामीटर का उपयोग अनुबंध कोड सेट करने के लिए किया जाता है, वैकल्पिक मान हैंः"this_week", "next_week", "quarter", "next_quarter", "swap"आदि।
क्रिप्टोकरेंसी वायदा अनुबंधवितरण अनुबंधकोड, यदि निर्दिष्ट नहीं हैं, तो आम तौर पर होते हैंः
this_week: चालू सप्ताह का अनुबंध।next_week: अगले सप्ताह का अनुबंध।quarter: त्रैमासिक अनुबंध।next_quarter: अगले त्रैमासिक अनुबंध।स्थायी अनुबंधक्रिप्टोक्यूरेंसी वायदा अनुबंधों में कोड, यदि निर्दिष्ट नहीं हैं, तो आम तौर पर निम्नलिखित होते हैंःswap: शाश्वत अनुबंध।चिह्न सच स्ट्रिंग
function main() {
// Set to this week contract
exchange.SetContractType("this_week")
}
def main():
exchange.SetContractType("this_week")
void main() {
exchange.SetContractType("this_week");
}
वर्तमान अनुबंध को वर्तमान सप्ताह के अनुबंध के रूप में सेट करें:
function main() {
// The default trading pair is BTC_USD, set the contract for this week, and the contract is a currency standard contract
exchange.SetContractType("this_week")
Log("ticker:", exchange.GetTicker())
// Switching trading pairs, then setting up contracts, switching to USDT as margin contracts, as opposed to currency standard contracts
exchange.IO("currency", "BTC_USDT")
exchange.SetContractType("swap")
Log("ticker:", exchange.GetTicker())
}
def main():
exchange.SetContractType("this_week")
Log("ticker:", exchange.GetTicker())
exchange.IO("currency", "BTC_USDT")
exchange.SetContractType("swap")
Log("ticker:", exchange.GetTicker())
void main() {
exchange.SetContractType("this_week");
Log("ticker:", exchange.GetTicker());
exchange.IO("currency", "BTC_USDT");
exchange.SetContractType("swap");
Log("ticker:", exchange.GetTicker());
}
के साथ अनुबंध बनाते समयUSDTमार्जिन के रूप में, आपको कोड में ट्रेडिंग जोड़ी को स्विच करने की आवश्यकता है (आप एक्सचेंज ऑब्जेक्ट जोड़ते समय ट्रेडिंग जोड़ी को सीधे भी सेट कर सकते हैं):
function main(){
// Set the contract for this week
var ret = exchange.SetContractType("this_week")
// Return information about the current week's contracts
Log(ret)
}
def main():
ret = exchange.SetContractType("this_week")
Log(ret)
void main() {
auto ret = exchange.SetContractType("this_week");
Log(ret);
}
रिटर्न मान मुद्रित करेंexchange.SetContractType()कार्य:
क्रिप्टोक्यूरेंसी वायदा अनुबंध रणनीति में, उदाहरण के लिए ले लोBTC_USDTव्यापारिक जोड़ीः जब व्यापारिक जोड़े को बदलते समयexchange.SetCurrency("BTC_USDT")याexchange.IO("currency", "BTC_USDT")कार्यों, स्विच करने के बाद, आप का उपयोग करने की जरूरत हैexchange.SetContractType()प्रणाली यह निर्धारित करती है कि क्या यह एक नया ट्रेडिंग जोड़ा है या नहीं।मुद्रा मानक अनुबंधया एकUSDT मानक अनुबंधउदाहरण के लिए, यदि एक ट्रेडिंग जोड़ी कोBTC_USDT, का प्रयोग करेंexchange.SetContractType("swap")अनुबंध कोड को सेट करने के लिए कार्यswapइस बिंदु पर, यह सेट हैBTCके लिएUSDT मानकयदि व्यापारिक जोड़ीBTC_USD, का प्रयोग करेंexchange.SetContractType("swap")अनुबंध कोड को सेट करने के लिए कार्यswapइस बिंदु पर, यह सेट हैBTCहैमुद्रा मानकस्थायी अनुबंध।
समर्थित क्रिप्टोक्यूरेंसी वायदा अनुबंध एक्सचेंजों का विवरण, प्रत्येक एक्सचेंज के लिए अनुबंध नामों के साथ निम्नानुसारः
फ्यूचर्स_OKCoin (OKX)
स्थायी अनुबंधों के लिए सेट करेंःexchange.SetContractType("swap")इस सप्ताह के अनुबंध के लिए सेटःexchange.SetContractType("this_week")अगले सप्ताह के अनुबंध के लिए सेटःexchange.SetContractType("next_week")मासिक अनुबंध पर सेट करेंःexchange.SetContractType("month")अगले महीने के अनुबंध के लिए सेटःexchange.SetContractType("next_month")त्रैमासिक अनुबंधों में सेटःexchange.SetContractType("quarter")अगली तिमाही के अनुबंध के लिए सेटःexchange.SetContractType("next_quarter")
ओकेएक्स के पास प्री-मार्केट ट्रेडिंग अनुबंध हैंः अनुबंध वितरण तिथि एक निश्चित समय है। एक्सचेंज द्वारा परिभाषित अनुबंध कोड उदाहरण के लिए हैःHMSTR-USDT-250207. व्यापारिक जोड़ी को सेट करेंHMSTR_USDTएफएमजेड प्लेटफॉर्म पर, और फिर उपयोगexchange.SetContractType("HMSTR-USDT-250207")अनुबंध स्थापित करने के लिए।
कार्य के लिए जो समर्थन करते हैंsymbolपैरामीटर, जैसेःexchange.GetTicker(), exchange.CreateOrder(), आदि आप निर्दिष्ट कर सकते हैंsymbolपैरामीटर के रूप मेंःHMSTR_USDT.HMSTR-USDT-250207इस अनुबंध के बाज़ार के आंकड़े प्राप्त करने या आदेश देने के लिए।
फ्यूचर्स_हुओबीडीएम (हुओबी वायदा)
इस सप्ताह के अनुबंध के लिए सेटःexchange.SetContractType("this_week").
अगले सप्ताह के अनुबंध के लिए सेटःexchange.SetContractType("next_week").
त्रैमासिक अनुबंधों में सेटःexchange.SetContractType("quarter").
अगली तिमाही के अनुबंध के लिए सेटःexchange.SetContractType("next_quarter").
स्थायी अनुबंधों के लिए सेट करेंःexchange.SetContractType("swap").
यह अनुबंध का समर्थन करता हैUSDTमार्जिन के रूप में, लेBTCउदाहरण के तौर पर अनुबंधः उपयोगexchange.IO("currency", "BTC_USDT")एक अनुबंध पर स्विच करने के लिए जो उपयोग करता हैUSDTमार्जिन के रूप में।
या वर्तमान ट्रेडिंग जोड़ी कोBTC_USDTसीधे लाइव ट्रेडिंग मापदंडों को कॉन्फ़िगर करते समय और विनिमय वस्तुओं को जोड़ने के बाद।exchange.SetContractType()अनुबंध सेट करने के लिए फिर से कार्य।
फ्यूचर्स_बिटएमईएक्स (बिटएमईएक्स)
स्थायी अनुबंधों के लिए सेट करेंःexchange.SetContractType("swap").
फ्यूचर्स_बिटमेक्स एक्सचेंज डिलीवरी कॉन्ट्रैक्ट्स निम्नलिखित कॉन्ट्रैक्ट कोड (जनवरी से दिसंबर तक) वाले मासिक कॉन्ट्रैक्ट हैं:
"January", "February", "March", "April", "May", "June", "July", "August", "September", "October", "November", "December"
वितरण अनुबंध की स्थापनाःexchange.SetContractType("December")उदाहरण के लिए, जब ट्रेडिंग जोड़ी कोXBT_USDT,exchange.SetContractType("December")कार्य को BTC के आधार पर USDT में दिसंबर की डिलीवरी के लिए अनुबंध सेट करने के लिए कहा जाता है (जो की वास्तविक अनुबंध कोड के अनुरूप हैXBTUSDTZ23).
फ्यूचर्स_बिटमेक्स अनुबंध सूचना सारांश
| Futures_BitMEX द्वारा परिभाषित अनुबंध कोड | एफएमजेड में संबंधित ट्रेडिंग जोड़ी | एफएमजेड में संबंधित अनुबंध कोड | टिप्पणियाँ |
|---|---|---|---|
| DOGEUSD | DOGE_USD | स्वैप | अमरीकी डालर में मुद्रित, एक्सबीटी सेटल। एक्सबीटी बीटीसी है। |
| DOGEUSDT | DOGE_USDT | स्वैप | USDT में मुद्रित, USDT में निपटान। |
| XBTETH | XBT_ETH | स्वैप | ईटीएच में अंकित, एक्सबीटी सेटल। |
| एक्सबीटीयूआर | XBT_EUR | स्वैप | यूरो में अंकित, एक्सबीटी में निपटान किया गया। |
| USDTUSDC | USDT_USDC | स्वैप | यूएसडीसी में अंकित, एक्सबीटी में निपटान। |
| ETHUSD_ETH | ETH_USD_ETH | स्वैप | अमरीकी डालर में मुद्रित, ईटीएच में निपटान। |
| XBTH24 | XBT_USD | मार्च | समाप्ति तिथिः 24 मार्च, महीने का कोड हैः एच; अमरीकी डालर में, एक्सबीटी में निपटान। |
| ETHUSDZ23 | ETH_USD | दिसम्बर | समाप्ति तिथिः 23 दिसम्बर, महीने का कोड हैः Z; USD में तारिख, XBT में निपटान। |
| XBTUSDTZ23 | XBT_USDT | दिसम्बर | समाप्ति तिथिः 23 दिसंबर, महीने का कोड हैः Z ; USDT में मुद्रित, USDT में निपटान किया गया। |
| ADAZ23 | ADA_XBT | दिसम्बर | समाप्ति तिथिः 23 दिसंबर, महीने का कोड हैः Z ; XBT बिलिंग, XBT सेटल। |
| P_XBTETFX23 | USDT_XXX | P_XBTETFX23 | समाप्ति तिथिः 11/23/23; प्रतिशत के रूप में और USDT में निपटान किया गया। |
फ्यूचर्स_गेटियो
इस सप्ताह के अनुबंध के लिए सेटःexchange.SetContractType("this_week").
अगले सप्ताह के अनुबंध के लिए सेटःexchange.SetContractType("next_week").
त्रैमासिक अनुबंधों में सेटःexchange.SetContractType("quarter").
अगली तिमाही के अनुबंध के लिए सेटःexchange.SetContractType("next_quarter").
स्थायी अनुबंधों के लिए सेट करेंःexchange.SetContractType("swap").
यह अनुबंध का समर्थन करता हैUSDTमार्जिन के रूप में, लेBTCउदाहरण के तौर पर अनुबंधः उपयोगexchange.IO("currency", "BTC_USDT")एक अनुबंध पर स्विच करने के लिए जो उपयोग करता हैUSDTमार्जिन के रूप में।
या वर्तमान ट्रेडिंग जोड़ी कोBTC_USDTसीधे लाइव ट्रेडिंग मापदंडों को कॉन्फ़िगर करते समय और विनिमय वस्तुओं को जोड़ने के बाद।exchange.SetContractType()अनुबंध सेट करने के लिए फिर से कार्य।
फ्यूचर्स_डेरबिट
स्थायी अनुबंधों के लिए सेट करेंःexchange.SetContractType("swap").
यह डेरिबिट्स का समर्थन करता हैUSDCअनुबंध।
वितरण संविदाएं इस प्रकार हैं:"this_week", "next_week", "month", "quarter", "next_quarter", "third_quarter", "fourth_quarter".
सीएफडी (फ्यूचर_कॉम्बो):"this_week,swap", "next_week,swap", "next_quarter,this_week", "third_quarter,this_week", "month,next_week", कई संयोजन हैं।
विकल्प अनुबंधों के लिए आपको एक्सचेंज द्वारा परिभाषित विशिष्ट विकल्प अनुबंध कोड में पास करने की आवश्यकता है, विवरण के लिए Deribit वेबसाइट देखें।
वायदा_कुकोइन
उदाहरण के लिए, यदि ट्रेडिंग जोड़ी कोBTC_USDऔर अनुबंध कोड सेट है, यह मुद्रा आधारित अनुबंध हैः
स्थायी अनुबंधों के लिए सेट करेंःexchange.SetContractType("swap").
त्रैमासिक अनुबंधों में सेटःexchange.SetContractType("quarter").
अगली तिमाही के अनुबंध के लिए सेटःexchange.SetContractType("next_quarter").
मार्जिन अनुबंध के रूप में USDT:
उदाहरण के लिए, यदि ट्रेडिंग जोड़ी कोBTC_USDT, और फिर अनुबंध कोड सेट करें, यह USDT के साथ एक अनुबंध है।
स्थायी अनुबंधों के लिए सेट करेंःexchange.SetContractType("swap").
वायदा_बाइनेंस
बिनेंस फ्यूचर्स एक्सचेंज वर्तमान ट्रेडिंग जोड़ी के स्थायी अनुबंध के लिए डिफ़ॉल्ट, अनुबंध कोडःswap.
स्थायी अनुबंधों के लिए सेट करेंःexchange.SetContractType("swap"), बिनेंस के स्थायी अनुबंधों में ऐसे अनुबंध हैं जो उपयोग करते हैंUSDTमार्जिन के रूप में। उदाहरण के लिए,USDTमानक स्थायी अनुबंधBTCएक मार्जिन अनुबंध के रूप में इस्तेमाल किया जा सकता है, और व्यापार जोड़ी के लिए सेट हैBTC_USDT. बिनेंस स्थायी अनुबंधों का भी समर्थन करता है जो उदाहरण के लिए, मार्जिन के रूप में सिक्कों का उपयोग करते हैं,BTCBinance के मानक शाश्वत अनुबंध, व्यापार जोड़ी के साथ सेट करने के लिएBTC_USD.
त्रैमासिक अनुबंधों में सेटःexchange.SetContractType("quarter"), वितरण अनुबंध में मुद्रा मानक अनुबंध होता है (यानी, मुद्राओं को मार्जिन के रूप में उपयोग करना), उदाहरण के लिए,BTCके तिमाही अनुबंध में, व्यापारिक जोड़ी को निम्न पर सेट किया गया हैःBTC_USDऔर फिर अनुबंध सेटexchange.SetContractType("quarter"), पर सेट हैBTCमुद्रा मानक अनुबंध के साथ त्रैमासिक अनुबंध।
अगले तिमाही अनुबंध के लिए सेट करेंःexchange.SetContractType("next_quarter")उदाहरण के लिए,BTCमुद्रा मानक त्रैमासिक अनुबंध की, व्यापारिक जोड़ी को निम्न पर सेट किया गया हैःBTC_USD, और फिर अनुबंध सेटexchange.SetContractType("next_quarter").
बाइनेंस आंशिक समर्थन करता हैUSDTमार्जिन वितरण अनुबंध के रूप में, लेBTCउदाहरण के लिए, व्यापारिक जोड़ी को सेट करेंBTC_USDT, फिर अनुबंध कोड सेट करें।
बिनेंस विकल्प अनुबंधों के लिए समर्थनः
विकल्प अनुबंध कोड का प्रारूप एक्सचेंज द्वारा परिभाषित विकल्प अनुबंध कोड पर आधारित हैःBTC-241227-15000-C, XRP-240112-0.5-C, BTC-241227-15000-P. Binance विकल्प अनुबंध कोड ले लोBTC-241227-15000-Pउदाहरण के लिएः BTC विकल्प मुद्रा कोड है, 241227 अभ्यास तिथि है, 15000 अभ्यास मूल्य है, P एक बिक्री विकल्प और C एक कॉल विकल्प का प्रतिनिधित्व करता है।
विकल्प के प्रकार के बारे में विवरण, चाहे वह यूरोपीय विकल्प हो या अमेरिकी विकल्प, कृपया एक्सचेंज के विकल्प अनुबंध की प्रासंगिक जानकारी देखें।
विनिमय विकल्प विक्रेताओं को प्रतिबंधित कर सकता है और उन्हें योग्यता के लिए अलग से आवेदन करने की आवश्यकता हो सकती है। बिनेंस विकल्पों के लिए विक्रेता योग्यता की आवश्यकता होती है।
वायदा_बिबॉक्स
बिबॉक्स स्थायी अनुबंधों के लिए अनुबंध कोडःswap.
स्थायी अनुबंधों के लिए सेट करेंःexchange.SetContractType("swap").
फ्यूचर्स_बीबिट
डिफ़ॉल्ट रूप से वर्तमान ट्रेडिंग जोड़ी के लिए स्थायी अनुबंध है, अनुबंध कोडःswap.
इस सप्ताह अनुबंध कोडःthis_week.
अगले सप्ताह अनुबंध कोडःnext_week.
तीसरे सप्ताह का अनुबंध कोडःthird_week.
मासिक अनुबंध कोडःmonth.
अगले महीने का अनुबंध कोडःnext_month.
त्रैमासिक अनुबंध कोडःquarter.
अगली तिमाही अनुबंध कोडःnext_quarter.
तीसरी तिमाही अनुबंध कोडःthird_quarter.
फ्यूचर्स_क्राकेन
डिफ़ॉल्ट वर्तमान ट्रेडिंग जोड़ी का स्थायी अनुबंध है, अनुबंध कोडःswap.
swap: शाश्वत अनुबंध।month: चालू माह का अनुबंध।quarter: त्रैमासिक अनुबंध।next_quarterअगले तिमाही का अनुबंध।swap_pfमिश्रित मार्जिन वाला स्थायी अनुबंध।quarter_ff: मिश्रित मार्जिन वाला त्रैमासिक अनुबंध।month_ff: मिश्रित मार्जिन चालू माह का अनुबंध।next_quarter_ff: मिश्रित मार्जिन अगले तिमाही अनुबंध।
फ्यूचर्स_बिटफाइनएक्स
डिफ़ॉल्ट वर्तमान ट्रेडिंग जोड़ी के लिए स्थायी अनुबंध है, अनुबंध कोडःswap.
फ्यूचर्स_बिटगेट
डिफ़ॉल्ट वर्तमान ट्रेडिंग जोड़ी के लिए स्थायी अनुबंध है, अनुबंध कोडःswap.
व्यापारिक जोड़ी कोBTC_USDमुद्रा मानक अनुबंधों के लिए, और व्यापारिक जोड़ी कोBTC_USDTद्वारा निपटारे किए गए अनुबंधों के लिएUSDT. डेमो अनुबंधों को व्यापारिक जोड़े के साथ स्थापित किया जा सकता है जैसेSBTC_USD, BTC_SUSDT.
फ्यूचर्स_डीवाईडीएक्स
dYdX स्थायी अनुबंधों के लिए अनुबंध कोडःswap.
स्थायी अनुबंधों के लिए सेट करेंःexchange.SetContractType("swap"), dYdX में केवल USDT मानक अनुबंध हैं।
फ्यूचर्स_मेक्सिको
एमईएक्ससी स्थायी अनुबंधों के लिए अनुबंध कोडःswap.
स्थायी अनुबंधों के लिए सेट करेंःexchange.SetContractType("swap"). व्यापारिक जोड़ी को सेट करेंBTC_USD, जो मुद्रा मानक अनुबंध है, और व्यापार जोड़ी को सेट करने के लिएBTC_USDT, जो कि हैUSDT- समझौता किया।
वायदा_क्रिप्टो
खाते में टोकनcrypto.comविनिमय को USD में तब्दील कर दिया जा सकता है, जिसका उपयोग अनुबंध व्यापार के लिए मार्जिन के रूप में किया जा सकता है।
स्थायी अनुबंध पर सेट करेंःexchange.SetContractType("swap"). उदाहरण के लिएexchange.SetContractType("swap")BTC के लिए एक स्थायी अनुबंध सेट करने के लिए समारोह जब व्यापार जोड़ी के लिए सेट किया गया हैBTC_USD.
दcrypto.comविनिमय वितरण अनुबंध निम्नलिखित अनुबंध कोडों के साथ मासिक अनुबंध हैं (जनवरी से दिसंबर तक):
"January", "February", "March", "April", "May", "June", "July", "August", "September", "October", "November", "December"
वितरण अनुबंध सेट करेंःexchange.SetContractType("October")उदाहरण के लिए, जब ट्रेडिंग जोड़ी कोBTC_USD, फ़ंक्शन को कॉल करेंexchange.SetContractType("October")बीटीसी के लिए अक्टूबर के वितरण अनुबंध को निर्धारित करने के लिए।
वर्तमान समय में संबंधित अनुबंध कोड हैःBTCUSD-231027.
फ्यूचर्स_WOO
वायदा_WOO विनिमय समर्थनUSDTके एक स्थायी अनुबंध कोड के साथ आधारित अनुबंधswapउदाहरण के लिए, जब ट्रेडिंग जोड़ी कोBTC_USDT, कार्यexchange.SetContractType("swap")वर्तमान अनुबंध को BTC के लिए USDT आधारित स्थायी अनुबंध के रूप में स्थापित करने के लिए कहा जाता है।
{@fun/Futures/exchange.GetContractType exchange.GetContractType}, {@fun/Account/exchange.SetCurrency exchange.SetCurrency}, {@fun/Futures/Futures/exchange.GetContractType exchange.GetContractType}, {@fun/Account/exchange.SetCurrency exchange.SetCurrency}, {@fun/Account/exchange.
..exchange.GetContractType(){@var/EXCHANGE exchange} एक्सचेंज ऑब्जेक्ट की वर्तमान सेटिंग के लिए कॉन्ट्रैक्ट कोड प्राप्त करने के लिए फ़ंक्शन का उपयोग किया जाता है.
..exchange.GetContractType()फ़ंक्शन एफएमजेड प्लेटफॉर्म द्वारा परिभाषित अनुबंध कोड लौटाता है, उदाहरण के लिएःthis_week, swapआदि।
स्ट्रिंग
exchange.GetContractType (()
function main () {
Log(exchange.SetContractType("this_week"))
Log(exchange.GetContractType())
}
def main():
Log(exchange.SetContractType("this_week"))
Log(exchange.GetContractType())
void main() {
Log(exchange.SetContractType("this_week"));
Log(exchange.GetContractType());
}
{@fun/Futures/exchange.SetContractType exchange.SetContractType}
..exchange.GetFundings()वर्तमान अवधि के लिए वित्तपोषण दर के आंकड़ों को प्राप्त करने के लिए कार्य का उपयोग किया जाता है।
..exchange.GetFundings()फ़ंक्शन {@struct/Funding Funding} संरचनाओं की एक सरणी देता है जब डेटा अनुरोध सफल होता है, और डेटा अनुरोध विफल होने पर शून्य मान देता है.
{@struct/Funding Funding} सरणी, शून्य मान
विनिमय.वित्तपोषण प्राप्त करें exchange.GetFundings (प्रतीक)
पैरामीटरsymbolसेट करने के लिए प्रयोग किया जाता हैलेनदेन चिह्नयालेन-देन प्रतीक श्रेणीप्रश्न पूछने के लिए।symbolपैरामीटर पारित नहीं किया जाता है, सभी साधनों की वर्तमान वित्तपोषण दर डेटा को मौजूदा ट्रेडिंग जोड़ी और अनुबंध कोड के आयाम सीमा में डिफ़ॉल्ट रूप से अनुरोध किया जाएगा।
चिह्न झूठी स्ट्रिंग
/*backtest
start: 2024-10-01 00:00:00
end: 2024-10-23 00:05:00
period: 1m
basePeriod: 1m
exchanges: [{"eid":"Futures_Binance","currency":"SOL_USDC"}]
*/
function main() {
// LPT_USDT.swap 4-hour period
var symbols = ["SOL_USDT.swap", "ETH_USDT.swap", "LTC_USDT.swap", "SOL_USDC.swap", "ETH_USDC.swap", "BTC_USD.swap", "BTC_USDT.quarter", "LPT_USDT.swap"]
for (var symbol of symbols) {
exchange.GetTicker(symbol)
}
var arr = []
var arrParams = ["no param", "LTC_USDT.swap", "USDT.swap", "USD.swap", "USDC.swap", "USDT.futures", "BTC_USDT.quarter"]
for (p of arrParams) {
if (p == "no param") {
arr.push(exchange.GetFundings())
} else {
arr.push(exchange.GetFundings(p))
}
}
var tbls = []
var index = 0
for (var fundings of arr) {
var tbl = {
"type": "table",
"title": arrParams[index],
"cols": ["Symbol", "Interval", "Time", "Rate"],
"rows": [],
}
for (var f of fundings) {
tbl["rows"].push([f.Symbol, f.Interval / 3600000, _D(f.Time), f.Rate * 100 + " %"])
}
tbls.push(tbl)
index++
}
LogStatus(_D(), "\n Requested market types:", symbols, "\n`" + JSON.stringify(tbls) + "`")
}
'''backtest
start: 2024-10-01 00:00:00
end: 2024-10-23 00:05:00
period: 1m
basePeriod: 1m
exchanges: [{"eid":"Futures_Binance","currency":"SOL_USDC"}]
'''
import json
def main():
# LPT_USDT.swap 4-hour period
symbols = ["SOL_USDT.swap", "ETH_USDT.swap", "LTC_USDT.swap", "SOL_USDC.swap", "ETH_USDC.swap", "BTC_USD.swap", "BTC_USDT.quarter", "LPT_USDT.swap"]
for symbol in symbols:
exchange.GetTicker(symbol)
arr = []
arrParams = ["no param", "LTC_USDT.swap", "USDT.swap", "USD.swap", "USDC.swap", "USDT.futures", "BTC_USDT.quarter"]
for p in arrParams:
if p == "no param":
arr.append(exchange.GetFundings())
else:
arr.append(exchange.GetFundings(p))
tbls = []
index = 0
for fundings in arr:
tbl = {
"type": "table",
"title": arrParams[index],
"cols": ["Symbol", "Interval", "Time", "Rate"],
"rows": [],
}
for f in fundings:
tbl["rows"].append([f["Symbol"], f["Interval"] / 3600000, _D(f["Time"]), str(f["Rate"] * 100) + " %"])
tbls.append(tbl)
index += 1
LogStatus(_D(), "\n Requested market types:", symbols, "\n`" + json.dumps(tbls) + "`")
/*backtest
start: 2024-10-01 00:00:00
end: 2024-10-23 00:05:00
period: 1m
basePeriod: 1m
exchanges: [{"eid":"Futures_Binance","currency":"SOL_USDC"}]
*/
void main() {
// LPT_USDT.swap 4-hour period
json arrSymbol = R"([])"_json;
std::string symbols[] = {"SOL_USDT.swap", "ETH_USDT.swap", "LTC_USDT.swap", "SOL_USDC.swap", "ETH_USDC.swap", "BTC_USD.swap", "BTC_USDT.quarter", "LPT_USDT.swap"};
for (const std::string& symbol : symbols) {
exchange.GetTicker(symbol);
arrSymbol.push_back(symbol);
}
std::vector<std::vector<Funding>> arr = {};
std::string arrParams[] = {"no param", "LTC_USDT.swap", "USDT.swap", "USD.swap", "USDC.swap", "USDT.futures", "BTC_USDT.quarter"};
for (const std::string& p : arrParams) {
if (p == "no param") {
arr.push_back(exchange.GetFundings());
} else {
arr.push_back(exchange.GetFundings(p));
}
}
json tbls = R"([])"_json;
int index = 0;
for (int i = 0; i < arr.size(); i++) {
auto fundings = arr[i];
json tbl = R"({
"type": "table",
"cols": ["Symbol", "Interval", "Time", "Rate"],
"rows": []
})"_json;
tbl["title"] = arrParams[index];
for (int j = 0; j < fundings.size(); j++) {
auto f = fundings[j];
// json arrJson = {f.Symbol, f.Interval / 3600000, _D(f.Time), string(f.Rate * 100) + " %"};
json arrJson = {f.Symbol, f.Interval / 3600000, _D(f.Time), f.Rate};
tbl["rows"].push_back(arrJson);
}
tbls.push_back(tbl);
index++;
}
LogStatus(_D(), "\n Requested market types:", arrSymbol.dump(), "\n`" + tbls.dump() + "`");
}
फ्यूचर्स एक्सचेंज ऑब्जेक्ट का उपयोग करेंexchange.GetFundings()बैकटेस्टिंग सिस्टम में फ़ंक्शन। किसी भी बाजार फ़ंक्शन को कॉल करने से पहले, GetFundings केवल वर्तमान डिफ़ॉल्ट ट्रेडिंग जोड़ी के फंडिंग डेटा को लौटाता है। बाजार फ़ंक्शन को कॉल करने के बाद, यह सभी अनुरोधित किस्मों के फंडिंग डेटा को लौटाता है। आप निम्नलिखित परीक्षण उदाहरण का संदर्भ ले सकते हैंः
फ्यूचर्स एक्सचेंजों के लिए जो फंडिंग दर डेटा के बैच क्वेरी का समर्थन नहीं करते हैं, यदिsymbolपैरामीटर क्वेरी रेंज के रूप में निर्दिष्ट किया जाता है, उदाहरण के लिएःUSDT.swapयाsymbolपैरामीटर पारित नहीं किया जाता है, इंटरफ़ेस एक त्रुटि रिपोर्ट करेगा.GetFundings()फ्यूचर्स एक्सचेंज ऑब्जेक्ट के इस प्रकार का उपयोग कर समारोह, आप निर्दिष्ट करना होगाsymbolपैरामीटर को एक विशिष्ट स्थायी अनुबंध प्रकार के रूप में इस प्रकार के वर्तमान वित्तपोषण दर डेटा को क्वेरी करने के लिए।
दexchange.GetFundings()कार्य वास्तविक व्यापार और बैकटेस्टिंग प्रणालियों का समर्थन करता है।
एक्सचेंज जो फंडिंग दर डेटा के बैच अधिग्रहण का समर्थन नहीं करते हैंः फ्यूचर्स_बिटगेट, फ्यूचर्स_ओकेएक्स, फ्यूचर्स_एमईएक्ससी, फ्यूचर्स_डेरबिट, फ्यूचर्स_क्रिप्टो।symbolविशिष्ट प्रतीक कोड के साथ पैरामीटर, उदाहरण के लिएःETH_USDT.swap.
एक्सचेंजों जो समर्थन नहीं करते हैंexchange.GetFundings()कार्य:
| फ़ंक्शन का नाम | असमर्थित स्पॉट एक्सचेंज | बिना समर्थन वाले फ्यूचर्स एक्सचेंज |
|---|---|---|
| प्राप्त करें | – | फ्यूचर्स_डिजीफाइनक्स |
{@struct/फंडिंग फंडिंग}
..exchange.SetBase(){@var/EXCHANGE exchange} एक्सचेंज ऑब्जेक्ट में कॉन्फ़िगर किए गए एक्सचेंज एपीआई इंटरफेस के आधार पते को सेट करने के लिए फ़ंक्शन का उपयोग किया जाता है.
exchange.SetBase ((s)
..sपैरामीटर का उपयोग एक्सचेंज एपीआई इंटरफेस बेस पता निर्दिष्ट करने के लिए किया जाता है.
s
सच
स्ट्रिंग
function main() {
// Use default base address
Log(exchange.GetTicker())
// Switch to https://aws.okx.com
exchange.SetBase("https://aws.okx.com")
Log(exchange.GetTicker())
}
def main():
Log(exchange.GetTicker())
exchange.SetBase("https://aws.okx.com")
Log(exchange.GetTicker())
void main() {
Log(exchange.GetTicker());
exchange.SetBase("https://aws.okx.com");
Log(exchange.GetTicker());
}
एक्सचेंज एपीआई आधार पते को स्विच करना बैकटेस्टिंग सिस्टम में समर्थित नहीं है, क्योंकि बैकटेस्टिंग सिस्टम एक सैंडबॉक्स सिमुलेशन वातावरण है और यह वास्तव में एक्सचेंज एपीआई इंटरफ़ेस तक नहीं पहुंचता है।
{@fun/Trade/exchange.IO exchange.IO}
..exchange.GetBase()फ़ंक्शन का उपयोग वर्तमान एक्सचेंज एपीआई इंटरफ़ेस आधार पता प्राप्त करने के लिए किया जाता है.
वर्तमान एक्सचेंज एपीआई इंटरफ़ेस आधार पता. स्ट्रिंग
विनिमय.GetBase()
function main() {
Log(exchange.GetBase())
}
def main():
Log(exchange.GetBase())
void main() {
Log(exchange.GetBase());
}
{@fun/NetSettings/exchange.SetBase exchange.SetBase}
..exchange.SetProxy(){@var/EXCHANGE exchange} एक्सचेंज ऑब्जेक्ट के प्रॉक्सी कॉन्फ़िगरेशन को सेट करने के लिए फ़ंक्शन का उपयोग किया जाता है.
exchange.SetProxy ((प्रॉक्सी)
..proxyपैरामीटर का उपयोग प्रॉक्सी कॉन्फ़िगरेशन निर्दिष्ट करने के लिए किया जाता है.
प्रोक्सी
सच
स्ट्रिंग
function main() {
exchange.SetProxy("socks5://192.168.1.10:8080")
// If you can't access the exchange ticker interface, set up an available ss5 proxy and you can access the ticker interface
Log(exchange.GetTicker())
}
def main():
exchange.SetProxy("socks5://192.168.1.10:8080")
Log(exchange.GetTicker())
void main() {
exchange.SetProxy("socks5://192.168.1.10:8080");
Log(exchange.GetTicker());
}
{@var/EXCHANGE exchange} विनिमय वस्तु को कॉन्फ़िगर करेंsocks5प्रोक्सीः
function main(){
exchange.SetProxy("ip://10.0.3.15")
// The requested IP address is 10.0.3.15
exchange.GetTicker()
}
def main():
exchange.SetProxy("ip://10.0.3.15")
exchange.GetTicker()
void main() {
exchange.SetProxy("ip://10.0.3.15");
exchange.GetTicker();
}
इसके अतिरिक्तवैश्विक विनिर्देश{@var/EXCHANGE exchange} एक्सचेंज ऑब्जेक्ट से अनुरोध के आईपी पते का, {@var/EXCHANGE exchange} के आधार पर एक आईपी पते को निर्दिष्ट करने के लिए भी समर्थन हैः
यदि प्रॉक्सी सेटिंग विफल हो जाती है, तोexchange.SetProxy()फ़ंक्शन कॉल करने पर शून्य लौटा देगा.exchange.SetProxy()कार्य के लिए प्रॉक्सी सेट करता हैrestप्रत्येक {@var/EXCHANGE exchange} एक्सचेंज ऑब्जेक्ट के लिए एक प्रॉक्सी सेट किया जा सकता है, और प्रॉक्सी सेट करने के बाद {@var/EXCHANGE exchange} एक्सचेंज ऑब्जेक्ट से बंधे एक्सचेंज इंटरफ़ेस तक पहुंच प्रॉक्सी के माध्यम से प्राप्त की जाएगी.
सेटिंग के लिए समर्थनsocks5प्रॉक्सी, पहला एक्सचेंज ऑब्जेक्ट {@var/EXCHANGE exchange} जोड़कर, यानीःexchanges[0]उदाहरण के तौर परः
exchange.SetProxy("socks5://127.0.0.1:8889").exchange.SetProxy("socks5://username:password@127.0.0.1:8889"). usernameउपयोगकर्ता नाम है औरpasswordपासवर्ड है।exchange.SetProxy("").{@var/EXCHANGE exchange} विनिमय वस्तु से अनुरोध का आईपी पता सेट करने का समर्थन करता है,वैश्विक रूप से निर्दिष्ट.
{@var/EXCHANGE विनिमय}
..exchange.SetTimeout()समय सीमा निर्धारित करने के लिए उपयोग किया जाता हैrest{@var/EXCHANGE exchange} एक्सचेंज ऑब्जेक्ट के लिए अनुरोध.
विनिमय.सेटटाइमआउट ((टाइमआउट)
..timeoutपैरामीटर का उपयोग टाइमआउट सेटिंग के लिए मिलीसेकंड की संख्या निर्दिष्ट करने के लिए किया जाता है।
टाइमआउट
सच
संख्या
function main() {
exchange.SetTimeout(3000)
Log(exchange.GetTicker())
}
def main():
exchange.SetTimeout(3000)
Log(exchange.GetTicker())
void main() {
exchange.SetTimeout(3000);
Log(exchange.GetTicker());
}
पैरामीटरtimeoutएक मिलीसेकंड मान है, 1000 मिलीसेकंड 1 सेकंड के बराबर है।restकेवल प्रोटोकॉल, पर टाइमआउट सेट करने के लिए इस्तेमाल कियाrestअनुरोधों, यह केवल एक बार सेट करके प्रभाव पड़ता है. उदाहरण के लिए,exchange.SetTimeout(3000), सेट करता हैrestसमय सीमा का अनुरोध करेंexchangeनेटवर्क अनुरोधों के साथ कार्यों को कॉल करना जैसे किexchange.GetTicker()जो 3 सेकंड से अधिक समय तक उत्तर प्राप्त नहीं करते हैं, वे टाइमआउट करेंगे, और टाइमआउट करने वाले फ़ंक्शन कॉल शून्य मान लौटाएंगे.SetTimeout()एक वैश्विक फ़ंक्शन नहीं है, यह {@var/EXCHANGE exchange} एक्सचेंज ऑब्जेक्ट का एक तरीका है.
{@var/EXCHANGE विनिमय}
एफएमजेड क्वांट ट्रेडिंग प्लेटफॉर्म वास्तव में मल्टी-थ्रेडेड फ़ंक्शन का समर्थन करता हैJavaScriptप्रणाली के नीचे से भाषा रणनीति, और निम्नलिखित उद्देश्यों को लागू करता हैः
| वस्तुएँ | निर्देश | टिप्पणी |
|---|---|---|
| थ्रेडिंग | बहु-थ्रेड वैश्विक वस्तु | सदस्य के कार्य:Thread, getThread, mainThreadआदि। |
| धागा | धागा वस्तु | सदस्य के कार्य:peekMessage, postMessage, joinआदि। |
| थ्रेडलॉक | थ्रेड लॉक ऑब्जेक्ट | सदस्य के कार्य:acquire, releaseउन्हें थ्रेड निष्पादन फंक्शन के पैरामीटर के रूप में थ्रेड वातावरण में पारित किया जा सकता है। |
| थ्रेड घटना | घटना वस्तु | सदस्य के कार्य:set, clear, wait, isSetउन्हें थ्रेड निष्पादन फंक्शन के पैरामीटर के रूप में थ्रेड वातावरण में पारित किया जा सकता है। |
| थ्रेडCondition | शर्त वस्तु | सदस्य के कार्य:notify, notifyAll, wait, acquire, releaseउन्हें थ्रेड निष्पादन फंक्शन के पैरामीटर के रूप में थ्रेड वातावरण में पारित किया जा सकता है। |
| ThreadDict | शब्दकोश वस्तु | सदस्य के कार्य:get, setउन्हें थ्रेड निष्पादन फंक्शन के पैरामीटर के रूप में थ्रेड वातावरण में पारित किया जा सकता है। |
..threadingobject एक वैश्विक मल्टीथ्रेडिंग प्रबंधन उपकरण है जो समवर्ती थ्रेड, थ्रेड लॉक, और शर्त ऑब्जेक्ट बनाने जैसे कार्य प्रदान करता है। यह अनुभाग सदस्य कार्यों का परिचय देता हैthreadingइस ऑब्जेक्ट केवल द्वारा समर्थित हैJavaScriptभाषा रणनीति।
..Thread()समारोह समवर्ती धागे बनाने के लिए प्रयोग किया जाता है.
..Thread()फ़ंक्शन a लौटाता हैThreadऑब्जेक्ट, जिसका उपयोग बनाए गए समवर्ती थ्रेड, थ्रेड संचार आदि को प्रबंधित करने के लिए किया जाता है।
Threadवस्तु
थ्रेड ((मज़ा,... args) थ्रेड ((...आइटम)
पैरामीटरfuncसमवर्ती निष्पादन के लिए एक फ़ंक्शन है (संदर्भ द्वारा पारित), और गुमनाम कार्यों में पारित करने का समर्थन करता है.funcकई मापदंडों को स्वीकार कर सकते हैं, जो के माध्यम से पारित किया जाएगा...argsइसी समय निष्पादन के दौरान. इसलिए, पैरामीटर सूचीfuncके अनुरूप होना चाहिए...args.
कार्य
सच
कार्य
पैरामीटरargवास्तविक पैरामीटर को पारित किया जाता हैfunc(यानी समवर्ती थ्रेड निष्पादन फ़ंक्शन) जब कॉलबैक निष्पादित किया जाता है; कई पैरामीटर हो सकते हैंarg, और पैरामीटर सूचीfuncके अनुरूप होना चाहिए...args.
आर्ग
झूठी
string, number, bool, object, array, function, null value और सिस्टम द्वारा समर्थित अन्य प्रकार
पैरामीटरitemएक सरणी है जिसमें फ़ंक्शन संदर्भ और उनके पैरामीटर होते हैं जिन्हें एक साथ निष्पादित किया जाना है।itemमापदंडों में पारित किया जा सकता है जबThread function.
पद सच सरणी
function test1(a, b, c) {
Log("test1:", a, b, c)
}
function main() {
var t1 = threading.Thread(test1, 1, 2, 3)
var t2 = threading.Thread(function (msg) {
Log("msg:", msg)
}, "Hello thread2")
t1.join()
t2.join()
}
कस्टम फ़ंक्शन और गुमनाम फ़ंक्शन दोनों के लिए समवर्ती थ्रेड बनाएँ.
function test1(msg) {
Log("msg:", msg)
test2("Hello test2")
}
function main() {
var t1 = threading.Thread(
[function(a, b, c) {Log(a, b, c)}, 1, 2, 3],
[test1, "Hello test1"],
[`function test2(msg) {Log("msg:", msg)}`])
t1.join()
}
उपयोग करेंThread(...items)समवर्ती थ्रेड बनाने और कई कार्यों को क्रमिक रूप से निष्पादित करने के लिए।
function ml(input) {
const net = new brain.NeuralNetwork()
net.train([
{ input: [0, 0], output: [0] },
{ input: [0, 1], output: [1] },
{ input: [1, 0], output: [1] },
{ input: [1, 1], output: [0] },
])
return net.run(input)
}
function main() {
var ret = threading.Thread([ml, [1, 0]], [HttpQuery("https://unpkg.com/brain.js")]).join()
// ret: {"id":1,"terminated":false,"elapsed":337636000,"ret":{"0":0.9339330196380615}}
Log(ret)
}
यह फ़ंक्शन स्ट्रिंग्स को पास करने का समर्थन करता है और समवर्ती कंप्यूटिंग के लिए बाहरी पुस्तकालयों को गतिशील रूप से आयात कर सकता है।
थ्रेड फ़ंक्शनfuncमें पारित कियाThread()समवर्ती निष्पादन के लिए फ़ंक्शन एक अलग वातावरण में चलता है, इसलिए थ्रेड के बाहर के चर का सीधे संदर्भ नहीं दिया जा सकता है, और संदर्भित होने पर संकलन विफल हो जाएगा। उसी समय, थ्रेड के भीतर अन्य क्लोजर फ़ंक्शन के संदर्भ का समर्थन नहीं किया जाता है। प्लेटफ़ॉर्म द्वारा प्रदान किए गए सभी एपीआई को थ्रेड के भीतर बुलाया जा सकता है, लेकिन अन्य उपयोगकर्ता-परिभाषित फ़ंक्शन को नहीं बुलाया जा सकता है।
यह बैकटेस्टिंग सिस्टम और लाइव ट्रेडिंग वातावरण का समर्थन करता है। सभी समवर्ती धागे से संबंधित कार्यों को केवल बैकटेस्टिंग सिस्टम में कोड संगतता के रूप में समर्थित किया जाता है और वास्तव में समवर्ती धागे द्वारा निष्पादित नहीं किया जाएगा, इसलिए वे इस अध्याय में दोहराए नहीं जाएंगे।
{@fun/Threads/threading/getThread getThread}, {@fun/Threads/threading/mainThread mainThread}, {@fun/Threads/threading/currentThread currentThread}, {@fun/Threads/threading/Lock Lock}, {@fun/Threads/threading/Condition Condition}, {@fun/Threads/threading/Event Event}, {@fun/Threads/threading/Dict Dict}, {@fun/Threads/threading/pending pending}, {@fun/Threads/threading/eventLoop}, {@fun/Threads/threading/eventLoop}
..getThread()फ़ंक्शन का उपयोग निर्दिष्ट थ्रेड आईडी के आधार पर थ्रेड ऑब्जेक्ट प्राप्त करने के लिए किया जाता है.
..getThread()फ़ंक्शन रिटर्नThreadपैरामीटर द्वारा निर्दिष्ट threadId के साथ वस्तु
Threadवस्तु
getThread ((थ्रेडआईडी)
पैरामीटरthreadIdहै थ्रेड ऑब्जेक्ट आईडी. पैरामीटर निर्दिष्ट करके संबंधित थ्रेड ऑब्जेक्ट प्राप्त करें.
थ्रेड आईडी सच संख्या
function main() {
var t1 = threading.Thread(function () {
Log("Hello thread1")
})
// The Thread object has a method: id(), which is used to get the thread ID. You can view the section of the document corresponding to the Thread object.
var threadId = t1.id()
var threadName = t1.name()
Log("threadId:", threadId, ", threadName:", threadName)
var t2 = threading.getThread(threadId)
Log(`threadId == t2.id():`, threadId == t2.id(), `, threadName == t2.name():`, threadName == t2.name())
}
निर्दिष्ट थ्रेड ऑब्जेक्ट प्राप्त करेंthreadId.
यह बैकटेस्टिंग प्रणाली और लाइव ट्रेडिंग वातावरण का समर्थन करता है।
यदि आप प्राप्त करना चाहते हैं धागा निष्पादित किया गया है और जारी किया गया है, आप उपयोग नहीं कर सकतेthreading.getThread(threadId)यार्न की धागा वस्तु प्राप्त करने के लिए।
{@fun/Threads/threading/Thread Thread}, {@fun/Threads/threading/mainThread mainThread}, {@fun/Threads/threading/currentThread currentThread}, {@fun/Threads/threading/Lock Lock}, {@fun/Threads/threading/Condition Condition}, {@fun/Threads/threading/Event Event}, {@fun/Threads/threads/Dict Dict}, {@fun/Threads/threading/currentThread currentThread}, {@fun/Threads/threading/Lock Lock}, {@fun/Threads/threading/eventLoop}
..mainThread()मुख्य धागे की धागा वस्तु प्राप्त करने के लिए, अर्थात् धागा जहांmain()रणनीति में कार्य स्थित है।
..mainThread()फ़ंक्शन मुख्य फ़ंक्शन के थ्रेड ऑब्जेक्ट को लौटाता है.
Threadवस्तु
mainThread()
function main() {
Log("The threadId of the main thread:", threading.mainThread().id())
}
ले लोThreadमुख्य धागे के वस्तु और आउटपुटthreadIdमुख्य सूत्र का।
function test() {
Log("Output the main thread ID in the test function:", threading.mainThread().id())
}
function main() {
var t1 = threading.Thread(test)
t1.join()
}
मुख्य धागे का धागा वस्तु समवर्ती धागे में भी प्राप्त किया जा सकता है।
यह बैकटेस्टिंग प्रणाली और लाइव ट्रेडिंग वातावरण का समर्थन करता है।
{@fun/Threads/getThread getThread}, {@fun/Threads/threading/Thread Thread}, {@fun/Threads/threading/currentThread currentThread}, {@fun/Threads/threading/Lock Lock}, {@fun/Threads/threading/Condition Condition}, {@fun/Threads/threading/event Event}, {@fun/Threads/threads/threading/Dict Dict}, {@fun/Threads/threading/currentThread currentThread}, {@fun/Threads/threading/threading/Lock Lock}, {@fun/Threads/threading/eventLoop}, {@fun/Threads/threads/threading/eventLoop}, {@fun/Threads/threading/eventLoop}
..currentThread()फ़ंक्शन का प्रयोग वर्तमान फ़ंक्शन के थ्रेड ऑब्जेक्ट को प्राप्त करने के लिए किया जाता है.
..currentThread()फ़ंक्शन वर्तमान फ़ंक्शन के थ्रेड ऑब्जेक्ट को लौटाता है.
Threadवस्तु
वर्तमान थ्रेड()
function test() {
Log("Id of the current thread:", threading.currentThread().id())
}
function main() {
var t1 = threading.Thread(test)
t1.join()
}
ले लोThreadवर्तमान धागे के वस्तु और आउटपुटthreadIdवर्तमान धागे का।
यह बैकटेस्टिंग प्रणाली और लाइव ट्रेडिंग वातावरण का समर्थन करता है।
{@fun/Threads/threading/Thread Thread}, {@fun/Threads/threading/mainThread mainThread}, {@fun/Threads/threading/Thread Thread}, {@fun/Threads/threading/Lock Lock}, {@fun/Threads/threading/threading/Condition Condition}, {@fun/Threads/threading/event Event}, {@fun/Threads/threading/threading/Dict Dict}, {@fun/Threads/threading/threading/eventLoop pending}, {@fun/Threads/threading/eventLoop eventLoop}, {@fun/Threads/threading/eventLoop}, {@fun/Threads/threads/threading/eventLoop}, {@eventLoop}
..Lock()फ़ंक्शन का उपयोग थ्रेड लॉक ऑब्जेक्ट बनाने के लिए किया जाता है.
..Lock()फ़ंक्शन एक थ्रेड लॉक ऑब्जेक्ट लौटाता है.
ThreadLockवस्तु
तालाबंदी
function consumer(productionQuantity, dict, lock) {
for (var i = 0; i < productionQuantity; i++) {
lock.acquire()
var count = dict.get("count")
Log("consumer:", count)
Sleep(1000)
lock.release()
}
}
function producer(productionQuantity, dict, lock) {
for (var i = 0; i < productionQuantity; i++) {
lock.acquire()
dict.set("count", i)
Log("producer:", i)
Sleep(1000)
lock.release()
}
}
function main() {
var dict = threading.Dict()
dict.set("count", -1)
var lock = threading.Lock()
var productionQuantity = 10
var producerThread = threading.Thread(producer, productionQuantity, dict, lock)
var consumerThread = threading.Thread(consumer, productionQuantity, dict, lock)
consumerThread.join()
producerThread.join()
}
दो समवर्ती थ्रेड एक आम संसाधन तक पहुँचते हैं.
यह बैकटेस्टिंग प्रणाली और लाइव ट्रेडिंग वातावरण का समर्थन करता है।
{@fun/Threads/threading/getThread getThread}, {@fun/Threads/threading/mainThread mainThread}, {@fun/Threads/threading/currentThread currentThread}, {@fun/Threads/threads/threading/ThreadThread}, {@fun/Threads/threads/threading/Condition Condition}, {@fun/Threads/threads/threading/Event Event}, {@fun/Threads/threads/threading/Dict Dict}, {@fun/Threads/threads/threading/pending pending}, {@fun/Threads/threads/threading/eventLoop}
..Condition()function का उपयोग एक condition variable object बनाने के लिए किया जाता है, जिसका उपयोग मल्टी-थ्रेडेड समवर्ती वातावरण में थ्रेडों के बीच सिंक्रनाइज़ेशन और संचार प्राप्त करने के लिए किया जाता है।Condition(), एक थ्रेड जब कुछ शर्तें पूरी नहीं होती हैं तब तक प्रतीक्षा कर सकता है जब तक कि कोई अन्य थ्रेड उसे सूचित नहीं करता कि शर्त पूरी हो गई है।
..Condition()फ़ंक्शन a लौटाता हैThreadCondition object.
ThreadConditionवस्तु
स्थिति
function consumer(productionQuantity, dict, condition) {
for (var i = 0; i < productionQuantity; i++) {
condition.acquire()
while (dict.get("array").length == 0) {
condition.wait()
}
var arr = dict.get("array")
var count = arr.shift()
dict.set("array", arr)
Log("consumer:", count, ", array:", arr)
condition.release()
Sleep(1000)
}
}
function producer(productionQuantity, dict, condition) {
for (var i = 0; i < productionQuantity; i++) {
condition.acquire()
var arr = dict.get("array")
arr.push(i)
dict.set("array", arr)
Log("producer:", i, ", array:", arr)
condition.notify()
condition.release()
Sleep(1000)
}
}
function main() {
var dict = threading.Dict()
dict.set("array", [])
var condition = threading.Condition()
var productionQuantity = 10
var producerThread = threading.Thread(producer, productionQuantity, dict, condition)
var consumerThread = threading.Thread(consumer, productionQuantity, dict, condition)
consumerThread.join()
producerThread.join()
}
दो समवर्ती थ्रेड एक आम संसाधन तक पहुँचते हैं.
बैकटेस्टिंग प्रणाली इस कार्यक्षमता को लागू नहीं करती है, यह केवल इसे परिभाषित करती है।
{@fun/Threads/getThread getThread}, {@fun/Threads/threading/mainThread mainThread}, {@fun/Threads/threading/currentThread currentThread}, {@fun/Threads/threading/Lock Lock}, {@fun/Threads/threading/Thread Thread}, {@fun/Threads/threading/event Event}, {@fun/Threads/threads/threading/Dict Dict}, {@fun/Threads/threading/pending pending}, {@fun/Threads/threading/eventLoop}
..Event()फ़ंक्शन का उपयोग एक बनाने के लिए किया जाता हैथ्रेड घटनाऑब्जेक्ट, जिसका उपयोग थ्रेडों के बीच सिंक्रनाइज़ेशन के लिए किया जाता है, जिससे एक थ्रेड दूसरे थ्रेड से सूचना या संकेत का इंतजार कर सकता है।
..Event()फ़ंक्शन a लौटाता हैThreadEvent object.
ThreadEventवस्तु
घटना
function consumer(productionQuantity, dict, pEvent, cEvent) {
for (var i = 0; i < productionQuantity; i++) {
while (dict.get("array").length == 0) {
pEvent.wait()
}
if (pEvent.isSet()) {
pEvent.clear()
}
var arr = dict.get("array")
var count = arr.shift()
dict.set("array", arr)
Log("consumer:", count, ", array:", arr)
cEvent.set()
Sleep(1000)
}
}
function producer(productionQuantity, dict, pEvent, cEvent) {
for (var i = 0; i < productionQuantity; i++) {
while (dict.get("array").length != 0) {
cEvent.wait()
}
if (cEvent.isSet()) {
cEvent.clear()
}
var arr = dict.get("array")
arr.push(i)
dict.set("array", arr)
Log("producer:", i, ", array:", arr)
pEvent.set()
Sleep(1000)
}
}
function main() {
var dict = threading.Dict()
dict.set("array", [])
var pEvent = threading.Event()
var cEvent = threading.Event()
var productionQuantity = 10
var producerThread = threading.Thread(producer, productionQuantity, dict, pEvent, cEvent)
var consumerThread = threading.Thread(consumer, productionQuantity, dict, pEvent, cEvent)
consumerThread.join()
producerThread.join()
}
दो समवर्ती थ्रेड एक आम संसाधन तक पहुँचते हैं.
यह बैकटेस्टिंग प्रणाली और लाइव ट्रेडिंग वातावरण का समर्थन करता है।
{@fun/Threads/threading/getThread getThread}, {@fun/Threads/threading/mainThread mainThread}, {@fun/Threads/threading/currentThread currentThread}, {@fun/Threads/threading/Lock Lock}, {@fun/Threads/threading/Condition Condition}, {@fun/Threads/threading/Thread}, {@fun/Threads/threads/threading/Dict Dict}, {@fun/Threads/threading/pending pending}, {@fun/Threads/threads/threading/eventLoop}
..Dict()function का उपयोग समवर्ती धागे में पारित करने के लिए एक शब्दकोश वस्तु बनाने के लिए किया जाता है.
..Dict()फ़ंक्शन a लौटाता हैThreadDict object.
ThreadDictवस्तु
डिक्टेट
function threadFun1(obj) {
obj["age"] = 100
while (true) {
Log("threadFun1 obj:", obj)
Sleep(5000)
}
}
function threadFun2(obj) {
while (true) {
Log("threadFun2 obj:", obj)
Sleep(5000)
}
}
function main() {
var obj = {"age": 10}
var t1 = threading.Thread(threadFun1, obj)
var t2 = threading.Thread(threadFun2, obj)
t1.join()
t2.join()
}
एक सामान्य ऑब्जेक्ट को समवर्ती थ्रेड निष्पादन फ़ंक्शन में पास करें यह परीक्षण करने के लिए कि क्या ऑब्जेक्ट के कुंजी मान को संशोधित करने से अन्य थ्रेड में ऑब्जेक्ट के कुंजी मान में परिवर्तन होगा.
function threadFun1(threadDict) {
threadDict.set("age", 100)
while (true) {
Log(`threadFun1 threadDict.get("age"):`, threadDict.get("age"))
Sleep(5000)
}
}
function threadFun2(threadDict) {
while (true) {
Log(`threadFun2 threadDict.get("age"):`, threadDict.get("age"))
Sleep(5000)
}
}
function main() {
var threadDict = threading.Dict()
threadDict.set("age", 10)
var t1 = threading.Thread(threadFun1, threadDict)
var t2 = threading.Thread(threadFun2, threadDict)
t1.join()
t2.join()
}
पास करेंThreadDictद्वारा बनाई गई वस्तुDict()एक साथ चल रहे थ्रेड निष्पादन फ़ंक्शन के लिए फ़ंक्शन, और परीक्षण करें कि क्या ऑब्जेक्ट के कुंजी मान को संशोधित करने से अन्य थ्रेड में ऑब्जेक्ट के कुंजी मान में परिवर्तन होगा।
जब एक आम ऑब्जेक्ट एक समवर्ती थ्रेड फ़ंक्शन में पारित किया जाता है, तो इसे एक गहरी प्रति के रूप में पारित किया जाता है. एक समवर्ती थ्रेड में कुंजी मान को संशोधित करने से अन्य थ्रेडों में शब्दकोश प्रभावित नहीं होगा.
यह बैकटेस्टिंग प्रणाली और लाइव ट्रेडिंग वातावरण का समर्थन करता है।
{@fun/Threads/threading/getThread getThread}, {@fun/Threads/threading/mainThread mainThread}, {@fun/Threads/threading/currentThread currentThread}, {@fun/Threads/threading/Lock Lock}, {@fun/Threads/threading/Condition Condition}, {@fun/Threads/threading/event Event}, {@fun/Threads/threading/threading/Thread Thread}, {@fun/Threads/threading/threading/pending pending}, {@fun/Threads/threading/eventLoop}
..pendingफ़ंक्शन का उपयोग वर्तमान रणनीति कार्यक्रम में चल रहे समवर्ती थ्रेडों की संख्या प्राप्त करने के लिए किया जाता है.
..pending()फ़ंक्शन समवर्ती थ्रेडों की संख्या लौटाता है जो वर्तमान रणनीति कार्यक्रम चला रहा है.
संख्या
लंबित
function threadFun1() {
Log("threadFun1")
Sleep(3000)
}
function threadFun2() {
for (var i = 0; i < 3; i++) {
LogStatus(_D(), "print from threadFun2")
Sleep(3000)
}
}
function main() {
Log(`begin -- threading.pending():`, threading.pending())
var t1 = threading.Thread(threadFun1)
var t2 = threading.Thread(threadFun2)
Log(`after threading.Thread -- threading.pending():`, threading.pending())
t1.join()
t2.join()
Log(`after thread.join -- threading.pending():`, threading.pending())
}
एक साथ चलने वाले दो थ्रेड बनाएँ और कॉल करेंpending()विभिन्न समय नोड्स पर कार्य।
जब रणनीतिmain()फ़ंक्शन चलाता है, फ़ंक्शन को कॉल करता हैpending()सीधे 1 वापस आ जाएगा, क्योंकि मुख्य धागा जहां रणनीतिmain()फ़ंक्शन स्थित है भी एक लंबित धागा है.
यह बैकटेस्टिंग प्रणाली और लाइव ट्रेडिंग वातावरण का समर्थन करता है।
{@fun/Threads/threading/getThread getThread}, {@fun/Threads/threading/mainThread mainThread}, {@fun/Threads/threading/currentThread currentThread}, {@fun/Threads/threading/Lock Lock}, {@fun/Threads/threading/Condition Condition}, {@fun/Threads/threading/Event Event}, {@fun/Threads/threading/Dict Dict}, {@fun/Threads/threading/Thread Thread}, {@fun/Threads/threading/eventLoop}
Threadऑब्जेक्ट द्वारा बनाया या लौटाया जा सकता हैthreading.Thread(), threading.getThread(), threading.mainThread(), औरthreading.currentThread().
..peekMessage()फ़ंक्शन का उपयोग किसी थ्रेड से संदेश प्राप्त करने के लिए किया जाता है.
..peekMessage()फ़ंक्शन वर्तमान थ्रेड ऑब्जेक्ट से जुड़े थ्रेड द्वारा प्राप्त संदेश लौटाता है.
string, number, bool, object, array, null value और अन्य प्रकार जो सिस्टम द्वारा समर्थित हैं
peekMessage() peekMessage ((टाइमआउट)
पैरामीटरtimeouttimeout setting है. यह पैरामीटर द्वारा सेट मिलीसेकंड की संख्या के लिए ब्लॉक और प्रतीक्षा करेगा और डेटा लौटाएगा. यदि कोई डेटा नहीं है और timeout सीमा से अधिक है, तो एक शून्य मान लौटाया जाएगा. यदिtimeout0 पर सेट है याtimeoutपैरामीटर पारित नहीं किया जाता है, इसका मतलब यह है कि प्रक्रिया अवरुद्ध होगा और प्रतीक्षा जब तक चैनल से डेटा प्राप्त होता है।timeoutयदि -१ पर सेट किया गया है, तो इसका अर्थ है कि प्रक्रिया तुरंत डेटा को ब्लॉक और वापस नहीं करेगी। यदि कोई डेटा नहीं है, तो शून्य मान वापस किया जाएगा।
टाइमआउट झूठी संख्या
function main() {
var t1 = threading.Thread(function() {
for (var i = 0; i < 10; i++) {
Log("thread1 postMessage():", i)
threading.mainThread().postMessage(i)
Sleep(500)
}
})
while (true) {
var msg = threading.currentThread().peekMessage()
Log("main peekMessage():", msg)
if (msg == 9) {
break
}
Sleep(1000)
}
t1.join()
}
एक समवर्ती थ्रेड से मुख्य थ्रेड में संदेश भेजें.
जब हम प्रोग्राम लिखते हैं, तो हमें थ्रेड गतिरोध की समस्याओं पर ध्यान देने की आवश्यकता होती है।
{@fun/Threads/Thread/postMessage postMessage}, {@fun/Threads/Thread/join join}, {@fun/Threads/Thread/terminate terminate}, {@fun/Threads/Thread/getData getData}, {@fun/Threads/Thread/setData setData}, {@fun/Threads/Thread/id id}, {@fun/Threads/Thread/join name}, {@Threads/Threads/eventLoop eventLoop}
..postMessage()फ़ंक्शन का उपयोग किसी थ्रेड को संदेश भेजने के लिए किया जाता है.
postMessage(msg)
पैरामीटरmsgसंदेश भेजा जाना है।
msg सच सिस्टम द्वारा समर्थित कोई भी प्रकार, जैसे स्ट्रिंग, संख्या, बूल, ऑब्जेक्ट, सरणी, शून्य मान आदि।
function main() {
var t1 = threading.Thread(function() {
for (var i = 0; i < 10; i++) {
Log("thread1 postMessage():", i)
threading.mainThread().postMessage(i)
Sleep(500)
}
})
for (var i = 0; i < 10; i++) {
var event = threading.mainThread().eventLoop()
Log("main event:", event)
Sleep(500)
}
t1.join()
}
समवर्ती थ्रेड में संदेश भेजें और उपयोग करेंeventLoop()संदेश सूचनाएं प्राप्त करने के लिए।
जब एक थ्रेडpostMessage()एक संकेत या डेटा भेजने के लिए समारोह, एक संदेश घटना भी उत्पन्न होता है. हम उपयोग कर सकते हैंeventLoop()संदेश सूचनाओं को प्राप्त करने के लिए कार्य।
{@fun/Threads/Thread/peekMessage peekMessage}, {@fun/Threads/Thread/join join}, {@fun/Threads/Thread/terminate terminate}, {@fun/Threads/Thread/getData getData}, {@fun/Threads/Thread/setData setData}, {@fun/Threads/Thread/id id}, {@fun/Threads/Threads/Thread/name name join}, {@fun/Threads/Thread/eventLoop eventLoop}, {@fun/Threads/Thread/name}, {@fun/Threads/Thread/eventLoop eventLoop}, {@fun/Threads/eventLoop eventLoop}, {@fun/Threads/Threads/eventLoop eventLoop}, {@fun/Threads/eventLoop eventLoop}, {@fun/Threads/eventLoop eventLoop}, {@fun/
..join()कार्य का उपयोग थ्रेड के बाहर निकलने और सिस्टम संसाधनों को पुनः प्राप्त करने के लिए किया जाता है।
..ThreadRetवस्तुनिष्पादन परिणाम के बारे में डेटा शामिल है। गुणों में निम्नलिखित शामिल हैंः
ThreadRetवस्तु
सम्मिलित होना शामिल होना (timeout)
..timeoutपैरामीटर का उपयोग थ्रेड के समाप्त होने की प्रतीक्षा करने के लिए मिलीसेकंड में टाइमआउट सेट करने के लिए किया जाता है।timeoutपैरामीटर 0 पर सेट है याtimeoutपैरामीटर सेट नहीं है,join()फ़ंक्शन ब्लॉक होगा और प्रतीक्षा जब तक धागा निष्पादन समाप्त होता है.timeoutपैरामीटर -1 पर सेट है,join()कार्य तुरंत वापस आ जाएगा।
टाइमआउट झूठी संख्या
function main() {
var t1 = threading.Thread(function() {
Log("Hello thread1")
Sleep(5000)
})
var ret = t1.join(1000)
Log("ret:", ret) // ret: undefined
ret = t1.join()
Log("ret:", ret) // ret: {"id":1,"terminated":false,"elapsed":5003252000}
}
परीक्षण करेंjoin()टाइमआउट के लिए फ़ंक्शन और रिटर्न मान आउटपुट करें.
..join()फ़ंक्शन समय बाहर और लौटाता हैundefined.
{@fun/Threads/Thread/peekMessage peekMessage}, {@fun/Threads/Thread/postMessage postMessage}, {@fun/Threads/Thread/terminate terminate}, {@fun/Threads/Thread/getData getData}, {@fun/Threads/Thread/setData setData}, {@fun/Threads/Thread/id id}, {@fun/Threads/Thread/name name name}, {@fun/Threads/Threads/Thread/eventLoop eventLoop}
..terminate()फ़ंक्शन का उपयोग किसी थ्रेड को जबरन समाप्त करने और बनाए गए थ्रेड द्वारा उपयोग किए जाने वाले हार्डवेयर संसाधनों को मुक्त करने के लिए किया जाता है.
समाप्त करना
function main() {
var t1 = threading.Thread(function() {
for (var i = 0; i < 10; i++) {
Log("thread1 i:", i)
Sleep(1000)
}
})
Sleep(3000)
t1.terminate()
Log("after t1.terminate()")
while (true) {
LogStatus(_D())
Sleep(1000)
}
}
किसी थ्रेड के निष्पादन को बलपूर्वक समाप्त करें. किसी थ्रेड को बलपूर्वक समाप्त करने के बाद, लॉग में इस थ्रेड से कोई आउटपुट नहीं होगा.
धागे के लिए जो बलपूर्वक समाप्त होते हैंterminate()कार्य, हम अब उपयोग नहीं कर सकतेjoin()उन्हें समाप्त करने के लिए प्रतीक्षा करने के लिए समारोह.
{@fun/Threads/Thread/peekMessage peekMessage}, {@fun/Threads/Thread/postMessage postMessage}, {@fun/Threads/Thread/join join}, {@fun/Threads/Thread/getData getData}, {@fun/Threads/Thread/setData setData}, {@fun/Threads/Thread/id id}, {@fun/Threads/Thread/name name name}, {@fun/Threads/Thread/eventLoop eventLoop}, {@fun/Threads/Thread/eventLoop eventLoop}, {@fun/Threads/Thread/eventLoop eventLoop}, {@fun/Threads/eventLoop eventLoop}, {@fun/Threads/eventLoop eventLoop}, {@fun/Threads/eventLoop eventLoop}, {@fun/Threads/eventLoop eventLoop}, {@
..getData()कार्य का उपयोग थ्रेड वातावरण में दर्ज चर तक पहुँचने के लिए किया जाता है।join()कार्य (सफलता से बाहर निकलने की प्रतीक्षा) और निष्पादित नहीं किया हैterminate()कार्य (गंजा को बलपूर्वक समाप्त करना) ।
..getData()फ़ंक्शन कुंजी मान के अनुरूप लौटाता हैkeyवर्तमान थ्रेड संदर्भ में संग्रहीत कुंजी-मूल्य जोड़ी में पैरामीटर.
string, number, bool, object, array, null value और अन्य प्रकार जो सिस्टम द्वारा समर्थित हैं
getData() getData ((कुंजी)
..keyपैरामीटर संग्रहीत कुंजी-मूल्य जोड़ी का कुंजी नाम है.
कुंजी सच स्ट्रिंग
function main() {
var t1 = threading.Thread(function() {
for (var i = 0; i < 5; i++) {
threading.currentThread().setData("count", i)
Log(`setData("count"):`, i)
Sleep(1000)
}
})
for (var i = 0; i < 5; i++) {
var count = threading.getThread(t1.id()).getData("count")
Log(`getData("count"):`, count)
Sleep(1000)
}
t1.join()
}
कुंजी का मान दर्ज करेंcountसमवर्ती धागा पर्यावरण में, और फिर की कुंजी मूल्य पढ़नाcountमुख्य धागे में।
{@fun/Threads/Thread/peekMessage peekMessage}, {@fun/Threads/Thread/postMessage postMessage}, {@fun/Threads/Thread/join join}, {@fun/Threads/Thread/terminate terminate}, {@fun/Threads/Thread/setData set}, {@fun/Threads/Thread/id id}, {@fun/Threads/Thread/name name name}, {@fun/Threads/Thread/eventLoop eventLoop}
..setData()फ़ंक्शन का उपयोग थ्रेड संदर्भ में चर को संग्रहीत करने के लिए किया जाता है.
setData ((कुंजी, मान)
..keyपैरामीटर का उपयोग संग्रहीत कुंजी-मूल्य जोड़ी के कुंजी नाम को निर्दिष्ट करने के लिए किया जाता है.
कुंजी
सच
स्ट्रिंग
दvalueपैरामीटर का उपयोग संग्रहीत कुंजी-मूल्य जोड़ी के कुंजी मूल्य को निर्दिष्ट करने के लिए किया जाता है।
मूल्य सच सिस्टम द्वारा समर्थित कोई भी प्रकार, जैसे स्ट्रिंग, संख्या, बूल, ऑब्जेक्ट, सरणी, शून्य मान आदि।
function main() {
var t1 = threading.Thread(function() {
threading.currentThread().setData("data", 100)
})
Sleep(1000)
Log(`t1.getData("data"):`, t1.getData("data"))
t1.join()
}
समवर्ती धागे में कुंजी-मूल्य जोड़ी सेट करें और मुख्य धागे में कुंजी-मूल्य जोड़ी पढ़ें.
डेटा वैध है जब धागा निष्पादित नहीं किया हैjoin()कार्य (सफलता से बाहर निकलने की प्रतीक्षा) और निष्पादित नहीं किया हैterminate()फंक्शन (कठोर रूप से धागे को समाप्त करना) पैरामीटर का मानvalueएक serializable चर होना चाहिए.
{@fun/Threads/Thread/peekMessage peekMessage}, {@fun/Threads/Thread/postMessage postMessage}, {@fun/Threads/Thread/join join}, {@fun/Threads/Thread/terminate terminate}, {@fun/Threads/Thread/getData getData}, {@fun/Threads/Thread/id id}, {@fun/Threads/Thread/name name name}, {@fun/Threads/Thread/eventLoop eventLoop}, {@fun/Threads/Thread/eventLoop eventLoop}, {@fun/Threads/Thread/eventLoop eventLoop}, {@fun/Threads/eventLoop eventLoop}, {@fun/Threads/eventLoop eventLoop}, {@fun/Threads/eventLoop eventLoop}, {@fun/Threads/eventLoop eventLoop}, {@
..id()फ़ंक्शन का उपयोग लौटाता हैthreadIdवर्तमान मल्टीथ्रेडेड ऑब्जेक्ट इंस्टेंस का.
रिटर्न मूल्यid()कार्य हैthreadId.
संख्या
id()
function main() {
var t1 = threading.Thread(function() {
threading.currentThread().setData("data", 100)
})
Log(`t1.id():`, t1.id())
t1.join()
}
एक साथ चलने वाला थ्रेड बनाएँ और आउटपुटthreadIdमुख्य धागे में इस समानांतर धागे के।
{@fun/Threads/Thread/peekMessage peekMessage}, {@fun/Threads/Thread/postMessage postMessage}, {@fun/Threads/Thread/join join}, {@fun/Threads/Thread/terminate terminate}, {@fun/Threads/Thread/getData getData}, {@fun/Threads/Threads/setData set}, {@fun/Threads/Thread/name name name}, {@fun/Threads/Threads/Thread/eventLoop eventLoop}, {@fun/Threads/Thread/eventLoop eventLoop}, {@fun/Threads/Thread/eventLoop eventLoop}, {@fun/Threads/thread/eventLoop eventLoop}, {@fun/Threads/eventLoop eventLoop}, {@fun/Threads/eventLoop eventLoop}, {@fun/Threads/event
..name()फ़ंक्शन का उपयोग वर्तमान मल्टीथ्रेडेड ऑब्जेक्ट इंस्टेंस का नाम वापस करने के लिए किया जाता है.
..name()फ़ंक्शन समवर्ती थ्रेड नाम लौटाता है.
स्ट्रिंग
नाम
function main() {
var t1 = threading.Thread(function() {
threading.currentThread().setData("data", 100)
})
Log(`t1.name():`, t1.name()) // t1.name(): Thread-1
t1.join()
}
एक समवर्ती थ्रेड बनाएँ और मुख्य थ्रेड में समवर्ती थ्रेड का नाम आउटपुट करें.
{@fun/Threads/Thread/peekMessage peekMessage}, {@fun/Threads/Thread/postMessage postMessage}, {@fun/Threads/Thread/join join}, {@fun/Threads/Thread/terminate terminate}, {@fun/Threads/Thread/getData getData}, {@fun/Threads/Threads/setData set}, {@fun/Threads/Thread/id id}, {@fun/Threads/Threads/Thread/eventLoop eventLoop}, {@fun/Threads/Thread/eventLoop eventLoop}, {@fun/Threads/Thread/eventLoop eventLoop}, {@fun/Threads/Thread/eventLoop eventLoop}, {@fun/Threads/Thread/eventLoop}, {@fun/Threads/Thread/eventLoop eventLoop}, {@fun/Threads/
..eventLoop()फ़ंक्शन का उपयोग थ्रेड द्वारा प्राप्त घटनाओं के लिए सुनने के लिए किया जाता है.
..eventLoop()फ़ंक्शन वर्तमान थ्रेड द्वारा प्राप्त घटना जानकारी लौटाता है.घटना सूचना संरचना.
वस्तु, शून्य मान
घटनाLoop() घटना लूप (टाइमआउट)
पैरामीटरtimeoutमिलीसेकंड में टाइमआउट सेटिंग है. यदि पैरामीटरtimeoutयदि यह 0 से अधिक है, तो यह घटना प्रतीक्षा समय सीमा सेट करेगा। यदि यह 0 से कम है, तो यह नवीनतम घटना को तुरंत लौटाएगा।
टाइमआउट झूठी संख्या
function main() {
var t1 = threading.Thread(function() {
while (true) {
var eventMsg = threading.currentThread().eventLoop() // Blocking wait
// 2024-11-14 10:14:18 thread1 eventMsg: {"Seq":1,"Event":"thread","ThreadId":0,"Index":1,"Queue":0,"Nano":1731550458699947000}
Log(_D(), "thread1 eventMsg:", eventMsg)
}
})
var t2 = threading.Thread(function() {
while (true) {
var eventMsg = threading.currentThread().eventLoop(-1) // Return immediately
Log(_D(), "thread2 eventMsg:", eventMsg)
Sleep(5000)
}
})
var t3 = threading.Thread(function() {
while (true) {
var eventMsg = threading.currentThread().eventLoop(3000) // Set a 3 second timeout
Log(_D(), "thread3 eventMsg:", eventMsg)
}
})
t1.postMessage("Hello ", t1.name())
t2.postMessage("Hello ", t2.name())
t3.postMessage("Hello ", t3.name())
t1.join()
t2.join()
t3.join()
}
एक साथ तीन थ्रेड निष्पादित करें और प्राप्त घटना जानकारी आउटपुट करें. यदि टाइमआउट होता है या फ़ंक्शन तुरंत वापस आता है, तो आउटपुट मान शून्य है.
प्रक्रिया तंत्रeventLoop()समारोह वैश्विक समारोह के समान हैEventLoop().
{@fun/Threads/Thread/peekMessage peekMessage}, {@fun/Threads/Thread/postMessage postMessage}, {@fun/Threads/Thread/join join}, {@fun/Threads/Thread/terminate terminate}, {@fun/Threads/Thread/getData getData}, {@fun/Threads/Threads/setData setData}, {@fun/Threads/Thread/id id}, {@fun/Threads/Threads/Thread/name name name}, {@fun/Threads/name name name}, {@fun/Threads/Thread/name name name}, {@fun/Threads/data setData}, {@fun/Threads/Threads/id id}, {@fun/Threads/Thread/name name}, {@fun/Threads/name name name}, {@fun/Threads/Thread/name name name}, {@fun/Thre
थ्रेड लॉक ऑब्जेक्ट, बहु-थ्रेड सिंक्रनाइज़ेशन प्रसंस्करण के लिए प्रयोग किया जाता है.
..acquire()फ़ंक्शन का उपयोग थ्रेड लॉक (लॉक) का अनुरोध करने के लिए किया जाता है।
प्राप्त करना
कृपया देखेंthreading.Lock()उदाहरणों के लिए अनुभाग।
..acquire()फ़ंक्शन का उपयोग थ्रेड लॉक अनुरोध करने के लिए किया जाता है. जब एक थ्रेड कॉल करता हैacquire()एक थ्रेड लॉक ऑब्जेक्ट का कार्य, यह लॉक प्राप्त करने का प्रयास करता है। यदि लॉक वर्तमान में किसी अन्य थ्रेड द्वारा आयोजित नहीं किया जाता है, तो कॉलिंग थ्रेड सफलतापूर्वक लॉक प्राप्त करता है और निष्पादन जारी रखता है। यदि लॉक पहले से ही किसी अन्य थ्रेड द्वारा आयोजित किया जाता है, तो थ्रेड कॉल करनाacquire()जब तक ताला खोला नहीं जाता तब तक बंद रहेगा।
{@fun/Threads/threading/Lock Lock}, {@fun/Threads/ThreadLock/release release}
..release()फ़ंक्शन का प्रयोग धागे के ताले को खोलने के लिए किया जाता है।
विमोचन
function consumer(productionQuantity, dict, pLock, cLock) {
for (var i = 0; i < productionQuantity; i++) {
pLock.acquire()
cLock.acquire()
var arr = dict.get("array")
var count = arr.shift()
dict.set("array", arr)
Log("consumer:", count, ", array:", arr)
cLock.release()
Sleep(1000)
pLock.release()
}
}
function producer(productionQuantity, dict, pLock, cLock) {
for (var i = 0; i < productionQuantity; i++) {
cLock.acquire() // cLock.acquire() placed after pLock.acquire() will not cause deadlock
pLock.acquire()
var arr = dict.get("array")
arr.push(i)
dict.set("array", arr)
Log("producer:", i, ", array:", arr)
pLock.release()
Sleep(1000)
cLock.release()
}
}
function main() {
var dict = threading.Dict()
dict.set("array", [])
var pLock = threading.Lock()
var cLock = threading.Lock()
var productionQuantity = 10
var producerThread = threading.Thread(producer, productionQuantity, dict, pLock, cLock)
var consumerThread = threading.Thread(consumer, productionQuantity, dict, pLock, cLock)
consumerThread.join()
producerThread.join()
}
गतिरोध के परिदृश्यों का परीक्षण
यह ध्यान दिया जाना चाहिए कि धागे के ताले का अनुचित उपयोग गतिरोध का कारण बन सकता है।
{@fun/Threads/threading/Lock Lock}, {@fun/Threads/ThreadLock/acquire acquire}
घटना वस्तु, बहु-थ्रेडेड घटना अधिसूचना और संकेत के लिए प्रयोग की जाती है।
..set()समारोह का उपयोग घटनाओं (सेट संकेत) को सूचित करने के लिए किया जाता है।
सेट (()
कृपया देखेंthreading.Event()उदाहरणों के लिए अनुभाग।
यदि सिग्नल का उपयोग करके सेट किया गया हैset(), यह फिर से सेट नहीं किया जा सकता है. हम संकेत को साफ करने और इसे फिर से सेट करने की जरूरत है.
{@fun/Threads/ThreadEvent/clear clear}, {@fun/Threads/ThreadEvent/wait wait}, {@fun/Threads/ThreadEvent/isSet isSet}
..clear()सिग्नल को साफ करने के लिए फ़ंक्शन का प्रयोग किया जाता है।
साफ
कृपया देखेंthreading.Event()उदाहरणों के लिए अनुभाग।
{@fun/Threads/ThreadEvent/set set}, {@fun/Threads/ThreadEvent/wait wait}, {@fun/Threads/ThreadEvent/isSet isSet}
..wait()function का उपयोग एक घटना (सिग्नल) प्रतीक्षा सेट करने के लिए किया जाता है, और घटना (सिग्नल) सेट होने से पहले ब्लॉक हो जाएगा; यह एक टाइमआउट पैरामीटर सेट करने का समर्थन करता है।
..wait()फ़ंक्शन लौटाता है कि क्या टाइमआउट हुआ है. यदि हां, तो यह एक सही मान लौटाता है.
बोल
प्रतीक्षा करो प्रतीक्षा (टाइमआउट)
..timeoutपैरामीटर का उपयोग प्रतीक्षा समय को मिलीसेकंड में सेट करने के लिए किया जाता है।
टाइमआउट झूठी संख्या
function main() {
var event = threading.Event()
var t1 = threading.Thread(function(event) {
var ret = event.wait(100)
Log(`event.wait(100):`, ret)
ret = event.wait()
Log(`event.wait():`, ret)
}, event)
Sleep(1000)
event.set()
t1.join()
}
रिटर्न मान का परीक्षण करेंwait() function.
{@fun/Threads/ThreadEvent/set set}, {@fun/Threads/ThreadEvent/clear clear}, {@fun/Threads/ThreadEvent/isSet isSet}
..isSet()फ़ंक्शन का उपयोग यह निर्धारित करने के लिए किया जाता है कि क्या कोई घटना (सिग्नल) सेट की गई है।
..isSet()फ़ंक्शन लौटाता है कि क्या घटना (सिग्नल) सेट की गई है; यदि घटना (सिग्नल) सेट की गई है, तो यह एक सही मान लौटाता है।
बोल
isSet()
कृपया देखेंthreading.Event()उदाहरणों के लिए अनुभाग।
{@fun/Threads/ThreadEvent/set set}, {@fun/Threads/ThreadEvent/clear clear}, {@fun/Threads/ThreadEvent/wait wait}
बहु-थ्रेड सिंक्रनाइज़ेशन के लिए उपयोग की जाने वाली स्थिति वस्तु।
..notify()function का उपयोग प्रतीक्षा थ्रेड (यदि कोई हो) को जगाने के लिए किया जाता है. केवल थ्रेड जो कॉल किया हैwait()विधि जागृत हो जाएगा।
सूचित करना
function consumer(dict, condition) {
while (true) {
condition.acquire()
while (dict.get("array").length == 0) {
Log(threading.currentThread().name(), "wait()...", ", array:", dict.get("array"))
condition.wait()
}
var arr = dict.get("array")
var num = arr.shift()
Log(threading.currentThread().name(), ", num:", num, ", array:", arr, "#FF0000")
dict.set("array", arr)
Sleep(1000)
condition.release()
}
}
function main() {
var condition = threading.Condition()
var dict = threading.Dict()
dict.set("array", [])
var t1 = threading.Thread(consumer, dict, condition)
var t2 = threading.Thread(consumer, dict, condition)
var t3 = threading.Thread(consumer, dict, condition)
Sleep(1000)
var i = 0
while (true) {
condition.acquire()
var msg = ""
var arr = dict.get("array")
var randomNum = Math.floor(Math.random() * 5) + 1
if (arr.length >= 3) {
condition.notifyAll()
msg = "notifyAll"
} else {
arr.push(i)
dict.set("array", arr)
if (randomNum > 3 && arr.length > 0) {
condition.notify()
msg = "notify"
} else {
msg = "pass"
}
i++
}
Log(_D(), "randomNum:", randomNum, ", array:", arr, ", msg:", msg)
condition.release()
Sleep(1000)
}
}
उपयोग करेंnotify()कार्य प्रतीक्षा धागे को जगाने के लिए।
..notify()समारोह प्रतीक्षा कतार में एक धागा जागता है.
जबnotify()समारोह एक धागा जागता है, धागा धागा लॉक पुनः प्राप्त होगा.
{@fun/Threads/ThreadCondition/notifyAll notifyAll}, {@fun/Threads/ThreadCondition/wait wait}, {@fun/Threads/ThreadCondition/acquire acquire}, {@fun/Threads/ThreadCondition/release release}, {@fun/Threads/ThreadCondition/release release}, {@fun/Threads/ThreadCondition/release release}
..notifyAll()समारोह सभी प्रतीक्षा धागे जागता है.
सभी को सूचित करें
कृपया देखेंThreadCondition.notify()उदाहरणों के लिए अनुभाग।
..notifyAll()कार्य सभी प्रतीक्षा धागे एक एक करके जागृत करता है, और जागृत धागे धागा ताला पुनः प्राप्त करते हैं।
{@fun/Threads/ThreadCondition/notify notify}, {@fun/Threads/ThreadCondition/wait wait}, {@fun/Threads/ThreadCondition/acquire acquire}, {@fun/Threads/ThreadCondition/release release}
..wait()कार्य का उपयोग कुछ डिज़ाइन की गई परिस्थितियों में थ्रेड को प्रतीक्षा करने के लिए किया जाता है।
प्रतीक्षा करो
कृपया देखेंThreadCondition.notify()उदाहरणों के लिए अनुभाग।
..wait()कार्य थ्रेड लॉक को रिलीज़ करता है और जागने पर थ्रेड लॉक को पुनः प्राप्त करता है।
{@fun/Threads/ThreadCondition/notify notify}, {@fun/Threads/ThreadCondition/notifyAll notifyAll}, {@fun/Threads/ThreadCondition/acquire acquire}, {@fun/Threads/ThreadCondition/release release}
..acquire()फ़ंक्शन का उपयोग थ्रेड लॉक (लॉक) का अनुरोध करने के लिए किया जाता है।
प्राप्त करना
कृपया देखेंThreadCondition.notify()उदाहरणों के लिए अनुभाग।
उपयोग करने से पहलेwait(), आपको वर्तमान स्थिति वस्तु के थ्रेड लॉक (लॉक) का अनुरोध करने की आवश्यकता है.
{@fun/Threads/ThreadCondition/notify notify}, {@fun/Threads/ThreadCondition/notifyAll notifyAll}, {@fun/Threads/ThreadCondition/wait wait}, {@fun/Threads/ThreadCondition/release release}, {@fun/ThreadCondition/ThreadCondition/release release}, {@fun/ThreadCondition/ThreadCondition/notifyAll notifyAll}, {@fun/Threads/ThreadCondition/wait wait}, {@fun/Threads/ThreadCondition/release release}, {@fun/ThreadCondition/release release}
..release()फ़ंक्शन का प्रयोग धागे के ताले को खोलने के लिए किया जाता है।
विमोचन
कृपया देखेंThreadCondition.notify()उदाहरणों के लिए अनुभाग।
उपयोग के बादwait(), हम वर्तमान स्थिति वस्तु के धागे लॉक (अनलॉक) को जारी करने की जरूरत है.
{@fun/Threads/ThreadCondition/notify notify}, {@fun/Threads/ThreadCondition/notifyAll notifyAll}, {@fun/Threads/ThreadCondition/wait wait}, {@fun/Threads/ThreadCondition/acquire acquire}
शब्दकोश वस्तु, डेटा साझा करने के लिए प्रयोग की जाती है।
..get()function का प्रयोग शब्दकोश वस्तु में दर्ज की गई कुंजी मान प्राप्त करने के लिए किया जाता है.
..get()फ़ंक्शन द्वारा निर्दिष्ट कुंजी का मान लौटाता हैkey parameter.
string, number, bool, object, array, null value और अन्य प्रकार जो सिस्टम द्वारा समर्थित हैं
प्राप्त करना (key)
..keyपैरामीटर का उपयोग प्राप्त की जाने वाली कुंजी के अनुरूप कुंजी नाम निर्दिष्ट करने के लिए किया जाता है।
कुंजी सच स्ट्रिंग
function main() {
var event = threading.Event()
var dict = threading.Dict()
dict.set("data", 100)
var t1 = threading.Thread(function(dict, event) {
Log(`thread1, dict.get("data"):`, dict.get("data"))
event.set()
event.clear()
event.wait()
Log(`after main change data, thread1 dict.get("data"):`, dict.get("data"))
dict.set("data", 0)
}, dict, event)
event.wait()
dict.set("data", 99)
event.set()
event.clear()
t1.join()
Log(`main thread, dict.get("data"):`, dict.get("data"))
}
डेटा को पढ़ने और संशोधित करने के लिए थ्रेड को सूचित करने के लिए घटना वस्तुओं का उपयोग करें.
{@fun/Threads/ThreadDict/set set}
..set()एक कुंजी-मूल्य जोड़ी सेट करने के लिए फ़ंक्शन का उपयोग किया जाता है.
सेट (कुंजी, मान)
पैरामीटरkeyपरिवर्तित होने वाले कुंजी नाम को सेट करने के लिए प्रयोग किया जाता है.
कुंजी
सच
स्ट्रिंग
पैरामीटरvalueपरिवर्तित होने वाले कुंजी मान को निर्धारित करने के लिए प्रयोग किया जाता है।
मूल्य सच string, number, bool, object, array, null value और अन्य प्रकार जो सिस्टम द्वारा समर्थित हैं
कृपया देखेंThreadDict.get()उदाहरणों के लिए अनुभाग।
{@fun/Threads/ThreadDict/get get} {@fun/Threads/ThreadDict/get get}
एफएमजेड क्वांट ट्रेडिंग प्लेटफॉर्म में, यह मुख्य रूप से विभिन्न कार्यों को लागू करता है, ब्लॉकचेन से संबंधित कॉलexchange.IO()निम्नलिखित दस्तावेज मेंexchange.IO()अपने कार्य के अनुसार अलग से कार्य करता है।exchange.IO("abi", ...)एबीआई को पंजीकृत करने के लिए कार्य का प्रयोग किया जाता है।
exchange.IO(k, पता, abiContent)
..kपैरामीटर का उपयोग फंक्शन सेट करने के लिए किया जाता हैexchange.IO()फंक्शन, पर सेट"abi"का अर्थ है कि फ़ंक्शन का उपयोग पंजीकरण के लिए किया जाता हैABI.
क
सच
स्ट्रिंग
दaddressपैरामीटर का उपयोग स्मार्ट कॉन्ट्रैक्ट के पते को निर्दिष्ट करने के लिए किया जाता है।
पता
सच
स्ट्रिंग
दabiContentपैरामीटर का उपयोग निर्दिष्ट करने के लिए किया जाता हैABIस्मार्ट कॉन्ट्रैक्ट का।
abiसामग्री
सच
स्ट्रिंग
function main() {
// register Uniswap SwapRouter02 abi
var routerAddress = "0x68b3465833fb72A70ecDF485E0e4C7bD8665Fc45"
var abi = `[{"inputs":[{"components":[{"internalType":"bytes","name":"path","type":"bytes"},{"internalType":"address","name":"recipient","type":"address"},{"internalType":"uint256","name":"amountOut","type":"uint256"},{"internalType":"uint256","name":"amountInMaximum","type":"uint256"}],"internalType":"struct IV3SwapRouter.ExactOutputParams","name":"params","type":"tuple"}],"name":"exactOutput","outputs":[{"internalType":"uint256","name":"amountIn","type":"uint256"}],"stateMutability":"payable","type":"function"}]`
// Get the ```ABI``` content of the contract can be obtained with the following URL, taking the ```result``` field only, e.g:
exchange.IO("abi", routerAddress, abi)
}
स्मार्ट कॉन्ट्रैक्ट को बुलाने की विधियों को पंजीकृत करने की आवश्यकता नहीं है यदि वे मानक ERC20 विधियां हैं।
ले लोABIअनुबंध की सामग्री निम्न URL पर प्राप्त की जा सकती है,resultकेवल क्षेत्र, उदाहरण के लिएः
https://api.etherscan.io/api?module=contract&action=getabi&address=0x68b3465833fb72A70ecDF485E0e4C7bD8665Fc45
कॉल करने की विधिexchange.IO("api", "eth", ...)function का उपयोग Ethereum RPC विधि को कॉल करने के लिए किया जाता है.
..exchange.IO("api", "eth", ...)फ़ंक्शन RPC विधि का लौटाया गया मान लौटाता है।
string, number, bool, object, array, null और सिस्टम द्वारा समर्थित अन्य सभी प्रकार
exchange.IO(k, blockChain, rpcMethod)exchange.IO(k, blockChain, rpcMethod,...args)
..kपैरामीटर का उपयोग फंक्शन सेट करने के लिए किया जाता हैexchange.IO()फंक्शन, पर सेट"api"इंगित करता है कि फ़ंक्शन का उपयोग कॉल अनुरोध का विस्तार करने के लिए किया जाता है.
क
सच
स्ट्रिंग
दblockChainपैरामीटर का उपयोग फंक्शन सेट करने के लिए किया जाता हैexchange.IO()फंक्शन, पर सेट"eth"यह दर्शाता है कि फ़ंक्शन का उपयोग एथेरियम नेटवर्क पर आरपीसी विधि कॉल के लिए किया जाता है।
ब्लॉकचेन
सच
स्ट्रिंग
दrpcMethodपैरामीटर RPC विधि सेट करने के लिए प्रयोग किया जाता है द्वारा बुलाया जाना हैexchange.IO()कार्य।
rpc विधि
सच
स्ट्रिंग
दargपैरामीटर का उपयोग आरपीसी विधि के मापदंडों को निर्दिष्ट करने के लिए किया जाता है। एक से अधिक हो सकते हैंargप्रकार और संख्याargमापदंडों RPC विधि द्वारा निर्दिष्ट पर निर्भर करते हैंrpcMethodपैरामीटर
आर्ग
झूठी
string, number, bool, object, array, function, null, और अन्य सभी प्रकार सिस्टम द्वारा समर्थित
function main() {
// "owner" needs to be replaced with the specific wallet address
// Parameter labels for the "latest" string position: 'latest', 'earliest' or 'pending', please refrer to https://eth.wiki/json-rpc/API#the-default-block-parameter
// The return value ethBalance is a hexadecimal string: 0x9b19ce56113070
var ethBalance = exchange.IO("api", "eth", "eth_getBalance", "owner", "latest")
// ETH has a precision unit of 1e18
var ethDecimal = 18
// Because of the JavaScript language precision, it is necessary to use the system underlying package function BigInt, BigDecimal to process
// Convert ethBalance to readable amount, 0x9b19ce56113070 to 0.043656995388076145
Log(Number((BigDecimal(BigInt(ethBalance))/BigDecimal(Math.pow(10, ethDecimal))).toString()))
}
अपने बटुए में ईटीएच की शेष राशि की जाँच करेंः
function mian() {
// ETH has a precision unit of 1e18
var ethDecimal = 18
// Number of transfers, readable amount e.g. 0.01 ETH
var sendAmount = 0.01
// Due to the JavaScript language precision, it is necessary to use the system underlying encapsulated functions BigInt, BigDecimal to process, and to convert the readable amount to the data processed on the chain
var toAmount = (BigDecimal(sendAmount)*BigDecimal(Math.pow(10, ethDecimal))).toFixed(0)
// "toAddress" is the address of the recipient's ETH wallet at the time of the transfer, which needs to be filled in specifically, and toAmount is the number of transfers
exchange.IO("api", "eth", "send", "toAddress", toAmount)
}
ईटीएच हस्तांतरण के लिए, आप सेट कर सकते हैं{gasPrice: 11, gasLimit: 111, nonce: 111}पैरामीटर, जो कि अंतिम पैरामीटर पर सेट किया जाता हैexchange.IO()आप अपनी विशिष्ट आवश्यकताओं के अनुसार कार्य कर सकते हैं।nonceऔर सिस्टम डिफ़ॉल्ट का उपयोग करें, या छोड़ देंgasLimit/gasPrice/nonceअनसेट करें और सभी के लिए सिस्टम डिफ़ॉल्ट मान का उपयोग करें.
function toAmount(s, decimals) {
return Number((BigDecimal(BigInt(s))/BigDecimal(Math.pow(10, decimals))).toString())
}
function main() {
var gasPrice = exchange.IO("api", "eth", "eth_gasPrice")
Log("gasPrice:", toAmount(gasPrice, 0)) // 5000000000 , in wei (5 gwei)
}
क्वेरीgasPrice:
function toAmount(s, decimals) {
// The toAmount function can convert hex-encoded values to decimal values
return Number((BigDecimal(BigInt(s))/BigDecimal(Math.pow(10, decimals))).toString())
}
function main() {
// Coding approve (authorization) method calls
var data = exchange.IO("encode", "0x111111111117dC0aa78b770fA6A738034120C302", "approve", "0xe592427a0aece92de3edee1f18e0157c05861564", "0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff")
Log("data:", data)
var gasPrice = exchange.IO("api", "eth", "eth_gasPrice")
Log("gasPrice:", toAmount(gasPrice, 0))
var obj = {
"from" : "0x0xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", // walletAddress
"to" : "0x111111111117dC0aa78b770fA6A738034120C302",
"gasPrice" : gasPrice,
"value" : "0x0",
"data" : "0x" + data,
}
var gasLimit = exchange.IO("api", "eth", "eth_estimateGas", obj)
Log("gasLimit:", toAmount(gasLimit, 0))
Log("gas fee", toAmount(gasLimit, 0) * toAmount(gasPrice, 0) / 1e18)
}
क्वेरीeth_estimateGas:
के दूसरे पैरामीटरexchange.IO()कार्य के साथ"eth"सीधे एथेरियम नोड सर्वर के लिए उपलब्ध आरपीसी विधियों को कॉल कर सकते हैं.
{@मज़ा BigDecimal}, {@मज़ा BigInt}
..exchange.IO("encode", ...)फ़ंक्शन को डेटा एन्कोडिंग के लिए बुलाया जाता है.
..exchange.IO("encode", ...)फ़ंक्शन एन्कोडेड डेटा लौटाता है.
स्ट्रिंग
exchange.IO(k, dataFormat,...args)exchange.IO(k, पता, डेटा प्रारूप)exchange.IO(k, पता, डेटाफॉर्मेट,...args)
..kपैरामीटर का उपयोग फंक्शन सेट करने के लिए किया जाता हैexchange.IO()फंक्शन, पर सेट"encode"इसका अर्थ है कि फ़ंक्शन का उपयोग डेटा कोडिंग के लिए किया जाता है।
क
सच
स्ट्रिंग
दaddressपैरामीटर का उपयोग स्मार्ट अनुबंध का पता सेट करने के लिए किया जाता है।exchange.IO("encode", ...)कार्य, में पारितaddressपैरामीटर स्मार्ट अनुबंध पर विधि कॉल को एन्कोडिंग इंगित करता है.exchange.IO("encode", ...)कार्य, यदिaddressपैरामीटर पारित नहीं किया जाता है, समारोह निर्दिष्ट प्रकार आदेश को कोड करने के लिए प्रयोग किया जाता है और कार्यात्मक रूप से बराबर हैabi.encodeमेंSolidity.
पता
झूठी
स्ट्रिंग
दdataFormatपैरामीटर का उपयोग एन्कोडेड डेटा की विधि, प्रकार और क्रम को निर्दिष्ट करने के लिए किया जाता है।
डेटाफ़ॉर्मेट
सच
स्ट्रिंग
दargपैरामीटर का उपयोग विशिष्ट डेटा मान को निर्दिष्ट करने के लिए किया जाता है जो किdataFormatपैरामीटर. वहाँ एक से अधिक हो सकता हैargपैरामीटर, और प्रकार और संख्याargपैरामीटर पर निर्भर करता हैdataFormatपैरामीटर सेटिंग.
आर्ग
झूठी
स्ट्रिंग, संख्या, टपल, सरणी, और अन्य सभी प्रकार सिस्टम द्वारा समर्थित
function main() {
// Main network address of ContractV3SwapRouterV2: 0x68b3465833fb72A70ecDF485E0e4C7bD8665Fc45
// Calling the unwrapWETH9 method requires registering the ABI first, which is omitted here
// "owner" represents the wallet address, which need to fill in the specific, 1 represents the number of unpacking, unpacking a WETH into ETH
var data = exchange.IO("encode", "0x68b3465833fb72A70ecDF485E0e4C7bD8665Fc45", "unwrapWETH9(uint256,address)", 1, "owner")
Log(data)
}
उदाहरण के लिए, एन्कोडिंग विधि बुलाunwrapWETH9:
function main() {
var x = 10
var address = "0x02a5fBb259d20A3Ad2Fdf9CCADeF86F6C1c1Ccc9"
var str = "Hello World"
var array = [1, 2, 3]
var ret = exchange.IO("encode", "uint256,address,string,uint256[]", x, address, str, array) // uint i.e. uint256 , the type length needs to be specified on FMZ
Log("ret:", ret)
/*
000000000000000000000000000000000000000000000000000000000000000a // x
00000000000000000000000002a5fbb259d20a3ad2fdf9ccadef86f6c1c1ccc9 // address
0000000000000000000000000000000000000000000000000000000000000080 // Offset of str
00000000000000000000000000000000000000000000000000000000000000c0 // Offset of array
000000000000000000000000000000000000000000000000000000000000000b // The length of str
48656c6c6f20576f726c64000000000000000000000000000000000000000000 // str data
0000000000000000000000000000000000000000000000000000000000000003 // The length of the array
0000000000000000000000000000000000000000000000000000000000000001 // array the first data
0000000000000000000000000000000000000000000000000000000000000002 // array the second data
0000000000000000000000000000000000000000000000000000000000000003 // array the third data
*/
}
यह abi.encodeमेंSolidity:
function main() {
var types = "tuple(a uint256,b uint8,c address),bytes"
var ret = exchange.IO("encode", types, {
a: 30,
b: 20,
c: "0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2"
}, "0011")
Log("encode: ", ret)
}
यह एक टपल या एक टपल युक्त प्रकार क्रम कोडिंग का समर्थन करता है.
इस प्रकार के आदेश में निम्नलिखित शामिल हैंtuple, bytes, तो जब कॉलexchange.IO()एन्कोडिंग के लिए, आप दो मापदंडों पारित करने के लिए जारी रखने की जरूरत हैः
{
a: 30,
b: 20,
c: "0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2"
}
दिए गए मापदंडों को भी संरचना और प्रकार के अनुरूप होना चाहिएtuple, के रूप में परिभाषितtypesप्रपत्र का पैरामीटर:tuple(a uint256,b uint8,c address).
bytes:"0011"
function main() {
var path = ["0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2", "0xdac17f958d2ee523a2206206994597c13d831ec7"] // ETH address, USDT address
var ret = exchange.IO("encode", "address[]", path)
Log("encode: ", ret)
}
यह सरणियों या प्रकारों में सरणियों के अनुक्रमिक एन्कोडिंग के लिए समर्थन करता हैः
..exchange.IO()फंक्शन में समाहित हैencodeविधि, जो फ़ंक्शन कॉल कोड को वापस कर सकता हैhexविशिष्ट उपयोग के लिए, आप सार्वजनिक रूप से उपलब्ध प्लेटफार्मों का संदर्भ ले सकते हैं
..exchange.IO("encodePacked", ...)फ़ंक्शन एक तरह से कहा जाता है कि के लिए प्रयोग किया जाता हैencodePacked encoding.
..exchange.IO("encodePacked", ...)फ़ंक्शन रिटर्नencodePackedएन्कोडेड डेटा।
स्ट्रिंग
exchange.IO(k, dataFormat,...args)
..kपैरामीटर का उपयोग फंक्शन सेट करने के लिए किया जाता हैexchange.IO()फंक्शन, पर सेट"encodePacked"का अर्थ है कि फ़ंक्शन का उपयोग डेटा के लिए किया जाता हैencodePackedएन्कोडिंग।
क
सच
स्ट्रिंग
दdataFormatपैरामीटर का उपयोग प्रकार और क्रम को निर्दिष्ट करने के लिए किया जाता हैencodePackedएन्कोडेड डेटा।
डेटाफ़ॉर्मेट
सच
स्ट्रिंग
दargपैरामीटर का उपयोग विशिष्ट डेटा मान को निर्दिष्ट करने के लिए किया जाता है जो किdataFormatपैरामीटर. वहाँ एक से अधिक हो सकता हैargपैरामीटर, और प्रकार और संख्याargपैरामीटर पर निर्भर करता हैdataFormatपैरामीटर सेटिंग.
आर्ग
सच
स्ट्रिंग, संख्या, टपल, सरणी, और अन्य सभी प्रकार सिस्टम द्वारा समर्थित
function main() {
var fee = exchange.IO("encodePacked", "uint24", 3000)
var tokenInAddress = "0x111111111117dC0aa78b770fA6A738034120C302"
var tokenOutAddress = "0x6b175474e89094c44da98b954eedeac495271d0f"
var path = tokenInAddress.slice(2).toLowerCase()
path += fee + tokenOutAddress.slice(2).toLowerCase()
Log("path:", path)
}
उपयोग करते समयUniswap V3, आप विनिमय पथ की तरह मापदंडों में पारित करने की जरूरत है, आप का उपयोग करने की जरूरत हैencodePackedएन्कोडिंग ऑपरेशनः
..exchange.IO("decode", ...)फ़ंक्शन को इस तरह से बुलाया जाता है जिसका उपयोग डिकोडिंग के लिए किया जाता है।
..exchange.IO("decode", ...)फ़ंक्शन डिकोड किए गए डेटा को लौटाता है. एक स्ट्रिंग लौटाता है जब केवल एक डेटा निर्दिष्ट हैdataFormatपैरामीटर. एक सरणी देता है जब वहाँ एक से अधिक डेटा द्वारा निर्दिष्ट हैdataFormatपैरामीटर
array、string
exchange.IO(k, dataफॉर्मेट, डेटा)
..kपैरामीटर का उपयोग फंक्शन सेट करने के लिए किया जाता हैexchange.IO()कार्य, और इसे सेट करने के लिए"decode"इसका अर्थ है कि फ़ंक्शन का उपयोग डेटा डिकोडिंग के लिए किया जाता है।
क
सच
स्ट्रिंग
दdataFormatपैरामीटर का उपयोग डिकोड किए गए डेटा के प्रकार और क्रम को निर्दिष्ट करने के लिए किया जाता है।
डेटाफ़ॉर्मेट
सच
स्ट्रिंग
दdataपैरामीटर का प्रयोग डेटा को डिकोड करने के लिए किया जाता है।
आंकड़ा
सच
स्ट्रिंग
function main() {
var types = "tuple(a uint256,b uint8,c address),bytes"
var ret = exchange.IO("encode", types, {
a: 30,
b: 20,
c: "0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2"
}, "0011")
Log("encode: ", ret)
var rawData = exchange.IO("decode", types, ret)
Log("decode:", rawData)
}
रिवर्स ऑपरेशनexchange.IO("encode", ...)कार्य:
function main() {
// register SwapRouter02 abi
var walletAddress = "0x398a93ca23CBdd2642a07445bCD2b8435e0a373f"
var routerAddress = "0x68b3465833fb72A70ecDF485E0e4C7bD8665Fc45"
var abi = `[{"inputs":[{"components":[{"internalType":"bytes","name":"path","type":"bytes"},{"internalType":"address","name":"recipient","type":"address"},{"internalType":"uint256","name":"amountOut","type":"uint256"},{"internalType":"uint256","name":"amountInMaximum","type":"uint256"}],"internalType":"struct IV3SwapRouter.ExactOutputParams","name":"params","type":"tuple"}],"name":"exactOutput","outputs":[{"internalType":"uint256","name":"amountIn","type":"uint256"}],"stateMutability":"payable","type":"function"}]`
exchange.IO("abi", routerAddress, abi) // abi only uses the contents of the local exactOutput method, the full abi can be searched on the Internet
// encode path
var fee = exchange.IO("encodePacked", "uint24", 3000)
var tokenInAddress = "0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2"
var tokenOutAddress = "0xdac17f958d2ee523a2206206994597c13d831ec7"
var path = tokenInAddress.slice(2).toLowerCase()
path += fee + tokenOutAddress.slice(2).toLowerCase()
Log("path:", path)
var dataTuple = {
"path" : path,
"recipient" : walletAddress,
"amountOut" : 1000,
"amountInMaximum" : 1,
}
// encode SwapRouter02 exactOutput
var rawData = exchange.IO("encode", routerAddress, "exactOutput", dataTuple)
Log("method hash:", rawData.slice(0, 8)) // 09b81346
Log("params hash:", rawData.slice(8))
// decode exactOutput params
var decodeRaw = exchange.IO("decode", "tuple(path bytes,recipient address,amountOut uint256,amountInMaximum uint256)", rawData.slice(8))
Log("decodeRaw:", decodeRaw)
}
निम्नलिखित उदाहरण पहले एकencodePackedऑपरेशन परpathपैरामीटर प्रसंस्करण, क्योंकिexactOutputविधि कॉल है कि बाद में एन्कोड करने की जरूरत है की आवश्यकता हैpathएक पैरामीटर के रूप में. तोencodeदexactOutputमार्ग अनुबंध की विधि, जिसमें केवल एक प्रकार का पैरामीटर होता हैtuple. विधि का नामexactOutputइस प्रकार कोडित हैः0x09b81346, औरexchange.IO("decode", ...)परिणामी कोड को डिकोड करने की विधिdecodeRaw, चर के अनुरूपdataTuple.
डाटा प्रोसेसिंग के लिए,exchange.IO()समारोह न केवल एन्कोडिंग का समर्थन करता है, बल्कि डिकोडिंग भी करता है।
..exchange.IO("key", ...)फ़ंक्शन निजी कुंजी स्विच करने के लिए एक तरह से कहा जाता है.
exchange.IO(के, कुंजी)
पैरामीटरkके कार्य को सेट करने के लिए प्रयोग किया जाता हैexchange.IO()फंक्शन, पर सेट"key"इसका अर्थ है कि फ़ंक्शन का उपयोग निजी कुंजी को स्विच करने के लिए किया जाता है.
क
सच
स्ट्रिंग
दkeyपैरामीटर का उपयोग निजी कुंजी सेट करने के लिए किया जाता है.
कुंजी
सच
स्ट्रिंग
function main() {
exchange.IO("key", "Private Key") // "Private Key" represents the private key string, which needs to be filled in specifically
}
..exchange.IO()फ़ंक्शन निजी कुंजी स्विच करने का समर्थन करता है और यह कई वॉलेट पते को हेरफेर कर सकता है। कई वॉलेट पते को हेरफेर करने के लिए कई एक्सचेंज ऑब्जेक्ट (देखेंः {@var/EXCHANGE/exchanges exchanges}) जोड़ना भी संभव है।
..exchange.IO("api", ...)फ़ंक्शन को उस तरह से बुलाया जाता है जिसका उपयोग स्मार्ट कॉन्ट्रैक्ट के तरीकों को बुलाने के लिए किया जाता है।
..exchange.IO("api", ...)फ़ंक्शन तथाकथित स्मार्ट कॉन्ट्रैक्ट विधि का रिटर्न मान लौटाता है.
string, number, bool, object, array, null और सिस्टम द्वारा समर्थित अन्य सभी प्रकार
exchange.IO(k, पता, विधि)exchange.IO(k, पता, विधि,... args)exchange.IO(k, पता, विधि, मूल्य,... args)
..kपैरामीटर का उपयोग फंक्शन सेट करने के लिए किया जाता हैexchange.IO()फंक्शन, पर सेट"api"इंगित करता है कि फ़ंक्शन का उपयोग कॉल अनुरोध का विस्तार करने के लिए किया जाता है.
क
सच
स्ट्रिंग
दaddressपैरामीटर का उपयोग स्मार्ट कॉन्ट्रैक्ट के पते को निर्दिष्ट करने के लिए किया जाता है।
पता
सच
स्ट्रिंग
दmethodपैरामीटर का उपयोग स्मार्ट कॉन्ट्रैक्ट की विधि को निर्दिष्ट करने के लिए किया जाता है।
विधि
सच
स्ट्रिंग
दvalueपैरामीटर का उपयोग ईटीएच की मात्रा को भेजने के लिए किया जाता है।stateMutabilityनिष्पादित करने के लिए स्मार्ट अनुबंध विधि की विशेषता हैpayable, फिरvalueपैरामीटर पारित करने की जरूरत है."stateMutability": "payable"एट्रिब्यूट को एबीआई से देखा जा सकता है।exchange.IO()समारोह के आधार पर आवश्यक पैरामीटर निर्धारित करेगाstateMutabilityएबीआई में विशेषता है कि पंजीकृत किया गया है.stateMutabilityविशेषता हैnonpayable, फिरvalueपैरामीटर को पास करने की आवश्यकता नहीं है।
मूल्य
झूठी
संख्या, स्ट्रिंग
दargपैरामीटर का उपयोग स्मार्ट अनुबंध की विधि के मापदंडों को निर्दिष्ट करने के लिए किया जाता है।argपैरामीटर, और प्रकार और संख्याargपैरामीटर स्मार्ट अनुबंध की विधि पर निर्भर करता है बुलाया जा रहा है।
आर्ग
झूठी
स्ट्रिंग, संख्या, bool, और सिस्टम द्वारा समर्थित अन्य सभी प्रकार
function main(){
var tokenAddress = "0x111111111117dC0aa78b770fA6A738034120C302" // The contract address of the token, the token is 1INCH in the example
Log(exchange.IO("api", tokenAddress, "decimals")) // Query, print 1INCH tokens with precision index of 18
}
..decimalsविधि हैconstantईआरसी20 की ऐसी विधि जो गैस की खपत नहीं करती है और यह टोकन के सटीक डेटा को क्वेरी कर सकती है।decimalsविधि के पास कोई पैरामीटर नहीं है। रिटर्न मानः टोकन के सटीक डेटा।
function main(){
// The contract address of the token, in the example the token is 1INCH
var tokenAddress = "0x111111111117dC0aa78b770fA6A738034120C302"
// For example, the query yields 1000000000000000000, divided by the precision unit of the token 1e18, the wallet to which the current exchange object is bound has authorized 1 1INCH to the spender address
Log(exchange.IO("api", tokenAddress, "allowance", "owner", "spender"))
}
..allowanceविधि हैconstantERC20 की एक विधि है कि गैस की खपत उत्पन्न नहीं करता है और एक निश्चित अनुबंध पते के लिए एक टोकन की अधिकृत राशि की क्वेरी कर सकते हैं।allowanceविधि 2 मापदंड लेता है, पहला वॉलेट पता है और दूसरा अधिकृत पता है। रिटर्न मानः टोकन की प्राधिकरण राशि।
owner: वॉलेट का पता, उदाहरण स्ट्रिंग spender: अनुमोदित अनुबंध का पता, उदाहरण स्ट्रिंग Uniswap V3 router v1 address.
function main(){
// The contract address of the token, the token is 1INCH in the example
var tokenAddress = "0x111111111117dC0aa78b770fA6A738034120C302"
// The hexadecimal string of the authorization amount: 0xde0b6b3a7640000 , the corresponding decimal string: 1e18 , 1e18 divided by the precision unit of the token, i.e. 1 token amount, so this refers to the authorization of one token
Log(exchange.IO("api", tokenAddress, "approve", "spender", "0xde0b6b3a7640000"))
}```
The ```approve``` method is a non-```constant``` method of ERC20, which generates gas consumption and is used to authorize the operation amount of a token to a contract address. The ```approve``` method takes 2 parameters, the first one is the address to be authorized and the second one is the amount to be authorized. Return value: txid.
```spender```: the address of the authorized contract, the example is replaced by the string "spender", the actual use needs to fill in the specific address, for example, it can be ```Uniswap V3 router v1``` address. ```0xde0b6b3a7640000```: the number of authorizations, here is the hexadecimal string, the corresponding decimal value is 1e18, divided by the token precision unit in the example (i.e. 1e18). The result is that 1 token is authorized. The third parameter of the ```exchange.IO()``` function is passed to the method name ```approve```, which can also be written in the form of methodId, such as "0x571ac8b0". It is also possible to write the full standard method name, for example: "approve(address,uint256)".
```javascript
function main() {
var ContractV3SwapRouterV2 = "0x68b3465833fb72A70ecDF485E0e4C7bD8665Fc45"
var tokenInName = "ETH"
var amountIn = 0.01
var options = {gasPrice: 5000000000, gasLimit: 21000, nonce: 100} // This is an example, depending on the actual scene settings
var data = "" // The encoded data, here is the empty string, depending on the actual scene settings
var tx = exchange.IO("api", ContractV3SwapRouterV2, "multicall(uint256,bytes[])", (tokenInName == 'ETH' ? amountIn : 0), (new Date().getTime() / 1000) + 3600, data, options || {})
}
..multicallविधि एक गैर-constantविधिUniswap V3जो गैस की खपत उत्पन्न करता है और टोकन को कई तरीकों से रिडीम करने के लिए उपयोग किया जाता है।
दmulticallविधि के पास पैरामीटर पास करने के विभिन्न तरीके हो सकते हैं, आप एबीआई की जांच कर सकते हैं जिसमें विधि विशेष रूप से है, आपको विधि को कॉल करने से पहले एबीआई को पंजीकृत करने की आवश्यकता है। रिटर्न मानः txid.
विशिष्ट उदाहरणों के लिएmulticallविधि कॉल, आप सार्वजनिक रूप से उपलब्ध प्लेटफार्मों का संदर्भ ले सकते हैं
कुछ विवरण यहाँ छद्म-कोड का उपयोग करके वर्णित हैं:
exchange.IO("api", ContractV3SwapRouterV2, "multicall(uint256,bytes[])", value, deadline, data)
ContractV3SwapRouterV2: Uniswap V3 के राउटर v2 का पता।value: स्थानांतरित करने के लिए ईटीएच की राशि, यदि एक्सचेंज ऑपरेशन का टोकन ईटीएच नहीं है तो 0 पर सेट की जाती है।deadline: deadlineके पैरामीटर हैmulticallविधि, जिसे (नई दिनांक))) / 1000) + 3600 पर सेट किया जा सकता है, यह दर्शाता है कि यह एक घंटे के लिए मान्य है।data: dataके पैरामीटर हैmulticallविधि, पैकिंग ऑपरेशन के आंकड़े जो किया जाना है।
के समानexchange.IO("api", "eth", "send", "toAddress", toAmount),gasLimit/gasPrice/nonceविधि कॉल की सेटिंग को कॉल करते समय निर्दिष्ट किया जा सकताmulticallविधि।
फिर, हम वर्णन करने के लिए छद्म कोड का उपयोग करते हैंः
exchange.IO("api", ContractV3SwapRouterV2, "multicall(uint256,bytes[])", value, deadline, data, {gasPrice: 123456, gasLimit: 21000})
पैरामीटर{gasPrice: 11, gasLimit: 111, nonce: 111}विशिष्ट आवश्यकताओं के अनुसार सेट किया जा सकता है, जो किexchange.IO()कार्य।
आप छोड़ सकते हैंnonceऔर सिस्टम डिफ़ॉल्ट मान का उपयोग करें, या छोड़ देंgasLimit/gasPrice/nonceअनसेट करें और सभी के लिए सिस्टम डिफ़ॉल्ट मान का उपयोग करें.
..exchange.IO("address")फ़ंक्शन को इस तरह से बुलाया जाता है कि {@var/EXCHANGE exchange} विनिमय ऑब्जेक्ट द्वारा कॉन्फ़िगर किए गए वॉलेट का पता प्राप्त हो।
..exchange.IO("address")फ़ंक्शन कॉन्फ़िगर किए गए वॉलेट का पता लौटाता है.
स्ट्रिंग
exchange.IO(क)
..kपैरामीटर का उपयोग फंक्शन सेट करने के लिए किया जाता हैexchange.IO()फंक्शन, पर सेट"address"इसका मतलब है कि फ़ंक्शन का उपयोग कॉन्फ़िगर किए गए वॉलेट पते को प्राप्त करने के लिए किया जाता है.
क
सच
स्ट्रिंग
function main() {
Log(exchange.IO("address")) // Print the wallet address of the private key configured on the exchange object
}
..exchange.IO("base", ...)फ़ंक्शन को आरपीसी नोड पता सेट करने के तरीके से बुलाया जाता है.
exchange.IO(k, पता)
..kपैरामीटर का उपयोग फंक्शन सेट करने के लिए किया जाता हैexchange.IO()फंक्शन, पर सेट"base"इसका मतलब है कि फ़ंक्शन का उपयोग आरपीसी नोड्स को स्विच करने के लिए किया जाता है।
क
सच
स्ट्रिंग
दaddressपैरामीटर का उपयोग आरपीसी नोड पते को सेट करने के लिए किया जाता है.
पता
सच
स्ट्रिंग
function main() {
var chainRpc = "https://bsc-dataseed.binance.org"
e.IO("base", chainRpc) // Switching to BSC chain
}
..TA.MACD()फलन का उपयोग गणना के लिए किया जाता हैघातीय समतल असमानता और समानता MACD संकेतक.
रिटर्न मूल्यTA.MACD()फलन एक दो आयामी सरणी है जिसकी संरचना हैः[DIF, DEA, MACD].
सरणी
TA.MACD ((inReal) TA.MACD ((इंरियल, ऑप्टइंफास्टपीरियड, ऑप्टइंस्लोपीरियड, ऑप्टइंसिग्नलपीरियड)
..inRealपैरामीटर का उपयोग के-लाइन डेटा को निर्दिष्ट करने के लिए किया जाता है।
वास्तविक
सच
{@struct/Record Record} संरचना सरणी, संख्यात्मक सरणी
दoptInFastPeriodतेजी से अवधि निर्धारित करने के लिए पैरामीटर का उपयोग किया जाता है।
optInFastPeriod
झूठी
संख्या
दoptInSlowPeriodपैरामीटर धीमी अवधि सेट करने के लिए प्रयोग किया जाता है.
optInSlowPeriod
झूठी
संख्या
दoptInSignalPeriodपैरामीटर का उपयोग संकेत अवधि सेट करने के लिए किया जाता है।
सिग्नल अवधि में
झूठी
संख्या
function main(){
// You can fill in different k-line periods, such as PERIOD_M1,PERIOD_M30,PERIOD_H1...
var records = exchange.GetRecords(PERIOD_M15)
var macd = TA.MACD(records, 12, 26, 9)
// Watching the logs, you can see that three arrays are returned, corresponding to DIF, DEA and MACD.
Log("DIF:", macd[0], "DEA:", macd[1], "MACD:", macd[2])
}
def main():
r = exchange.GetRecords(PERIOD_M15)
macd = TA.MACD(r, 12, 26, 9)
Log("DIF:", macd[0], "DEA:", macd[1], "MACD:", macd[2])
void main() {
auto r = exchange.GetRecords(PERIOD_M15);
auto macd = TA.MACD(r, 12, 26, 9);
Log("DIF:", macd[0], "DEA:", macd[1], "MACD:", macd[2]);
}
..TAएफएमजेड क्वांट के संकेतक पुस्तकालय, सामान्य संकेतक एल्गोरिदम के लिए अनुकूलित। यह समर्थन करता हैJavaScript, Python, C++भाषा रणनीति कॉल,ओपन सोर्स टीए लाइब्रेरी कोड.
के डिफ़ॉल्ट मानoptInFastPeriod, optInSlowPeriod, औरoptInSignalPeriodपैरामीटरTA.MACD()कार्य हैंः12, 26, और9.
{@fun/TA/TA.KDJ TA.KDJ}, {@fun/TA/TA.RSI TA.RSI}, {@fun/TA/TA.ATR TA.ATR}, {@fun/TA/TA.OBV TA.OBV}, {@fun/TA/TA.MA}TA.MA}, {@fun/TA/TA.EMA TA.EMA}, {@fun/TA/TA.BOLL TA.BOLL}, {@fun/TA/TA.Alligator TA.Alligator}, {@fun/TA/TA.CMF TA.CMF}, {@fun/TA/TA.Highest TA.Highest}, {@fun/TA/TA.Lowest TA.Lowest}
..TA.KDJ()फलन की गणना करने के लिए प्रयोग किया जाता हैस्टोकैस्टिक संकेतकों.
रिटर्न मूल्यTA.KDJ()फलन एक दो आयामी सरणी है जिसकी संरचना हैः[K, D, J].
सरणी
TA.KDJ ((inReal) TA.KDJ ((Real, अवधि, kPeriod, dPeriod)
..inRealपैरामीटर का उपयोग के-लाइन डेटा को निर्दिष्ट करने के लिए किया जाता है।
वास्तविक
सच
{@struct/Record Record} संरचना सरणी, संख्यात्मक सरणी
दperiodपैरामीटर अवधि 1 सेट करने के लिए प्रयोग किया जाता है।
अवधि
झूठी
संख्या
दkPeriodपैरामीटर अवधि 2 सेट करने के लिए प्रयोग किया जाता है।
पीरियड
झूठी
संख्या
दdPeriodपैरामीटर अवधि 3 सेट करने के लिए प्रयोग किया जाता है।
dअवधि
झूठी
संख्या
function main(){
var records = exchange.GetRecords(PERIOD_M15)
var kdj = TA.KDJ(records, 9, 3, 3)
Log("k:", kdj[0], "d:", kdj[1], "j:", kdj[2])
}
def main():
r = exchange.GetRecords(PERIOD_M15)
kdj = TA.KDJ(r, 9, 3, 3)
Log("k:", kdj[0], "d:", kdj[1], "j:", kdj[2])
void main() {
auto r = exchange.GetRecords();
auto kdj = TA.KDJ(r, 9, 3, 3);
Log("k:", kdj[0], "d:", kdj[1], "j:", kdj[2]);
}
के लिए डिफ़ॉल्ट मानperiod, kPeriod, औरdPeriodपैरामीटरTA.KDJ()कार्य हैंः9, 3, और3.
{@fun/TA/TA.MACD TA.MACD}, {@fun/TA/TA.RSI TA.RSI}, {@fun/TA/TA.ATR TA.ATR}, {@fun/TA/TA.OBV TA.OBV}, {@fun/TA/TA.MA}TA.MA}, {@fun/TA/TA.EMA TA.EMA}, {@fun/TA/TA.BOLL TA.BOLL}, {@fun/TA/TA.Alligator TA.Alligator}, {@fun/TA/TA.CMF TA.CMF}, {@fun/TA/TA.Highest TA.Highest}, {@fun/TA/TA.Lowest TA.Lowest}
..TA.RSI()फलन का उपयोग गणना के लिए किया जाता हैशक्ति सूचक.
रिटर्न मूल्यTA.RSI()कार्य हैः एक आयामी सरणी।
सरणी
TA.RSI ((inReal) TA.RSI ((inReal, optInTimePeriod)
..inRealपैरामीटर का उपयोग के-लाइन डेटा को निर्दिष्ट करने के लिए किया जाता है।
वास्तविक
सच
{@struct/Record Record} संरचना सरणी, संख्यात्मक सरणी
दoptInTimePeriodपैरामीटर का उपयोग अवधि को सेट करने के लिए किया जाता है।
optInTimeपीरियड
झूठी
संख्या
function main(){
var records = exchange.GetRecords(PERIOD_M30)
var rsi = TA.RSI(records, 14)
Log(rsi)
}
def main():
r = exchange.GetRecords(PERIOD_M30)
rsi = TA.RSI(r, 14)
Log(rsi)
void main() {
auto r = exchange.GetRecords(PERIOD_M30);
auto rsi = TA.RSI(r, 14);
Log(rsi);
}
डिफ़ॉल्ट मानoptInTimePeriodपैरामीटरTA.RSI()कार्य है:14.
{@fun/TA/TA.MACD TA.MACD}, {@fun/TA/TA.KDJ TA.KDJ}, {@fun/TA/TA.ATR TA.ATR}, {@fun/TA/TA.OBV TA.OBV}, {@fun/TA/TA.MA}TA.MA}, {@fun/TA/TA.EMA TA.EMA}, {@fun/TA/TA.BOLL TA.BOLL}, {@fun/TA/TA.Alligator TA.Alligator}, {@fun/TA/TA.CMF TA.CMF}, {@fun/TA/TA.Highest TA.Highest}, {@fun/TA/TA.Lowest TA.Lowest}
..TA.ATR()फलन का उपयोग गणना के लिए किया जाता हैऔसत वास्तविक अस्थिरता सूचक.
रिटर्न मूल्यTA.ATR()कार्य हैः एक आयामी सरणी।
सरणी
TA.ATR ((inPriceHLC) TA.ATR ((PriceHLC, optInTimePeriod)
..inPriceHLCपैरामीटर का उपयोग के-लाइन डेटा को निर्दिष्ट करने के लिए किया जाता है।
inPriceHLC
सच
{@struct/Record Record} संरचना सरणी
दoptInTimePeriodपैरामीटर का उपयोग अवधि को सेट करने के लिए किया जाता है।
optInTimeपीरियड
झूठी
संख्या
function main(){
var records = exchange.GetRecords(PERIOD_M30)
var atr = TA.ATR(records, 14)
Log(atr)
}
def main():
r = exchange.GetRecords(PERIOD_M30)
atr = TA.ATR(r, 14)
Log(atr)
void main() {
auto r = exchange.GetRecords(PERIOD_M30);
auto atr = TA.ATR(r, 14);
Log(atr);
}
डिफ़ॉल्ट मानoptInTimePeriodपैरामीटरTA.ATR()कार्य है:14.
{@fun/TA/TA.MACD TA.MACD}, {@fun/TA/TA.KDJ TA.KDJ}, {@fun/TA/TA.RSI TA.RSI}, {@fun/TA/TA.OBV TA.OBV}, {@fun/TA/TA.MA}TA.MA}, {@fun/TA/TA.EMA TA.EMA}, {@fun/TA/TA.BOLL TA.BOLL}, {@fun/TA/TA.Alligator TA.Alligator}, {@fun/TA/TA.CMF TA.CMF}, {@fun/TA/TA.Highest TA.Highest}, {@fun/TA/TA.Lowest TA.Lowest}
..TA.OBV()फलन का उपयोग गणना के लिए किया जाता हैऊर्जा ज्वार सूचक.
रिटर्न मूल्यTA.OBV()कार्य हैः एक आयामी सरणी।
सरणी
TA.OBV ((inReal) TA.OBV ((inReal, inPriceV)
..inRealपैरामीटर का उपयोग के-लाइन डेटा को निर्दिष्ट करने के लिए किया जाता है।
वास्तविक
सच
{@struct/Record Record} संरचना सरणी, संख्यात्मक सरणी
दinPriceVपैरामीटर का उपयोग लेनदेन राशि के आंकड़ों को निर्दिष्ट करने के लिए किया जाता है।
inPriceV
झूठी
{@struct/Record Record} संरचना सरणी
function main(){
var records = exchange.GetRecords(PERIOD_M30)
var obv = TA.OBV(records)
Log(obv)
}
def main():
r = exchange.GetRecords(PERIOD_M30)
obv = TA.OBV(r)
Log(obv)
void main() {
auto r = exchange.GetRecords(PERIOD_M30);
auto obv = TA.OBV(r);
Log(obv);
}
{@fun/TA/TA.MACD TA.MACD}, {@fun/TA/TA.KDJ TA.KDJ}, {@fun/TA/TA.RSI TA.RSI}, {@fun/TA/TA.ATR TA.ATR}, {@fun/TA/TA.MA}, {@fun/TA/TA.MA}, {@fun/TA/TA.ATR TA.ATR}, {@fun/TA/TA.MA}, {@fun/TA/TA.KDJ TA.KDJ}, {@fun/TA/TA.RSI TA.RSI}, {@fun/TA/TA.RSI TA.RSI},TA.MA}, {@fun/TA/TA.EMA TA.EMA}, {@fun/TA/TA.BOLL TA.BOLL}, {@fun/TA/TA.Alligator TA.Alligator}, {@fun/TA/TA.CMF TA.CMF}, {@fun/TA/TA.Highest TA.Highest}, {@fun/TA/TA.Lowest TA.Lowest}
..TA.MA()फलन का उपयोग गणना के लिए किया जाता हैएमएसीडी सूचक.
रिटर्न मूल्यTA.MA()कार्य हैः एक आयामी सरणी।
सरणी
TA.MA(असत्य)TA.MA(inReal, optInTimePeriod)
..inRealपैरामीटर का उपयोग के-लाइन डेटा को निर्दिष्ट करने के लिए किया जाता है।
वास्तविक
सच
{@struct/Record Record} संरचना सरणी, संख्यात्मक सरणी
दoptInTimePeriodपैरामीटर का उपयोग अवधि को सेट करने के लिए किया जाता है।
optInTimeपीरियड
झूठी
संख्या
function main(){
var records = exchange.GetRecords(PERIOD_M30)
var ma = TA.MA(records, 14)
Log(ma)
}
def main():
r = exchange.GetRecords(PERIOD_M30)
ma = TA.MA(r, 14)
Log(ma)
void main() {
auto r = exchange.GetRecords(PERIOD_M30);
auto ma = TA.MA(r, 14);
Log(ma);
}
डिफ़ॉल्ट मानoptInTimePeriodपैरामीटरTA.MA()कार्य है:9.
{@fun/TA/TA.MACD TA.MACD}, {@fun/TA/TA.KDJ TA.KDJ}, {@fun/TA/TA.RSI TA.RSI}, {@fun/TA/TA.ATR TA.ATR}, {@fun/TA/TA.OBV TA.OBV}, {@fun/TA/TA.EMA TA.EMA}, {@fun/TA/TA.BOLL TA.BOLL}, {@fun/TA/TA.Alligator TA.Alligator}, {@fun/TA/TA.CMF TA.CMF}, {@fun/TA/TA.Highest.Highest}, {@fun/TA/TA.Lowest.TA.Lowest}, {@fun/TA/TA.Lowest.TA.Lowest}, {@fun/TA/TA.BOLL TA.BOLL}, {@fun/TA/TA.ALIGATOR TA.CMF.CMF}, {@fun/TA/TA/TA.H
..TA.EMA()फलन का उपयोग गणना के लिए किया जाता हैघातीय औसत सूचक.
रिटर्न मूल्यTA.EMA()कार्य हैः एक आयामी सरणी।
सरणी
TA.EMA ((inReal) TA.EMA ((Real, optInTimePeriod)
..inRealपैरामीटर का उपयोग के-लाइन डेटा को निर्दिष्ट करने के लिए किया जाता है।
वास्तविक
सच
{@struct/Record Record} संरचना सरणी, संख्यात्मक सरणी
दoptInTimePeriodपैरामीटर का उपयोग अवधि को सेट करने के लिए किया जाता है।
optInTimeपीरियड
झूठी
संख्या
function main(){
var records = exchange.GetRecords()
// Determine if the number of K-line bars meets the calculation period of the indicator
if (records && records.length > 9) {
var ema = TA.EMA(records, 9)
Log(ema)
}
}
def main():
r = exchange.GetRecords()
if r and len(r) > 9:
ema = TA.EMA(r, 9)
Log(ema)
void main() {
auto r = exchange.GetRecords();
if(r.Valid && r.size() > 9) {
auto ema = TA.EMA(r, 9);
Log(ema);
}
}
डिफ़ॉल्ट मानoptInTimePeriodपैरामीटरTA.EMA()कार्य है:9.
{@fun/TA/TA.MACD TA.MACD}, {@fun/TA/TA.KDJ TA.KDJ}, {@fun/TA/TA.RSI TA.RSI}, {@fun/TA/TA.ATR TA.ATR}, {@fun/TA/TA.OBV TA.OBV}, {@fun/TA/TA.MA},TA.MA}, {@fun/TA/TA.BOLL TA.BOLL}, {@fun/TA/TA.Alligator TA.Alligator}, {@fun/TA/TA.CMF TA.CMF}, {@fun/TA/TA.Highest TA.Highest}, {@fun/TA/TA.Lowest TA.Lowest}
..TA.BOLL()फलन का उपयोग गणना के लिए किया जाता हैबोलिंगर बैंड सूचक.
रिटर्न मूल्यTA.BOLL()फलन एक दो आयामी सरणी है जिसकी संरचना हैः[upLine, midLine, downLine].
सरणी
TA.BOLL ((inReal) TA.BOLL ((inReal, अवधि, गुणक)
..inRealपैरामीटर का उपयोग के-लाइन डेटा को निर्दिष्ट करने के लिए किया जाता है।
वास्तविक
सच
{@struct/Record Record} संरचना सरणी, संख्यात्मक सरणी
दperiodपैरामीटर का उपयोग अवधि को सेट करने के लिए किया जाता है।
अवधि
झूठी
संख्या
दmultiplierगुणक सेट करने के लिए पैरामीटर का प्रयोग किया जाता है।
गुणक
झूठी
संख्या
function main() {
var records = exchange.GetRecords()
if(records && records.length > 20) {
var boll = TA.BOLL(records, 20, 2)
var upLine = boll[0]
var midLine = boll[1]
var downLine = boll[2]
Log(upLine)
Log(midLine)
Log(downLine)
}
}
def main():
r = exchange.GetRecords()
if r and len(r) > 20:
boll = TA.BOLL(r, 20, 2)
upLine = boll[0]
midLine = boll[1]
downLine = boll[2]
Log(upLine)
Log(midLine)
Log(downLine)
void main() {
auto r = exchange.GetRecords();
if(r.Valid && r.size() > 20) {
auto boll = TA.BOLL(r, 20, 2);
auto upLine = boll[0];
auto midLine = boll[1];
auto downLine = boll[2];
Log(upLine);
Log(midLine);
Log(downLine);
}
}
के लिए डिफ़ॉल्ट मानperiodऔरmultiplierपैरामीटरTA.BOLL()कार्य हैंः20और2.
{@fun/TA/TA.MACD TA.MACD}, {@fun/TA/TA.KDJ TA.KDJ}, {@fun/TA/TA.RSI TA.RSI}, {@fun/TA/TA.ATR TA.ATR}, {@fun/TA/TA.OBV TA.OBV}, {@fun/TA/TA.MA},TA.MA}, {@fun/TA/TA.EMA TA.EMA}, {@fun/TA/TA.Alligator TA.Alligator}, {@fun/TA/TA.CMF TA.CMF}, {@fun/TA/TA.Highest TA.Highest}, {@fun/TA/TA.Lowest TA.Lowest}
..TA.Alligator()फलन का उपयोग गणना के लिए किया जाता हैमगरमच्छ सूचक.
रिटर्न मूल्यTA.Alligator()फलन एक दो आयामी सरणी है जिसकी संरचना हैः[jawLine, teethLine, lipsLine].
सरणी
टी.ए. मगरमच्छ ((इंरियल) टी.ए. मगरमच्छ ((वास्तविक में, जबड़ालंबाई, दांतलंबाई, होंठलंबाई)
..inRealपैरामीटर का उपयोग के-लाइन डेटा को निर्दिष्ट करने के लिए किया जाता है।
वास्तविक
सच
{@struct/Record Record} संरचना सरणी, संख्यात्मक सरणी
दjawLengthपैरामीटर जबड़े की अवधि को सेट करने के लिए प्रयोग किया जाता है।
जबड़ालंबाई
झूठी
संख्या
दteethLengthपैरामीटर दांत अवधि सेट करने के लिए प्रयोग किया जाता है।
दांतलंबाई
झूठी
संख्या
दlipsLengthपैरामीटर का उपयोग ऊपरी होंठ की अवधि को सेट करने के लिए किया जाता है।
होंठलंबाई
झूठी
संख्या
function main(){
var records = exchange.GetRecords()
var alligator = TA.Alligator(records)
Log("jawLine:", alligator[0])
Log("teethLine:", alligator[1])
Log("lipsLine:", alligator[2])
}
def main():
records = exchange.GetRecords()
alligator = TA.Alligator(records)
Log("jawLine:", alligator[0])
Log("teethLine:", alligator[1])
Log("lipsLine:", alligator[2])
void main() {
auto records = exchange.GetRecords();
auto alligator = TA.Alligator(records);
Log("jawLine:", alligator[0]);
Log("teethLine:", alligator[1]);
Log("lipsLine:", alligator[2]);
}
के डिफ़ॉल्ट मानjawLength, teethLength, औरlipsLengthपैरामीटरTA.Alligator()कार्य हैंः13, 8, और5.
{@fun/TA/TA.MACD TA.MACD}, {@fun/TA/TA.KDJ TA.KDJ}, {@fun/TA/TA.RSI TA.RSI}, {@fun/TA/TA.ATR TA.ATR}, {@fun/TA/TA.OBV TA.OBV}, {@fun/TA/TA.MA},TA.MA}, {@fun/TA/TA.EMA TA.EMA}, {@fun/TA/TA.BOLL TA.BOLL}, {@fun/TA/TA.CMF TA.CMF}, {@fun/TA/TA.Highest TA.Highest}, {@fun/TA/TA.Lowest TA.Lowest}
..TA.CMF()फलन का उपयोग गणना के लिए किया जाता हैचाइकिन नकदी प्रवाह सूचक.
रिटर्न मूल्यTA.CMF()कार्य हैः एक आयामी सरणी।
सरणी
TA.CMF ((inReal) TA.CMF ((inReal, inPriceV)
..inRealपैरामीटर का उपयोग के-लाइन डेटा को निर्दिष्ट करने के लिए किया जाता है।
वास्तविक
सच
{@struct/Record Record} संरचना सरणी, संख्यात्मक सरणी
दinPriceVपैरामीटर का उपयोग वॉल्यूम डेटा को निर्दिष्ट करने के लिए किया जाता है।
inPriceV
झूठी
{@struct/Record Record} संरचना सरणी
function main() {
var records = exchange.GetRecords()
var cmf = TA.CMF(records)
Log(cmf)
}
def main():
records = exchange.GetRecords()
cmf = TA.CMF(records)
Log(cmf)
void main() {
auto records = exchange.GetRecords();
auto cmf = TA.CMF(records);
Log(cmf);
}
{@fun/TA/TA.MACD TA.MACD}, {@fun/TA/TA.KDJ TA.KDJ}, {@fun/TA/TA.RSI TA.RSI}, {@fun/TA/TA.ATR TA.ATR}, {@fun/TA/TA.OBV TA.OBV}, {@fun/TA/TA.MA},TA.MA}, {@fun/TA/TA.EMA TA.EMA}, {@fun/TA/TA.BOLL TA.BOLL}, {@fun/TA/TA.Alligator TA.Alligator}, {@fun/TA/TA.Highest TA.Highest}, {@fun/TA/TA.Lowest TA.Lowest}
..TA.Highest()फलन का उपयोग गणना के लिए किया जाता हैअवधि की उच्चतम कीमत.
..TA.Highest()फ़ंक्शन वर्तमान बार को छोड़कर, अंतिम निश्चित अवधि में किसी विशेषता का अधिकतम मान लौटाता है.
संख्या
उच्चतम (सत्य में) TA.Highest ((inReal, period, attr)
..inRealपैरामीटर का उपयोग के-लाइन डेटा को निर्दिष्ट करने के लिए किया जाता है।
वास्तविक
सच
{@struct/Record Record} संरचना सरणी, संख्यात्मक सरणी
दperiodपैरामीटर का उपयोग अवधि को सेट करने के लिए किया जाता है।
अवधि
झूठी
संख्या
दattrपैरामीटर का उपयोग गुणों को सेट करने के लिए किया जाता है, वैकल्पिक रूप सेःOpen, Close, Low, High, Volume, OpenInterest.
एटीआर
झूठी
स्ट्रिंग
function main() {
var records = exchange.GetRecords()
var highestForOpen = TA.Highest(records, 10, "Open")
Log(highestForOpen)
}
def main():
records = exchange.GetRecords()
highestForOpen = TA.Highest(records, 10, "Open")
Log(highestForOpen)
void main() {
auto records = exchange.GetRecords();
auto highestForOpen = TA.Highest(records.Open(), 10);
Log(highestForOpen);
}
उदाहरण के लिए, यदिTA.Highest(records, 30, "High")समारोह कहा जाता है, यदि अवधि पैरामीटरperiodपर सेट है0, इसका मतलब है कि सभी गणना करने के लिएBarsके-लाइन डेटा के द्वारा पारितinRealपैरामीटर; यदि विशेषता पैरामीटरattrनिर्दिष्ट नहीं है, तो K-लाइन डेटाinRealपैरामीटर को साधारण सरणी माना जाता है।
{@fun/TA/TA.MACD TA.MACD}, {@fun/TA/TA.KDJ TA.KDJ}, {@fun/TA/TA.RSI TA.RSI}, {@fun/TA/TA.ATR TA.ATR}, {@fun/TA/TA.OBV TA.OBV}, {@fun/TA/TA.MA},TA.MA}, {@fun/TA/TA.EMA TA.EMA}, {@fun/TA/TA.BOLL TA.BOLL}, {@fun/TA/TA.Alligator TA.Alligator}, {@fun/TA/TA.CMF TA.CMF}, {@fun/TA/TA.Lowest TA.Lowest}, {@fun/TA/TA.Lowest TA.CMF}, {@fun/TA/TA.Lowest TA.Lowest}, {@fun/TA/TA.BOLL TA.BOLL}, {@fun/TA/TA.
..TA.Lowest()फलन का उपयोग गणना के लिए किया जाता हैअवधि की सबसे कम कीमत.
..TA.Lowest()फ़ंक्शन वर्तमान बार को छोड़कर अंतिम निश्चित अवधि में किसी विशेषता का न्यूनतम मान लौटाता है.
संख्या
TA.Lowerest ((inReal) टीए.सबसे कम ((वास्तविक, अवधि, एटीआर)
..inRealपैरामीटर का उपयोग के-लाइन डेटा को निर्दिष्ट करने के लिए किया जाता है।
वास्तविक
सच
{@struct/Record Record} संरचना सरणी, संख्यात्मक सरणी
दperiodपैरामीटर का उपयोग अवधि को सेट करने के लिए किया जाता है।
अवधि
झूठी
संख्या
दattrपैरामीटर का उपयोग गुणों को सेट करने के लिए किया जाता है, वैकल्पिक रूप सेःOpen, Close, Low, High, Volume, OpenInterest.
एटीआर
झूठी
स्ट्रिंग
function main() {
var records = exchange.GetRecords()
var lowestForOpen = TA.Lowest(records, 10, "Open")
Log(lowestForOpen)
}
def main():
records = exchange.GetRecords()
lowestForOpen = TA.Lowest(records, 10, "Open")
Log(lowestForOpen)
void main() {
auto records = exchange.GetRecords();
auto lowestForOpen = TA.Lowest(records.Open(), 10);
Log(lowestForOpen);
}
उदाहरण के लिए, यदिTA.Lowest(records, 30, "Low")समारोह कहा जाता है, यदि अवधि पैरामीटरperiodपर सेट है0, इसका मतलब है कि सभी गणना करने के लिएBarsके-लाइन डेटा के द्वारा पारितinRealपैरामीटर; यदि विशेषता पैरामीटरattrनिर्दिष्ट नहीं है, तो K-लाइन डेटाinRealपैरामीटर को साधारण सरणी माना जाता है।
के उपयोगTA.Highest()औरTA.Lowest()कार्य मेंC++रणनीति के लिए यह ध्यान दिया जाना चाहिए किHighest()औरLowest()प्रत्येक फ़ंक्शन में केवल 2 पैरामीटर होते हैं।
और पहले पैरामीटर में पारित नहीं है K-लाइन डेटाrप्राप्त किया जाता है जब समारोहauto r = exchange.GetRecords()बुलाया गया था।
आपको कॉल करने की जरूरत हैrविधि और विशिष्ट विशेषता डेटा में पास. उदाहरण के लिए, पास मेंr.Close()समापन मूल्य के आंकड़ेClose, High, Low, Open, Volumeजैसा किr.Close()कॉल विधि।
के परीक्षण का उदाहरणC++भाषा रणनीति:
void main() {
Records r;
r.Valid = true;
for (auto i = 0; i < 10; i++) {
Record ele;
ele.Time = i * 100000;
ele.High = i * 10000;
ele.Low = i * 1000;
ele.Close = i * 100;
ele.Open = i * 10;
ele.Volume = i * 1;
r.push_back(ele);
}
for(int j = 0; j < r.size(); j++){
Log(r[j]);
}
// Note: the first parameter passed is not r, you need to call r.Close()
auto highest = TA.Highest(r.Close(), 8);
Log(highest);
}
{@fun/TA/TA.MACD TA.MACD}, {@fun/TA/TA.KDJ TA.KDJ}, {@fun/TA/TA.RSI TA.RSI}, {@fun/TA/TA.ATR TA.ATR}, {@fun/TA/TA.OBV TA.OBV}, {@fun/TA/TA.MA},TA.MA}, {@fun/TA/TA.EMA TA.EMA}, {@fun/TA/TA.BOLL TA.BOLL}, {@fun/TA/TA.Alligator TA.Alligator}, {@fun/TA/TA.CMF TA.CMF}, {@fun/TA/TA.Highest TA.Highest}
..TA.SMA()फलन का उपयोग गणना के लिए किया जाता हैसरल चलती औसत सूचक.
रिटर्न मूल्यTA.SMA()कार्य हैः एक आयामी सरणी।
सरणी
TA.SMA ((inReal) TA.SMA ((inReal, optInTimePeriod)
..inRealपैरामीटर का उपयोग के-लाइन डेटा को निर्दिष्ट करने के लिए किया जाता है।
वास्तविक
सच
{@struct/Record Record} संरचना सरणी, संख्यात्मक सरणी
दoptInTimePeriodपैरामीटर का उपयोग अवधि को सेट करने के लिए किया जाता है।
optInTimeपीरियड
झूठी
संख्या
function main(){
var records = exchange.GetRecords(PERIOD_M30)
var sma = TA.SMA(records, 14)
Log(sma)
}
def main():
r = exchange.GetRecords(PERIOD_M30)
sma = TA.SMA(r, 14)
Log(sma)
void main() {
auto r = exchange.GetRecords(PERIOD_M30);
auto sma = TA.SMA(r, 14);
Log(sma);
}
डिफ़ॉल्ट मानoptInTimePeriodपैरामीटरTA.SMA()कार्य है:9.
{@fun/TA/TA.MACD TA.MACD}, {@fun/TA/TA.KDJ TA.KDJ}, {@fun/TA/TA.RSI TA.RSI}, {@fun/TA/TA.ATR TA.ATR}, {@fun/TA/TA.OBV TA.OBV}, {@fun/TA/TA.MA},TA.MA}, {@fun/TA/TA.EMA TA.EMA}, {@fun/TA/TA.BOLL TA.BOLL}, {@fun/TA/TA.Alligator TA.Alligator}, {@fun/TA/TA.CMF TA.CMF}, {@fun/TA/TA.Highest TA.Highest}, {@fun/TA/TA.Lowest TA.Lowest}
..talib.CDL2CROWS()फलन की गणना करने के लिए प्रयोग किया जाता हैदो कौवे (के-लाइन चार्ट - दो कौवे).
रिटर्न मूल्यtalib.CDL2CROWS()समारोह एक एक आयामी सरणी है।
सरणी
talib.CDL2CROWS ((inPriceOHLC)
..inPriceOHLCपैरामीटर का उपयोग के-लाइन डेटा को निर्दिष्ट करने के लिए किया जाता है।
inPriceOHLC
सच
{@struct/Record Record} संरचना सरणी
function main() {
var records = exchange.GetRecords()
var ret = talib.CDL2CROWS(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.CDL2CROWS(records.Open, records.High, records.Low, records.Close)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.CDL2CROWS(records);
Log(ret);
}
..CDL2CROWS()कार्य तालिब पुस्तकालय प्रलेखन में वर्णित हैःCDL2CROWS(Records[Open,High,Low,Close]) = Array(outInteger)के भीतर कॉल के लिएPythonभाषा, पासिंग मापदंडों अलग है और ऊपर के विवरण पर आधारित होने की जरूरत हैःRecords[Open,High,Low,Close].
चर को विभाजित करने का उदाहरणrecords(यानी पैरामीटरinPriceOHLC, प्रकार {@struct/Record Record} संरचनाओं की सरणी) मेंःOpenlist: पायथन में लिखा गया हैrecords.Open.
Highसूचीः लिखा जाता हैrecords.Highपायथन में।Lowlist: पायथन में लिखा गया हैrecords.Low.
Closelist: पायथन में लिखा गया हैrecords.Close.
पायथन रणनीति कोड में कहा जाता हैः
talib.CDL2CROWS(records.Open, records.High, records.Low, records.Close)
दूसराtalibसूचक एक ही तरीके से वर्णित हैं और वे दोहराए नहीं जाएंगे।
..talib.CDL3BLACKCROWS()फलन की गणना करने के लिए प्रयोग किया जाता हैतीन काले कौवे (के-लाइन चार्ट - तीन काले कौवे).
रिटर्न मूल्यtalib.CDL3BLACKCROWS()कार्य हैः एक आयामी सरणी।
सरणी
talib.CDL3BLACKCROWS ((inPriceOHLC)
..inPriceOHLCपैरामीटर का उपयोग के-लाइन डेटा को निर्दिष्ट करने के लिए किया जाता है।
inPriceOHLC
सच
{@struct/Record Record} संरचना सरणी
function main() {
var records = exchange.GetRecords()
var ret = talib.CDL3BLACKCROWS(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.CDL3BLACKCROWS(records.Open, records.High, records.Low, records.Close)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.CDL3BLACKCROWS(records);
Log(ret);
}
..CDL3BLACKCROWS()कार्य तालिब पुस्तकालय प्रलेखन में वर्णित हैःCDL3BLACKCROWS(Records[Open,High,Low,Close]) = Array(outInteger)
..talib.CDL3INSIDE()फलन की गणना करने के लिए प्रयोग किया जाता हैतीन अंदर ऊपर/नीचे (के-लाइन चार्टः तीन अंदर ऊपर/नीचे).
रिटर्न मूल्यtalib.CDL3INSIDE()कार्य हैः एक आयामी सरणी।
सरणी
talib.CDL3INSIDE ((inPriceOHLC)
..inPriceOHLCपैरामीटर का उपयोग के-लाइन डेटा को निर्दिष्ट करने के लिए किया जाता है।
inPriceOHLC
सच
{@struct/Record Record} संरचना सरणी
function main() {
var records = exchange.GetRecords()
var ret = talib.CDL3INSIDE(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.CDL3INSIDE(records.Open, records.High, records.Low, records.Close)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.CDL3INSIDE(records);
Log(ret);
}
..CDL3INSIDE()कार्य तालिब पुस्तकालय प्रलेखन में वर्णित हैःCDL3INSIDE(Records[Open,High,Low,Close]) = Array(outInteger)
..talib.CDL3LINESTRIKE()फलन का उपयोग गणना के लिए किया जाता हैतीन-लाइन स्ट्राइक (के-लाइन चार्टः तीन-लाइन स्ट्राइक).
रिटर्न मूल्यtalib.CDL3LINESTRIKE()कार्य हैः एक आयामी सरणी।
सरणी
talib.CDL3LINESTRIKE ((InPriceOHLC)
..inPriceOHLCपैरामीटर का उपयोग के-लाइन डेटा को निर्दिष्ट करने के लिए किया जाता है।
inPriceOHLC
सच
{@struct/Record Record} संरचना सरणी
function main() {
var records = exchange.GetRecords()
var ret = talib.CDL3LINESTRIKE(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.CDL3LINESTRIKE(records.Open, records.High, records.Low, records.Close)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.CDL3LINESTRIKE(records);
Log(ret);
}
..CDL3LINESTRIKE()कार्य तालिब पुस्तकालय प्रलेखन में वर्णित हैःCDL3LINESTRIKE(Records[Open,High,Low,Close]) = Array(outInteger)
..talib.CDL3OUTSIDE()फलन की गणना करने के लिए प्रयोग किया जाता हैतीन बाहर ऊपर/नीचे (के-लाइन चार्टः तीन बाहर ऊपर/नीचे).
रिटर्न मूल्यtalib.CDL3OUTSIDE()कार्य हैः एक आयामी सरणी।
सरणी
talib.CDL3OUTSIDE ((inPriceOHLC)
..inPriceOHLCपैरामीटर का उपयोग के-लाइन डेटा को निर्दिष्ट करने के लिए किया जाता है।
inPriceOHLC
सच
{@struct/Record Record} संरचना सरणी
function main() {
var records = exchange.GetRecords()
var ret = talib.CDL3OUTSIDE(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.CDL3OUTSIDE(records.Open, records.High, records.Low, records.Close)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.CDL3OUTSIDE(records);
Log(ret);
}
..CDL3OUTSIDE()कार्य तालिब पुस्तकालय प्रलेखन में वर्णित हैःCDL3OUTSIDE(Records[Open,High,Low,Close]) = Array(outInteger)
..talib.CDL3STARSINSOUTH()फलन की गणना करने के लिए प्रयोग किया जाता हैदक्षिण में तीन सितारे (के-लाइन चार्टः दक्षिण में तीन सितारे).
रिटर्न मूल्यtalib.CDL3STARSINSOUTH()कार्य हैः एक आयामी सरणी।
सरणी
talib.CDL3STARSINSOUTH ((InPriceOHLC)
..inPriceOHLCपैरामीटर का उपयोग के-लाइन डेटा को निर्दिष्ट करने के लिए किया जाता है।
inPriceOHLC
सच
{@struct/Record Record} संरचना सरणी
function main() {
var records = exchange.GetRecords()
var ret = talib.CDL3STARSINSOUTH(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.CDL3STARSINSOUTH(records.Open, records.High, records.Low, records.Close)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.CDL3STARSINSOUTH(records);
Log(ret);
}
..CDL3STARSINSOUTH()कार्य तालिब पुस्तकालय प्रलेखन में वर्णित हैःCDL3STARSINSOUTH(Records[Open,High,Low,Close]) = Array(outInteger)
..talib.CDL3WHITESOLDIERS()फलन की गणना करने के लिए प्रयोग किया जाता हैतीन अग्रिम श्वेत सैनिक (के-लाइन चार्ट: तीन अग्रिम श्वेत सैनिक).
रिटर्न मूल्यtalib.CDL3WHITESOLDIERS()कार्य हैः एक आयामी सरणी।
सरणी
talib.CDL3WHITESOLDIERS ((इनप्राइसOHLC)
..inPriceOHLCपैरामीटर का उपयोग के-लाइन डेटा को निर्दिष्ट करने के लिए किया जाता है।
inPriceOHLC
सच
{@struct/Record Record} संरचना सरणी
function main() {
var records = exchange.GetRecords()
var ret = talib.CDL3WHITESOLDIERS(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.CDL3WHITESOLDIERS(records.Open, records.High, records.Low, records.Close)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.CDL3WHITESOLDIERS(records);
Log(ret);
}
..CDL3WHITESOLDIERS()कार्य तालिब पुस्तकालय प्रलेखन में वर्णित हैःCDL3WHITESOLDIERS(Records[Open,High,Low,Close]) = Array(outInteger)
..talib.CDLABANDONEDBABY()फलन की गणना करने के लिए प्रयोग किया जाता हैपरित्यक्त शिशु (के-लाइन चार्ट: परित्यक्त शिशु).
रिटर्न मूल्यtalib.CDLABANDONEDBABY()कार्य हैः एक आयामी सरणी।
सरणी
talib.CDLABANDONEDBABY ((InPriceOHLC) talib.CDLABANDONEDBABY ((इनप्राइसओएचएलसी, ऑप्टइनपेनेट्रेशन)
..inPriceOHLCपैरामीटर का उपयोग के-लाइन डेटा को निर्दिष्ट करने के लिए किया जाता है।
inPriceOHLC
सच
{@struct/Record Record} संरचना सरणी
दoptInPenetrationपैरामीटर का उपयोग प्रवेश को सेट करने के लिए किया जाता है, डिफ़ॉल्ट मान 0.3 है।
optInPenetration
झूठी
संख्या
function main() {
var records = exchange.GetRecords()
var ret = talib.CDLABANDONEDBABY(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.CDLABANDONEDBABY(records.Open, records.High, records.Low, records.Close)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.CDLABANDONEDBABY(records);
Log(ret);
}
..CDLABANDONEDBABY()कार्य तालिब पुस्तकालय प्रलेखन में वर्णित हैःCDLABANDONEDBABY(Records[Open,High,Low,Close],Penetration = 0.3) = Array(outInteger)
..talib.CDLADVANCEBLOCK()फलन का उपयोग गणना के लिए किया जाता हैअग्रिम ब्लॉक (के-लाइन चार्टः अग्रिम).
रिटर्न मूल्यtalib.CDLADVANCEBLOCK()समारोह एक एक आयामी सरणी है।
सरणी
talib.CDLADVANCEBLOCK ((InPriceOHLC)
..inPriceOHLCपैरामीटर का उपयोग के-लाइन डेटा को निर्दिष्ट करने के लिए किया जाता है।
inPriceOHLC
सच
{@struct/Record Record} संरचना सरणी
function main() {
var records = exchange.GetRecords()
var ret = talib.CDLADVANCEBLOCK(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.CDLADVANCEBLOCK(records.Open, records.High, records.Low, records.Close)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.CDLADVANCEBLOCK(records);
Log(ret);
}
..CDLADVANCEBLOCK()कार्य तालिब पुस्तकालय प्रलेखन में वर्णित हैःCDLADVANCEBLOCK(Records[Open,High,Low,Close]) = Array(outInteger)
..talib.CDLBELTHOLD()फलन का उपयोग गणना के लिए किया जाता हैबेल्ट पकड़ (के-लाइन चार्टः बेल्ट पकड़).
रिटर्न मूल्यtalib.CDLBELTHOLD()कार्य हैः एक आयामी सरणी।
सरणी
talib.CDLBELTHOLD ((inPriceOHLC)
..inPriceOHLCपैरामीटर का उपयोग के-लाइन डेटा को निर्दिष्ट करने के लिए किया जाता है।
inPriceOHLC
सच
{@struct/Record Record} संरचना सरणी
function main() {
var records = exchange.GetRecords()
var ret = talib.CDLBELTHOLD(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.CDLBELTHOLD(records.Open, records.High, records.Low, records.Close)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.CDLBELTHOLD(records);
Log(ret);
}
..CDLBELTHOLD()कार्य तालिब पुस्तकालय प्रलेखन में वर्णित हैःCDLBELTHOLD(Records[Open,High,Low,Close]) = Array(outInteger)
..talib.CDLBREAKAWAY()फलन का उपयोग गणना के लिए किया जाता हैब्रेकआउट (के-लाइन चार्टः ब्रेकआउट).
रिटर्न मूल्यtalib.CDLBREAKAWAY()कार्य हैः एक आयामी सरणी।
सरणी
talib.CDLBBREAKWAY ((इनप्राइसOHLC)
..inPriceOHLCपैरामीटर का उपयोग के-लाइन डेटा को निर्दिष्ट करने के लिए किया जाता है।
inPriceOHLC
सच
{@struct/Record Record} संरचना सरणी
function main() {
var records = exchange.GetRecords()
var ret = talib.CDLBREAKAWAY(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.CDLBREAKAWAY(records.Open, records.High, records.Low, records.Close)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.CDLBREAKAWAY(records);
Log(ret);
}
CDLBREAKAWAY()कार्य तालिब पुस्तकालय प्रलेखन में वर्णित हैःCDLBREAKAWAY(Records[Open,High,Low,Close]) = Array(outInteger)
..talib.CDLCLOSINGMARUBOZU()फलन की गणना करने के लिए प्रयोग किया जाता हैमारुबोज़ु का समापन (के-लाइन चार्टः नंगे सिर और नंगे पैरों का समापन).
रिटर्न मूल्यtalib.CDLCLOSINGMARUBOZU()कार्य हैः एक आयामी सरणी।
सरणी
talib.CDLCLOSINGMARUBOZU ((InPriceOHLC)
..inPriceOHLCपैरामीटर का उपयोग के-लाइन डेटा को निर्दिष्ट करने के लिए किया जाता है।
inPriceOHLC
सच
{@struct/Record Record} संरचना सरणी
function main() {
var records = exchange.GetRecords()
var ret = talib.CDLCLOSINGMARUBOZU(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.CDLCLOSINGMARUBOZU(records.Open, records.High, records.Low, records.Close)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.CDLCLOSINGMARUBOZU(records);
Log(ret);
}
..CDLCLOSINGMARUBOZU()कार्य तालिब पुस्तकालय प्रलेखन में वर्णित हैःCDLCLOSINGMARUBOZU(Records[Open,High,Low,Close]) = Array(outInteger)
..talib.CDLCONCEALBABYSWALL()फलन का उपयोग गणना के लिए किया जाता हैबेबी स्वॉलो छिपाना (के-लाइन चार्टः बेबी स्वॉलो पैटर्न छिपाना).
रिटर्न मूल्यtalib.CDLCONCEALBABYSWALL()कार्य हैः एक आयामी सरणी।
सरणी
talib.CDLCONCEALBABYSWALL ((इनप्राइसOHLC)
..inPriceOHLCपैरामीटर का उपयोग के-लाइन डेटा को निर्दिष्ट करने के लिए किया जाता है।
inPriceOHLC
सच
{@struct/Record Record} संरचना सरणी
function main() {
var records = exchange.GetRecords()
var ret = talib.CDLCONCEALBABYSWALL(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.CDLCONCEALBABYSWALL(records.Open, records.High, records.Low, records.Close)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.CDLCONCEALBABYSWALL(records);
Log(ret);
}
..CDLCONCEALBABYSWALL()कार्य तालिब पुस्तकालय प्रलेखन में वर्णित हैःCDLCONCEALBABYSWALL(Records[Open,High,Low,Close]) = Array(outInteger)
..talib.CDLCOUNTERATTACK()फलन की गणना करने के लिए प्रयोग किया जाता हैप्रति-आक्रमण (के-लाइन चार्टः प्रति-आक्रमण).
रिटर्न मूल्यtalib.CDLCOUNTERATTACK()समारोह एक एक आयामी सरणी है।
सरणी
तालिब.सी.डी.एल.काउंटर अटैक ((इनप्राइसओएचएलसी)
..inPriceOHLCपैरामीटर का उपयोग के-लाइन डेटा को निर्दिष्ट करने के लिए किया जाता है।
inPriceOHLC
सच
{@struct/Record Record} संरचना सरणी
function main() {
var records = exchange.GetRecords()
var ret = talib.CDLCOUNTERATTACK(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.CDLCOUNTERATTACK(records.Open, records.High, records.Low, records.Close)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.CDLCOUNTERATTACK(records);
Log(ret);
}
..CDLCOUNTERATTACK()कार्य तालिब पुस्तकालय प्रलेखन में वर्णित हैःCDLCOUNTERATTACK(Records[Open,High,Low,Close]) = Array(outInteger)
..talib.CDLDARKCLOUDCOVER()फलन की गणना करने के लिए प्रयोग किया जाता हैअंधेरे बादल आवरण (के-लाइन चार्टः अंधेरे बादल आवरण).
रिटर्न मूल्यtalib.CDLDARKCLOUDCOVER()समारोह एक एक आयामी सरणी है।
सरणी
talib.CDLDARKCLOUDCOVER ((InPriceOHLC) talib.CDLDARKCLOUDCOVER ((InPriceOHLC, optInPenetration)
..inPriceOHLCपैरामीटर का उपयोग के-लाइन डेटा को निर्दिष्ट करने के लिए किया जाता है।
inPriceOHLC
सच
{@struct/Record Record} संरचना सरणी
दoptInPenetrationपैरामीटर प्रवेश सेट करने के लिए प्रयोग किया जाता है, डिफ़ॉल्ट मान 0.5 है।
optInPenetration
झूठी
संख्या
function main() {
var records = exchange.GetRecords()
var ret = talib.CDLDARKCLOUDCOVER(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.CDLDARKCLOUDCOVER(records.Open, records.High, records.Low, records.Close)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.CDLDARKCLOUDCOVER(records);
Log(ret);
}
..CDLDARKCLOUDCOVER()कार्य तालिब पुस्तकालय प्रलेखन में वर्णित हैःCDLDARKCLOUDCOVER(Records[Open,High,Low,Close],Penetration = 0.5) = Array(outInteger)
..talib.CDLDOJI()फलन की गणना करने के लिए प्रयोग किया जाता हैडोजी (के-लाइन चार्टः डोजी).
रिटर्न मूल्यtalib.CDLDOJI()कार्य हैः एक आयामी सरणी।
सरणी
talib.CDLDOJI ((InPriceOHLC)
..inPriceOHLCपैरामीटर का उपयोग के-लाइन डेटा को निर्दिष्ट करने के लिए किया जाता है।
inPriceOHLC
सच
{@struct/Record Record} संरचना सरणी
function main() {
var records = exchange.GetRecords()
var ret = talib.CDLDOJI(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.CDLDOJI(records.Open, records.High, records.Low, records.Close)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.CDLDOJI(records);
Log(ret);
}
..CDLDOJI()कार्य तालिब पुस्तकालय प्रलेखन में वर्णित हैःCDLDOJI(Records[Open,High,Low,Close]) = Array(outInteger)
..talib.CDLDOJISTAR()फलन का उपयोग गणना के लिए किया जाता हैडोजी स्टार (के-लाइन चार्टः डोजी स्टार).
रिटर्न मूल्यtalib.CDLDOJISTAR()कार्य हैः एक आयामी सरणी।
सरणी
talib.CDLDOJISTAR ((InPriceOHLC)
..inPriceOHLCपैरामीटर का उपयोग के-लाइन डेटा को निर्दिष्ट करने के लिए किया जाता है।
inPriceOHLC
सच
{@struct/Record Record} संरचना सरणी
function main() {
var records = exchange.GetRecords()
var ret = talib.CDLDOJISTAR(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.CDLDOJISTAR(records.Open, records.High, records.Low, records.Close)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.CDLDOJISTAR(records);
Log(ret);
}
..CDLDOJISTAR()कार्य तालिब पुस्तकालय प्रलेखन में वर्णित हैःCDLDOJISTAR(Records[Open,High,Low,Close]) = Array(outInteger)
..talib.CDLDRAGONFLYDOJI()फलन की गणना करने के लिए प्रयोग किया जाता हैड्रैगनफ्लाई डोजी (के-लाइन चार्टः ड्रैगनफ्लाई डोजी).
रिटर्न मूल्यtalib.CDLDRAGONFLYDOJI()कार्य हैः एक आयामी सरणी।
सरणी
talib.CDLDRAGONFLYDOJI ((इनप्राइसओएचएलसी)
..inPriceOHLCपैरामीटर का उपयोग के-लाइन डेटा को निर्दिष्ट करने के लिए किया जाता है।
inPriceOHLC
सच
{@struct/Record Record} संरचना सरणी
function main() {
var records = exchange.GetRecords()
var ret = talib.CDLDRAGONFLYDOJI(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.CDLDRAGONFLYDOJI(records.Open, records.High, records.Low, records.Close)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.CDLDRAGONFLYDOJI(records);
Log(ret);
}
..CDLDRAGONFLYDOJI()कार्य तालिब पुस्तकालय प्रलेखन में वर्णित हैःCDLDRAGONFLYDOJI(Records[Open,High,Low,Close]) = Array(outInteger)
..talib.CDLENGULFING()फलन का उपयोग गणना के लिए किया जाता हैनिगलने का पैटर्न (के-लाइन चार्टः निगलना).
रिटर्न मूल्यtalib.CDLENGULFING()समारोह एक एक आयामी सरणी है।
सरणी
talib.CDLENGULFING ((InPriceOHLC)
..inPriceOHLCपैरामीटर का उपयोग के-लाइन डेटा को निर्दिष्ट करने के लिए किया जाता है।
inPriceOHLC
सच
{@struct/Record Record} संरचना सरणी
function main() {
var records = exchange.GetRecords()
var ret = talib.CDLENGULFING(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.CDLENGULFING(records.Open, records.High, records.Low, records.Close)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.CDLENGULFING(records);
Log(ret);
}
..CDLENGULFING()कार्य तालिब पुस्तकालय प्रलेखन में वर्णित हैःCDLENGULFING(Records[Open,High,Low,Close]) = Array(outInteger)
..talib.CDLEVENINGDOJISTAR()फलन का उपयोग गणना के लिए किया जाता हैसंध्या दोजी तारा (के-लाइन चार्टः संध्या दोजी तारा).
रिटर्न मूल्यtalib.CDLEVENINGDOJISTAR()कार्य हैः एक आयामी सरणी।
सरणी
talib.CDLEVENINGDOJISTAR ((इनप्राइसओएचएलसी) talib.CDLEVENINGDOJISTAR ((इनप्राइसओएचएलसी, ऑप्टइनपेनेट्रेशन)
..inPriceOHLCपैरामीटर का उपयोग के-लाइन डेटा को निर्दिष्ट करने के लिए किया जाता है।
inPriceOHLC
सच
{@struct/Record Record} संरचना सरणी
दoptInPenetrationपैरामीटर का उपयोग प्रवेश को सेट करने के लिए किया जाता है, डिफ़ॉल्ट मान 0.3 है।
optInPenetration
झूठी
संख्या
function main() {
var records = exchange.GetRecords()
var ret = talib.CDLEVENINGDOJISTAR(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.CDLEVENINGDOJISTAR(records.Open, records.High, records.Low, records.Close)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.CDLEVENINGDOJISTAR(records);
Log(ret);
}
..CDLEVENINGDOJISTAR()कार्य तालिब पुस्तकालय प्रलेखन में वर्णित हैःCDLEVENINGDOJISTAR(Records[Open,High,Low,Close],Penetration = 0.3) = Array(outInteger)
..talib.CDLEVENINGSTAR()फलन का उपयोग गणना के लिए किया जाता हैशाम का तारा (के-लाइन चार्टः शाम का तारा).
रिटर्न मूल्यtalib.CDLEVENINGSTAR()कार्य हैः एक आयामी सरणी।
सरणी
talib.CDLEVENINGSTAR ((इनप्राइसओएचएलसी) talib.CDLEVENINGSTAR ((इनप्राइसओएचएलसी, ऑप्टइनपेनेट्रेशन)
..inPriceOHLCपैरामीटर का उपयोग के-लाइन डेटा को निर्दिष्ट करने के लिए किया जाता है।
inPriceOHLC
सच
{@struct/Record Record} संरचना सरणी
दoptInPenetrationपैरामीटर का उपयोग प्रवेश को सेट करने के लिए किया जाता है, डिफ़ॉल्ट मान 0.3 है।
optInPenetration
झूठी
संख्या
function main() {
var records = exchange.GetRecords()
var ret = talib.CDLEVENINGSTAR(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.CDLEVENINGSTAR(records.Open, records.High, records.Low, records.Close)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.CDLEVENINGSTAR(records);
Log(ret);
}
..CDLEVENINGSTAR()कार्य तालिब पुस्तकालय प्रलेखन में वर्णित हैःCDLEVENINGSTAR(Records[Open,High,Low,Close],Penetration = 0.3) = Array(outInteger)
..talib.CDLGAPSIDESIDEWHITE()फलन की गणना करने के लिए प्रयोग किया जाता हैऊपर/नीचे के बीच का अंतर साइड-बाय-साइड सफेद रेखाएं (के-लाइन चार्टः ऊपर/नीचे के बीच का अंतर साइड-बाय-साइड सफेद रेखाएं).
रिटर्न मूल्यtalib.CDLGAPSIDESIDEWHITE()कार्य हैः एक आयामी सरणी।
सरणी
talib.CDLGAPSIDESIDEWHITE ((इनप्राइसOHLC)
..inPriceOHLCपैरामीटर का उपयोग के-लाइन डेटा को निर्दिष्ट करने के लिए किया जाता है।
inPriceOHLC
सच
{@struct/Record Record} संरचना सरणी
function main() {
var records = exchange.GetRecords()
var ret = talib.CDLGAPSIDESIDEWHITE(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.CDLGAPSIDESIDEWHITE(records.Open, records.High, records.Low, records.Close)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.CDLGAPSIDESIDEWHITE(records);
Log(ret);
}
..CDLGAPSIDESIDEWHITE()कार्य तालिब पुस्तकालय प्रलेखन में वर्णित हैःCDLGAPSIDESIDEWHITE(Records[Open,High,Low,Close]) = Array(outInteger)
..talib.CDLGRAVESTONEDOJI()फलन का उपयोग गणना के लिए किया जाता हैग्रेवस्टोन डोजी (के-लाइन चार्टः ग्रेवस्टोन डोजी).
रिटर्न मूल्यtalib.CDLGRAVESTONEDOJI()कार्य हैः एक आयामी सरणी।
सरणी
talib.CDLGRAVESTONEDOJI ((InPriceOHLC)
..inPriceOHLCपैरामीटर का उपयोग के-लाइन डेटा को निर्दिष्ट करने के लिए किया जाता है।
inPriceOHLC
सच
{@struct/Record Record} संरचना सरणी
function main() {
var records = exchange.GetRecords()
var ret = talib.CDLGRAVESTONEDOJI(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.CDLGRAVESTONEDOJI(records.Open, records.High, records.Low, records.Close)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.CDLGRAVESTONEDOJI(records);
Log(ret);
}
..CDLGRAVESTONEDOJI()कार्य तालिब पुस्तकालय प्रलेखन में वर्णित हैःCDLGRAVESTONEDOJI(Records[Open,High,Low,Close]) = Array(outInteger)
..talib.CDLHAMMER()फलन की गणना करने के लिए प्रयोग किया जाता हैहथौड़ा (के-लाइन चार्टः हथौड़ा).
रिटर्न मूल्यtalib.CDLHAMMER()कार्य हैः एक आयामी सरणी।
सरणी
talib.CDLHAMMER ((inPriceOHLC)
..inPriceOHLCपैरामीटर का उपयोग के-लाइन डेटा को निर्दिष्ट करने के लिए किया जाता है।
inPriceOHLC
सच
{@struct/Record Record} संरचना सरणी
function main() {
var records = exchange.GetRecords()
var ret = talib.CDLHAMMER(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.CDLHAMMER(records.Open, records.High, records.Low, records.Close)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.CDLHAMMER(records);
Log(ret);
}
..CDLHAMMER()कार्य तालिब पुस्तकालय प्रलेखन में वर्णित हैःCDLHAMMER(Records[Open,High,Low,Close]) = Array(outInteger)
..talib.CDLHANGINGMAN()फलन की गणना करने के लिए प्रयोग किया जाता हैहैंगिंग मैन (के-लाइन चार्टः हैंगिंग मैन).
रिटर्न मूल्यtalib.CDLHANGINGMAN()समारोह एक एक आयामी सरणी है।
सरणी
talib.CDLHANGINGMAN ((InPriceOHLC)
..inPriceOHLCपैरामीटर का उपयोग के-लाइन डेटा को निर्दिष्ट करने के लिए किया जाता है।
inPriceOHLC
सच
{@struct/Record Record} संरचना सरणी
function main() {
var records = exchange.GetRecords()
var ret = talib.CDLHANGINGMAN(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.CDLHANGINGMAN(records.Open, records.High, records.Low, records.Close)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.CDLHANGINGMAN(records);
Log(ret);
}
..CDLHANGINGMAN()कार्य तालिब पुस्तकालय प्रलेखन में वर्णित हैःCDLHANGINGMAN(Records[Open,High,Low,Close]) = Array(outInteger)
..talib.CDLHARAMI()फलन का उपयोग गणना के लिए किया जाता हैहरमी पैटर्न (के-लाइन चार्टः नकारात्मक और सकारात्मक रेखाएं).
रिटर्न मूल्यtalib.CDLHARAMI()समारोह एक एक आयामी सरणी है।
सरणी
talib.CDLHARAMI ((InPriceOHLC)
..inPriceOHLCपैरामीटर का उपयोग के-लाइन डेटा को निर्दिष्ट करने के लिए किया जाता है।
inPriceOHLC
सच
{@struct/Record Record} संरचना सरणी
function main() {
var records = exchange.GetRecords()
var ret = talib.CDLHARAMI(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.CDLHARAMI(records.Open, records.High, records.Low, records.Close)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.CDLHARAMI(records);
Log(ret);
}
..CDLHARAMI()कार्य तालिब पुस्तकालय प्रलेखन में वर्णित हैःCDLHARAMI(Records[Open,High,Low,Close]) = Array(outInteger)
..talib.CDLHARAMICROSS()फलन का उपयोग गणना के लिए किया जाता हैहरमी क्रॉस पैटर्न (के-लाइन चार्टः क्रॉस नकारात्मक और सकारात्मक रेखाएं).
रिटर्न मूल्यtalib.CDLHARAMICROSS()कार्य हैः एक आयामी सरणी।
सरणी
talib.CDLHARAMICROSS ((inPriceOHLC)
..inPriceOHLCपैरामीटर का उपयोग के-लाइन डेटा को निर्दिष्ट करने के लिए किया जाता है।
inPriceOHLC
सच
{@struct/Record Record} संरचना सरणी
function main() {
var records = exchange.GetRecords()
var ret = talib.CDLHARAMICROSS(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.CDLHARAMICROSS(records.Open, records.High, records.Low, records.Close)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.CDLHARAMICROSS(records);
Log(ret);
}
..CDLHARAMICROSS()कार्य तालिब पुस्तकालय प्रलेखन में वर्णित हैःCDLHARAMICROSS(Records[Open,High,Low,Close]) = Array(outInteger)
..talib.CDLHIGHWAVE()फलन का उपयोग गणना के लिए किया जाता हैहाई-वेव कैंडल (के-लाइन चार्टः लॉन्ग लेग क्रॉस).
रिटर्न मूल्यtalib.CDLHIGHWAVE()समारोह एक एक आयामी सरणी है।
सरणी
talib.CDLHIGHWAVE ((InPriceOHLC)
..inPriceOHLCपैरामीटर का उपयोग के-लाइन डेटा को निर्दिष्ट करने के लिए किया जाता है।
inPriceOHLC
सच
{@struct/Record Record} संरचना सरणी
function main() {
var records = exchange.GetRecords()
var ret = talib.CDLHIGHWAVE(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.CDLHIGHWAVE(records.Open, records.High, records.Low, records.Close)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.CDLHIGHWAVE(records);
Log(ret);
}
..CDLHIGHWAVE()कार्य तालिब पुस्तकालय प्रलेखन में वर्णित हैःCDLHIGHWAVE(Records[Open,High,Low,Close]) = Array(outInteger)
..talib.CDLHIKKAKE()फलन का उपयोग गणना के लिए किया जाता हैहिक्काके पैटर्न (के-लाइन चार्टः जाल).
रिटर्न मूल्यtalib.CDLHIKKAKE()समारोह एक एक आयामी सरणी है।
सरणी
talib.CDLHIKKAKE ((InPriceOHLC)
..inPriceOHLCपैरामीटर का उपयोग के-लाइन डेटा को निर्दिष्ट करने के लिए किया जाता है।
inPriceOHLC
सच
{@struct/Record Record} संरचना सरणी
function main() {
var records = exchange.GetRecords()
var ret = talib.CDLHIKKAKE(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.CDLHIKKAKE(records.Open, records.High, records.Low, records.Close)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.CDLHIKKAKE(records);
Log(ret);
}
..CDLHIKKAKE()कार्य तालिब पुस्तकालय प्रलेखन में वर्णित हैःCDLHIKKAKE(Records[Open,High,Low,Close]) = Array(outInteger)
..talib.CDLHIKKAKEMOD()फलन का उपयोग गणना के लिए किया जाता हैसंशोधित हिकके पैटर्न (के-लाइन चार्टः संशोधित जाल).
रिटर्न मूल्यtalib.CDLHIKKAKEMOD()कार्य हैः एक आयामी सरणी।
सरणी
talib.CDLHIKKAKEMOD ((InPriceOHLC)
..inPriceOHLCपैरामीटर का उपयोग के-लाइन डेटा को निर्दिष्ट करने के लिए किया जाता है।
inPriceOHLC
सच
{@struct/Record Record} संरचना सरणी
function main() {
var records = exchange.GetRecords()
var ret = talib.CDLHIKKAKEMOD(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.CDLHIKKAKEMOD(records.Open, records.High, records.Low, records.Close)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.CDLHIKKAKEMOD(records);
Log(ret);
}
..CDLHIKKAKEMOD()कार्य तालिब पुस्तकालय प्रलेखन में वर्णित हैःCDLHIKKAKEMOD(Records[Open,High,Low,Close]) = Array(outInteger)
..talib.CDLHOMINGPIGEON()फलन का उपयोग गणना के लिए किया जाता हैहोमिंग ड्यूम (के-लाइन चार्टः ड्यूम).
रिटर्न मूल्यtalib.CDLHOMINGPIGEON()कार्य हैः एक आयामी सरणी।
सरणी
talib.CDLHOMINGPIGEON ((InPriceOHLC)
..inPriceOHLCपैरामीटर का उपयोग के-लाइन डेटा को निर्दिष्ट करने के लिए किया जाता है।
inPriceOHLC
सच
{@struct/Record Record} संरचना सरणी
function main() {
var records = exchange.GetRecords()
var ret = talib.CDLHOMINGPIGEON(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.CDLHOMINGPIGEON(records.Open, records.High, records.Low, records.Close)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.CDLHOMINGPIGEON(records);
Log(ret);
}
..CDLHOMINGPIGEON()कार्य तालिब पुस्तकालय प्रलेखन में वर्णित हैःCDLHOMINGPIGEON(Records[Open,High,Low,Close]) = Array(outInteger)
..talib.CDLIDENTICAL3CROWS()फलन की गणना करने के लिए प्रयोग किया जाता हैसमान तीन कौवे (के-लाइन चार्टः समान तीन कौवे).
रिटर्न मूल्यtalib.CDLIDENTICAL3CROWS()कार्य हैः एक आयामी सरणी।
सरणी
talib.CDLIDENTICAL3CROWS ((InPriceOHLC)
..inPriceOHLCपैरामीटर का उपयोग के-लाइन डेटा को निर्दिष्ट करने के लिए किया जाता है।
inPriceOHLC
सच
{@struct/Record Record} संरचना सरणी
function main() {
var records = exchange.GetRecords()
var ret = talib.CDLIDENTICAL3CROWS(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.CDLIDENTICAL3CROWS(records.Open, records.High, records.Low, records.Close)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.CDLIDENTICAL3CROWS(records);
Log(ret);
}
..CDLIDENTICAL3CROWS()कार्य तालिब पुस्तकालय प्रलेखन में वर्णित हैःCDLIDENTICAL3CROWS(Records[Open,High,Low,Close]) = Array(outInteger)
..talib.CDLINNECK()फलन का उपयोग गणना के लिए किया जाता हैगर्दन में पैटर्न (के-लाइन चार्टः गर्दन की रेखा).
रिटर्न मूल्यtalib.CDLINNECK()कार्य हैः एक आयामी सरणी।
सरणी
talib.CDLINNECK ((inPriceOHLC)
..inPriceOHLCपैरामीटर का उपयोग के-लाइन डेटा को निर्दिष्ट करने के लिए किया जाता है।
inPriceOHLC
सच
{@struct/Record Record} संरचना सरणी
function main() {
var records = exchange.GetRecords()
var ret = talib.CDLINNECK(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.CDLINNECK(records.Open, records.High, records.Low, records.Close)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.CDLINNECK(records);
Log(ret);
}
..CDLINNECK()कार्य तालिब पुस्तकालय प्रलेखन में वर्णित हैःCDLINNECK(Records[Open,High,Low,Close]) = Array(outInteger)
..talib.CDLINVERTEDHAMMER()फलन का उपयोग गणना के लिए किया जाता हैउलटा हथौड़ा (के-लाइन चार्टः उलटा हथौड़ा).
रिटर्न मूल्यtalib.CDLINVERTEDHAMMER()कार्य हैः एक आयामी सरणी।
सरणी
talib.CDLINVERTEDHAMMER ((इनप्राइसOHLC)
..inPriceOHLCपैरामीटर का उपयोग के-लाइन डेटा को निर्दिष्ट करने के लिए किया जाता है।
inPriceOHLC
सच
{@struct/Record Record} संरचना सरणी
function main() {
var records = exchange.GetRecords()
var ret = talib.CDLINVERTEDHAMMER(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.CDLINVERTEDHAMMER(records.Open, records.High, records.Low, records.Close)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.CDLINVERTEDHAMMER(records);
Log(ret);
}
..CDLINVERTEDHAMMER()कार्य तालिब पुस्तकालय प्रलेखन में वर्णित हैःCDLINVERTEDHAMMER(Records[Open,High,Low,Close]) = Array(outInteger)
..talib.CDLKICKING()फलन की गणना करने के लिए प्रयोग किया जाता हैकिकिंग (के-लाइन चार्टः किकिंग).
रिटर्न मूल्यtalib.CDLKICKING()समारोह एक एक आयामी सरणी है।
सरणी
talib.CDLKICKING ((InPriceOHLC)
..inPriceOHLCपैरामीटर का उपयोग के-लाइन डेटा को निर्दिष्ट करने के लिए किया जाता है।
inPriceOHLC
सच
{@struct/Record Record} संरचना सरणी
function main() {
var records = exchange.GetRecords()
var ret = talib.CDLKICKING(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.CDLKICKING(records.Open, records.High, records.Low, records.Close)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.CDLKICKING(records);
Log(ret);
}
..CDLKICKING()कार्य तालिब पुस्तकालय प्रलेखन में वर्णित हैःCDLKICKING(Records[Open,High,Low,Close]) = Array(outInteger)
..talib.CDLKICKINGBYLENGTH()फलन का उपयोग गणना के लिए किया जाता हैकिक-बुल/बीर, जो कि लंबे मरुबोज़ू द्वारा निर्धारित किया गया है (के-लाइन चार्टः किक-बुल/किक-बीर).
रिटर्न मूल्यtalib.CDLKICKINGBYLENGTH()कार्य हैः एक आयामी सरणी।
सरणी
talib.CDLKICKINGBYLENGTH ((InPriceOHLC)
..inPriceOHLCपैरामीटर का उपयोग के-लाइन डेटा को निर्दिष्ट करने के लिए किया जाता है।
inPriceOHLC
सच
{@struct/Record Record} संरचना सरणी
function main() {
var records = exchange.GetRecords()
var ret = talib.CDLKICKINGBYLENGTH(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.CDLKICKINGBYLENGTH(records.Open, records.High, records.Low, records.Close)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.CDLKICKINGBYLENGTH(records);
Log(ret);
}
..CDLKICKINGBYLENGTH()कार्य तालिब पुस्तकालय प्रलेखन में वर्णित हैःCDLKICKINGBYLENGTH(Records[Open,High,Low,Close]) = Array(outInteger)
..talib.CDLLADDERBOTTOM()फलन का उपयोग गणना के लिए किया जाता हैसीढ़ी के नीचे (के-लाइन चार्टः सीढ़ी के नीचे).
रिटर्न मूल्यtalib.CDLLADDERBOTTOM()कार्य हैः एक आयामी सरणी।
सरणी
talib.CDLLADDERBOTTOM ((InPriceOHLC)
..inPriceOHLCपैरामीटर का उपयोग के-लाइन डेटा को निर्दिष्ट करने के लिए किया जाता है।
inPriceOHLC
सच
{@struct/Record Record} संरचना सरणी
function main() {
var records = exchange.GetRecords()
var ret = talib.CDLLADDERBOTTOM(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.CDLLADDERBOTTOM(records.Open, records.High, records.Low, records.Close)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.CDLLADDERBOTTOM(records);
Log(ret);
}
..CDLLADDERBOTTOM()कार्य तालिब पुस्तकालय प्रलेखन में वर्णित हैःCDLLADDERBOTTOM(Records[Open,High,Low,Close]) = Array(outInteger)
..talib.CDLLONGLEGGEDDOJI()फलन का उपयोग गणना के लिए किया जाता हैलम्बे पैर वाला डोजी (के-लाइन चार्टः लम्बे पैर वाला डोजी).
रिटर्न मूल्यtalib.CDLLONGLEGGEDDOJI()कार्य हैः एक आयामी सरणी।
सरणी
talib.CDLLONGLEGGEDDOJI ((InPriceOHLC)
..inPriceOHLCपैरामीटर का उपयोग के-लाइन डेटा को निर्दिष्ट करने के लिए किया जाता है।
inPriceOHLC
सच
{@struct/Record Record} संरचना सरणी
function main() {
var records = exchange.GetRecords()
var ret = talib.CDLLONGLEGGEDDOJI(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.CDLLONGLEGGEDDOJI(records.Open, records.High, records.Low, records.Close)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.CDLLONGLEGGEDDOJI(records);
Log(ret);
}
..CDLLONGLEGGEDDOJI()कार्य तालिब पुस्तकालय प्रलेखन में वर्णित हैःCDLLONGLEGGEDDOJI(Records[Open,High,Low,Close]) = Array(outInteger)
..talib.CDLLONGLINE()फलन का उपयोग गणना के लिए किया जाता हैलंबी रेखा मोमबत्ती (के-लाइन चार्टः लंबी रेखा).
रिटर्न मूल्यtalib.CDLLONGLINE()कार्य हैः एक आयामी सरणी।
सरणी
talib.CDLLONGLINE ((InPriceOHLC)
..inPriceOHLCपैरामीटर का उपयोग के-लाइन डेटा को निर्दिष्ट करने के लिए किया जाता है।
inPriceOHLC
सच
{@struct/Record Record} संरचना सरणी
function main() {
var records = exchange.GetRecords()
var ret = talib.CDLLONGLINE(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.CDLLONGLINE(records.Open, records.High, records.Low, records.Close)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.CDLLONGLINE(records);
Log(ret);
}
..CDLLONGLINE()कार्य तालिब पुस्तकालय प्रलेखन में वर्णित हैःCDLLONGLINE(Records[Open,High,Low,Close]) = Array(outInteger)
..talib.CDLMARUBOZU()फलन का उपयोग गणना के लिए किया जाता हैमारुबोज़ु (के-लाइन चार्टः नंगे सिर और नंगे पैर).
रिटर्न मूल्यtalib.CDLMARUBOZU()समारोह एक एक आयामी सरणी है।
सरणी
talib.CDLMARUBOZU ((InPriceOHLC)
..inPriceOHLCपैरामीटर का उपयोग के-लाइन डेटा को निर्दिष्ट करने के लिए किया जाता है।
inPriceOHLC
सच
{@struct/Record Record} संरचना सरणी
function main() {
var records = exchange.GetRecords()
var ret = talib.CDLMARUBOZU(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.CDLMARUBOZU(records.Open, records.High, records.Low, records.Close)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.CDLMARUBOZU(records);
Log(ret);
}
..CDLMARUBOZU()कार्य तालिब पुस्तकालय प्रलेखन में वर्णित हैःCDLMARUBOZU(Records[Open,High,Low,Close]) = Array(outInteger)
..talib.CDLMATCHINGLOW()फलन की गणना करने के लिए प्रयोग किया जाता हैमिलान कम (के-लाइन चार्टः मिलान कम).
रिटर्न मूल्यtalib.CDLMATCHINGLOW()कार्य हैः एक आयामी सरणी।
सरणी
talib.CDLMMATCHINGLOW ((InPriceOHLC)
..inPriceOHLCपैरामीटर का उपयोग के-लाइन डेटा को निर्दिष्ट करने के लिए किया जाता है।
inPriceOHLC
सच
{@struct/Record Record} संरचना सरणी
function main() {
var records = exchange.GetRecords()
var ret = talib.CDLMATCHINGLOW(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.CDLMATCHINGLOW(records.Open, records.High, records.Low, records.Close)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.CDLMATCHINGLOW(records);
Log(ret);
}
..CDLMATCHINGLOW()कार्य तालिब पुस्तकालय प्रलेखन में वर्णित हैःCDLMATCHINGLOW(Records[Open,High,Low,Close]) = Array(outInteger)
..talib.CDLMATHOLD()फलन की गणना करने के लिए प्रयोग किया जाता हैमैट होल्ड (के-लाइन चार्टः मैट होल्ड).
रिटर्न मूल्यtalib.CDLMATHOLD()कार्य हैः एक आयामी सरणी।
सरणी
talib.CDLMATHOLD ((inPriceOHLC) talib.CDLMATHOLD ((inPriceOHLC, optInPenetration)
..inPriceOHLCपैरामीटर का उपयोग के-लाइन डेटा को निर्दिष्ट करने के लिए किया जाता है।
inPriceOHLC
सच
{@struct/Record Record} संरचना सरणी
दoptInPenetrationयह पैरामीटर वैकल्पिक है और इसका उपयोग बढ़ते/गिरते ट्रेंड लाइन की चौड़ाई के प्रतिशत को निर्दिष्ट करने के लिए किया जाता है, डिफ़ॉल्ट मान 0.5 है।
optInPenetration
झूठी
संख्या
function main() {
var records = exchange.GetRecords()
var ret = talib.CDLMATHOLD(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.CDLMATHOLD(records.Open, records.High, records.Low, records.Close)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.CDLMATHOLD(records);
Log(ret);
}
..CDLMATHOLD()कार्य तालिब पुस्तकालय प्रलेखन में वर्णित हैःCDLMATHOLD(Records[Open,High,Low,Close],Penetration = 0.5) = Array(outInteger)
..talib.CDLMORNINGDOJISTAR()फलन का उपयोग गणना के लिए किया जाता हैसुबह का तारा (के-लाइन चार्टः सुबह का तारा).
रिटर्न मूल्यtalib.CDLMORNINGDOJISTAR()कार्य हैः एक आयामी सरणी।
सरणी
talib.CDLMORNINGDOJISTAR ((इनप्राइसओएचएलसी) talib.CDLMORNINGDOJISTAR ((इनप्राइसOHLC, ऑप्टइनपेनेट्रेशन)
..inPriceOHLCपैरामीटर का उपयोग के-लाइन डेटा को निर्दिष्ट करने के लिए किया जाता है।
inPriceOHLC
सच
{@struct/Record Record} संरचना सरणी
दoptInPenetrationपैरामीटर का उपयोग सत्यापन उद्घाटन मूल्य और ठोस भाग के बीच ओवरलैप की डिग्री को निर्दिष्ट करने के लिए किया जाता है, डिफ़ॉल्ट मान 0.3 है।
optInPenetration
झूठी
संख्या
function main() {
var records = exchange.GetRecords()
var ret = talib.CDLMORNINGDOJISTAR(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.CDLMORNINGDOJISTAR(records.Open, records.High, records.Low, records.Close)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.CDLMORNINGDOJISTAR(records);
Log(ret);
}
..CDLMORNINGDOJISTAR()कार्य तालिब पुस्तकालय प्रलेखन में वर्णित हैःCDLMORNINGDOJISTAR(Records[Open,High,Low,Close],Penetration = 0.3) = Array(outInteger)
..talib.CDLMORNINGSTAR()फलन की गणना करने के लिए प्रयोग किया जाता हैमॉर्निंग स्टार (के-लाइन चार्टः मॉर्निंग स्टार).
रिटर्न मूल्यtalib.CDLMORNINGSTAR()कार्य हैः एक आयामी सरणी।
सरणी
talib.CDLMORNINGSTAR ((InPriceOHLC) talib.CDLMORNINGSTAR ((इनप्राइसOHLC, optInPenetration)
..inPriceOHLCपैरामीटर का उपयोग के-लाइन डेटा को निर्दिष्ट करने के लिए किया जाता है।
inPriceOHLC
सच
{@struct/Record Record} संरचना सरणी
दoptInPenetrationपैरामीटर प्रवृत्ति की पुष्टि के लिए आवश्यक मूल्य फ्लोट प्रतिशत सीमा है और [0,1] के दायरे में एक मान लेता है, जिसमें डिफ़ॉल्ट मान 0.3 है।
optInPenetration
झूठी
संख्या
function main() {
var records = exchange.GetRecords()
var ret = talib.CDLMORNINGSTAR(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.CDLMORNINGSTAR(records.Open, records.High, records.Low, records.Close)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.CDLMORNINGSTAR(records);
Log(ret);
}
..CDLMORNINGSTAR()कार्य तालिब पुस्तकालय प्रलेखन में वर्णित हैःCDLMORNINGSTAR(Records[Open,High,Low,Close],Penetration=0.3) = Array(outInteger)
..talib.CDLONNECK()फलन का उपयोग गणना के लिए किया जाता हैगर्दन पर पैटर्न (के-लाइन चार्टः गर्दन पर पैटर्न).
रिटर्न मूल्यtalib.CDLONNECK()समारोह एक एक आयामी सरणी है।
सरणी
talib.CDLONNECK ((inPriceOHLC)
..inPriceOHLCपैरामीटर का उपयोग के-लाइन डेटा को निर्दिष्ट करने के लिए किया जाता है।
inPriceOHLC
सच
{@struct/Record Record} संरचना सरणी
function main() {
var records = exchange.GetRecords()
var ret = talib.CDLONNECK(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.CDLONNECK(records.Open, records.High, records.Low, records.Close)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.CDLONNECK(records);
Log(ret);
}
..CDLONNECK()कार्य तालिब पुस्तकालय प्रलेखन में वर्णित हैःCDLONNECK(Records[Open,High,Low,Close]) = Array(outInteger)
..talib.CDLPIERCING()फलन का उपयोग गणना के लिए किया जाता हैछिद्रण पैटर्न (के-लाइन चार्टः छिद्रण पैटर्न).
रिटर्न मूल्यtalib.CDLPIERCING()समारोह एक एक आयामी सरणी है।
सरणी
talib.CDLPIERCING ((InPriceOHLC)
..inPriceOHLCपैरामीटर का उपयोग के-लाइन डेटा को निर्दिष्ट करने के लिए किया जाता है।
inPriceOHLC
सच
{@struct/Record Record} संरचना सरणी
function main() {
var records = exchange.GetRecords()
var ret = talib.CDLPIERCING(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.CDLPIERCING(records.Open, records.High, records.Low, records.Close)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.CDLPIERCING(records);
Log(ret);
}
..CDLPIERCING()कार्य तालिब पुस्तकालय प्रलेखन में वर्णित हैःCDLPIERCING(Records[Open,High,Low,Close]) = Array(outInteger)
..talib.CDLRICKSHAWMAN()फलन की गणना करने के लिए प्रयोग किया जाता हैरिक्शा आदमी (के-लाइन चार्टः रिक्शा आदमी).
रिटर्न मूल्यtalib.CDLRICKSHAWMAN()कार्य हैः एक आयामी सरणी।
सरणी
talib.CDLRICKSHAWMAN ((InPriceOHLC)
..inPriceOHLCपैरामीटर का उपयोग K-लाइन डेटा निर्दिष्ट करने के लिए किया जाता है।
inPriceOHLC
सच
{@struct/Record Record} संरचना सरणी
function main() {
var records = exchange.GetRecords()
var ret = talib.CDLRICKSHAWMAN(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.CDLRICKSHAWMAN(records.Open, records.High, records.Low, records.Close)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.CDLRICKSHAWMAN(records);
Log(ret);
}
..CDLRICKSHAWMAN()कार्य तालिब पुस्तकालय प्रलेखन में वर्णित हैःCDLRICKSHAWMAN(Records[Open,High,Low,Close]) = Array(outInteger)
..talib.CDLRISEFALL3METHODS()फलन की गणना करने के लिए प्रयोग किया जाता हैबढ़ते/घटते तीन तरीके (के-लाइन चार्टः बढ़ते/घटते तीन तरीके).
रिटर्न मूल्यtalib.CDLRISEFALL3METHODS()कार्य हैः एक आयामी सरणी।
सरणी
talib.CDLRISEFALL3METHODS ((इनप्राइसOHLC)
..inPriceOHLCपैरामीटर का उपयोग के-लाइन डेटा को निर्दिष्ट करने के लिए किया जाता है।
inPriceOHLC
सच
{@struct/Record Record} संरचना सरणी
function main() {
var records = exchange.GetRecords()
var ret = talib.CDLRISEFALL3METHODS(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.CDLRISEFALL3METHODS(records.Open, records.High, records.Low, records.Close)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.CDLRISEFALL3METHODS(records);
Log(ret);
}
..CDLRISEFALL3METHODS()कार्य तालिब पुस्तकालय प्रलेखन में वर्णित हैःCDLRISEFALL3METHODS(Records[Open,High,Low,Close]) = Array(outInteger)
..talib.CDLSEPARATINGLINES()फलन की गणना करने के लिए प्रयोग किया जाता हैअलग करने वाली रेखाएँ (K-लाइन चार्टः अलग करने वाली रेखाएँ).
रिटर्न मूल्यtalib.CDLSEPARATINGLINES()समारोह एक एक आयामी सरणी है।
सरणी
talib.CDLSEPARATINGLINES ((इनप्राइसOHLC)
..inPriceOHLCपैरामीटर का उपयोग के-लाइन डेटा को निर्दिष्ट करने के लिए किया जाता है।
inPriceOHLC
सच
{@struct/Record Record} संरचना सरणी
function main() {
var records = exchange.GetRecords()
var ret = talib.CDLSEPARATINGLINES(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.CDLSEPARATINGLINES(records.Open, records.High, records.Low, records.Close)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.CDLSEPARATINGLINES(records);
Log(ret);
}
..CDLSEPARATINGLINES()कार्य तालिब पुस्तकालय प्रलेखन में वर्णित हैःCDLSEPARATINGLINES(Records[Open,High,Low,Close]) = Array(outInteger)
..talib.CDLSHOOTINGSTAR()फलन का उपयोग गणना के लिए किया जाता हैशूटिंग स्टार (के-लाइन चार्टः शूटिंग स्टार).
रिटर्न मूल्यtalib.CDLSHOOTINGSTAR()समारोह एक एक आयामी सरणी है।
सरणी
talib.CDLSHOOTINGSTAR ((इनप्राइसOHLC)
..inPriceOHLCपैरामीटर का उपयोग के-लाइन डेटा को निर्दिष्ट करने के लिए किया जाता है।
inPriceOHLC
सच
{@struct/Record Record} संरचना सरणी
function main() {
var records = exchange.GetRecords()
var ret = talib.CDLSHOOTINGSTAR(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.CDLSHOOTINGSTAR(records.Open, records.High, records.Low, records.Close)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.CDLSHOOTINGSTAR(records);
Log(ret);
}
..CDLSHOOTINGSTAR()कार्य तालिब पुस्तकालय प्रलेखन में वर्णित हैःCDLSHOOTINGSTAR(Records[Open,High,Low,Close]) = Array(outInteger)
..talib.CDLSHORTLINE()फलन का उपयोग गणना के लिए किया जाता हैलघु रेखा मोमबत्ती (के-लाइन चार्टः लघु रेखा).
रिटर्न मूल्यtalib.CDLSHORTLINE()कार्य हैः एक आयामी सरणी।
सरणी
talib.CDLSSORTLINE ((InPriceOHLC)
..inPriceOHLCपैरामीटर का उपयोग के-लाइन डेटा को निर्दिष्ट करने के लिए किया जाता है।
inPriceOHLC
सच
{@struct/Record Record} संरचना सरणी
function main() {
var records = exchange.GetRecords()
var ret = talib.CDLSHORTLINE(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.CDLSHORTLINE(records.Open, records.High, records.Low, records.Close)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.CDLSHORTLINE(records);
Log(ret);
}
..CDLSHORTLINE()कार्य तालिब पुस्तकालय प्रलेखन में वर्णित हैःCDLSHORTLINE(Records[Open,High,Low,Close]) = Array(outInteger)
..talib.CDLSPINNINGTOP()फलन की गणना करने के लिए प्रयोग किया जाता हैस्पिनिंग टॉप (के-लाइन चार्टः स्पिनिंग टॉप).
रिटर्न मूल्यtalib.CDLSPINNINGTOP()कार्य हैः एक आयामी सरणी।
सरणी
talib.CDLSPINNINGTOP ((InPriceOHLC)
..inPriceOHLCपैरामीटर का उपयोग के-लाइन डेटा को निर्दिष्ट करने के लिए किया जाता है।
inPriceOHLC
सच
{@struct/Record Record} संरचना सरणी
function main() {
var records = exchange.GetRecords()
var ret = talib.CDLSPINNINGTOP(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.CDLSPINNINGTOP(records.Open, records.High, records.Low, records.Close)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.CDLSPINNINGTOP(records);
Log(ret);
}
..CDLSPINNINGTOP()कार्य तालिब पुस्तकालय प्रलेखन में वर्णित हैःCDLSPINNINGTOP(Records[Open,High,Low,Close]) = Array(outInteger)
..talib.CDLSTALLEDPATTERN()फलन की गणना करने के लिए प्रयोग किया जाता हैरुका हुआ पैटर्न (के-लाइन चार्टः रुका हुआ पैटर्न).
रिटर्न मूल्यtalib.CDLSTALLEDPATTERN()कार्य हैः एक आयामी सरणी।
सरणी
talib.CDLSTALLEDPATTERN ((इनप्राइसओएचएलसी)
..inPriceOHLCपैरामीटर का उपयोग के-लाइन डेटा को निर्दिष्ट करने के लिए किया जाता है।
inPriceOHLC
सच
{@struct/Record Record} संरचना सरणी
function main() {
var records = exchange.GetRecords()
var ret = talib.CDLSTALLEDPATTERN(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.CDLSTALLEDPATTERN(records.Open, records.High, records.Low, records.Close)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.CDLSTALLEDPATTERN(records);
Log(ret);
}
..CDLSTALLEDPATTERN()कार्य तालिब पुस्तकालय प्रलेखन में वर्णित हैःCDLSTALLEDPATTERN(Records[Open,High,Low,Close]) = Array(outInteger)
..talib.CDLSTICKSANDWICH()फलन का उपयोग गणना के लिए किया जाता हैस्टिक सैंडविच (के-लाइन चार्टः स्टिक सैंडविच).
रिटर्न मूल्यtalib.CDLSTICKSANDWICH()समारोह एक एक आयामी सरणी है।
सरणी
talib.CDLSTICKSANDWICH ((इनप्राइसओएचएलसी)
..inPriceOHLCपैरामीटर का उपयोग के-लाइन डेटा को निर्दिष्ट करने के लिए किया जाता है।
inPriceOHLC
सच
{@struct/Record Record} संरचना सरणी
function main() {
var records = exchange.GetRecords()
var ret = talib.CDLSTICKSANDWICH(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.CDLSTICKSANDWICH(records.Open, records.High, records.Low, records.Close)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.CDLSTICKSANDWICH(records);
Log(ret);
}
..CDLSTICKSANDWICH()कार्य तालिब पुस्तकालय प्रलेखन में वर्णित हैःCDLSTICKSANDWICH(Records[Open,High,Low,Close]) = Array(outInteger)
..talib.CDLTAKURI()फलन की गणना करने के लिए प्रयोग किया जाता हैताकुरी (बहुत लंबी निचली छाया रेखा के साथ ड्रैगनफ्लाई डोजी) (के-लाइन चार्टः ताकुरी).
रिटर्न मूल्यtalib.CDLTAKURI()समारोह एक एक आयामी सरणी है।
सरणी
talib.CDLTAKURI ((inPriceOHLC)
..inPriceOHLCपैरामीटर का उपयोग के-लाइन डेटा को निर्दिष्ट करने के लिए किया जाता है।
inPriceOHLC
सच
{@struct/Record Record} संरचना सरणी
function main() {
var records = exchange.GetRecords()
var ret = talib.CDLTAKURI(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.CDLTAKURI(records.Open, records.High, records.Low, records.Close)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.CDLTAKURI(records);
Log(ret);
}
..CDLTAKURI()कार्य तालिब पुस्तकालय प्रलेखन में वर्णित हैःCDLTAKURI(Records[Open,High,Low,Close]) = Array(outInteger)
..talib.CDLTASUKIGAP()फलन का उपयोग गणना के लिए किया जाता हैतासुकी गैप (के-लाइन चार्टः तासुकी गैप).
रिटर्न मूल्यtalib.CDLTASUKIGAP()समारोह एक एक आयामी सरणी है।
सरणी
talib.CDLTASUKIGAP ((InPriceOHLC)
..inPriceOHLCपैरामीटर का उपयोग के-लाइन डेटा को निर्दिष्ट करने के लिए किया जाता है।
inPriceOHLC
सच
{@struct/Record Record} संरचना सरणी
function main() {
var records = exchange.GetRecords()
var ret = talib.CDLTASUKIGAP(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.CDLTASUKIGAP(records.Open, records.High, records.Low, records.Close)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.CDLTASUKIGAP(records);
Log(ret);
}
..CDLTASUKIGAP()कार्य तालिब पुस्तकालय प्रलेखन में वर्णित हैःCDLTASUKIGAP(Records[Open,High,Low,Close]) = Array(outInteger)
..talib.CDLTHRUSTING()फलन का उपयोग गणना के लिए किया जाता हैधक्का देने वाला पैटर्न (के-लाइन चार्टः धक्का देने वाला पैटर्न).
रिटर्न मूल्यtalib.CDLTHRUSTING()कार्य हैः एक आयामी सरणी।
सरणी
talib.CDLTHRUSTING ((InPriceOHLC)
..inPriceOHLCपैरामीटर का उपयोग के-लाइन डेटा को निर्दिष्ट करने के लिए किया जाता है।
inPriceOHLC
सच
{@struct/Record Record} संरचना सरणी
function main() {
var records = exchange.GetRecords()
var ret = talib.CDLTHRUSTING(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.CDLTHRUSTING(records.Open, records.High, records.Low, records.Close)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.CDLTHRUSTING(records);
Log(ret);
}
..CDLTHRUSTING()कार्य तालिब पुस्तकालय प्रलेखन में वर्णित हैःCDLTHRUSTING(Records[Open,High,Low,Close]) = Array(outInteger)
..talib.CDLTRISTAR()फलन का उपयोग गणना के लिए किया जाता हैत्रिस्तरीय पैटर्न (के-लाइन चार्टः त्रिस्तरीय पैटर्न).
रिटर्न मूल्यtalib.CDLTRISTAR()कार्य हैः एक आयामी सरणी।
सरणी
talib.CDLTRISTAR ((InPriceOHLC)
..inPriceOHLCपैरामीटर का उपयोग के-लाइन डेटा को निर्दिष्ट करने के लिए किया जाता है।
inPriceOHLC
सच
{@struct/Record Record} संरचना सरणी
function main() {
var records = exchange.GetRecords()
var ret = talib.CDLTRISTAR(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.CDLTRISTAR(records.Open, records.High, records.Low, records.Close)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.CDLTRISTAR(records);
Log(ret);
}
..CDLTRISTAR()कार्य तालिब पुस्तकालय प्रलेखन में वर्णित हैःCDLTRISTAR(Records[Open,High,Low,Close]) = Array(outInteger)
..talib.CDLUNIQUE3RIVER()फलन का उपयोग गणना के लिए किया जाता हैयूनिक 3 नदी (के-लाइन चार्टः यूनिक 3 नदी).
रिटर्न मूल्यtalib.CDLUNIQUE3RIVER()कार्य हैः एक आयामी सरणी।
सरणी
talib.CDLUNIQUE3RIVER ((InPriceOHLC)
..inPriceOHLCपैरामीटर का उपयोग के-लाइन डेटा को निर्दिष्ट करने के लिए किया जाता है।
inPriceOHLC
सच
{@struct/Record Record} संरचना सरणी
function main() {
var records = exchange.GetRecords()
var ret = talib.CDLUNIQUE3RIVER(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.CDLUNIQUE3RIVER(records.Open, records.High, records.Low, records.Close)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.CDLUNIQUE3RIVER(records);
Log(ret);
}
..CDLUNIQUE3RIVER()कार्य तालिब पुस्तकालय प्रलेखन में वर्णित हैःCDLUNIQUE3RIVER(Records[Open,High,Low,Close]) = Array(outInteger)
..talib.CDLUPSIDEGAP2CROWS()फलन की गणना करने के लिए प्रयोग किया जाता हैऊपर की ओर दो कौवे (के-लाइन चार्टः ऊपर की ओर दो कौवे).
रिटर्न मूल्यtalib.CDLUPSIDEGAP2CROWS()कार्य हैः एक आयामी सरणी।
सरणी
talib.CDLUPSIDEGAP2CROWS ((InPriceOHLC)
..inPriceOHLCपैरामीटर का उपयोग के-लाइन डेटा को निर्दिष्ट करने के लिए किया जाता है।
inPriceOHLC
सच
{@struct/Record Record} संरचना सरणी
function main() {
var records = exchange.GetRecords()
var ret = talib.CDLUPSIDEGAP2CROWS(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.CDLUPSIDEGAP2CROWS(records.Open, records.High, records.Low, records.Close)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.CDLUPSIDEGAP2CROWS(records);
Log(ret);
}
..CDLUPSIDEGAP2CROWS()कार्य तालिब पुस्तकालय प्रलेखन में वर्णित हैःCDLUPSIDEGAP2CROWS(Records[Open,High,Low,Close]) = Array(outInteger)
..talib.CDLXSIDEGAP3METHODS()फलन की गणना करने के लिए प्रयोग किया जाता हैऊपर/नीचे की ओर अंतर तीन विधियाँ (के-लाइन चार्टः ऊपर/नीचे की ओर अंतर तीन विधियाँ).
रिटर्न मूल्यtalib.CDLXSIDEGAP3METHODS()कार्य हैः एक आयामी सरणी।
सरणी
talib.CDLXSIDEGAP3METHODS ((इनप्राइसOHLC)
..inPriceOHLCपैरामीटर का उपयोग के-लाइन डेटा को निर्दिष्ट करने के लिए किया जाता है।
inPriceOHLC
सच
{@struct/Record Record} संरचना सरणी
function main() {
var records = exchange.GetRecords()
var ret = talib.CDLXSIDEGAP3METHODS(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.CDLXSIDEGAP3METHODS(records.Open, records.High, records.Low, records.Close)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.CDLXSIDEGAP3METHODS(records);
Log(ret);
}
..CDLXSIDEGAP3METHODS()कार्य तालिब पुस्तकालय प्रलेखन में वर्णित हैःCDLXSIDEGAP3METHODS(Records[Open,High,Low,Close]) = Array(outInteger)
..talib.AD()फलन का उपयोग गणना के लिए किया जाता हैचाइकिन ए/डी रेखा (लाइन स्टोकैस्टिक संकेतक).
रिटर्न मूल्यtalib.AD()कार्य हैः एक आयामी सरणी।
सरणी
talib.AD(PriceHLCV में)
..inPriceHLCVपैरामीटर का उपयोग के-लाइन डेटा को निर्दिष्ट करने के लिए किया जाता है।
inPriceHLCV
सच
{@struct/Record Record} संरचना सरणी
function main() {
var records = exchange.GetRecords()
var ret = talib.AD(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.AD(records.High, records.Low, records.Close, records.Volume)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.AD(records);
Log(ret);
}
..AD()कार्य तालिब पुस्तकालय प्रलेखन में वर्णित हैःAD(Records[High,Low,Close,Volume]) = Array(outReal)
..talib.ADOSC()फलन का उपयोग गणना के लिए किया जाता हैचाइकिन ए/डी ऑसिलेटर (Chaikin Oscillator).
रिटर्न मूल्यtalib.ADOSC()समारोह एक एक आयामी सरणी है।
सरणी
talib.ADOSC ((inPriceHLCV) talib.ADOSC ((inPriceHLCV, optInFastPeriod, optInSlowPeriod)
..inPriceHLCVपैरामीटर का उपयोग के-लाइन डेटा को निर्दिष्ट करने के लिए किया जाता है।
inPriceHLCV
सच
{@struct/Record Record} संरचना सरणी
दoptInFastPeriodतेजी से अवधि निर्धारित करने के लिए पैरामीटर का उपयोग किया जाता है।
optInFastPeriod
झूठी
संख्या
दoptInSlowPeriodपैरामीटर धीमी अवधि सेट करने के लिए प्रयोग किया जाता है.
optInSlowPeriod
झूठी
संख्या
function main() {
var records = exchange.GetRecords()
var ret = talib.ADOSC(records, 3, 10)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.ADOSC(records.High, records.Low, records.Close, records.Volume, 3, 10)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.ADOSC(records, 3, 10);
Log(ret);
}
..ADOSC()कार्य तालिब पुस्तकालय प्रलेखन में वर्णित हैःADOSC(Records[High,Low,Close,Volume],Fast Period = 3,Slow Period = 10) = Array(outReal)
..talib.OBV()फलन की गणना करने के लिए प्रयोग किया जाता हैसंतुलन मात्रा (ऊर्जा ज्वार) पर.
रिटर्न मूल्यtalib.OBV()समारोह एक एक आयामी सरणी है।
सरणी
talib.OBV ((inReal) talib.OBV ((inReal, inPriceV)
..inRealपैरामीटर का उपयोग के-लाइन डेटा को निर्दिष्ट करने के लिए किया जाता है।
वास्तविक
सच
{@struct/Record Record} संरचना सरणी, संख्यात्मक सरणी
दinPriceVपैरामीटर का उपयोग के-लाइन डेटा को निर्दिष्ट करने के लिए किया जाता है।
inPriceV
झूठी
{@struct/Record Record} संरचना सरणी
function main() {
var records = exchange.GetRecords()
var ret = talib.OBV(records, records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.OBV(records.Close, records.Volume)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.OBV(records);
Log(ret);
}
..OBV()कार्य तालिब पुस्तकालय प्रलेखन में वर्णित हैःOBV(Records[Close],Records[Volume]) = Array(outReal)
..talib.ACOS()फलन की गणना करने के लिए प्रयोग किया जाता हैवेक्टर त्रिकोणमितीय एसीओएस (विपरित कोसिनोस फलन).
रिटर्न मूल्यtalib.ACOS()समारोह एक एक आयामी सरणी है।
सरणी
talib.ACOS ((inReal)
..inRealपैरामीटर का उपयोग के-लाइन डेटा को निर्दिष्ट करने के लिए किया जाता है।
वास्तविक
सच
{@struct/Record Record} संरचना सरणी, संख्यात्मक सरणी
function main() {
var data = [-1, 0, 1]
var ret = talib.ACOS(data)
Log(ret)
}
import talib
import numpy as np
def main():
data = [-1.0, 0, 1.0]
ret = talib.ACOS(np.array(data))
Log(ret)
void main() {
std::vector<double> data = {-1, 0, 1};
auto ret = talib.ACOS(data);
Log(ret);
}
..ACOS()कार्य तालिब पुस्तकालय प्रलेखन में वर्णित हैःACOS(Records[Close]) = Array(outReal)
..talib.ASIN()फलन का उपयोग गणना के लिए किया जाता हैवेक्टर त्रिकोणमितीय एएसिन (उलटा साइन फलन).
रिटर्न मूल्यtalib.ASIN()समारोह एक एक आयामी सरणी है।
सरणी
talib.ASIN ((inReal)
..inRealपैरामीटर का उपयोग के-लाइन डेटा को निर्दिष्ट करने के लिए किया जाता है।
वास्तविक
सच
{@struct/Record Record} संरचना सरणी, संख्यात्मक सरणी
function main() {
var data = [-1, 0, 1]
var ret = talib.ASIN(data)
Log(ret)
}
import talib
import numpy as np
def main():
data = [-1.0, 0, 1.0]
ret = talib.ASIN(np.array(data))
Log(ret)
void main() {
std::vector<double> data = {-1, 0, 1};
auto ret = talib.ASIN(data);
Log(ret);
}
..ASIN()कार्य तालिब पुस्तकालय प्रलेखन में वर्णित हैःASIN(Records[Close]) = Array(outReal)
..talib.ATAN()फलन का उपयोग गणना के लिए किया जाता हैवेक्टर त्रिकोणमितीय ATan (उलटा स्पर्श समारोह).
रिटर्न मूल्यtalib.ATAN()कार्य हैः एक आयामी सरणी।
सरणी
talib.ATAN ((inReal)
..inRealपैरामीटर का उपयोग के-लाइन डेटा को निर्दिष्ट करने के लिए किया जाता है।
वास्तविक
सच
{@struct/Record Record} संरचना सरणी, संख्यात्मक सरणी
function main() {
var data = [-3.14/2, 0, 3.14/2]
var ret = talib.ATAN(data)
Log(ret)
}
import talib
import numpy as np
def main():
data = [-3.14/2, 0, 3.14/2]
ret = talib.ATAN(np.array(data))
Log(ret)
void main() {
std::vector<double> data = {-3.14/2, 0, 3.14/2};
auto ret = talib.ATAN(data);
Log(ret);
}
..ATAN()कार्य तालिब पुस्तकालय प्रलेखन में वर्णित हैःATAN(Records[Close]) = Array(outReal)
..talib.CEIL()फलन की गणना करने के लिए प्रयोग किया जाता हैवेक्टर सीलिंग (रोन्डिंग फंक्शन).
रिटर्न मूल्यtalib.CEIL()समारोह एक एक आयामी सरणी है।
सरणी
talib.CEIL ((inReal)
..inRealपैरामीटर का उपयोग के-लाइन डेटा को निर्दिष्ट करने के लिए किया जाता है।
वास्तविक
सच
{@struct/Record Record} संरचना सरणी, संख्यात्मक सरणी
function main() {
var records = exchange.GetRecords()
var ret = talib.CEIL(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.CEIL(records.Close)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.CEIL(records);
Log(ret);
}
..CEIL()कार्य तालिब पुस्तकालय प्रलेखन में वर्णित हैःCEIL(Records[Close]) = Array(outReal)
..talib.COS()फलन का उपयोग गणना के लिए किया जाता हैवेक्टर त्रिकोणमितीय कॉस (कोसिनस फलन).
रिटर्न मूल्यtalib.COS()कार्य हैः एक आयामी सरणी।
सरणी
talib.COS ((inReal)
..inRealपैरामीटर का उपयोग के-लाइन डेटा को निर्दिष्ट करने के लिए किया जाता है।
वास्तविक
सच
{@struct/Record Record} संरचना सरणी, संख्यात्मक सरणी
function main() {
var data = [-3.14, 0, 3.14]
var ret = talib.COS(data)
Log(ret)
}
import talib
import numpy as np
def main():
data = [-3.14, 0, 3.14]
ret = talib.COS(np.array(data))
Log(ret)
void main() {
std::vector<double> data = {-3.14, 0, 3.14};
auto ret = talib.COS(data);
Log(ret);
}
..COS()कार्य तालिब पुस्तकालय प्रलेखन में वर्णित हैःCOS(Records[Close]) = Array(outReal)
..talib.COSH()फलन की गणना करने के लिए प्रयोग किया जाता हैवेक्टर त्रिकोणमितीय कोश (हाइपरबोलिक कोसिनस मान).
रिटर्न मूल्यtalib.COSH()समारोह एक एक आयामी सरणी है।
सरणी
talib.COSH ((inReal)
..inRealपैरामीटर का उपयोग के-लाइन डेटा को निर्दिष्ट करने के लिए किया जाता है।
वास्तविक
सच
{@struct/Record Record} संरचना सरणी, संख्यात्मक सरणी
function main() {
var data = [-1, 0, 1]
var ret = talib.COSH(data)
Log(ret)
}
import talib
import numpy as np
def main():
data = [-1.0, 0, 1.0]
ret = talib.COSH(np.array(data))
Log(ret)
void main() {
std::vector<double> data = {-1, 0, 1};
auto ret = talib.COSH(data);
Log(ret);
}
..COSH()कार्य तालिब पुस्तकालय प्रलेखन में वर्णित हैःCOSH(Records[Close]) = Array(outReal)
..talib.EXP()फलन का उपयोग गणना के लिए किया जाता हैवेक्टर अंकगणित Exp (अभिसरणात्मक कार्य).
रिटर्न मूल्यtalib.EXP()कार्य हैः एक आयामी सरणी।
सरणी
talib.EXP ((inReal)
..inRealपैरामीटर का उपयोग के-लाइन डेटा को निर्दिष्ट करने के लिए किया जाता है।
वास्तविक
सच
{@struct/Record Record} संरचना सरणी, संख्यात्मक सरणी
function main() {
var data = [0, 1, 2]
var ret = talib.EXP(data) // e^0, e^1, e^2
Log(ret)
}
import talib
import numpy as np
def main():
data = [0, 1.0, 2.0]
ret = talib.EXP(np.array(data))
Log(ret)
void main() {
std::vector<double> data = {0, 1.0, 2.0};
auto ret = talib.EXP(data);
Log(ret);
}
..EXP()कार्य तालिब पुस्तकालय प्रलेखन में वर्णित हैःEXP(Records[Close]) = Array(outReal)
..talib.FLOOR()फलन का उपयोग गणना के लिए किया जाता हैवेक्टर तल (नीचे को गोल).
रिटर्न मूल्यtalib.FLOOR()समारोह एक एक आयामी सरणी है।
सरणी
talib.FLOOR ((inReal)
..inRealपैरामीटर का उपयोग के-लाइन डेटा को निर्दिष्ट करने के लिए किया जाता है।
वास्तविक
सच
{@struct/Record Record} संरचना सरणी, संख्यात्मक सरणी
function main() {
var records = exchange.GetRecords()
var ret = talib.FLOOR(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.FLOOR(records.Close)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.FLOOR(records);
Log(ret);
}
..FLOOR()कार्य तालिब पुस्तकालय प्रलेखन में वर्णित हैःFLOOR(Records[Close]) = Array(outReal)
..talib.LN()फलन का उपयोग गणना के लिए किया जाता हैवेक्टर लॉग प्राकृतिक (प्राकृतिक लघुगणक).
रिटर्न मूल्यtalib.LN()समारोह एक एक आयामी सरणी है।
सरणी
talib.LN ((inReal)
..inRealपैरामीटर का उपयोग के-लाइन डेटा को निर्दिष्ट करने के लिए किया जाता है।
वास्तविक
सच
{@struct/Record Record} संरचना सरणी, संख्यात्मक सरणी
function main() {
var data = [1, 2, 3]
var ret = talib.LN(data)
Log(ret)
}
import talib
import numpy as np
def main():
data = [1.0, 2.0, 3.0]
ret = talib.LN(np.array(data))
Log(ret)
void main() {
std::vector<double> data = {1, 2, 3};
auto ret = talib.LN(data);
Log(ret);
}
..LN()कार्य तालिब पुस्तकालय प्रलेखन में वर्णित हैःLN(Records[Close]) = Array(outReal)
..talib.LOG10()फलन की गणना करने के लिए प्रयोग किया जाता हैवेक्टर लॉग10 (लॉगरिथमिक फलन).
रिटर्न मूल्यtalib.LOG10()समारोह एक एक आयामी सरणी है।
सरणी
talib.LOG10 ((inReal)
..inRealपैरामीटर का उपयोग के-लाइन डेटा को निर्दिष्ट करने के लिए किया जाता है।
वास्तविक
सच
{@struct/Record Record} संरचना सरणी, संख्यात्मक सरणी
function main() {
var data = [10, 100, 1000]
var ret = talib.LOG10(data)
Log(ret)
}
import talib
import numpy as np
def main():
data = [10.0, 100.0, 1000.0]
ret = talib.LOG10(np.array(data))
Log(ret)
void main() {
std::vector<double> data = {10, 100, 1000};
auto ret = talib.LOG10(data);
Log(ret);
}
..LOG10()कार्य तालिब पुस्तकालय प्रलेखन में वर्णित हैःLOG10(Records[Close]) = Array(outReal)
..talib.SIN()फलन की गणना करने के लिए प्रयोग किया जाता हैवेक्टर त्रिकोणमितीय सिन (सिन मान).
रिटर्न मूल्यtalib.SIN()समारोह एक एक आयामी सरणी है।
सरणी
talib.SIN ((inReal)
..inRealपैरामीटर का उपयोग के-लाइन डेटा को निर्दिष्ट करने के लिए किया जाता है।
वास्तविक
सच
{@struct/Record Record} संरचना सरणी, संख्यात्मक सरणी
function main() {
var data = [-3.14/2, 0, 3.14/2]
var ret = talib.SIN(data)
Log(ret)
}
import talib
import numpy as np
def main():
data = [-3.14/2, 0, 3.14/2]
ret = talib.SIN(np.array(data))
Log(ret)
void main() {
std::vector<double> data = {-3.14/2, 0, 3.14/2};
auto ret = talib.SIN(data);
Log(ret);
}
..SIN()कार्य तालिब पुस्तकालय प्रलेखन में वर्णित हैःSIN(Records[Close]) = Array(outReal)
..talib.SINH()फलन का उपयोग गणना के लिए किया जाता हैवेक्टर त्रिकोणमितीय सिन्ह (हाइपरबोलिक सीन फंक्शन).
रिटर्न मूल्यtalib.SINH()कार्य हैः एक आयामी सरणी।
सरणी
talib.SINH ((inReal)
..inRealपैरामीटर का उपयोग के-लाइन डेटा को निर्दिष्ट करने के लिए किया जाता है।
वास्तविक
सच
{@struct/Record Record} संरचना सरणी, संख्यात्मक सरणी
function main() {
var data = [-1, 0, 1]
var ret = talib.SINH(data)
Log(ret)
}
import talib
import numpy as np
def main():
data = [-1.0, 0, 1.0]
ret = talib.SINH(np.array(data))
Log(ret)
void main() {
std::vector<double> data = {-1, 0, 1};
auto ret = talib.SINH(data);
Log(ret);
}
..SINH()कार्य तालिब पुस्तकालय प्रलेखन में वर्णित हैःSINH(Records[Close]) = Array(outReal)
..talib.SQRT()फलन का उपयोग गणना के लिए किया जाता हैवेक्टर वर्गमूल (वर्गमूल).
रिटर्न मूल्यtalib.SQRT()कार्य हैः एक आयामी सरणी।
सरणी
talib.SQRT ((inReal)
..inRealपैरामीटर का उपयोग के-लाइन डेटा को निर्दिष्ट करने के लिए किया जाता है।
वास्तविक
सच
{@struct/Record Record} संरचना सरणी, संख्यात्मक सरणी
function main() {
var data = [4, 64, 100]
var ret = talib.SQRT(data)
Log(ret)
}
import talib
import numpy as np
def main():
data = [4.0, 64.0, 100.0]
ret = talib.SQRT(np.array(data))
Log(ret)
void main() {
std::vector<double> data = {4, 64, 100};
auto ret = talib.SQRT(data);
Log(ret);
}
..SQRT()कार्य तालिब पुस्तकालय प्रलेखन में वर्णित हैःSQRT(Records[Close]) = Array(outReal)
..talib.TAN()फलन का उपयोग गणना के लिए किया जाता हैवेक्टर त्रिकोणमितीय टैन (टांगेंट).
रिटर्न मूल्यtalib.TAN()समारोह एक एक आयामी सरणी है।
सरणी
talib.TAN ((inReal)
..inRealपैरामीटर का उपयोग के-लाइन डेटा को निर्दिष्ट करने के लिए किया जाता है।
वास्तविक
सच
{@struct/Record Record} संरचना सरणी, संख्यात्मक सरणी
function main() {
var data = [-1, 0, 1]
var ret = talib.TAN(data)
Log(ret)
}
import talib
import numpy as np
def main():
data = [-1.0, 0, 1.0]
ret = talib.TAN(np.array(data))
Log(ret)
void main() {
std::vector<double> data = {-1, 0, 1};
auto ret = talib.TAN(data);
Log(ret);
}
..TAN()कार्य तालिब पुस्तकालय प्रलेखन में वर्णित हैःTAN(Records[Close]) = Array(outReal)
..talib.TANH()फलन का उपयोग गणना के लिए किया जाता हैवेक्टर त्रिकोणमितीय तनह (हाइपरबोलिक स्पर्श समारोह).
रिटर्न मूल्यtalib.TANH()कार्य हैः एक आयामी सरणी।
सरणी
talib.TANH ((inReal)
..inRealपैरामीटर का उपयोग के-लाइन डेटा को निर्दिष्ट करने के लिए किया जाता है।
वास्तविक
सच
{@struct/Record Record} संरचना सरणी, संख्यात्मक सरणी
function main() {
var data = [-1, 0, 1]
var ret = talib.TANH(data)
Log(ret)
}
import talib
import numpy as np
def main():
data = [-1.0, 0, 1.0]
ret = talib.TANH(np.array(data))
Log(ret)
void main() {
std::vector<double> data = {-1, 0, 1};
auto ret = talib.TANH(data);
Log(ret);
}
..TANH()कार्य तालिब पुस्तकालय प्रलेखन में वर्णित हैःTANH(Records[Close]) = Array(outReal)
..talib.MAX()एक के लिए उच्चतम (अधिकतम) मूल्य की गणना करने के लिए समारोह का उपयोग किया जाता हैविशिष्ट अवधि.
रिटर्न मूल्यtalib.MAX()कार्य हैः एक आयामी सरणी।
सरणी
talib.MAX ((inReal) talib.MAX ((inReal, optInTimePeriod)
..inRealपैरामीटर का उपयोग के-लाइन डेटा को निर्दिष्ट करने के लिए किया जाता है।
वास्तविक
सच
{@struct/Record Record} संरचना सरणी, संख्यात्मक सरणी
दoptInTimePeriodपैरामीटर अवधि सेट करने के लिए प्रयोग किया जाता है, डिफ़ॉल्ट मान 30 है।
optInTimeपीरियड
झूठी
संख्या
function main() {
var records = exchange.GetRecords()
var ret = talib.MAX(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.MAX(records.Close)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.MAX(records);
Log(ret);
}
..MAX()कार्य तालिब पुस्तकालय प्रलेखन में वर्णित हैःMAX(Records[Close],Time Period = 30) = Array(outReal)
..talib.MAXINDEX()फलन की गणना करने के लिए प्रयोग किया जाता हैनिर्दिष्ट अवधि में उच्चतम मूल्य का सूचकांक (अधिकतम सूचकांक).
रिटर्न मूल्यtalib.MAXINDEX()कार्य हैः एक आयामी सरणी।
सरणी
talib.MAXINDEX ((inReal) talib.MAXINDEX ((inReal, optInTimePeriod)
..inRealपैरामीटर का उपयोग के-लाइन डेटा को निर्दिष्ट करने के लिए किया जाता है।
वास्तविक
सच
{@struct/Record Record} संरचना सरणी, संख्यात्मक सरणी
दoptInTimePeriodपैरामीटर अवधि सेट करने के लिए प्रयोग किया जाता है, डिफ़ॉल्ट मान 30 है।
optInTimeपीरियड
झूठी
संख्या
function main() {
var records = exchange.GetRecords()
var ret = talib.MAXINDEX(records, 5)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.MAXINDEX(records.Close, 5)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.MAXINDEX(records, 5);
Log(ret);
}
..MAXINDEX()कार्य तालिब पुस्तकालय प्रलेखन में वर्णित हैःMAXINDEX(Records[Close],Time Period = 30) = Array(outInteger)
..talib.MIN()फ़ंक्शन का उपयोग निर्दिष्ट अवधि के लिए निम्नतम मूल्य (न्यूनतम मूल्य) ** की गणना करने के लिए किया जाता है।
रिटर्न मूल्यtalib.MIN()कार्य हैः एक आयामी सरणी।
सरणी
talib.MIN ((inReal) talib.MIN ((inReal, optInTimePeriod)
..inRealपैरामीटर का उपयोग के-लाइन डेटा को निर्दिष्ट करने के लिए किया जाता है।
वास्तविक
सच
{@struct/Record Record} संरचना सरणी, संख्यात्मक सरणी
दoptInTimePeriodपैरामीटर अवधि सेट करने के लिए प्रयोग किया जाता है, डिफ़ॉल्ट मान 30 है।
optInTimeपीरियड
झूठी
संख्या
function main() {
var records = exchange.GetRecords()
var ret = talib.MIN(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.MIN(records.Close)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.MIN(records);
Log(ret);
}
..MIN()कार्य तालिब पुस्तकालय प्रलेखन में वर्णित हैःMIN(Records[Close],Time Period = 30) = Array(outReal)
..talib.MININDEX()फलन की गणना करने के लिए प्रयोग किया जाता हैसबसे कम मूल्य सूचकांक (न्यूनतम मूल्य सूचकांक)निर्दिष्ट अवधि के लिए।
रिटर्न मूल्यtalib.MININDEX()कार्य हैः एक आयामी सरणी।
सरणी
talib.MININDEX ((inReal) talib.MININDEX ((inReal, optInTimePeriod)
..inRealपैरामीटर का उपयोग के-लाइन डेटा को निर्दिष्ट करने के लिए किया जाता है।
वास्तविक
सच
{@struct/Record Record} संरचना सरणी, संख्यात्मक सरणी
दoptInTimePeriodपैरामीटर अवधि सेट करने के लिए प्रयोग किया जाता है, डिफ़ॉल्ट मान 30 है।
optInTimeपीरियड
झूठी
संख्या
function main() {
var records = exchange.GetRecords()
var ret = talib.MININDEX(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.MININDEX(records.Close)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.MININDEX(records);
Log(ret);
}
..MININDEX()कार्य तालिब पुस्तकालय प्रलेखन में वर्णित हैःMININDEX(Records[Close],Time Period = 30) = Array(outInteger)
..talib.MINMAX()फलन की गणना करने के लिए प्रयोग किया जाता हैनिर्दिष्ट अवधि के लिए निम्नतम और उच्चतम (न्यूनतम और अधिकतम) मूल्य.
रिटर्न मूल्यtalib.MINMAX()इस दो आयामी सरणी का पहला तत्व न्यूनतम मानों का सरणी है, और दूसरा तत्व अधिकतम मानों का सरणी है।
सरणी
talib.MINMAX ((inReal) talib.MINMAX ((inReal, optInTimePeriod)
..inRealपैरामीटर का उपयोग के-लाइन डेटा को निर्दिष्ट करने के लिए किया जाता है।
वास्तविक
सच
{@struct/Record Record} संरचना सरणी, संख्यात्मक सरणी
दoptInTimePeriodपैरामीटर अवधि सेट करने के लिए प्रयोग किया जाता है, डिफ़ॉल्ट मान 30 है।
optInTimeपीरियड
झूठी
संख्या
function main() {
var records = exchange.GetRecords()
var ret = talib.MINMAX(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.MINMAX(records.Close)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.MINMAX(records);
Log(ret);
}
..MINMAX()कार्य तालिब पुस्तकालय प्रलेखन में वर्णित हैःMINMAX(Records[Close],Time Period = 30) = [Array(outMin),Array(outMax)]
..talib.MINMAXINDEX()फलन की गणना करने के लिए प्रयोग किया जाता हैनिर्दिष्ट अवधि में निम्नतम और उच्चतम (न्यूनतम और अधिकतम सूचकांक) मूल्यों का सूचकांक.
रिटर्न मूल्यtalib.MINMAXINDEX()function is: a two-dimensional array. इस दो-आयामी सरणी का पहला तत्व न्यूनतम अनुक्रमित सरणी है, और दूसरा तत्व अधिकतम अनुक्रमित सरणी है.
सरणी
talib.MINMAXINDEX ((inReal) talib.MINMAXINDEX ((inReal, optInTimePeriod)
..inRealपैरामीटर का उपयोग के-लाइन डेटा को निर्दिष्ट करने के लिए किया जाता है।
वास्तविक
सच
{@struct/Record Record} संरचना सरणी, संख्यात्मक सरणी
दoptInTimePeriodपैरामीटर अवधि सेट करने के लिए प्रयोग किया जाता है, डिफ़ॉल्ट मान 30 है।
optInTimeपीरियड
झूठी
संख्या
function main() {
var records = exchange.GetRecords()
var ret = talib.MINMAXINDEX(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.MINMAXINDEX(records.Close)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.MINMAXINDEX(records);
Log(ret);
}
..MINMAXINDEX()कार्य तालिब पुस्तकालय प्रलेखन में वर्णित हैःMINMAXINDEX(Records[Close],Time Period = 30) = [Array(outMinIdx),Array(outMaxIdx)]
..talib.SUM()फलन की गणना करने के लिए प्रयोग किया जाता हैसारांश.
रिटर्न मूल्यtalib.SUM()कार्य हैः एक आयामी सरणी।
सरणी
talib.SUM ((inReal) talib.SUM ((inReal, optInTimePeriod)
..inRealपैरामीटर का उपयोग के-लाइन डेटा को निर्दिष्ट करने के लिए किया जाता है।
वास्तविक
सच
{@struct/Record Record} संरचना सरणी, संख्यात्मक सरणी
दoptInTimePeriodपैरामीटर अवधि सेट करने के लिए प्रयोग किया जाता है, डिफ़ॉल्ट मान 30 है।
optInTimeपीरियड
झूठी
संख्या
function main() {
var records = exchange.GetRecords()
var ret = talib.SUM(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.SUM(records.Close)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.SUM(records);
Log(ret);
}
..SUM()कार्य तालिब पुस्तकालय प्रलेखन में वर्णित हैःSUM(Records[Close],Time Period = 30) = Array(outReal)
..talib.HT_DCPERIOD()फलन का उपयोग गणना के लिए किया जाता हैहिल्बर्ट परिवर्तन - प्रमुख चक्र अवधि (हिल्बर्ट परिवर्तन, प्रमुख अवधि).
रिटर्न मूल्यtalib.HT_DCPERIOD()कार्य हैः एक आयामी सरणी।
सरणी
talib.HT_DCPERIOD ((inReal)
..inRealपैरामीटर का उपयोग के-लाइन डेटा को निर्दिष्ट करने के लिए किया जाता है।
वास्तविक
सच
{@struct/Record Record} संरचना सरणी, संख्यात्मक सरणी
function main() {
var records = exchange.GetRecords()
var ret = talib.HT_DCPERIOD(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.HT_DCPERIOD(records.Close)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.HT_DCPERIOD(records);
Log(ret);
}
..HT_DCPERIOD()कार्य तालिब पुस्तकालय प्रलेखन में वर्णित हैःHT_DCPERIOD(Records[Close]) = Array(outReal)
..talib.HT_DCPHASE()फलन का उपयोग गणना के लिए किया जाता हैहिल्बर्ट परिवर्तन - प्रमुख चक्र चरण (हिल्बर्ट परिवर्तन, प्रमुख चक्र चरण).
रिटर्न मूल्यtalib.HT_DCPHASE()कार्य हैः एक आयामी सरणी।
सरणी
talib.HT_DCPHASE ((inReal)
..inRealपैरामीटर का उपयोग के-लाइन डेटा को निर्दिष्ट करने के लिए किया जाता है।
वास्तविक
सच
{@struct/Record Record} संरचना सरणी, संख्यात्मक सरणी
function main() {
var records = exchange.GetRecords()
var ret = talib.HT_DCPHASE(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.HT_DCPHASE(records.Close)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.HT_DCPHASE(records);
Log(ret);
}
..HT_DCPHASE()कार्य तालिब पुस्तकालय प्रलेखन में वर्णित हैःHT_DCPHASE(Records[Close]) = Array(outReal)
..talib.HT_PHASOR()फलन का उपयोग गणना के लिए किया जाता हैहिल्बर्ट परिवर्तन - फासोर घटक (हिल्बर्ट परिवर्तन, चरण घटक).
रिटर्न मूल्यtalib.HT_PHASOR()समारोह एक दो आयामी सरणी है।
सरणी
talib.HT_PHASOR ((inReal)
..inRealपैरामीटर का उपयोग के-लाइन डेटा को निर्दिष्ट करने के लिए किया जाता है।
वास्तविक
सच
{@struct/Record Record} संरचना सरणी, संख्यात्मक सरणी
function main() {
var records = exchange.GetRecords()
var ret = talib.HT_PHASOR(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.HT_PHASOR(records.Close)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.HT_PHASOR(records);
Log(ret);
}
..HT_PHASOR()कार्य तालिब पुस्तकालय प्रलेखन में वर्णित हैःHT_PHASOR(Records[Close]) = [Array(outInPhase),Array(outQuadrature)]
..talib.HT_SINE()फलन का उपयोग गणना के लिए किया जाता हैहिल्बर्ट परिवर्तन - सीन वेव.
रिटर्न मूल्यtalib.HT_SINE()कार्य हैः एक दो आयामी सरणी।
सरणी
talib.HT_SINE ((inReal)
..inRealपैरामीटर का उपयोग के-लाइन डेटा को निर्दिष्ट करने के लिए किया जाता है।
वास्तविक
सच
{@struct/Record Record} संरचना सरणी, संख्यात्मक सरणी
function main() {
var records = exchange.GetRecords()
var ret = talib.HT_SINE(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.HT_SINE(records.Close)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.HT_SINE(records);
Log(ret);
}
..HT_SINE()कार्य तालिब पुस्तकालय प्रलेखन में वर्णित हैःHT_SINE(Records[Close]) = [Array(outSine),Array(outLeadSine)]
..talib.HT_TRENDMODE()फलन का उपयोग गणना के लिए किया जाता हैहिल्बर्ट परिवर्तन - प्रवृत्ति और चक्र मोड.
रिटर्न मूल्यtalib.HT_TRENDMODE()कार्य हैः एक आयामी सरणी।
सरणी
talib.HT_TRENDMODE ((inReal)
..inRealपैरामीटर का उपयोग के-लाइन डेटा को निर्दिष्ट करने के लिए किया जाता है।
वास्तविक
सच
{@struct/Record Record} संरचना सरणी, संख्यात्मक सरणी
function main() {
var records = exchange.GetRecords()
var ret = talib.HT_TRENDMODE(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.HT_TRENDMODE(records.Close)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.HT_TRENDMODE(records);
Log(ret);
}
..HT_TRENDMODE()कार्य तालिब पुस्तकालय प्रलेखन में वर्णित हैःHT_TRENDMODE(Records[Close]) = Array(outInteger)
..talib.ATR()फलन का उपयोग गणना के लिए किया जाता हैऔसत वास्तविक सीमा.
रिटर्न मूल्यtalib.ATR()समारोह एक एक आयामी सरणी है।
सरणी
talib.ATR ((inPriceHLC) talib.ATR ((inPriceHLC, optInTimePeriod)
..inPriceHLCपैरामीटर का उपयोग के-लाइन डेटा को निर्दिष्ट करने के लिए किया जाता है।
inPriceHLC
सच
{@struct/Record Record} संरचना सरणी
दoptInTimePeriodपैरामीटर अवधि सेट करने के लिए प्रयोग किया जाता है, डिफ़ॉल्ट मान 14 है।
optInTimeपीरियड
झूठी
संख्या
function main() {
var records = exchange.GetRecords()
var ret = talib.ATR(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.ATR(records.High, records.Low, records.Close)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.ATR(records);
Log(ret);
}
..ATR()कार्य तालिब पुस्तकालय प्रलेखन में वर्णित हैःATR(Records[High,Low,Close],Time Period = 14) = Array(outReal)
..talib.NATR()फलन का उपयोग गणना के लिए किया जाता हैसामान्यीकृत औसत वास्तविक सीमा.
रिटर्न मूल्यtalib.NATR()समारोह एक एक आयामी सरणी है।
सरणी
talib.NATR ((inPriceHLC) talib.NATR ((inPriceHLC, optInTimePeriod)
..inPriceHLCपैरामीटर का उपयोग के-लाइन डेटा को निर्दिष्ट करने के लिए किया जाता है।
inPriceHLC
सच
{@struct/Record Record} संरचना सरणी
दoptInTimePeriodपैरामीटर अवधि सेट करने के लिए प्रयोग किया जाता है, डिफ़ॉल्ट मान 14 है।
optInTimeपीरियड
झूठी
संख्या
function main() {
var records = exchange.GetRecords()
var ret = talib.NATR(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.NATR(records.High, records.Low, records.Close)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.NATR(records);
Log(ret);
}
..NATR()कार्य तालिब पुस्तकालय प्रलेखन में वर्णित हैःNATR(Records[High,Low,Close],Time Period = 14) = Array(outReal)
..talib.TRANGE()फलन का उपयोग गणना के लिए किया जाता हैवास्तविक सीमा.
रिटर्न मूल्यtalib.TRANGE()कार्य हैः एक आयामी सरणी।
सरणी
talib.TRANGE ((inPriceHLC)
..inPriceHLCपैरामीटर का उपयोग के-लाइन डेटा को निर्दिष्ट करने के लिए किया जाता है।
inPriceHLC
सच
{@struct/Record Record} संरचना सरणी
function main() {
var records = exchange.GetRecords()
var ret = talib.TRANGE(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.TRANGE(records.High, records.Low, records.Close)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.TRANGE(records);
Log(ret);
}
..TRANGE()कार्य तालिब पुस्तकालय प्रलेखन में वर्णित हैःTRANGE(Records[High,Low,Close]) = Array(outReal)
..talib.BBANDS()फलन की गणना करने के लिए प्रयोग किया जाता हैबोलिंगर बैंड.
रिटर्न मूल्यtalib.BBANDS()function is: a two-dimensional array. array में तीन तत्व होते हैं जो हैंः ऊपरी रेखा array, मध्य रेखा array, और निचली रेखा array.
सरणी
talib.BBANDS ((इनरियल) talib.BBANDS ((inReal, optInTimePeriod) talib.BBANDS ((inReal, optInTimePeriod, optInNbDevUp) talib.BBANDS ((inReal, optInTimePeriod, optInNbDevUp, optInNbDevDn) talib.BBANDS ((inReal, optInTimePeriod, optInNbDevUp, optInNbDevDn, optInMAType)
..inRealपैरामीटर का उपयोग के-लाइन डेटा को निर्दिष्ट करने के लिए किया जाता है।
वास्तविक
सच
{@struct/Record Record} संरचना सरणी, संख्यात्मक सरणी
दoptInTimePeriodपैरामीटर अवधि सेट करने के लिए प्रयोग किया जाता है, डिफ़ॉल्ट मान 5 है।
optInTimeपीरियड
झूठी
संख्या
दoptInNbDevUpपैरामीटर अपलाइन गुणक सेट करने के लिए प्रयोग किया जाता है, डिफ़ॉल्ट मान 2 है।
optInNbDevUp
झूठी
संख्या
दoptInNbDevDnपैरामीटर का उपयोग निचली पंक्ति गुणक सेट करने के लिए किया जाता है, डिफ़ॉल्ट मान 2 है।
optInNbDevDn
झूठी
संख्या
दoptInMATypeपैरामीटर औसत प्रकार सेट करने के लिए प्रयोग किया जाता है, डिफ़ॉल्ट मान 0 है।
optInMAType
झूठी
संख्या
function main() {
var records = exchange.GetRecords()
var ret = talib.BBANDS(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.BBANDS(records.Close)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.BBANDS(records);
Log(ret);
}
..BBANDS()कार्य तालिब पुस्तकालय प्रलेखन में वर्णित हैःBBANDS(Records[Close],Time Period = 5,Deviations up = 2,Deviations down = 2,MA Type = 0) = [Array(outRealUpperBand),Array(outRealMiddleBand),Array(outRealLowerBand)]
..talib.DEMA()फलन का उपयोग गणना के लिए किया जाता हैडबल एक्सपोनेंशियल चलती औसत.
रिटर्न मूल्यtalib.DEMA()समारोह एक एक आयामी सरणी है।
सरणी
talib.DEMA ((inReal) talib.DEMA ((वास्तविक में, optInTimePeriod)
..inRealपैरामीटर का उपयोग के-लाइन डेटा को निर्दिष्ट करने के लिए किया जाता है।
वास्तविक
सच
{@struct/Record Record} संरचना सरणी, संख्यात्मक सरणी
दoptInTimePeriodपैरामीटर अवधि सेट करने के लिए प्रयोग किया जाता है, डिफ़ॉल्ट मान 30 है।
optInTimeपीरियड
झूठी
संख्या
function main() {
var records = exchange.GetRecords()
var ret = talib.DEMA(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.DEMA(records.Close)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.DEMA(records);
Log(ret);
}
..DEMA()कार्य तालिब पुस्तकालय प्रलेखन में वर्णित हैःDEMA(Records[Close],Time Period = 30) = Array(outReal)
..talib.EMA()फलन का उपयोग गणना के लिए किया जाता हैघातीय चलती औसत.
रिटर्न मूल्यtalib.EMA()समारोह एक एक आयामी सरणी है।
सरणी
तालिब.ई.एम.ए. (इंरियल) talib.EMA ((inReal, optInTimePeriod)
..inRealपैरामीटर का उपयोग के-लाइन डेटा को निर्दिष्ट करने के लिए किया जाता है।
वास्तविक
सच
{@struct/Record Record} संरचना सरणी, संख्यात्मक सरणी
दoptInTimePeriodपैरामीटर अवधि सेट करने के लिए प्रयोग किया जाता है, डिफ़ॉल्ट मान 30 है।
optInTimeपीरियड
झूठी
संख्या
function main() {
var records = exchange.GetRecords()
var ret = talib.EMA(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.EMA(records.Close)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.EMA(records);
Log(ret);
}
..EMA()कार्य तालिब पुस्तकालय प्रलेखन में वर्णित हैःEMA(Records[Close],Time Period = 30) = Array(outReal)
..talib.HT_TRENDLINE()फलन का उपयोग गणना के लिए किया जाता हैहिल्बर्ट परिवर्तन - तत्काल प्रवृत्ति रेखा (हिल्बर्ट परिवर्तन, तत्काल प्रवृत्ति).
रिटर्न मूल्यtalib.HT_TRENDLINE()कार्य हैः एक आयामी सरणी।
सरणी
talib.HT_TRENDLINE ((inReal)
..inRealपैरामीटर का उपयोग के-लाइन डेटा को निर्दिष्ट करने के लिए किया जाता है।
वास्तविक
सच
{@struct/Record Record} संरचना सरणी, संख्यात्मक सरणी
function main() {
var records = exchange.GetRecords()
var ret = talib.HT_TRENDLINE(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.HT_TRENDLINE(records.Close)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.HT_TRENDLINE(records);
Log(ret);
}
..HT_TRENDLINE()कार्य तालिब पुस्तकालय प्रलेखन में वर्णित हैःHT_TRENDLINE(Records[Close]) = Array(outReal)
..talib.KAMA()फलन का उपयोग गणना के लिए किया जाता हैकौफमैन अनुकूलनशील चलती औसत.
रिटर्न मूल्यtalib.KAMA()कार्य हैः एक आयामी सरणी।
सरणी
तालिब.कामा ((इंरियल) talib.KAMA ((inReal, optInTimePeriod)
..inRealपैरामीटर का उपयोग के-लाइन डेटा को निर्दिष्ट करने के लिए किया जाता है।
वास्तविक
सच
{@struct/Record Record} संरचना सरणी, संख्यात्मक सरणी
दoptInTimePeriodपैरामीटर अवधि सेट करने के लिए प्रयोग किया जाता है, डिफ़ॉल्ट मान 30 है।
optInTimeपीरियड
झूठी
संख्या
function main() {
var records = exchange.GetRecords()
var ret = talib.KAMA(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.KAMA(records.Close)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.KAMA(records);
Log(ret);
}
..KAMA()कार्य तालिब पुस्तकालय प्रलेखन में वर्णित हैःKAMA(Records[Close],Time Period = 30) = Array(outReal)
..talib.MA()फलन का उपयोग गणना के लिए किया जाता हैचलती औसत.
रिटर्न मूल्यtalib.MA()कार्य हैः एक आयामी सरणी।
सरणी
talib.MA(असत्य)talib.MA(inReal, optInTimePeriod)talib.MA(inReal, optInTimePeriod, optInMAType)
..inRealपैरामीटर का उपयोग के-लाइन डेटा को निर्दिष्ट करने के लिए किया जाता है।
वास्तविक
सच
{@struct/Record Record} संरचना सरणी, संख्यात्मक सरणी
दoptInTimePeriodपैरामीटर अवधि सेट करने के लिए प्रयोग किया जाता है, डिफ़ॉल्ट मान 30 है।
optInTimeपीरियड
झूठी
संख्या
दoptInMATypeपैरामीटर औसत प्रकार सेट करने के लिए प्रयोग किया जाता है, डिफ़ॉल्ट मान 0 है।
optInMAType
झूठी
संख्या
function main() {
var records = exchange.GetRecords()
var ret = talib.MA(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.MA(records.Close)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.MA(records);
Log(ret);
}
..MA()कार्य तालिब पुस्तकालय प्रलेखन में वर्णित हैःMA(Records[Close],Time Period = 30,MA Type = 0) = Array(outReal)
..talib.MAMA()फलन का उपयोग गणना के लिए किया जाता हैएमईएसए अनुकूली चलती औसत.
रिटर्न मूल्यtalib.MAMA()कार्य हैः एक दो आयामी सरणी।
सरणी
तालिब.मामा ((इंरियल) तालिब.मामा ((इंरियल, ऑप्ट इन फास्टलिमिट) talib.MAMA ((inReal, optInFastLimit, optInSlowLimit)
..inRealपैरामीटर का उपयोग के-लाइन डेटा को निर्दिष्ट करने के लिए किया जाता है।
वास्तविक
सच
{@struct/Record Record} संरचना सरणी, संख्यात्मक सरणी
दoptInFastLimitपैरामीटर तेजी से सीमा निर्धारित करने के लिए प्रयोग किया जाता है, डिफ़ॉल्ट मान 0.5 है।
optInFastLimit
झूठी
संख्या
दoptInSlowLimitपैरामीटर धीमी सीमा सेट करने के लिए प्रयोग किया जाता है, डिफ़ॉल्ट मान 0.05 है।
optInSlowLimit
झूठी
संख्या
function main() {
var records = exchange.GetRecords()
var ret = talib.MAMA(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.MAMA(records.Close)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.MAMA(records);
Log(ret);
}
..MAMA()कार्य तालिब पुस्तकालय प्रलेखन में वर्णित हैःMAMA(Records[Close],Fast Limit = 0.5,Slow Limit = 0.05) = [Array(outMAMA),Array(outFAMA)]
..talib.MIDPOINT()फलन का उपयोग गणना के लिए किया जाता हैअवधि में मध्य बिंदु (मध्य बिंदु).
रिटर्न मूल्यtalib.MIDPOINT()समारोह एक एक आयामी सरणी है।
सरणी
तालिब.मिडपॉइंट ((इनरियल) talib.MIDPOINT ((inReal, optInTimePeriod)
..inRealपैरामीटर का उपयोग के-लाइन डेटा को निर्दिष्ट करने के लिए किया जाता है।
वास्तविक
सच
{@struct/Record Record} संरचना सरणी, संख्यात्मक सरणी
दoptInTimePeriodपैरामीटर अवधि सेट करने के लिए प्रयोग किया जाता है, डिफ़ॉल्ट मान 14 है।
optInTimeपीरियड
झूठी
संख्या
function main() {
var records = exchange.GetRecords()
var ret = talib.MIDPOINT(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.MIDPOINT(records.Close)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.MIDPOINT(records);
Log(ret);
}
..MIDPOINT()कार्य तालिब पुस्तकालय प्रलेखन में वर्णित हैःMIDPOINT(Records[Close],Time Period = 14) = Array(outReal)
..talib.MIDPRICE()फलन का उपयोग गणना के लिए किया जाता हैअवधि में मध्य बिंदु मूल्य (मध्य बिंदु मूल्य).
रिटर्न मूल्यtalib.MIDPRICE()समारोह एक एक आयामी सरणी है।
सरणी
talib.MIDPRICE ((इनप्राइसएचएल) talib.MIDPRICE ((InPriceHL, optInTimePeriod)
..inPriceHLपैरामीटर का उपयोग के-लाइन डेटा को निर्दिष्ट करने के लिए किया जाता है।
inPriceHL
सच
{@struct/Record Record} संरचना सरणी
दoptInTimePeriodपैरामीटर अवधि सेट करने के लिए प्रयोग किया जाता है, डिफ़ॉल्ट मान 14 है।
optInTimeपीरियड
झूठी
संख्या
function main() {
var records = exchange.GetRecords()
var ret = talib.MIDPRICE(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.MIDPRICE(records.High, records.Low)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.MIDPRICE(records);
Log(ret);
}
..MIDPRICE()कार्य तालिब पुस्तकालय प्रलेखन में वर्णित हैःMIDPRICE(Records[High,Low],Time Period = 14) = Array(outReal)
..talib.SAR()फलन का उपयोग गणना के लिए किया जाता हैपैराबोलिक एसएआर.
रिटर्न मूल्यtalib.SAR()कार्य हैः एक आयामी सरणी।
सरणी
talib.SAR ((inPriceHL) talib.SAR ((inPriceHL, optInAcceleration) talib.SAR ((inPriceHL, optInAcceleration, optInMaximum)
..inPriceHLपैरामीटर का उपयोग के-लाइन डेटा को निर्दिष्ट करने के लिए किया जाता है।
inPriceHL
सच
{@struct/Record Record} संरचना सरणी
दoptInAccelerationपैरामीटर त्वरण कारक सेट करने के लिए प्रयोग किया जाता है, डिफ़ॉल्ट मान 0.02 है।
ऑप्टइनएक्सेलेरेशन
झूठी
संख्या
दoptInMaximumपैरामीटर का उपयोग अधिकतम एफए सेट करने के लिए किया जाता है, डिफ़ॉल्ट मान 0.2 है।
optInMaximum
झूठी
संख्या
function main() {
var records = exchange.GetRecords()
var ret = talib.SAR(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.SAR(records.High, records.Low)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.SAR(records);
Log(ret);
}
..SAR()कार्य तालिब पुस्तकालय प्रलेखन में वर्णित हैःSAR(Records[High,Low],Acceleration Factor = 0.02,AF Maximum = 0.2) = Array(outReal)
..talib.SAREXT()फलन का उपयोग गणना के लिए किया जाता हैपैराबोलिक SAR - विस्तारित (बढ़ाया गया पैराबोलिक स्टीयरिंग).
रिटर्न मूल्यtalib.SAREXT()समारोह एक एक आयामी सरणी है।
सरणी
talib.SAREXT ((inPriceHL) talib.SAREXT ((inPriceHL, optInStartValue) talib.SAREXT ((inPriceHL, optInStartValue, optInOffsetOnReverse) talib.SAREXT ((inPriceHL, optInStartValue, optInOffsetOnReverse, optInAccelerationInitLong) talib.SAREXT ((inPriceHL, optInStartValue, optInOffsetOnReverse, optInAccelerationInitLong, optInAccelerationLong) talib.SAREXT ((inPriceHL, optInStartValue, optInOffsetOnReverse, optInAccelerationInitLong, optInAccelerationLong, optInAccelerationMaxLong) talib.SAREXT ((inPriceHL, optInStartValue, optInOffsetOnReverse, optInAccelerationInitLong, optInAccelerationLong, optInAccelerationMaxLong, optInAccelerationInitShort) talib.SAREXT ((inPriceHL, optInStartValue, optInOffsetOnReverse, optInAccelerationInitLong, optInAccelerationLong, optInAccelerationMaxLong, optInAccelerationInitShort, optInAccelerationShort) talib.SAREXT ((inPriceHL, optInStartValue, optInOffsetOnReverse, optInAccelerationInitLong, optInAccelerationLong, optInAccelerationMaxLong, optInAccelerationInitShort, optInAccelerationShort, optInAccelerationMaxShort)
..inPriceHLपैरामीटर का उपयोग के-लाइन डेटा को निर्दिष्ट करने के लिए किया जाता है।
inPriceHL
सच
{@struct/Record Record} संरचना सरणी
दoptInStartValueपैरामीटर प्रारंभ मान सेट करने के लिए प्रयोग किया जाता है, डिफ़ॉल्ट मान 0 है।
optInStartValue का चयन करें
झूठी
संख्या
दoptInOffsetOnReverseपैरामीटर रिवर्स पर ऑफसेट सेट करने के लिए प्रयोग किया जाता है, डिफ़ॉल्ट मान 0 है।
optInOffsetOnReverse का चयन करें
झूठी
संख्या
दoptInAccelerationInitLongपैरामीटर AF Init Long सेट करने के लिए प्रयोग किया जाता है, डिफ़ॉल्ट मान 0.02 है।
optInAccelerationInitLong में
झूठी
संख्या
दoptInAccelerationLongपैरामीटर का उपयोग AF Long को सेट करने के लिए किया जाता है, डिफ़ॉल्ट मान 0.02 है।
optInAccelerationलंबी
झूठी
संख्या
दoptInAccelerationMaxLongपैरामीटर का उपयोग AF Max Long को सेट करने के लिए किया जाता है, डिफ़ॉल्ट मान 0.2 है।
optInAccelerationMaxLong
झूठी
संख्या
दoptInAccelerationInitShortपैरामीटर का उपयोग AF Init Short सेट करने के लिए किया जाता है, डिफ़ॉल्ट मान 0.02 है।
ऑप्टइनएक्सेलेरेशनइनइटशॉर्ट
झूठी
संख्या
दoptInAccelerationShortपैरामीटर का उपयोग AF शॉर्ट सेट करने के लिए किया जाता है, डिफ़ॉल्ट मान 0.02 है।
ऑप्टइनएक्सेलेरेशनशॉर्ट
झूठी
संख्या
दoptInAccelerationMaxShortपैरामीटर का उपयोग AF Max Short सेट करने के लिए किया जाता है, डिफ़ॉल्ट मान 0.2 है।
optInAccelerationMaxShort का चयन करें
झूठी
संख्या
function main() {
var records = exchange.GetRecords()
var ret = talib.SAREXT(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.SAREXT(records.High, records.Low)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.SAREXT(records);
Log(ret);
}
..SAREXT()कार्य तालिब पुस्तकालय प्रलेखन में वर्णित हैःSAREXT(Records[High,Low],Start Value = 0,Offset on Reverse = 0,AF Init Long = 0.02,AF Long = 0.02,AF Max Long = 0.2,AF Init Short = 0.02,AF Short = 0.02,AF Max Short = 0.2) = Array(outReal)
..talib.SMA()फलन की गणना करने के लिए प्रयोग किया जाता हैसरल चलती औसत.
रिटर्न मूल्यtalib.SMA()कार्य हैः एक आयामी सरणी।
सरणी
talib.SMA ((inReal) talib.SMA ((inReal, optInTimePeriod)
..inRealपैरामीटर का उपयोग के-लाइन डेटा को निर्दिष्ट करने के लिए किया जाता है।
वास्तविक
सच
{@struct/Record Record} संरचना सरणी, संख्यात्मक सरणी
दoptInTimePeriodपैरामीटर अवधि सेट करने के लिए प्रयोग किया जाता है, डिफ़ॉल्ट मान 30 है।
optInTimeपीरियड
झूठी
संख्या
function main() {
var records = exchange.GetRecords()
var ret = talib.SMA(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.SMA(records.Close)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.SMA(records);
Log(ret);
}
..SMA()कार्य तालिब पुस्तकालय प्रलेखन में वर्णित हैःSMA(Records[Close],Time Period = 30) = Array(outReal)
..talib.T3()फलन का उपयोग गणना के लिए किया जाता हैट्रिपल एक्सपोनेंशियल मूविंग एवरेज (T3) (ट्रिपल एक्सपोनेंशियल मूविंग एवरेज).
रिटर्न मूल्यtalib.T3()समारोह एक एक आयामी सरणी है।
सरणी
talib.T3 ((inReal) talib.T3 ((inReal, optInTimePeriod) talib.T3 ((inReal, optInTimePeriod, optInVFactor)
..inRealपैरामीटर का उपयोग के-लाइन डेटा को निर्दिष्ट करने के लिए किया जाता है।
वास्तविक
सच
{@struct/Record Record} संरचना सरणी, संख्यात्मक सरणी
दoptInTimePeriodपैरामीटर अवधि सेट करने के लिए प्रयोग किया जाता है, डिफ़ॉल्ट मान 5 है।
optInTimeपीरियड
झूठी
संख्या
दoptInVFactorपैरामीटर वॉल्यूम कारक सेट करने के लिए प्रयोग किया जाता है, डिफ़ॉल्ट मान 0.7 है।
optInVFactor
झूठी
संख्या
function main() {
var records = exchange.GetRecords()
var ret = talib.T3(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.T3(records.Close)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.T3(records);
Log(ret);
}
..T3()कार्य तालिब पुस्तकालय प्रलेखन में वर्णित हैःT3(Records[Close],Time Period = 5,Volume Factor = 0.7) = Array(outReal)
..talib.TEMA()फलन की गणना करने के लिए प्रयोग किया जाता हैत्रिगुट घातीय चलती औसत.
रिटर्न मूल्यtalib.TEMA()समारोह एक एक आयामी सरणी है।
सरणी
talib.TEMA ((inReal) talib.TEMA ((inReal, optInTimePeriod)
..inRealपैरामीटर का उपयोग के-लाइन डेटा को निर्दिष्ट करने के लिए किया जाता है।
वास्तविक
सच
{@struct/Record Record} संरचना सरणी, संख्यात्मक सरणी
दoptInTimePeriodपैरामीटर अवधि सेट करने के लिए प्रयोग किया जाता है, डिफ़ॉल्ट मान 30 है।
optInTimeपीरियड
झूठी
संख्या
function main() {
var records = exchange.GetRecords()
var ret = talib.TEMA(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.TEMA(records.Close)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.TEMA(records);
Log(ret);
}
..TEMA()कार्य तालिब पुस्तकालय प्रलेखन में वर्णित हैःTEMA(Records[Close],Time Period = 30) = Array(outReal)
..talib.TRIMA()फलन का उपयोग गणना के लिए किया जाता हैत्रिकोणीय चलती औसत (त्रि-अभिमानात्मक चलती औसत).
रिटर्न मूल्यtalib.TRIMA()समारोह एक एक आयामी सरणी है।
सरणी
talib.TRIMA ((inReal) talib.TRIMA ((inReal, optInTimePeriod)
..inRealपैरामीटर का उपयोग के-लाइन डेटा को निर्दिष्ट करने के लिए किया जाता है।
वास्तविक
सच
{@struct/Record Record} संरचना सरणी, संख्यात्मक सरणी
दoptInTimePeriodपैरामीटर अवधि सेट करने के लिए प्रयोग किया जाता है, डिफ़ॉल्ट मान 30 है।
optInTimeपीरियड
झूठी
संख्या
function main() {
var records = exchange.GetRecords()
var ret = talib.TRIMA(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.TRIMA(records.Close)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.TRIMA(records);
Log(ret);
}
..TRIMA()कार्य तालिब पुस्तकालय प्रलेखन में वर्णित हैःTRIMA(Records[Close],Time Period = 30) = Array(outReal)
..talib.WMA()फलन का उपयोग गणना के लिए किया जाता हैभारित चलती औसत (WMA).
रिटर्न मूल्यtalib.WMA()समारोह एक एक आयामी सरणी है।
सरणी
talib.WMA ((inReal) talib.WMA ((inReal, optInTimePeriod)
..inRealपैरामीटर का उपयोग के-लाइन डेटा को निर्दिष्ट करने के लिए किया जाता है।
वास्तविक
सच
{@struct/Record Record} संरचना सरणी, संख्यात्मक सरणी
दoptInTimePeriodपैरामीटर अवधि सेट करने के लिए प्रयोग किया जाता है, डिफ़ॉल्ट मान 30 है।
optInTimeपीरियड
झूठी
संख्या
function main() {
var records = exchange.GetRecords()
var ret = talib.WMA(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.WMA(records.Close)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.WMA(records);
Log(ret);
}
..WMA()कार्य तालिब पुस्तकालय प्रलेखन में वर्णित हैःWMA(Records[Close],Time Period = 30) = Array(outReal)
..talib.LINEARREG()फलन की गणना करने के लिए प्रयोग किया जाता हैरैखिक प्रतिगमन.
रिटर्न मूल्यtalib.LINEARREG()समारोह एक एक आयामी सरणी है।
सरणी
talib.LINEARREG ((inReal) talib.LINEARREG ((वास्तविक में, समय अवधि में चुनें)
..inRealपैरामीटर का उपयोग के-लाइन डेटा को निर्दिष्ट करने के लिए किया जाता है।
वास्तविक
सच
{@struct/Record Record} संरचना सरणी, संख्यात्मक सरणी
दoptInTimePeriodपैरामीटर अवधि सेट करने के लिए प्रयोग किया जाता है, डिफ़ॉल्ट मान 14 है।
optInTimeपीरियड
झूठी
संख्या
function main() {
var records = exchange.GetRecords()
var ret = talib.LINEARREG(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.LINEARREG(records.Close)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.LINEARREG(records);
Log(ret);
}
..LINEARREG()कार्य तालिब पुस्तकालय प्रलेखन में वर्णित हैःLINEARREG(Records[Close],Time Period = 14) = Array(outReal)
..talib.LINEARREG_ANGLE()फलन का उपयोग गणना के लिए किया जाता हैरैखिक प्रतिगमन कोण.
रिटर्न मूल्यtalib.LINEARREG_ANGLE()कार्य हैः एक आयामी सरणी।
सरणी
talib.LINEARREG_ANGLE ((inReal) talib.LINEARREG_ANGLE ((वास्तविक में, समय अवधि में चुनें)
..inRealपैरामीटर का उपयोग के-लाइन डेटा को निर्दिष्ट करने के लिए किया जाता है।
वास्तविक
सच
{@struct/Record Record} संरचना सरणी, संख्यात्मक सरणी
दoptInTimePeriodपैरामीटर अवधि सेट करने के लिए प्रयोग किया जाता है, डिफ़ॉल्ट मान 14 है।
optInTimeपीरियड
झूठी
संख्या
function main() {
var records = exchange.GetRecords()
var ret = talib.LINEARREG_ANGLE(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.LINEARREG_ANGLE(records.Close)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.LINEARREG_ANGLE(records);
Log(ret);
}
..LINEARREG_ANGLE()कार्य तालिब पुस्तकालय प्रलेखन में वर्णित हैःLINEARREG_ANGLE(Records[Close],Time Period = 14) = Array(outReal)
..talib.LINEARREG_INTERCEPT()फलन का उपयोग गणना के लिए किया जाता हैरैखिक प्रतिगमन इंटरसेप्ट.
रिटर्न मूल्यtalib.LINEARREG_INTERCEPT()कार्य हैः एक आयामी सरणी।
सरणी
talib.LINEARREG_INTERCEPT ((inReal) talib.LINEARREG_INTERCEPT ((वास्तविक में, समय अवधि में चुनें)
..inRealपैरामीटर का उपयोग के-लाइन डेटा को निर्दिष्ट करने के लिए किया जाता है।
वास्तविक
सच
{@struct/Record Record} संरचना सरणी, संख्यात्मक सरणी
दoptInTimePeriodपैरामीटर अवधि सेट करने के लिए प्रयोग किया जाता है, डिफ़ॉल्ट मान 14 है।
optInTimeपीरियड
झूठी
संख्या
function main() {
var records = exchange.GetRecords()
var ret = talib.LINEARREG_INTERCEPT(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.LINEARREG_INTERCEPT(records.Close)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.LINEARREG_INTERCEPT(records);
Log(ret);
}
..LINEARREG_INTERCEPT()कार्य तालिब पुस्तकालय प्रलेखन में वर्णित हैःLINEARREG_INTERCEPT(Records[Close],Time Period = 14) = Array(outReal)
..talib.LINEARREG_SLOPE()फलन का उपयोग गणना के लिए किया जाता हैरैखिक प्रतिगमन ढलान.
रिटर्न मूल्यtalib.LINEARREG_SLOPE()कार्य हैः एक आयामी सरणी।
सरणी
talib.LINEARREG_SLOPE ((inReal) talib.LINEARREG_SLOPE ((inReal, optInTimePeriod)
..inRealपैरामीटर का उपयोग के-लाइन डेटा को निर्दिष्ट करने के लिए किया जाता है।
वास्तविक
सच
{@struct/Record Record} संरचना सरणी, संख्यात्मक सरणी
दoptInTimePeriodपैरामीटर अवधि सेट करने के लिए प्रयोग किया जाता है, डिफ़ॉल्ट मान 14 है।
optInTimeपीरियड
झूठी
संख्या
function main() {
var records = exchange.GetRecords()
var ret = talib.LINEARREG_SLOPE(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.LINEARREG_SLOPE(records.Close)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.LINEARREG_SLOPE(records);
Log(ret);
}
..LINEARREG_SLOPE()कार्य तालिब पुस्तकालय प्रलेखन में वर्णित हैःLINEARREG_SLOPE(Records[Close],Time Period = 14) = Array(outReal)
..talib.STDDEV()फलन की गणना करने के लिए प्रयोग किया जाता हैमानक विचलन.
रिटर्न मूल्यtalib.STDDEV()कार्य हैः एक आयामी सरणी।
सरणी
talib.STDDEV ((inReal) talib.STDDEV ((inReal, optInTimePeriod) talib.STDDEV ((inReal, optInTimePeriod, optInNbDev)
..inRealपैरामीटर का उपयोग के-लाइन डेटा को निर्दिष्ट करने के लिए किया जाता है।
वास्तविक
सच
{@struct/Record Record} संरचना सरणी, संख्यात्मक सरणी
दoptInTimePeriodपैरामीटर अवधि सेट करने के लिए प्रयोग किया जाता है, डिफ़ॉल्ट मान 5 है।
optInTimeपीरियड
झूठी
संख्या
दoptInNbDevपैरामीटर विचलन सेट करने के लिए प्रयोग किया जाता है, डिफ़ॉल्ट मान 1 है।
optInNbDev
झूठी
संख्या
function main() {
var records = exchange.GetRecords()
var ret = talib.STDDEV(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.STDDEV(records.Close)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.STDDEV(records);
Log(ret);
}
..STDDEV()कार्य तालिब पुस्तकालय प्रलेखन में वर्णित हैःSTDDEV(Records[Close],Time Period = 5,Deviations = 1) = Array(outReal)
..talib.TSF()फलन की गणना करने के लिए प्रयोग किया जाता हैसमय श्रृंखला पूर्वानुमान.
रिटर्न मूल्यtalib.TSF()समारोह एक एक आयामी सरणी है।
सरणी
talib.TSF ((inReal) talib.TSF ((inReal, optInTimePeriod)
..inRealपैरामीटर का उपयोग के-लाइन डेटा को निर्दिष्ट करने के लिए किया जाता है।
वास्तविक
सच
{@struct/Record Record} संरचना सरणी, संख्यात्मक सरणी
दoptInTimePeriodपैरामीटर अवधि सेट करने के लिए प्रयोग किया जाता है, डिफ़ॉल्ट मान 14 है।
optInTimeपीरियड
झूठी
संख्या
function main() {
var records = exchange.GetRecords()
var ret = talib.TSF(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.TSF(records.Close)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.TSF(records);
Log(ret);
}
..TSF()कार्य तालिब पुस्तकालय प्रलेखन में वर्णित हैःTSF(Records[Close],Time Period = 14) = Array(outReal)
..talib.VAR()फलन की गणना करने के लिए प्रयोग किया जाता हैभिन्नता.
रिटर्न मूल्यtalib.VAR()कार्य हैः एक आयामी सरणी।
सरणी
talib.VAR ((inReal) talib.VAR ((inReal, optInTimePeriod) talib.VAR ((inReal, optInTimePeriod, optInNbDev)
..inRealपैरामीटर का उपयोग के-लाइन डेटा को निर्दिष्ट करने के लिए किया जाता है।
वास्तविक
सच
{@struct/Record Record} संरचना सरणी, संख्यात्मक सरणी
दoptInTimePeriodपैरामीटर अवधि सेट करने के लिए प्रयोग किया जाता है, डिफ़ॉल्ट मान 5 है।
optInTimeपीरियड
झूठी
संख्या
दoptInNbDevपैरामीटर विचलन सेट करने के लिए प्रयोग किया जाता है, डिफ़ॉल्ट मान 1 है।
optInNbDev
झूठी
संख्या
function main() {
var records = exchange.GetRecords()
var ret = talib.VAR(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.VAR(records.Close)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.VAR(records);
Log(ret);
}
..VAR()कार्य तालिब पुस्तकालय प्रलेखन में वर्णित हैःVAR(Records[Close],Time Period = 5,Deviations = 1) = Array(outReal)
..talib.ADX()फलन का उपयोग गणना के लिए किया जाता हैऔसत दिशात्मक आंदोलन सूचकांक.
रिटर्न मूल्यtalib.ADX()समारोह एक एक आयामी सरणी है।
सरणी
talib.ADX ((inPriceHLC) talib.ADX ((inPriceHLC, optInTimePeriod)
..inPriceHLCपैरामीटर का उपयोग के-लाइन डेटा को निर्दिष्ट करने के लिए किया जाता है।
inPriceHLC
सच
{@struct/Record Record} संरचना सरणी
दoptInTimePeriodपैरामीटर अवधि सेट करने के लिए प्रयोग किया जाता है, डिफ़ॉल्ट मान 14 है।
optInTimeपीरियड
झूठी
संख्या
function main() {
var records = exchange.GetRecords()
var ret = talib.ADX(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.ADX(records.High, records.Low, records.Close)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.ADX(records);
Log(ret);
}
..ADX()कार्य तालिब पुस्तकालय प्रलेखन में वर्णित हैःADX(Records[High,Low,Close],Time Period = 14) = Array(outReal)
..talib.ADXR()फलन का उपयोग गणना के लिए किया जाता हैऔसत दिशात्मक आंदोलन सूचकांक रेटिंग (मूल्यांकन सूचकांक).
रिटर्न मूल्यtalib.ADXR()समारोह एक एक आयामी सरणी है।
सरणी
talib.ADXR ((inPriceHLC) talib.ADXR ((inPriceHLC, optInTimePeriod)
..inPriceHLCपैरामीटर का उपयोग के-लाइन डेटा को निर्दिष्ट करने के लिए किया जाता है।
inPriceHLC
सच
{@struct/Record Record} संरचना सरणी
दoptInTimePeriodपैरामीटर अवधि सेट करने के लिए प्रयोग किया जाता है, डिफ़ॉल्ट मान 14 है।
optInTimeपीरियड
झूठी
संख्या
function main() {
var records = exchange.GetRecords()
var ret = talib.ADXR(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.ADXR(records.High, records.Low, records.Close)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.ADXR(records);
Log(ret);
}
..ADXR()कार्य तालिब पुस्तकालय प्रलेखन में वर्णित हैःADXR(Records[High,Low,Close],Time Period = 14) = Array(outReal)
..talib.APO()फलन का उपयोग गणना के लिए किया जाता हैनिरपेक्ष मूल्य दोलनकर्ता.
रिटर्न मूल्यtalib.APO()कार्य हैः एक आयामी सरणी।
सरणी
talib.APO ((inReal) talib.APO ((inReal, optInFastPeriod) talib.APO ((inReal, optInFastPeriod, optInSlowPeriod) talib.APO ((inReal, optInFastPeriod, optInSlowPeriod, optInMAType)
..inRealपैरामीटर का उपयोग के-लाइन डेटा को निर्दिष्ट करने के लिए किया जाता है।
वास्तविक
सच
{@struct/Record Record} संरचना सरणी, संख्यात्मक सरणी
दoptInFastPeriodतेजी से अवधि सेट करने के लिए पैरामीटर का उपयोग किया जाता है, डिफ़ॉल्ट मान 12 है।
optInFastPeriod
झूठी
संख्या
दoptInSlowPeriodपैरामीटर धीमी अवधि सेट करने के लिए प्रयोग किया जाता है, डिफ़ॉल्ट मान 26 है।
optInSlowPeriod
झूठी
संख्या
दoptInMATypeपैरामीटर औसत प्रकार सेट करने के लिए प्रयोग किया जाता है, डिफ़ॉल्ट मान 0 है।
optInMAType
झूठी
संख्या
function main() {
var records = exchange.GetRecords()
var ret = talib.APO(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.APO(records.Close)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.APO(records);
Log(ret);
}
..APO()कार्य तालिब पुस्तकालय प्रलेखन में वर्णित हैःAPO(Records[Close],Fast Period = 12,Slow Period = 26,MA Type = 0) = Array(outReal)
..talib.AROON()फलन का उपयोग गणना के लिए किया जाता हैएरोन (एरोन संकेतक).
रिटर्न मूल्यtalib.AROON()समारोह एक दो आयामी सरणी है।
सरणी
talib.AROON ((inPriceHL) talib.AROON ((InPriceHL, optInTimePeriod)
..inPriceHLपैरामीटर का उपयोग के-लाइन डेटा को निर्दिष्ट करने के लिए किया जाता है।
inPriceHL
सच
{@struct/Record Record} संरचना सरणी
दoptInTimePeriodपैरामीटर अवधि सेट करने के लिए प्रयोग किया जाता है, डिफ़ॉल्ट मान 14 है।
optInTimeपीरियड
झूठी
संख्या
function main() {
var records = exchange.GetRecords()
var ret = talib.AROON(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.AROON(records.High, records.Low)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.AROON(records);
Log(ret);
}
..AROON()कार्य तालिब पुस्तकालय प्रलेखन में वर्णित हैःAROON(Records[High,Low],Time Period = 14) = [Array(outAroonDown),Array(outAroonUp)]
..talib.AROONOSC()फलन का उपयोग गणना के लिए किया जाता हैएरून ऑसिलेटर.
रिटर्न मूल्यtalib.AROONOSC()कार्य हैः एक आयामी सरणी।
सरणी
talib.AROONOSC ((inPriceHL) talib.AROONOSC ((InPriceHL, optInTimePeriod)
..inPriceHLपैरामीटर का उपयोग के-लाइन डेटा को निर्दिष्ट करने के लिए किया जाता है।
inPriceHL
सच
{@struct/Record Record} संरचना सरणी
दoptInTimePeriodपैरामीटर अवधि सेट करने के लिए प्रयोग किया जाता है, डिफ़ॉल्ट मान 14 है।
optInTimeपीरियड
झूठी
संख्या
function main() {
var records = exchange.GetRecords()
var ret = talib.AROONOSC(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.AROONOSC(records.High, records.Low)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.AROONOSC(records);
Log(ret);
}
..AROONOSC()कार्य तालिब पुस्तकालय प्रलेखन में वर्णित हैःAROONOSC(Records[High,Low],Time Period = 14) = Array(outReal)
..talib.BOP()फलन का उपयोग गणना के लिए किया जाता हैशक्ति का संतुलन.
रिटर्न मूल्यtalib.BOP()समारोह एक एक आयामी सरणी है।
सरणी
talib.BOP ((inPriceOHLC)
..inPriceOHLCपैरामीटर का उपयोग के-लाइन डेटा को निर्दिष्ट करने के लिए किया जाता है।
inPriceOHLC
सच
{@struct/Record Record} संरचना सरणी
function main() {
var records = exchange.GetRecords()
var ret = talib.BOP(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.BOP(records.Open, records.High, records.Low, records.Close)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.BOP(records);
Log(ret);
}
..BOP()कार्य तालिब पुस्तकालय प्रलेखन में वर्णित हैःBOP(Records[Open,High,Low,Close]) = Array(outReal)
..talib.CCI()फलन का उपयोग गणना के लिए किया जाता हैकमोडिटी चैनल इंडेक्स (होमेओपैथिक संकेतक).
रिटर्न मूल्यtalib.CCI()समारोह एक एक आयामी सरणी है।
सरणी
talib.CCI ((inPriceHLC) talib.CCI ((inPriceHLC, optInTimePeriod)
..inPriceHLCपैरामीटर का उपयोग के-लाइन डेटा को निर्दिष्ट करने के लिए किया जाता है।
inPriceHLC
सच
{@struct/Record Record} संरचना सरणी
दoptInTimePeriodपैरामीटर अवधि सेट करने के लिए प्रयोग किया जाता है, डिफ़ॉल्ट मान 14 है।
optInTimeपीरियड
झूठी
संख्या
function main() {
var records = exchange.GetRecords()
var ret = talib.CCI(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.CCI(records.High, records.Low, records.Close)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.CCI(records);
Log(ret);
}
..CCI()कार्य तालिब पुस्तकालय प्रलेखन में वर्णित हैःCCI(Records[High,Low,Close],Time Period = 14) = Array(outReal)
..talib.CMO()फलन का उपयोग गणना के लिए किया जाता हैचैंडे मोमेंटम ऑसिलेटर (CMO).
रिटर्न मूल्यtalib.CMO()कार्य हैः एक आयामी सरणी।
सरणी
talib.CMO ((इनरियल) talib.CMO ((inReal, optInTimePeriod)
..inRealपैरामीटर का उपयोग के-लाइन डेटा को निर्दिष्ट करने के लिए किया जाता है।
वास्तविक
सच
{@struct/Record Record} संरचना सरणी, संख्यात्मक सरणी
दoptInTimePeriodपैरामीटर अवधि सेट करने के लिए प्रयोग किया जाता है, डिफ़ॉल्ट मान 14 है।
optInTimeपीरियड
झूठी
संख्या
function main() {
var records = exchange.GetRecords()
var ret = talib.CMO(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.CMO(records.Close)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.CMO(records);
Log(ret);
}
..CMO()कार्य तालिब पुस्तकालय प्रलेखन में वर्णित हैःCMO(Records[Close],Time Period = 14) = Array(outReal)
..talib.DX()फलन का उपयोग गणना के लिए किया जाता हैदिशागत आंदोलन सूचकांक.
रिटर्न मूल्यtalib.DX()कार्य हैः एक आयामी सरणी।
सरणी
talib.DX ((inPriceHLC) talib.DX ((inPriceHLC, optInTimePeriod)
..inPriceHLCपैरामीटर का उपयोग के-लाइन डेटा को निर्दिष्ट करने के लिए किया जाता है।
inPriceHLC
सच
{@struct/Record Record} संरचना सरणी
दoptInTimePeriodपैरामीटर अवधि सेट करने के लिए प्रयोग किया जाता है, डिफ़ॉल्ट मान 14 है।
optInTimeपीरियड
झूठी
संख्या
function main() {
var records = exchange.GetRecords()
var ret = talib.DX(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.DX(records.High, records.Low, records.Close)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.DX(records);
Log(ret);
}
..DX()कार्य तालिब पुस्तकालय प्रलेखन में वर्णित हैःDX(Records[High,Low,Close],Time Period = 14) = Array(outReal)
..talib.MACD()फलन की गणना करने के लिए प्रयोग किया जाता हैचलती औसत अभिसरण/विचलन (अभिमानात्मक रूप से समतल चलती औसत).
रिटर्न मूल्यtalib.MACD()कार्य हैः एक दो आयामी सरणी।
सरणी
talib.MACD ((inReal) talib.MACD ((inReal, optInFastPeriod) talib.MACD ((inReal, optInFastPeriod, optInSlowPeriod) talib.MACD ((inReal, optInFastPeriod, optInSlowPeriod, optInSignalPeriod)
..inRealपैरामीटर का उपयोग के-लाइन डेटा को निर्दिष्ट करने के लिए किया जाता है।
वास्तविक
सच
{@struct/Record Record} संरचना सरणी, संख्यात्मक सरणी
दoptInFastPeriodतेजी से अवधि सेट करने के लिए पैरामीटर का उपयोग किया जाता है, डिफ़ॉल्ट मान 12 है।
optInFastPeriod
झूठी
संख्या
दoptInSlowPeriodपैरामीटर धीमी अवधि सेट करने के लिए प्रयोग किया जाता है, डिफ़ॉल्ट मान 26 है।
optInSlowPeriod
झूठी
संख्या
दoptInSignalPeriodपैरामीटर संकेत अवधि सेट करने के लिए प्रयोग किया जाता है, डिफ़ॉल्ट मान 9 है।
सिग्नल अवधि में
झूठी
संख्या
function main() {
var records = exchange.GetRecords()
var ret = talib.MACD(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.MACD(records.Close)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.MACD(records);
Log(ret);
}
..MACD()कार्य तालिब पुस्तकालय प्रलेखन में वर्णित हैःMACD(Records[Close],Fast Period = 12,Slow Period = 26,Signal Period = 9) = [Array(outMACD),Array(outMACDSignal),Array(outMACDHist)]
..talib.MACDEXT()फलन की गणना करने के लिए प्रयोग किया जाता हैनियंत्रण योग्य एमए प्रकार के साथ एमएसीडी.
रिटर्न मूल्यtalib.MACDEXT()समारोह एक दो आयामी सरणी है।
सरणी
talib.MACDEXT ((inReal) talib.MACDEXT ((inReal, optInFastPeriod) talib.MACDEXT ((inReal, optInFastPeriod, optInFastMAType) talib.MACDEXT ((inReal, optInFastPeriod, optInFastMAType, optInSlowPeriod) talib.MACDEXT ((inReal, optInFastPeriod, optInFastMAType, optInSlowPeriod, optInSlowMAType) talib.MACDEXT ((inReal, optInFastPeriod, optInFastMAType, optInSlowPeriod, optInSlowMAType, optInSignalPeriod) talib.MACDEXT ((inReal, optInFastPeriod, optInFastMAType, optInSlowPeriod, optInSlowMAType, optInSignalPeriod, optInSignalMAType)
..inRealपैरामीटर का उपयोग के-लाइन डेटा को निर्दिष्ट करने के लिए किया जाता है।
वास्तविक
सच
{@struct/Record Record} संरचना सरणी, संख्यात्मक सरणी
दoptInFastPeriodतेजी से अवधि सेट करने के लिए पैरामीटर का उपयोग किया जाता है, डिफ़ॉल्ट मान 12 है।
optInFastPeriod
झूठी
संख्या
दoptInFastMATypeपैरामीटर तेजी से औसत प्रकार सेट करने के लिए प्रयोग किया जाता है, डिफ़ॉल्ट मान 0 है।
optInFastMAType
झूठी
संख्या
दoptInSlowPeriodपैरामीटर धीमी अवधि सेट करने के लिए प्रयोग किया जाता है, डिफ़ॉल्ट मान 26 है।
optInSlowPeriod
झूठी
संख्या
दoptInSlowMATypeपैरामीटर धीमी औसत प्रकार सेट करने के लिए प्रयोग किया जाता है, डिफ़ॉल्ट मान 0 है।
optInSlowMAType
झूठी
संख्या
दoptInSignalPeriodपैरामीटर संकेत अवधि सेट करने के लिए प्रयोग किया जाता है, डिफ़ॉल्ट मान 9 है।
सिग्नल अवधि में
झूठी
संख्या
दoptInSignalMATypeपैरामीटर संकेत औसत प्रकार सेट करने के लिए प्रयोग किया जाता है, डिफ़ॉल्ट मान 0 है।
optInSignalMAType
झूठी
संख्या
function main() {
var records = exchange.GetRecords()
var ret = talib.MACDEXT(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.MACDEXT(records.Close)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.MACDEXT(records);
Log(ret);
}
..MACDEXT()कार्य तालिब पुस्तकालय प्रलेखन में वर्णित हैःMACDEXT(Records[Close],Fast Period = 12,Fast MA = 0,Slow Period = 26,Slow MA = 0,Signal Period = 9,Signal MA = 0) = [Array(outMACD),Array(outMACDSignal),Array(outMACDHist)]
..talib.MACDFIX()फलन की गणना करने के लिए प्रयोग किया जाता हैचलती औसत अभिसरण/विचलन फिक्स 12/26.
रिटर्न मूल्यtalib.MACDFIX()समारोह एक दो आयामी सरणी है।
सरणी
talib.MACDFIX ((inReal) talib.MACDFIX ((inReal, optInSignalPeriod)
..inRealपैरामीटर का उपयोग के-लाइन डेटा को निर्दिष्ट करने के लिए किया जाता है।
वास्तविक
सच
{@struct/Record Record} संरचना सरणी, संख्यात्मक सरणी
दoptInSignalPeriodपैरामीटर संकेत अवधि सेट करने के लिए प्रयोग किया जाता है, डिफ़ॉल्ट मान 9 है।
सिग्नल अवधि में
झूठी
संख्या
function main() {
var records = exchange.GetRecords()
var ret = talib.MACDFIX(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.MACDFIX(records.Close)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.MACDFIX(records);
Log(ret);
}
..MACDFIX()कार्य तालिब पुस्तकालय प्रलेखन में वर्णित हैःMACDFIX(Records[Close],Signal Period = 9) = [Array(outMACD),Array(outMACDSignal),Array(outMACDHist)]
..talib.MFI()फलन का उपयोग गणना के लिए किया जाता हैनकदी प्रवाह सूचकांक.
रिटर्न मूल्यtalib.MFI()समारोह एक एक आयामी सरणी है।
सरणी
talib.MFI ((inPriceHLCV) talib.MFI ((inPriceHLCV, optInTimePeriod)
..inPriceHLCVपैरामीटर का उपयोग के-लाइन डेटा को निर्दिष्ट करने के लिए किया जाता है।
inPriceHLCV
सच
{@struct/Record Record} संरचना सरणी
दoptInTimePeriodपैरामीटर अवधि सेट करने के लिए प्रयोग किया जाता है, डिफ़ॉल्ट मान 14 है।
optInTimeपीरियड
झूठी
संख्या
function main() {
var records = exchange.GetRecords()
var ret = talib.MFI(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.MFI(records.High, records.Low, records.Close, records.Volume)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.MFI(records);
Log(ret);
}
..MFI()कार्य तालिब पुस्तकालय प्रलेखन में वर्णित हैःMFI(Records[High,Low,Close,Volume],Time Period = 14) = Array(outReal)
..talib.MINUS_DI()फलन का उपयोग गणना के लिए किया जाता हैमाइनस दिशात्मक सूचक (नकारात्मक सूचक).
रिटर्न मूल्यtalib.MINUS_DI()समारोह एक एक आयामी सरणी है।
सरणी
talib.MINUS_DI ((inPriceHLC) talib.MINUS_DI ((PriceHLC में, optInTimePeriod में)
..inPriceHLCपैरामीटर का उपयोग के-लाइन डेटा को निर्दिष्ट करने के लिए किया जाता है।
inPriceHLC
सच
{@struct/Record Record} संरचना सरणी
दoptInTimePeriodपैरामीटर अवधि सेट करने के लिए प्रयोग किया जाता है, डिफ़ॉल्ट मान 14 है।
optInTimeपीरियड
झूठी
संख्या
function main() {
var records = exchange.GetRecords()
var ret = talib.MINUS_DI(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.MINUS_DI(records.High, records.Low, records.Close)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.MINUS_DI(records);
Log(ret);
}
..MINUS_DI()कार्य तालिब पुस्तकालय प्रलेखन में वर्णित हैःMINUS_DI(Records[High,Low,Close],Time Period = 14) = Array(outReal)
..talib.MINUS_DM()फलन का उपयोग गणना के लिए किया जाता हैमाइनस दिशात्मक आंदोलन (नकारात्मक प्रस्ताव).
रिटर्न मूल्यtalib.MINUS_DM()समारोह एक एक आयामी सरणी है।
सरणी
talib.MINUS_DM ((inPriceHL) talib.MINUS_DM ((InPriceHL, optInTimePeriod)
..inPriceHLपैरामीटर का उपयोग के-लाइन डेटा को निर्दिष्ट करने के लिए किया जाता है।
inPriceHL
सच
{@struct/Record Record} संरचना सरणी
दoptInTimePeriodपैरामीटर अवधि सेट करने के लिए प्रयोग किया जाता है, डिफ़ॉल्ट मान 14 है।
optInTimeपीरियड
झूठी
संख्या
function main() {
var records = exchange.GetRecords()
var ret = talib.MINUS_DM(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.MINUS_DM(records.High, records.Low)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.MINUS_DM(records);
Log(ret);
}
..MINUS_DM()कार्य तालिब पुस्तकालय प्रलेखन में वर्णित हैःMINUS_DM(Records[High,Low],Time Period = 14) = Array(outReal)
..talib.MOM()फलन की गणना करने के लिए प्रयोग किया जाता हैगतिशीलता.
रिटर्न मूल्यtalib.MOM()समारोह एक एक आयामी सरणी है।
सरणी
talib.MOM ((inReal) talib.MOM ((inReal, optInTimePeriod)
..inRealपैरामीटर का उपयोग के-लाइन डेटा को निर्दिष्ट करने के लिए किया जाता है।
वास्तविक
सच
{@struct/Record Record} संरचना सरणी, संख्यात्मक सरणी
दoptInTimePeriodपैरामीटर अवधि सेट करने के लिए प्रयोग किया जाता है, डिफ़ॉल्ट मान 10 है।
optInTimeपीरियड
झूठी
संख्या
function main() {
var records = exchange.GetRecords()
var ret = talib.MOM(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.MOM(records.Close)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.MOM(records);
Log(ret);
}
..MOM()कार्य तालिब पुस्तकालय प्रलेखन में वर्णित हैःMOM(Records[Close],Time Period = 10) = Array(outReal)
..talib.PLUS_DI()फलन का उपयोग गणना के लिए किया जाता हैप्लस दिशा संकेतक.
रिटर्न मूल्यtalib.PLUS_DI()कार्य हैः एक आयामी सरणी।
सरणी
talib.PLUS_DI ((inPriceHLC) talib.PLUS_DI ((inPriceHLC, optInTimePeriod)
..inPriceHLCपैरामीटर का उपयोग के-लाइन डेटा को निर्दिष्ट करने के लिए किया जाता है।
inPriceHLC
सच
{@struct/Record Record} संरचना सरणी
दoptInTimePeriodपैरामीटर अवधि सेट करने के लिए प्रयोग किया जाता है, डिफ़ॉल्ट मान 14 है।
optInTimeपीरियड
झूठी
संख्या
function main() {
var records = exchange.GetRecords()
var ret = talib.PLUS_DI(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.PLUS_DI(records.High, records.Low, records.Close)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.PLUS_DI(records);
Log(ret);
}
..PLUS_DI()कार्य तालिब पुस्तकालय प्रलेखन में वर्णित हैःPLUS_DI(Records[High,Low,Close],Time Period = 14) = Array(outReal)
..talib.PLUS_DM()फलन की गणना करने के लिए प्रयोग किया जाता हैप्लस दिशात्मक आंदोलन.
रिटर्न मूल्यtalib.PLUS_DM()समारोह एक एक आयामी सरणी है।
सरणी
talib.PLUS_DM ((inPriceHL) talib.PLUS_DM ((PriceHL में, optInTimePeriod में)
..inPriceHLपैरामीटर का उपयोग के-लाइन डेटा को निर्दिष्ट करने के लिए किया जाता है।
inPriceHL
सच
{@struct/Record Record} संरचना सरणी
दoptInTimePeriodपैरामीटर अवधि सेट करने के लिए प्रयोग किया जाता है, डिफ़ॉल्ट मान 14 है।
optInTimeपीरियड
झूठी
संख्या
function main() {
var records = exchange.GetRecords()
var ret = talib.PLUS_DM(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.PLUS_DM(records.High, records.Low)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.PLUS_DM(records);
Log(ret);
}
..PLUS_DM()कार्य तालिब पुस्तकालय प्रलेखन में वर्णित हैःPLUS_DM(Records[High,Low],Time Period = 14) = Array(outReal)
..talib.PPO()फलन का उपयोग गणना के लिए किया जाता हैप्रतिशत मूल्य थरथरानवाला.
रिटर्न मूल्यtalib.PPO()समारोह एक एक आयामी सरणी है।
सरणी
talib.PPO ((inReal) talib.PPO ((inReal, optInFastPeriod) talib.PPO ((inReal, optInFastPeriod, optInSlowPeriod) talib.PPO ((inReal, optInFastPeriod, optInSlowPeriod, optInMAType)
..inRealपैरामीटर का उपयोग के-लाइन डेटा को निर्दिष्ट करने के लिए किया जाता है।
वास्तविक
सच
{@struct/Record Record} संरचना सरणी, संख्यात्मक सरणी
दoptInFastPeriodतेजी से अवधि सेट करने के लिए पैरामीटर का उपयोग किया जाता है, डिफ़ॉल्ट मान 12 है।
optInFastPeriod
झूठी
संख्या
दoptInSlowPeriodपैरामीटर धीमी अवधि सेट करने के लिए प्रयोग किया जाता है, डिफ़ॉल्ट मान 26 है।
optInSlowPeriod
झूठी
संख्या
दoptInMATypeपैरामीटर औसत प्रकार सेट करने के लिए प्रयोग किया जाता है, डिफ़ॉल्ट मान 0 है।
optInMAType
झूठी
संख्या
function main() {
var records = exchange.GetRecords()
var ret = talib.PPO(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.PPO(records.Close)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.PPO(records);
Log(ret);
}
..PPO()कार्य तालिब पुस्तकालय प्रलेखन में वर्णित हैःPPO(Records[Close],Fast Period = 12,Slow Period = 26,MA Type = 0) = Array(outReal)
..talib.ROC()फलन की गणना करने के लिए प्रयोग किया जाता हैपरिवर्तन दर: ((मूल्य/पूर्व मूल्य) -1) *100 (परिवर्तन दर सूचक).
रिटर्न मूल्यtalib.ROC()समारोह एक एक आयामी सरणी है।
सरणी
talib.ROC ((inReal) talib.ROC ((inReal, optInTimePeriod)
..inRealपैरामीटर का उपयोग के-लाइन डेटा को निर्दिष्ट करने के लिए किया जाता है।
वास्तविक
सच
{@struct/Record Record} संरचना सरणी, संख्यात्मक सरणी
दoptInTimePeriodपैरामीटर अवधि सेट करने के लिए प्रयोग किया जाता है, डिफ़ॉल्ट मान 10 है।
optInTimeपीरियड
झूठी
संख्या
function main() {
var records = exchange.GetRecords()
var ret = talib.ROC(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.ROC(records.Close)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.ROC(records);
Log(ret);
}
..ROC()कार्य तालिब पुस्तकालय प्रलेखन में वर्णित हैःROC(Records[Close],Time Period = 10) = Array(outReal)
..talib.ROCP()फलन की गणना करने के लिए प्रयोग किया जाता हैपरिवर्तन दर प्रतिशतः (मूल्य-पूर्व-मूल्य) /पूर्व-मूल्य (मूल्य परिवर्तन दर).
रिटर्न मूल्यtalib.ROCP()कार्य हैः एक आयामी सरणी।
सरणी
talib.ROCP ((inReal) talib.ROCP ((inReal, optInTimePeriod)
..inRealपैरामीटर का उपयोग के-लाइन डेटा को निर्दिष्ट करने के लिए किया जाता है।
वास्तविक
सच
{@struct/Record Record} संरचना सरणी, संख्यात्मक सरणी
दoptInTimePeriodपैरामीटर अवधि सेट करने के लिए प्रयोग किया जाता है, डिफ़ॉल्ट मान 10 है।
optInTimeपीरियड
झूठी
संख्या
function main() {
var records = exchange.GetRecords()
var ret = talib.ROCP(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.ROCP(records.Close)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.ROCP(records);
Log(ret);
}
..ROCP()कार्य तालिब पुस्तकालय प्रलेखन में वर्णित हैःROCP(Records[Close],Time Period = 10) = Array(outReal)
..talib.ROCR()फलन का उपयोग गणना के लिए किया जाता हैदर परिवर्तन अनुपात: (मूल्य/पूर्व मूल्य) (मूल्य परिवर्तन अनुपात).
रिटर्न मूल्यtalib.ROCR()समारोह एक एक आयामी सरणी है।
सरणी
talib.ROCR ((inReal) talib.ROCR ((inReal, optInTimePeriod)
..inRealपैरामीटर का उपयोग के-लाइन डेटा को निर्दिष्ट करने के लिए किया जाता है।
वास्तविक
सच
{@struct/Record Record} संरचना सरणी, संख्यात्मक सरणी
दoptInTimePeriodपैरामीटर अवधि सेट करने के लिए प्रयोग किया जाता है, डिफ़ॉल्ट मान 10 है।
optInTimeपीरियड
झूठी
संख्या
function main() {
var records = exchange.GetRecords()
var ret = talib.ROCR(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.ROCR(records.Close)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.ROCR(records);
Log(ret);
}
..ROCR()कार्य तालिब पुस्तकालय प्रलेखन में वर्णित हैःROCR(Records[Close],Time Period = 10) = Array(outReal)
..talib.ROCR100()फलन की गणना करने के लिए प्रयोग किया जाता हैपरिवर्तन दर अनुपात 100 स्केलः (मूल्य/पूर्व मूल्य) *100 (मूल्य परिवर्तन अनुपात).
रिटर्न मूल्यtalib.ROCR100()कार्य हैः एक आयामी सरणी।
सरणी
talib.ROCR100 ((inReal) talib.ROCR100 ((inReal, optInTimePeriod)
..inRealपैरामीटर का उपयोग के-लाइन डेटा को निर्दिष्ट करने के लिए किया जाता है।
वास्तविक
सच
{@struct/Record Record} संरचना सरणी, संख्यात्मक सरणी
दoptInTimePeriodपैरामीटर अवधि सेट करने के लिए प्रयोग किया जाता है, डिफ़ॉल्ट मान 10 है।
optInTimeपीरियड
झूठी
संख्या
function main() {
var records = exchange.GetRecords()
var ret = talib.ROCR100(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.ROCR100(records.Close)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.ROCR100(records);
Log(ret);
}
..ROCR100()कार्य तालिब पुस्तकालय प्रलेखन में वर्णित हैःROCR100(Records[Close],Time Period = 10) = Array(outReal)
..talib.RSI()फलन का उपयोग गणना के लिए किया जाता हैसापेक्ष शक्ति सूचकांक.
रिटर्न मूल्यtalib.RSI()समारोह एक एक आयामी सरणी है।
सरणी
talib.RSI ((inReal) talib.RSI ((inReal, optInTimePeriod)
..inRealपैरामीटर का उपयोग के-लाइन डेटा को निर्दिष्ट करने के लिए किया जाता है।
वास्तविक
सच
{@struct/Record Record} संरचना सरणी, संख्यात्मक सरणी
दoptInTimePeriodपैरामीटर अवधि सेट करने के लिए प्रयोग किया जाता है, डिफ़ॉल्ट मान 14 है।
optInTimeपीरियड
झूठी
संख्या
function main() {
var records = exchange.GetRecords()
var ret = talib.RSI(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.RSI(records.Close)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.RSI(records);
Log(ret);
}
..RSI()कार्य तालिब पुस्तकालय प्रलेखन में वर्णित हैःRSI(Records[Close],Time Period = 14) = Array(outReal)
..talib.STOCH()फलन का उपयोग गणना के लिए किया जाता हैस्टोकैस्टिक (स्टोक संकेतक).
रिटर्न मूल्यtalib.STOCH()समारोह एक दो आयामी सरणी है।
सरणी
talib.STOCH ((inPriceHLC) talib.STOCH ((inPriceHLC, optInFastK_Period) talib.STOCH ((inPriceHLC, optInFastK_Period, optInSlowK_Period) talib.STOCH ((inPriceHLC, optInFastK_Period, optInSlowK_Period, optInSlowK_MAType) talib.STOCH ((inPriceHLC, optInFastK_Period, optInSlowK_Period, optInSlowK_MAType, optInSlowD_Period) talib.STOCH(inPriceHLC, optInFastK_Period, optInSlowK_Period, optInSlowK_MAType, optInSlowD_Period, optInSlowD_MAType)
..inPriceHLCपैरामीटर का उपयोग के-लाइन डेटा को निर्दिष्ट करने के लिए किया जाता है।
inPriceHLC
सच
{@struct/Record Record} संरचना सरणी
दoptInFastK_Periodपैरामीटर Fast-K अवधि सेट करने के लिए प्रयोग किया जाता है, डिफ़ॉल्ट मान 5 है।
optInFastK_Period
झूठी
संख्या
दoptInSlowK_Periodपैरामीटर धीमी गति से-के अवधि सेट करने के लिए प्रयोग किया जाता है, डिफ़ॉल्ट मान 3 है।
optInSlowK_Period का चयन करें
झूठी
संख्या
दoptInSlowK_MATypeपैरामीटर Slow-K औसत प्रकार सेट करने के लिए प्रयोग किया जाता है, डिफ़ॉल्ट मान 0 है।
optInSlowK_MAType
झूठी
संख्या
दoptInSlowD_Periodपैरामीटर धीमी गति से-डी अवधि सेट करने के लिए प्रयोग किया जाता है, डिफ़ॉल्ट मान 3 है।
optInSlowD_Period का चयन करें
झूठी
संख्या
दoptInSlowD_MATypeपैरामीटर धीमी गति से डी औसत प्रकार सेट करने के लिए प्रयोग किया जाता है, डिफ़ॉल्ट मान 0 है।
optInSlowD_MAType
झूठी
संख्या
function main() {
var records = exchange.GetRecords()
var ret = talib.STOCH(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.STOCH(records.High, records.Low, records.Close)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.STOCH(records);
Log(ret);
}
..STOCH()कार्य तालिब पुस्तकालय प्रलेखन में वर्णित हैःSTOCH(Records[High,Low,Close],Fast-K Period = 5,Slow-K Period = 3,Slow-K MA = 0,Slow-D Period = 3,Slow-D MA = 0) = [Array(outSlowK),Array(outSlowD)]
..talib.STOCHF()फलन का उपयोग गणना के लिए किया जाता हैस्टोकैस्टिक फास्ट (फास्ट स्टोक सूचक).
रिटर्न मूल्यtalib.STOCHF()समारोह एक दो आयामी सरणी है।
सरणी
talib.STOCHF ((inPriceHLC) talib.STOCHF ((inPriceHLC, optInFastK_Period) talib.STOCHF ((inPriceHLC, optInFastK_Period, optInFastD_Period) talib.STOCHF ((inPriceHLC, optInFastK_Period, optInFastD_Period, optInFastD_MAType)
..inPriceHLCपैरामीटर का उपयोग के-लाइन डेटा को निर्दिष्ट करने के लिए किया जाता है।
inPriceHLC
सच
{@struct/Record Record} संरचना सरणी
दoptInFastK_Periodपैरामीटर Fast-K अवधि सेट करने के लिए प्रयोग किया जाता है, डिफ़ॉल्ट मान 5 है।
optInFastK_Period
झूठी
संख्या
दoptInFastD_Periodपैरामीटर का उपयोग फास्ट-डी अवधि सेट करने के लिए किया जाता है, डिफ़ॉल्ट मान 3 है।
optInFastD_Period का चयन करें
झूठी
संख्या
दoptInFastD_MATypeपैरामीटर Fast-D औसत प्रकार सेट करने के लिए प्रयोग किया जाता है, डिफ़ॉल्ट मान 0 है।
optInFastD_MAType
झूठी
संख्या
function main() {
var records = exchange.GetRecords()
var ret = talib.STOCHF(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.STOCHF(records.High, records.Low, records.Close)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.STOCHF(records);
Log(ret);
}
..STOCHF()कार्य तालिब पुस्तकालय प्रलेखन में वर्णित हैःSTOCHF(Records[High,Low,Close],Fast-K Period = 5,Fast-D Period = 3,Fast-D MA = 0) = [Array(outFastK),Array(outFastD)]
..talib.STOCHRSI()फलन का उपयोग गणना के लिए किया जाता हैस्टोकैस्टिक सापेक्ष शक्ति सूचकांक.
रिटर्न मूल्यtalib.STOCHRSI()कार्य हैः एक दो आयामी सरणी।
सरणी
talib.STOCHRSI ((इनरियल) talib.STOCHRSI ((इंरियल, ऑप्टइनटाइमपीरियड) talib.STOCHRSI ((inReal, optInTimePeriod, optInFastK_Period) talib.STOCHRSI ((inReal, optInTimePeriod, optInFastK_Period, optInFastD_Period) talib.STOCHRSI ((inReal, optInTimePeriod, optInFastK_Period, optInFastD_Period, optInFastD_MAType)
..inRealपैरामीटर का उपयोग के-लाइन डेटा को निर्दिष्ट करने के लिए किया जाता है।
वास्तविक
सच
{@struct/Record Record} संरचना सरणी, संख्यात्मक सरणी
दoptInTimePeriodपैरामीटर अवधि सेट करने के लिए प्रयोग किया जाता है, डिफ़ॉल्ट मान 14 है।
optInTimeपीरियड
झूठी
संख्या
दoptInFastK_Periodपैरामीटर Fast-K अवधि सेट करने के लिए प्रयोग किया जाता है, डिफ़ॉल्ट मान 5 है।
optInFastK_Period
झूठी
संख्या
दoptInFastD_Periodपैरामीटर का उपयोग फास्ट-डी अवधि सेट करने के लिए किया जाता है, डिफ़ॉल्ट मान 3 है।
optInFastD_Period का चयन करें
झूठी
संख्या
दoptInFastD_MATypeपैरामीटर Fast-D औसत प्रकार सेट करने के लिए प्रयोग किया जाता है, डिफ़ॉल्ट मान 0 है।
optInFastD_MAType
झूठी
संख्या
function main() {
var records = exchange.GetRecords()
var ret = talib.STOCHRSI(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.STOCHRSI(records.Close)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.STOCHRSI(records);
Log(ret);
}
..STOCHRSI()कार्य तालिब पुस्तकालय प्रलेखन में वर्णित हैःSTOCHRSI(Records[Close],Time Period = 14,Fast-K Period = 5,Fast-D Period = 3,Fast-D MA = 0) = [Array(outFastK),Array(outFastD)]
..talib.TRIX()फलन का उपयोग गणना के लिए किया जाता हैट्रिपल स्मूथ ईएमए का एक दिवसीय रेट-ऑफ-चेंज (आरओसी).
रिटर्न मूल्यtalib.TRIX()कार्य हैः एक आयामी सरणी।
सरणी
talib.TRIX ((inReal) talib.TRIX ((inReal, optInTimePeriod)
..inRealपैरामीटर का उपयोग के-लाइन डेटा को निर्दिष्ट करने के लिए किया जाता है।
वास्तविक
सच
{@struct/Record Record} संरचना सरणी, संख्यात्मक सरणी
दoptInTimePeriodपैरामीटर अवधि सेट करने के लिए प्रयोग किया जाता है, डिफ़ॉल्ट मान 30 है।
optInTimeपीरियड
झूठी
संख्या
function main() {
var records = exchange.GetRecords()
var ret = talib.TRIX(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.TRIX(records.Close)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.TRIX(records);
Log(ret);
}
..TRIX()कार्य तालिब पुस्तकालय प्रलेखन में वर्णित हैःTRIX(Records[Close],Time Period = 30) = Array(outReal)
..talib.ULTOSC()फलन का उपयोग गणना के लिए किया जाता हैअंतिम थरथरानवाला.
रिटर्न मूल्यtalib.ULTOSC()समारोह एक एक आयामी सरणी है।
सरणी
talib.ULTOSC ((inPriceHLC) talib.ULTOSC ((inPriceHLC, optInTimePeriod1) talib.ULTOSC ((inPriceHLC, optInTimePeriod1, optInTimePeriod2) talib.ULTOSC ((inPriceHLC, optInTimePeriod1, optInTimePeriod2, optInTimePeriod3)
..inPriceHLCपैरामीटर का उपयोग के-लाइन डेटा को निर्दिष्ट करने के लिए किया जाता है।
inPriceHLC
सच
{@struct/Record Record} संरचना सरणी
दoptInTimePeriod1पैरामीटर का उपयोग पहली अवधि सेट करने के लिए किया जाता है, डिफ़ॉल्ट मान 7 है।
optInTimePeriod1
झूठी
संख्या
दoptInTimePeriod2पैरामीटर का उपयोग दूसरी अवधि सेट करने के लिए किया जाता है, डिफ़ॉल्ट मान 14 है।
optInTimePeriod2
झूठी
संख्या
दoptInTimePeriod3पैरामीटर तीसरी अवधि सेट करने के लिए प्रयोग किया जाता है, डिफ़ॉल्ट मान 28 है।
optInTimePeriod3
झूठी
संख्या
function main() {
var records = exchange.GetRecords()
var ret = talib.ULTOSC(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.ULTOSC(records.High, records.Low, records.Close)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.ULTOSC(records);
Log(ret);
}
..ULTOSC()कार्य तालिब पुस्तकालय प्रलेखन में वर्णित हैःULTOSC(Records[High,Low,Close],First Period = 7,Second Period = 14,Third Period = 28) = Array(outReal)
..talib.WILLR()फलन की गणना करने के लिए प्रयोग किया जाता हैविलियम्स
रिटर्न मूल्यtalib.WILLR()कार्य हैः एक आयामी सरणी।
सरणी
talib.WILLR ((inPriceHLC) talib.WILLR ((inPriceHLC, optInTimePeriod)
..inPriceHLCपैरामीटर का उपयोग के-लाइन डेटा को निर्दिष्ट करने के लिए किया जाता है।
inPriceHLC
सच
{@struct/Record Record} संरचना सरणी
दoptInTimePeriodपैरामीटर अवधि सेट करने के लिए प्रयोग किया जाता है, डिफ़ॉल्ट मान 14 है।
optInTimeपीरियड
झूठी
संख्या
function main() {
var records = exchange.GetRecords()
var ret = talib.WILLR(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.WILLR(records.High, records.Low, records.Close)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.WILLR(records);
Log(ret);
}```
The ```WILLR()``` function is described in the talib library documentation as: ```WILLR(Records[High,Low,Close],Time Period = 14) = Array(outReal)```
### talib.AVGPRICE
The ```talib.AVGPRICE()``` function is used to calculate **Average Price**.
The return value of the ```talib.AVGPRICE()``` function is a one-dimensional array.
array
talib.AVGPRICE(inPriceOHLC)
The ```inPriceOHLC``` parameter is used to specify the K-line data.
inPriceOHLC
true
{@struct/Record Record} structure array
```javascript
function main() {
var records = exchange.GetRecords()
var ret = talib.AVGPRICE(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.AVGPRICE(records.Open, records.High, records.Low, records.Close)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.AVGPRICE(records);
Log(ret);
}
..AVGPRICE()कार्य तालिब पुस्तकालय प्रलेखन में वर्णित हैःAVGPRICE(Records[Open,High,Low,Close]) = Array(outReal)
..talib.MEDPRICE()फलन का उपयोग गणना के लिए किया जाता हैमध्य मूल्य.
रिटर्न मूल्यtalib.MEDPRICE()समारोह एक एक आयामी सरणी है।
सरणी
talib.MEDPRICE ((इनप्राइसएचएल)
..inPriceHLपैरामीटर का उपयोग के-लाइन डेटा को निर्दिष्ट करने के लिए किया जाता है।
inPriceHL
सच
{@struct/Record Record} संरचना सरणी
function main() {
var records = exchange.GetRecords()
var ret = talib.MEDPRICE(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.MEDPRICE(records.High, records.Low)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.MEDPRICE(records);
Log(ret);
}
..MEDPRICE()कार्य तालिब पुस्तकालय प्रलेखन में वर्णित हैःMEDPRICE(Records[High,Low]) = Array(outReal)
..talib.TYPPRICE()फलन की गणना करने के लिए प्रयोग किया जाता हैविशिष्ट मूल्य.
रिटर्न मूल्यtalib.TYPPRICE()समारोह एक एक आयामी सरणी है।
सरणी
talib.TYPPRICE ((इनप्राइसएचएलसी)
..inPriceHLCपैरामीटर का उपयोग के-लाइन डेटा को निर्दिष्ट करने के लिए किया जाता है।
inPriceHLC
सच
{@struct/Record Record} संरचना सरणी
function main() {
var records = exchange.GetRecords()
var ret = talib.TYPPRICE(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.TYPPRICE(records.High, records.Low, records.Close)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.TYPPRICE(records);
Log(ret);
}
..TYPPRICE()कार्य तालिब पुस्तकालय प्रलेखन में वर्णित हैःTYPPRICE(Records[High,Low,Close]) = Array(outReal)
..talib.WCLPRICE()फलन का उपयोग गणना के लिए किया जाता हैभारित समापन मूल्य.
रिटर्न मूल्यtalib.WCLPRICE()समारोह एक एक आयामी सरणी है।
सरणी
talib.WCLPRICE ((inPriceHLC)
..inPriceHLCपैरामीटर का उपयोग के-लाइन डेटा को निर्दिष्ट करने के लिए किया जाता है।
inPriceHLC
सच
{@struct/Record Record} संरचना सरणी
function main() {
var records = exchange.GetRecords()
var ret = talib.WCLPRICE(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.WCLPRICE(records.High, records.Low, records.Close)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.WCLPRICE(records);
Log(ret);
}
..WCLPRICE()कार्य तालिब पुस्तकालय प्रलेखन में वर्णित हैःWCLPRICE(Records[High,Low,Close]) = Array(outReal)