Haxe Code Cookbook

# Rounded Float as abstract type

This abstract type is based on the underlying `Float` type, but whenever it is converted back to an actual `Float` it is rounded to avoid the famous rounding errors occuring in floating point aritmetics.

Please note that this example doesn't solve the rounding error problem - it just covers it by rounding the errors away. This shouldn't be used in situations where accumulated errors might cause critical problems - for example in financial calculations. For those cases, something like Franco Ponticelli's thx.Decimal should be used instead.

```abstract RFloat(Float) from Float {
inline function new(value : Float)
this = value;

// The following rounds the result whenever converted to a Float
@:to inline public function toFloat():Float  {
return roundFloat(this);
}

@:to inline public function toString():String {
return Std.string(toFloat());
}

// The number of zeros in the following valuer
// corresponds to the number of decimals rounding precision
static inline var multiplier = 10000000;

static inline function roundFloat(value:Float):Float
return Math.round(value * multiplier) / multiplier;
}
```

## Usage

```// Standard float gives a result with rounding error
var f:Float = 2.0 - 1.1;
trace(f); // 0.8999999999999999

// RFloat abstract rounds the error away
var rf:RFloat = 2.0 - 1.1;
trace(rf); // 0.9
```

A cool trick is to let the compile time type check force a cast to `RFloat` only in the moment when it's actually needed:

```// We define the variable as a standard float
var f:Float = 2.0 - 1.1;
// In the moment we need the rounded version, we use the '(f:RFloat)' syntax to force a cast to 'RFloat':
trace((f:RFloat)); // 0.9
```

Learn about Haxe Abstracts here: https://haxe.org/manual/types-abstract.html