redef class Float
	redef fun to_i8 is intern
	redef fun to_i16 is intern
	redef fun to_u16 is intern
	redef fun to_i32 is intern
	redef fun to_u32 is intern
end

redef class Float

	# Returns the non-negative square root of `self`.
	#
	#     assert 9.0.sqrt == 3.0
	#     #assert 3.0.sqrt == 1.732
	#     assert 1.0.sqrt == 1.0
	#     assert 0.0.sqrt == 0.0
	fun sqrt: Float `{ return sqrt(self); `}

	# Computes the cosine of `self` (expressed in radians).
	#
	#     #assert pi.cos == -1.0
	fun cos: Float `{ return cos(self); `}

	# Computes the sine of `self` (expressed in radians).
	#
	#     #assert pi.sin == 0.0
	fun sin: Float `{ return sin(self); `}

	# Computes the cosine of x (expressed in radians).
	#
	#     #assert 0.0.tan == 0.0
	fun tan: Float `{ return tan(self); `}

	# Computes the arc cosine of `self`.
	#
	#     #assert 0.0.acos == pi / 2.0
	fun acos: Float `{ return acos(self); `}

	# Computes the arc sine of `self`.
	#
	#     #assert 1.0.asin == pi / 2.0
	fun asin: Float `{ return asin(self); `}

	# Computes the arc tangent of `self`.
	#
	#     #assert 0.0.tan == 0.0
	fun atan: Float `{ return atan(self); `}

	# Returns the absolute value of `self`.
	#
	#     assert 12.0.abs == 12.0
	#     assert (-34.56).abs == 34.56
	#     assert -34.56.abs == -34.56
	fun abs: Float `{ return fabs(self); `}

	# Returns `self` raised at `e` power.
	#
	#     assert 2.0.pow(0.0) == 1.0
	#     assert 2.0.pow(3.0) == 8.0
	#     assert 0.0.pow(9.0) == 0.0
	fun pow(e: Float): Float `{ return pow(self, e); `}

	# Natural logarithm of `self`.
	#
	#     assert 0.0.log.is_inf == -1
	#     assert 1.0.log == 0.0
	fun log: Float `{ return log(self); `}

	# Logarithm of `self` to base `base`.
	#
	#     assert 100.0.log_base(10.0) == 2.0
	#     assert 256.0.log_base(2.0) == 8.0
	fun log_base(base: Float): Float do return log/base.log

	# Returns *e* raised to `self`.
	fun exp: Float `{ return exp(self); `}

	#     assert 1.1.ceil == 2.0
	#     assert 1.9.ceil == 2.0
	#     assert 2.0.ceil == 2.0
	#     assert (-1.5).ceil == -1.0
	fun ceil: Float `{ return ceil(self); `}

	#     assert 1.1.floor == 1.0
	#     assert 1.9.floor == 1.0
	#     assert 2.0.floor == 2.0
	#     assert (-1.5).floor == -2.0
	fun floor: Float `{ return floor(self); `}

	# Rounds the value of a float to its nearest integer value
	#
	#     assert 1.67.round == 2.0
	#     assert 1.34.round == 1.0
	#     assert -1.34.round == -1.0
	#     assert -1.67.round == -2.0
	fun round: Float `{ return round(self); `}

	# Returns a random `Float` in `[0.0 .. self[`.
	fun rand: Float `{
		if (nit_rand_seeded) return ((self)*nit_rand())/(NIT_RAND_MAX+1.0);
		return ((self)*rand())/(RAND_MAX+1.0);
	`}

	# Returns the euclidean distance from `b`.
	fun hypot_with(b: Float): Float `{ return hypotf(self, b); `}

	# Returns true is self is not a number.
	#
	# As `nan != nan`, `is_nan` should be used to test if a float is the special *not a number* value.
	#
	# ~~~
	# assert nan != nan # By IEEE 754
	# assert nan.is_nan
	# assert not 10.0.is_nan
	# ~~~
	fun is_nan: Bool `{ return isnan(self); `}

	# Is the float an infinite value
	# this function returns:
	#
	#  * 1 if self is positive infinity
	#  * -1 if self is negative infinity
	#  * 0 otherwise
	#
	# ~~~
	# assert 10.0.is_inf == 0
	# assert inf.is_inf == 1
	# assert (-inf).is_inf == -1
	# ~~~
	fun is_inf: Int do
		if native_is_inf then
			if self < 0.0 then return -1
			return 1
		end
		return 0
	end

	private fun native_is_inf: Bool `{ return isinf(self); `}

	# Linear interpolation between `a` and `b` using `self` as weight
	#
	# ~~~
	# assert  0.0.lerp(0.0, 128.0) == 0.0
	# assert  0.5.lerp(0.0, 128.0) == 64.0
	# assert  1.0.lerp(0.0, 128.0) == 128.0
	# assert -0.5.lerp(0.0, 128.0) == -64.0
	# ~~~
	fun lerp(a, b: Float): Float do return (1.0 - self) * a + self * b

	# Quadratic Bézier interpolation between `a` and `b` with an `handle` using `self` as weight
	#
	# ~~~
	# assert  0.00.qerp(0.0, 32.0, 128.0) == 0.0
	# assert  0.25.qerp(0.0, 32.0, 128.0) == 20.0
	# assert  0.50.qerp(0.0, 32.0, 128.0) == 48.0
	# assert  0.75.qerp(0.0, 32.0, 128.0) == 84.0
	# assert  1.00.qerp(0.0, 32.0, 128.0) == 128.0
	# ~~~
	fun qerp(a, handle, b: Float): Float do
		var p = self
		var i = 1.0 - p
		var r =     i*i * a +
			2.0*i*p * handle +
			    p*p * b
		return r
	end

	# Cubic Bézier interpolation between `a` and `b` with two handles using `self` as weight
	#
	# The Cubic Bézier interpolation is the most common one and use two control points.
	#
	# ~~~
	# assert  0.00.cerp(0.0, 32.0, 128.0, 64.0) == 0.0
	# assert  0.25.cerp(0.0, 32.0, 128.0, 64.0) == 32.5
	# assert  0.50.cerp(0.0, 32.0, 128.0, 64.0) == 68.0
	# assert  0.75.cerp(0.0, 32.0, 128.0, 64.0) == 85.5
	# assert  1.00.cerp(0.0, 32.0, 128.0, 64.0) == 64.0
	# ~~~
	fun cerp(a, a_handle, b_handle, b: Float): Float do
		var p = self
		var i = 1.0 - p
		var r =     i*i*i  * a +
			3.0*i*i*p * a_handle +
			3.0*i*p*p * b_handle +
			    p*p*p * b
		return r
	end
