|
|
On 2/18/23 08:33, Bald Eagle wrote:
> William F Pokorny <ano### [at] anonymousorg> wrote:
>
>> What spooks me some is that -0 and +0 are real things in the IEEE
>> floating point standard and as supported by C++. If a C++ coder has
>> thought to test for -0 < 0, they can.
>
> Which raises the question about how the IEEE 754 gets implemented in POV-Ray's
> source code, and if a user can test for -0 through SDL.
So tempted to answer I don't know(a)... ;-)
For the floating point standard we mostly get what the C++ compilers
give us depending upon options used while compiling. Excepting where in
the POV-Ray source there might be hard coded behavior which is not
strictly compliant or in days gone by was intended to handle things is
some more compliant manner(b).
As for testing for -0 via SDL, I cannot think of any direct method...
On my development compiles using g++ 11.3 and the -ffast_math flag, I
can code:
#declare negZero = -0.0;
#declare posZero = +0.0;
#declare hmmZero = 0.0/-1.0;
#debug concat("-0.0 shows up as : ",str(-0.0,0,-1)," \n")
#debug concat("+0.0 shows up as : ",str(+0.0,0,-1)," \n")
#debug concat("Var negZero shows up as : ",str(negZero,0,-1)," \n")
#debug concat("Var posZero shows up as : ",str(posZero,0,-1)," \n")
#debug concat("Var hmmZero shows up as : ",str(hmmZero,0,-1)," \n")
#error "\nStopping at end of parsing\n"
and see as a result:
-0.0 shows up as : -0.000000
+0.0 shows up as : 0.000000
Var negZero shows up as : -0.000000
Var posZero shows up as : 0.000000
Var hmmZero shows up as : -0.000000
So maybe build up strings and do a string compare?
Aside: The C++ value comparison operators mirrored in SDL will - by
default - ignore the sign of zero.
>
> I actually just watched:
>
> Fast Inverse Square Root — A Quake III Algorithm
> https://www.youtube.com/watch?v=p8u_k2LIZyo
>
> yesterday (it was in the sidebar when watching yesbird's animation), and they
> went over some interesting points, and was also wondering if we could implement
> something like this in POV-Ray SDL, and source, and if you'd find it useful or
> are already using it in povr.
>
Cool old stuff!
As for fast, clever algorithms... I've tried some tricks in povr and
looked over quite a few, though not the particular one in the video.
Most come with somewhat noisy behavior compared to standards compliant
code. The noise is difficult to swallow given the end benefit(c) -
floor() and ceil() fast equivalents, for example.
Bill P.
(a) I don't know it all - about anything. Where I do know a little,
there's almost never a simple, complete answer.
(b) The radiosity code to this day has some complicated configurations
related to the floating point math, for example. Unsure what all of this
used or needed these days.
(c) The povr fork, while coding up new functions, did implement single
and floating point flavors / options for many functions. Anywhere the
single floating point code was significantly faster on my i3 hardware -
at the expense of accuracy. Often single float accuracy in functions is
OK depending on - stuff.
Measuring and tuning for performance is REALLY difficult these days
given the hardware realities. For core functionality, the tuning job is
best left to the compiler folks as a near hard rule.
Post a reply to this message
|
|