     ///   - lhs: The point to divide components.
     ///   - rhs: The value to devide by.
     @inlinable
-    static func /<F: BinaryFloatingPoint>(lhs: CGPoint, rhs: F) -> CGPoint {
-        lhs / CGFloat(rhs)
-    }
-    
+    static func / <F: BinaryFloatingPoint>(lhs: CGPoint, rhs: F) -> CGPoint {
+        .init(simd2: lhs.simd2 / rhs.native)
+    }
     
     /// Divides `x` and `y` by the given value and returns the resulting `CGPoint`.
     /// - Parameters:
     ///   - lhs: The point to divide components.
     ///   - rhs: The value to devide by.
     @inlinable
-    static func /(lhs: CGPoint, rhs: CGFloat) -> CGPoint {
-        CGPoint(x: lhs.x / rhs, y: lhs.y / rhs)
+    static func / (lhs: CGPoint, rhs: CGFloat.NativeType) -> CGPoint {
+        .init(simd2: lhs.simd2 / rhs)
     }
     
     /// Divides a point's components by another one's and returns the resulting `CGPoint`.


public extension CGPoint {
    /// Creates a point with coordinates specified as integer values.
    @inlinable
    init<T: BinaryInteger>(_ x: T, _ y: T) {
        self.init(x: CGFloat(x), y: CGFloat(y))
    }
    
    /// Creates a point with coordinates specified as floating-point values.
    @inlinable
    init<T: BinaryFloatingPoint>(_ x: T, _ y: T) {
        self.init(x: CGFloat(x), y: CGFloat(y))
    }
}

public extension CGPoint {
    /// Returns the vector that exists between `self` and `p2`.
    @inlinable
    func formVector(with p2: CGPoint) -> CGVector {
        CGVector(dx: p2.x - self.x, dy: p2.y - self.y)
    }
    
    /// Returns a copy of `self` translated along the given vector.
    @inlinable
    func translated(along vector: CGVector) -> CGPoint {
        CGPoint(x: self.x + vector.dx, y: self.y + vector.dy)
    }
    
    /// Returns a copy of `self` translated by `tx` on the X-axis and by `ty` on the Y-axis.
    @inlinable
    func translated<I: BinaryInteger>(tx: I, ty: I) -> CGPoint {
        CGPoint(x: self.x + CGFloat(tx), y: self.y + CGFloat(ty))
    }
    
    /// Returns a copy of `self` translated by `tx` on the X-axis and by `ty` on the Y-axis.
    @inlinable
    func translated<F: BinaryFloatingPoint>(tx: F, ty: F) -> CGPoint {
        CGPoint(x: self.x + CGFloat(tx), y: self.y + CGFloat(ty))
    }
    
    /// Returns a copy of `self` translated by `tx` on the X-axis and by `ty` on the Y-axis.
    @inlinable
    func translated(tx: CGFloat, ty: CGFloat) -> CGPoint {
        CGPoint(x: self.x + tx, y: self.y + ty)
    }
    
    /// Translates `self` along the given vector.
    @inlinable
    mutating func translate(by vector: CGVector) {
        self = self.translated(along: vector)
    }
    
    /// Translates `self` by `tx` on the X-axis and by `ty` on the Y-axis.
    @inlinable
    mutating func translate<I: BinaryInteger>(tx: I, ty: I) {
        self = self.translated(tx: tx, ty: ty)
    }
    
    /// Translates `self` by `tx` on the X-axis and by `ty` on the Y-axis.
    @inlinable
    mutating func translate<F: BinaryFloatingPoint>(tx: F, ty: F) {
        self = self.translated(tx: tx, ty: ty)
    }
    
    /// Translates `self` by `tx` on the X-axis and by `ty` on the Y-axis.
    @inlinable
    mutating func translate(tx: CGFloat, ty: CGFloat) {
        self = self.translated(tx: tx, ty: ty)
    }
    
    /// Returns a copy of `self` rotated around the given center by the given angle.
    ///
    /// - note: Rotates clockwise on iOS and counter-clockwise on OS X.
    @inlinable
    func rotated(relativeTo center: CGPoint, by angle: CGFloat) -> CGPoint {
        var transform = CGAffineTransform(translationX: center.x, y: center.y)
        transform = transform.rotated(by: angle)
        transform = transform.translatedBy(x: -center.x, y: -center.y)
        return self.applying(transform)
    }
    
    /// Rotates `self` around the givent center by the given angle.
    ///
    /// - note: Rotates clockwise on iOS and counter-clockwise on OS X.
    @inlinable
    mutating func rotate(relativeTo center: CGPoint, by angle: CGFloat) {
        self = self.rotated(relativeTo: center, by: angle)
    }
}

    ///   - lhs: A point to devide.
    ///   - rhs: Another point the devide.
    @inlinable
    static func / (lhs: CGPoint, rhs: CGPoint) -> CGPoint {
        .init(simd2: lhs.simd2 / rhs.simd2)
    }
}

extension CGPoint: AdditiveArithmetic {
    
    @inlinable public static func + (lhs: CGPoint, rhs: CGPoint) -> CGPoint {
        .init(simd2: lhs.simd2 + rhs.simd2)
    }
    
    /// Adds a value to a point's component.
    /// - Parameters:
    ///   - lhs: A point.
    ///   - rhs: The value to add.
    /// - Returns: The resulting point.
    @inlinable public static func + <I: BinaryInteger>(lhs: CGPoint, rhs: I) -> CGPoint {
        .init(simd2: lhs.simd2 + rhs.native)
    }
    
    /// Adds a value to a point's component.
    /// - Parameters:
    ///   - lhs: A point.
    ///   - rhs: The value to add.
    /// - Returns: The resulting point.
    @inlinable public static func + <I: BinaryFloatingPoint>(lhs: CGPoint, rhs: I) -> CGPoint {
        .init(simd2: lhs.simd2 + rhs.native)
    }
    
    /// Adds a value to a point's component.
    /// - Parameters:
    ///   - lhs: A point.
    ///   - rhs: The value to add.
    /// - Returns: The resulting point.
    @inlinable public static func + (lhs: CGPoint, rhs: CGFloat.NativeType) -> CGPoint {
        .init(simd2: lhs.simd2 + rhs.native)
    }
    
    @inlinable public static func - (lhs: CGPoint, rhs: CGPoint) -> CGPoint {
        .init(simd2: lhs.simd2 - rhs.simd2)
    }
    
    /// Substracts a value from a point's components.
    /// - Parameters:
    ///   - lhs: A point.
    ///   - rhs: The value to substract.
    /// - Returns: The resulting vector.
    @inlinable public static func - <I: BinaryInteger>(lhs: CGPoint, rhs: I) -> CGPoint {
        .init(simd2: lhs.simd2 - rhs.native)
    }
    
    /// Substracts a value from a point's components.
    /// - Parameters:
    ///   - lhs: A point.
    ///   - rhs: The value to substract.
    /// - Returns: The resulting vector.
    @inlinable public static func - <F: BinaryFloatingPoint>(lhs: CGPoint, rhs: F) -> CGPoint {
        .init(simd2: lhs.simd2 - rhs.native)
    }
    
    /// Substracts a value from a point's components.
    /// - Parameters:
    ///   - lhs: A point.
    ///   - rhs: The value to substract.
    /// - Returns: The resulting vector.
    @inlinable public static func - (lhs: CGPoint, rhs: CGFloat.NativeType) -> CGPoint {
        .init(simd2: lhs.simd2 - rhs)
    }
}
