Author SHA1 Message Date
Stephen Canon e0ec0f5f3a Cherry-pick pow edge case fixes from main. 2025-03-03 11:13:12 -05:00
Stephen Canon aa76ee5658 Link the system math library explicitly when building for Android and Linux 2025-02-25 15:17:29 -05:00
Stephen Canon d42ab140f7 Merge pull request #299 from stephentyrone/sendable-minimum-swift
Restrict sendable conformance for Complex to 5.5 and higher.
2025-02-20 17:40:06 -05:00
Stephen Canon 77b98fab75 Merge branch 'release/1.0' into sendable-minimum-swift 2025-02-20 17:39:57 -05:00
Stephen Canon ba43341621 Add explicit import of RealModule to support Swift 6. 2025-02-20 17:39:20 -05:00
Stephen Canon 6a3ecdb480 Restrict sendable conformance for Complex to 5.5 and higher. 2025-02-20 17:26:04 -05:00
Stephen Canon 803aae1ef0 Conditionally conform Complex to Sendable. 2025-02-20 16:59:36 -05:00
Stephen Canon db4ef5686a Merge pull request #270 from stephentyrone/fix-tvOS-availability-1.0
Correct tvOS availability for Float16 in _TestSupport.
2023-09-28 14:55:25 -04:00
Stephen Canon a85dd8c2bb Correct tvOS availability for Float16 in _TestSupport. 2023-09-20 09:59:46 -04:00
Stephen Canon 0a5bc04095 Merge pull request #215 from stephentyrone/arm64-mac-cmake-1.0
add arm64 support for M1 Mac
2021-11-18 09:21:09 -05:00
bob a6bea6639c add arm64 support for M1 Mac 2021-11-18 09:18:40 -05:00
Stephen Canon 0a23770641 Merge pull request #198 from stephentyrone/clarify-stability-differentiable
Clarify that differentaible API is not stable.
2021-08-31 16:29:00 -04:00
Stephen Canon d560765047 Clarify that differentaible API is not stable. 2021-08-31 16:26:17 -04:00
Stephen Canon 1e5cbc4e21 Merge pull request #195 from stephentyrone/readme-semver-1.0
Update README for 1.0.0.
2021-08-31 11:34:42 -04:00
Stephen Canon b4ec7556e9 Update README for 1.0.0. 2021-08-31 11:31:30 -04:00
Stephen Canon 79f6025798 Merge pull request #193 from stephentyrone/cherry-pick-doc-changes-from-main
Cherry pick doc changes from main
2021-08-27 09:38:44 -04:00
Stephen Canon 03c5840722 Merge pull request #194 from stephentyrone/source-stability-api
Add notes about what the public API is.
2021-08-27 09:38:19 -04:00
Stephen Canon ed66862a2c Add notes about what the public API is. 2021-08-27 09:36:56 -04:00
Stephen Canon bcde4bc513 Comment cleanups. 2021-08-27 09:25:57 -04:00
Stephen Canon 58f95289a0 Merge pull request #185 from stephentyrone/reciprocal-documentation
Further expand documentation of `reciprocal` with some example use.
2021-08-27 09:09:21 -04:00
Stephen Canon 832dac1ef8 Merge pull request #184 from stephentyrone/document-real-reciprocal-1.0
Merge pull request #182 from stephentyrone/more-documentation-for-1.0
2021-08-19 19:41:47 -04:00
Stephen Canon 419caa222f Merge pull request #182 from stephentyrone/more-documentation-for-1.0
Add some documentation for AlgebraicField ops, minor fix for Augmented.
2021-08-19 19:38:54 -04:00
Stephen Canon 5a0aedbccd Merge pull request #183 from stephentyrone/deprecations-for-1.0
Add deprecation warnings for old Augmented names in release/1.0
2021-08-19 19:38:17 -04:00
Stephen Canon 8e3d889b5f Add deprecation warnings for old Augmented names in release/1.0 2021-08-19 19:35:06 -04:00
Stephen Canon 92f0095962 Document the Augmented enum in RealModule in advance of 1.0 2021-08-19 14:08:22 -04:00
71 changed files with 1104 additions and 7080 deletions

No files matched your search

-4
View File
@@ -1,4 +0,0 @@
version: 1
builder:
configs:
- documentation_targets: [Numerics, RealModule, ComplexModule, BigIntModule]
+14 -77
View File
@@ -1,9 +1,9 @@
// swift-tools-version:5.5
// swift-tools-version:5.2
//===--- Package.swift ----------------------------------------*- swift -*-===//
//
// This source file is part of the Swift Numerics open source project
//
// Copyright (c) 2019-2021 Apple Inc. and the Swift Numerics project authors
// Copyright (c) 2019 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
@@ -12,100 +12,37 @@
import PackageDescription
let excludedFilenames = ["CMakeLists.txt", "README.md"]
let package = Package(
name: "swift-numerics",
products: [
.library(name: "BigIntModule", targets: ["BigIntModule"]),
.library(name: "ComplexModule", targets: ["ComplexModule"]),
.library(name: "Numerics", targets: ["Numerics"]),
.library(name: "RealModule", targets: ["RealModule"]),
],
targets: [
// MARK: - Public API
.target(
name: "BigIntModule",
dependencies: [],
exclude: excludedFilenames
),
.target(
name: "ComplexModule",
dependencies: ["RealModule"],
exclude: excludedFilenames
),
.target(
name: "IntegerUtilities",
dependencies: [],
exclude: excludedFilenames
),
.target(
name: "Numerics",
dependencies: ["ComplexModule", "IntegerUtilities", "RealModule", "BigIntModule"],
exclude: excludedFilenames
),
// User-facing modules
.target(name: "ComplexModule", dependencies: ["RealModule"]),
.target(name: "Numerics", dependencies: ["ComplexModule", "RealModule"]),
.target(
name: "RealModule",
dependencies: ["_NumericsShims"],
exclude: excludedFilenames,
linkerSettings: [
.linkedLibrary("m", .when(platforms: [.linux, .android]))
]
),
// MARK: - Implementation details
.target(
name: "_NumericsShims",
exclude: excludedFilenames
),
// Implementation details
.target(name: "_NumericsShims", dependencies: []),
.target(name: "_TestSupport", dependencies: ["Numerics"]),
.target(
name: "_TestSupport",
dependencies: ["Numerics"],
exclude: ["CMakeLists.txt"]
),
// Unit test bundles
.testTarget(name: "ComplexTests", dependencies: ["_TestSupport"]),
.testTarget(name: "RealTests", dependencies: ["_TestSupport"]),
// MARK: - Unit test bundles
.testTarget(
name: "BigIntTests",
dependencies: ["BigIntModule"]
),
.testTarget(
name: "ComplexTests",
dependencies: ["_TestSupport"],
exclude: ["CMakeLists.txt"]
),
.testTarget(
name: "IntegerUtilitiesTests",
dependencies: ["IntegerUtilities", "_TestSupport"],
exclude: ["CMakeLists.txt"]
),
.testTarget(
name: "RealTests",
dependencies: ["_TestSupport"],
exclude: ["CMakeLists.txt"]
),
// MARK: - Test executables
.executableTarget(
name: "ComplexLog",
dependencies: ["Numerics", "_TestSupport"],
path: "Tests/Executable/ComplexLog"
),
.executableTarget(
name: "ComplexLog1p",
dependencies: ["Numerics", "_TestSupport"],
path: "Tests/Executable/ComplexLog1p"
)
// Test executables
.target(name: "ComplexLog", dependencies: ["Numerics", "_TestSupport"], path: "Tests/Executable/ComplexLog"),
.target(name: "ComplexLog1p", dependencies: ["Numerics", "_TestSupport"], path: "Tests/Executable/ComplexLog1p")
]
)
+46
View File
@@ -0,0 +1,46 @@
// swift-tools-version:5.0
//===--- Package@swift-5.0.swift ------------------------------*- swift -*-===//
//
// This source file is part of the Swift Numerics open source project
//
// Copyright (c) 2019 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 PackageDescription
let package = Package(
name: "swift-numerics",
products: [
.library(name: "ComplexModule", targets: ["ComplexModule"]),
.library(name: "Numerics", targets: ["Numerics"]),
.library(name: "RealModule", targets: ["RealModule"]),
],
targets: [
// User-facing modules
.target(name: "ComplexModule", dependencies: ["RealModule"]),
.target(name: "Numerics", dependencies: ["ComplexModule", "RealModule"]),
.target(
name: "RealModule",
dependencies: ["_NumericsShims"],
linkerSettings: [ .linkedLibrary("m", .when(platforms: [.linux])) ]
),
// 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")
]
)
-111
View File
@@ -1,111 +0,0 @@
// swift-tools-version:5.4
//===--- Package.swift ----------------------------------------*- swift -*-===//
//
// This source file is part of the Swift Numerics open source project
//
// Copyright (c) 2019-2021 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 PackageDescription
let excludedFilenames = ["CMakeLists.txt", "README.md"]
let package = Package(
name: "swift-numerics",
products: [
.library(name: "BigIntModule", targets: ["BigIntModule"]),
.library(name: "ComplexModule", targets: ["ComplexModule"]),
.library(name: "Numerics", targets: ["Numerics"]),
.library(name: "RealModule", targets: ["RealModule"]),
],
targets: [
// MARK: - Public API
.target(
name: "BigIntModule",
dependencies: [],
exclude: excludedFilenames
),
.target(
name: "ComplexModule",
dependencies: ["RealModule"],
exclude: excludedFilenames
),
.target(
name: "IntegerUtilities",
dependencies: [],
exclude: excludedFilenames
),
.target(
name: "Numerics",
dependencies: ["ComplexModule", "IntegerUtilities", "RealModule", "BigIntModule"],
exclude: excludedFilenames
),
.target(
name: "RealModule",
dependencies: ["_NumericsShims"],
exclude: excludedFilenames,
linkerSettings: [
.linkedLibrary("m", .when(platforms: [.linux, .android]))
]
),
// MARK: - Implementation details
.target(
name: "_NumericsShims",
exclude: excludedFilenames
),
.target(
name: "_TestSupport",
dependencies: ["Numerics"],
exclude: ["CMakeLists.txt"]
),
// MARK: - Unit test bundles
.testTarget(
name: "BigIntTests",
dependencies: ["BigIntModule"]
),
.testTarget(
name: "ComplexTests",
dependencies: ["_TestSupport"],
exclude: ["CMakeLists.txt"]
),
.testTarget(
name: "IntegerUtilitiesTests",
dependencies: ["IntegerUtilities", "_TestSupport"],
exclude: ["CMakeLists.txt"]
),
.testTarget(
name: "RealTests",
dependencies: ["_TestSupport"],
exclude: ["CMakeLists.txt"]
),
// MARK: - Test executables
.executableTarget(
name: "ComplexLog",
dependencies: ["Numerics", "_TestSupport"],
path: "Tests/Executable/ComplexLog"
),
.executableTarget(
name: "ComplexLog1p",
dependencies: ["Numerics", "_TestSupport"],
path: "Tests/Executable/ComplexLog1p"
)
]
)
+25 -25
View File
@@ -11,7 +11,7 @@ These modules fall broadly into two categories:
There is some overlap between these two categories, and an API that begins in the first category may migrate into the second as it matures and new uses are discovered.
Swift Numerics modules are fine-grained.
For example, if you need support for Complex numbers, you can import ComplexModule[^1] as a standalone module:
For example, if you need support for Complex numbers, you can import ComplexModule¹ as a standalone module:
```swift
import ComplexModule
@@ -59,7 +59,7 @@ To use Swift Numerics in a SwiftPM project:
## Source stability
The Swift Numerics package is source stable; version numbers follow [Semantic Versioning](https://semver.org).
The public API of the `swift-numerics` package consists of non-underscored declarations that are marked either `public` or `usableFromInline` in modules re-exported by the top-level `Numerics` module.
The public API of the `swift-numerics` package consists of non-underscored declarations that are marked either `public` or `usableFromInline` in modules re-exported by the top-level `Numerics` module, *excepting any API that involves a conformance to Differentiable (because Differentiable itself is not stable in Swift)*.
Interfaces that aren't part of the public API may continue to change in any release, including patch releases.
Note that contents of the `_NumericsShims` and `_TestSupport` modules, as well as contents of the `Tests` directory, explicitly are not public API.
@@ -105,8 +105,6 @@ Questions about how to use Swift Numerics modules, or issues that are not clearl
1. [`RealModule`](Sources/RealModule/README.md)
2. [`ComplexModule`](Sources/ComplexModule/README.md)
3. [`IntegerUtilities`](Sources/IntegerUtilities/README.md) (on main only, not yet present in a released tag)
4. [`BigIntModule`](Sources/BigIntModule/README.md) (on branch only)
## Future expansion
@@ -115,26 +113,28 @@ Questions about how to use Swift Numerics modules, or issues that are not clearl
3. [Shaped Arrays](https://github.com/apple/swift-numerics/issues/6)
4. [Decimal Floating-point](https://github.com/apple/swift-numerics/issues/7)
[^1]: The module is named `ComplexModule` instead of `Complex` because Swift is currently unable to use the fully-qualified name for types when a type and module have the same name (discussion here: https://forums.swift.org/t/pitch-fully-qualified-name-syntax/28482).
This would prevent users of Swift Numerics who don't need generic types from doing things such as:
## Notes
```swift
import Complex
// I know I only ever want Complex<Double>, so I shouldn't need the generic parameter.
typealias Complex = Complex.Complex<Double> // This doesn't work, because name lookup fails.
```
For this reason, modules that would have this ambiguity are suffixed with `Module` within Swift Numerics:
```swift
import ComplexModule
// I know I only ever want Complex<Double>, so I shouldn't need the generic parameter.
typealias Complex = ComplexModule.Complex<Double>
// But I can still refer to the generic type by qualifying the name if I need it occasionally:
let a = ComplexModule.Complex<Float>
```
¹ Swift is currently unable to use the fully-qualified name for types when a type and module have the same name (discussion here: https://forums.swift.org/t/pitch-fully-qualified-name-syntax/28482).
This would prevent users of Swift Numerics who don't need generic types from doing things such as:
The `Real` module does not contain a `Real` type, but does contain a `Real` protocol.
Users may want to define their own `Real` type (and possibly re-export the `Real` module)--that is why the suffix is also applied there.
New modules have to evaluate this decision carefully, but can err on the side of adding the suffix.
It's expected that most users will simply `import Numerics`, so this isn't an issue for them.
```swift
import Complex
// I know I only ever want Complex<Double>, so I shouldn't need the generic parameter.
typealias Complex = Complex.Complex<Double> // This doesn't work, because name lookup fails.
```
For this reason, modules that would have this ambiguity are suffixed with `Module` within Swift Numerics:
```swift
import ComplexModule
// I know I only ever want Complex<Double>, so I shouldn't need the generic parameter.
typealias Complex = ComplexModule.Complex<Double>
// But I can still refer to the generic type by qualifying the name if I need it occasionally:
let a = ComplexModule.Complex<Float>
```
The `Real` module does not contain a `Real` type, but does contain a `Real` protocol.
Users may want to define their own `Real` type (and possibly re-export the `Real` module)--that is why the suffix is also applied there.
New modules have to evaluate this decision carefully, but can err on the side of adding the suffix.
It's expected that most users will simply `import Numerics`, so this isn't an issue for them.
-810
View File
@@ -1,810 +0,0 @@
//===--- BigInt.swift -----------------------------------------*- swift -*-===//
//
// This source file is part of the Swift Numerics open source project
//
// 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
//
//===----------------------------------------------------------------------===//
public struct BigInt: SignedInteger {
public typealias Words = [UInt]
public private(set) var words: Words
@usableFromInline
internal init(_uncheckedWords: Words) {
self.words = _uncheckedWords
}
public init<T>(bitPattern source: T) where T: BinaryInteger {
words = Words(source.words)
BigInt._dropExcessWords(words: &words)
}
@usableFromInline
internal var _isNegative: Bool {
words[words.endIndex - 1] > Int.max
}
private static let _digits: [BigInt] = (0 ... 36).map {
BigInt(_uncheckedWords: [UInt(bitPattern: $0)])
}
private static let _digitRadix = BigInt(_uncheckedWords: [0, 1])
}
// MARK: - Basic Behaviors
extension BigInt: Equatable {
@inlinable
public static func == (lhs: BigInt, rhs: BigInt) -> Bool {
lhs.words == rhs.words
}
@inlinable
public static func != (lhs: BigInt, rhs: BigInt) -> Bool {
!(lhs == rhs)
}
}
extension BigInt: Hashable {
@inlinable
public func hash(into hasher: inout Hasher) {
hasher.combine(words)
}
}
extension BigInt: Comparable {
@inlinable
public static func < (lhs: BigInt, rhs: BigInt) -> Bool {
let lhsNegative = lhs._isNegative
let rhsNegative = rhs._isNegative
if lhsNegative && !rhsNegative { return true }
if rhsNegative && !lhsNegative { return false }
if (lhsNegative && rhsNegative) || (!lhsNegative && !rhsNegative) {
if lhs.words.count > rhs.words.count {
return lhsNegative ? true : false
}
if lhs.words.count < rhs.words.count {
return lhsNegative ? false : true
}
for i in stride(from: lhs.words.count - 1, through: 0, by: -1) {
if lhs.words[i] > rhs.words[i] {
return false
} else if lhs.words[i] < rhs.words[i] {
return true
}
}
}
return false
}
}
extension BigInt: LosslessStringConvertible {
public init?(_ description: String) {
self.init(description, radix: 10)
}
public init?<T>(_ description: T, radix: Int = 10) where T: StringProtocol {
precondition(2 ... 36 ~= radix, "Radix not in range 2 ... 36")
self = 0
let isNegative = description.hasPrefix("-")
let hasPrefix = isNegative || description.hasPrefix("+")
let utf8 = description.utf8.dropFirst(hasPrefix ? 1 : 0)
guard !utf8.isEmpty else { return nil }
for var byte in utf8 {
switch byte {
case UInt8(ascii: "0") ... UInt8(ascii: "9"):
byte -= UInt8(ascii: "0")
case UInt8(ascii: "A") ... UInt8(ascii: "Z"):
byte -= UInt8(ascii: "A")
byte += 10
case UInt8(ascii: "a") ... UInt8(ascii: "z"):
byte -= UInt8(ascii: "a")
byte += 10
default:
return nil
}
guard byte < radix else { return nil }
self *= BigInt._digits[radix]
self += BigInt._digits[Int(byte)]
}
if isNegative {
self.negate()
}
}
}
extension BigInt: Decodable {
public init(from decoder: Decoder) throws {
let singleValueContainer = try decoder.singleValueContainer()
let description = try singleValueContainer.decode(String.self)
guard let result = BigInt(description) else {
throw DecodingError.dataCorruptedError(
in: singleValueContainer,
debugDescription: "BigInt(\(description.debugDescription)) failed")
}
self = result
}
}
extension BigInt: Encodable {
public func encode(to encoder: Encoder) throws {
var singleValueContainer = encoder.singleValueContainer()
try singleValueContainer.encode(description)
}
}
// MARK: - Numeric Protocols
extension BigInt: ExpressibleByIntegerLiteral {
public init(integerLiteral value: Int) {
if value >= 0, value < BigInt._digits.count {
self = BigInt._digits[value]
} else {
words = [UInt(bitPattern: value)]
}
}
}
extension BigInt: AdditiveArithmetic {
@inlinable
public static func + (lhs: BigInt, rhs: BigInt) -> BigInt {
var result = lhs
result += rhs
return result
}
public static func += (lhs: inout BigInt, rhs: BigInt) {
if lhs.words.count == 1, rhs.words.count == 1 {
let lhsWord = lhs.words[0]
let rhsWord = rhs.words[0]
let (result, isOverflow) = lhsWord.addingReportingOverflow(rhsWord)
if !isOverflow && result < Int.max {
lhs.words[0] = result
return
}
let knownNegativeResult = lhsWord > Int.max && rhsWord > Int.max
if lhsWord > Int.max || rhsWord > Int.max, !knownNegativeResult {
// positive + negative is always smaller, so overflow is a red herring
lhs.words[0] = result
return
}
}
var isOverflow = false
var rhsWords = rhs.words
lhs.words.append(lhs._isNegative ? UInt.max : 0)
rhsWords.append(rhs._isNegative ? UInt.max : 0)
BigInt._signExtend(lhsWords: &lhs.words, rhsWords: &rhsWords)
var temp: UInt = 0
for index in 0 ..< lhs.words.count {
var carryOverflow = false
if isOverflow {
(temp, carryOverflow) = rhsWords[index].addingReportingOverflow(1)
} else {
temp = rhsWords[index]
}
(lhs.words[index], isOverflow) = lhs.words[index].addingReportingOverflow(temp)
isOverflow = carryOverflow || isOverflow
}
BigInt._dropExcessWords(words: &lhs.words)
}
@inlinable
public static func - (lhs: BigInt, rhs: BigInt) -> BigInt {
var result = lhs
result -= rhs
return result
}
@inlinable
public static func -= (lhs: inout BigInt, rhs: BigInt) {
lhs += -rhs
}
}
extension BigInt: Numeric {
public init?<T>(exactly source: T) where T: BinaryInteger {
self.init(source)
}
public var magnitude: BigInt { _isNegative ? -self : self }
public static func * (lhs: BigInt, rhs: BigInt) -> BigInt {
let lhsIsNeg = lhs.words[lhs.words.endIndex - 1] > Int.max
let rhsIsNeg = rhs.words[rhs.words.endIndex - 1] > Int.max
let lhsWords = lhsIsNeg ? (-lhs).words : lhs.words
let rhsWords = rhsIsNeg ? (-rhs).words : rhs.words
let count = lhsWords.count + rhsWords.count + 1
var newWords = Words(repeating: 0, count: count)
for i in 0 ..< rhsWords.count {
var carry: UInt = 0
var digit: UInt = 0
var lastJ: Int = 0
for j in i ..< (lhsWords.count + i) {
var (high, low) = rhsWords[i].multipliedFullWidth(by: lhsWords[j - i])
var isOverflow: Bool
(digit, isOverflow) = low.addingReportingOverflow(newWords[j])
if isOverflow {
high += 1
}
(digit, isOverflow) = digit.addingReportingOverflow(carry)
if isOverflow {
high += 1
}
carry = high
newWords[j] = digit
lastJ = j
}
if carry != 0 {
let isOverflow: Bool
(digit, isOverflow) = newWords[lastJ + 1].addingReportingOverflow(carry)
if isOverflow {
carry = 1
}
newWords[lastJ + 1] = digit
}
}
for i in stride(from: count - 1, through: 1, by: -1) {
if newWords[i] == 0, newWords[i - 1] <= Int.max {
newWords.removeLast()
} else {
break
}
}
if lhsIsNeg || rhsIsNeg, !(lhsIsNeg && rhsIsNeg) {
return -BigInt(_uncheckedWords: newWords)
}
return BigInt(_uncheckedWords: newWords)
}
@inlinable
public static func *= (lhs: inout BigInt, rhs: BigInt) {
lhs = lhs * rhs
}
}
extension BigInt: SignedNumeric {
public mutating func negate() {
var isOverflow = true
for i in 0 ..< words.count {
if isOverflow {
(words[i], isOverflow) = (~words[i]).addingReportingOverflow(1)
} else {
words[i] = ~words[i]
}
}
BigInt._dropExcessWords(words: &words)
}
@inlinable
public static prefix func - (x: BigInt) -> BigInt {
var result = x
result.negate()
return result
}
}
extension BigInt: BinaryInteger {
public init?<T>(exactly source: T) where T: BinaryFloatingPoint {
guard source.isFinite, source == source.rounded(.towardZero) else {
return nil
}
self.init(source)
}
public init<T>(_ source: T) where T: BinaryFloatingPoint {
precondition(
source.isFinite,
"""
\(type(of: source)) value cannot be converted to BigInt because it is \
either infinite or NaN
""")
let isNegative = source < 0.0
var float = isNegative ? -source : source
if let _ = UInt(exactly: T.greatestFiniteMagnitude) {
words = [UInt(float)]
} else {
var words = Words()
let radix = T(sign: .plus, exponent: T.Exponent(UInt.bitWidth), significand: 1)
repeat {
let digit = UInt(float.truncatingRemainder(dividingBy: radix))
words.append(digit)
float = (float / radix).rounded(.towardZero)
} while float != 0
if let last = words.last, last >= Int.max {
words.append(0)
}
self.words = words
}
if isNegative {
self.negate()
}
}
public init<T>(_ source: T) where T: BinaryInteger {
if source >= 0, source < BigInt._digits.count {
self = BigInt._digits[Int(source)]
} else {
words = Words(source.words)
if source > 0 && source.words[source.words.endIndex - 1] > Int.max {
words.append(0)
}
// needed to handle sign-extended multi-word numbers that
// actually fit in a single word
BigInt._dropExcessWords(words: &words)
}
}
public init<T>(clamping source: T) where T: BinaryInteger {
self.init(source)
}
public init<T>(truncatingIfNeeded source: T) where T: BinaryInteger {
words = Words(source.words)
}
public var bitWidth: Int { words.count * UInt.bitWidth }
public var trailingZeroBitCount: Int {
var totalZeros = 0
for word in words {
if word == 0 {
totalZeros += UInt.bitWidth
} else {
totalZeros += word.trailingZeroBitCount
break
}
}
return totalZeros
}
@inlinable
public static func / (lhs: BigInt, rhs: BigInt) -> BigInt {
let (result, _) = _div(lhs: lhs, rhs: rhs)
return result
}
@inlinable
public static func /= (lhs: inout BigInt, rhs: BigInt) {
lhs = lhs / rhs
}
@inlinable
public static func % (lhs: BigInt, rhs: BigInt) -> BigInt {
let (_, result) = _div(lhs: lhs, rhs: rhs)
return result
}
@inlinable
public static func %= (lhs: inout BigInt, rhs: BigInt) {
lhs = lhs % rhs
}
@inlinable
public static prefix func ~ (x: BigInt) -> BigInt {
let newWords = x.words.map { ~$0 }
return BigInt(_uncheckedWords: Words(newWords))
}
public static func &= (lhs: inout BigInt, rhs: BigInt) {
var rhsWords = rhs.words
BigInt._signExtend(lhsWords: &lhs.words, rhsWords: &rhsWords)
for i in 0 ..< rhsWords.count {
lhs.words[i] &= rhsWords[i]
}
BigInt._dropExcessWords(words: &lhs.words)
}
public static func |= (lhs: inout BigInt, rhs: BigInt) {
var rhsWords = rhs.words
BigInt._signExtend(lhsWords: &lhs.words, rhsWords: &rhsWords)
for i in 0 ..< rhsWords.count {
lhs.words[i] |= rhsWords[i]
}
BigInt._dropExcessWords(words: &lhs.words)
}
public static func ^= (lhs: inout BigInt, rhs: BigInt) {
var rhsWords = rhs.words
BigInt._signExtend(lhsWords: &lhs.words, rhsWords: &rhsWords)
for i in 0 ..< rhsWords.count {
lhs.words[i] &= rhsWords[i]
}
BigInt._dropExcessWords(words: &lhs.words)
}
public static func <<= <RHS>(lhs: inout BigInt, rhs: RHS) where RHS: BinaryInteger {
if rhs.signum() < 0 {
lhs >>= rhs.magnitude
return
}
let wordLength = UInt.bitWidth
let isNegative = lhs._isNegative
let (fullWords, remainder) = rhs.quotientAndRemainder(dividingBy: RHS(wordLength))
lhs.words = Words(repeating: 0, count: Int(fullWords)) + lhs.words + [isNegative ? UInt.max : 0]
if remainder > 0 {
var value: UInt = 0
for i in 0 ..< lhs.words.count {
let temp = lhs.words[i] >> (wordLength - Int(remainder))
lhs.words[i] <<= Int(remainder)
if i > 0 {
lhs.words[i] &= UInt.max << Int(remainder)
lhs.words[i] |= value
}
value = temp
}
if isNegative {
lhs.words[lhs.words.count - 1] |= (UInt.max << Int(remainder))
}
}
BigInt._dropExcessWords(words: &lhs.words)
}
public static func >>= <RHS>(lhs: inout BigInt, rhs: RHS) where RHS: BinaryInteger {
if rhs.signum() < 0 {
lhs <<= rhs.magnitude
return
}
let wordLength = UInt.bitWidth
let isNegative = lhs._isNegative
let (fullWords, remainder) = rhs.quotientAndRemainder(dividingBy: RHS(wordLength))
if fullWords < lhs.words.count {
lhs.words.removeFirst(Int(fullWords))
} else {
lhs = isNegative ? -1 : 0
return
}
if remainder > 0 {
let mask = ~(UInt.max << remainder)
var value: UInt = 0
for i in stride(from: lhs.words.count - 1, through: 0, by: -1) {
let temp = lhs.words[i] & mask
lhs.words[i] >>= remainder
lhs.words[i] |= (value << (UInt.bitWidth - Int(remainder)))
value = temp
}
}
if isNegative {
lhs.words[lhs.words.count - 1] |= (UInt.max << (UInt.bitWidth - Int(remainder)))
}
BigInt._dropExcessWords(words: &lhs.words)
}
@inlinable
public func quotientAndRemainder(dividingBy rhs: BigInt) -> (quotient: BigInt, remainder: BigInt) {
return BigInt._div(lhs: self, rhs: rhs)
}
@inlinable
public func signum() -> BigInt { _isNegative ? -1 : (self == 0) ? 0 : 1 }
}
// MARK: -
extension BigInt {
/// See _The Art of Computer Programming_ volume 2 by Donald Knuth, Section 4.3.1: The Classical Algorithms
private static func _findQhat(
high: UInt,
low: UInt.Magnitude,
divisor: UInt,
nextVdigit: UInt,
nextUdigit: UInt
) -> UInt {
var qhat: Array<UInt>
var rhat: Array<UInt>
if high >= divisor {
let v = divisor
let u = [low, high]
var r: UInt = 0
qhat = Words(repeating: 0, count: 2)
for j in (0...1).reversed() {
let uj = u[j]
(qhat[j], r) = v.dividingFullWidth((r, uj))
}
BigInt._dropExcessWords(words: &qhat)
rhat = [r]
} else {
let (qhatWord, rhatWord) = divisor.dividingFullWidth((high, low))
qhat = [qhatWord]
rhat = [rhatWord]
}
repeat {
var qhatTooLarge = false
if qhat.count > 1 {
qhatTooLarge = true
} else {
// All of the following is computing and checking qhat*v_n-2 > rhat*b + u_j+n-2
// from TAoCP Volume 2 Section 4.3.1, Algorithm D, step D3
let (comp_lhs_hi, comp_lhs_lo) = qhat[0].multipliedFullWidth(by: nextVdigit)
if comp_lhs_hi > rhat[0] {
qhatTooLarge = true
} else if comp_lhs_hi == rhat[0] && comp_lhs_lo > nextUdigit {
qhatTooLarge = true
}
}
// high >= divisor is standing in for the test qhat >= b from Algorithm D step D3
if qhatTooLarge {
// begin qhat -= 1
if qhat.count == 1 {
qhat[0] -= 1
} else {
let (qlow, underflow) = qhat[0].subtractingReportingOverflow(1)
qhat[0] = qlow
if qhat[1] > 0 && underflow {
qhat[1] -= 1
if qhat[1] == 0 {
qhat.remove(at: 1)
}
}
}
// end qhat -= 1
// begin rhat += divisor
let (rhatResult, overflow) : (UInt, Bool)
if rhat.count == 1 || rhat[1] == 0 {
(rhatResult, overflow) = rhat[0].addingReportingOverflow(divisor)
rhat[0] = rhatResult
if overflow {
rhat.append(1)
}
} // we don't need an else because rhat is already larger than BigInt._digitRadix
// end rhat += divisor
} else {
break
}
} while rhat.count == 1 // equivalent to rhat < b
return qhat[0]
}
/// See _The Art of Computer Programming_ volume 2 by Donald Knuth, Section 4.3.1: The Classical Algorithms
@usableFromInline
internal static func _div(lhs: BigInt, rhs: BigInt) -> (quotient: BigInt, remainder: BigInt) {
precondition(rhs != _digits[0], "Division by zero error!")
if lhs.words.count == 1, rhs.words.count == 1 {
let (quot, rem) = Int(bitPattern: lhs.words[0]).quotientAndRemainder(dividingBy: Int(bitPattern: rhs.words[0]))
return (BigInt(_uncheckedWords: [UInt(bitPattern: quot)]), BigInt(_uncheckedWords: [UInt(bitPattern: rem)]))
}
let lhsIsNeg = lhs._isNegative
let rhsIsNeg = rhs._isNegative
var lhsWords = lhsIsNeg ? (-lhs).words : lhs.words
var rhsWords = rhsIsNeg ? (-rhs).words : rhs.words
// See the answer to exercise 16 in Section 4.3.1 of TAOCP
if rhsWords.count == 1 || (rhsWords.count == 2 && rhsWords[1] == 0) {
let v = rhsWords[0]
let u = lhsWords
var r: UInt = 0
var quot = Words(repeating: 0, count: u.count)
for j in (0...(u.count - 1)).reversed() {
let uj = u[j]
(quot[j], r) = v.dividingFullWidth((r, uj))
}
if quot[u.count - 1] > UInt(Int.max) {
quot.append(0)
}
BigInt._dropExcessWords(words: &quot)
return (quotient: BigInt(_uncheckedWords: quot), remainder: BigInt(r))
}
while rhsWords[rhsWords.endIndex - 1] == 0 {
rhsWords.removeLast()
}
if rhsWords.count > lhsWords.count { return (0, lhs) }
if lhsWords.count <= rhsWords.count {
for _ in 0 ... (rhsWords.count - lhsWords.count) {
lhsWords.append(0)
}
}
let m = lhsWords.count - rhsWords.count
let n = rhsWords.count
let bitWidth = UInt(UInt.bitWidth)
let s = UInt(rhsWords[n - 1].leadingZeroBitCount)
let rn = UnsafeMutablePointer<UInt>.allocate(capacity: n)
rn.initialize(repeating: 0, count: n)
defer { rn.deallocate() }
for i in (1 ... (n - 1)).reversed() {
rn[i] = (rhsWords[i] << s) | (rhsWords[i - 1] >> (bitWidth - s))
}
rn[0] = rhsWords[0] << s
let ln = UnsafeMutablePointer<UInt>.allocate(capacity: m + n + 1)
ln.initialize(repeating: 0, count: m + n + 1)
defer { ln.deallocate() }
ln[m + n] = lhsWords[m + n - 1] >> (bitWidth - s)
for i in (1 ... (m + n - 1)).reversed() {
ln[i] = (lhsWords[i] << s) | (lhsWords[i - 1] >> (bitWidth - s))
}
ln[0] = lhsWords[0] << s
let resultSize = m + 1
var quot = Words(repeating: 0, count: resultSize)
for j in (0 ... m).reversed() {
let qhat = _findQhat(
high: ln[j + n],
low: UInt.Magnitude(ln[j + n - 1]),
divisor: rn[n - 1],
nextVdigit: rn[n - 2],
nextUdigit: ln[j + n - 2])
var carry: UInt = 0
var isOverflow = false
var borrow: UInt = 0
var underflow = false
for i in 0 ..< n {
if borrow > 0 {
(ln[i + j], underflow) = ln[i + j].subtractingReportingOverflow(borrow)
borrow = underflow ? 1 : 0
}
var (pHigh, pLow) = qhat.multipliedFullWidth(by: rn[i])
(pLow, isOverflow) = pLow.addingReportingOverflow(carry)
if isOverflow {
pHigh += 1
}
(ln[i + j], underflow) = ln[i + j].subtractingReportingOverflow(pLow)
if underflow {
borrow += 1
}
carry = pHigh
}
(ln[j + n], underflow) = ln[j + n].subtractingReportingOverflow(carry + borrow)
if underflow {
let newQhat = qhat - 1
carry = 0
var total: UInt = 0
for i in 0 ..< n {
(total, isOverflow) = ln[i + j].addingReportingOverflow(carry)
carry = isOverflow ? 1 : 0
(ln[i + j], isOverflow) = total.addingReportingOverflow(rn[i])
if carry == 0 { carry = isOverflow ? 1 : 0 }
}
(ln[j + n], _) = ln[j + n].addingReportingOverflow(carry)
quot[j] = newQhat
} else {
quot[j] = qhat
}
}
var rem = Words(repeating: 0, count: n)
for i in 0 ..< (n - 1) {
rem[i] = (ln[i] >> s) | ln[i + 1] << (bitWidth - s)
}
rem[n - 1] = ln[n - 1] >> s
if rem[n - 1] > UInt(Int.max) {
rem.append(0)
}
BigInt._dropExcessWords(words: &quot)
BigInt._dropExcessWords(words: &rem)
return (BigInt(_uncheckedWords: quot), BigInt(_uncheckedWords: rem))
}
private static func _signExtend(lhsWords: inout Words, rhsWords: inout Words) {
let lhsIsNeg = (lhsWords.last ?? 0) >> (UInt.bitWidth - Int(1)) == 1
let rhsIsNeg = (rhsWords.last ?? 0) >> (UInt.bitWidth - Int(1)) == 1
if lhsWords.count > rhsWords.count {
for _ in 0 ..< (lhsWords.count - rhsWords.count) {
rhsIsNeg ? rhsWords.append(UInt.max) : rhsWords.append(0)
}
} else if rhsWords.count > lhsWords.count {
for _ in 0 ..< (rhsWords.count - lhsWords.count) {
lhsIsNeg ? lhsWords.append(UInt.max) : lhsWords.append(0)
}
}
}
@usableFromInline
internal static func _dropExcessWords(words: inout Words) {
while words.count > 1, words[words.endIndex - 1] == 0 {
if words[words.endIndex - 2] <= Int.max {
words.removeLast()
} else {
break
}
}
while words.count > 1, words[words.endIndex - 1] == UInt.max {
if words[words.endIndex - 2] > Int.max {
words.removeLast()
} else {
break
}
}
}
}
-751
View File
@@ -1,751 +0,0 @@
//===--- BigUInt.swift ----------------------------------------*- swift -*-===//
//
// This source file is part of the Swift Numerics open source project
//
// 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
//
//===----------------------------------------------------------------------===//
public struct BigUInt: UnsignedInteger {
public typealias Words = [UInt]
public private(set) var words: Words
@usableFromInline
internal init(_uncheckedWords: Words) {
self.words = _uncheckedWords
}
public init<T>(bitPattern source: T) where T: BinaryInteger {
words = Words(source.words)
BigUInt._dropExcessWords(words: &words)
}
@usableFromInline
internal var _isNegative: Bool {
words[words.endIndex - 1] > Int.max
}
private static let _digits: [BigUInt] = (0 ... 36).map {
BigUInt(_uncheckedWords: [UInt(bitPattern: $0)])
}
private static let _digitRadix = BigInt(_uncheckedWords: [0, 1])
}
// MARK: - Basic Behaviors
extension BigUInt: Equatable {
@inlinable
public static func == (lhs: BigUInt, rhs: BigUInt) -> Bool {
lhs.words == rhs.words
}
@inlinable
public static func != (lhs: BigUInt, rhs: BigUInt) -> Bool {
!(lhs == rhs)
}
}
extension BigUInt: Hashable {
@inlinable
public func hash(into hasher: inout Hasher) {
hasher.combine(words)
}
}
extension BigUInt: Comparable {
@inlinable
public static func < (lhs: BigUInt, rhs: BigUInt) -> Bool {
let lhsNegative = lhs._isNegative
let rhsNegative = rhs._isNegative
if lhsNegative && !rhsNegative { return true }
if rhsNegative && !lhsNegative { return false }
if (lhsNegative && rhsNegative) || (!lhsNegative && !rhsNegative) {
if lhs.words.count > rhs.words.count {
return lhsNegative ? true : false
}
if lhs.words.count < rhs.words.count {
return lhsNegative ? false : true
}
for i in stride(from: lhs.words.count - 1, through: 0, by: -1) {
if lhs.words[i] > rhs.words[i] {
return false
} else if lhs.words[i] < rhs.words[i] {
return true
}
}
}
return false
}
}
extension BigUInt: LosslessStringConvertible {
public init?(_ description: String) {
self.init(description, radix: 10)
}
public init?<T>(_ description: T, radix: Int = 10) where T: StringProtocol {
precondition(2 ... 36 ~= radix, "Radix not in range 2 ... 36")
self = 0
let hasPrefix = description.hasPrefix("+")
let utf8 = description.utf8.dropFirst(hasPrefix ? 1 : 0)
guard !utf8.isEmpty else { return nil }
for var byte in utf8 {
switch byte {
case UInt8(ascii: "0") ... UInt8(ascii: "9"):
byte -= UInt8(ascii: "0")
case UInt8(ascii: "A") ... UInt8(ascii: "Z"):
byte -= UInt8(ascii: "A")
byte += 10
case UInt8(ascii: "a") ... UInt8(ascii: "z"):
byte -= UInt8(ascii: "a")
byte += 10
default:
return nil
}
guard byte < radix else { return nil }
self *= BigUInt._digits[radix]
self += BigUInt._digits[Int(byte)]
}
}
}
extension BigUInt: Decodable {
public init(from decoder: Decoder) throws {
let singleValueContainer = try decoder.singleValueContainer()
let description = try singleValueContainer.decode(String.self)
guard let result = BigUInt(description) else {
throw DecodingError.dataCorruptedError(
in: singleValueContainer,
debugDescription: "BigUInt(\(description.debugDescription)) failed")
}
self = result
}
}
extension BigUInt: Encodable {
public func encode(to encoder: Encoder) throws {
var singleValueContainer = encoder.singleValueContainer()
try singleValueContainer.encode(description)
}
}
// MARK: - Numeric Protocols
extension BigUInt: ExpressibleByIntegerLiteral {
public init(integerLiteral value: Int) {
if value < BigUInt._digits.count {
self = BigUInt._digits[value]
} else {
words = [UInt(bitPattern: value)]
}
}
}
extension BigUInt: AdditiveArithmetic {
@inlinable
public static func + (lhs: BigUInt, rhs: BigUInt) -> BigUInt {
var result = lhs
result += rhs
return result
}
public static func += (lhs: inout BigUInt, rhs: BigUInt) {
if lhs.words.count == 1, rhs.words.count == 1 {
let lhsWord = lhs.words[0]
let rhsWord = rhs.words[0]
let (result, isOverflow) = lhsWord.addingReportingOverflow(rhsWord)
if !isOverflow && result < Int.max {
lhs.words[0] = result
return
}
let knownNegativeResult = lhsWord > Int.max && rhsWord > Int.max
if lhsWord > Int.max || rhsWord > Int.max, !knownNegativeResult {
// positive + negative is always smaller, so overflow is a red herring
lhs.words[0] = result
return
}
}
var isOverflow = false
var rhsWords = rhs.words
lhs.words.append(0)
rhsWords.append(0)
BigUInt._zeroExtend(lhsWords: &lhs.words, rhsWords: &rhsWords)
var temp: UInt = 0
for index in 0 ..< lhs.words.count {
var carryOverflow = false
if isOverflow {
(temp, carryOverflow) = rhsWords[index].addingReportingOverflow(1)
} else {
temp = rhsWords[index]
}
(lhs.words[index], isOverflow) = lhs.words[index].addingReportingOverflow(temp)
isOverflow = carryOverflow || isOverflow
}
BigUInt._dropExcessWords(words: &lhs.words)
}
@inlinable
public static func - (lhs: BigUInt, rhs: BigUInt) -> BigUInt {
var result = lhs
result -= rhs
return result
}
@inlinable
public static func -= (lhs: inout BigUInt, rhs: BigUInt) {
lhs = .init(_uncheckedWords: (BigInt(_uncheckedWords: lhs.words) + -BigInt(_uncheckedWords: rhs.words)).words)
}
}
extension BigUInt: Numeric {
public init?<T>(exactly source: T) where T: BinaryInteger {
self.init(source)
}
public var magnitude: BigUInt { self }
public static func * (lhs: BigUInt, rhs: BigUInt) -> BigUInt {
let lhsWords = lhs.words
let rhsWords = rhs.words
let count = lhsWords.count + rhsWords.count + 1
var newWords = Words(repeating: 0, count: count)
for i in 0 ..< rhsWords.count {
var carry: UInt = 0
var digit: UInt = 0
var lastJ: Int = 0
for j in i ..< (lhsWords.count + i) {
var (high, low) = rhsWords[i].multipliedFullWidth(by: lhsWords[j - i])
var isOverflow: Bool
(digit, isOverflow) = low.addingReportingOverflow(newWords[j])
if isOverflow {
high += 1
}
(digit, isOverflow) = digit.addingReportingOverflow(carry)
if isOverflow {
high += 1
}
carry = high
newWords[j] = digit
lastJ = j
}
if carry != 0 {
let isOverflow: Bool
(digit, isOverflow) = newWords[lastJ + 1].addingReportingOverflow(carry)
if isOverflow {
carry = 1
}
newWords[lastJ + 1] = digit
}
}
for i in stride(from: count - 1, through: 1, by: -1) {
if newWords[i] == 0, newWords[i - 1] <= Int.max {
newWords.removeLast()
} else {
break
}
}
return BigUInt(_uncheckedWords: newWords)
}
@inlinable
public static func *= (lhs: inout BigUInt, rhs: BigUInt) {
lhs = lhs * rhs
}
}
extension BigUInt: BinaryInteger {
public init?<T>(exactly source: T) where T: BinaryFloatingPoint {
guard source.isFinite, source == source.rounded(.towardZero) else {
return nil
}
self.init(source)
}
public init<T>(_ source: T) where T: BinaryFloatingPoint {
precondition(
source.isFinite && source >= 0.0,
"""
\(type(of: source)) value cannot be converted to BigUInt because it is \
either infinite, NaN, or negative
""")
var float = source
if let _ = UInt(exactly: T.greatestFiniteMagnitude) {
words = [UInt(float)]
} else {
var words = Words()
let radix = T(sign: .plus, exponent: T.Exponent(UInt.bitWidth), significand: 1)
repeat {
let digit = UInt(float.truncatingRemainder(dividingBy: radix))
words.append(digit)
float = (float / radix).rounded(.towardZero)
} while float != 0
if let last = words.last, last >= Int.max {
words.append(0)
}
self.words = words
}
}
public init<T>(_ source: T) where T: BinaryInteger {
if source >= 0, source < BigUInt._digits.count {
self = BigUInt._digits[Int(source)]
} else {
words = Words(source.words)
if source > 0 && source.words[source.words.endIndex - 1] > Int.max {
words.append(0)
}
// needed to handle sign-extended multi-word numbers that
// actually fit in a single word
BigUInt._dropExcessWords(words: &words)
}
}
public init<T>(clamping source: T) where T: BinaryInteger {
self.init(source)
}
public init<T>(truncatingIfNeeded source: T) where T: BinaryInteger {
words = Words(source.words)
}
public var bitWidth: Int { words.count * UInt.bitWidth }
public var trailingZeroBitCount: Int {
var totalZeros = 0
for word in words {
if word == 0 {
totalZeros += UInt.bitWidth
} else {
totalZeros += word.trailingZeroBitCount
break
}
}
return totalZeros
}
@inlinable
public static func / (lhs: BigUInt, rhs: BigUInt) -> BigUInt {
let (result, _) = _div(lhs: lhs, rhs: rhs)
return result
}
@inlinable
public static func /= (lhs: inout BigUInt, rhs: BigUInt) {
lhs = lhs / rhs
}
@inlinable
public static func % (lhs: BigUInt, rhs: BigUInt) -> BigUInt {
let (_, result) = _div(lhs: lhs, rhs: rhs)
return result
}
@inlinable
public static func %= (lhs: inout BigUInt, rhs: BigUInt) {
lhs = lhs % rhs
}
@inlinable
public static prefix func ~ (x: BigUInt) -> BigUInt {
let newWords = x.words.map { ~$0 }
return BigUInt(_uncheckedWords: Words(newWords))
}
public static func &= (lhs: inout BigUInt, rhs: BigUInt) {
var rhsWords = rhs.words
BigUInt._zeroExtend(lhsWords: &lhs.words, rhsWords: &rhsWords)
for i in 0 ..< rhsWords.count {
lhs.words[i] &= rhsWords[i]
}
BigUInt._dropExcessWords(words: &lhs.words)
}
public static func |= (lhs: inout BigUInt, rhs: BigUInt) {
var rhsWords = rhs.words
BigUInt._zeroExtend(lhsWords: &lhs.words, rhsWords: &rhsWords)
for i in 0 ..< rhsWords.count {
lhs.words[i] |= rhsWords[i]
}
BigUInt._dropExcessWords(words: &lhs.words)
}
public static func ^= (lhs: inout BigUInt, rhs: BigUInt) {
var rhsWords = rhs.words
BigUInt._zeroExtend(lhsWords: &lhs.words, rhsWords: &rhsWords)
for i in 0 ..< rhsWords.count {
lhs.words[i] &= rhsWords[i]
}
BigUInt._dropExcessWords(words: &lhs.words)
}
public static func <<= <RHS>(lhs: inout BigUInt, rhs: RHS) where RHS: BinaryInteger {
if rhs.signum() < 0 {
lhs >>= rhs.magnitude
return
}
let wordLength = UInt.bitWidth
let (fullWords, remainder) = rhs.quotientAndRemainder(dividingBy: RHS(wordLength))
lhs.words = Words(repeating: 0, count: Int(fullWords)) + lhs.words + [0]
if remainder > 0 {
var value: UInt = 0
for i in 0 ..< lhs.words.count {
let temp = lhs.words[i] >> (wordLength - Int(remainder))
lhs.words[i] <<= Int(remainder)
if i > 0 {
lhs.words[i] &= UInt.max << Int(remainder)
lhs.words[i] |= value
}
value = temp
}
}
BigUInt._dropExcessWords(words: &lhs.words)
}
public static func >>= <RHS>(lhs: inout BigUInt, rhs: RHS) where RHS: BinaryInteger {
if rhs.signum() < 0 {
lhs <<= rhs.magnitude
return
}
let wordLength = UInt.bitWidth
let (fullWords, remainder) = rhs.quotientAndRemainder(dividingBy: RHS(wordLength))
if fullWords < lhs.words.count {
lhs.words.removeFirst(Int(fullWords))
} else {
lhs = 0
return
}
if remainder > 0 {
let mask = ~(UInt.max << remainder)
var value: UInt = 0
for i in stride(from: lhs.words.count - 1, through: 0, by: -1) {
let temp = lhs.words[i] & mask
lhs.words[i] >>= remainder
lhs.words[i] |= (value << (UInt.bitWidth - Int(remainder)))
value = temp
}
}
BigUInt._dropExcessWords(words: &lhs.words)
}
@inlinable
public func quotientAndRemainder(dividingBy rhs: BigUInt) -> (quotient: BigUInt, remainder: BigUInt) {
return BigUInt._div(lhs: self, rhs: rhs)
}
}
// MARK: -
extension BigUInt {
/// See _The Art of Computer Programming_ volume 2 by Donald Knuth, Section 4.3.1: The Classical Algorithms
private static func _findQhat(
high: UInt,
low: UInt.Magnitude,
divisor: UInt,
nextVdigit: UInt,
nextUdigit: UInt
) -> UInt {
var qhat: Array<UInt>
var rhat: Array<UInt>
if high >= divisor {
let v = divisor
let u = [low, high]
var r: UInt = 0
qhat = Words(repeating: 0, count: 2)
for j in (0...1).reversed() {
let uj = u[j]
(qhat[j], r) = v.dividingFullWidth((r, uj))
}
BigUInt._dropExcessWords(words: &qhat)
rhat = [r]
} else {
let (qhatWord, rhatWord) = divisor.dividingFullWidth((high, low))
qhat = [qhatWord]
rhat = [rhatWord]
}
repeat {
var qhatTooLarge = false
if qhat.count > 1 {
qhatTooLarge = true
} else {
// All of the following is computing and checking qhat*v_n-2 > rhat*b + u_j+n-2
// from TAoCP Volume 2 Section 4.3.1, Algorithm D, step D3
let (comp_lhs_hi, comp_lhs_lo) = qhat[0].multipliedFullWidth(by: nextVdigit)
if comp_lhs_hi > rhat[0] {
qhatTooLarge = true
} else if comp_lhs_hi == rhat[0] && comp_lhs_lo > nextUdigit {
qhatTooLarge = true
}
}
// high >= divisor is standing in for the test qhat >= b from Algorithm D step D3
if qhatTooLarge {
// begin qhat -= 1
if qhat.count == 1 {
qhat[0] -= 1
} else {
let (qlow, underflow) = qhat[0].subtractingReportingOverflow(1)
qhat[0] = qlow
if qhat[1] > 0 && underflow {
qhat[1] -= 1
if qhat[1] == 0 {
qhat.remove(at: 1)
}
}
}
// end qhat -= 1
// begin rhat += divisor
let (rhatResult, overflow) : (UInt, Bool)
if rhat.count == 1 || rhat[1] == 0 {
(rhatResult, overflow) = rhat[0].addingReportingOverflow(divisor)
rhat[0] = rhatResult
if overflow {
rhat.append(1)
}
} // we don't need an else because rhat is already larger than BigInt._digitRadix
// end rhat += divisor
} else {
break
}
} while rhat.count == 1 // equivalent to rhat < b
return qhat[0]
}
/// See _The Art of Computer Programming_ volume 2 by Donald Knuth, Section 4.3.1: The Classical Algorithms
@usableFromInline
internal static func _div(lhs: BigUInt, rhs: BigUInt) -> (quotient: BigUInt, remainder: BigUInt) {
precondition(rhs != _digits[0], "Division by zero error!")
if lhs.words.count == 1, rhs.words.count == 1 {
let (quot, rem) = Int(bitPattern: lhs.words[0]).quotientAndRemainder(dividingBy: Int(bitPattern: rhs.words[0]))
return (BigUInt(_uncheckedWords: [UInt(bitPattern: quot)]), BigUInt(_uncheckedWords: [UInt(bitPattern: rem)]))
}
var lhsWords = lhs.words
var rhsWords = rhs.words
// See the answer to exercise 16 in Section 4.3.1 of TAOCP
if rhsWords.count == 1 || (rhsWords.count == 2 && rhsWords[1] == 0) {
let v = rhsWords[0]
let u = lhsWords
var r: UInt = 0
var quot = Words(repeating: 0, count: u.count)
for j in (0...(u.count - 1)).reversed() {
let uj = u[j]
(quot[j], r) = v.dividingFullWidth((r, uj))
}
if quot[u.count - 1] > UInt(Int.max) {
quot.append(0)
}
BigUInt._dropExcessWords(words: &quot)
return (quotient: BigUInt(_uncheckedWords: quot), remainder: BigUInt(r))
}
while rhsWords[rhsWords.endIndex - 1] == 0 {
rhsWords.removeLast()
}
if rhsWords.count > lhsWords.count { return (0, lhs) }
if lhsWords.count <= rhsWords.count {
for _ in 0 ... (rhsWords.count - lhsWords.count) {
lhsWords.append(0)
}
}
let m = lhsWords.count - rhsWords.count
let n = rhsWords.count
let bitWidth = UInt(UInt.bitWidth)
let s = UInt(rhsWords[n - 1].leadingZeroBitCount)
let rn = UnsafeMutablePointer<UInt>.allocate(capacity: n)
rn.initialize(repeating: 0, count: n)
defer { rn.deallocate() }
for i in (1 ... (n - 1)).reversed() {
rn[i] = (rhsWords[i] << s) | (rhsWords[i - 1] >> (bitWidth - s))
}
rn[0] = rhsWords[0] << s
let ln = UnsafeMutablePointer<UInt>.allocate(capacity: m + n + 1)
ln.initialize(repeating: 0, count: m + n + 1)
defer { ln.deallocate() }
ln[m + n] = lhsWords[m + n - 1] >> (bitWidth - s)
for i in (1 ... (m + n - 1)).reversed() {
ln[i] = (lhsWords[i] << s) | (lhsWords[i - 1] >> (bitWidth - s))
}
ln[0] = lhsWords[0] << s
let resultSize = m + 1
var quot = Words(repeating: 0, count: resultSize)
for j in (0 ... m).reversed() {
let qhat = _findQhat(
high: ln[j + n],
low: UInt.Magnitude(ln[j + n - 1]),
divisor: rn[n - 1],
nextVdigit: rn[n - 2],
nextUdigit: ln[j + n - 2])
var carry: UInt = 0
var isOverflow = false
var borrow: UInt = 0
var underflow = false
for i in 0 ..< n {
if borrow > 0 {
(ln[i + j], underflow) = ln[i + j].subtractingReportingOverflow(borrow)
borrow = underflow ? 1 : 0
}
var (pHigh, pLow) = qhat.multipliedFullWidth(by: rn[i])
(pLow, isOverflow) = pLow.addingReportingOverflow(carry)
if isOverflow {
pHigh += 1
}
(ln[i + j], underflow) = ln[i + j].subtractingReportingOverflow(pLow)
if underflow {
borrow += 1
}
carry = pHigh
}
(ln[j + n], underflow) = ln[j + n].subtractingReportingOverflow(carry + borrow)
if underflow {
let newQhat = qhat - 1
carry = 0
var total: UInt = 0
for i in 0 ..< n {
(total, isOverflow) = ln[i + j].addingReportingOverflow(carry)
carry = isOverflow ? 1 : 0
(ln[i + j], isOverflow) = total.addingReportingOverflow(rn[i])
if carry == 0 { carry = isOverflow ? 1 : 0 }
}
(ln[j + n], _) = ln[j + n].addingReportingOverflow(carry)
quot[j] = newQhat
} else {
quot[j] = qhat
}
}
var rem = Words(repeating: 0, count: n)
for i in 0 ..< (n - 1) {
rem[i] = (ln[i] >> s) | ln[i + 1] << (bitWidth - s)
}
rem[n - 1] = ln[n - 1] >> s
if rem[n - 1] > UInt(Int.max) {
rem.append(0)
}
BigUInt._dropExcessWords(words: &quot)
BigUInt._dropExcessWords(words: &rem)
return (BigUInt(_uncheckedWords: quot), BigUInt(_uncheckedWords: rem))
}
private static func _zeroExtend(lhsWords: inout Words, rhsWords: inout Words) {
if lhsWords.count > rhsWords.count {
for _ in 0 ..< (lhsWords.count - rhsWords.count) {
rhsWords.append(0)
}
} else if rhsWords.count > lhsWords.count {
for _ in 0 ..< (rhsWords.count - lhsWords.count) {
lhsWords.append(0)
}
}
}
@usableFromInline
internal static func _dropExcessWords(words: inout Words) {
while words.count > 1, words[words.endIndex - 1] == 0 {
if words[words.endIndex - 2] <= Int.max {
words.removeLast()
} else {
break
}
}
while words.count > 1, words[words.endIndex - 1] == UInt.max {
if words[words.endIndex - 2] > Int.max {
words.removeLast()
} else {
break
}
}
}
}
-16
View File
@@ -1,16 +0,0 @@
#[[
This source file is part of the Swift Numerics open source project
Copyright (c) 2019 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
#]]
add_library(BigIntModule
BigInt.swift)
set_target_properties(BigIntModule PROPERTIES
INTERFACE_INCLUDE_DIRECTORIES ${CMAKE_Swift_MODULE_DIRECTORY})
_install_target(BigIntModule)
set_property(GLOBAL APPEND PROPERTY SWIFT_NUMERICS_EXPORTS BigIntModule)
-3
View File
@@ -1,3 +0,0 @@
# Arbitrary-precision integers
This module provides a `BigInt` type.
+1 -2
View File
@@ -1,7 +1,7 @@
#[[
This source file is part of the Swift Numerics open source project
Copyright (c) 2019-2021 Apple Inc. and the Swift Numerics project authors
Copyright (c) 2019 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
@@ -9,7 +9,6 @@ See https://swift.org/LICENSE.txt for license information
add_subdirectory(_NumericsShims)
add_subdirectory(ComplexModule)
add_subdirectory(IntegerUtilities)
add_subdirectory(Numerics)
add_subdirectory(RealModule)
if(BUILD_TESTING)
@@ -1,8 +1,8 @@
//===--- Complex+AlgebraicField.swift -------------------------*- swift -*-===//
//===--- Arithmetic.swift -------------------------------------*- swift -*-===//
//
// This source file is part of the Swift Numerics open source project
//
// Copyright (c) 2019-2021 Apple Inc. and the Swift Numerics project authors
// Copyright (c) 2019 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
@@ -11,19 +11,81 @@
import RealModule
extension Complex: AlgebraicField {
/// The multiplicative identity `1 + 0i`.
// MARK: - Additive structure
extension Complex: AdditiveArithmetic {
@_transparent
public static var one: Complex {
Complex(1, 0)
public static func +(z: Complex, w: Complex) -> Complex {
return Complex(z.x + w.x, z.y + w.y)
}
/// The [complex conjugate][conj] of this value.
///
/// [conj]: https://en.wikipedia.org/wiki/Complex_conjugate
@_transparent
public var conjugate: Complex {
Complex(x, -y)
public static func -(z: Complex, w: Complex) -> Complex {
return Complex(z.x - w.x, z.y - w.y)
}
@_transparent
public static func +=(z: inout Complex, w: Complex) {
z = z + w
}
@_transparent
public static func -=(z: inout Complex, w: Complex) {
z = z - w
}
}
// MARK: - Vector space structure
//
// Policy: deliberately not using the * and / operators for these at the
// moment, because then there's an ambiguity in expressions like 2*z; is
// that Complex(2) * z or is it RealType(2) * z? This is especially
// problematic in type inference: suppose we have:
//
// let a: RealType = 1
// let b = 2*a
//
// what is the type of b? If we don't have a type context, it's ambiguous.
// If we have a Complex type context, then b will be inferred to have type
// Complex! Obviously, that doesn't help anyone.
//
// TODO: figure out if there's some way to avoid these surprising results
// and turn these into operators if/when we have it.
// (https://github.com/apple/swift-numerics/issues/12)
extension Complex {
/// `self` scaled by `a`.
@usableFromInline @_transparent
internal func multiplied(by a: RealType) -> Complex {
// This can be viewed in two different ways, which are mathematically
// equivalent: either we are computing `self * Complex(a)` (i.e.
// converting `a` to be a complex value, and then using the complex
// multiplication) or we are using the scalar product of the vector
// space structure: `Complex(a*real, a*imaginary)`.
//
// Although these two interpretations are _mathematically_ equivalent,
// they will generate different representations of the point at
// infinity in general. For example, suppose `self` is represented by
// `(infinity, 0)`. Then `self * Complex(1)` would evaluate as
// `(1*infinity - 0*0, 0*infinity + 1*0) = (infinity, nan)`, but
// the vector space interpretation produces `(infinity, 0)`. This does
// not matter much, because these are two representations of the same
// semantic value, but note that one requires four multiplies and two
// additions, while the one we use requires only two real multiplications.
Complex(x*a, y*a)
}
/// `self` unscaled by `a`.
@usableFromInline @_transparent
internal func divided(by a: RealType) -> Complex {
// See implementation notes for `multiplied` above.
Complex(x/a, y/a)
}
}
// MARK: - Multiplicative structure
extension Complex: AlgebraicField {
@_transparent
public static func *(z: Complex, w: Complex) -> Complex {
return Complex(z.x*w.x - z.y*w.y, z.x*w.y + z.y*w.x)
}
@_transparent
@@ -36,6 +98,11 @@ extension Complex: AlgebraicField {
return z * (w.conjugate.divided(by: lenSq))
}
@_transparent
public static func *=(z: inout Complex, w: Complex) {
z = z * w
}
@_transparent
public static func /=(z: inout Complex, w: Complex) {
z = z / w
@@ -96,7 +163,7 @@ extension Complex: AlgebraicField {
/// If z.reciprocal is non-nil, you can safely replace division by z with
/// multiplication by this value. It is not advantageous to do this for an
/// isolated division, but if you are dividing many values by a single
/// denominator, this will often be a significant performance win.
/// denominator, this may sometimes be a significant performance win.
///
/// A typical use case looks something like this:
/// ```
@@ -111,7 +178,7 @@ extension Complex: AlgebraicField {
/// ```
///
/// Error Bounds:
///
///
/// Unlike real types, when working with complex types, multiplying by the
/// reciprocal instead of dividing cannot change the result. If the
/// reciprocal is non-nil, the two computations are always equivalent.
@@ -123,17 +190,4 @@ extension Complex: AlgebraicField {
}
return nil
}
@_transparent
public static func _relaxedAdd(_ a: Self, _ b: Self) -> Self {
Complex(Relaxed.sum(a.x, b.x), Relaxed.sum(a.y, b.y))
}
@_transparent
public static func _relaxedMul(_ a: Self, _ b: Self) -> Self {
Complex(
Relaxed.sum(Relaxed.product(a.x, b.x), -Relaxed.product(a.y, b.y)),
Relaxed.sum(Relaxed.product(a.x, b.y), Relaxed.product(a.y, b.x))
)
}
}
+3 -10
View File
@@ -8,17 +8,10 @@ See https://swift.org/LICENSE.txt for license information
#]]
add_library(ComplexModule
Arithmetic.swift
Complex.swift
Complex+AdditiveArithmetic.swift
Complex+AlgebraicField.swift
Complex+Codable.swift
Complex+ElementaryFunctions.swift
Complex+Hashable.swift
Complex+IntegerLiteral.swift
Complex+Numeric.swift
Complex+StringConvertible.swift
Polar.swift
Scale.swift)
Differentiable.swift
ElementaryFunctions.swift)
set_target_properties(ComplexModule PROPERTIES
INTERFACE_INCLUDE_DIRECTORIES ${CMAKE_Swift_MODULE_DIRECTORY})
target_link_libraries(ComplexModule PUBLIC
@@ -1,42 +0,0 @@
//===--- Complex+AdditiveArithmetic.swift ---------------------*- swift -*-===//
//
// This source file is part of the Swift Numerics open source project
//
// Copyright (c) 2019-2021 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 RealModule
extension Complex: AdditiveArithmetic {
/// The additive identity, with real and imaginary parts both zero.
///
/// See also: `one`, `i`, `infinity`
@_transparent
public static var zero: Complex {
Complex(0, 0)
}
@_transparent
public static func +(z: Complex, w: Complex) -> Complex {
return Complex(z.x + w.x, z.y + w.y)
}
@_transparent
public static func -(z: Complex, w: Complex) -> Complex {
return Complex(z.x - w.x, z.y - w.y)
}
@_transparent
public static func +=(z: inout Complex, w: Complex) {
z = z + w
}
@_transparent
public static func -=(z: inout Complex, w: Complex) {
z = z - w
}
}
@@ -1,30 +0,0 @@
//===--- Complex+Codable.swift --------------------------------*- swift -*-===//
//
// This source file is part of the Swift Numerics open source project
//
// Copyright (c) 2019 - 2021 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 RealModule
// FloatingPoint does not refine Codable, so this is a conditional conformance.
extension Complex: Decodable where RealType: Decodable {
public init(from decoder: Decoder) throws {
var unkeyedContainer = try decoder.unkeyedContainer()
let x = try unkeyedContainer.decode(RealType.self)
let y = try unkeyedContainer.decode(RealType.self)
self.init(x, y)
}
}
extension Complex: Encodable where RealType: Encodable {
public func encode(to encoder: Encoder) throws {
var unkeyedContainer = encoder.unkeyedContainer()
try unkeyedContainer.encode(x)
try unkeyedContainer.encode(y)
}
}
@@ -1,42 +0,0 @@
//===--- Complex+Hashable.swift -------------------------------*- swift -*-===//
//
// This source file is part of the Swift Numerics open source project
//
// Copyright (c) 2019 - 2021 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 RealModule
extension Complex: Hashable {
@_transparent
public static func ==(a: Complex, b: Complex) -> Bool {
// Identify all numbers with either component non-finite as a single
// "point at infinity".
guard a.isFinite || b.isFinite else { return true }
// For finite numbers, equality is defined componentwise. Cases where
// only one of a or b is infinite fall through to here as well, but this
// expression correctly returns false for them so we don't need to handle
// them explicitly.
return a.x == b.x && a.y == b.y
}
@_transparent
public func hash(into hasher: inout Hasher) {
// There are two equivalence classes to which we owe special attention:
// All zeros should hash to the same value, regardless of sign, and all
// non-finite numbers should hash to the same value, regardless of
// representation. The correct behavior for zero falls out for free from
// the hash behavior of floating-point, but we need to use a
// representative member for any non-finite values.
if isFinite {
hasher.combine(x)
hasher.combine(y)
} else {
hasher.combine(RealType.infinity)
}
}
}
@@ -1,19 +0,0 @@
//===--- Complex+IntegerLiteral.swift -------------------------*- swift -*-===//
//
// This source file is part of the Swift Numerics open source project
//
// Copyright (c) 2019 - 2021 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
//
//===----------------------------------------------------------------------===//
extension Complex: ExpressibleByIntegerLiteral {
public typealias IntegerLiteralType = RealType.IntegerLiteralType
@inlinable
public init(integerLiteral value: IntegerLiteralType) {
self.init(RealType(integerLiteral: value))
}
}
@@ -1,56 +0,0 @@
//===--- Complex+Numeric.swift --------------------------------*- swift -*-===//
//
// This source file is part of the Swift Numerics open source project
//
// Copyright (c) 2019 - 2021 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
//
//===----------------------------------------------------------------------===//
extension Complex: Numeric {
@_transparent
public static func *(z: Complex, w: Complex) -> Complex {
return Complex(z.x*w.x - z.y*w.y, z.x*w.y + z.y*w.x)
}
@_transparent
public static func *=(z: inout Complex, w: Complex) {
z = z * w
}
/// The complex number with specified real part and zero imaginary part.
///
/// Equivalent to `Complex(RealType(real), 0)`.
@inlinable
public init<Other: BinaryInteger>(_ real: Other) {
self.init(RealType(real), 0)
}
/// The complex number with specified real part and zero imaginary part,
/// if it can be constructed without rounding.
@inlinable
public init?<Other: BinaryInteger>(exactly real: Other) {
guard let real = RealType(exactly: real) else { return nil }
self.init(real, 0)
}
/// The ∞-norm of the value (`max(abs(real), abs(imaginary))`).
///
/// If you need the Euclidean norm (a.k.a. 2-norm) use the `length` or
/// `lengthSquared` properties instead.
///
/// Edge cases:
/// - If `z` is not finite, `z.magnitude` is `.infinity`.
/// - If `z` is zero, `z.magnitude` is `0`.
/// - Otherwise, `z.magnitude` is finite and non-zero.
///
/// See also `.length` and `.lengthSquared`.
@_transparent
public var magnitude: RealType {
guard isFinite else { return .infinity }
return max(abs(x), abs(y))
}
}
@@ -1,23 +0,0 @@
//===--- Complex+StringConvertible.swift ----------------------*- swift -*-===//
//
// This source file is part of the Swift Numerics open source project
//
// Copyright (c) 2019 - 2021 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
//
//===----------------------------------------------------------------------===//
extension Complex: CustomStringConvertible {
public var description: String {
guard isFinite else { return "inf" }
return "(\(x), \(y))"
}
}
extension Complex: CustomDebugStringConvertible {
public var debugDescription: String {
"Complex<\(RealType.self)>(\(String(reflecting: x)), \(String(reflecting: y)))"
}
}
+321 -14
View File
@@ -2,7 +2,7 @@
//
// This source file is part of the Swift Numerics open source project
//
// Copyright (c) 2019 - 2021 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
@@ -16,7 +16,7 @@ import RealModule
/// TODO: introductory text on complex numbers
///
/// Implementation notes:
///
/// -
/// This type does not provide heterogeneous real/complex arithmetic,
/// not even the natural vector-space operations like real * complex.
/// There are two reasons for this choice: first, Swift broadly avoids
@@ -69,7 +69,9 @@ public struct Complex<RealType> where RealType: Real {
}
}
#if swift(>=5.5)
extension Complex: Sendable where RealType: Sendable { }
#endif
// MARK: - Basic properties
extension Complex {
@@ -95,19 +97,37 @@ extension Complex {
set { y = newValue }
}
/// The raw representation of the real part of this value.
/// The additive identity, with real and imaginary parts both zero.
///
/// See also:
/// -
/// - .one
/// - .i
/// - .infinity
@_transparent
public var _rawX: RealType { x }
public static var zero: Complex {
Complex(0, 0)
}
/// The raw representation of the imaginary part of this value.
/// The multiplicative identity, with real part one and imaginary part zero.
///
/// See also:
/// -
/// - .zero
/// - .i
/// - .infinity
@_transparent
public var _rawY: RealType { y }
}
public static var one: Complex {
Complex(1, 0)
}
extension Complex {
/// The imaginary unit.
///
/// See also `.zero`, `.one` and `.infinity`.
/// See also:
/// -
/// - .zero
/// - .one
/// - .infinity
@_transparent
public static var i: Complex {
Complex(0, 1)
@@ -115,17 +135,31 @@ extension Complex {
/// The point at infinity.
///
/// See also `.zero`, `.one` and `.i`.
/// See also:
/// -
/// - .zero
/// - .one
/// - .i
@_transparent
public static var infinity: Complex {
Complex(.infinity, 0)
}
/// The complex conjugate of this value.
@_transparent
public var conjugate: Complex {
Complex(x, -y)
}
/// True if this value is finite.
///
/// A complex value is finite if neither component is an infinity or nan.
///
/// See also `.isNormal`, `.isSubnormal` and `.isZero`.
/// See also:
/// -
/// - `.isNormal`
/// - `.isSubnormal`
/// - `.isZero`
@_transparent
public var isFinite: Bool {
x.isFinite && y.isFinite
@@ -138,7 +172,11 @@ extension Complex {
/// one of the components is normal if its exponent allows a full-precision
/// representation.
///
/// See also `.isFinite`, `.isSubnormal` and `.isZero`.
/// See also:
/// -
/// - `.isFinite`
/// - `.isSubnormal`
/// - `.isZero`
@_transparent
public var isNormal: Bool {
isFinite && (x.isNormal || y.isNormal)
@@ -150,7 +188,11 @@ extension Complex {
/// When the result of a computation is subnormal, underflow has occurred and
/// the result generally does not have full precision.
///
/// See also `.isFinite`, `.isNormal` and `.isZero`.
/// See also:
/// -
/// - `.isFinite`
/// - `.isNormal`
/// - `.isZero`
@_transparent
public var isSubnormal: Bool {
isFinite && !isNormal && !isZero
@@ -161,12 +203,37 @@ extension Complex {
/// A complex number is zero if *both* the real and imaginary components
/// are zero.
///
/// See also `.isFinite`, `.isNormal` and `isSubnormal`.
/// See also:
/// -
/// - `.isFinite`
/// - `.isNormal`
/// - `.isSubnormal`
@_transparent
public var isZero: Bool {
x == 0 && y == 0
}
/// The ∞-norm of the value (`max(abs(real), abs(imaginary))`).
///
/// If you need the Euclidean norm (a.k.a. 2-norm) use the `length` or
/// `lengthSquared` properties instead.
///
/// Edge cases:
/// -
/// - If `z` is not finite, `z.magnitude` is `.infinity`.
/// - If `z` is zero, `z.magnitude` is `0`.
/// - Otherwise, `z.magnitude` is finite and non-zero.
///
/// See also:
/// -
/// - `.length`
/// - `.lengthSquared`
@_transparent
public var magnitude: RealType {
guard isFinite else { return .infinity }
return max(abs(x), abs(y))
}
/// A "canonical" representation of the value.
///
/// For normal complex numbers with a RealType conforming to
@@ -207,6 +274,29 @@ extension Complex {
public init(imaginary: RealType) {
self.init(0, imaginary)
}
/// The complex number with specified real part and zero imaginary part.
///
/// Equivalent to `Complex(RealType(real), 0)`.
@inlinable
public init<Other: BinaryInteger>(_ real: Other) {
self.init(RealType(real), 0)
}
/// The complex number with specified real part and zero imaginary part,
/// if it can be constructed without rounding.
@inlinable
public init?<Other: BinaryInteger>(exactly real: Other) {
guard let real = RealType(exactly: real) else { return nil }
self.init(real, 0)
}
public typealias IntegerLiteralType = Int
@inlinable
public init(integerLiteral value: Int) {
self.init(RealType(value))
}
}
extension Complex where RealType: BinaryFloatingPoint {
@@ -224,3 +314,220 @@ extension Complex where RealType: BinaryFloatingPoint {
self.init(x, y)
}
}
// MARK: - Conformance to Hashable and Equatable
//
// The Complex type identifies all non-finite points (waving hands slightly,
// we identify all NaNs and infinites as the point at infinity on the Riemann
// sphere).
extension Complex: Hashable {
@_transparent
public static func ==(a: Complex, b: Complex) -> Bool {
// Identify all numbers with either component non-finite as a single
// "point at infinity".
guard a.isFinite || b.isFinite else { return true }
// For finite numbers, equality is defined componentwise. Cases where
// only one of a or b is infinite fall through to here as well, but this
// expression correctly returns false for them so we don't need to handle
// them explicitly.
return a.x == b.x && a.y == b.y
}
@_transparent
public func hash(into hasher: inout Hasher) {
// There are two equivalence classes to which we owe special attention:
// All zeros should hash to the same value, regardless of sign, and all
// non-finite numbers should hash to the same value, regardless of
// representation. The correct behavior for zero falls out for free from
// the hash behavior of floating-point, but we need to use a
// representative member for any non-finite values.
if isFinite {
hasher.combine(x)
hasher.combine(y)
} else {
hasher.combine(RealType.infinity)
}
}
}
// MARK: - Conformance to Codable
// FloatingPoint does not refine Codable, so this is a conditional conformance.
extension Complex: Decodable where RealType: Decodable {
public init(from decoder: Decoder) throws {
var unkeyedContainer = try decoder.unkeyedContainer()
let x = try unkeyedContainer.decode(RealType.self)
let y = try unkeyedContainer.decode(RealType.self)
self.init(x, y)
}
}
extension Complex: Encodable where RealType: Encodable {
public func encode(to encoder: Encoder) throws {
var unkeyedContainer = encoder.unkeyedContainer()
try unkeyedContainer.encode(x)
try unkeyedContainer.encode(y)
}
}
// MARK: - Formatting
extension Complex: CustomStringConvertible {
public var description: String {
guard isFinite else {
return "inf"
}
return "(\(x), \(y))"
}
}
extension Complex: CustomDebugStringConvertible {
public var debugDescription: String {
"Complex<\(RealType.self)>(\(String(reflecting: x)), \(String(reflecting: y)))"
}
}
// MARK: - Operations for working with polar form
extension Complex {
/// The Euclidean norm (a.k.a. 2-norm, `sqrt(real*real + imaginary*imaginary)`).
///
/// This property takes care to avoid spurious over- or underflow in
/// this computation. For example:
///
/// let x: Float = 3.0e+20
/// let x: Float = 4.0e+20
/// let naive = sqrt(x*x + y*y) // +Inf
/// let careful = Complex(x, y).length // 5.0e+20
///
/// Note that it *is* still possible for this property to overflow,
/// because the length can be as much as sqrt(2) times larger than
/// either component, and thus may not be representable in the real type.
///
/// For most use cases, you can use the cheaper `.magnitude`
/// property (which computes the ∞-norm) instead, which always produces
/// a representable result.
///
/// Edge cases:
/// -
/// If a complex value is not finite, its `.length` is `infinity`.
///
/// See also:
/// -
/// - `.magnitude`
/// - `.lengthSquared`
/// - `.phase`
/// - `.polar`
/// - `init(r:θ:)`
@_transparent
public var length: RealType {
let naive = lengthSquared
guard naive.isNormal else { return carefulLength }
return .sqrt(naive)
}
// Internal implementation detail of `length`, moving slow path off
// of the inline function. Note that even `carefulLength` can overflow
// for finite inputs, but only when the result is outside the range
// of representable values.
@usableFromInline
internal var carefulLength: RealType {
guard isFinite else { return .infinity }
return .hypot(x, y)
}
/// The squared length `(real*real + imaginary*imaginary)`.
///
/// This property is more efficient to compute than `length`, but is
/// highly prone to overflow or underflow; for finite values that are
/// not well-scaled, `lengthSquared` is often either zero or
/// infinity, even when `length` is a finite number. Use this property
/// only when you are certain that this value is well-scaled.
///
/// For many cases, `.magnitude` can be used instead, which is similarly
/// cheap to compute and always returns a representable value.
///
/// See also:
/// -
/// - `.length`
/// - `.magnitude`
@_transparent
public var lengthSquared: RealType {
x*x + y*y
}
@available(*, unavailable, renamed: "lengthSquared")
public var unsafeLengthSquared: RealType { lengthSquared }
/// The phase (angle, or "argument").
///
/// Returns the angle (measured above the real axis) in radians. If
/// the complex value is zero or infinity, the phase is not defined,
/// and `nan` is returned.
///
/// Edge cases:
/// -
/// If the complex value is zero or non-finite, phase is `nan`.
///
/// See also:
/// -
/// - `.length`
/// - `.polar`
/// - `init(r:θ:)`
@inlinable
public var phase: RealType {
guard isFinite && !isZero else { return .nan }
return .atan2(y: y, x: x)
}
/// The length and phase (or polar coordinates) of this value.
///
/// Edge cases:
/// -
/// If the complex value is zero or non-finite, phase is `.nan`.
/// If the complex value is non-finite, length is `.infinity`.
///
/// See also:
/// -
/// - `.length`
/// - `.phase`
/// - `init(r:θ:)`
public var polar: (length: RealType, phase: RealType) {
(length, phase)
}
/// Creates a complex value specified with polar coordinates.
///
/// Edge cases:
/// -
/// - Negative lengths are interpreted as reflecting the point through the
/// origin, i.e.:
/// ```
/// Complex(length: -r, phase: θ) == -Complex(length: r, phase: θ)
/// ```
/// - For any `θ`, even `.infinity` or `.nan`:
/// ```
/// Complex(length: .zero, phase: θ) == .zero
/// ```
/// - For any `θ`, even `.infinity` or `.nan`, if `r` is infinite then:
/// ```
/// Complex(length: r, phase: θ) == .infinity
/// ```
/// - Otherwise, `θ` must be finite, or a precondition failure occurs.
///
/// See also:
/// -
/// - `.length`
/// - `.phase`
/// - `.polar`
@inlinable
public init(length: RealType, phase: RealType) {
if phase.isFinite {
self = Complex(.cos(phase), .sin(phase)).multiplied(by: length)
} else {
precondition(
length.isZero || length.isInfinite,
"Either phase must be finite, or length must be zero or infinite."
)
self = Complex(length)
}
}
}
@@ -0,0 +1,99 @@
//===--- Differentiable.swift ---------------------------------*- swift -*-===//
//
// This source file is part of the Swift Numerics open source project
//
// 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
//
//===----------------------------------------------------------------------===//
#if swift(>=5.3) && canImport(_Differentiation)
import _Differentiation
extension Complex: Differentiable
where RealType: Differentiable, RealType.TangentVector == RealType {
public typealias TangentVector = Self
@inlinable
public var zeroTangentVectorInitializer: () -> Self {
{ Complex.zero }
}
}
extension Complex
where RealType: Differentiable, RealType.TangentVector == RealType {
@derivative(of: init(_:_:))
@usableFromInline
static func _derivativeInit(
_ real: RealType,
_ imaginary: RealType
) -> (value: Complex, pullback: (Complex) -> (RealType, RealType)) {
(value: .init(real, imaginary), pullback: { v in
(v.real, v.imaginary)
})
}
@derivative(of: real)
@usableFromInline
func _derivativeReal() -> (value: RealType, pullback: (RealType) -> Complex) {
(value: real, pullback: { v in
Complex(v, .zero)
})
}
@derivative(of: imaginary)
@usableFromInline
func _derivativeImaginary() -> (
value: RealType,
pullback: (RealType) -> Complex
) {
(value: real, pullback: { v in
Complex(.zero, v)
})
}
@derivative(of: +)
@usableFromInline
static func _derivativeAdd(lhs: Complex, rhs: Complex)
-> (value: Complex, pullback: (Complex) -> (Complex, Complex))
{
(lhs + rhs, { v in (v, v) })
}
@derivative(of: -)
@usableFromInline
static func _derivativeSubtract(lhs: Complex, rhs: Complex)
-> (value: Complex, pullback: (Complex) -> (Complex, Complex))
{
(lhs - rhs, { v in (v, -v) })
}
@derivative(of: *)
@usableFromInline
static func _derivativeMultiply(lhs: Complex, rhs: Complex)
-> (value: Complex, pullback: (Complex) -> (Complex, Complex))
{
(lhs * rhs, { v in (rhs * v, lhs * v) })
}
@derivative(of: /)
@usableFromInline
static func _derivativeDivide(lhs: Complex, rhs: Complex)
-> (value: Complex, pullback: (Complex) -> (Complex, Complex))
{
(lhs / rhs, { v in (v / rhs, -lhs / (rhs * rhs) * v) })
}
@derivative(of: conjugate)
@usableFromInline
func _derivativeConjugate() -> (
value: Complex,
pullback: (Complex) -> Complex
) {
(conjugate, { v in v.conjugate })
}
}
#endif
@@ -1,4 +1,4 @@
//===--- Complex+ElementaryFunctions.swift --------------------*- swift -*-===//
//===--- ElementaryFunctions.swift ----------------------------*- swift -*-===//
//
// This source file is part of the Swift.org open source project
//
@@ -119,7 +119,7 @@ extension Complex: ElementaryFunctions {
}
// Special cases out of the way, evaluate as discussed above.
return Complex(
Relaxed.multiplyAdd(.cos(z.y), .expMinusOne(z.x), .cosMinusOne(z.y)),
RealType._mulAdd(.cos(z.y), .expMinusOne(z.x), .cosMinusOne(z.y)),
.exp(z.x) * .sin(z.y)
)
}
@@ -164,7 +164,7 @@ extension Complex: ElementaryFunctions {
)
}
// sinh(x + iy) = sinh(x) cos(y) + i cosh(x) sin(y)
// sinh(x + iy) = sinh(x) cos(y) + i cosh(x) sinh(y)
//
// See cosh above for algorithm details.
@inlinable
@@ -300,7 +300,7 @@ extension Complex: ElementaryFunctions {
// We are not trying for sub-ulp accuracy, just a good relative error
// bound, so for our purposes it suffices to have log u dominate the
// result:
if u >= 1 || u >= Relaxed.multiplyAdd(u, u, v*v) {
if u >= 1 || u >= RealType._mulAdd(u,u,v*v) {
let r = v / u
return Complex(.log(u) + .log(onePlus: r*r)/2, θ)
}
-133
View File
@@ -1,133 +0,0 @@
//===--- Polar.swift ------------------------------------------*- swift -*-===//
//
// This source file is part of the Swift Numerics open source project
//
// Copyright (c) 2019 - 2021 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 RealModule
extension Complex {
/// The Euclidean norm (a.k.a. 2-norm, `sqrt(real*real + imaginary*imaginary)`).
///
/// This property takes care to avoid spurious over- or underflow in
/// this computation. For example:
///
/// let x: Float = 3.0e+20
/// let x: Float = 4.0e+20
/// let naive = sqrt(x*x + y*y) // +Inf
/// let careful = Complex(x, y).length // 5.0e+20
///
/// Note that it *is* still possible for this property to overflow,
/// because the length can be as much as sqrt(2) times larger than
/// either component, and thus may not be representable in the real type.
///
/// For most use cases, you can use the cheaper `.magnitude`
/// property (which computes the ∞-norm) instead, which always produces
/// a representable result.
///
/// Edge cases:
/// - If a complex value is not finite, its `.length` is `infinity`.
///
/// See also `.magnitude`, `.lengthSquared`, `.phase`, `.polar`
/// and `init(r:θ:)`.
@_transparent
public var length: RealType {
let naive = lengthSquared
guard naive.isNormal else { return carefulLength }
return .sqrt(naive)
}
// Internal implementation detail of `length`, moving slow path off
// of the inline function. Note that even `carefulLength` can overflow
// for finite inputs, but only when the result is outside the range
// of representable values.
@usableFromInline
internal var carefulLength: RealType {
guard isFinite else { return .infinity }
return .hypot(x, y)
}
/// The squared length `(real*real + imaginary*imaginary)`.
///
/// This property is more efficient to compute than `length`, but is
/// highly prone to overflow or underflow; for finite values that are
/// not well-scaled, `lengthSquared` is often either zero or
/// infinity, even when `length` is a finite number. Use this property
/// only when you are certain that this value is well-scaled.
///
/// For many cases, `.magnitude` can be used instead, which is similarly
/// cheap to compute and always returns a representable value.
///
/// See also `.length` and `.magnitude`.
@_transparent
public var lengthSquared: RealType {
x*x + y*y
}
@available(*, unavailable, renamed: "lengthSquared")
public var unsafeLengthSquared: RealType { lengthSquared }
/// The phase (angle, or "argument").
///
/// Returns the angle (measured above the real axis) in radians. If
/// the complex value is zero or infinity, the phase is not defined,
/// and `nan` is returned.
///
/// Edge cases:
/// - If the complex value is zero or non-finite, phase is `nan`.
///
/// See also `.length`, `.polar` and `init(r:θ:)`.
@inlinable
public var phase: RealType {
guard isFinite && !isZero else { return .nan }
return .atan2(y: y, x: x)
}
/// The length and phase (or polar coordinates) of this value.
///
/// Edge cases:
/// - If the complex value is zero or non-finite, phase is `.nan`.
/// - If the complex value is non-finite, length is `.infinity`.
///
/// See also: `.length`, `.phase` and `init(r:θ:)`.
public var polar: (length: RealType, phase: RealType) {
(length, phase)
}
/// Creates a complex value specified with polar coordinates.
///
/// Edge cases:
/// - Negative lengths are interpreted as reflecting the point through the
/// origin, i.e.:
/// ```
/// Complex(length: -r, phase: θ) == -Complex(length: r, phase: θ)
/// ```
/// - For any `θ`, even `.infinity` or `.nan`:
/// ```
/// Complex(length: .zero, phase: θ) == .zero
/// ```
/// - For any `θ`, even `.infinity` or `.nan`, if `r` is infinite then:
/// ```
/// Complex(length: r, phase: θ) == .infinity
/// ```
/// - Otherwise, `θ` must be finite, or a precondition failure occurs.
///
/// See also `.length`, `.phase` and `.polar`.
@inlinable
public init(length: RealType, phase: RealType) {
if phase.isFinite {
self = Complex(.cos(phase), .sin(phase)).multiplied(by: length)
} else {
precondition(
length.isZero || length.isInfinite,
"Either phase must be finite, or length must be zero or infinite."
)
self = Complex(length)
}
}
}
+7 -10
View File
@@ -2,14 +2,12 @@
This module provides a `Complex` number type generic over an underlying `RealType`:
```swift
import Numerics
let z = Complex(1,1) // z = 1 + i
1> import ComplexModule
2> let z = Complex(1,1) // z = 1 + i
```
This module provides approximate feature parity and memory layout compatibility with C, Fortran, and C++ complex types (although the importer does not map the types for you, buffers may be reinterpreted to shim API defined in other languages).
This module provides approximate feature parity and memory layout compatibility with C, Fortran, and C++ complex types (although the importer cannot map the types for you, buffers may be reinterpreted to shim API defined in other languages).
The usual arithmetic operators are provided for complex numbers, as well as conversion to and from polar coordinates and many useful properties, plus conformances to the obvious usual protocols: `Equatable`, `Hashable`, `Codable` (if the underlying `RealType` is), and `AlgebraicField` (hence also `AdditiveArithmetic` and `SignedNumeric`).
The `Complex` type conforms to `ElementaryFunctions`, which makes common transcendental functions like `log`, `pow`, and `sin` available (consult the documentation for `ElementaryFunctions` in the `RealModule` for a full list and more information.
The usual arithmetic operators are provided for Complex numbers, as well as conversion to and from polar coordinates and many useful properties, plus conformances to the obvious usual protocols: `Equatable`, `Hashable`, `Codable` (if the underlying `RealType` is), and `AlgebraicField` (hence also `AdditiveArithmetic` and `SignedNumeric`).
### Dependencies:
- `RealModule`.
@@ -38,10 +36,10 @@ They are not provided by the Complex module for two reasons:
}
}
```
This makes heterogeneous arithmetic operators a non-option in the short term.
This is a show-stopper for heterogeneous arithmetic operators in the short term.
### Infinity and nan
C and C++ attempt to define semantics that interpret the signs of infinity and zero.
C and C++ attempt to define precise semantics that interpret the sign of infinity and zero.
This is occasionally useful, but it also results in a lot of extra work.
The Swift Numerics `Complex` type does not assign any semantic meaning to the sign of zero and infinity; `(±0,±0)`, are all considered to be encodings of the value zero.
Similarly, `(±inf, y)`, `(x, ±inf)`, `(nan, y)` and `(x, nan)` are all considered to be encodings of a single exceptional value with infinite magnitude and undefined phase.
@@ -56,8 +54,7 @@ However, in practice there are good reasons to use something else instead:
- The 2-norm requires special care to avoid spurious overflow/underflow, but the naive expressions for the 1-norm ("taxicab norm") or ∞-norm ("sup norm") are always correct.
- Even when care is used, near the overflow boundary the 2-norm and the 1-norm are not representable.
As an example, consider `z = Complex(big, big)`, where `big` is `Double.greatestFiniteMagnitude`.
The 1-norm and 2-norm of `z` both overflow (the 1-norm would be `2*big`, and the 2-norm would be `sqrt(2)*big`, neither of which are representable as `Double`), but the ∞-norm is always equal to either `real` or `imaginary`, so it is guaranteed to be representable.
As an example, consider `z = Complex(big, big)`, where `big` is `Double.greatestFiniteMagnitude`. The 1-norm and 2-norm of `z` both overflow (the 1-norm would be `2*big`, and the 2-norm would be `sqrt(2)*big`, neither of which are representable as `Double`), but the ∞-norm is always equal to either `real` or `imaginary`, so it is guaranteed to be representable.
Because of this, the ∞-norm is the obvious alternative; it gives the nicest API surface.
- If we consider the magnitude of more exotic types, like operators, the 1-norm and ∞-norm are significantly easier to compute than the 2-norm (O(n) vs. "no closed form expression, but O(n^3) iterative methods"), so it is nice to establish a precedent of `.magnitude` binding one of these cheaper-to-compute norms.
- The ∞-norm is heavily used in other computational libraries; for example, it is used by the `izamax` and `icamax` functions in BLAS.
-55
View File
@@ -1,55 +0,0 @@
//===--- Scale.swift ------------------------------------------*- swift -*-===//
//
// This source file is part of the Swift Numerics open source project
//
// Copyright (c) 2019-2021 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
//
//===----------------------------------------------------------------------===//
// Policy: deliberately not using the * and / operators for these at the
// moment, because then there's an ambiguity in expressions like 2*z; is
// that Complex(2) * z or is it RealType(2) * z? This is especially
// problematic in type inference: suppose we have:
//
// let a: RealType = 1
// let b = 2*a
//
// what is the type of b? If we don't have a type context, it's ambiguous.
// If we have a Complex type context, then b will be inferred to have type
// Complex! Obviously, that doesn't help anyone.
//
// TODO: figure out if there's some way to avoid these surprising results
// and turn these into operators if/when we have it.
// (https://github.com/apple/swift-numerics/issues/12)
extension Complex {
/// `self` scaled by `a`.
@usableFromInline @_transparent
internal func multiplied(by a: RealType) -> Complex {
// This can be viewed in two different ways, which are mathematically
// equivalent: either we are computing `self * Complex(a)` (i.e.
// converting `a` to be a complex value, and then using the complex
// multiplication) or we are using the scalar product of the vector
// space structure: `Complex(a*real, a*imaginary)`.
//
// Although these two interpretations are _mathematically_ equivalent,
// they will generate different representations of the point at
// infinity in general. For example, suppose `self` is represented by
// `(infinity, 0)`. Then `self * Complex(1)` would evaluate as
// `(1*infinity - 0*0, 0*infinity + 1*0) = (infinity, nan)`, but
// the vector space interpretation produces `(infinity, 0)`. This does
// not matter much, because these are two representations of the same
// semantic value, but note that one requires four multiplies and two
// additions, while the one we use requires only two real multiplications.
Complex(x*a, y*a)
}
/// `self` unscaled by `a`.
@usableFromInline @_transparent
internal func divided(by a: RealType) -> Complex {
// See implementation notes for `multiplied` above.
Complex(x/a, y/a)
}
}
-21
View File
@@ -1,21 +0,0 @@
#[[
This source file is part of the Swift Numerics open source project
Copyright (c) 2019-2021 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
#]]
add_library(IntegerUtilities
DivideWithRounding.swift
GCD.swift
Rotate.swift
RoundingRule.swift
SaturatingArithmetic.swift
ShiftWithRounding.swift)
set_target_properties(IntegerUtilities PROPERTIES
INTERFACE_INCLUDE_DIRECTORIES ${CMAKE_Swift_MODULE_DIRECTORY})
_install_target(IntegerUtilities)
set_property(GLOBAL APPEND PROPERTY SWIFT_NUMERICS_EXPORTS IntegerUtilities)
@@ -1,315 +0,0 @@
//===--- DivideWithRounding.swift -----------------------------*- swift -*-===//
//
// This source file is part of the Swift Numerics open source project
//
// Copyright (c) 2021 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
//
//===----------------------------------------------------------------------===//
extension BinaryInteger {
/// `self` divided by `other`, rounding the result according to `rule`.
///
/// The default rounding rule is `.down`, which _is not the same_ as the
/// behavior of the `/` operator from the Swift standard library, but is
/// chosen because it generally produces a more useful remainder. In
/// particular, when `b` is positive, the remainder is always positive.
/// To match the behavior of `/`, use the `.towardZero` rounding mode.
///
/// Note that the remainder of division is not always representable in an
/// unsigned type if a rounding rule other than `.down`, `.towardZero`, or
/// `.requireExact` is used. For example:
///
/// let a: UInt = 5
/// let b: UInt = 3
/// let q = a.divided(by: b, rounding: .up) // 2
/// let r = a - b*q // 5 - 3*2 overflows UInt.
///
/// For this reason, there is no `remainder(dividingBy:rounding:)`
/// operation defined on `BinaryInteger`. Signed integers do not have
/// this problem, so it is defined on the `SignedInteger` protocol
/// instead, as is an overload of `divided(by:rounding:)` that returns
/// both quotient and remainder.
@inlinable
public func divided(
by other: Self,
rounding rule: RoundingRule = .down
) -> Self {
// "Normal divsion" rounds toward zero, so we get self = q*other + r
// with |r| < |other| and r matching the sign of self.
let q = self / other
let r = self - q*other
// In every rounding mode, the result is the same when the result is
// exact.
if r == 0 { return q }
// From this point forward, we can assume r != 0.
//
// To get the quotient and remainder rounded as directed by rule, we
// will adjust q and r. Note that the quotient is either q-1 or q (if
// q is negative) or q or q+1 (if q is positive), because q has been
// rounded toward zero.
//
// If we subtract 1 from q, we add other to r to compensate, because:
//
// self = q*other + r
// = (q-1)*other + (r+other)
//
// Similarly, if we add 1 to q, we subtract other from r to compensate.
switch rule {
case .down:
// For rounding down, we want to have r match the sign of other
// rather than self; this means that if the signs of r and other
// disagree, we have to adjust q downward and r to match.
if other.signum() != r.signum() { return q-1 }
return q
case .up:
// For rounding up, we want to have r have the opposite sign of
// other; if not, we adjust q upward and r to match.
if other.signum() == r.signum() { return q+1 }
return q
case .towardZero:
// This is exactly what the `/` operator did for us.
return q
case .toOdd:
// If q is already odd, we're done.
if q._lowWord & 1 == 1 { return q }
// Otherwise, q is even but inexact; it was originally rounded toward
// zero, so rounding away from zero instead will make it odd.
fallthrough
case .awayFromZero:
// To round away from zero, we apply the adjustments for both down
// and up.
if other.signum() != r.signum() { return q-1 }
return q+1
case .toNearestOrAwayFromZero:
// For round to nearest or away, the condition we want to satisfy is
// |r| <= |other/2|, with sign(q) != sign(r) when equality holds.
if r.magnitude < other.magnitude.shifted(rightBy: 1, rounding: .up) {
return q
}
// The (q,r) we have does not satisfy the to nearest or away condition;
// round away from zero to choose the other representative of (q, r).
if other.signum() != r.signum() { return q-1 }
return q+1
case .toNearestOrEven:
// For round to nearest or away, the condition we want to satisfy is
// |r| <= |other/2|, with q even when equality holds.
if r.magnitude > other.magnitude.shifted(rightBy: 1, rounding: .down) ||
2*r.magnitude == other.magnitude && q._lowWord & 1 == 1 {
if (other > 0) != (r > 0) { return q-1 }
return q+1
}
return q
case .stochastically:
var qhi: UInt64
var rhi: UInt64
if other.magnitude <= UInt64.max {
qhi = UInt64(other.magnitude)
rhi = UInt64(r.magnitude)
} else {
// TODO: this is untested currently.
let qmag = other.magnitude
let shift = qmag._msb - 1
qhi = UInt64(truncatingIfNeeded: qmag >> shift)
rhi = UInt64(truncatingIfNeeded: r.magnitude >> shift)
}
let (sum, car) = rhi.addingReportingOverflow(.random(in: 0 ..< qhi))
if car || sum >= qhi {
if (other > 0) != (r > 0) { return q-1 }
return q+1
}
return q
case .requireExact:
preconditionFailure("Division was not exact.")
}
}
// TODO: make this API and make it possible to implement more efficiently.
// Customization point on new/revised integer protocol? Shouldn't have to
// go through .words.
/// The index of the most-significant set bit.
///
/// - Precondition: self is assumed to be non-zero (should be changed
/// if/when this becomes API).
@usableFromInline
internal var _msb: Int {
// a == 0 is never used for division, because this is called
// on the divisor which cannot be zero as a precondition; if
// this becomes API, the behavior for this case will have to
// be defined.
assert(self != 0)
// Because self is non-zero, mswIndex is guaranteed to exist,
// hence force-unwrap is appropriate.
let mswIndex = words.lastIndex { $0 != 0 }!
let mswBits = UInt.bitWidth * words.distance(from: words.startIndex, to: mswIndex)
return mswBits + (UInt.bitWidth - words[mswIndex].leadingZeroBitCount - 1)
}
}
extension SignedInteger {
/// Divides `self` by `other`, rounding the quotient according to `rule`,
/// and returns the remainder.
///
/// The default rounding rule is `.down`, which _is not the same_ as the
/// behavior of the `%` operator from the Swift standard library, but is
/// chosen because it generally produces a more useful remainder. To
/// match the behavior of `%`, use the `.towardZero` rounding mode.
///
/// - Precondition: `other` cannot be zero.
@inlinable
public func remainder(
dividingBy other: Self,
rounding rule: RoundingRule = .down
) -> Self {
// Produce correct remainder for the .min/-1 case, rather than trapping.
if other == -1 { return 0 }
return self.divided(by: other, rounding: rule).remainder
}
/// Divides `self` by `other`, rounding the quotient according to `rule`,
/// and returns both the quotient and remainder.
///
/// The default rounding rule is `.down`, which _is not the same_ as the
/// behavior of the `/` operator from the Swift standard library, but is
/// chosen because it generally produces a more useful remainder. To
/// match the behavior of `/`, use the `.towardZero` rounding mode.
///
/// Because the default rounding mode does not match Swift's standard
/// library, this function is a disfavored overload of `divided(by:)`
/// instead of using the name `quotientAndRemainder(dividingBy:)`, which
/// would shadow the standard library operation and change the behavior
/// of any existing use sites. To call this method, you must explicitly
/// bind the result to a tuple:
///
/// // This calls BinaryInteger's method, which returns only
/// // the quotient.
/// let result = 5.divided(by: 3, rounding: .up) // 2
///
/// // This calls SignedInteger's method, which returns both
/// // the quotient and remainder.
/// let (q, r) = 5.divided(by: 3, rounding: .up) // (q = 2, r = -1)
@inlinable @inline(__always) @_disfavoredOverload
public func divided(
by other: Self,
rounding rule: RoundingRule = .down
) -> (quotient: Self, remainder: Self) {
// "Normal divsion" rounds toward zero, so we get self = q*other + r
// with |r| < |other| and r matching the sign of self.
let q = self / other
let r = self - q*other
// In every rounding mode, the result is the same when the result is
// exact.
if r == 0 { return (q, r) }
// From this point forward, we can assume r != 0.
//
// To get the quotient and remainder rounded as directed by rule, we
// will adjust q and r. Note that the quotient is either q-1 or q (if
// q is negative) or q or q+1 (if q is positive), because q has been
// rounded toward zero.
//
// If we subtract 1 from q, we add other to r to compensate, because:
//
// self = q*other + r
// = (q-1)*other + (r+other)
//
// Similarly, if we add 1 to q, we subtract other from r to compensate.
switch rule {
case .down:
// For rounding down, we want to have r match the sign of other
// rather than self; this means that if the signs of r and other
// disagree, we have to adjust q downward and r to match.
if other.signum() != r.signum() { return (q-1, r+other) }
return (q, r)
case .up:
// For rounding up, we want to have r have the opposite sign of
// other; if not, we adjust q upward and r to match.
if other.signum() == r.signum() { return (q+1, r-other) }
return (q, r)
case .towardZero:
// This is exactly what the `/` operator did for us.
return (q, r)
case .toOdd:
// If q is already odd, we're done.
if q._lowWord & 1 == 1 { return (q, r) }
// Otherwise, q is even but inexact; it was originally rounded toward
// zero, so rounding away from zero instead will make it odd.
fallthrough
case .awayFromZero:
// To round away from zero, we apply the adjustments for both down
// and up.
if other.signum() != r.signum() { return (q-1, r+other) }
return (q+1, r-other)
case .toNearestOrAwayFromZero:
// For round to nearest or away, the condition we want to satisfy is
// |r| <= |other/2|, with sign(q) != sign(r) when equality holds.
if r.magnitude < other.magnitude.shifted(rightBy: 1, rounding: .up) {
return (q, r)
}
// The (q,r) we have does not satisfy the to nearest or away condition;
// round away from zero to choose the other representative of (q, r).
if other.signum() != r.signum() { return (q-1, r+other) }
return (q+1, r-other)
case .toNearestOrEven:
// For round to nearest or away, the condition we want to satisfy is
// |r| <= |other/2|, with q even when equality holds.
if r.magnitude > other.magnitude.shifted(rightBy: 1, rounding: .down) ||
2*r.magnitude == other.magnitude && q._lowWord & 1 == 1 {
if (other > 0) != (r > 0) { return (q-1, r+other) }
return (q+1, r-other)
}
return (q, r)
case .stochastically:
var qhi: UInt64
var rhi: UInt64
if other.magnitude <= UInt64.max {
qhi = UInt64(other.magnitude)
rhi = UInt64(r.magnitude)
} else {
// TODO: this is untested currently.
let qmag = other.magnitude
let shift = qmag._msb - 1
qhi = UInt64(truncatingIfNeeded: qmag >> shift)
rhi = UInt64(truncatingIfNeeded: r.magnitude >> shift)
}
let (sum, car) = rhi.addingReportingOverflow(.random(in: 0 ..< qhi))
if car || sum >= qhi {
if (other > 0) != (r > 0) { return (q-1, r+other) }
return (q+1, r-other)
}
return (q, r)
case .requireExact:
preconditionFailure("Division was not exact.")
}
}
}
/// `a = quotient*b + remainder`, with `remainder >= 0`.
///
/// When `a` and `b` are both positive, `quotient` is `a/b` and `remainder`
/// is `a%b`.
///
/// Rounding the quotient so that the remainder is non-negative is called
/// "Euclidean division". This is not a _rounding rule_, as `quotient`
/// cannot be determined from the unrounded value `a/b`; we need to also
/// know the sign of `a` or `b` or `r` to know which way to round. Because
/// of this, is not present in the `RoundingRule` enum and uses a separate
/// API from the other division operations.
///
/// - Parameters:
/// - a: The dividend
/// - b: The divisor
///
/// - Precondition: `b` must be non-zero, and the quotient `a/b` must be
/// representable. In particular, if `T` is a signed fixed-width integer
/// type, then `euclideanDivision(T.min, -1)` will trap, because `-T.min`
/// is not representable.
///
/// - Returns: `(quotient, remainder)`, with `0 <= remainder < b.magnitude`.
func euclideanDivision<T>(_ a: T, _ b: T) -> (quotient: T, remainder: T)
where T: SignedInteger
{
a.divided(by: b, rounding: a >= 0 ? .towardZero : .awayFromZero)
}
-53
View File
@@ -1,53 +0,0 @@
//===--- GCD.swift --------------------------------------------*- swift -*-===//
//
// This source file is part of the Swift Numerics open source project
//
// Copyright (c) 2021 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
//
//===----------------------------------------------------------------------===//
/// The greatest common divisor of `a` and `b`.
///
/// If both inputs are zero, the result is zero. If one input is zero, the
/// result is the absolute value of the other input.
///
/// The result must be representable within its type. In particular, the gcd
/// of a signed, fixed-width integer type's minimum with itself (or zero)
/// cannot be represented, and results in a trap.
///
/// gcd(Int.min, Int.min) // Overflow error
/// gcd(Int.min, 0) // Overflow error
///
/// [wiki]: https://en.wikipedia.org/wiki/Greatest_common_divisor
@inlinable
public func gcd<T: BinaryInteger>(_ a: T, _ b: T) -> T {
var x = a.magnitude
var y = b.magnitude
if x == 0 { return T(y) }
if y == 0 { return T(x) }
let xtz = x.trailingZeroBitCount
let ytz = y.trailingZeroBitCount
y >>= ytz
// The binary GCD algorithm
//
// After the right-shift in the loop, both x and y are odd. Each pass removes
// at least one low-order bit from the larger of the two, so the number of
// iterations is bounded by the sum of the bit-widths of the inputs.
//
// A tighter bound is the maximum bit-width of the inputs, which is achieved
// by odd numbers that sum to a power of 2, though the proof is more involved.
repeat {
x >>= x.trailingZeroBitCount
if x < y { swap(&x, &y) }
x -= y
} while x != 0
return T(y << min(xtz, ytz))
}
-68
View File
@@ -1,68 +0,0 @@
# Integer Utilities
_Note: This module is only present on `main`, and has not yet been stabilized and released in a tag._
## Utilities defined for `BinaryInteger`
The following API are defined for all integer types:
- The `gcd(_:_:)` free function implements the _Greatest Common Divisor_ operation.
- The `shifted(rightBy:rounding:)` method implements _bitwise shift with rounding_.
- The `divided(by:rounding:)` method implements division with specified rounding.
(See also `SignedInteger.divided(by:rounding:)`, `remainder(dividingBy:rounding:)`, and `euclideanDivision(_:_:)` below).
## Utilities defined for `SignedInteger`
The following API are defined for signed integer types:
- The `divided(by:rounding:)` method implementing division with specified rounding, returning both quotient and remainder.
This requires a signed type because the remainder is not generally representable for unsigned types.
This is a disfavored overload; by default, you will get only the quotient as the result:
```
let p = 5.divided(by: 3, rounding: .up) // p = 2
let (q, r) = 5.divided(by: 3, rounding: .up) // q = 2, r = -1
```
- The `remainder(dividingBy:rounding:)` method implementing the remainder operation; the `rounding` argument describes how to round the _quotient_, which is not returned.
(The remainder is always exact, and hence is not rounded).
- The `euclideanDivision(_:_:)` free function implements _Euclidean division_.
In this operation, the remainder is chosen to always be non-negative.
This does not correspond to any rounding rule on the quotient, which is why it uses a distinct API.
## Utilities defined for `FixedWidthInteger`
- The `rotated(right:)` and `rotated(left:)` methods implement _bitwise rotation_ for signed and unsigned integer types.
The count parameter may be any `BinaryInteger` type.
### [Saturating Arithmetic][saturating]
The following saturating operations are defined as methods on `FixedWidthInteger`:
- `addingWithSaturation(_:)`
- `subtractingWithSaturation(_:)`
- `negatedWithSaturation(_:)`
- `multipliedWithSaturation(by:)`
- `shiftedWithSaturation(leftBy:rounding:)`
These implement _saturating arithmetic_.
They are an alternative to the usual `+`, `-`, and `*` operators, which trap if the result cannot be represented in the argument type, and `&+`, `&-`, `&*`, and `<<`, which wrap out-of-range results modulo 2ⁿ for some n.
Instead these methods clamp the result to the representable range of the type:
```
let x: Int8 = 84
let y: Int8 = 100
let a = x + y // traps due to overflow
let b = x &+ y // wraps to -72
let c = x.addingWithSaturation(y) // saturates to 127
```
If you are using saturating arithmetic, you may also want to perform saturating conversions between integer types; this functionality is provided by the standard library via the [`init(clamping:)` API][clamping].
## Types
The `RoundingRule` enum is used with shift, division, and round operations to specify how to round their results to a representable value.
[saturating]: https://en.wikipedia.org/wiki/Saturation_arithmetic
[clamping]: https://developer.apple.com/documentation/swift/binaryinteger/init(clamping:)
-43
View File
@@ -1,43 +0,0 @@
//===--- Rotate.swift -----------------------------------------*- swift -*-===//
//
// This source file is part of the Swift Numerics open source project
//
// Copyright (c) 2021 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
//
//===----------------------------------------------------------------------===//
extension FixedWidthInteger {
@_transparent @usableFromInline
internal func rotateImplementation(right count: Int) -> Self {
// We don't have an unsigned right shift operation for signed values, so
// we need to convert to an unsigned type. The only unsigned type that's
// guaranteed to be able to represent the bit pattern of any Self value
// is Magnitude. It would be possible to have Magnitude be _wider_ than
// Self, but that's OK as long as we're careful to complement the shift
// count using Self.bitWidth and not Magnitude.bitWidth or zero.
let bitPattern = Magnitude(truncatingIfNeeded: self)
let countComplement = Self.bitWidth &- count
return Self(truncatingIfNeeded:
bitPattern &>> count | bitPattern &<< countComplement
)
}
/// `self` rotated bitwise right by `count` bits.
///
/// Equivalent to `rotated(left: 0 &- count)`.
@inlinable
public func rotated<Count: BinaryInteger>(right count: Count) -> Self {
rotateImplementation(right: Int(truncatingIfNeeded: count))
}
/// `self` rotated bitwise left by `count` bits.
///
/// Equivalent to `rotated(right: 0 &- count)`.
@inlinable
public func rotated<Count: BinaryInteger>(left count: Count) -> Self {
rotateImplementation(right: 0 &- Int(truncatingIfNeeded: count))
}
}
-187
View File
@@ -1,187 +0,0 @@
//===--- RoundingRule.swift -----------------------------------*- swift -*-===//
//
// This source file is part of the Swift Numerics open source project
//
// Copyright (c) 2021 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
//
//===----------------------------------------------------------------------===//
/// A rule that defines how to select one of the two representable results
/// closest to a given value.
///
/// [Wikipedia](https://en.wikipedia.org/wiki/Rounding#Rounding_to_integer)
/// provides a good overview of different rounding rules.
///
/// Examples using rounding to integer to illustrate the various options:
/// ```
/// value | down | up | towardZero | awayFromZero |
/// =======+==============+==============+==============+==============+
/// 1.5 | 1 | 2 | 1 | 2 |
/// -------+--------------+--------------+--------------+--------------+
/// -0.5 | -1 | 0 | 0 | -1 |
/// -------+--------------+--------------+--------------+--------------+
/// 0.3 | 0 | 1 | 0 | 1 |
/// -------+--------------+--------------+--------------+--------------+
/// 2 | 2 | 2 | 2 | 2 |
/// -------+--------------+--------------+--------------+--------------+
///
/// value | toOdd | toNearestOrAwayFromZero | toNearestOrEven |
/// =======+==============+=========================+==================+
/// 1.5 | 1 | 2 | 2 |
/// -------+--------------+-------------------------+------------------+
/// -0.5 | -1 | -1 | 0 |
/// -------+--------------+-------------------------+------------------+
/// 0.3 | 1 | 0 | 0 |
/// -------+--------------+-------------------------+------------------+
/// 2 | 2 | 2 | 2 |
/// -------+--------------+-------------------------+------------------+
///
/// value | stochastically | requireExact |
/// =======+=======================+================+
/// 1.5 | 50% 1, 50% 2 | trap |
/// -------+-----------------------+----------------+
/// -0.5 | 50% -1, 50% 0 | trap |
/// -------+-----------------------+----------------+
/// 0.3 | 70% 0, 30% 1 | trap |
/// -------+-----------------------+----------------+
/// 2 | 2 | 2 |
/// -------+-----------------------+----------------+
/// ```
public enum RoundingRule {
/// Produces the closest representable value that is less than or equal
/// to the value being rounded.
///
/// This is the default rounding mode for integer shifts, including the
/// shift operators defined in the standard library.
///
/// Examples:
/// - `(-4).divided(by: 3, rounding: .down)` is `-2`, because –2 is the
/// largest integer less than –4/3 = –1.3̅
/// - `5.shifted(rightBy: 1, rounding: .down)` is `2`, because 2 is the
/// largest integer less than 5/2 = 2.5.
case down
/// Produces the closest representable value that is greater than or equal
/// to the value being rounded.
///
/// Examples:
/// - `(-4).divided(by: 3, rounding: .up)` is `-1`, because –1 is the
/// smallest integer greater than –4/3 = –1.3̅
/// - `5.shifted(rightBy: 1, rounding: .up)` is `3`, because 3 is the
/// smallest integer greater than 5/2 = 2.5.
case up
/// Produces the closest representable value whose magnitude is less than
/// or equal to that of the value being rounded.
///
/// Examples:
/// - `(-4).divided(by: 3, rounding: .towardZero)` is `-1`, because –1
/// is the closest integer to –4/3 = –1.3̅ with smaller magnitude.
/// - `5.shifted(rightBy: 1, rounding: .towardZero)` is `2`, because 2
/// is the closest integer to 5/2 = 2.5 with smaller magnitude.
case towardZero
/// Produces the closest representable value whose magnitude is greater
/// than or equal to that of the value being rounded.
///
/// Examples:
/// - `(-4).divided(by: 3, rounding: .awayFromZero)` is `-2`, because –2
/// is the closest integer to –4/3 = –1.3̅ with greater magnitude.
/// - `5.shifted(rightBy: 1, rounding: .awayFromZero)` is `3`, because 3
/// is the closest integer to 5/2 = 2.5 with greater magnitude.
case awayFromZero
/// If the value being rounded is representable, that value is returned.
/// Otherwise, whichever of the two closest representable values has its
/// least significant bit set is returned.
///
/// This is also called _sticky rounding_, and it is useful as an
/// implementation detail because it has the property that if we do
/// rounding in two steps, first to intermediate precision p₁ with .toOdd,
/// then to the final precision p₂ with any other rounding mode, the result
/// we get is the same as if we rounded directly to p₂ in the desired mode
/// so long as p₂ + 1 < p₁. Other rounding modes do not have this property,
/// and admit _double roundings_ when interoperating with some modes.
///
/// Examples:
/// - `(-4).divided(by: 3, rounding: .toOdd)` is `-1`, because –4/3 = –1.3̅
/// is not an exact integer, and –1 is the closest odd integer.
/// - `4.shifted(rightBy: 1, rounding: .toOdd)` is `2`,
/// even though 2 is even, because 4/2 is exactly 2 and no rounding occurs.
case toOdd
/// Produces the representable value that is closest to the value being
/// rounded. If two values are equally close, the one that has greater
/// magnitude is returned.
///
/// Examples:
/// - `(-4).divided(by: 3, rounding: .toNearestOrAwayFromZero)`
/// is `-1`, because –4/3 = –1.3̅ is closer to –1 than it is to –2.
///
/// - `5.shifted(rightBy: 1, rounding: .toNearestOrAwayFromZero)` is `3`,
/// because 5/2 = 2.5 is equally close to 2 and 3, and 3 is further away
/// from zero.
case toNearestOrAwayFromZero
/// Produces the representable value that is closest to the value being
/// rounded. If two values are equally close, the one whose least
/// significant bit is not set is returned.
///
/// Examples:
/// - `(-4).divided(by: 3, rounding: .toNearestOrEven)`
/// is `-1`, because –4/3 = –1.3̅ is closer to –1 than it is to –2.
///
/// - `5.shifted(rightBy: 1, rounding: .toNearestOrEven)` is `2`,
/// because 5/2 = 2.5 is equally close to 2 and 3, and 2 is even.
case toNearestOrEven
/// Adds a uniform random value from [0, d) to the value being rounded,
/// where d is the distance between the two closest representable values,
/// then rounds the sum downwards.
///
/// Unlike all the other rounding modes, this mode is _not deterministic_;
/// repeated calls to rounding operations with this mode will generally
/// produce different results. There is a tradeoff implicit in using this
/// mode: you can sacrifice _reproducible_ results to get _more accurate_
/// results in aggregate. For a contrived but illustrative example, consider
/// the following:
/// ```
/// let data = Array(repeating: 1, count: 100)
/// let result = data.reduce(0) {
/// $0 + $1.divided(by: 3, rounding: rule)
/// }
/// ```
/// because 1/3 is always the same value between 0 and 1, any
/// deterministic rounding rule must produce either 0 or 100 for
/// this computation. But rounding `stochastically` will
/// produce a value close to 33. The _error_ of the computation
/// is smaller, but the result will now change between runs of the
/// program.
///
/// For this simple case a better solution would be to add the
/// values first, and then divide. This gives a result that is both
/// reproducible _and_ accurate:
/// ```
/// let result = data.reduce(0, +)/3
/// ```
/// but this isn't always possible in more sophisticated scenarios,
/// and in those cases this rounding rule may be useful.
///
/// Examples:
/// - `(-4).divided(by: 3, rounding: .stochastically)`
/// will be –1 with probability 2/3 and –2 with probability 1/3.
/// - `5.shifted(rightBy: 1, rounding: .stochastically)`
/// will be 2 with probability 1/2 and 3 with probability 1/2.
case stochastically
/// If the value being rounded is representable, that value is returned.
/// Otherwise, a precondition failure occurs.
///
/// Examples:
/// - `(-4).divided(by: 3, rounding: .requireExact)` will trap,
/// because –4/3 = –1.3̅ is not an integer.
case requireExact
}
@@ -1,167 +0,0 @@
//===--- SaturatingArithmetic.swift ---------------------------*- swift -*-===//
//
// This source file is part of the Swift Numerics open source project
//
// Copyright (c) 2023 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
//
//===----------------------------------------------------------------------===//
extension FixedWidthInteger {
/// `~0` (all-ones) if this value is negative, otherwise `0`.
///
/// Note that if `Self` is unsigned, this always returns `0`,
/// but it is useful for writing algorithms that are generic over
/// signed and unsigned integers.
@inline(__always) @usableFromInline
var signbit: Self {
return self < .zero ? ~.zero : .zero
}
/// Saturating integer addition
///
/// `self + other` clamped to the representable range of the type. e.g.:
/// ```
/// let a: Int8 = 84
/// let b: Int8 = 100
/// // 84 + 100 = 184 is not representable as
/// // Int8, so `c` is clamped to Int8.max (127).
/// let c = a.addingWithSaturation(b)
/// ```
///
/// Anytime the "normal addition" `self + other` does not trap,
/// `addingWithSaturation` produces the same result.
@inlinable
public func addingWithSaturation(_ other: Self) -> Self {
let (wrapped, overflow) = addingReportingOverflow(other)
return overflow ? Self.max &- signbit : wrapped
}
/// Saturating integer subtraction
///
/// `self - other` clamped to the representable range of the type. e.g.:
/// ```
/// let a: UInt = 37
/// let b: UInt = 42
/// // 37 - 42 = -5, which is not representable as
/// // UInt, so `c` is clamped to UInt.min (zero).
/// let c = a.subtractingWithSaturation(b)
/// ```
///
/// Note that `a.addingWithSaturation(-b)` is not always equivalent to
/// `a.subtractingWithSaturation(b)`, because `-b` is not representable
/// if `b` is the minimum value of a signed type.
///
/// Anytime the "normal subtraction" `self - other` does not trap,
/// `subtractingWithSaturation` produces the same result.
@inlinable
public func subtractingWithSaturation(_ other: Self) -> Self {
let (wrapped, overflow) = subtractingReportingOverflow(other)
if !overflow { return wrapped }
return Self.isSigned ? Self.max &- signbit : 0
}
/// Saturating integer negation
///
/// For unsigned types, the result is always zero. This is not very
/// interesting, but may occasionally be useful in generic contexts.
/// For signed types, the result is `-self` unless `self` is `.min`,
/// in which case the result is `.max`.
@inlinable
public func negatedWithSaturation() -> Self {
Self.zero.subtractingWithSaturation(self)
}
/// Saturating integer multiplication
///
/// `self * other` clamped to the representable range of the type. e.g.:
/// ```
/// let a: Int8 = -16
/// let b: Int8 = -8
/// // -16 * -8 = 128 is not representable as
/// // Int8, so `c` is clamped to Int8.max (127).
/// let c = a.multipliedWithSaturation(by: b)
/// ```
///
/// Anytime the "normal multiplication" `self * other` does not trap,
/// `multipliedWithSaturation` produces the same result.
@inlinable
public func multipliedWithSaturation(by other: Self) -> Self {
let (high, low) = multipliedFullWidth(by: other)
let wrapped = Self(truncatingIfNeeded: low)
if high == wrapped.signbit { return wrapped }
return Self.max &- high.signbit
}
/// Bitwise left with rounding and saturation.
///
/// `self` multiplied by the rational number 2^(`count`), saturated to the
/// range `Self.min ... Self.max`, and rounded according to `rule`.
///
/// See `shifted(rightBy:rounding:)` for more discussion of rounding
/// shifts with examples.
///
/// - Parameters:
/// - leftBy count: the number of bits to shift by. If positive, this is a left-shift,
/// and if negative a right shift.
/// - rounding rule: the direction in which to round if `count` is negative.
@inlinable
public func shiftedWithSaturation(
leftBy count: Int,
rounding rule: RoundingRule = .down
) -> Self {
if count == 0 { return self }
// If count is negative, negate it and do a right shift without
// saturation instead, since we already have that implemented.
guard count > 0 else {
return shifted(
rightBy: count.negatedWithSaturation(),
rounding: rule
)
}
let clamped = Self.max &- signbit
guard count < Self.bitWidth else {
// If count is bitWidth or greater, we always overflow
// unless self is zero.
return self == 0 ? 0 : clamped
}
// Now we have 0 < count < bitWidth, so we can use a nice
// straightforward implementation; a shift overflows if
// the complementary shift doesn't match sign-or-zero
// extension. E.g.:
//
// - signed 0b0010_1111 << 2 overflows, because
// 0b0010_1111 >> 5 is 0b0000_0001, which does not
// equal 0b0000_0000
//
// - unsigned 0b0010_1111 << 2 does not overflow,
// because 0b0010_0000 >> 6 is 0b0000_0000, which
// does equal 0b0000_0000.
let valueBits = Self.bitWidth &- (Self.isSigned ? 1 : 0)
let wrapped = self &<< count
let complement = valueBits &- count
return self &>> complement == signbit ? wrapped : clamped
}
/// Bitwise left with rounding and saturation.
///
/// `self` multiplied by the rational number 2^(`count`), saturated to the
/// range `Self.min ... Self.max`, and rounded according to `rule`.
///
/// See `shifted(rightBy:rounding:)` for more discussion of rounding
/// shifts with examples.
///
/// - Parameters:
/// - leftBy count: the number of bits to shift by. If positive, this is a left-shift,
/// and if negative a right shift.
/// - rounding rule: the direction in which to round if `count` is negative.
@_transparent
public func shiftedWithSaturation<Count: BinaryInteger>(
leftBy count: Count,
rounding rule: RoundingRule = .down
) -> Self {
self.shiftedWithSaturation(leftBy: Int(clamping: count), rounding: rule)
}
}
@@ -1,197 +0,0 @@
//===--- ShiftWithRounding.swift ------------------------------*- swift -*-===//
//
// This source file is part of the Swift Numerics open source project
//
// Copyright (c) 2021 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
//
//===----------------------------------------------------------------------===//
extension BinaryInteger {
/// `self` divided by 2^(`count`), rounding the result according to `rule`.
///
/// The default rounding rule is `.down`, which matches the behavior of
/// the `>>` operator from the standard library.
///
/// Some examples of different rounding rules:
///
/// // 3/2 is 1.5, which rounds (down by default) to 1.
/// 3.shifted(rightBy: 1)
///
/// // 1.5 rounds up to 2.
/// 3.shifted(rightBy: 1, rounding: .up)
///
/// // The two closest values are 1 and 2, 1 is returned because it
/// // is odd.
/// 3.shifted(rightBy: 1, rounding: .toOdd)
///
/// // 7/4 = 1.75, so the result is 1 with probability 1/4, or 2
/// // with probability 3/4.
/// 7.shifted(rightBy: 2, rounding: .stochastically)
///
/// // 4/4 is exactly 1, so this does not trap.
/// 4.shifted(rightBy: 2, rounding: .requireExact)
///
/// // 5/2 is 2.5, which is not an integer, so this traps.
/// 5.shifted(rightBy: 1, rounding: .requireExact)
///
/// When `Self(1) << count` is positive, the following are equivalent:
///
/// a.shifted(rightBy: count, rounding: rule)
/// a.divided(by: 1 << count, rounding: rule)
@inlinable
public func shifted(
rightBy count: Int,
rounding rule: RoundingRule = .down
) -> Self {
// Easiest case: count is zero or negative, so shift is always exact;
// delegate to the normal >> operator.
if count <= 0 { return self >> count }
if count >= bitWidth {
// Note: what follows would cause an infinite loop if bitWidth <= 1.
// This will essentially never happen, but in the highly unlikely event
// that we encounter such a case, we promote to Int8, do the shift, and
// then convert back to the appropriate result type.
if bitWidth <= 1 {
return Self(Int8(self).shifted(rightBy: count, rounding: rule))
}
// That pathological case taken care of, we can now handle over-wide
// shifts by first shifting all but bitWidth - 1 bits with sticky
// rounding, and then shifting the remaining bitWidth - 1 bits with
// the desired rounding mode.
let count = count - (bitWidth - 1)
let floor = self >> count
let lost = self - (floor << count)
let sticky = floor | (lost == 0 ? 0 : 1)
return sticky.shifted(rightBy: bitWidth - 1, rounding: rule)
}
// Now we are in the happy case: 0 < count < bitWidth, which makes all
// the math to handle rounding simpler.
//
// TODO: If we were really, really careful about overflow, some of these
// could be made simpler. E.g. mathematically round up is implemented here
// via:
//
// floor = self >> count
// mask = 1 << count - 1
// lost = self & mask
// return floor + (lost == 0 ? 0 : 1)
//
// _if_ we didn't have to worry about intermediate overflow (either because
// self is bounded away from .max or because we don't have a fixed-width
// type), then we could use the following instead:
//
// mask = 1 << count - 1
// return (self + mask) >> count
//
// However, self + mask can overflow, e.g. if we're shifting .max by 1:
//
// mask = 1 << 1 - 1 = 1
// self + mask = .max + 1 // uh-oh
//
// This cannot occur for arbitrary-precision numbers, so we could use
// the simpler expressions for those (but those are precisely the cases
// where performance of rounding does not matter much, because shifts
// get swamped by even basic arithmetic). More interesting, we could
// promote fixed-width numbers to a wider type, preventing this
// intermediate overflow and allowing us to use the simpler expressions
// much of the time. We could also explicitly _detect_ the overflow if
// it happens and patch up the result, though this is a little bit tricky
// because addingReportingOverflow and friends do not exist on
// BinaryInteger. Hence, this is a TODO for the future.
let mask = Magnitude(1) << count - 1
let lost = Magnitude(truncatingIfNeeded: self) & mask
let floor = self >> count
let ceiling = floor + (lost == 0 ? 0 : 1)
switch rule {
case .down:
return floor
case .up:
return ceiling
case .towardZero:
return self > 0 ? floor : ceiling
case .awayFromZero:
return self < 0 ? floor : ceiling
case .toOdd:
return floor | (lost == 0 ? 0 : 1)
case .toNearestOrAwayFromZero:
let round = mask >> 1 + (self > 0 ? 1 : 0)
return floor + Self((round + lost) >> count)
case .toNearestOrEven:
let round = mask >> 1 + Magnitude(floor & 1)
return floor + Self((round + lost) >> count)
case .stochastically:
// TODO: it's unfortunate that we can't specify a custom random source
// for the stochastically rounding rule, but I don't see a nice way to
// have that share the API with the other rounding rules, because we'd
// then have to take the RNG in-out. The same problem applies to
// rounding with dithering. We should consider adding a stateful
// rounding API down the road to support those use cases.
//
// In theory, u01 should be Self.random(in: 0 ..< onesBit), but the
// random(in:) method does not exist on BinaryInteger. This is
// (arguably) good, though, because there's actually no reason to
// generate large amounts of randomness just to implement stochastic
// rounding; 32b suffices for almost all purposes, and 64b is more
// than enough.
var g = SystemRandomNumberGenerator()
let u01 = g.next()
if count < 64 {
// count is small, so mask and lost are representable as both
// UInt64 and Self, regardless of what type Self actually is.
return floor + Self(((u01 & UInt64(mask)) + UInt64(lost)) >> count)
} else {
// count is large, so lost may not be representable as UInt64; pre-
// shift by count-64 to isolate the high 64b of the fraction, then
// add u01 and carry-out to round.
let highWord = UInt64(truncatingIfNeeded: lost >> (Int(count) - 64))
let (_, carry) = highWord.addingReportingOverflow(u01)
return floor + (carry ? 1 : 0)
}
case .requireExact:
precondition(lost == 0, "shift was not exact.")
return floor
}
}
/// `self` divided by 2^(`count`), rounding the result according to `rule`.
///
/// The default rounding rule is `.down`, which matches the behavior of
/// the `>>` operator from the standard library.
///
/// Some examples of different rounding rules:
///
/// // 3/2 is 1.5, which rounds (down by default) to 1.
/// 3.shifted(rightBy: 1)
///
/// // 1.5 rounds up to 2.
/// 3.shifted(rightBy: 1, rounding: .up)
///
/// // The two closest values are 1 and 2, 1 is returned because it
/// // is odd.
/// 3.shifted(rightBy: 1, rounding: .toOdd)
///
/// // 7/4 = 1.75, so the result is 1 with probability 1/4, or 2
/// // with probability 3/4.
/// 7.shifted(rightBy: 2, rounding: .stochastically)
///
/// // 4/4 is exactly 1, so this does not trap.
/// 4.shifted(rightBy: 2, rounding: .requireExact)
///
/// // 5/2 is 2.5, which is not an integer, so this traps.
/// 5.shifted(rightBy: 1, rounding: .requireExact)
///
/// When `Self(1) << count` is positive, the following are equivalent:
///
/// a.shifted(rightBy: count, rounding: rule)
/// a.divided(by: 1 << count, rounding: rule)
@_transparent
public func shifted<Count: BinaryInteger>(
rightBy count: Count,
rounding rule: RoundingRule = .down
) -> Self {
self.shifted(rightBy: Int(clamping: count), rounding: rule)
}
}
-2
View File
@@ -19,9 +19,7 @@ target_compile_options(Numerics PUBLIC
# load symbol when validating the TBD
-Xfrontend -validate-tbd-against-ir=none)
target_link_libraries(Numerics PUBLIC
BigIntModule
ComplexModule
IntegerUtilities
RealModule)
+1 -3
View File
@@ -10,7 +10,5 @@
//===----------------------------------------------------------------------===//
// A module that re-exports the complete Swift Numerics public API.
@_exported import BigIntModule
@_exported import ComplexModule
@_exported import IntegerUtilities
@_exported import RealModule
@_exported import ComplexModule
+17 -38
View File
@@ -16,7 +16,7 @@
/// division are defined, and behave basically like those operations on
/// the real numbers. More precisely, a field is a commutative group under
/// its addition, the non-zero elements of the field form a commutative
/// group under its multiplication, and the distributive law holds.
/// group under its multiplication, and the distributitve law holds.
///
/// Some common examples of fields include:
///
@@ -37,7 +37,12 @@
/// If a type `T` conforms to the `Real` protocol, then `T` and `Complex<T>`
/// both conform to `AlgebraicField`.
///
/// See also `Real`, `SignedNumeric`, `Numeric` and `AdditiveArithmetic`.
/// See Also:
/// -
/// - Real
/// - SignedNumeric
/// - Numeric
/// - AdditiveArithmetic
///
/// [field]: https://en.wikipedia.org/wiki/Field_(mathematics)
public protocol AlgebraicField: SignedNumeric {
@@ -51,11 +56,6 @@ public protocol AlgebraicField: SignedNumeric {
/// The (approximate) reciprocal (multiplicative inverse) of this number,
/// if it is representable.
///
/// If reciprocal is non-nil, you can replace division by self with
/// multiplication by reciprocal and either get exact the same result
/// (for finite fields) or approximately the same result up to a typical
/// rounding error (for floating-point formats).
///
/// If self is zero and the type has no representation for infinity (as
/// in a typical finite field implementation), or if a reciprocal would
/// overflow or underflow such that it cannot be accurately represented,
@@ -65,17 +65,17 @@ public protocol AlgebraicField: SignedNumeric {
/// for `Real` or `Complex` types, because these types have an
/// `.infinity` value that acts as the reciprocal of `.zero`.
///
/// If `b.reciprocal` is non-nil, you may be able to replace division by `b`
/// If `x.reciprocal` is non-nil, you may be able to replace division by `x`
/// with multiplication by this value. It is not advantageous to do this
/// for an isolated division unless it is a compile-time constant visible
/// to the compiler, but if you are dividing many values by a single
/// denominator, this will often be a significant performance win.
///
/// Note that this will slightly perturb results for fields with approximate
/// arithmetic, such as real or complex types--using a normal division
/// Note that this will slightly perturb results for some fields with
/// approximate arithmetic, such as real types--using a normal division
/// is generally more accurate--but no catastrophic loss of accuracy will
/// result. For fields with exact arithmetic, the results are necessarily
/// identical.
/// result. For fields with exact arithmetic, or for the Complex types,
/// the results are identical.
///
/// A typical use case looks something like this:
/// ```
@@ -89,12 +89,6 @@ public protocol AlgebraicField: SignedNumeric {
/// }
/// ```
var reciprocal: Self? { get }
/// a + b, with the optimizer licensed to reassociate and form FMAs.
static func _relaxedAdd(_ a: Self, _ b: Self) -> Self
/// a * b, with the optimizer licensed to reassociate and form FMAs.
static func _relaxedMul(_ a: Self, _ b: Self) -> Self
}
extension AlgebraicField {
@@ -105,27 +99,12 @@ extension AlgebraicField {
return result
}
// Implementations should be *conservative* with the reciprocal property;
// it is OK to return `nil` even in cases where a reciprocal could be
// represented. For this reason, a default implementation that simply
// always returns `nil` is correct, but conforming types should provide
// a better implementation if possible.
@_transparent
/// Implementations should be *conservative* with the reciprocal property;
/// it is OK to return `nil` even in cases where a reciprocal could be
/// represented. For this reason, a default implementation that simply
/// always returns `nil` is correct, but conforming types should provide
/// a better implementation if possible.
public var reciprocal: Self? {
return nil
}
// It's always OK to simply fall back on normal arithmetic, and for any
// field with exact arithmetic, this is the correct definition.
@_transparent
public static func _relaxedAdd(_ a: Self, _ b: Self) -> Self {
a + b
}
// It's always OK to simply fall back on normal arithmetic, and for any
// field with exact arithmetic, this is the correct definition.
@_transparent
public static func _relaxedMul(_ a: Self, _ b: Self) -> Self {
a * b
}
}
+14 -5
View File
@@ -28,7 +28,8 @@ extension Numeric where Magnitude: FloatingPoint {
/// is not suitable for all use cases.
///
/// Mathematical Properties:
///
/// ------------------------
///
/// - `isApproximatelyEqual(to:relativeTolerance:norm:)` is _reflexive_ for
/// non-exceptional values (such as NaN).
///
@@ -50,7 +51,9 @@ extension Numeric where Magnitude: FloatingPoint {
/// so long as no underflow or overflow has occured, and no exceptional
/// value is produced by the scaling.
///
/// See also `isApproximatelyEqual(to:absoluteTolerance:[relativeTolerance:norm:])`.
/// See Also:
/// -------
/// - `isApproximatelyEqual(to:absoluteTolerance:[relativeTolerance:norm:])`
///
/// - Parameters:
///
@@ -95,6 +98,7 @@ extension Numeric where Magnitude: FloatingPoint {
/// where `scale` is `max(self.magnitude, other.magnitude)`.
///
/// Mathematical Properties:
/// ------------------------
///
/// - `isApproximatelyEqual(to:absoluteTolerance:relativeTolerance:)`
/// is _reflexive_ for non-exceptional values (such as NaN).
@@ -114,7 +118,9 @@ extension Numeric where Magnitude: FloatingPoint {
/// to `a` is _convex_. (Under the assumption that `norm` implements a
/// valid norm, which cannot be checked by this function.)
///
/// See also `isApproximatelyEqual(to:[relativeTolerance:])`.
/// See Also:
/// -------
/// - `isApproximatelyEqual(to:[relativeTolerance:])`
///
/// - Parameters:
///
@@ -164,6 +170,7 @@ extension AdditiveArithmetic {
/// where `scale` is `max(norm(self), norm(other))`.
///
/// Mathematical Properties:
/// ------------------------
///
/// - `isApproximatelyEqual(to:absoluteTolerance:relativeTolerance:norm:)`
/// is _reflexive_ for non-exceptional values (such as NaN).
@@ -184,8 +191,10 @@ extension AdditiveArithmetic {
/// to `a` is _convex_ (under the assumption that `norm` implements a
/// valid norm, which cannot be checked by this function or a protocol).
///
/// See also `isApproximatelyEqual(to:[relativeTolerance:norm:])` and
/// `isApproximatelyEqual(to:absoluteTolerance:[relativeTolerance:])`.
/// See Also:
/// -------
/// - `isApproximatelyEqual(to:[relativeTolerance:norm:])`
/// - `isApproximatelyEqual(to:absoluteTolerance:[relativeTolerance:])`
///
/// - Parameters:
///
+18 -54
View File
@@ -2,7 +2,7 @@
//
// This source file is part of the Swift Numerics open source project
//
// Copyright (c) 2020-2021 Apple Inc. and the Swift Numerics project authors
// 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
@@ -28,7 +28,7 @@ extension Augmented {
/// This operation is sometimes called "twoProd" or "twoProduct".
///
/// Edge Cases:
///
/// -
/// - `head` is always the IEEE 754 product `a * b`.
/// - If `head` is not finite, `tail` is unspecified and should not be
/// interpreted as having any meaning (it may be `NaN` or `infinity`).
@@ -39,7 +39,7 @@ extension Augmented {
/// - If `head` is zero, `tail` is also a zero with unspecified sign.
///
/// Postconditions:
///
/// -
/// - If `head` is normal, then `abs(tail) < head.ulp`.
/// Assuming IEEE 754 default rounding, `abs(tail) <= head.ulp/2`.
/// - If both `head` and `tail` are normal, then `a * b` is exactly
@@ -61,32 +61,31 @@ extension Augmented {
/// value.
///
/// Unlike `Augmented.product(a, b)`, the rounding error of a sum can
/// never underflow.
/// never underflow. However, it may not be exactly representable when
/// `a` and `b` differ widely in magnitude.
///
/// This operation is sometimes called ["fastTwoSum"].
/// This operation is sometimes called "fastTwoSum".
///
/// - Parameters:
/// - a: The summand with larger magnitude.
/// - b: The summand with smaller magnitude.
///
/// Preconditions:
///
/// -
/// - `large.magnitude` must not be smaller than `small.magnitude`.
/// They may be equal, or one or both may be `NaN`.
/// This precondition is only enforced in debug builds.
///
/// Edge Cases:
///
/// -
/// - `head` is always the IEEE 754 sum `a + b`.
/// - If `head` is not finite, `tail` is unspecified and should not be
/// interpreted as having any meaning (it may be `NaN` or `infinity`).
///
/// Postconditions:
///
/// -
/// - If `head` is normal, then `abs(tail) < head.ulp`.
/// Assuming IEEE 754 default rounding, `abs(tail) <= head.ulp/2`.
///
/// ["fastTwoSum"]: https://en.wikipedia.org/wiki/2Sum
@_transparent
public static func sum<T:Real>(large a: T, small b: T) -> (head: T, tail: T) {
assert(!(b.magnitude > a.magnitude))
@@ -94,49 +93,14 @@ extension Augmented {
let tail = a - head + b
return (head, tail)
}
/// The sum `a + b` represented as an implicit sum `head + tail`.
///
/// `head` is the correctly rounded value of `a + b`. `tail` is the
/// error from that computation rounded to the closest representable
/// value.
///
/// Unlike `Augmented.sum(large: a, small: b)`, the magnitude of the summands
/// does not matter and `a.magnitude` might as well be strictly less than
/// `b.magnitude`. However, it is recommended to only use this function over
/// `Augmented.sum(large: a, small: b)` in cases where the ordering of the
/// summands magnitude is unknown at compile time. In cases where either of
/// the summands magnitude is guaranteed to be greater than or equal the
/// magnitude of the other summand, use `Augmented.sum(large: a, small: b)`
/// over this function; as it faster to calculate.
///
/// Unlike `Augmented.product(a, b)`, the rounding error of a sum can
/// never underflow.
///
/// This operation is sometimes called ["twoSum"].
///
/// - Parameters:
/// - a: One of the summand
/// - b: The other summand
///
/// Edge Cases:
///
/// - `head` is always the IEEE 754 sum `a + b`.
/// - If `head` is not finite, `tail` is unspecified and should not be
/// interpreted as having any meaning (it may be `NaN` or `infinity`).
///
/// Postconditions:
///
/// - If `head` is normal, then `abs(tail) < head.ulp`.
/// Assuming IEEE 754 default rounding, `abs(tail) <= head.ulp/2`.
///
/// ["twoSum"]: https://en.wikipedia.org/wiki/2Sum
@_transparent
public static func sum<T: Real>(_ a: T, _ b: T) -> (head: T, tail: T) {
let head = a + b
let x = head - b
let y = head - x
let tail = (a - x) + (b - y)
return (head, tail)
@available(*, deprecated, renamed: "product")
public static func twoProdFMA<T:Real>(_ a: T, _ b: T) -> (head: T, tail: T) {
product(a, b)
}
@available(*, deprecated, renamed: "sum(large:small:)")
public static func fastTwoSum<T:Real>(_ a: T, _ b: T) -> (head: T, tail: T) {
sum(large: a, small: b)
}
}
+1 -2
View File
@@ -17,8 +17,7 @@ add_library(RealModule
Float16+Real.swift
Float80+Real.swift
Real.swift
RealFunctions.swift
RelaxedArithmetic.swift)
RealFunctions.swift)
set_target_properties(RealModule PROPERTIES
INTERFACE_INCLUDE_DIRECTORIES ${CMAKE_Swift_MODULE_DIRECTORY})
target_link_libraries(RealModule PUBLIC
+9 -14
View File
@@ -107,14 +107,14 @@ extension Double: Real {
libm_exp2(x)
}
#if os(macOS) || os(iOS) || os(tvOS) || os(watchOS)
#if os(macOS) || os(iOS) || os(tvOS) || os(watchOS)
@_transparent
public static func exp10(_ x: Double) -> Double {
libm_exp10(x)
}
#endif
#endif
#if os(macOS) && arch(x86_64)
#if os(macOS) && arch(x86_64)
// Workaround for macOS bug (<rdar://problem/56844150>) where hypot can
// overflow for values very close to the overflow boundary of the naive
// algorithm. Since this is only for macOS, we can just unconditionally
@@ -125,12 +125,12 @@ extension Double: Real {
let y80 = Float80(y)
return Double(Float80.sqrt(x80*x80 + y80*y80))
}
#else
#else
@_transparent
public static func hypot(_ x: Double, _ y: Double) -> Double {
libm_hypot(x, y)
}
#endif
#endif
@_transparent
public static func gamma(_ x: Double) -> Double {
@@ -212,21 +212,16 @@ extension Double: Real {
libm_atan2(y, x)
}
#if !os(Windows)
#if !os(Windows)
@_transparent
public static func logGamma(_ x: Double) -> Double {
var dontCare: Int32 = 0
return libm_lgamma(x, &dontCare)
}
#endif
#endif
@_transparent
public static func _relaxedAdd(_ a: Double, _ b: Double) -> Double {
_numerics_relaxed_add(a, b)
}
@_transparent
public static func _relaxedMul(_ a: Double, _ b: Double) -> Double {
_numerics_relaxed_mul(a, b)
public static func _mulAdd(_ a: Double, _ b: Double, _ c: Double) -> Double {
_numerics_muladd(a, b, c)
}
}
+97 -26
View File
@@ -47,7 +47,7 @@
/// protocol that you will want to use most often for generic code.
///
/// See Also:
///
/// -
/// - `RealFunctions`
/// - `Real`
///
@@ -56,8 +56,11 @@ public protocol ElementaryFunctions: AdditiveArithmetic {
/// The [exponential function][wiki] e^x whose base `e` is the base of the
/// natural logarithm.
///
/// See also `expMinusOne()`, as well as `exp2()` and `exp10()`
/// defined for types conforming to `RealFunctions`.
/// See also:
/// -
/// - `expMinusOne()`
/// - `exp2()` (for types conforming to `RealFunctions`)
/// - `exp10()` (for types conforming to `RealFunctions`)
///
/// [wiki]: https://en.wikipedia.org/wiki/Exponential_function
static func exp(_ x: Self) -> Self
@@ -79,8 +82,11 @@ public protocol ElementaryFunctions: AdditiveArithmetic {
/// This re-written expression delivers an accurate result for all values
/// of `x`, not just for small values.
///
/// See also `exp()`, as well as `exp2()` and `exp10()` defined for types
/// conforming to `RealFunctions`.
/// See also:
/// -
/// - `exp()`
/// - `exp2()` (for types conforming to `RealFunctions`)
/// - `exp10()` (for types conforming to `RealFunctions`)
static func expMinusOne(_ x: Self) -> Self
/// The [hyperbolic cosine][wiki] of `x`.
@@ -90,7 +96,11 @@ public protocol ElementaryFunctions: AdditiveArithmetic {
/// 2
/// ```
///
/// See also `sinh()`, `tanh()` and `acosh()`.
/// See also:
/// -
/// - `sinh()`
/// - `tanh()`
/// - `acosh()`
///
/// [wiki]: https://en.wikipedia.org/wiki/Hyperbolic_function
static func cosh(_ x: Self) -> Self
@@ -102,7 +112,11 @@ public protocol ElementaryFunctions: AdditiveArithmetic {
/// 2
/// ```
///
/// See also `cosh()`, `tanh()` and `asinh()`.
/// See also:
/// -
/// - `cosh()`
/// - `tanh()`
/// - `asinh()`
///
/// [wiki]: https://en.wikipedia.org/wiki/Hyperbolic_function
static func sinh(_ x: Self) -> Self
@@ -114,7 +128,11 @@ public protocol ElementaryFunctions: AdditiveArithmetic {
/// cosh(x)
/// ```
///
/// See also `cosh()`, `sinh()` and `atanh()`.
/// See also:
/// -
/// - `cosh()`
/// - `sinhh()`
/// - `atanh()`
///
/// [wiki]: https://en.wikipedia.org/wiki/Hyperbolic_function
static func tanh(_ x: Self) -> Self
@@ -123,7 +141,11 @@ public protocol ElementaryFunctions: AdditiveArithmetic {
///
/// For real types, `x` may be interpreted as an angle measured in radians.
///
/// See also `sin()`, `tan()` and `acos()`.
/// See also:
/// -
/// - `sin()`
/// - `tan()`
/// - `acos()`
///
/// [wiki]: https://en.wikipedia.org/wiki/Cosine
static func cos(_ x: Self) -> Self
@@ -133,7 +155,11 @@ public protocol ElementaryFunctions: AdditiveArithmetic {
///
/// For real types, `x` may be interpreted as an angle measured in radians.
///
/// See also `cos()`, `tan()` and `asin()`.
/// See also:
/// -
/// - `cos()`
/// - `tan()`
/// - `asin()`
///
/// [wiki]: https://en.wikipedia.org/wiki/Sine
static func sin(_ x: Self) -> Self
@@ -142,31 +168,49 @@ public protocol ElementaryFunctions: AdditiveArithmetic {
///
/// For real types, `x` may be interpreted as an angle measured in radians.
///
/// See also `cos()`, `sin()` and `atan()`, as well as `atan2(y:x:)` for
/// types that conform to `RealFunctions`.
///
/// See also:
/// -
/// - `cos()`
/// - `sin()`
/// - `atan()`
/// - `atan2(y:x:)` (for types conforming to `RealFunctions`)
/// ```
/// sin(x)
/// tan(x) = --------
/// cos(x)
/// ```
/// [wiki]: https://en.wikipedia.org/wiki/Tangent
static func tan(_ x: Self) -> Self
/// The [natural logarithm][wiki] of `x`.
///
/// See also `log(onePlus:)`, as well as `log2()` and `log10()` for types
/// that conform to `RealFunctions`.
/// See also:
/// -
/// - `log(onePlus:)`
/// - `log2()` (for types conforming to `RealFunctions`)
/// - `log10()` (for types conforming to `RealFunctions`)
///
/// [wiki]: https://en.wikipedia.org/wiki/Logarithm
static func log(_ x: Self) -> Self
/// log(1 + x), computed in such a way as to maintain accuracy for small x.
///
/// See also `log()`, as well as `log2()` and `log10()` for types
/// that conform to `RealFunctions`.
/// See also:
/// -
/// - `log()`
/// - `log2()` (for types conforming to `RealFunctions`)
/// - `log10()` (for types conforming to `RealFunctions`)
static func log(onePlus x: Self) -> Self
/// The [inverse hyperbolic cosine][wiki] of `x`.
/// ```
/// cosh(acosh(x)) ≅ x
/// ```
/// See also `asinh()`, `atanh()` and `cosh()`.
/// See also:
/// -
/// - `asinh()`
/// - `atanh()`
/// - `cosh()`
///
/// [wiki]: https://en.wikipedia.org/wiki/Inverse_hyperbolic_function
static func acosh(_ x: Self) -> Self
@@ -175,7 +219,11 @@ public protocol ElementaryFunctions: AdditiveArithmetic {
/// ```
/// sinh(asinh(x)) ≅ x
/// ```
/// See also `acosh()`, `atanh()` and `sinh()`.
/// See also:
/// -
/// - `acosh()`
/// - `atanh()`
/// - `sinh()`
///
/// [wiki]: https://en.wikipedia.org/wiki/Inverse_hyperbolic_function
static func asinh(_ x: Self) -> Self
@@ -184,7 +232,11 @@ public protocol ElementaryFunctions: AdditiveArithmetic {
/// ```
/// tanh(atanh(x)) ≅ x
/// ```
/// See also `acosh()`, `asinh()` and `tanh()`.
/// See also:
/// -
/// - `acosh()`
/// - `asinh()`
/// - `tanh()`
///
/// [wiki]: https://en.wikipedia.org/wiki/Inverse_hyperbolic_function
static func atanh(_ x: Self) -> Self
@@ -196,7 +248,11 @@ public protocol ElementaryFunctions: AdditiveArithmetic {
/// ```
/// cos(acos(x)) ≅ x
/// ```
/// See also `asin()`, `atan()` and `cos()`.
/// See also:
/// -
/// - `asin()`
/// - `atan()`
/// - `cos()`
///
/// [wiki]: https://en.wikipedia.org/wiki/Inverse_trigonometric_functions
static func acos(_ x: Self) -> Self
@@ -208,7 +264,11 @@ public protocol ElementaryFunctions: AdditiveArithmetic {
/// ```
/// sin(asin(x)) ≅ x
/// ```
/// See also `acos()`, `atan()` and `sin()`.
/// See also:
/// -
/// - `acos()`
/// - `atan()`
/// - `sin()`
///
/// [wiki]: https://en.wikipedia.org/wiki/Inverse_trigonometric_functions
static func asin(_ x: Self) -> Self
@@ -220,8 +280,12 @@ public protocol ElementaryFunctions: AdditiveArithmetic {
/// ```
/// tan(atan(x)) ≅ x
/// ```
/// See also `acos()`, `asin()` and `tan()`, as well as `atan2(y:x:)` for
/// types that conform to `RealArithmetic`.
/// See also:
/// -
/// - `acos()`
/// - `asin()`
/// - `atan2()` (for types conforming to `RealFunctions`)
/// - `tan()`
///
/// [wiki]: https://en.wikipedia.org/wiki/Inverse_trigonometric_functions
static func atan(_ x: Self) -> Self
@@ -250,13 +314,20 @@ public protocol ElementaryFunctions: AdditiveArithmetic {
/// The [square root][wiki] of `x`.
///
/// See also `pow()` and `root()`.
/// See also:
/// -
/// - `pow()`
/// - `root()`
///
/// [wiki]: https://en.wikipedia.org/wiki/Square_root
static func sqrt(_ x: Self) -> Self
/// The nth root of `x`.
///
/// See also `pow()` and `sqrt()`.
/// See also:
/// -
/// - `pow()`
/// - `sqrt()`
///
static func root(_ x: Self, _ n: Int) -> Self
}
+2 -7
View File
@@ -194,12 +194,7 @@ extension Float: Real {
#endif
@_transparent
public static func _relaxedAdd(_ a: Float, _ b: Float) -> Float {
_numerics_relaxed_addf(a, b)
}
@_transparent
public static func _relaxedMul(_ a: Float, _ b: Float) -> Float {
_numerics_relaxed_mulf(a, b)
public static func _mulAdd(_ a: Float, _ b: Float, _ c: Float) -> Float {
_numerics_muladdf(a, b, c)
}
}
+162 -10
View File
@@ -11,8 +11,9 @@
import _NumericsShims
// Float16 is only available on macOS when targeting arm64.
#if !((os(macOS) || targetEnvironment(macCatalyst)) && arch(x86_64))
// When building with a Swift 5.4 or later toolchain, Float16 is available on
// non-x86 macOS from 11.0 onward.
#if swift(>=5.4) && !((os(macOS) || targetEnvironment(macCatalyst)) && arch(x86_64))
@available(macOS 11.0, iOS 14.0, tvOS 14.0, watchOS 7.0, *)
extension Float16: Real {
@@ -172,18 +173,169 @@ extension Float16: Real {
Float16(.logGamma(Float(x)))
}
#endif
// TODO: once clang stabilizes the calling conventions for _Float16 on Intel,
// we can re-enable these; presently the type is disabled on the target.
#if !(arch(i386) || arch(x86_64))
}
// When building with older Swift toolchains for macOS, Float16 is not
// available. We will drop support for these older toolchains at some
// future point and remove this duplication.
#elseif swift(>=5.3) && !(os(macOS) || targetEnvironment(macCatalyst))
@available(iOS 14.0, tvOS 14.0, watchOS 7.0, *)
extension Float16: Real {
@_transparent
public static func _relaxedAdd(_ a: Float16, _ b: Float16) -> Float16 {
_numerics_relaxed_addf16(a, b)
public static func cos(_ x: Float16) -> Float16 {
Float16(.cos(Float(x)))
}
@_transparent
public static func _relaxedMul(_ a: Float16, _ b: Float16) -> Float16 {
_numerics_relaxed_mulf16(a, b)
public static func sin(_ x: Float16) -> Float16 {
Float16(.sin(Float(x)))
}
@_transparent
public static func tan(_ x: Float16) -> Float16 {
Float16(.tan(Float(x)))
}
@_transparent
public static func acos(_ x: Float16) -> Float16 {
Float16(.acos(Float(x)))
}
@_transparent
public static func asin(_ x: Float16) -> Float16 {
Float16(.asin(Float(x)))
}
@_transparent
public static func atan(_ x: Float16) -> Float16 {
Float16(.atan(Float(x)))
}
@_transparent
public static func cosh(_ x: Float16) -> Float16 {
Float16(.cosh(Float(x)))
}
@_transparent
public static func sinh(_ x: Float16) -> Float16 {
Float16(.sinh(Float(x)))
}
@_transparent
public static func tanh(_ x: Float16) -> Float16 {
Float16(.tanh(Float(x)))
}
@_transparent
public static func acosh(_ x: Float16) -> Float16 {
Float16(.acosh(Float(x)))
}
@_transparent
public static func asinh(_ x: Float16) -> Float16 {
Float16(.asinh(Float(x)))
}
@_transparent
public static func atanh(_ x: Float16) -> Float16 {
Float16(.atanh(Float(x)))
}
@_transparent
public static func exp(_ x: Float16) -> Float16 {
Float16(.exp(Float(x)))
}
@_transparent
public static func expMinusOne(_ x: Float16) -> Float16 {
Float16(.expMinusOne(Float(x)))
}
@_transparent
public static func log(_ x: Float16) -> Float16 {
Float16(.log(Float(x)))
}
@_transparent
public static func log(onePlus x: Float16) -> Float16 {
Float16(.log(onePlus: Float(x)))
}
@_transparent
public static func erf(_ x: Float16) -> Float16 {
Float16(.erf(Float(x)))
}
@_transparent
public static func erfc(_ x: Float16) -> Float16 {
Float16(.erfc(Float(x)))
}
@_transparent
public static func exp2(_ x: Float16) -> Float16 {
Float16(.exp2(Float(x)))
}
@_transparent
public static func exp10(_ x: Float16) -> Float16 {
Float16(.exp10(Float(x)))
}
@_transparent
public static func hypot(_ x: Float16, _ y: Float16) -> Float16 {
if x.isInfinite || y.isInfinite { return .infinity }
let xf = Float(x)
let yf = Float(y)
return Float16(.sqrt(xf*xf + yf*yf))
}
@_transparent
public static func gamma(_ x: Float16) -> Float16 {
Float16(.gamma(Float(x)))
}
@_transparent
public static func log2(_ x: Float16) -> Float16 {
Float16(.log2(Float(x)))
}
@_transparent
public static func log10(_ x: Float16) -> Float16 {
Float16(.log10(Float(x)))
}
@_transparent
public static func pow(_ x: Float16, _ y: Float16) -> Float16 {
Float16(.pow(Float(x), Float(y)))
}
@_transparent
public static func pow(_ x: Float16, _ n: Int) -> Float16 {
// Float16 is simpler than Float or Double, because the range of
// "interesting" exponents is pretty small; anything outside of
// -22707 ... 34061 simply overflows or underflows for every
// x that isn't zero or one. This whole range is representable
// as Float, so we can just use powf as long as we're a little
// bit (get it?) careful to preserve parity.
let clamped = min(max(n, -0x10000), 0x10000) | (n & 1)
return Float16(libm_powf(Float(x), Float(clamped)))
}
@_transparent
public static func root(_ x: Float16, _ n: Int) -> Float16 {
Float16(.root(Float(x), n))
}
@_transparent
public static func atan2(y: Float16, x: Float16) -> Float16 {
Float16(.atan2(y: Float(y), x: Float(x)))
}
#if !os(Windows)
@_transparent
public static func logGamma(_ x: Float16) -> Float16 {
Float16(.logGamma(Float(x)))
}
#endif
}
-10
View File
@@ -165,15 +165,5 @@ extension Float80: Real {
var dontCare: Int32 = 0
return libm_lgammal(x, &dontCare)
}
@_transparent
public static func _relaxedAdd(_ a: Float80, _ b: Float80) -> Float80 {
_numerics_relaxed_addl(a, b)
}
@_transparent
public static func _relaxedMul(_ a: Float80, _ b: Float80) -> Float80 {
_numerics_relaxed_mull(a, b)
}
}
#endif
+14 -6
View File
@@ -23,7 +23,11 @@
/// return 1/(1 + .exp(-x))
/// }
/// ```
/// See also `ElementaryFunctions`, `RealFunctions` and `AlgebraicField`.
/// See Also:
/// -
/// - `ElementaryFunctions`
/// - `RealFunctions`
/// - `AlgebraicField`
public protocol Real: FloatingPoint, RealFunctions, AlgebraicField {
}
@@ -40,7 +44,9 @@ extension Real {
/// cos(x) - 1, computed in such a way as to maintain accuracy for small x.
///
/// See also `ElementaryFunctions.expMinusOne()`.
/// See also:
/// -
/// - `ElementaryFunctions.expMinusOne()`
@_transparent
public static func cosMinusOne(_ x: Self) -> Self {
let sinxOver2 = sin(x/2)
@@ -96,10 +102,10 @@ extension Real {
/// The (approximate) reciprocal (multiplicative inverse) of this number,
/// if it is representable.
///
/// If `a` if finite and nonzero, and `1/a` overflows or underflows,
/// then `a.reciprocal` is `nil`. Otherwise, `a.reciprocal` is `1/a`.
/// If `x` if finite and nonzero, and `1/x` overflows or underflows,
/// then `x.reciprocal` is `nil`. Otherwise, `a.reciprocal` is `1/x`.
///
/// If `b.reciprocal` is non-nil, you may be able to replace division by `b`
/// If `x.reciprocal` is non-nil, you may be able to replace division by `x`
/// with multiplication by this value. It is not advantageous to do this
/// for an isolated division unless it is a compile-time constant visible
/// to the compiler, but if you are dividing many values by a single
@@ -129,12 +135,14 @@ extension Real {
/// operators to denote real-number arithmetic, and normal operators
/// for floating-point arithmetic):
///
/// ```
/// a * b.reciprocal! = a * (1/b)
/// = a * (1 ⊘ b)(1 + δ₁)
/// = (a ⊘ b)(1 + δ₁)(1 + δ₂)
/// = (a ⊘ b)(1 + δ₁ + δ₂ + δ₁δ₂)
/// ```
///
/// where 0 < δᵢ <= ulpOfOne/2. This gives a roughly 1-ulp error,
/// where `0 < δᵢ <= ulpOfOne/2`. This gives a roughly 1-ulp error,
/// about twice the error bound we get using division. For most
/// purposes this is an acceptable error, but if you need to match
/// results obtained using division, you should not use this.
+52 -10
View File
@@ -12,27 +12,45 @@
public protocol RealFunctions: ElementaryFunctions {
/// `atan(y/x)`, with sign selected according to the quadrant of `(x, y)`.
///
/// See also `atan()`.
/// See also:
/// -
/// - `atan()`
static func atan2(y: Self, x: Self) -> Self
/// The error function evaluated at `x`.
///
/// See also `erfc()`.
/// See also:
/// -
/// - `erfc()`
static func erf(_ x: Self) -> Self
/// The complimentary error function evaluated at `x`.
///
/// See also `erf()`.
/// See also:
/// -
/// - `erf()`
static func erfc(_ x: Self) -> Self
/// 2^x
///
/// See also `exp()`, `expMinusOne()`, `exp10()`, `log2()` and `pow()`.
/// See also:
/// -
/// - `exp()`
/// - `expMinusOne()`
/// - `exp10()`
/// - `log2()`
/// - `pow()`
static func exp2(_ x: Self) -> Self
/// 10^x
///
/// See also `exp()`, `expMinusOne()`, `exp2()`, `log10()` and `pow()`.
/// See also:
/// -
/// - `exp()`
/// - `expMinusOne()`
/// - `exp2()`
/// - `log10()`
/// - `pow()`
static func exp10(_ x: Self) -> Self
/// `sqrt(x*x + y*y)`, computed in a manner that avoids spurious overflow or
@@ -41,17 +59,30 @@ public protocol RealFunctions: ElementaryFunctions {
/// The gamma function Γ(x).
///
/// See also `logGamma()` and `signGamma()`.
/// See also:
/// -
/// - `logGamma()`
/// - `signGamma()`
static func gamma(_ x: Self) -> Self
/// The base-2 logarithm of `x`.
///
/// See also `exp2()`, `log()`, `log(onePlus:)` and `log10()`.
/// See also:
/// -
/// - `exp2()`
/// - `log()`
/// - `log(onePlus:)`
/// - `log10()`
static func log2(_ x: Self) -> Self
/// The base-10 logarithm of `x`.
///
/// See also: `exp10()`, `log()`, `log(onePlus:)` and `log2()`.
/// See also:
/// -
/// - `exp10()`
/// - `log()`
/// - `log(onePlus:)`
/// - `log2()`
static func log10(_ x: Self) -> Self
#if !os(Windows)
@@ -59,7 +90,10 @@ public protocol RealFunctions: ElementaryFunctions {
///
/// Not available on Windows targets.
///
/// See also `gamma()` and `signGamma()`.
/// See also:
/// -
/// - `gamma()`
/// - `signGamma()`
static func logGamma(_ x: Self) -> Self
/// The sign of the gamma function, Γ(x).
@@ -73,7 +107,15 @@ public protocol RealFunctions: ElementaryFunctions {
///
/// Not available on Windows targets.
///
/// See also `gamma()` and `logGamma()`.
/// See also:
/// -
/// - `gamma()`
/// - `logGamma()`
static func signGamma(_ x: Self) -> FloatingPointSign
#endif
/// a*b + c, computed _either_ with an FMA or with separate multiply and add.
///
/// Whichever is faster should be chosen by the compiler statically.
static func _mulAdd(_ a: Self, _ b: Self, _ c: Self) -> Self
}
@@ -1,82 +0,0 @@
//===--- RelaxedArithmetic.swift ------------------------------*- swift -*-===//
//
// This source file is part of the Swift Numerics open source project
//
// Copyright (c) 2021 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 _NumericsShims
/// A namespace for "relaxed arithmetic" operations for types conforming to
/// `AlgebraicField`.
public enum Relaxed { }
extension Relaxed {
/// a+b with the optimizer licensed to reassociate expressions and form FMAs.
///
/// Floating-point addition is not an associative operation, so the Swift
/// compiler does not have any flexibility in how it evaluates an expression
/// like:
/// ```
/// func sum(array: [Float]) -> Float {
/// array.reduce(0, +)
/// }
/// ```
/// Using `Relaxed.sum` instead of `+` permits the compiler to reorder the
/// terms in the summation, which unlocks loop unrolling and vectorization.
/// In a benchmark, simply using `Relaxed.sum` provides about an 8x speedup
/// for release builds, without any unsafe flags or other optimizations.
/// Further improvement should be possible by improving LLVM optimizations
/// or adding attributes to license more aggressive unrolling and taking
/// advantage of vector ISA extensions for swift.
///
/// If you want to compute `a-b` with relaxed semantics, use
/// `Relaxed.sum(a, -b)`.
///
/// If a type or toolchain does not support reassociation for optimization
/// purposes, this operation decays to a normal addition; it is a license
/// for the compiler to optimize, not a guarantee that any change occurs.
@_transparent
public static func sum<T: AlgebraicField>(_ a: T, _ b: T) -> T {
T._relaxedAdd(a, b)
}
/// a*b with the optimizer licensed to reassociate expressions and form FMAs.
///
/// Floating-point addition and multiplication are not associative operations,
/// so the Swift compiler does not have any flexibility in how it evaluates
/// an expression like:
/// ```
/// func sumOfSquares(array: [Float]) -> Float {
/// array.reduce(0) { $0 + $1*$1 }
/// }
/// ```
/// Using `Relaxed.sum` and `Relaxed.product` instead of `+` and `*` permits
/// the compiler to reorder the terms in the summation, which unlocks loop
/// unrolling and vectorization, and form fused multiply-adds, which allows
/// us to achieve twice the throughput on some hardware.
///
/// If a type or toolchain does not support reassociation for optimization
/// purposes, this operation decays to a normal multiplication; it is a
/// license for the compiler to optimize, not a guarantee that any change
/// occurs.
@_transparent
public static func product<T: AlgebraicField>(_ a: T, _ b: T) -> T {
T._relaxedMul(a, b)
}
}
extension Relaxed {
/// a*b + c, computed _either_ with an FMA or with separate multiply and add,
/// whichever is fastest according to the optimizer's heuristics.
@_transparent
public static func multiplyAdd<T: AlgebraicField>(
_ a: T, _ b: T, _ c: T
) -> T {
T._relaxedAdd(c, T._relaxedMul(a, b))
}
}
+11 -64
View File
@@ -382,71 +382,18 @@ HEADER_SHIM long double libm_lgammal(long double x, int *signp) {
}
#endif
// MARK: - math inlines with relaxed semantics to support optimization.
#define CLANG_RELAX_FP _Pragma("clang fp reassociate(on) contract(fast)")
#if !(__i386__ || __x86_64__)
/// a + b with the "allow reassociation" and "allow FMA formation" flags
/// set in the IR.
HEADER_SHIM _Float16 _numerics_relaxed_addf16(_Float16 a, _Float16 b) {
CLANG_RELAX_FP
return a + b;
// MARK: - fast mul-add inlines
/// a*b + c evaluated _either_ as two operations or fma, whichever is faster.
HEADER_SHIM float _numerics_muladdf(float a, float b, float c) {
#pragma STDC FP_CONTRACT ON
return a*b + c;
}
/// a * b with the "allow reassociation" and "allow FMA formation" flags
/// set in the IR.
HEADER_SHIM _Float16 _numerics_relaxed_mulf16(_Float16 a, _Float16 b) {
CLANG_RELAX_FP
return a * b;
}
#endif
/// a + b with the "allow reassociation" and "allow FMA formation" flags
/// set in the IR.
HEADER_SHIM float _numerics_relaxed_addf(float a, float b) {
CLANG_RELAX_FP
return a + b;
/// a*b + c evaluated _either_ as two operations or fma, whichever is faster.
HEADER_SHIM double _numerics_muladd(double a, double b, double c) {
#pragma STDC FP_CONTRACT ON
return a*b + c;
}
/// a * b with the "allow reassociation" and "allow FMA formation" flags
/// set in the IR.
HEADER_SHIM float _numerics_relaxed_mulf(float a, float b) {
CLANG_RELAX_FP
return a * b;
}
/// a + b with the "allow reassociation" and "allow FMA formation" flags
/// set in the IR.
HEADER_SHIM double _numerics_relaxed_add(double a, double b) {
CLANG_RELAX_FP
return a + b;
}
/// a * b with the "allow reassociation" and "allow FMA formation" flags
/// set in the IR.
HEADER_SHIM double _numerics_relaxed_mul(double a, double b) {
CLANG_RELAX_FP
return a * b;
}
#if !defined _WIN32 && (defined __i386__ || defined __x86_64__)
/// a + b with the "allow reassociation" and "allow FMA formation" flags
/// set in the IR.
HEADER_SHIM long double _numerics_relaxed_addl(long double a, long double b) {
CLANG_RELAX_FP
return a + b;
}
/// a * b with the "allow reassociation" and "allow FMA formation" flags
/// set in the IR.
HEADER_SHIM long double _numerics_relaxed_mull(long double a, long double b) {
CLANG_RELAX_FP
return a * b;
}
#endif
HEADER_SHIM void _numerics_optimization_barrier(const void *pointer) {
__asm("": :"r" (pointer));
}
#undef CLANG_RELAX_FP
// No long-double muladd operation, because no one has built an FMA for it
// (except for Itanium, which Swift doesn't support).
-19
View File
@@ -1,19 +0,0 @@
//===--- BlackHole.swift --------------------------------------*- swift -*-===//
//
// This source file is part of the Swift Numerics open source project
//
// Copyright (c) 2021 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 _NumericsShims
@_transparent
public func blackHole<T>(_ thing: T) {
withUnsafePointer(to: thing) {
_numerics_optimization_barrier($0)
}
}
+1 -3
View File
@@ -1,15 +1,13 @@
#[[
This source file is part of the Swift Numerics open source project
Copyright (c) 2019-2021 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
#]]
add_library(_TestSupport
BlackHole.swift
DoubleWidth.swift
Error.swift
Interval.swift
RealTestSupport.swift)
-756
View File
@@ -1,756 +0,0 @@
//===--- DoubleWidth.swift ------------------------------------*- swift -*-===//
//
// This source file is part of the Swift Numerics open source project
//
// Copyright (c) 2017-2021 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
//
//===----------------------------------------------------------------------===//
/// A fixed-width integer that has twice the bit width of its base type.
///
/// You can use the `DoubleWidth` type to continue calculations with the result
/// of a full width arithmetic operation. Normally, when you perform a full
/// width operation, the result is a tuple of the high and low parts of the
/// result.
///
/// let a = 2241543570477705381
/// let b = 186319822866995413
/// let c = a.multipliedFullWidth(by: b)
/// // c == (high: 22640526660490081, low: 7959093232766896457)
///
/// The tuple `c` can't be used in any further comparisons or calculations. To
/// use this value, create a `DoubleWidth` instance from the result. You can
/// use the `DoubleWidth` instance in the same way that you would use any other
/// integer type.
///
/// let d = DoubleWidth(a.multipliedFullWidth(by: b))
/// // d == 417644001000058515200174966092417353
///
/// // Check the calculation:
/// print(d / DoubleWidth(a) == b)
/// // Prints "true"
///
/// if d > Int.max {
/// print("Too big to be an 'Int'!")
/// } else {
/// print("Small enough to fit in an 'Int'")
/// }
/// // Prints "Too big to be an 'Int'!"
///
/// The `DoubleWidth` type is not intended as a replacement for a variable-width
/// integer type. Nesting `DoubleWidth` instances, in particular, may result in
/// undesirable performance.
public struct DoubleWidth<Base : FixedWidthInteger> {
public typealias High = Base
public typealias Low = Base.Magnitude
internal var _storage: (low: Low, high: High)
}
extension DoubleWidth {
/// The "high word" of this value.
///
/// Equivalent to `Base(self >> Base.bitWidth)`.
public var high: High {
return _storage.high
}
/// The "low word" of the value.
///
/// Equivalent to`Base.Magnitude(truncatingIfNecessary: self)`.
public var low: Low {
return _storage.low
}
/// Creates a new instance from the given tuple of high and low parts.
///
/// Equivalent to
/// ```
/// DoubleWidth<Base>(high) << Base.bitWidth + DoubleWidth<Base>(low)
/// ```
///
/// - Parameter value: The tuple to use as the source of the new instance's
/// high and low parts.
public init(_ value: (high: High, low: Low)) {
self._storage = (low: value.low, high: value.high)
}
// We expect users to invoke the public initializer above as demonstrated in
// the documentation (that is, by passing in the result of a full width
// operation).
//
// Internally, we'll need to create new instances by supplying high and low
// parts directly; ((double parentheses)) greatly impair readability,
// especially when nested:
//
// DoubleWidth<DoubleWidth>((DoubleWidth((0, 0)), DoubleWidth((0, 0))))
//
// For that reason, we'll include an internal initializer that takes two
// separate arguments.
/// Creates a new instance from the given tuple of high and low parts.
///
/// Equivalent to
/// ```
/// DoubleWidth<Base>(high) << Base.bitWidth + DoubleWidth<Base>(low)
/// ```
internal init(_ _high: High, _ low: Low) {
self.init((_high, low))
}
/// Zero.
public init() {
self.init(0, 0)
}
}
extension DoubleWidth : CustomStringConvertible {
public var description: String {
return String(self, radix: 10)
}
}
extension DoubleWidth : CustomDebugStringConvertible {
public var debugDescription: String {
return "(\(_storage.high), \(_storage.low))"
}
}
extension DoubleWidth : Equatable {
public static func ==(lhs: DoubleWidth, rhs: DoubleWidth) -> Bool {
return lhs._storage.low == rhs._storage.low
&& lhs._storage.high == rhs._storage.high
}
}
extension DoubleWidth : Comparable {
public static func <(lhs: DoubleWidth, rhs: DoubleWidth) -> Bool {
if lhs._storage.high < rhs._storage.high { return true }
else if lhs._storage.high > rhs._storage.high { return false }
else { return lhs._storage.low < rhs._storage.low }
}
}
extension DoubleWidth : Hashable {
public func hash(into hasher: inout Hasher) {
hasher.combine(low)
hasher.combine(high)
}
}
extension DoubleWidth : Numeric {
public typealias Magnitude = DoubleWidth<Low>
public var magnitude: Magnitude {
let result = Magnitude(Low(truncatingIfNeeded: _storage.high), _storage.low)
if Base.isSigned && _storage.high < (0 as High) {
return ~result &+ 1
} else {
return result
}
}
internal init(_ _magnitude: Magnitude) {
self.init(High(_magnitude._storage.high), _magnitude._storage.low)
}
public init<T : BinaryInteger>(_ source: T) {
guard let result = DoubleWidth<Base>(exactly: source) else {
preconditionFailure("Value is outside the representable range")
}
self = result
}
public init?<T : BinaryInteger>(exactly source: T) {
// Can't represent a negative 'source' if Base is unsigned.
guard DoubleWidth.isSigned || source >= 0 else { return nil }
// Is 'source' entirely representable in Low?
if let low = Low(exactly: source.magnitude) {
self.init(source < (0 as T) ? (~0, ~low &+ 1) : (0, low))
} else {
// At this point we know source.bitWidth > Base.bitWidth, or else we
// would've taken the first branch.
let lowInT = source & T(~0 as Low)
let highInT = source >> Low.bitWidth
let low = Low(lowInT)
guard let high = High(exactly: highInT) else { return nil }
self.init(high, low)
}
}
}
extension DoubleWidth {
public struct Words {
public var _high: High.Words
public var _low: Low.Words
public init(_ value: DoubleWidth<Base>) {
// Multiples of word size only.
guard Base.bitWidth == Base.Magnitude.bitWidth &&
(UInt.bitWidth % Base.bitWidth == 0 ||
Base.bitWidth % UInt.bitWidth == 0) else {
fatalError("Access to words is not supported on this type")
}
self._high = value._storage.high.words
self._low = value._storage.low.words
assert(!_low.isEmpty)
}
}
}
extension DoubleWidth.Words: RandomAccessCollection {
public typealias Index = Int
public var startIndex: Index {
return 0
}
public var endIndex: Index {
return count
}
public var count: Int {
if Base.bitWidth < UInt.bitWidth { return 1 }
return _low.count + _high.count
}
public subscript(_ i: Index) -> UInt {
if Base.bitWidth < UInt.bitWidth {
precondition(i == 0, "Invalid index")
assert(2 * Base.bitWidth <= UInt.bitWidth)
return _low.first! | (_high.first! &<< Base.bitWidth._lowWord)
}
if i < _low.count {
return _low[i + _low.startIndex]
}
return _high[i - _low.count + _high.startIndex]
}
}
extension DoubleWidth : FixedWidthInteger {
public var words: Words {
return Words(self)
}
public static var isSigned: Bool {
return Base.isSigned
}
public static var max: DoubleWidth {
return self.init(High.max, Low.max)
}
public static var min: DoubleWidth {
return self.init(High.min, Low.min)
}
public static var bitWidth: Int {
return High.bitWidth + Low.bitWidth
}
public func addingReportingOverflow(_ rhs: DoubleWidth)
-> (partialValue: DoubleWidth, overflow: Bool) {
let (low, lowOverflow) =
_storage.low.addingReportingOverflow(rhs._storage.low)
let (high, highOverflow) =
_storage.high.addingReportingOverflow(rhs._storage.high)
let result = (high &+ (lowOverflow ? 1 : 0), low)
let overflow = highOverflow ||
high == Base.max && lowOverflow
return (partialValue: DoubleWidth(result), overflow: overflow)
}
public func subtractingReportingOverflow(_ rhs: DoubleWidth)
-> (partialValue: DoubleWidth, overflow: Bool) {
let (low, lowOverflow) =
_storage.low.subtractingReportingOverflow(rhs._storage.low)
let (high, highOverflow) =
_storage.high.subtractingReportingOverflow(rhs._storage.high)
let result = (high &- (lowOverflow ? 1 : 0), low)
let overflow = highOverflow ||
high == Base.min && lowOverflow
return (partialValue: DoubleWidth(result), overflow: overflow)
}
public func multipliedReportingOverflow(
by rhs: DoubleWidth
) -> (partialValue: DoubleWidth, overflow: Bool) {
let (carry, product) = multipliedFullWidth(by: rhs)
let result = DoubleWidth(truncatingIfNeeded: product)
let isNegative = DoubleWidth.isSigned &&
(self < (0 as DoubleWidth)) != (rhs < (0 as DoubleWidth))
let didCarry = isNegative
? carry != ~(0 as DoubleWidth)
: carry != (0 as DoubleWidth)
let hadPositiveOverflow =
DoubleWidth.isSigned && !isNegative && product.leadingZeroBitCount == 0
return (result, didCarry || hadPositiveOverflow)
}
public func quotientAndRemainder(
dividingBy other: DoubleWidth
) -> (quotient: DoubleWidth, remainder: DoubleWidth) {
let (quotient, remainder) =
Magnitude._divide(self.magnitude, by: other.magnitude)
guard DoubleWidth.isSigned else {
return (DoubleWidth(quotient), DoubleWidth(remainder))
}
let isNegative = (self.high < (0 as High)) != (other.high < (0 as High))
let quotient_ = isNegative
? quotient == DoubleWidth.min.magnitude
? DoubleWidth.min
: 0 - DoubleWidth(quotient)
: DoubleWidth(quotient)
let remainder_ = self.high < (0 as High)
? 0 - DoubleWidth(remainder)
: DoubleWidth(remainder)
return (quotient_, remainder_)
}
public func dividedReportingOverflow(
by other: DoubleWidth
) -> (partialValue: DoubleWidth, overflow: Bool) {
if other == (0 as DoubleWidth) { return (self, true) }
if DoubleWidth.isSigned && other == -1 && self == .min {
return (self, true)
}
return (quotientAndRemainder(dividingBy: other).quotient, false)
}
public func remainderReportingOverflow(
dividingBy other: DoubleWidth
) -> (partialValue: DoubleWidth, overflow: Bool) {
if other == (0 as DoubleWidth) { return (self, true) }
if DoubleWidth.isSigned && other == -1 && self == .min { return (0, true) }
return (quotientAndRemainder(dividingBy: other).remainder, false)
}
public func multipliedFullWidth(
by other: DoubleWidth
) -> (high: DoubleWidth, low: DoubleWidth.Magnitude) {
let isNegative = DoubleWidth.isSigned &&
(self < (0 as DoubleWidth)) != (other < (0 as DoubleWidth))
func mul(_ x: Low, _ y: Low) -> (partial: Low, carry: Low) {
let (high, low) = x.multipliedFullWidth(by: y)
return (low, high)
}
func sum(_ x: Low, _ y: Low, _ z: Low) -> (partial: Low, carry: Low) {
let (sum1, overflow1) = x.addingReportingOverflow(y)
let (sum2, overflow2) = sum1.addingReportingOverflow(z)
let carry: Low = (overflow1 ? 1 : 0) + (overflow2 ? 1 : 0)
return (sum2, carry)
}
let lhs = self.magnitude
let rhs = other.magnitude
let a = mul(rhs._storage.low, lhs._storage.low)
let b = mul(rhs._storage.low, lhs._storage.high)
let c = mul(rhs._storage.high, lhs._storage.low)
let d = mul(rhs._storage.high, lhs._storage.high)
let mid1 = sum(a.carry, b.partial, c.partial)
let mid2 = sum(b.carry, c.carry, d.partial)
let low =
DoubleWidth<Low>(mid1.partial, a.partial)
let (sum_, overflow_) =
mid1.carry.addingReportingOverflow(mid2.partial)
let high =
DoubleWidth(High(mid2.carry + d.carry + (overflow_ ? 1 : 0)), sum_)
if isNegative {
let (lowComplement, overflow) = (~low).addingReportingOverflow(1)
return (~high + (overflow ? 1 : 0 as DoubleWidth), lowComplement)
} else {
return (high, low)
}
}
public func dividingFullWidth(
_ dividend: (high: DoubleWidth, low: DoubleWidth.Magnitude)
) -> (quotient: DoubleWidth, remainder: DoubleWidth) {
let other = DoubleWidth<DoubleWidth>(dividend)
let (quotient, remainder) =
Magnitude._divide(other.magnitude, by: self.magnitude)
guard DoubleWidth.isSigned else {
return (DoubleWidth(quotient), DoubleWidth(remainder))
}
let isNegative =
(self.high < (0 as High)) != (other.high.high < (0 as High))
let quotient_ = isNegative
? quotient == DoubleWidth.min.magnitude
? DoubleWidth.min
: 0 - DoubleWidth(quotient)
: DoubleWidth(quotient)
let remainder_ = other.high.high < (0 as High)
? 0 - DoubleWidth(remainder)
: DoubleWidth(remainder)
return (quotient_, remainder_)
}
public static func &=(
lhs: inout DoubleWidth, rhs: DoubleWidth
) {
lhs._storage.low &= rhs._storage.low
lhs._storage.high &= rhs._storage.high
}
public static func |=(
lhs: inout DoubleWidth, rhs: DoubleWidth
) {
lhs._storage.low |= rhs._storage.low
lhs._storage.high |= rhs._storage.high
}
public static func ^=(
lhs: inout DoubleWidth, rhs: DoubleWidth
) {
lhs._storage.low ^= rhs._storage.low
lhs._storage.high ^= rhs._storage.high
}
public static func <<=(lhs: inout DoubleWidth, rhs: DoubleWidth) {
if DoubleWidth.isSigned && rhs < (0 as DoubleWidth) {
lhs >>= 0 - rhs
return
}
// Shift is larger than this type's bit width.
if rhs._storage.high != (0 as High) ||
rhs._storage.low >= DoubleWidth.bitWidth
{
lhs = 0
return
}
lhs &<<= rhs
}
public static func >>=(lhs: inout DoubleWidth, rhs: DoubleWidth) {
if DoubleWidth.isSigned && rhs < (0 as DoubleWidth) {
lhs <<= 0 - rhs
return
}
// Shift is larger than this type's bit width.
if rhs._storage.high != (0 as High) ||
rhs._storage.low >= DoubleWidth.bitWidth
{
lhs = lhs < (0 as DoubleWidth) ? ~0 : 0
return
}
lhs &>>= rhs
}
/// Returns this value "masked" by its bit width.
///
/// "Masking" notionally involves repeatedly incrementing or decrementing this
/// value by `self.bitWidth` until the result is contained in the range
/// `0..<self.bitWidth`.
internal func _masked() -> DoubleWidth {
// FIXME(integers): test types with bit widths that aren't powers of 2
if DoubleWidth.bitWidth.nonzeroBitCount == 1 {
return self & DoubleWidth(DoubleWidth.bitWidth &- 1)
}
if DoubleWidth.isSigned && self._storage.high < (0 as High) {
return self % DoubleWidth(DoubleWidth.bitWidth) + self
}
return self % DoubleWidth(DoubleWidth.bitWidth)
}
public static func &<<=(lhs: inout DoubleWidth, rhs: DoubleWidth) {
let rhs = rhs._masked()
guard rhs._storage.low < Base.bitWidth else {
lhs._storage.high = High(
truncatingIfNeeded: lhs._storage.low &<<
(rhs._storage.low &- Low(Base.bitWidth)))
lhs._storage.low = 0
return
}
guard rhs._storage.low != (0 as Low) else { return }
lhs._storage.high &<<= High(rhs._storage.low)
lhs._storage.high |= High(
truncatingIfNeeded: lhs._storage.low &>>
(Low(Base.bitWidth) &- rhs._storage.low))
lhs._storage.low &<<= rhs._storage.low
}
public static func &>>=(lhs: inout DoubleWidth, rhs: DoubleWidth) {
let rhs = rhs._masked()
guard rhs._storage.low < Base.bitWidth else {
lhs._storage.low = Low(
truncatingIfNeeded: lhs._storage.high &>>
High(rhs._storage.low &- Low(Base.bitWidth)))
lhs._storage.high = lhs._storage.high < (0 as High) ? ~0 : 0
return
}
guard rhs._storage.low != (0 as Low) else { return }
lhs._storage.low &>>= rhs._storage.low
lhs._storage.low |= Low(
truncatingIfNeeded: lhs._storage.high &<<
High(Low(Base.bitWidth) &- rhs._storage.low))
lhs._storage.high &>>= High(rhs._storage.low)
}
// FIXME(integers): remove this once the operators are back to Numeric
public static func + (
lhs: DoubleWidth, rhs: DoubleWidth
) -> DoubleWidth {
var lhs = lhs
lhs += rhs
return lhs
}
public static func +=(
lhs: inout DoubleWidth, rhs: DoubleWidth
) {
let (result, overflow) = lhs.addingReportingOverflow(rhs)
precondition(!overflow, "Overflow in +=")
lhs = result
}
// FIXME(integers): remove this once the operators are back to Numeric
public static func - (
lhs: DoubleWidth, rhs: DoubleWidth
) -> DoubleWidth {
var lhs = lhs
lhs -= rhs
return lhs
}
public static func -=(
lhs: inout DoubleWidth, rhs: DoubleWidth
) {
let (result, overflow) = lhs.subtractingReportingOverflow(rhs)
precondition(!overflow, "Overflow in -=")
lhs = result
}
// FIXME(integers): remove this once the operators are back to Numeric
public static func * (
lhs: DoubleWidth, rhs: DoubleWidth
) -> DoubleWidth {
var lhs = lhs
lhs *= rhs
return lhs
}
public static func *=(
lhs: inout DoubleWidth, rhs: DoubleWidth
) {
let (result, overflow) = lhs.multipliedReportingOverflow(by:rhs)
precondition(!overflow, "Overflow in *=")
lhs = result
}
// FIXME(integers): remove this once the operators are back to Numeric
public static func / (
lhs: DoubleWidth, rhs: DoubleWidth
) -> DoubleWidth {
var lhs = lhs
lhs /= rhs
return lhs
}
public static func /=(
lhs: inout DoubleWidth, rhs: DoubleWidth
) {
let (result, overflow) = lhs.dividedReportingOverflow(by:rhs)
precondition(!overflow, "Overflow in /=")
lhs = result
}
// FIXME(integers): remove this once the operators are back to Numeric
public static func % (
lhs: DoubleWidth, rhs: DoubleWidth
) -> DoubleWidth {
var lhs = lhs
lhs %= rhs
return lhs
}
public static func %=(
lhs: inout DoubleWidth, rhs: DoubleWidth
) {
let (result, overflow) = lhs.remainderReportingOverflow(dividingBy:rhs)
precondition(!overflow, "Overflow in %=")
lhs = result
}
public init(_truncatingBits bits: UInt) {
_storage.low = Low(_truncatingBits: bits)
_storage.high = High(_truncatingBits: bits >> UInt(Low.bitWidth))
}
public init(integerLiteral x: Int) {
self.init(x)
}
public var leadingZeroBitCount: Int {
return high == (0 as High)
? High.bitWidth + low.leadingZeroBitCount
: high.leadingZeroBitCount
}
public var trailingZeroBitCount: Int {
return low == (0 as Low)
? Low.bitWidth + high.trailingZeroBitCount
: low.trailingZeroBitCount
}
public var nonzeroBitCount: Int {
return high.nonzeroBitCount + low.nonzeroBitCount
}
public var byteSwapped: DoubleWidth {
return DoubleWidth(
High(truncatingIfNeeded: low.byteSwapped),
Low(truncatingIfNeeded: high.byteSwapped))
}
}
extension DoubleWidth : UnsignedInteger where Base : UnsignedInteger {
/// Returns the quotient and remainder after dividing a triple-width magnitude
/// `lhs` by a double-width magnitude `rhs`.
///
/// This operation is conceptually that described by Burnikel and Ziegler
/// (1998).
internal static func _divide(
_ lhs: (high: Low, mid: Low, low: Low), by rhs: Magnitude
) -> (quotient: Low, remainder: Magnitude) {
// The following invariants are guaranteed to hold by dividingFullWidth or
// quotientAndRemainder before this method is invoked:
assert(rhs.leadingZeroBitCount == 0)
assert(Magnitude(lhs.high, lhs.mid) < rhs)
guard lhs.high != (0 as Low) else {
let lhs_ = Magnitude(lhs.mid, lhs.low)
return lhs_ < rhs ? (0, lhs_) : (1, lhs_ &- rhs)
}
// Estimate the quotient.
var quotient = lhs.high == rhs.high
? Low.max
: rhs.high.dividingFullWidth((lhs.high, lhs.mid)).quotient
// Compute quotient * rhs.
// TODO: This could be performed more efficiently.
var product =
DoubleWidth<Magnitude>(
0, Magnitude(quotient.multipliedFullWidth(by: rhs.low)))
let (x, y) = quotient.multipliedFullWidth(by: rhs.high)
product += DoubleWidth<Magnitude>(Magnitude(0, x), Magnitude(y, 0))
// Compute the remainder after decrementing quotient as necessary.
var remainder =
DoubleWidth<Magnitude>(
Magnitude(0, lhs.high), Magnitude(lhs.mid, lhs.low))
while remainder < product {
quotient = quotient &- 1
remainder += DoubleWidth<Magnitude>(0, rhs)
}
remainder -= product
return (quotient, remainder.low)
}
/// Returns the quotient and remainder after dividing a quadruple-width
/// magnitude `lhs` by a double-width magnitude `rhs`.
internal static func _divide(
_ lhs: DoubleWidth<Magnitude>, by rhs: Magnitude
) -> (quotient: Magnitude, remainder: Magnitude) {
guard _fastPath(rhs > (0 as Magnitude)) else {
fatalError("Division by zero")
}
guard _fastPath(rhs >= lhs.high) else {
fatalError("Division results in an overflow")
}
if lhs.high == (0 as Magnitude) {
return lhs.low.quotientAndRemainder(dividingBy: rhs)
}
if rhs.high == (0 as Low) {
let a = lhs.high.high % rhs.low
let b = a == (0 as Low)
? lhs.high.low % rhs.low
: rhs.low.dividingFullWidth((a, lhs.high.low)).remainder
let (x, c) = b == (0 as Low)
? lhs.low.high.quotientAndRemainder(dividingBy: rhs.low)
: rhs.low.dividingFullWidth((b, lhs.low.high))
let (y, d) = c == (0 as Low)
? lhs.low.low.quotientAndRemainder(dividingBy: rhs.low)
: rhs.low.dividingFullWidth((c, lhs.low.low))
return (Magnitude(x, y), Magnitude(0, d))
}
// Left shift both rhs and lhs, then divide and right shift the remainder.
let shift = rhs.leadingZeroBitCount
let rhs = rhs &<< shift
let lhs = lhs &<< shift
if lhs.high.high == (0 as Low)
&& Magnitude(lhs.high.low, lhs.low.high) < rhs {
let (quotient, remainder) =
Magnitude._divide((lhs.high.low, lhs.low.high, lhs.low.low), by: rhs)
return (Magnitude(0, quotient), remainder &>> shift)
}
let (x, a) =
Magnitude._divide((lhs.high.high, lhs.high.low, lhs.low.high), by: rhs)
let (y, b) =
Magnitude._divide((a.high, a.low, lhs.low.low), by: rhs)
return (Magnitude(x, y), b &>> shift)
}
/// Returns the quotient and remainder after dividing a double-width
/// magnitude `lhs` by a double-width magnitude `rhs`.
internal static func _divide(
_ lhs: Magnitude, by rhs: Magnitude
) -> (quotient: Magnitude, remainder: Magnitude) {
guard _fastPath(rhs > (0 as Magnitude)) else {
fatalError("Division by zero")
}
guard rhs < lhs else {
if _fastPath(rhs > lhs) { return (0, lhs) }
return (1, 0)
}
if lhs.high == (0 as Low) {
let (quotient, remainder) =
lhs.low.quotientAndRemainder(dividingBy: rhs.low)
return (Magnitude(quotient), Magnitude(remainder))
}
if rhs.high == (0 as Low) {
let (x, a) = lhs.high.quotientAndRemainder(dividingBy: rhs.low)
let (y, b) = a == (0 as Low)
? lhs.low.quotientAndRemainder(dividingBy: rhs.low)
: rhs.low.dividingFullWidth((a, lhs.low))
return (Magnitude(x, y), Magnitude(0, b))
}
// Left shift both rhs and lhs, then divide and right shift the remainder.
let shift = rhs.leadingZeroBitCount
// Note the use of `>>` instead of `&>>` below,
// as `high` should be zero if `shift` is zero.
let high = (lhs >> (Magnitude.bitWidth &- shift)).low
let rhs = rhs &<< shift
let lhs = lhs &<< shift
let (quotient, remainder) =
Magnitude._divide((high, lhs.high, lhs.low), by: rhs)
return (Magnitude(0, quotient), remainder &>> shift)
}
}
extension DoubleWidth : SignedNumeric, SignedInteger
where Base : SignedInteger {}
+1 -1
View File
@@ -10,8 +10,8 @@
//
//===----------------------------------------------------------------------===//
import ComplexModule
import RealModule
import ComplexModule
public func relativeError(_ tst: Float, _ ref: Double) -> Double {
let scale = max(ref.magnitude, Double(Float.leastNormalMagnitude))
+1 -1
View File
@@ -15,7 +15,7 @@ public protocol FixedWidthFloatingPoint: BinaryFloatingPoint
where Exponent: FixedWidthInteger,
RawSignificand: FixedWidthInteger { }
#if !((os(macOS) || targetEnvironment(macCatalyst)) && arch(x86_64))
#if swift(>=5.4) && !((os(macOS) || targetEnvironment(macCatalyst)) && arch(x86_64))
@available(macOS 11.0, iOS 14.0, tvOS 14.0, watchOS 7.0, *)
extension Float16: FixedWidthFloatingPoint { }
#endif
-460
View File
@@ -1,460 +0,0 @@
//===--- BigIntTests.swift ------------------------------------*- swift -*-===//
//
// This source file is part of the Swift Numerics open source project
//
// 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 BigIntModule
import XCTest
extension BigInt {
static func fac(_ n: BigInt) -> BigInt {
precondition(n >= 0, "Factorial of a negative integer is undefined")
return stride(from: n, to: 1, by: -1).reduce(into: 1, { $0 *= $1 })
}
// inspired by https://eli.thegreenplace.net/2009/03/21/efficient-integer-exponentiation-algorithms
static func pow(_ lhs: BigInt, _ rhs: BigInt) -> BigInt {
let bits_of_n = {
(n: BigInt) -> [Int] in
var bits: [Int] = []
var n = n
while n != 0 {
bits.append(Int(n % 2))
n /= 2
}
return bits
}
var r: BigInt = 1
for bit in bits_of_n(rhs).reversed() {
r *= r
if bit == 1 {
r *= lhs
}
}
return r
}
}
final class BigIntTests: XCTestCase {
/// Python: `bitWidth = 1024; -(2 ** (bitWidth - 1))`
static let descriptionInt1024Min: String =
"""
-89884656743115795386465259539451236680898848947115328636715040578866337902\
750481566354238661203768010560056939935696678829394884407208311246423715319\
737062188883946712432742638151109800623047059726541476042502884419075341171\
231440736956555270413618581675255342293149119973622969239858152417678164812\
112068608
"""
/// Python: `bitWidth = 1024; (2 ** (bitWidth - 1)) - 1`
static let descriptionInt1024Max: String =
"""
89884656743115795386465259539451236680898848947115328636715040578866337902\
750481566354238661203768010560056939935696678829394884407208311246423715319\
737062188883946712432742638151109800623047059726541476042502884419075341171\
231440736956555270413618581675255342293149119973622969239858152417678164812\
112068607
"""
/// Python: `numpy.base_repr(math.factorial(512), base=36)`
static let descriptionFactorial512_radix36: String =
"""
7FA5Y7EHR9XHMQ519MBHGYOF8XDYMUX8OZHO9WF1KCM0SSPXV2V45UA73BAFRYM2PFB8CZLTODV\
OS3QWA7PYFJ7WAFBI4VF371E27N6XZ4LGWHMFDS4ZH1O3DGNFG4YABUE1G90ORGRTIOGSQVZLSQ\
4TKHKHIQ262JVQ0J6LSKAPN5I65AJD33XODVHRNWJ1VSO0Q2FBOUNCPGQG2SFQKR17XHF1OLTV2\
MVNJVTDAIYWVJ9ZH7KXT0EPS00IGIVC7MNCU25HFWE37KNMSJQUL5ALUCE5XZVPFQCQGEVEB93B\
GA8LKG67PVZ7Q9QMQKIVNIMPT2973MVDTD1D1A0A4QT6NBZYR0TGSZXBV1PD0CHW4SKZJSLBS4Z\
W5WCKDY8BCQCE17KKADVLCTVSQL1BZ2PL52DDPB8S5L0ZEG2ZAZF9V4TNJJNO1D9U9JU7B264QZ\
5GLHC3Q0Y3BTECGTI8GRENQ2FV4HSEZKPM9OG302KLSY9MBCSOO0FN229AST84TT87LYWOOS71C\
54RPJ9RTO9875Z9DE3HPH89EW5I3SV219O04UU09A4KME7DD7IH49ABO79NR4EXFX1VLL4YOHSA\
7AHD1LS5YKZ66F4UPG0RCBGG000000000000000000000000000000000000000000000000000\
000000000000000000000000000000000000000000000000000000000000000000000000000
"""
// MARK: - Basic arithmetic
func testDivision() {
let num1 = BigInt("18446744073709551616")!
let den1 = BigInt(123)
let expected1 = BigInt(UInt64(149973529054549200))
XCTAssertEqual(num1 / den1, expected1)
let num2 = BigInt.pow(BigInt(10), 100)
let den2: BigInt = 3
let expected2: BigInt = BigInt(String(repeating: "3", count: 100))!
let actual2 = num2 / den2
XCTAssertEqual(actual2, expected2)
let num3 = BigInt.pow(BigInt(10), 97)
let den3: BigInt = BigInt("33333333333333333333")!
let expected3: BigInt = BigInt("300000000000000000003000000000000000000030000000000000000000300000000000000000")!
let actual3 = num3 / den3
XCTAssertEqual(actual3, expected3)
let foo = BigInt("12345678901234567890123456789012345678901234567890123456789012345678901234567890")!
let bar = BigInt("351235231535161613134135135135")!
let baz = foo / bar
XCTAssertEqual(baz, BigInt("35149318157164029153358504918339691272847595997760")!)
XCTAssertNotNil(BigInt(exactly: 2.4e39))
XCTAssertNotNil(BigInt(exactly: 1e38))
XCTAssertEqual(BigInt(2.4e39) / BigInt(1e38), BigInt(24))
for _ in 0 ..< 100 {
let expected = BigInt(Float64.random(in: 0x1p64 ... 0x1p255))
let divisor = BigInt(Float64.random(in: 0x1p64 ... 0x1p128))
let (quotient, remainder) = expected.quotientAndRemainder(dividingBy: divisor)
let actual = divisor * quotient + remainder
XCTAssertEqual(quotient, expected / divisor)
XCTAssertEqual(remainder, expected % divisor)
XCTAssertEqual(
actual, expected,
"""
## FAILURE ##
~~~~~~~~~~~~~
actual: \(actual)
!= expected: \(expected)
~~~~~~~~~~~~~
divisor: \(divisor)
* quotient: \(quotient)
+ remainder: \(remainder)
~~~~~~~~~~~~~
""")
}
}
func testFactorial() {
var expectedNumber: BigInt?
var actualNumber: BigInt!
var actualString: String!
measure {
expectedNumber = BigInt(Self.descriptionFactorial512_radix36, radix: 36)
actualNumber = BigInt.fac(512)
actualString = String(actualNumber, radix: 36, uppercase: true)
}
XCTAssertEqual(actualNumber, expectedNumber)
XCTAssertEqual(actualString, Self.descriptionFactorial512_radix36)
XCTAssertEqual(BigInt.fac(0), 1)
XCTAssertEqual(BigInt.fac(1), 1)
XCTAssertEqual(BigInt.fac(2), 2)
XCTAssertEqual(BigInt.fac(3), 6)
XCTAssertEqual(BigInt.fac(4), 24)
XCTAssertEqual(BigInt.fac(5), 120)
XCTAssertEqual(BigInt.fac(6), 720)
XCTAssertEqual(BigInt.fac(7), 5040)
XCTAssertEqual(BigInt.fac(8), 40320)
XCTAssertEqual(BigInt.fac(9), 362880)
}
func testMath() {
let foo = BigInt.pow(10, 20)
let bar = BigInt("1234567890123456789012345678901234567890")!
let baz = foo + bar
XCTAssertEqual(baz, BigInt("1234567890123456789112345678901234567890")!)
let fooz = foo >> BigInt(10)
XCTAssertEqual(fooz, foo / 1024)
let barz = BigInt(1) << 64
XCTAssertEqual(barz, BigInt(UInt64.max) + 1)
}
func testNegation() {
let foo = BigInt("1234567890123456789012345678901234567890")!
let bar = BigInt(0) - foo
XCTAssertEqual(-foo, bar)
var baz = foo
baz.negate()
XCTAssertEqual(baz, bar)
}
func testSignum() {
XCTAssertEqual(BigInt(-0x1p1023).signum(), -1)
XCTAssertEqual(BigInt(Int64.min).signum(), -1)
XCTAssertEqual(BigInt(Int32.min).signum(), -1)
XCTAssertEqual(BigInt(Int16.min).signum(), -1)
XCTAssertEqual(BigInt(Int8.min).signum(), -1)
XCTAssertEqual(BigInt(-1).signum(), -1)
XCTAssertEqual(BigInt(0).signum(), 0)
XCTAssertEqual(BigInt(+1).signum(), +1)
XCTAssertEqual(BigInt(Int8.max).signum(), +1)
XCTAssertEqual(BigInt(Int16.max).signum(), +1)
XCTAssertEqual(BigInt(Int32.max).signum(), +1)
XCTAssertEqual(BigInt(Int64.max).signum(), +1)
XCTAssertEqual(BigInt(+0x1p1023).signum(), +1)
}
func testTrailingZeroCount() {
let foo = BigInt(1) << 300
XCTAssertEqual(foo.trailingZeroBitCount, 300)
let bar = (BigInt(1) << 300) + 0b101000
XCTAssertEqual(bar.trailingZeroBitCount, 3)
}
// MARK: - Comparing and hashing
func testComparable() {
let foo = BigInt("1234567890123456789012345678901234567890")!
let bar = foo * foo
XCTAssertLessThan(foo, bar)
XCTAssertFalse(foo < foo)
XCTAssertFalse(bar < bar)
XCTAssertFalse(foo > foo)
XCTAssertFalse(bar > bar)
XCTAssertGreaterThan(bar, foo)
let baz = bar * -1
XCTAssertLessThan(baz, foo)
XCTAssertNotEqual(bar, baz)
XCTAssertFalse(baz < baz)
}
func testComparison() {
let foo = BigInt(-10)
let bar = BigInt(-20)
XCTAssert(foo > bar)
XCTAssert(bar < foo)
XCTAssert(foo == BigInt(-10))
let baz = BigInt.pow(foo, -bar)
XCTAssertEqual(baz, BigInt("100000000000000000000")!)
}
func testExample() {
let bar = BigInt(exactly: -100)
XCTAssertNotNil(bar)
if let bar = bar {
XCTAssertLessThan(bar, 0)
XCTAssertGreaterThan(-bar, 0)
XCTAssertEqual(-bar, BigInt(100))
}
XCTAssertEqual(-BigInt("-1234567890123456789012345678901234567890")!,
+BigInt("+1234567890123456789012345678901234567890")!)
}
func testHashable() {
let foo = BigInt("1234567890123456789012345678901234567890")!
let bar = BigInt("1234567890123456789112345678901234567890")!
let baz: BigInt = 153
let dict = [ foo: "Hello", bar: "World", baz: "!" ]
let hash = foo.hashValue
print(hash)
XCTAssertEqual(dict[foo]!, "Hello")
XCTAssertEqual(dict[bar]!, "World")
}
func testClampingConversion() {
XCTAssertEqual(BigInt(clamping: UInt64.max), BigInt(UInt64(18446744073709551615)))
}
func testUIntConversion() {
let foo = BigInt(UInt.max)
XCTAssertNotEqual(foo, BigInt(-1))
let bar = BigInt(bitPattern: UInt.max)
XCTAssertEqual(bar, BigInt(-1))
}
// MARK: - Converting to/from textual representations
func testCodable() throws {
let lowerBound = BigInt("-1234567890123456789012345678901234567890")!
let upperBound = BigInt("+1234567890123456789012345678901234567890")!
let expectedRange: Range<BigInt> = lowerBound ..< upperBound
let encoder = JSONEncoder()
let decoder = JSONDecoder()
let data = try encoder.encode(expectedRange)
let actualRange = try decoder.decode(Range<BigInt>.self, from: data)
XCTAssertEqual(actualRange, expectedRange)
}
func testCustomStringConvertible() {
XCTAssertEqual("\(BigInt(UInt64.min) - 2)", "-2")
XCTAssertEqual("\(BigInt(UInt64.min) - 1)", "-1")
XCTAssertEqual("\(BigInt(UInt64.min) + 0)", "0")
XCTAssertEqual("\(BigInt(UInt64.min) + 1)", "1")
XCTAssertEqual("\(BigInt(UInt64.min) + 2)", "2")
XCTAssertEqual("\(BigInt(UInt64.max) - 2)", "18446744073709551613")
XCTAssertEqual("\(BigInt(UInt64.max) - 1)", "18446744073709551614")
XCTAssertEqual("\(BigInt(UInt64.max) + 0)", "18446744073709551615")
XCTAssertEqual("\(BigInt(UInt64.max) + 1)", "18446744073709551616")
XCTAssertEqual("\(BigInt(UInt64.max) + 2)", "18446744073709551617")
XCTAssertEqual("\(BigInt(Int64.min) - 2)", "-9223372036854775810")
XCTAssertEqual("\(BigInt(Int64.min) - 1)", "-9223372036854775809")
XCTAssertEqual("\(BigInt(Int64.min) + 0)", "-9223372036854775808")
XCTAssertEqual("\(BigInt(Int64.min) + 1)", "-9223372036854775807")
XCTAssertEqual("\(BigInt(Int64.min) + 2)", "-9223372036854775806")
XCTAssertEqual("\(BigInt(Int64.max) - 2)", "9223372036854775805")
XCTAssertEqual("\(BigInt(Int64.max) - 1)", "9223372036854775806")
XCTAssertEqual("\(BigInt(Int64.max) + 0)", "9223372036854775807")
XCTAssertEqual("\(BigInt(Int64.max) + 1)", "9223372036854775808")
XCTAssertEqual("\(BigInt(Int64.max) + 2)", "9223372036854775809")
XCTAssertEqual("\(-(BigInt(1) << 1023))", Self.descriptionInt1024Min)
XCTAssertEqual("\(+(BigInt(1) << 1023) - 1)", Self.descriptionInt1024Max)
}
func testLosslessStringConvertible() {
XCTAssertNil(BigInt(""))
XCTAssertNil(BigInt("-"))
XCTAssertNil(BigInt("+"))
XCTAssertNil(BigInt("A"))
XCTAssertNil(BigInt(" 0"))
XCTAssertNil(BigInt("0 "))
XCTAssertEqual(BigInt(UInt64.min) - 2, BigInt("-2"))
XCTAssertEqual(BigInt(UInt64.min) - 1, BigInt("-1"))
XCTAssertEqual(BigInt(UInt64.min) + 0, BigInt("0"))
XCTAssertEqual(BigInt(UInt64.min) + 1, BigInt("1"))
XCTAssertEqual(BigInt(UInt64.min) + 2, BigInt("2"))
XCTAssertEqual(BigInt(UInt64.max) - 2, BigInt("18446744073709551613"))
XCTAssertEqual(BigInt(UInt64.max) - 1, BigInt("18446744073709551614"))
XCTAssertEqual(BigInt(UInt64.max) + 0, BigInt("18446744073709551615"))
XCTAssertEqual(BigInt(UInt64.max) + 1, BigInt("18446744073709551616"))
XCTAssertEqual(BigInt(UInt64.max) + 2, BigInt("18446744073709551617"))
XCTAssertEqual(BigInt(Int64.min) - 2, BigInt("-9223372036854775810"))
XCTAssertEqual(BigInt(Int64.min) - 1, BigInt("-9223372036854775809"))
XCTAssertEqual(BigInt(Int64.min) + 0, BigInt("-9223372036854775808"))
XCTAssertEqual(BigInt(Int64.min) + 1, BigInt("-9223372036854775807"))
XCTAssertEqual(BigInt(Int64.min) + 2, BigInt("-9223372036854775806"))
XCTAssertEqual(BigInt(Int64.max) - 2, BigInt("9223372036854775805"))
XCTAssertEqual(BigInt(Int64.max) - 1, BigInt("9223372036854775806"))
XCTAssertEqual(BigInt(Int64.max) + 0, BigInt("9223372036854775807"))
XCTAssertEqual(BigInt(Int64.max) + 1, BigInt("9223372036854775808"))
XCTAssertEqual(BigInt(Int64.max) + 2, BigInt("9223372036854775809"))
XCTAssertEqual(-(BigInt(1) << 1023), BigInt(Self.descriptionInt1024Min))
XCTAssertEqual(+(BigInt(1) << 1023) - 1, BigInt(Self.descriptionInt1024Max))
}
func testRadicesAndNumerals() {
for radix in 2 ... 36 {
for uppercase in [false, true] {
for _ in 0 ..< 100 {
let expectedNumber = BigInt(Int.random(in: .min ... .max))
let expectedString = String(expectedNumber,
radix: radix,
uppercase: uppercase)
let actualNumber = BigInt(expectedString, radix: radix)
XCTAssertEqual(actualNumber, expectedNumber)
if radix == 10 {
let actualString = expectedNumber.description
XCTAssertEqual(actualString, expectedString)
}
}
}
}
}
// MARK: - Converting from floating-point binary types
func testBinaryFloatingPoint<T>(_ type: T.Type) where T: BinaryFloatingPoint {
var expected = BigInt(T.greatestFiniteMagnitude.significandBitPattern)
expected |= BigInt(1) << T.significandBitCount
expected <<= T.greatestFiniteMagnitude.exponent
expected >>= T.significandBitCount
XCTAssertEqual(BigInt(exactly: -T.greatestFiniteMagnitude), -expected)
XCTAssertEqual(BigInt(exactly: +T.greatestFiniteMagnitude), +expected)
XCTAssertEqual(BigInt(-T.greatestFiniteMagnitude), -expected)
XCTAssertEqual(BigInt(+T.greatestFiniteMagnitude), +expected)
XCTAssertNil(BigInt(exactly: -T.infinity))
XCTAssertNil(BigInt(exactly: +T.infinity))
XCTAssertNil(BigInt(exactly: -T.leastNonzeroMagnitude))
XCTAssertNil(BigInt(exactly: +T.leastNonzeroMagnitude))
XCTAssertEqual(BigInt(-T.leastNonzeroMagnitude), 0)
XCTAssertEqual(BigInt(+T.leastNonzeroMagnitude), 0)
XCTAssertNil(BigInt(exactly: -T.leastNormalMagnitude))
XCTAssertNil(BigInt(exactly: +T.leastNormalMagnitude))
XCTAssertEqual(BigInt(-T.leastNormalMagnitude), 0)
XCTAssertEqual(BigInt(+T.leastNormalMagnitude), 0)
XCTAssertNil(BigInt(exactly: T.nan))
XCTAssertNil(BigInt(exactly: T.signalingNaN))
XCTAssertNil(BigInt(exactly: -T.pi))
XCTAssertNil(BigInt(exactly: +T.pi))
XCTAssertEqual(BigInt(-T.pi), -3)
XCTAssertEqual(BigInt(+T.pi), +3)
XCTAssertNil(BigInt(exactly: -T.ulpOfOne))
XCTAssertNil(BigInt(exactly: +T.ulpOfOne))
XCTAssertEqual(BigInt(-T.ulpOfOne), 0)
XCTAssertEqual(BigInt(+T.ulpOfOne), 0)
XCTAssertEqual(BigInt(exactly: -T.zero), 0)
XCTAssertEqual(BigInt(exactly: +T.zero), 0)
XCTAssertEqual(BigInt(-T.zero), 0)
XCTAssertEqual(BigInt(+T.zero), 0)
}
func testBinaryFloatingPoint() {
testBinaryFloatingPoint(Float32.self)
testBinaryFloatingPoint(Float64.self)
#if (arch(i386) || arch(x86_64)) && !os(Windows) && !os(Android)
testBinaryFloatingPoint(Float80.self)
#endif
for _ in 0 ..< 100 {
let small = Float32.random(in: -10 ... +10)
XCTAssertEqual(BigInt(small), BigInt(Int64(small)))
let large = Float32.random(in: -0x1p23 ... +0x1p23)
XCTAssertEqual(BigInt(large), BigInt(Int64(large)))
}
for _ in 0 ..< 100 {
let small = Float64.random(in: -10 ... +10)
XCTAssertEqual(BigInt(small), BigInt(Int64(small)))
let large = Float64.random(in: -0x1p52 ... +0x1p52)
XCTAssertEqual(BigInt(large), BigInt(Int64(large)))
}
#if (arch(i386) || arch(x86_64)) && !os(Windows) && !os(Android)
for _ in 0 ..< 100 {
let small = Float80.random(in: -10 ... +10)
XCTAssertEqual(BigInt(small), BigInt(Int64(small)))
let large = Float80.random(in: -0x1p63 ..< +0x1p63)
XCTAssertEqual(BigInt(large), BigInt(Int64(large)))
}
#endif
}
}
-360
View File
@@ -1,360 +0,0 @@
//===--- BigUIntTests.swift -----------------------------------*- swift -*-===//
//
// This source file is part of the Swift Numerics open source project
//
// 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 BigIntModule
import XCTest
extension BigUInt {
static func fac(_ n: BigUInt) -> BigUInt {
return stride(from: n, to: 1, by: -1).reduce(into: 1, { $0 *= $1 })
}
// inspired by https://eli.thegreenplace.net/2009/03/21/efficient-integer-exponentiation-algorithms
static func pow(_ lhs: BigUInt, _ rhs: BigUInt) -> BigUInt {
let bits_of_n = { (n: BigUInt) -> [Int] in
var bits: [Int] = []
var n = n
while n != 0 {
bits.append(Int(n % 2))
n /= 2
}
return bits
}
var r: BigUInt = 1
for bit in bits_of_n(rhs).reversed() {
r *= r
if bit == 1 {
r *= lhs
}
}
return r
}
}
final class BigUIntTests: XCTestCase {
/// Python: `bitWidth = 1024; -(2 ** (bitWidth - 1))`
static let descriptionInt1024Min: String =
"""
-89884656743115795386465259539451236680898848947115328636715040578866337902\
750481566354238661203768010560056939935696678829394884407208311246423715319\
737062188883946712432742638151109800623047059726541476042502884419075341171\
231440736956555270413618581675255342293149119973622969239858152417678164812\
112068608
"""
/// Python: `bitWidth = 1024; (2 ** (bitWidth - 1)) - 1`
static let descriptionInt1024Max: String =
"""
89884656743115795386465259539451236680898848947115328636715040578866337902\
750481566354238661203768010560056939935696678829394884407208311246423715319\
737062188883946712432742638151109800623047059726541476042502884419075341171\
231440736956555270413618581675255342293149119973622969239858152417678164812\
112068607
"""
/// Python: `numpy.base_repr(math.factorial(512), base=36)`
static let descriptionFactorial512_radix36: String =
"""
7FA5Y7EHR9XHMQ519MBHGYOF8XDYMUX8OZHO9WF1KCM0SSPXV2V45UA73BAFRYM2PFB8CZLTODV\
OS3QWA7PYFJ7WAFBI4VF371E27N6XZ4LGWHMFDS4ZH1O3DGNFG4YABUE1G90ORGRTIOGSQVZLSQ\
4TKHKHIQ262JVQ0J6LSKAPN5I65AJD33XODVHRNWJ1VSO0Q2FBOUNCPGQG2SFQKR17XHF1OLTV2\
MVNJVTDAIYWVJ9ZH7KXT0EPS00IGIVC7MNCU25HFWE37KNMSJQUL5ALUCE5XZVPFQCQGEVEB93B\
GA8LKG67PVZ7Q9QMQKIVNIMPT2973MVDTD1D1A0A4QT6NBZYR0TGSZXBV1PD0CHW4SKZJSLBS4Z\
W5WCKDY8BCQCE17KKADVLCTVSQL1BZ2PL52DDPB8S5L0ZEG2ZAZF9V4TNJJNO1D9U9JU7B264QZ\
5GLHC3Q0Y3BTECGTI8GRENQ2FV4HSEZKPM9OG302KLSY9MBCSOO0FN229AST84TT87LYWOOS71C\
54RPJ9RTO9875Z9DE3HPH89EW5I3SV219O04UU09A4KME7DD7IH49ABO79NR4EXFX1VLL4YOHSA\
7AHD1LS5YKZ66F4UPG0RCBGG000000000000000000000000000000000000000000000000000\
000000000000000000000000000000000000000000000000000000000000000000000000000
"""
// MARK: - Basic arithmetic
func testDivision() {
let num1 = BigUInt("18446744073709551616")!
let den1 = BigUInt(123)
let expected1 = BigUInt(UInt64(149973529054549200))
XCTAssertEqual(num1 / den1, expected1)
let num2 = BigUInt.pow(BigUInt(10), 100)
let den2: BigUInt = 3
let expected2: BigUInt = BigUInt(String(repeating: "3", count: 100))!
let actual2 = num2 / den2
XCTAssertEqual(actual2, expected2)
let num3 = BigUInt.pow(BigUInt(10), 97)
let den3: BigUInt = BigUInt("33333333333333333333")!
let expected3: BigUInt = BigUInt("300000000000000000003000000000000000000030000000000000000000300000000000000000")!
let actual3 = num3 / den3
XCTAssertEqual(actual3, expected3)
let foo = BigUInt("12345678901234567890123456789012345678901234567890123456789012345678901234567890")!
let bar = BigUInt("351235231535161613134135135135")!
let baz = foo / bar
XCTAssertEqual(baz, BigUInt("35149318157164029153358504918339691272847595997760")!)
XCTAssertNotNil(BigUInt(exactly: 2.4e39))
XCTAssertNotNil(BigUInt(exactly: 1e38))
XCTAssertEqual(BigUInt(2.4e39) / BigUInt(1e38), BigUInt(24))
for _ in 0 ..< 100 {
let expected = BigUInt(Float64.random(in: 0x1p64 ... 0x1p255))
let divisor = BigUInt(Float64.random(in: 0x1p64 ... 0x1p128))
let (quotient, remainder) = expected.quotientAndRemainder(dividingBy: divisor)
let actual = divisor * quotient + remainder
XCTAssertEqual(quotient, expected / divisor)
XCTAssertEqual(remainder, expected % divisor)
XCTAssertEqual(
actual, expected,
"""
## FAILURE ##
~~~~~~~~~~~~~
actual: \(actual)
!= expected: \(expected)
~~~~~~~~~~~~~
divisor: \(divisor)
* quotient: \(quotient)
+ remainder: \(remainder)
~~~~~~~~~~~~~
""")
}
}
func testFactorial() {
var expectedNumber: BigUInt?
var actualNumber: BigUInt!
var actualString: String!
measure {
expectedNumber = BigUInt(Self.descriptionFactorial512_radix36, radix: 36)
actualNumber = BigUInt.fac(512)
actualString = String(actualNumber, radix: 36, uppercase: true)
}
XCTAssertEqual(actualNumber, expectedNumber)
XCTAssertEqual(actualString, Self.descriptionFactorial512_radix36)
XCTAssertEqual(BigUInt.fac(0), 1)
XCTAssertEqual(BigUInt.fac(1), 1)
XCTAssertEqual(BigUInt.fac(2), 2)
XCTAssertEqual(BigUInt.fac(3), 6)
XCTAssertEqual(BigUInt.fac(4), 24)
XCTAssertEqual(BigUInt.fac(5), 120)
XCTAssertEqual(BigUInt.fac(6), 720)
XCTAssertEqual(BigUInt.fac(7), 5040)
XCTAssertEqual(BigUInt.fac(8), 40320)
XCTAssertEqual(BigUInt.fac(9), 362880)
}
func testMath() {
let foo = BigUInt.pow(10, 20)
let bar = BigUInt("1234567890123456789012345678901234567890")!
let baz = foo + bar
XCTAssertEqual(baz, BigUInt("1234567890123456789112345678901234567890")!)
let fooz = foo >> BigUInt(10)
XCTAssertEqual(fooz, foo / 1024)
let barz = BigUInt(1) << 64
XCTAssertEqual(barz, BigUInt(UInt64.max) + 1)
}
func testTrailingZeroCount() {
let foo = BigUInt(1) << 300
XCTAssertEqual(foo.trailingZeroBitCount, 300)
let bar = (BigUInt(1) << 300) + 0b101000
XCTAssertEqual(bar.trailingZeroBitCount, 3)
}
// MARK: - Comparing and hashing
func testComparable() {
let foo = BigUInt("1234567890123456789012345678901234567890")!
let bar = foo * foo
XCTAssertLessThan(foo, bar)
XCTAssertFalse(foo < foo)
XCTAssertFalse(bar < bar)
XCTAssertFalse(foo > foo)
XCTAssertFalse(bar > bar)
XCTAssertGreaterThan(bar, foo)
}
func testHashable() {
let foo = BigInt("1234567890123456789012345678901234567890")!
let bar = BigInt("1234567890123456789112345678901234567890")!
let baz: BigInt = 153
let dict = [foo: "Hello", bar: "World", baz: "!"]
let hash = foo.hashValue
print(hash)
XCTAssertEqual(dict[foo]!, "Hello")
XCTAssertEqual(dict[bar]!, "World")
}
func testClampingConversion() {
XCTAssertEqual(BigUInt(clamping: UInt64.max), BigUInt(UInt64(18446744073709551615)))
}
// MARK: - Converting to/from textual representations
func testCodable() throws {
let lowerBound = BigUInt("0")!
let upperBound = BigUInt("+1234567890123456789012345678901234567890")!
let expectedRange: Range<BigUInt> = lowerBound ..< upperBound
let encoder = JSONEncoder()
let decoder = JSONDecoder()
let data = try encoder.encode(expectedRange)
let actualRange = try decoder.decode(Range<BigUInt>.self, from: data)
XCTAssertEqual(actualRange, expectedRange)
}
func testCustomStringConvertible() {
XCTAssertEqual("\(BigUInt(UInt64.min) + 0)", "0")
XCTAssertEqual("\(BigUInt(UInt64.min) + 1)", "1")
XCTAssertEqual("\(BigUInt(UInt64.min) + 2)", "2")
XCTAssertEqual("\(BigUInt(UInt64.max) - 2)", "18446744073709551613")
XCTAssertEqual("\(BigUInt(UInt64.max) - 1)", "18446744073709551614")
XCTAssertEqual("\(BigUInt(UInt64.max) + 0)", "18446744073709551615")
XCTAssertEqual("\(BigUInt(UInt64.max) + 1)", "18446744073709551616")
XCTAssertEqual("\(BigUInt(UInt64.max) + 2)", "18446744073709551617")
XCTAssertEqual("\(BigUInt(Int64.max) - 2)", "9223372036854775805")
XCTAssertEqual("\(BigUInt(Int64.max) - 1)", "9223372036854775806")
XCTAssertEqual("\(BigUInt(Int64.max) + 0)", "9223372036854775807")
XCTAssertEqual("\(BigUInt(Int64.max) + 1)", "9223372036854775808")
XCTAssertEqual("\(BigUInt(Int64.max) + 2)", "9223372036854775809")
XCTAssertEqual("\(+(BigUInt(1) << 1023) - 1)", Self.descriptionInt1024Max)
}
func testLosslessStringConvertible() {
XCTAssertNil(BigUInt(""))
XCTAssertNil(BigUInt("+"))
XCTAssertNil(BigUInt("A"))
XCTAssertNil(BigUInt(" 0"))
XCTAssertNil(BigUInt("0 "))
XCTAssertEqual(BigUInt(UInt64.min) + 0, BigUInt("0"))
XCTAssertEqual(BigUInt(UInt64.min) + 1, BigUInt("1"))
XCTAssertEqual(BigUInt(UInt64.min) + 2, BigUInt("2"))
XCTAssertEqual(BigUInt(UInt64.max) - 2, BigUInt("18446744073709551613"))
XCTAssertEqual(BigUInt(UInt64.max) - 1, BigUInt("18446744073709551614"))
XCTAssertEqual(BigUInt(UInt64.max) + 0, BigUInt("18446744073709551615"))
XCTAssertEqual(BigUInt(UInt64.max) + 1, BigUInt("18446744073709551616"))
XCTAssertEqual(BigUInt(UInt64.max) + 2, BigUInt("18446744073709551617"))
XCTAssertEqual(BigUInt(Int64.max) - 2, BigUInt("9223372036854775805"))
XCTAssertEqual(BigUInt(Int64.max) - 1, BigUInt("9223372036854775806"))
XCTAssertEqual(BigUInt(Int64.max) + 0, BigUInt("9223372036854775807"))
XCTAssertEqual(BigUInt(Int64.max) + 1, BigUInt("9223372036854775808"))
XCTAssertEqual(BigUInt(Int64.max) + 2, BigUInt("9223372036854775809"))
XCTAssertEqual(+(BigUInt(1) << 1023) - 1, BigUInt(Self.descriptionInt1024Max))
}
func testRadicesAndNumerals() {
for radix in 2 ... 36 {
for uppercase in [false, true] {
for _ in 0 ..< 100 {
let expectedNumber = BigUInt(UInt.random(in: .min ... .max))
let expectedString = String(expectedNumber,
radix: radix,
uppercase: uppercase)
let actualNumber = BigUInt(expectedString, radix: radix)
XCTAssertEqual(actualNumber, expectedNumber)
if radix == 10 {
let actualString = expectedNumber.description
XCTAssertEqual(actualString, expectedString)
}
}
}
}
}
// MARK: - Converting from floating-point binary types
func testBinaryFloatingPoint<T>(_ type: T.Type) where T: BinaryFloatingPoint {
var expected = BigUInt(T.greatestFiniteMagnitude.significandBitPattern)
expected |= BigUInt(1) << T.significandBitCount
expected <<= T.greatestFiniteMagnitude.exponent
expected >>= T.significandBitCount
XCTAssertEqual(BigUInt(exactly: +T.greatestFiniteMagnitude), +expected)
XCTAssertEqual(BigUInt(+T.greatestFiniteMagnitude), +expected)
XCTAssertNil(BigUInt(exactly: +T.infinity))
XCTAssertNil(BigUInt(exactly: +T.leastNonzeroMagnitude))
XCTAssertEqual(BigUInt(+T.leastNonzeroMagnitude), 0)
XCTAssertNil(BigUInt(exactly: +T.leastNormalMagnitude))
XCTAssertEqual(BigUInt(+T.leastNormalMagnitude), 0)
XCTAssertNil(BigUInt(exactly: T.nan))
XCTAssertNil(BigUInt(exactly: T.signalingNaN))
XCTAssertNil(BigUInt(exactly: +T.pi))
XCTAssertEqual(BigUInt(+T.pi), +3)
XCTAssertNil(BigUInt(exactly: +T.ulpOfOne))
XCTAssertEqual(BigUInt(+T.ulpOfOne), 0)
XCTAssertEqual(BigUInt(exactly: +T.zero), 0)
XCTAssertEqual(BigUInt(+T.zero), 0)
}
func testBinaryFloatingPoint() {
testBinaryFloatingPoint(Float32.self)
testBinaryFloatingPoint(Float64.self)
#if (arch(i386) || arch(x86_64)) && !os(Windows) && !os(Android)
testBinaryFloatingPoint(Float80.self)
#endif
for _ in 0 ..< 100 {
let small = Float32.random(in: 0 ... +10)
XCTAssertEqual(BigUInt(small), BigUInt(Int64(small)))
let large = Float32.random(in: 0 ... +0x1p23)
XCTAssertEqual(BigUInt(large), BigUInt(Int64(large)))
}
for _ in 0 ..< 100 {
let small = Float64.random(in: 0 ... +10)
XCTAssertEqual(BigUInt(small), BigUInt(Int64(small)))
let large = Float64.random(in: -0x1p52 ... +0x1p52)
XCTAssertEqual(BigInt(large), BigInt(Int64(large)))
}
#if (arch(i386) || arch(x86_64)) && !os(Windows) && !os(Android)
for _ in 0 ..< 100 {
let small = Float80.random(in: 0 ... +10)
XCTAssertEqual(BigUInt(small), BigUInt(Int64(small)))
let large = Float80.random(in: 0 ..< +0x1p63)
XCTAssertEqual(BigUInt(large), BigUInt(Int64(large)))
}
#endif
}
}
-2
View File
@@ -12,14 +12,12 @@ find_package(Foundation CONFIG QUIET)
find_package(XCTest CONFIG QUIET)
add_subdirectory(ComplexTests)
add_subdirectory(IntegerUtilitiesTests)
add_subdirectory(RealTests)
add_executable(SwiftNumericsTestRunner
WindowsMain.swift)
target_link_libraries(SwiftNumericsTestRunner PRIVATE
ComplexTests
IntegerUtilitiesTests
RealTests)
add_test(NAME SwiftNumericsTestRunner
+1
View File
@@ -10,6 +10,7 @@ See https://swift.org/LICENSE.txt for license information
add_library(ComplexTests
ApproximateEqualityTests.swift
ArithmeticTests.swift
DifferentiableTests.swift
ElementaryFunctionTests.swift
PropertyTests.swift)
set_target_properties(ComplexTests PROPERTIES
@@ -0,0 +1,74 @@
//===--- DifferentiableTests.swift ----------------------------*- swift -*-===//
//
// This source file is part of the Swift Numerics open source project
//
// 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
//
//===----------------------------------------------------------------------===//
#if swift(>=5.3) && canImport(_Differentiation)
import XCTest
import ComplexModule
import _Differentiation
final class DifferentiableTests: XCTestCase {
func testComponentGetter() {
XCTAssertEqual(
gradient(at: Complex<Float>(5, 5)) { $0.real * 2 },
Complex(2, 0))
XCTAssertEqual(
gradient(at: Complex<Float>(5, 5)) { $0.imaginary * 2 },
Complex(0, 2))
XCTAssertEqual(
gradient(at: Complex<Float>(5, 5)) { $0.real * 5 + $0.imaginary * 2 },
Complex(5, 2))
}
func testInitializer() {
let φ1 = pullback(at: 4, -3) { r, i in Complex<Float>(r, i) }
let tan1 = φ1(Complex(-1, 2))
XCTAssertEqual(tan1.0, -1)
XCTAssertEqual(tan1.1, 2)
let φ2 = pullback(at: 4, -3) { r, i in Complex<Float>(r * r, i + i) }
let tan2 = φ2(Complex(-1, 1))
XCTAssertEqual(tan2.0, -8)
XCTAssertEqual(tan2.1, 2)
}
func testConjugate() {
let φ = pullback(at: Complex<Float>(20, -4)) { x in x.conjugate }
XCTAssertEqual(φ(Complex(1, 0)), Complex(1, 0))
XCTAssertEqual(φ(Complex(0, 1)), Complex(0, -1))
XCTAssertEqual(φ(Complex(-1, 1)), Complex(-1, -1))
}
func testArithmetics() {
let φAdd = pullback(at: Complex<Float>(2, 3)) { x in
x + Complex(5, 6)
}
XCTAssertEqual(φAdd(Complex(1, 1)), Complex(1, 1))
let φSubtract = pullback(at: Complex<Float>(2, 3)) { x in
Complex(5, 6) - x
}
XCTAssertEqual(φSubtract(Complex(1, 1)), Complex(-1, -1))
let φMultiply = pullback(at: Complex<Float>(2, 3)) { x in x * x }
XCTAssertEqual(φMultiply(Complex(1, 0)), Complex(4, 6))
XCTAssertEqual(φMultiply(Complex(0, 1)), Complex(-6, 4))
XCTAssertEqual(φMultiply(Complex(1, 1)), Complex(-2, 10))
let φDivide = pullback(at: Complex<Float>(20, -4)) { x in
x / Complex(2, 2)
}
XCTAssertEqual(φDivide(Complex(1, 0)), Complex(0.25, -0.25))
XCTAssertEqual(φDivide(Complex(0, 1)), Complex(0.25, 0.25))
}
}
#endif
@@ -400,18 +400,6 @@ final class ElementaryFunctionTests: XCTestCase {
}
}
func testPowR<T: Real & FixedWidthFloatingPoint>(_ type: T.Type) {
XCTAssertEqual(Complex<T>.pow(.zero, -.one), .infinity)
XCTAssertEqual(Complex<T>.pow(.zero, .zero), .infinity)
XCTAssertEqual(Complex<T>.pow(.zero, +.one), .zero)
}
func testPowN<T: Real & FixedWidthFloatingPoint>(_ type: T.Type) {
XCTAssertEqual(Complex<T>.pow(.zero, -1), .infinity)
XCTAssertEqual(Complex<T>.pow(.zero, 0), .one)
XCTAssertEqual(Complex<T>.pow(.zero, +1), .zero)
}
func testFloat() {
testExp(Float.self)
testExpMinusOne(Float.self)
@@ -423,8 +411,6 @@ final class ElementaryFunctionTests: XCTestCase {
testAcosh(Float.self)
testAsinh(Float.self)
testAtanh(Float.self)
testPowR(Float.self)
testPowN(Float.self)
}
func testDouble() {
@@ -438,11 +424,9 @@ final class ElementaryFunctionTests: XCTestCase {
testAcosh(Double.self)
testAsinh(Double.self)
testAtanh(Double.self)
testPowR(Double.self)
testPowN(Double.self)
}
#if (arch(i386) || arch(x86_64)) && !os(Windows) && !os(Android)
#if (arch(i386) || arch(x86_64)) && !os(Windows) && !os(Android)
func testFloat80() {
testExp(Float80.self)
testExpMinusOne(Float80.self)
@@ -454,8 +438,6 @@ final class ElementaryFunctionTests: XCTestCase {
testAcosh(Float80.self)
testAsinh(Float80.self)
testAtanh(Float80.self)
testPowR(Float80.self)
testPowN(Float80.self)
}
#endif
#endif
}
@@ -1,23 +0,0 @@
#[[
This source file is part of the Swift Numerics open source project
Copyright (c) 2019-2021 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
#]]
add_library(IntegerUtilitiesTests
DivideTests.swift
DoubleWidthTests.swift
GCDTests.swift
RotateTests.swift
SaturatingArithmeticTests.swift
ShiftTests.swift)
target_compile_options(IntegerUtilitiesTests PRIVATE
-enable-testing)
target_link_libraries(IntegerUtilitiesTests PUBLIC
$<$<NOT:$<PLATFORM_ID:Darwin>>:Foundation>
Numerics
_TestSupport
XCTest)
@@ -1,354 +0,0 @@
//===--- DivideTests.swift ------------------------------------*- swift -*-===//
//
// This source file is part of the Swift.org open source project
//
// Copyright (c) 2021 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 IntegerUtilities
import XCTest
final class IntegerUtilitiesDivideTests: XCTestCase {
func divisionRuleHolds<T: BinaryInteger>(_ a: T, _ b: T, _ q: T, _ r: T) -> Bool {
// Validate division rule holds: a = qb + r (have to be careful about
// computing qb, though, to ensure it does not overflow due to
// rounding of q; compute it in two pieces, subtracting the first from
// a to avoid intermediate overflow).
let b1 = b >> 1
let b2 = b - b1
let ref = a - q*b1 - q*b2
if r != ref {
XCTFail("""
\(a).divided(by: \(b), rounding: .down) failed the division rule.
a - qb was \(ref), but r is \(r).
""")
return false
}
if r.magnitude >= b.magnitude {
XCTFail("""
\(a).divided(by: \(b), rounding: .down) failed check on r.
|remainder| must be smaller than |divisor|, but was \(r).
""")
return false
}
return true
}
func testDivideDown<T: SignedInteger & FixedWidthInteger>(_ values: [T]) {
for a in values {
for b in values where b != 0 {
// Skip any SignedInt.min / -1 cases, because those will trap.
if a == .min && b == -1 { continue }
let (q, r) = a.divided(by: b, rounding: .down)
if divisionRuleHolds(a, b, q, r) {
// We know a = bq + r with |r| < |b|. Now validate sign(r) == sign(b).
guard r == 0 || r.signum() == b.signum() else {
XCTFail("""
\(a).divided(by: \(b), rounding: .down) failed check on r.
remainder must match sign of divisor, but was \(r).
""")
return
}
}
}
}
}
func testDivideUp<T: SignedInteger & FixedWidthInteger>(_ values: [T]) {
for a in values {
for b in values where b != 0 {
// Skip any SignedInt.min / -1 cases, because those will trap.
if a == .min && b == -1 { continue }
let (q, r) = a.divided(by: b, rounding: .up)
if divisionRuleHolds(a, b, q, r) {
// We know a = bq + r with |r| < |b|. Now validate sign(r) != sign(b).
guard r == 0 || r.signum() != b.signum() else {
XCTFail("""
\(a).divided(by: \(b), rounding: .up) failed check on r.
remainder must oppose sign of divisor, but was \(r).
""")
return
}
}
}
}
}
func testDivideTowardZero<T: SignedInteger & FixedWidthInteger>(_ values: [T]) {
for a in values {
for b in values where b != 0 {
// Skip any SignedInt.min / -1 cases, because those will trap.
if a == .min && b == -1 { continue }
let (q, r) = a.divided(by: b, rounding: .towardZero)
if divisionRuleHolds(a, b, q, r) {
// We know a = bq + r with |r| < |b|. Now validate sign(r) == sign(a).
guard r == 0 || r.signum() == a.signum() else {
XCTFail("""
\(a).divided(by: \(b), rounding: .towardZero) failed check on r.
remainder must match sign of dividend, but was \(r).
""")
return
}
}
}
}
}
func testDivideAwayFromZero<T: SignedInteger & FixedWidthInteger>(_ values: [T]) {
for a in values {
for b in values where b != 0 {
// Skip any SignedInt.min / -1 cases, because those will trap.
if a == .min && b == -1 { continue }
let (q, r) = a.divided(by: b, rounding: .awayFromZero)
if divisionRuleHolds(a, b, q, r) {
// We know a = bq + r with |r| < |b|. Now validate sign(r) != sign(a).
guard r == 0 || r.signum() != a.signum() else {
XCTFail("""
\(a).divided(by: \(b), rounding: .awayFromZero) failed check on r.
remainder must oppose sign of dividend, but was \(r).
""")
return
}
}
}
}
}
func testDivideToOdd<T: SignedInteger & FixedWidthInteger>(_ values: [T]) {
for a in values {
for b in values where b != 0 {
// Skip any SignedInt.min / -1 cases, because those will trap.
if a == .min && b == -1 { continue }
let (q, r) = a.divided(by: b, rounding: .toOdd)
if divisionRuleHolds(a, b, q, r) {
// We know a = bq + r with |r| < |b|. Now validate q is odd if r is
// non-zero.
guard r == 0 || q & 1 == 1 else {
XCTFail("""
\(a).divided(by: \(b), rounding: .toOdd) failed check:
quotient must be odd if remainder is non-zero, but quotient was \(q) and remainder was \(r).
""")
return
}
}
}
}
}
func testDivideToNearestOrAway<T: SignedInteger & FixedWidthInteger>(_ values: [T]) {
for a in values {
for b in values where b != 0 {
// Skip any SignedInt.min / -1 cases, because those will trap.
if a == .min && b == -1 { continue }
let (q, r) = a.divided(by: b, rounding: .toNearestOrAwayFromZero)
if divisionRuleHolds(a, b, q, r) {
// We know a = bq + r with |r| < |b|. Now check |r| <= |b|/2
// with equality only if sign(r) != sign(a).
if 2*r.magnitude > b.magnitude {
XCTFail("""
\(a).divided(by: \(b), rounding: .toNearestOrAwayFromZero) failed check:
|remainder| must be less than or equal to |divisor|/2, but remainder was \(r).
""")
return
}
if 2*r.magnitude == b.magnitude && r.signum() == a.signum() {
XCTFail("""
\(a).divided(by: \(b), rounding: .toNearestOrAwayFromZero) failed check:
If |remainder| equals |divisor|/2, remainder must oppose sign of dividend, but was \(r).
""")
return
}
}
}
}
}
func testDivideToNearestOrEven<T: SignedInteger & FixedWidthInteger>(_ values: [T]) {
for a in values {
for b in values where b != 0 {
// Skip any SignedInt.min / -1 cases, because those will trap.
if a == .min && b == -1 { continue }
let (q, r) = a.divided(by: b, rounding: .toNearestOrEven)
if divisionRuleHolds(a, b, q, r) {
// We know a = bq + r with |r| < |b|. Now check |r| <= |b|/2
// with equality only if sign(r) != sign(a).
if 2*r.magnitude > b.magnitude {
XCTFail("""
\(a).divided(by: \(b), rounding: .toNearestOrEven) failed check:
|remainder| must be less than or equal to |divisor|/2, but remainder was \(r).
""")
return
}
if 2*r.magnitude == b.magnitude && q & 1 == 1 {
XCTFail("""
\(a).divided(by: \(b), rounding: .toNearestOrEven) failed check:
If |remainder| equals |divisor|/2, quotient must be even, but quotient was \(q) and remainder was \(r).
""")
return
}
}
}
}
}
func testDivideStochastic<T: SignedInteger & FixedWidthInteger>(_ values: [T]) {
for a in values {
for b in values where b != 0 {
// Skip any SignedInt.min / -1 cases, because those will trap.
if a == .min && b == -1 { continue }
let (q, r) = a.divided(by: b, rounding: .stochastically)
let _ = divisionRuleHolds(a, b, q, r)
}
}
}
func testDivideExact<T: SignedInteger & FixedWidthInteger>(_ values: [T]) {
for a in values {
for b in values where b != 0 {
// Skip any SignedInt.min / -1 cases, because those will trap.
if a == .min && b == -1 { continue }
// Skip any cases with a remainder (most of them!)
if a % b != 0 { continue }
// Test that division rule holds ignoring r for the cases that
// make it through.
let (q, _) = a.divided(by: b, rounding: .requireExact)
let _ = divisionRuleHolds(a, b, q, 0)
}
}
}
func testDivideInt8() {
let values = Array<Int8>(-128 ... 127)
testDivideDown(values)
testDivideUp(values)
testDivideTowardZero(values)
testDivideAwayFromZero(values)
testDivideToOdd(values)
testDivideToNearestOrAway(values)
testDivideToNearestOrEven(values)
testDivideStochastic(values)
testDivideExact(values)
}
func testDivideInt() {
var values = [Int](repeating: 0, count: 64)
for i in 0 ..< values.count {
while values[i] == 0 {
values[i] = .random(in: .min ... .max)
}
}
testDivideDown(values)
testDivideUp(values)
testDivideTowardZero(values)
testDivideAwayFromZero(values)
testDivideToOdd(values)
testDivideToNearestOrAway(values)
testDivideToNearestOrEven(values)
testDivideStochastic(values)
testDivideExact(values)
}
func divideUInt8(_ a: UInt8, _ b: UInt8, rounding rule: RoundingRule) {
let expected = UInt8(Int16(a).divided(by: Int16(b), rounding: rule).quotient)
let observed = a.divided(by: b, rounding: rule)
guard expected == observed else {
XCTFail("""
\(a).divided(by: \(b), rounding: \(rule)) did not match expected result:
Computed with Int16: \(expected)
Computed with UInt8: \(observed)
""")
return
}
}
func testDivideUInt8() {
let values = Array<UInt8>(0 ... 255)
for a in values {
for b in values where b != 0 {
divideUInt8(a, b, rounding: .down)
divideUInt8(a, b, rounding: .up)
divideUInt8(a, b, rounding: .towardZero)
divideUInt8(a, b, rounding: .awayFromZero)
divideUInt8(a, b, rounding: .toOdd)
divideUInt8(a, b, rounding: .toNearestOrAwayFromZero)
divideUInt8(a, b, rounding: .toNearestOrEven)
}
}
}
// stochastically rounding doesn't have a deterministic "expected" answer,
// but we know that the result must be either the floor or the ceiling.
// The above tests ensure that, but that's not a very strong guarantee;
// an implementation could just implement it as self / other and pass
// that test.
//
// Here we round the _same_ value many times, compute the average, and
// check that it is acceptably close to the exact expected value; simple
// use of any deterministic rounding rule will not achieve this.
func testStochasticDivide<T: FixedWidthInteger>(_ a: T, _ b: T) -> Bool {
let sum = (0..<1024).reduce(into: 0.0) { sum, _ in
let rounded = a.divided(by: b, rounding: .stochastically)
sum += Double(rounded)
}
let expected = 1024 * Double(a) / Double(b)
let difference = abs(sum - expected)
// Waving my hands slightly instead of giving a precise explanation
// here, the expectation is that difference should be about
// 1/2 sqrt(1024). If we're more than a couple standard deviations
// off, we should flag that. This isn't _necessarily_ a problem,
// but if you see a repeated failure, that's almost surely a real bug.
//
// TODO: precise justification of thresholds
XCTAssertLessThanOrEqual(difference, 64,
"Accumulated error (\(difference)) was unexpectedly large in \(a).divided(by: \(b))"
)
return difference > 16
}
func testDivideStochasticInt8() {
var values = [Int8](repeating: 0, count: 32)
for i in 0 ..< values.count {
while values[i] == 0 {
values[i] = .random(in: .min ... .max)
}
}
var fails = 0
for a in values {
for b in values {
if a == .min && b == -1 { continue }
fails += testStochasticDivide(a, b) ? 1 : 0
}
}
XCTAssertLessThanOrEqual(fails, 32*16)
}
func testDivideStochasticUInt32() {
var values = [UInt32](repeating: 0, count: 32)
for i in 0 ..< values.count {
while values[i] == 0 {
values[i] = .random(in: .min ... .max)
}
}
var fails = 0
for a in values {
for b in values {
fails += testStochasticDivide(a, b) ? 1 : 0
}
}
XCTAssertLessThanOrEqual(fails, 32*16)
}
func testRemainderByMinusOne() {
// These would trap if implemented as a - bq or similar, even though
// the remainder is well-defined.
XCTAssertEqual(0, Int.min.remainder(dividingBy: -1))
XCTAssertEqual(0, Int.min.remainder(dividingBy: -1, rounding: .up))
XCTAssertEqual(0, Int.min.remainder(dividingBy: -1, rounding: .stochastically))
}
}
@@ -1,525 +0,0 @@
//===--- DoubleWidthTests.swift -------------------------------*- swift -*-===//
//
// This source file is part of the Swift Numerics open source project
//
// Copyright (c) 2017-2021 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 _TestSupport
import XCTest
final class DoubleWidthTests: XCTestCase {
typealias _Int16 = DoubleWidth<Int8>
typealias _Int128 = DoubleWidth<Int64>
typealias _Int256 = DoubleWidth<_Int128>
typealias _Int512 = DoubleWidth<_Int256>
typealias _Int1024 = DoubleWidth<_Int512>
typealias _UInt16 = DoubleWidth<UInt8>
typealias _UInt128 = DoubleWidth<UInt64>
typealias _UInt256 = DoubleWidth<_UInt128>
typealias _UInt512 = DoubleWidth<_UInt256>
typealias _UInt1024 = DoubleWidth<_UInt512>
// <https://bugs.swift.org/browse/SR-6947>
// Swift 4.x took over 15 minutes to compile this test code.
// Swift 5.5 takes less than one second (`-Onone` or `-O` or `-Osize`).
func testCompileTime_SR_6947() {
typealias _Int32 = DoubleWidth<DoubleWidth<Int8>>
typealias _Int64 = DoubleWidth<DoubleWidth<DoubleWidth<Int8>>>
var sum = 0
let (q, r) = (_Int128(Int64.max) * 16).quotientAndRemainder(dividingBy: 16)
sum += Int(q * r)
XCTAssertEqual(sum, 0)
let x = _Int64(Int64.max / 4)
let y = _Int32(Int32.max)
let xx = _Int1024(x)
let yy = _Int512(y)
let (q3, r3) = yy.dividingFullWidth((xx.high, xx.low))
sum -= Int(q3 - r3)
XCTAssertEqual(sum, -1)
}
func testLiterals() {
let w: _UInt16 = 100
XCTAssertTrue(w == 100 as Int)
let x: _UInt16 = 1000
XCTAssertTrue(x == 1000 as Int)
let y: _Int16 = 1000
XCTAssertTrue(y == 1000 as Int)
let z: _Int16 = -1000
XCTAssertTrue(z == -1000 as Int)
}
func testLiterals_Underflow() {
// TODO: expectCrashLater()
// _ = -1 as _UInt16
}
#if false // TODO: _ExpressibleByBuiltinIntegerLiteral
func testLiterals_LargeSigned() {
let a: _Int256 =
0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff
let b: _Int256 =
-0x8000000000000000000000000000000000000000000000000000000000000000
XCTAssertEqual(a, _Int256.max)
XCTAssertEqual(b, _Int256.min)
}
func testLiterals_LargeSigned_Underflow() {
// TODO: expectCrashLater()
// _ = -0x8000000000000000000000000000000000000000000000000000000000000001
// as _Int256
}
func testLiterals_LargeSigned_Overflow() {
// TODO: expectCrashLater()
// _ = 0x8000000000000000000000000000000000000000000000000000000000000000
// as _Int256
}
func testLiterals_LargeUnsigned() {
let a: _UInt256 =
0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff
let b: _UInt256 = 0
XCTAssertEqual(a, _UInt256.max)
XCTAssertEqual(b, _UInt256.min)
}
func testLiterals_LargeUnsigned_Underflow() {
// TODO: expectCrashLater()
// _ = -1 as _UInt256
}
func testLiterals_LargeUnsigned_Overflow() {
// TODO: expectCrashLater()
// _ = 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff0
// as _UInt256
}
#endif // TODO: _ExpressibleByBuiltinIntegerLiteral
func testArithmetic_Unsigned() {
let x: _UInt16 = 1000
let y: _UInt16 = 1111
XCTAssertEqual(x + 1, 1001)
XCTAssertEqual(x + x, 2000)
XCTAssertEqual(x - (1 as _UInt16), 999)
XCTAssertEqual(x - x, 0)
XCTAssertEqual(y - x, 111)
XCTAssertEqual(x * 7, 7000)
XCTAssertEqual(y * 7, 7777)
XCTAssertEqual(x / 3, 333)
XCTAssertEqual(x / x, 1)
XCTAssertEqual(x / y, 0)
XCTAssertEqual(y / x, 1)
XCTAssertEqual(x % 3, 1)
XCTAssertEqual(x % y, x)
do {
let lhs = _UInt16((high: 0b0011_0000, low: 0))
let rhs = _UInt16((high: 0b0010_0000, low: 0))
XCTAssertEqual(lhs % rhs, 4096)
}
do {
let lhs = _UInt128((high: 0xa0c7d7165cf01386, low: 0xbf3f66a93056143f))
let rhs = _UInt128((high: 0x9ac3a19b1e7d6b83, low: 0x513929792d588736))
XCTAssertEqual(String(lhs % rhs), "7997221894243298914179865336050715913")
}
do {
let lhs = _UInt128((high: 0xea8a9116b7af33b7, low: 0x3d9d6779ddd22ca3))
let rhs = _UInt128((high: 0xc3673efc7f1f37cc, low: 0x312f661057d0ba94))
XCTAssertEqual(String(lhs % rhs), "52023287460685389410162512181093036559")
}
do {
let lhs = _UInt256("2369676578372158364766242369061213561181961479062237766620")!
let rhs = _UInt256("102797312405202436815976773795958969482")!
XCTAssertEqual(String(lhs / rhs), "23051931251193218442")
}
do {
let lhs = _UInt256("96467201117289166187766181030232879447148862859323917044548749804018359008044")!
let rhs = _UInt256("4646260627574879223760172113656436161581617773435991717024")!
XCTAssertEqual(String(lhs / rhs), "20762331011904583253")
}
XCTAssertTrue((0xff01 as _UInt16).multipliedFullWidth(by: 0x101) == (high: 256, low: 1))
}
func testArithmetic_Signed() {
let x: _Int16 = 1000
let y: _Int16 = -1111
XCTAssertEqual(x + 1, 1001)
XCTAssertEqual(x + x, 2000)
XCTAssertEqual(x - (1 as _Int16), 999)
XCTAssertEqual(x - x, 0)
XCTAssertEqual(0 - x, -1000)
XCTAssertEqual(x + y, -111)
XCTAssertEqual(x - y, 2111)
XCTAssertEqual(x * 7, 7000)
XCTAssertEqual(y * 7, -7777)
XCTAssertEqual(x * -7, -7000)
XCTAssertEqual(y * -7, 7777)
XCTAssertEqual(x / 3, 333)
XCTAssertEqual(x / -3, -333)
XCTAssertEqual(x / x, 1)
XCTAssertEqual(x / y, 0)
XCTAssertEqual(y / x, -1)
XCTAssertEqual(y / y, 1)
XCTAssertEqual(x % 3, 1)
XCTAssertEqual(x % -3, 1)
XCTAssertEqual(y % 3, -1)
XCTAssertEqual(y % -3, -1)
XCTAssertEqual(-y, 1111)
XCTAssertEqual(-x, -1000)
}
func testNested() {
do {
let x = _UInt1024.max
let (y, o) = x.addingReportingOverflow(1)
XCTAssertEqual(y, 0)
XCTAssertTrue(y == (0 as Int))
XCTAssertTrue(o)
}
do {
let x = _Int1024.max
let (y, o) = x.addingReportingOverflow(1)
XCTAssertEqual(y, _Int1024.min)
XCTAssertLessThan(y, 0)
XCTAssertTrue(y < (0 as Int))
XCTAssertTrue(y < (0 as UInt))
XCTAssertTrue(o)
}
XCTAssertFalse(_UInt1024.isSigned)
XCTAssertEqual(_UInt1024.bitWidth, 1024)
XCTAssertTrue(_Int1024.isSigned)
XCTAssertEqual(_Int1024.bitWidth, 1024)
XCTAssertTrue(
_UInt1024.max.words.elementsEqual(
repeatElement(UInt.max, count: 1024 / UInt.bitWidth)
)
)
}
func testInitialization() {
XCTAssertTrue(_UInt16(UInt16.max) == UInt16.max)
XCTAssertNil(_UInt16(exactly: UInt32.max))
XCTAssertEqual(_UInt16(truncatingIfNeeded: UInt64.max), _UInt16.max)
}
func testInitialization_Overflow() {
// TODO: expectCrashLater()
// _ = _UInt16(UInt32.max)
}
func testMagnitude() {
XCTAssertTrue(_UInt16.min.magnitude == UInt16.min.magnitude)
XCTAssertTrue((42 as _UInt16).magnitude == (42 as UInt16).magnitude)
XCTAssertTrue(_UInt16.max.magnitude == UInt16.max.magnitude)
XCTAssertTrue(_Int16.min.magnitude == Int16.min.magnitude)
XCTAssertTrue((-42 as _Int16).magnitude == (-42 as Int16).magnitude)
XCTAssertTrue(_Int16().magnitude == Int16(0).magnitude) // See SR-6602.
XCTAssertTrue((42 as _Int16).magnitude == (42 as Int16).magnitude)
XCTAssertTrue(_Int16.max.magnitude == Int16.max.magnitude)
}
func testTwoWords() {
typealias DW = DoubleWidth<Int>
XCTAssertEqual(-1 as DW, DW(truncatingIfNeeded: -1 as Int8))
XCTAssertNil(Int(exactly: DW(Int.min) - 1))
XCTAssertNil(Int(exactly: DW(Int.max) + 1))
XCTAssertTrue(DW(Int.min) - 1 < Int.min)
XCTAssertTrue(DW(Int.max) + 1 > Int.max)
}
func testBitwise_LeftAndRightShifts() {
typealias _UInt64 = DoubleWidth<DoubleWidth<DoubleWidth<UInt8>>>
typealias _Int64 = DoubleWidth<DoubleWidth<DoubleWidth<Int8>>>
func f<T: FixedWidthInteger, U: FixedWidthInteger>(_ x: T, type: U.Type) {
let y = U(x)
XCTAssertEqual(T.bitWidth, U.bitWidth)
for i in -(T.bitWidth + 1)...(T.bitWidth + 1) {
XCTAssertTrue(x << i == y << i)
XCTAssertTrue(x >> i == y >> i)
XCTAssertTrue(x &<< i == y &<< i)
XCTAssertTrue(x &>> i == y &>> i)
}
}
f(1 as UInt64, type: _UInt64.self)
f(~(~0 as UInt64 >> 1), type: _UInt64.self)
f(UInt64.max, type: _UInt64.self)
// 0b01010101_10100101_11110000_10100101_11110000_10100101_11110000_10100101
f(17340530535757639845 as UInt64, type: _UInt64.self)
f(1 as Int64, type: _Int64.self)
f(Int64.min, type: _Int64.self)
f(Int64.max, type: _Int64.self)
// 0b01010101_10100101_11110000_10100101_11110000_10100101_11110000_10100101
f(6171603459878809765 as Int64, type: _Int64.self)
}
func testRemainder_ByZero() {
func f(_ x: _Int1024, _ y: _Int1024) -> _Int1024 {
return x % y
}
// TODO: expectCrashLater()
// _ = f(42, 0)
}
func testRemainder_ByMinusOne() {
func f(_ x: _Int256, _ y: _Int256) -> _Int256 {
return x.remainderReportingOverflow(dividingBy: y).partialValue
}
XCTAssertEqual(f(.max, -1), 0)
XCTAssertEqual(f(.min, -1), 0)
}
func testDivision_ByZero() {
func f(_ x: _Int1024, _ y: _Int1024) -> _Int1024 {
return x / y
}
// TODO: expectCrashLater()
// _ = f(42, 0)
}
func testDivision_ByMinusOne() {
func f(_ x: _Int1024) -> _Int1024 {
return x / -1
}
// TODO: expectCrashLater()
// _ = f(_Int1024.min)
}
func testMultipleOf() {
func isMultipleTest<T: FixedWidthInteger>(type: T.Type) {
XCTAssertTrue(T.min.isMultiple(of: 2))
XCTAssertFalse(T.max.isMultiple(of: 10))
// Test that these do not crash.
XCTAssertTrue((0 as T).isMultiple(of: 0))
XCTAssertFalse((1 as T).isMultiple(of: 0))
XCTAssertTrue(T.min.isMultiple(of: 0 &- 1))
}
isMultipleTest(type: _Int128.self)
isMultipleTest(type: _UInt128.self)
}
func testMultiplication_ByMinusOne() {
func f(_ x: _Int1024) -> _Int1024 {
return x * -1
}
// TODO: expectCrashLater()
// _ = f(_Int1024.min)
}
func testConversions() {
XCTAssertTrue(_Int16(1 << 15 - 1) == Int(1 << 15 - 1))
XCTAssertTrue(_Int16(-1 << 15) == Int(-1 << 15))
XCTAssertTrue(_UInt16(1 << 16 - 1) == Int(1 << 16 - 1))
XCTAssertTrue(_UInt16(0) == Int(0))
XCTAssertTrue(_Int16(Double(1 << 15 - 1)) == Int(1 << 15 - 1))
XCTAssertTrue(_Int16(Double(-1 << 15)) == Int(-1 << 15))
XCTAssertTrue(_UInt16(Double(1 << 16 - 1)) == Int(1 << 16 - 1))
XCTAssertTrue(_UInt16(Double(0)) == Int(0))
XCTAssertTrue(_Int16(Double(1 << 15 - 1) + 0.9) == Int(1 << 15 - 1))
XCTAssertTrue(_Int16(Double(-1 << 15) - 0.9) == Int(-1 << 15))
XCTAssertTrue(_UInt16(Double(1 << 16 - 1) + 0.9) == Int(1 << 16 - 1))
XCTAssertTrue(_UInt16(Double(0) - 0.9) == Int(0))
XCTAssertEqual(_Int16(0.00001), 0)
XCTAssertEqual(_UInt16(0.00001), 0)
}
func testConversions_Exact() {
XCTAssertEqual(
_Int16(Double(1 << 15 - 1)),
_Int16(exactly: Double(1 << 15 - 1))
)
XCTAssertEqual(
_Int16(Double(-1 << 15)),
_Int16(exactly: Double(-1 << 15))
)
XCTAssertEqual(
_UInt16(Double(1 << 16 - 1)),
_UInt16(exactly: Double(1 << 16 - 1))
)
XCTAssertEqual(
_UInt16(Double(0)),
_UInt16(exactly: Double(0))
)
XCTAssertNil(_Int16(exactly: Double(1 << 15 - 1) + 0.9))
XCTAssertNil(_Int16(exactly: Double(-1 << 15) - 0.9))
XCTAssertNil(_UInt16(exactly: Double(1 << 16 - 1) + 0.9))
XCTAssertNil(_UInt16(exactly: Double(0) - 0.9))
XCTAssertNil(_Int16(exactly: Double(1 << 15)))
XCTAssertNil(_Int16(exactly: Double(-1 << 15) - 1))
XCTAssertNil(_UInt16(exactly: Double(1 << 16)))
XCTAssertNil(_UInt16(exactly: Double(-1)))
XCTAssertNil(_Int16(exactly: 0.00001))
XCTAssertNil(_UInt16(exactly: 0.00001))
XCTAssertNil(_UInt16(exactly: Double.nan))
XCTAssertNil(_UInt16(exactly: Float.nan))
XCTAssertNil(_UInt16(exactly: Double.infinity))
XCTAssertNil(_UInt16(exactly: Float.infinity))
}
func testConversions_SignedMax() {
// TODO: expectCrashLater()
// _ = _Int16(1 << 15)
}
func testConversions_SignedMin() {
// TODO: expectCrashLater()
// _ = _Int16(-1 << 15 - 1)
}
func testConversions_UnsignedMax() {
// TODO: expectCrashLater()
// _ = _UInt16(1 << 16)
}
func testConversions_UnsignedMin() {
// TODO: expectCrashLater()
// _ = _UInt16(-1)
}
func testConversions_ToAndFromString<Number: FixedWidthInteger>(
_ expectedNumber: Number,
_ expectedString: String,
radix: Int,
file: StaticString = #filePath,
line: UInt = #line
) {
let actualString = String(expectedNumber, radix: radix)
XCTAssertEqual(expectedString, actualString, file: file, line: line)
let actualNumber = Number(expectedString, radix: radix)
XCTAssertEqual(expectedNumber, actualNumber, file: file, line: line)
}
func testConversions_ToAndFromString_Binary() {
testConversions_ToAndFromString(
_Int128.max,
"""
111111111111111111111111111111111111111111111111111111111111111\
1111111111111111111111111111111111111111111111111111111111111111
""",
radix: 2
)
testConversions_ToAndFromString(
_Int128.min,
"""
-1000000000000000000000000000000000000000000000000000000000000000\
0000000000000000000000000000000000000000000000000000000000000000
""",
radix: 2
)
}
func testConversions_ToAndFromString_Decimal() {
testConversions_ToAndFromString(
_Int256.max,
"""
5789604461865809771178549250434395392663\
4992332820282019728792003956564819967
""",
radix: 10
)
testConversions_ToAndFromString(
_Int256.min,
"""
-5789604461865809771178549250434395392663\
4992332820282019728792003956564819968
""",
radix: 10
)
}
func testConversions_ToAndFromString_Hexadecimal() {
testConversions_ToAndFromString(
_Int512.max,
"""
7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff\
ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff
""",
radix: 16
)
testConversions_ToAndFromString(
_Int512.min,
"""
-8000000000000000000000000000000000000000000000000000000000000000\
0000000000000000000000000000000000000000000000000000000000000000
""",
radix: 16
)
}
func testWords() {
XCTAssertTrue(_Int16(0).words.elementsEqual([0]))
XCTAssertTrue(_Int16(1).words.elementsEqual([1]))
XCTAssertTrue(_Int16(-1).words.elementsEqual([UInt.max]))
XCTAssertTrue(_Int16(256).words.elementsEqual([256]))
XCTAssertTrue(_Int16(-256).words.elementsEqual([UInt.max - 255]))
XCTAssertTrue(_Int16.max.words.elementsEqual([32767]))
XCTAssertTrue(_Int16.min.words.elementsEqual([UInt.max - 32767]))
XCTAssertTrue(
(0 as _Int1024).words.elementsEqual(
repeatElement(0 as UInt, count: 1024 / UInt.bitWidth)
)
)
XCTAssertTrue(
(-1 as _Int1024).words.elementsEqual(
repeatElement(UInt.max, count: 1024 / UInt.bitWidth)
)
)
XCTAssertTrue(
(1 as _Int1024).words.elementsEqual(
[1] + Array(repeating: 0, count: 1024 / UInt.bitWidth - 1)
)
)
}
func testConditionalConformance() {
func checkSignedIntegerConformance<T: SignedInteger>(_: T) {}
func checkUnsignedIntegerConformance<T: UnsignedInteger>(_: T) {}
checkSignedIntegerConformance(0 as _Int128)
checkSignedIntegerConformance(0 as _Int1024)
checkUnsignedIntegerConformance(0 as _UInt128)
checkUnsignedIntegerConformance(0 as _UInt1024)
}
}
@@ -1,44 +0,0 @@
//===--- GCDTests.swift ---------------------------------------*- swift -*-===//
//
// This source file is part of the Swift.org open source project
//
// Copyright (c) 2021 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 IntegerUtilities
import XCTest
final class IntegerUtilitiesGCDTests: XCTestCase {
func testGCDInt() {
XCTAssertEqual(gcd(0, 0), 0)
XCTAssertEqual(gcd(0, 1), 1)
XCTAssertEqual(gcd(1, 0), 1)
XCTAssertEqual(gcd(0, -1), 1)
XCTAssertEqual(gcd(1, 1), 1)
XCTAssertEqual(gcd(1, 2), 1)
XCTAssertEqual(gcd(2, 2), 2)
XCTAssertEqual(gcd(4, 2), 2)
XCTAssertEqual(gcd(6, 8), 2)
XCTAssertEqual(gcd(77, 91), 7)
XCTAssertEqual(gcd(24, -36), 12)
XCTAssertEqual(gcd(-24, -36), 12)
XCTAssertEqual(gcd(51, 34), 17)
XCTAssertEqual(gcd(64, 96), 32)
XCTAssertEqual(gcd(-64, 96), 32)
XCTAssertEqual(gcd(4*7*19, 27*25), 1)
XCTAssertEqual(gcd(16*315, 11*315), 315)
XCTAssertEqual(gcd(97*67*53*27*8, 83*67*53*9*32), 67*53*9*8)
XCTAssertEqual(gcd(Int.min, 2), 2)
// TODO: Enable these when version compatibility allows.
//
// XCTExpectFailure{ gcd(0, Int.min) }
// XCTExpectFailure{ gcd(Int.min, 0) }
// XCTExpectFailure{ gcd(Int.min, Int.min) }
}
}
@@ -1,74 +0,0 @@
//===--- RotateTests.swift ------------------------------------*- swift -*-===//
//
// This source file is part of the Swift.org open source project
//
// Copyright (c) 2021 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 IntegerUtilities
import XCTest
final class IntegerUtilitiesRotateTests: XCTestCase {
func testRotateUInt8() {
let x: UInt8 = 0b10011100
XCTAssertEqual(0b01001110, x.rotated(right:-7))
XCTAssertEqual(0b00100111, x.rotated(right:-6))
XCTAssertEqual(0b10010011, x.rotated(right:-5))
XCTAssertEqual(0b11001001, x.rotated(right:-4))
XCTAssertEqual(0b11100100, x.rotated(right:-3))
XCTAssertEqual(0b01110010, x.rotated(right:-2))
XCTAssertEqual(0b00111001, x.rotated(right:-1))
XCTAssertEqual(0b10011100, x.rotated(right: 0))
XCTAssertEqual(0b01001110, x.rotated(right: 1))
XCTAssertEqual(0b00100111, x.rotated(right: 2))
XCTAssertEqual(0b10010011, x.rotated(right: 3))
XCTAssertEqual(0b11001001, x.rotated(right: 4))
XCTAssertEqual(0b11100100, x.rotated(right: 5))
XCTAssertEqual(0b01110010, x.rotated(right: 6))
XCTAssertEqual(0b00111001, x.rotated(right: 7))
XCTAssertEqual(0b10011100, x.rotated(right: 8))
}
func testRotateInt16() {
let x = Int16(bitPattern: 0b1001110000111110)
XCTAssertEqual(Int16(bitPattern: 0b1001110000111110), x.rotated(left:-16))
XCTAssertEqual(Int16(bitPattern: 0b0011100001111101), x.rotated(left:-15))
XCTAssertEqual(Int16(bitPattern: 0b0111000011111010), x.rotated(left:-14))
XCTAssertEqual(Int16(bitPattern: 0b1110000111110100), x.rotated(left:-13))
XCTAssertEqual(Int16(bitPattern: 0b1100001111101001), x.rotated(left:-12))
XCTAssertEqual(Int16(bitPattern: 0b1000011111010011), x.rotated(left:-11))
XCTAssertEqual(Int16(bitPattern: 0b0000111110100111), x.rotated(left:-10))
XCTAssertEqual(Int16(bitPattern: 0b0001111101001110), x.rotated(left:-9))
XCTAssertEqual(Int16(bitPattern: 0b0011111010011100), x.rotated(left:-8))
XCTAssertEqual(Int16(bitPattern: 0b0111110100111000), x.rotated(left:-7))
XCTAssertEqual(Int16(bitPattern: 0b1111101001110000), x.rotated(left:-6))
XCTAssertEqual(Int16(bitPattern: 0b1111010011100001), x.rotated(left:-5))
XCTAssertEqual(Int16(bitPattern: 0b1110100111000011), x.rotated(left:-4))
XCTAssertEqual(Int16(bitPattern: 0b1101001110000111), x.rotated(left:-3))
XCTAssertEqual(Int16(bitPattern: 0b1010011100001111), x.rotated(left:-2))
XCTAssertEqual(Int16(bitPattern: 0b0100111000011111), x.rotated(left:-1))
XCTAssertEqual(Int16(bitPattern: 0b1001110000111110), x.rotated(left: 0))
XCTAssertEqual(Int16(bitPattern: 0b0011100001111101), x.rotated(left: 1))
XCTAssertEqual(Int16(bitPattern: 0b0111000011111010), x.rotated(left: 2))
XCTAssertEqual(Int16(bitPattern: 0b1110000111110100), x.rotated(left: 3))
XCTAssertEqual(Int16(bitPattern: 0b1100001111101001), x.rotated(left: 4))
XCTAssertEqual(Int16(bitPattern: 0b1000011111010011), x.rotated(left: 5))
XCTAssertEqual(Int16(bitPattern: 0b0000111110100111), x.rotated(left: 6))
XCTAssertEqual(Int16(bitPattern: 0b0001111101001110), x.rotated(left: 7))
XCTAssertEqual(Int16(bitPattern: 0b0011111010011100), x.rotated(left: 8))
XCTAssertEqual(Int16(bitPattern: 0b0111110100111000), x.rotated(left: 9))
XCTAssertEqual(Int16(bitPattern: 0b1111101001110000), x.rotated(left: 10))
XCTAssertEqual(Int16(bitPattern: 0b1111010011100001), x.rotated(left: 11))
XCTAssertEqual(Int16(bitPattern: 0b1110100111000011), x.rotated(left: 12))
XCTAssertEqual(Int16(bitPattern: 0b1101001110000111), x.rotated(left: 13))
XCTAssertEqual(Int16(bitPattern: 0b1010011100001111), x.rotated(left: 14))
XCTAssertEqual(Int16(bitPattern: 0b0100111000011111), x.rotated(left: 15))
XCTAssertEqual(Int16(bitPattern: 0b1001110000111110), x.rotated(left: 16))
}
}
@@ -1,192 +0,0 @@
//===--- SaturatingArithmeticTests.swift ----------------------*- swift -*-===//
//
// This source file is part of the Swift.org open source project
//
// Copyright (c) 2023 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 IntegerUtilities
import XCTest
import _TestSupport
final class IntegerUtilitiesSaturatingTests: XCTestCase {
func testSaturatingAddSigned() {
for a in Int8.min ... Int8.max {
for b in Int8.min ... Int8.max {
let expected = Int8(clamping: Int16(a) + Int16(b))
let observed = a.addingWithSaturation(b)
if expected != observed {
print("Error found in (\(a)).addingWithSaturation(\(b)).")
print("Expected: \(String(expected, radix: 16))")
print("Observed: \(String(observed, radix: 16))")
XCTFail()
return
}
}
}
}
func testSaturatingSubSigned() {
for a in Int8.min ... Int8.max {
for b in Int8.min ... Int8.max {
let expected = Int8(clamping: Int16(a) - Int16(b))
let observed = a.subtractingWithSaturation(b)
if expected != observed {
print("Error found in (\(a)).subtractingWithSaturation(\(b)).")
print("Expected: \(String(expected, radix: 16))")
print("Observed: \(String(observed, radix: 16))")
XCTFail()
return
}
}
}
}
func testSaturatingNegSigned() {
for a in Int8.min ... Int8.max {
let expected = Int8(clamping: 0 - Int16(a))
let observed = a.negatedWithSaturation()
if expected != observed {
print("Error found in (\(a)).negatedWithSaturation().")
print("Expected: \(String(expected, radix: 16))")
print("Observed: \(String(observed, radix: 16))")
XCTFail()
return
}
}
}
func testSaturatingMulSigned() {
for a in Int8.min ... Int8.max {
for b in Int8.min ... Int8.max {
let expected = Int8(clamping: Int16(a) * Int16(b))
let observed = a.multipliedWithSaturation(by: b)
if expected != observed {
print("Error found in (\(a)).multipliedWithSaturation(by: \(b)).")
print("Expected: \(String(expected, radix: 16))")
print("Observed: \(String(observed, radix: 16))")
XCTFail()
return
}
}
}
}
func testSaturatingAddUnsigned() {
for a in UInt8.min ... UInt8.max {
for b in UInt8.min ... UInt8.max {
let expected = UInt8(clamping: UInt16(a) + UInt16(b))
let observed = a.addingWithSaturation(b)
if expected != observed {
print("Error found in (\(a)).addingWithSaturation(\(b)).")
print("Expected: \(String(expected, radix: 16))")
print("Observed: \(String(observed, radix: 16))")
XCTFail()
return
}
}
}
}
func testSaturatingSubUnsigned() {
for a in UInt8.min ... UInt8.max {
for b in UInt8.min ... UInt8.max {
let expected = UInt8(clamping: Int16(a) - Int16(b))
let observed = a.subtractingWithSaturation(b)
if expected != observed {
print("Error found in (\(a)).subtractingWithSaturation(\(b)).")
print("Expected: \(String(expected, radix: 16))")
print("Observed: \(String(observed, radix: 16))")
XCTFail()
return
}
}
}
}
func testSaturatingNegUnsigned() {
for a in UInt8.min ... UInt8.max {
let observed = a.negatedWithSaturation()
if 0 != observed {
print("Error found in (\(a)).negatedWithSaturation().")
print("Expected: zero")
print("Observed: \(String(observed, radix: 16))")
XCTFail()
return
}
}
}
func testSaturatingMulUnsigned() {
for a in UInt8.min ... UInt8.max {
for b in UInt8.min ... UInt8.max {
let expected = UInt8(clamping: UInt16(a) * UInt16(b))
let observed = a.multipliedWithSaturation(by: b)
if expected != observed {
print("Error found in (\(a)).multipliedWithSaturation(by: \(b)).")
print("Expected: \(String(expected, radix: 16))")
print("Observed: \(String(observed, radix: 16))")
XCTFail()
}
}
}
}
func testSaturatingShift<T, C>(
_ value: T, _ count: C, rounding rule: RoundingRule
) where T: FixedWidthInteger, C: FixedWidthInteger {
let observed = value.shiftedWithSaturation(leftBy: count, rounding: rule)
var expected: T = 0
if count <= 0 {
expected = value.shifted(rightBy: -Int64(count), rounding: rule)
} else {
let multiplier: T = 1 << count
if multiplier <= 0 {
expected = value == 0 ? 0 :
value < 0 ? .min : .max
} else {
expected = value.multipliedWithSaturation(by: multiplier)
}
}
if observed != expected {
print("Error found in \(T.self).shiftedWithSaturation(leftBy: \(count), rounding: \(rule)).")
print(" Value: \(String(value, radix: 16))")
print("Expected: \(String(expected, radix: 16))")
print("Observed: \(String(observed, radix: 16))")
XCTFail()
return
}
}
func testSaturatingShift<T: FixedWidthInteger>(
_ type: T.Type, rounding rule: RoundingRule
) {
for count in Int8.min ... .max {
testSaturatingShift(0, count, rounding: rule)
for bits in 0 ..< T.bitWidth {
let msb: T.Magnitude = 1 << bits
let value = T(truncatingIfNeeded: msb) | .random(in: 0 ... T(msb-1))
testSaturatingShift(value, count, rounding: rule)
testSaturatingShift(0 &- value, count, rounding: rule)
}
}
}
func testSaturatingShifts() {
testSaturatingShift(Int8.self, rounding: .toOdd)
testSaturatingShift(UInt8.self, rounding: .toOdd)
testSaturatingShift(Int.self, rounding: .toOdd)
testSaturatingShift(UInt.self, rounding: .toOdd)
}
func testEdgeCaseForNegativeCount() {
XCTAssertEqual(1.shiftedWithSaturation(leftBy: Int.min), 0)
}
}
@@ -1,197 +0,0 @@
//===--- ShiftTests.swift -------------------------------------*- swift -*-===//
//
// This source file is part of the Swift.org open source project
//
// Copyright (c) 2021 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 IntegerUtilities
import XCTest
import _TestSupport
final class IntegerUtilitiesShiftTests: XCTestCase {
func testRoundingShift<T, C>(
_ value: T, _ count: C, rounding rule: RoundingRule
) where T: FixedWidthInteger, C: BinaryInteger {
let floor = value >> count
let lost = value &- floor << count
let exact = count <= 0 || lost == 0
let ceiling = exact ? floor : floor &+ 1
let expected: T
switch rule {
case .down:
expected = floor
case .up:
expected = ceiling
case .towardZero:
expected = value < 0 ? ceiling : floor
case .awayFromZero:
expected = value > 0 ? ceiling : floor
case .toOdd:
expected = floor | (exact ? 0 : 1)
case .toNearestOrAwayFromZero:
if exact { expected = floor }
else {
let step = value.shifted(rightBy: count - 2, rounding: .toOdd)
switch step & 0b11 {
case 0b01: expected = floor
case 0b10: expected = value > 0 ? ceiling : floor
case 0b11: expected = ceiling
default: preconditionFailure()
}
}
case .toNearestOrEven:
if exact { expected = floor }
else {
let step = value.shifted(rightBy: count - 2, rounding: .toOdd)
switch step & 0b11 {
case 0b01: expected = floor
case 0b10: expected = floor & 1 == 0 ? floor : ceiling
case 0b11: expected = ceiling
default: preconditionFailure()
}
}
case .stochastically:
// Just test that it's floor if exact, otherwise either floor
// or ceiling.
if exact { expected = floor }
else {
let observed = value.shifted(rightBy: count, rounding: rule)
if observed != floor && observed != ceiling {
print("Error found in \(T.self).shifted(rightBy: \(count), rounding: \(rule)).")
print(" Value: \(String(value, radix: 16))")
print("Expected: \(String(floor, radix: 16)) or \(String(ceiling, radix: 16))")
print("Observed: \(String(observed, radix: 16))")
XCTFail()
}
return
}
case .requireExact:
preconditionFailure()
}
let observed = value.shifted(rightBy: count, rounding: rule)
if observed != expected {
print("Error found in \(T.self).shifted(rightBy: \(count), rounding: \(rule)).")
print(" Value: \(String(value, radix: 16))")
print("Expected: \(String(expected, radix: 16))")
print("Observed: \(String(observed, radix: 16))")
XCTFail()
}
}
func testRoundingShift<T: FixedWidthInteger>(
_ type: T.Type, rounding rule: RoundingRule
) {
for count in -2*T.bitWidth ... 2*T.bitWidth {
// zero shifted by anything is always zero
XCTAssertEqual(0, (0 as T).shifted(rightBy: count, rounding: rule))
for _ in 0 ..< 100 {
testRoundingShift(T.random(in: .min ... .max), count, rounding: rule)
}
}
for count in Int8.min ... .max {
testRoundingShift(T.random(in: .min ... .max), count, rounding: rule)
}
}
func testRoundingShifts() {
testRoundingShift(Int8.self, rounding: .down)
testRoundingShift(Int8.self, rounding: .up)
testRoundingShift(Int8.self, rounding: .towardZero)
testRoundingShift(Int8.self, rounding: .awayFromZero)
testRoundingShift(Int8.self, rounding: .toOdd)
testRoundingShift(Int8.self, rounding: .toNearestOrAwayFromZero)
testRoundingShift(Int8.self, rounding: .toNearestOrEven)
testRoundingShift(Int8.self, rounding: .stochastically)
testRoundingShift(UInt8.self, rounding: .down)
testRoundingShift(UInt8.self, rounding: .up)
testRoundingShift(UInt8.self, rounding: .towardZero)
testRoundingShift(UInt8.self, rounding: .awayFromZero)
testRoundingShift(UInt8.self, rounding: .toOdd)
testRoundingShift(UInt8.self, rounding: .toNearestOrAwayFromZero)
testRoundingShift(UInt8.self, rounding: .toNearestOrEven)
testRoundingShift(UInt8.self, rounding: .stochastically)
testRoundingShift(Int.self, rounding: .down)
testRoundingShift(Int.self, rounding: .up)
testRoundingShift(Int.self, rounding: .towardZero)
testRoundingShift(Int.self, rounding: .awayFromZero)
testRoundingShift(Int.self, rounding: .toOdd)
testRoundingShift(Int.self, rounding: .toNearestOrAwayFromZero)
testRoundingShift(Int.self, rounding: .toNearestOrEven)
testRoundingShift(Int.self, rounding: .stochastically)
testRoundingShift(UInt.self, rounding: .down)
testRoundingShift(UInt.self, rounding: .up)
testRoundingShift(UInt.self, rounding: .towardZero)
testRoundingShift(UInt.self, rounding: .awayFromZero)
testRoundingShift(UInt.self, rounding: .toOdd)
testRoundingShift(UInt.self, rounding: .toNearestOrAwayFromZero)
testRoundingShift(UInt.self, rounding: .toNearestOrEven)
testRoundingShift(UInt.self, rounding: .stochastically)
}
// Stochastic rounding doesn't have a deterministic "expected" answer,
// but we know that the result must be either the floor or the ceiling.
// The above tests ensure that, but that's not a very strong guarantee;
// an implementation could just implement it as self >> count and pass
// that test.
//
// Here we round the _same_ value many times, compute the average, and
// check that it is acceptably close to the exact expected value; simple
// use of any deterministic rounding rule will not achieve this.
func testStochasticAverage<T: FixedWidthInteger>(_ value: T) {
var fails = 0
for count in 1 ... T.bitWidth {
let sum = (0..<256).reduce(into: DoubleWidth<T>.zero) { sum, _ in
let rounded = value.shifted(rightBy: count, rounding: .stochastically)
sum += DoubleWidth(rounded)
}
let expected = DoubleWidth<T>(value) << (8 - count)
let difference = sum >= expected ? sum - expected : expected - sum
// Waving my hands slightly instead of giving a precise explanation
// here, the expectation is that difference should be about
// 1/2 sqrt(256). If it's repeatedly bigger than that, we _may_
// have a problem, but it's OK for this to fail occasionally.
//
// TODO: precise justification of thresholds
if difference > 8 { fails += 1 }
// On the other hand, if we're more than a couple standard deviations
// off, we should flag that. This still isn't _necessarily_ a problem,
// but if you see a repeated failure for a given shift count, that's
// almost surely a real bug.
XCTAssertLessThanOrEqual(difference, 32,
"Accumulated error (\(difference)) was unexpectedly large in \(value).shifted(rightBy: \(count))"
)
}
// Threshold chosen so that this is expected to _usually_ pass, but
// it will fail sporadically even with a correct implementation. This is
// not a great fit for CI workflows, sorry. Basically ignore one-off
// failures, but a repeated failure here is an indication that a bug
// exists.
XCTAssertLessThanOrEqual(fails, T.bitWidth/2,
"Accumulated error was large more often than expected for \(value).shifted(rightBy:)"
)
}
func testStochasticShifts() {
testStochasticAverage(Int8.random(in: .min ... .max))
testStochasticAverage(Int16.random(in: .min ... .max))
testStochasticAverage(Int32.random(in: .min ... .max))
testStochasticAverage(UInt8.random(in: .min ... .max))
testStochasticAverage(UInt16.random(in: .min ... .max))
testStochasticAverage(UInt32.random(in: .min ... .max))
testStochasticAverage(Int64.random(in: .min ... .max))
testStochasticAverage(UInt64.random(in: .min ... .max))
testStochasticAverage(DoubleWidth<Int64>.random(in: .min ... .max))
testStochasticAverage(DoubleWidth<UInt64>.random(in: .min ... .max))
}
}
@@ -1,160 +0,0 @@
//===--- AugmentedArithmeticTests.swift -----------------------*- swift -*-===//
//
// This source file is part of the Swift.org open source project
//
// Copyright (c) 2021 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 RealModule
import XCTest
import _TestSupport
final class AugmentedArithmeticTests: XCTestCase {
func testTwoSumSpecials<T: Real & FixedWidthFloatingPoint>(_: T.Type) {
// Must be exact and not overflow on outer bounds
var x = T.greatestFiniteMagnitude
var y = -T.greatestFiniteMagnitude
XCTAssertEqual(Augmented.sum(x, y).head, .zero)
XCTAssertEqual(Augmented.sum(x, y).tail, .zero)
XCTAssert(Augmented.sum(x, y).head.isFinite)
XCTAssert(Augmented.sum(x, y).tail.isFinite)
// Must be exact on lower subnormal bounds
x = T.leastNonzeroMagnitude
y = -T.leastNonzeroMagnitude
XCTAssertEqual(Augmented.sum(x, y).head, .zero)
XCTAssertEqual(Augmented.sum(x, y).tail, .zero)
// Must preserve floating point signs for:
// (1) (+0) + (-0) == +0
// (2) (-0) + (+0) == +0
// (3) (-0) + (-0) == -0
x = T(sign: .plus, exponent: 1, significand: 0)
y = T(sign: .minus, exponent: 1, significand: 0)
XCTAssertEqual(Augmented.sum(x, y).head.sign, .plus) // (1)
XCTAssertEqual(Augmented.sum(x, y).tail.sign, .plus)
x = T(sign: .minus, exponent: 1, significand: 0)
y = T(sign: .plus, exponent: 1, significand: 0)
XCTAssertEqual(Augmented.sum(x, y).head.sign, .plus) // (2)
XCTAssertEqual(Augmented.sum(x, y).tail.sign, .plus)
x = T(sign: .minus, exponent: 1, significand: 0)
y = T(sign: .minus, exponent: 1, significand: 0)
XCTAssertEqual(Augmented.sum(x, y).head.sign, .minus) // (3)
XCTAssertEqual(Augmented.sum(x, y).tail.sign, .plus)
// Infinity and NaN are propagated correctly
XCTAssertEqual(Augmented.sum( 0, T.infinity).head, T.infinity)
XCTAssertEqual(Augmented.sum( T.infinity, 0 ).head, T.infinity)
XCTAssertEqual(Augmented.sum( T.infinity, T.infinity).head, T.infinity)
XCTAssertEqual(Augmented.sum( 0, -T.infinity).head, -T.infinity)
XCTAssertEqual(Augmented.sum(-T.infinity, 0 ).head, -T.infinity)
XCTAssertEqual(Augmented.sum(-T.infinity, -T.infinity).head, -T.infinity)
XCTAssert(Augmented.sum( T.infinity, -T.infinity).head.isNaN)
XCTAssert(Augmented.sum(-T.infinity, T.infinity).head.isNaN)
XCTAssert(Augmented.sum( T.infinity, T.nan).head.isNaN)
XCTAssert(Augmented.sum( T.nan, T.infinity).head.isNaN)
XCTAssert(Augmented.sum(-T.infinity, T.nan).head.isNaN)
XCTAssert(Augmented.sum( T.nan, -T.infinity).head.isNaN)
XCTAssert(Augmented.sum( 0, T.nan).head.isNaN)
XCTAssert(Augmented.sum(T.nan, 0).head.isNaN)
XCTAssert(Augmented.sum(T.nan, T.nan).head.isNaN)
}
func testTwoSumRandomValues<T: Real & FixedWidthFloatingPoint>(_: T.Type) {
// For randomly-chosen well-scaled finite values, we expect:
// (1) `head` to be exactly the IEEE 754 sum of `a + b`
// (2) `tail` to be less than or equal `head.ulp/2`
// (3) the result of `twoSum` for unordered input to be exactly equal to
// the result of `fastTwoSum` for ordered input.
var g = SystemRandomNumberGenerator()
let values: [T] = (0 ..< 100).map { _ in
T.random(
in: T.ulpOfOne ..< 1,
using: &g)
}
for a in values {
for b in values {
let twoSum = Augmented.sum(a, b)
XCTAssertEqual(twoSum.head, a + b) // (1)
XCTAssert(twoSum.tail.magnitude <= twoSum.head.ulp/2) // (2)
let x: T = a.magnitude < b.magnitude ? b : a
let y: T = a.magnitude < b.magnitude ? a : b
let fastTwoSum = Augmented.sum(large: x, small: y)
XCTAssertEqual(twoSum.head, fastTwoSum.head) // (3)
XCTAssertEqual(twoSum.tail, fastTwoSum.tail) // (3)
}
}
}
func testTwoSumCancellation<T: Real & FixedWidthFloatingPoint>(_: T.Type) {
// Must be exact for exactly representable values
XCTAssertEqual(Augmented.sum( 0.984375, 1.375).head, 2.359375)
XCTAssertEqual(Augmented.sum( 0.984375, 1.375).tail, 0.0)
XCTAssertEqual(Augmented.sum(-0.984375, 1.375).head, 0.390625)
XCTAssertEqual(Augmented.sum(-0.984375, 1.375).tail, 0.0)
XCTAssertEqual(Augmented.sum( 0.984375,-1.375).head,-0.390625)
XCTAssertEqual(Augmented.sum( 0.984375,-1.375).tail, 0.0)
XCTAssertEqual(Augmented.sum(-0.984375,-1.375).head,-2.359375)
XCTAssertEqual(Augmented.sum(-0.984375,-1.375).tail, 0.0)
XCTAssertEqual(Augmented.sum( 1.375, 0.984375).head, 2.359375)
XCTAssertEqual(Augmented.sum( 1.375, 0.984375).tail, 0.0)
XCTAssertEqual(Augmented.sum( 1.375,-0.984375).head, 0.390625)
XCTAssertEqual(Augmented.sum( 1.375,-0.984375).tail, 0.0)
XCTAssertEqual(Augmented.sum(-1.375, 0.984375).head,-0.390625)
XCTAssertEqual(Augmented.sum(-1.375, 0.984375).tail, 0.0)
XCTAssertEqual(Augmented.sum(-1.375,-0.984375).head,-2.359375)
XCTAssertEqual(Augmented.sum(-1.375,-0.984375).tail, 0.0)
// Must handle cancellation when `b` is not representable in `a` and
// we expect `b` to be lost entirely in the calculation of `a + b`.
var a: T = 1.0
var b: T = .ulpOfOne * .ulpOfOne
var twoSum = Augmented.sum(a, b)
XCTAssertEqual(twoSum.head, a) // a + b = a
XCTAssertEqual(twoSum.tail, b) // Error: b
twoSum = Augmented.sum( a, -b)
XCTAssertEqual(twoSum.head, a)
XCTAssertEqual(twoSum.tail,-b)
twoSum = Augmented.sum(-a, b)
XCTAssertEqual(twoSum.head,-a)
XCTAssertEqual(twoSum.tail, b)
twoSum = Augmented.sum(-a, -b)
XCTAssertEqual(twoSum.head,-a)
XCTAssertEqual(twoSum.tail,-b)
// Must handle cancellation when `b` is only partially representable in `a`.
// We expect the fractional digits of `b` to be cancelled in the following
// example but the fractional digits to be preserved in `tail`.
let exponent = T.Exponent(T.significandBitCount + 1)
a = T(sign: .plus, exponent: exponent, significand: 1.0)
b = 256 + 0.5
twoSum = Augmented.sum( a, b)
XCTAssertEqual(twoSum.head, a + 256)
XCTAssertEqual(twoSum.tail, 0.5)
twoSum = Augmented.sum( a, -b)
XCTAssertEqual(twoSum.head, a - 256)
XCTAssertEqual(twoSum.tail, -0.5)
twoSum = Augmented.sum(-a, b)
XCTAssertEqual(twoSum.head, -a + 256)
XCTAssertEqual(twoSum.tail, 0.5)
twoSum = Augmented.sum(-a, -b)
XCTAssertEqual(twoSum.head, -a - 256)
XCTAssertEqual(twoSum.tail, -0.5)
}
func testTwoSum() {
testTwoSumSpecials(Float32.self)
testTwoSumRandomValues(Float32.self)
testTwoSumCancellation(Float32.self)
testTwoSumSpecials(Float64.self)
testTwoSumRandomValues(Float64.self)
testTwoSumCancellation(Float64.self)
#if (arch(i386) || arch(x86_64)) && !os(Windows) && !os(Android)
testTwoSumSpecials(Float80.self)
testTwoSumRandomValues(Float80.self)
testTwoSumCancellation(Float80.self)
#endif
}
}
+1 -3
View File
@@ -9,10 +9,8 @@ See https://swift.org/LICENSE.txt for license information
add_library(RealTests
ApproximateEqualityTests.swift
AugmentedArithmeticTests.swift
ElementaryFunctionChecks.swift
IntegerExponentTests.swift
RelaxedArithmeticTests.swift)
IntegerExponentTests.swift)
target_compile_options(RealTests PRIVATE
-enable-testing)
target_link_libraries(RealTests PUBLIC
@@ -120,11 +120,11 @@ internal extension Real where Self: BinaryFloatingPoint {
assertClose(0.4041169094348222983238250859191217675, Self.erf(0.375))
assertClose(0.5958830905651777016761749140808782324, Self.erfc(0.375))
assertClose(2.3704361844166009086464735041766525098, Self.gamma(0.375))
#if !os(Windows)
#if !os(Windows)
assertClose( -0.11775527074107877445136203331798850, Self.logGamma(1.375))
XCTAssertEqual(.plus, Self.signGamma(1.375))
XCTAssertEqual(.minus, Self.signGamma(-2.375))
#endif
#endif
}
}
@@ -146,7 +146,7 @@ extension Real {
final class ElementaryFunctionChecks: XCTestCase {
#if !((os(macOS) || targetEnvironment(macCatalyst)) && arch(x86_64))
#if swift(>=5.4) && !((os(macOS) || targetEnvironment(macCatalyst)) && arch(x86_64))
func testFloat16() {
if #available(macOS 11.0, iOS 14.0, watchOS 14.0, tvOS 7.0, *) {
Float16.elementaryFunctionChecks()
@@ -154,7 +154,7 @@ final class ElementaryFunctionChecks: XCTestCase {
Float16.powZeroChecks()
}
}
#endif
#endif
func testFloat() {
Float.elementaryFunctionChecks()
@@ -168,11 +168,11 @@ final class ElementaryFunctionChecks: XCTestCase {
Double.powZeroChecks()
}
#if (arch(i386) || arch(x86_64)) && !os(Windows) && !os(Android)
#if (arch(i386) || arch(x86_64)) && !os(Windows) && !os(Android)
func testFloat80() {
Float80.elementaryFunctionChecks()
Float80.realFunctionChecks()
Float80.powZeroChecks()
}
#endif
#endif
}
+2 -2
View File
@@ -77,7 +77,7 @@ internal extension Real where Self: FixedWidthFloatingPoint {
}
}
#if !((os(macOS) || targetEnvironment(macCatalyst)) && arch(x86_64))
#if swift(>=5.4) && !((os(macOS) || targetEnvironment(macCatalyst)) && arch(x86_64))
@available(macOS 11.0, iOS 14.0, watchOS 14.0, tvOS 7.0, *)
extension Float16 {
static func testIntegerExponent() {
@@ -174,7 +174,7 @@ extension Double {
final class IntegerExponentTests: XCTestCase {
#if !((os(macOS) || targetEnvironment(macCatalyst)) && arch(x86_64))
#if swift(>=5.4) && !((os(macOS) || targetEnvironment(macCatalyst)) && arch(x86_64))
func testFloat16() {
if #available(macOS 11.0, iOS 14.0, watchOS 14.0, tvOS 7.0, *) {
Float16.testIntegerExponent()
@@ -1,129 +0,0 @@
//===--- RelaxedArithmeticTests.swift -------------------------*- swift -*-===//
//
// This source file is part of the Swift Numerics open source project
//
// Copyright (c) 2021 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
import _TestSupport
#if canImport(Accelerate)
import Accelerate
#endif
#if !DEBUG
func strictSum<T: Real>(_ array: [T]) -> T {
array.reduce(0, +)
}
func relaxedSum<T: Real>(_ array: [T]) -> T {
array.reduce(0, Relaxed.sum)
}
func strictSumOfSquares<T: Real>(_ array: [T]) -> T {
array.reduce(0) { $0 + $1*$1 }
}
func relaxedSumOfSquares<T: Real>(_ array: [T]) -> T {
array.reduce(0) { Relaxed.multiplyAdd($1, $1, $0) }
}
// TODO: not a great harness, but making it better bumps up against the
// limitations of what XCT measure { } lets us do easily. Good enough for now.
func benchmarkReduction(_ data: [Float], _ reduction: ([Float]) -> Float) {
var accum: Float = 0
let iters = 100_000
for _ in 0 ..< iters {
accum += reduction(data)
}
blackHole(accum)
}
final class RelaxedArithmeticTests: XCTestCase {
var floatData: [Float] = []
override func setUp() {
super.setUp()
floatData = (0 ..< 1024).map { _ in .random(in: .sqrt(1/2) ..< .sqrt(2)) }
}
func testStrictSumPerformance() {
measure { benchmarkReduction(floatData, strictSum) }
}
func testRelaxedSumPerformance() {
// Performance of this should be closer to vDSP.sum than to
// strict sum
measure { benchmarkReduction(floatData, relaxedSum) }
}
#if canImport(Accelerate)
func testvDSPSumPerformance() {
measure { benchmarkReduction(floatData, vDSP.sum) }
}
#endif
func testStrictDotPerformance() {
measure { benchmarkReduction(floatData, strictSumOfSquares) }
}
func testRelaxedDotPerformance() {
// Performance of this should be closer to vDSP.sumOfSquares than to
// strict sumOfSquares
measure { benchmarkReduction(floatData, relaxedSumOfSquares) }
}
#if canImport(Accelerate)
func testvDSPDotPerformance() {
measure { benchmarkReduction(floatData, vDSP.sumOfSquares) }
}
#endif
func testRelaxedArithmetic<T: FixedWidthFloatingPoint & Real>(_ type: T.Type) {
// Relaxed add is still an add; it's just permitted to reorder relative
// to other adds or form FMAs. So if we do one in isolation, it has to
// produce the same result as a normal addition.
let a = T.random(in: -1 ... 1)
let b = T.random(in: -1 ... 1)
XCTAssertEqual(a + b, Relaxed.sum(a, b))
// Same is true for mul.
XCTAssertEqual(a * b, Relaxed.product(a, b))
// add + mul must be either two operations or an FMA:
let unfused = a + 1.5 * b
let fused = a.addingProduct(1.5, b)
let relaxed = Relaxed.multiplyAdd(1.5, b, a)
XCTAssert(relaxed == unfused || relaxed == fused)
// Summing all values in an array can be associated however we want, but
// has to satisfy the usual error bound of 0.5 * sum.ulp * numberOfElements.
// We don't have a golden reference, but we can compare two sums with twice
// the bound for a sanity check.
let array = (0 ..< 128).map { _ in T.random(in: 1 ..< 2) }
var ref = strictSum(array)
var tst = relaxedSum(array)
var bound = max(ref, tst).ulp * T(array.count)
XCTAssertLessThanOrEqual(abs(ref - tst), bound)
// Similarly for sum of squares ...
ref = strictSumOfSquares(array)
tst = relaxedSumOfSquares(array)
bound = 2 * max(ref, tst).ulp * T(array.count)
XCTAssertLessThanOrEqual(abs(ref - tst), bound)
}
func testRelaxedArithmetic() {
#if swift(>=5.4) && !((os(macOS) || targetEnvironment(macCatalyst)) && arch(x86_64))
testRelaxedArithmetic(Float16.self)
#endif
testRelaxedArithmetic(Float.self)
testRelaxedArithmetic(Double.self)
#if (arch(i386) || arch(x86_64)) && !os(Windows) && !os(Android)
testRelaxedArithmetic(Float80.self)
#endif
}
}
#endif
+17 -102
View File
@@ -2,7 +2,7 @@
//
// This source file is part of the Swift Numerics open source project
//
// Copyright (c) 2019-2021 Apple Inc. and the Swift Numerics project authors
// Copyright (c) 2019 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
@@ -18,9 +18,6 @@ import RealTests
@testable
import ComplexTests
@testable
import IntegerUtilitiesTests
extension ComplexTests.ApproximateEqualityTests {
static var all = testCase([
("testFloat", ComplexTests.ApproximateEqualityTests.testFloat),
@@ -35,7 +32,7 @@ extension RealTests.ApproximateEqualityTests {
])
}
#if !((os(macOS) || targetEnvironment(macCatalyst)) && arch(x86_64))
#if swift(>=5.4) && !((os(macOS) || targetEnvironment(macCatalyst)) && arch(x86_64))
extension ElementaryFunctionChecks {
static var all = testCase([
("testFloat16", ElementaryFunctionChecks.testFloat16),
@@ -67,18 +64,6 @@ extension IntegerExponentTests {
}
#endif
extension RealTests.AugmentedArithmeticTests {
static var all = testCase([
("testTwoSum", RealTests.AugmentedArithmeticTests.testTwoSum),
])
}
extension RealTests.RelaxedArithmeticTests {
static var all = testCase([
("testRelaxedArithmetic", RealTests.RelaxedArithmeticTests.testRelaxedArithmetic),
])
}
extension ArithmeticTests {
static var all = testCase([
("testPolar", ArithmeticTests.testPolar),
@@ -95,85 +80,6 @@ extension PropertyTests {
])
}
extension IntegerUtilitiesDivideTests {
static var all = testCase([
("testDivideInt8", IntegerUtilitiesDivideTests.testDivideInt8),
("testDivideInt", IntegerUtilitiesDivideTests.testDivideInt),
("testDivideUInt8", IntegerUtilitiesDivideTests.testDivideUInt8),
("testDivideStochasticInt8", IntegerUtilitiesDivideTests.testDivideStochasticInt8),
("testDivideStochasticUInt32", IntegerUtilitiesDivideTests.testDivideStochasticUInt32),
("testRemainderByMinusOne", IntegerUtilitiesDivideTests.testRemainderByMinusOne),
])
}
extension IntegerUtilitiesGCDTests {
static var all = testCase([
("testGCDInt", IntegerUtilitiesGCDTests.testGCDInt),
])
}
extension IntegerUtilitiesRotateTests {
static var all = testCase([
("testRotateUInt8", IntegerUtilitiesRotateTests.testRotateUInt8),
("testRotateInt16", IntegerUtilitiesRotateTests.testRotateInt16),
])
}
extension IntegerUtilitiesSaturatingTests {
static var all = testCase([
("testSaturatingAddSigned", IntegerUtilitiesSaturatingTests.testSaturatingAddSigned),
("testSaturatingSubSigned", IntegerUtilitiesSaturatingTests.testSaturatingSubSigned),
("testSaturatingNegSigned", IntegerUtilitiesSaturatingTests.testSaturatingNegSigned),
("testSaturatingMulSigned", IntegerUtilitiesSaturatingTests.testSaturatingMulSigned),
("testSaturatingAddUnsigned", IntegerUtilitiesSaturatingTests.testSaturatingAddUnsigned),
("testSaturatingSubUnsigned", IntegerUtilitiesSaturatingTests.testSaturatingSubUnsigned),
("testSaturatingNegUnsigned", IntegerUtilitiesSaturatingTests.testSaturatingNegUnsigned),
("testSaturatingMulUnsigned", IntegerUtilitiesSaturatingTests.testSaturatingMulUnsigned),
("testSaturatingShifts", IntegerUtilitiesSaturatingTests.testSaturatingShifts),
("testEdgeCaseForNegativeCount", IntegerUtilitiesSaturatingTests.testEdgeCaseForNegativeCount)
])
}
extension IntegerUtilitiesShiftTests {
static var all = testCase([
("testRoundingShifts", IntegerUtilitiesShiftTests.testRoundingShifts),
("testStochasticShifts", IntegerUtilitiesShiftTests.testStochasticShifts),
])
}
extension IntegerUtilitiesTests.DoubleWidthTests {
static var all = testCase([
("testArithmetic_Signed", IntegerUtilitiesTests.DoubleWidthTests.testArithmetic_Signed),
("testArithmetic_Unsigned", IntegerUtilitiesTests.DoubleWidthTests.testArithmetic_Unsigned),
("testBitwise_LeftAndRightShifts", IntegerUtilitiesTests.DoubleWidthTests.testBitwise_LeftAndRightShifts),
("testCompileTime_SR_6947", IntegerUtilitiesTests.DoubleWidthTests.testCompileTime_SR_6947),
("testConditionalConformance", IntegerUtilitiesTests.DoubleWidthTests.testConditionalConformance),
("testConversions", IntegerUtilitiesTests.DoubleWidthTests.testConversions),
("testConversions_Exact", IntegerUtilitiesTests.DoubleWidthTests.testConversions_Exact),
("testConversions_SignedMax", IntegerUtilitiesTests.DoubleWidthTests.testConversions_SignedMax),
("testConversions_SignedMin", IntegerUtilitiesTests.DoubleWidthTests.testConversions_SignedMin),
("testConversions_ToAndFromString_Binary", IntegerUtilitiesTests.DoubleWidthTests.testConversions_ToAndFromString_Binary),
("testConversions_ToAndFromString_Decimal", IntegerUtilitiesTests.DoubleWidthTests.testConversions_ToAndFromString_Decimal),
("testConversions_ToAndFromString_Hexadecimal", IntegerUtilitiesTests.DoubleWidthTests.testConversions_ToAndFromString_Hexadecimal),
("testConversions_UnsignedMax", IntegerUtilitiesTests.DoubleWidthTests.testConversions_UnsignedMax),
("testConversions_UnsignedMin", IntegerUtilitiesTests.DoubleWidthTests.testConversions_UnsignedMin),
("testDivision_ByMinusOne", IntegerUtilitiesTests.DoubleWidthTests.testDivision_ByMinusOne),
("testDivision_ByZero", IntegerUtilitiesTests.DoubleWidthTests.testDivision_ByZero),
("testInitialization", IntegerUtilitiesTests.DoubleWidthTests.testInitialization),
("testInitialization_Overflow", IntegerUtilitiesTests.DoubleWidthTests.testInitialization_Overflow),
("testLiterals", IntegerUtilitiesTests.DoubleWidthTests.testLiterals),
("testLiterals_Underflow", IntegerUtilitiesTests.DoubleWidthTests.testLiterals_Underflow),
("testMagnitude", IntegerUtilitiesTests.DoubleWidthTests.testMagnitude),
("testMultipleOf", IntegerUtilitiesTests.DoubleWidthTests.testMultipleOf),
("testMultiplication_ByMinusOne", IntegerUtilitiesTests.DoubleWidthTests.testMultiplication_ByMinusOne),
("testNested", IntegerUtilitiesTests.DoubleWidthTests.testNested),
("testRemainder_ByMinusOne", IntegerUtilitiesTests.DoubleWidthTests.testRemainder_ByMinusOne),
("testRemainder_ByZero", IntegerUtilitiesTests.DoubleWidthTests.testRemainder_ByZero),
("testTwoWords", IntegerUtilitiesTests.DoubleWidthTests.testTwoWords),
("testWords", IntegerUtilitiesTests.DoubleWidthTests.testWords),
])
}
var testCases = [
ComplexTests.ApproximateEqualityTests.all,
RealTests.ApproximateEqualityTests.all,
@@ -181,14 +87,23 @@ var testCases = [
IntegerExponentTests.all,
ArithmeticTests.all,
PropertyTests.all,
IntegerUtilitiesDivideTests.all,
IntegerUtilitiesGCDTests.all,
IntegerUtilitiesRotateTests.all,
IntegerUtilitiesShiftTests.all,
IntegerUtilitiesSaturatingTests.all,
IntegerUtilitiesTests.DoubleWidthTests.all,
]
#if swift(>=5.3) && canImport(_Differentiation)
extension DifferentiableTests {
static var all = testCase([
("testComponentGetter", DifferentiableTests.testComponentGetter),
("testInitializer", DifferentiableTests.testInitializer),
("testConjugate", DifferentiableTests.testConjugate),
("testArithmetics", DifferentiableTests.testArithmetics),
])
}
testCases += [
DifferentiableTests.all
]
#endif
XCTMain(testCases)
#endif