Des tâches d'entraînement cérébral liées d'une manière ou d'une autre au commerce. Théoricien, théorie des jeux, etc. - page 22

Nouveau commentaire
 
new-rena:
C'est bon. J'ai déjà posté le code. Je vais juste le secouer jusqu'à la bonne réponse et c'est tout.

Allez-vous partager le résultat... ? :-)
 
new-rena:
Je me demande - à quoi cela ressemble-t-il - une progression géométrique non sinusoïdale ?
 
avtomat:

Très décent. C'est-à-dire que nous disons que chaque étape ultérieure d'ouverture d'un lot en pips se rapproche de plus en plus d'un renversement de tendance, donc nous n'augmenterons pas la taille de l'ordre, mais nous l'ouvrirons juste au cas où quelque chose tournerait mal))).
 

Renat, de quoi avez-vous besoin - de résoudre une équation ou autre chose ?

Si l'équation

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

doit être résolu par rapport à x, alors c'est plus facile que jamais - par la méthode de Newton ou les sécantes. Mais vous devez spécifier MiniLot, VolMax et N.

 
new-rena:
C'est assez décent. C'est-à-dire que nous disons que chaque étape suivante d'ouverture de lot en pips se rapproche de plus en plus d'un renversement de tendance, donc nous n'augmenterons pas la taille de l'ordre, mais nous l'ouvrirons juste au cas où quelque chose tournerait mal))).

Je n'en sais rien.... Je résolvais juste un problème... il ne s'agissait pas de revirements, de tendances ou de quoi que ce soit d'autre.

Et j'ai mes propres idées à ce sujet, aussi.

 
Mathemat:
Renat, de quoi avez-vous besoin - de résoudre l'équation ou d'autre chose ?

Je veux maintenant écrire sa solution sous la forme d'une formule. Je suis déjà en train de dériver la formule.

Merci beaucoup.

 
new-rena: Je veux maintenant écrire sa solution sous la forme d'une formule. Je suis déjà en train d'élaborer la formule.
Vous ne pouvez pas dériver une formule, vous aurez un cerveau cancéreux. Mais il est possible d'écrire une fonction qui la résout approximativement. Mais c'est si vous devez le résoudre par rapport à x, bien sûr.
 
Mathemat:
Tu ne peux pas dériver une formule, tu vas avoir un cancer au cerveau. Mais vous pouvez écrire une fonction qui la résout approximativement. Mais c'est si vous devez le résoudre par rapport à x, bien sûr.
Je l'ai fait, c'est vraiment une fonction.
 
new-rena: Fait, en effet la fonction

Montre-moi.

P.S. Mon cerveau refuse de résoudre un problème aussi étrange et étranger. La monotonicité de la dérivée première n'est pas respectée. Et cela m'empêche de résoudre facilement et simplement l'équation sur x par les sécantes/la méthode de Newton. Bien qu'une recherche muette (fortement optimisée) permette de le résoudre assez rapidement.

Mais si ce n'était pas un doublement, mais une simple multiplication, tout serait plus facile et plus clair.

Voici l'algorithme le plus stupide. Mais c'est rapide. Il faut environ 50 itérations pour obtenir une précision de 10^(-8).

Voici la photo d'avtomat de la page précédente, pour commencer.

Et maintenant le mien (mêmes paramètres) :

Et le code :

#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. Il est bon de garder à l'esprit que cet algorithme ne fonctionne que pour cette fonction. Elle est monotone et a donc une seule racine. Malheureusement, la non-monotonicité de la dérivée première rend impossible l'application de la méthode des tangentes. Il est vrai que la perte n'est pas du tout ressentie - le temps de calcul pris avec GetTickCount() n'est même pas compté.

 

il y a un peu plus que la solution

pour compléter le tableau ;))

1...151617181920212223
Nouveau commentaire