Merge pull request #4 from chenhaiteng/develop

Develop

Author: chenhaiteng

.gitignore

@@ -3,3 +3,4 @@
 /Packages
 /*.xcodeproj
 xcuserdata/
+CoreGraphicsExtension.xcscheme

Sources/CoreGraphicsExtension/CGAngle.swift

@@ -8,45 +8,14 @@
 import Foundation
 import CoreGraphics
 
-public struct CGAngle {
-    public static var zero = CGAngle()
-    public var radians: CGFloat
-    
-    public var degrees: CGFloat {
-        radians*180/CGFloat.pi
-    }
-
-    @inlinable public init() {
-        radians = 0
-    }
+public typealias CGAngle = CGFloat
 
-    @inlinable public init<T: BinaryFloatingPoint>(radians: T) {
-        self.radians = CGFloat(radians)
-    }
-    
-    @inlinable public init<T: BinaryFloatingPoint>(degrees: T) {
-        self.radians = CGFloat(degrees)*CGFloat.pi/180
-    }
-    
-    @inlinable public static func radians<T: BinaryFloatingPoint>(_ radians: T) -> CGAngle {
-        CGAngle(radians: radians)
+extension CGAngle {
+    public static var zero: CGFloat = 0.0
+    public var radians: CGFloat {
+        self
     }
-    
-    @inlinable public static func degrees<T: BinaryFloatingPoint>(_ degrees: T) -> CGAngle {
-        CGAngle(degrees: degrees)
-    }
-    
-    public static func +(lhs:CGAngle, rhs: CGAngle) -> CGAngle {
-        CGAngle(radians: lhs.radians + rhs.radians)
-    }
-    
-    public static func +=(lhs: inout CGAngle, rhs: CGAngle) {
-        lhs.radians += rhs.radians
-    }
-}
-
-extension CGAngle: Hashable {
-    public func hash(into hasher: inout Hasher) {
-        hasher.combine(radians)
+    public var degrees: CGFloat {
+        self*180/CGFloat.pi
     }
 }

Sources/CoreGraphicsExtension/CGPolarPoint.swift

@@ -22,6 +22,8 @@ public struct CGPolarPoint {
     @inlinable public init<T: BinaryFloatingPoint>(radius: T, angle: CGAngle) {
         self.radius = CGFloat(radius)
         cgangle = angle
-        cgpoint = CGPoint(x: self.radius*cos(cgangle.radians), y: self.radius*sin(cgangle.radians))
+        let _cos: CGFloat = cos(cgangle.radians)
+        let _sin: CGFloat = sin(cgangle.radians)
+        cgpoint = CGPoint(x: self.radius*_cos, y: self.radius*_sin)
     }
 }

Tests/CoreGraphicsExtensionTests/CoreGraphicsExtensionTests.swift

@@ -2,17 +2,38 @@ import XCTest
 @testable import CoreGraphicsExtension
 
 final class CoreGraphicExtensionTests: XCTestCase {
-    func testExample() {
-        // This is an example of a functional test case.
-        // Use XCTAssert and related functions to verify your tests produce the correct
-        // results.
+    
+    let __CosZero = cos(CGFloat.pi/2.0)
+    let __Cos45 = cos(CGFloat.pi/4.0)
+    func testCGAngle() {
+        // Ensure zero works
         XCTAssertEqual(CGAngle.zero.radians, 0)
+        
+        let rightAngle = CGAngle.pi/2
+        XCTAssertEqual(rightAngle, CGFloat.pi/2)
+        XCTAssertEqual(rightAngle.degrees, 90)
+        XCTAssertEqual(rightAngle.radians, CGFloat.pi/2)
+    }
+    
+    func testPolarPoint() {
+        // Ensure zero works
         XCTAssertEqual(CGPolarPoint.zero.radius, 0)
         XCTAssertEqual(CGPolarPoint.zero.cgangle, CGAngle.zero)
         XCTAssertEqual(CGPolarPoint.zero.cgpoint, CGPoint.zero)
+        
+        let upPoint = CGPolarPoint(radius: CGFloat(1), angle: CGAngle.pi/2)
+        let rightUpPoint = CGPolarPoint(radius: CGFloat(sqrt(2)), angle: CGAngle.pi/4)
+        XCTAssertEqual(upPoint.radius, 1)
+        XCTAssertEqual(upPoint.cgangle, CGAngle.pi/2)
+        //For floating precisly problem, it cannot compare with CGPoint(x: 0.0, y: 1.0) directly.
+        XCTAssertEqual(upPoint.cgpoint, CGPoint(x: __CosZero, y: 1))
+        
+        //For floating precisly problem, it cannot compare with CGPoint(x: 1.0, y: 1.0) directly.
+        XCTAssertEqual(rightUpPoint.cgpoint, CGPoint(x: __Cos45*CGFloat(sqrt(2)), y:1))
     }
 
     static var allTests = [
-        ("testExample", testExample),
+        ("CGAngle", testCGAngle),
+        ("CGPolarPoint", testPolarPoint),
     ]
 }