Lucro a partir de uma faixa de preço aleatória - página 8

Novo comentário
 
avatara:

No que me diz respeito, o tema merece ser discutido mais a fundo. O tempo passou - havia muito o que pensar e aprender.

Especialmente a Transformada Fisher é como que descrita...

;)

Eu criei dois scripts para gerar séries de testes. (para incrementos uniformes e normais).

Por favor, não chute por necromancia e desleixo em código apressado...

A transformação Fisher, como qualquer outro expansor, amplifica enormemente o ruído fracionário próximo aos limites superior e inferior do intervalo, e no limite (no próprio limite) com um fator infinito. Para o mercado, isto é apenas relevante - todos os preços são quantificados por ponto, e portanto, em certa medida, todos os indicadores também são quantificados por ponto.
 
NorthernWind:

Entretanto, se você jogar como sugeri no link acima, certamente poderá ganhar em caminhadas aleatórias com mo=0. Mas, mais uma vez, este não é exatamente o jogo do qual somos informados nos teoremas. Além disso, existe uma situação paradoxal, de tal forma que quanto mais vezes você não adivinhar, mais você ganha. Mais uma vez, este jogo não tem nada a ver com a realidade e se destina a demonstrar a importância de testes precisos. A questão é que os ganhos lá são acumulados ao se subestimar as apostas ganhas e perdidas. É isso mesmo.

Se você conseguir jogar um jogo como eu sugeri, você definitivamente ficará rico. :) E eu devo acrescentar que a distribuição neste jogo também faz uma grande diferença. O jogo é simplesmente inviável em alguns tipos de vagabundagem aleatória.

ZS. Sem considerar o que foi discutido, se você converter a distribuição existente para outra, então você pode realmente ter uma vantagem às vezes, mas uma vantagem muito vacilante.

Se você tiver a idéia correta, esboçou o código para um teste rápido sobre "preços" com uma distribuição normal de incrementos:

#property strict

extern int AmountPrices = 10000;
extern int TakeProfit = 100;
extern int StopLoss = 100;
extern double point = 0.0001;
extern int Temp = 0;

#define  MAX_RAND 32767.0

double GetRand()
{
  return(2 * MathRand() / MAX_RAND - 1);
}

void GetRandGauss( double& Rand1, double& Rand2 )
{
  double X1, X2, W = 2;
  
  while (W >= 1)
  {
    X1 = GetRand();
    X2 = GetRand();
    
    W = X1 * X1 + X2 * X2;
  }
  
  W = MathSqrt(-2 * MathLog(W) / W);
  
  Rand1 = X1 * W;
  Rand2 = X2 * W;
    
  return;
}

void GetPrices( double &Prices[], int Amount )
{
  static uint Tmp = 0;
  double Rand1, Rand2;
  
  MathSrand((int)TimeLocal() + Tmp);
  
  Amount <<= 1;
  
  ArrayResize(Prices, Amount);
  
  Prices[0] = 0;
  
  for (int i = 2; i < Amount; i += 2)
  {
    GetRandGauss(Rand1, Rand2);
    Prices[i - 1] = Prices[i - 2] + Rand1;
    Prices[i] = Prices[i - 1] + Rand2;    
  }
  
  Tmp += GetTickCount();
  
  return;
}

void NormalizeArray( double &Array[] )
{
  const int Size = ArraySize(Array);
  const double Interval = ArrayMaximum(Array) - ArrayMinimum(Array);  
  
  for (int i = 0; i < Size; i++)
    Array[i] /= Interval;
    
  return;
}

double System( const double &Prices[], const double TP, const double SL )
{
  const int Amount = ArraySize(Prices);
  bool Flag = TRUE;
  double OpenPrice = Prices[0];
  double Balance = 0;
  
  for (int i = 0; i < Amount; i++)
  {
    if (Flag)
    {
      if ((Prices[i] >= OpenPrice + TP) || (Prices[i] <= OpenPrice - SL))
      {
        Balance += Prices[i] - OpenPrice;
        
        Flag = (MathRand() > (SHORT_MAX + 1) / 2 - 1);  
        OpenPrice = Prices[i];
      }
    }
    else if ((Prices[i] <= OpenPrice - TP) || (Prices[i] >= OpenPrice + SL))
    {
      Balance -= Prices[i] - OpenPrice;

      Flag = (MathRand() > (SHORT_MAX + 1) / 2 - 1);  
      OpenPrice = Prices[i];
    }
  }
  
  return(Balance);
}

