Merge pull request #162 from apple/complex-elfns

Conform Complex to Elementary Functions

Author: stephentyrone

Package.swift

@@ -13,23 +13,30 @@
 import PackageDescription
 
 let package = Package(
+  
   name: "swift-numerics",
   products: [
     .library(name: "ComplexModule", targets: ["ComplexModule"]),
     .library(name: "Numerics", targets: ["Numerics"]),
     .library(name: "RealModule", targets: ["RealModule"]),
   ],
-  dependencies: [
-  ],
+  
   targets: [
+    // User-facing modules
     .target(name: "ComplexModule", dependencies: ["RealModule"]),
     .target(name: "Numerics", dependencies: ["ComplexModule", "RealModule"]),
     .target(name: "RealModule", dependencies: ["_NumericsShims"]),
 
+    // Implementation details
     .target(name: "_NumericsShims", dependencies: []),
     .target(name: "_TestSupport", dependencies: ["Numerics"]),
 
+    // Unit test bundles
     .testTarget(name: "ComplexTests", dependencies: ["_TestSupport"]),
     .testTarget(name: "RealTests", dependencies: ["_TestSupport"]),
+    
+    // Test executables
+    .target(name: "ComplexLog", dependencies: ["Numerics", "_TestSupport"], path: "Tests/Executable/ComplexLog"),
+    .target(name: "ComplexLog1p", dependencies: ["Numerics", "_TestSupport"], path: "Tests/Executable/ComplexLog1p")
   ]
 )

Sources/ComplexModule/CMakeLists.txt

