Help me understand this simple code snippet to get the magnitude frequency response

Question

I inherited the following FFT code to get the magnitude frequency response of a sample window. I understand what fft() does. What I don't understand are the lines marked with a "???". What do they do? In particular the "real[i]/real.length/2" portion and the multiplication and division by 1000 portion.

double[] real = new double[_FFTSize];
double[] imaginary = new double[_FFTSize];

loadDataIntoReal(real);

fft(real, imaginary); // in-place FFT

for (int i = 0; i < spectrum.length; i++)
{
    double reValue =((int)((real[i]/(real.length/2))*1000)/1000.0); // ???
    double imValue =((int)((imaginary[i]/(real.length/2))*1000)/1000.0); // ???
    double value = Math.sqrt(reValue * reValue + imValue * imValue);
    spectrum[i] = value;
}

Each line seems to have a redundant multiplication and division by 1000. However, if I change the code to be the following, then I get slightly different floating-point results, so I guess they must provide some sort of precision.

    double reValue =(real[i]/(real.length/2));
    double imValue =(imaginary[i]/(real.length/2));

Answer 1

It looks like this mul-floor-div is an incorrect attempt to limit some numeric print-out to 3 or 6 decimal places. Better to do that during the print formatting.

Answer 2

It's probably a quantizer. It multiplies by 1000, converts to integer (hence the quantization), and then divides by 1000 again (in floating point).

However, this feels like awkwardly written code as it depends on operator precedence. I think typecast has precedence 3 with right-to-left associativity and division has precedence 5 with left-to-right associativity, and it's not entirely clear to me what comes first.

If the type cast happens before the division than it's quantizer (to 1/1000). If the division comes first, than it simply truncates the result to the nearest smaller whole number.

It would be much cleaner if the last bracket would move in front of the division sign like this:

double reValue =((int)((real[i]/(real.length/2))*1000))/1000.0;

If one was worried about efficiency and readability, one could also do something like this

// outside the loop
double scale = 1000/(realLength/2);
// inside the loop
double reValue =((int)(real[i]*scale))*.001;