Added arithmetic operations that ignore overflow for Complex where the scalar type conforms to FixedWidthInteger

Author: Joe Newton

Sources/Complex/ComplexArithmetic.swift

@@ -103,6 +103,87 @@ extension Complex where Scalar: SignedNumeric {
     }
 }
 
+extension Complex where Scalar: FixedWidthInteger {
+
+    @_transparent
+    public static func &+ (lhs: Complex<Scalar>, rhs: Complex<Scalar>) -> Complex<Scalar> {
+        return Complex<Scalar>(real: lhs.real &+ rhs.real, imaginary: lhs.imaginary &+ rhs.imaginary)
+    }
+
+    @_transparent
+    public static func &+= (lhs: inout Complex<Scalar>, rhs: Complex<Scalar>) {
+        lhs = lhs &+ rhs
+    }
+
+    @_transparent
+    public static func &- (lhs: Complex<Scalar>, rhs: Complex<Scalar>) -> Complex<Scalar> {
+        return Complex<Scalar>(real: lhs.real &- rhs.real, imaginary: lhs.imaginary &- rhs.imaginary)
+    }
+
+    @_transparent
+    public static func &-= (lhs: inout Complex<Scalar>, rhs: Complex<Scalar>) {
+        lhs = lhs &- rhs
+    }
+
+    //
+
+    @_transparent
+    public static func &+ (lhs: Complex<Scalar>, rhs: Scalar) -> Complex<Scalar> {
+        return Complex<Scalar>(real: lhs.real &+ rhs, imaginary: lhs.imaginary)
+    }
+
+    @_transparent
+    public static func &+ (lhs: Scalar, rhs: Complex<Scalar>) -> Complex<Scalar> {
+        return Complex<Scalar>(real: lhs &+ rhs.real, imaginary: rhs.imaginary)
+    }
+
+    @_transparent
+    public static func &+= (lhs: inout Complex<Scalar>, rhs: Scalar) {
+        lhs = lhs &+ rhs
+    }
+
+    //
+
+    @inlinable @inline(__always)
+    public static func .&+ (lhs: Complex<Scalar>, rhs: Complex<Scalar>) -> Complex<Scalar> {
+        return lhs &+ rhs
+    }
+
+    @inlinable @inline(__always)
+    public static func .&+= (lhs: inout Complex<Scalar>, rhs: Complex<Scalar>) {
+        lhs = lhs .&+ rhs
+    }
+
+    //
+
+    @_transparent
+    public static func &- (lhs: Complex<Scalar>, rhs: Scalar) -> Complex<Scalar> {
+        return Complex<Scalar>(real: lhs.real &- rhs, imaginary: lhs.imaginary)
+    }
+
+    @_transparent
+    public static func &- (lhs: Scalar, rhs: Complex<Scalar>) -> Complex<Scalar> {
+        return Complex<Scalar>(real: lhs &- rhs.real, imaginary: .zero &- rhs.imaginary)
+    }
+
+    @_transparent
+    public static func &-= (lhs: inout Complex<Scalar>, rhs: Scalar) {
+        lhs = lhs &- rhs
+    }
+
+    //
+
+    @inlinable @inline(__always)
+    public static func .&- (lhs: Complex<Scalar>, rhs: Complex<Scalar>) -> Complex<Scalar> {
+        return lhs &- rhs
+    }
+
+    @inlinable @inline(__always)
+    public static func .&-= (lhs: inout Complex<Scalar>, rhs: Complex<Scalar>) {
+        lhs = lhs .&- rhs
+    }
+}
+
 // MARK: - Multiplication
 
 extension Complex {
@@ -150,6 +231,51 @@ extension Complex {
     }
 }
 
