# Native 16-bit unsigned integer.
# Same as a C `uint16_t`
universal UInt16
	super Discrete
	super Numeric

	redef type OTHER: UInt16

	redef fun successor(i) do return self + i.to_u16
	redef fun predecessor(i) do return self - i.to_u16

	redef fun object_id is intern
	redef fun hash do return self.to_i
	redef fun ==(i) is intern
	redef fun !=(i) is intern
	redef fun output is intern

	redef fun <=(i) is intern
	redef fun <(i) is intern
	redef fun >=(i) is intern
	redef fun >(i) is intern
	redef fun +(i) is intern

	#     assert -1u16 == 0xFFFFu16
	#     assert -0u16 == 0u16
	redef fun - is intern
	redef fun -(i) is intern
	redef fun *(i) is intern
	redef fun /(i) is intern

	# Modulo of `self` with `i`.
	#
	# Returns the remainder of division of `self` by `i`.
	#
	#     assert 5u16 % 2u16	== 1u16
	#     assert 10u16 % 2u16	== 0u16
	fun %(i: UInt16): UInt16 is intern

	redef fun zero do return 0.to_u16
	redef fun value_of(val) do return val.to_u16

	# `i` bits shift to the left
	#
	#     assert 5u16 << 1    == 10u16
	fun <<(i: Int): UInt16 is intern

	# `i` bits shift to the right
	#
	#     assert 5u16 >> 1    == 2u16
	fun >>(i: Int): UInt16 is intern

	redef fun to_i is intern
	redef fun to_f is intern
	redef fun to_b is intern
	redef fun to_i8 is intern
	redef fun to_i16 is intern
	redef fun to_u16 do return self
	redef fun to_i32 is intern
	redef fun to_u32 is intern

	redef fun distance(i) do return (self - i).to_i

	redef fun <=>(other)
	do
		if self < other then
			return -1
		else if other < self then
			return 1
		else
			return 0
		end
	end

	redef fun is_between(c, d)
	do
		if self < c or d < self then
			return false
		else
			return true
		end
	end

	redef fun max(other)
	do
		if self < other then
			return other
		else
			return self
		end
	end

	redef fun min(c)
	do
		if c < self then
			return c
		else
			return self
		end
	end

	# Returns the result of a binary AND operation on `self` and `i`
	#
	#     assert 0x10u16 & 0x01u16 == 0u16
	fun &(i: UInt16): UInt16 is intern

	# Returns the result of a binary OR operation on `self` and `i`
	#
	#     assert 0x10u16 | 0x01u16 == 0x11u16
	fun |(i: UInt16): UInt16 is intern

	# Returns the result of a binary XOR operation on `self` and `i`
	#
	#     assert 0x101u16 ^ 0x110u16 == 0x11u16
	fun ^(i: UInt16): UInt16 is intern

	# Returns the 1's complement of `self`
	#
	#     assert ~0x2Fu16 == 0xFFD0u16
	fun ~: UInt16 is intern
end