Floating Points (#2)

Replaced all default 'Float' types with 'Double'.

Author: richardpiazza

Package.resolved

@@ -14,18 +14,15 @@ let package = Package(
     products: [
         .library(
             name: "GraphPoint",
-            targets: ["GraphPoint", "GraphPointUI"]),
+            targets: ["GraphPoint"]),
     ],
     dependencies: [
-        .package(url: "https://github.com/richardpiazza/Swift2D", .upToNextMinor(from: "1.1.0")),
+        .package(url: "https://github.com/richardpiazza/Swift2D", .upToNextMajor(from: "2.0.0")),
     ],
     targets: [
         .target(
             name: "GraphPoint",
             dependencies: ["Swift2D"]),
-        .target(
-            name: "GraphPointUI",
-            dependencies: ["GraphPoint"]),
         .testTarget(
             name: "GraphPointTests",
             dependencies: ["GraphPoint"]),

Package.swift

@@ -47,7 +47,8 @@ public extension CartesianFrame {
 public extension CartesianFrame {
     /// Identifies the minimum `CartesianFrame` that contains all of the provided points.
     ///
-    /// - parameter points: The `CartesianPoint`s with which to map into a frame.
+    /// - parameters:
+    ///   - points: The `CartesianPoint`s with which to map into a frame.
     /// - returns: A `CartesianFrame` containing all of the points.
     static func make(for points: [CartesianPoint]) -> CartesianFrame {
         var minXMaxY = Point()
@@ -112,8 +113,9 @@ public extension CartesianFrame {
     ///               ▼
     /// ```
     ///
-    /// - parameter arc: The points and radius of the circle on which the chord is present.
-    /// - parameter points: Additional points that extend the resulting frame.
+    /// - parameters:
+    ///   - arc: The points and radius of the circle on which the chord is present.
+    ///   - points: Additional points that extend the resulting frame.
     /// - returns: A `CartesianFrame` containing all of the points.
     /// - throws: GraphPointError.unhandledQuadrantTransition(_:_:)
     static func make(for arc: Arc, points: [CartesianPoint]) throws -> CartesianFrame {

Sources/GraphPoint/CartesianFrame.swift

@@ -39,12 +39,12 @@ public extension CartesianPlane {
     }
 
     /// The length of the shortest axis found in this plane.
-    var minimumAxis: Float {
+    var minimumAxis: Double {
         return min(midX, midY)
     }
 
     /// The length of the shortest axis found in this plane.
-    var maximumAxis: Float {
+    var maximumAxis: Double {
         return max(midX, midY)
     }
 
@@ -62,7 +62,8 @@ public extension CartesianPlane {
     /// // cartesianPoint == CartesianPoint(x: -25, y: 25)
     /// ```
     ///
-    /// - parameter point: A standard `Point` (which uses top-left as {0, 0}).
+    /// - parameters:
+    ///   - point: A standard `Point` (which uses top-left as {0, 0}).
     /// - returns A `CartesianPoint` which has been translated onto the _plane_.
     func cartesianPoint(for point: Point) -> CartesianPoint {
         let origin = cartesianOrigin
@@ -107,4 +108,9 @@ public extension CartesianPlane {
         let origin = cartesianOrigin
         return Rect(origin: Point(x: origin.x + cartesianFrame.origin.x, y: origin.y - cartesianFrame.origin.y), size: cartesianFrame.size)
     }
+    
+    /// A `CartesianPoint` within the bounds of the plane for the given `Degree` and `maximumAxis`.
+    func cartesianPoint(for degree: Degree, clockwise: Bool = true) throws -> CartesianPoint {
+        try CartesianPoint.make(for: maximumAxis, degree: degree, clockwise: clockwise)
+    }
 }

Sources/GraphPoint/CartesianPlane.swift

@@ -21,7 +21,7 @@ public typealias CartesianPoint = Point
 
 public extension CartesianPoint {
     /// The minimum axis for a `CartesianPlane` that would contain this point.
-    var minimumAxis: Float {
+    var minimumAxis: Double {
         return max(abs(x), abs(y))
     }
 }
@@ -31,8 +31,9 @@ public extension CartesianPoint {
     ///
     /// Uses the mathematical **Law of Sines**.
     ///
-    /// - parameter radius: The straight line distance from the _origin_.
-    /// - parameter degree: The angular degree (0-360), clockwise from the x-axis.
+    /// - parameters:
+    ///   - radius: The straight line distance from the _origin_.
+    ///   - degree: The angular degree (0-360), clockwise from the x-axis.
     /// - returns:A `CartesianPoint` with offsets from the _origin_.
     static func make(for radius: Radius, degree: Degree, clockwise: Bool = true) throws -> CartesianPoint {
         guard degree >= 0.0, degree <= 360.0 else {
@@ -47,10 +48,10 @@ public extension CartesianPoint {
             return .zero
         }
 
-        let rightAngle: Float = 90.0
+        let rightAngle: Double = 90.0
         let sinRight = sin(rightAngle.radians)
-        var rise: Float = 0.0
-        var run: Float = 0.0
+        var rise: Double = 0.0
+        var run: Double = 0.0
         var point: CartesianPoint = .zero
 
         switch clockwise {
@@ -110,9 +111,10 @@ public extension CartesianPoint {
     /// * **c**: calculated based on `degree` and `radius`.
     /// * **a**: supplied via the `point` (x/y based on closest axis)
     ///
-    /// - parameter radius: The straight line distance from the _origin_.
-    /// - parameter degree: The angular degree (0-360), clockwise from the x-axis.
-    /// - parameter modifier: The point used to clip or expand the result. The nearest axis value is used.
+    /// - parameters:
+    ///   - radius: The straight line distance from the _origin_.
+    ///   - degree: The angular degree (0-360), clockwise from the x-axis.
+    ///   - modifier: The point used to clip or expand the result. The nearest axis value is used.
     static func make(for radius: Radius, degree: Degree, modifier: CartesianPoint, clockwise: Bool = true) throws -> CartesianPoint {
         guard degree >= 0.0, degree <= 360.0 else {
             throw GraphPointError.invalidDegree(degree)
@@ -131,28 +133,28 @@ public extension CartesianPoint {
         switch clockwise {
         case true:
             if (degree >= 315) {
-                point.x = sqrtf(powf(radius, 2) - powf(modifier.y, 2))
+                point.x = sqrt(pow(radius, 2) - pow(modifier.y, 2))
                 point.y = modifier.y
             } else if (degree >= 270) {
                 point.x = modifier.x
-                point.y = sqrtf(powf(radius, 2) - powf(modifier.x, 2))
+                point.y = sqrt(pow(radius, 2) - pow(modifier.x, 2))
             } else if (degree >= 225) {
                 point.x = modifier.x
-                point.y = sqrtf(powf(radius, 2) - powf(modifier.x, 2))
+                point.y = sqrt(pow(radius, 2) - pow(modifier.x, 2))
             } else if (degree >= 180) {
-                point.x = -(sqrtf(powf(radius, 2) - powf(modifier.y, 2)))
+                point.x = -(sqrt(pow(radius, 2) - pow(modifier.y, 2)))
                 point.y = modifier.y
             } else if (degree >= 135) {
-                point.x = -(sqrtf(powf(radius, 2) - powf(modifier.y, 2)))
+                point.x = -(sqrt(pow(radius, 2) - pow(modifier.y, 2)))
                 point.y = modifier.y
             } else if (degree >= 90) {
                 point.x = modifier.x
-                point.y = -(sqrtf(powf(radius, 2) - powf(modifier.x, 2)))
+                point.y = -(sqrt(pow(radius, 2) - pow(modifier.x, 2)))
             } else if (degree >= 45) {
                 point.x = modifier.x
-                point.y = -(sqrtf(powf(radius, 2) - powf(modifier.x, 2)))
+                point.y = -(sqrt(pow(radius, 2) - pow(modifier.x, 2)))
             } else if (degree >= 0) {
-                point.x = sqrtf(powf(radius, 2) - powf(modifier.y, 2))
+                point.x = sqrt(pow(radius, 2) - pow(modifier.y, 2))
                 point.y = modifier.y
             }
         case false:

Sources/GraphPoint/CartesianPoint.swift

@@ -5,7 +5,7 @@ import Swift2D
 ///
 /// Degree 0 (zero) is the positive x axis and increments clockwise.
 /// TODO: Rotating clockwise to match CoreGraphics, but should this match the Quadrant flow?
-public typealias Degree = Float
+public typealias Degree = Double
 
 public extension Degree {
     /// Converts an angular degree to radians
@@ -17,7 +17,8 @@ public extension Degree {
     ///
     /// Uses the mathematical **Law of Cotangents**.
     ///
-    /// - parameter point: A `CartesianPoint` with offsets from the _origin_.
+    /// - parameters:
+    ///   - point: A `CartesianPoint` with offsets from the _origin_.
     /// - returns:The angular degree (0-360), clockwise from the x-axis.
     static func make(for cartesianPoint: CartesianPoint, clockwise: Bool = true) throws -> Degree {
         guard cartesianPoint != .nan else {