+extension Complex where Scalar: FixedWidthInteger {
+
+    @_transparent
+    public static func &* (lhs: Complex<Scalar>, rhs: Complex<Scalar>) -> Complex<Scalar> {
+        let real = (lhs.real &* rhs.real) &- (lhs.imaginary &* rhs.imaginary)
+        let imaginary = (lhs.real &* rhs.imaginary) &+ (lhs.imaginary &* rhs.real)
+
+        return Complex<Scalar>(real: real, imaginary: imaginary)
+    }
+
+    @_transparent
+    public static func &*= (lhs: inout Complex<Scalar>, rhs: Complex<Scalar>) {
+        lhs = lhs &* rhs
+    }
+
+    //
+
+    @_transparent
+    public static func &* (lhs: Complex<Scalar>, rhs: Scalar) -> Complex<Scalar> {
+        return Complex<Scalar>(real: lhs.real &* rhs, imaginary: lhs.imaginary &* rhs)
+    }
+
+    @_transparent
+    public static func &* (lhs: Scalar, rhs: Complex<Scalar>) -> Complex<Scalar> {
+        return Complex<Scalar>(real: lhs &* rhs.real, imaginary: lhs &* rhs.imaginary)
+    }
+
+    @_transparent
+    public static func &*= (lhs: inout Complex<Scalar>, rhs: Scalar) {
+        lhs = lhs &* rhs
+    }
+
+    //
+
+    @_transparent
+    public static func .&* (lhs: Complex<Scalar>, rhs: Complex<Scalar>) -> Complex<Scalar> {
+        return Complex<Scalar>(real: lhs.real &* rhs.real, imaginary: lhs.imaginary &* rhs.imaginary)
+    }
+
+    @_transparent
+    public static func .&*= (lhs: inout Complex<Scalar>, rhs: Complex<Scalar>) {
+        lhs = lhs .&* rhs
+    }
+}
+
 // MARK: - Division (BinaryInteger)
 
 extension Complex where Scalar: BinaryInteger {

Sources/Complex/Operators.swift

@@ -11,14 +11,26 @@ import Foundation
 infix operator .+: AdditionPrecedence
 infix operator .+=: AssignmentPrecedence
 
+/// Component-wise addition, ignoring overflow
+infix operator .&+: AdditionPrecedence
+infix operator .&+=: AssignmentPrecedence
+
 /// Component-wise subtraction
 infix operator .-: AdditionPrecedence
 infix operator .-=: AssignmentPrecedence
 
+/// Component-wise subtraction, ignoring overflow
+infix operator .&-: AdditionPrecedence
+infix operator .&-=: AssignmentPrecedence
+
 /// Component-wise multiplication
 infix operator .*: MultiplicationPrecedence
 infix operator .*=: AssignmentPrecedence
 
+/// Component-wise multiplication, ignoring overflow
+infix operator .&*: MultiplicationPrecedence
+infix operator .&*=: AssignmentPrecedence
+
 /// Component-wise division
 infix operator ./: MultiplicationPrecedence
 infix operator ./=: AssignmentPrecedence

Tests/ComplexTests/ComplexArithmeticTests.swift

@@ -96,6 +96,19 @@ class ComplexArithmeticTests: XCTestCase {
         testAddition(Complex<Float80>(real: 1.0, imaginary: 2.0), 3.0, Complex<Float80>(real: 4.0, imaginary: 2.0))
     }
 
+    func testAdditionIgnoringOverflow() {
+        testAdditionIgnoringOverflow(forType: Int8.self)
+        testAdditionIgnoringOverflow(forType: Int16.self)
+        testAdditionIgnoringOverflow(forType: Int32.self)
+        testAdditionIgnoringOverflow(forType: Int64.self)
+        testAdditionIgnoringOverflow(forType: Int.self)
+        testAdditionIgnoringOverflow(forType: UInt8.self)
+        testAdditionIgnoringOverflow(forType: UInt16.self)
+        testAdditionIgnoringOverflow(forType: UInt32.self)
+        testAdditionIgnoringOverflow(forType: UInt64.self)
+        testAdditionIgnoringOverflow(forType: UInt.self)
+    }
+
     func testSubtraction() {
         testSubtraction(Complex<Int8>(real: 3, imaginary: 4), Complex<Int8>(real: 1, imaginary: 2), Complex<Int8>(real: 2, imaginary: 2))
         testSubtraction(Complex<Int16>(real: 3, imaginary: 4), Complex<Int16>(real: 1, imaginary: 2), Complex<Int16>(real: 2, imaginary: 2))
@@ -128,6 +141,19 @@ class ComplexArithmeticTests: XCTestCase {
         testSubtraction(Complex<Float80>(real: 3.0, imaginary: 4.0), 1.0, Complex<Float80>(real: 2.0, imaginary: 4.0))
     }
 
+    func testSubtractionIgnoringOverflow() {
+        testSubtractionIgnoringOverflow(forType: Int8.self)
+        testSubtractionIgnoringOverflow(forType: Int16.self)
+        testSubtractionIgnoringOverflow(forType: Int32.self)
+        testSubtractionIgnoringOverflow(forType: Int64.self)
+        testSubtractionIgnoringOverflow(forType: Int.self)
+        testSubtractionIgnoringOverflow(forType: UInt8.self)
+        testSubtractionIgnoringOverflow(forType: UInt16.self)
+        testSubtractionIgnoringOverflow(forType: UInt32.self)
+        testSubtractionIgnoringOverflow(forType: UInt64.self)
+        testSubtractionIgnoringOverflow(forType: UInt.self)
+    }
+
     func testMultiplication() {
         testMultiplication(Complex<Int8>(real: 3, imaginary: 4), Complex<Int8>(real: 1, imaginary: 2), Complex<Int8>(real: -5, imaginary: 10))
         testMultiplication(Complex<Int16>(real: 3, imaginary: 4), Complex<Int16>(real: 1, imaginary: 2), Complex<Int16>(real: -5, imaginary: 10))
@@ -160,6 +186,19 @@ class ComplexArithmeticTests: XCTestCase {
         testMultiplication(Complex<Float80>(real: 3.0, imaginary: 4.0), 2.0)
     }
 
+    func testMultiplicationIgnoringOverflow() {
+        testMultiplicationIgnoringOverflow(forType: Int8.self)
+        testMultiplicationIgnoringOverflow(forType: Int16.self)
+        testMultiplicationIgnoringOverflow(forType: Int32.self)
+        testMultiplicationIgnoringOverflow(forType: Int64.self)
+        testMultiplicationIgnoringOverflow(forType: Int.self)
+        testMultiplicationIgnoringOverflow(forType: UInt8.self)
+        testMultiplicationIgnoringOverflow(forType: UInt16.self)
+        testMultiplicationIgnoringOverflow(forType: UInt32.self)
+        testMultiplicationIgnoringOverflow(forType: UInt64.self)
+        testMultiplicationIgnoringOverflow(forType: UInt.self)
+    }
+
     func testComponentwiseMultiplication() {
         testComponentwiseMultiplication(Complex<Int8>(real: 3, imaginary: 4), Complex<Int8>(real: 1, imaginary: 2))
         testComponentwiseMultiplication(Complex<Int16>(real: 3, imaginary: 4), Complex<Int16>(real: 1, imaginary: 2))
@@ -316,8 +355,62 @@ class ComplexArithmeticTests: XCTestCase {
         XCTAssertEqual(complex, result, file: file, line: line)
     }
 
+    private func testAdditionIgnoringOverflow<Scalar>(forType: Scalar.Type, file: StaticString = #file, line: UInt = #line) where Scalar: FixedWidthInteger {
+        // The test is defined to "succeed" if it doesn't crash
+        let lhs = Complex<Scalar>(real: Scalar.max, imaginary: Scalar.max)
+        let rhs = Complex<Scalar>(real: Scalar.max, imaginary: Scalar.max)
+        let rhs2 = Scalar.max
+
+        _ = lhs &+ rhs
+        _ = rhs &+ lhs
+        _ = lhs .&+ rhs
+        _ = rhs .&+ lhs
+        _ = lhs &+ rhs2
+        _ = rhs2 &+ lhs
+
+        var complex = lhs
+        complex &+= rhs
+
+        complex = rhs
+        complex &+= lhs
+
+        complex = lhs
+        complex .&+= rhs
+
+        complex = rhs
+        complex .&+= lhs
+
+        if Scalar.isSigned {
+            // If the scalar is signed each min is the smallest negative number. Adding these
+            // two together would overflow.
+            let lhs = Complex<Scalar>(real: Scalar.min, imaginary: Scalar.min)
+            let rhs = Complex<Scalar>(real: Scalar.min, imaginary: Scalar.min)
+
+            _ = lhs &+ rhs
+            _ = rhs &+ lhs
+            _ = lhs .&+ rhs
+            _ = rhs .&+ lhs
+
+            var complex = lhs
+            complex &+= rhs
+
+            complex = lhs
+            complex &+= rhs2
+
+            complex = rhs
+            complex &+= lhs
+
+            complex = lhs
+            complex .&+= rhs
+
+            complex = rhs
+            complex .&+= lhs
+        }
+    }
+
     private func testSubtraction<Scalar>(_ lhs: Complex<Scalar>, _ rhs: Complex<Scalar>, _ result: Complex<Scalar>, file: StaticString = #file, line: UInt = #line) {
         XCTAssertEqual(lhs - rhs, result, file: file, line: line)
+        XCTAssertEqual(lhs .- rhs, result, file: file, line: line)
 
         var complex = lhs
         complex -= rhs
@@ -368,6 +461,47 @@ class ComplexArithmeticTests: XCTestCase {
         XCTAssertEqual(complex, result, file: file, line: line)
     }
 
+    private func testSubtractionIgnoringOverflow<Scalar>(forType: Scalar.Type, file: StaticString = #file, line: UInt = #line) where Scalar: FixedWidthInteger {
+        // The test is defined to "succeed" if it doesn't crash
+        let lhs = Complex<Scalar>(real: Scalar.min, imaginary: Scalar.min)
+        let rhs = Complex<Scalar>(real: Scalar.max, imaginary: Scalar.max)
+        let rhs2 = Scalar.max
+        let rhs3 = Scalar.min
+
+        _ = lhs &- rhs
+        _ = lhs .&- rhs
+        _ = lhs &- rhs2
+        _ = rhs3 &- rhs
+
+        var complex = lhs
+        complex &-= rhs
+
+        complex = lhs
+        complex &-= rhs2
+
+        complex = lhs
+        complex .&-= rhs
+
+        if Scalar.isSigned {
+            // If the scalar is signed each min is the smallest negative number. Subtracting
+            // these from the max would overflow.
+            let lhs = Complex<Scalar>(real: Scalar.max, imaginary: Scalar.max)
+            let rhs = Complex<Scalar>(real: Scalar.min, imaginary: Scalar.min)
+
+            _ = lhs &- rhs
+            _ = lhs .&- rhs
+
+            var complex = lhs
+            complex &-= rhs
+
+            complex = lhs
+            complex &-= rhs3
+
+            complex = lhs
+            complex .&-= rhs
+        }
+    }
+
     private func testMultiplication<Scalar>(_ lhs: Complex<Scalar>, _ rhs: Complex<Scalar>, _ result: Complex<Scalar>, file: StaticString = #file, line: UInt = #line) {
         XCTAssertEqual(lhs * rhs, result, file: file, line: line)
         XCTAssertEqual(rhs * lhs, result, file: file, line: line)
@@ -381,6 +515,35 @@ class ComplexArithmeticTests: XCTestCase {
         XCTAssertEqual(complex, result, file: file, line: line)
     }
 
+    private func testMultiplicationIgnoringOverflow<Scalar>(forType: Scalar.Type, file: StaticString = #file, line: UInt = #line) where Scalar: FixedWidthInteger {
+        // The test is defined to "succeed" if it doesn't crash
+        let lhs = Complex<Scalar>(real: Scalar.max, imaginary: Scalar.max)
+        let rhs = Complex<Scalar>(real: Scalar.max, imaginary: Scalar.max)
+        let rhs2 = Scalar.max
+
+        _ = lhs &* rhs
+        _ = rhs &* lhs
+        _ = lhs .&* rhs
+        _ = rhs .&* lhs
+        _ = lhs &* rhs2
+        _ = rhs2 &* lhs
+
+        var complex = lhs
+        complex &*= rhs
+
+        complex = rhs
+        complex &*= lhs
+
+        complex = lhs
+        complex &*= rhs2
+
+        complex = lhs
+        complex .&*= rhs
+
+        complex = rhs
+        complex .&*= lhs
+    }
+
     private func testMultiplication<Scalar>(_ lhs: Complex<Scalar>, _ rhs: Scalar, file: StaticString = #file, line: UInt = #line) {
         let result = Complex(real: lhs.real * rhs, imaginary: lhs.imaginary * rhs)
         XCTAssertEqual(lhs * rhs, result, file: file, line: line)