Compiti di allenamento del cervello legati al trading in un modo o nell'altro. Teorico, teoria dei giochi, ecc. - pagina 22

[Роман]

new-rena:
Va bene. Ho già pubblicato il codice. Mi limiterò a scuoterlo fino alla risposta giusta ed è tutto.

Condividerai il risultato...? :-)

[[Eliminato]]

new-rena:
Mi chiedo - che aspetto ha - una progressione geometrica non sinusoidale?

[[Eliminato]]

avtomat:

Molto decente. Cioè diciamo che ogni successiva apertura di un lotto in pip si avvicina sempre di più a un'inversione di tendenza, quindi non aumenteremo la dimensione dell'ordine, ma lo apriremo solo nel caso in cui qualcosa vada storto)))

[Sceptic Philozoff]

Renat, allora di cosa hai bisogno - di risolvere un'equazione o qualcos'altro?

Se l'equazione

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

deve essere risolto rispetto a x, allora è più facile che mai - con il metodo di Newton o le secanti. Ma è necessario specificare MiniLot, VolMax e N.

[[Eliminato]]

new-rena:
Questo è abbastanza decente. Cioè, diciamo che ogni passo successivo di apertura del lotto in pip è sempre più vicino a un'inversione di tendenza, quindi non aumenteremo la dimensione dell'ordine, ma lo apriremo solo nel caso in cui qualcosa vada storto)))

Non lo so .... Stavo solo risolvendo un problema... non si trattava di inversioni, tendenze o altro.

E anche io ho le mie idee al riguardo.

[[Eliminato]]

Mathemat:
Renat, di cosa hai bisogno - di risolvere l'equazione o di qualcos'altro?

Ora voglio scrivere la sua soluzione sotto forma di formula. Sto già ricavando la formula.

Grazie mille.

[Sceptic Philozoff]

new-rena: Ora voglio scrivere la sua soluzione sotto forma di formula. Sto già elaborando la formula.

Non puoi derivare una formula, ti verrà un cervello canceroso. Ma è possibile scrivere una funzione che la risolva approssimativamente. Ma questo se si deve risolvere rispetto a x, ovviamente.

[[Eliminato]]

Mathemat:
Non puoi derivare una formula, ti verrà il cancro al cervello. Ma si può scrivere una funzione che la risolva approssimativamente. Ma questo se si deve risolvere rispetto a x, ovviamente.

L'ho fatto, ma è davvero una funzione

[Sceptic Philozoff]

new-rena: Fatto, infatti la funzione

Mostrami.

P.S. Il mio cervello si rifiuta di risolvere un problema così strano e alieno. La monotonicità della derivata prima non è rispettata. E questo mi impedisce di risolvere facilmente e semplicemente l'equazione su x con il metodo delle secanti/Newton. Anche se una ricerca stupida (fortemente ottimizzata) lo risolve piuttosto rapidamente.

Ma se non fosse un raddoppio, ma una semplice moltiplicazione, tutto sarebbe più facile e più chiaro.

Ecco l'algoritmo più stupido. Però è veloce. Ha bisogno di circa 50 iterazioni per ottenere una precisione di 10^(-8).

Ecco la foto di avtomat della pagina precedente, per cominciare.

E ora il mio (stessi parametri):

E il codice:

#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.S. È bene tenere a mente che questo algoritmo funziona solo per questa funzione. È monotona e quindi ha una sola radice. Purtroppo, la non monotonicità della derivata prima rende impossibile applicare il metodo delle tangenti. Vero, la perdita non si sente affatto - il tempo di calcolo preso usando GetTickCount() non viene nemmeno contato.

[[Eliminato]]

c'è un po' di più nella soluzione

per completare il quadro ;))