RawValueConvertible.swift

import Foundation

// value types which are convertible to and from a Double raw value
protocol RawValueConvertible
{
	init(_ rawValue: Double)
	var rawValue: Double { get set }
}

func enumerateRawValues<T: RawValueConvertible>(from: T, to: T, unitDivisor: T, block: (_ value: T)->())
{
	let start = from.rawValue
	let divisor = abs(unitDivisor.rawValue)
	let actualStart = divisor * ceil(start / divisor)
	
	var value = T(actualStart)
	
	repeat
	{
		block(value)
		
		value = T(value.rawValue + divisor)
	}
		while value < to
}

func round<T: RawValueConvertible>(_ value: T) -> T
{
	let newValue = round(value.rawValue)
	return T(newValue)
}

// MARK: - Equatable

func == <T: RawValueConvertible>(left: T, right: T) -> Bool
{
	let leftVal = round(left.rawValue*10.0)
	let rightVal = round(right.rawValue*10.0)
	
	return leftVal == rightVal
}

// MARK: - Comparable

func < <T: RawValueConvertible>(left: T, right: T) -> Bool
{
	let leftVal = round(left.rawValue*10.0)
	let rightVal = round(right.rawValue*10.0)
	
	return leftVal < rightVal
}

func <= <T: RawValueConvertible>(left: T, right: T) -> Bool
{
	let leftVal = round(left.rawValue*10.0)
	let rightVal = round(right.rawValue*10.0)
	
	return leftVal <= rightVal
}

func > <T: RawValueConvertible>(left: T, right: T) -> Bool
{
	let leftVal = round(left.rawValue*10.0)
	let rightVal = round(right.rawValue*10.0)
	
	return leftVal > rightVal
}

func >= <T: RawValueConvertible>(left: T, right: T) -> Bool
{
	let leftVal = round(left.rawValue*10.0)
	let rightVal = round(right.rawValue*10.0)
	
	return leftVal >= rightVal
}

func min<T: RawValueConvertible>(_ left: T, _ right: T) -> T
{
	let value = min(left.rawValue, right.rawValue)
	
	return T(value)
}

func max<T: RawValueConvertible>(_ left: T, _ right: T) -> T
{
	let value = max(left.rawValue, right.rawValue)
	
	return T(value)
}

func -= <T: RawValueConvertible>(lhs: inout T, rhs: T)
{
	let newValue = lhs.rawValue - rhs.rawValue
	lhs = T(newValue)
}

func += <T: RawValueConvertible>(lhs: inout T, rhs: T)
{
	let newValue = lhs.rawValue + rhs.rawValue
	lhs = T(newValue)
}

func - <T: RawValueConvertible>(lhs: T, rhs: T) -> T
{
	let newValue = lhs.rawValue - rhs.rawValue
	return T(newValue)
}

func / <T: RawValueConvertible>(lhs: T, rhs: T) -> Int
{
	return Int(round(lhs.rawValue / rhs.rawValue))
}