Prüfung von Echtzeit-Prognosesystemen

Denis Timoshin 2009.11.24 14:11 #761

mpeugep писал(а) >>

Ich habe früher EAs darauf geschrieben, also habe ich mich daran gewöhnt.

Wollen Sie die Wirksamkeit Ihrer Prognosemethode ermitteln?

Дима 2009.11.24 14:20 #762

Ja - durch Testen, und das ist es, was ich tue...

Сергей 2009.11.24 21:17 #763

Der zweite Tag der Vorhersage neigt sich dem Ende zu. Zur Erinnerung: Die grundlegenden "Attraktoren" (d. h. 200 Flugbahnen, die die folgenden "durchschnittlichen" Flugbahnen bilden)

Identifikation Einheit getestet wird, statt der "idealen Flugbahn", wählte die nächste am Samstag, gleich (es ist nicht so schwierig mit ihnen, in Bezug auf die Entscheidungen, in der Regel warten auf die ersten Zählungen ...):

Werfen Sie die Fährte.

PS: Yay, ich bin cool, ich habe eine weitere Funktion in MT implementiert, - "skylining indicator", äh ich bin nicht ganz sicher, dass es richtig funktioniert

double getScaleParametr(double signal[])
{
   int i;
   int n;
   int m;
   
   double h;

   // +------------------------------------------------------+
   // |                       Интегрирование временного ряда |
   // +------------------------------------------------------+
   
   int N;
   int Nsignal;
   
   double delta[];
   
   Nsignal=ArraySize( signal);
   N= Nsignal-1;
   
   ArrayResize( delta, N);
   ArrayInitialize( delta, 0.0);
   
   i=0;
   
   for( n=0; n<= Nsignal-1; n++)
   {
      if( n>0)
      {
         delta[ i]=MathAbs( signal[ n]- signal[ n-1]);
         i= i+1;
      }
   }
   
   // +------------------------------------------------------+
   // |                       Расчет накопленного отклонения |
   // +------------------------------------------------------+
   
   double Mu;
   double SUM;
   double accumulateDeviation[];

   ArrayResize( accumulateDeviation, N);
   ArrayInitialize( accumulateDeviation, 0.0);
   
   Mu= getMu( delta);
   SUM=0.0;
   
   for( n=0; n<= N-1; n++)
   {
      SUM= SUM+( delta[ n]- Mu);
      accumulateDeviation[ n]= SUM;
   }
   
   // +------------------------------------------------------+
   // |                          Итерационный расчет матрицы |
   // +------------------------------------------------------+   
   
   int window;
   int s;
   int k;
   int M;
   int zone;
   
   double a;
   double b;
   
   double x[];
   double y[];
   
   double T[];
   double F[];
   
   double trend[];
   double regress[];
   
   zone=5;

   ArrayResize( T, N- zone);
   ArrayInitialize( T, 0.0);   

   ArrayResize( F, N- zone);
   ArrayInitialize( F, 0.0);   
   
   i=0;
   
   for( window= zone; window<= N; window++)
   {
      s=MathFloor( N/ window);

      ArrayResize( trend, s* window);      
      ArrayInitialize( trend, 0.0);
      
      for( n=0; n<= s-1; n++)
      {
         ArrayResize( x, window);
         ArrayInitialize( x, 0.0);

         ArrayResize( y, window);
         ArrayInitialize( y, 0.0);
         
         for( m=0; m<= window-1; m++)
         {
            x[ m]= m;
            y[ m]= accumulateDeviation[ m+ n* window];
         }

         ArrayResize( regress, 2);
         ArrayInitialize( regress, 0.0);
         
         getLineRegression( regress, x, y);
         
         a= regress[0];
         b= regress[1];

         for( m=0; m<= window-1; m++)
         {
            trend[ m+ n* window]= a+ b* x[ m];
         }
      }

      SUM=0.0;
      
      M=ArraySize( trend);
      
      for( k=0; k<= M-1; k++)
      {
         SUM= SUM+MathPow(( accumulateDeviation[ k]- trend[ k]), 2);
      }
      
      T[ i]=MathLog( window);
      F[ i]=MathLog(MathSqrt((1.0/ M)* SUM));

      i= i+1;
   }

   ArrayResize( regress, 2);
   ArrayInitialize( regress, 0.0);
   
   getLineRegression( regress, T, F);
   h= regress[1];
   
   return( h);
}