From 9b1ae393404be15a54c8cb6f49efca07684f7d78 Mon Sep 17 00:00:00 2001
From: Yuta Koshizawa <koher@koherent.org>
Date: Thu, 21 Jun 2018 10:53:48 +0900
Subject: [PATCH 01/20] Rename `cos(angleFrom:)` to `cos(from:)`

---
 .../xcshareddata/IDEWorkspaceChecks.plist                 | 8 ++++++++
 Sources/CGPointVector/CGPoint.swift                       | 4 ++--
 Tests/CGPointVectorTests/CGPointTests.swift               | 2 +-
 3 files changed, 11 insertions(+), 3 deletions(-)
 create mode 100644 CGPointVector.xcodeproj/project.xcworkspace/xcshareddata/IDEWorkspaceChecks.plist

diff --git a/CGPointVector.xcodeproj/project.xcworkspace/xcshareddata/IDEWorkspaceChecks.plist b/CGPointVector.xcodeproj/project.xcworkspace/xcshareddata/IDEWorkspaceChecks.plist
new file mode 100644
index 0000000..18d9810
--- /dev/null
+++ b/CGPointVector.xcodeproj/project.xcworkspace/xcshareddata/IDEWorkspaceChecks.plist
@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+	<key>IDEDidComputeMac32BitWarning</key>
+	<true/>
+</dict>
+</plist>
diff --git a/Sources/CGPointVector/CGPoint.swift b/Sources/CGPointVector/CGPoint.swift
index 776b264..dfeb8fe 100644
--- a/Sources/CGPointVector/CGPoint.swift
+++ b/Sources/CGPointVector/CGPoint.swift
@@ -31,10 +31,10 @@ extension CGPoint {
     }
     
     public func angle(from point: CGPoint) -> CGFloat {
-        return acos(cos(angleFrom: point))
+        return acos(cos(from: point))
     }
     
-    public func cos(angleFrom point: CGPoint) -> CGFloat {
+    public func cos(from point: CGPoint) -> CGFloat {
         return fmin(fmax(self * point / sqrt(self.squareLength * point.squareLength), -1.0), 1.0)
     }
 }
diff --git a/Tests/CGPointVectorTests/CGPointTests.swift b/Tests/CGPointVectorTests/CGPointTests.swift
index 0ef3db4..f277927 100644
--- a/Tests/CGPointVectorTests/CGPointTests.swift
+++ b/Tests/CGPointVectorTests/CGPointTests.swift
@@ -45,7 +45,7 @@ class CGPointTests: XCTestCase {
     }
     
     func testCosOfAngle() {
-        XCTAssertEqual(CGPoint(x: 1.0, y: 0.0).cos(angleFrom: CGPoint(x: 1.0, y: sqrt(3.0))), 0.5, accuracy: torelance)
+        XCTAssertEqual(CGPoint(x: 1.0, y: 0.0).cos(from: CGPoint(x: 1.0, y: sqrt(3.0))), 0.5, accuracy: torelance)
     }
     
     func testDescription() {

From 612242e012d0001a4f65f7a23011b14ef2aaabc0 Mon Sep 17 00:00:00 2001
From: Yuta Koshizawa <koher@koherent.org>
Date: Thu, 21 Jun 2018 11:16:54 +0900
Subject: [PATCH 02/20] Rename `*(CGPoint, CGPoint)` to `dot(_:)`

---
 README.md                                         |  2 +-
 Sources/CGPointVector/CGPoint.swift               | 10 +++++-----
 Tests/CGPointVectorTests/CGPointTests.swift       | 10 +++++-----
 Tests/CGPointVectorTests/CGPointVectorTests.swift |  2 +-
 4 files changed, 12 insertions(+), 12 deletions(-)

diff --git a/README.md b/README.md
index 3edab4d..9feb418 100644
--- a/README.md
+++ b/README.md
@@ -25,7 +25,7 @@ let sum = a + b // (5.0, -9.0)
 let length = a.length // 5.0
 let distance = a.distance(from: b) // 1.4142135623731
 let unitVector = a.unit // (0.6, -0.8)
-let dotProduct = a * b // 26.0
+let dotProduct = a.dot(b) // 26.0
 ```
 
 ## Installation
diff --git a/Sources/CGPointVector/CGPoint.swift b/Sources/CGPointVector/CGPoint.swift
index dfeb8fe..5125c06 100644
--- a/Sources/CGPointVector/CGPoint.swift
+++ b/Sources/CGPointVector/CGPoint.swift
@@ -35,7 +35,11 @@ extension CGPoint {
     }
     
     public func cos(from point: CGPoint) -> CGFloat {
-        return fmin(fmax(self * point / sqrt(self.squareLength * point.squareLength), -1.0), 1.0)
+        return fmin(fmax(self.dot(point) / sqrt(self.squareLength * point.squareLength), -1.0), 1.0)
+    }
+    
+    public func dot(_ other: CGPoint) -> CGFloat {
+        return self.x * other.x + self.y * other.y
     }
 }
 
@@ -61,10 +65,6 @@ public func - (left: CGPoint, right: CGPoint) -> CGPoint {
     return CGPoint(x: left.x - right.x, y: left.y - right.y)
 }
 
-public func * (left: CGPoint, right: CGPoint) -> CGFloat {
-    return left.x * right.x + left.y * right.y
-}
-
 public func * (left: CGPoint, right: CGFloat) -> CGPoint {
     return CGPoint(x: left.x * right, y: left.y * right)
 }
diff --git a/Tests/CGPointVectorTests/CGPointTests.swift b/Tests/CGPointVectorTests/CGPointTests.swift
index f277927..4286cf5 100644
--- a/Tests/CGPointVectorTests/CGPointTests.swift
+++ b/Tests/CGPointVectorTests/CGPointTests.swift
@@ -48,6 +48,10 @@ class CGPointTests: XCTestCase {
         XCTAssertEqual(CGPoint(x: 1.0, y: 0.0).cos(from: CGPoint(x: 1.0, y: sqrt(3.0))), 0.5, accuracy: torelance)
     }
     
+    func testDot() {
+        XCTAssertEqual(CGPoint(x: 1.0, y: 2.0).dot(CGPoint(x: -3.0, y: 4.0)), 5.0, accuracy: torelance)
+    }
+    
     func testDescription() {
         XCTAssertEqual(CGPoint(x: 1.0, y: 2.0).description, "(1.0, 2.0)")
     }
@@ -69,10 +73,6 @@ class CGPointTests: XCTestCase {
     }
     
     func testMultiply() {
-        XCTAssertEqual(CGPoint(x: 1.0, y: 2.0) * CGPoint(x: -3.0, y: 4.0), 5.0, accuracy: torelance)
-    }
-    
-    func testMultiplyByFloat() {
         XCTAssertTrue((CGPoint(x: 1.0, y: -2.0) * 3.0).nearlyEqual(to: CGPoint(x: 3.0, y: -6.0), epsilon: torelance))
         XCTAssertTrue((3.0 * CGPoint(x: 1.0, y: -2.0)).nearlyEqual(to: CGPoint(x: 3.0, y: -6.0), epsilon: torelance))
     }
@@ -118,13 +118,13 @@ class CGPointTests: XCTestCase {
             ("testSquareDistance", testSquareDistance),
             ("testAngle", testAngle),
             ("testCosOfAngle", testCosOfAngle),
+            ("testDot", testDot),
             ("testDescription", testDescription),
             ("testPrefixPlus", testPrefixPlus),
             ("testNegate", testNegate),
             ("testAdd", testAdd),
             ("testSubtract", testSubtract),
             ("testMultiply", testMultiply),
-            ("testMultiplyByFloat", testMultiplyByFloat),
             ("testDivide", testDivide),
             ("testAdditionAssignment", testAdditionAssignment),
             ("testSuntractionAssignment", testSuntractionAssignment),
diff --git a/Tests/CGPointVectorTests/CGPointVectorTests.swift b/Tests/CGPointVectorTests/CGPointVectorTests.swift
index c2d00be..2521138 100644
--- a/Tests/CGPointVectorTests/CGPointVectorTests.swift
+++ b/Tests/CGPointVectorTests/CGPointVectorTests.swift
@@ -26,7 +26,7 @@ class CGPointVectorTests: XCTestCase {
         let length = a.length // 5.0
         let distance = a.distance(from: b) // 1.4142135623731
         let unitVector = a.unit // (0.6, -0.8)
-        let dotProduct = a * b // 26.0
+        let dotProduct = a.dot(b) // 26.0
 
         /**/ XCTAssertTrue(sum.nearlyEqual(to: CGPoint(x: 5.0, y: -9.0), epsilon: torelance))
         /**/ XCTAssertEqual(length, 5.0, accuracy: torelance)

From 115571a1f4faa607b2fb370a54a282b9afcc896f Mon Sep 17 00:00:00 2001
From: Yuta Koshizawa <koher@koherent.org>
Date: Thu, 21 Jun 2018 11:17:57 +0900
Subject: [PATCH 03/20] Implement `*(CGPoint, CGPoint) -> CGPoint)`

---
 Sources/CGPointVector/CGPoint.swift         | 4 ++++
 Tests/CGPointVectorTests/CGPointTests.swift | 1 +
 2 files changed, 5 insertions(+)

diff --git a/Sources/CGPointVector/CGPoint.swift b/Sources/CGPointVector/CGPoint.swift
index 5125c06..259c075 100644
--- a/Sources/CGPointVector/CGPoint.swift
+++ b/Sources/CGPointVector/CGPoint.swift
@@ -65,6 +65,10 @@ public func - (left: CGPoint, right: CGPoint) -> CGPoint {
     return CGPoint(x: left.x - right.x, y: left.y - right.y)
 }
 
+public func * (left: CGPoint, right: CGPoint) -> CGPoint {
+    return CGPoint(x: left.x * right.x, y: left.y * right.y)
+}
+
 public func * (left: CGPoint, right: CGFloat) -> CGPoint {
     return CGPoint(x: left.x * right, y: left.y * right)
 }
diff --git a/Tests/CGPointVectorTests/CGPointTests.swift b/Tests/CGPointVectorTests/CGPointTests.swift
index 4286cf5..53776ee 100644
--- a/Tests/CGPointVectorTests/CGPointTests.swift
+++ b/Tests/CGPointVectorTests/CGPointTests.swift
@@ -73,6 +73,7 @@ class CGPointTests: XCTestCase {
     }
     
     func testMultiply() {
+        XCTAssertTrue((CGPoint(x: 2.0, y: 3.0) * CGPoint(x: 5.0, y: 7.0)).nearlyEqual(to: CGPoint(x: 10.0, y: 21.0), epsilon: torelance))
         XCTAssertTrue((CGPoint(x: 1.0, y: -2.0) * 3.0).nearlyEqual(to: CGPoint(x: 3.0, y: -6.0), epsilon: torelance))
         XCTAssertTrue((3.0 * CGPoint(x: 1.0, y: -2.0)).nearlyEqual(to: CGPoint(x: 3.0, y: -6.0), epsilon: torelance))
     }

From 5cc96cb988d417cbe20d00f0da7d559141c54a8b Mon Sep 17 00:00:00 2001
From: Yuta Koshizawa <koher@koherent.org>
Date: Thu, 21 Jun 2018 11:27:29 +0900
Subject: [PATCH 04/20] =?UTF-8?q?Rename=20`*`=20for=20`CGAffineTransform`?=
 =?UTF-8?q?=20to=20`=E2=8A=97`?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Following to Swift for TensorFlow.
---
 README.md                                           |  2 +-
 Sources/CGPointVector/CGAffineTransform.swift       | 13 ++++++++-----
 .../CGPointVectorTests/CGAffineTransormTests.swift  | 10 +++++-----
 Tests/CGPointVectorTests/CGPointVectorTests.swift   |  2 +-
 4 files changed, 15 insertions(+), 12 deletions(-)

diff --git a/README.md b/README.md
index 9feb418..fe549cd 100644
--- a/README.md
+++ b/README.md
@@ -10,7 +10,7 @@ let a = CGPoint(x: 1, y: 2), b = CGPoint(x: -3, y: 5)
 let sum = a + b // (-2.0, 7.0)
 let distance = (b - a).length // 5.0
 let direction = (b - a).unit // (-0.8, 0.6)
-let rotated = a * CGAffineTransform(rotationAngle: CGFloat.pi / 2) // (-2.0, 1.0)
+let rotated = a ⊗ CGAffineTransform(rotationAngle: CGFloat.pi / 2) // (-2.0, 1.0)
 ```
 
 ## Usage
diff --git a/Sources/CGPointVector/CGAffineTransform.swift b/Sources/CGPointVector/CGAffineTransform.swift
index 426efbe..ee3eeba 100644
--- a/Sources/CGPointVector/CGAffineTransform.swift
+++ b/Sources/CGPointVector/CGAffineTransform.swift
@@ -1,5 +1,8 @@
 import CoreGraphics
 