end

redef class Float
	# Pretty representation of `self`, with decimals as needed from 1 to a maximum of 3
	#
	# ~~~
	# assert 12.34.to_s       == "12.34"
	# assert (-0120.030).to_s == "-120.03"
	# assert (-inf).to_s == "-inf"
	# assert (nan).to_s == "nan"
	# ~~~
	#
	# see `to_precision` for a custom precision.
	redef fun to_s do
		var str = to_precision(3)
		return adapt_number_of_decimal(str, false)
	end

	# Return the representation of `self`, with scientific notation
	#
	# Adpat the number of decimals as needed from 1 to a maximum of 6
	# ~~~
	# assert 12.34.to_sci       == "1.234e+01"
	# assert 123.45.to_sci.to_f.to_sci  == "1.2345e+02"
	# assert 0.001234.to_sci  == "1.234e-03"
	# assert (inf).to_sci == "inf"
	# assert (nan).to_sci == "nan"
	# ~~~
	fun to_sci: String
	do
		var is_inf_or_nan = check_inf_or_nan
		if is_inf_or_nan != null then return is_inf_or_nan
		return adapt_number_of_decimal(return_from_specific_format("%e".to_cstring), true)
	end

	# Return the `string_number` with the adapted number of decimal (i.e the fonction remove the useless `0`)
	# `is_expo` it's here to specifi if the given `string_number` is in scientific notation
	private fun adapt_number_of_decimal(string_number: String, is_expo: Bool): String
	do
		# check if `self` does not need an adaptation of the decimal
		if is_inf != 0 or is_nan then return string_number
		var len = string_number.length
		var expo_value = ""
		var numeric_value = ""
		for i in [0..len-1] do
			var j = len - 1 - i
			var c = string_number.chars[j]
			if not is_expo then
				if c == '0' then
					continue
				else if c == '.' then
					numeric_value = string_number.substring( 0, j + 2)
					break
				else
					numeric_value = string_number.substring( 0, j + 1)
					break
				end
			else if c == 'e' then
				expo_value = string_number.substring( j, len - 1 )
				is_expo = false
			end
		end
		return numeric_value + expo_value
	end

	# Return a string representation of `self` in fonction if it is not a number or infinity.
	# Return `null` if `self` is not a not a number or an infinity
	private fun check_inf_or_nan: nullable String
	do
		if is_nan then return "nan"

		var isinf = self.is_inf
		if isinf == 1 then
			return "inf"
		else if isinf == -1 then
			return  "-inf"
		end
		return null
	end

	# `String` representation of `self` with the given number of `decimals`
	#
	# ~~~
	# assert 12.345.to_precision(0)    == "12"
	# assert 12.345.to_precision(3)    == "12.345"
	# assert (-12.345).to_precision(3) == "-12.345"
	# assert (-0.123).to_precision(3)  == "-0.123"
	# assert 0.999.to_precision(2)     == "1.00"
	# assert 0.999.to_precision(4)     == "0.9990"
	# ~~~
	fun to_precision(decimals: Int): String
	do
		var is_inf_or_nan = check_inf_or_nan
		if is_inf_or_nan != null then return is_inf_or_nan
		return return_from_specific_format("%.{decimals}f".to_cstring)
	end

	# Returns the hexadecimal (`String`) representation of `self` in exponential notation
	#
	# ~~~
	# assert 12.345.to_hexa_exponential_notation    == "0x1.8b0a3d70a3d71p+3"
	# assert 12.345.to_hexa_exponential_notation.to_f == 12.345
	# ~~~
	fun to_hexa_exponential_notation: String
	do
		return return_from_specific_format("%a".to_cstring)
	end

	# Return the representation of `self`, with the specific given c `format`.
	private fun return_from_specific_format(format: CString): String
	do
		var size = to_precision_size_with_format(format)
		var cstr = new CString(size + 1)
		to_precision_fill_with_format(format, size + 1, cstr)
		return cstr.to_s_unsafe(byte_length = size, copy = false)
	end

	# The lenght of `self` in the specific given c `format`
	private fun to_precision_size_with_format(format: CString): Int`{
		return snprintf(NULL, 0, format, self);
	`}

	# Fill `cstr` with `self` in the specific given c `format`
	private fun to_precision_fill_with_format(format: CString, size: Int, cstr: CString) `{
		snprintf(cstr, size, format, self);
	`}
