Como deve ser o preço do vidro? - página 12

Novo comentário
 
O atraso na liberação do secador surgiu porque um novo tipo de motor precisa ser feito. O Beaker, como uma aplicação autônoma que funciona como um motor independente, precisa fornecer um API de usuário, caso contrário, como um programa fechado, seu valor será muito menor. Os motores que fiz no passado eram completamente dependentes dos comandos do usuário e não tinham nenhuma funcionalidade própria. O novo tipo de motor, deve funcionar de forma independente, bem como controlado por fora. Estou resolvendo este problema agora.
 

Hoje marcou mais um importante passo em frente. O motor pode agora operar como uma aplicação autônoma, sincronizando seus valores de parâmetros com a aplicação do usuário conectada a ele. A aplicação está conectada como antes, mas agora ela pode solicitar valores que são definidos pela funcionalidade do motor. Assim, esta é uma transição para um novo nível de interação entre os programas. O motor como um programa autônomo pode acumular sua funcionalidade e estender a API fornecida às aplicações.

No caso da pilha de preços, - tornou-se uma aplicação autônoma (que terminarei amanhã, depois de amanhã), e funciona como um indicador. Usando a conexão, os usuários podem recuperar os valores deste copo e anulá-los, devolvendo-os ao copo de uma forma modificada. Por exemplo: O preço em um dos campos de vidro foi analisado pelo código do usuário e se revela ser o nível de algum indicador importante. O usuário envia seu marcador de cordas para aquele campo e ele aparecerá ao lado daquele preço. Isto abre novas e interessantes possibilidades para o desenvolvimento tanto de motores quanto de programas de usuário.

SZZ. Os eventos do GUI deslizante, antes enviados apenas para o aplicativo, agora também são recebidos internamente pelo motor e o tratamento paralelo dos eventos é realizado em ambas as extremidades - no motor (de acordo com meu código) e na aplicação do usuário (de acordo com o código do usuário). Clicando no botão aciona tanto a funcionalidade do motor quanto a funcionalidade da aplicação conectada.
 
Outra coisa que falta no copo é o lucro se você fechar agora no mercado, ou seja, contabilizar o enchimento do copo - relevante para posições ligeiramente maiores do que as pequenas (por exemplo, 100-150 lotes).
 
Haverá alguma tecla de atalho?
 
Andrey Gladyshev:
Haverá hotkeys?
Absolutamente.
 
Aleksey Vyazmikin:
Outra coisa que falta no copo é o lucro se você fechar agora no mercado, ou seja, encher o copo - relevante para posições ligeiramente maiores do que pequenas (por exemplo, 100-150 lotes).
Conta do enchimento do copo. Pensarei após o lançamento da versão básica, para não atrasar.
 
O preço do copo estará pronto. A documentação da conexão API foi muito atrasada. É extremamente demorado escrever sua documentação em sua própria linguagem de marcação. E a documentação do secador também tem que ser feita. E o próprio vidro. E, ao mesmo tempo, otimizar o código, construtor, corrigir bugs e adicionar recursos. É por isso que é tão longo. Mas então tudo será mais rápido e mais rápido.
 
Em que língua está escrito o programa?
Qual é a velocidade real de processamento dos dados recebidos?
Como os dados são alocados para os níveis de preços?
É um para loop ou há uma variável com dados para cada nível?
O fato de ter escolhido o tipo de vista do vidro, como nos terminais ocidentais, é correto.
Eu sugeriria acrescentar à taça, gerenciamento de pedidos OCO ligados até três níveis.
E em geral, você pode pegar qualquer Dock funcional do mercado ocidental e ver o que é implementado nele.
Ou veja como o QScalp scalper drive é implementado.
 
Roman:
Em que idioma o programa está escrito?
Qual é a velocidade real de processamento dos dados recebidos?
Como os dados são distribuídos por níveis de preço?
Em um para loop ou para cada nível tem sua própria variável com dados?
O fato de ter escolhido o tipo de vista do vidro, como nos terminais ocidentais, é correto.
Eu sugeriria acrescentar ao vidro, gerenciamento de licitações OCO ligadas até três níveis.

1. O programa está escrito em dois idiomas. A linguagem de base é MQL5 e, além disso, minha linguagem de marcação.

2. Distribuído da mesma forma que o enviado. Quero dizer, nas células certas. É difícil explicar em palavras. Eu lhe enviarei o código mais tarde. É claro que tive que suar para colocar os dados nas células certas, mas esta questão foi resolvida.

3. Acrescentarei tudo o que me será pedido e isso tem sentido e importância.
 

Aqui está o código para distribuir os dados para as células do meu copo:

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);
}


Para registrar os dados recebidos, eu fiz uma matriz de 100 células. Distribuo os dados recebidos do centro da matriz (célula 49) para o lado asc e bid, calculando antecipadamente o preço mais próximo ao lado asc e bid.

1...567891011121314
Novo comentário