Refactor math types

Author: STREGA

Sources/GameMath/2D Types (New)/Vector2n.swift

@@ -28,6 +28,8 @@ public struct Position2n<Scalar: Vector2n.ScalarType>: Vector2n {
     }
 }
 extension Position2n: AdditiveArithmetic where Scalar: AdditiveArithmetic { }
+extension Position2n: ExpressibleByIntegerLiteral where Scalar: FixedWidthInteger & _ExpressibleByBuiltinIntegerLiteral & ExpressibleByIntegerLiteral { }
+extension Position2n: ExpressibleByFloatLiteral where Scalar: FloatingPoint & _ExpressibleByBuiltinFloatLiteral & ExpressibleByFloatLiteral { }
 extension Position2n: Equatable where Scalar: Equatable { }
 extension Position2n: Hashable where Scalar: Hashable { }
 extension Position2n: Comparable where Scalar: Comparable { }
@@ -50,6 +52,8 @@ public struct Size2n<Scalar: Vector2n.ScalarType>: Vector2n {
     public static var one: Self { .init(x: 1, y: 1) }
 }
 extension Size2n: AdditiveArithmetic where Scalar: AdditiveArithmetic { }
+extension Size2n: ExpressibleByIntegerLiteral where Scalar: FixedWidthInteger & _ExpressibleByBuiltinIntegerLiteral & ExpressibleByIntegerLiteral { }
+extension Size2n: ExpressibleByFloatLiteral where Scalar: FloatingPoint & _ExpressibleByBuiltinFloatLiteral & ExpressibleByFloatLiteral { }
 extension Size2n: Equatable where Scalar: Equatable { }
 extension Size2n: Hashable where Scalar: Hashable { }
 extension Size2n: Comparable where Scalar: Comparable { }
@@ -74,6 +78,42 @@ extension Vector2n where Scalar: BinaryInteger {
         )
     }
 
