Lua : new Math class and extern

The Lua math class has a lot of useful methods, which would be nice
to expose as an extern.  This means we need to distinguish between
the base Math class and the Lua extern version.

std/lua/Math.hx

@@ -0,0 +1,43 @@
+package lua;
+
+@:native("_G.math")
+extern class Math {
+	public static var pi   : Float;
+	public static var huge : Float;
+	public static var NaN  : Float;
+
+	public static function abs  (i : Float) : Float;
+	public static function ceil (i : Float) : Int;
+	public static function floor(i : Float) : Int;
+
+	public static function acos (i : Float) : Float;
+	public static function asin (i : Float) : Float;
+	public static function atan (i : Float) : Float;
+	public static function atan2(i : Float, j : Float) : Float;
+	public static function cos  (i : Float) : Float;
+	public static function cosh (i : Float) : Float;
+	public static function sin  (i : Float) : Float;
+	public static function sinh (i : Float) : Float;
+	public static function tan  (i : Float) : Float;
+	public static function tanh (i : Float) : Float;
+	public static function rad  (i : Float) : Float;
+
+	public static function modf (i : Float) : Float;
+	public static function fmod (i : Float) : Float;
+
+	public static function pow  (i : Float, j : Float) : Float;
+	public static function sqrt (i : Float) : Float;
+	public static function exp  (i : Float) : Float;
+	public static function frexp(i : Float) : Float;
+	public static function ldexp(i : Float) : Float;
+
+	public static function log  (i : Float) : Float;
+	public static function log10(i : Float) : Float;
+
+	public static function max  (i : Float, j :Float) : Float;
+	public static function min  (i : Float, j :Float) : Float;
+
+	public static function random() : Float;
+	public static function randomseed(i : Float) : Float;
+}
+

std/lua/_std/Math.hx

@@ -21,73 +21,56 @@
  */
 package;
 
-// Can't enable @:coreApi because some fields are now inline getters
-// @:coreApi
-@:keepInit
-@:native("_G.math")
-extern class Math
+class Math
 {
-	static var PI(get,null) : Float;
-	private static inline function get_PI () : Float {
-		return untyped Math.pi;
-	}
+	public static var PI(get,null) : Float;
+	static inline function get_PI () : Float return lua.Math.pi;
 
-	static var NEGATIVE_INFINITY(get, null) : Float;
-	private static inline function get_NEGATIVE_INFINITY () : Float {
-		return untyped Math.huge; 
-	}
+	public static var NEGATIVE_INFINITY(get, null) : Float;
+	static inline function get_NEGATIVE_INFINITY () : Float return -lua.Math.huge; 
 
-	static var POSITIVE_INFINITY(get,null) : Float;
-	private static inline function get_POSITIVE_INFINITY () : Float {
-		return untyped -Math.huge; 
-	}
+	public static var POSITIVE_INFINITY(get,null) : Float;
+	static inline function get_POSITIVE_INFINITY () : Float return lua.Math.huge; 
 
-	static var NaN(get, null) : Float;
-	private static inline function get_NaN () : Float {
-		return 0/0; 
-	}
+	public static var NaN(get, null) : Float;
+	static inline function get_NaN () : Float return 0/0; 
 
-	static function abs(v:Float):Float;
-	static function acos(v:Float):Float;
-	static function asin(v:Float):Float;
-	static function atan(v:Float):Float;
-	static function atan2(y:Float, x:Float):Float;
-	static function ceil(v:Float):Int;
-	static function cos(v:Float):Float;
-	static function exp(v:Float):Float;
-	static function floor(v:Float):Int;
-	static function log(v:Float):Float;
-	static function max(a:Float, b:Float):Float;
-	static function min(a:Float, b:Float):Float;
-	static function pow(v:Float, exp:Float):Float;
-	static function random() : Float;
-	static inline function round(v:Float):Int {
-		return Std.int(v + 0.5);
+	public static inline function isNaN( f : Float ) : Bool return (f != f);
+	public static inline function isFinite( f : Float ) : Bool {
+		return (f > Math.NEGATIVE_INFINITY && f < Math.POSITIVE_INFINITY);
 	}
-	static function sin(v:Float):Float;
-	static function sqrt(v:Float):Float;
-	static function tan(v:Float):Float;
 
-	static inline function ffloor( v : Float ) : Float {
-		return floor(v);
-	}
+	public static inline function abs(v:Float) :Float return lua.Math.abs(v);
+	public static inline function acos(v:Float):Float return lua.Math.acos(v);
+	public static inline function asin(v:Float):Float return lua.Math.asin(v);
+	public static inline function atan(v:Float):Float return lua.Math.atan(v);
+	public static inline function ceil(v:Float):Int   return lua.Math.ceil(v);
+	public static inline function cos(v:Float):Float  return lua.Math.cos(v);
+	public static inline function exp(v:Float):Float  return lua.Math.exp(v);
+	public static inline function sin(v:Float):Float  return lua.Math.sin(v);
+	public static inline function sqrt(v:Float):Float return lua.Math.sqrt(v);
+	public static inline function tan(v:Float):Float  return lua.Math.tan(v);
 
-	static inline function fceil( v : Float ) : Float {
-		return ceil(v);
-	}
+	public static inline function floor(v:Float):Int  return lua.Math.floor(v);
+	public static inline function log(v:Float):Float  return lua.Math.log(v);
 
-	static inline function fround( v : Float ) : Float {
-		return round(v);
-	}
+	public static inline function random() : Float    return lua.Math.random();
 
-	static inline function isFinite( f : Float ) : Bool {
-		return (f > Math.NEGATIVE_INFINITY && f < Math.POSITIVE_INFINITY);
-	}
+	public static inline function atan2(y:Float, x:Float):Float return lua.Math.atan2(y,x);
+	public static inline function max(a:Float, b:Float):Float   return lua.Math.max(a,b);
+	public static inline function min(a:Float, b:Float):Float   return lua.Math.min(a,b);
+	public static inline function pow(v:Float, exp:Float):Float return lua.Math.pow(v,exp);
 
-	static inline function isNaN( f : Float ) : Bool {
-		return (f != f);
+	public static inline function round(v:Float):Int {
+		return Std.int(v + 0.5);
 	}
 
+	public static inline function ffloor( v : Float ) : Float return floor(v); 
+	public static inline function fceil( v : Float ) : Float return ceil(v);
+	public static inline function fround( v : Float ) : Float return round(v);
+
+
+
 	static function __init__() : Void {
 		untyped __feature__("Type.resolveClass", _hxClasses["Math"] = Math);
 	}