I appreciate the idea, but... still confused. I've changed the code to the following:

my $tolerance = 1.0e-16; # Change this value based on observation

if ($tolerance*abs($range_min + $change_min) < abs($range_min - $chang
+e_min)) {
    print "$variable has different minimum value:\n";
    print "  Change list: $changes{$variable}{min} ($changes{$variable
+}{sheet})\n";
    print "  Range file : $range_file{$variable}{min} ($range_file{$va
+riable}{sheet})\n";
    my $difference = $range_min - $change_min;
    printf "  Difference : %0.24f\n", $difference;
}
    
if ($tolerance*abs($range_max + $change_max) < abs($range_max - $chang
+e_max)) {
    print "$variable has different maximum value:\n";
    print "  Change list: $changes{$variable}{max} ($changes{$variable
+}{sheet})\n";
    print "  Range file : $range_file{$variable}{max} ($range_file{$va
+riable}{sheet})\n";
    my $difference = $range_min - $change_min;
    printf "  Difference : %0.24f\n", $difference;
}
[download]

Only difference to what you posted is the printf rather than print. And that was because the difference being shown with print was zero. This change in the code eliminated differences for four of the seven variables, but three remain:

variable_c has different maximum value:
  Change list: 45142.388774415 (Intermediate Variables)
  Range file : 45142.388774415 (Intermediate Variables)
  Difference : -0.000000000000014210854715
variable_f has different maximum value:
  Change list: 181.019658002611 (Intermediate Variables)
  Range file : 181.019658002611 (Intermediate Variables)
  Difference : 0.000000000000000000000000
variable_g has different maximum value:
  Change list: 1.57615706403821 (Intermediate Variables)
  Range file : 1.57615706403821 (Intermediate Variables)
  Difference : 0.000000000000000000000000
[download]

Variable C makes some sort of sense. I mean, I'm still under the impression that if I assign 45142.388774415 directly to two different variables, they should both have the same floating point representation. But they don't, obviously.

But what the hork is up with the other two? It seems to me that if the tolerance is 1e-16, there should be some difference shown in 24 places in the floating point number.

Can I suggest that you dump each value to a file along with some natural identifier (line number or cell ID), using:

print unpack 'b64', pack 'd', $float;;
1011110110001011101100101110110101100111111000110111101000000011
[download]

Do this immediately after reading it into your script to ensure the minimum possibility of 'internal influences'. Then, when you encounter unexpected/unexplainable differences, dump both values in the same form, along with their original identifiers.

I can't offer an explanation for how or why what you are seeing could happen, but I have seen some weirdness in Perl's internal handling of floats in the past. Dumping bit patterns is surest way I know of inspecting what is actually there.

That said, you can still be fooled, as IEEE allow for the possibility of denormalised representations. That is, the bit patterns can be different but represent (exactly) the same values. Kind of like binary equivalent of 10e-6 vs. 1e-5.

Anyway, if you can track what differences are being perceived, then you may be able to backtrack to where they arise. And if you can do that, an explanation of why may be obvious or forthcoming.

Good luck.

---

Examine what is said, not who speaks -- Silence betokens consent -- Love the truth but pardon error.

"Science is about questioning the status quo. Questioning authority".

In the absence of evidence, opinion is indistinguishable from prejudice.

"Too many [] have been sedated by an oppressive environment of political correctness and risk aversion."

For the record, I did try this as well, but it didn't help my Monday morning mind narrow anything down. Specifically, I found the same three differences. The binary representations didn't change between the time I read the values in and the time I compared them.

First two lines are reading files in from Excel sheets, second two are later in the script when the difference is found. I didn't include all three differences here, since they're all the same scenario. Different values read in from the files, no change to those values for the comparison:


read var_f in from change file: 10011100010100111000101110010000100001
+01000001010110011000000010
read var_f in from range file : 10101100010100111000101110010000100001
+01000001010110011000000010
var_f value in change hash    : 10011100010100111000101110010000100001
+01000001010110011000000010
var_f value in range hash     : 10101100010100111000101110010000100001
+01000001010110011000000010
[download]

I'm not familiar enough with floating point representation to say what the difference is (it's been years since I had to convert a binary to float, and unfortunately need to do actual work this morning rather than brush up on the process). I think this is a difference in exponents, but that wouldn't make a lot of sense to me with the rest of the binary value being identical.