Tarefas de treinamento do cérebro relacionadas ao comércio de uma forma ou de outra. Teórico, teoria dos jogos, etc. - página 22

[Роман]

new-rena:
Está tudo bem. Eu já afixei o código. Vou apenas agitar para a resposta certa e pronto.

Você vai compartilhar o resultado...? :-)

[[Excluído]]

new-rena:
Eu me pergunto - o que parece - uma progressão geométrica não-inusoidal?

[[Excluído]]

avtomat:

Muito decente. Isto é, dizemos que cada passo subsequente de abertura do lote em pips está cada vez mais próximo de uma inversão de tendência, portanto não vamos aumentar o tamanho do pedido, mas vamos abri-lo no caso de algo dar errado))))

[Sceptic Philozoff]

Renat, então o que você precisa - para resolver uma equação ou algo mais?

Se a equação

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

é para ser resolvido com respeito a x, então é mais fácil do que nunca - pelo método de Newton ou secants. Mas você precisa especificar MiniLot, VolMax e N.

[[Excluído]]

new-rena:
Isso é bastante decente. Ou seja, dizemos que cada passo subsequente de abertura do lote em pips está cada vez mais próximo de uma inversão de tendência, portanto não vamos aumentar o tamanho do pedido, mas vamos abri-lo no caso de algo dar errado))))

eu não sei sobre isso.... Eu estava apenas resolvendo um problema... não se tratava de reversões, tendências ou qualquer outra coisa.

E eu também tenho minhas próprias idéias a respeito disso.

[[Excluído]]

Mathemat:
Renat, então o que você precisa - para resolver a equação ou algo mais?

Agora eu quero escrever sua solução na forma de uma fórmula. Eu já estou derivando a fórmula.

Muito obrigado.

[Sceptic Philozoff]

new-rena: Agora eu quero escrever sua solução na forma de uma fórmula. Eu já estou trabalhando na fórmula.

Você não pode derivar uma fórmula, você terá um cérebro canceroso. Mas é possível escrever uma função que a resolva aproximadamente. Mas isso se você tiver que resolver com respeito a x, é claro.

[[Excluído]]

Mathemat:
Você não pode derivar uma fórmula, você vai ter câncer no cérebro. Mas você pode escrever uma função que a resolva aproximadamente. Mas isso se você tiver que resolver com respeito a x, é claro.

Eu já fiz isso, é realmente uma função.

[Sceptic Philozoff]

new-rena: Feito, de fato a função

Mostre-me.

P.S. Meu cérebro se recusa a resolver um problema tão estranho e alienígena. A monotonicidade da primeira derivada não é respeitada. E isto me impede de resolver a equação sobre x por secants/Newton com facilidade e simplicidade. Embora uma pesquisa idiota (fortemente otimizada) a resolva bastante rapidamente.

Mas se não fosse a duplicação, mas a simples multiplicação, tudo seria mais fácil e mais claro.

Aqui está o algoritmo mais idiota. É rápido, no entanto. São necessárias cerca de 50 iterações para obter uma precisão de 10^(-8).

Aqui está a foto do avtomat da página anterior, para começar.

E agora o meu (mesmos parâmetros):

E 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.S. É bom ter em mente que este algoritmo funciona apenas para esta função. É monótono e, portanto, tem uma única raiz. Infelizmente, a não-monotonicidade da primeira derivada torna impossível a aplicação do método tangente. É verdade, a perda não é sentida de forma alguma - o tempo de computação gasto usando GetTickCount() não é sequer contado.

[[Excluído]]

há um pouco mais de solução

para completar o quadro ;))