Klassifizierung Problem

Question

Ich habe ein Array von Struktur mit 4 Variablen.

records[i].time 
records[i].xaxis 
records[i].yaxis 
records[i].zaxis 

Wo i wird der Index der Datensätze. Wessen Maximum ist n. In obigem ist records[i].time in aufsteigender Reihenfolge der Zeit in Array angeordnet und ist in Millisekunden. Ich habe die

maximum of records[i].xaxis 
minimum of records[i].xaxis 
maximum of records[i].yaxis 
minimum of records[i].yaxis 
maximum of records[i].zaxis 
minimum of records[i].zaxis 

für eine Gruppe von jedem zweiten in records[i].time finden es die Differenz (Maximum-Minimum) und

neighbour[k].difx 
neighbour[k].dify 
neighbour[k].difz 

zu einem anderen struct zuweisen, wobei k der Index jeder Gruppe wird . Hier ist das, was ich getan habe bisher

i = 0; //initialize counter 
int k = 1; // second 
int j; //internal counter 
float minx, maxx, miny, maxy, minz, maxz; // min and max values of the other 3 fields of the struct records 
for (i = 0; i < n; i++){ 
//initialize min and max 
    maxx = records[i].xaxis; 
    minx = records[i].xaxis; 
    maxy = records[i].yaxis; 
    miny = records[i].yaxis; 
    maxz = records[i].zaxis; 
    minz = records[i].zaxis; 
    //start looking for the maximum and the minimum 
    for(j = i; j < n; j++){ 
     if(records[j].time < k * 1000){//check only for values within the desired time period 
      if(records[j].xaxis > maxx){ 
       maxx = records[j].xaxis; 
      } 
      if(records[j].xaxis < minx){ 
       minx = records[j].xaxis; 
      } 
      if(records[j].yaxis > maxy){ 
       maxy = records[j].yaxis; 
      } 
      if(records[j].yaxis < miny){ 
       miny = records[j].yaxis; 
      } 
      if(records[j].zaxis > maxz){ 
       maxz = records[j].zaxis; 
      } 
      if(records[j].zaxis < minz){ 
       minz = records[j].zaxis; 
      } 
     } 
    }//once the proper values are found save the difference between max and min. 
    neighbour[i].difx = maxx-minx; 
    neighbour[i].dify = maxy-miny; 
    neighbour[i].difz = maxz-minz; 
    k++;  
} 

Ergebnisse ich bin immer unterschiedlich sind. Danke für Ihre Hilfe.

Answer 1

Von dem, was Sie gesagt haben. Ich nehme an, dass records [i] .time in aufsteigender Reihenfolge ist. Dann wird der Code werden.

i = 0; //initialize counter 
int k = 1; // second 
float minx, maxx, miny, maxy, minz, maxz; // min and max values of the other 3 fields of the struct records 

//initialize min and max 
maxx = records[0].xaxis; 
minx = records[0].xaxis; 
maxy = records[0].yaxis; 
miny = records[0].yaxis; 
maxz = records[0].zaxis; 
minz = records[0].zaxis; 

for (i = 1; i < n; i++){ 
//start looking for the maximum and the minimum 
    if(records[i].time <= k * 1000){//check only for values within the desired time period 
     if(records[i].xaxis > maxx){ 
      maxx = records[i].xaxis; 
     } 
     if(records[i].xaxis < minx){ 
      minx = records[i].xaxis; 
     } 
     if(records[i].yaxis > maxy){ 
      maxy = records[i].yaxis; 
     } 
     if(records[i].yaxis < miny){ 
      miny = records[i].yaxis; 
     } 
     if(records[i].zaxis > maxz){ 
      maxz = records[i].zaxis; 
     } 
     if(records[i].zaxis < minz){ 
      minz = records[i].zaxis; 
     } 
    } 
    else 
    { 
     neighbour[k-1].difx = maxx-minx; 
     neighbour[k-1].dify = maxy-miny; 
     neighbour[k-1].difz = maxz-minz; 
     k++;  
     maxx = records[i].xaxis; 
     minx = records[i].xaxis; 
     maxy = records[i].yaxis; 
     miny = records[i].yaxis; 
     maxz = records[i].zaxis; 
     minz = records[i].zaxis; 
    } 

}