double GetRandProfit( int Amount, const double TP, const double SL )
{
   double Prices[];
   
   GetPrices(Prices, Amount >> 1);
   NormalizeArray(Prices);
   
   return(System(Prices, TP, SL));  
}


double OnTester( void )
{
  return(GetRandProfit(AmountPrices, TakeProfit * point, StopLoss * point));
}

A otimização (tomada e perda) por critério personalizado já mostrou claramente o fracasso esperado do antigo mito (ou mina).

 
hrenfx:

Se eu tiver a idéia correta, esbocei o código para uma verificação rápida dos "preços" com uma distribuição normal dos incrementos:

A otimização (tomada e perda) por critério personalizado já mostrou claramente o fracasso esperado do antigo mito (ou mina).

Senhor, sua senhora saiu há relativamente pouco tempo.
 
hrenfx:

Se eu tiver a idéia correta, esbocei o código para uma verificação rápida dos "preços" com uma distribuição normal dos incrementos:

A otimização (tomada e perda) por critério personalizado já mostrou claramente o fracasso esperado do antigo mito (ou mina).

mito de quê?
 
ZaPutina:
mito de quê?

Alguns tios têm argumentado sobre a possibilidade de criar um TS rentável sobre os preços de SB gerados (mais especificamente, incrementos com uma distribuição normal). Formalizou o TS, fez muitas pesquisas...

Chegou a isto, graças a uma discussão privada relacionada indiretamente a este tópico. Pois, talvez, em algum momento no futuro, um cético, decidiu esboçar no domínio público alguns códigos que ninguém precisa verificar.

 

por exemplo, um preço de mercado (gerado artificialmente). e, como iniciante, em qual distribuição você pode ter lucro?



 
YOUNGA:

Por exemplo, o preço de mercado (gerado artificialmente). e, para começar, que distribuição pode ser usada para obter lucro?

Os lucros garantidos podem ser espremidos a preços "fofos". Não será dada a definição de "fluffiness" e a formalização do TS para isso. Talvez em outro lugar. Tudo isso tem pouco a ver com comércio real.

O código pode ser modificado para adequar-se a qualquer distribuição. Para fazer isso, basta substituir a função GetRandGauss pela função quantil da distribuição desejada - ela converte a variável aleatória (MathRand) uniformemente distribuída para a distribuição correspondente.

 
hrenfx:

Os lucros garantidos podem ser espremidos a preços "fofos". Não será dada a definição de "fluffiness" e a formalização do TS para isso. Talvez em outro lugar. Tudo isso tem pouco a ver com comércio real.

O código pode ser modificado para adequar-se a qualquer distribuição. Para isso, basta substituir a função GetRandGauss pela função de quantil de distribuição desejada - ela converte a variável aleatória (MathRand) uniformemente distribuída para a distribuição correspondente.

Você está dizendo que seu código passa por TODAS as escolhas possíveis com 100 linhas ou menos? Como não tem, o que tem a ver com provar que não se pode ganhar dinheiro com pseudo SB (não há SB pura na natureza).
 
ZaPutina:
Você quer dizer que seu código passa por TODAS as variantes possíveis com não mais de 100 linhas? E como não tem, o que tem a ver com provar que não se pode ganhar dinheiro com pseudo SB (não há SB pura na natureza).

Mude o ruído branco para a função de distribuição de interesse e verifique se você deseja fazê-lo. Só que isto é um disparate: provar que não se pode ganhar dinheiro. Comprove o contrário.

ZZY Falando da natureza aleatória do mercado: seu estado atual(preço de fechamento hoje) foi pré-determinado em 23.03 às 19:00+3:00, horário de Moscou.

 
tara:

Mude o ruído branco para a função de distribuição em que você está interessado e verifique se deseja. Só que isto é um disparate: provar que não se pode ganhar dinheiro. Comprove o contrário.

Falando da natureza aleatória do mercado: seu estado atual (preço de fechamento hoje) foi pré-determinado em 23.03 às 19:00+3:00, horário de Moscou.

Com você somente através de seu genro...sem desrespeito.
123456789
Novo comentário