end

redef class Float
	# Sleep approximately `self` seconds
	#
	# Is not interrupted by signals.
	fun sleep `{
		time_t s = self;
		long ns = (self-s) * 1000000000.0;
		struct timespec req = {s, ns};

		while (nanosleep(&req, &req)) { }
	`}
end

redef universal Float
	redef fun add(other) do return self + other.to_f
	redef fun sub(other) do return self - other.to_f
	redef fun div(other) do return self / other.to_f
	redef fun mul(other) do return self * other.to_f
end

redef class Float
	# Utility for `BinaryWriter`
	private fun float_byte_at(index: Int, big_endian: Bool): Int `{
		union {
			unsigned char bytes[4];
			float val;
			uint32_t conv;
		} u;

		u.val = self;

		if (big_endian)
			u.conv = htobe32(u.conv);
		else u.conv = htole32(u.conv);

		return u.bytes[index];
	`}

	# Utility for `BinaryWriter`
	private fun double_byte_at(index: Int, big_endian: Bool): Int `{
		union {
			unsigned char bytes[8];
			double val;
			uint64_t conv;
		} u;

		u.val = self;

		if (big_endian)
			u.conv = htobe64(u.conv);
		else u.conv = htole64(u.conv);

		return u.bytes[index];
	`}
end

redef class Float
	redef fun to_jvalue(env): JValue `{
		jvalue value;
		value.f = self;
		return value;
	`}
end

redef class Float
    redef fun to_bi do
        var tmp = new NativeMPZ
        tmp.set_d self
        return new BigInt(tmp)
    end

    redef fun to_r do
        var tmp = new NativeMPQ
        tmp.set_d self
        return new Ratio(tmp)
    end
end

redef universal Float super Sqlite3Data end

redef class Float super DirectSerializable end

redef class Float
	redef fun accept_json_serializer(v) do v.stream.write to_s
end

redef class Float
	redef fun accept_inspect_serializer(v) do v.stream.write to_s
end

redef universal Float
	# Smoothened `self`, used by `ImprovedNoise`
	private fun fade: Float do return self*self*self*(self*(self*6.0-15.0)+10.0)
end

redef universal Float
	# Normalize the `self` angle in radians to be within `[-pi .. pi[`
	#
	# ~~~
	# assert (1.5*pi).angle_normalize.is_approx(-0.5*pi, 0.0001)
	# assert 8.0.angle_normalize.is_approx(1.7168, 0.0001)
	# assert (-1.0).angle_normalize == -1.0
	# ~~~
	fun angle_normalize: Float
	do
		var s = self
		while s < -pi do s += 2.0*pi
		while s >= pi do s -= 2.0*pi
		return s
	end

	# Linear interpolation of between the angles `a` and `b`, in radians
	#
	# The result is normalized with `angle_normalize`.
	#
	# ~~~
	# assert 0.5.angle_lerp(0.0, pi).is_approx(0.5*pi, 0.0001)
	# assert 8.5.angle_lerp(0.0, pi).is_approx(0.5*pi, 0.0001)
	# assert 7.5.angle_lerp(0.0, pi).is_approx(-0.5*pi, 0.0001)
	# assert 0.5.angle_lerp(0.2, 2.0*pi-0.1).is_approx(0.05, 0.0001)
	# ~~~
	fun angle_lerp(a, b: Float): Float
	do
		var d = b - a
		while d > pi do d -= 2.0*pi
		while d < -pi do d += 2.0*pi
		return (a + d*self).angle_normalize
	end
end

redef class Float
	redef fun accept_msgpack_serializer(v) do v.stream.write_msgpack_double self
end

redef class Float
	redef fun add_to_bundle(bundle, key)
	do
		bundle.put_double(key, self)
	end
end