FórumSeções

[ARQUIVO]Qualquer pergunta de novato, para não desorganizar o fórum. Profissionais, não passem por ela. Não posso ir a lugar nenhum sem você - 5. - página 424

Novo comentário
gyfto:

Bem, em teoria, se forem autodeclarados buffers indicadores adicionais e forem utilizadas outras linhas de tendência, então funcionará...

Então porque a documentação diz que
o número de tampões não pode exceder 8
Não está claro aqui. Não diz que é o número de amortecedores principais, não todos eles. Diz o número de amortecedores e pronto. Portanto, estou lendo isto e é meu entendimento que isto deve se aplicar ao número total de amortecedores para um determinado indicador.
gyfto:

Não, estou falando do ObjectCreate(), você tem que definir o número da janela lá. Mostrei como configurá-lo se for uma subjanela (ou seja, não zero, que é a janela principal).

Então você tem o parâmetro de função WindowOnDropped lá quando cria um objeto, e já é uma espécie de janela principal relativamente. Ou a janela principal é ajanela mais à esquerda no terminal?

Olá! Não consigo entender por que as compras não são excluídas.

extern double Lots       =0.01;
extern int    Magic      =333;

extern int    StopLoss      = 100;      // Размер фиксированного стопа
extern int    TakeProfit    = 100;       // Размер фиксированного тэйка
extern int    DistanceSet   = 160;      // Расстояние от рынка
extern int    Slippage      = 3;       // Проскальзывание цены
color  clOpenBuy     = LightBlue;    // Цвет ордера BuyStop
color  clOpenSell    = LightCoral;   // Цвет ордера SellStop
string Name_Expert   = "Scalp";

string Symb;
bool Work=true;

extern bool   UseSound       = True;  // Использовать звуковой сигнал
extern string NameFileSound  = "expert.wav";  // Наименование звукового файла
//============================================================================================
int start()
  {
   int
   Total,
   Tip=-1,
   Ticket,
   TicketB,
   TicketS,
   TicketMB,
   TicketMS,
   buys,
   sells,
   mbuys,
   msells;
   double
   OP_PriceSell,
   OP_PriceBuy, 
   Lot,
   Lts,
   Min_Lot,
   Max_Lot,
   Step,
   Free,
   One_Lot,
   Price,
   SL,
   TP,
   TP1,
   PriceB,
   PriceS,
   SLB,
   SLS;
   bool
   Ans  =false,
   Opn_B=false,
   Opn_S=false,
   Cls_B=false,
   Cls_S=false;
//============================================================================================
   // Учёт ордеров
   Symb=Symbol();
   Total=0;
   buys=0;
   sells=0;
   mbuys=0;
   msells=0;                                    
   for(int i=1; i<=OrdersTotal(); i++)
     {
      if (OrderSelect(i-1,SELECT_BY_POS)==true)
        {
         Total++;
         if(OrderType()==OP_BUYSTOP)  buys++;
         if(OrderType()==OP_SELLSTOP) sells++;
         if(OrderType()==OP_BUY)  mbuys++;
         if(OrderType()==OP_SELL) msells++;
         if(OrderType()==OP_BUYSTOP) TicketB=OrderTicket();
         if(OrderType()==OP_SELLSTOP) TicketS=OrderTicket(); 
         Ticket=OrderTicket();
         Tip   =OrderType();
         TP    =OrderTakeProfit();
         Lot   =OrderLots();
        }
     }
//============================================================================================
   // Открытие ордеров
   while(true)                                  
     {
      if (Total==0)            
        {                                      
         star();
        }
      break;                                   
     }
//============================================================================================
  while(true)
     {
      if(Total==2)
        {
         if(msells==1)
           {
            if(buys==1)
              {
               if(OrderType()==OP_BUYSTOP && OrderLots()==Lots)
                 {
                  OrderDelete(Ticket);
                 }
              }
           }
        }
      if(Total==2)
        {
         if(mbuys==1)
           {
            if(sells==1)
              {
               if(OrderType()==OP_SELLSTOP && OrderLots()==Lots)
                 {
                  OrderDelete(Ticket);
                 }
              }
           }
        }
      break;
     }  
//============================================================================================
   return;
  }
//============================================================================================
//+------------------------------------------------------------------+
void star() {
  double ldStop=0, ldTake=0;
  double pAsk=Ask+DistanceSet*Point;
  double pBid=Bid-DistanceSet*Point;

  if (StopLoss!=0) ldStop=pAsk-StopLoss*Point;
  if (TakeProfit!=0) ldTake=pAsk+TakeProfit*Point;
  SetOrder(OP_BUYSTOP, pAsk, ldStop, ldTake);

  if (StopLoss!=0) ldStop=pBid+StopLoss*Point;
  if (TakeProfit!=0) ldTake=pBid-TakeProfit*Point;
  SetOrder(OP_SELLSTOP, pBid, ldStop, ldTake);
}