@@ -10,7 +10,8 @@ See https://swift.org/LICENSE.txt for license information
 add_library(ComplexModule
   Arithmetic.swift
   Complex.swift
-  Differentiable.swift)
+  Differentiable.swift
+  ElementaryFunctions.swift)
 set_target_properties(ComplexModule PROPERTIES
   INTERFACE_INCLUDE_DIRECTORIES ${CMAKE_Swift_MODULE_DIRECTORY})
 target_link_libraries(ComplexModule PUBLIC

Sources/ComplexModule/ElementaryFunctions.swift

@@ -0,0 +1,29 @@
+//===--- AugmentedArithmetic.swift ----------------------------*- swift -*-===//
+//
+// This source file is part of the Swift Numerics open source project
+//
+// Copyright (c) 2020 Apple Inc. and the Swift Numerics project authors
+// Licensed under Apache License v2.0 with Runtime Library Exception
+//
+// See https://swift.org/LICENSE.txt for license information
+//
+//===----------------------------------------------------------------------===//
+
+public enum Augmented { }
+
+extension Augmented {
+  @_transparent
+  public static func twoProdFMA<T:Real>(_ a: T, _ b: T) -> (head: T, tail: T) {
+    let head = a*b
+    let tail = (-head).addingProduct(a, b)
+    return (head, tail)
+  }
+  
+  @_transparent
+  public static func fastTwoSum<T:Real>(_ a: T, _ b: T) -> (head: T, tail: T) {
+    assert(!(b.magnitude > a.magnitude))
+    let head = a + b
+    let tail = a - head + b
+    return (head, tail)
+  }
+}

Sources/RealModule/AugmentedArithmetic.swift

@@ -417,4 +417,10 @@ HEADER_SHIM CComplex libm_cmul(CComplex z, CComplex w) {
   double _Complex c = a*b;
   return (CComplex){ __real__ c, __imag__ c };
 }
+
+HEADER_SHIM CComplex libm_catanh(CComplex z) {
+  double _Complex a = { z.real, z.imag };
+  double _Complex w = __builtin_catanh(a);
+  return (CComplex){ __real__ w, __imag__ w };
+}
 #endif // !defined _WIN32

Sources/_NumericsShims/include/_NumericsShims.h

@@ -0,0 +1,31 @@
+//===--- Error.swift ------------------------------------------*- swift -*-===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2020 Apple Inc. and the Swift project authors
+// Licensed under Apache License v2.0 with Runtime Library Exception
+//
+// See https://swift.org/LICENSE.txt for license information
+// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
+//
+//===----------------------------------------------------------------------===//
+
+import ComplexModule
+
+public func relativeError(_ tst: Float, _ ref: Double) -> Double {
+  let scale = max(ref.magnitude, Double(Float.leastNormalMagnitude))
+  let error = (Double(tst) - ref).magnitude
+  return error / scale
+}
+
+public func componentwiseError(_ tst: Complex<Float>, _ ref: Complex<Double>) -> Double {
+  return max(relativeError(tst.real, ref.real),
+             relativeError(tst.imaginary, ref.imaginary))
+}
+
+public func relativeError(_ tst: Complex<Float>, _ ref: Complex<Double>) -> Double {
+  let scale = max(ref.magnitude, Double(Float.leastNormalMagnitude))
+  let dtst = Complex(Double(tst.real), Double(tst.imaginary))
+  let error = (dtst - ref).magnitude
+  return error / scale
+}

Sources/_TestSupport/Error.swift

@@ -0,0 +1,51 @@
+//===--- Interval.swift ---------------------------------------*- swift -*-===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2020 Apple Inc. and the Swift project authors
+// Licensed under Apache License v2.0 with Runtime Library Exception
+//
+// See https://swift.org/LICENSE.txt for license information
+// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
+//
+//===----------------------------------------------------------------------===//
+
+// A not-particularly-clever floating-point iterval that is iterable for the
+// purposes of testing.
+public struct Interval<Element>: Sequence where Element: FloatingPoint {
+  
+  let lower: Element
+  
+  let upper: Element
+  
+  public init(from: Element, through: Element) {
+    precondition(from <= through)
+    lower = from
+    upper = through
+  }
+  
+  public init(from: Element, to: Element) {
+    self.init(from: from, through: to.nextDown)
+  }
+  
+  public func makeIterator() -> Iterator {
+    Iterator(self)
+  }
+  
+  public struct Iterator: IteratorProtocol {
+    let interval: Interval
+    var nextOutput: Element?
+    
+    init(_ interval: Interval) {
+      self.interval = interval
+      self.nextOutput = interval.lower
+    }
+    
+    public mutating func next() -> Element? {
+      let result = nextOutput
+      if nextOutput == interval.upper { nextOutput = nil }
+      else { nextOutput = nextOutput?.nextUp }
+      return result
+    }
+  }
+}

Sources/_TestSupport/Interval.swift

@@ -2,86 +2,15 @@
 //
 // This source file is part of the Swift Numerics open source project
 //
-// Copyright (c) 2019 Apple Inc. and the Swift Numerics project authors
+// Copyright (c) 2019-2020 Apple Inc. and the Swift Numerics project authors
 // Licensed under Apache License v2.0 with Runtime Library Exception
 //
 // See https://swift.org/LICENSE.txt for license information
 //
 //===----------------------------------------------------------------------===//
 
-import XCTest
 import RealModule
 
-#if (arch(i386) || arch(x86_64)) && !os(Windows) && !os(Android)
-public typealias TestLiteralType = Float80
-#else
-public typealias TestLiteralType = Double
-#endif
-
-@discardableResult
-public func assertClose<T>(
-  _ expected: TestLiteralType,
-  _ observed: T,
-  allowedError: T = 16,
-  file: StaticString = #file,
-  line: UInt = #line
-) -> T where T: BinaryFloatingPoint {
-  // Shortcut relative-error check if we got the sign wrong; it's OK to
-  // underflow to zero, but we do not want to allow going right through
-  // zero and getting the sign wrong.
-  guard observed.sign == expected.sign else {
-    print("Sign was wrong: expected \(expected) but saw \(observed).")
-    XCTFail(file: file, line: line)
-    return .infinity
-  }
-  if observed.isNaN && expected.isNaN { return 0 }
-  // If T(expected) is zero or infinite, and matches observed, the error
-  // is zero.
-  let expectedT = T(expected)
-  if observed.isZero && expectedT.isZero { return 0 }
-  if observed.isInfinite && expectedT.isInfinite { return 0 }
-  // Special-case where only one of expectedT or observed is infinity.
-  // Artificially knock everything down a binade, treat actual infinity as
-  // the base of the next binade up.
-  func topBinade(signOf x: T) -> T {
-    T(signOf: x, magnitudeOf: T.greatestFiniteMagnitude.binade)
-  }
-  if observed.isInfinite {
-    return assertClose(
-      expected/2, topBinade(signOf: observed),
-      allowedError: allowedError, file: file, line: line
-    )
-  }
-  if expectedT.isInfinite {
-    return assertClose(
-      TestLiteralType(topBinade(signOf: expectedT)), observed/2,
-      allowedError: allowedError, file: file, line: line
-    )
-  }
-  // Compute error in ulp, compare to tolerance.
-  let absoluteError = (TestLiteralType(observed) - expected).magnitude
-  let scale = max(expectedT.magnitude, T.leastNormalMagnitude).ulp
-  let ulps = T(absoluteError/TestLiteralType(scale))
-  if ulps > allowedError {
-    print("ULP error was unacceptably large: expected \(expected) but saw \(observed) (\(ulps)-ulp error).")
-    XCTFail(file: file, line: line)
-  }
-  return ulps
-}
-
-public func assertClose<T>(
-  _ expected: TestLiteralType,
-  _ observed: T,
-  allowedError: T = 16,
-  worstError: inout T,
-  file: StaticString = #file,
-  line: UInt = #line
-) where T: BinaryFloatingPoint {
-  worstError = max(worstError, assertClose(
-    expected, observed, allowedError: allowedError, file: file, line: line
-  ))
-}
-
 public protocol FixedWidthFloatingPoint: BinaryFloatingPoint
 where Exponent: FixedWidthInteger,
       RawSignificand: FixedWidthInteger { }

Sources/_TestSupport/RealTestSupport.swift

@@ -11,6 +11,7 @@ add_library(ComplexTests
   ApproximateEqualityTests.swift
   ArithmeticTests.swift
   DifferentiableTests.swift
+  ElementaryFunctionTests.swift
   PropertyTests.swift)
 set_target_properties(ComplexTests PROPERTIES
   INTERFACE_INCLUDE_DIRECTORIES ${CMAKE_Swift_MODULE_DIRECTORY})