Lib.swift

import Darwin
import CoreGraphics

protocol ScalarFunctions {
  var acos:Double  {get}
  var asin:Double  {get}
  var atan:Double  {get}
  func atan2(x:Double) -> Double
  var cos:Double   {get}
  var sin:Double   {get}
  var tan:Double   {get}
  var exp:Double   {get}
  var exp2:Double  {get}
  var log:Double   {get}
  var log10:Double {get}
  var log2:Double  {get}
  func pow(exponent:Double) -> Double
  var sqrt:Double  {get}
}


extension Double : ScalarFunctions {
  var abs:Double  { return Double.abs(self)   }
  var acos:Double { return Darwin.acos(self)  }
  var asin:Double { return Darwin.asin(self)  }
  var atan:Double { return Darwin.atan(self)  }
  func atan2(x:Double) -> Double { return Darwin.atan2(self,x) }
  var cos:Double  { return Darwin.cos(self)   }
  var sin:Double  { return Darwin.sin(self)   }
  var tan:Double  { return Darwin.tan(self)   }
  var exp:Double  { return Darwin.exp(self)   }
  var exp2:Double { return Darwin.exp2(self)  }
  var log:Double  { return Darwin.log(self)   }
  var log10:Double{ return Darwin.log10(self) }
  var log2:Double { return Darwin.log2(self)  }
  func pow(exponent:Double)-> Double { return Darwin.pow(self, exponent) }
  var sqrt:Double { return Darwin.sqrt(self)  }
}

protocol ScalarArithmetic {
  var toDouble:Double { get }
  init(_ value:Double)
}

extension Int : ScalarArithmetic {
  var toDouble:Double { return Double(self) }
}


#if !(arch(x86_64) || arch(arm64))
extension CGFloat : ScalarArithmetic, ScalarFunctions {
  var toDouble:Double { return Double(self)      }
  var abs:Double      { return Double(self).abs  }
  var acos:Double     { return Double(self).acos }
  var asin:Double     { return Double(self).asin }
  var atan:Double     { return Double(self).atan }
  func atan2(x:Double) -> Double { return Double(self).atan2(x) }
  var cos:Double      { return Double(self).cos  }
  var sin:Double      { return Double(self).sin  }
  var tan:Double      { return Double(self).tan  }
  var exp:Double      { return Double(self).exp  }
  var exp2:Double     { return Double(self).exp2 }
  var log:Double      { return Double(self).log  }
  var log10:Double    { return Double(self).log10}
  var log2:Double     { return Double(self).log2 }
  func pow(exponent:Double)-> Double { return Double(self).pow(exponent) }
  var sqrt:Double     { return Double(self).sqrt }
}
  
#endif


//Equality T<===>T
//@infix func == <T:ScalarArithmetic, U:ScalarArithmetic> (lhs:T,rhs:U) -> Bool {
//  return (lhs.toDouble == rhs.toDouble)
//}
//@infix func != <T:ScalarArithmetic, U:ScalarArithmetic> (lhs:T,rhs:U) -> Bool {
//  return (lhs == rhs) == false
//}
@infix func <= <T:ScalarArithmetic, U:ScalarArithmetic> (lhs:T,rhs:U) -> Bool {
  return (lhs.toDouble <= rhs.toDouble)
}
@infix func < <T:ScalarArithmetic, U:ScalarArithmetic> (lhs:T,rhs:U) -> Bool {
  return (lhs.toDouble <  rhs.toDouble)
}
//@infix func >= <T:ScalarArithmetic, U:ScalarArithmetic> (lhs:T,rhs:U) -> Bool {
//  return (lhs < rhs) == false
//}
//@infix func >  <T:ScalarArithmetic, U:ScalarArithmetic> (lhs:T,rhs:U) -> Bool {
//  return (lhs <= rhs) == false
//}

//Equality Double<==>T
//@infix func == <T:ScalarArithmetic> (lhs:Double, rhs:T) -> Bool {
//  return (lhs == rhs.toDouble)
//}
//@infix func != <T:ScalarArithmetic> (lhs:Double, rhs:T) -> Bool {
//  return (lhs == rhs) == false
//}
@infix func <= <T:ScalarArithmetic> (lhs:Double, rhs:T) -> Bool {
  return (lhs <= rhs.toDouble)
}
@infix func < <T:ScalarArithmetic> (lhs:Double, rhs:T) -> Bool {
  return (lhs <  rhs.toDouble)
}
//@infix func >= <T:ScalarArithmetic> (lhs:Double, rhs:T) -> Bool {
//  return (lhs < rhs) == false
//}
//@infix func >  <T:ScalarArithmetic> (lhs:Double, rhs:T) -> Bool {
//  return (lhs <= rhs) == false
//}


//Equality T<==>Double
//@infix func == <T:ScalarArithmetic> (lhs:T,rhs:Double) -> Bool {
//  return (lhs.toDouble == rhs)
//}
//@infix func != <T:ScalarArithmetic> (lhs:T,rhs:Double) -> Bool {
//  return (lhs == rhs) == false
//}
@infix func <= <T:ScalarArithmetic> (lhs:T,rhs:Double) -> Bool {
  return (lhs.toDouble <= rhs)
}
@infix func < <T:ScalarArithmetic> (lhs:T,rhs:Double) -> Bool {
  return (lhs.toDouble <  rhs)
}
//@infix func >= <T:ScalarArithmetic> (lhs:T,rhs:Double) -> Bool {
//  return (lhs < rhs) == false
//}
//@infix func >  <T:ScalarArithmetic> (lhs:T,rhs:Double) -> Bool {
//  return (lhs <= rhs) == false
//}


