Tareas de entrenamiento cerebral relacionadas con el comercio de un modo u otro. Teórico, teoría del juego, etc. - página 22

[Роман]

new-rena:
Está bien. Ya he publicado el código. Sólo voy a agitarlo hasta la respuesta correcta y ya está.

¿Compartirás el resultado...? :-)

[[Eliminado]]

new-rena:
Me pregunto: ¿qué aspecto tiene una progresión geométrica no sinusoidal?

[[Eliminado]]

avtomat:

Muy decente. Es decir, decimos que cada apertura posterior de un lote en pips está cada vez más cerca de un cambio de tendencia, por lo que no aumentaremos el tamaño de la orden, pero la abriremos por si acaso algo va mal))

[Sceptic Philozoff]

Renat, ¿qué necesitas, resolver una ecuación o algo más?

Si la ecuación

MiniLot^(x^0)+MiniLot^(x^1)+MiniLot^(x^2) ... + MiniLot^(x^(N-1))=VolMax

debe ser resuelto con respecto a x, entonces es más fácil que nunca - por el método de Newton o secantes. Pero hay que especificar MiniLot, VolMax y N.

[[Eliminado]]

new-rena:
Eso es bastante decente. Es decir, decimos que cada paso de apertura de lote posterior en pips se acerca cada vez más a un cambio de tendencia, por lo que no aumentaremos el tamaño de la orden, pero la abriremos por si acaso algo va mal))

No sé si .... Sólo estaba resolviendo un problema... no se trataba de retrocesos, tendencias o cualquier otra cosa.

Y también tengo mis propias ideas al respecto.

[[Eliminado]]

Mathemat:
Renat, ¿qué necesitas, resolver la ecuación o algo más?

Ahora quiero escribir su solución en forma de fórmula. Ya estoy derivando la fórmula.

Muchas gracias.

[Sceptic Philozoff]

new-rena: Ahora quiero escribir su solución en forma de fórmula. Ya estoy elaborando la fórmula.

No puedes derivar una fórmula, tendrás un cerebro canceroso. Pero es posible escribir una función que lo resuelva aproximadamente. Pero eso si hay que resolverlo con respecto a x, claro.

[[Eliminado]]

Mathemat:
No puedes derivar una fórmula, tendrás cáncer en el cerebro. Pero se puede escribir una función que lo resuelva aproximadamente. Pero eso si hay que resolverlo con respecto a x, claro.

Lo he hecho, es realmente una función.

[Sceptic Philozoff]

new-rena: Hecho, efectivamente la función

Muéstrame.

P.D. Mi cerebro se niega a resolver un problema tan extraño y ajeno. No se respeta la monotonicidad de la primera derivada. Y esto me impide resolver fácil y sencillamente la ecuación en x por secantes/método de Newton. Aunque una búsqueda tonta (fuertemente optimizada) lo resuelve bastante rápido.

Pero si no fuera una duplicación, sino una simple multiplicación, todo sería más fácil y claro.

Este es el algoritmo más tonto. Pero es rápido. Necesita unas 50 iteraciones para obtener una precisión de 10^(-8).

Aquí está la foto de avtomat de la página anterior, para empezar.

Y ahora el mío (con los mismos parámetros):

Y el código:

#property show_inputs

extern double _MiniLot = 0.01;
extern double _N = 77;
extern double _VolMax = 5.96;
extern double _err = 0.0000000001;
extern double _parts = 7;


double resolve( double err, int& count )
{
   double currErr = 10;
   double xLeft = 0.00000001;
   double xRight;
   double valLeft, valRight;
   double step = _VolMax / _parts;
   count = 0;
   while( step > err )
   {
      count ++;
      xRight = xLeft + step;
      valLeft = funct( xLeft );
      valRight = funct( xRight );
      if( valLeft * valRight > 0 )     
      { 
         xLeft += step; 
         continue; 
      }
      else                             step /= _parts;
   }
   return( xLeft );
}//+------------------------------------------------------------------+


      double funct( double x )
      {
         double sum = 0;
         for( int i = 0; i < _N; i ++ )
         {
            double xPowered = MathPow( x, i );
            sum += MathPow( _MiniLot, xPowered );
         }   
         return( sum - _VolMax );
      }//+------------------------------------------------------------------+




int start( )
{
   int st = GetTickCount( );
   int count;
   double x = resolve( _err, count );
   double gone = ( GetTickCount( ) - st ) / 1000.;
   Print( "Root is x = " + x + "; funct is f = " + funct( x ) + "; gone " + gone + " sec.; count = " + count  + " steps");
   return( 0 );
}//+------------------------------------------------------------------+

P.D. Es bueno tener en cuenta que este algoritmo sólo funciona para esta función. Es monótona y, por tanto, tiene una única raíz. Lamentablemente, la no monotonicidad de la primera derivada hace imposible aplicar el método de la tangente. Cierto, la pérdida no se siente en absoluto - el tiempo de cálculo que se toma usando GetTickCount() ni siquiera se cuenta.

[[Eliminado]]

hay un poco más de solución

para completar el cuadro ;))