Quel devrait être le prix du verre ? - page 12

Nouveau commentaire
 
Le retard dans la sortie du Tumbler est dû au fait qu'un nouveau type de moteur doit être fabriqué. Beaker, en tant qu'application autonome fonctionnant comme un moteur indépendant, doit fournir une API utilisateur, sinon, en tant que programme fermé, sa valeur sera bien moindre. Les moteurs que j'ai réalisés dans le passé étaient complètement dépendants des commandes de l'utilisateur et n'avaient aucune fonctionnalité propre. Le nouveau type de moteur, doit fonctionner de manière indépendante et être contrôlé de l'extérieur. Je suis en train de résoudre ce problème.
 

Aujourd'hui, nous avons franchi une nouvelle étape importante. Le moteur peut maintenant fonctionner comme une application autonome, en synchronisant ses valeurs de paramètres avec l'application utilisateur qui lui est connectée. L'application est connectée comme auparavant, mais elle peut maintenant demander des valeurs qui sont définies par la fonctionnalité du moteur. Il s'agit donc d'une transition vers un nouveau niveau d'interaction entre les programmes. Le moteur, en tant que programme autonome, peut accumuler ses fonctionnalités et étendre l'API fournie aux applications.

Dans le cas de la pile de prix, - elle est devenue une application autonome (que je terminerai demain, après-demain), et fonctionne comme un indicateur. En utilisant la connexion, les utilisateurs peuvent récupérer les valeurs de ce gobelet et les remplacer, en les renvoyant au gobelet sous une forme modifiée. Par exemple : Le prix dans l'un des champs de verre a été analysé par le code utilisateur et il s'avère être le niveau d'un indicateur important. L'utilisateur envoie son marqueur de chaîne dans ce champ et il apparaîtra à côté de ce prix. Cela ouvre de nouvelles possibilités intéressantes pour le développement des moteurs et des programmes utilisateurs.

SZZ. Les événements liés aux curseurs de l'interface graphique, qui étaient auparavant uniquement envoyés à l'application, sont maintenant également reçus en interne par le moteur et le traitement parallèle des événements est effectué aux deux extrémités - dans le moteur (selon mon code) et dans l'application utilisateur (selon le code utilisateur). Un clic sur le bouton déclenche à la fois la fonctionnalité du moteur et celle de l'application connectée.
 
Une autre chose qui manque dans la tasse est le bénéfice si vous fermez maintenant sur le marché, c'est-à-dire en tenant compte du remplissage de la tasse - pertinent pour les positions légèrement plus grandes que les petites (par exemple 100-150 lots).
 
Y aura-t-il des touches de raccourci ?
 
Andrey Gladyshev:
Y aura-t-il des touches de raccourci ?
Absolument.
 
Aleksey Vyazmikin:
Une autre chose qui manque à la tasse est le profit si vous fermez maintenant sur le marché, c'est-à-dire en remplissant la tasse - pertinent pour les positions légèrement plus grandes que petites (par exemple 100-150 lots).
Compte rendu du remplissage de la tasse. Je réfléchirai après la sortie de la version de base, pour ne pas retarder.
 
Lacoupe de prix sera prête. La documentation de la connexion API a été très retardée. Il est extrêmement fastidieux d'écrire votre documentation dans votre propre langage de balisage. Et la documentation du gobelet doit être faite aussi. Et le verre lui-même. Et en même temps, optimiser le code, le constructeur, corriger les bogues et ajouter des fonctionnalités. C'est pour ça que c'est si long. Mais alors, tout sera plus rapide.
 
Dans quelle langue le programme est-il écrit ?
Quelle est la vitesse de traitement réelle des données entrantes ?
Comment les données sont-elles réparties entre les niveaux de prix ?
S'agit-il d'une boucle for ou d'une variable contenant des données pour chaque niveau ?
Le fait que vous ayez choisi le type de vue du verre comme dans les terminaux occidentaux est correct.
Je suggère d'ajouter à la coupe, la gestion des ordres OCO liés jusqu'à trois niveaux.
Mais en général, nous pouvons prendre n'importe quel marché occidental fonctionnel Dock et voir ce qui y est implémenté.
Ou voyez comment le lecteur scalpeur QScalp est mis en œuvre.
 
Roman:
Dans quel langage le programme est-il écrit ?
Quelle est la vitesse de traitement réelle des données entrantes ?
Comment les données sont-elles réparties par niveaux de prix ?
Dans une boucle for ou for chaque niveau a sa propre variable avec des données ?
Le fait que vous ayez choisi le type de cartographie de la coupe, comme dans les terminaux occidentaux, est correct.
Je suggère d'ajouter au verre, la gestion des offres OCO liées jusqu'à trois niveaux.

1. Le programme est rédigé en deux langues. Le langage de base est MQL5, et par-dessus, mon langage de balisage.