+infix operator ⊗ : MultiplicationPrecedence
+infix operator ⊗= : AssignmentPrecedence
+
 extension CGAffineTransform {
     public func nearlyEqual(to transform: CGAffineTransform, epsilon: CGFloat) -> Bool {
         return fabs(a - transform.a) < epsilon && fabs(b - transform.b) < epsilon && fabs(c - transform.c) < epsilon && fabs(d - transform.d) < epsilon && fabs(tx - transform.tx) < epsilon && fabs(ty - transform.ty) < epsilon
@@ -16,18 +19,18 @@ extension CGAffineTransform: CustomStringConvertible {
     }
 }
 
-public func * (left: CGAffineTransform, right: CGAffineTransform) -> CGAffineTransform {
+public func ⊗ (left: CGAffineTransform, right: CGAffineTransform) -> CGAffineTransform {
     return left.concatenating(right)
 }
 
-public func * (left: CGAffineTransform, right: CGPoint) -> CGPoint {
+public func ⊗ (left: CGAffineTransform, right: CGPoint) -> CGPoint {
     return right.applying(left)
 }
 
-public func * (left: CGPoint, right: CGAffineTransform) -> CGPoint {
+public func ⊗ (left: CGPoint, right: CGAffineTransform) -> CGPoint {
     return left.applying(right)
 }
 
-public func *= (left: inout CGAffineTransform, right: CGAffineTransform) {
-    left = left * right
+public func ⊗= (left: inout CGAffineTransform, right: CGAffineTransform) {
+    left = left ⊗ right
 }
diff --git a/Tests/CGPointVectorTests/CGAffineTransormTests.swift b/Tests/CGPointVectorTests/CGAffineTransormTests.swift
index 7d26cd4..849d8fc 100644
--- a/Tests/CGPointVectorTests/CGAffineTransormTests.swift
+++ b/Tests/CGPointVectorTests/CGAffineTransormTests.swift
@@ -70,14 +70,14 @@ class CGAffineTransormTests: XCTestCase {
     }
     
     func testMultiply() {
-        XCTAssertTrue((CGAffineTransform(a: 1, b: 2, c: 3, d: 4, tx: 5, ty: 6) * CGAffineTransform(a: 6, b: 5, c: 4, d: 3, tx: 2, ty: 1))
+        XCTAssertTrue((CGAffineTransform(a: 1, b: 2, c: 3, d: 4, tx: 5, ty: 6) ⊗ CGAffineTransform(a: 6, b: 5, c: 4, d: 3, tx: 2, ty: 1))
             .nearlyEqual(to: CGAffineTransform(a: 14, b: 11, c: 34, d: 27, tx: 56, ty: 44), epsilon: torelance))
     }
     
     func testMultiplyByPoint() {
-        XCTAssertTrue((CGPoint(x: 1.0, y: 1.0) * CGAffineTransform(rotationAngle: CGFloat.pi / 4))
+        XCTAssertTrue((CGPoint(x: 1.0, y: 1.0) ⊗ CGAffineTransform(rotationAngle: CGFloat.pi / 4))
             .nearlyEqual(to: CGPoint(x: 0.0, y: sqrt(2)), epsilon: torelance))
-        XCTAssertTrue((CGAffineTransform(translationX: 1.0, y: -2.0) * CGPoint(x: 1.0, y: 1.0))
+        XCTAssertTrue((CGAffineTransform(translationX: 1.0, y: -2.0) ⊗ CGPoint(x: 1.0, y: 1.0))
             .nearlyEqual(to: CGPoint(x: 2.0, y: -1.0), epsilon: torelance))
     }
     
@@ -87,11 +87,11 @@ class CGAffineTransormTests: XCTestCase {
     
     func testMultiplicationAssignment() {
         var a = CGAffineTransform(a: 1, b: 2, c: 3, d: 4, tx: 5, ty: 6)
-        a *= CGAffineTransform(a: 6, b: 5, c: 4, d: 3, tx: 2, ty: 1)
+        a ⊗= CGAffineTransform(a: 6, b: 5, c: 4, d: 3, tx: 2, ty: 1)
         print(a)
         
         XCTAssertTrue(a.nearlyEqual(to: CGAffineTransform(a: 1, b: 2, c: 3, d: 4, tx: 5, ty: 6)
-            * CGAffineTransform(a: 6, b: 5, c: 4, d: 3, tx: 2, ty: 1), epsilon: torelance))
+            ⊗ CGAffineTransform(a: 6, b: 5, c: 4, d: 3, tx: 2, ty: 1), epsilon: torelance))
     }
     
     static var allTests : [(String, (CGAffineTransormTests) -> () throws -> Void)] {
diff --git a/Tests/CGPointVectorTests/CGPointVectorTests.swift b/Tests/CGPointVectorTests/CGPointVectorTests.swift
index 2521138..2e07e60 100644
--- a/Tests/CGPointVectorTests/CGPointVectorTests.swift
+++ b/Tests/CGPointVectorTests/CGPointVectorTests.swift
@@ -10,7 +10,7 @@ class CGPointVectorTests: XCTestCase {
         let sum = a + b // (-2.0, 7.0)
         let distance = (b - a).length // 5.0
         let direction = (b - a).unit // (-0.8, 0.6)
-        let rotated = a * CGAffineTransform(rotationAngle: CGFloat.pi / 2) // (-2.0, 1.0)
+        let rotated = a ⊗ CGAffineTransform(rotationAngle: CGFloat.pi / 2) // (-2.0, 1.0)
 
         /**/ XCTAssertTrue(sum.nearlyEqual(to: CGPoint(x: -2.0, y: 7.0), epsilon: torelance))
         /**/ XCTAssertEqual(distance, 5.0, accuracy: torelance)

From 471fc47a4e91e168f996f36df772e8fe3f33c6d6 Mon Sep 17 00:00:00 2001
From: Yuta Koshizawa <koher@koherent.org>
Date: Thu, 21 Jun 2018 11:29:14 +0900
Subject: [PATCH 05/20] Fix typo

---
 CGPointVector.xcodeproj/project.pbxproj          | 16 ++++++++--------
 ...mTests.swift => CGAffineTransformTests.swift} |  0
 2 files changed, 8 insertions(+), 8 deletions(-)
 rename Tests/CGPointVectorTests/{CGAffineTransormTests.swift => CGAffineTransformTests.swift} (100%)

diff --git a/CGPointVector.xcodeproj/project.pbxproj b/CGPointVector.xcodeproj/project.pbxproj
index f77e85c..90f67e9 100644
--- a/CGPointVector.xcodeproj/project.pbxproj
+++ b/CGPointVector.xcodeproj/project.pbxproj
@@ -30,17 +30,17 @@
 		D62C6DFD1FB5657B00E7DF02 /* CGPointVector.h in Headers */ = {isa = PBXBuildFile; fileRef = D62C6DE81FB5657000E7DF02 /* CGPointVector.h */; settings = {ATTRIBUTES = (Public, ); }; };
 		D62C6DFE1FB5657B00E7DF02 /* CGRect.swift in Sources */ = {isa = PBXBuildFile; fileRef = D62C6DE91FB5657000E7DF02 /* CGRect.swift */; };
 		D62C6DFF1FB5657B00E7DF02 /* CGSize.swift in Sources */ = {isa = PBXBuildFile; fileRef = D62C6DEA1FB5657000E7DF02 /* CGSize.swift */; };
-		D62C6E001FB5658A00E7DF02 /* CGAffineTransormTests.swift in Sources */ = {isa = PBXBuildFile; fileRef = D62C6DDD1FB5657000E7DF02 /* CGAffineTransormTests.swift */; };
+		D62C6E001FB5658A00E7DF02 /* CGAffineTransformTests.swift in Sources */ = {isa = PBXBuildFile; fileRef = D62C6DDD1FB5657000E7DF02 /* CGAffineTransformTests.swift */; };
 		D62C6E011FB5658A00E7DF02 /* CGPointTests.swift in Sources */ = {isa = PBXBuildFile; fileRef = D62C6DDE1FB5657000E7DF02 /* CGPointTests.swift */; };
 		D62C6E021FB5658A00E7DF02 /* CGPointVectorTests.swift in Sources */ = {isa = PBXBuildFile; fileRef = D62C6DDF1FB5657000E7DF02 /* CGPointVectorTests.swift */; };
 		D62C6E031FB5658A00E7DF02 /* CGRectTests.swift in Sources */ = {isa = PBXBuildFile; fileRef = D62C6DE01FB5657000E7DF02 /* CGRectTests.swift */; };
 		D62C6E041FB5658A00E7DF02 /* CGSizeTests.swift in Sources */ = {isa = PBXBuildFile; fileRef = D62C6DE11FB5657000E7DF02 /* CGSizeTests.swift */; };
-		D62C6E051FB5658A00E7DF02 /* CGAffineTransormTests.swift in Sources */ = {isa = PBXBuildFile; fileRef = D62C6DDD1FB5657000E7DF02 /* CGAffineTransormTests.swift */; };
+		D62C6E051FB5658A00E7DF02 /* CGAffineTransformTests.swift in Sources */ = {isa = PBXBuildFile; fileRef = D62C6DDD1FB5657000E7DF02 /* CGAffineTransformTests.swift */; };
 		D62C6E061FB5658A00E7DF02 /* CGPointTests.swift in Sources */ = {isa = PBXBuildFile; fileRef = D62C6DDE1FB5657000E7DF02 /* CGPointTests.swift */; };
 		D62C6E071FB5658A00E7DF02 /* CGPointVectorTests.swift in Sources */ = {isa = PBXBuildFile; fileRef = D62C6DDF1FB5657000E7DF02 /* CGPointVectorTests.swift */; };
 		D62C6E081FB5658A00E7DF02 /* CGRectTests.swift in Sources */ = {isa = PBXBuildFile; fileRef = D62C6DE01FB5657000E7DF02 /* CGRectTests.swift */; };
 		D62C6E091FB5658A00E7DF02 /* CGSizeTests.swift in Sources */ = {isa = PBXBuildFile; fileRef = D62C6DE11FB5657000E7DF02 /* CGSizeTests.swift */; };
-		D62C6E0A1FB5658C00E7DF02 /* CGAffineTransormTests.swift in Sources */ = {isa = PBXBuildFile; fileRef = D62C6DDD1FB5657000E7DF02 /* CGAffineTransormTests.swift */; };
+		D62C6E0A1FB5658C00E7DF02 /* CGAffineTransformTests.swift in Sources */ = {isa = PBXBuildFile; fileRef = D62C6DDD1FB5657000E7DF02 /* CGAffineTransformTests.swift */; };
 		D62C6E0B1FB5658C00E7DF02 /* CGPointTests.swift in Sources */ = {isa = PBXBuildFile; fileRef = D62C6DDE1FB5657000E7DF02 /* CGPointTests.swift */; };
 		D62C6E0C1FB5658C00E7DF02 /* CGPointVectorTests.swift in Sources */ = {isa = PBXBuildFile; fileRef = D62C6DDF1FB5657000E7DF02 /* CGPointVectorTests.swift */; };
 		D62C6E0D1FB5658C00E7DF02 /* CGRectTests.swift in Sources */ = {isa = PBXBuildFile; fileRef = D62C6DE01FB5657000E7DF02 /* CGRectTests.swift */; };
@@ -79,7 +79,7 @@
 		D62C6DB71FB564F700E7DF02 /* CGPointVector.framework */ = {isa = PBXFileReference; explicitFileType = wrapper.framework; includeInIndex = 0; path = CGPointVector.framework; sourceTree = BUILT_PRODUCTS_DIR; };
 		D62C6DBF1FB564F700E7DF02 /* CGPointVectorTests-tvOS.xctest */ = {isa = PBXFileReference; explicitFileType = wrapper.cfbundle; includeInIndex = 0; path = "CGPointVectorTests-tvOS.xctest"; sourceTree = BUILT_PRODUCTS_DIR; };
 		D62C6DD31FB5650C00E7DF02 /* CGPointVector.framework */ = {isa = PBXFileReference; explicitFileType = wrapper.framework; includeInIndex = 0; path = CGPointVector.framework; sourceTree = BUILT_PRODUCTS_DIR; };
-		D62C6DDD1FB5657000E7DF02 /* CGAffineTransormTests.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = CGAffineTransormTests.swift; sourceTree = "<group>"; };
+		D62C6DDD1FB5657000E7DF02 /* CGAffineTransformTests.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = CGAffineTransformTests.swift; sourceTree = "<group>"; };
 		D62C6DDE1FB5657000E7DF02 /* CGPointTests.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = CGPointTests.swift; sourceTree = "<group>"; };
 		D62C6DDF1FB5657000E7DF02 /* CGPointVectorTests.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = CGPointVectorTests.swift; sourceTree = "<group>"; };
 		D62C6DE01FB5657000E7DF02 /* CGRectTests.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = CGRectTests.swift; sourceTree = "<group>"; };
@@ -185,7 +185,7 @@
 		D62C6DDC1FB5657000E7DF02 /* CGPointVectorTests */ = {
 			isa = PBXGroup;
 			children = (
-				D62C6DDD1FB5657000E7DF02 /* CGAffineTransormTests.swift */,
+				D62C6DDD1FB5657000E7DF02 /* CGAffineTransformTests.swift */,
 				D62C6DDE1FB5657000E7DF02 /* CGPointTests.swift */,
 				D62C6DDF1FB5657000E7DF02 /* CGPointVectorTests.swift */,
 				D62C6DE01FB5657000E7DF02 /* CGRectTests.swift */,
@@ -514,7 +514,7 @@
 				D62C6E011FB5658A00E7DF02 /* CGPointTests.swift in Sources */,
 				D62C6E021FB5658A00E7DF02 /* CGPointVectorTests.swift in Sources */,
 				D62C6E041FB5658A00E7DF02 /* CGSizeTests.swift in Sources */,
-				D62C6E001FB5658A00E7DF02 /* CGAffineTransormTests.swift in Sources */,
+				D62C6E001FB5658A00E7DF02 /* CGAffineTransformTests.swift in Sources */,
 				D62C6E031FB5658A00E7DF02 /* CGRectTests.swift in Sources */,
 			);
 			runOnlyForDeploymentPostprocessing = 0;
@@ -537,7 +537,7 @@
 				D62C6E061FB5658A00E7DF02 /* CGPointTests.swift in Sources */,
 				D62C6E071FB5658A00E7DF02 /* CGPointVectorTests.swift in Sources */,
 				D62C6E091FB5658A00E7DF02 /* CGSizeTests.swift in Sources */,
-				D62C6E051FB5658A00E7DF02 /* CGAffineTransormTests.swift in Sources */,
+				D62C6E051FB5658A00E7DF02 /* CGAffineTransformTests.swift in Sources */,
 				D62C6E081FB5658A00E7DF02 /* CGRectTests.swift in Sources */,
 			);
 			runOnlyForDeploymentPostprocessing = 0;
@@ -560,7 +560,7 @@
 				D62C6E0B1FB5658C00E7DF02 /* CGPointTests.swift in Sources */,
 				D62C6E0C1FB5658C00E7DF02 /* CGPointVectorTests.swift in Sources */,
 				D62C6E0E1FB5658C00E7DF02 /* CGSizeTests.swift in Sources */,
-				D62C6E0A1FB5658C00E7DF02 /* CGAffineTransormTests.swift in Sources */,
+				D62C6E0A1FB5658C00E7DF02 /* CGAffineTransformTests.swift in Sources */,
 				D62C6E0D1FB5658C00E7DF02 /* CGRectTests.swift in Sources */,
 			);
 			runOnlyForDeploymentPostprocessing = 0;
diff --git a/Tests/CGPointVectorTests/CGAffineTransormTests.swift b/Tests/CGPointVectorTests/CGAffineTransformTests.swift
similarity index 100%
rename from Tests/CGPointVectorTests/CGAffineTransormTests.swift
rename to Tests/CGPointVectorTests/CGAffineTransformTests.swift

From 70ced00c1cb22a837d2210e02549ca7ec7324728 Mon Sep 17 00:00:00 2001
From: Yuta Koshizawa <koher@koherent.org>
Date: Thu, 21 Jun 2018 12:52:53 +0900
Subject: [PATCH 06/20] Refactor operators and tests

---
 CGPointVector.xcodeproj/project.pbxproj       |  10 +
 Sources/CGPointVector/CGAffineTransform.swift |  29 ++-
 Sources/CGPointVector/CGPoint.swift           | 128 ++++++++-----
 Sources/CGPointVector/CGRect.swift            |  10 +-
 Sources/CGPointVector/CGSize.swift            | 180 ++++++++++++------
 Sources/CGPointVector/Operators.swift         |   2 +
 .../CGAffineTransformTests.swift              |  19 +-
 Tests/CGPointVectorTests/CGPointTests.swift   |  18 ++
 Tests/CGPointVectorTests/CGRectTests.swift    |   8 +-
 Tests/CGPointVectorTests/CGSizeTests.swift    |  72 ++++++-
 10 files changed, 324 insertions(+), 152 deletions(-)
 create mode 100644 Sources/CGPointVector/Operators.swift

diff --git a/CGPointVector.xcodeproj/project.pbxproj b/CGPointVector.xcodeproj/project.pbxproj
index 90f67e9..d91cb23 100644
--- a/CGPointVector.xcodeproj/project.pbxproj
+++ b/CGPointVector.xcodeproj/project.pbxproj
@@ -45,6 +45,10 @@
 		D62C6E0C1FB5658C00E7DF02 /* CGPointVectorTests.swift in Sources */ = {isa = PBXBuildFile; fileRef = D62C6DDF1FB5657000E7DF02 /* CGPointVectorTests.swift */; };
 		D62C6E0D1FB5658C00E7DF02 /* CGRectTests.swift in Sources */ = {isa = PBXBuildFile; fileRef = D62C6DE01FB5657000E7DF02 /* CGRectTests.swift */; };
 		D62C6E0E1FB5658C00E7DF02 /* CGSizeTests.swift in Sources */ = {isa = PBXBuildFile; fileRef = D62C6DE11FB5657000E7DF02 /* CGSizeTests.swift */; };
+		D63F165820DB574100F8B479 /* Operators.swift in Sources */ = {isa = PBXBuildFile; fileRef = D63F165720DB574100F8B479 /* Operators.swift */; };
+		D63F165920DB574100F8B479 /* Operators.swift in Sources */ = {isa = PBXBuildFile; fileRef = D63F165720DB574100F8B479 /* Operators.swift */; };
+		D63F165A20DB574100F8B479 /* Operators.swift in Sources */ = {isa = PBXBuildFile; fileRef = D63F165720DB574100F8B479 /* Operators.swift */; };
+		D63F165B20DB574100F8B479 /* Operators.swift in Sources */ = {isa = PBXBuildFile; fileRef = D63F165720DB574100F8B479 /* Operators.swift */; };
 /* End PBXBuildFile section */
 
 /* Begin PBXContainerItemProxy section */
@@ -92,6 +96,7 @@
 		D62C6DE91FB5657000E7DF02 /* CGRect.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = CGRect.swift; sourceTree = "<group>"; };
 		D62C6DEA1FB5657000E7DF02 /* CGSize.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = CGSize.swift; sourceTree = "<group>"; };
 		D62C6DEB1FB5657000E7DF02 /* Info.plist */ = {isa = PBXFileReference; lastKnownFileType = text.plist.xml; path = Info.plist; sourceTree = "<group>"; };
+		D63F165720DB574100F8B479 /* Operators.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = Operators.swift; sourceTree = "<group>"; };
 /* End PBXFileReference section */
 
 /* Begin PBXFrameworksBuildPhase section */
@@ -212,6 +217,7 @@
 				D62C6DE91FB5657000E7DF02 /* CGRect.swift */,
 				D62C6DEA1FB5657000E7DF02 /* CGSize.swift */,
 				D62C6DEB1FB5657000E7DF02 /* Info.plist */,
+				D63F165720DB574100F8B479 /* Operators.swift */,
 			);
 			path = CGPointVector;
 			sourceTree = "<group>";
@@ -501,6 +507,7 @@
 			buildActionMask = 2147483647;
 			files = (
 				D62C6DF01FB5657900E7DF02 /* CGSize.swift in Sources */,
+				D63F165820DB574100F8B479 /* Operators.swift in Sources */,
 				D62C6DED1FB5657900E7DF02 /* CGPoint.swift in Sources */,
 				D62C6DEF1FB5657900E7DF02 /* CGRect.swift in Sources */,
 				D62C6DEC1FB5657900E7DF02 /* CGAffineTransform.swift in Sources */,
@@ -524,6 +531,7 @@
 			buildActionMask = 2147483647;
 			files = (
 				D62C6DF51FB5657A00E7DF02 /* CGSize.swift in Sources */,
+				D63F165920DB574100F8B479 /* Operators.swift in Sources */,
 				D62C6DF21FB5657A00E7DF02 /* CGPoint.swift in Sources */,
 				D62C6DF41FB5657A00E7DF02 /* CGRect.swift in Sources */,
 				D62C6DF11FB5657A00E7DF02 /* CGAffineTransform.swift in Sources */,
@@ -547,6 +555,7 @@
 			buildActionMask = 2147483647;
 			files = (
 				D62C6DFA1FB5657A00E7DF02 /* CGSize.swift in Sources */,
+				D63F165A20DB574100F8B479 /* Operators.swift in Sources */,
 				D62C6DF71FB5657A00E7DF02 /* CGPoint.swift in Sources */,
 				D62C6DF91FB5657A00E7DF02 /* CGRect.swift in Sources */,
 				D62C6DF61FB5657A00E7DF02 /* CGAffineTransform.swift in Sources */,
@@ -570,6 +579,7 @@
 			buildActionMask = 2147483647;
 			files = (
 				D62C6DFF1FB5657B00E7DF02 /* CGSize.swift in Sources */,
+				D63F165B20DB574100F8B479 /* Operators.swift in Sources */,
 				D62C6DFC1FB5657B00E7DF02 /* CGPoint.swift in Sources */,
 				D62C6DFE1FB5657B00E7DF02 /* CGRect.swift in Sources */,
 				D62C6DFB1FB5657B00E7DF02 /* CGAffineTransform.swift in Sources */,
diff --git a/Sources/CGPointVector/CGAffineTransform.swift b/Sources/CGPointVector/CGAffineTransform.swift
index ee3eeba..35ec5b7 100644
--- a/Sources/CGPointVector/CGAffineTransform.swift
+++ b/Sources/CGPointVector/CGAffineTransform.swift
@@ -1,8 +1,5 @@
 import CoreGraphics
 
-infix operator ⊗ : MultiplicationPrecedence
-infix operator ⊗= : AssignmentPrecedence
-
 extension CGAffineTransform {
     public func nearlyEqual(to transform: CGAffineTransform, epsilon: CGFloat) -> Bool {
         return fabs(a - transform.a) < epsilon && fabs(b - transform.b) < epsilon && fabs(c - transform.c) < epsilon && fabs(d - transform.d) < epsilon && fabs(tx - transform.tx) < epsilon && fabs(ty - transform.ty) < epsilon
@@ -19,18 +16,16 @@ extension CGAffineTransform: CustomStringConvertible {
     }
 }
 
-public func ⊗ (left: CGAffineTransform, right: CGAffineTransform) -> CGAffineTransform {
-    return left.concatenating(right)
-}
-
-public func ⊗ (left: CGAffineTransform, right: CGPoint) -> CGPoint {
-    return right.applying(left)
-}
-
-public func ⊗ (left: CGPoint, right: CGAffineTransform) -> CGPoint {
-    return left.applying(right)
-}
-
-public func ⊗= (left: inout CGAffineTransform, right: CGAffineTransform) {
-    left = left ⊗ right
+extension CGAffineTransform {
+    public static func ⊗ (lhs: CGAffineTransform, rhs: CGAffineTransform) -> CGAffineTransform {
+        return lhs.concatenating(rhs)
+    }
+    
+    public static func ⊗= (lhs: inout CGAffineTransform, rhs: CGAffineTransform) {
+        lhs = lhs ⊗ rhs
+    }
+    
+    public static func ⊗ (lhs: CGAffineTransform, rhs: CGPoint) -> CGPoint {
+        return rhs.applying(lhs)
+    }
 }
diff --git a/Sources/CGPointVector/CGPoint.swift b/Sources/CGPointVector/CGPoint.swift
index 259c075..140bfce 100644
--- a/Sources/CGPointVector/CGPoint.swift
+++ b/Sources/CGPointVector/CGPoint.swift
@@ -49,50 +49,90 @@ extension CGPoint: CustomStringConvertible {
     }
 }
 
-public prefix func + (value: CGPoint) -> CGPoint {
-    return value
-}
-
-public prefix func - (value: CGPoint) -> CGPoint {
-    return CGPoint(x: -value.x, y: -value.y)
-}
-
-public func + (left: CGPoint, right: CGPoint) -> CGPoint {
-    return CGPoint(x: left.x + right.x, y: left.y + right.y)
-}
-
-public func - (left: CGPoint, right: CGPoint) -> CGPoint {
-    return CGPoint(x: left.x - right.x, y: left.y - right.y)
-}
-
-public func * (left: CGPoint, right: CGPoint) -> CGPoint {
-    return CGPoint(x: left.x * right.x, y: left.y * right.y)
-}
-
-public func * (left: CGPoint, right: CGFloat) -> CGPoint {
-    return CGPoint(x: left.x * right, y: left.y * right)
-}
-
-public func * (left: CGFloat, right: CGPoint) -> CGPoint {
-    return CGPoint(x: right.x * left, y: right.y * left)
-}
-
-public func / (left: CGPoint, right: CGFloat) -> CGPoint {
-    return CGPoint(x: left.x / right, y: left.y / right)
-}
-
-public func += (left: inout CGPoint, right: CGPoint) {
-    left = left + right
-}
-
-public func -= (left: inout CGPoint, right: CGPoint) {
-    left = left - right
-}
-
-public func *= (left: inout CGPoint, right: CGFloat) {
-    left = left * right
+extension CGPoint {
+    public static prefix func + (value: CGPoint) -> CGPoint {
+        return value
+    }
+    
+    public static prefix func - (value: CGPoint) -> CGPoint {
+        return CGPoint(x: -value.x, y: -value.y)
+    }
+    
+    public static func + (lhs: CGPoint, rhs: CGPoint) -> CGPoint {
+        return CGPoint(x: lhs.x + rhs.x, y: lhs.y + rhs.y)
+    }
+    
+    public static func - (lhs: CGPoint, rhs: CGPoint) -> CGPoint {
+        return CGPoint(x: lhs.x - rhs.x, y: lhs.y - rhs.y)
+    }
+    
+    public static func * (lhs: CGPoint, rhs: CGPoint) -> CGPoint {
+        return CGPoint(x: lhs.x * rhs.x, y: lhs.y * rhs.y)
+    }
+    
+    public static func * (lhs: CGPoint, rhs: CGFloat) -> CGPoint {
+        return CGPoint(x: lhs.x * rhs, y: lhs.y * rhs)
+    }
+    
+    public static func * (lhs: CGFloat, rhs: CGPoint) -> CGPoint {
+        return CGPoint(x: rhs.x * lhs, y: rhs.y * lhs)
+    }
+    
+    public static func / (lhs: CGPoint, rhs: CGPoint) -> CGPoint {
+        return CGPoint(x: lhs.x / rhs.x, y: lhs.y / rhs.y)
+    }
+    
+    public static func / (lhs: CGPoint, rhs: CGFloat) -> CGPoint {
+        return CGPoint(x: lhs.x / rhs, y: lhs.y / rhs)
+    }
+    
+    public static func ⊗ (lhs: CGPoint, rhs: CGAffineTransform) -> CGPoint {
+        return lhs.applying(rhs)
+    }
+    
+    public static func += (lhs: inout CGPoint, rhs: CGPoint) {
+        lhs = lhs + rhs
+    }
+    
+    public static func -= (lhs: inout CGPoint, rhs: CGPoint) {
+        lhs = lhs - rhs
+    }
+    
+    public static func *= (lhs: inout CGPoint, rhs: CGPoint) {
+        lhs = lhs * rhs
+    }
+    
+    public static func *= (lhs: inout CGPoint, rhs: CGFloat) {
+        lhs = lhs * rhs
+    }
+    
+    public static func /= (lhs: inout CGPoint, rhs: CGPoint) {
+        lhs = lhs / rhs
+    }
+    
+    public static func /= (lhs: inout CGPoint, rhs: CGFloat) {
+        lhs = lhs / rhs
+    }
+    
+    public static func ⊗= (lhs: inout CGPoint, rhs: CGAffineTransform) {
+        lhs = lhs ⊗ rhs
+    }
 }
 
-public func /= (left: inout CGPoint, right: CGFloat) {
-    left = left / right
+extension CGPoint {
+    public static func + (lhs: CGPoint, rhs: CGSize) -> CGPoint {
+        return CGPoint(x: lhs.x + rhs.width, y: lhs.y + rhs.height)
+    }
+    
+    public static func - (lhs: CGPoint, rhs: CGSize) -> CGPoint {
+        return CGPoint(x: lhs.x - rhs.width, y: lhs.y - rhs.height)
+    }
+    
+    public static func * (lhs: CGPoint, rhs: CGSize) -> CGPoint {
+        return CGPoint(x: lhs.x * rhs.width, y: lhs.y * rhs.height)
+    }
+    
+    public static func / (lhs: CGPoint, rhs: CGSize) -> CGPoint {
+        return CGPoint(x: lhs.x / rhs.width, y: lhs.y / rhs.height)
+    }
 }
diff --git a/Sources/CGPointVector/CGRect.swift b/Sources/CGPointVector/CGRect.swift
index 884828f..6f7bd09 100644
--- a/Sources/CGPointVector/CGRect.swift
+++ b/Sources/CGPointVector/CGRect.swift
@@ -19,6 +19,12 @@ extension CGRect: CustomStringConvertible {
     }
 }
 
-public func * (left: CGRect, right: CGAffineTransform) -> CGRect {
-    return left.applying(right)
+extension CGRect {
+    public static func ⊗ (lhs: CGRect, rhs: CGAffineTransform) -> CGRect {
+        return lhs.applying(rhs)
+    }
+    
+    public static func ⊗= (lhs: inout CGRect, rhs: CGAffineTransform) {
+        lhs = lhs ⊗ rhs
+    }
 }
diff --git a/Sources/CGPointVector/CGSize.swift b/Sources/CGPointVector/CGSize.swift
index 5f0bdfa..19923bd 100644
--- a/Sources/CGPointVector/CGSize.swift
+++ b/Sources/CGPointVector/CGSize.swift
@@ -5,6 +5,42 @@ extension CGSize {
         let difference = self - point
         return fabs(difference.width) < epsilon && fabs(difference.height) < epsilon
     }
+    
+    public var length: CGFloat {
+        return sqrt(squareLength)
+    }
+    
+    public var squareLength: CGFloat {
+        return width * width + height * height
+    }
+    
+    public var unit: CGSize {
+        return self * (1.0 / length)
+    }
+    
+    public var phase: CGFloat {
+        return atan2(height, width)
+    }
+    
+    public func distance(from point: CGSize) -> CGFloat {
+        return (self - point).length
+    }
+    
+    public func squareDistance(from point: CGSize) -> CGFloat {
+        return (self - point).squareLength
+    }
+    
+    public func angle(from point: CGSize) -> CGFloat {
+        return acos(cos(from: point))
+    }
+    
+    public func cos(from point: CGSize) -> CGFloat {
+        return fmin(fmax(self.dot(point) / sqrt(self.squareLength * point.squareLength), -1.0), 1.0)
+    }
+    
+    public func dot(_ other: CGSize) -> CGFloat {
+        return self.width * other.width + self.height * other.height
+    }
 }
 
 extension CGSize: CustomStringConvertible {
@@ -13,66 +49,90 @@ extension CGSize: CustomStringConvertible {
     }
 }
 
-public prefix func + (value: CGSize) -> CGSize {
-    return value
-}
-
-public prefix func - (value: CGSize) -> CGSize {
-    return CGSize(width: -value.width, height: -value.height)
-}
-
-public func + (left: CGSize, right: CGSize) -> CGSize {
-    return CGSize(width: left.width + right.width, height: left.height + right.height)
-}
-
-public func - (left: CGSize, right: CGSize) -> CGSize {
-    return CGSize(width: left.width - right.width, height: left.height - right.height)
-}
-
-public func * (left: CGSize, right: CGAffineTransform) -> CGSize {
-    return left.applying(right)
-}
-
-public func * (left: CGSize, right: CGFloat) -> CGSize {
-    return CGSize(width: left.width * right, height: left.height * right)
-}
-
-public func * (left: CGFloat, right: CGSize) -> CGSize {
-    return CGSize(width: right.width * left, height: right.height * left)
-}
-
-public func / (left: CGSize, right: CGFloat) -> CGSize {
-    return CGSize(width: left.width / right, height: left.height / right)
-}
-
-public func += (left: inout CGSize, right: CGSize) {
-    left = left + right
-}
-
-public func -= (left: inout CGSize, right: CGSize) {
-    left = left - right
-}
-
-public func *= (left: inout CGSize, right: CGFloat) {
-    left = left * right
-}
-
-public func /= (left: inout CGSize, right: CGFloat) {
-    left = left / right
-}
-
-public func + (left: CGPoint, right: CGSize) -> CGPoint {
-    return CGPoint(x: left.x + right.width, y: left.y + right.height)
-}
-
-public func + (left: CGSize, right: CGPoint) -> CGPoint {
-    return CGPoint(x: left.width + right.x, y: left.height + right.y)
-}
-
-public func - (left: CGPoint, right: CGSize) -> CGPoint {
-    return CGPoint(x: left.x - right.width, y: left.y - right.height)
+extension CGSize {
+    public static prefix func + (value: CGSize) -> CGSize {
+        return value
+    }
+    
+    public static prefix func - (value: CGSize) -> CGSize {
+        return CGSize(width: -value.width, height: -value.height)
+    }
+    
+    public static func + (lhs: CGSize, rhs: CGSize) -> CGSize {
+        return CGSize(width: lhs.width + rhs.width, height: lhs.height + rhs.height)
+    }
+    
+    public static func - (lhs: CGSize, rhs: CGSize) -> CGSize {
+        return CGSize(width: lhs.width - rhs.width, height: lhs.height - rhs.height)
+    }
+    
+    public static func * (lhs: CGSize, rhs: CGSize) -> CGSize {
+        return CGSize(width: lhs.width * rhs.width, height: lhs.height * rhs.height)
+    }
+    
+    public static func * (lhs: CGSize, rhs: CGFloat) -> CGSize {
+        return CGSize(width: lhs.width * rhs, height: lhs.height * rhs)
+    }
+    
+    public static func * (lhs: CGFloat, rhs: CGSize) -> CGSize {
+        return CGSize(width: rhs.width * lhs, height: rhs.height * lhs)
+    }
+    
+    public static func / (lhs: CGSize, rhs: CGSize) -> CGSize {
+        return CGSize(width: lhs.width / rhs.width, height: lhs.height / rhs.height)
+    }
+    
+    public static func / (lhs: CGSize, rhs: CGFloat) -> CGSize {
+        return CGSize(width: lhs.width / rhs, height: lhs.height / rhs)
+    }
+    
+    public static func ⊗ (lhs: CGSize, rhs: CGAffineTransform) -> CGSize {
+        return lhs.applying(rhs)
+    }
+    
+    public static func += (lhs: inout CGSize, rhs: CGSize) {
+        lhs = lhs + rhs
+    }
+    
+    public static func -= (lhs: inout CGSize, rhs: CGSize) {
+        lhs = lhs - rhs
+    }
+    
+    public static func *= (lhs: inout CGSize, rhs: CGSize) {
+        lhs = lhs * rhs
+    }
+    
+    public static func *= (lhs: inout CGSize, rhs: CGFloat) {
+        lhs = lhs * rhs
+    }
+    
+    public static func /= (lhs: inout CGSize, rhs: CGSize) {
+        lhs = lhs / rhs
+    }
+    
+    public static func /= (lhs: inout CGSize, rhs: CGFloat) {
+        lhs = lhs / rhs
+    }
+    
+    public static func ⊗= (lhs: inout CGSize, rhs: CGAffineTransform) {
+        lhs = lhs ⊗ rhs
+    }
 }
 
-public func - (left: CGSize, right: CGPoint) -> CGPoint {
-    return CGPoint(x: left.width - right.x, y: left.height - right.y)
+extension CGSize {
+    public static func + (lhs: CGSize, rhs: CGPoint) -> CGPoint {
+        return CGPoint(x: lhs.width + rhs.x, y: lhs.height + rhs.y)
+    }
+    
+    public static func - (lhs: CGSize, rhs: CGPoint) -> CGPoint {
+        return CGPoint(x: lhs.width - rhs.x, y: lhs.height - rhs.y)
+    }
+    
+    public static func * (lhs: CGSize, rhs: CGPoint) -> CGPoint {
+        return CGPoint(x: lhs.width * rhs.x, y: lhs.height * rhs.y)
+    }
+    
+    public static func / (lhs: CGSize, rhs: CGPoint) -> CGPoint {
+        return CGPoint(x: lhs.width / rhs.x, y: lhs.height / rhs.y)
+    }
 }
diff --git a/Sources/CGPointVector/Operators.swift b/Sources/CGPointVector/Operators.swift
new file mode 100644
index 0000000..d237293
--- /dev/null
+++ b/Sources/CGPointVector/Operators.swift
@@ -0,0 +1,2 @@
+infix operator ⊗ : MultiplicationPrecedence
+infix operator ⊗= : AssignmentPrecedence
diff --git a/Tests/CGPointVectorTests/CGAffineTransformTests.swift b/Tests/CGPointVectorTests/CGAffineTransformTests.swift
index 849d8fc..b78e9d3 100644
--- a/Tests/CGPointVectorTests/CGAffineTransformTests.swift
+++ b/Tests/CGPointVectorTests/CGAffineTransformTests.swift
@@ -69,23 +69,14 @@ class CGAffineTransormTests: XCTestCase {
         XCTAssertEqual(CGAffineTransform(a: 1, b: 2, c: 3, d: 4, tx: 5, ty: 6).description, "(1.0, 2.0, 3.0, 4.0, 5.0, 6.0)")
     }
     
-    func testMultiply() {
+    func testMatmul() {
         XCTAssertTrue((CGAffineTransform(a: 1, b: 2, c: 3, d: 4, tx: 5, ty: 6) ⊗ CGAffineTransform(a: 6, b: 5, c: 4, d: 3, tx: 2, ty: 1))
             .nearlyEqual(to: CGAffineTransform(a: 14, b: 11, c: 34, d: 27, tx: 56, ty: 44), epsilon: torelance))
-    }
-    
-    func testMultiplyByPoint() {
-        XCTAssertTrue((CGPoint(x: 1.0, y: 1.0) ⊗ CGAffineTransform(rotationAngle: CGFloat.pi / 4))
-            .nearlyEqual(to: CGPoint(x: 0.0, y: sqrt(2)), epsilon: torelance))
         XCTAssertTrue((CGAffineTransform(translationX: 1.0, y: -2.0) ⊗ CGPoint(x: 1.0, y: 1.0))
             .nearlyEqual(to: CGPoint(x: 2.0, y: -1.0), epsilon: torelance))
     }
     
-    func testEquals() {
-        
-    }
-    
-    func testMultiplicationAssignment() {
+    func testMatmulAssignment() {
         var a = CGAffineTransform(a: 1, b: 2, c: 3, d: 4, tx: 5, ty: 6)
         a ⊗= CGAffineTransform(a: 6, b: 5, c: 4, d: 3, tx: 2, ty: 1)
         print(a)
@@ -99,10 +90,8 @@ class CGAffineTransormTests: XCTestCase {
             ("testNearlyEqual", testNearlyEqual),
             ("testInverse", testInverse),
             ("testDescription", testDescription),
-            ("testMultiply", testMultiply),
-            ("testMultiplyByPoint", testMultiplyByPoint),
-            ("testEquals", testEquals),
-            ("testMultiplicationAssignment", testMultiplicationAssignment),
+            ("testMatmul", testMatmul),
+            ("testMatmulAssignment", testMatmulAssignment),
         ]
     }
 }
diff --git a/Tests/CGPointVectorTests/CGPointTests.swift b/Tests/CGPointVectorTests/CGPointTests.swift
index 53776ee..dcea78f 100644
--- a/Tests/CGPointVectorTests/CGPointTests.swift
+++ b/Tests/CGPointVectorTests/CGPointTests.swift
@@ -66,22 +66,32 @@ class CGPointTests: XCTestCase {
     
     func testAdd() {
         XCTAssertTrue((CGPoint(x: 1.0, y: 2.0) + CGPoint(x: 3.0, y: -4.0)).nearlyEqual(to: CGPoint(x: 4.0, y: -2.0), epsilon: torelance))
+        XCTAssertTrue((CGPoint(x: 1.0, y: 2.0) + CGSize(width: 3.0, height: -4.0)).nearlyEqual(to: CGPoint(x: 4.0, y: -2.0), epsilon: torelance))
     }
     
     func testSubtract() {
         XCTAssertTrue((CGPoint(x: 3.0, y: 2.0) - CGPoint(x: 1.0, y: 4.0)).nearlyEqual(to: CGPoint(x: 2.0, y: -2.0), epsilon: torelance))
+        XCTAssertTrue((CGPoint(x: 3.0, y: 2.0) - CGSize(width: 1.0, height: 4.0)).nearlyEqual(to: CGPoint(x: 2.0, y: -2.0), epsilon: torelance))
     }
     
     func testMultiply() {
         XCTAssertTrue((CGPoint(x: 2.0, y: 3.0) * CGPoint(x: 5.0, y: 7.0)).nearlyEqual(to: CGPoint(x: 10.0, y: 21.0), epsilon: torelance))
+        XCTAssertTrue((CGPoint(x: 2.0, y: 3.0) * CGSize(width: 5.0, height: 7.0)).nearlyEqual(to: CGPoint(x: 10.0, y: 21.0), epsilon: torelance))
         XCTAssertTrue((CGPoint(x: 1.0, y: -2.0) * 3.0).nearlyEqual(to: CGPoint(x: 3.0, y: -6.0), epsilon: torelance))
         XCTAssertTrue((3.0 * CGPoint(x: 1.0, y: -2.0)).nearlyEqual(to: CGPoint(x: 3.0, y: -6.0), epsilon: torelance))
     }
     
     func testDivide() {
+        XCTAssertTrue((CGPoint(x: 8.0, y: 27.0) / CGPoint(x: 2.0, y: 3.0)).nearlyEqual(to: CGPoint(x: 4.0, y: 9.0), epsilon: torelance))
+        XCTAssertTrue((CGPoint(x: 8.0, y: 27.0) / CGSize(width: 2.0, height: 3.0)).nearlyEqual(to: CGPoint(x: 4.0, y: 9.0), epsilon: torelance))
         XCTAssertTrue((CGPoint(x: 8.0, y: -2.0) / 4.0).nearlyEqual(to: CGPoint(x: 2.0, y: -0.5), epsilon: torelance))
     }
     
+    func testMatmul() {
+        XCTAssertTrue((CGPoint(x: 1.0, y: 1.0) ⊗ CGAffineTransform(rotationAngle: CGFloat.pi / 4))
+            .nearlyEqual(to: CGPoint(x: 0.0, y: sqrt(2)), epsilon: torelance))
+    }
+    
     func testAdditionAssignment() {
         var a = CGPoint(x: 1.0, y: 2.0)
         a += CGPoint(x: 3.0, y: -4.0)
@@ -108,6 +118,12 @@ class CGPointTests: XCTestCase {
         XCTAssertTrue(a.nearlyEqual(to: CGPoint(x: 8.0, y: -2.0) / 4.0, epsilon: torelance))
     }
     
+    func testMatmulAssignment() {
+        var a = CGPoint(x: 1.0, y: 1.0)
+        a ⊗= CGAffineTransform(rotationAngle: CGFloat.pi / 4)
+        XCTAssertTrue(a.nearlyEqual(to: CGPoint(x: 0.0, y: sqrt(2)), epsilon: torelance))
+    }
+    
     static var allTests : [(String, (CGPointTests) -> () throws -> Void)] {
         return [
             ("testNearlyEqual", testNearlyEqual),
@@ -127,10 +143,12 @@ class CGPointTests: XCTestCase {
             ("testSubtract", testSubtract),
             ("testMultiply", testMultiply),
             ("testDivide", testDivide),
+            ("testMatmul", testMatmul),
             ("testAdditionAssignment", testAdditionAssignment),
             ("testSuntractionAssignment", testSuntractionAssignment),
             ("testMultiplicationAssignment", testMultiplicationAssignment),
             ("testDivisionAssignment", testDivisionAssignment),
+            ("testMatmulAssignment", testMatmulAssignment),
         ]
     }
 }
diff --git a/Tests/CGPointVectorTests/CGRectTests.swift b/Tests/CGPointVectorTests/CGRectTests.swift
index 5431b45..bce07e2 100644
--- a/Tests/CGPointVectorTests/CGRectTests.swift
+++ b/Tests/CGPointVectorTests/CGRectTests.swift
@@ -35,9 +35,9 @@ class CGRectTests: XCTestCase {
         XCTAssertEqual(CGRect(x: 1.0, y: 2.0, width: 3.0, height: 4.0).description, "((1.0, 2.0), (3.0, 4.0))")
     }
     
-    func testMultiply() {
-        print(CGRect(x: 1.0, y: 2.0, width: 3.0, height: 4.0) * CGAffineTransform(a: 0, b: 1, c: -1, d: 0, tx: 0, ty: 0))
-        XCTAssertTrue((CGRect(x: 1.0, y: 2.0, width: 3.0, height: 4.0) * CGAffineTransform(a: 0, b: 1, c: -1, d: 0, tx: 0, ty: 0))
+    func testMatmul() {
+        print(CGRect(x: 1.0, y: 2.0, width: 3.0, height: 4.0) ⊗ CGAffineTransform(a: 0, b: 1, c: -1, d: 0, tx: 0, ty: 0))
+        XCTAssertTrue((CGRect(x: 1.0, y: 2.0, width: 3.0, height: 4.0) ⊗ CGAffineTransform(a: 0, b: 1, c: -1, d: 0, tx: 0, ty: 0))
             .nearlyEqual(to: CGRect(x: -6.0, y: 1.0, width: 4.0, height: 3.0), epsilon: torelance))
     }
     
@@ -46,7 +46,7 @@ class CGRectTests: XCTestCase {
             ("testNearlyEqual", testNearlyEqual),
             ("testCenter", testCenter),
             ("testDescription", testDescription),
-            ("testMultiply", testMultiply),
+            ("testMatmul", testMatmul),
         ]
     }
 }
diff --git a/Tests/CGPointVectorTests/CGSizeTests.swift b/Tests/CGPointVectorTests/CGSizeTests.swift
index 0c2580a..2c2237a 100644
--- a/Tests/CGPointVectorTests/CGSizeTests.swift
+++ b/Tests/CGPointVectorTests/CGSizeTests.swift
@@ -16,6 +16,42 @@ class CGSizeTests: XCTestCase {
         XCTAssertFalse(CGSize(width: 1.0, height: 2.0).nearlyEqual(to: CGSize(width: 1.0, height: 3.0), epsilon: 1.0))
     }
     
+    func testLength() {
+        XCTAssertEqual(CGSize(width: 3.0, height: -4.0).length, 5.0, accuracy: torelance)
+    }
+    
+    func testSquareLength() {
+        XCTAssertEqual(CGSize(width: 3.0, height: -4.0).squareLength, 25.0, accuracy: torelance)
+    }
+    
+    func testUnit() {
+        XCTAssertTrue(CGSize(width: 3.0, height: -4.0).unit.nearlyEqual(to: CGSize(width: 0.6, height: -0.8), epsilon: torelance))
+    }
+    
+    func testPhase() {
+        XCTAssertEqual(CGSize(width: 1.0, height: sqrt(3)).phase, CGFloat.pi / 3, accuracy: torelance)
+    }
+    
+    func testDistance() {
+        XCTAssertEqual(CGSize(width: 1.0, height: 2.0).distance(from: CGSize(width: -3.0, height: 5.0)), 5.0, accuracy: torelance)
+    }
+    
+    func testSquareDistance() {
+        XCTAssertEqual(CGSize(width: 1.0, height: 2.0).squareDistance(from: CGSize(width: -3.0, height: 5.0)), 25.0, accuracy: torelance)
+    }
+    
+    func testAngle() {
+        XCTAssertEqual(CGSize(width: 1.0, height: 0.0).angle(from: CGSize(width: sqrt(3.0), height: 1.0)), CGFloat.pi / 6, accuracy: torelance)
+    }
+    
+    func testCosOfAngle() {
+        XCTAssertEqual(CGSize(width: 1.0, height: 0.0).cos(from: CGSize(width: 1.0, height: sqrt(3.0))), 0.5, accuracy: torelance)
+    }
+    
+    func testDot() {
+        XCTAssertEqual(CGSize(width: 1.0, height: 2.0).dot(CGSize(width: -3.0, height: 4.0)), 5.0, accuracy: torelance)
+    }
+    
     func testDescription() {
         XCTAssertEqual(CGSize(width: 1.0, height: 2.0).description, "(1.0, 2.0)")
     }
@@ -30,21 +66,32 @@ class CGSizeTests: XCTestCase {
     
     func testAdd() {
         XCTAssertTrue((CGSize(width: 1.0, height: 2.0) + CGSize(width: 3.0, height: -4.0)).nearlyEqual(to: CGSize(width: 4.0, height: -2.0), epsilon: torelance))
+        XCTAssertTrue((CGSize(width: 1.0, height: 2.0) + CGPoint(x: 3.0, y: -4.0)).nearlyEqual(to: CGPoint(x: 4.0, y: -2.0), epsilon: torelance))
     }
     
     func testSubtract() {
         XCTAssertTrue((CGSize(width: 3.0, height: 2.0) - CGSize(width: 1.0, height: 4.0)).nearlyEqual(to: CGSize(width: 2.0, height: -2.0), epsilon: torelance))
+        XCTAssertTrue((CGSize(width: 3.0, height: 2.0) - CGPoint(x: 1.0, y: 4.0)).nearlyEqual(to: CGPoint(x: 2.0, y: -2.0), epsilon: torelance))
     }
     
     func testMultiply() {
+        XCTAssertTrue((CGSize(width: 2.0, height: 3.0) * CGSize(width: 5.0, height: 7.0)).nearlyEqual(to: CGSize(width: 10.0, height: 21.0), epsilon: torelance))
+        XCTAssertTrue((CGSize(width: 2.0, height: 3.0) * CGPoint(x: 5.0, y: 7.0)).nearlyEqual(to: CGPoint(x: 10.0, y: 21.0), epsilon: torelance))
         XCTAssertTrue((CGSize(width: 1.0, height: -2.0) * 3.0).nearlyEqual(to: CGSize(width: 3.0, height: -6.0), epsilon: torelance))
         XCTAssertTrue((3.0 * CGSize(width: 1.0, height: -2.0)).nearlyEqual(to: CGSize(width: 3.0, height: -6.0), epsilon: torelance))
     }
     
     func testDivide() {
+        XCTAssertTrue((CGSize(width: 8.0, height: 27.0) / CGSize(width: 2.0, height: 3.0)).nearlyEqual(to: CGSize(width: 4.0, height: 9.0), epsilon: torelance))
+        XCTAssertTrue((CGSize(width: 8.0, height: 27.0) / CGPoint(x: 2.0, y: 3.0)).nearlyEqual(to: CGPoint(x: 4.0, y: 9.0), epsilon: torelance))
         XCTAssertTrue((CGSize(width: 8.0, height: -2.0) / 4.0).nearlyEqual(to: CGSize(width: 2.0, height: -0.5), epsilon: torelance))
     }
     
+    func testMatmul() {
+        XCTAssertTrue((CGSize(width: 1.0, height: 1.0) ⊗ CGAffineTransform(rotationAngle: CGFloat.pi / 4))
+            .nearlyEqual(to: CGSize(width: 0.0, height: sqrt(2)), epsilon: torelance))
+    }
+    
     func testAdditionAssignment() {
         var a = CGSize(width: 1.0, height: 2.0)
         a += CGSize(width: 3.0, height: -4.0)
@@ -71,19 +118,24 @@ class CGSizeTests: XCTestCase {
         XCTAssertTrue(a.nearlyEqual(to: CGSize(width: 8.0, height: -2.0) / 4.0, epsilon: torelance))
     }
     
-    func testAddWithPoint() {
-        XCTAssertTrue((CGSize(width: 1.0, height: 2.0) + CGPoint(x: 3.0, y: -4.0)).nearlyEqual(to: CGPoint(x: 4.0, y: -2.0), epsilon: torelance))
-        XCTAssertTrue((CGPoint(x: 1.0, y: 2.0) + CGSize(width: 3.0, height: -4.0)).nearlyEqual(to: CGPoint(x: 4.0, y: -2.0), epsilon: torelance))
-    }
-    
-    func testSubtractWithPoint() {
-        XCTAssertTrue((CGSize(width: 3.0, height: 2.0) - CGPoint(x: 1.0, y: 4.0)).nearlyEqual(to: CGPoint(x: 2.0, y: -2.0), epsilon: torelance))
-        XCTAssertTrue((CGPoint(x: 3.0, y: 2.0) - CGSize(width: 1.0, height: 4.0)).nearlyEqual(to: CGPoint(x: 2.0, y: -2.0), epsilon: torelance))
+    func testMatmulAssignment() {
+        var a = CGSize(width: 1.0, height: 1.0)
+        a ⊗= CGAffineTransform(rotationAngle: CGFloat.pi / 4)
+        XCTAssertTrue(a.nearlyEqual(to: CGSize(width: 0.0, height: sqrt(2)), epsilon: torelance))
     }
     
     static var allTests : [(String, (CGSizeTests) -> () throws -> Void)] {
         return [
             ("testNearlyEqual", testNearlyEqual),
+            ("testLength", testLength),
+            ("testSquareLength", testSquareLength),
+            ("testUnit", testUnit),
+            ("testPhase", testPhase),
+            ("testDistance", testDistance),
+            ("testSquareDistance", testSquareDistance),
+            ("testAngle", testAngle),
+            ("testCosOfAngle", testCosOfAngle),
+            ("testDot", testDot),
             ("testDescription", testDescription),
             ("testPrefixPlus", testPrefixPlus),
             ("testNegate", testNegate),
@@ -91,12 +143,12 @@ class CGSizeTests: XCTestCase {
             ("testSubtract", testSubtract),
             ("testMultiply", testMultiply),
             ("testDivide", testDivide),
+            ("testMatmul", testMatmul),
             ("testAdditionAssignment", testAdditionAssignment),
             ("testSuntractionAssignment", testSuntractionAssignment),
             ("testMultiplicationAssignment", testMultiplicationAssignment),
             ("testDivisionAssignment", testDivisionAssignment),
-            ("testAddWithPoint", testAddWithPoint),
-            ("testSubtractWithPoint", testSubtractWithPoint),
+            ("testMatmulAssignment", testMatmulAssignment),
         ]
     }
 }

From 0453c661fc4cf5bb16f233bb48e225bbeebdc453 Mon Sep 17 00:00:00 2001
From: Yuta Koshizawa <koher@koherent.org>
Date: Thu, 21 Jun 2018 12:58:05 +0900
Subject: [PATCH 07/20] Rename `nearlyEqual` to `isNearlyEqual`

---
 Sources/CGPointVector/CGAffineTransform.swift |  2 +-
 Sources/CGPointVector/CGPoint.swift           |  2 +-
 Sources/CGPointVector/CGRect.swift            |  2 +-
 Sources/CGPointVector/CGSize.swift            |  2 +-
 .../CGAffineTransformTests.swift              | 60 +++++++++----------
 Tests/CGPointVectorTests/CGPointTests.swift   | 60 +++++++++----------
 .../CGPointVectorTests.swift                  | 10 ++--
 Tests/CGPointVectorTests/CGRectTests.swift    | 40 ++++++-------
 Tests/CGPointVectorTests/CGSizeTests.swift    | 60 +++++++++----------
 9 files changed, 119 insertions(+), 119 deletions(-)

diff --git a/Sources/CGPointVector/CGAffineTransform.swift b/Sources/CGPointVector/CGAffineTransform.swift
index 35ec5b7..0ea8e3f 100644
--- a/Sources/CGPointVector/CGAffineTransform.swift
+++ b/Sources/CGPointVector/CGAffineTransform.swift
@@ -1,7 +1,7 @@
 import CoreGraphics
 
 extension CGAffineTransform {
-    public func nearlyEqual(to transform: CGAffineTransform, epsilon: CGFloat) -> Bool {
+    public func isNearlyEqual(to transform: CGAffineTransform, epsilon: CGFloat) -> Bool {
         return fabs(a - transform.a) < epsilon && fabs(b - transform.b) < epsilon && fabs(c - transform.c) < epsilon && fabs(d - transform.d) < epsilon && fabs(tx - transform.tx) < epsilon && fabs(ty - transform.ty) < epsilon
     }
     
diff --git a/Sources/CGPointVector/CGPoint.swift b/Sources/CGPointVector/CGPoint.swift
index 140bfce..28b3c04 100644
--- a/Sources/CGPointVector/CGPoint.swift
+++ b/Sources/CGPointVector/CGPoint.swift
@@ -1,7 +1,7 @@
 import CoreGraphics
 
 extension CGPoint {
-    public func nearlyEqual(to point: CGPoint, epsilon: CGFloat) -> Bool {
+    public func isNearlyEqual(to point: CGPoint, epsilon: CGFloat) -> Bool {
         let difference = self - point
         return fabs(difference.x) < epsilon && fabs(difference.y) < epsilon
     }
diff --git a/Sources/CGPointVector/CGRect.swift b/Sources/CGPointVector/CGRect.swift
index 6f7bd09..cbdcd40 100644
--- a/Sources/CGPointVector/CGRect.swift
+++ b/Sources/CGPointVector/CGRect.swift
@@ -1,7 +1,7 @@
 import CoreGraphics
 
 extension CGRect {
-    public func nearlyEqual(to rect: CGRect, epsilon: CGFloat) -> Bool {
+    public func isNearlyEqual(to rect: CGRect, epsilon: CGFloat) -> Bool {
         let difference1 = self.origin - rect.origin
         let difference2 = (self.origin + self.size) - (rect.origin + rect.size)
         return fabs(difference1.x) < epsilon && fabs(difference1.y) < epsilon
diff --git a/Sources/CGPointVector/CGSize.swift b/Sources/CGPointVector/CGSize.swift
index 19923bd..87b60f5 100644
--- a/Sources/CGPointVector/CGSize.swift
+++ b/Sources/CGPointVector/CGSize.swift
@@ -1,7 +1,7 @@
 import CoreGraphics
 
 extension CGSize {
-    public func nearlyEqual(to point: CGSize, epsilon: CGFloat) -> Bool {
+    public func isNearlyEqual(to point: CGSize, epsilon: CGFloat) -> Bool {
         let difference = self - point
         return fabs(difference.width) < epsilon && fabs(difference.height) < epsilon
     }
diff --git a/Tests/CGPointVectorTests/CGAffineTransformTests.swift b/Tests/CGPointVectorTests/CGAffineTransformTests.swift
index b78e9d3..8e19e55 100644
--- a/Tests/CGPointVectorTests/CGAffineTransformTests.swift
+++ b/Tests/CGPointVectorTests/CGAffineTransformTests.swift
@@ -4,65 +4,65 @@ import CGPointVector
 class CGAffineTransormTests: XCTestCase {
     let torelance: CGFloat = 1.0e-5;
     
-    func testNearlyEqual() {
+    func testisNearlyEqual() {
         XCTAssertFalse(CGAffineTransform(a: 1.0, b: 2.0, c: 3.0, d: 4.0, tx: 5.0, ty: 6.0)
-            .nearlyEqual(to: CGAffineTransform(a: 0.0, b: 2.0, c: 3.0, d: 4.0, tx: 5.0, ty: 6.0), epsilon: 1.0))
+            .isNearlyEqual(to: CGAffineTransform(a: 0.0, b: 2.0, c: 3.0, d: 4.0, tx: 5.0, ty: 6.0), epsilon: 1.0))
         XCTAssertTrue(CGAffineTransform(a: 1.0, b: 2.0, c: 3.0, d: 4.0, tx: 5.0, ty: 6.0)
-            .nearlyEqual(to: CGAffineTransform(a: 0.1, b: 2.0, c: 3.0, d: 4.0, tx: 5.0, ty: 6.0), epsilon: 1.0))
+            .isNearlyEqual(to: CGAffineTransform(a: 0.1, b: 2.0, c: 3.0, d: 4.0, tx: 5.0, ty: 6.0), epsilon: 1.0))
         XCTAssertTrue(CGAffineTransform(a: 1.0, b: 2.0, c: 3.0, d: 4.0, tx: 5.0, ty: 6.0)
-            .nearlyEqual(to: CGAffineTransform(a: 1.9, b: 2.0, c: 3.0, d: 4.0, tx: 5.0, ty: 6.0), epsilon: 1.0))
+            .isNearlyEqual(to: CGAffineTransform(a: 1.9, b: 2.0, c: 3.0, d: 4.0, tx: 5.0, ty: 6.0), epsilon: 1.0))
         XCTAssertFalse(CGAffineTransform(a: 1.0, b: 2.0, c: 3.0, d: 4.0, tx: 5.0, ty: 6.0)
-            .nearlyEqual(to: CGAffineTransform(a: 2.0, b: 2.0, c: 3.0, d: 4.0, tx: 5.0, ty: 6.0), epsilon: 1.0))
+            .isNearlyEqual(to: CGAffineTransform(a: 2.0, b: 2.0, c: 3.0, d: 4.0, tx: 5.0, ty: 6.0), epsilon: 1.0))
 
         XCTAssertFalse(CGAffineTransform(a: 1.0, b: 2.0, c: 3.0, d: 4.0, tx: 5.0, ty: 6.0)
-            .nearlyEqual(to: CGAffineTransform(a: 1.0, b: 1.0, c: 3.0, d: 4.0, tx: 5.0, ty: 6.0), epsilon: 1.0))
+            .isNearlyEqual(to: CGAffineTransform(a: 1.0, b: 1.0, c: 3.0, d: 4.0, tx: 5.0, ty: 6.0), epsilon: 1.0))
         XCTAssertTrue(CGAffineTransform(a: 1.0, b: 2.0, c: 3.0, d: 4.0, tx: 5.0, ty: 6.0)
-            .nearlyEqual(to: CGAffineTransform(a: 1.0, b: 1.1, c: 3.0, d: 4.0, tx: 5.0, ty: 6.0), epsilon: 1.0))
+            .isNearlyEqual(to: CGAffineTransform(a: 1.0, b: 1.1, c: 3.0, d: 4.0, tx: 5.0, ty: 6.0), epsilon: 1.0))
         XCTAssertTrue(CGAffineTransform(a: 1.0, b: 2.0, c: 3.0, d: 4.0, tx: 5.0, ty: 6.0)
-            .nearlyEqual(to: CGAffineTransform(a: 1.0, b: 2.9, c: 3.0, d: 4.0, tx: 5.0, ty: 6.0), epsilon: 1.0))
+            .isNearlyEqual(to: CGAffineTransform(a: 1.0, b: 2.9, c: 3.0, d: 4.0, tx: 5.0, ty: 6.0), epsilon: 1.0))
         XCTAssertFalse(CGAffineTransform(a: 1.0, b: 2.0, c: 3.0, d: 4.0, tx: 5.0, ty: 6.0)
-            .nearlyEqual(to: CGAffineTransform(a: 1.0, b: 3.0, c: 3.0, d: 4.0, tx: 5.0, ty: 6.0), epsilon: 1.0))
+            .isNearlyEqual(to: CGAffineTransform(a: 1.0, b: 3.0, c: 3.0, d: 4.0, tx: 5.0, ty: 6.0), epsilon: 1.0))
         
         XCTAssertFalse(CGAffineTransform(a: 1.0, b: 2.0, c: 3.0, d: 4.0, tx: 5.0, ty: 6.0)
-            .nearlyEqual(to: CGAffineTransform(a: 1.0, b: 2.0, c: 2.0, d: 4.0, tx: 5.0, ty: 6.0), epsilon: 1.0))
+            .isNearlyEqual(to: CGAffineTransform(a: 1.0, b: 2.0, c: 2.0, d: 4.0, tx: 5.0, ty: 6.0), epsilon: 1.0))
         XCTAssertTrue(CGAffineTransform(a: 1.0, b: 2.0, c: 3.0, d: 4.0, tx: 5.0, ty: 6.0)
-            .nearlyEqual(to: CGAffineTransform(a: 1.0, b: 2.0, c: 2.1, d: 4.0, tx: 5.0, ty: 6.0), epsilon: 1.0))
+            .isNearlyEqual(to: CGAffineTransform(a: 1.0, b: 2.0, c: 2.1, d: 4.0, tx: 5.0, ty: 6.0), epsilon: 1.0))
         XCTAssertTrue(CGAffineTransform(a: 1.0, b: 2.0, c: 3.0, d: 4.0, tx: 5.0, ty: 6.0)
-            .nearlyEqual(to: CGAffineTransform(a: 1.0, b: 2.0, c: 3.9, d: 4.0, tx: 5.0, ty: 6.0), epsilon: 1.0))
+            .isNearlyEqual(to: CGAffineTransform(a: 1.0, b: 2.0, c: 3.9, d: 4.0, tx: 5.0, ty: 6.0), epsilon: 1.0))
         XCTAssertFalse(CGAffineTransform(a: 1.0, b: 2.0, c: 3.0, d: 4.0, tx: 5.0, ty: 6.0)
-            .nearlyEqual(to: CGAffineTransform(a: 1.0, b: 2.0, c: 4.0, d: 4.0, tx: 5.0, ty: 6.0), epsilon: 1.0))
+            .isNearlyEqual(to: CGAffineTransform(a: 1.0, b: 2.0, c: 4.0, d: 4.0, tx: 5.0, ty: 6.0), epsilon: 1.0))
         
         XCTAssertFalse(CGAffineTransform(a: 1.0, b: 2.0, c: 3.0, d: 4.0, tx: 5.0, ty: 6.0)
-            .nearlyEqual(to: CGAffineTransform(a: 1.0, b: 2.0, c: 3.0, d: 3.0, tx: 5.0, ty: 6.0), epsilon: 1.0))
+            .isNearlyEqual(to: CGAffineTransform(a: 1.0, b: 2.0, c: 3.0, d: 3.0, tx: 5.0, ty: 6.0), epsilon: 1.0))
         XCTAssertTrue(CGAffineTransform(a: 1.0, b: 2.0, c: 3.0, d: 4.0, tx: 5.0, ty: 6.0)
-            .nearlyEqual(to: CGAffineTransform(a: 1.0, b: 2.0, c: 3.0, d: 3.1, tx: 5.0, ty: 6.0), epsilon: 1.0))
+            .isNearlyEqual(to: CGAffineTransform(a: 1.0, b: 2.0, c: 3.0, d: 3.1, tx: 5.0, ty: 6.0), epsilon: 1.0))
         XCTAssertTrue(CGAffineTransform(a: 1.0, b: 2.0, c: 3.0, d: 4.0, tx: 5.0, ty: 6.0)
-            .nearlyEqual(to: CGAffineTransform(a: 1.0, b: 2.0, c: 3.0, d: 4.9, tx: 5.0, ty: 6.0), epsilon: 1.0))
+            .isNearlyEqual(to: CGAffineTransform(a: 1.0, b: 2.0, c: 3.0, d: 4.9, tx: 5.0, ty: 6.0), epsilon: 1.0))
         XCTAssertFalse(CGAffineTransform(a: 1.0, b: 2.0, c: 3.0, d: 4.0, tx: 5.0, ty: 6.0)
-            .nearlyEqual(to: CGAffineTransform(a: 1.0, b: 2.0, c: 3.0, d: 5.0, tx: 5.0, ty: 6.0), epsilon: 1.0))
+            .isNearlyEqual(to: CGAffineTransform(a: 1.0, b: 2.0, c: 3.0, d: 5.0, tx: 5.0, ty: 6.0), epsilon: 1.0))
         
         XCTAssertFalse(CGAffineTransform(a: 1.0, b: 2.0, c: 3.0, d: 4.0, tx: 5.0, ty: 6.0)
-            .nearlyEqual(to: CGAffineTransform(a: 1.0, b: 2.0, c: 3.0, d: 4.0, tx: 4.0, ty: 6.0), epsilon: 1.0))
+            .isNearlyEqual(to: CGAffineTransform(a: 1.0, b: 2.0, c: 3.0, d: 4.0, tx: 4.0, ty: 6.0), epsilon: 1.0))
         XCTAssertTrue(CGAffineTransform(a: 1.0, b: 2.0, c: 3.0, d: 4.0, tx: 5.0, ty: 6.0)
-            .nearlyEqual(to: CGAffineTransform(a: 1.0, b: 2.0, c: 3.0, d: 4.0, tx: 4.1, ty: 6.0), epsilon: 1.0))
+            .isNearlyEqual(to: CGAffineTransform(a: 1.0, b: 2.0, c: 3.0, d: 4.0, tx: 4.1, ty: 6.0), epsilon: 1.0))
         XCTAssertTrue(CGAffineTransform(a: 1.0, b: 2.0, c: 3.0, d: 4.0, tx: 5.0, ty: 6.0)
-            .nearlyEqual(to: CGAffineTransform(a: 1.0, b: 2.0, c: 3.0, d: 4.0, tx: 5.9, ty: 6.0), epsilon: 1.0))
+            .isNearlyEqual(to: CGAffineTransform(a: 1.0, b: 2.0, c: 3.0, d: 4.0, tx: 5.9, ty: 6.0), epsilon: 1.0))
         XCTAssertFalse(CGAffineTransform(a: 1.0, b: 2.0, c: 3.0, d: 4.0, tx: 5.0, ty: 6.0)
-            .nearlyEqual(to: CGAffineTransform(a: 1.0, b: 2.0, c: 3.0, d: 4.0, tx: 6.0, ty: 6.0), epsilon: 1.0))
+            .isNearlyEqual(to: CGAffineTransform(a: 1.0, b: 2.0, c: 3.0, d: 4.0, tx: 6.0, ty: 6.0), epsilon: 1.0))
         
         XCTAssertFalse(CGAffineTransform(a: 1.0, b: 2.0, c: 3.0, d: 4.0, tx: 5.0, ty: 6.0)
-            .nearlyEqual(to: CGAffineTransform(a: 1.0, b: 2.0, c: 3.0, d: 4.0, tx: 5.0, ty: 5.0), epsilon: 1.0))
+            .isNearlyEqual(to: CGAffineTransform(a: 1.0, b: 2.0, c: 3.0, d: 4.0, tx: 5.0, ty: 5.0), epsilon: 1.0))
         XCTAssertTrue(CGAffineTransform(a: 1.0, b: 2.0, c: 3.0, d: 4.0, tx: 5.0, ty: 6.0)
-            .nearlyEqual(to: CGAffineTransform(a: 1.0, b: 2.0, c: 3.0, d: 4.0, tx: 5.0, ty: 5.1), epsilon: 1.0))
+            .isNearlyEqual(to: CGAffineTransform(a: 1.0, b: 2.0, c: 3.0, d: 4.0, tx: 5.0, ty: 5.1), epsilon: 1.0))
         XCTAssertTrue(CGAffineTransform(a: 1.0, b: 2.0, c: 3.0, d: 4.0, tx: 5.0, ty: 6.0)
-            .nearlyEqual(to: CGAffineTransform(a: 1.0, b: 2.0, c: 3.0, d: 4.0, tx: 5.0, ty: 6.9), epsilon: 1.0))
+            .isNearlyEqual(to: CGAffineTransform(a: 1.0, b: 2.0, c: 3.0, d: 4.0, tx: 5.0, ty: 6.9), epsilon: 1.0))
         XCTAssertFalse(CGAffineTransform(a: 1.0, b: 2.0, c: 3.0, d: 4.0, tx: 5.0, ty: 6.0)
-            .nearlyEqual(to: CGAffineTransform(a: 1.0, b: 2.0, c: 3.0, d: 4.0, tx: 5.0, ty: 7.0), epsilon: 1.0))
+            .isNearlyEqual(to: CGAffineTransform(a: 1.0, b: 2.0, c: 3.0, d: 4.0, tx: 5.0, ty: 7.0), epsilon: 1.0))
     }
 
     func testInverse() {
         XCTAssertTrue(CGAffineTransform(a: 1, b: 2, c: 3, d: 4, tx: 5, ty: 6).inverse
-            .nearlyEqual(to: CGAffineTransform(a: 1, b: 2, c: 3, d: 4, tx: 5, ty: 6).inverted(), epsilon: torelance))
+            .isNearlyEqual(to: CGAffineTransform(a: 1, b: 2, c: 3, d: 4, tx: 5, ty: 6).inverted(), epsilon: torelance))
     }
     
     func testDescription() {
@@ -71,9 +71,9 @@ class CGAffineTransormTests: XCTestCase {
     
     func testMatmul() {
         XCTAssertTrue((CGAffineTransform(a: 1, b: 2, c: 3, d: 4, tx: 5, ty: 6) ⊗ CGAffineTransform(a: 6, b: 5, c: 4, d: 3, tx: 2, ty: 1))
-            .nearlyEqual(to: CGAffineTransform(a: 14, b: 11, c: 34, d: 27, tx: 56, ty: 44), epsilon: torelance))
+            .isNearlyEqual(to: CGAffineTransform(a: 14, b: 11, c: 34, d: 27, tx: 56, ty: 44), epsilon: torelance))
         XCTAssertTrue((CGAffineTransform(translationX: 1.0, y: -2.0) ⊗ CGPoint(x: 1.0, y: 1.0))
-            .nearlyEqual(to: CGPoint(x: 2.0, y: -1.0), epsilon: torelance))
+            .isNearlyEqual(to: CGPoint(x: 2.0, y: -1.0), epsilon: torelance))
     }
     
     func testMatmulAssignment() {
@@ -81,13 +81,13 @@ class CGAffineTransormTests: XCTestCase {
         a ⊗= CGAffineTransform(a: 6, b: 5, c: 4, d: 3, tx: 2, ty: 1)
         print(a)
         
-        XCTAssertTrue(a.nearlyEqual(to: CGAffineTransform(a: 1, b: 2, c: 3, d: 4, tx: 5, ty: 6)
+        XCTAssertTrue(a.isNearlyEqual(to: CGAffineTransform(a: 1, b: 2, c: 3, d: 4, tx: 5, ty: 6)
             ⊗ CGAffineTransform(a: 6, b: 5, c: 4, d: 3, tx: 2, ty: 1), epsilon: torelance))
     }
     
     static var allTests : [(String, (CGAffineTransormTests) -> () throws -> Void)] {
         return [
-            ("testNearlyEqual", testNearlyEqual),
+            ("testisNearlyEqual", testisNearlyEqual),
             ("testInverse", testInverse),
             ("testDescription", testDescription),
             ("testMatmul", testMatmul),
diff --git a/Tests/CGPointVectorTests/CGPointTests.swift b/Tests/CGPointVectorTests/CGPointTests.swift
index dcea78f..d8be162 100644
--- a/Tests/CGPointVectorTests/CGPointTests.swift
+++ b/Tests/CGPointVectorTests/CGPointTests.swift
@@ -4,16 +4,16 @@ import CGPointVector
 class CGPointTests: XCTestCase {
     let torelance: CGFloat = 1.0e-5;
     
-    func testNearlyEqual() {
-        XCTAssertFalse(CGPoint(x: 1.0, y: 2.0).nearlyEqual(to: CGPoint(x: 0.5, y: 2.0), epsilon: 0.5))
-        XCTAssertTrue(CGPoint(x: 1.0, y: 2.0).nearlyEqual(to: CGPoint(x: 0.51, y: 2.0), epsilon: 0.5))
-        XCTAssertTrue(CGPoint(x: 1.0, y: 2.0).nearlyEqual(to: CGPoint(x: 1.49, y: 2.0), epsilon: 0.5))
-        XCTAssertFalse(CGPoint(x: 1.0, y: 2.0).nearlyEqual(to: CGPoint(x: 0.4, y: 2.0), epsilon: 0.5))
+    func testisNearlyEqual() {
+        XCTAssertFalse(CGPoint(x: 1.0, y: 2.0).isNearlyEqual(to: CGPoint(x: 0.5, y: 2.0), epsilon: 0.5))
+        XCTAssertTrue(CGPoint(x: 1.0, y: 2.0).isNearlyEqual(to: CGPoint(x: 0.51, y: 2.0), epsilon: 0.5))
+        XCTAssertTrue(CGPoint(x: 1.0, y: 2.0).isNearlyEqual(to: CGPoint(x: 1.49, y: 2.0), epsilon: 0.5))
+        XCTAssertFalse(CGPoint(x: 1.0, y: 2.0).isNearlyEqual(to: CGPoint(x: 0.4, y: 2.0), epsilon: 0.5))
         
-        XCTAssertFalse(CGPoint(x: 1.0, y: 2.0).nearlyEqual(to: CGPoint(x: 1.0, y: 1.0), epsilon: 1.0))
-        XCTAssertTrue(CGPoint(x: 1.0, y: 2.0).nearlyEqual(to: CGPoint(x: 1.0, y: 1.1), epsilon: 1.0))
-        XCTAssertTrue(CGPoint(x: 1.0, y: 2.0).nearlyEqual(to: CGPoint(x: 1.0, y: 2.9), epsilon: 1.0))
-        XCTAssertFalse(CGPoint(x: 1.0, y: 2.0).nearlyEqual(to: CGPoint(x: 1.0, y: 3.0), epsilon: 1.0))
+        XCTAssertFalse(CGPoint(x: 1.0, y: 2.0).isNearlyEqual(to: CGPoint(x: 1.0, y: 1.0), epsilon: 1.0))
+        XCTAssertTrue(CGPoint(x: 1.0, y: 2.0).isNearlyEqual(to: CGPoint(x: 1.0, y: 1.1), epsilon: 1.0))
+        XCTAssertTrue(CGPoint(x: 1.0, y: 2.0).isNearlyEqual(to: CGPoint(x: 1.0, y: 2.9), epsilon: 1.0))
+        XCTAssertFalse(CGPoint(x: 1.0, y: 2.0).isNearlyEqual(to: CGPoint(x: 1.0, y: 3.0), epsilon: 1.0))
     }
     
     func testLength() {
@@ -25,7 +25,7 @@ class CGPointTests: XCTestCase {
     }
     
     func testUnit() {
-        XCTAssertTrue(CGPoint(x: 3.0, y: -4.0).unit.nearlyEqual(to: CGPoint(x: 0.6, y: -0.8), epsilon: torelance))
+        XCTAssertTrue(CGPoint(x: 3.0, y: -4.0).unit.isNearlyEqual(to: CGPoint(x: 0.6, y: -0.8), epsilon: torelance))
     }
     
     func testPhase() {
@@ -57,76 +57,76 @@ class CGPointTests: XCTestCase {
     }
     
     func testPrefixPlus() {
-        XCTAssertTrue((+CGPoint(x: 1.0, y: -2.0)).nearlyEqual(to: CGPoint(x: 1.0, y: -2.0), epsilon: torelance))
+        XCTAssertTrue((+CGPoint(x: 1.0, y: -2.0)).isNearlyEqual(to: CGPoint(x: 1.0, y: -2.0), epsilon: torelance))
     }
     
     func testNegate() {
-        XCTAssertTrue((-CGPoint(x: 1.0, y: -2.0)).nearlyEqual(to: CGPoint(x: -1.0, y: 2.0), epsilon: torelance))
+        XCTAssertTrue((-CGPoint(x: 1.0, y: -2.0)).isNearlyEqual(to: CGPoint(x: -1.0, y: 2.0), epsilon: torelance))
     }
     
     func testAdd() {
-        XCTAssertTrue((CGPoint(x: 1.0, y: 2.0) + CGPoint(x: 3.0, y: -4.0)).nearlyEqual(to: CGPoint(x: 4.0, y: -2.0), epsilon: torelance))
-        XCTAssertTrue((CGPoint(x: 1.0, y: 2.0) + CGSize(width: 3.0, height: -4.0)).nearlyEqual(to: CGPoint(x: 4.0, y: -2.0), epsilon: torelance))
+        XCTAssertTrue((CGPoint(x: 1.0, y: 2.0) + CGPoint(x: 3.0, y: -4.0)).isNearlyEqual(to: CGPoint(x: 4.0, y: -2.0), epsilon: torelance))
+        XCTAssertTrue((CGPoint(x: 1.0, y: 2.0) + CGSize(width: 3.0, height: -4.0)).isNearlyEqual(to: CGPoint(x: 4.0, y: -2.0), epsilon: torelance))
     }
     
     func testSubtract() {
-        XCTAssertTrue((CGPoint(x: 3.0, y: 2.0) - CGPoint(x: 1.0, y: 4.0)).nearlyEqual(to: CGPoint(x: 2.0, y: -2.0), epsilon: torelance))
-        XCTAssertTrue((CGPoint(x: 3.0, y: 2.0) - CGSize(width: 1.0, height: 4.0)).nearlyEqual(to: CGPoint(x: 2.0, y: -2.0), epsilon: torelance))
+        XCTAssertTrue((CGPoint(x: 3.0, y: 2.0) - CGPoint(x: 1.0, y: 4.0)).isNearlyEqual(to: CGPoint(x: 2.0, y: -2.0), epsilon: torelance))
+        XCTAssertTrue((CGPoint(x: 3.0, y: 2.0) - CGSize(width: 1.0, height: 4.0)).isNearlyEqual(to: CGPoint(x: 2.0, y: -2.0), epsilon: torelance))
     }
     
     func testMultiply() {
-        XCTAssertTrue((CGPoint(x: 2.0, y: 3.0) * CGPoint(x: 5.0, y: 7.0)).nearlyEqual(to: CGPoint(x: 10.0, y: 21.0), epsilon: torelance))
-        XCTAssertTrue((CGPoint(x: 2.0, y: 3.0) * CGSize(width: 5.0, height: 7.0)).nearlyEqual(to: CGPoint(x: 10.0, y: 21.0), epsilon: torelance))
-        XCTAssertTrue((CGPoint(x: 1.0, y: -2.0) * 3.0).nearlyEqual(to: CGPoint(x: 3.0, y: -6.0), epsilon: torelance))
-        XCTAssertTrue((3.0 * CGPoint(x: 1.0, y: -2.0)).nearlyEqual(to: CGPoint(x: 3.0, y: -6.0), epsilon: torelance))
+        XCTAssertTrue((CGPoint(x: 2.0, y: 3.0) * CGPoint(x: 5.0, y: 7.0)).isNearlyEqual(to: CGPoint(x: 10.0, y: 21.0), epsilon: torelance))
+        XCTAssertTrue((CGPoint(x: 2.0, y: 3.0) * CGSize(width: 5.0, height: 7.0)).isNearlyEqual(to: CGPoint(x: 10.0, y: 21.0), epsilon: torelance))
+        XCTAssertTrue((CGPoint(x: 1.0, y: -2.0) * 3.0).isNearlyEqual(to: CGPoint(x: 3.0, y: -6.0), epsilon: torelance))
+        XCTAssertTrue((3.0 * CGPoint(x: 1.0, y: -2.0)).isNearlyEqual(to: CGPoint(x: 3.0, y: -6.0), epsilon: torelance))
     }
     
     func testDivide() {
-        XCTAssertTrue((CGPoint(x: 8.0, y: 27.0) / CGPoint(x: 2.0, y: 3.0)).nearlyEqual(to: CGPoint(x: 4.0, y: 9.0), epsilon: torelance))
-        XCTAssertTrue((CGPoint(x: 8.0, y: 27.0) / CGSize(width: 2.0, height: 3.0)).nearlyEqual(to: CGPoint(x: 4.0, y: 9.0), epsilon: torelance))
-        XCTAssertTrue((CGPoint(x: 8.0, y: -2.0) / 4.0).nearlyEqual(to: CGPoint(x: 2.0, y: -0.5), epsilon: torelance))
+        XCTAssertTrue((CGPoint(x: 8.0, y: 27.0) / CGPoint(x: 2.0, y: 3.0)).isNearlyEqual(to: CGPoint(x: 4.0, y: 9.0), epsilon: torelance))
+        XCTAssertTrue((CGPoint(x: 8.0, y: 27.0) / CGSize(width: 2.0, height: 3.0)).isNearlyEqual(to: CGPoint(x: 4.0, y: 9.0), epsilon: torelance))
+        XCTAssertTrue((CGPoint(x: 8.0, y: -2.0) / 4.0).isNearlyEqual(to: CGPoint(x: 2.0, y: -0.5), epsilon: torelance))
     }
     
     func testMatmul() {
         XCTAssertTrue((CGPoint(x: 1.0, y: 1.0) ⊗ CGAffineTransform(rotationAngle: CGFloat.pi / 4))
-            .nearlyEqual(to: CGPoint(x: 0.0, y: sqrt(2)), epsilon: torelance))
+            .isNearlyEqual(to: CGPoint(x: 0.0, y: sqrt(2)), epsilon: torelance))
     }
     
     func testAdditionAssignment() {
         var a = CGPoint(x: 1.0, y: 2.0)
         a += CGPoint(x: 3.0, y: -4.0)
-        XCTAssertTrue(a.nearlyEqual(to: CGPoint(x: 1.0, y: 2.0)
+        XCTAssertTrue(a.isNearlyEqual(to: CGPoint(x: 1.0, y: 2.0)
             + CGPoint(x: 3.0, y: -4.0), epsilon: torelance))
     }
     
     func testSuntractionAssignment() {
         var a = CGPoint(x: 3.0, y: 2.0)
         a -= CGPoint(x: 1.0, y: 4.0)
-        XCTAssertTrue(a.nearlyEqual(to: CGPoint(x: 3.0, y: 2.0)
+        XCTAssertTrue(a.isNearlyEqual(to: CGPoint(x: 3.0, y: 2.0)
             - CGPoint(x: 1.0, y: 4.0), epsilon: torelance))
     }
     
     func testMultiplicationAssignment() {
         var a = CGPoint(x: 1.0, y: -2.0)
         a *= 3.0
-        XCTAssertTrue(a.nearlyEqual(to: CGPoint(x: 1.0, y: -2.0) * 3, epsilon: torelance))
+        XCTAssertTrue(a.isNearlyEqual(to: CGPoint(x: 1.0, y: -2.0) * 3, epsilon: torelance))
     }
     
     func testDivisionAssignment() {
         var a = CGPoint(x: 8.0, y: -2.0)
         a /= 4.0
-        XCTAssertTrue(a.nearlyEqual(to: CGPoint(x: 8.0, y: -2.0) / 4.0, epsilon: torelance))
+        XCTAssertTrue(a.isNearlyEqual(to: CGPoint(x: 8.0, y: -2.0) / 4.0, epsilon: torelance))
     }
     
     func testMatmulAssignment() {
         var a = CGPoint(x: 1.0, y: 1.0)
         a ⊗= CGAffineTransform(rotationAngle: CGFloat.pi / 4)
-        XCTAssertTrue(a.nearlyEqual(to: CGPoint(x: 0.0, y: sqrt(2)), epsilon: torelance))
+        XCTAssertTrue(a.isNearlyEqual(to: CGPoint(x: 0.0, y: sqrt(2)), epsilon: torelance))
     }
     
     static var allTests : [(String, (CGPointTests) -> () throws -> Void)] {
         return [
-            ("testNearlyEqual", testNearlyEqual),
+            ("testisNearlyEqual", testisNearlyEqual),
             ("testLength", testLength),
             ("testSquareLength", testSquareLength),
             ("testUnit", testUnit),
diff --git a/Tests/CGPointVectorTests/CGPointVectorTests.swift b/Tests/CGPointVectorTests/CGPointVectorTests.swift
index 2e07e60..be9e05c 100644
--- a/Tests/CGPointVectorTests/CGPointVectorTests.swift
+++ b/Tests/CGPointVectorTests/CGPointVectorTests.swift
@@ -12,10 +12,10 @@ class CGPointVectorTests: XCTestCase {
         let direction = (b - a).unit // (-0.8, 0.6)
         let rotated = a ⊗ CGAffineTransform(rotationAngle: CGFloat.pi / 2) // (-2.0, 1.0)
 
-        /**/ XCTAssertTrue(sum.nearlyEqual(to: CGPoint(x: -2.0, y: 7.0), epsilon: torelance))
+        /**/ XCTAssertTrue(sum.isNearlyEqual(to: CGPoint(x: -2.0, y: 7.0), epsilon: torelance))
         /**/ XCTAssertEqual(distance, 5.0, accuracy: torelance)
-        /**/ XCTAssertTrue(direction.nearlyEqual(to: CGPoint(x: -0.8, y: 0.6), epsilon: torelance))
-        /**/ XCTAssertTrue(rotated.nearlyEqual(to: CGPoint(x: -2.0, y: 1.0), epsilon: torelance))
+        /**/ XCTAssertTrue(direction.isNearlyEqual(to: CGPoint(x: -0.8, y: 0.6), epsilon: torelance))
+        /**/ XCTAssertTrue(rotated.isNearlyEqual(to: CGPoint(x: -2.0, y: 1.0), epsilon: torelance))
     }
     
     func testUsage() {
@@ -28,10 +28,10 @@ class CGPointVectorTests: XCTestCase {
         let unitVector = a.unit // (0.6, -0.8)
         let dotProduct = a.dot(b) // 26.0
 
-        /**/ XCTAssertTrue(sum.nearlyEqual(to: CGPoint(x: 5.0, y: -9.0), epsilon: torelance))
+        /**/ XCTAssertTrue(sum.isNearlyEqual(to: CGPoint(x: 5.0, y: -9.0), epsilon: torelance))
         /**/ XCTAssertEqual(length, 5.0, accuracy: torelance)
         /**/ XCTAssertEqual(distance, 1.4142135623731, accuracy: torelance)
-        /**/ XCTAssertTrue(unitVector.nearlyEqual(to: CGPoint(x: 0.6, y: -0.8), epsilon: torelance))
+        /**/ XCTAssertTrue(unitVector.isNearlyEqual(to: CGPoint(x: 0.6, y: -0.8), epsilon: torelance))
         /**/ XCTAssertEqual(dotProduct, 26.0, accuracy: torelance)
     }
     
diff --git a/Tests/CGPointVectorTests/CGRectTests.swift b/Tests/CGPointVectorTests/CGRectTests.swift
index bce07e2..f2c75d0 100644
--- a/Tests/CGPointVectorTests/CGRectTests.swift
+++ b/Tests/CGPointVectorTests/CGRectTests.swift
@@ -4,31 +4,31 @@ import CGPointVector
 class CGRectTests: XCTestCase {
     let torelance: CGFloat = 1.0e-5;
     
-    func testNearlyEqual() {
-        XCTAssertFalse(CGRect(x: 1.0, y: 2.0, width: 3.0, height: 4.0).nearlyEqual(to: CGRect(x: 0.0, y: 2.0, width: 3.0, height: 4.0), epsilon: 1.0))
-        XCTAssertTrue(CGRect(x: 1.0, y: 2.0, width: 3.0, height: 4.0).nearlyEqual(to: CGRect(x: 0.1, y: 2.0, width: 3.0, height: 4.0), epsilon: 1.0))
-        XCTAssertTrue(CGRect(x: 1.0, y: 2.0, width: 3.0, height: 4.0).nearlyEqual(to: CGRect(x: 1.9, y: 2.0, width: 3.0, height: 4.0), epsilon: 1.0))
-        XCTAssertFalse(CGRect(x: 1.0, y: 2.0, width: 3.0, height: 4.0).nearlyEqual(to: CGRect(x: 2.0, y: 2.0, width: 3.0, height: 4.0), epsilon: 1.0))
+    func testisNearlyEqual() {
+        XCTAssertFalse(CGRect(x: 1.0, y: 2.0, width: 3.0, height: 4.0).isNearlyEqual(to: CGRect(x: 0.0, y: 2.0, width: 3.0, height: 4.0), epsilon: 1.0))
+        XCTAssertTrue(CGRect(x: 1.0, y: 2.0, width: 3.0, height: 4.0).isNearlyEqual(to: CGRect(x: 0.1, y: 2.0, width: 3.0, height: 4.0), epsilon: 1.0))
+        XCTAssertTrue(CGRect(x: 1.0, y: 2.0, width: 3.0, height: 4.0).isNearlyEqual(to: CGRect(x: 1.9, y: 2.0, width: 3.0, height: 4.0), epsilon: 1.0))
+        XCTAssertFalse(CGRect(x: 1.0, y: 2.0, width: 3.0, height: 4.0).isNearlyEqual(to: CGRect(x: 2.0, y: 2.0, width: 3.0, height: 4.0), epsilon: 1.0))
         
-        XCTAssertFalse(CGRect(x: 1.0, y: 2.0, width: 3.0, height: 4.0).nearlyEqual(to: CGRect(x: 1.0, y: 1.0, width: 3.0, height: 4.0), epsilon: 1.0))
-        XCTAssertTrue(CGRect(x: 1.0, y: 2.0, width: 3.0, height: 4.0).nearlyEqual(to: CGRect(x: 1.0, y: 1.1, width: 3.0, height: 4.0), epsilon: 1.0))
-        XCTAssertTrue(CGRect(x: 1.0, y: 2.0, width: 3.0, height: 4.0).nearlyEqual(to: CGRect(x: 1.0, y: 2.9, width: 3.0, height: 4.0), epsilon: 1.0))
-        XCTAssertFalse(CGRect(x: 1.0, y: 2.0, width: 3.0, height: 4.0).nearlyEqual(to: CGRect(x: 1.0, y: 3.0, width: 3.0, height: 4.0), epsilon: 1.0))
+        XCTAssertFalse(CGRect(x: 1.0, y: 2.0, width: 3.0, height: 4.0).isNearlyEqual(to: CGRect(x: 1.0, y: 1.0, width: 3.0, height: 4.0), epsilon: 1.0))
+        XCTAssertTrue(CGRect(x: 1.0, y: 2.0, width: 3.0, height: 4.0).isNearlyEqual(to: CGRect(x: 1.0, y: 1.1, width: 3.0, height: 4.0), epsilon: 1.0))
+        XCTAssertTrue(CGRect(x: 1.0, y: 2.0, width: 3.0, height: 4.0).isNearlyEqual(to: CGRect(x: 1.0, y: 2.9, width: 3.0, height: 4.0), epsilon: 1.0))
+        XCTAssertFalse(CGRect(x: 1.0, y: 2.0, width: 3.0, height: 4.0).isNearlyEqual(to: CGRect(x: 1.0, y: 3.0, width: 3.0, height: 4.0), epsilon: 1.0))
         
-        XCTAssertFalse(CGRect(x: 1.0, y: 2.0, width: 3.0, height: 4.0).nearlyEqual(to: CGRect(x: 1.0, y: 2.0, width: 2.0, height: 4.0), epsilon: 1.0))
-        XCTAssertTrue(CGRect(x: 1.0, y: 2.0, width: 3.0, height: 4.0).nearlyEqual(to: CGRect(x: 1.0, y: 2.0, width: 2.1, height: 4.0), epsilon: 1.0))
-        XCTAssertTrue(CGRect(x: 1.0, y: 2.0, width: 3.0, height: 4.0).nearlyEqual(to: CGRect(x: 1.0, y: 2.0, width: 3.9, height: 4.0), epsilon: 1.0))
-        XCTAssertFalse(CGRect(x: 1.0, y: 2.0, width: 3.0, height: 4.0).nearlyEqual(to: CGRect(x: 1.0, y: 2.0, width: 4.0, height: 4.0), epsilon: 1.0))
+        XCTAssertFalse(CGRect(x: 1.0, y: 2.0, width: 3.0, height: 4.0).isNearlyEqual(to: CGRect(x: 1.0, y: 2.0, width: 2.0, height: 4.0), epsilon: 1.0))
+        XCTAssertTrue(CGRect(x: 1.0, y: 2.0, width: 3.0, height: 4.0).isNearlyEqual(to: CGRect(x: 1.0, y: 2.0, width: 2.1, height: 4.0), epsilon: 1.0))
+        XCTAssertTrue(CGRect(x: 1.0, y: 2.0, width: 3.0, height: 4.0).isNearlyEqual(to: CGRect(x: 1.0, y: 2.0, width: 3.9, height: 4.0), epsilon: 1.0))
+        XCTAssertFalse(CGRect(x: 1.0, y: 2.0, width: 3.0, height: 4.0).isNearlyEqual(to: CGRect(x: 1.0, y: 2.0, width: 4.0, height: 4.0), epsilon: 1.0))
         
-        XCTAssertFalse(CGRect(x: 1.0, y: 2.0, width: 3.0, height: 4.0).nearlyEqual(to: CGRect(x: 1.0, y: 2.0, width: 3.0, height: 3.0), epsilon: 1.0))
-        XCTAssertTrue(CGRect(x: 1.0, y: 2.0, width: 3.0, height: 4.0).nearlyEqual(to: CGRect(x: 1.0, y: 2.0, width: 3.0, height: 3.1), epsilon: 1.0))
-        XCTAssertTrue(CGRect(x: 1.0, y: 2.0, width: 3.0, height: 4.0).nearlyEqual(to: CGRect(x: 1.0, y: 2.0, width: 3.0, height: 4.9), epsilon: 1.0))
-        XCTAssertFalse(CGRect(x: 1.0, y: 2.0, width: 3.0, height: 4.0).nearlyEqual(to: CGRect(x: 1.0, y: 2.0, width: 3.0, height: 5.0), epsilon: 1.0))
+        XCTAssertFalse(CGRect(x: 1.0, y: 2.0, width: 3.0, height: 4.0).isNearlyEqual(to: CGRect(x: 1.0, y: 2.0, width: 3.0, height: 3.0), epsilon: 1.0))
+        XCTAssertTrue(CGRect(x: 1.0, y: 2.0, width: 3.0, height: 4.0).isNearlyEqual(to: CGRect(x: 1.0, y: 2.0, width: 3.0, height: 3.1), epsilon: 1.0))
+        XCTAssertTrue(CGRect(x: 1.0, y: 2.0, width: 3.0, height: 4.0).isNearlyEqual(to: CGRect(x: 1.0, y: 2.0, width: 3.0, height: 4.9), epsilon: 1.0))
+        XCTAssertFalse(CGRect(x: 1.0, y: 2.0, width: 3.0, height: 4.0).isNearlyEqual(to: CGRect(x: 1.0, y: 2.0, width: 3.0, height: 5.0), epsilon: 1.0))
     }
     
     func testCenter() {
         XCTAssertTrue(CGRect(x: 1.0, y: 2.0, width: 3.0, height: 4.0).center
-            .nearlyEqual(to: CGPoint(x: 2.5, y: 4.0), epsilon: torelance))
+            .isNearlyEqual(to: CGPoint(x: 2.5, y: 4.0), epsilon: torelance))
     }
     
     func testDescription() {
@@ -38,12 +38,12 @@ class CGRectTests: XCTestCase {
     func testMatmul() {
         print(CGRect(x: 1.0, y: 2.0, width: 3.0, height: 4.0) ⊗ CGAffineTransform(a: 0, b: 1, c: -1, d: 0, tx: 0, ty: 0))
         XCTAssertTrue((CGRect(x: 1.0, y: 2.0, width: 3.0, height: 4.0) ⊗ CGAffineTransform(a: 0, b: 1, c: -1, d: 0, tx: 0, ty: 0))
-            .nearlyEqual(to: CGRect(x: -6.0, y: 1.0, width: 4.0, height: 3.0), epsilon: torelance))
+            .isNearlyEqual(to: CGRect(x: -6.0, y: 1.0, width: 4.0, height: 3.0), epsilon: torelance))
     }
     
     static var allTests : [(String, (CGRectTests) -> () throws -> Void)] {
         return [
-            ("testNearlyEqual", testNearlyEqual),
+            ("testisNearlyEqual", testisNearlyEqual),
             ("testCenter", testCenter),
             ("testDescription", testDescription),
             ("testMatmul", testMatmul),
diff --git a/Tests/CGPointVectorTests/CGSizeTests.swift b/Tests/CGPointVectorTests/CGSizeTests.swift
index 2c2237a..ac77c6c 100644
--- a/Tests/CGPointVectorTests/CGSizeTests.swift
+++ b/Tests/CGPointVectorTests/CGSizeTests.swift
@@ -4,16 +4,16 @@ import CGPointVector
 class CGSizeTests: XCTestCase {
     let torelance: CGFloat = 1.0e-5;
     
-    func testNearlyEqual() {
-        XCTAssertFalse(CGSize(width: 1.0, height: 2.0).nearlyEqual(to: CGSize(width: 0.5, height: 2.0), epsilon: 0.5))
-        XCTAssertTrue(CGSize(width: 1.0, height: 2.0).nearlyEqual(to: CGSize(width: 0.51, height: 2.0), epsilon: 0.5))
-        XCTAssertTrue(CGSize(width: 1.0, height: 2.0).nearlyEqual(to: CGSize(width: 1.49, height: 2.0), epsilon: 0.5))
-        XCTAssertFalse(CGSize(width: 1.0, height: 2.0).nearlyEqual(to: CGSize(width: 0.4, height: 2.0), epsilon: 0.5))
+    func testisNearlyEqual() {
+        XCTAssertFalse(CGSize(width: 1.0, height: 2.0).isNearlyEqual(to: CGSize(width: 0.5, height: 2.0), epsilon: 0.5))
+        XCTAssertTrue(CGSize(width: 1.0, height: 2.0).isNearlyEqual(to: CGSize(width: 0.51, height: 2.0), epsilon: 0.5))
+        XCTAssertTrue(CGSize(width: 1.0, height: 2.0).isNearlyEqual(to: CGSize(width: 1.49, height: 2.0), epsilon: 0.5))
+        XCTAssertFalse(CGSize(width: 1.0, height: 2.0).isNearlyEqual(to: CGSize(width: 0.4, height: 2.0), epsilon: 0.5))
         
-        XCTAssertFalse(CGSize(width: 1.0, height: 2.0).nearlyEqual(to: CGSize(width: 1.0, height: 1.0), epsilon: 1.0))
-        XCTAssertTrue(CGSize(width: 1.0, height: 2.0).nearlyEqual(to: CGSize(width: 1.0, height: 1.1), epsilon: 1.0))
-        XCTAssertTrue(CGSize(width: 1.0, height: 2.0).nearlyEqual(to: CGSize(width: 1.0, height: 2.9), epsilon: 1.0))
-        XCTAssertFalse(CGSize(width: 1.0, height: 2.0).nearlyEqual(to: CGSize(width: 1.0, height: 3.0), epsilon: 1.0))
+        XCTAssertFalse(CGSize(width: 1.0, height: 2.0).isNearlyEqual(to: CGSize(width: 1.0, height: 1.0), epsilon: 1.0))
+        XCTAssertTrue(CGSize(width: 1.0, height: 2.0).isNearlyEqual(to: CGSize(width: 1.0, height: 1.1), epsilon: 1.0))
+        XCTAssertTrue(CGSize(width: 1.0, height: 2.0).isNearlyEqual(to: CGSize(width: 1.0, height: 2.9), epsilon: 1.0))
+        XCTAssertFalse(CGSize(width: 1.0, height: 2.0).isNearlyEqual(to: CGSize(width: 1.0, height: 3.0), epsilon: 1.0))
     }
     
     func testLength() {
@@ -25,7 +25,7 @@ class CGSizeTests: XCTestCase {
     }
     
     func testUnit() {
-        XCTAssertTrue(CGSize(width: 3.0, height: -4.0).unit.nearlyEqual(to: CGSize(width: 0.6, height: -0.8), epsilon: torelance))
+        XCTAssertTrue(CGSize(width: 3.0, height: -4.0).unit.isNearlyEqual(to: CGSize(width: 0.6, height: -0.8), epsilon: torelance))
     }
     
     func testPhase() {
@@ -57,76 +57,76 @@ class CGSizeTests: XCTestCase {
     }
     
     func testPrefixPlus() {
-        XCTAssertTrue((+CGSize(width: 1.0, height: -2.0)).nearlyEqual(to: CGSize(width: 1.0, height: -2.0), epsilon: torelance))
+        XCTAssertTrue((+CGSize(width: 1.0, height: -2.0)).isNearlyEqual(to: CGSize(width: 1.0, height: -2.0), epsilon: torelance))
     }
     
     func testNegate() {
-        XCTAssertTrue((-CGSize(width: 1.0, height: -2.0)).nearlyEqual(to: CGSize(width: -1.0, height: 2.0), epsilon: torelance))
+        XCTAssertTrue((-CGSize(width: 1.0, height: -2.0)).isNearlyEqual(to: CGSize(width: -1.0, height: 2.0), epsilon: torelance))
     }
     
     func testAdd() {
-        XCTAssertTrue((CGSize(width: 1.0, height: 2.0) + CGSize(width: 3.0, height: -4.0)).nearlyEqual(to: CGSize(width: 4.0, height: -2.0), epsilon: torelance))
-        XCTAssertTrue((CGSize(width: 1.0, height: 2.0) + CGPoint(x: 3.0, y: -4.0)).nearlyEqual(to: CGPoint(x: 4.0, y: -2.0), epsilon: torelance))
+        XCTAssertTrue((CGSize(width: 1.0, height: 2.0) + CGSize(width: 3.0, height: -4.0)).isNearlyEqual(to: CGSize(width: 4.0, height: -2.0), epsilon: torelance))
+        XCTAssertTrue((CGSize(width: 1.0, height: 2.0) + CGPoint(x: 3.0, y: -4.0)).isNearlyEqual(to: CGPoint(x: 4.0, y: -2.0), epsilon: torelance))
     }
     
     func testSubtract() {
-        XCTAssertTrue((CGSize(width: 3.0, height: 2.0) - CGSize(width: 1.0, height: 4.0)).nearlyEqual(to: CGSize(width: 2.0, height: -2.0), epsilon: torelance))
-        XCTAssertTrue((CGSize(width: 3.0, height: 2.0) - CGPoint(x: 1.0, y: 4.0)).nearlyEqual(to: CGPoint(x: 2.0, y: -2.0), epsilon: torelance))
+        XCTAssertTrue((CGSize(width: 3.0, height: 2.0) - CGSize(width: 1.0, height: 4.0)).isNearlyEqual(to: CGSize(width: 2.0, height: -2.0), epsilon: torelance))
+        XCTAssertTrue((CGSize(width: 3.0, height: 2.0) - CGPoint(x: 1.0, y: 4.0)).isNearlyEqual(to: CGPoint(x: 2.0, y: -2.0), epsilon: torelance))
     }
     
     func testMultiply() {
-        XCTAssertTrue((CGSize(width: 2.0, height: 3.0) * CGSize(width: 5.0, height: 7.0)).nearlyEqual(to: CGSize(width: 10.0, height: 21.0), epsilon: torelance))
-        XCTAssertTrue((CGSize(width: 2.0, height: 3.0) * CGPoint(x: 5.0, y: 7.0)).nearlyEqual(to: CGPoint(x: 10.0, y: 21.0), epsilon: torelance))
-        XCTAssertTrue((CGSize(width: 1.0, height: -2.0) * 3.0).nearlyEqual(to: CGSize(width: 3.0, height: -6.0), epsilon: torelance))
-        XCTAssertTrue((3.0 * CGSize(width: 1.0, height: -2.0)).nearlyEqual(to: CGSize(width: 3.0, height: -6.0), epsilon: torelance))
+        XCTAssertTrue((CGSize(width: 2.0, height: 3.0) * CGSize(width: 5.0, height: 7.0)).isNearlyEqual(to: CGSize(width: 10.0, height: 21.0), epsilon: torelance))
+        XCTAssertTrue((CGSize(width: 2.0, height: 3.0) * CGPoint(x: 5.0, y: 7.0)).isNearlyEqual(to: CGPoint(x: 10.0, y: 21.0), epsilon: torelance))
+        XCTAssertTrue((CGSize(width: 1.0, height: -2.0) * 3.0).isNearlyEqual(to: CGSize(width: 3.0, height: -6.0), epsilon: torelance))
+        XCTAssertTrue((3.0 * CGSize(width: 1.0, height: -2.0)).isNearlyEqual(to: CGSize(width: 3.0, height: -6.0), epsilon: torelance))
     }
     
     func testDivide() {
-        XCTAssertTrue((CGSize(width: 8.0, height: 27.0) / CGSize(width: 2.0, height: 3.0)).nearlyEqual(to: CGSize(width: 4.0, height: 9.0), epsilon: torelance))
-        XCTAssertTrue((CGSize(width: 8.0, height: 27.0) / CGPoint(x: 2.0, y: 3.0)).nearlyEqual(to: CGPoint(x: 4.0, y: 9.0), epsilon: torelance))
-        XCTAssertTrue((CGSize(width: 8.0, height: -2.0) / 4.0).nearlyEqual(to: CGSize(width: 2.0, height: -0.5), epsilon: torelance))
+        XCTAssertTrue((CGSize(width: 8.0, height: 27.0) / CGSize(width: 2.0, height: 3.0)).isNearlyEqual(to: CGSize(width: 4.0, height: 9.0), epsilon: torelance))
+        XCTAssertTrue((CGSize(width: 8.0, height: 27.0) / CGPoint(x: 2.0, y: 3.0)).isNearlyEqual(to: CGPoint(x: 4.0, y: 9.0), epsilon: torelance))
+        XCTAssertTrue((CGSize(width: 8.0, height: -2.0) / 4.0).isNearlyEqual(to: CGSize(width: 2.0, height: -0.5), epsilon: torelance))
     }
     
     func testMatmul() {
         XCTAssertTrue((CGSize(width: 1.0, height: 1.0) ⊗ CGAffineTransform(rotationAngle: CGFloat.pi / 4))
-            .nearlyEqual(to: CGSize(width: 0.0, height: sqrt(2)), epsilon: torelance))
+            .isNearlyEqual(to: CGSize(width: 0.0, height: sqrt(2)), epsilon: torelance))
     }
     
     func testAdditionAssignment() {
         var a = CGSize(width: 1.0, height: 2.0)
         a += CGSize(width: 3.0, height: -4.0)
-        XCTAssertTrue(a.nearlyEqual(to: CGSize(width: 1.0, height: 2.0)
+        XCTAssertTrue(a.isNearlyEqual(to: CGSize(width: 1.0, height: 2.0)
             + CGSize(width: 3.0, height: -4.0), epsilon: torelance))
     }
     
     func testSuntractionAssignment() {
         var a = CGSize(width: 3.0, height: 2.0)
         a -= CGSize(width: 1.0, height: 4.0)
-        XCTAssertTrue(a.nearlyEqual(to: CGSize(width: 3.0, height: 2.0)
+        XCTAssertTrue(a.isNearlyEqual(to: CGSize(width: 3.0, height: 2.0)
             - CGSize(width: 1.0, height: 4.0), epsilon: torelance))
     }
     
     func testMultiplicationAssignment() {
         var a = CGSize(width: 1.0, height: -2.0)
         a *= 3.0
-        XCTAssertTrue(a.nearlyEqual(to: CGSize(width: 1.0, height: -2.0) * 3, epsilon: torelance))
+        XCTAssertTrue(a.isNearlyEqual(to: CGSize(width: 1.0, height: -2.0) * 3, epsilon: torelance))
     }
     
     func testDivisionAssignment() {
         var a = CGSize(width: 8.0, height: -2.0)
         a /= 4.0
-        XCTAssertTrue(a.nearlyEqual(to: CGSize(width: 8.0, height: -2.0) / 4.0, epsilon: torelance))
+        XCTAssertTrue(a.isNearlyEqual(to: CGSize(width: 8.0, height: -2.0) / 4.0, epsilon: torelance))
     }
     
     func testMatmulAssignment() {
         var a = CGSize(width: 1.0, height: 1.0)
         a ⊗= CGAffineTransform(rotationAngle: CGFloat.pi / 4)
-        XCTAssertTrue(a.nearlyEqual(to: CGSize(width: 0.0, height: sqrt(2)), epsilon: torelance))
+        XCTAssertTrue(a.isNearlyEqual(to: CGSize(width: 0.0, height: sqrt(2)), epsilon: torelance))
     }
     
     static var allTests : [(String, (CGSizeTests) -> () throws -> Void)] {
         return [
-            ("testNearlyEqual", testNearlyEqual),
+            ("testisNearlyEqual", testisNearlyEqual),
             ("testLength", testLength),
             ("testSquareLength", testSquareLength),
             ("testUnit", testUnit),

From 1b4939f021de55a009f9f0f9858057537e7d02cf Mon Sep 17 00:00:00 2001
From: Yuta Koshizawa <koher@koherent.org>
Date: Thu, 21 Jun 2018 13:35:09 +0900
Subject: [PATCH 08/20] Remove `CGAffineTransform.inverse`

Because it has `inverted()`. When `inverse` was introduced, maybe it did not have `inverted()` and it was required to use `CGAffineTransformInvert`.
---
 Sources/CGPointVector/CGAffineTransform.swift         | 4 ----
 Tests/CGPointVectorTests/CGAffineTransformTests.swift | 6 ------
 2 files changed, 10 deletions(-)

diff --git a/Sources/CGPointVector/CGAffineTransform.swift b/Sources/CGPointVector/CGAffineTransform.swift
index 0ea8e3f..c9aebef 100644
--- a/Sources/CGPointVector/CGAffineTransform.swift
+++ b/Sources/CGPointVector/CGAffineTransform.swift
@@ -4,10 +4,6 @@ extension CGAffineTransform {
     public func isNearlyEqual(to transform: CGAffineTransform, epsilon: CGFloat) -> Bool {
         return fabs(a - transform.a) < epsilon && fabs(b - transform.b) < epsilon && fabs(c - transform.c) < epsilon && fabs(d - transform.d) < epsilon && fabs(tx - transform.tx) < epsilon && fabs(ty - transform.ty) < epsilon
     }
-    
-    public var inverse: CGAffineTransform {
-        return self.inverted()
-    }
 }
 
 extension CGAffineTransform: CustomStringConvertible {
diff --git a/Tests/CGPointVectorTests/CGAffineTransformTests.swift b/Tests/CGPointVectorTests/CGAffineTransformTests.swift
index 8e19e55..961cbb0 100644
--- a/Tests/CGPointVectorTests/CGAffineTransformTests.swift
+++ b/Tests/CGPointVectorTests/CGAffineTransformTests.swift
@@ -60,11 +60,6 @@ class CGAffineTransormTests: XCTestCase {
             .isNearlyEqual(to: CGAffineTransform(a: 1.0, b: 2.0, c: 3.0, d: 4.0, tx: 5.0, ty: 7.0), epsilon: 1.0))
     }
 
-    func testInverse() {
-        XCTAssertTrue(CGAffineTransform(a: 1, b: 2, c: 3, d: 4, tx: 5, ty: 6).inverse
-            .isNearlyEqual(to: CGAffineTransform(a: 1, b: 2, c: 3, d: 4, tx: 5, ty: 6).inverted(), epsilon: torelance))
-    }
-    
     func testDescription() {
         XCTAssertEqual(CGAffineTransform(a: 1, b: 2, c: 3, d: 4, tx: 5, ty: 6).description, "(1.0, 2.0, 3.0, 4.0, 5.0, 6.0)")
     }
@@ -88,7 +83,6 @@ class CGAffineTransormTests: XCTestCase {
     static var allTests : [(String, (CGAffineTransormTests) -> () throws -> Void)] {
         return [
             ("testisNearlyEqual", testisNearlyEqual),
-            ("testInverse", testInverse),
             ("testDescription", testDescription),
             ("testMatmul", testMatmul),
             ("testMatmulAssignment", testMatmulAssignment),

From c43c9b82d8872211d225bf7f9d4b822fa51ee677 Mon Sep 17 00:00:00 2001
From: Yuta Koshizawa <koher@koherent.org>
Date: Thu, 21 Jun 2018 13:46:14 +0900
Subject: [PATCH 09/20] Add extensions for `CGVector`

---
 CGPointVector.xcodeproj/project.pbxproj      |  18 +++
 Sources/CGPointVector/CGVector.swift         | 139 +++++++++++++++++
 Tests/CGPointVectorTests/CGVectorTests.swift | 154 +++++++++++++++++++
 3 files changed, 311 insertions(+)
 create mode 100644 Sources/CGPointVector/CGVector.swift
 create mode 100644 Tests/CGPointVectorTests/CGVectorTests.swift

diff --git a/CGPointVector.xcodeproj/project.pbxproj b/CGPointVector.xcodeproj/project.pbxproj
index d91cb23..180fdde 100644
--- a/CGPointVector.xcodeproj/project.pbxproj
+++ b/CGPointVector.xcodeproj/project.pbxproj
@@ -49,6 +49,13 @@
 		D63F165920DB574100F8B479 /* Operators.swift in Sources */ = {isa = PBXBuildFile; fileRef = D63F165720DB574100F8B479 /* Operators.swift */; };
 		D63F165A20DB574100F8B479 /* Operators.swift in Sources */ = {isa = PBXBuildFile; fileRef = D63F165720DB574100F8B479 /* Operators.swift */; };
 		D63F165B20DB574100F8B479 /* Operators.swift in Sources */ = {isa = PBXBuildFile; fileRef = D63F165720DB574100F8B479 /* Operators.swift */; };
+		D63F165D20DB641300F8B479 /* CGVector.swift in Sources */ = {isa = PBXBuildFile; fileRef = D63F165C20DB641300F8B479 /* CGVector.swift */; };
+		D63F165E20DB641300F8B479 /* CGVector.swift in Sources */ = {isa = PBXBuildFile; fileRef = D63F165C20DB641300F8B479 /* CGVector.swift */; };
+		D63F165F20DB641300F8B479 /* CGVector.swift in Sources */ = {isa = PBXBuildFile; fileRef = D63F165C20DB641300F8B479 /* CGVector.swift */; };
+		D63F166020DB641300F8B479 /* CGVector.swift in Sources */ = {isa = PBXBuildFile; fileRef = D63F165C20DB641300F8B479 /* CGVector.swift */; };
+		D63F166220DB64CE00F8B479 /* CGVectorTests.swift in Sources */ = {isa = PBXBuildFile; fileRef = D63F166120DB64CE00F8B479 /* CGVectorTests.swift */; };
+		D63F166320DB64CE00F8B479 /* CGVectorTests.swift in Sources */ = {isa = PBXBuildFile; fileRef = D63F166120DB64CE00F8B479 /* CGVectorTests.swift */; };
+		D63F166420DB64CE00F8B479 /* CGVectorTests.swift in Sources */ = {isa = PBXBuildFile; fileRef = D63F166120DB64CE00F8B479 /* CGVectorTests.swift */; };
 /* End PBXBuildFile section */
 
 /* Begin PBXContainerItemProxy section */
@@ -97,6 +104,8 @@
 		D62C6DEA1FB5657000E7DF02 /* CGSize.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = CGSize.swift; sourceTree = "<group>"; };
 		D62C6DEB1FB5657000E7DF02 /* Info.plist */ = {isa = PBXFileReference; lastKnownFileType = text.plist.xml; path = Info.plist; sourceTree = "<group>"; };
 		D63F165720DB574100F8B479 /* Operators.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = Operators.swift; sourceTree = "<group>"; };
+		D63F165C20DB641300F8B479 /* CGVector.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = CGVector.swift; sourceTree = "<group>"; };
+		D63F166120DB64CE00F8B479 /* CGVectorTests.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = CGVectorTests.swift; sourceTree = "<group>"; };
 /* End PBXFileReference section */
 
 /* Begin PBXFrameworksBuildPhase section */
@@ -195,6 +204,7 @@
 				D62C6DDF1FB5657000E7DF02 /* CGPointVectorTests.swift */,
 				D62C6DE01FB5657000E7DF02 /* CGRectTests.swift */,
 				D62C6DE11FB5657000E7DF02 /* CGSizeTests.swift */,
+				D63F166120DB64CE00F8B479 /* CGVectorTests.swift */,
 				D62C6DE21FB5657000E7DF02 /* Info.plist */,
 			);
 			path = CGPointVectorTests;
@@ -216,6 +226,7 @@
 				D62C6DE81FB5657000E7DF02 /* CGPointVector.h */,
 				D62C6DE91FB5657000E7DF02 /* CGRect.swift */,
 				D62C6DEA1FB5657000E7DF02 /* CGSize.swift */,
+				D63F165C20DB641300F8B479 /* CGVector.swift */,
 				D62C6DEB1FB5657000E7DF02 /* Info.plist */,
 				D63F165720DB574100F8B479 /* Operators.swift */,
 			);
@@ -508,6 +519,7 @@
 			files = (
 				D62C6DF01FB5657900E7DF02 /* CGSize.swift in Sources */,
 				D63F165820DB574100F8B479 /* Operators.swift in Sources */,
+				D63F165D20DB641300F8B479 /* CGVector.swift in Sources */,
 				D62C6DED1FB5657900E7DF02 /* CGPoint.swift in Sources */,
 				D62C6DEF1FB5657900E7DF02 /* CGRect.swift in Sources */,
 				D62C6DEC1FB5657900E7DF02 /* CGAffineTransform.swift in Sources */,
@@ -520,6 +532,7 @@
 			files = (
 				D62C6E011FB5658A00E7DF02 /* CGPointTests.swift in Sources */,
 				D62C6E021FB5658A00E7DF02 /* CGPointVectorTests.swift in Sources */,
+				D63F166220DB64CE00F8B479 /* CGVectorTests.swift in Sources */,
 				D62C6E041FB5658A00E7DF02 /* CGSizeTests.swift in Sources */,
 				D62C6E001FB5658A00E7DF02 /* CGAffineTransformTests.swift in Sources */,
 				D62C6E031FB5658A00E7DF02 /* CGRectTests.swift in Sources */,
@@ -532,6 +545,7 @@
 			files = (
 				D62C6DF51FB5657A00E7DF02 /* CGSize.swift in Sources */,
 				D63F165920DB574100F8B479 /* Operators.swift in Sources */,
+				D63F165E20DB641300F8B479 /* CGVector.swift in Sources */,
 				D62C6DF21FB5657A00E7DF02 /* CGPoint.swift in Sources */,
 				D62C6DF41FB5657A00E7DF02 /* CGRect.swift in Sources */,
 				D62C6DF11FB5657A00E7DF02 /* CGAffineTransform.swift in Sources */,
@@ -544,6 +558,7 @@
 			files = (
 				D62C6E061FB5658A00E7DF02 /* CGPointTests.swift in Sources */,
 				D62C6E071FB5658A00E7DF02 /* CGPointVectorTests.swift in Sources */,
+				D63F166320DB64CE00F8B479 /* CGVectorTests.swift in Sources */,
 				D62C6E091FB5658A00E7DF02 /* CGSizeTests.swift in Sources */,
 				D62C6E051FB5658A00E7DF02 /* CGAffineTransformTests.swift in Sources */,
 				D62C6E081FB5658A00E7DF02 /* CGRectTests.swift in Sources */,
@@ -556,6 +571,7 @@
 			files = (
 				D62C6DFA1FB5657A00E7DF02 /* CGSize.swift in Sources */,
 				D63F165A20DB574100F8B479 /* Operators.swift in Sources */,
+				D63F165F20DB641300F8B479 /* CGVector.swift in Sources */,
 				D62C6DF71FB5657A00E7DF02 /* CGPoint.swift in Sources */,
 				D62C6DF91FB5657A00E7DF02 /* CGRect.swift in Sources */,
 				D62C6DF61FB5657A00E7DF02 /* CGAffineTransform.swift in Sources */,
@@ -568,6 +584,7 @@
 			files = (
 				D62C6E0B1FB5658C00E7DF02 /* CGPointTests.swift in Sources */,
 				D62C6E0C1FB5658C00E7DF02 /* CGPointVectorTests.swift in Sources */,
+				D63F166420DB64CE00F8B479 /* CGVectorTests.swift in Sources */,
 				D62C6E0E1FB5658C00E7DF02 /* CGSizeTests.swift in Sources */,
 				D62C6E0A1FB5658C00E7DF02 /* CGAffineTransformTests.swift in Sources */,
 				D62C6E0D1FB5658C00E7DF02 /* CGRectTests.swift in Sources */,
@@ -580,6 +597,7 @@
 			files = (
 				D62C6DFF1FB5657B00E7DF02 /* CGSize.swift in Sources */,
 				D63F165B20DB574100F8B479 /* Operators.swift in Sources */,
+				D63F166020DB641300F8B479 /* CGVector.swift in Sources */,
 				D62C6DFC1FB5657B00E7DF02 /* CGPoint.swift in Sources */,
 				D62C6DFE1FB5657B00E7DF02 /* CGRect.swift in Sources */,
 				D62C6DFB1FB5657B00E7DF02 /* CGAffineTransform.swift in Sources */,
diff --git a/Sources/CGPointVector/CGVector.swift b/Sources/CGPointVector/CGVector.swift
new file mode 100644
index 0000000..d5fdaab
--- /dev/null
+++ b/Sources/CGPointVector/CGVector.swift
@@ -0,0 +1,139 @@
+import CoreGraphics
+
+extension CGVector {
+    public func isNearlyEqual(to point: CGVector, epsilon: CGFloat) -> Bool {
+        let difference = self - point
+        return fabs(difference.dx) < epsilon && fabs(difference.dy) < epsilon
+    }
+    
+    public var length: CGFloat {
+        return sqrt(squareLength)
+    }
+    
+    public var squareLength: CGFloat {
+        return dx * dx + dy * dy
+    }
+    
+    public var unit: CGVector {
+        return self * (1.0 / length)
+    }
+    
+    public var phase: CGFloat {
+        return atan2(dy, dx)
+    }
+    
+    public func distance(from point: CGVector) -> CGFloat {
+        return (self - point).length
+    }
+    
+    public func squareDistance(from point: CGVector) -> CGFloat {
+        return (self - point).squareLength
+    }
+    
+    public func angle(from point: CGVector) -> CGFloat {
+        return acos(cos(from: point))
+    }
+    
+    public func cos(from point: CGVector) -> CGFloat {
+        return fmin(fmax(self.dot(point) / sqrt(self.squareLength * point.squareLength), -1.0), 1.0)
+    }
+    
+    public func dot(_ other: CGVector) -> CGFloat {
+        return self.dx * other.dx + self.dy * other.dy
+    }
+}
+
+extension CGVector: CustomStringConvertible {
+    public var description: String {
+        return "(\(dx), \(dy))"
+    }
+}
+
+extension CGVector {
+    public static prefix func + (value: CGVector) -> CGVector {
+        return value
+    }
+    
+    public static prefix func - (value: CGVector) -> CGVector {
+        return CGVector(dx: -value.dx, dy: -value.dy)
+    }
+    
+    public static func + (lhs: CGVector, rhs: CGVector) -> CGVector {
+        return CGVector(dx: lhs.dx + rhs.dx, dy: lhs.dy + rhs.dy)
+    }
+    
+    public static func - (lhs: CGVector, rhs: CGVector) -> CGVector {
+        return CGVector(dx: lhs.dx - rhs.dx, dy: lhs.dy - rhs.dy)
+    }
+    
+    public static func * (lhs: CGVector, rhs: CGVector) -> CGVector {
+        return CGVector(dx: lhs.dx * rhs.dx, dy: lhs.dy * rhs.dy)
+    }
+    
+    public static func * (lhs: CGVector, rhs: CGFloat) -> CGVector {
+        return CGVector(dx: lhs.dx * rhs, dy: lhs.dy * rhs)
+    }
+    
+    public static func * (lhs: CGFloat, rhs: CGVector) -> CGVector {
+        return CGVector(dx: rhs.dx * lhs, dy: rhs.dy * lhs)
+    }
+    
+    public static func / (lhs: CGVector, rhs: CGVector) -> CGVector {
+        return CGVector(dx: lhs.dx / rhs.dx, dy: lhs.dy / rhs.dy)
+    }
+    
+    public static func / (lhs: CGVector, rhs: CGFloat) -> CGVector {
+        return CGVector(dx: lhs.dx / rhs, dy: lhs.dy / rhs)
+    }
+    
+    public static func ⊗ (lhs: CGVector, rhs: CGAffineTransform) -> CGVector {
+        let point = CGPoint(x: lhs.dx, y: lhs.dy).applying(rhs)
+        return CGVector(dx: point.x, dy: point.y)
+    }
+    
+    public static func += (lhs: inout CGVector, rhs: CGVector) {
+        lhs = lhs + rhs
+    }
+    
+    public static func -= (lhs: inout CGVector, rhs: CGVector) {
+        lhs = lhs - rhs
+    }
+    
+    public static func *= (lhs: inout CGVector, rhs: CGVector) {
+        lhs = lhs * rhs
+    }
+    
+    public static func *= (lhs: inout CGVector, rhs: CGFloat) {
+        lhs = lhs * rhs
+    }
+    
+    public static func /= (lhs: inout CGVector, rhs: CGVector) {
+        lhs = lhs / rhs
+    }
+    
+    public static func /= (lhs: inout CGVector, rhs: CGFloat) {
+        lhs = lhs / rhs
+    }
+    
+    public static func ⊗= (lhs: inout CGVector, rhs: CGAffineTransform) {
+        lhs = lhs ⊗ rhs
+    }
+}
+
+extension CGVector {
+    public static func + (lhs: CGVector, rhs: CGPoint) -> CGPoint {
+        return CGPoint(x: lhs.dx + rhs.x, y: lhs.dy + rhs.y)
+    }
+    
+    public static func - (lhs: CGVector, rhs: CGPoint) -> CGPoint {
+        return CGPoint(x: lhs.dx - rhs.x, y: lhs.dy - rhs.y)
+    }
+    
+    public static func * (lhs: CGVector, rhs: CGPoint) -> CGPoint {
+        return CGPoint(x: lhs.dx * rhs.x, y: lhs.dy * rhs.y)
+    }
+    
+    public static func / (lhs: CGVector, rhs: CGPoint) -> CGPoint {
+        return CGPoint(x: lhs.dx / rhs.x, y: lhs.dy / rhs.y)
+    }
+}
diff --git a/Tests/CGPointVectorTests/CGVectorTests.swift b/Tests/CGPointVectorTests/CGVectorTests.swift
new file mode 100644
index 0000000..da3de9a
--- /dev/null
+++ b/Tests/CGPointVectorTests/CGVectorTests.swift
@@ -0,0 +1,154 @@
+import XCTest
+import CGPointVector
+
+class CGVectorTests: XCTestCase {
+    let torelance: CGFloat = 1.0e-5;
+    
+    func testisNearlyEqual() {
+        XCTAssertFalse(CGVector(dx: 1.0, dy: 2.0).isNearlyEqual(to: CGVector(dx: 0.5, dy: 2.0), epsilon: 0.5))
+        XCTAssertTrue(CGVector(dx: 1.0, dy: 2.0).isNearlyEqual(to: CGVector(dx: 0.51, dy: 2.0), epsilon: 0.5))
+        XCTAssertTrue(CGVector(dx: 1.0, dy: 2.0).isNearlyEqual(to: CGVector(dx: 1.49, dy: 2.0), epsilon: 0.5))
+        XCTAssertFalse(CGVector(dx: 1.0, dy: 2.0).isNearlyEqual(to: CGVector(dx: 0.4, dy: 2.0), epsilon: 0.5))
+        
+        XCTAssertFalse(CGVector(dx: 1.0, dy: 2.0).isNearlyEqual(to: CGVector(dx: 1.0, dy: 1.0), epsilon: 1.0))
+        XCTAssertTrue(CGVector(dx: 1.0, dy: 2.0).isNearlyEqual(to: CGVector(dx: 1.0, dy: 1.1), epsilon: 1.0))
+        XCTAssertTrue(CGVector(dx: 1.0, dy: 2.0).isNearlyEqual(to: CGVector(dx: 1.0, dy: 2.9), epsilon: 1.0))
+        XCTAssertFalse(CGVector(dx: 1.0, dy: 2.0).isNearlyEqual(to: CGVector(dx: 1.0, dy: 3.0), epsilon: 1.0))
+    }
+    
+    func testLength() {
+        XCTAssertEqual(CGVector(dx: 3.0, dy: -4.0).length, 5.0, accuracy: torelance)
+    }
+    
+    func testSquareLength() {
+        XCTAssertEqual(CGVector(dx: 3.0, dy: -4.0).squareLength, 25.0, accuracy: torelance)
+    }
+    
+    func testUnit() {
+        XCTAssertTrue(CGVector(dx: 3.0, dy: -4.0).unit.isNearlyEqual(to: CGVector(dx: 0.6, dy: -0.8), epsilon: torelance))
+    }
+    
+    func testPhase() {
+        XCTAssertEqual(CGVector(dx: 1.0, dy: sqrt(3)).phase, CGFloat.pi / 3, accuracy: torelance)
+    }
+    
+    func testDistance() {
+        XCTAssertEqual(CGVector(dx: 1.0, dy: 2.0).distance(from: CGVector(dx: -3.0, dy: 5.0)), 5.0, accuracy: torelance)
+    }
+    
+    func testSquareDistance() {
+        XCTAssertEqual(CGVector(dx: 1.0, dy: 2.0).squareDistance(from: CGVector(dx: -3.0, dy: 5.0)), 25.0, accuracy: torelance)
+    }
+    
+    func testAngle() {
+        XCTAssertEqual(CGVector(dx: 1.0, dy: 0.0).angle(from: CGVector(dx: sqrt(3.0), dy: 1.0)), CGFloat.pi / 6, accuracy: torelance)
+    }
+    
+    func testCosOfAngle() {
+        XCTAssertEqual(CGVector(dx: 1.0, dy: 0.0).cos(from: CGVector(dx: 1.0, dy: sqrt(3.0))), 0.5, accuracy: torelance)
+    }
+    
+    func testDot() {
+        XCTAssertEqual(CGVector(dx: 1.0, dy: 2.0).dot(CGVector(dx: -3.0, dy: 4.0)), 5.0, accuracy: torelance)
+    }
+    
+    func testDescription() {
+        XCTAssertEqual(CGVector(dx: 1.0, dy: 2.0).description, "(1.0, 2.0)")
+    }
+    
+    func testPrefixPlus() {
+        XCTAssertTrue((+CGVector(dx: 1.0, dy: -2.0)).isNearlyEqual(to: CGVector(dx: 1.0, dy: -2.0), epsilon: torelance))
+    }
+    
+    func testNegate() {
+        XCTAssertTrue((-CGVector(dx: 1.0, dy: -2.0)).isNearlyEqual(to: CGVector(dx: -1.0, dy: 2.0), epsilon: torelance))
+    }
+    
+    func testAdd() {
+        XCTAssertTrue((CGVector(dx: 1.0, dy: 2.0) + CGVector(dx: 3.0, dy: -4.0)).isNearlyEqual(to: CGVector(dx: 4.0, dy: -2.0), epsilon: torelance))
+        XCTAssertTrue((CGVector(dx: 1.0, dy: 2.0) + CGPoint(x: 3.0, y: -4.0)).isNearlyEqual(to: CGPoint(x: 4.0, y: -2.0), epsilon: torelance))
+    }
+    
+    func testSubtract() {
+        XCTAssertTrue((CGVector(dx: 3.0, dy: 2.0) - CGVector(dx: 1.0, dy: 4.0)).isNearlyEqual(to: CGVector(dx: 2.0, dy: -2.0), epsilon: torelance))
+        XCTAssertTrue((CGVector(dx: 3.0, dy: 2.0) - CGPoint(x: 1.0, y: 4.0)).isNearlyEqual(to: CGPoint(x: 2.0, y: -2.0), epsilon: torelance))
+    }
+    
+    func testMultiply() {
+        XCTAssertTrue((CGVector(dx: 2.0, dy: 3.0) * CGVector(dx: 5.0, dy: 7.0)).isNearlyEqual(to: CGVector(dx: 10.0, dy: 21.0), epsilon: torelance))
+        XCTAssertTrue((CGVector(dx: 2.0, dy: 3.0) * CGPoint(x: 5.0, y: 7.0)).isNearlyEqual(to: CGPoint(x: 10.0, y: 21.0), epsilon: torelance))
+        XCTAssertTrue((CGVector(dx: 1.0, dy: -2.0) * 3.0).isNearlyEqual(to: CGVector(dx: 3.0, dy: -6.0), epsilon: torelance))
+        XCTAssertTrue((3.0 * CGVector(dx: 1.0, dy: -2.0)).isNearlyEqual(to: CGVector(dx: 3.0, dy: -6.0), epsilon: torelance))
+    }
+    
+    func testDivide() {
+        XCTAssertTrue((CGVector(dx: 8.0, dy: 27.0) / CGVector(dx: 2.0, dy: 3.0)).isNearlyEqual(to: CGVector(dx: 4.0, dy: 9.0), epsilon: torelance))
+        XCTAssertTrue((CGVector(dx: 8.0, dy: 27.0) / CGPoint(x: 2.0, y: 3.0)).isNearlyEqual(to: CGPoint(x: 4.0, y: 9.0), epsilon: torelance))
+        XCTAssertTrue((CGVector(dx: 8.0, dy: -2.0) / 4.0).isNearlyEqual(to: CGVector(dx: 2.0, dy: -0.5), epsilon: torelance))
+    }
+    
+    func testMatmul() {
+        XCTAssertTrue((CGVector(dx: 1.0, dy: 1.0) ⊗ CGAffineTransform(rotationAngle: CGFloat.pi / 4))
+            .isNearlyEqual(to: CGVector(dx: 0.0, dy: sqrt(2)), epsilon: torelance))
+    }
+    
+    func testAdditionAssignment() {
+        var a = CGVector(dx: 1.0, dy: 2.0)
+        a += CGVector(dx: 3.0, dy: -4.0)
+        XCTAssertTrue(a.isNearlyEqual(to: CGVector(dx: 1.0, dy: 2.0)
+            + CGVector(dx: 3.0, dy: -4.0), epsilon: torelance))
+    }
+    
+    func testSuntractionAssignment() {
+        var a = CGVector(dx: 3.0, dy: 2.0)
+        a -= CGVector(dx: 1.0, dy: 4.0)
+        XCTAssertTrue(a.isNearlyEqual(to: CGVector(dx: 3.0, dy: 2.0)
+            - CGVector(dx: 1.0, dy: 4.0), epsilon: torelance))
+    }
+    
+    func testMultiplicationAssignment() {
+        var a = CGVector(dx: 1.0, dy: -2.0)
+        a *= 3.0
+        XCTAssertTrue(a.isNearlyEqual(to: CGVector(dx: 1.0, dy: -2.0) * 3, epsilon: torelance))
+    }
+    
+    func testDivisionAssignment() {
+        var a = CGVector(dx: 8.0, dy: -2.0)
+        a /= 4.0
+        XCTAssertTrue(a.isNearlyEqual(to: CGVector(dx: 8.0, dy: -2.0) / 4.0, epsilon: torelance))
+    }
+    
+    func testMatmulAssignment() {
+        var a = CGVector(dx: 1.0, dy: 1.0)
+        a ⊗= CGAffineTransform(rotationAngle: CGFloat.pi / 4)
+        XCTAssertTrue(a.isNearlyEqual(to: CGVector(dx: 0.0, dy: sqrt(2)), epsilon: torelance))
+    }
+    
+    static var allTests : [(String, (CGVectorTests) -> () throws -> Void)] {
+        return [
+            ("testisNearlyEqual", testisNearlyEqual),
+            ("testLength", testLength),
+            ("testSquareLength", testSquareLength),
+            ("testUnit", testUnit),
+            ("testPhase", testPhase),
+            ("testDistance", testDistance),
+            ("testSquareDistance", testSquareDistance),
+            ("testAngle", testAngle),
+            ("testCosOfAngle", testCosOfAngle),
+            ("testDot", testDot),
+            ("testDescription", testDescription),
+            ("testPrefixPlus", testPrefixPlus),
+            ("testNegate", testNegate),
+            ("testAdd", testAdd),
+            ("testSubtract", testSubtract),
+            ("testMultiply", testMultiply),
+            ("testDivide", testDivide),
+            ("testMatmul", testMatmul),
+            ("testAdditionAssignment", testAdditionAssignment),
+            ("testSuntractionAssignment", testSuntractionAssignment),
+            ("testMultiplicationAssignment", testMultiplicationAssignment),
+            ("testDivisionAssignment", testDivisionAssignment),
+            ("testMatmulAssignment", testMatmulAssignment),
+        ]
+    }
+}

From ab4bebb25eb7a6fb7c4dc74107213bea05de927b Mon Sep 17 00:00:00 2001
From: Yuta Koshizawa <koher@koherent.org>
Date: Thu, 21 Jun 2018 13:49:01 +0900
Subject: [PATCH 10/20] Update README

---
 README.md | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/README.md b/README.md
index fe549cd..ccb44b8 100644
--- a/README.md
+++ b/README.md
@@ -35,14 +35,14 @@ let dotProduct = a.dot(b) // 26.0
 ```swift
 .package(
     url: "https://github.com/koher/CGPointVector.git",
-    from: "0.2.0"
+    from: "0.3.0-alpha"
 )
 ```
 
 ### Carthage
 
 ```
-github "koher/CGPointVector" ~> 0.2.0
+github "koher/CGPointVector" "dev-0.3.0"
 ```
 
 ## License

From 4ee16806566aaca69f8bdad0f3a77f79d756cb46 Mon Sep 17 00:00:00 2001
From: Yuta Koshizawa <koher@koherent.org>
Date: Thu, 21 Jun 2018 13:57:34 +0900
Subject: [PATCH 11/20] Rename `testCosOfAngle` to `testCos`

---
 Tests/CGPointVectorTests/CGPointTests.swift  | 4 ++--
 Tests/CGPointVectorTests/CGSizeTests.swift   | 4 ++--
 Tests/CGPointVectorTests/CGVectorTests.swift | 4 ++--
 3 files changed, 6 insertions(+), 6 deletions(-)

diff --git a/Tests/CGPointVectorTests/CGPointTests.swift b/Tests/CGPointVectorTests/CGPointTests.swift
index d8be162..adb29e8 100644
--- a/Tests/CGPointVectorTests/CGPointTests.swift
+++ b/Tests/CGPointVectorTests/CGPointTests.swift
@@ -44,7 +44,7 @@ class CGPointTests: XCTestCase {
         XCTAssertEqual(CGPoint(x: 1.0, y: 0.0).angle(from: CGPoint(x: sqrt(3.0), y: 1.0)), CGFloat.pi / 6, accuracy: torelance)
     }
     
-    func testCosOfAngle() {
+    func testCos() {
         XCTAssertEqual(CGPoint(x: 1.0, y: 0.0).cos(from: CGPoint(x: 1.0, y: sqrt(3.0))), 0.5, accuracy: torelance)
     }
     
@@ -134,7 +134,7 @@ class CGPointTests: XCTestCase {
             ("testDistance", testDistance),
             ("testSquareDistance", testSquareDistance),
             ("testAngle", testAngle),
-            ("testCosOfAngle", testCosOfAngle),
+            ("testCos", testCos),
             ("testDot", testDot),
             ("testDescription", testDescription),
             ("testPrefixPlus", testPrefixPlus),
diff --git a/Tests/CGPointVectorTests/CGSizeTests.swift b/Tests/CGPointVectorTests/CGSizeTests.swift
index ac77c6c..5511aab 100644
--- a/Tests/CGPointVectorTests/CGSizeTests.swift
+++ b/Tests/CGPointVectorTests/CGSizeTests.swift
@@ -44,7 +44,7 @@ class CGSizeTests: XCTestCase {
         XCTAssertEqual(CGSize(width: 1.0, height: 0.0).angle(from: CGSize(width: sqrt(3.0), height: 1.0)), CGFloat.pi / 6, accuracy: torelance)
     }
     
-    func testCosOfAngle() {
+    func testCos() {
         XCTAssertEqual(CGSize(width: 1.0, height: 0.0).cos(from: CGSize(width: 1.0, height: sqrt(3.0))), 0.5, accuracy: torelance)
     }
     
@@ -134,7 +134,7 @@ class CGSizeTests: XCTestCase {
             ("testDistance", testDistance),
             ("testSquareDistance", testSquareDistance),
             ("testAngle", testAngle),
-            ("testCosOfAngle", testCosOfAngle),
+            ("testCos", testCos),
             ("testDot", testDot),
             ("testDescription", testDescription),
             ("testPrefixPlus", testPrefixPlus),
diff --git a/Tests/CGPointVectorTests/CGVectorTests.swift b/Tests/CGPointVectorTests/CGVectorTests.swift
index da3de9a..399d948 100644
--- a/Tests/CGPointVectorTests/CGVectorTests.swift
+++ b/Tests/CGPointVectorTests/CGVectorTests.swift
@@ -44,7 +44,7 @@ class CGVectorTests: XCTestCase {
         XCTAssertEqual(CGVector(dx: 1.0, dy: 0.0).angle(from: CGVector(dx: sqrt(3.0), dy: 1.0)), CGFloat.pi / 6, accuracy: torelance)
     }
     
-    func testCosOfAngle() {
+    func testCos() {
         XCTAssertEqual(CGVector(dx: 1.0, dy: 0.0).cos(from: CGVector(dx: 1.0, dy: sqrt(3.0))), 0.5, accuracy: torelance)
     }
     
@@ -134,7 +134,7 @@ class CGVectorTests: XCTestCase {
             ("testDistance", testDistance),
             ("testSquareDistance", testSquareDistance),
             ("testAngle", testAngle),
-            ("testCosOfAngle", testCosOfAngle),
+            ("testCos", testCos),
             ("testDot", testDot),
             ("testDescription", testDescription),
             ("testPrefixPlus", testPrefixPlus),

From 9db8df57f65a8c0abacff5068958b8982f5a396b Mon Sep 17 00:00:00 2001
From: Yuta Koshizawa <koher@koherent.org>
Date: Fri, 28 Sep 2018 11:33:29 +0900
Subject: [PATCH 12/20] Remove LinuxMain.swift from the project

---
 CGPointVector.xcodeproj/project.pbxproj | 2 --
 1 file changed, 2 deletions(-)

diff --git a/CGPointVector.xcodeproj/project.pbxproj b/CGPointVector.xcodeproj/project.pbxproj
index 180fdde..0979499 100644
--- a/CGPointVector.xcodeproj/project.pbxproj
+++ b/CGPointVector.xcodeproj/project.pbxproj
@@ -96,7 +96,6 @@
 		D62C6DE01FB5657000E7DF02 /* CGRectTests.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = CGRectTests.swift; sourceTree = "<group>"; };
 		D62C6DE11FB5657000E7DF02 /* CGSizeTests.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = CGSizeTests.swift; sourceTree = "<group>"; };
 		D62C6DE21FB5657000E7DF02 /* Info.plist */ = {isa = PBXFileReference; lastKnownFileType = text.plist.xml; path = Info.plist; sourceTree = "<group>"; };
-		D62C6DE31FB5657000E7DF02 /* LinuxMain.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = LinuxMain.swift; sourceTree = "<group>"; };
 		D62C6DE61FB5657000E7DF02 /* CGAffineTransform.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = CGAffineTransform.swift; sourceTree = "<group>"; };
 		D62C6DE71FB5657000E7DF02 /* CGPoint.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = CGPoint.swift; sourceTree = "<group>"; };
 		D62C6DE81FB5657000E7DF02 /* CGPointVector.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = CGPointVector.h; sourceTree = "<group>"; };
@@ -191,7 +190,6 @@
 			isa = PBXGroup;
 			children = (
 				D62C6DDC1FB5657000E7DF02 /* CGPointVectorTests */,
-				D62C6DE31FB5657000E7DF02 /* LinuxMain.swift */,
 			);
 			path = Tests;
 			sourceTree = "<group>";

From 18a1f5d8f9cd8ab255b67897274ce407b308e8b3 Mon Sep 17 00:00:00 2001
From: Yuta Koshizawa <koher@koherent.org>
Date: Fri, 28 Sep 2018 11:40:44 +0900
Subject: [PATCH 13/20] Update for Swift 4.2

---
 CGPointVector.xcodeproj/project.pbxproj       | 35 +++++++++++--------
 Sources/CGPointVector/CGAffineTransform.swift |  2 +-
 Sources/CGPointVector/CGPoint.swift           |  2 +-
 Sources/CGPointVector/CGRect.swift            |  4 +--
 Sources/CGPointVector/CGSize.swift            |  2 +-
 Sources/CGPointVector/CGVector.swift          |  2 +-
 6 files changed, 27 insertions(+), 20 deletions(-)

diff --git a/CGPointVector.xcodeproj/project.pbxproj b/CGPointVector.xcodeproj/project.pbxproj
index 0979499..73e09a9 100644
--- a/CGPointVector.xcodeproj/project.pbxproj
+++ b/CGPointVector.xcodeproj/project.pbxproj
@@ -407,30 +407,37 @@
 				TargetAttributes = {
 					D62C6D7E1FB564A300E7DF02 = {
 						CreatedOnToolsVersion = 9.1;
+						LastSwiftMigration = 1000;
 						ProvisioningStyle = Automatic;
 					};
 					D62C6D861FB564A300E7DF02 = {
 						CreatedOnToolsVersion = 9.1;
+						LastSwiftMigration = 1000;
 						ProvisioningStyle = Automatic;
 					};
 					D62C6D9A1FB564CF00E7DF02 = {
 						CreatedOnToolsVersion = 9.1;
+						LastSwiftMigration = 1000;
 						ProvisioningStyle = Automatic;
 					};
 					D62C6DA21FB564CF00E7DF02 = {
 						CreatedOnToolsVersion = 9.1;
+						LastSwiftMigration = 1000;
 						ProvisioningStyle = Automatic;
 					};
 					D62C6DB61FB564F700E7DF02 = {
 						CreatedOnToolsVersion = 9.1;
+						LastSwiftMigration = 1000;
 						ProvisioningStyle = Automatic;
 					};
 					D62C6DBE1FB564F700E7DF02 = {
 						CreatedOnToolsVersion = 9.1;
+						LastSwiftMigration = 1000;
 						ProvisioningStyle = Automatic;
 					};
 					D62C6DD21FB5650C00E7DF02 = {
 						CreatedOnToolsVersion = 9.1;
+						LastSwiftMigration = 1000;
 						ProvisioningStyle = Automatic;
 					};
 				};
@@ -750,7 +757,7 @@
 				PRODUCT_BUNDLE_IDENTIFIER = org.koherent.CGPointVector;
 				PRODUCT_NAME = CGPointVector;
 				SKIP_INSTALL = YES;
-				SWIFT_VERSION = 4.0;
+				SWIFT_VERSION = 4.2;
 				TARGETED_DEVICE_FAMILY = "1,2";
 			};
 			name = Debug;
@@ -769,7 +776,7 @@
 				PRODUCT_BUNDLE_IDENTIFIER = org.koherent.CGPointVector;
 				PRODUCT_NAME = CGPointVector;
 				SKIP_INSTALL = YES;
-				SWIFT_VERSION = 4.0;
+				SWIFT_VERSION = 4.2;
 				TARGETED_DEVICE_FAMILY = "1,2";
 			};
 			name = Release;
@@ -783,7 +790,7 @@
 				LD_RUNPATH_SEARCH_PATHS = "$(inherited) @executable_path/Frameworks @loader_path/Frameworks";
 				PRODUCT_BUNDLE_IDENTIFIER = org.koherent.CGPointVectorTests;
 				PRODUCT_NAME = "$(TARGET_NAME)";
-				SWIFT_VERSION = 4.0;
+				SWIFT_VERSION = 4.2;
 				TARGETED_DEVICE_FAMILY = "1,2";
 			};
 			name = Debug;
@@ -797,7 +804,7 @@
 				LD_RUNPATH_SEARCH_PATHS = "$(inherited) @executable_path/Frameworks @loader_path/Frameworks";
 				PRODUCT_BUNDLE_IDENTIFIER = org.koherent.CGPointVectorTests;
 				PRODUCT_NAME = "$(TARGET_NAME)";
-				SWIFT_VERSION = 4.0;
+				SWIFT_VERSION = 4.2;
 				TARGETED_DEVICE_FAMILY = "1,2";
 			};
 			name = Release;
@@ -820,7 +827,7 @@
 				PRODUCT_NAME = CGPointVector;
 				SDKROOT = macosx;
 				SKIP_INSTALL = YES;
-				SWIFT_VERSION = 4.0;
+				SWIFT_VERSION = 4.2;
 			};
 			name = Debug;
 		};
@@ -842,7 +849,7 @@
 				PRODUCT_NAME = CGPointVector;
 				SDKROOT = macosx;
 				SKIP_INSTALL = YES;
-				SWIFT_VERSION = 4.0;
+				SWIFT_VERSION = 4.2;
 			};
 			name = Release;
 		};
@@ -859,7 +866,7 @@
 				PRODUCT_BUNDLE_IDENTIFIER = org.koherent.CGPointVectorTests;
 				PRODUCT_NAME = "$(TARGET_NAME)";
 				SDKROOT = macosx;
-				SWIFT_VERSION = 4.0;
+				SWIFT_VERSION = 4.2;
 			};
 			name = Debug;
 		};
@@ -876,7 +883,7 @@
 				PRODUCT_BUNDLE_IDENTIFIER = org.koherent.CGPointVectorTests;
 				PRODUCT_NAME = "$(TARGET_NAME)";
 				SDKROOT = macosx;
-				SWIFT_VERSION = 4.0;
+				SWIFT_VERSION = 4.2;
 			};
 			name = Release;
 		};
@@ -895,7 +902,7 @@
 				PRODUCT_NAME = CGPointVector;
 				SDKROOT = appletvos;
 				SKIP_INSTALL = YES;
-				SWIFT_VERSION = 4.0;
+				SWIFT_VERSION = 4.2;
 				TARGETED_DEVICE_FAMILY = 3;
 				TVOS_DEPLOYMENT_TARGET = 11.1;
 			};
@@ -916,7 +923,7 @@
 				PRODUCT_NAME = CGPointVector;
 				SDKROOT = appletvos;
 				SKIP_INSTALL = YES;
-				SWIFT_VERSION = 4.0;
+				SWIFT_VERSION = 4.2;
 				TARGETED_DEVICE_FAMILY = 3;
 				TVOS_DEPLOYMENT_TARGET = 11.1;
 			};
@@ -932,7 +939,7 @@
 				PRODUCT_BUNDLE_IDENTIFIER = org.koherent.CGPointVectorTests;
 				PRODUCT_NAME = "$(TARGET_NAME)";
 				SDKROOT = appletvos;
-				SWIFT_VERSION = 4.0;
+				SWIFT_VERSION = 4.2;
 				TARGETED_DEVICE_FAMILY = 3;
 				TVOS_DEPLOYMENT_TARGET = 11.1;
 			};
@@ -948,7 +955,7 @@
 				PRODUCT_BUNDLE_IDENTIFIER = org.koherent.CGPointVectorTests;
 				PRODUCT_NAME = "$(TARGET_NAME)";
 				SDKROOT = appletvos;
-				SWIFT_VERSION = 4.0;
+				SWIFT_VERSION = 4.2;
 				TARGETED_DEVICE_FAMILY = 3;
 				TVOS_DEPLOYMENT_TARGET = 11.1;
 			};
@@ -970,7 +977,7 @@
 				PRODUCT_NAME = CGPointVector;
 				SDKROOT = watchos;
 				SKIP_INSTALL = YES;
-				SWIFT_VERSION = 4.0;
+				SWIFT_VERSION = 4.2;
 				TARGETED_DEVICE_FAMILY = 4;
 				WATCHOS_DEPLOYMENT_TARGET = 4.1;
 			};
@@ -992,7 +999,7 @@
 				PRODUCT_NAME = CGPointVector;
 				SDKROOT = watchos;
 				SKIP_INSTALL = YES;
-				SWIFT_VERSION = 4.0;
+				SWIFT_VERSION = 4.2;
 				TARGETED_DEVICE_FAMILY = 4;
 				WATCHOS_DEPLOYMENT_TARGET = 4.1;
 			};
diff --git a/Sources/CGPointVector/CGAffineTransform.swift b/Sources/CGPointVector/CGAffineTransform.swift
index c9aebef..1c8c0d9 100644
--- a/Sources/CGPointVector/CGAffineTransform.swift
+++ b/Sources/CGPointVector/CGAffineTransform.swift
@@ -2,7 +2,7 @@ import CoreGraphics
 
 extension CGAffineTransform {
     public func isNearlyEqual(to transform: CGAffineTransform, epsilon: CGFloat) -> Bool {
-        return fabs(a - transform.a) < epsilon && fabs(b - transform.b) < epsilon && fabs(c - transform.c) < epsilon && fabs(d - transform.d) < epsilon && fabs(tx - transform.tx) < epsilon && fabs(ty - transform.ty) < epsilon
+        return abs(a - transform.a) < epsilon && abs(b - transform.b) < epsilon && abs(c - transform.c) < epsilon && abs(d - transform.d) < epsilon && abs(tx - transform.tx) < epsilon && abs(ty - transform.ty) < epsilon
     }
 }
 
diff --git a/Sources/CGPointVector/CGPoint.swift b/Sources/CGPointVector/CGPoint.swift
index 28b3c04..4285f28 100644
--- a/Sources/CGPointVector/CGPoint.swift
+++ b/Sources/CGPointVector/CGPoint.swift
@@ -3,7 +3,7 @@ import CoreGraphics
 extension CGPoint {
     public func isNearlyEqual(to point: CGPoint, epsilon: CGFloat) -> Bool {
         let difference = self - point
-        return fabs(difference.x) < epsilon && fabs(difference.y) < epsilon
+        return abs(difference.x) < epsilon && abs(difference.y) < epsilon
     }
     
     public var length: CGFloat {
diff --git a/Sources/CGPointVector/CGRect.swift b/Sources/CGPointVector/CGRect.swift
index cbdcd40..6f018e0 100644
--- a/Sources/CGPointVector/CGRect.swift
+++ b/Sources/CGPointVector/CGRect.swift
@@ -4,8 +4,8 @@ extension CGRect {
     public func isNearlyEqual(to rect: CGRect, epsilon: CGFloat) -> Bool {
         let difference1 = self.origin - rect.origin
         let difference2 = (self.origin + self.size) - (rect.origin + rect.size)
-        return fabs(difference1.x) < epsilon && fabs(difference1.y) < epsilon
-            && fabs(difference2.x) < epsilon && fabs(difference2.y) < epsilon
+        return abs(difference1.x) < epsilon && abs(difference1.y) < epsilon
+            && abs(difference2.x) < epsilon && abs(difference2.y) < epsilon
     }
     
     public var center: CGPoint {
diff --git a/Sources/CGPointVector/CGSize.swift b/Sources/CGPointVector/CGSize.swift
index 87b60f5..3bb0749 100644
--- a/Sources/CGPointVector/CGSize.swift
+++ b/Sources/CGPointVector/CGSize.swift
@@ -3,7 +3,7 @@ import CoreGraphics
 extension CGSize {
     public func isNearlyEqual(to point: CGSize, epsilon: CGFloat) -> Bool {
         let difference = self - point
-        return fabs(difference.width) < epsilon && fabs(difference.height) < epsilon
+        return abs(difference.width) < epsilon && abs(difference.height) < epsilon
     }
     
     public var length: CGFloat {
diff --git a/Sources/CGPointVector/CGVector.swift b/Sources/CGPointVector/CGVector.swift
index d5fdaab..88bfc05 100644
--- a/Sources/CGPointVector/CGVector.swift
+++ b/Sources/CGPointVector/CGVector.swift
@@ -3,7 +3,7 @@ import CoreGraphics
 extension CGVector {
     public func isNearlyEqual(to point: CGVector, epsilon: CGFloat) -> Bool {
         let difference = self - point
-        return fabs(difference.dx) < epsilon && fabs(difference.dy) < epsilon
+        return abs(difference.dx) < epsilon && abs(difference.dy) < epsilon
     }
     
     public var length: CGFloat {

From 2c8751f336193c89c6480b6ef90ff65a09fc9f1a Mon Sep 17 00:00:00 2001
From: Yuta Koshizawa <koher@koherent.org>
Date: Fri, 28 Sep 2018 11:41:40 +0900
Subject: [PATCH 14/20] Update the project settings for Xcode 10

---
 CGPointVector.xcodeproj/project.pbxproj                | 10 +++++++++-
 .../xcshareddata/xcschemes/CGPointVector-iOS.xcscheme  |  4 +---
 .../xcschemes/CGPointVector-macOS.xcscheme             |  4 +---
 .../xcshareddata/xcschemes/CGPointVector-tvOS.xcscheme |  4 +---
 .../xcschemes/CGPointVector-watchOS.xcscheme           |  4 +---
 5 files changed, 13 insertions(+), 13 deletions(-)

diff --git a/CGPointVector.xcodeproj/project.pbxproj b/CGPointVector.xcodeproj/project.pbxproj
index 73e09a9..388dd0f 100644
--- a/CGPointVector.xcodeproj/project.pbxproj
+++ b/CGPointVector.xcodeproj/project.pbxproj
@@ -402,7 +402,7 @@
 			isa = PBXProject;
 			attributes = {
 				LastSwiftUpdateCheck = 0910;
-				LastUpgradeCheck = 0910;
+				LastUpgradeCheck = 1000;
 				ORGANIZATIONNAME = koherent.org;
 				TargetAttributes = {
 					D62C6D7E1FB564A300E7DF02 = {
@@ -644,6 +644,7 @@
 				CLANG_WARN_BOOL_CONVERSION = YES;
 				CLANG_WARN_COMMA = YES;
 				CLANG_WARN_CONSTANT_CONVERSION = YES;
+				CLANG_WARN_DEPRECATED_OBJC_IMPLEMENTATIONS = YES;
 				CLANG_WARN_DIRECT_OBJC_ISA_USAGE = YES_ERROR;
 				CLANG_WARN_DOCUMENTATION_COMMENTS = YES;
 				CLANG_WARN_EMPTY_BODY = YES;
@@ -651,6 +652,7 @@
 				CLANG_WARN_INFINITE_RECURSION = YES;
 				CLANG_WARN_INT_CONVERSION = YES;
 				CLANG_WARN_NON_LITERAL_NULL_CONVERSION = YES;
+				CLANG_WARN_OBJC_IMPLICIT_RETAIN_SELF = YES;
 				CLANG_WARN_OBJC_LITERAL_CONVERSION = YES;
 				CLANG_WARN_OBJC_ROOT_CLASS = YES_ERROR;
 				CLANG_WARN_RANGE_LOOP_ANALYSIS = YES;
@@ -704,6 +706,7 @@
 				CLANG_WARN_BOOL_CONVERSION = YES;
 				CLANG_WARN_COMMA = YES;
 				CLANG_WARN_CONSTANT_CONVERSION = YES;
+				CLANG_WARN_DEPRECATED_OBJC_IMPLEMENTATIONS = YES;
 				CLANG_WARN_DIRECT_OBJC_ISA_USAGE = YES_ERROR;
 				CLANG_WARN_DOCUMENTATION_COMMENTS = YES;
 				CLANG_WARN_EMPTY_BODY = YES;
@@ -711,6 +714,7 @@
 				CLANG_WARN_INFINITE_RECURSION = YES;
 				CLANG_WARN_INT_CONVERSION = YES;
 				CLANG_WARN_NON_LITERAL_NULL_CONVERSION = YES;
+				CLANG_WARN_OBJC_IMPLICIT_RETAIN_SELF = YES;
 				CLANG_WARN_OBJC_LITERAL_CONVERSION = YES;
 				CLANG_WARN_OBJC_ROOT_CLASS = YES_ERROR;
 				CLANG_WARN_RANGE_LOOP_ANALYSIS = YES;
@@ -890,6 +894,7 @@
 		D62C6DC91FB564F700E7DF02 /* Debug */ = {
 			isa = XCBuildConfiguration;
 			buildSettings = {
+				CODE_SIGN_IDENTITY = "";
 				CODE_SIGN_STYLE = Automatic;
 				DEFINES_MODULE = YES;
 				DYLIB_COMPATIBILITY_VERSION = 1;
@@ -911,6 +916,7 @@
 		D62C6DCA1FB564F700E7DF02 /* Release */ = {
 			isa = XCBuildConfiguration;
 			buildSettings = {
+				CODE_SIGN_IDENTITY = "";
 				CODE_SIGN_STYLE = Automatic;
 				DEFINES_MODULE = YES;
 				DYLIB_COMPATIBILITY_VERSION = 1;
@@ -965,6 +971,7 @@
 			isa = XCBuildConfiguration;
 			buildSettings = {
 				APPLICATION_EXTENSION_API_ONLY = YES;
+				CODE_SIGN_IDENTITY = "";
 				CODE_SIGN_STYLE = Automatic;
 				DEFINES_MODULE = YES;
 				DYLIB_COMPATIBILITY_VERSION = 1;
@@ -987,6 +994,7 @@
 			isa = XCBuildConfiguration;
 			buildSettings = {
 				APPLICATION_EXTENSION_API_ONLY = YES;
+				CODE_SIGN_IDENTITY = "";
 				CODE_SIGN_STYLE = Automatic;
 				DEFINES_MODULE = YES;
 				DYLIB_COMPATIBILITY_VERSION = 1;
diff --git a/CGPointVector.xcodeproj/xcshareddata/xcschemes/CGPointVector-iOS.xcscheme b/CGPointVector.xcodeproj/xcshareddata/xcschemes/CGPointVector-iOS.xcscheme
index 6a9f108..18bc350 100644
--- a/CGPointVector.xcodeproj/xcshareddata/xcschemes/CGPointVector-iOS.xcscheme
+++ b/CGPointVector.xcodeproj/xcshareddata/xcschemes/CGPointVector-iOS.xcscheme
@@ -1,6 +1,6 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <Scheme
-   LastUpgradeVersion = "0910"
+   LastUpgradeVersion = "1000"
    version = "1.3">
    <BuildAction
       parallelizeBuildables = "YES"
@@ -26,7 +26,6 @@
       buildConfiguration = "Debug"
       selectedDebuggerIdentifier = "Xcode.DebuggerFoundation.Debugger.LLDB"
       selectedLauncherIdentifier = "Xcode.DebuggerFoundation.Launcher.LLDB"
-      language = ""
       shouldUseLaunchSchemeArgsEnv = "YES">
       <Testables>
          <TestableReference
@@ -56,7 +55,6 @@
       buildConfiguration = "Debug"
       selectedDebuggerIdentifier = "Xcode.DebuggerFoundation.Debugger.LLDB"
       selectedLauncherIdentifier = "Xcode.DebuggerFoundation.Launcher.LLDB"
-      language = ""
       launchStyle = "0"
       useCustomWorkingDirectory = "NO"
       ignoresPersistentStateOnLaunch = "NO"
diff --git a/CGPointVector.xcodeproj/xcshareddata/xcschemes/CGPointVector-macOS.xcscheme b/CGPointVector.xcodeproj/xcshareddata/xcschemes/CGPointVector-macOS.xcscheme
index 6e2a56e..b21fd3a 100644
--- a/CGPointVector.xcodeproj/xcshareddata/xcschemes/CGPointVector-macOS.xcscheme
+++ b/CGPointVector.xcodeproj/xcshareddata/xcschemes/CGPointVector-macOS.xcscheme
@@ -1,6 +1,6 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <Scheme
-   LastUpgradeVersion = "0910"
+   LastUpgradeVersion = "1000"
    version = "1.3">
    <BuildAction
       parallelizeBuildables = "YES"
@@ -26,7 +26,6 @@
       buildConfiguration = "Debug"
       selectedDebuggerIdentifier = "Xcode.DebuggerFoundation.Debugger.LLDB"
       selectedLauncherIdentifier = "Xcode.DebuggerFoundation.Launcher.LLDB"
-      language = ""
       shouldUseLaunchSchemeArgsEnv = "YES">
       <Testables>
          <TestableReference
@@ -56,7 +55,6 @@
       buildConfiguration = "Debug"
       selectedDebuggerIdentifier = "Xcode.DebuggerFoundation.Debugger.LLDB"
       selectedLauncherIdentifier = "Xcode.DebuggerFoundation.Launcher.LLDB"
-      language = ""
       launchStyle = "0"
       useCustomWorkingDirectory = "NO"
       ignoresPersistentStateOnLaunch = "NO"
diff --git a/CGPointVector.xcodeproj/xcshareddata/xcschemes/CGPointVector-tvOS.xcscheme b/CGPointVector.xcodeproj/xcshareddata/xcschemes/CGPointVector-tvOS.xcscheme
index a785c1f..4413f03 100644
--- a/CGPointVector.xcodeproj/xcshareddata/xcschemes/CGPointVector-tvOS.xcscheme
+++ b/CGPointVector.xcodeproj/xcshareddata/xcschemes/CGPointVector-tvOS.xcscheme
@@ -1,6 +1,6 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <Scheme
-   LastUpgradeVersion = "0910"
+   LastUpgradeVersion = "1000"
    version = "1.3">
    <BuildAction
       parallelizeBuildables = "YES"
@@ -26,7 +26,6 @@
       buildConfiguration = "Debug"
       selectedDebuggerIdentifier = "Xcode.DebuggerFoundation.Debugger.LLDB"
       selectedLauncherIdentifier = "Xcode.DebuggerFoundation.Launcher.LLDB"
-      language = ""
       shouldUseLaunchSchemeArgsEnv = "YES">
       <Testables>
          <TestableReference
@@ -56,7 +55,6 @@
       buildConfiguration = "Debug"
       selectedDebuggerIdentifier = "Xcode.DebuggerFoundation.Debugger.LLDB"
       selectedLauncherIdentifier = "Xcode.DebuggerFoundation.Launcher.LLDB"
-      language = ""
       launchStyle = "0"
       useCustomWorkingDirectory = "NO"
       ignoresPersistentStateOnLaunch = "NO"
diff --git a/CGPointVector.xcodeproj/xcshareddata/xcschemes/CGPointVector-watchOS.xcscheme b/CGPointVector.xcodeproj/xcshareddata/xcschemes/CGPointVector-watchOS.xcscheme
index ec083c3..05bb65b 100644
--- a/CGPointVector.xcodeproj/xcshareddata/xcschemes/CGPointVector-watchOS.xcscheme
+++ b/CGPointVector.xcodeproj/xcshareddata/xcschemes/CGPointVector-watchOS.xcscheme
@@ -1,6 +1,6 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <Scheme
-   LastUpgradeVersion = "0910"
+   LastUpgradeVersion = "1000"
    version = "1.3">
    <BuildAction
       parallelizeBuildables = "YES"
@@ -26,7 +26,6 @@
       buildConfiguration = "Debug"
       selectedDebuggerIdentifier = "Xcode.DebuggerFoundation.Debugger.LLDB"
       selectedLauncherIdentifier = "Xcode.DebuggerFoundation.Launcher.LLDB"
-      language = ""
       shouldUseLaunchSchemeArgsEnv = "YES">
       <Testables>
       </Testables>
@@ -37,7 +36,6 @@
       buildConfiguration = "Debug"
       selectedDebuggerIdentifier = "Xcode.DebuggerFoundation.Debugger.LLDB"
       selectedLauncherIdentifier = "Xcode.DebuggerFoundation.Launcher.LLDB"
-      language = ""
       launchStyle = "0"
       useCustomWorkingDirectory = "NO"
       ignoresPersistentStateOnLaunch = "NO"

From c904164f89605d2dc4401a6cb6734ec2bf78abe4 Mon Sep 17 00:00:00 2001
From: Yuta Koshizawa <koher@koherent.org>
Date: Fri, 28 Sep 2018 11:46:59 +0900
Subject: [PATCH 15/20] Update the settings of Travis CI

---
 .travis.yml | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/.travis.yml b/.travis.yml
index f0046fc..6b81e2b 100644
--- a/.travis.yml
+++ b/.travis.yml
@@ -2,16 +2,16 @@ matrix:
   include:
     - os: osx
       language: objective-c
-      osx_image: xcode9.2
+      osx_image: xcode10
       script:
         - set -o pipefail
         - xcodebuild test -scheme CGPointVector-macOS -configuration Debug | xcpretty -c
-        - xcodebuild test -scheme CGPointVector-iOS -configuration Debug -sdk iphonesimulator -destination "platform=iOS Simulator,name=iPhone X" | xcpretty -c
+        - xcodebuild test -scheme CGPointVector-iOS -configuration Debug -sdk iphonesimulator -destination "platform=iOS Simulator,name=iPhone XS" | xcpretty -c
         - xcodebuild test -scheme CGPointVector-tvOS -configuration Debug -sdk appletvsimulator -destination "platform=tvOS Simulator,name=Apple TV 4K" | xcpretty -c
-        - xcodebuild build -scheme CGPointVector-watchOS -configuration Debug -sdk watchsimulator -destination "platform=watchOS Simulator,name=Apple Watch Series 3 - 38mm" | xcpretty -c
+        - xcodebuild build -scheme CGPointVector-watchOS -configuration Debug -sdk watchsimulator -destination "platform=watchOS Simulator,name=Apple Watch Series 4 - 44mm" | xcpretty -c
     - os: osx
       language: generic
-      osx_image: xcode9.2
+      osx_image: xcode10
       script:
         - swift --version
         - swift build

From 9a28a6dbecff2397efc40ea932b758e10010e53e Mon Sep 17 00:00:00 2001
From: Yuta Koshizawa <koher@koherent.org>
Date: Fri, 28 Sep 2018 12:01:47 +0900
Subject: [PATCH 16/20] =?UTF-8?q?Revert=20`=E2=8A=97`=20to=20`*`?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

`*` was once changed to `⊗` because Swift for TensorFlow used `⊗`. After that, however, Swift for TensorFlow quitted to use `⊗`. Although Swift for TensorFlow still avoids to use `*` for matmul, CGPointVector reverted `⊗` to `*` temporarily because of the following reasons:

1. CGPointVector had used `*` for matmul until 0.2.0 and `*` is familiar to users
2. APIs of Swift for TensorFlow are unstable and it is inappropriate to follow them for the moment
3. simd uses `*` for matmul
---
 CGPointVector.xcodeproj/project.pbxproj               | 10 ----------
 Sources/CGPointVector/CGAffineTransform.swift         |  8 ++++----
 Sources/CGPointVector/CGPoint.swift                   |  6 +++---
 Sources/CGPointVector/CGRect.swift                    |  6 +++---
 Sources/CGPointVector/CGSize.swift                    |  6 +++---
 Sources/CGPointVector/CGVector.swift                  |  6 +++---
 Sources/CGPointVector/Operators.swift                 |  2 --
 Tests/CGPointVectorTests/CGAffineTransformTests.swift |  8 ++++----
 Tests/CGPointVectorTests/CGPointTests.swift           |  4 ++--
 Tests/CGPointVectorTests/CGPointVectorTests.swift     |  2 +-
 Tests/CGPointVectorTests/CGRectTests.swift            |  4 ++--
 Tests/CGPointVectorTests/CGSizeTests.swift            |  4 ++--
 Tests/CGPointVectorTests/CGVectorTests.swift          |  4 ++--
 13 files changed, 29 insertions(+), 41 deletions(-)
 delete mode 100644 Sources/CGPointVector/Operators.swift

diff --git a/CGPointVector.xcodeproj/project.pbxproj b/CGPointVector.xcodeproj/project.pbxproj
index 388dd0f..b9e335c 100644
--- a/CGPointVector.xcodeproj/project.pbxproj
+++ b/CGPointVector.xcodeproj/project.pbxproj
@@ -45,10 +45,6 @@
 		D62C6E0C1FB5658C00E7DF02 /* CGPointVectorTests.swift in Sources */ = {isa = PBXBuildFile; fileRef = D62C6DDF1FB5657000E7DF02 /* CGPointVectorTests.swift */; };
 		D62C6E0D1FB5658C00E7DF02 /* CGRectTests.swift in Sources */ = {isa = PBXBuildFile; fileRef = D62C6DE01FB5657000E7DF02 /* CGRectTests.swift */; };
 		D62C6E0E1FB5658C00E7DF02 /* CGSizeTests.swift in Sources */ = {isa = PBXBuildFile; fileRef = D62C6DE11FB5657000E7DF02 /* CGSizeTests.swift */; };
-		D63F165820DB574100F8B479 /* Operators.swift in Sources */ = {isa = PBXBuildFile; fileRef = D63F165720DB574100F8B479 /* Operators.swift */; };
-		D63F165920DB574100F8B479 /* Operators.swift in Sources */ = {isa = PBXBuildFile; fileRef = D63F165720DB574100F8B479 /* Operators.swift */; };
-		D63F165A20DB574100F8B479 /* Operators.swift in Sources */ = {isa = PBXBuildFile; fileRef = D63F165720DB574100F8B479 /* Operators.swift */; };
-		D63F165B20DB574100F8B479 /* Operators.swift in Sources */ = {isa = PBXBuildFile; fileRef = D63F165720DB574100F8B479 /* Operators.swift */; };
 		D63F165D20DB641300F8B479 /* CGVector.swift in Sources */ = {isa = PBXBuildFile; fileRef = D63F165C20DB641300F8B479 /* CGVector.swift */; };
 		D63F165E20DB641300F8B479 /* CGVector.swift in Sources */ = {isa = PBXBuildFile; fileRef = D63F165C20DB641300F8B479 /* CGVector.swift */; };
 		D63F165F20DB641300F8B479 /* CGVector.swift in Sources */ = {isa = PBXBuildFile; fileRef = D63F165C20DB641300F8B479 /* CGVector.swift */; };
@@ -102,7 +98,6 @@
 		D62C6DE91FB5657000E7DF02 /* CGRect.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = CGRect.swift; sourceTree = "<group>"; };
 		D62C6DEA1FB5657000E7DF02 /* CGSize.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = CGSize.swift; sourceTree = "<group>"; };
 		D62C6DEB1FB5657000E7DF02 /* Info.plist */ = {isa = PBXFileReference; lastKnownFileType = text.plist.xml; path = Info.plist; sourceTree = "<group>"; };
-		D63F165720DB574100F8B479 /* Operators.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = Operators.swift; sourceTree = "<group>"; };
 		D63F165C20DB641300F8B479 /* CGVector.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = CGVector.swift; sourceTree = "<group>"; };
 		D63F166120DB64CE00F8B479 /* CGVectorTests.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = CGVectorTests.swift; sourceTree = "<group>"; };
 /* End PBXFileReference section */
@@ -226,7 +221,6 @@
 				D62C6DEA1FB5657000E7DF02 /* CGSize.swift */,
 				D63F165C20DB641300F8B479 /* CGVector.swift */,
 				D62C6DEB1FB5657000E7DF02 /* Info.plist */,
-				D63F165720DB574100F8B479 /* Operators.swift */,
 			);
 			path = CGPointVector;
 			sourceTree = "<group>";
@@ -523,7 +517,6 @@
 			buildActionMask = 2147483647;
 			files = (
 				D62C6DF01FB5657900E7DF02 /* CGSize.swift in Sources */,
-				D63F165820DB574100F8B479 /* Operators.swift in Sources */,
 				D63F165D20DB641300F8B479 /* CGVector.swift in Sources */,
 				D62C6DED1FB5657900E7DF02 /* CGPoint.swift in Sources */,
 				D62C6DEF1FB5657900E7DF02 /* CGRect.swift in Sources */,
@@ -549,7 +542,6 @@
 			buildActionMask = 2147483647;
 			files = (
 				D62C6DF51FB5657A00E7DF02 /* CGSize.swift in Sources */,
-				D63F165920DB574100F8B479 /* Operators.swift in Sources */,
 				D63F165E20DB641300F8B479 /* CGVector.swift in Sources */,
 				D62C6DF21FB5657A00E7DF02 /* CGPoint.swift in Sources */,
 				D62C6DF41FB5657A00E7DF02 /* CGRect.swift in Sources */,
@@ -575,7 +567,6 @@
 			buildActionMask = 2147483647;
 			files = (
 				D62C6DFA1FB5657A00E7DF02 /* CGSize.swift in Sources */,
-				D63F165A20DB574100F8B479 /* Operators.swift in Sources */,
 				D63F165F20DB641300F8B479 /* CGVector.swift in Sources */,
 				D62C6DF71FB5657A00E7DF02 /* CGPoint.swift in Sources */,
 				D62C6DF91FB5657A00E7DF02 /* CGRect.swift in Sources */,
@@ -601,7 +592,6 @@
 			buildActionMask = 2147483647;
 			files = (
 				D62C6DFF1FB5657B00E7DF02 /* CGSize.swift in Sources */,
-				D63F165B20DB574100F8B479 /* Operators.swift in Sources */,
 				D63F166020DB641300F8B479 /* CGVector.swift in Sources */,
 				D62C6DFC1FB5657B00E7DF02 /* CGPoint.swift in Sources */,
 				D62C6DFE1FB5657B00E7DF02 /* CGRect.swift in Sources */,
diff --git a/Sources/CGPointVector/CGAffineTransform.swift b/Sources/CGPointVector/CGAffineTransform.swift
index 1c8c0d9..46a8b97 100644
--- a/Sources/CGPointVector/CGAffineTransform.swift
+++ b/Sources/CGPointVector/CGAffineTransform.swift
@@ -13,15 +13,15 @@ extension CGAffineTransform: CustomStringConvertible {
 }
 
 extension CGAffineTransform {
-    public static func ⊗ (lhs: CGAffineTransform, rhs: CGAffineTransform) -> CGAffineTransform {
+    public static func * (lhs: CGAffineTransform, rhs: CGAffineTransform) -> CGAffineTransform {
         return lhs.concatenating(rhs)
     }
     
-    public static func ⊗= (lhs: inout CGAffineTransform, rhs: CGAffineTransform) {
-        lhs = lhs ⊗ rhs
+    public static func *= (lhs: inout CGAffineTransform, rhs: CGAffineTransform) {
+        lhs = lhs * rhs
     }
     
-    public static func ⊗ (lhs: CGAffineTransform, rhs: CGPoint) -> CGPoint {
+    public static func * (lhs: CGAffineTransform, rhs: CGPoint) -> CGPoint {
         return rhs.applying(lhs)
     }
 }
diff --git a/Sources/CGPointVector/CGPoint.swift b/Sources/CGPointVector/CGPoint.swift
index 4285f28..dbe306a 100644
--- a/Sources/CGPointVector/CGPoint.swift
+++ b/Sources/CGPointVector/CGPoint.swift
@@ -86,7 +86,7 @@ extension CGPoint {
         return CGPoint(x: lhs.x / rhs, y: lhs.y / rhs)
     }
     
-    public static func ⊗ (lhs: CGPoint, rhs: CGAffineTransform) -> CGPoint {
+    public static func * (lhs: CGPoint, rhs: CGAffineTransform) -> CGPoint {
         return lhs.applying(rhs)
     }
     
@@ -114,8 +114,8 @@ extension CGPoint {
         lhs = lhs / rhs
     }
     
-    public static func ⊗= (lhs: inout CGPoint, rhs: CGAffineTransform) {
-        lhs = lhs ⊗ rhs
+    public static func *= (lhs: inout CGPoint, rhs: CGAffineTransform) {
+        lhs = lhs * rhs
     }
 }
 
diff --git a/Sources/CGPointVector/CGRect.swift b/Sources/CGPointVector/CGRect.swift
index 6f018e0..c08951c 100644
--- a/Sources/CGPointVector/CGRect.swift
+++ b/Sources/CGPointVector/CGRect.swift
@@ -20,11 +20,11 @@ extension CGRect: CustomStringConvertible {
 }
 
 extension CGRect {
-    public static func ⊗ (lhs: CGRect, rhs: CGAffineTransform) -> CGRect {
+    public static func * (lhs: CGRect, rhs: CGAffineTransform) -> CGRect {
         return lhs.applying(rhs)
     }
     
-    public static func ⊗= (lhs: inout CGRect, rhs: CGAffineTransform) {
-        lhs = lhs ⊗ rhs
+    public static func *= (lhs: inout CGRect, rhs: CGAffineTransform) {
+        lhs = lhs * rhs
     }
 }
diff --git a/Sources/CGPointVector/CGSize.swift b/Sources/CGPointVector/CGSize.swift
index 3bb0749..39d5368 100644
--- a/Sources/CGPointVector/CGSize.swift
+++ b/Sources/CGPointVector/CGSize.swift
@@ -86,7 +86,7 @@ extension CGSize {
         return CGSize(width: lhs.width / rhs, height: lhs.height / rhs)
     }
     
-    public static func ⊗ (lhs: CGSize, rhs: CGAffineTransform) -> CGSize {
+    public static func * (lhs: CGSize, rhs: CGAffineTransform) -> CGSize {
         return lhs.applying(rhs)
     }
     
@@ -114,8 +114,8 @@ extension CGSize {
         lhs = lhs / rhs
     }
     
-    public static func ⊗= (lhs: inout CGSize, rhs: CGAffineTransform) {
-        lhs = lhs ⊗ rhs
+    public static func *= (lhs: inout CGSize, rhs: CGAffineTransform) {
+        lhs = lhs * rhs
     }
 }
 
diff --git a/Sources/CGPointVector/CGVector.swift b/Sources/CGPointVector/CGVector.swift
index 88bfc05..c7ad0d4 100644
--- a/Sources/CGPointVector/CGVector.swift
+++ b/Sources/CGPointVector/CGVector.swift
@@ -86,7 +86,7 @@ extension CGVector {
         return CGVector(dx: lhs.dx / rhs, dy: lhs.dy / rhs)
     }
     
-    public static func ⊗ (lhs: CGVector, rhs: CGAffineTransform) -> CGVector {
+    public static func * (lhs: CGVector, rhs: CGAffineTransform) -> CGVector {
         let point = CGPoint(x: lhs.dx, y: lhs.dy).applying(rhs)
         return CGVector(dx: point.x, dy: point.y)
     }
@@ -115,8 +115,8 @@ extension CGVector {
         lhs = lhs / rhs
     }
     
-    public static func ⊗= (lhs: inout CGVector, rhs: CGAffineTransform) {
-        lhs = lhs ⊗ rhs
+    public static func *= (lhs: inout CGVector, rhs: CGAffineTransform) {
+        lhs = lhs * rhs
     }
 }
 
diff --git a/Sources/CGPointVector/Operators.swift b/Sources/CGPointVector/Operators.swift
deleted file mode 100644
index d237293..0000000
--- a/Sources/CGPointVector/Operators.swift
+++ /dev/null
@@ -1,2 +0,0 @@
-infix operator ⊗ : MultiplicationPrecedence
-infix operator ⊗= : AssignmentPrecedence
diff --git a/Tests/CGPointVectorTests/CGAffineTransformTests.swift b/Tests/CGPointVectorTests/CGAffineTransformTests.swift
index 961cbb0..d95f806 100644
--- a/Tests/CGPointVectorTests/CGAffineTransformTests.swift
+++ b/Tests/CGPointVectorTests/CGAffineTransformTests.swift
@@ -65,19 +65,19 @@ class CGAffineTransormTests: XCTestCase {
     }
     
     func testMatmul() {
-        XCTAssertTrue((CGAffineTransform(a: 1, b: 2, c: 3, d: 4, tx: 5, ty: 6) ⊗ CGAffineTransform(a: 6, b: 5, c: 4, d: 3, tx: 2, ty: 1))
+        XCTAssertTrue((CGAffineTransform(a: 1, b: 2, c: 3, d: 4, tx: 5, ty: 6) * CGAffineTransform(a: 6, b: 5, c: 4, d: 3, tx: 2, ty: 1))
             .isNearlyEqual(to: CGAffineTransform(a: 14, b: 11, c: 34, d: 27, tx: 56, ty: 44), epsilon: torelance))
-        XCTAssertTrue((CGAffineTransform(translationX: 1.0, y: -2.0) ⊗ CGPoint(x: 1.0, y: 1.0))
+        XCTAssertTrue((CGAffineTransform(translationX: 1.0, y: -2.0) * CGPoint(x: 1.0, y: 1.0))
             .isNearlyEqual(to: CGPoint(x: 2.0, y: -1.0), epsilon: torelance))
     }
     
     func testMatmulAssignment() {
         var a = CGAffineTransform(a: 1, b: 2, c: 3, d: 4, tx: 5, ty: 6)
-        a ⊗= CGAffineTransform(a: 6, b: 5, c: 4, d: 3, tx: 2, ty: 1)
+        a *= CGAffineTransform(a: 6, b: 5, c: 4, d: 3, tx: 2, ty: 1)
         print(a)
         
         XCTAssertTrue(a.isNearlyEqual(to: CGAffineTransform(a: 1, b: 2, c: 3, d: 4, tx: 5, ty: 6)
-            ⊗ CGAffineTransform(a: 6, b: 5, c: 4, d: 3, tx: 2, ty: 1), epsilon: torelance))
+            * CGAffineTransform(a: 6, b: 5, c: 4, d: 3, tx: 2, ty: 1), epsilon: torelance))
     }
     
     static var allTests : [(String, (CGAffineTransormTests) -> () throws -> Void)] {
diff --git a/Tests/CGPointVectorTests/CGPointTests.swift b/Tests/CGPointVectorTests/CGPointTests.swift
index adb29e8..ccf7b91 100644
--- a/Tests/CGPointVectorTests/CGPointTests.swift
+++ b/Tests/CGPointVectorTests/CGPointTests.swift
@@ -88,7 +88,7 @@ class CGPointTests: XCTestCase {
     }
     
     func testMatmul() {
-        XCTAssertTrue((CGPoint(x: 1.0, y: 1.0) ⊗ CGAffineTransform(rotationAngle: CGFloat.pi / 4))
+        XCTAssertTrue((CGPoint(x: 1.0, y: 1.0) * CGAffineTransform(rotationAngle: CGFloat.pi / 4))
             .isNearlyEqual(to: CGPoint(x: 0.0, y: sqrt(2)), epsilon: torelance))
     }
     
@@ -120,7 +120,7 @@ class CGPointTests: XCTestCase {
     
     func testMatmulAssignment() {
         var a = CGPoint(x: 1.0, y: 1.0)
-        a ⊗= CGAffineTransform(rotationAngle: CGFloat.pi / 4)
+        a *= CGAffineTransform(rotationAngle: CGFloat.pi / 4)
         XCTAssertTrue(a.isNearlyEqual(to: CGPoint(x: 0.0, y: sqrt(2)), epsilon: torelance))
     }
     
diff --git a/Tests/CGPointVectorTests/CGPointVectorTests.swift b/Tests/CGPointVectorTests/CGPointVectorTests.swift
index be9e05c..e8118f3 100644
--- a/Tests/CGPointVectorTests/CGPointVectorTests.swift
+++ b/Tests/CGPointVectorTests/CGPointVectorTests.swift
@@ -10,7 +10,7 @@ class CGPointVectorTests: XCTestCase {
         let sum = a + b // (-2.0, 7.0)
         let distance = (b - a).length // 5.0
         let direction = (b - a).unit // (-0.8, 0.6)
-        let rotated = a ⊗ CGAffineTransform(rotationAngle: CGFloat.pi / 2) // (-2.0, 1.0)
+        let rotated = a * CGAffineTransform(rotationAngle: CGFloat.pi / 2) // (-2.0, 1.0)
 
         /**/ XCTAssertTrue(sum.isNearlyEqual(to: CGPoint(x: -2.0, y: 7.0), epsilon: torelance))
         /**/ XCTAssertEqual(distance, 5.0, accuracy: torelance)
diff --git a/Tests/CGPointVectorTests/CGRectTests.swift b/Tests/CGPointVectorTests/CGRectTests.swift
index f2c75d0..006c92d 100644
--- a/Tests/CGPointVectorTests/CGRectTests.swift
+++ b/Tests/CGPointVectorTests/CGRectTests.swift
@@ -36,8 +36,8 @@ class CGRectTests: XCTestCase {
     }
     
     func testMatmul() {
-        print(CGRect(x: 1.0, y: 2.0, width: 3.0, height: 4.0) ⊗ CGAffineTransform(a: 0, b: 1, c: -1, d: 0, tx: 0, ty: 0))
-        XCTAssertTrue((CGRect(x: 1.0, y: 2.0, width: 3.0, height: 4.0) ⊗ CGAffineTransform(a: 0, b: 1, c: -1, d: 0, tx: 0, ty: 0))
+        print(CGRect(x: 1.0, y: 2.0, width: 3.0, height: 4.0) * CGAffineTransform(a: 0, b: 1, c: -1, d: 0, tx: 0, ty: 0))
+        XCTAssertTrue((CGRect(x: 1.0, y: 2.0, width: 3.0, height: 4.0) * CGAffineTransform(a: 0, b: 1, c: -1, d: 0, tx: 0, ty: 0))
             .isNearlyEqual(to: CGRect(x: -6.0, y: 1.0, width: 4.0, height: 3.0), epsilon: torelance))
     }
     
diff --git a/Tests/CGPointVectorTests/CGSizeTests.swift b/Tests/CGPointVectorTests/CGSizeTests.swift
index 5511aab..2f5fc3f 100644
--- a/Tests/CGPointVectorTests/CGSizeTests.swift
+++ b/Tests/CGPointVectorTests/CGSizeTests.swift
@@ -88,7 +88,7 @@ class CGSizeTests: XCTestCase {
     }
     
     func testMatmul() {
-        XCTAssertTrue((CGSize(width: 1.0, height: 1.0) ⊗ CGAffineTransform(rotationAngle: CGFloat.pi / 4))
+        XCTAssertTrue((CGSize(width: 1.0, height: 1.0) * CGAffineTransform(rotationAngle: CGFloat.pi / 4))
             .isNearlyEqual(to: CGSize(width: 0.0, height: sqrt(2)), epsilon: torelance))
     }
     
@@ -120,7 +120,7 @@ class CGSizeTests: XCTestCase {
     
     func testMatmulAssignment() {
         var a = CGSize(width: 1.0, height: 1.0)
-        a ⊗= CGAffineTransform(rotationAngle: CGFloat.pi / 4)
+        a *= CGAffineTransform(rotationAngle: CGFloat.pi / 4)
         XCTAssertTrue(a.isNearlyEqual(to: CGSize(width: 0.0, height: sqrt(2)), epsilon: torelance))
     }
     
diff --git a/Tests/CGPointVectorTests/CGVectorTests.swift b/Tests/CGPointVectorTests/CGVectorTests.swift
index 399d948..1cd304d 100644
--- a/Tests/CGPointVectorTests/CGVectorTests.swift
+++ b/Tests/CGPointVectorTests/CGVectorTests.swift
@@ -88,7 +88,7 @@ class CGVectorTests: XCTestCase {
     }
     
     func testMatmul() {
-        XCTAssertTrue((CGVector(dx: 1.0, dy: 1.0) ⊗ CGAffineTransform(rotationAngle: CGFloat.pi / 4))
+        XCTAssertTrue((CGVector(dx: 1.0, dy: 1.0) * CGAffineTransform(rotationAngle: CGFloat.pi / 4))
             .isNearlyEqual(to: CGVector(dx: 0.0, dy: sqrt(2)), epsilon: torelance))
     }
     
@@ -120,7 +120,7 @@ class CGVectorTests: XCTestCase {
     
     func testMatmulAssignment() {
         var a = CGVector(dx: 1.0, dy: 1.0)
-        a ⊗= CGAffineTransform(rotationAngle: CGFloat.pi / 4)
+        a *= CGAffineTransform(rotationAngle: CGFloat.pi / 4)
         XCTAssertTrue(a.isNearlyEqual(to: CGVector(dx: 0.0, dy: sqrt(2)), epsilon: torelance))
     }
     

From 13d84cf4fd4869795830a568fde1980c2f97ee5a Mon Sep 17 00:00:00 2001
From: Yuta Koshizawa <koher@koherent.org>
Date: Fri, 28 Sep 2018 12:24:09 +0900
Subject: [PATCH 17/20] Update README

---
 README.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/README.md b/README.md
index ccb44b8..5ae2b43 100644
--- a/README.md
+++ b/README.md
@@ -10,7 +10,7 @@ let a = CGPoint(x: 1, y: 2), b = CGPoint(x: -3, y: 5)
 let sum = a + b // (-2.0, 7.0)
 let distance = (b - a).length // 5.0
 let direction = (b - a).unit // (-0.8, 0.6)
-let rotated = a ⊗ CGAffineTransform(rotationAngle: CGFloat.pi / 2) // (-2.0, 1.0)
+let rotated = a * CGAffineTransform(rotationAngle: CGFloat.pi / 2) // (-2.0, 1.0)
 ```
 
 ## Usage

From f2fd23bc0284aea7bd0c50be5edc9835e3f3e197 Mon Sep 17 00:00:00 2001
From: Yuta Koshizawa <koher@koherent.org>
Date: Thu, 11 Oct 2018 11:51:41 +0900
Subject: [PATCH 18/20] Fix `cos/angle(from:)` for zero vectors

---
 Sources/CGPointVector/CGPoint.swift          | 6 +++++-
 Sources/CGPointVector/CGSize.swift           | 6 +++++-
 Sources/CGPointVector/CGVector.swift         | 6 +++++-
 Tests/CGPointVectorTests/CGPointTests.swift  | 6 ++++++
 Tests/CGPointVectorTests/CGSizeTests.swift   | 6 ++++++
 Tests/CGPointVectorTests/CGVectorTests.swift | 6 ++++++
 6 files changed, 33 insertions(+), 3 deletions(-)

diff --git a/Sources/CGPointVector/CGPoint.swift b/Sources/CGPointVector/CGPoint.swift
index dbe306a..7bca1ec 100644
--- a/Sources/CGPointVector/CGPoint.swift
+++ b/Sources/CGPointVector/CGPoint.swift
@@ -35,7 +35,11 @@ extension CGPoint {
     }
     
     public func cos(from point: CGPoint) -> CGFloat {
-        return fmin(fmax(self.dot(point) / sqrt(self.squareLength * point.squareLength), -1.0), 1.0)
+        let squareLength1 = self.squareLength
+        guard squareLength1 > 0.0 else { return 1.0 }
+        let squareLength2 = point.squareLength
+        guard squareLength2 > 0.0 else { return 1.0 }
+        return Swift.min(Swift.max(self.dot(point) / sqrt(squareLength1 * squareLength2), -1.0), 1.0)
     }
     
     public func dot(_ other: CGPoint) -> CGFloat {
diff --git a/Sources/CGPointVector/CGSize.swift b/Sources/CGPointVector/CGSize.swift
index 39d5368..f2412c2 100644
--- a/Sources/CGPointVector/CGSize.swift
+++ b/Sources/CGPointVector/CGSize.swift
@@ -35,7 +35,11 @@ extension CGSize {
     }
     
     public func cos(from point: CGSize) -> CGFloat {
-        return fmin(fmax(self.dot(point) / sqrt(self.squareLength * point.squareLength), -1.0), 1.0)
+        let squareLength1 = self.squareLength
+        guard squareLength1 > 0.0 else { return 1.0 }
+        let squareLength2 = point.squareLength
+        guard squareLength2 > 0.0 else { return 1.0 }
+        return Swift.min(Swift.max(self.dot(point) / sqrt(squareLength1 * squareLength2), -1.0), 1.0)
     }
     
     public func dot(_ other: CGSize) -> CGFloat {
diff --git a/Sources/CGPointVector/CGVector.swift b/Sources/CGPointVector/CGVector.swift
index c7ad0d4..8dec2f2 100644
--- a/Sources/CGPointVector/CGVector.swift
+++ b/Sources/CGPointVector/CGVector.swift
@@ -35,7 +35,11 @@ extension CGVector {
     }
     
     public func cos(from point: CGVector) -> CGFloat {
-        return fmin(fmax(self.dot(point) / sqrt(self.squareLength * point.squareLength), -1.0), 1.0)
+        let squareLength1 = self.squareLength
+        guard squareLength1 > 0.0 else { return 1.0 }
+        let squareLength2 = point.squareLength
+        guard squareLength2 > 0.0 else { return 1.0 }
+        return Swift.min(Swift.max(self.dot(point) / sqrt(squareLength1 * squareLength2), -1.0), 1.0)
     }
     
     public func dot(_ other: CGVector) -> CGFloat {
diff --git a/Tests/CGPointVectorTests/CGPointTests.swift b/Tests/CGPointVectorTests/CGPointTests.swift
index ccf7b91..efd1d2e 100644
--- a/Tests/CGPointVectorTests/CGPointTests.swift
+++ b/Tests/CGPointVectorTests/CGPointTests.swift
@@ -42,10 +42,16 @@ class CGPointTests: XCTestCase {
     
     func testAngle() {
         XCTAssertEqual(CGPoint(x: 1.0, y: 0.0).angle(from: CGPoint(x: sqrt(3.0), y: 1.0)), CGFloat.pi / 6, accuracy: torelance)
+        XCTAssertEqual(CGPoint(x: 1.0, y: 0.0).angle(from: .zero), 0.0, accuracy: torelance)
+        XCTAssertEqual(CGPoint.zero.angle(from: CGPoint(x: 0.0, y: 1.0)), 0.0, accuracy: torelance)
+        XCTAssertEqual(CGPoint.zero.angle(from: .zero), 0.0, accuracy: torelance)
     }
     
     func testCos() {
         XCTAssertEqual(CGPoint(x: 1.0, y: 0.0).cos(from: CGPoint(x: 1.0, y: sqrt(3.0))), 0.5, accuracy: torelance)
+        XCTAssertEqual(CGPoint(x: 1.0, y: 0.0).cos(from: .zero), 1.0, accuracy: torelance)
+        XCTAssertEqual(CGPoint.zero.cos(from: CGPoint(x: 0.0, y: 1.0)), 1.0, accuracy: torelance)
+        XCTAssertEqual(CGPoint.zero.cos(from: .zero), 1.0, accuracy: torelance)
     }
     
     func testDot() {
diff --git a/Tests/CGPointVectorTests/CGSizeTests.swift b/Tests/CGPointVectorTests/CGSizeTests.swift
index 2f5fc3f..6daae63 100644
--- a/Tests/CGPointVectorTests/CGSizeTests.swift
+++ b/Tests/CGPointVectorTests/CGSizeTests.swift
@@ -42,10 +42,16 @@ class CGSizeTests: XCTestCase {
     
     func testAngle() {
         XCTAssertEqual(CGSize(width: 1.0, height: 0.0).angle(from: CGSize(width: sqrt(3.0), height: 1.0)), CGFloat.pi / 6, accuracy: torelance)
+        XCTAssertEqual(CGSize(width: 1.0, height: 0.0).angle(from: .zero), 0.0, accuracy: torelance)
+        XCTAssertEqual(CGSize.zero.angle(from: CGSize(width: 0.0, height: 1.0)), 0.0, accuracy: torelance)
+        XCTAssertEqual(CGSize.zero.angle(from: .zero), 0.0, accuracy: torelance)
     }
     
     func testCos() {
         XCTAssertEqual(CGSize(width: 1.0, height: 0.0).cos(from: CGSize(width: 1.0, height: sqrt(3.0))), 0.5, accuracy: torelance)
+        XCTAssertEqual(CGSize(width: 1.0, height: 0.0).cos(from: .zero), 1.0, accuracy: torelance)
+        XCTAssertEqual(CGSize.zero.cos(from: CGSize(width: 0.0, height: 1.0)), 1.0, accuracy: torelance)
+        XCTAssertEqual(CGSize.zero.cos(from: .zero), 1.0, accuracy: torelance)
     }
     
     func testDot() {
diff --git a/Tests/CGPointVectorTests/CGVectorTests.swift b/Tests/CGPointVectorTests/CGVectorTests.swift
index 1cd304d..1fed2aa 100644
--- a/Tests/CGPointVectorTests/CGVectorTests.swift
+++ b/Tests/CGPointVectorTests/CGVectorTests.swift
@@ -42,10 +42,16 @@ class CGVectorTests: XCTestCase {
     
     func testAngle() {
         XCTAssertEqual(CGVector(dx: 1.0, dy: 0.0).angle(from: CGVector(dx: sqrt(3.0), dy: 1.0)), CGFloat.pi / 6, accuracy: torelance)
+        XCTAssertEqual(CGVector(dx: 1.0, dy: 0.0).angle(from: .zero), 0.0, accuracy: torelance)
+        XCTAssertEqual(CGVector.zero.angle(from: CGVector(dx: 0.0, dy: 1.0)), 0.0, accuracy: torelance)
+        XCTAssertEqual(CGVector.zero.angle(from: .zero), 0.0, accuracy: torelance)
     }
     
     func testCos() {
         XCTAssertEqual(CGVector(dx: 1.0, dy: 0.0).cos(from: CGVector(dx: 1.0, dy: sqrt(3.0))), 0.5, accuracy: torelance)
+        XCTAssertEqual(CGVector(dx: 1.0, dy: 0.0).cos(from: .zero), 1.0, accuracy: torelance)
+        XCTAssertEqual(CGVector.zero.cos(from: CGVector(dx: 0.0, dy: 1.0)), 1.0, accuracy: torelance)
+        XCTAssertEqual(CGVector.zero.cos(from: .zero), 1.0, accuracy: torelance)
     }
     
     func testDot() {

From 3fac0bf451b2994223b6da9ab9b67a25629fef00 Mon Sep 17 00:00:00 2001
From: Yuta Koshizawa <koher@koherent.org>
Date: Thu, 11 Oct 2018 11:52:48 +0900
Subject: [PATCH 19/20] Remove `@testable` from CGPointVectorTests.swift

---
 Tests/CGPointVectorTests/CGPointVectorTests.swift | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/Tests/CGPointVectorTests/CGPointVectorTests.swift b/Tests/CGPointVectorTests/CGPointVectorTests.swift
index e8118f3..703a7d5 100644
--- a/Tests/CGPointVectorTests/CGPointVectorTests.swift
+++ b/Tests/CGPointVectorTests/CGPointVectorTests.swift
@@ -1,5 +1,5 @@
 import XCTest
-@testable import CGPointVector
+import CGPointVector
 
 class CGPointVectorTests: XCTestCase {
     let torelance: CGFloat = 1.0e-5;

From a8a7c592da39c8887f1bd919efae8909491d5f02 Mon Sep 17 00:00:00 2001
From: Yuta Koshizawa <koher@koherent.org>
Date: Tue, 30 Oct 2018 00:35:34 +0900
Subject: [PATCH 20/20] Update README for release

---
 README.md | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/README.md b/README.md
index 5ae2b43..03893c7 100644
--- a/README.md
+++ b/README.md
@@ -35,14 +35,14 @@ let dotProduct = a.dot(b) // 26.0
 ```swift
 .package(
     url: "https://github.com/koher/CGPointVector.git",
-    from: "0.3.0-alpha"
+    from: "0.3.0"
 )
 ```
 
 ### Carthage
 
 ```
-github "koher/CGPointVector" "dev-0.3.0"
+github "koher/CGPointVector" ~> 0.3.0
 ```
 
 ## License