My opinions about the solutions below ...
Am 13.02.2024 um 12:07 schrieb Thomas Kurz via fpc-pascal:
But, sorry, because we are talking about compile time math, performance
(nanoseconds) in this case doesn't count, IMO.
That's what i thought at first, too. But then I started thinking about how to
deal with it and sumbled upon difficulties very soon:
a) 8427.0 + 33.0 / 1440.0
An easy case: all constants, so do the calculation at highest precision and
reduce it afterwards, if possible.
I agree; I would say:
all constants, so do the calculation at highest precision and reduce it
afterwards, if required by the target
b) var_single + 33.0 / 1440.0
Should also be feasable by evaluating the constant expression first, then
reducing it to single (if possible) and adding the variable in the end.
yes ... first evaluate the constant expression with maximum precision
(best at compile time), then reduce the result.
The reduction to single must be done in any case, because the var_single
in the expression dictates it, IMO
c) 8427.0 + var_double / 1440.0
Because of using the double-type variable here, constants should be treated as
double even at the cost of performance due to not knowing whether the result
will be assigned to a single or double.
yes
d) 8427.0 + var_single / 1440.0
And this is the one I got to struggle with. And I can imagine this is the
reason for the decision about how to handle decimal constants.
My first approach would have been to implicitly use single precision values throughout
the expression. This would mean to lose precision if the result will be assigned to a
double-precision variable. One could say: "bad luck - if the programmer intended to
get better precision, he should have used a double-precision variable as in case c".
But this wouldn't be any better than the current state we have now.
8427.0 + (var_single / 1440.0)
the 1440.0 can be reduced to single, because the other operand is single
and so the whole operation is done using single arithmetic.
If here we had a FP constant instead of var_single, the whole operation
IMO should be done
with maximum precision and at compile time in the best case. I have no
problem that this
operation may give a different result with decimal constants than with
explicitly typed
(reduced) FP variables. This can be easily explained to the users.
Operations involving
FP variables with reduced precision may give reduced precision results.
This seems to
be desirable for performance reasons and can be avoided by appropriate
type casting.
_______________________________________________
fpc-pascal maillist - fpc-pascal@lists.freepascal.org
https://lists.freepascal.org/cgi-bin/mailman/listinfo/fpc-pascal
