Beneficio de un rango de precios aleatorio - página 8

Nuevo comentario
 
avatara:

En mi opinión, el tema merece ser discutido más a fondo. El tiempo ha pasado: había mucho que pensar y aprender.

Especialmente la Transformación de Fisher es una especie de descripción...

;)

He creado dos scripts para generar series de prueba. (para incrementos uniformes y normales).

Por favor, no patalees por la nigromancia y la dejadez en el código apresurado...

La Transformada de Fisher, como cualquier otro expansor, amplifica salvajemente el ruido fraccionario cerca de los límites superior e inferior del intervalo, y en el límite (en el propio límite) con un factor infinito. Para el mercado esto es simplemente relevante - todos los precios están cuantificados por Punto, y por lo tanto, en cierta medida, todos los indicadores también están cuantificados por Punto.
 
NorthernWind:

Sin embargo, si juegas como he sugerido en el enlace anterior, seguro que puedes ganar en paseos aleatorios con mo=0. Pero, una vez más, este no es exactamente el juego del que nos hablan los teoremas. Además, se da una situación paradójica, ya que cuantas más veces se falle, más se gana. Una vez más, este juego no tiene nada que ver con la realidad y pretende demostrar la importancia de realizar pruebas precisas. La cuestión es que las ganancias se acumulan al no contabilizar las apuestas ganadas y perdidas. Así es.

Si consigues jugar a un juego como el que te he sugerido, seguro que te harás rico. :) Y debo añadir que la distribución en este juego también marca una gran diferencia. El juego es simplemente inviable en algunos tipos de vagabundeo aleatorio.

ZS. Sin tener en cuenta lo que se ha discutido, si se convierte la distribución existente en otra, entonces sí se puede tener una ventaja a veces, pero una muy inestable.

Si se entiende bien la idea, se ha esbozado el código para una prueba rápida del mismo en "precios" con una distribución 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));
}

La optimización (toma y pérdida) por el criterio de la costumbre ya ha mostrado claramente el esperado fracaso del antiguo mito (o del mío).

 
hrenfx:

Si entiendo bien la idea, he esbozado el código para una comprobación rápida de los "precios" con una distribución normal de los incrementos:

La optimización (toma y pérdida) por el criterio de la costumbre ya ha mostrado claramente el esperado fracaso del antiguo mito (o del mío).

Señor, su señora se ha ido hace relativamente poco.
 
hrenfx:

Si entiendo bien la idea, he esbozado el código para una comprobación rápida de los "precios" con una distribución normal de los incrementos:

La optimización (toma y pérdida) por el criterio de la costumbre ya ha mostrado claramente el esperado fracaso del antiguo mito (o del mío).

¿Mito de qué?
 
ZaPutina:
¿Mito de qué?

Algunos tíos han discutido sobre la posibilidad de crear una TS rentable sobre los precios generados de la SB (más concretamente, incrementos con una distribución normal). Formalizó la ST, investigó mucho...

Se ha llegado a esto, gracias a una discusión privada relacionada indirectamente con este tema. Porque, tal vez, en algún momento en el futuro un escéptico, decidió esbozar en el dominio público un código de comprobación que nadie necesita.

 

para dickfks , ¿no se puede probar una distribución diferente? por ejemplo, un precio de mercado (generado artificialmente). y como entrada, ¿en qué distribución se puede obtener un beneficio?



 
YOUNGA:

Para dickfks, ¿podría probar otra distribución? por ejemplo, el precio de mercado (generado artificialmente). y para empezar, ¿qué distribución se puede utilizar para obtener un beneficio?

Los beneficios garantizados pueden ser exprimidos a precios "blandos". No se dará la definición de esponjosidad ni la formalización de la ST para ello. Tal vez en otro lugar. Todo esto tiene poco que ver con el comercio real.

El código puede modificarse para adaptarse a cualquier distribución. Para ello, basta con sustituir la función GetRandGauss por la función cuantílica de la distribución deseada: convierte la variable aleatoria uniformemente distribuida (MathRand) en la distribución correspondiente.

 
hrenfx:

Los beneficios garantizados pueden ser exprimidos a precios "blandos". No se dará la definición de esponjosidad ni la formalización de la ST para ello. Tal vez en otro lugar. Todo esto tiene poco que ver con el comercio real.

El código puede modificarse para adaptarse a cualquier distribución. Para ello, basta con sustituir la función GetRandGauss por la función del cuantil de la distribución deseada - convierte la variable aleatoria uniformemente distribuida (MathRand) en la distribución correspondiente.

¿Está diciendo que su código pasa por TODAS las opciones posibles con 100 líneas o menos? Como no lo hace, qué tiene que ver con demostrar que no se puede ganar dinero con el pseudo SB (no hay SB puro en la naturaleza).
 
ZaPutina:
¿Quiere decir que su código pasa por TODAS las variantes posibles con no más de 100 líneas? Y como no lo hace, qué tiene que ver con demostrar que no se puede ganar dinero con el pseudo SB (no hay SB puro en la naturaleza).

Cambia el ruido blanco por la función de distribución que te interesa y comprueba si quieres. Sólo que esto es una tontería: demostrar que no se puede ganar dinero. Demuestra lo contrario.

ZZY Hablando de la naturaleza aleatoria del mercado: su estado actual(precio de cierre de hoy) fue predeterminado el 23.03 a las 19:00+3:00 hora de Moscú.

 
tara:

Cambia el ruido blanco por la función de distribución que te interesa y comprueba si quieres. Sólo que esto es una tontería: demostrar que no se puede ganar dinero. Demuestra lo contrario.

Hablando de la naturaleza aleatoria del mercado: su estado actual (precio de cierre de hoy) fue predeterminado el 23.03 a las 19:00+3:00 hora de Moscú.

Con usted sólo a través de su yerno... sin faltar al respeto.
123456789
Nuevo comentario