mirror of
https://github.com/apple/swift-numerics
synced 2026-11-22 04:30:45 +00:00
Compare commits
| Author | SHA1 | Date | |
|---|---|---|---|
|
|
1e5cbc4e21 | ||
|
|
b4ec7556e9 | ||
|
|
79f6025798 | ||
|
|
03c5840722 | ||
|
|
ed66862a2c | ||
|
|
bcde4bc513 | ||
|
|
58f95289a0 | ||
|
|
832dac1ef8 | ||
|
|
419caa222f | ||
|
|
5a0aedbccd | ||
|
|
8e3d889b5f | ||
|
|
92f0095962 |
No files matched your search
@@ -1,28 +0,0 @@
|
||||
name: Pull request
|
||||
|
||||
permissions:
|
||||
contents: read
|
||||
|
||||
on:
|
||||
pull_request:
|
||||
types: [opened, reopened, synchronize]
|
||||
|
||||
jobs:
|
||||
tests:
|
||||
name: Test
|
||||
uses: swiftlang/github-workflows/.github/workflows/swift_package_test.yml@main
|
||||
with:
|
||||
enable_macos_checks: true
|
||||
windows_exclude_swift_versions: '[{"swift_version": "5.9"}]'
|
||||
enable_wasm_sdk_build: true
|
||||
wasm_sdk_build_command: swift build --target Numerics
|
||||
enable_freebsd_checks: true
|
||||
soundness:
|
||||
name: Soundness
|
||||
uses: swiftlang/github-workflows/.github/workflows/soundness.yml@main
|
||||
with:
|
||||
license_header_check_project_name: "Swift Numerics"
|
||||
# https://github.com/apple/swift-numerics/issues/303
|
||||
license_header_check_enabled: false
|
||||
# https://github.com/apple/swift-numerics/issues/302
|
||||
format_check_enabled: false
|
||||
@@ -1,4 +0,0 @@
|
||||
version: 1
|
||||
builder:
|
||||
configs:
|
||||
- documentation_targets: [Numerics, RealModule, ComplexModule]
|
||||
+5
-2
@@ -7,11 +7,11 @@ Licensed under Apache License v2.0 with Runtime Library Exception
|
||||
See https://swift.org/LICENSE.txt for license information
|
||||
#]]
|
||||
|
||||
cmake_minimum_required(VERSION 3.29)
|
||||
cmake_minimum_required(VERSION 3.16)
|
||||
project(swift-numerics
|
||||
LANGUAGES Swift)
|
||||
|
||||
list(APPEND CMAKE_MODULE_PATH ${PROJECT_SOURCE_DIR}/cmake/modules)
|
||||
list(APPEND CMAKE_MODULE_PATH ${CMAKE_SOURCE_DIR}/cmake/modules)
|
||||
|
||||
set(CMAKE_ARCHIVE_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/lib)
|
||||
set(CMAKE_LIBRARY_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/lib)
|
||||
@@ -22,6 +22,9 @@ include(CTest)
|
||||
include(SwiftSupport)
|
||||
|
||||
add_subdirectory(Sources)
|
||||
if(BUILD_TESTING)
|
||||
add_subdirectory(Tests)
|
||||
endif()
|
||||
|
||||
get_property(SWIFT_NUMERICS_EXPORTS GLOBAL PROPERTY SWIFT_NUMERICS_EXPORTS)
|
||||
export(TARGETS ${SWIFT_NUMERICS_EXPORTS}
|
||||
|
||||
+15
-62
@@ -1,9 +1,9 @@
|
||||
// swift-tools-version:5.9
|
||||
// swift-tools-version:5.0
|
||||
//===--- Package.swift ----------------------------------------*- swift -*-===//
|
||||
//
|
||||
// This source file is part of the Swift Numerics open source project
|
||||
//
|
||||
// Copyright (c) 2019-2025 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,8 +12,6 @@
|
||||
|
||||
import PackageDescription
|
||||
|
||||
let excludedFilenames = ["CMakeLists.txt", "README.md"]
|
||||
|
||||
let package = Package(
|
||||
|
||||
name: "swift-numerics",
|
||||
@@ -24,66 +22,21 @@ let package = Package(
|
||||
],
|
||||
|
||||
targets: [
|
||||
// MARK: - Public API
|
||||
.target(
|
||||
name: "ComplexModule",
|
||||
dependencies: ["RealModule"],
|
||||
exclude: excludedFilenames
|
||||
),
|
||||
// User-facing modules
|
||||
.target(name: "ComplexModule", dependencies: ["RealModule"]),
|
||||
.target(name: "Numerics", dependencies: ["ComplexModule", "RealModule"]),
|
||||
.target(name: "RealModule", dependencies: ["_NumericsShims"]),
|
||||
|
||||
.target(
|
||||
name: "IntegerUtilities",
|
||||
dependencies: [],
|
||||
exclude: excludedFilenames
|
||||
),
|
||||
// Implementation details
|
||||
.target(name: "_NumericsShims", dependencies: []),
|
||||
.target(name: "_TestSupport", dependencies: ["Numerics"]),
|
||||
|
||||
.target(
|
||||
name: "Numerics",
|
||||
dependencies: ["ComplexModule", "IntegerUtilities", "RealModule"],
|
||||
exclude: excludedFilenames
|
||||
),
|
||||
// Unit test bundles
|
||||
.testTarget(name: "ComplexTests", dependencies: ["_TestSupport"]),
|
||||
.testTarget(name: "RealTests", dependencies: ["_TestSupport"]),
|
||||
|
||||
.target(
|
||||
name: "RealModule",
|
||||
dependencies: ["_NumericsShims"],
|
||||
exclude: excludedFilenames,
|
||||
swiftSettings: [
|
||||
.enableExperimentalFeature("BuiltinModule")
|
||||
],
|
||||
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: "ComplexTests",
|
||||
dependencies: ["_TestSupport"],
|
||||
exclude: ["CMakeLists.txt"]
|
||||
),
|
||||
|
||||
.testTarget(
|
||||
name: "IntegerUtilitiesTests",
|
||||
dependencies: ["IntegerUtilities", "_TestSupport"],
|
||||
exclude: ["CMakeLists.txt"]
|
||||
),
|
||||
|
||||
.testTarget(
|
||||
name: "RealTests",
|
||||
dependencies: ["_TestSupport"],
|
||||
exclude: ["CMakeLists.txt"]
|
||||
)
|
||||
// Test executables
|
||||
.target(name: "ComplexLog", dependencies: ["Numerics", "_TestSupport"], path: "Tests/Executable/ComplexLog"),
|
||||
.target(name: "ComplexLog1p", dependencies: ["Numerics", "_TestSupport"], path: "Tests/Executable/ComplexLog1p")
|
||||
]
|
||||
)
|
||||
@@ -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
|
||||
@@ -84,7 +84,7 @@ Swift Numerics uses GitHub issues to track bugs and features. We use pull reques
|
||||
1. Raise an issue with the [new module] tag.
|
||||
2. Raise a PR with an implementation sketch.
|
||||
3. Once you have some consensus, ask an admin to create a feature branch against which PRs can be raised.
|
||||
4. When the design has stabilized and is functional enough to be useful, raise a PR to merge the new module to main.
|
||||
4. When the design has stabilized and is functional enough to be useful, raise a PR to merge the new module to master.
|
||||
|
||||
### How to propose a new feature for an existing module
|
||||
|
||||
@@ -105,7 +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)
|
||||
|
||||
## Future expansion
|
||||
|
||||
@@ -114,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.
|
||||
@@ -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)
|
||||
|
||||
@@ -0,0 +1,193 @@
|
||||
//===--- Arithmetic.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 RealModule
|
||||
|
||||
// MARK: - Additive structure
|
||||
extension Complex: AdditiveArithmetic {
|
||||
@_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
|
||||
}
|
||||
}
|
||||
|
||||
// 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
|
||||
public static func /(z: Complex, w: Complex) -> Complex {
|
||||
// Try the naive expression z/w = z*conj(w) / |w|^2; if we can compute
|
||||
// this without over/underflow, everything is fine and the result is
|
||||
// correct. If not, we have to rescale and do the computation carefully.
|
||||
let lenSq = w.lengthSquared
|
||||
guard lenSq.isNormal else { return rescaledDivide(z, w) }
|
||||
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
|
||||
}
|
||||
|
||||
@usableFromInline @_alwaysEmitIntoClient @inline(never)
|
||||
internal static func rescaledDivide(_ z: Complex, _ w: Complex) -> Complex {
|
||||
if w.isZero { return .infinity }
|
||||
if z.isZero || !w.isFinite { return .zero }
|
||||
// TODO: detect when RealType is Float and just promote to Double, then
|
||||
// use the naive algorithm.
|
||||
let zScale = z.magnitude
|
||||
let wScale = w.magnitude
|
||||
let zNorm = z.divided(by: zScale)
|
||||
let wNorm = w.divided(by: wScale)
|
||||
let r = (zNorm * wNorm.conjugate).divided(by: wNorm.lengthSquared)
|
||||
// At this point, the result is (r * zScale)/wScale computed without
|
||||
// undue overflow or underflow. We know that r is close to unity, so
|
||||
// the question is simply what order in which to do this computation
|
||||
// to avoid spurious overflow or underflow. There are three options
|
||||
// to choose from:
|
||||
//
|
||||
// - r * (zScale / wScale)
|
||||
// - (r * zScale) / wScale
|
||||
// - (r / wScale) * zScale
|
||||
//
|
||||
// The simplest case is when zScale / wScale is normal:
|
||||
if (zScale / wScale).isNormal {
|
||||
return r.multiplied(by: zScale / wScale)
|
||||
}
|
||||
// Otherwise, we need to compute either rNorm * zScale or rNorm / wScale
|
||||
// first. Choose the first if the first scaling behaves well, otherwise
|
||||
// choose the other one.
|
||||
if (r.magnitude * zScale).isNormal {
|
||||
return r.multiplied(by: zScale).divided(by: wScale)
|
||||
}
|
||||
return r.divided(by: wScale).multiplied(by: zScale)
|
||||
}
|
||||
|
||||
/// A normalized complex number with the same phase as this value.
|
||||
///
|
||||
/// If such a value cannot be produced (because the phase of zero and
|
||||
/// infinity is undefined), `nil` is returned.
|
||||
@inlinable
|
||||
public var normalized: Complex? {
|
||||
if length.isNormal {
|
||||
return self.divided(by: length)
|
||||
}
|
||||
if isZero || !isFinite {
|
||||
return nil
|
||||
}
|
||||
return self.divided(by: magnitude).normalized
|
||||
}
|
||||
|
||||
/// The reciprocal of this value, if it can be computed without undue
|
||||
/// overflow or underflow.
|
||||
///
|
||||
/// 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 may sometimes be a significant performance win.
|
||||
///
|
||||
/// A typical use case looks something like this:
|
||||
/// ```
|
||||
/// func divide<T: Real>(data: [Complex<T>], by divisor: Complex<T>) -> [Complex<T>] {
|
||||
/// // If divisor is well-scaled, multiply by reciprocal.
|
||||
/// if let recip = divisor.reciprocal {
|
||||
/// return data.map { $0 * recip }
|
||||
/// }
|
||||
/// // Fallback on using division.
|
||||
/// return data.map { $0 / divisor }
|
||||
/// }
|
||||
/// ```
|
||||
///
|
||||
/// 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.
|
||||
@inlinable
|
||||
public var reciprocal: Complex? {
|
||||
let recip = 1/self
|
||||
if recip.isNormal || isZero || !isFinite {
|
||||
return recip
|
||||
}
|
||||
return nil
|
||||
}
|
||||
}
|
||||
@@ -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-2025 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,190 +0,0 @@
|
||||
//===--- Complex+AlgebraicField.swift -------------------------*- swift -*-===//
|
||||
//
|
||||
// This source file is part of the Swift Numerics open source project
|
||||
//
|
||||
// Copyright (c) 2019-2025 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: AlgebraicField {
|
||||
/// The multiplicative identity `1 + 0i`.
|
||||
///
|
||||
/// See also: ``zero``, ``i``, ``infinity``
|
||||
@_transparent
|
||||
public static var one: Complex {
|
||||
Complex(1, 0)
|
||||
}
|
||||
|
||||
/// The [complex conjugate][conj] of this value.
|
||||
///
|
||||
/// [conj]: https://en.wikipedia.org/wiki/Complex_conjugate
|
||||
@_transparent
|
||||
public var conjugate: Complex {
|
||||
Complex(x, -y)
|
||||
}
|
||||
|
||||
@_transparent
|
||||
public static func /=(z: inout Complex, w: Complex) {
|
||||
z = z / w
|
||||
}
|
||||
|
||||
@_transparent
|
||||
public static func /(z: Complex, w: Complex) -> Complex {
|
||||
// Try the naive expression z/w = z * (conj(w) / |w|^2); if we can
|
||||
// compute this without over/underflow, everything is fine and the
|
||||
// result is correct. If not, we have to rescale and do the
|
||||
// computation carefully (see below).
|
||||
let lenSq = w.lengthSquared
|
||||
guard lenSq.isNormal else { return rescaledDivide(z, w) }
|
||||
return z * w.conjugate.divided(by: lenSq)
|
||||
}
|
||||
|
||||
@usableFromInline @_alwaysEmitIntoClient @inline(never)
|
||||
internal static func rescaledDivide(_ z: Complex, _ w: Complex) -> Complex {
|
||||
if w.isZero { return .infinity }
|
||||
if !w.isFinite { return .zero }
|
||||
// Scaling algorithm adapted from Doug Priest's "Efficient Scaling for
|
||||
// Complex Division":
|
||||
if w.magnitude < .leastNormalMagnitude {
|
||||
// A difference from Priest's algorithm is that he didn't have to worry
|
||||
// about types like Float16, where the significand width is comparable
|
||||
// to the exponent range, such that |leastNormalMagnitude|^(-¾) isn't
|
||||
// representable (e.g. for Float16 it would want to be 2¹⁸, but the
|
||||
// largest allowed exponent is 15). Note that it's critical to use zʹ/wʹ
|
||||
// after rescaling to avoid this, rather than falling through into the
|
||||
// normal rescaling, because otherwise we might end up back in the
|
||||
// situation where |w| ~ 1.
|
||||
let s = 1/(RealType(RealType.radix) * .leastNormalMagnitude)
|
||||
let wʹ = w.multiplied(by: s)
|
||||
let zʹ = z.multiplied(by: s)
|
||||
return zʹ / wʹ
|
||||
}
|
||||
// Having handled that case, we proceed pretty similarly to Priest:
|
||||
//
|
||||
// 1. Choose real scale s ~ |w|^(-¾), an exact power of the radix.
|
||||
// 2. wʹ ← sw
|
||||
// 3. zʹ ← sz
|
||||
// 4. return zʹ * (wʹ.conjugate / wʹ.lengthSquared) (i.e. zʹ/wʹ).
|
||||
//
|
||||
// Why is this safe and accurate? First, observe that wʹ and zʹ are both
|
||||
// computed exactly because:
|
||||
//
|
||||
// - s is an exact power of radix.
|
||||
// - wʹ ~ |w|^(¼), and hence cannot overflow or underflow.
|
||||
// - zʹ might overflow or underflow, but only if the final result also
|
||||
// overflows or underflows. (This is more subtle than I make it
|
||||
// sound. In particular, most of the fast ways one might try to
|
||||
// compute s give rise to a situation where when |w| is close to
|
||||
// one, multiplication by s is a dilation even though the actual
|
||||
// division is a contraction or vice-versa, and thus intermediate
|
||||
// computations might incorrectly overflow or underflow. Priest
|
||||
// had to take some care to avoid this situation, but we do not,
|
||||
// because we have already ruled out |w| ~ 1 before we call this
|
||||
// function.)
|
||||
//
|
||||
// Next observe that |wʹ.lengthSquared| ~ |w|^(½), so again this cannot
|
||||
// overflow or underflow, and neither can (wʹ.conjugate/wʹ.lengthSquared),
|
||||
// which has magnitude like |w|^(-¼).
|
||||
//
|
||||
// Note that because the scale factor is always a power of the radix,
|
||||
// the rescaling does not affect rounding, and so this algorithm is scale-
|
||||
// invariant compared to the mainline `/` implementation, up to the
|
||||
// underflow boundary.
|
||||
//
|
||||
// Note that our final assembly of the result is different from Priest;
|
||||
// he applies s to w twice, instead of once to w and once to z, and
|
||||
// does the product as (zw̅ʺ)*(1/|wʹ|²), while we do zʹ(w̅ʹ/|wʹ|²). We
|
||||
// prefer our version for three reasons:
|
||||
//
|
||||
// 1. it extracts a little more ILP
|
||||
// 2. it makes it so that we get exactly the same roundings on the
|
||||
// rescaled divide path as on the fast path, so that z/w = tz/tw
|
||||
// when tz and tw are computed exactly.
|
||||
// 3. it unlocks a future optimization where we hoist s and
|
||||
// (w̅ʹ/|wʹ|²) and make divisions all fast-path without perturbing
|
||||
// rounding.
|
||||
let s = RealType(
|
||||
sign: .plus,
|
||||
exponent: -3*w.magnitude.exponent/4,
|
||||
significand: 1
|
||||
)
|
||||
let wʹ = w.multiplied(by: s)
|
||||
let zʹ = z.multiplied(by: s)
|
||||
return zʹ * wʹ.conjugate.divided(by: wʹ.lengthSquared)
|
||||
}
|
||||
|
||||
/// A normalized complex number with the same phase as this value.
|
||||
///
|
||||
/// If such a value cannot be produced (because the phase of zero and
|
||||
/// infinity is undefined), `nil` is returned.
|
||||
@inlinable
|
||||
public var normalized: Complex? {
|
||||
if length.isNormal {
|
||||
return self.divided(by: length)
|
||||
}
|
||||
if isZero || !isFinite {
|
||||
return nil
|
||||
}
|
||||
return self.divided(by: magnitude).normalized
|
||||
}
|
||||
|
||||
/// The reciprocal of this value, if it can be computed without undue
|
||||
/// overflow or underflow.
|
||||
///
|
||||
/// 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.
|
||||
///
|
||||
/// A typical use case looks something like this:
|
||||
/// ```
|
||||
/// func divide<T: Real>(data: [Complex<T>], by divisor: Complex<T>) -> [Complex<T>] {
|
||||
/// // If divisor is well-scaled, multiply by reciprocal.
|
||||
/// if let recip = divisor.reciprocal {
|
||||
/// return data.map { $0 * recip }
|
||||
/// }
|
||||
/// // Fallback on using division.
|
||||
/// return data.map { $0 / divisor }
|
||||
/// }
|
||||
/// ```
|
||||
///
|
||||
/// Error Bounds:
|
||||
///
|
||||
/// Unlike real types, with Complex types, _if no underflow occurs in
|
||||
/// computing the reciprocal_, replacing division with multiplication by
|
||||
/// this value does not perturb the result. Note that this condition is
|
||||
/// not the same as `reciprocal` returning a non-nil value. If the `real`
|
||||
/// and `imaginary` components are poorly scaled with respect to each other,
|
||||
/// one component of `reciprocal` may underflow while the other component
|
||||
/// is normal, resulting in a non-nil `reciprocal`.
|
||||
///
|
||||
/// We return a non-nil reciprocal in this case because it still
|
||||
/// satisfies the accuracy expectations of `reciprocal` in any Complex
|
||||
/// norm (but not componentwise).
|
||||
@inlinable
|
||||
public var reciprocal: Complex? {
|
||||
let recip = 1/self
|
||||
if recip.isNormal || isZero || !isFinite {
|
||||
return recip
|
||||
}
|
||||
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))
|
||||
)
|
||||
}
|
||||
}
|
||||
@@ -1,36 +0,0 @@
|
||||
//===--- Complex+Codable.swift --------------------------------*- swift -*-===//
|
||||
//
|
||||
// This source file is part of the Swift Numerics open source project
|
||||
//
|
||||
// Copyright (c) 2019-2025 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.
|
||||
#if compiler(>=6.0)
|
||||
@_unavailableInEmbedded
|
||||
#endif
|
||||
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)
|
||||
}
|
||||
}
|
||||
|
||||
#if compiler(>=6.0)
|
||||
@_unavailableInEmbedded
|
||||
#endif
|
||||
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-2025 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-2025 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,59 +0,0 @@
|
||||
//===--- Complex+Numeric.swift --------------------------------*- swift -*-===//
|
||||
//
|
||||
// This source file is part of the Swift Numerics open source project
|
||||
//
|
||||
// Copyright (c) 2019-2025 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 infinity-norm of the value (a.k.a. "maximum norm" or "Чебышёв
|
||||
/// [Chebyshev] norm").
|
||||
///
|
||||
/// Equal to `max(abs(real), abs(imaginary))`.
|
||||
///
|
||||
/// If you need to work with the Euclidean norm (a.k.a. 2-norm) instead,
|
||||
/// use the ``length`` or ``lengthSquared`` properties. If you just need
|
||||
/// to know "how big" a number is, use this property.
|
||||
///
|
||||
/// **Edge cases:**
|
||||
///
|
||||
/// - If `z` is not finite, `z.magnitude` is infinity.
|
||||
/// - If `z` is zero, `z.magnitude` is zero.
|
||||
/// - Otherwise, `z.magnitude` is finite and non-zero.
|
||||
@_transparent
|
||||
public var magnitude: RealType {
|
||||
guard isFinite else { return .infinity }
|
||||
return max(abs(x), abs(y))
|
||||
}
|
||||
}
|
||||
@@ -1,26 +0,0 @@
|
||||
//===--- Complex+StringConvertible.swift ----------------------*- swift -*-===//
|
||||
//
|
||||
// This source file is part of the Swift Numerics open source project
|
||||
//
|
||||
// Copyright (c) 2019-2025 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))"
|
||||
}
|
||||
}
|
||||
|
||||
#if compiler(>=6.0)
|
||||
@_unavailableInEmbedded
|
||||
#endif
|
||||
extension Complex: CustomDebugStringConvertible {
|
||||
public var debugDescription: String {
|
||||
"Complex<\(RealType.self)>(\(String(reflecting: x)), \(String(reflecting: y)))"
|
||||
}
|
||||
}
|
||||
@@ -2,7 +2,7 @@
|
||||
//
|
||||
// This source file is part of the Swift Numerics open source project
|
||||
//
|
||||
// Copyright (c) 2019-2025 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
|
||||
@@ -11,8 +11,39 @@
|
||||
|
||||
import RealModule
|
||||
|
||||
// A [complex number](https://en.wikipedia.org/wiki/Complex_number).
|
||||
// See Documentation.docc/Complex.md for more details.
|
||||
/// A complex number represented by real and imaginary parts.
|
||||
///
|
||||
/// 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
|
||||
/// mixed-type arithmetic when the operation can be adequately expressed
|
||||
/// by a conversion and homogeneous arithmetic. Second, with the current
|
||||
/// typechecker rules, it would lead to undesirable ambiguity in common
|
||||
/// expressions (see README.md for more details).
|
||||
///
|
||||
/// Unlike C's `_Complex` and C++'s `std::complex<>` types, we do not
|
||||
/// attempt to make meaningful semantic distinctions between different
|
||||
/// representations of infinity or NaN. Any Complex value with at least
|
||||
/// one non-finite component is simply "non-finite". In as much as
|
||||
/// possible, we use the semantics of the point at infinity on the
|
||||
/// Riemann sphere for such values. This approach simplifies the number of
|
||||
/// edge cases that need to be considered for multiplication, division, and
|
||||
/// the elementary functions considerably.
|
||||
///
|
||||
/// `.magnitude` does not return the Euclidean norm; it uses the "infinity
|
||||
/// norm" (`max(|real|,|imaginary|)`) instead. There are two reasons for this
|
||||
/// choice: first, it's simply faster to compute on most hardware. Second,
|
||||
/// there exist values for which the Euclidean norm cannot be represented
|
||||
/// (consider a number with `.real` and `.imaginary` both equal to
|
||||
/// `RealType.greatestFiniteMagnitude`; the Euclidean norm would be
|
||||
/// `.sqrt(2) * .greatestFiniteMagnitude`, which overflows). Using
|
||||
/// the infinity norm avoids this problem entirely without significant
|
||||
/// downsides. You can access the Euclidean norm using the `length`
|
||||
/// property.
|
||||
@frozen
|
||||
public struct Complex<RealType> where RealType: Real {
|
||||
// A note on the `x` and `y` properties
|
||||
@@ -22,11 +53,11 @@ public struct Complex<RealType> where RealType: Real {
|
||||
// `.real` and `.imaginary` properties, which wrap this storage and
|
||||
// fixup the semantics for non-finite values.
|
||||
|
||||
/// The storage for the real component of the value.
|
||||
/// The real component of the value.
|
||||
@usableFromInline @inline(__always)
|
||||
internal var x: RealType
|
||||
|
||||
/// The storage for the imaginary part of the value.
|
||||
/// The imaginary part of the value.
|
||||
@usableFromInline @inline(__always)
|
||||
internal var y: RealType
|
||||
|
||||
@@ -38,8 +69,6 @@ public struct Complex<RealType> where RealType: Real {
|
||||
}
|
||||
}
|
||||
|
||||
extension Complex: Sendable where RealType: Sendable { }
|
||||
|
||||
// MARK: - Basic properties
|
||||
extension Complex {
|
||||
/// The real part of this complex value.
|
||||
@@ -64,32 +93,37 @@ extension Complex {
|
||||
set { y = newValue }
|
||||
}
|
||||
|
||||
/// The raw representation of the value.
|
||||
/// The additive identity, with real and imaginary parts both zero.
|
||||
///
|
||||
/// Use this when you need the underlying RealType values,
|
||||
/// without fixup for NaN or infinity.
|
||||
public var rawStorage: (x: RealType, y: RealType) {
|
||||
@_transparent
|
||||
get { (x, y) }
|
||||
@_transparent
|
||||
set { (x, y) = newValue }
|
||||
/// See also:
|
||||
/// -
|
||||
/// - .one
|
||||
/// - .i
|
||||
/// - .infinity
|
||||
@_transparent
|
||||
public static var zero: Complex {
|
||||
Complex(0, 0)
|
||||
}
|
||||
|
||||
/// The raw representation of the real part of this value.
|
||||
@available(*, deprecated, message: "Use rawStorage")
|
||||
/// The multiplicative identity, with real part one and imaginary part zero.
|
||||
///
|
||||
/// See also:
|
||||
/// -
|
||||
/// - .zero
|
||||
/// - .i
|
||||
/// - .infinity
|
||||
@_transparent
|
||||
public var _rawX: RealType { x }
|
||||
public static var one: Complex {
|
||||
Complex(1, 0)
|
||||
}
|
||||
|
||||
/// The raw representation of the imaginary part of this value.
|
||||
@available(*, deprecated, message: "Use rawStorage")
|
||||
@_transparent
|
||||
public var _rawY: RealType { y }
|
||||
}
|
||||
|
||||
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)
|
||||
@@ -97,17 +131,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
|
||||
@@ -120,7 +168,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)
|
||||
@@ -132,7 +184,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
|
||||
@@ -143,12 +199,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
|
||||
@@ -182,13 +263,36 @@ extension Complex {
|
||||
self.init(real, 0)
|
||||
}
|
||||
|
||||
/// The complex number with zero real part and specified imaginary part.
|
||||
/// The complex number with specified imaginary part and zero real part.
|
||||
///
|
||||
/// Equivalent to `Complex(0, imaginary)`.
|
||||
@inlinable
|
||||
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 {
|
||||
@@ -206,3 +310,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,67 +0,0 @@
|
||||
# ``Complex``
|
||||
|
||||
A complex number type represented by its real and imaginary parts, and equipped
|
||||
with the usual arithmetic operators and math functions.
|
||||
|
||||
## Overview
|
||||
|
||||
You can access these Cartesian components using the real and imaginary
|
||||
properties.
|
||||
|
||||
```swift
|
||||
let z = Complex(1,-1) // 1 - i
|
||||
let re = z.real // 1
|
||||
let im = z.imaginary // -1
|
||||
```
|
||||
|
||||
All `Complex` numbers with a non-finite component are treated as a single
|
||||
"point at infinity," with infinite magnitude and indeterminant phase. Thus,
|
||||
the real and imaginary parts of an infinity are nan.
|
||||
|
||||
```swift
|
||||
let w = Complex<Double>.infinity
|
||||
w == -w // true
|
||||
let re = w.real // .nan
|
||||
let im = w.imag // .nan
|
||||
```
|
||||
|
||||
See <doc:Infinity> for more details.
|
||||
|
||||
The ``magnitude`` property of a complex number is the infinity norm of the
|
||||
value (a.k.a. “maximum norm” or “Чебышёв [Chebyshev] norm”). To get the two
|
||||
norm (a.k.a. "Euclidean norm"), use the ``length`` property. See
|
||||
<doc:Magnitude> for more details.
|
||||
|
||||
## Topics
|
||||
|
||||
### Real and imaginary parts
|
||||
|
||||
- ``real``
|
||||
- ``imaginary``
|
||||
- ``rawStorage``
|
||||
- ``init(_:_:)``
|
||||
- ``init(_:)-5aesj``
|
||||
- ``init(imaginary:)``
|
||||
|
||||
### Phase, length and magnitude
|
||||
|
||||
- ``magnitude``
|
||||
- ``length``
|
||||
- ``lengthSquared``
|
||||
- ``normalized``
|
||||
- ``phase``
|
||||
- ``polar``
|
||||
- ``init(length:phase:)``
|
||||
|
||||
### Scaling by real numbers
|
||||
- ``multiplied(by:)``
|
||||
- ``divided(by:)``
|
||||
|
||||
### Complex-specific operations
|
||||
- ``conjugate``
|
||||
|
||||
### Classification
|
||||
- ``isZero``
|
||||
- ``isSubnormal``
|
||||
- ``isNormal``
|
||||
- ``isFinite``
|
||||
@@ -1,88 +0,0 @@
|
||||
# ``ComplexModule``
|
||||
|
||||
Types and operations for working with complex numbers.
|
||||
|
||||
## Overview
|
||||
|
||||
### Representation
|
||||
|
||||
The `Complex` type is generic over an associated `RealType`; complex numbers
|
||||
are represented as two `RealType` values, the real and imaginary parts of the
|
||||
number.
|
||||
|
||||
```
|
||||
let z = Complex<Double>(1, 2)
|
||||
let re = z.real
|
||||
let im = z.imaginary
|
||||
```
|
||||
|
||||
### Memory layout
|
||||
|
||||
A `Complex` value is stored as two `RealType` values arranged consecutively
|
||||
in memory. Thus it has the same memory layout as:
|
||||
- A Fortran complex value built on the corresponding real type (as used
|
||||
by BLAS and LAPACK).
|
||||
- A C struct with real and imaginary parts and nothing else (as used by
|
||||
computational libraries predating C99).
|
||||
- A C99 `_Complex` value built on the corresponding real type.
|
||||
- A C++ `std::complex` value built on the corresponding real type.
|
||||
Functions taking complex arguments in these other languages are not
|
||||
automatically converted on import, but you can safely write shims that
|
||||
map them into Swift types by converting pointers.
|
||||
|
||||
### Real-Complex arithmetic
|
||||
|
||||
Because the real numbers are a subset of the complex numbers, many
|
||||
languages support arithmetic with mixed real and complex operands.
|
||||
For example, C allows the following:
|
||||
|
||||
```c
|
||||
#include <complex.h>
|
||||
double r = 1;
|
||||
double complex z = CMPLX(0, 2); // 2i
|
||||
double complex w = r + z; // 1 + 2i
|
||||
```
|
||||
|
||||
The `Complex` type does not provide such mixed operators:
|
||||
|
||||
```swift
|
||||
let r = 1.0
|
||||
let z = Complex(imaginary: 2.0)
|
||||
let w = r + z // error: binary operator '+' cannot be applied to operands of type 'Double' and 'Complex<Double>'
|
||||
```
|
||||
|
||||
In order to write the example from C above in Swift, you have to perform an
|
||||
explicit conversion:
|
||||
|
||||
```swift
|
||||
let r = 1.0
|
||||
let z = Complex(imaginary: 2.0)
|
||||
let w = Complex(r) + z // OK
|
||||
```
|
||||
|
||||
There are two reasons for this choice. Most importantly, Swift generally avoids
|
||||
mixed-type arithmetic. Second, if we _did_ provide such heterogeneous operators,
|
||||
it would lead to undesirable behavior in common expressions when combined with
|
||||
literal type inference. Consider the following example:
|
||||
|
||||
```swift
|
||||
let a: Double = 1
|
||||
let b = 2*a
|
||||
```
|
||||
|
||||
`b` ought to have type `Double`, but if we did have a Complex-by-Real `*`
|
||||
operation, `2*a` would either be ambiguous (if there were no type context),
|
||||
or be inferred to have type `Complex<Double>` (if the expression appeared
|
||||
in the context of an extension defined on `Complex`).
|
||||
|
||||
Note that we _do_ provide heterogeneous multiplication and division by a real
|
||||
value, spelled as ``Complex/divided(by:)`` and ``Complex/multiplied(by:)``
|
||||
to avoid ambiguity.
|
||||
|
||||
```swift
|
||||
let z = Complex<Double>(1,3)
|
||||
let w = z.multiplied(by: 2)
|
||||
```
|
||||
|
||||
These operations are generally more efficient than converting the scale to
|
||||
a complex number and then using `*` or `/`.
|
||||
@@ -1,140 +0,0 @@
|
||||
# Notes on Complex Division
|
||||
|
||||
A discussion of the algorithms used to implement complex division
|
||||
|
||||
## Overview
|
||||
|
||||
How does compute the quotient of two complex numbers z/w? The naïve schoolbook
|
||||
answer is to turn it into complex multiplication by scaling both numerator and
|
||||
denominator by the conjugate of w: z/w = (zw̅)/(ww̅) = (zw̅)/|w|². Translated
|
||||
directly into swift, this expression would become:
|
||||
|
||||
```swift
|
||||
extension Complex {
|
||||
func naïveDivision(_ z: Complex, _ w: Complex) -> Complex {
|
||||
(z * w.conjugate).divded(by: w.lengthSquared)
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
If both z and w are both "well-scaled" (i.e. their exponents are neither very
|
||||
large nor very small), then this expression works reasonably well when
|
||||
evaluated in floating-point. Cancellation may occur in the computation of
|
||||
either the real or the imaginary part of the zw̅ term, but not in both
|
||||
simultaneously, so the relative error in any vector norm is bounded by a
|
||||
small multiple of machine epsilon.
|
||||
|
||||
However, if z or w is not well-scaled, then either zw̅ or |w|² or both may
|
||||
underflow or overflow, even when the actual quotient may be perfectly
|
||||
representable. For example, if we have
|
||||
|
||||
```swift
|
||||
let a: Float = 1.84467441E+19 // large, but not outrageously large
|
||||
let z = Complex(a, a)
|
||||
let w = z
|
||||
```
|
||||
|
||||
then both `(z * w.conjugate)` and `w.lengthSquared` overflow, and the result
|
||||
of `naïveDivision` is `(NaN, NaN)` even though the actual mathematical quotient
|
||||
is 1.
|
||||
|
||||
At least `(NaN, NaN)` is obviously wrong; when intermediate results underflow
|
||||
instead of overflow, we can instead get bogus results that are not obvious at
|
||||
all. For example:
|
||||
|
||||
```swift
|
||||
let z = Complex<Float>(imaginary: 6.6174449e-24)
|
||||
let w = Complex<Float>(5.29395592e-23, 3.97046694e-23)
|
||||
let q = naïveDivision(z, w)
|
||||
```
|
||||
|
||||
`q` is computed as `(0.666666686, 0.666666686)`, which looks like a reasonable
|
||||
result, but the exact `z/w` would be `(0.6, 0.8)`; both the phase and magnitude
|
||||
of the computed result have large errors, and there is no indication that
|
||||
anything went wrong.
|
||||
|
||||
## Complex division in Swift Numerics
|
||||
|
||||
### Goals
|
||||
|
||||
Programming languages and libraries have developed a variety of approaches to
|
||||
handle this problem. Swift Numerics' approach is somewhat novel, so I will
|
||||
first lay out the considerations that lead us to it.
|
||||
|
||||
1. Division should be reasonably fast, and permit compiler optimizations that
|
||||
make it faster. So long as all inputs are well-scaled, it should not be
|
||||
much slower than multiplication.
|
||||
|
||||
2. Division should have the same error characteristics as multiplication;
|
||||
componentwise error bounds and correct rounding are non-goals. Good error
|
||||
bounds in a complex norm are what matters.
|
||||
|
||||
3. Division should not be any more sensitive to undue overflow or underflow
|
||||
than multiplication is (i.e. it is OK for results very near the boundaries
|
||||
to overflow or underflow even though the exact result would be
|
||||
representable, but results that are far from those boundaries should always
|
||||
be computed with good accuracy).
|
||||
|
||||
### Fast path
|
||||
|
||||
These considerations lead us to a first draft of our implementation; since we
|
||||
want division to be roughly like multiplication, we will "simply" turn it into
|
||||
a multiplication via the naïve formula:
|
||||
|
||||
```swift
|
||||
public static func /(z: Complex, w: Complex) -> Complex {
|
||||
let lenSq = w.lengthSquared
|
||||
guard lenSq.isNormal else { /* naive formula will not work */ }
|
||||
return z * w.conjugate.divided(by: lenSq)
|
||||
}
|
||||
```
|
||||
|
||||
if `lenSq` can be computed without overflow or underflow, then
|
||||
`w.conjugate.divided(by: lenSq)` is a (rounded) reciprocal `1/w`, and so
|
||||
multiplying that by `z` satisfies the goals that we laid out above. Note
|
||||
in particular that if we are dividing multiple values by a single divisor,
|
||||
the reciprocal is a constant, and this check only has to happen once.
|
||||
|
||||
That leaves us just needing to figure out what to do when the reciprocal
|
||||
is not well-scaled.
|
||||
|
||||
### Slow path
|
||||
|
||||
When an approximate reciprocal for the divisor is not representable, we use
|
||||
a scaling algorithm adapted from Doug Priest's "Efficient Scaling for
|
||||
Complex Division". In hand-wavy form, Priest's idea is:
|
||||
|
||||
1. choose a scale factor s ~ |w|^(-¾)
|
||||
2. let wʹ ← sw
|
||||
2. let zʹ ← sz
|
||||
|
||||
Note that we _can_ compute a reciprocal for wʹ without overflow or underflow,
|
||||
because |wʹ| ~ |w|^(¼), so |wʹ²| ~ |w|^(½) and so |w̅ʹ/wʹ²| ~ |w|^(-¼).¹
|
||||
To compute z/w, we compute zʹ/wʹ. sz might overflow or underflow, but only
|
||||
if the final computation would overflow or underflow anyway. This is because
|
||||
division by w is a dilation combined with a rotation; because |w| is bounded
|
||||
away from 1, the multiplication by s is a dilation if and only if division
|
||||
by w is also dilation (this is where we diverge from Priest; because he
|
||||
doesn't have a fast-path for well-scaled w, he has to handle this case
|
||||
carefully).
|
||||
|
||||
Like Priest, we arrange for s to be a power of the radix with the desired
|
||||
scale, which makes the computation of wʹ and zʹ exact (unless zʹ over- or
|
||||
underflows). This achieves one more desirable property: barring underflow,
|
||||
rescaling both w and z by the radix does not change results when we move
|
||||
between the fast and slow algorithms.
|
||||
|
||||
Instead of `zʹ/wʹ = zʹ(w̅ʹ/|wʹ|²)`, Priest uses `(zw″)/|wʹ|²`. There isn't
|
||||
a strong reason to favor one or the other numerically, but our formulation
|
||||
lets us preserve `z/w = z * w.reciprocal` under scaling by powers of the
|
||||
radix (up to the underflow boundary), which is somewhat nice to have, and
|
||||
allows us to extract a little bit more ILP in some cases.
|
||||
|
||||
----
|
||||
### Notes
|
||||
|
||||
¹ This analysis fails for types like Float16 where the number of
|
||||
significand bits is on the order of the greatest exponent because the desired
|
||||
s may not be representable if w is subnormal. Note that the problem is _only_
|
||||
in the representation of s, so we can handle this case by rescaling in two
|
||||
steps.
|
||||
@@ -1,55 +0,0 @@
|
||||
# Zero and infinity
|
||||
|
||||
Semantics of `Complex` zero and infinity values, and important considerations
|
||||
when porting code from other languages.
|
||||
|
||||
## Overview
|
||||
|
||||
Unlike C and C++'s complex types, `Complex` does not attempt to make a
|
||||
semantic distinction between different infinity and NaN values. Any `Complex`
|
||||
datum with a non-finite component is treated as the "point at infinity" on
|
||||
the Riemann sphere--a value with infinite magnitude and unspecified phase.
|
||||
|
||||
As a consequence, all values with either component infinite or NaN compare
|
||||
equal, and hash the same. Similarly, all zero values compare equal and hash
|
||||
the same.
|
||||
|
||||
### Rationale
|
||||
|
||||
This choice has some drawbacks,¹ but also some significant advantages.
|
||||
In particular, complex multiplication is the most common operation performed
|
||||
with a complex type, and one would like to be able to use the usual naive
|
||||
arithmetic implementation, consisting of four real multiplications and two
|
||||
real additions:
|
||||
|
||||
```
|
||||
(a + bi) * (c + di) = (ac - bd) + (ad + bc)i
|
||||
```
|
||||
|
||||
`Complex` can use this implementation, because we do not differentiate between
|
||||
infinities and NaN values. C and C++, by contrast, cannot use this
|
||||
implementation by default, because, for example:
|
||||
|
||||
```
|
||||
(1 + ∞i) * (0 - 2i) = (1*0 - ∞*(-2)) + (1*(-2) + ∞*0)i
|
||||
= (0 - ∞) + (-2 + nan)i
|
||||
= -∞ + nan i
|
||||
```
|
||||
|
||||
`Complex` treats this as "infinity", which is the correct result. C and C++
|
||||
treat it as a nan value, however, which is incorrect; infinity multiplied
|
||||
by a non-zero number should be infinity. Thus, C and C++ (by default) must
|
||||
detect these special cases and fix them up, which makes multiplication a
|
||||
more computationally expensive operation.²
|
||||
|
||||
### Footnotes:
|
||||
¹ W. Kahan, Branch Cuts for Complex Elementary Functions, or Much Ado
|
||||
About Nothing's Sign Bit. In A. Iserles and M.J.D. Powell, editors,
|
||||
_Proceedings The State of Art in Numerical Analysis_, pages 165–211, 1987.
|
||||
|
||||
² This can be addressed in C programs by use of the `STDC CX_LIMITED_RANGE`
|
||||
pragma, which instructs the compiler to simply not care about these cases.
|
||||
Unfortunately, this pragma is not often used in real C or C++ programs
|
||||
(though it does see some use in _libraries_). Programmers tend to specify
|
||||
`-ffast-math` or maybe `-ffinite-math-only` instead, which has other
|
||||
undesirable consequences.
|
||||
@@ -1,144 +0,0 @@
|
||||
# Magnitude and norms
|
||||
|
||||
Introduction to the concept of norm and discussion of the `Complex` type's
|
||||
`.magnitude` property.
|
||||
|
||||
## Overview
|
||||
|
||||
In mathematics, a *norm* is a function that gives each element of a vector
|
||||
space a non-negative length.¹
|
||||
|
||||
Many different norms can be defined on the complex numbers, viewed as a
|
||||
vector space over the reals. All of these norms have some basic
|
||||
properties. If we use *‖z‖* to represent any norm of *z*, it must:
|
||||
- be *subadditive* (a.k.a. satisfy the triangle inequalty):
|
||||
‖z + w‖ ≤ ‖z‖ + ‖w‖ for any two complex numbers z and w.
|
||||
- be *homogeneous*
|
||||
‖az‖ = |a|‖z‖ for any real number a and complex number z.
|
||||
- and be *positive definite*
|
||||
‖z‖ is zero if and only if z is zero.
|
||||
|
||||
The three most commonly-used norms are:
|
||||
- 1-norm ("taxicab norm"):
|
||||
‖x + iy‖₁ = |x| + |y|
|
||||
- 2-norm ("Euclidean norm"):
|
||||
‖x + iy‖₂ = √(x² + y²)
|
||||
- ∞-norm ("maximum norm" or "Чебышёв [Chebyshev] norm")²:
|
||||
‖x + iy‖ = max(|x|,|y|)
|
||||
|
||||
> Exercise:
|
||||
> 1. Check that these properties hold for one of the three norms
|
||||
that we just defined. (Hint: write z = a+bi and w = c+di,
|
||||
and use the fact that the absolute value is a norm on the
|
||||
real numbers, and therefore has the same property).
|
||||
|
||||
The `Complex` type gives special names to two of these norms; `length`
|
||||
for the 2-norm, and `magnitude` for the ∞-norm.
|
||||
|
||||
### Magnitude:
|
||||
|
||||
The `Numeric` protocol requires us to choose a norm to call `magnitude`,
|
||||
but does not give guidance as to which one we should pick. The easiest choice
|
||||
might have been the Euclidean norm; it's the one with which people are most
|
||||
likely to be familiar.
|
||||
|
||||
However, there are good reasons to make a different choice:
|
||||
- Computing the Euclidean norm requires special care to avoid spurious
|
||||
overflow/underflow (see implementation notes for `length` below). The
|
||||
naive expressions for the taxicab and maximum norm always give the best
|
||||
answer possible.
|
||||
- Even when special care is used, the Euclidean and taxicab norms are
|
||||
not necessarily representable. Both can be infinite even for finite
|
||||
numbers.
|
||||
|
||||
```swift
|
||||
let big = Double.greatestFiniteMagnitude
|
||||
let z = Complex(big, big)
|
||||
```
|
||||
|
||||
The taxicab norm of `z` would be `big + big`, which overflows; the
|
||||
Euclidean norm would be `sqrt(2) * big`, which also overflows.
|
||||
But the maximum norm is always equal to the magnitude of either `real`
|
||||
or `imaginary`, so it is necessarily representable.
|
||||
- The ∞-norm is the choice of established computational libraries, like
|
||||
BLAS and LAPACK.
|
||||
|
||||
For these reasons, the `magnitude` property of `Complex` binds the
|
||||
maximum norm:
|
||||
|
||||
```swift
|
||||
Complex(2, 3).magnitude // 3
|
||||
Complex(-1, 0.5).magnitude // 1
|
||||
```
|
||||
|
||||
### Length:
|
||||
|
||||
The `length` property of a `Complex` value is its Euclidean norm.
|
||||
|
||||
```swift
|
||||
Complex(2, 3).length // 3.605551275463989
|
||||
Complex(-1, 0.5).length // 1.118033988749895
|
||||
```
|
||||
|
||||
Aside from familiarity, the Euclidean norm has one important property
|
||||
that the maximum norm lacks:
|
||||
- it is *multiplicative*:
|
||||
‖zw‖₂ = ‖z‖₂‖w‖₂ for any two complex numbers z and w.
|
||||
|
||||
> Exercises:
|
||||
> 1. Find z and w that show that the maximum norm is not multiplicative.
|
||||
(i.e. exhibit z and w such that ‖zw‖ ≠ ‖z‖‖w‖.)
|
||||
> 2. Is the 1-norm multiplicative?
|
||||
|
||||
### Implementation notes:
|
||||
|
||||
The `length` property takes special care to produce an accurate answer,
|
||||
even when the value is poorly-scaled. The naive expression for `length`
|
||||
would be `sqrt(x*x + y*y)`, but this can overflow or underflow even when
|
||||
the final result should be a finite number.
|
||||
|
||||
```swift
|
||||
// Suppose that length were implemented like this:
|
||||
extension Complex {
|
||||
var naiveLength: RealType {
|
||||
.sqrt(real*real + imaginary*imaginary)
|
||||
}
|
||||
}
|
||||
|
||||
// Then taking the length of even a modestly large number:
|
||||
let z = Complex<Float>(1e20, 1e20)
|
||||
// or small number:
|
||||
let w = Complex<Float>(1e-24, 1e-24)
|
||||
// would overflow:
|
||||
z.naiveLength // Inf
|
||||
// or underflow:
|
||||
w.naiveLength // 0
|
||||
```
|
||||
|
||||
Instead, `length` is implemented using a two-step algorithm. First we
|
||||
compute `lengthSquared`, which is `x*x + y*y`. If this is a normal
|
||||
number (meaning that no overflow or underflow has occured), we can safely
|
||||
return its square root. Otherwise, we redo the computation with a more
|
||||
careful computation, which avoids spurious under- or overflow:
|
||||
|
||||
```swift
|
||||
let z = Complex<Float>(1e20, 1e20)
|
||||
let w = Complex<Float>(1e-24, 1e-24)
|
||||
z.length // 1.41421358E+20
|
||||
w.length // 1.41421362E-24
|
||||
```
|
||||
|
||||
### Footnotes:
|
||||
|
||||
¹ Throughout this documentation, "norm" refers to a
|
||||
[vector norm](https://en.wikipedia.org/wiki/Norm_(mathematics)).
|
||||
To confuse the matter, there are several similar things also called
|
||||
"norm" in mathematics. The other one you are most likely to run into
|
||||
is the [field norm](https://en.wikipedia.org/wiki/Field_norm).
|
||||
|
||||
Field norms are much less common than vector norms, but the C++
|
||||
`std::norm` operation implements a field norm. To get the (Euclidean)
|
||||
vector norm in C++, use `std::abs`.
|
||||
|
||||
² There's no subscript-∞ in unicode, so I write the infinity norm
|
||||
without the usual subscript.
|
||||
+10
-23
@@ -1,8 +1,8 @@
|
||||
//===--- Complex+ElementaryFunctions.swift --------------------*- swift -*-===//
|
||||
//===--- ElementaryFunctions.swift ----------------------------*- swift -*-===//
|
||||
//
|
||||
// This source file is part of the Swift Numerics open source project
|
||||
// This source file is part of the Swift.org open source project
|
||||
//
|
||||
// Copyright (c) 2019-2025 Apple Inc. and the Swift Numerics project authors
|
||||
// Copyright (c) 2019-2020 Apple Inc. and the Swift project authors
|
||||
// Licensed under Apache License v2.0 with Runtime Library Exception
|
||||
//
|
||||
// See https://swift.org/LICENSE.txt for license information
|
||||
@@ -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)
|
||||
)
|
||||
}
|
||||
@@ -141,10 +141,7 @@ extension Complex: ElementaryFunctions {
|
||||
public static func cosh(_ z: Complex) -> Complex {
|
||||
guard z.isFinite else { return z }
|
||||
guard z.x.magnitude < -RealType.log(.ulpOfOne) else {
|
||||
let phase = Complex(
|
||||
RealType.cos(z.y),
|
||||
RealType(signOf: z.x, magnitudeOf: 1) * RealType.sin(z.y)
|
||||
)
|
||||
let phase = Complex(RealType.cos(z.y), RealType.sin(z.y))
|
||||
let firstScale = RealType.exp(z.x.magnitude/2)
|
||||
let secondScale = firstScale/2
|
||||
return phase.multiplied(by: firstScale).multiplied(by: secondScale)
|
||||
@@ -167,19 +164,16 @@ 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
|
||||
public static func sinh(_ z: Complex) -> Complex {
|
||||
guard z.isFinite else { return z }
|
||||
guard z.x.magnitude < -RealType.log(.ulpOfOne) else {
|
||||
let phase = Complex(
|
||||
RealType(signOf: z.x, magnitudeOf: RealType.cos(z.y)),
|
||||
RealType.sin(z.y)
|
||||
)
|
||||
let phase = Complex(RealType.cos(z.y), RealType.sin(z.y))
|
||||
let firstScale = RealType.exp(z.x.magnitude/2)
|
||||
let secondScale = firstScale/2
|
||||
let secondScale = RealType(signOf: z.x, magnitudeOf: firstScale/2)
|
||||
return phase.multiplied(by: firstScale).multiplied(by: secondScale)
|
||||
}
|
||||
return Complex(
|
||||
@@ -306,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, θ)
|
||||
}
|
||||
@@ -419,21 +413,14 @@ extension Complex: ElementaryFunctions {
|
||||
}
|
||||
|
||||
// MARK: - pow-like functions
|
||||
/// `exp(w*log(z))`
|
||||
///
|
||||
/// Edge cases for this function are defined according to the defining
|
||||
/// expression exp(w log(z)), except that we define pow(0, w) to be 0
|
||||
/// instead of infinity when w is in the (strict) right half-plane, so that
|
||||
/// we agree with RealType.pow on the positive real line.
|
||||
@inlinable
|
||||
public static func pow(_ z: Complex, _ w: Complex) -> Complex {
|
||||
if z.isZero { return w.real > 0 ? zero : infinity }
|
||||
return exp(w * log(z))
|
||||
}
|
||||
|
||||
@inlinable
|
||||
public static func pow(_ z: Complex, _ n: Int) -> Complex {
|
||||
if z.isZero { return n < 0 ? infinity : n == 0 ? one : zero }
|
||||
if z.isZero { return .zero }
|
||||
// TODO: this implementation is not quite correct, because n may be
|
||||
// rounded in conversion to RealType. This only effects very extreme
|
||||
// cases, so we'll leave it alone for now.
|
||||
@@ -1,130 +0,0 @@
|
||||
//===--- Polar.swift ------------------------------------------*- swift -*-===//
|
||||
//
|
||||
// This source file is part of the Swift Numerics open source project
|
||||
//
|
||||
// Copyright (c) 2019-2025 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).
|
||||
///
|
||||
/// 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. See <doc:Magnitude> for more details.
|
||||
///
|
||||
/// Edge cases:
|
||||
/// - If a complex value is not finite, its `length` is `infinity`.
|
||||
///
|
||||
/// See also ``lengthSquared``, ``phase``, ``polar``
|
||||
/// and ``init(length:phase:)``.
|
||||
@_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.
|
||||
///
|
||||
/// Note that because of how `lengthSquared` is used, it is a primary
|
||||
/// design goal that it be as fast as possible. Therefore, it does not
|
||||
/// normalize infinities, and may return either `.infinity` or `.nan`
|
||||
/// for non-finite values.
|
||||
@_transparent
|
||||
public var lengthSquared: RealType {
|
||||
x*x + y*y
|
||||
}
|
||||
|
||||
/// 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.
|
||||
///
|
||||
/// See also ``length``, ``polar`` and ``init(length:phase:)``.
|
||||
@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(length:phase:)``.
|
||||
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)
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -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.
|
||||
|
||||
@@ -1,41 +0,0 @@
|
||||
//===--- Scale.swift ------------------------------------------*- swift -*-===//
|
||||
//
|
||||
// This source file is part of the Swift Numerics open source project
|
||||
//
|
||||
// Copyright (c) 2019-2025 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.
|
||||
|
||||
extension Complex {
|
||||
/// The result of multiplying this value by the real number `a`.
|
||||
///
|
||||
/// Equivalent to `self * Complex(a)`, but may be computed more efficiently.
|
||||
@inlinable @inline(__always)
|
||||
public func multiplied(by a: RealType) -> Complex {
|
||||
Complex(x*a, y*a)
|
||||
}
|
||||
|
||||
/// The result of dividing this value by the real number `a`.
|
||||
///
|
||||
/// More efficient than `self / Complex(a)`. May not produce exactly the
|
||||
/// same result, but will always be more accurate if they differ.
|
||||
@inlinable @inline(__always)
|
||||
public func divided(by a: RealType) -> Complex {
|
||||
Complex(x/a, y/a)
|
||||
}
|
||||
}
|
||||
@@ -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,325 +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`.
|
||||
///
|
||||
/// By default, this function uses ``RoundingRule/down``, which **is not
|
||||
/// the same** as the rounding of the `/` operator from the Swift standard
|
||||
/// library. They agree when the signs of the arguments match, but produce
|
||||
/// different results when the quotient is negative. This behavior is
|
||||
/// chosen because it generally produces a more useful remainder; in
|
||||
/// particular, when the divisor is positive, the remainder is always
|
||||
/// positive. To match the behavior of `/`, use ``RoundingRule/towardZero``.
|
||||
///
|
||||
/// Note that the remainder of division is not always representable in an
|
||||
/// unsigned type if a rounding rule other than ``RoundingRule/down``,
|
||||
/// ``RoundingRule/towardZero``, or ``RoundingRule/requireExact`` is
|
||||
/// used. For example:
|
||||
/// ```swift
|
||||
/// 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 the `SignedInteger` protocol is extended with
|
||||
/// ``SignedInteger/divided(by:rounding:)`` returning 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 .awayFromZero:
|
||||
break
|
||||
|
||||
case .toNearestOrDown:
|
||||
if r.magnitude > other.magnitude.shifted(rightBy: 1, rounding: .down) ||
|
||||
2*r.magnitude == other.magnitude && other.signum() != r.signum() {
|
||||
break
|
||||
}
|
||||
return q
|
||||
|
||||
case .toNearestOrUp:
|
||||
if r.magnitude > other.magnitude.shifted(rightBy: 1, rounding: .down) ||
|
||||
2*r.magnitude == other.magnitude && other.signum() == r.signum() {
|
||||
break
|
||||
}
|
||||
return q
|
||||
|
||||
case .toNearestOrZero:
|
||||
if r.magnitude <= other.magnitude.shifted(rightBy: 1, rounding: .down) {
|
||||
return q
|
||||
}
|
||||
// Otherwise, round q away from zero.
|
||||
|
||||
case .toNearestOrAway:
|
||||
if r.magnitude < other.magnitude.shifted(rightBy: 1, rounding: .up) {
|
||||
return q
|
||||
}
|
||||
|
||||
case .toNearestOrEven:
|
||||
// First guarantee that |r| <= |other/2|; if not we have to round away
|
||||
// instead, so break to do that.
|
||||
if r.magnitude > other.magnitude.shifted(rightBy: 1, rounding: .down) ||
|
||||
2*r.magnitude == other.magnitude && !q.isMultiple(of: 2) {
|
||||
break
|
||||
}
|
||||
return q
|
||||
|
||||
case .toOdd:
|
||||
// If q is already odd, we have the correct result.
|
||||
if q._lowWord & 1 == 1 { return q }
|
||||
|
||||
case .requireExact:
|
||||
preconditionFailure("Division was not exact.")
|
||||
}
|
||||
|
||||
// We didn't have the right result, so round q away from zero.
|
||||
return other.signum() == r.signum() ? q+1 : q-1
|
||||
}
|
||||
|
||||
// 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 ``RoundingRule/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 ``RoundingRule/towardZero``.
|
||||
///
|
||||
/// - 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 ``RoundingRule/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 ``RoundingRule/towardZero``.
|
||||
///
|
||||
/// 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.
|
||||
return other.signum() == r.signum() ? (q, r) : (q-1, r+other)
|
||||
|
||||
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.
|
||||
return other.signum() == r.signum() ? (q+1, r-other) : (q, r)
|
||||
|
||||
case .towardZero:
|
||||
// This is exactly what the `/` operator did for us.
|
||||
return (q, r)
|
||||
|
||||
case .awayFromZero:
|
||||
break
|
||||
|
||||
case .toNearestOrDown:
|
||||
// If |r| < |other/2|, we already rounded q to nearest. If the are
|
||||
// equal and q is negative, then we already broke the tie in the right
|
||||
// direction. However, we don't have access to the before-rounding q,
|
||||
// which may have rounded up to zero, losing the sign information, so
|
||||
// we have to look at other and r instead.
|
||||
if 2*r.magnitude < other.magnitude ||
|
||||
2*r.magnitude == other.magnitude && other.signum() == r.signum() {
|
||||
return (q, r)
|
||||
}
|
||||
|
||||
case .toNearestOrUp:
|
||||
// If |r| < |other/2|, we already rounded q to nearest. If the are
|
||||
// equal and q is non-negative, then we already broke the tie in the
|
||||
// right direction.
|
||||
if 2*r.magnitude < other.magnitude ||
|
||||
2*r.magnitude == other.magnitude && other.signum() != r.signum() {
|
||||
return (q, r)
|
||||
}
|
||||
|
||||
case .toNearestOrZero:
|
||||
// Check first if |r| <= |other/2|. If this holds, we have already
|
||||
// rounded q correctly. Because we're working with magnitudes, we can
|
||||
// safely compute 2r without worrying about overflow, even for fixed-
|
||||
// width types, because r cannot be .min (because |r| < |other| by
|
||||
// construction).
|
||||
if 2*r.magnitude <= other.magnitude {
|
||||
return (q, r)
|
||||
}
|
||||
|
||||
case .toNearestOrAway:
|
||||
// Check first if |r| < |other/2|. If this holds, we already rounded
|
||||
// q to nearest.
|
||||
if 2*r.magnitude < other.magnitude {
|
||||
return (q, r)
|
||||
}
|
||||
|
||||
case .toNearestOrEven:
|
||||
// If |r| < |other/2|, we already rounded q to nearest. If the are
|
||||
// equal and q is even, then we already broke the tie in the right
|
||||
// direction.
|
||||
if 2*r.magnitude < other.magnitude ||
|
||||
2*r.magnitude == other.magnitude && q.isMultiple(of: 2) {
|
||||
return (q, r)
|
||||
}
|
||||
|
||||
case .toOdd:
|
||||
// If q is already odd, we have the correct result.
|
||||
if q._lowWord & 1 == 1 { return (q, r) }
|
||||
|
||||
case .requireExact:
|
||||
preconditionFailure("Division was not exact.")
|
||||
}
|
||||
|
||||
// Fallthrough behavior is to round q away from zero and adjust r to
|
||||
// match.
|
||||
return other.signum() == r.signum() ? (q+1, r-other) : (q-1, r+other)
|
||||
}
|
||||
}
|
||||
|
||||
/// `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`.
|
||||
public func euclideanDivision<T>(_ a: T, _ b: T) -> (quotient: T, remainder: T)
|
||||
where T: SignedInteger
|
||||
{
|
||||
a.divided(by: b, rounding: a >= 0 ? .towardZero : .awayFromZero)
|
||||
}
|
||||
@@ -1,40 +0,0 @@
|
||||
//===--- GCD.swift --------------------------------------------*- swift -*-===//
|
||||
//
|
||||
// This source file is part of the Swift Numerics open source project
|
||||
//
|
||||
// Copyright (c) 2021-2024 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][gcd] 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
|
||||
///
|
||||
/// [gcd]: https://en.wikipedia.org/wiki/Greatest_common_divisor
|
||||
@inlinable
|
||||
public func gcd<T: BinaryInteger>(_ a: T, _ b: T) -> T {
|
||||
var x = a
|
||||
var y = b
|
||||
if x.magnitude < y.magnitude { swap(&x, &y) }
|
||||
// Avoid overflow when x = signed min, y = -1.
|
||||
if y.magnitude == 1 { return 1 }
|
||||
// Euclidean algorithm for GCD. It's worth using Lehmer instead for larger
|
||||
// integer types, but for now this is good and dead-simple and faster than
|
||||
// the other obvious choice, the binary algorithm.
|
||||
while y != 0 { (x, y) = (y, x%y) }
|
||||
// Try to convert result to T.
|
||||
if let result = T(exactly: x.magnitude) { return result }
|
||||
// If that fails, produce a diagnostic.
|
||||
fatalError("GCD (\(x)) is not representable as \(T.self).")
|
||||
}
|
||||
@@ -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:)
|
||||
@@ -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))
|
||||
}
|
||||
}
|
||||
@@ -1,266 +0,0 @@
|
||||
//===--- RoundingRule.swift -----------------------------------*- swift -*-===//
|
||||
//
|
||||
// This source file is part of the Swift Numerics open source project
|
||||
//
|
||||
// Copyright (c) 2021-2025 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:
|
||||
/// ```
|
||||
/// Directed rounding rules
|
||||
///
|
||||
/// value | down | up | towardZero | awayFromZero |
|
||||
/// =======+==============+==============+==============+==============+
|
||||
/// -1.5 | -2 | -1 | -1 | -2 |
|
||||
/// -------+--------------+--------------+--------------+--------------+
|
||||
/// -0.5 | -1 | 0 | 0 | -1 |
|
||||
/// -------+--------------+--------------+--------------+--------------+
|
||||
/// 0.5 | 0 | 1 | 0 | 1 |
|
||||
/// -------+--------------+--------------+--------------+--------------+
|
||||
/// 0.7 | 0 | 1 | 0 | 1 |
|
||||
/// -------+--------------+--------------+--------------+--------------+
|
||||
/// 1.2 | 1 | 2 | 1 | 2 |
|
||||
/// -------+--------------+--------------+--------------+--------------+
|
||||
/// 2.0 | 2 | 2 | 2 | 2 |
|
||||
/// -------+--------------+--------------+--------------+--------------+
|
||||
///
|
||||
/// toNearestOr... rounding rules
|
||||
///
|
||||
/// value | orDown | orUp | orZero | orAway | orEven |
|
||||
/// =======+==========+==========+==========+==========+==========+
|
||||
/// -1.5 | -2 | -1 | -1 | -2 | -2 |
|
||||
/// -------+----------+----------+----------+----------+----------+
|
||||
/// -0.5 | -1 | 0 | 0 | -1 | 0 |
|
||||
/// -------+----------+----------+----------+----------+----------+
|
||||
/// 0.5 | 0 | 1 | 0 | 1 | 0 |
|
||||
/// -------+----------+----------+----------+----------+----------+
|
||||
/// 0.7 | 1 | 1 | 1 | 1 | 1 |
|
||||
/// -------+----------+----------+----------+----------+----------+
|
||||
/// 1.2 | 1 | 1 | 1 | 1 | 1 |
|
||||
/// -------+----------+----------+----------+----------+----------+
|
||||
/// 2.0 | 2 | 2 | 2 | 2 | 2 |
|
||||
/// -------+----------+----------+----------+----------+----------+
|
||||
///
|
||||
/// Specialized rounding rules
|
||||
///
|
||||
/// value | toOdd | requireExact |
|
||||
/// =======+==============+================+
|
||||
/// -1.5 | -1 | trap |
|
||||
/// -------+--------------+----------------+
|
||||
/// -0.5 | -1 | trap |
|
||||
/// -------+--------------+----------------+
|
||||
/// 0.5 | 1 | trap |
|
||||
/// -------+--------------+----------------+
|
||||
/// 0.7 | 1 | trap |
|
||||
/// -------+--------------+----------------+
|
||||
/// 1.2 | 1 | trap |
|
||||
/// -------+--------------+----------------+
|
||||
/// 2.0 | 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 is less than
|
||||
/// the value being rounded is chosen.
|
||||
///
|
||||
/// Examples:
|
||||
/// - `(-4).divided(by: 3, rounding: .toNearestOrDown)`
|
||||
/// is `-1`, because –4/3 = –1.3̅ is closer to –1 than it is to –2.
|
||||
///
|
||||
/// - `5.shifted(rightBy: 1, rounding: .toNearestOrDown)` is `2`,
|
||||
/// because 5/2 = 2.5 is equally close to 2 and 3, and 2 is less.
|
||||
case toNearestOrDown
|
||||
|
||||
/// Produces the representable value that is closest to the value being
|
||||
/// rounded. If two values are equally close, the one that is greater than
|
||||
/// the value being rounded is chosen.
|
||||
///
|
||||
/// Examples:
|
||||
/// - `(-4).divided(by: 3, rounding: .toNearestOrUp)`
|
||||
/// is `-1`, because –4/3 = –1.3̅ is closer to –1 than it is to –2.
|
||||
///
|
||||
/// - `5.shifted(rightBy: 1, rounding: .toNearestOrUp)` is `3`,
|
||||
/// because 5/2 = 2.5 is equally close to 2 and 3, and 3 is greater.
|
||||
case toNearestOrUp
|
||||
|
||||
/// Produces the representable value that is closest to the value being
|
||||
/// rounded. If two values are equally close, the one that has smaller
|
||||
/// magnitude is returned.
|
||||
///
|
||||
/// Examples:
|
||||
/// - `(-4).divided(by: 3, rounding: .toNearestOrZero)`
|
||||
/// is `-1`, because –4/3 = –1.3̅ is closer to –1 than it is to –2.
|
||||
///
|
||||
/// - `5.shifted(rightBy: 1, rounding: .toNearestOrZero)` is `2`,
|
||||
/// because 5/2 = 2.5 is equally close to 2 and 3, and 2 is closer to zero.
|
||||
case toNearestOrZero
|
||||
|
||||
/// 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: .toNearestOrAway)`
|
||||
/// is `-1`, because –4/3 = –1.3̅ is closer to –1 than it is to –2.
|
||||
///
|
||||
/// - `5.shifted(rightBy: 1, rounding: .toNearestOrAway)` is `3`,
|
||||
/// because 5/2 = 2.5 is equally close to 2 and 3, and 3 is further away
|
||||
/// from zero.
|
||||
case toNearestOrAway
|
||||
|
||||
/// 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
|
||||
|
||||
/// 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
|
||||
}
|
||||
|
||||
extension RoundingRule {
|
||||
/// 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.
|
||||
///
|
||||
/// > Deprecated: Use `.toNearestOrAway` instead.
|
||||
@inlinable
|
||||
@available(*, deprecated, renamed: "toNearestOrAway")
|
||||
public static var toNearestOrAwayFromZero: Self { .toNearestOrAway }
|
||||
}
|
||||
|
||||
extension FloatingPoint {
|
||||
/// `self` rounded to integer according to `rule`.
|
||||
///
|
||||
/// This mirrors the standard library `rounded` API, providing access to
|
||||
/// the expanded set of rounding rules defined in IntegerUtilities. It is
|
||||
/// not just a shadow because that would lead to ambiguity errors in
|
||||
/// existing code that uses the shortened `rounded(.down)` form.
|
||||
@inlinable @inline(__always)
|
||||
public func rounding(_ rule: RoundingRule) -> Self {
|
||||
switch rule {
|
||||
case .down:
|
||||
return rounded(.down)
|
||||
case .up:
|
||||
return rounded(.up)
|
||||
case .towardZero:
|
||||
return rounded(.towardZero)
|
||||
case .awayFromZero:
|
||||
return rounded(.awayFromZero)
|
||||
case .toNearestOrDown:
|
||||
// FP doesn't have toNearestOrDown, so round toNearestOrEven and fixup
|
||||
// any exact-halfway cases.
|
||||
let nearest = rounded(.toNearestOrEven)
|
||||
return nearest - self == 1/2 ? rounded(.down) : nearest
|
||||
case .toNearestOrUp:
|
||||
// FP doesn't have toNearestOrUp, so round toNearestOrEven and fixup
|
||||
// any exact-halfway cases.
|
||||
let nearest = rounded(.toNearestOrEven)
|
||||
return self - nearest == 1/2 ? rounded(.up) : nearest
|
||||
case .toNearestOrZero:
|
||||
// FP doesn't have toNearestOrZero, so round toNearestOrEven and fixup
|
||||
// any exact-halfway cases.
|
||||
let nearest = rounded(.toNearestOrEven)
|
||||
return (self - nearest).magnitude == 1/2 ? rounded(.towardZero) : nearest
|
||||
case .toNearestOrAway:
|
||||
return self.rounded(.toNearestOrAwayFromZero)
|
||||
case .toNearestOrEven:
|
||||
return self.rounded(.toNearestOrEven)
|
||||
case .toOdd:
|
||||
let trunc = rounded(.towardZero)
|
||||
if trunc == self { return trunc }
|
||||
let one = Self(signOf: self, magnitudeOf: 1)
|
||||
// We have eliminated all large values at this point; add ±0.5, and see
|
||||
// which way that rounds, then select the other value.
|
||||
let even = (trunc + one/2).rounded(.toNearestOrEven)
|
||||
return trunc == even ? trunc + one : trunc
|
||||
case .requireExact:
|
||||
let trunc = rounded(.towardZero)
|
||||
precondition(isInfinite || trunc == self, "\(self) is not an exact integer.")
|
||||
return self
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -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)
|
||||
/// ```
|
||||
///
|
||||
/// If the "normal addition" `self + other` does not trap,
|
||||
/// this method 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.
|
||||
///
|
||||
/// If the "normal subtraction" `self - other` does not trap,
|
||||
/// this method 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)
|
||||
/// ```
|
||||
///
|
||||
/// If the "normal multiplication" `self * other` does not trap,
|
||||
/// this method 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 shift 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:)`, defined on `BinaryInteger`, 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,175 +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 ``RoundingRule/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)
|
||||
///
|
||||
/// // 6/4 = 1.5, so the tie is broken in favor of the even value 2.
|
||||
/// 6.shifted(rightBy: 2, rounding: .toNearestOrEven)
|
||||
///
|
||||
/// // 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)
|
||||
let half: Magnitude = (1 as Magnitude) << (count &- 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 .toNearestOrDown:
|
||||
return floor + Self((lost + (half - 1)) >> count)
|
||||
case .toNearestOrUp:
|
||||
return floor + Self((lost + half) >> count)
|
||||
case .toNearestOrZero:
|
||||
let round = half - (self < 0 ? 0 : 1)
|
||||
return floor + Self((round + lost) >> count)
|
||||
case .toNearestOrAway:
|
||||
let round = half - (self > 0 ? 0 : 1)
|
||||
return floor + Self((round + lost) >> count)
|
||||
case .toNearestOrEven:
|
||||
let round = mask >> 1 + Magnitude(floor & 1)
|
||||
return floor + Self((round + lost) >> count)
|
||||
case .toOdd:
|
||||
return floor | (lost == 0 ? 0 : 1)
|
||||
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 ``RoundingRule/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)
|
||||
///
|
||||
/// // 6/4 = 1.5, so the tie is broken in favor of the even value 2.
|
||||
/// 6.shifted(rightBy: 2, rounding: .toNearestOrEven)
|
||||
///
|
||||
/// // 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)
|
||||
}
|
||||
}
|
||||
@@ -20,7 +20,6 @@ target_compile_options(Numerics PUBLIC
|
||||
-Xfrontend -validate-tbd-against-ir=none)
|
||||
target_link_libraries(Numerics PUBLIC
|
||||
ComplexModule
|
||||
IntegerUtilities
|
||||
RealModule)
|
||||
|
||||
|
||||
|
||||
@@ -10,6 +10,5 @@
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
// A module that re-exports the complete Swift Numerics public API.
|
||||
@_exported import ComplexModule
|
||||
@_exported import IntegerUtilities
|
||||
@_exported import RealModule
|
||||
@_exported import ComplexModule
|
||||
@@ -2,7 +2,7 @@
|
||||
//
|
||||
// This source file is part of the Swift Numerics open source project
|
||||
//
|
||||
// Copyright (c) 2019-2025 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
|
||||
@@ -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:
|
||||
///
|
||||
@@ -32,16 +32,20 @@
|
||||
/// Because integer multiplication does not form a group; it's commutative and
|
||||
/// associative, but integers do not have multiplicative inverses.
|
||||
/// I.e. if a is any integer other than 1 or -1, there is no integer b such
|
||||
/// that `a*b = 1`. The existence of inverses is requried to form a field.
|
||||
/// that a*b = 1. The existence of inverses is requried to form a field.
|
||||
///
|
||||
/// If a type `T` conforms to the ``Real`` protocol, then `T` and `Complex<T>`
|
||||
/// If a type `T` conforms to the `Real` protocol, then `T` and `Complex<T>`
|
||||
/// both conform to `AlgebraicField`.
|
||||
///
|
||||
/// See also Swift's `SignedNumeric`, `Numeric` and `AdditiveArithmetic`
|
||||
/// protocols.
|
||||
/// See Also:
|
||||
/// -
|
||||
/// - Real
|
||||
/// - SignedNumeric
|
||||
/// - Numeric
|
||||
/// - AdditiveArithmetic
|
||||
///
|
||||
/// [field]: https://en.wikipedia.org/wiki/Field_(mathematics)
|
||||
public protocol AlgebraicField: SignedNumeric where Magnitude: AlgebraicField {
|
||||
public protocol AlgebraicField: SignedNumeric {
|
||||
|
||||
/// Replaces a with the (approximate) quotient `a/b`.
|
||||
static func /=(a: inout Self, b: Self)
|
||||
@@ -52,11 +56,6 @@ public protocol AlgebraicField: SignedNumeric where Magnitude: AlgebraicField {
|
||||
/// 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,
|
||||
@@ -66,17 +65,17 @@ public protocol AlgebraicField: SignedNumeric where Magnitude: AlgebraicField {
|
||||
/// 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:
|
||||
/// ```
|
||||
@@ -90,12 +89,6 @@ public protocol AlgebraicField: SignedNumeric where Magnitude: AlgebraicField {
|
||||
/// }
|
||||
/// ```
|
||||
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 {
|
||||
@@ -106,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
|
||||
}
|
||||
}
|
||||
@@ -2,7 +2,7 @@
|
||||
//
|
||||
// This source file is part of the Swift Numerics open source project
|
||||
//
|
||||
// Copyright (c) 2020-2025 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,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).
|
||||
///
|
||||
@@ -47,10 +48,12 @@ extension Numeric where Magnitude: FloatingPoint {
|
||||
/// property implements a valid norm.)
|
||||
///
|
||||
/// - `isApproximatelyEqual(to:relativeTolerance:norm:)` is _scale invariant_,
|
||||
/// so long as no underflow or overflow has occurred, and no exceptional
|
||||
/// 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:
|
||||
///
|
||||
@@ -218,7 +227,7 @@ extension AdditiveArithmetic {
|
||||
/// norm: \.length
|
||||
/// )
|
||||
/// ```
|
||||
/// (if we used the default norm, `\.magnitude`, we would be testing if
|
||||
/// (if we used the default norm, `.magnitude`, we would be testing if
|
||||
/// `z` were inside a square region instead.)
|
||||
@inlinable
|
||||
public func isApproximatelyEqual<Magnitude>(
|
||||
@@ -227,6 +236,12 @@ extension AdditiveArithmetic {
|
||||
relativeTolerance: Magnitude = 0,
|
||||
norm: (Self) -> Magnitude
|
||||
) -> Bool
|
||||
// TODO: constraint should really be weaker than FloatingPoint,
|
||||
// but we need to have `isFinite` for it to work correctly with
|
||||
// floating-point magnitudes in generic contexts, which is the
|
||||
// most common case. The fix for this is to lift the isFinite
|
||||
// requirement to Numeric in the standard library, but that's
|
||||
// source-breaking, so requires an ABI rumspringa.
|
||||
where Magnitude: FloatingPoint {
|
||||
assert(
|
||||
absoluteTolerance >= 0 && absoluteTolerance.isFinite,
|
||||
|
||||
@@ -2,13 +2,19 @@
|
||||
//
|
||||
// This source file is part of the Swift Numerics open source project
|
||||
//
|
||||
// Copyright (c) 2020-2025 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
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
/// A namespace for "augmented arithmetic" operations for types conforming to
|
||||
/// `Real`.
|
||||
///
|
||||
/// Augmented arithmetic refers to a family of algorithms that represent
|
||||
/// the results of floating-point computations using multiple values such that
|
||||
/// either the error is minimized or the result is exact.
|
||||
public enum Augmented { }
|
||||
|
||||
extension Augmented {
|
||||
@@ -22,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`).
|
||||
@@ -33,15 +39,13 @@ 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
|
||||
/// equal to `head + tail` when computed as real numbers.
|
||||
@_transparent
|
||||
public static func product<T:FloatingPoint>(
|
||||
_ a: T, _ b: T
|
||||
) -> (head: T, tail: T) {
|
||||
public static func product<T:Real>(_ a: T, _ b: T) -> (head: T, tail: T) {
|
||||
let head = a*b
|
||||
// TODO: consider providing an FMA-less implementation for use when
|
||||
// targeting platforms without hardware FMA support. This works everywhere,
|
||||
@@ -52,97 +56,51 @@ extension Augmented {
|
||||
|
||||
/// The sum `a + b` represented as an implicit sum `head + tail`.
|
||||
///
|
||||
/// - Parameters:
|
||||
/// - a: The summand with larger magnitude.
|
||||
/// - b: The summand with smaller magnitude.
|
||||
///
|
||||
/// `head` is the correctly rounded value of `a + b`. `tail` is the
|
||||
/// error from that computation rounded to the closest representable
|
||||
/// value.
|
||||
///
|
||||
/// > Note:
|
||||
/// > `tail` is guaranteed to be the best approximation to the error of
|
||||
/// the sum only if `large.magnitude` >= `small.magnitude`. If this is
|
||||
/// not the case, then `head` is the correctly rounded sum, but `tail`
|
||||
/// is not guaranteed to be the exact error. If you do not know a priori
|
||||
/// how the magnitudes of `a` and `b` compare, you likely want to use
|
||||
/// ``sum(_:_:)`` instead.
|
||||
/// Unlike `Augmented.product(a, b)`, the rounding error of a sum can
|
||||
/// never underflow. However, it may not be exactly representable when
|
||||
/// `a` and `b` differ widely in magnitude.
|
||||
///
|
||||
/// Unlike ``product(_:_:)``, the rounding error of `sum` never underflows.
|
||||
/// 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.
|
||||
///
|
||||
/// > Note:
|
||||
/// > Classical fastTwoSum does not work when `radix` is 10. This function
|
||||
/// will fall back on another algorithm for decimal floating-point types
|
||||
/// to ensure correct results.
|
||||
/// 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: FloatingPoint>(
|
||||
large a: T, small b: T
|
||||
) -> (head: T, tail: T) {
|
||||
// Fall back on 2Sum if radix != 2. Future implementations might use an
|
||||
// cheaper algorithm specialized for decimal FP, but must deliver a
|
||||
// correct result if the preconditions are satisfied.
|
||||
guard T.radix == 2 else { return sum(a, b) }
|
||||
// Fast2Sum:
|
||||
public static func sum<T:Real>(large a: T, small b: T) -> (head: T, tail: T) {
|
||||
assert(!(b.magnitude > a.magnitude))
|
||||
let head = a + b
|
||||
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.
|
||||
///
|
||||
/// The magnitude of the summands does not change the result of this
|
||||
/// operation. If you know statically that `a.magnitude >= b.magnitude`,
|
||||
/// you may want to consider using ``sum(large:small:)`` to get the same
|
||||
/// result somewhat more efficiently. If you do not have such a static
|
||||
/// bound, you usually want to use this function instead.
|
||||
///
|
||||
/// Unlike ``product(_:_:)``, the rounding error of `sum` never underflows.
|
||||
///
|
||||
/// This operation is sometimes called ["twoSum"].
|
||||
///
|
||||
/// - Parameters:
|
||||
/// - a: One of the summands
|
||||
/// - 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: FloatingPoint>(
|
||||
_ 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)
|
||||
}
|
||||
}
|
||||
@@ -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
|
||||
|
||||
@@ -1,228 +0,0 @@
|
||||
# Approximate Equality
|
||||
|
||||
Test whether two values agree within a specified tolerance.
|
||||
|
||||
## Overview
|
||||
|
||||
In numerical computing, mathematical equality often diverges from computed
|
||||
equality. Rounding in floating-point arithmetic is one common cause, but many
|
||||
nontrivial numerical algorithms also have inherent truncation or discretization
|
||||
errors, and empirical measurements carry uncertainty to begin with. In these
|
||||
scenarios, exact equality (`==`) may be too strict or inappropriate, and an
|
||||
approximate equality comparison is needed instead. Conversely, exact equality
|
||||
remains entirely appropriate when checking for identical values, sentinel states,
|
||||
or integers.
|
||||
|
||||
`RealModule` provides a family of `isApproximatelyEqual` methods that test
|
||||
whether two values are within a tolerance of one another. They are available
|
||||
on any `Numeric` type whose `Magnitude` is a `FloatingPoint` type (including
|
||||
`Float`, `Double`, and `Complex`), and a more general form is available on any
|
||||
`AdditiveArithmetic` type for which you can supply a norm.
|
||||
|
||||
```swift
|
||||
import Numerics
|
||||
|
||||
let x = 0.1 + 0.2
|
||||
x == 0.3 // false
|
||||
x.isApproximatelyEqual(to: 0.3) // true
|
||||
```
|
||||
|
||||
### Comparing non-Numeric types with a custom norm
|
||||
|
||||
The approximate equality API is not limited to scalar numbers or `Numeric`
|
||||
types. Any type conforming to `AdditiveArithmetic` can be compared once you
|
||||
supply a suitable norm function mapping differences to a `FloatingPoint`
|
||||
magnitude.
|
||||
|
||||
For example, consider a 2D geometric vector or point type representing spatial
|
||||
displacements:
|
||||
|
||||
```swift
|
||||
struct Vector2D: AdditiveArithmetic, Equatable {
|
||||
var x: Double
|
||||
var y: Double
|
||||
|
||||
static var zero: Vector2D {
|
||||
Vector2D(x: 0, y: 0)
|
||||
}
|
||||
|
||||
static func + (lhs: Vector2D, rhs: Vector2D) -> Vector2D {
|
||||
Vector2D(x: lhs.x + rhs.x, y: lhs.y + rhs.y)
|
||||
}
|
||||
|
||||
static func - (lhs: Vector2D, rhs: Vector2D) -> Vector2D {
|
||||
Vector2D(x: lhs.x - rhs.x, y: lhs.y - rhs.y)
|
||||
}
|
||||
}
|
||||
|
||||
// Compare vectors using the Euclidean distance (L2 norm):
|
||||
let v1 = Vector2D(x: 1.0, y: 2.0)
|
||||
let v2 = Vector2D(x: 1.000000001, y: 1.999999999)
|
||||
|
||||
let areClose = v1.isApproximatelyEqual(
|
||||
to: v2,
|
||||
absoluteTolerance: 1e-6,
|
||||
norm: { v in (v.x * v.x + v.y * v.y).squareRoot() }
|
||||
)
|
||||
// areClose == true
|
||||
```
|
||||
|
||||
Because `Vector2D` is not `Numeric` (it does not define multiplication of
|
||||
vectors to produce a vector), it cannot use the standard `Numeric.isApproximatelyEqual`
|
||||
overload. However, because vector subtraction forms a difference vector in an
|
||||
additive space, the general `AdditiveArithmetic` overload evaluates the custom
|
||||
norm directly.
|
||||
|
||||
### Choosing a tolerance
|
||||
|
||||
The simplest method uses a _relative_ tolerance:
|
||||
|
||||
```swift
|
||||
public func isApproximatelyEqual(
|
||||
to other: Self,
|
||||
relativeTolerance: Magnitude = Magnitude.ulpOfOne.squareRoot(),
|
||||
norm: (Self) -> Magnitude = \.magnitude
|
||||
) -> Bool
|
||||
```
|
||||
|
||||
Two finite values compare equal when
|
||||
|
||||
```
|
||||
norm(self - other) <= relativeTolerance * scale
|
||||
```
|
||||
|
||||
where `scale` is `max(norm(self), norm(other), .leastNormalMagnitude)`.
|
||||
Because the bound grows with the size of the operands, a single relative
|
||||
tolerance works across a wide range of magnitudes.
|
||||
|
||||
The default tolerance is `.ulpOfOne.squareRoot()`, which corresponds to
|
||||
expecting about half of the available digits in the result to be correct. This
|
||||
is the usual rule of thumb in numerical analysis when you have no other
|
||||
information about the computation, but it is not appropriate for every use
|
||||
case, so you should pass an explicit value when you can estimate how much error
|
||||
your computation introduces.
|
||||
|
||||
#### Absolute versus relative tolerance
|
||||
|
||||
A relative tolerance scales with the magnitude of the operands, making it
|
||||
effective across numbers of very small or very large scale. However, a pure
|
||||
relative tolerance fails when comparing against zero or numbers much smaller
|
||||
than the surrounding computation, because `scale` approaches zero and shrinks
|
||||
the allowable difference to near zero.
|
||||
|
||||
To handle values near zero, use the overload that also accepts an _absolute_
|
||||
tolerance:
|
||||
|
||||
```swift
|
||||
public func isApproximatelyEqual(
|
||||
to other: Self,
|
||||
absoluteTolerance: Magnitude,
|
||||
relativeTolerance: Magnitude = 0
|
||||
) -> Bool
|
||||
```
|
||||
|
||||
Two finite values compare equal when _either_ the absolute or the relative
|
||||
bound is satisfied:
|
||||
|
||||
```
|
||||
(self - other).magnitude <= absoluteTolerance
|
||||
```
|
||||
|
||||
or
|
||||
|
||||
```
|
||||
(self - other).magnitude <= relativeTolerance * scale
|
||||
```
|
||||
|
||||
where `scale` is `max(self.magnitude, other.magnitude)`.
|
||||
|
||||
When choosing values:
|
||||
- Use **relative tolerance** when the allowed error is proportional to the
|
||||
magnitude of the values being computed (e.g. general floating-point arithmetic).
|
||||
- Use **absolute tolerance** when values can be near zero, or when the error
|
||||
is independent of the scale of the inputs (e.g. fixed measurement resolution).
|
||||
- Supplying both allows the absolute tolerance to govern comparisons near
|
||||
zero, while the relative tolerance takes over once values grow beyond
|
||||
`absoluteTolerance / relativeTolerance`.
|
||||
|
||||
Setting `absoluteTolerance == relativeTolerance` is typically appropriate only
|
||||
when values are expected to lie on an integral or unit-spaced grid due to
|
||||
algorithmic considerations (where `1.0` represents the base unit scale). For
|
||||
general computations, the two tolerances should be chosen independently based on
|
||||
the scale of the problem and the expected precision.
|
||||
|
||||
### Special values
|
||||
|
||||
The comparison follows the same conventions as `FloatingPoint`:
|
||||
|
||||
```swift
|
||||
Double.nan.isApproximatelyEqual(to: .nan) // false
|
||||
Double.infinity.isApproximatelyEqual(to: .infinity) // true
|
||||
(0.0).isApproximatelyEqual(to: -0.0) // true
|
||||
```
|
||||
|
||||
A NaN is never approximately equal to anything, including itself, and a finite
|
||||
value is never approximately equal to an infinity. Equal values always compare
|
||||
approximately equal regardless of the tolerance, so infinities compare equal to
|
||||
themselves and `+0` compares equal to `-0`.
|
||||
|
||||
### Comparing other types with a custom norm
|
||||
|
||||
The methods above measure the difference between two values using the
|
||||
`.magnitude` property. Sometimes you want to use a different
|
||||
[norm](https://en.wikipedia.org/wiki/Norm_(mathematics)). The most general
|
||||
overload, defined on `AdditiveArithmetic`, lets you supply one:
|
||||
|
||||
```swift
|
||||
public func isApproximatelyEqual<Magnitude>(
|
||||
to other: Self,
|
||||
absoluteTolerance: Magnitude,
|
||||
relativeTolerance: Magnitude = 0,
|
||||
norm: (Self) -> Magnitude
|
||||
) -> Bool
|
||||
where Magnitude: FloatingPoint
|
||||
```
|
||||
|
||||
#### Complex magnitude vs other norms
|
||||
|
||||
For complex numbers, the default norm is `\.magnitude`, which computes the
|
||||
infinity-norm (`max(abs(real), abs(imaginary))`).
|
||||
|
||||
A major numerical advantage of `\.magnitude` for complex values is that it is
|
||||
finite and non-zero for any finite non-zero value:
|
||||
- Unlike Euclidean length (`\.length`, $\sqrt{x^2 + y^2}$), which can overflow
|
||||
to infinity if $x^2 + y^2$ exceeds the maximum representable finite value or
|
||||
underflow if both components are tiny, `\.magnitude` never overflows or underflows
|
||||
for finite numbers.
|
||||
- It avoids intermediate squaring, square roots, or the complex scaling logic of
|
||||
`hypot`, making it robust even when handling very poorly scaled values.
|
||||
|
||||
If you specifically need to test whether a complex number lies inside a circular
|
||||
disk of radius `0.001` centered at `1 + 0i` rather than a square box, you can
|
||||
pass the Euclidean length as the norm:
|
||||
|
||||
```swift
|
||||
import ComplexModule
|
||||
|
||||
z.isApproximatelyEqual(
|
||||
to: 1,
|
||||
absoluteTolerance: 0.001,
|
||||
norm: \.length
|
||||
)
|
||||
```
|
||||
|
||||
## Mathematical properties
|
||||
|
||||
For any fixed tolerance, approximate equality is _reflexive_ on
|
||||
non-exceptional values and _symmetric_: if `a` is approximately equal to `b`,
|
||||
then `b` is approximately equal to `a`.
|
||||
|
||||
It is **not transitive**. `a` can be approximately equal to `b`, and `b` to
|
||||
`c`, while `a` and `c` differ by more than the tolerance. Approximate equality
|
||||
is therefore **not** an equivalence relation, even when restricted to
|
||||
non-exceptional values. For this reason you must not use it to implement a
|
||||
conformance to `Equatable`: doing so would violate the invariants that generic
|
||||
code written against `Equatable` relies on.
|
||||
|
||||
For any point `a`, the set of values that compare approximately equal to `a`
|
||||
is _convex_ (under the assumption that `norm` implements a valid norm).
|
||||
@@ -1,37 +0,0 @@
|
||||
# ``Augmented``
|
||||
|
||||
A namespace for a family of algorithms that compute the results of floating-
|
||||
point arithmetic using multiple values such that either the error is minimized
|
||||
or the result is exact.
|
||||
|
||||
## Overview
|
||||
|
||||
Consider multiplying two Doubles. A Double has 53 significand bits, so their
|
||||
product could be up to 106 bits wide before it is rounded to a Double result.
|
||||
So up to 53 of those 106 bits will be "lost" in that process:
|
||||
|
||||
```swift
|
||||
let a = 1.0 + .ulpOfOne // 1 + 2⁻⁵²
|
||||
let b = 1.0 - .ulpOfOne // 1 - 2⁻⁵²
|
||||
let c = a * b // 1 - 2⁻¹⁰⁴ before rounding, rounds to 1.0
|
||||
```
|
||||
|
||||
Sometimes it is necessary to preserve some or all of those low-order bits;
|
||||
maybe a subsequent subtraction cancels most of the high-order bits, and so
|
||||
the low-order part of the product suddenly becomes significant:
|
||||
|
||||
```swift
|
||||
let result = 1 - c // exactly zero, but "should be" 2⁻¹⁰⁴
|
||||
```
|
||||
|
||||
Augmented arithmetic is a building-block that library writers can use to
|
||||
handle cases like this more carefully. For the example above, one might
|
||||
compute:
|
||||
|
||||
```swift
|
||||
let (head, tail) = Augmented.product(a,b)
|
||||
```
|
||||
|
||||
`head` is then 1.0 and `tail` is -2⁻¹⁰⁴, so no information has been lost.
|
||||
Of course, the result is now split across two Doubles instead of one, but the
|
||||
information in `tail` can be carried forward into future computations.
|
||||
@@ -1,68 +0,0 @@
|
||||
# ``ElementaryFunctions``
|
||||
|
||||
A type that has elementary functions (`sin`, `cos`, etc.) available.
|
||||
|
||||
## Overview
|
||||
|
||||
An ["elementary function"][elfn] is a function built up from powers, roots,
|
||||
exponentials, logarithms, trigonometric functions (sin, cos, tan) and
|
||||
their inverses, and the hyperbolic functions (sinh, cosh, tanh) and their
|
||||
inverses.
|
||||
|
||||
Conformance to this protocol means that all of these building blocks are
|
||||
available as static functions on the type.
|
||||
|
||||
```swift
|
||||
let x: Float = 1
|
||||
let y = Float.sin(x) // 0.84147096
|
||||
```
|
||||
|
||||
`ElementaryFunctions` conformance implies `AdditiveArithmetic`, so addition
|
||||
and subtraction and the `zero` property are also available.
|
||||
|
||||
``RealFunctions`` refines this protocol and adds additional functions that
|
||||
are primarily used with real numbers, such as ``RealFunctions/atan2(y:x:)``
|
||||
and ``RealFunctions/exp10(_:)``.
|
||||
|
||||
``Real`` conforms to `RealFunctions` and `FloatingPoint`, and is the
|
||||
protocol that you will use most often for generic code.
|
||||
|
||||
## Topics
|
||||
|
||||
There are a few families of functions defined by `ElementaryFunctions`:
|
||||
|
||||
### Exponential functions
|
||||
- ``exp(_:)``
|
||||
- ``expMinusOne(_:)``
|
||||
|
||||
### Logarithmetic functions
|
||||
- ``log(_:)``
|
||||
- ``log(onePlus:)``
|
||||
|
||||
### Power and root functions:
|
||||
- ``pow(_:_:)-9imp6``
|
||||
- ``pow(_:_:)-2qmul``
|
||||
- ``sqrt(_:)``
|
||||
- ``root(_:_:)``
|
||||
|
||||
### Trigonometric functions
|
||||
- ``cos(_:)``
|
||||
- ``sin(_:)``
|
||||
- ``tan(_:)``
|
||||
|
||||
### Inverse trigonometric functions
|
||||
- ``acos(_:)``
|
||||
- ``asin(_:)``
|
||||
- ``atan(_:)``
|
||||
|
||||
### Hyperbolic functions
|
||||
- ``cosh(_:)``
|
||||
- ``sinh(_:)``
|
||||
- ``tanh(_:)``
|
||||
|
||||
### Inverse hyperbolic functions
|
||||
- ``acosh(_:)``
|
||||
- ``asinh(_:)``
|
||||
- ``atanh(_:)``
|
||||
|
||||
[elfn]: http://en.wikipedia.org/wiki/Elementary_function
|
||||
@@ -1,27 +0,0 @@
|
||||
# ``RealFunctions``
|
||||
|
||||
A type that extends ``ElementaryFunctions`` with additional operations that
|
||||
are primarily used with real numbers.
|
||||
|
||||
## Topics
|
||||
|
||||
### Exponential functions
|
||||
- ``exp2(_:)``
|
||||
- ``exp10(_:)``
|
||||
|
||||
### Logarithmetic functions
|
||||
- ``log2(_:)``
|
||||
- ``log10(_:)``
|
||||
|
||||
### Plane geometry
|
||||
- ``atan2(y:x:)``
|
||||
- ``hypot(_:_:)``
|
||||
|
||||
### Gamma function
|
||||
- ``gamma(_:)``
|
||||
- ``logGamma(_:)``
|
||||
- ``signGamma(_:)``
|
||||
|
||||
### Error function
|
||||
- ``erf(_:)``
|
||||
- ``erfc(_:)``
|
||||
@@ -1,32 +0,0 @@
|
||||
# ``RealModule``
|
||||
|
||||
Extensions on the Swift standard library that provide functionality for
|
||||
floating-point types.
|
||||
|
||||
## Overview
|
||||
|
||||
``RealModule`` provides four protocols that extend the standard library's
|
||||
numeric protocol hierarchy: AlgebraicField, ElementaryFunctions,
|
||||
RealFunctions, and Real.
|
||||
|
||||
Types conforming to AlgebraicField represent
|
||||
[fields](https://en.wikipedia.org/wiki/Field_(mathematics)). These are the
|
||||
mathematical structures that typically form the elements of vectors and
|
||||
matrices, so this protocol is appropriate for writing generic code to do
|
||||
linear-algebra-type operations.
|
||||
|
||||
ElementaryFunctions provides bindings for the "math functions": the logarithm
|
||||
and exponential functions, sine, cosine and tangent as well as their inverses,
|
||||
and other functions that you may be familiar with from trigonometry and
|
||||
calculus. RealFunctions refines ElementaryFunctions and provides functions that
|
||||
are primarily used with the real numbers, such as atan2, erf and gamma, and
|
||||
the base-2 and -10 logarithm and exponential funtions.
|
||||
|
||||
The Real protocol is a convenient name for the intersection of `FloatingPoint`,
|
||||
`RealFunctions`, and `AlgebraicField`; this is the protocol that you are most
|
||||
likely to want to constrain to when writing generic "math" code that works
|
||||
with floating-point types.
|
||||
|
||||
``RealModule`` also provides `isApproximatelyEqual` methods for comparing
|
||||
floating-point values up to a tolerance, which is almost always what you want
|
||||
instead of an exact `==` comparison. See <doc:ApproximateEquality> for details.
|
||||
@@ -1,53 +0,0 @@
|
||||
# ``Relaxed``
|
||||
|
||||
A namespace for a family of operations that "relax" the usual rules for
|
||||
floating-point to allow reassociation of arithmetic and FMA formation.
|
||||
|
||||
## Overview
|
||||
|
||||
Because of rounding, and the arithmetic rules for infinity and NaN values,
|
||||
floating-point addition and multiplication are not associative:
|
||||
|
||||
```swift
|
||||
let ε = Double.leastNormalMagnitude
|
||||
let sumLeft = (-1 + 1) + ε // 0 + ε = ε
|
||||
let sumRight = -1 + (1 + ε) // -1 + 1 = 0
|
||||
|
||||
let ∞ = Double.infinity
|
||||
let productLeft = (ε * ε) * ∞ // 0 * ∞ = .nan
|
||||
let productRight = ε * (ε * ∞) // ε * ∞ = ∞
|
||||
```
|
||||
|
||||
For some algorithms, the distinction between these results is incidental; for
|
||||
some others it is critical to their correct function. Because of this,
|
||||
compilers cannot freely change the order of reductions, which prevents some
|
||||
important optimizations: extraction of instruction-level parallelism and
|
||||
vectorization.
|
||||
|
||||
If you know that you are in a case where the order of elements being summed
|
||||
or multiplied is incidental, the Relaxed operations give you a mechanism
|
||||
to communicate that to the compiler and unlock these optimizations. For
|
||||
example, consider the following two functions:
|
||||
|
||||
```swift
|
||||
func sum(array: [Float]) -> Float {
|
||||
array.reduce(0, +)
|
||||
}
|
||||
|
||||
func relaxedSum(array: [Float]) -> Float {
|
||||
array.reduce(0, Relaxed.sum)
|
||||
}
|
||||
```
|
||||
|
||||
when called on an array with 1000 elements in a Release build, `relaxedSum`
|
||||
is about 8x faster than `sum` on Apple M2, with a similar speedup on Intel
|
||||
processors, without the need for any unsafe code or flags.
|
||||
|
||||
### multiplyAdd
|
||||
|
||||
In addition to `sum` and `product`, `Relaxed` provides the
|
||||
``multiplyAdd(_:_:_:)`` operation, which communciates to the compiler that
|
||||
it is allowed to replace separate multiply and add operations with a single
|
||||
_fused multiply-add_ instruction if its cost model indicates that it would
|
||||
be advantageous to do so. When targeting processors that support this
|
||||
instruction, this may be a significant performance advantage.
|
||||
@@ -2,7 +2,7 @@
|
||||
//
|
||||
// This source file is part of the Swift Numerics open source project
|
||||
//
|
||||
// Copyright (c) 2019-2025 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
|
||||
@@ -10,7 +10,6 @@
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
import _NumericsShims
|
||||
import Builtin
|
||||
|
||||
extension Double: Real {
|
||||
@_transparent
|
||||
@@ -108,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
|
||||
@@ -126,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 {
|
||||
@@ -151,7 +150,6 @@ extension Double: Real {
|
||||
@_transparent
|
||||
public static func pow(_ x: Double, _ y: Double) -> Double {
|
||||
guard x >= 0 else { return .nan }
|
||||
if x == 0 && y == 0 { return .nan }
|
||||
return libm_pow(x, y)
|
||||
}
|
||||
|
||||
@@ -213,29 +211,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 {
|
||||
#if hasFeature(BuiltinRelaxedFP) // Swift 6.5 and later
|
||||
Double(Builtin.fadd_relaxed_FPIEEE64(a._value, b._value))
|
||||
#else
|
||||
_numerics_relaxed_add(a, b)
|
||||
#endif
|
||||
}
|
||||
|
||||
@_transparent
|
||||
public static func _relaxedMul(_ a: Double, _ b: Double) -> Double {
|
||||
#if hasFeature(BuiltinRelaxedFP) // Swift 6.5 and later
|
||||
Double(Builtin.fmul_relaxed_FPIEEE64(a._value, b._value))
|
||||
#else
|
||||
_numerics_relaxed_mul(a, b)
|
||||
#endif
|
||||
public static func _mulAdd(_ a: Double, _ b: Double, _ c: Double) -> Double {
|
||||
_numerics_muladd(a, b, c)
|
||||
}
|
||||
}
|
||||
@@ -2,19 +2,65 @@
|
||||
//
|
||||
// This source file is part of the Swift Numerics open source project
|
||||
//
|
||||
// Copyright (c) 2019-2025 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
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
/// A type that has elementary functions available.
|
||||
///
|
||||
/// An ["elementary function"][elfn] is a function built up from powers, roots,
|
||||
/// exponentials, logarithms, trigonometric functions (sin, cos, tan) and
|
||||
/// their inverses, and the hyperbolic functions (sinh, cosh, tanh) and their
|
||||
/// inverses.
|
||||
///
|
||||
/// Conformance to this protocol means that all of these building blocks are
|
||||
/// available as static functions on the type.
|
||||
///
|
||||
/// ```swift
|
||||
/// let x: Float = 1
|
||||
/// let y = Float.sin(x) // 0.84147096
|
||||
/// ```
|
||||
///
|
||||
/// There are three broad families of functions defined by
|
||||
/// `ElementaryFunctions`:
|
||||
/// - Exponential, trigonometric, and hyperbolic functions:
|
||||
/// `exp`, `expMinusOne`, `cos`, `sin`, `tan`, `cosh`, `sinh`, and `tanh`.
|
||||
/// - Logarithmic, inverse trigonometric, and inverse hyperbolic functions:
|
||||
/// `log`, `log(onePlus:)`, `acos`, `asin`, `atan`, `acosh`, `asinh`, and
|
||||
/// `atanh`.
|
||||
/// - Power and root functions:
|
||||
/// `pow`, `sqrt`, and `root`.
|
||||
///
|
||||
/// `ElementaryFunctions` conformance implies `AdditiveArithmetic`, so addition
|
||||
/// and subtraction and the `.zero` property are also available.
|
||||
///
|
||||
/// There are two other protocols that you are more likely to want to use
|
||||
/// directly:
|
||||
///
|
||||
/// `RealFunctions` refines `ElementaryFunctions` and includes
|
||||
/// additional functions specific to real number types.
|
||||
///
|
||||
/// `Real` conforms to `RealFunctions` and `FloatingPoint`, and is the
|
||||
/// protocol that you will want to use most often for generic code.
|
||||
///
|
||||
/// See Also:
|
||||
/// -
|
||||
/// - `RealFunctions`
|
||||
/// - `Real`
|
||||
///
|
||||
/// [elfn]: http://en.wikipedia.org/wiki/Elementary_function
|
||||
public protocol ElementaryFunctions: AdditiveArithmetic {
|
||||
/// The [exponential function][wiki] e^x whose base `e` is the base of the
|
||||
/// natural logarithm.
|
||||
///
|
||||
/// For types that conform to ``RealFunctions`` see
|
||||
/// ``RealFunctions/exp2(_:)`` and ``RealFunctions/exp10(_:)``.
|
||||
/// 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
|
||||
@@ -25,7 +71,7 @@ public protocol ElementaryFunctions: AdditiveArithmetic {
|
||||
/// catastrophic cancellation and the result will not have full accuracy.
|
||||
/// The `.expMinusOne(x)` function gives you a means to address this problem.
|
||||
///
|
||||
/// As an example, consider the expression `(x + 1) * .exp(x) - 1`. When `x`
|
||||
/// As an example, consider the expression `(x + 1)*exp(x) - 1`. When `x`
|
||||
/// is smaller than `.ulpOfOne`, this expression evaluates to `0.0`, when it
|
||||
/// should actually round to `2*x`. We can get a full-accuracy result by
|
||||
/// using the following instead:
|
||||
@@ -36,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.
|
||||
///
|
||||
/// For types that conform to ``RealFunctions`` see
|
||||
/// ``RealFunctions/exp2(_:)`` and ``RealFunctions/exp10(_:)``.
|
||||
/// 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`.
|
||||
@@ -47,7 +96,11 @@ public protocol ElementaryFunctions: AdditiveArithmetic {
|
||||
/// 2
|
||||
/// ```
|
||||
///
|
||||
/// See also ``acosh(_:)``.
|
||||
/// See also:
|
||||
/// -
|
||||
/// - `sinh()`
|
||||
/// - `tanh()`
|
||||
/// - `acosh()`
|
||||
///
|
||||
/// [wiki]: https://en.wikipedia.org/wiki/Hyperbolic_function
|
||||
static func cosh(_ x: Self) -> Self
|
||||
@@ -59,7 +112,11 @@ public protocol ElementaryFunctions: AdditiveArithmetic {
|
||||
/// 2
|
||||
/// ```
|
||||
///
|
||||
/// See also ``asinh(_:)``.
|
||||
/// See also:
|
||||
/// -
|
||||
/// - `cosh()`
|
||||
/// - `tanh()`
|
||||
/// - `asinh()`
|
||||
///
|
||||
/// [wiki]: https://en.wikipedia.org/wiki/Hyperbolic_function
|
||||
static func sinh(_ x: Self) -> Self
|
||||
@@ -71,7 +128,11 @@ public protocol ElementaryFunctions: AdditiveArithmetic {
|
||||
/// cosh(x)
|
||||
/// ```
|
||||
///
|
||||
/// See also ``atanh(_:)``.
|
||||
/// See also:
|
||||
/// -
|
||||
/// - `cosh()`
|
||||
/// - `sinhh()`
|
||||
/// - `atanh()`
|
||||
///
|
||||
/// [wiki]: https://en.wikipedia.org/wiki/Hyperbolic_function
|
||||
static func tanh(_ x: Self) -> Self
|
||||
@@ -80,7 +141,11 @@ public protocol ElementaryFunctions: AdditiveArithmetic {
|
||||
///
|
||||
/// For real types, `x` may be interpreted as an angle measured in radians.
|
||||
///
|
||||
/// See also ``acos(_:)``.
|
||||
/// See also:
|
||||
/// -
|
||||
/// - `sin()`
|
||||
/// - `tan()`
|
||||
/// - `acos()`
|
||||
///
|
||||
/// [wiki]: https://en.wikipedia.org/wiki/Cosine
|
||||
static func cos(_ x: Self) -> Self
|
||||
@@ -90,7 +155,11 @@ public protocol ElementaryFunctions: AdditiveArithmetic {
|
||||
///
|
||||
/// For real types, `x` may be interpreted as an angle measured in radians.
|
||||
///
|
||||
/// See also ``asin(_:)``.
|
||||
/// See also:
|
||||
/// -
|
||||
/// - `cos()`
|
||||
/// - `tan()`
|
||||
/// - `asin()`
|
||||
///
|
||||
/// [wiki]: https://en.wikipedia.org/wiki/Sine
|
||||
static func sin(_ x: Self) -> Self
|
||||
@@ -99,54 +168,75 @@ public protocol ElementaryFunctions: AdditiveArithmetic {
|
||||
///
|
||||
/// For real types, `x` may be interpreted as an angle measured in radians.
|
||||
///
|
||||
/// See also ``atan(_:)``.
|
||||
///
|
||||
/// 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`.
|
||||
///
|
||||
/// For types that conform to ``RealFunctions`` see also
|
||||
/// ``RealFunctions/log2(_:)`` and ``RealFunctions/log10(_:)``.
|
||||
/// 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.
|
||||
///
|
||||
/// For types that conform to ``RealFunctions`` see also
|
||||
/// ``RealFunctions/log2(_:)`` and ``RealFunctions/log10(_:)``.
|
||||
/// 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 ``cosh(_:)``.
|
||||
/// See also:
|
||||
/// -
|
||||
/// - `asinh()`
|
||||
/// - `atanh()`
|
||||
/// - `cosh()`
|
||||
///
|
||||
/// [wiki]: https://en.wikipedia.org/wiki/Inverse_hyperbolic_function
|
||||
static func acosh(_ x: Self) -> Self
|
||||
|
||||
/// The [inverse hyperbolic sine][wiki] of `x`.
|
||||
///
|
||||
/// ```
|
||||
/// sinh(asinh(x)) ≅ x
|
||||
/// ```
|
||||
///
|
||||
/// See also ``sinh(_:)``.
|
||||
/// See also:
|
||||
/// -
|
||||
/// - `acosh()`
|
||||
/// - `atanh()`
|
||||
/// - `sinh()`
|
||||
///
|
||||
/// [wiki]: https://en.wikipedia.org/wiki/Inverse_hyperbolic_function
|
||||
static func asinh(_ x: Self) -> Self
|
||||
|
||||
/// The [inverse hyperbolic tangent][wiki] of `x`.
|
||||
///
|
||||
/// ```
|
||||
/// tanh(atanh(x)) ≅ x
|
||||
/// ```
|
||||
///
|
||||
/// See also ``tanh(_:)``.
|
||||
/// See also:
|
||||
/// -
|
||||
/// - `acosh()`
|
||||
/// - `asinh()`
|
||||
/// - `tanh()`
|
||||
///
|
||||
/// [wiki]: https://en.wikipedia.org/wiki/Inverse_hyperbolic_function
|
||||
static func atanh(_ x: Self) -> Self
|
||||
@@ -155,12 +245,14 @@ public protocol ElementaryFunctions: AdditiveArithmetic {
|
||||
///
|
||||
/// For real types, the result may be interpreted as an angle measured in
|
||||
/// radians.
|
||||
///
|
||||
/// ```
|
||||
/// cos(acos(x)) ≅ x
|
||||
/// ```
|
||||
///
|
||||
/// See also ``cos(_:)``.
|
||||
/// See also:
|
||||
/// -
|
||||
/// - `asin()`
|
||||
/// - `atan()`
|
||||
/// - `cos()`
|
||||
///
|
||||
/// [wiki]: https://en.wikipedia.org/wiki/Inverse_trigonometric_functions
|
||||
static func acos(_ x: Self) -> Self
|
||||
@@ -169,12 +261,14 @@ public protocol ElementaryFunctions: AdditiveArithmetic {
|
||||
///
|
||||
/// For real types, the result may be interpreted as an angle measured in
|
||||
/// radians.
|
||||
///
|
||||
/// ```
|
||||
/// sin(asin(x)) ≅ x
|
||||
/// ```
|
||||
///
|
||||
/// See also ``sin(_:)``.
|
||||
/// See also:
|
||||
/// -
|
||||
/// - `acos()`
|
||||
/// - `atan()`
|
||||
/// - `sin()`
|
||||
///
|
||||
/// [wiki]: https://en.wikipedia.org/wiki/Inverse_trigonometric_functions
|
||||
static func asin(_ x: Self) -> Self
|
||||
@@ -183,42 +277,53 @@ public protocol ElementaryFunctions: AdditiveArithmetic {
|
||||
///
|
||||
/// For real types, the result may be interpreted as an angle measured in
|
||||
/// radians.
|
||||
///
|
||||
/// ```
|
||||
/// tan(atan(x)) ≅ x
|
||||
/// ```
|
||||
///
|
||||
/// See also ``tan(_:)``.
|
||||
/// For types that conform to ``RealFunctions``, you will sometimes want
|
||||
/// to use ``RealFunctions/atan2(y:x:)`` instead.
|
||||
/// 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
|
||||
|
||||
/// exp(y * log(x)) computed with additional internal precision.
|
||||
///
|
||||
/// The edge-cases of this function are defined based on the behavior of the
|
||||
/// expression `exp(y log x)`, matching IEEE 754's `powr` operation.
|
||||
/// In particular, this means that if `x` and `y` are both zero, `pow(x,y)`
|
||||
/// is `nan` for real types and `infinity` for complex types, rather than 1.
|
||||
/// See also:
|
||||
/// -
|
||||
/// - `sqrt()`
|
||||
/// - `root()`
|
||||
///
|
||||
/// There is also
|
||||
/// <doc:/documentation/RealModule/ElementaryFunctions/pow(_:_:)-9imp6>,
|
||||
/// whose behavior is defined in terms of repeated multiplication.
|
||||
static func pow(_ x: Self, _ y: Self) -> Self
|
||||
|
||||
/// `x` raised to the nth power.
|
||||
///
|
||||
/// The edge-cases of this function are defined in terms of repeated
|
||||
/// multiplication or division, rather than exp(n log x). In particular,
|
||||
/// `Float.pow(0, 0)` is 1.
|
||||
/// See also:
|
||||
/// -
|
||||
/// - `sqrt()`
|
||||
/// - `root()`
|
||||
///
|
||||
static func pow(_ x: Self, _ n: Int) -> Self
|
||||
|
||||
/// The [square root][wiki] of `x`.
|
||||
///
|
||||
/// 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()`
|
||||
/// - `sqrt()`
|
||||
///
|
||||
static func root(_ x: Self, _ n: Int) -> Self
|
||||
}
|
||||
@@ -10,7 +10,6 @@
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
import _NumericsShims
|
||||
import Builtin
|
||||
|
||||
extension Float: Real {
|
||||
@_transparent
|
||||
@@ -138,7 +137,6 @@ extension Float: Real {
|
||||
@_transparent
|
||||
public static func pow(_ x: Float, _ y: Float) -> Float {
|
||||
guard x >= 0 else { return .nan }
|
||||
if x == 0 && y == 0 { return .nan }
|
||||
return libm_powf(x, y)
|
||||
}
|
||||
|
||||
@@ -195,20 +193,7 @@ extension Float: Real {
|
||||
#endif
|
||||
|
||||
@_transparent
|
||||
public static func _relaxedAdd(_ a: Float, _ b: Float) -> Float {
|
||||
#if hasFeature(BuiltinRelaxedFP) // Swift 6.5 and later
|
||||
Float(Builtin.fadd_relaxed_FPIEEE32(a._value, b._value))
|
||||
#else
|
||||
_numerics_relaxed_addf(a, b)
|
||||
#endif
|
||||
}
|
||||
|
||||
@_transparent
|
||||
public static func _relaxedMul(_ a: Float, _ b: Float) -> Float {
|
||||
#if hasFeature(BuiltinRelaxedFP) // Swift 6.5 and later
|
||||
Float(Builtin.fmul_relaxed_FPIEEE32(a._value, b._value))
|
||||
#else
|
||||
_numerics_relaxed_mulf(a, b)
|
||||
#endif
|
||||
public static func _mulAdd(_ a: Float, _ b: Float, _ c: Float) -> Float {
|
||||
_numerics_muladdf(a, b, c)
|
||||
}
|
||||
}
|
||||
@@ -10,10 +10,10 @@
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
import _NumericsShims
|
||||
import Builtin
|
||||
|
||||
// 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 {
|
||||
@@ -173,28 +173,169 @@ extension Float16: Real {
|
||||
Float16(.logGamma(Float(x)))
|
||||
}
|
||||
#endif
|
||||
|
||||
#if !arch(wasm32) || hasFeature(BuiltinRelaxedFP)
|
||||
// WASM doesn't have _Float16 on the C side, so we can't define the C hooks
|
||||
// that these use. However, if we have BuiltinRelaxedFP we can use builtins
|
||||
// to do this directly without needing the C hooks.
|
||||
|
||||
}
|
||||
|
||||
// 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 {
|
||||
#if hasFeature(BuiltinRelaxedFP) // Swift 6.5 and later
|
||||
Float16(Builtin.fadd_relaxed_FPIEEE16(a._value, b._value))
|
||||
#else
|
||||
_numerics_relaxed_addf16(a, b)
|
||||
#endif
|
||||
public static func cos(_ x: Float16) -> Float16 {
|
||||
Float16(.cos(Float(x)))
|
||||
}
|
||||
|
||||
@_transparent
|
||||
public static func _relaxedMul(_ a: Float16, _ b: Float16) -> Float16 {
|
||||
#if hasFeature(BuiltinRelaxedFP) // Swift 6.5 and later
|
||||
Float16(Builtin.fmul_relaxed_FPIEEE16(a._value, b._value))
|
||||
#else
|
||||
_numerics_relaxed_mulf16(a, b)
|
||||
#endif
|
||||
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,7 +10,6 @@
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
import _NumericsShims
|
||||
import Builtin
|
||||
|
||||
// Restrict extension to platforms for which Float80 exists.
|
||||
#if (arch(i386) || arch(x86_64)) && !os(Windows) && !os(Android)
|
||||
@@ -133,7 +132,6 @@ extension Float80: Real {
|
||||
@_transparent
|
||||
public static func pow(_ x: Float80, _ y: Float80) -> Float80 {
|
||||
guard x >= 0 else { return .nan }
|
||||
if x == 0 && y == 0 { return .nan }
|
||||
return libm_powl(x, y)
|
||||
}
|
||||
|
||||
@@ -166,23 +164,5 @@ extension Float80: Real {
|
||||
var dontCare: Int32 = 0
|
||||
return libm_lgammal(x, &dontCare)
|
||||
}
|
||||
|
||||
@_transparent
|
||||
public static func _relaxedAdd(_ a: Float80, _ b: Float80) -> Float80 {
|
||||
#if hasFeature(BuiltinRelaxedFP) // Swift 6.5 and later
|
||||
Float80(Builtin.fadd_relaxed_FPIEEE80(a._value, b._value))
|
||||
#else
|
||||
_numerics_relaxed_addl(a, b)
|
||||
#endif
|
||||
}
|
||||
|
||||
@_transparent
|
||||
public static func _relaxedMul(_ a: Float80, _ b: Float80) -> Float80 {
|
||||
#if hasFeature(BuiltinRelaxedFP) // Swift 6.5 and later
|
||||
Float80(Builtin.fmul_relaxed_FPIEEE80(a._value, b._value))
|
||||
#else
|
||||
_numerics_relaxed_mull(a, b)
|
||||
#endif
|
||||
}
|
||||
}
|
||||
#endif
|
||||
@@ -68,31 +68,10 @@ This gives us an implementation that works for `Float`, `Double`, and `Float80`
|
||||
When new basic floating-point types are added to Swift, like `Float16` or `Float128`, it will work for them as well.
|
||||
Not having this protocol is a significant missing feature for numerical computing in Swift, and I'm really looking forward to seeing what people do with it.
|
||||
|
||||
## Approximate equality
|
||||
|
||||
`RealModule` provides a family of `isApproximatelyEqual` methods that test
|
||||
whether two values agree up to a relative or absolute tolerance:
|
||||
|
||||
```swift
|
||||
import Numerics
|
||||
|
||||
let x = 0.1 + 0.2
|
||||
x == 0.3 // false
|
||||
x.isApproximatelyEqual(to: 0.3) // true
|
||||
```
|
||||
|
||||
These methods are available on any `Numeric` type whose `Magnitude` is a
|
||||
`FloatingPoint` type, with a more general form on `AdditiveArithmetic` that
|
||||
takes a custom norm.
|
||||
See the [Approximate Equality][ApproximateEquality] article for a discussion of
|
||||
how to choose a tolerance, how special values are handled, and why approximate
|
||||
equality must not be used to implement `Equatable`.
|
||||
|
||||
### Dependencies:
|
||||
- The C standard math library (`libm`) via the `_NumericsShims` target.
|
||||
|
||||
[ApproximateEquality]: Documentation.docc/ApproximateEquality.md
|
||||
[ErrorFunction]: https://en.wikipedia.org/wiki/Error_function
|
||||
[GammaFunction]: https://en.wikipedia.org/wiki/Gamma_function
|
||||
[SE-0246]: https://github.com/swiftlang/swift-evolution/blob/main/proposals/0246-mathable.md
|
||||
[SE-0246]: https://github.com/apple/swift-evolution/blob/master/proposals/0246-mathable.md
|
||||
[Sigmoid]: https://en.wikipedia.org/wiki/Sigmoid_function
|
||||
@@ -2,7 +2,7 @@
|
||||
//
|
||||
// This source file is part of the Swift Numerics open source project
|
||||
//
|
||||
// Copyright (c) 2019-2025 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
|
||||
@@ -23,25 +23,30 @@
|
||||
/// return 1/(1 + .exp(-x))
|
||||
/// }
|
||||
/// ```
|
||||
/// See also `ElementaryFunctions`, `RealFunctions` and `AlgebraicField`.
|
||||
public protocol Real: FloatingPoint, RealFunctions, AlgebraicField { }
|
||||
/// See Also:
|
||||
/// -
|
||||
/// - `ElementaryFunctions`
|
||||
/// - `RealFunctions`
|
||||
/// - `AlgebraicField`
|
||||
public protocol Real: FloatingPoint, RealFunctions, AlgebraicField {
|
||||
}
|
||||
|
||||
// While `Real` does not provide any additional customization points,
|
||||
// it does allow us to default the implementation of a few operations,
|
||||
// and also provides `signGamma`.
|
||||
extension Real {
|
||||
// Most math libraries do not provide exp10, so we need a default
|
||||
// implementation. This is not a great one (if the underlying math
|
||||
// library does not have a sub-ulp accurate pow, this will not get
|
||||
// exact powers of ten right), but suffices in the short term.
|
||||
// implementation.
|
||||
@_transparent
|
||||
public static func exp10(_ x: Self) -> Self {
|
||||
pow(10, x)
|
||||
return pow(10, x)
|
||||
}
|
||||
|
||||
/// 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)
|
||||
@@ -91,16 +96,16 @@ extension Real {
|
||||
|
||||
@_transparent
|
||||
public static func sqrt(_ x: Self) -> Self {
|
||||
x.squareRoot()
|
||||
return x.squareRoot()
|
||||
}
|
||||
|
||||
/// 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 +134,14 @@ extension Real {
|
||||
/// the real reciprocal (when it exists) as follows (I will use circle
|
||||
/// 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 + δ₁ + δ₂ + δ₁δ₂)
|
||||
/// 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,
|
||||
/// about twice the error bound we get using division. For most
|
||||
/// purposes this is an acceptable error, but if you need to match
|
||||
|
||||
@@ -2,7 +2,7 @@
|
||||
//
|
||||
// This source file is part of the Swift Numerics open source project
|
||||
//
|
||||
// Copyright (c) 2019-2025 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
|
||||
@@ -10,89 +10,112 @@
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
public protocol RealFunctions: ElementaryFunctions {
|
||||
/// The signed angle formed in the plane between the vector `(x,y)` and the
|
||||
/// positive real axis, measured in radians.
|
||||
/// `atan(y/x)`, with sign selected according to the quadrant of `(x, y)`.
|
||||
///
|
||||
/// The result is in the interval `[-π, π]`.
|
||||
///
|
||||
/// The argument order to `atan2` may be surprising to new programmers.
|
||||
/// The convention of `y` being the first argument goes back at least to
|
||||
/// Fortran IV in 1961 and is generally followed in computing with a few
|
||||
/// notable exceptions (e.g. Mathematica and Excel). This convention was
|
||||
/// originally chosen because of the mathematical definition of the
|
||||
/// function:
|
||||
///
|
||||
/// ```
|
||||
/// atan2(y,x) = atan(y/x) if x > 0
|
||||
/// ```
|
||||
///
|
||||
/// See also ``ElementaryFunctions/atan(_:)``, as well as the `phase` and
|
||||
/// `polar` properties defined on the `Complex` type.
|
||||
/// See also:
|
||||
/// -
|
||||
/// - `atan()`
|
||||
static func atan2(y: Self, x: Self) -> Self
|
||||
|
||||
/// The [error function](https://en.wikipedia.org/wiki/Error_function)
|
||||
/// evaluated at `x`.
|
||||
/// The error function evaluated at `x`.
|
||||
///
|
||||
/// See also:
|
||||
/// -
|
||||
/// - `erfc()`
|
||||
static func erf(_ x: Self) -> Self
|
||||
|
||||
/// The complimentary [error function](https://en.wikipedia.org/wiki/Error_function)
|
||||
/// evaluated at `x`.
|
||||
/// The complimentary error function evaluated at `x`.
|
||||
///
|
||||
/// See also:
|
||||
/// -
|
||||
/// - `erf()`
|
||||
static func erfc(_ x: Self) -> Self
|
||||
|
||||
/// 2 raised to the power x.
|
||||
/// 2^x
|
||||
///
|
||||
/// See also ``log2(_:)``, ``ElementaryFunctions/exp(_:)``,
|
||||
/// ``ElementaryFunctions/expMinusOne(_:)``
|
||||
/// and ``ElementaryFunctions/pow(_:_:)-2qmul``.
|
||||
/// See also:
|
||||
/// -
|
||||
/// - `exp()`
|
||||
/// - `expMinusOne()`
|
||||
/// - `exp10()`
|
||||
/// - `log2()`
|
||||
/// - `pow()`
|
||||
static func exp2(_ x: Self) -> Self
|
||||
|
||||
/// 10 raised to the power x.
|
||||
/// 10^x
|
||||
///
|
||||
/// See also ``log10(_:)``, ``ElementaryFunctions/exp(_:)``,
|
||||
/// ``ElementaryFunctions/expMinusOne(_:)``
|
||||
/// and ``ElementaryFunctions/pow(_:_:)-2qmul``.
|
||||
/// See also:
|
||||
/// -
|
||||
/// - `exp()`
|
||||
/// - `expMinusOne()`
|
||||
/// - `exp2()`
|
||||
/// - `log10()`
|
||||
/// - `pow()`
|
||||
static func exp10(_ x: Self) -> Self
|
||||
|
||||
/// The length of the vector `(x,y)`, computed in a manner that avoids
|
||||
/// spurious overflow or underflow.
|
||||
///
|
||||
/// See also the `length` and `polar` properties defined on the `Complex`
|
||||
/// type.
|
||||
/// `sqrt(x*x + y*y)`, computed in a manner that avoids spurious overflow or
|
||||
/// underflow.
|
||||
static func hypot(_ x: Self, _ y: Self) -> Self
|
||||
|
||||
/// The [gamma function](https://en.wikipedia.org/wiki/Gamma_function) Γ(x).
|
||||
/// The gamma function Γ(x).
|
||||
///
|
||||
/// See also:
|
||||
/// -
|
||||
/// - `logGamma()`
|
||||
/// - `signGamma()`
|
||||
static func gamma(_ x: Self) -> Self
|
||||
|
||||
/// The base-2 logarithm of `x`.
|
||||
///
|
||||
/// See also ``exp2(_:)``, ``ElementaryFunctions/log(_:)``,
|
||||
/// and ``ElementaryFunctions/log(onePlus:)``.
|
||||
/// See also:
|
||||
/// -
|
||||
/// - `exp2()`
|
||||
/// - `log()`
|
||||
/// - `log(onePlus:)`
|
||||
/// - `log10()`
|
||||
static func log2(_ x: Self) -> Self
|
||||
|
||||
/// The base-10 logarithm of `x`.
|
||||
///
|
||||
/// See also ``exp10(_:)``, ``ElementaryFunctions/log(_:)``,
|
||||
/// and ``ElementaryFunctions/log(onePlus:)``.
|
||||
/// See also:
|
||||
/// -
|
||||
/// - `exp10()`
|
||||
/// - `log()`
|
||||
/// - `log(onePlus:)`
|
||||
/// - `log2()`
|
||||
static func log10(_ x: Self) -> Self
|
||||
|
||||
#if !os(Windows)
|
||||
/// The logarithm of the absolute value of the
|
||||
/// [gamma function](https://en.wikipedia.org/wiki/Gamma_function),
|
||||
/// log(|Γ(x)|).
|
||||
/// The logarithm of the absolute value of the gamma function, log(|Γ(x)|).
|
||||
///
|
||||
/// Not available on Windows targets.
|
||||
///
|
||||
/// See also:
|
||||
/// -
|
||||
/// - `gamma()`
|
||||
/// - `signGamma()`
|
||||
static func logGamma(_ x: Self) -> Self
|
||||
|
||||
/// The sign of the
|
||||
/// [gamma function](https://en.wikipedia.org/wiki/Gamma_function), Γ(x).
|
||||
/// The sign of the gamma function, Γ(x).
|
||||
///
|
||||
/// For `x >= 0`, `signGamma(x)` is `.plus`. For negative `x`, `signGamma(x)`
|
||||
/// is `.plus` when `x` is an integer, and otherwise it is `.minus` whenever
|
||||
/// `trunc(x)` is even, and `.plus` when `trunc(x)` is odd.
|
||||
///
|
||||
/// This function is used together with ``logGamma(_:)``, which computes the
|
||||
/// This function is used together with `logGamma`, which computes the
|
||||
/// logarithm of the absolute value of Γ(x), to recover the sign information.
|
||||
///
|
||||
/// Not available on Windows targets.
|
||||
///
|
||||
/// 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-2025 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
|
||||
|
||||
public enum Relaxed { }
|
||||
|
||||
extension Relaxed {
|
||||
/// a+b, but grants the optimizer permission 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, but grants the optimizer permission 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))
|
||||
}
|
||||
}
|
||||
@@ -10,7 +10,5 @@ See https://swift.org/LICENSE.txt for license information
|
||||
add_library(_NumericsShims INTERFACE)
|
||||
target_include_directories(_NumericsShims INTERFACE
|
||||
include)
|
||||
target_link_libraries(_NumericsShims INTERFACE
|
||||
$<$<PLATFORM_ID:Linux>:m>)
|
||||
|
||||
set_property(GLOBAL APPEND PROPERTY SWIFT_NUMERICS_EXPORTS _NumericsShims)
|
||||
@@ -9,10 +9,6 @@
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
#define HEADER_SHIM static inline __attribute__((__always_inline__))
|
||||
|
||||
// This header uses most of the libm functions, but we don't want to end up
|
||||
@@ -386,75 +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 !defined __wasm__ // No _Float16 on wasm
|
||||
/// 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
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
// No long-double muladd operation, because no one has built an FMA for it
|
||||
// (except for Itanium, which Swift doesn't support).
|
||||
@@ -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)
|
||||
|
||||
@@ -1,782 +0,0 @@
|
||||
//===--- DoubleWidth.swift ------------------------------------*- swift -*-===//
|
||||
//
|
||||
// This source file is part of the Swift Numerics open source project
|
||||
//
|
||||
// Copyright (c) 2017-2024 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 partialValue = DoubleWidth(truncatingIfNeeded: product)
|
||||
// Overflow has occured if carry is not just the sign-extension of
|
||||
// partialValue (which is zero when Base is unsigned).
|
||||
let overflow = carry != (partialValue >> DoubleWidth.bitWidth)
|
||||
return (partialValue, overflow)
|
||||
}
|
||||
|
||||
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)
|
||||
}
|
||||
|
||||
// When using a pre-Swift 6.0 runtime, `&*` is not a protocol requirement of
|
||||
// FixedWidthInteger, which results in the default implementation of this
|
||||
// operation ending up recursively calling itself forever. In order to avoid
|
||||
// this, we keep the concrete implementation around.
|
||||
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 {
|
||||
let bits = DoubleWidth(DoubleWidth.bitWidth)
|
||||
if DoubleWidth.bitWidth.nonzeroBitCount == 1 {
|
||||
return self & (bits &- 1)
|
||||
}
|
||||
let reduced = self % bits
|
||||
// bitWidth is always positive, but the value being reduced might have
|
||||
// been negative, in which case reduced will also be negative. We need
|
||||
// the representative in [0, bitWidth), so conditionally add the count
|
||||
// to get the positive residue.
|
||||
if Base.isSigned && reduced < 0 { return reduced &+ bits }
|
||||
return reduced
|
||||
}
|
||||
|
||||
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 static func &+(
|
||||
lhs: DoubleWidth, rhs: DoubleWidth
|
||||
) -> DoubleWidth {
|
||||
let (low, carry) = lhs.low.addingReportingOverflow(rhs.low)
|
||||
let high = lhs.high &+ rhs.high &+ (carry ? 1 : 0)
|
||||
return DoubleWidth(high, low)
|
||||
}
|
||||
|
||||
public static func &-(
|
||||
lhs: DoubleWidth, rhs: DoubleWidth
|
||||
) -> DoubleWidth {
|
||||
let (low, borrow) = lhs.low.subtractingReportingOverflow(rhs.low)
|
||||
let high = lhs.high &- rhs.high &- (borrow ? 1 : 0)
|
||||
return DoubleWidth(high, low)
|
||||
}
|
||||
|
||||
public static func &*(
|
||||
lhs: DoubleWidth, rhs: DoubleWidth
|
||||
) -> DoubleWidth {
|
||||
let p00 = lhs.low.multipliedFullWidth(by: rhs.low)
|
||||
let p10 = lhs.high &* Base(truncatingIfNeeded: rhs.low)
|
||||
let p01 = Base(truncatingIfNeeded: lhs.low) &* rhs.high
|
||||
return DoubleWidth(p10 &+ p01 &+ Base(truncatingIfNeeded: p00.high), p00.low)
|
||||
}
|
||||
|
||||
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,8 +1,8 @@
|
||||
//===--- Error.swift ------------------------------------------*- swift -*-===//
|
||||
//
|
||||
// This source file is part of the Swift Numerics open source project
|
||||
// This source file is part of the Swift.org open source project
|
||||
//
|
||||
// Copyright (c) 2020 Apple Inc. and the Swift Numerics project authors
|
||||
// Copyright (c) 2020 Apple Inc. and the Swift project authors
|
||||
// Licensed under Apache License v2.0 with Runtime Library Exception
|
||||
//
|
||||
// See https://swift.org/LICENSE.txt for license information
|
||||
@@ -11,7 +11,6 @@
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
import ComplexModule
|
||||
import RealModule
|
||||
|
||||
public func relativeError(_ tst: Float, _ ref: Double) -> Double {
|
||||
let scale = max(ref.magnitude, Double(Float.leastNormalMagnitude))
|
||||
|
||||
@@ -1,8 +1,8 @@
|
||||
//===--- Interval.swift ---------------------------------------*- swift -*-===//
|
||||
//
|
||||
// This source file is part of the Swift Numerics open source project
|
||||
// This source file is part of the Swift.org open source project
|
||||
//
|
||||
// Copyright (c) 2020 Apple Inc. and the Swift Numerics project authors
|
||||
// Copyright (c) 2020 Apple Inc. and the Swift project authors
|
||||
// Licensed under Apache License v2.0 with Runtime Library Exception
|
||||
//
|
||||
// See https://swift.org/LICENSE.txt for license information
|
||||
|
||||
@@ -15,8 +15,8 @@ public protocol FixedWidthFloatingPoint: BinaryFloatingPoint
|
||||
where Exponent: FixedWidthInteger,
|
||||
RawSignificand: FixedWidthInteger { }
|
||||
|
||||
#if !((os(macOS) || targetEnvironment(macCatalyst)) && arch(x86_64))
|
||||
@available(macOS 11.0, iOS 14.0, tvOS 14.0, watchOS 7.0, *)
|
||||
#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: FixedWidthFloatingPoint { }
|
||||
#endif
|
||||
|
||||
|
||||
@@ -0,0 +1,24 @@
|
||||
#[[
|
||||
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
|
||||
#]]
|
||||
|
||||
find_package(dispatch CONFIG QUIET)
|
||||
find_package(Foundation CONFIG QUIET)
|
||||
find_package(XCTest CONFIG QUIET)
|
||||
|
||||
add_subdirectory(ComplexTests)
|
||||
add_subdirectory(RealTests)
|
||||
|
||||
add_executable(SwiftNumericsTestRunner
|
||||
WindowsMain.swift)
|
||||
target_link_libraries(SwiftNumericsTestRunner PRIVATE
|
||||
ComplexTests
|
||||
RealTests)
|
||||
|
||||
add_test(NAME SwiftNumericsTestRunner
|
||||
COMMAND SwiftNumericsTestRunner)
|
||||
@@ -1,8 +1,8 @@
|
||||
//===--- ApproximateEqualityTests.swift -----------------------*- swift -*-===//
|
||||
//
|
||||
// This source file is part of the Swift Numerics open source project
|
||||
// This source file is part of the Swift.org open source project
|
||||
//
|
||||
// Copyright (c) 2020 Apple Inc. and the Swift Numerics project authors
|
||||
// Copyright (c) 2020 Apple Inc. and the Swift project authors
|
||||
// Licensed under Apache License v2.0 with Runtime Library Exception
|
||||
//
|
||||
// See https://swift.org/LICENSE.txt for license information
|
||||
|
||||
@@ -2,7 +2,7 @@
|
||||
//
|
||||
// This source file is part of the Swift Numerics open source project
|
||||
//
|
||||
// Copyright (c) 2019-2024 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
|
||||
@@ -13,23 +13,11 @@ import XCTest
|
||||
import ComplexModule
|
||||
import RealModule
|
||||
|
||||
func ulpsFromInfinity<T: Real>(_ a: T) -> T {
|
||||
(.greatestFiniteMagnitude - a) / .greatestFiniteMagnitude.ulp + 1
|
||||
}
|
||||
|
||||
// TODO: improve this to be a general-purpose complex comparison with tolerance
|
||||
func relativeError<T>(_ a: Complex<T>, _ b: Complex<T>) -> T {
|
||||
if a == b { return 0 }
|
||||
if a.isFinite && b.isFinite {
|
||||
let scale = max(a.magnitude, b.magnitude, T.leastNormalMagnitude).ulp
|
||||
return (a - b).magnitude / scale
|
||||
} else {
|
||||
if a.isFinite {
|
||||
return ulpsFromInfinity(a.magnitude)
|
||||
} else {
|
||||
return ulpsFromInfinity(b.magnitude)
|
||||
}
|
||||
}
|
||||
let scale = max(a.magnitude, b.magnitude, T.leastNormalMagnitude).ulp
|
||||
return (a - b).magnitude / scale
|
||||
}
|
||||
|
||||
func closeEnough<T: Real>(_ a: T, _ b: T, ulps allowed: T) -> Bool {
|
||||
@@ -41,15 +29,11 @@ func checkMultiply<T>(
|
||||
_ a: Complex<T>, _ b: Complex<T>, expected: Complex<T>, ulps allowed: T
|
||||
) -> Bool {
|
||||
let observed = a*b
|
||||
if observed == expected { return false }
|
||||
// Even if the expected result is finite, we allow overflow if
|
||||
// the two-norm of the expected result overflows.
|
||||
if !observed.isFinite && !expected.length.isFinite { return false }
|
||||
let rel = relativeError(observed, expected)
|
||||
guard rel <= allowed else {
|
||||
if rel > allowed {
|
||||
print("Over-large error in \(a)*\(b)")
|
||||
print("Expected: \(expected)\nObserved: \(observed)")
|
||||
print("Relative error was \(rel) (tolerance: \(allowed)).")
|
||||
print("Relative error was \(rel) (tolerance: \(allowed).")
|
||||
return true
|
||||
}
|
||||
return false
|
||||
@@ -59,15 +43,11 @@ func checkDivide<T>(
|
||||
_ a: Complex<T>, _ b: Complex<T>, expected: Complex<T>, ulps allowed: T
|
||||
) -> Bool {
|
||||
let observed = a/b
|
||||
if observed == expected { return false }
|
||||
// Even if the expected result is finite, we allow overflow if
|
||||
// the two-norm of the expected result overflows.
|
||||
if !observed.isFinite && !expected.length.isFinite { return false }
|
||||
let rel = relativeError(observed, expected)
|
||||
guard rel <= allowed else {
|
||||
if rel > allowed {
|
||||
print("Over-large error in \(a)/\(b)")
|
||||
print("Expected: \(expected)\nObserved: \(observed)")
|
||||
print("Relative error was \(rel) (tolerance: \(allowed)).")
|
||||
print("Relative error was \(rel) (tolerance: \(allowed).")
|
||||
return true
|
||||
}
|
||||
return false
|
||||
@@ -83,6 +63,7 @@ final class ArithmeticTests: XCTestCase {
|
||||
func testPolar<T>(_ type: T.Type)
|
||||
where T: BinaryFloatingPoint, T: Real,
|
||||
T.Exponent: FixedWidthInteger, T.RawSignificand: FixedWidthInteger {
|
||||
|
||||
// In order to support round-tripping from rectangular to polar coordinate
|
||||
// systems, as a special case phase can be non-finite when length is
|
||||
// either zero or infinity.
|
||||
@@ -95,9 +76,10 @@ final class ArithmeticTests: XCTestCase {
|
||||
XCTAssertEqual(Complex<T>(length:-.infinity, phase: .infinity), .infinity)
|
||||
XCTAssertEqual(Complex<T>(length:-.infinity, phase:-.infinity), .infinity)
|
||||
XCTAssertEqual(Complex<T>(length:-.infinity, phase: .nan ), .infinity)
|
||||
|
||||
|
||||
let exponentRange =
|
||||
T.leastNormalMagnitude.exponent ... T.greatestFiniteMagnitude.exponent
|
||||
(T.leastNormalMagnitude.exponent + T.Exponent(T.significandBitCount)) ...
|
||||
T.greatestFiniteMagnitude.exponent
|
||||
let inputs = (0..<100).map { _ in
|
||||
Polar(length: T(
|
||||
sign: .plus,
|
||||
@@ -154,29 +136,20 @@ final class ArithmeticTests: XCTestCase {
|
||||
// Now test multiplication and division using the polar inputs:
|
||||
for q in inputs {
|
||||
let w = Complex(length: q.length, phase: q.phase)
|
||||
var product = Complex(length: p.length, phase: p.phase + q.phase)
|
||||
product.real *= q.length
|
||||
product.imaginary *= q.length
|
||||
let product = Complex(length: p.length * q.length, phase: p.phase + q.phase)
|
||||
if checkMultiply(z, w, expected: product, ulps: 16) { XCTFail() }
|
||||
var quotient = Complex(length: p.length, phase: p.phase - q.phase)
|
||||
quotient.real /= q.length
|
||||
quotient.imaginary /= q.length
|
||||
let quotient = Complex(length: p.length / q.length, phase: p.phase - q.phase)
|
||||
if checkDivide(z, w, expected: quotient, ulps: 16) { XCTFail() }
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func testPolar() {
|
||||
#if !((os(macOS) || targetEnvironment(macCatalyst)) && arch(x86_64)) && LONG_TESTS
|
||||
if #available(macOS 11.0, iOS 14.0, tvOS 14.0, watchOS 7.0, *) {
|
||||
testPolar(Float16.self)
|
||||
}
|
||||
#endif
|
||||
testPolar(Float.self)
|
||||
testPolar(Double.self)
|
||||
#if (arch(i386) || arch(x86_64)) && !os(Windows) && !os(Android)
|
||||
#if (arch(i386) || arch(x86_64)) && !os(Windows) && !os(Android)
|
||||
testPolar(Float80.self)
|
||||
#endif
|
||||
#endif
|
||||
}
|
||||
|
||||
func testBaudinSmith() {
|
||||
@@ -218,38 +191,16 @@ final class ArithmeticTests: XCTestCase {
|
||||
Complex(1.02951151789360578e-84, 6.97145987515076231e-220)),
|
||||
]
|
||||
for test in vectors {
|
||||
if checkDivide(test.a, test.b, expected: test.c, ulps: 1.0) { XCTFail() }
|
||||
if checkDivide(test.a, test.b, expected: test.c, ulps: 0.5) { XCTFail() }
|
||||
if checkDivide(test.a, test.c, expected: test.b, ulps: 1.0) { XCTFail() }
|
||||
if checkMultiply(test.b, test.c, expected: test.a, ulps: 1.0) { XCTFail() }
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
func testDivisionByZero() {
|
||||
XCTAssertFalse((Complex(0, 0) / Complex(0, 0)).isFinite)
|
||||
XCTAssertFalse((Complex(1, 1) / Complex(0, 0)).isFinite)
|
||||
XCTAssertFalse((Complex.infinity / Complex(0, 0)).isFinite)
|
||||
XCTAssertFalse((Complex.i / Complex(0, 0)).isFinite)
|
||||
|
||||
}
|
||||
|
||||
#if !((os(macOS) || targetEnvironment(macCatalyst)) && arch(x86_64)) && LONG_TESTS
|
||||
@available(macOS 11.0, iOS 14.0, tvOS 14.0, watchOS 7.0, *)
|
||||
func testFloat16DivisionSemiExhaustive() {
|
||||
func complex(bitPattern: UInt32) -> Complex<Float16> {
|
||||
Complex(
|
||||
Float16(bitPattern: UInt16(truncatingIfNeeded: bitPattern)),
|
||||
Float16(bitPattern: UInt16(truncatingIfNeeded: bitPattern >> 16))
|
||||
)
|
||||
}
|
||||
for bits in 0 ... UInt32.max {
|
||||
let a = complex(bitPattern: bits)
|
||||
if bits & 0xfffff == 0 { print(a) }
|
||||
let b = complex(bitPattern: UInt32.random(in: 0 ... .max))
|
||||
var q = Complex<Float>(a)/Complex<Float>(b)
|
||||
if checkDivide(a, b, expected: Complex<Float16>(q), ulps: 4) { XCTFail() }
|
||||
q = Complex<Float>(b)/Complex<Float>(a)
|
||||
if checkDivide(b, a, expected: Complex<Float16>(q), ulps: 4) { XCTFail() }
|
||||
}
|
||||
}
|
||||
#endif
|
||||
}
|
||||
@@ -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
|
||||
@@ -1,8 +1,8 @@
|
||||
//===--- ElementaryFunctionTests.swift ------------------------*- swift -*-===//
|
||||
//
|
||||
// This source file is part of the Swift Numerics open source project
|
||||
// This source file is part of the Swift.org open source project
|
||||
//
|
||||
// Copyright (c) 2020 Apple Inc. and the Swift Numerics project authors
|
||||
// Copyright (c) 2020 Apple Inc. and the Swift project authors
|
||||
// Licensed under Apache License v2.0 with Runtime Library Exception
|
||||
//
|
||||
// See https://swift.org/LICENSE.txt for license information
|
||||
@@ -180,13 +180,7 @@ final class ElementaryFunctionTests: XCTestCase {
|
||||
XCTAssert(huge.imaginary.isApproximatelyEqual(to: mag))
|
||||
huge = Complex<T>.cosh(Complex(-x, .pi/4))
|
||||
XCTAssert(huge.real.isApproximatelyEqual(to: mag))
|
||||
XCTAssert(huge.imaginary.isApproximatelyEqual(to: -mag))
|
||||
huge = Complex<T>.cosh(Complex(-x, -.pi/4))
|
||||
XCTAssert(huge.real.isApproximatelyEqual(to: mag))
|
||||
XCTAssert(huge.imaginary.isApproximatelyEqual(to: mag))
|
||||
huge = Complex<T>.cosh(Complex(x, -.pi/4))
|
||||
XCTAssert(huge.real.isApproximatelyEqual(to: mag))
|
||||
XCTAssert(huge.imaginary.isApproximatelyEqual(to: -mag))
|
||||
}
|
||||
|
||||
func testSinh<T: Real & FixedWidthFloatingPoint>(_ type: T.Type) {
|
||||
@@ -218,12 +212,6 @@ final class ElementaryFunctionTests: XCTestCase {
|
||||
XCTAssert(huge.imaginary.isApproximatelyEqual(to: mag))
|
||||
huge = Complex<T>.sinh(Complex(-x, .pi/4))
|
||||
XCTAssert(huge.real.isApproximatelyEqual(to: -mag))
|
||||
XCTAssert(huge.imaginary.isApproximatelyEqual(to: mag))
|
||||
huge = Complex<T>.sinh(Complex(-x, -.pi/4))
|
||||
XCTAssert(huge.real.isApproximatelyEqual(to: -mag))
|
||||
XCTAssert(huge.imaginary.isApproximatelyEqual(to: -mag))
|
||||
huge = Complex<T>.sinh(Complex(x, -.pi/4))
|
||||
XCTAssert(huge.real.isApproximatelyEqual(to: mag))
|
||||
XCTAssert(huge.imaginary.isApproximatelyEqual(to: -mag))
|
||||
// For randomly-chosen well-scaled finite values, we expect to have
|
||||
// cosh² - sinh² ≈ 1. Note that this test would break down due to
|
||||
@@ -412,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)
|
||||
@@ -435,8 +411,6 @@ final class ElementaryFunctionTests: XCTestCase {
|
||||
testAcosh(Float.self)
|
||||
testAsinh(Float.self)
|
||||
testAtanh(Float.self)
|
||||
testPowR(Float.self)
|
||||
testPowN(Float.self)
|
||||
}
|
||||
|
||||
func testDouble() {
|
||||
@@ -450,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)
|
||||
@@ -466,8 +438,6 @@ final class ElementaryFunctionTests: XCTestCase {
|
||||
testAcosh(Float80.self)
|
||||
testAsinh(Float80.self)
|
||||
testAtanh(Float80.self)
|
||||
testPowR(Float80.self)
|
||||
testPowN(Float80.self)
|
||||
}
|
||||
#endif
|
||||
#endif
|
||||
}
|
||||
@@ -0,0 +1,108 @@
|
||||
//===--- main.swift -------------------------------------------*- swift -*-===//
|
||||
//
|
||||
// This source file is part of the Swift.org open source project
|
||||
//
|
||||
// Copyright (c) 2020 Apple Inc. and the Swift project authors
|
||||
// Licensed under Apache License v2.0 with Runtime Library Exception
|
||||
//
|
||||
// See https://swift.org/LICENSE.txt for license information
|
||||
// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
import Numerics
|
||||
import _TestSupport
|
||||
|
||||
#if DEBUG
|
||||
fatalError("Run this test in Release configuration")
|
||||
#else
|
||||
|
||||
var componentError = Double(Float.ulpOfOne/2)
|
||||
var complexError = Double(Float.ulpOfOne/2)
|
||||
var componentMaxInput = Complex<Float>.zero
|
||||
var complexMaxInput = Complex<Float>.zero
|
||||
|
||||
func test(_ z: Complex<Float>) {
|
||||
let tst = Complex.log(z)
|
||||
// TODO: we _should_ be able to say Complex<Double>(z), but that goes through
|
||||
// the slow, generic path for BinaryFloatingPoint conversion; once we get
|
||||
// that resolved in the standard library, we can replace the conversion on
|
||||
// this and the next line. Currently it dominate testing time if we do that.
|
||||
let ref = Complex.log(Complex(Double(z.real), Double(z.imaginary)))
|
||||
if tst == Complex(Float(ref.real), Float(ref.imaginary)) { return }
|
||||
let thisError = relativeError(tst, ref)
|
||||
if thisError > complexError {
|
||||
complexMaxInput = z
|
||||
complexError = thisError
|
||||
}
|
||||
let thisComponentError = componentwiseError(tst, ref)
|
||||
if thisComponentError > componentError {
|
||||
componentMaxInput = z
|
||||
componentError = thisComponentError
|
||||
}
|
||||
}
|
||||
|
||||
func testWithSymmetries(_ x: Float, _ y: Float) {
|
||||
test(Complex( x, y))
|
||||
test(Complex( y, x))
|
||||
test(Complex(-y, x))
|
||||
test(Complex(-x, y))
|
||||
test(Complex(-x,-y))
|
||||
test(Complex(-y,-x))
|
||||
test(Complex( y,-x))
|
||||
test(Complex( x,-y))
|
||||
}
|
||||
|
||||
// The hardest to evaluate cases for log are those close to the unit circle,
|
||||
// where log(z) is nearly zero. We want to have plausibly dense test coverage
|
||||
// close to the circle.
|
||||
let radii: [Float] = [0.9,
|
||||
0.95,
|
||||
0.99,
|
||||
0.999,
|
||||
0.9999,
|
||||
1 - 10 * .ulpOfOne,
|
||||
1,
|
||||
1 + 10 * .ulpOfOne,
|
||||
1.0001,
|
||||
1.001,
|
||||
1.01,
|
||||
1.05,
|
||||
1.1]
|
||||
|
||||
for r in radii {
|
||||
for x in Interval(from: 1/Float.sqrt(2), to: r) {
|
||||
// Generate the two y values that put us closest to the circle of radius r
|
||||
let base = Double.sqrt(Double(r).addingProduct(Double(-x), Double(x)))
|
||||
let a, b: Float
|
||||
if Double(Float(base)) < base { a = Float(base); b = a.nextUp }
|
||||
else { b = Float(base); a = b.nextDown }
|
||||
testWithSymmetries(x, a)
|
||||
testWithSymmetries(x, b)
|
||||
}
|
||||
}
|
||||
|
||||
// Away from the unit circle is "easy" but we still want to get some coverage.
|
||||
// Generate 1 million uniform random points inside the circle, and then test
|
||||
// both z and 1/z.
|
||||
var g = SystemRandomNumberGenerator()
|
||||
var count = 0
|
||||
while count < 1_000_000 {
|
||||
let z = Complex<Float>(.random(in: -1 ... 1, using: &g), .random(in: -1 ... 1, using: &g))
|
||||
if z.length > 1 { continue }
|
||||
count += 1
|
||||
test(z)
|
||||
test(1/z)
|
||||
}
|
||||
|
||||
print("Worst complex norm error seen for log was \(complexError)")
|
||||
print("For input \(complexMaxInput).")
|
||||
print("Reference result: \(Complex.log(Complex<Double>(complexMaxInput)))")
|
||||
print(" Observed result: \(Complex.log(complexMaxInput))")
|
||||
|
||||
print("Worst componentwise error seen for log was \(componentError)")
|
||||
print("For input \(componentMaxInput).")
|
||||
print("Reference result: \(Complex.log(Complex<Double>(componentMaxInput)))")
|
||||
print(" Observed result: \(Complex.log(componentMaxInput))")
|
||||
|
||||
#endif
|
||||
@@ -0,0 +1,108 @@
|
||||
//===--- main.swift -------------------------------------------*- swift -*-===//
|
||||
//
|
||||
// This source file is part of the Swift.org open source project
|
||||
//
|
||||
// Copyright (c) 2020 Apple Inc. and the Swift project authors
|
||||
// Licensed under Apache License v2.0 with Runtime Library Exception
|
||||
//
|
||||
// See https://swift.org/LICENSE.txt for license information
|
||||
// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
import Numerics
|
||||
import _TestSupport
|
||||
|
||||
#if DEBUG
|
||||
fatalError("Run this test in Release configuration")
|
||||
#else
|
||||
|
||||
var componentError = Double(Float.ulpOfOne/2)
|
||||
var complexError = Double(Float.ulpOfOne/2)
|
||||
var componentMaxInput = Complex<Float>.zero
|
||||
var complexMaxInput = Complex<Float>.zero
|
||||
|
||||
func test(_ z: Complex<Float>) {
|
||||
let tst = Complex.log(onePlus: z)
|
||||
// TODO: we _should_ be able to say Complex<Double>(z), but that goes through
|
||||
// the slow, generic path for BinaryFloatingPoint conversion; once we get
|
||||
// that resolved in the standard library, we can replace the conversion on
|
||||
// this and the next line. Currently it dominate testing time if we do that.
|
||||
let ref = Complex.log(onePlus: Complex(Double(z.real), Double(z.imaginary)))
|
||||
if tst == Complex(Float(ref.real), Float(ref.imaginary)) { return }
|
||||
let thisError = relativeError(tst, ref)
|
||||
if thisError > complexError {
|
||||
complexMaxInput = z
|
||||
complexError = thisError
|
||||
}
|
||||
let thisComponentError = componentwiseError(tst, ref)
|
||||
if thisComponentError > componentError {
|
||||
componentMaxInput = z
|
||||
componentError = thisComponentError
|
||||
}
|
||||
}
|
||||
|
||||
func testWithSymmetry(_ x: Float, _ y: Float) {
|
||||
test(Complex( x-1, y))
|
||||
test(Complex( y-1, x))
|
||||
test(Complex(-y-1, x))
|
||||
test(Complex(-x-1, y))
|
||||
test(Complex(-x-1,-y))
|
||||
test(Complex(-y-1,-x))
|
||||
test(Complex( y-1,-x))
|
||||
test(Complex( x-1,-y))
|
||||
}
|
||||
|
||||
// The hardest to evaluate cases for log are those close to the unit circle
|
||||
// centered at -1, where log(1+z) is nearly zero. We want to have plausibly
|
||||
// dense test coverage close to the circle.
|
||||
let radii: [Float] = [0.9,
|
||||
0.95,
|
||||
0.99,
|
||||
0.999,
|
||||
0.9999,
|
||||
1 - 10 * .ulpOfOne,
|
||||
1,
|
||||
1 + 10 * .ulpOfOne,
|
||||
1.0001,
|
||||
1.001,
|
||||
1.01,
|
||||
1.05,
|
||||
1.1]
|
||||
|
||||
for r in radii {
|
||||
for x in Interval(from: 1/Float.sqrt(2), to: r) {
|
||||
// Generate the two y values that put us closest to the circle of radius r
|
||||
let base = Double.sqrt(Double(r).addingProduct(Double(-x), Double(x)))
|
||||
let a, b: Float
|
||||
if Double(Float(base)) < base { a = Float(base); b = a.nextUp }
|
||||
else { b = Float(base); a = b.nextDown }
|
||||
testWithSymmetry(x, a)
|
||||
testWithSymmetry(x, b)
|
||||
}
|
||||
}
|
||||
|
||||
// Away from the unit circle is "easy" but we still want to get some coverage.
|
||||
// Generate 1 million uniform random points inside the circle, and then test
|
||||
// both z and 1/z.
|
||||
var g = SystemRandomNumberGenerator()
|
||||
var count = 0
|
||||
while count < 1_000_000 {
|
||||
let z = Complex<Float>(.random(in: -1 ... 1, using: &g), .random(in: -1 ... 1, using: &g))
|
||||
if z.length > 1 { continue }
|
||||
count += 1
|
||||
test(z - 1)
|
||||
test(1/z - 1)
|
||||
}
|
||||
|
||||
print("Worst complex norm error seen for log(onePlus:) was \(complexError)")
|
||||
print("For input \(complexMaxInput).")
|
||||
print("Reference result: \(Complex.log(onePlus: Complex<Double>(complexMaxInput)))")
|
||||
print(" Observed result: \(Complex.log(onePlus: complexMaxInput))")
|
||||
|
||||
print("Worst componentwise error seen for log(onePlus:) was \(componentError)")
|
||||
print("For input \(componentMaxInput).")
|
||||
print("Reference result: \(Complex.log(onePlus: Complex<Double>(componentMaxInput)))")
|
||||
print(" Observed result: \(Complex.log(onePlus: componentMaxInput))")
|
||||
|
||||
#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,484 +0,0 @@
|
||||
//===--- DivideTests.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
|
||||
// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
import IntegerUtilities
|
||||
import _TestSupport
|
||||
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)) failed the division rule.
|
||||
a - qb was \(ref), but r is \(r).
|
||||
""")
|
||||
return false
|
||||
}
|
||||
if r.magnitude >= b.magnitude {
|
||||
XCTFail("""
|
||||
\(a).divided(by: \(b)) 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)
|
||||
let justq = a.divided(by: b, rounding: .down)
|
||||
if q != justq {
|
||||
XCTFail("""
|
||||
\(a).divided(by: \(b), rounding: .down) failed check:
|
||||
BinaryInteger overload did not produce the same quotient as SignedInteger.
|
||||
BinaryInteger result was \(justq), but SignedInteger was \(q).
|
||||
""")
|
||||
return
|
||||
}
|
||||
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)
|
||||
let justq = a.divided(by: b, rounding: .up)
|
||||
if q != justq {
|
||||
XCTFail("""
|
||||
\(a).divided(by: \(b), rounding: .up) failed check:
|
||||
BinaryInteger overload did not produce the same quotient as SignedInteger.
|
||||
BinaryInteger result was \(justq), but SignedInteger was \(q).
|
||||
""")
|
||||
return
|
||||
}
|
||||
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)
|
||||
let justq = a.divided(by: b, rounding: .towardZero)
|
||||
if q != justq {
|
||||
XCTFail("""
|
||||
\(a).divided(by: \(b), rounding: .towardZero) failed check:
|
||||
BinaryInteger overload did not produce the same quotient as SignedInteger.
|
||||
BinaryInteger result was \(justq), but SignedInteger was \(q).
|
||||
""")
|
||||
return
|
||||
}
|
||||
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)
|
||||
let justq = a.divided(by: b, rounding: .awayFromZero)
|
||||
if q != justq {
|
||||
XCTFail("""
|
||||
\(a).divided(by: \(b), rounding: .awayFromZero) failed check:
|
||||
BinaryInteger overload did not produce the same quotient as SignedInteger.
|
||||
BinaryInteger result was \(justq), but SignedInteger was \(q).
|
||||
""")
|
||||
return
|
||||
}
|
||||
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 testDivideToNearestOrDown<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: .toNearestOrDown)
|
||||
let justq = a.divided(by: b, rounding: .toNearestOrDown)
|
||||
if q != justq {
|
||||
XCTFail("""
|
||||
\(a).divided(by: \(b), rounding: .toNearestOrDown) failed check:
|
||||
BinaryInteger overload did not produce the same quotient as SignedInteger.
|
||||
BinaryInteger result was \(justq), but SignedInteger was \(q).
|
||||
""")
|
||||
return
|
||||
}
|
||||
|
||||
XCTAssertEqual(q, justq)
|
||||
if divisionRuleHolds(a, b, q, r) {
|
||||
// We know a = bq + r with |r| < |b|. Now check |r| <= |b|/2
|
||||
// with equality only if q rounded down.
|
||||
if 2*r.magnitude > b.magnitude {
|
||||
XCTFail("""
|
||||
\(a).divided(by: \(b), rounding: .toNearestOrDown) 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() != b.signum() {
|
||||
XCTFail("""
|
||||
\(a).divided(by: \(b), rounding: .toNearestOrDown) failed check:
|
||||
If |remainder| equals |divisor|/2, remainder must have same sign as divisor, but was \(r).
|
||||
""")
|
||||
return
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func testDivideToNearestOrUp<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: .toNearestOrUp)
|
||||
let justq = a.divided(by: b, rounding: .toNearestOrUp)
|
||||
if q != justq {
|
||||
XCTFail("""
|
||||
\(a).divided(by: \(b), rounding: .toNearestOrUp) failed check:
|
||||
BinaryInteger overload did not produce the same quotient as SignedInteger.
|
||||
BinaryInteger result was \(justq), but SignedInteger was \(q).
|
||||
""")
|
||||
return
|
||||
}
|
||||
if divisionRuleHolds(a, b, q, r) {
|
||||
// We know a = bq + r with |r| < |b|. Now check |r| <= |b|/2
|
||||
// with equality only if q rounded up.
|
||||
if 2*r.magnitude > b.magnitude {
|
||||
XCTFail("""
|
||||
\(a).divided(by: \(b), rounding: .toNearestOrUp) 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() == b.signum() {
|
||||
XCTFail("""
|
||||
\(a).divided(by: \(b), rounding: .toNearestOrUp) failed check:
|
||||
If |remainder| equals |divisor|/2, remainder must have opposite sign of divisor, but was \(r).
|
||||
""")
|
||||
return
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func testDivideToNearestOrZero<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: .toNearestOrZero)
|
||||
let justq = a.divided(by: b, rounding: .toNearestOrZero)
|
||||
if q != justq {
|
||||
XCTFail("""
|
||||
\(a).divided(by: \(b), rounding: .toNearestOrZero) failed check:
|
||||
BinaryInteger overload did not produce the same quotient as SignedInteger.
|
||||
BinaryInteger result was \(justq), but SignedInteger was \(q).
|
||||
""")
|
||||
return
|
||||
}
|
||||
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: .toNearestOrZero) 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: .toNearestOrZero) failed check:
|
||||
If |remainder| equals |divisor|/2, remainder must match sign of dividend, but 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: .toNearestOrAway)
|
||||
let justq = a.divided(by: b, rounding: .toNearestOrAway)
|
||||
if q != justq {
|
||||
XCTFail("""
|
||||
\(a).divided(by: \(b), rounding: .toNearestOrAway) failed check:
|
||||
BinaryInteger overload did not produce the same quotient as SignedInteger.
|
||||
BinaryInteger result was \(justq), but SignedInteger was \(q).
|
||||
""")
|
||||
return
|
||||
}
|
||||
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: .toNearestOrAway) 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: .toNearestOrAway) 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)
|
||||
let justq = a.divided(by: b, rounding: .toNearestOrEven)
|
||||
if q != justq {
|
||||
XCTFail("""
|
||||
\(a).divided(by: \(b), rounding: .toNearestOrEven) failed check:
|
||||
BinaryInteger overload did not produce the same quotient as SignedInteger.
|
||||
BinaryInteger result was \(justq), but SignedInteger was \(q).
|
||||
""")
|
||||
return
|
||||
}
|
||||
if divisionRuleHolds(a, b, q, r) {
|
||||
// We know a = bq + r with |r| < |b|. Now check |r| <= |b|/2
|
||||
// with equality only if q is even.
|
||||
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 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)
|
||||
let justq = a.divided(by: b, rounding: .toOdd)
|
||||
if q != justq {
|
||||
XCTFail("""
|
||||
\(a).divided(by: \(b), rounding: .toOdd) failed check:
|
||||
BinaryInteger overload did not produce the same quotient as SignedInteger.
|
||||
BinaryInteger result was \(justq), but SignedInteger was \(q).
|
||||
""")
|
||||
return
|
||||
}
|
||||
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 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)
|
||||
testDivideToNearestOrDown(values)
|
||||
testDivideToNearestOrUp(values)
|
||||
testDivideToNearestOrZero(values)
|
||||
testDivideToNearestOrAway(values)
|
||||
testDivideToNearestOrEven(values)
|
||||
testDivideToOdd(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)
|
||||
testDivideToNearestOrDown(values)
|
||||
testDivideToNearestOrUp(values)
|
||||
testDivideToNearestOrZero(values)
|
||||
testDivideToNearestOrAway(values)
|
||||
testDivideToNearestOrEven(values)
|
||||
testDivideToOdd(values)
|
||||
testDivideExact(values)
|
||||
}
|
||||
|
||||
func testDivideInt128() {
|
||||
var values = [DoubleWidth<Int64>](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)
|
||||
testDivideToNearestOrDown(values)
|
||||
testDivideToNearestOrUp(values)
|
||||
testDivideToNearestOrZero(values)
|
||||
testDivideToNearestOrAway(values)
|
||||
testDivideToNearestOrEven(values)
|
||||
testDivideToOdd(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: .toNearestOrDown)
|
||||
divideUInt8(a, b, rounding: .toNearestOrUp)
|
||||
divideUInt8(a, b, rounding: .toNearestOrZero)
|
||||
divideUInt8(a, b, rounding: .toNearestOrAway)
|
||||
divideUInt8(a, b, rounding: .toNearestOrEven)
|
||||
divideUInt8(a, b, rounding: .toOdd)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
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))
|
||||
}
|
||||
}
|
||||
@@ -1,529 +0,0 @@
|
||||
//===--- DoubleWidthTests.swift -------------------------------*- swift -*-===//
|
||||
//
|
||||
// This source file is part of the Swift Numerics open source project
|
||||
//
|
||||
// Copyright (c) 2017-2024 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)
|
||||
}
|
||||
|
||||
func testMultiplyOverflow() {
|
||||
XCTAssertFalse(_Int128(-1).multipliedReportingOverflow(by: 0).overflow)
|
||||
}
|
||||
}
|
||||
@@ -1,44 +0,0 @@
|
||||
//===--- GCDTests.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
|
||||
// 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 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
|
||||
// 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,243 +0,0 @@
|
||||
//===--- RoundingTests.swift ----------------------------------*- swift -*-===//
|
||||
//
|
||||
// This source file is part of the Swift Numerics open source project
|
||||
//
|
||||
// Copyright (c) 2024 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
|
||||
// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
import IntegerUtilities
|
||||
import _TestSupport
|
||||
import XCTest
|
||||
|
||||
final class IntegerUtilitiesRoundingTests: XCTestCase {
|
||||
func testRoundingDirected<T: BinaryFloatingPoint>(_ type: T.Type) {
|
||||
let inf = T.infinity
|
||||
let gfm = T.greatestFiniteMagnitude
|
||||
let big: T = 1 / .ulpOfOne
|
||||
let two: T = 2
|
||||
let threeHalves: T = 1.5
|
||||
let one: T = 1
|
||||
let half: T = 0.5
|
||||
let nrm = T.leastNormalMagnitude
|
||||
let lnm = T.leastNonzeroMagnitude
|
||||
let vectors: [(input: T, down: T, up: T, zero: T, away: T)] = [
|
||||
(-inf, -inf, -inf, -inf, -inf),
|
||||
(-gfm, -gfm, -gfm, -gfm, -gfm),
|
||||
(-big.nextUp, -big-1, -big-1, -big-1, -big-1),
|
||||
(-big, -big, -big, -big, -big),
|
||||
(-big.nextDown, -big, -big+1, -big+1, -big),
|
||||
(-two, -two, -two, -two, -two),
|
||||
(-two.nextDown, -two, -one, -one, -two),
|
||||
(-threeHalves.nextUp, -two, -one, -one, -two),
|
||||
(-threeHalves, -two, -one, -one, -two),
|
||||
(-threeHalves.nextDown, -two, -one, -one, -two),
|
||||
(-one.nextUp, -two, -one, -one, -two),
|
||||
(-one, -one, -one, -one, -one),
|
||||
(-one.nextDown, -one, 0, 0, -one),
|
||||
(-half.nextUp, -one, 0, 0, -one),
|
||||
(-half, -one, 0, 0, -one),
|
||||
(-half.nextDown, -one, 0, 0, -one),
|
||||
(-nrm, -one, 0, 0, -one),
|
||||
(-lnm, -one, 0, 0, -one),
|
||||
(-.zero, 0, 0, 0, 0),
|
||||
( .zero, 0, 0, 0, 0),
|
||||
( lnm, 0, one, 0, one),
|
||||
( nrm, 0, one, 0, one),
|
||||
( half.nextDown, 0, one, 0, one),
|
||||
( half, 0, one, 0, one),
|
||||
( half.nextUp, 0, one, 0, one),
|
||||
( one.nextDown, 0, one, 0, one),
|
||||
( one, one, one, one, one),
|
||||
( one.nextUp, one, two, one, two),
|
||||
( threeHalves.nextDown, one, two, one, two),
|
||||
( threeHalves, one, two, one, two),
|
||||
( threeHalves.nextUp, one, two, one, two),
|
||||
( two.nextDown, one, two, one, two),
|
||||
( two, two, two, two, two),
|
||||
( big.nextDown, big-1, big, big-1, big),
|
||||
( big, big, big, big, big),
|
||||
( big.nextUp, big+1, big+1, big+1, big+1),
|
||||
( gfm, gfm, gfm, gfm, gfm),
|
||||
( inf, inf, inf, inf, inf),
|
||||
]
|
||||
for vector in vectors {
|
||||
|
||||
XCTAssertEqual(vector.input.rounding(.down), vector.down)
|
||||
if vector.down == 0 {
|
||||
XCTAssertEqual(vector.input.rounding(.down).sign, vector.input.sign)
|
||||
}
|
||||
|
||||
XCTAssertEqual(vector.input.rounding(.up), vector.up)
|
||||
if vector.up == 0 {
|
||||
XCTAssertEqual(vector.input.rounding(.up).sign, vector.input.sign)
|
||||
}
|
||||
|
||||
XCTAssertEqual(vector.input.rounding(.towardZero), vector.zero)
|
||||
if vector.zero == 0 {
|
||||
XCTAssertEqual(vector.input.rounding(.towardZero).sign, vector.input.sign)
|
||||
}
|
||||
|
||||
XCTAssertEqual(vector.input.rounding(.awayFromZero), vector.away)
|
||||
if vector.away == 0 {
|
||||
XCTAssertEqual(vector.input.rounding(.awayFromZero).sign, vector.input.sign)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func testRoundingDirected() {
|
||||
testRoundingDirected(Float.self)
|
||||
testRoundingDirected(Double.self)
|
||||
}
|
||||
|
||||
func testRoundingNearest<T: BinaryFloatingPoint>(_ type: T.Type) {
|
||||
let inf = T.infinity
|
||||
let gfm = T.greatestFiniteMagnitude
|
||||
let big: T = 1 / .ulpOfOne
|
||||
let two: T = 2
|
||||
let threeHalves: T = 1.5
|
||||
let one: T = 1
|
||||
let half: T = 0.5
|
||||
let nrm = T.leastNormalMagnitude
|
||||
let lnm = T.leastNonzeroMagnitude
|
||||
let vectors: [(input: T, down: T, up: T, zero: T, away: T, even: T)] = [
|
||||
(-inf, -inf, -inf, -inf, -inf, -inf),
|
||||
(-gfm, -gfm, -gfm, -gfm, -gfm, -gfm),
|
||||
(-big.nextUp, -big-1, -big-1, -big-1, -big-1, -big-1),
|
||||
(-big, -big, -big, -big, -big, -big),
|
||||
(-big.nextDown, -big, -big+1, -big+1, -big, -big),
|
||||
(-two, -two, -two, -two, -two, -two),
|
||||
(-two.nextDown, -two, -two, -two, -two, -two),
|
||||
(-threeHalves.nextUp, -two, -two, -two, -two, -two),
|
||||
(-threeHalves, -two, -one, -one, -two, -two),
|
||||
(-threeHalves.nextDown, -one, -one, -one, -one, -one),
|
||||
(-one.nextUp, -one, -one, -one, -one, -one),
|
||||
(-one, -one, -one, -one, -one, -one),
|
||||
(-one.nextDown, -one, -one, -one, -one, -one),
|
||||
(-half.nextUp, -one, -one, -one, -one, -one),
|
||||
(-half, -one, 0, 0, -one, 0),
|
||||
(-half.nextDown, 0, 0, 0, 0, 0),
|
||||
(-nrm, 0, 0, 0, 0, 0),
|
||||
(-lnm, 0, 0, 0, 0, 0),
|
||||
(-.zero, 0, 0, 0, 0, 0),
|
||||
( .zero, 0, 0, 0, 0, 0),
|
||||
( lnm, 0, 0, 0, 0, 0),
|
||||
( nrm, 0, 0, 0, 0, 0),
|
||||
( half.nextDown, 0, 0, 0, 0, 0),
|
||||
( half, 0, one, 0, one, 0),
|
||||
( half.nextUp, one, one, one, one, one),
|
||||
( one.nextDown, one, one, one, one, one),
|
||||
( one, one, one, one, one, one),
|
||||
( one.nextUp, one, one, one, one, one),
|
||||
( threeHalves.nextDown, one, one, one, one, one),
|
||||
( threeHalves, one, two, one, two, two),
|
||||
( threeHalves.nextUp, two, two, two, two, two),
|
||||
( two.nextDown, two, two, two, two, two),
|
||||
( two, two, two, two, two, two),
|
||||
( big.nextDown, big-1, big, big-1, big, big),
|
||||
( big, big, big, big, big, big),
|
||||
( big.nextUp, big+1, big+1, big+1, big+1, big+1),
|
||||
( gfm, gfm, gfm, gfm, gfm, gfm),
|
||||
( inf, inf, inf, inf, inf, inf),
|
||||
]
|
||||
for vector in vectors {
|
||||
|
||||
XCTAssertEqual(vector.input.rounding(.toNearestOrDown), vector.down, "\(vector.input).rounding(.toNearestOrDown)")
|
||||
if vector.down == 0 {
|
||||
XCTAssertEqual(vector.input.rounding(.toNearestOrDown).sign, vector.input.sign, "\(vector.input).rounding(.toNearestOrDown)")
|
||||
}
|
||||
|
||||
XCTAssertEqual(vector.input.rounding(.toNearestOrUp), vector.up, "\(vector.input).rounding(.toNearestOrUp)")
|
||||
if vector.up == 0 {
|
||||
XCTAssertEqual(vector.input.rounding(.toNearestOrUp).sign, vector.input.sign, "\(vector.input).rounding(.toNearestOrUp)")
|
||||
}
|
||||
|
||||
XCTAssertEqual(vector.input.rounding(.toNearestOrZero), vector.zero, "\(vector.input).rounding(.toNearestOrZero)")
|
||||
if vector.zero == 0 {
|
||||
XCTAssertEqual(vector.input.rounding(.toNearestOrZero).sign, vector.input.sign, "\(vector.input).rounding(.toNearestOrZero)")
|
||||
}
|
||||
|
||||
XCTAssertEqual(vector.input.rounding(.toNearestOrAway), vector.away, "\(vector.input).rounding(.toNearestOrAway)")
|
||||
if vector.away == 0 {
|
||||
XCTAssertEqual(vector.input.rounding(.toNearestOrAway).sign, vector.input.sign, "\(vector.input).rounding(.toNearestOrAway)")
|
||||
}
|
||||
|
||||
XCTAssertEqual(vector.input.rounding(.toNearestOrEven), vector.even, "\(vector.input).rounding(.toNearestOrEven)")
|
||||
if vector.even == 0 {
|
||||
XCTAssertEqual(vector.input.rounding(.toNearestOrEven).sign, vector.input.sign, "\(vector.input).rounding(.toNearestOrEven)")
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func testRoundingNearest() {
|
||||
testRoundingNearest(Float.self)
|
||||
testRoundingNearest(Double.self)
|
||||
}
|
||||
|
||||
func testRoundingOdd<T: BinaryFloatingPoint>(_ type: T.Type) {
|
||||
let inf = T.infinity
|
||||
let gfm = T.greatestFiniteMagnitude
|
||||
let big: T = 1 / .ulpOfOne
|
||||
let two: T = 2
|
||||
let threeHalves: T = 1.5
|
||||
let one: T = 1
|
||||
let half: T = 0.5
|
||||
let nrm = T.leastNormalMagnitude
|
||||
let lnm = T.leastNonzeroMagnitude
|
||||
let vectors: [(input: T, odd: T)] = [
|
||||
(-inf, -inf),
|
||||
(-gfm, -gfm),
|
||||
(-big.nextUp, -big-1),
|
||||
(-big, -big),
|
||||
(-big.nextDown, -big+1),
|
||||
(-two, -two),
|
||||
(-two.nextDown, -one),
|
||||
(-threeHalves.nextUp, -one),
|
||||
(-threeHalves, -one),
|
||||
(-threeHalves.nextDown, -one),
|
||||
(-one.nextUp, -one),
|
||||
(-one, -one),
|
||||
(-one.nextDown, -one),
|
||||
(-half.nextUp, -one),
|
||||
(-half, -one),
|
||||
(-half.nextDown, -one),
|
||||
(-nrm, -one),
|
||||
(-lnm, -one),
|
||||
(-.zero, 0),
|
||||
( .zero, 0),
|
||||
( lnm, one),
|
||||
( nrm, one),
|
||||
( half.nextDown, one),
|
||||
( half, one),
|
||||
( half.nextUp, one),
|
||||
( one.nextDown, one),
|
||||
( one, one),
|
||||
( one.nextUp, one),
|
||||
( threeHalves.nextDown, one),
|
||||
( threeHalves, one),
|
||||
( threeHalves.nextUp, one),
|
||||
( two.nextDown, one),
|
||||
( two, two),
|
||||
( big.nextDown, big-1),
|
||||
( big, big),
|
||||
( big.nextUp, big+1),
|
||||
( gfm, gfm),
|
||||
( inf, inf)
|
||||
]
|
||||
for vector in vectors {
|
||||
XCTAssertEqual(vector.input.rounding(.toOdd), vector.odd, "\(vector.input).rounding(.toOdd)")
|
||||
if vector.odd == 0 {
|
||||
XCTAssertEqual(vector.input.rounding(.toOdd).sign, vector.input.sign, "\(vector.input).rounding(.toOdd)")
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func testRoundingOdd() {
|
||||
testRoundingOdd(Float.self)
|
||||
testRoundingOdd(Double.self)
|
||||
}
|
||||
}
|
||||
@@ -1,192 +0,0 @@
|
||||
//===--- SaturatingArithmeticTests.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
|
||||
// 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,155 +0,0 @@
|
||||
//===--- ShiftTests.swift -------------------------------------*- swift -*-===//
|
||||
//
|
||||
// This source file is part of the Swift Numerics open source project
|
||||
//
|
||||
// Copyright (c) 2021-2024 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
|
||||
// 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
|
||||
if exact { expected = floor }
|
||||
else {
|
||||
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 .toNearestOrDown:
|
||||
let step = value.shifted(rightBy: count - 2, rounding: .toOdd)
|
||||
switch step & 0b11 {
|
||||
case 0b01: expected = floor
|
||||
case 0b10: expected = floor
|
||||
case 0b11: expected = ceiling
|
||||
default: preconditionFailure()
|
||||
}
|
||||
case .toNearestOrUp:
|
||||
let step = value.shifted(rightBy: count - 2, rounding: .toOdd)
|
||||
switch step & 0b11 {
|
||||
case 0b01: expected = floor
|
||||
case 0b10: expected = ceiling
|
||||
case 0b11: expected = ceiling
|
||||
default: preconditionFailure()
|
||||
}
|
||||
case .toNearestOrZero:
|
||||
let step = value.shifted(rightBy: count - 2, rounding: .toOdd)
|
||||
switch step & 0b11 {
|
||||
case 0b01: expected = floor
|
||||
case 0b10: expected = value > 0 ? floor : ceiling
|
||||
case 0b11: expected = ceiling
|
||||
default: preconditionFailure()
|
||||
}
|
||||
case .toNearestOrAway:
|
||||
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:
|
||||
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 .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: 2))")
|
||||
print("Expected: \(String(expected, radix: 2))")
|
||||
print("Observed: \(String(observed, radix: 2))")
|
||||
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: .toNearestOrUp)
|
||||
testRoundingShift(Int8.self, rounding: .toNearestOrDown)
|
||||
testRoundingShift(Int8.self, rounding: .toNearestOrZero)
|
||||
testRoundingShift(Int8.self, rounding: .toNearestOrAway)
|
||||
testRoundingShift(Int8.self, rounding: .toNearestOrEven)
|
||||
testRoundingShift(Int8.self, rounding: .toOdd)
|
||||
|
||||
testRoundingShift(UInt8.self, rounding: .down)
|
||||
testRoundingShift(UInt8.self, rounding: .up)
|
||||
testRoundingShift(UInt8.self, rounding: .towardZero)
|
||||
testRoundingShift(UInt8.self, rounding: .awayFromZero)
|
||||
testRoundingShift(UInt8.self, rounding: .toNearestOrUp)
|
||||
testRoundingShift(UInt8.self, rounding: .toNearestOrDown)
|
||||
testRoundingShift(UInt8.self, rounding: .toNearestOrZero)
|
||||
testRoundingShift(UInt8.self, rounding: .toNearestOrAway)
|
||||
testRoundingShift(UInt8.self, rounding: .toNearestOrEven)
|
||||
testRoundingShift(UInt8.self, rounding: .toOdd)
|
||||
|
||||
testRoundingShift(Int.self, rounding: .down)
|
||||
testRoundingShift(Int.self, rounding: .up)
|
||||
testRoundingShift(Int.self, rounding: .towardZero)
|
||||
testRoundingShift(Int.self, rounding: .awayFromZero)
|
||||
testRoundingShift(Int.self, rounding: .toNearestOrUp)
|
||||
testRoundingShift(Int.self, rounding: .toNearestOrDown)
|
||||
testRoundingShift(Int.self, rounding: .toNearestOrZero)
|
||||
testRoundingShift(Int.self, rounding: .toNearestOrAway)
|
||||
testRoundingShift(Int.self, rounding: .toNearestOrEven)
|
||||
testRoundingShift(Int.self, rounding: .toOdd)
|
||||
|
||||
testRoundingShift(UInt.self, rounding: .down)
|
||||
testRoundingShift(UInt.self, rounding: .up)
|
||||
testRoundingShift(UInt.self, rounding: .towardZero)
|
||||
testRoundingShift(UInt.self, rounding: .awayFromZero)
|
||||
testRoundingShift(UInt.self, rounding: .toNearestOrUp)
|
||||
testRoundingShift(UInt.self, rounding: .toNearestOrDown)
|
||||
testRoundingShift(UInt.self, rounding: .toNearestOrZero)
|
||||
testRoundingShift(UInt.self, rounding: .toNearestOrAway)
|
||||
testRoundingShift(UInt.self, rounding: .toNearestOrEven)
|
||||
testRoundingShift(UInt.self, rounding: .toOdd)
|
||||
}
|
||||
}
|
||||
@@ -1,19 +1,12 @@
|
||||
//===--- BlackHole.swift --------------------------------------*- swift -*-===//
|
||||
//===--- LinuxMain.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
|
||||
// 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 _NumericsShims
|
||||
|
||||
@_transparent
|
||||
public func blackHole<T>(_ thing: T) {
|
||||
withUnsafePointer(to: thing) {
|
||||
_numerics_optimization_barrier($0)
|
||||
}
|
||||
}
|
||||
fatalError("Use --enable-test-discovery to run Swift Numerics tests on Linux.")
|
||||
@@ -1,8 +1,8 @@
|
||||
//===--- ApproximateEqualityTests.swift -----------------------*- swift -*-===//
|
||||
//
|
||||
// This source file is part of the Swift Numerics open source project
|
||||
// This source file is part of the Swift.org open source project
|
||||
//
|
||||
// Copyright (c) 2020 Apple Inc. and the Swift Numerics project authors
|
||||
// Copyright (c) 2020 Apple Inc. and the Swift project authors
|
||||
// Licensed under Apache License v2.0 with Runtime Library Exception
|
||||
//
|
||||
// See https://swift.org/LICENSE.txt for license information
|
||||
|
||||
@@ -1,160 +0,0 @@
|
||||
//===--- AugmentedArithmeticTests.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
|
||||
// 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
|
||||
}
|
||||
}
|
||||
|
||||
@@ -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,59 +120,39 @@ 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
|
||||
}
|
||||
}
|
||||
|
||||
extension Real {
|
||||
static func powZeroChecks() {
|
||||
// pow(_:Self,_:Self) is defined by exp(y log(x)) and has edge-cases to
|
||||
// match. In particular, if x is zero, log(x) is -infinity, so pow(0,0)
|
||||
// is exp(0 * -infinity) = exp(nan) = nan.
|
||||
XCTAssertEqual(pow(0, -1 as Self), infinity)
|
||||
XCTAssert(pow(0, 0 as Self).isNaN)
|
||||
XCTAssertEqual(pow(0, 1 as Self), zero)
|
||||
// pow(_:Self,_:Int) is defined by repeated multiplication or division,
|
||||
// and hence pow(0, 0) is 1.
|
||||
XCTAssertEqual(pow(0, -1), infinity)
|
||||
XCTAssertEqual(pow(0, 0), 1)
|
||||
XCTAssertEqual(pow(0, 1), zero)
|
||||
#endif
|
||||
}
|
||||
}
|
||||
|
||||
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, tvOS 14.0, watchOS 7.0, *) {
|
||||
if #available(macOS 11.0, iOS 14.0, watchOS 14.0, tvOS 7.0, *) {
|
||||
Float16.elementaryFunctionChecks()
|
||||
Float16.realFunctionChecks()
|
||||
Float16.powZeroChecks()
|
||||
}
|
||||
}
|
||||
#endif
|
||||
#endif
|
||||
|
||||
func testFloat() {
|
||||
Float.elementaryFunctionChecks()
|
||||
Float.realFunctionChecks()
|
||||
Float.powZeroChecks()
|
||||
}
|
||||
|
||||
func testDouble() {
|
||||
Double.elementaryFunctionChecks()
|
||||
Double.realFunctionChecks()
|
||||
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
|
||||
}
|
||||
@@ -31,11 +31,6 @@ internal extension Real where Self: FixedWidthFloatingPoint {
|
||||
XCTAssertEqual(Self.pow(-1, Int.max), -1)
|
||||
XCTAssertEqual(Self.pow(-1, -Int.max), -1)
|
||||
XCTAssertEqual(Self.pow(-1, Int.min), 1)
|
||||
}
|
||||
|
||||
static func testIntegerExponentOverflowAndUnderflow() {
|
||||
// TODO: replace with seedable generator, print seed.
|
||||
var g = SystemRandomNumberGenerator()
|
||||
// Generate some random test values that definitely overflow or
|
||||
// underflow; we want to be sure that we get the right ±0 or ±∞
|
||||
// result.
|
||||
@@ -82,12 +77,11 @@ internal extension Real where Self: FixedWidthFloatingPoint {
|
||||
}
|
||||
}
|
||||
|
||||
#if !((os(macOS) || targetEnvironment(macCatalyst)) && arch(x86_64))
|
||||
@available(macOS 11.0, iOS 14.0, tvOS 14.0, watchOS 7.0, *)
|
||||
#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() {
|
||||
testIntegerExponentCommon()
|
||||
testIntegerExponentOverflowAndUnderflow()
|
||||
testIntegerExponentDoubleAndSmaller()
|
||||
let u = Float16(1).nextUp
|
||||
let d = Float16(1).nextDown
|
||||
@@ -115,7 +109,6 @@ extension Float16 {
|
||||
extension Float {
|
||||
static func testIntegerExponent() {
|
||||
testIntegerExponentCommon()
|
||||
testIntegerExponentOverflowAndUnderflow()
|
||||
testIntegerExponentDoubleAndSmaller()
|
||||
let u = Float(1).nextUp
|
||||
let d = Float(1).nextDown
|
||||
@@ -142,7 +135,6 @@ extension Float {
|
||||
extension Double {
|
||||
static func testIntegerExponent() {
|
||||
testIntegerExponentCommon()
|
||||
testIntegerExponentOverflowAndUnderflow()
|
||||
// Following tests only make sense (and are only necessary) on 64b platforms.
|
||||
#if arch(arm64) || arch(x86_64)
|
||||
testIntegerExponentDoubleAndSmaller()
|
||||
@@ -165,10 +157,10 @@ extension Double {
|
||||
#endif
|
||||
assertClose( 1.7976931348623151738531864721534215e308, Double.pow(-u, 3196577161300664268), allowedError: tol)
|
||||
assertClose(-1.7976931348623155730212483790972209e308, Double.pow(-u, 3196577161300664269), allowedError: tol)
|
||||
assertClose( 1.7976931348623159721893102860411089e308, Double.pow(-u, 3196577161300664270), allowedError: tol) // warning expected on non-x86
|
||||
assertClose( 1.7976931348623159721893102860411089e308, Double.pow(-u, 3196577161300664270), allowedError: tol)
|
||||
assertClose( 1.7976931348623157075547244136070910e308, Double.pow(-d, -6393154322601327474), allowedError: tol)
|
||||
assertClose(-1.7976931348623159071387553670790721e308, Double.pow(-d, -6393154322601327475), allowedError: tol) // warning expected on non-x86
|
||||
assertClose( 1.7976931348623161067227863205510754e308, Double.pow(-d, -6393154322601327476), allowedError: tol) // warning expected on non-x86
|
||||
assertClose(-1.7976931348623159071387553670790721e308, Double.pow(-d, -6393154322601327475), allowedError: tol)
|
||||
assertClose( 1.7976931348623161067227863205510754e308, Double.pow(-d, -6393154322601327476), allowedError: tol)
|
||||
// Exponents close to underflow boundary.
|
||||
assertClose( 2.4703282292062334560337346683707907e-324, Double.pow(-u, -3355781687888880946))
|
||||
assertClose(-2.4703282292062329075106789791206172e-324, Double.pow(-u, -3355781687888880947))
|
||||
@@ -182,9 +174,9 @@ 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, tvOS 14.0, watchOS 7.0, *) {
|
||||
if #available(macOS 11.0, iOS 14.0, watchOS 14.0, tvOS 7.0, *) {
|
||||
Float16.testIntegerExponent()
|
||||
}
|
||||
}
|
||||
@@ -201,10 +193,6 @@ final class IntegerExponentTests: XCTestCase {
|
||||
#if (arch(i386) || arch(x86_64)) && !os(Windows) && !os(Android)
|
||||
func testFloat80() {
|
||||
Float80.testIntegerExponentCommon()
|
||||
// FreeBSD's powl(3) has a bug where a minus sign is not perserved on overflow/underflow.
|
||||
#if !os(FreeBSD)
|
||||
Float80.testIntegerExponentOverflowAndUnderflow()
|
||||
#endif
|
||||
}
|
||||
#endif
|
||||
}
|
||||
@@ -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 basic 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 !((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
|
||||
@@ -0,0 +1,109 @@
|
||||
//===--- WindowsMain.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
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
#if os(Windows)
|
||||
import XCTest
|
||||
|
||||
@testable
|
||||
import RealTests
|
||||
|
||||
@testable
|
||||
import ComplexTests
|
||||
|
||||
extension ComplexTests.ApproximateEqualityTests {
|
||||
static var all = testCase([
|
||||
("testFloat", ComplexTests.ApproximateEqualityTests.testFloat),
|
||||
("testDouble", ComplexTests.ApproximateEqualityTests.testDouble),
|
||||
])
|
||||
}
|
||||
|
||||
extension RealTests.ApproximateEqualityTests {
|
||||
static var all = testCase([
|
||||
("testFloat", RealTests.ApproximateEqualityTests.testFloat),
|
||||
("testDouble", RealTests.ApproximateEqualityTests.testDouble),
|
||||
])
|
||||
}
|
||||
|
||||
#if swift(>=5.4) && !((os(macOS) || targetEnvironment(macCatalyst)) && arch(x86_64))
|
||||
extension ElementaryFunctionChecks {
|
||||
static var all = testCase([
|
||||
("testFloat16", ElementaryFunctionChecks.testFloat16),
|
||||
("testFloat", ElementaryFunctionChecks.testFloat),
|
||||
("testDouble", ElementaryFunctionChecks.testDouble),
|
||||
])
|
||||
}
|
||||
|
||||
extension IntegerExponentTests {
|
||||
static var all = testCase([
|
||||
("testFloat16", IntegerExponentTests.testFloat16),
|
||||
("testFloat", IntegerExponentTests.testFloat),
|
||||
("testDouble", IntegerExponentTests.testDouble),
|
||||
])
|
||||
}
|
||||
#else
|
||||
extension ElementaryFunctionChecks {
|
||||
static var all = testCase([
|
||||
("testFloat", ElementaryFunctionChecks.testFloat),
|
||||
("testDouble", ElementaryFunctionChecks.testDouble),
|
||||
])
|
||||
}
|
||||
|
||||
extension IntegerExponentTests {
|
||||
static var all = testCase([
|
||||
("testFloat", IntegerExponentTests.testFloat),
|
||||
("testDouble", IntegerExponentTests.testDouble),
|
||||
])
|
||||
}
|
||||
#endif
|
||||
|
||||
extension ArithmeticTests {
|
||||
static var all = testCase([
|
||||
("testPolar", ArithmeticTests.testPolar),
|
||||
("testBaudinSmith", ArithmeticTests.testBaudinSmith),
|
||||
("testDivisionByZero", ArithmeticTests.testDivisionByZero),
|
||||
])
|
||||
}
|
||||
|
||||
extension PropertyTests {
|
||||
static var all = testCase([
|
||||
("testProperties", PropertyTests.testProperties),
|
||||
("testEquatableHashable", PropertyTests.testEquatableHashable),
|
||||
("testCodable", PropertyTests.testCodable),
|
||||
])
|
||||
}
|
||||
|
||||
var testCases = [
|
||||
ComplexTests.ApproximateEqualityTests.all,
|
||||
RealTests.ApproximateEqualityTests.all,
|
||||
ElementaryFunctionChecks.all,
|
||||
IntegerExponentTests.all,
|
||||
ArithmeticTests.all,
|
||||
PropertyTests.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
|
||||
@@ -17,15 +17,11 @@ See https://swift.org/LICENSE.txt for license information
|
||||
function(get_swift_host_arch result_var_name)
|
||||
if("${CMAKE_SYSTEM_PROCESSOR}" STREQUAL "x86_64")
|
||||
set("${result_var_name}" "x86_64" PARENT_SCOPE)
|
||||
elseif ("${CMAKE_SYSTEM_PROCESSOR}" MATCHES "AArch64|aarch64|arm64")
|
||||
if(CMAKE_SYSTEM_NAME MATCHES Darwin)
|
||||
set("${result_var_name}" "arm64" PARENT_SCOPE)
|
||||
else()
|
||||
set("${result_var_name}" "aarch64" PARENT_SCOPE)
|
||||
endif()
|
||||
elseif("${CMAKE_SYSTEM_PROCESSOR}" STREQUAL "ppc64" OR "${CMAKE_SYSTEM_PROCESSOR}" STREQUAL "powerpc64")
|
||||
elseif("${CMAKE_SYSTEM_PROCESSOR}" STREQUAL "aarch64")
|
||||
set("${result_var_name}" "aarch64" PARENT_SCOPE)
|
||||
elseif("${CMAKE_SYSTEM_PROCESSOR}" STREQUAL "ppc64")
|
||||
set("${result_var_name}" "powerpc64" PARENT_SCOPE)
|
||||
elseif("${CMAKE_SYSTEM_PROCESSOR}" STREQUAL "ppc64le" OR "${CMAKE_SYSTEM_PROCESSOR}" STREQUAL "powerpc64le")
|
||||
elseif("${CMAKE_SYSTEM_PROCESSOR}" STREQUAL "ppc64le")
|
||||
set("${result_var_name}" "powerpc64le" PARENT_SCOPE)
|
||||
elseif("${CMAKE_SYSTEM_PROCESSOR}" STREQUAL "s390x")
|
||||
set("${result_var_name}" "s390x" PARENT_SCOPE)
|
||||
@@ -43,8 +39,6 @@ function(get_swift_host_arch result_var_name)
|
||||
set("${result_var_name}" "i686" PARENT_SCOPE)
|
||||
elseif("${CMAKE_SYSTEM_PROCESSOR}" STREQUAL "i686")
|
||||
set("${result_var_name}" "i686" PARENT_SCOPE)
|
||||
elseif("${CMAKE_SYSTEM_PROCESSOR}" STREQUAL "riscv64")
|
||||
set("${result_var_name}" "riscv64" PARENT_SCOPE)
|
||||
else()
|
||||
message(FATAL_ERROR "Unrecognized architecture on host system: ${CMAKE_SYSTEM_PROCESSOR}")
|
||||
endif()
|
||||
|
||||
Reference in new issue
Block a user