1

This is a question concerning cross-platform consistency and determinism of floating point operations (IE yield different results on different CPUs/sysetms)

Which one is more likely to stay cross-platform consistent(pseudo code):

float myFloat = float ( myInteger) / float( 1024 )

or

float myFloat = float ( myInteger ) / float( 1000 )

Platforms are C# and AS3.

.

AS3 versions:

var myFloat:Number = myInteger  /  1000 // AS3
var myFloat:Number = myInteger  /  1024 // AS3

- Ok I've added AS3 version for clarification, which is equivalent to the 'C pseudo code' above . As you can see in AS3 all calculations, even on integers, are performed as Floats automatically, a cast is not required ( and nor can you avoid it or force the runtime to perform true integer divisions ) Hopefully this explains why im 'casting' everything into Floats: I am not! that just simply what happens in one of the target languages!

Martin K
  • 765
  • 1
  • 6
  • 15
  • 1
    You do not specify any programming language in either your question or tags. In many programming languages, both constructs are equally portable and future-proof. Actually, in many programming languages, the division in your “pseudo-code” is an integer division, resulting in an integer result. – Pascal Cuoq Jul 08 '12 at 11:20
  • I've added the languages and also a 'cast to float', to make it clear. In C# it is true, that it will be considered an integer division, however in AS3, internally all calculations are performed as floats, and a cast is automatically implied. – Martin K Jul 08 '12 at 11:25
  • Aargh; stop changing the question! – Oliver Charlesworth Jul 08 '12 at 11:31
  • I am not changing it, just clarifying the 'pseudo code' parts, as I've said one of the languages is AS3, and in AS3 `var myInt:int = 1/3 + 2/3; // = 1` without any 'casts' to float, as in AS3 all calculations are internally performed as floats. So with the 'changes' I've added Im just explicitly stating what happens in AS3. Of course in C# it is different, but as I am targeting both languages, I have to work on the lowest common denominator. – Martin K Jul 08 '12 at 11:35
  • @MartinK: I had to delete my original answer, because it was no longer valid (therefore, you changed the meaning of the question!). Anyhow, I'm not sure what the "lowest-common denominator" of C# and AS3 is; they're completely different languages with potentially different specifications for handling floating-point issues. – Oliver Charlesworth Jul 08 '12 at 11:46

3 Answers3

0

The first one is likely the same on both platforms, since there are no representation issues. In particular for small integers (highest 8 bits unused) there is one exact result, and it's very likely that this result will be used.

But I wouldn't rely on it. If you need guaranteed determinism, I recommend implementing the required arithmetic yourself on top of plain integers. For example using a fixed point representation.

The second one is likely to be inconsistent, even when using the same C# code on different hardware or .net versions. See the related question Is floating-point math consistent in C#? Can it be?

Community
  • 1
  • 1
CodesInChaos
  • 106,488
  • 23
  • 218
  • 262
  • fixed point representation is not possible in AS3! in AS3 all calculations, even on integers are performed as floats ie `var myInt:int = 1/3 + 2/3; // = 1`. Where as in C# the equivalent would be = 0! Anyway, so are you suggesting that dividing by **1024 should be at least safer** than by 1000? (although not 100%) – Martin K Jul 08 '12 at 11:44
0

I suggest you read the IEEE 754-1985 standard. A copy can be purchased for $43. Although superseded by the 2008 version, it is an excellent introduction to floating-point because it is only 20 pages and is quite readable. It will show you why both dividing by 1000 and by 1024 are deterministic and why the former may have error but the latter does not (except in cases of underflow). It will also give you a basis for understanding the answers you have been given and why you are on the wrong track.

Eric Postpischil
  • 195,579
  • 13
  • 168
  • 312
  • As I said, I have to have the same code produce the same result on 2 different Languages C# and AS3 as well as on different systems(one is a client PC/MAC 32/64 bit another is a Server 64 bit). So there is absolutely no guarantee of any kind that the IEEE 754-1985 standard is there on all sides all the times. I am looking for the **least bad** solution of the lowest common denominator. – Martin K Jul 08 '12 at 13:09
0

Which one is more likely to stay cross-platform consistent(pseudo code):

Dividing by 1024. Every binary-based floating point systems (which are IEEE754, IBM, VAX, Cray) which applies division by 1024 to all finite numbers will yield exact results in the given representation. The reason is that dividing by 1024 is equivalent to

  • shifting the bits 10 positions to the right which means
  • decreasing the binary exponent by 10

If the number is too small (for IEEE754 1E-38/1E-308), you will lose an exact result, but this is not a problem of the operation, but of the limited range of the number...it simply cannot display such small results accurately.

As no rounding is necessary, there can be no difference due to rounding (and yes, while most programming languages use round to even, some enable choosing another rounding mode).

Thorsten S.
  • 4,144
  • 27
  • 41