Practical advice, please. - page 5

New comment
 
Dmitry Fedoseev:
Mod 1 Mode 2 Mode 3 Mode 4 Mode 5 (vi) Mode 6 (vi) Mode 7 (vi) Mode 8 (vi) Mod 9 (vi) Mod 10 (vi) Mod 11 (vi) Mod 12 (viii) mod 13 (vi) 14 Mode 15 Amount
4,43 1 17,09 1 15,82 2 2,53 1 0,63 1 17,72 1 28,48 1 5,70 2 13,29 3 5,70 2 8,23 2 6,33 2 0,63 1 3,16 3 6,96 3 23
5,06 2 17,72 2 12,66 1 3,80 2 0,63 1 19,62 2 29,11 2 4,43 1 9,49 2 5,06 1 6,33 1 6,33 2 1,90 2 1,90 2 6,33 2 26
4,43 1 20,25 3 16,46 3 4,43 3 0,63 1 17,72 1 29,75 3 6,33 3 5,06 1 8,23 3 10,13 3 5,06 1 0,63 1 1,27 1 4,43 1 29


The lowest sum is 23, picking the first row.

Thanks, I'll take note of that too.

But these are error values, is it reliable to use this method of rating estimation?
In statistics, they mainly use sum of squares to estimate errors.
And sum of squares and rating have different results, so which method to trust?

;))

In what mathematical area is the ranking method used?
To smoke this material and understand where it is used.
 

The method used should be the one that gives a satisfactory solution to the problem at hand. When applying any method, you must understand what you are doing and what you are getting.

If you have no idea what a satisfactory result should be, it makes no difference what method to use.

 
Dmitry Fedoseev:

The method used should be the one that gives a satisfactory solution to the problem at hand. When applying any method, you must understand what you are doing and what you are getting.

And if there is no idea what a satisfactory result should be, it makes no difference what method to use.

I agree in part, but in this case we are evaluating the error's value itself and not its recurrence in a module.
This method is suitable for evaluating repeating values.
I don't think it's the right method for evaluating the error values themselves.

 
Roman:

I partly agree, but in this case we are assessing the error itself, not its recurrence in a module.
This method is suitable for evaluating recurring values.
I don't think it's the right method for evaluating the error values themselves.

If the values are repeating, they will give exactly the same result as swapping them with 1, 2 and 3.

Read the first post of this thread, there the author of the thread formulated his problem - just read it, not make it up.

 
Dmitry Fedoseev:

If the values are repetitive, they themselves will give exactly the same result as swapping them with 1, 2, 3.

Read the first post of this thread, where the author of the thread formulated his problem - just read it, not make it up.

So no one is not making it up. As I understood from the first post, the original task was to estimate the error minimization.
And the author in his table even derived the average of all the errors. But he did not think it was practical or informative.
Estimating error minimisation and estimating repeating values are different tasks.

 
Roman:

So no one is making it up. As I understood from the first post, the original aim was to estimate error minimisation.
And the topicstarter even averaged out all the errors in his table. But he did not think it was practical or informative.
Estimating error minimisation and estimating recurring values are different tasks.

Just using the average is not enough, you also need to avoid a large overshoot.

 
Dmitry Fedoseev:

It's not enough to have an average, you also need to have a low ejection rate.

and so the product

 
Dmitry Fedoseev:

It is not enough to use just the average, we also need to avoid large outliers.

Then you need to additionally prepare input data, normalize it, or standardize it.
In my example this is taken into account by MathPow(arr[i] - (max-min)/* or avg*/, 2.0), and the product is performed by the square function.
That is, it takes it to the second power, which corresponds to the product.

 

While we are on the subject of normalisation and standardisation, this alignment applies when the values being compared need to be brought to the same scale.
What do you mean by "normalising to the same scale"?
For example, when we need to compare numbers like 81.500 and 1.13453 or 5200.1 or 27340 etc.
That is, the values have a different number of digits after the integer.
To compare such data or pass them into a model, if the model has several signs, apply normalisation or standardisation,
, so that the model calculates correctly and produces the correct calculation.
I have written such functions, if anyone needs them, please use them.

//--------------------------------------------------------------------
//Возвращает максимальное значение элементов массива
double ArrayMax(double & arrIn[])
{
   uint size = ArraySize(arrIn);
   if(size == 0) 
      return(0.0);          
   
   double max = arrIn[0];
   for(uint i=1; i<size; i++)
      if(arrIn[i] > max) 
         max = arrIn[i];

   return(max);
}

//--------------------------------------------------------------------
//Возвращает минимальное значение элементов массива
double ArrayMin(double & arrIn[])
{
   uint size = ArraySize(arrIn);
   if(size == 0) 
      return(0.0);   
   
   double min = arrIn[0];  
   for(uint i=1; i<size; i++)
      if(arrIn[i] < min) 
         min = arrIn[i];

   return(min);
}

//--------------------------------------------------------------------
//Возвращает средне арефметическое значение элементов массива
double ArrayMean(double & arrIn[])
{
   uint size = ArraySize(arrIn);
   if(size == 0) 
      return(0.0);         

   double sum = 0.0;       
   for(uint i=0; i<size; i++) 
      sum += arrIn[i];     
   
   return(sum/size);
}

//--------------------------------------------------------------------
//Возвращает среднеквадратичное (стандартное) отклонение значений элементов массива
double ArrayStd(double & arrIn[])
{
   uint size = ArraySize(arrIn);
   if(size == 0) 
      return(0.0);   
   
   double sum  = 0.0; 
   double mean = ArrayMean(arrIn); 
          
   for(uint i=0; i<size; i++)
      sum += MathPow(MathAbs(arrIn[i]-mean), 2.0);
      
   return(MathSqrt(sum/size));
}

//--------------------------------------------------------------------
//Возвращает нормализованные значения элементов масcива
void ArrayNormalized(double & arrIn[], double & arrOut[])
{
   uint size = ArraySize(arrIn);
   if(size == 0) 
      return; 
      
   double min = ArrayMin(arrIn);   
   double max = ArrayMax(arrIn);
   
   for(uint i=0; i<size; i++)
      arrOut[i] = (arrIn[i]-min) / (max-min);   
}

//--------------------------------------------------------------------
//Возвращает стандвртизированые значения элементов масcива
void ArrayStandardized(double & arrIn[], double & arrOut[])
{
   uint size = ArraySize(arrIn);
   if(size == 0) 
      return; 
      
   double mean = ArrayMean(arrIn);
   double std  = ArrayStd(arrIn);
   
   for(uint i=0; i<size; i++)
      arrOut[i] = (arrIn[i]-mean) / std;   
}
 
Roman:

While we are on the subject of normalisation and standardisation, this alignment applies when the values being compared need to be brought to the same scale.
What do you mean by "normalising to the same scale"?
For example, when we need to compare numbers like 81.500 and 1.13453 or 5200.1 or 27340 etc.
That is, the values have a different number of digits after the integer.
To compare such data or pass them into a model, if the model has several signs, apply normalisation or standardisation,
, so that the model calculates correctly and produces the correct calculation.
I have written such functions, if anyone needs them, please use them.

Why don't you like ArrayMaximum and ArrayMinimum? Why did you have to write it through a loop?
1234567
New comment