2. Distribué de la même manière qu'envoyé. Je veux dire dans les bonnes cellules. C'est difficile à expliquer avec des mots. Je vous enverrai le code plus tard. Bien sûr, j'ai dû transpirer pour faire entrer les données dans les bonnes cellules, mais ce problème a été résolu.

3. J'ajouterai tout ce qui me sera demandé et qui a un sens et une importance.
 

Voici le code pour distribuer les données aux cellules de ma tasse :

void On_DOM_Event()
{
 int t = 0;
 //----------------------------
 MqlTick last_tick;
 SymbolInfoTick(Symbol(),last_tick);
 //----------------------------
 MarketBookGet(NULL,priceArray); 
 //----------------------------
 double p = 0;
 long   ask_size = 0, bid_size = 0;
 int    s = ArraySize(priceArray);
 //----------------------------
 if(s > 0)
   {
    //-------------------------   ---
    for(int i1 = 0; i1 < 100; i1++)prices[i1]  = NULL;
    for(int i1 = 0; i1 < 100; i1++)ask_vol[i1] = NULL;
    for(int i1 = 0; i1 < 100; i1++)bid_vol[i1] = NULL; 
    //----------------------------
    int Closest_to_ask = 0;
    //----------------------------
    for(int a1 = 0; a1 < s; a1++)
      {
       if(
              priceArray[a1].price == last_tick.ask
          || (priceArray[a1].price < last_tick.ask && (((a1 + 1 < s) && priceArray[a1 + 1].price >= last_tick.bid) || (a1 + 1 == s)))
         )
         {
          Closest_to_ask = a1;
          break;
         } 
      } 
    //----------------------------
    for(int a2 = Closest_to_ask; a2 >= 0; a2--)
      { //Alert("t ",t,"  a2  ",a2);
       prices[49-t]  =  Normalize_Double(priceArray[a2].price,_Digits,_Point);
       ask_size     +=  priceArray[a2].volume;
       ask_vol[49-t] =  (string)priceArray[a2].volume;
       t++;
      }
    //--------------------------------  
    t = 0;
    //Alert("_Digits   ",_Digits);
    //--------------------------------  
    for(int a3 = Closest_to_ask + 1; a3 < s; a3++)
      { 
       prices[50+t]  =   Normalize_Double(priceArray[a3].price,_Digits,_Point);
       bid_size      +=  priceArray[a3].volume;
       bid_vol[50+t] =   (string)priceArray[a3].volume;
       t++;
      }         
 //------------------------------------------------       
 //------------------------------------------------ 
 E_DOM_1_Price(prices[40]);    E_DOM_1_Ask_size(ask_vol[40]);
 E_DOM_2_Price(prices[41]);    E_DOM_2_Ask_size(ask_vol[41]); 
 E_DOM_3_Price(prices[42]);    E_DOM_3_Ask_size(ask_vol[42]); 
 E_DOM_4_Price(prices[43]);    E_DOM_4_Ask_size(ask_vol[43]); 
 E_DOM_5_Price(prices[44]);    E_DOM_5_Ask_size(ask_vol[44]);
 E_DOM_6_Price(prices[45]);    E_DOM_6_Ask_size(ask_vol[45]);
 E_DOM_7_Price(prices[46]);    E_DOM_7_Ask_size(ask_vol[46]);
 E_DOM_8_Price(prices[47]);    E_DOM_8_Ask_size(ask_vol[47]);  
 E_DOM_9_Price(prices[48]);    E_DOM_9_Ask_size(ask_vol[48]); 
 E_DOM_10_Price(prices[49]);   E_DOM_10_Ask_size(ask_vol[49]);
 //-------------------------------------------------
 E_DOM_11_Price(prices[50]);  E_DOM_11_Bid_size(bid_vol[50]);
 E_DOM_12_Price(prices[51]);  E_DOM_12_Bid_size(bid_vol[51]);
 E_DOM_13_Price(prices[52]);  E_DOM_13_Bid_size(bid_vol[52]); 
 E_DOM_14_Price(prices[53]);  E_DOM_14_Bid_size(bid_vol[53]); 
 E_DOM_15_Price(prices[54]);  E_DOM_15_Bid_size(bid_vol[54]); 
 E_DOM_16_Price(prices[55]);  E_DOM_16_Bid_size(bid_vol[55]); 
 E_DOM_17_Price(prices[56]);  E_DOM_17_Bid_size(bid_vol[56]); 
 E_DOM_18_Price(prices[57]);  E_DOM_18_Bid_size(bid_vol[57]);    
 E_DOM_19_Price(prices[58]);  E_DOM_19_Bid_size(bid_vol[58]); 
 E_DOM_20_Price(prices[59]);  E_DOM_20_Bid_size(bid_vol[59]);
 //------------------------------------------------- 
 }
 RMSG(1);
}


Pour enregistrer les données entrantes, j'ai fait un réseau de 100 cellules. Je distribue les données entrantes depuis le centre du tableau (cellule 49) vers les côtés asc et bid, en calculant au préalable le prix le plus proche des côtés asc et bid.

1...567891011121314
Nouveau commentaire