+    @inlinable
+    public init<T: Vector2n>(_ vector2n: T) where T.Scalar: BinaryFloatingPoint {
+        self.init(
+            x: Scalar(vector2n.x),
+            y: Scalar(vector2n.y)
+        )
+    }
+    
+    @inlinable
+    public init<T: Vector2n>(truncatingIfNeeded vector2n: T) where T.Scalar: BinaryInteger {
+        self.init(
+            x: Scalar(truncatingIfNeeded: vector2n.x),
+            y: Scalar(truncatingIfNeeded: vector2n.y)
+        )
+    }
+}
+
+extension Vector2n where Scalar: BinaryFloatingPoint {
+    @inlinable
+    public init(_ vector2n: some Vector2n<Scalar>) {
+        self.init(
+            x: vector2n.x,
+            y: vector2n.y
+        )
+    }
+    
+    @inlinable
+    public init<T: Vector2n>(_ vector2n: T) where T.Scalar: BinaryInteger {
+        self.init(
+            x: Scalar(vector2n.x),
+            y: Scalar(vector2n.y)
+        )
+    }
+}
+
+extension Vector2n where Scalar: BinaryInteger {
     @inlinable
     public init(_ vector2: Vector2Counterpart) {
         self.init(
@@ -97,14 +137,6 @@ extension Vector2n where Scalar: BinaryInteger {
 }
 
 extension Vector2n where Scalar: BinaryFloatingPoint {
-    @inlinable
-    public init(_ vector2n: some Vector2n<Scalar>) {
-        self.init(
-            x: vector2n.x,
-            y: vector2n.y
-        )
-    }
-    
     @inlinable
     public init(_ vector2: Vector2Counterpart) {
         self.init(
@@ -127,31 +159,88 @@ extension Vector2n where Scalar: BinaryFloatingPoint {
     }
 }
 
+public extension Vector2n where Scalar: FixedWidthInteger & _ExpressibleByBuiltinIntegerLiteral & ExpressibleByIntegerLiteral {
+    typealias IntegerLiteralType = Scalar
+    init(integerLiteral value: IntegerLiteralType) {
+        self.init(x: value, y: value)
+    }
+}
+
+public extension Vector2n where Scalar: FloatingPoint & _ExpressibleByBuiltinFloatLiteral & ExpressibleByFloatLiteral {
+    typealias FloatLiteralType = Scalar
+    init(floatLiteral value: FloatLiteralType) {
+        self.init(x: value, y: value)
+    }
+}
+
 public extension Vector2n where Scalar: AdditiveArithmetic {
+    @inlinable
+    static func + (lhs: Self, rhs: some Vector2n<Scalar>) -> Self {
+        return Self(x: lhs.x + rhs.x, y: lhs.y + rhs.y)
+    }
+    
     @inlinable
     static func - (lhs: Self, rhs: some Vector2n<Scalar>) -> Self {
         return Self(x: lhs.x - rhs.x, y: lhs.y - rhs.y)
     }
 
+    @_disfavoredOverload // <- Tell the compiler to prefer using integer literals
     @inlinable
-    static func + (lhs: Self, rhs: some Vector2n<Scalar>) -> Self {
-        return Self(x: lhs.x + rhs.x, y: lhs.y + rhs.y)
+    static func + (lhs: Self, rhs: Scalar) -> Self {
+        return Self(x: lhs.x + rhs, y: lhs.y + rhs)
     }
 
+    @_disfavoredOverload // <- Tell the compiler to prefer using integer literals
     @inlinable
-    static var zero: Self {Self(x: .zero, y: .zero)}
+    static func - (lhs: Self, rhs: Scalar) -> Self {
+        return Self(x: lhs.x - rhs, y: lhs.y - rhs)
+    }
+    
+    @_disfavoredOverload // <- Tell the compiler to prefer using integer literals
+    @inlinable
+    static var zero: Self {Self(x: Scalar.zero, y: Scalar.zero)}
 }
 
 public extension Vector2n where Scalar: Numeric {
     @inlinable
     static func * (lhs: Self, rhs: some Vector2n<Scalar>) -> Self {
         return Self(x: lhs.x * rhs.x, y: lhs.y * rhs.y)
     }
-    
+
     @inlinable
     static func *= (lhs: inout Self, rhs: some Vector2n<Scalar>) {
         lhs = lhs * rhs
     }
+    
+    @_disfavoredOverload // <- Tell the compiler to prefer using integer literals
+    @inlinable
+    static func * (lhs: Self, rhs: Scalar) -> Self {
+        return Self(x: lhs.x * rhs, y: lhs.y * rhs)
+    }
+    
+    @_disfavoredOverload // <- Tell the compiler to prefer using integer literals
+    @inlinable
+    static func *= (lhs: inout Self, rhs: Scalar) {
+        lhs = lhs * rhs
+    }
+    
+    @inlinable
+    init?<T: Vector2n>(exactly vector2n: T) where T.Scalar: BinaryInteger {
+        guard let x = Scalar(exactly: vector2n.x), let y = Scalar(exactly: vector2n.y) else {
+            return nil
+        }
+        self.init(x: x, y: y)
+    }
+}
+
+public extension Vector2n where Scalar: SignedNumeric {
+    prefix static func - (operand: Self) -> Self {
+        return Self(x: -operand.x, y: -operand.y)
+    }
+    
+    mutating func negate() -> Self {
+        return Self(x: -x, y: -y)
+    }
 }
 
 public extension Vector2n where Scalar: FloatingPoint {
@@ -165,6 +254,18 @@ public extension Vector2n where Scalar: FloatingPoint {
         lhs = lhs / rhs
     }
 
+    @_disfavoredOverload // <- Tell the compiler to prefer using integer literals
+    @inlinable
+    static func / (lhs: Self, rhs: Scalar) -> Self {
+        return Self(x: lhs.x / rhs, y: lhs.y / rhs)
+    }
+    
+    @_disfavoredOverload // <- Tell the compiler to prefer using integer literals
+    @inlinable
+    static func /= (lhs: inout Self, rhs: Scalar) {
+        lhs = lhs / rhs
+    }
+    
     @inlinable
     static var nan: Self {Self(x: .nan, y: .nan)}
 
@@ -182,6 +283,18 @@ public extension Vector2n where Scalar: FixedWidthInteger {
     static func /= (lhs: inout Self, rhs: some Vector2n<Scalar>) {
         lhs = lhs / rhs
     }
+    
+    @_disfavoredOverload // <- Tell the compiler to prefer using integer literals
+    @inlinable
+    static func / (lhs: Self, rhs: Scalar) -> Self {
+        return Self(x: lhs.x / rhs, y: lhs.y / rhs)
+    }
+    
+    @_disfavoredOverload // <- Tell the compiler to prefer using integer literals
+    @inlinable
+    static func /= (lhs: inout Self, rhs: Scalar) {
+        lhs = lhs / rhs
+    }
 }
 
 public extension Vector2n where Scalar: Comparable {
@@ -201,6 +314,11 @@ public extension Vector2n where Scalar: Comparable {
     }
 }
 
+@inlinable
+public func abs<T: Vector2n>(_ vector: T) -> T where T.Scalar : Comparable, T.Scalar : SignedNumeric {
+    return T(x: abs(vector.x), y: abs(vector.y))
+}
+
 extension Vector2n where Scalar: Equatable {
     @inlinable
     public static func == (lhs: Self, rhs: some Vector2n<Scalar>) -> Bool {