//SUBTRACTION
@infix func - <T:ScalarArithmetic, U:ScalarArithmetic>(lhs: T, rhs:U) -> Double  {
  return lhs.toDouble - rhs.toDouble
}
@infix func - <T:ScalarArithmetic>(lhs:Double, rhs:T) -> Double  {
  return lhs - rhs.toDouble
}
@infix func - <T:ScalarArithmetic>(lhs:T, rhs:Double) -> Double  {
  return lhs.toDouble - rhs
}
@assignment  @infix func -= <T:ScalarArithmetic>(inout lhs:Double, rhs:T)  {
  lhs = lhs - rhs.toDouble
}

//ADDITION
@infix func + <T:ScalarArithmetic, U:ScalarArithmetic>(lhs: T, rhs:U) -> Double  {
  return lhs.toDouble + rhs.toDouble
}
@infix func + <T:ScalarArithmetic>(lhs:Double, rhs:T) -> Double  {
  return lhs + rhs.toDouble
}
@infix func + <T:ScalarArithmetic>(lhs:T, rhs:Double) -> Double  {
  return lhs.toDouble + rhs
}
@assignment  @infix func += <T:ScalarArithmetic>(inout lhs:Double, rhs:T)  {
  lhs = lhs + rhs.toDouble
}

//MULTIPLICATION
@infix func * <T:ScalarArithmetic, U:ScalarArithmetic>(lhs: T, rhs:U) -> Double  {
  return lhs.toDouble * rhs.toDouble
}
@infix func * <T:ScalarArithmetic>(lhs:Double, rhs:T) -> Double  {
  return lhs * rhs.toDouble
}
@infix func * <T:ScalarArithmetic>(lhs:T, rhs:Double) -> Double  {
  return lhs.toDouble * rhs
}
@assignment @infix func *= <T:ScalarArithmetic>(inout lhs:Double, rhs:T)  {
  lhs = lhs * rhs.toDouble
}

//DIVISION
@infix func / <T:ScalarArithmetic, U:ScalarArithmetic>(lhs: T, rhs:U) -> Double  {
  return lhs.toDouble / rhs.toDouble
}
@infix func / <T:ScalarArithmetic>(lhs: Double, rhs:T) -> Double  {
  return lhs / rhs.toDouble
}
@infix func / <T:ScalarArithmetic>(lhs: T, rhs:Double) -> Double  {
  return lhs.toDouble / rhs
}
@assignment @infix func /= <T:ScalarArithmetic>(inout lhs:Double, rhs:T)  {
  lhs = lhs / rhs.toDouble
}

testcase.swift

import XCTest
import CoreGraphics

class TestsScalarComparableGeneric: XCTestCase {
  var cgFloatValue  = CGFloat(2.0)
  var doubleValue = Double(2.0)
  var intValue      = 2

  func testEqual() {
    XCTAssert(self.cgFloatValue == self.doubleValue);
    XCTAssert(self.cgFloatValue == self.intValue);
    XCTAssert(self.doubleValue == self.intValue);
    XCTAssert(self.doubleValue == self.cgFloatValue);
    XCTAssert(self.intValue == self.doubleValue);
    XCTAssert(self.intValue == self.cgFloatValue);

  }
  func testNotEqual() {
    XCTAssertFalse(self.cgFloatValue != self.doubleValue);
    XCTAssertFalse(self.cgFloatValue != self.intValue);
    XCTAssertFalse(self.doubleValue != self.intValue);
    XCTAssertFalse(self.doubleValue != self.cgFloatValue);
    XCTAssertFalse(self.intValue != self.doubleValue);
    XCTAssertFalse(self.intValue != self.cgFloatValue);
    
  }
  func testLessThanOrEqual() {
    XCTAssert(self.cgFloatValue <= self.doubleValue);
    XCTAssert(self.cgFloatValue <= self.intValue);
    XCTAssert(self.doubleValue <= self.intValue);
    XCTAssert(self.doubleValue <= self.cgFloatValue);
    XCTAssert(self.intValue <= self.doubleValue);
    XCTAssert(self.intValue <= self.cgFloatValue);
    
    self.cgFloatValue = -1
    XCTAssert(self.cgFloatValue <= self.doubleValue);
    XCTAssert(self.cgFloatValue <= self.intValue);
    
    self.doubleValue = -2
    XCTAssert(self.doubleValue <= self.intValue);
    XCTAssert(self.doubleValue <= self.cgFloatValue);

    self.intValue = -3
    XCTAssert(self.intValue <= self.doubleValue);
    XCTAssert(self.intValue <= self.cgFloatValue);


  }
  func testLessThan() {
    self.cgFloatValue = -1
    XCTAssert(self.cgFloatValue < self.doubleValue);
    XCTAssert(self.cgFloatValue < self.intValue);
    
    self.doubleValue = -2
    XCTAssert(self.doubleValue < self.intValue);
    XCTAssert(self.doubleValue < self.cgFloatValue);
    
    self.intValue = -3
    XCTAssert(self.intValue < self.doubleValue);
    XCTAssert(self.intValue < self.cgFloatValue);

  }
  func testGreaterThanOrEqual() {
    
  }
  func testGreaterThan() {
    
  }

}