         
         self.init(center: center, size: .init(width: width, height: height))
     }
+}
+
+// MARK: -
+// MARK: Corners
+public extension CGRect {
+    
+    /// A point representing the rectangle's center.
+    @inlinable
+    public var center: CGPoint {
+        get {
+            return CGPoint(x: self.midX, y: self.midY)
+        }
+        set {
+            self.origin = newValue.translated(along: self.center.formVector(with: self.origin))
+        }
+    }
+    
+    /// A point representing the corner located at the smallest value of the x-coordinate and the smallest value of the y-coordinate of the rectangle.
+    @inlinable
+    public var minXminYCorner: CGPoint {
+        get {
+            return CGPoint(x: self.minX, y: self.minY)
+        }
+        set {
+            self.origin = newValue.translated(along: self.minXminYCorner.formVector(with: self.origin))
+        }
+    }
+    
+    /// A point representing the corner located at the smallest value of the x-coordinate and the largest value of the y-coordinate of the rectangle.
+    @inlinable
+    public var minXmaxYCorner: CGPoint {
+        get {
+            return CGPoint(x: self.minX, y: self.maxY)
+        }
+        set {
+            self.origin = newValue.translated(along: self.minXmaxYCorner.formVector(with: self.origin))
+        }
+    }
+    
+    /// A point representing the corner located at the largest value of the x-coordinate and the smallest value of the y-coordinate of the rectangle.
+    @inlinable
+    public var maxXminYCorner: CGPoint {
+        get {
+            return CGPoint(x: self.maxX, y: self.minY)
+        }
+        set {
+            self.origin = newValue.translated(along: self.maxXminYCorner.formVector(with: self.origin))
+        }
+    }
+    
+    /// A point representing the corner located at the largest value of the x-coordinate and the largest value of the y-coordinate of the rectangle.
+    @inlinable
+    public var maxXmaxYCorner: CGPoint {
+        get {
+            return CGPoint(x: self.maxX, y: self.maxY)
+        }
+        set {
+            self.origin = newValue.translated(along: self.maxXmaxYCorner.formVector(with: self.origin))
+        }
+    }
+    
+    /// A point representing the center of the edge located at the smallest value of the x-coordinate and the of the rectangle.
+    @inlinable
+    public var minXEdgeCenter: CGPoint {
+        get {
+            return CGPoint(x: self.minX, y: self.midY)
+        }
+        set {
+            self.origin = newValue.translated(along: self.minXEdgeCenter.formVector(with: self.origin))
+        }
+    }
+    
+    /// A point representing the center of the edge located at the smallest value of the x-coordinate and the of the rectangle.
+    @inlinable
+    public var maxXEdgeCenter: CGPoint {
+        get {
+            return CGPoint(x: self.maxX, y: self.midY)
+        }
+        set {
+            self.origin = newValue.translated(along: self.maxXEdgeCenter.formVector(with: self.origin))
+        }
+    }
+    
+    /// A point representing the center of the edge located at the smallest value of the y-coordinate and the of the rectangle.
+    @inlinable
+    public var minYEdgeCenter: CGPoint {
+        get {
+            return CGPoint(x: self.midX, y: self.minY)
+        }
+        set {
+            self.origin = newValue.translated(along: self.minYEdgeCenter.formVector(with: self.origin))
+        }
+    }
+    
+    /// A point representing the center of the edge located at the largest value of the y-coordinate and the of the rectangle.
+    @inlinable
+    public var maxYEdgeCenter: CGPoint {
+        get {
+            return CGPoint(x: self.midX, y: self.maxY)
+        }
+        set {
+            self.origin = newValue.translated(along: self.maxYEdgeCenter.formVector(with: self.origin))
+        }
+    }
+}
+
+// MARK: -
+// MARK: Geometry
+public extension CGRect {
+    /// The smallest square rectangle that can contain `self`.
+    @inlinable
+    public var maxSquare: CGRect {
+        let maxEdge = max(self.width, self.height)
+        return CGRect(origin: .zero, size: .init(width: maxEdge, height: maxEdge))
+    }
+    
+    /// The biggest square rectangle that `self` can contain.
+    @inlinable
+    public var minSquare: CGRect {
+        let minEdge = min(self.width, self.height)
+        return CGRect(origin: .zero, size: .init(width: minEdge, height: minEdge))
+    }
+    
+    /// The ratio of `self`.
+    @inlinable
+    public var ratio: CGFloat {
+        return self.width / self.height
+    }
+    
+    
+    /// The diagonal of `self`.
+    @inlinable
+    public var diagonal: CGFloat {
+        return sqrt(pow(self.width, 2.0) + pow(self.height, 2.0))
+    }
+    
+    /// The orientation of `self`.
+    @inlinable
+    public var orientation: Orientation {
+        switch self.width / self.height {
+        case let x where x < 1.0:
+            return .portrait
+        case let x where x > 1.0:
+            return .landscape
+        default:
+            return .square
+        }
+    }
+}
+
+// MARK: -
+// MARK: Center
+public extension CGRect {
 
     /// Returns a copy of `self` centered relative to the given rectangle.
     @inlinable

    public mutating func reset() {
        self.origin = CGPoint(x: 0, y: 0)
    }

    /// Returns a copy of `self` translated by the given vector.
    @inlinable
    public func translated(by vector: CGVector) -> CGRect {

    public mutating func slide(relativeTo center: CGPoint, by angle: CGFloat) {
        self = self.slided(relativeTo: center, by: angle)
    }
}

// MARK: -
// MARK: Offset
public extension CGRect {
    
    /// Offsets `self` by the given amount in the `maxX` direction.
    ///
