Abstracting floating point precision in java projects

Question

Consider a java project doing lots of floating point operations where efficiency and memory consumption can be important factors - such as a game. If this project targets multiple platforms, typically Android and the desktop, or more generally 32 and 64 bit machines, you might want to be able to build a single and a double precision build of your software.

In C/C++ and other lower level languages, this is easily achieved by typedef statements. You can have:

typedef float myfloat;

and the day you want to go 64 bit just change that to:

typedef double myfloat;

provided you use myfloat throughout your code.

How would one achieve a similar effect in java?

A global search and replace of "float" by "double" (or vice-versa) has the huge drawback of breaking compatibility with exterior libraries that only offer one flavor of floating point precision, chief among them certain functions of the java.lang.Math class.

Having a high-level polymorphic approach is less than ideal when you wish to remain efficient and keep memory tight (by having lots of primitive type arrays, for instance).

Have you ever dealt with such a situation and if so, what is in your opinion the most elegant approach to this problem?

Answer 1

The official Android documentation says this about float vs. double performance:

In speed terms, there's no difference between float and double on the more modern hardware. Space-wise, double is 2x larger. As with desktop machines, assuming space isn't an issue, you should prefer double to float.

So you shouldn't have to worry about performance too much. Just use the type that is reasonable for solving your problem.

Apart from that, if you really want to have the ability to switch between double and float, you could wrap your floatin point value in a class an work with that. But I would expect such a solution to be slower that using any floating point primitive directly. As Java does not support overloading operators, it would also make your math code much more complicated. Think of something like

double d = (a+b)/c;

when using primitives versus

MyFloat d = a.add(b).div(c);

when working with wrapper objects. According to my experience, the polymorphic approach makes maintaining your code much harder.

Answer 2

I will omit the part saying that for example double should be just fine etc. Others covered that more than good. I'm just assuming you want to do it - no matter what. Even for the sake of experiment to see what's the performance/memory difference - it's interesting.

So, a preprocessor would be great here. Java doesn't provide one.

But, you can use your own. Here are some existing implementations. Using javapp for example, you will have #define.

Answer 3

This is not practical without great pains.

While you could define your high level API's to work with wrapper types (e.g. use Number instead of a specific type and have multiple implementations of the API that uses Float or Double under the hood), chances are that the wrappers will eat more performance than you can ever gain by selecting a less precise type.

You could define high level objects as interfaces (e.g. Polygon etc.) and hide their actual data representation in the implementation. That means you will have to maintain two implementations, one using float and one for double. It probably requires considerable code duplication.

Personally, I think you are attempting to solve a non-existant conundrum. Either you need double precision, then float isn't an option, or float is "good enough", then there is no advantage of ever using double.

Simply use the smallest type that fits the requirements. Especially for a game float/double should make little difference. Its unlikely you spend that much time in math (in java code) - most likely your graphics will determine how fast you can go.

Generally use float and only switch to double for parts where you need the precision and the question disappears.

Answer 4

Java does not have such a functionality, aside from brute-force find-and-replace. However, you can create a helper class. Shown below, the type you will change to change the float precision is called F:

public class VarFloat {
    F boxedVal;
    public VarFloat(F f){
        this.boxedVal = f;
    }
    public F getVal() { return boxedVal; }
    public double getDoubleVal() { return (double)boxedVal; }
    public double getFloatVal() { return (float)boxedVal; }
}

Where at all possible, you should use getVal as opposed to any of the type-specific ones. You can also consider adding methods like add, addLocal, etc. For example, the two add methods would be:

public VarFloat add(VarFloat vf){ return new VarFloat(this.boxedVal + vf.boxedVal); }

public VarFloat addLocal(VarFloat vf){ this.boxedVal += vf.boxedVal; return this; // for method chaining }