//+------------------------------------------------------------------+
//| Установка ордера                                                 |
//| Параметры:                                                       |
//|   op     - операция                                              |
//|   pp     - цена                                                  |
//|   ldStop - уровень стоп                                          |
//|   ldTake - уровень тейк                                          |
//+------------------------------------------------------------------+
void SetOrder(int op, double pp, double ldStop, double ldTake) {
  color  clOpen;
  string lsComm=GetCommentForOrder();

  if (op==OP_BUYSTOP) clOpen=clOpenBuy;
  else clOpen=clOpenSell;
  OrderSend(Symbol(),op,Lots,pp,Slippage,ldStop,ldTake,lsComm,0,0,clOpen);
  if (UseSound) PlaySound(NameFileSound);
}

//+------------------------------------------------------------------+
//| Генерирует и возвращает строку коментария для ордера или позиции |
//+------------------------------------------------------------------+
string GetCommentForOrder() {
  return(Name_Expert+" "+GetNameTF(Period()));
}

//+------------------------------------------------------------------+
//| Возвращает наименование таймфрейма                               |
//+------------------------------------------------------------------+
string GetNameTF(int TimeFrame) {
        switch (TimeFrame) {
                case PERIOD_MN1: return("Monthly");
                case PERIOD_W1:  return("Weekly");
                case PERIOD_D1:  return("Daily");
                case PERIOD_H4:  return("H4");
                case PERIOD_H1:  return("H1");
                case PERIOD_M30: return("M30");
                case PERIOD_M15: return("M15");
                case PERIOD_M5:  return("M5");
                case PERIOD_M1:  return("M1");
                default:                     return("UnknownPeriod");
        }
}
//+------------------------------------------------------------------+
hoz:

Então por que a documentação diz que
o número de tampões não pode exceder 8
. Não diz o número de amortecedores principais... nem todos os amortecedores. Diz o número de amortecedores e pronto. Portanto, estou lendo-o e deve ser aplicado ao número total de amortecedores de um determinado indicador.

Não estou falando dos amortecedores indicadores, estou falando dos amortecedores indicadores simulados. E há ArrayResize(CustomBuffer, Bars) na embalagem do IndicatorCounted(), e as extremidades das linhas de tendência mais à direita devem ser redesenhadas por Bid.

hoz:

Então você tem um parâmetro de função lá quando cria um objeto - WindowOnDropped, e já é uma espécie de janela principal relativamente. Ou a janela principal é a mais esquerdaentre as janelas do terminal?
Não, no início eu também fiquei confuso. Por exemplo, temos dois gráficos abertos, euron e gold. Portanto, ambos têm um índice de zero. Mas, se tiverem sub-janelas, elas são numeradas a partir de uma. Por exemplo, joguei três índices na tabela eurenne, dois no ouro e todos os cinco com # janela separada e todas as diferentes subjanelas. Então eurene terá os números de janela 0, 1, 2, 3 e ouro 0, 1, 2.

Eu tenho uma pergunta. Meu cérebro está fervendo, honestamente. Se você puder - me ajude.

int n=1, limit=3;
double result;//или int result, что не столь сейчас важно
double temp[];
int start(){
        for(int slow=10; slow<=10*limit; slow++){
                for(int fast=10; fast<=slow; fast++){
                        for(int period=1; period<=slow/10; period++){
                                n++; Print(n-1, ": ", slow-9, ", ", fast-9, ", ", period);
                                //здесь идёт тестирование машки с параметрами slow, fast, period, а результаты тестирования заносим в массив:
                                ArrayResize(temp,n); temp[n-1]=result;
                        }
                }
        }
        //и находим максимальный результат:
        int max=ArrayMaximum(temp);
   return(0);
}

Agora uma pergunta: como posso restaurar valores lentos, rápidos, por período máximo (que é a posição de um item na matriz)? A ordem na qual os valores são colocados em temp[] é dada em Print(). Eu coloquei 3 no limite, mas qualquer número pode ser usado lá. Aqui estão os primeiros 77 valores (limite=2):

            10: 4, 4, 1  20: 6, 5, 1  30: 8, 2, 1  40: 9, 4, 1   50: 10, 5, 1   60: 11, 3, 1  70: 11, 8, 1
