Le journal d'apprentissage de la chimie quantique de l'inventeur (i) terminé

J'avais l'habitude de ne pas écrire de journal, mais maintenant j'ai l'impression que je dois écrire quelque chose tous les jours, je ne peux pas regarder la lumière du jour!

Question 1: Quelle est la différence?

• 1, les lignes K du graphique manquent parfois d'un BAR, cherchent un BUG. Le problème a été trouvé, analysé, et aucune donnée n'a été reçue lors des tests avec le disque d'analogie. Au moment de la réception des données, 2 BAR ont déjà été passées, de sorte que la dernière image de données est sur le graphique, ce qui entraîne le passage d'un ou plusieurs intervalles.
• 2, courir pendant un certain temps (de cycle de ligne K de 1 minute) sans problème, essayez à nouveau (de cycle de ligne K de 30 minutes) le problème arrive, et quelque chose d'étrange se produit:

TypeError: cannot read property length of null duk_hobject_props.c:2258 WToneAndWTtwo __FIL Cette erreur est signalée.

Regardez ci-dessous ce qui devrait être une erreur dans cette fonction WToneAndWTtwo, en lisant la valeur de null nommé la longueur d'une propriété, c'est-à-dire une variable telle que var name = null; et puis je lis la valeur de null nommé la longueur d'une variable, c'est-à-dire une variable appelée longitude, c'est-à-dire une variable appelée longitude. Une fonction a été écrite pour résoudre cette erreur:

function isNullAndLog(arr,strArrName){//空数组报错
     if(!arr){
         Log("arr is:",arr,"name:",strArrName);
         return true;
      }
      return false;
}

Pensez-y, oh! Je mets toutes les variables utilisées jusqu'à la longueur dans cette fonction et je vérifie qu'il n'y a pas de bug nul qui ne peut pas être évité. Il y a 30 minutes, le test de la ligne K a été effectué, et il s'est avéré que:

TypeError: ne peut pas lire la propriété length de duk_hobject_props.c:2258 WToneAndWTtwoLe dossierJe ne suis pas d'accord.

C'est un peu comme si je n'avais pas compris! patience! sortez, faites un tour et changez d'avis ou vous vous rendrez compte! Je me suis dit que si j'appelais la base d'indicateurs, le paramètre de transmission était nul, une erreur s'est produite lors de l'exécution de la base d'indicateurs.

function isNullAndLog(arr,strArrName){//空数组报错
    if(!arr){
        Log("arr is:",arr,"name:",strArrName);
        return true;
    }
    return false;
}

function main(){
   if(typeof(x) === undefined ){
       Log(typeof(x));
   }
    var aaa = null;
    Log(isNullAndLog(aaa));
    /*
    while(!aaa || aaa.length < 9){
        Log("while xunhuan");
        Sleep(5000 * 1000);
    } 
    */
    talib.EMA(aaa,5);
} 

