Auswertung einer Messreihe

[Tobias W. (wagnertobse)]

Im Rahmen meiner Diplomarbeit, muss ich eine TDEV Auswertung nach ITU-T 
G.810 II.3 machen.
Um diese Auswertung durchzuführen, habe ich ein kleines C++ Programm 
geschrieben. Im Anhang befindet sich die Formel, zur Berechnung des 
TDEV.

Leider bin ich mir bei den Ergebnissen für größere n relativ unsicher, 
ob sie richtig sind. Könnt ihr mal die Formel mit meinen C++ Code 
vergleichen und sagen, ob ich noch einen Fehler im Code habe?


In TIE[] sind die Messpunkte enthalten.
size gibt die Größe des Arrays TIE, in der Funktion berechnenTDEV der 
Klasse auswertung, an. Size kann in manchen Fällen eine Größen von 
200.000 annehmen.


C++code:

double auswertung::berechnenTDEV(unsigned int n){
  double *zwischenspeicher1 = new double [n];
  double *zwischenspeicher2 = new double [size-3*n+1];
  for(unsigned int j = 0;j<=(size-3*n);j++){
    for(unsigned int i=j;i<=(n+j-1);i++){
      zwischenspeicher1[i-j]=TIE[i+2*n]-2*TIE[i+n]+TIE[i];
    }
    double y = array_addieren(zwischenspeicher1,n);
    y = y*y;
    zwischenspeicher2[j] = y;
  }
  double z = array_addieren(zwischenspeicher2,size-3*n+1);
  z= z / (6*n*n*(size-3*n+2));
  return(sqrt(z));
}

//Erzeugt die Summe eines Arrays
double array_addieren(double *array1, int size){
  while(1){
    if(size == 1){
      break;
    }
    for(int i = 0;i<size/2;i++){
      array1[i]=array1[i*2]+array1[i*2+1];
    }
    if(size%2){
      array1[(size/2)-1]=array1[(size/2)-1]+array1[size-1];
    }
    size = size/2;
  }
  return(array1[0]);
}

[Yalu X. (yalu) (Moderator)]

Hier

  z= z / (6*n*n*(size-3*n+2));

muss statt der 2 eine 1 stehen.

Außerdem solltest du die mit new angelegten Arrays am Ende der Funktion
wieder deleten.

Warum ist array_addieren so kompliziert? Soll das eine Optimierung für
einen Parallelrechner sin? Sonst könntest du dir sogar die Arrays sparen
und stattdessen das Aufsummieren in zwei einfachen Variablen in
berechnenTDEV vornehmen.

[Tobias W. (wagnertobse)]

Danke, bei der 2 habe ich mich scheinbar vertippt.

Die Funktion Array_addieren habe ich programmiert, um Rundungsfehler zu 
minimieren. Wenn man es mit einfachen Variablen löst, wird nach vielen 
durchläufen eine kleine Zahl zu einer Großen addiert. Bei 200.000 
durchläufen machte es bei Double nicht viel aus, jedoch soll das 
Programm auch bei größeren Messreihen funktionieren.

[Dieter (Gast)]

Bei komplizierteren Formeln gehe ich gerne mal den Umweg und realisiere 
das in Matlab (Octave) um mir damit Vergleichswerte oder Testparameter 
für eine Art "Unittest" zu erstellen. In C verliert man schonmal schnell 
den Überblick.
Dann eine kleiner "Unittest" für die C-Funktion mit angehängtem 
Vergleichsprotokoll. So kann man immer mal wieder bei Codeänderungen die 
Funktionalität prüfen. Wichtig sind halt korrekte Schnittstellen der 
Funktion.

[Tobias W. (wagnertobse)]

Fals es jemanden interessiert, ich habe selber noch einen Fehler 
gefunden.
Bei Messreihen, die länger als 40minuten gehen, kommt es an der Stelle
z= z / (6*n*n*(size-3*n+));
zu einen Überlauf