1: 1, 1, 1  11: 5, 1, 1  21: 6, 6, 1  31: 8, 3, 1  41: 9, 5, 1   51: 10, 6, 1   61: 11, 3, 2  71: 11, 8, 2
2: 2, 1, 1  12: 5, 2, 1  22: 7, 1, 1  32: 8, 4, 1  42: 9, 6, 1   52: 10, 7, 1   62: 11, 4, 1  72: 11, 9, 1
3: 2, 2, 1  13: 5, 3, 1  23: 7, 2, 1  33: 8, 5, 1  43: 9, 7, 1   53: 10, 8, 1   63: 11, 4, 2  73: 11, 9, 2
4: 3, 1, 1  14: 5, 4, 1  24: 7, 3, 1  34: 8, 6, 1  44: 9, 8, 1   54: 10, 9, 1   64: 11, 5, 1  74: 11, 10, 1
5: 3, 2, 1  15: 5, 5, 1  25: 7, 4, 1  35: 8, 7, 1  45: 9, 9, 1   55: 10, 10, 1  65: 11, 5, 2  75: 11, 10, 2
6: 3, 3, 1  16: 6, 1, 1  26: 7, 5, 1  36: 8, 8, 1  46: 10, 1, 1  56: 11, 1, 1   66: 11, 6, 1  76: 11, 11, 1
7: 4, 1, 1  17: 6, 2, 1  27: 7, 6, 1  37: 9, 1, 1  47: 10, 2, 1  57: 11, 1, 2   67: 11, 6, 2  77: 11, 11, 2
8: 4, 2, 1  18: 6, 3, 1  28: 7, 7, 1  38: 9, 2, 1  48: 10, 3, 1  58: 11, 2, 1   68: 11, 7, 1
9: 4, 3, 1  19: 6, 4, 1  29: 8, 1, 1  39: 9, 3, 1  49: 10, 4, 1  59: 11, 2, 2   69: 11, 7, 2
gyfto:

Eu tenho uma pergunta. Meu cérebro está fervendo, honestamente. Se você puder - me ajude.

Agora uma pergunta: como posso restaurar valores lentos, rápidos, por período máximo (que é a posição de um item na matriz)? A ordem na qual os valores são colocados em temp[] é dada em Print(). Eu coloquei 3 no limite, mas pode ser qualquer número.


Onde "n++" verifica se o resultado é máximo, se é máximo, lembre-se dos valores de lento, rápido, etc.
Você poderia fazer mais três arrays (ou uma matriz tridimensional) para lentos, rápidos... Isto é melhor, pois caso você queira classificar os resultados de alguma forma, sempre haverá parâmetros de teste disponíveis.
Se estas ações forem freqüentes, por exemplo, uma vez por barra ou 10 barras, é melhor escalar as matrizes para resultados e três matrizes com valores de parâmetro no item, percorrer estes loops, preencher as matrizes com valores de período. Em seguida, rolar tudo de uma só vez. Então, poderemos usar a função ArrayMaximum e resolver as coisas. Isto tornará o trabalho o mais rápido possível.
gyfto:

Não, no início eu também fiquei confuso. Por exemplo, temos dois gráficos abertos, o euro e o ouro. Portanto, ambos têm um índice de zero. Mas, se tiverem sub-janelas, elas são numeradas a partir de uma. Por exemplo, joguei três índices na tabela eurenne, dois no ouro e todos os cinco com # janela separada e todas as diferentes subjanelas. Então o eurene teria os números de janela 0, 1, 2, 3 e o ouro teria 0, 1, 2.

Exatamente! Eu simplesmente não trabalho com perus, por isso não prestei atenção quando estudava a ajuda. Tudo isso faz sentido.

gyfto:

Não estou falando de amortecedores indicadores, estou falando de amortecedores indicadores simulados. Aí ArrayResize(CustomBuffer, Bars) na embalagem do IndicatorCounted(), e as extremidades das linhas de tendência mais à direita devem ser redesenhadas por Bid.

E eu estava perguntando especificamente como desenhar mais de 6 linhas em um gráfico. Em que janela (0 ou outra, não importa). É nisso que estou mais interessado e foi sobre isso que eu lhe perguntei em primeiro lugar.
Integer:

Onde "n+++" faz a verificação do resultado máximo, se máximo, lembre-se dos valores de lento, rápido, etc.

Não pensei sobre isso.


Inteiro:
Você pode fazer mais três arrays (ou um array tridimensional) para lentos, rápidos... Isso é melhor, pois caso você queira classificar os resultados de alguma forma, sempre haverá parâmetros de teste disponíveis.

Tridimensional é ideal, mas o ArrayMaximum() só funciona em uma dimensão, então você terá que convergir a matriz em uma linear, e novamente você terá que descobrir onde tudo está. Mas eu tenho fastMax=slow, e esse é o problema. Mas três matrizes diferentes... Eu tenho o mesmo resultado, portanto é uma tridimensional ou uma linear.


Inteiro:
arrays de escala para resultados

Eu não conheço esta terminologia, por favor explique. Criar uma matriz linear de comprimento em um cubo?


Bem, pelo menos já existe uma opção. Via MathMax(resultado, resultadoPrev).

1...417418419420421422423424425426427428429430431432
Novo comentário