Nvidia, Floating Point Blending and 'Errors'

I don't see why you should use MAX_FLOAT instead of INF. At least if INF * 0 = 0.
I agree with darkblu on that point.

 

Lots of standards ar old standards. That does not make them any less useful though.

Microsoft wants IEEE compliance for GPU's (if nothing else it helps system wide hardware abstraction by ensuring all processors use a common, widely accepted format).

As for division by zero, anyone who has done any programming at all knows very well that this is something that simply should not be done in the first instance.

 

this should be some help
http://msdn.microsoft.com/library/d...ore98/HTML/_crt__control87.2c_._controlfp.asp

 

Anyone who has done any real programming knows what a pain in the ass it is to take care of this special case every time you perform a division. The only problem is that division by zero is undefined in the science of math. That however doesn't mean we can't define it to something useful in programming tasks, rather than spending cycles having to take care of a rare special case.

 

We did this later in development after we discovered that we could.

 

One mans general case is another mans special case.

Some of the compilers I've worked with have had quite sophisticated support for dealing with FP exceptions, configurable behaviour for value replacement when FP ops generate Inf/NaN, etc, or have flags to auto-detect division-by-zero, etc.

 

But Humus, what if HW vendor X's decision on what to do with division by zero is not one you want? AFAICS it's up to the programmer to put in the handling that they want. Personally I think the IEEE behaviour is fairly sensible in this respect. I'm not that keen on its denormalised numbers but that's a different issue.

 

If you don't want to deal with division by zeros, you can condition your division by adding epsilon to your divisor. If you do want to deal with them, you can let the Infs/NaNs propagate and trace them back.

It would be nice if we had fast functions to set NaNs/Infs in the framebuffer/rendertextures to some specified value such a 0.

 

Yikes! It begins to sound worse than handling the special cases.

Wouldn't it be much better to have some sort of cheap exception handling rather than polluting your code?

 

This works fine until you try this with a denominator that happens to be -epsilon.

 

But in terms of graphics algorithms, where are you going to have division by zero?

Projection? That's handled by doing clipping against the frustum and is generally hardwired in so is a non-issue.

Lighting calcs where the light gets too close? Since that's computing a distance, the value will always be positive and so the epsilon trick should be ok. (In fact, it's probably necessary for realistic modelling since you wouldn't have an infinitely bright light anyway... it would have set fire to the material )

Vector normalisation where the vector is zero? Same sort of situation.

I think that, in general, it should be ok.

 

I have to admit that I don't usually deal with negative denominators when I'm normalising. Anyway, if that's your cup of tea, take the sign off your denominator, then multiply the end result of the division by the sign.

 

Even dividing by very small fractions may result in huge numbers that may not be very useful depending on what you're computing/modelling.

 

Who said anything about normalising?

 

Oh I agree completely. I certainly made sure Elan/Naomi2 had lighting parameters that could guard against nasty cases.

 

I was sharing my personal experience. I usually have to deal with divide by zero when I'm normalising/rescaling.

Dividing by negative numbers with the epsilon trick is not a biggie.

 

Ooops. Double post.

 

The division by zero is not a "problem" per se in maths.
That it is undefined is a requirement, not an annoyance,

If you want it to be defined you are begging for *real* problems, as you are throwing the consistency of simple arithmetics out of the window.

If you are dividing by zero you already got your problem. Just setting the result to your liking wont help you there.

Say you set something like real/0 = +-MaxNum (with respect to the signs of real and 0).

How do you trace such an "error"?
What about scientific computing on the GPUs?

IMHO it would be of grave error to throw exception handling of Div/0 out of the window, just because it seems convenient.

regards, alex