Talib.EMA ((aaa,5); la clé AAA est null, je l'ai délibérément mise, passez-la et voyez ce qui se passe. TypeError: Cannot read property length of null ~~OK, c'est probablement le problème, continuez à modifier le code.

Question 2: Quelle est la différence?

Il y a aussi un autre problème avec la façon dont on a pensé à enregistrer le code maintenant:

function DeleteNullEle(initArr){
    var dealArr = [];
    var initArrLen = initArr.length;
    for(var i = 0,j = 0 ; i < initArrLen ; i++,j++){
    //Log("initArr-",i,":",initArr[i]);//ceshi
    if(initArr[i] === null || isNaN(initArr[i]) ){
        j--;
        //Log("i:",i);//ceshi
        continue;
    }
        dealArr[j] = initArr[i];
    }
    //Log("dealArr:",dealArr);//ceshi
return dealArr;
}

La raison pour laquelle nous avons ajouté cette fonction est que certaines arithmétiques sont comme ceci [NaN, NaN, NaN, NaN, 22, 3, 56, 78, 4, 23], mais quand les inventeurs ont quantifié les tests, ils ont montré que la fonction Log était nulle, ce qui est une valeur nulle. Je me suis perdu pendant un long moment, grand trou, il faut se rappeler que ce que vous voyez est nul et peut-être NaN, donc juger nul est impossible.
Il y a aussi cette autre chose, c'est cette expression while ((!aaa gbla aaa.length < 10) {...}, si aaa === null, pourquoi ne pas retourner l'erreur, parce que dans ce cas, l'expression de cet opérateur est Dans ce cas, l'expression aaa est toujours vraie, donc l'expression aaa.length peut ne pas être exécutée. Il y a aussi des API utilisées.

Question 3: Quelle est la différence?

En outre, à la demande d'un ami, j'ai modifié la surveillance des différences, en fait, j'ai ajouté une plage de différences de détection et WeChat a été envoyé, c'est très simple.

 if (diff != __lastDiff) {
//--------------------------------------------------------------------------------------------
        if(openWeixin){
            if( (diff <= price1 || diff >= price2 ) && off_on === true ){
                Log("差价:"+diff+"微信推送@");
                off_on = false;
                Sleep(1000);
            }else{
                off_on = true;
                Sleep(1000);
                }
        }
//---------------------------------------------------------------------------------------------
        // add添加数据到series, 参数格式为[series序号, 数据];
        __chart.add([0, [new Date().getTime(), diff]]);
        __lastDiff = diff;
    }

Le code qui est ajouté entre les lignes de code est très simple et peut-être pas encore parfait.

Question 4: (Ce n'est pas vraiment un problème, mais un peu d'apprentissage)

Ces jours-ci, l'apprentissage des stratégies de négociation de contrats à terme est plus compliqué que celui des contrats à terme, (heureusement, il y a un modèle de négociation de contrats à terme de taille Z, sinon il suffit d'écrire les détails de la transaction >____

• exchange.GetPosition() // est utilisé pour obtenir des informations de stockage, notez que cette fonction renvoie une matrice d'une structure de position qui contient toutes les informations spécifiques à la position.
• exchange.SetMarginLevel (MarginLevel) // Cette fonction consiste à définir un effet de levier. Paramètres spécifiques MarginLevel sélection ((5 fois? 10 fois?) selon la variété, l'échange, en particulier, certains ne peuvent pas changer (par exemple, les futures de produits CTP)
• exchange.SetDirection ((Direction) // C'est une API très importante, qui est appelée avant la liste ci-dessous, car nous venons d'introduire quatre opérations (sell open position...), cette fonction est celle qui définit ces opérations (mais il y a un peu de contenu supplémentaire), et le deuxième paramètre de CTP n'a pas été étudié pour le moment.
• exchange.SetContractType (ContractType) // Avant l'ouverture ou l'établissement d'une position, l'un est de définir la direction de la transaction (plus? vide? plat?), l'autre est de définir le contrat de la transaction (indiqué par le sucre blanc? le coton?), donc utilisez cette fonction pour définir le type de contrat. Les fonctions suivantes sont essentiellement utilisées.
• Exchange.Buy ((() // acheter
• Exchange.Sell ((() // Vendre Voici le code de mon expérience, en sélectionnant une seule section (qui peut être copiée dans la fonction principale) et en testant à nouveau l'échange testé:

 if (!manager) {//Z大写的商品期货模板类库，用来管理交易的对象（manager 初始时null）。不明白的可以去看源代码，QQ群共享有注释版。
        if (_C(exchange.GetPosition).length > 0) {
            throw "策略启动前不能有持仓.";
        }
        Log('交易平台:', exchange.GetName(), _C(exchange.GetAccount));  //输出当前交易所 信息
        var insDetail = _C(exchange.SetContractType, ContractTypeName);  // 用容错函数 _C ，容错调用 SetContractType函数  首先明确 设置交易的合约类型。
        Log("合约", insDetail.InstrumentName, "一手", insDetail.VolumeMultiple, "份, 最大下单量", insDetail.MaxLimitOrderVolume, "保证金率:", insDetail.LongMarginRatio.toFixed(4), insDetail.ShortMarginRatio.toFixed(4), "交割日期", insDetail.StartDelivDate);
        // 上面这个Log 显示出合约的一些信息，注意 在回测的时候，与实际运行的结果不一样，可以看图杠杆都是null，保证金率都是0，可以试试看。
        manager = $.NewPositionManager();  // 这个生成管理者 对象
    }
    exchange.SetMarginLevel(10); //不支持       在这里我试着设置了一下杠杆试试，发现  显示 错误：Not support     ，CTP商品期货 应该不能自己调整杠杆
    var positions = exchange.GetPosition();     在所有的操作前 ，我试着调用了一下 GetPosition 函数  获取一下持仓信息，显示的null
    Log(positions[0]);
    exchange.SetDirection("buy"); // 在所有的操作前需要设置  操作方向  ，这里设置 买开仓（做多）。
    var id = exchange.Buy(1911,1); // 执行买入操作  下了一个  限价单，  有兴趣的同学 可以试试 市价单。（嘿嘿！自己动手记得牢）
    positions = _C(exchange.GetPosition); //再获取下 持仓信息 看看
    Log(positions);  //有持仓信息了，  在上面 Buy的时候  有兴趣的同学 试试 用低价格 买入。  Buy(1000,1) 看看。

Question 5: Aujourd'hui, un ami a écrit un extrait de code demandant à la fonction Sleep (()) d'avoir une grosse erreur qui affecte la politique de haute fréquence.

function main(){
    for(var i = 0 ; i < 10 ; i++){
        var b1 = 0;
        var b2 = 0;
        var b3 = 15;
        while(b1 < 200){
            var t2s1 = (new Date()).getTime();
            b1++;
            Sleep(b3);
            var t2s6 = (new Date()).getTime();
            b2 += (t2s6 - t2s1);
        }
        Log("Sleep()",b3,"MS",b1,"平均次数",b2/b1);
    }
    throw 2;
}

J'ai refait le test et j'ai découvert que la fonction Sleep fonctionne en une seconde (un écart de temps de 1000 avant et après) et que le temps d'exécution de ce code de test est très important, mais en fonction de la vitesse d'exécution de l'analogue, l'erreur est essentiellement inférieure à 1 milliseconde. Peut-être que le système de refaçon appartient au modèle de sable, l'erreur est causée par l'algorithme de temps d'exécution.

Question 6: Ce matin, un ami m'a dit que mon hôte s'était écrasé à minuit et m'a envoyé le journal du système.

- C'est un journal.

runtime/cgo: pthread_create failed: Resource temporarily unavailable
SIGABRT: abort
PC=0x7f332c591cc9 m=2

goroutine 0 [idle]:

goroutine 1 [select, 207 minutes]:

Dès la première ligne, nous voyons que la génération de thread a échoué et que les ressources sont temporairement indisponibles (insuffisantes). La solution: 1, Vérifie le code de stratégie du robot en cours d'exécution, s'il y a des ressources utilisées qui ne sont pas libérées, s'il y a des API utilisant plusieurs threads; 2、 Utiliser la commande ulimit pour vérifier les restrictions du système sur lequel l'administrateur est basé ((Linux) ).http://smilejay.com/2012/04/fork_resource/Je ne sais pas. 3° Veillez à l'utilisation de la mémoire du système.

Ulimit -a est utilisé pour afficher:

Les paramètres de la commande ulimit: -H définit une limite de ressources matérielles. -S définit les restrictions de ressources logicielles. -a affiche toutes les restrictions actuelles. -c size: définit la valeur maximale du fichier de base. Unité: blocs -d size: valeur maximale de la tranche de données à définir. Unité: kbytes -f size: définit la valeur maximale pour créer un fichier. Unité: blocs -l size: la valeur maximale pour un processus bloqué en mémoire. Unité: kbytes -m size: définit la valeur maximale de la mémoire permanente qui peut être utilisée. Unité: kbytes -n size: définit la valeur maximale des descripteurs de fichiers que le noyau peut ouvrir en même temps. Unité: n -p size: valeur maximale de la zone de stockage du pipeline. Unité: kbytes -s size: définir la valeur maximale de la pile. Unité: kbytes -t size: définit le maximum de temps d'utilisation du processeur. Unité:seconds -v size: valeur maximale de la mémoire virtuelle à définir. Unité: kbytes -u Nombre maximum de programmes pouvant être lancés par un utilisateur

Un ami qui a rencontré ce problème a découvert que l'erreur de filtrage de la fonction peut être à l'origine du problème, et a trouvé la cause de l'effondrement du gestionnaire (la mémoire continue de s'élargir). SetErrorFilter (( 502: 503: tcp character unexpected network timeout WSARecv Connect GetAddr no such reset httppreceived EOF reused ); une mauvaise utilisation de la fonction qui ne nécessite qu'un seul appel et qui ne peut pas être écrite dans une structure cyclable. Le problème ci-dessus est que la fonction est écrite dans la fonction onTick et que le nombre d'appels en cycles est constant, ce qui entraîne un effondrement final.

Problème 7: Résumé simple des fonctions _C (), _N (), _G ():

• La fonction _C(

Explanation: Cette fonction est principalement utilisée pour l'API d'erreur, comme la fonction exchange.GetAccount (), appelée comme suit: _C ((exchange.GetAccount); Notez que le nom de la fonction n'est pas placé entre parenthèses. Si la fonction d'erreur nécessite l'ajout d'un paramètre, elle est écrite dans le deuxième paramètre de la fonction _C (), dans l'ordre inverse. Utilisez des exemples.

function main(){
    var account = null;
    var amount = 1;
    var price = 2000;
    account = exchange.GetAccount();
    Log("_C 函数使用前  account :",account);
    //exchange = null; 
    _C(exchange.Buy,price,amount);
    //exchange.Buy(price,1);
    account = exchange.GetAccount();
    Log("_C 函数使用后  account :",account);
}

On peut supposer que la fonction_C est la suivante:

 function ___C(functionName,p1){
    functionName("执行需要容错的函数，传入的测试参数为：",p1);
    Log("__C 容错函数启动，容错完毕");
}
function main(){
    pstr = "测试参数--hello";
    ___C(Log,pstr);
}

Résultats:

• La fonction _N( Explanation: Cette fonction est utilisée pour traiter un trop grand nombre de post-composites, en conservant quelques particules. Voici quelques exemples:

function main(){
    var pi = 3.1415926535897;
    Log("使用_N函数 前pi:",pi);
    var piOfDeal = _N(pi,2);
    Log("使用_N函数后 pi:",piOfDeal);
}

Résultats:

• La fonction _G( Description: Cette liste de dictionnaires mondiaux est présentée dans la documentation API et peut être sauvegardée. Tableau KV, fichier local en permanence, chaque bot possède une base de données séparée, qui existe après le redémarrage ou la sortie de l'administrateur K doit être un chiffre ou une chaîne, peu importe la taille, V peut être écrit pour tout ce qui peut être sérifié en JSON. _G ((num, 1); // définit une variable globale num, dont la valeur est 1 _G ((num, ok); // Modifier une variable globale num, dont la valeur est la chaîne ok _G ((num, null); // supprime la variable globale num _G ((num); // renvoie la valeur de la variable globale num _G(); // renvoie l'ID du robot actuel _G ((null); // supprime toutes les variables globales

function main(){
    Log("totalYLMoney 初始赋值 0");
    var totalYLMoney = 0;
    Log("totalYLMoney 已赋，  = ",totalYLMoney);
    if(typeof(_G("totalYLMoney_save")) !== "object"){
        totalYLMoney = _G("totalYLMoney_save"); 
        Log("读取 totalYLMoney 本地数据库 名称为totalYLMoney_save 的值 赋给 totalYLMoney ");
    }else{
        totalYLMoney = 100.12546328765458;
        _G("totalYLMoney_save",totalYLMoney.toString());
        Log("记录 totalYLMoney 保存到本地数据库");
    }
    Log("totalYLMoney",totalYLMoney);
    Log("typeof\(_G(\"totalYLMoney_save\"))",typeof(_G("totalYLMoney_save")));
}

Le code de test de la fonction _G() ci-dessus nécessite un test sur le robot, le retest n'est pas pris en charge. La méthode de test consiste à déployer le programme sur le robot, la première fois que le robot est lancé, le robot enregistre 100.12546328765458; cette valeur est enregistrée dans le dictionnaire global "totalYLMoney_save" sous le nom de "totalYLMoney_save" et, une fois de plus, le robot est exécuté, vous trouverez var totalYLMoney = 0, cette variable totalYLMoney est toujours lue dans le dictionnaire après l'initialisation, la valeur stockée lors du premier exécution de la stratégie.

Question 8: Quelques idées sur la stratégie de calcul des gains et des pertes:

Il y a souvent des nouveaux élèves dans le groupe qui demandent des algorithmes pour gagner et perdre des stratégies. En général, il y a plusieurs façons de traiter, voici une simple, les idées sont également fournies par le grand dieu du groupe, je suis responsable d'expliquer ici.

• Le profit flottant:

Le bénéfice flottant est: divisé par (monnaie actuelle - monnaie initiale) x prix actuel + (argent actuel - monnaie initiale)

Exemple: par exemple, le prix initial est de 10 dollars par pièce, le compte commence avec 5 pièces et 100 dollars par pièce. Dans un certain laps de temps, j'ai acheté 3 pièces au prix moyen de 15 dollars par pièce. À la fin de ce laps de temps, le prix des pièces augmente à 20 dollars par pièce. Profit = (8 - 5) * 20 + (55 - 100) = 60 + (-45) = 15 Cette méthode de calcul Le profit est de 15 yuans. (Note: votre gain est flottant, car si le prix de la monnaie chute fortement en ce moment, vous risquez non seulement de ne pas gagner, mais aussi de perdre de l'argent. En outre, si, à un moment où le prix de la pièce est de 20 dollars, le solde, c'est-à-dire 20 dollars pour vendre 3 pièces de monnaie à 15 dollars, le compte est maintenant: 5 pièces, 115 pièces; ou l'algorithme ci-dessus: Profit = (5 - 5) * 20 + (115 - 100) = 15, le bénéfice reste de 15 yuans, la différence est que si vous ne prenez pas en compte la dépréciation initiale de la monnaie, le bénéfice ne change pas avec le prix.

• Les bénéfices:

Le bénéfice de compte: (maintenant la pièce x le prix actuel + l'argent actuel) - (maintenant la pièce x le prix initial + l'argent initial)

Utilisez l'exemple ci-dessus: par exemple, le prix initial est de 10 dollars, le compte commence avec 5 dollars, 100 dollars. Pendant un certain temps, j'ai acheté 3 dollars au prix moyen de 15 dollars. À la fin de cette période, le prix des pièces est passé à 20 dollars. Profit = (8 * 20 + 55) - (5 * 10 + 100) = 215 - 150 = 65 Cette façon de calculer le profit est de 65 $. De la même façon, j'ai acheté 3 pièces de monnaie au prix moyen de 15 et je les ai vendues à 20 dollars. Le profit = (5 * 20 + 115) - (5 * 10 + 100) = 215 - 150 = 65 est le même.

Il n'est pas difficile de comparer les deux méthodes ci-dessus, un gain de 15 et un gain de 65; la première méthode ignore les gains et les pertes liés à la dépréciation de la dépréciation initiale de la monnaie. La deuxième algorithme calcule les gains et les pertes en incluant les gains et les pertes liés à la dépréciation de la dépréciation de la monnaie initiale. Le calcul des bénéfices de compte est appliqué au paiement des fonds. Les bénéfices flottants s'appliquent aux gains et pertes générés par les transactions au cours d'une période de temps. Ce sont quelques-unes des expériences que j'ai vécues, comme si j'avais fait une erreur, merci beaucoup de me laisser le bon indice, merci d'avance.

Question 9: Un membre du groupe a vu apparaître un formulaire dans la barre d'état d'une politique ouverte, et a parcouru l'API ci-dessous pour voir ce qui semblait être une nouvelle fonctionnalité ajoutée, la fonction LogStatus dans l'API.

Pour commencer, regardez l'API de la plateforme:

LogStatus(Msg); //	此信息不保存到日志列表里, 只更新当前机器人的状态信息, 在日志上方显示, 可多次调用, 更新状态
LogStatus('这是一个普通的状态提示');
LogStatus('这是一个红色字体的状态提示 #ff0000');
LogStatus('这是一个多行的状态信息\n我是第二行');
var table = {type: 'table', title: '持仓信息', cols: ['列1', '列2'], rows: [ ['abc', 'def'], ['ABC', 'support color #ff0000']]};
LogStatus('`' + JSON.stringify(table)+'`'); // JSON序列化后两边加上`字符, 视为一个复杂消息格式(当前支持表格)
LogStatus('第一行消息\n`' + JSON.stringify(table)+'`\n第三行消息'); // 表格信息也可以在多行中出现
LogStatus('`' + JSON.stringify([table, table])+'`'); // 支持多个表格同时显示, 将以TAB显示到一组里

Le code de test:

function main(){
    var value1 = 99;
    var value2 ="ceshi 01";
    var table1 = { type : "table", title : "ceshi1", cols : ["列1","列2","列3"] , rows : [ ["abc","def","ghi"] , ["1","2","3"] ] };
    var table2 = { type : "table", title : "ceshi2", cols : ["列1","列2","列3"] , rows : [ ["abc",value1,"ghi"] , [value2,"2","3"] ] };
    LogStatus("测试文本1\n`" + JSON.stringify([table1,table2]) + "`");
}

Le premier graphique montre que dans ceshi1, nous avons une table de partition dont le format de données est var table1 et var table2. Les deux variables sont déclarées. Il est important de noter qu'avant et après la fonction JSON.stringify (([table1, table2]) il faut ajouter `. Sinon, la table ne s'affiche pas. Bien sûr, nous devons utiliser des tableaux pour afficher des données dynamiques, mais il ne peut pas toujours s'agir d'un contenu textuel fixe. Table 2 contient deux données de test, value1 et value2, toutes deux dans cette section.Les nouveaux élèves peuvent copier le code, essayer et modifier eux-mêmes.

Question 10: Si un utilisateur souhaite un graphique de rendement, il est possible que la présentation de l'API quantifiée par l'inventeur soit plus simple et qu'il soit plus difficile de l'utiliser.

Je l'ai testé directement en utilisant des nombres aléatoires pour simuler les variations dynamiques des rendements et les utiliser pour afficher les courbes de rendement sur le graphique.

var ChartObj = {//画图
    tooltip: {xDateFormat: '%Y-%m-%d %H:%M:%S, %A',enabled:true,valueDecimals:2,valueSuffix:'%'}, //提示框  就是鼠标在线上时 显示的一个 框框 里面有一些内容，这里是设置提示框的格式
    chart: { zoomType:'x',panning:true },//图表缩放  
    title: { text: '收益率 %'}, //标题
    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
        },
    subtitle: {text: " 显示瞬时收益率 % "},//副标题
    xAxis:{type: 'datetime'}, //设置 X轴  的数值为时间类型
    yAxis: [{
            title: {text: '收益率 %'},//标题
            style: {color: '#4572A7'},//样式 
            //opposite: false  //生成右边Y轴
        }
    ],
    series: [//系列
        {name:'收益率',dataLables:{enabled:true,format:'{y} %'},type:'spline',yAxis:0,data:[]} //该图标只用到一条曲线  ，所以 只用设置一个数据序列
        ]                  
};
var chart = Chart(ChartObj);  //初始化

function main(){ //测试用的主函数
    chart.update(ChartObj); //更新
    chart.reset(); //清空图表
    var i = 0; //初始一个 i 值 ， 后面循环用，   用来限制循环次数
    var randomNum = 0; //声明一个  随机数 初始化 0
    while(i < 5000){ //限制循环次数
        randomNum = Math.random() * 10;  // 生产随机数 0  -  9.9999
        //chart.add([0,[(new Date()),randomNum]]);
        chart.add(0,[(new Date()).getTime(),randomNum + 5]);  //把生成的随机数  按照时间（X 坐标）     把随机数 画在图表上（Y坐标）     
        Sleep(1000*60); // 程序 每次循环暂停60秒
        //chart.update(ChartObj);
        //chart.reset(500);
    }
    Log("over");
}

• Un problème m'a déconcerté pendant une demi-journée, et je l'ai enregistré. Au moment de l'écriture de l'heure, il faut un nombre de millisecondes, écrivez: new Date (().getTime (()) C'est un nombre de millisecondes, si c'est new Date (()) alors il y a un petit problème, comme l'affichage de l'heure, et la mise à l'échelle de l'axe X ne peut pas être utilisée. Il y a aussi un outil: {xDateFormat: %Y-%m-%d %H:%M:%S, %A, enabled:true,valueDecimals:2,valueSuffix:%}, ce paramètre est visible dans la vue.