Gehirnjogging-Aufgaben, die auf die eine oder andere Weise mit dem Handel zusammenhängen. Theoretiker, Spieltheorie, usw. - Seite 22

[Роман]

new-rena:
Das ist in Ordnung. Ich habe den Code bereits veröffentlicht. Ich schüttele sie nur bis zur richtigen Antwort auf und das war's.

Werden Sie das Ergebnis mitteilen? :-)

[[Gelöscht]]

new-rena:
Ich frage mich - wie sieht sie aus - eine nicht-sinusförmige geometrische Progression?

[[Gelöscht]]

avtomat:

Sehr anständig. D.h. wir sagen, dass jede nachfolgende schrittweise Öffnung eines Lots in Pips einer Trendumkehr immer näher kommt, also werden wir die Ordergröße nicht erhöhen, aber wir werden sie öffnen, nur für den Fall, dass etwas schief geht)))

[Sceptic Philozoff]

Renat, was brauchst du also - eine Gleichung lösen oder etwas anderes?

Wenn die Gleichung

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

in Bezug auf x zu lösen ist, dann ist es einfacher denn je - mit der Newton-Methode oder Sekanten. Sie müssen jedoch MiniLot, VolMax und N angeben.

[[Gelöscht]]

new-rena:
Das ist ziemlich anständig. D.h., wir sagen, dass jeder nachfolgende Lot-Eröffnungsschritt in Pips immer näher an eine Trendumkehr herankommt, also werden wir die Ordergröße nicht erhöhen, aber wir werden sie öffnen, nur für den Fall, dass etwas schief geht)))

Ich weiß nicht, ob das.... Ich habe nur ein Problem gelöst... es ging nicht um Umkehrungen, Trends oder sonst etwas.

Und ich habe auch meine eigenen Ideen dazu.

[[Gelöscht]]

Mathemat:
Renat, was brauchst du also - die Lösung der Gleichung oder etwas anderes?

Jetzt möchte ich die Lösung in Form einer Formel schreiben. Ich bin schon dabei, die Formel abzuleiten.

Ich danke Ihnen vielmals.

[Sceptic Philozoff]

new-rena: Nun möchte ich die Lösung in Form einer Formel schreiben. Ich bin schon dabei, die Formel auszuarbeiten.

Wenn man keine Formel ableiten kann, bekommt man ein krebsartiges Gehirn. Es ist jedoch möglich, eine Funktion zu schreiben, die diese Aufgabe annähernd löst. Aber das gilt natürlich nur, wenn man sie in Bezug auf x lösen muss.

[[Gelöscht]]

Mathemat:
Man kann keine Formel ableiten, sonst bekommt man Krebs im Gehirn. Aber man kann eine Funktion schreiben, die das Problem annähernd löst. Aber das gilt natürlich nur, wenn man die Aufgabe in Bezug auf x lösen muss.

Ich habe es getan, es ist wirklich eine Funktion.

[Sceptic Philozoff]

new-rena: Erledigt, nämlich die Funktion

Zeigen Sie es mir.

P.S. Mein Gehirn weigert sich, ein so seltsames, fremdes Problem zu lösen. Die Monotonie der ersten Ableitung wird nicht beachtet. Und das hindert mich daran, die Gleichung nach x leicht und einfach durch Sekanten/Newtonsche Methode zu lösen. Eine dumme Suche (stark optimiert) löst das Problem jedoch recht schnell.

Aber wenn es sich nicht um eine Verdopplung, sondern um eine einfache Multiplikation handeln würde, wäre alles einfacher und klarer.

Hier ist der dümmste Algorithmus. Es geht aber schnell. Es sind etwa 50 Iterationen erforderlich, um eine Genauigkeit von 10^(-8) zu erreichen.

Hier ist das Bild von avtomat von der vorherigen Seite, für den Anfang.

Und jetzt meine (gleiche Parameter):

Und 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. Es ist gut zu wissen, dass dieser Algorithmus nur für diese Funktion funktioniert. Sie ist monoton und hat daher eine einzige Wurzel. Leider macht die Nichtmonotonie der ersten Ableitung die Anwendung der Tangens-Methode unmöglich. Richtig, der Verlust ist überhaupt nicht spürbar - die mit GetTickCount() benötigte Berechnungszeit wird nicht einmal gezählt.

[[Gelöscht]]

die Lösung hat noch mehr zu bieten

um das Bild zu vervollständigen ;))