与交易有关的脑力训练任务，以这种或那种方式进行。理论家，博弈论，等等。 - 页 22

[Роман]

new-rena:
这很好。我已经发布了代码。我只是要把它摇到正确的答案，就这样了。

你会分享结果吗...？:-)

[[删除]]

new-rena:
我想知道--它看起来像什么--一个非正弦波的几何级数？

[[删除]]

avtomat:

非常体面。即我们说，以后每一步开仓的点数都离趋势反转越来越近，所以我们不会增加订单量，但我们会开仓，以防出错））。

[Sceptic Philozoff]

雷纳特，那么你需要什么--解方程还是其他什么？

如果方程

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

要解决关于x的问题，那么就比以前更容易了--通过牛顿法 或正切法。但你需要指定MiniLot、VolMax和N。

[[删除]]

new-rena:
那是相当体面的。也就是说，我们说以后每开一手的点数都越来越接近趋势反转，所以我们不会增加订单量，但我们会打开它，以防出错))

我不知道....我只是在解决一个问题......这与反转、趋势或其他任何东西无关。

对此，我也有自己的想法。

[[删除]]

Mathemat:
雷纳特，那么你需要什么--解方程还是别的什么？

现在我想以公式的形式写出它的解决方案。我已经在推导这个公式了。

非常感谢你。

[Sceptic Philozoff]

new-rena: 现在我想以公式的形式写出它的解决方案。我已经在计算这个公式了。

你不能推导出一个公式，你会得到一个癌症的大脑。但有可能写一个函数来近似地解决它。但这是在你必须就x求解的情况下，当然。

[[删除]]

Mathemat:
你不能推导出一个公式，你的大脑会得癌症。但你可以写一个函数来近似解决这个问题。但这是在你必须就x求解的情况下，当然。

我已经做了，这真的是一种功能。

[Sceptic Philozoff]

new-rena: 完成了，确实是这样的，函数

给我看看。

P.S. 我的大脑拒绝解决这样一个奇怪的、陌生的问题。第一个导数的单调性没有得到尊重。而这使我无法通过正切/牛顿法轻松简单地解出关于x的方程。虽然哑巴搜索（强烈优化）可以相当快地解决这个问题。

但如果不是翻倍，而是简单的乘法，一切都会变得更容易、更清晰。

这里有一个最愚蠢的算法。不过，这很迅速。它需要大约50次迭代才能得到10^(-8)的精度。

这里是avtomat 在前一页的照片，作为开始。

现在是我的（同样的参数）。

还有代码。

#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. 请记住，这个算法只对这个函数起作用，这是好事。它是单调的，因此有一个单根。不幸的是，第一个导数的非单调性使得它无法应用切线法。诚然，根本感觉不到损失--使用GetTickCount() 所花费的计算时间甚至没有计算在内。

[[删除]]

解决办法还有很多

来完成这幅画;))