13 Commits
Author SHA1 Message Date
Stephen Canon bbadd4b853 Merge pull request #326 from stephentyrone/wasm-testing-1.1
[1.1] enable wasm testing
2025-08-14 13:11:52 -04:00
Stephen Canon e46ddfe087 Merge pull request #325 from stephentyrone/enable-wasm-testing
Enable workflows testing for wasm.
2025-08-14 12:59:30 -04:00
Stephen Canon 1653d35461 Merge pull request #323 from stephentyrone/docc-stuff-1.1
[1.1] pull in documentation revamp from main
2025-08-14 09:36:49 -04:00
Stephen Canon 207fea2fc1 Pull documentation revamp from main into release/1.1 2025-08-13 23:18:57 -04:00
Stephen Canon c16e7a9617 Merge pull request #322 from stephentyrone/augmented-sum-assert-1.1
[1.1] Remove assert in Augmented.sum(large:small:)
2025-08-11 19:52:47 -04:00
Stephen Canon 416b94a80e Merge pull request #321 from stephentyrone/remove-2sum-assert
Remove precondition assert from Augmented.sum(large:small:)
2025-08-11 19:35:39 -04:00
Stephen Canon 1a19d0d28d Merge pull request #318 from stephentyrone/constrain-algebraic-field-1.1
[1.1] Constrain algebraic field to Magnitude: AlgebraicField
2025-08-09 12:48:26 -04:00
Stephen Canon d91884bb27 Merge pull request #315 from stephentyrone/algebraic-field-magnitude
Constrain AlgebraicField to required Magnitude:AlgebraicField
2025-08-08 17:19:36 -04:00
Stephen Canon 6bd8a0cc08 Merge pull request #317 from apple/stephentyrone-patch-1
Update README.md
2025-08-08 17:16:58 -04:00
Stephen Canon 05472f917c Update README.md
Move baseline to 1.1.0 in the how to adopt section
2025-08-08 17:16:45 -04:00
Stephen Canon 658bcd12f4 Merge pull request #313 from stephentyrone/relax-f16-x86-1.1
[1.1] Enable relaxed f16 arithmetic for x86
2025-08-08 10:07:13 -04:00
Stephen Canon b95ca135a6 Restore relaxed mul/add bindings for Float16 on x86
The ABI is stable, so these operations can be turned on.
2025-08-08 09:47:03 -04:00
Stephen Canon fd82b65b04 Create release/1.1 branch to prepare for tag.
This is a cut of main with IntegerUtilities removed; I plan to tag 1.1 with non-integer feature work from main, and 1.2 will be the first tag with IntegerUtilities.
2025-08-08 09:37:13 -04:00
43 changed files with 7 additions and 5376 deletions

No files matched your search

-1
View File
@@ -9,7 +9,6 @@ jobs:
name: Test
uses: swiftlang/github-workflows/.github/workflows/swift_package_test.yml@main
with:
windows_exclude_swift_versions: '[{"swift_version": "5.9"}]'
enable_wasm_sdk_build: true
wasm_sdk_build_command: swift build --target Numerics
soundness:
+2 -31
View File
@@ -20,22 +20,11 @@ let package = Package(
products: [
.library(name: "ComplexModule", targets: ["ComplexModule"]),
.library(name: "Numerics", targets: ["Numerics"]),
.library(name: "QuaternionModule", targets: ["QuaternionModule"]),
.library(name: "RealModule", targets: ["RealModule"]),
],
targets: [
// MARK: - Public API
.target(
name: "Numerics",
dependencies: [
"ComplexModule",
"IntegerUtilities",
"QuaternionModule",
"RealModule"],
exclude: excludedFilenames
),
.target(
name: "ComplexModule",
dependencies: ["RealModule"],
@@ -43,17 +32,11 @@ let package = Package(
),
.target(
name: "IntegerUtilities",
dependencies: [],
name: "Numerics",
dependencies: ["ComplexModule", "RealModule"],
exclude: excludedFilenames
),
.target(
name: "QuaternionModule",
dependencies: ["RealModule"],
exclude: ["README.md", "Transformation.md"]
),
.target(
name: "RealModule",
dependencies: ["_NumericsShims"],
@@ -82,22 +65,10 @@ let package = Package(
exclude: ["CMakeLists.txt"]
),
.testTarget(
name: "IntegerUtilitiesTests",
dependencies: ["_TestSupport"],
exclude: ["CMakeLists.txt"]
),
.testTarget(
name: "RealTests",
dependencies: ["_TestSupport"],
exclude: ["CMakeLists.txt"]
),
.testTarget(
name: "QuaternionTests",
dependencies: ["_TestSupport"],
exclude: ["CMakeLists.txt"]
)
]
)
+1 -3
View File
@@ -42,7 +42,7 @@ To use Swift Numerics in a SwiftPM project:
1. Add the following line to the dependencies in your `Package.swift` file:
```swift
.package(url: "https://github.com/apple/swift-numerics", branch: "Quaternions"),
.package(url: "https://github.com/apple/swift-numerics", from: "1.1.0"),
```
2. Add `Numerics` as a dependency for your target:
@@ -105,8 +105,6 @@ Questions about how to use Swift Numerics modules, or issues that are not clearl
1. [`RealModule`](Sources/RealModule/README.md)
2. [`ComplexModule`](Sources/ComplexModule/README.md)
3. [`QuaternionModule`](Sources/QuaternionModule/README.md) (on main only, not yet present in a released tag)
4. [`IntegerUtilities`](Sources/IntegerUtilities/README.md) (on main only, not yet present in a released tag)
## Future expansion
-1
View File
@@ -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)
@@ -32,12 +32,6 @@
// Except where derivations are given, the expressions used here are all
// adapted from Kahan's 1986 paper "Branch Cuts for Complex Elementary
// Functions; or: Much Ado About Nothing's Sign Bit".
//
// Elementary functions of complex numbers have many similarities with
// elementary functions of quaternions and their definition in terms of real
// operations. Therefore, if you make a modification to one of the following
// functions, you should almost surely make a parallel modification to the same
// elementary function of quaternions.
import RealModule
-21
View File
@@ -1,21 +0,0 @@
#[[
This source file is part of the Swift Numerics open source project
Copyright (c) 2019-2021 Apple Inc. and the Swift Numerics project authors
Licensed under Apache License v2.0 with Runtime Library Exception
See https://swift.org/LICENSE.txt for license information
#]]
add_library(IntegerUtilities
DivideWithRounding.swift
GCD.swift
Rotate.swift
RoundingRule.swift
SaturatingArithmetic.swift
ShiftWithRounding.swift)
set_target_properties(IntegerUtilities PROPERTIES
INTERFACE_INCLUDE_DIRECTORIES ${CMAKE_Swift_MODULE_DIRECTORY})
_install_target(IntegerUtilities)
set_property(GLOBAL APPEND PROPERTY SWIFT_NUMERICS_EXPORTS IntegerUtilities)
@@ -1,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)
}
-40
View File
@@ -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).")
}
-68
View File
@@ -1,68 +0,0 @@
# Integer Utilities
_Note: This module is only present on `main`, and has not yet been stabilized and released in a tag._
## Utilities defined for `BinaryInteger`
The following API are defined for all integer types:
- The `gcd(_:_:)` free function implements the _Greatest Common Divisor_ operation.
- The `shifted(rightBy:rounding:)` method implements _bitwise shift with rounding_.
- The `divided(by:rounding:)` method implements division with specified rounding.
(See also `SignedInteger.divided(by:rounding:)`, `remainder(dividingBy:rounding:)`, and `euclideanDivision(_:_:)` below).
## Utilities defined for `SignedInteger`
The following API are defined for signed integer types:
- The `divided(by:rounding:)` method implementing division with specified rounding, returning both quotient and remainder.
This requires a signed type because the remainder is not generally representable for unsigned types.
This is a disfavored overload; by default, you will get only the quotient as the result:
```
let p = 5.divided(by: 3, rounding: .up) // p = 2
let (q, r) = 5.divided(by: 3, rounding: .up) // q = 2, r = -1
```
- The `remainder(dividingBy:rounding:)` method implementing the remainder operation; the `rounding` argument describes how to round the _quotient_, which is not returned.
(The remainder is always exact, and hence is not rounded).
- The `euclideanDivision(_:_:)` free function implements _Euclidean division_.
In this operation, the remainder is chosen to always be non-negative.
This does not correspond to any rounding rule on the quotient, which is why it uses a distinct API.
## Utilities defined for `FixedWidthInteger`
- The `rotated(right:)` and `rotated(left:)` methods implement _bitwise rotation_ for signed and unsigned integer types.
The count parameter may be any `BinaryInteger` type.
### [Saturating Arithmetic][saturating]
The following saturating operations are defined as methods on `FixedWidthInteger`:
- `addingWithSaturation(_:)`
- `subtractingWithSaturation(_:)`
- `negatedWithSaturation(_:)`
- `multipliedWithSaturation(by:)`
- `shiftedWithSaturation(leftBy:rounding:)`
These implement _saturating arithmetic_.
They are an alternative to the usual `+`, `-`, and `*` operators, which trap if the result cannot be represented in the argument type, and `&+`, `&-`, `&*`, and `<<`, which wrap out-of-range results modulo 2ⁿ for some n.
Instead these methods clamp the result to the representable range of the type:
```
let x: Int8 = 84
let y: Int8 = 100
let a = x + y // traps due to overflow
let b = x &+ y // wraps to -72
let c = x.addingWithSaturation(y) // saturates to 127
```
If you are using saturating arithmetic, you may also want to perform saturating conversions between integer types; this functionality is provided by the standard library via the [`init(clamping:)` API][clamping].
## Types
The `RoundingRule` enum is used with shift, division, and round operations to specify how to round their results to a representable value.
[saturating]: https://en.wikipedia.org/wiki/Saturation_arithmetic
[clamping]: https://developer.apple.com/documentation/swift/binaryinteger/init(clamping:)
-43
View File
@@ -1,43 +0,0 @@
//===--- Rotate.swift -----------------------------------------*- swift -*-===//
//
// This source file is part of the Swift Numerics open source project
//
// Copyright (c) 2021 Apple Inc. and the Swift Numerics project authors
// Licensed under Apache License v2.0 with Runtime Library Exception
//
// See https://swift.org/LICENSE.txt for license information
//
//===----------------------------------------------------------------------===//
extension FixedWidthInteger {
@_transparent @usableFromInline
internal func rotateImplementation(right count: Int) -> Self {
// We don't have an unsigned right shift operation for signed values, so
// we need to convert to an unsigned type. The only unsigned type that's
// guaranteed to be able to represent the bit pattern of any Self value
// is Magnitude. It would be possible to have Magnitude be _wider_ than
// Self, but that's OK as long as we're careful to complement the shift
// count using Self.bitWidth and not Magnitude.bitWidth or zero.
let bitPattern = Magnitude(truncatingIfNeeded: self)
let countComplement = Self.bitWidth &- count
return Self(truncatingIfNeeded:
bitPattern &>> count | bitPattern &<< countComplement
)
}
/// `self` rotated bitwise right by `count` bits.
///
/// Equivalent to `rotated(left: 0 &- count)`.
@inlinable
public func rotated<Count: BinaryInteger>(right count: Count) -> Self {
rotateImplementation(right: Int(truncatingIfNeeded: count))
}
/// `self` rotated bitwise left by `count` bits.
///
/// Equivalent to `rotated(right: 0 &- count)`.
@inlinable
public func rotated<Count: BinaryInteger>(left count: Count) -> Self {
rotateImplementation(right: 0 &- Int(truncatingIfNeeded: count))
}
}
-266
View File
@@ -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 `3`,
/// 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,177 +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)
///
/// // 7/4 = 1.75, so the result is 1 with probability 1/4, or 2
/// // with probability 3/4.
/// 7.shifted(rightBy: 2, rounding: .stochastically)
///
/// // 4/4 is exactly 1, so this does not trap.
/// 4.shifted(rightBy: 2, rounding: .requireExact)
///
/// // 5/2 is 2.5, which is not an integer, so this traps.
/// 5.shifted(rightBy: 1, rounding: .requireExact)
///
/// When `Self(1) << count` is positive, the following are equivalent:
///
/// a.shifted(rightBy: count, rounding: rule)
/// a.divided(by: 1 << count, rounding: rule)
@inlinable
public func shifted(
rightBy count: Int,
rounding rule: RoundingRule = .down
) -> Self {
// Easiest case: count is zero or negative, so shift is always exact;
// delegate to the normal >> operator.
if count <= 0 { return self >> count }
if count >= bitWidth {
// Note: what follows would cause an infinite loop if bitWidth <= 1.
// This will essentially never happen, but in the highly unlikely event
// that we encounter such a case, we promote to Int8, do the shift, and
// then convert back to the appropriate result type.
if bitWidth <= 1 {
return Self(Int8(self).shifted(rightBy: count, rounding: rule))
}
// That pathological case taken care of, we can now handle over-wide
// shifts by first shifting all but bitWidth - 1 bits with sticky
// rounding, and then shifting the remaining bitWidth - 1 bits with
// the desired rounding mode.
let count = count - (bitWidth - 1)
let floor = self >> count
let lost = self - (floor << count)
let sticky = floor | (lost == 0 ? 0 : 1)
return sticky.shifted(rightBy: bitWidth - 1, rounding: rule)
}
// Now we are in the happy case: 0 < count < bitWidth, which makes all
// the math to handle rounding simpler.
//
// TODO: If we were really, really careful about overflow, some of these
// could be made simpler. E.g. mathematically round up is implemented here
// via:
//
// floor = self >> count
// mask = 1 << count - 1
// lost = self & mask
// return floor + (lost == 0 ? 0 : 1)
//
// _if_ we didn't have to worry about intermediate overflow (either because
// self is bounded away from .max or because we don't have a fixed-width
// type), then we could use the following instead:
//
// mask = 1 << count - 1
// return (self + mask) >> count
//
// However, self + mask can overflow, e.g. if we're shifting .max by 1:
//
// mask = 1 << 1 - 1 = 1
// self + mask = .max + 1 // uh-oh
//
// This cannot occur for arbitrary-precision numbers, so we could use
// the simpler expressions for those (but those are precisely the cases
// where performance of rounding does not matter much, because shifts
// get swamped by even basic arithmetic). More interesting, we could
// promote fixed-width numbers to a wider type, preventing this
// intermediate overflow and allowing us to use the simpler expressions
// much of the time. We could also explicitly _detect_ the overflow if
// it happens and patch up the result, though this is a little bit tricky
// because addingReportingOverflow and friends do not exist on
// BinaryInteger. Hence, this is a TODO for the future.
let mask = Magnitude(1) << count - 1
let lost = Magnitude(truncatingIfNeeded: self) & mask
let floor = self >> count
let ceiling = floor + (lost == 0 ? 0 : 1)
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)
///
/// // 7/4 = 1.75, so the result is 1 with probability 1/4, or 2
/// // with probability 3/4.
/// 7.shifted(rightBy: 2, rounding: .stochastically)
///
/// // 4/4 is exactly 1, so this does not trap.
/// 4.shifted(rightBy: 2, rounding: .requireExact)
///
/// // 5/2 is 2.5, which is not an integer, so this traps.
/// 5.shifted(rightBy: 1, rounding: .requireExact)
///
/// When `Self(1) << count` is positive, the following are equivalent:
///
/// a.shifted(rightBy: count, rounding: rule)
/// a.divided(by: 1 << count, rounding: rule)
@_transparent
public func shifted<Count: BinaryInteger>(
rightBy count: Count,
rounding rule: RoundingRule = .down
) -> Self {
self.shifted(rightBy: Int(clamping: count), rounding: rule)
}
}
-1
View File
@@ -20,7 +20,6 @@ target_compile_options(Numerics PUBLIC
-Xfrontend -validate-tbd-against-ir=none)
target_link_libraries(Numerics PUBLIC
ComplexModule
IntegerUtilities
RealModule)
-2
View File
@@ -11,6 +11,4 @@
// A module that re-exports the complete Swift Numerics public API.
@_exported import ComplexModule
@_exported import IntegerUtilities
@_exported import RealModule
@_exported import QuaternionModule
@@ -1,83 +0,0 @@
//===--- ImaginaryHelper.swift --------------------------------*- swift -*-===//
//
// This source file is part of the Swift.org open source project
//
// Copyright (c) 2019-2021 Apple Inc. and the Swift project authors
// Licensed under Apache License v2.0 with Runtime Library Exception
//
// See https://swift.org/LICENSE.txt for license information
// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
//
//===----------------------------------------------------------------------===//
// Provides common vector operations on SIMD3 to ease the use of the quaternions
// imaginary/vector components internally to the module, and in tests.
extension SIMD3 where Scalar: FloatingPoint {
/// Returns a vector with infinity in all lanes
@usableFromInline @inline(__always)
internal static var infinity: Self {
SIMD3(repeating: .infinity)
}
/// Returns a vector with nan in all lanes
@usableFromInline @inline(__always)
internal static var nan: Self {
SIMD3(repeating: .nan)
}
/// True if all values of this instance are finite
@usableFromInline @inline(__always)
internal var isFinite: Bool {
x.isFinite && y.isFinite && z.isFinite
}
/// The ∞-norm of the value (`max(abs(x), abs(y), abs(z))`).
@usableFromInline @inline(__always)
internal var magnitude: Scalar {
Swift.max(x.magnitude, y.magnitude, z.magnitude)
}
/// The 1-norm of the value (`abs(x) + abs(y) + abs(z))`).
@usableFromInline @inline(__always)
internal var oneNorm: Scalar {
x.magnitude + y.magnitude + z.magnitude
}
/// The Euclidean norm (a.k.a. 2-norm, `sqrt(x*x + y*y + z*z)`).
@usableFromInline @inline(__always)
internal var length: Scalar {
let naive = lengthSquared
guard naive.isNormal else { return carefulLength }
return naive.squareRoot()
}
// Implementation detail of `length`, moving slow path off of the
// inline function.
@usableFromInline
internal var carefulLength: Scalar {
guard isFinite else { return .infinity }
guard !magnitude.isZero else { return .zero }
// Unscale the vector, calculate its length and rescale the result
return (self / magnitude).length * magnitude
}
/// Returns the squared length of this instance.
@usableFromInline @inline(__always)
internal var lengthSquared: Scalar {
dot(self)
}
/// Returns the scalar/dot product of this vector with `other`.
@usableFromInline @inline(__always)
internal func dot(_ other: SIMD3<Scalar>) -> Scalar {
(self * other).sum()
}
/// Returns the vector/cross product of this vector with `other`.
@usableFromInline @inline(__always)
internal func cross(_ other: SIMD3<Scalar>) -> SIMD3<Scalar> {
let yzx = SIMD3<Int>(1,2,0)
let zxy = SIMD3<Int>(2,0,1)
return (self[yzx] * other[zxy]) - (self[zxy] * other[yzx])
}
}
-201
View File
@@ -1,201 +0,0 @@
//===--- Polar.swift ------------------------------------------*- swift -*-===//
//
// This source file is part of the Swift Numerics open source project
//
// Copyright (c) 2019 - 2022 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
// Norms and related quantities defined for Quaternion.
//
// The following API are provided by this extension:
//
// var magnitude: RealType // infinity norm
// var length: RealType // Euclidean norm
// var lengthSquared: RealType // Euclidean norm squared
//
// For detailed documentation, consult Norms.md or the inline documentation
// for each operation.
//
// Implementation notes:
//
// `.magnitude` does not bind the Euclidean norm; it binds the infinity norm
// instead. There are two reasons for this choice:
//
// - It's simply faster to compute in general, because it does not require
// a square root.
//
// - There exist finite values `q` for which the Euclidean norm is not
// representable (consider the quaternion with `r`, `x`, `y` and `z` all
// equal to `RealType.greatestFiniteMagnitude`; the Euclidean norm is
// `.sqrt(4) * .greatestFiniteMagnitude`, which overflows).
//
// The infinity norm is unique among the common vector norms in having
// the property that every finite vector has a representable finite norm,
// which makes it the obvious choice to bind `.magnitude`.
extension Quaternion {
/// The Euclidean norm (a.k.a. 2-norm, `sqrt(r*r + x*x + y*y + z*z)`).
///
/// This value is highly prone to overflow or underflow.
///
/// 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 quaternion is not finite, its `.length` is `infinity`.
///
/// See also `.magnitude`, `.lengthSquared`, `.polar` and
/// `init(length:halfAngle:axis:)`.
@_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.
@usableFromInline
internal var carefulLength: RealType {
guard isFinite else { return .infinity }
guard !magnitude.isZero else { return .zero }
// Unscale the quaternion, calculate its length and rescale the result
return divided(by: magnitude).length * magnitude
}
/// The squared length `(r*r + x*x + y*y + z*z)`.
///
/// This value is highly prone to overflow or underflow.
///
/// For many cases, `.magnitude` can be used instead, which is similarly
/// cheap to compute and always returns a representable value.
///
/// This property is more efficient to compute than `length`.
///
/// See also `.magnitude`, `.length`, `.polar` and
/// `init(length:halfAngle:axis:)`.
@_transparent
public var lengthSquared: RealType {
(components * components).sum()
}
/// The half rotation angle in radians within *[0, π]* range.
///
/// Edge cases:
/// - If the quaternion is zero or non-finite, halfAngle is `nan`.
@inlinable
public var halfAngle: RealType {
guard isFinite else { return .nan }
// A zero quaternion does not encode transformation properties.
// If imaginary is zero, real must be non-zero or nan is returned.
guard !isReal else { return isPure ? .nan : .zero }
// If lengthSquared computes without over/underflow, everything is fine
// and the result is correct. If not, we have to do the computation
// carefully and unscale the quaternion first.
let lenSq = imaginary.lengthSquared
guard lenSq.isNormal else { return divided(by: magnitude).halfAngle }
return .atan2(y: .sqrt(lenSq), x: real)
}
/// The [polar decomposition][wiki].
///
/// Returns the length of this quaternion, halfAngle in radians of range
/// *[0, π]* and the rotation axis as SIMD3 vector of unit length.
///
/// Edge cases:
/// - If the quaternion is zero, length is `.zero` and halfAngle and axis
/// are `nan`.
/// - If the quaternion is non-finite, length is `.infinity` and halfAngle and
/// axis are `nan`.
/// - For any length other than `.zero` or `.infinity`, if halfAngle is zero,
/// axis is `nan`.
///
/// See also `.magnitude`, `.length`, `.lengthSquared` and
/// `init(length:halfAngle:axis:)`.
///
/// [wiki]: https://en.wikipedia.org/wiki/Polar_decomposition#Quaternion_polar_decomposition
public var polar: (
length: RealType,
halfAngle: RealType,
axis: SIMD3<RealType>
) {
(length, halfAngle, axis)
}
/// Creates a new quaternion from given half rotation angle about given
/// rotation axis.
///
/// The angle-axis values are transformed using the following equation:
///
/// Q = (cos(halfAngle), unitAxis * sin(halfAngle))
///
/// - Parameters:
/// - halfAngle: The half rotation angle
/// - unitAxis: The rotation axis of unit length
@usableFromInline @inline(__always)
internal init(halfAngle: RealType, unitAxis: SIMD3<RealType>) {
self.init(real: .cos(halfAngle), imaginary: unitAxis * .sin(halfAngle))
}
/// Creates a quaternion specified with [polar coordinates][wiki].
///
/// This initializer reads given `length`, `halfAngle` and `axis` values and
/// creates a quaternion of equal rotation properties and specified *length*
/// using the following equation:
///
/// Q = (cos(halfAngle), axis * sin(halfAngle)) * length
///
/// Edge cases:
/// - Negative lengths are interpreted as reflecting the point through the
/// origin, i.e.:
/// ```
/// Quaternion(length: -r, halfAngle: θ, axis: axis) == -Quaternion(length: r, halfAngle: θ, axis: axis)
/// ```
/// - For any `θ` and any `axis`, even `.infinity` or `.nan`:
/// ```
/// Quaternion(length: .zero, halfAngle: θ, axis: axis) == .zero
/// ```
/// - For any `θ` and any `axis`, even `.infinity` or `.nan`:
/// ```
/// Quaternion(length: .infinity, halfAngle: θ, axis: axis) == .infinity
/// ```
/// - Otherwise, `θ` must be finite, or a precondition failure occurs and
/// `axis` must be of unit length, or an assertion failure occurs.
///
/// See also `.magnitude`, `.length`, `.lengthSquared` and `.polar`.
///
/// [wiki]: https://en.wikipedia.org/wiki/Polar_decomposition#Quaternion_polar_decomposition
@inlinable
public init(length: RealType, halfAngle: RealType, axis: SIMD3<RealType>) {
guard !length.isZero, length.isFinite else {
self = Quaternion(length)
return
}
// Length is finite and non-zero, therefore
// 1. `halfAngle` must be finite or a precondition failure needs to occur;
// as this is not representable.
// 2. `axis` must be of unit length or an assertion failure occurs; while
// "wrong" by definition, it is representable.
precondition(
halfAngle.isFinite,
"Either halfAngle must be finite, or length must be zero or infinite."
)
assert(
// TODO: Replace with `approximateEquality()`
abs(.sqrt(axis.lengthSquared)-1) < max(.sqrt(axis.lengthSquared), 1)*RealType.ulpOfOne.squareRoot(),
"Given axis must be of unit length."
)
self = Quaternion(
halfAngle: halfAngle,
unitAxis: axis
).multiplied(by: length)
}
}
@@ -1,41 +0,0 @@
//===--- Quaternion+AdditiveArithmetic.swift ------------------*- swift -*-===//
//
// This source file is part of the Swift Numerics open source project
//
// Copyright (c) 2019 - 2022 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 Quaternion: AdditiveArithmetic {
/// The additive identity, with real and *all* imaginary parts zero, i.e.:
/// `0 + 0i + 0j + 0k`
///
/// See also: `one`, `i`, `j`, `k`, `infinity`
@_transparent
public static var zero: Quaternion {
Quaternion(from: SIMD4(repeating: 0))
}
@_transparent
public static func + (lhs: Quaternion, rhs: Quaternion) -> Quaternion {
Quaternion(from: lhs.components + rhs.components)
}
@_transparent
public static func - (lhs: Quaternion, rhs: Quaternion) -> Quaternion {
Quaternion(from: lhs.components - rhs.components)
}
@_transparent
public static func += (lhs: inout Quaternion, rhs: Quaternion) {
lhs = lhs + rhs
}
@_transparent
public static func -= (lhs: inout Quaternion, rhs: Quaternion) {
lhs = lhs - rhs
}
}
@@ -1,25 +0,0 @@
//===--- Quaternion+Codable.swift -----------------------------*- swift -*-===//
//
// This source file is part of the Swift Numerics open source project
//
// Copyright (c) 2019 - 2022 Apple Inc. and the Swift Numerics project authors
// Licensed under Apache License v2.0 with Runtime Library Exception
//
// See https://swift.org/LICENSE.txt for license information
//
//===----------------------------------------------------------------------===//
import RealModule
// FloatingPoint does not refine Codable, so this is a conditional conformance.
extension Quaternion: Decodable where RealType: Decodable {
public init(from decoder: Decoder) throws {
try self.init(from: SIMD4(from: decoder))
}
}
extension Quaternion: Encodable where RealType: Encodable {
public func encode(to encoder: Encoder) throws {
try components.encode(to: encoder)
}
}
@@ -1,221 +0,0 @@
//===--- Quaternion+ElementaryFunctions.swift -----------------*- swift -*-===//
//
// This source file is part of the Swift.org open source project
//
// Copyright (c) 2019 - 2022 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
//
//===----------------------------------------------------------------------===//
// (r + xi + yj + zk) is a common representation that is often seen for
// quaternions. However, when we want to expand the elementary functions of
// quaternions in terms of real operations it is almost always easier to view
// them as real part (r) and imaginary vector part (v),
// i.e: r + xi + yj + zk = r + v; and so we diverge a little from the
// representation that is used in the documentation in other files and use this
// notation of quaternions in the comments of the following functions.
//
// Quaternionic elementary functions have many similarities with elementary
// functions of complex numbers and their definition in terms of real
// operations. Therefore, if you make a modification to one of the following
// functions, you should almost surely make a parallel modification to the same
// elementary function of complex numbers.
import RealModule
extension Quaternion/*: ElementaryFunctions */ {
// MARK: - exp-like functions
@inlinable
public static func exp(_ q: Quaternion) -> Quaternion {
// Mathematically, this operation can be expanded in terms of the `Real`
// operations `exp`, `cos` and `sin` as follows (`let θ = ||v||`):
//
// ```
// exp(r + v) = exp(r) exp(v)
// = exp(r) (cos(θ) + (v/θ) sin(θ))
// ```
//
// Note that naive evaluation of this expression in floating-point would be
// prone to premature overflow, since `cos` and `sin` both have magnitude
// less than 1 for most inputs (i.e. `exp(r)` may be infinity when
// `exp(r) cos(||v||)` would not be.
guard q.isFinite else { return q }
let (â, θ) = q.imaginary.unitAxisAndLength
let rotation = Quaternion(halfAngle: θ, unitAxis: â)
// If real < log(greatestFiniteMagnitude), then exp(real) does not overflow.
// To protect ourselves against sketchy log or exp implementations in
// an unknown host library, or slight rounding disagreements between
// the two, subtract one from the bound for a little safety margin.
guard q.real < RealType.log(.greatestFiniteMagnitude) - 1 else {
let halfScale = RealType.exp(q.real/2)
return rotation.multiplied(by: halfScale).multiplied(by: halfScale)
}
return rotation.multiplied(by: .exp(q.real))
}
@inlinable
public static func expMinusOne(_ q: Quaternion) -> Quaternion {
// Mathematically, this operation can be expanded in terms of the `Real`
// operations `exp`, `cos` and `sin` as follows (`let θ = ||v||`):
//
// ```
// exp(r + v) - 1 = exp(r) exp(v) - 1
// = exp(r) (cos(θ) + (v/θ) sin(θ)) - 1
// = exp(r) cos(θ) + exp(r) (v/θ) sin(θ) - 1
// = (exp(r) cos(θ) - 1) + exp(r) (v/θ) sin(θ)
// -------- u --------
// ```
//
// Note that the imaginary part is just the usual exp(x) sin(y);
// the only trick is computing the real part ("u"):
//
// ```
// u = exp(r) cos(θ) - 1
// = exp(r) cos(θ) - cos(θ) + cos(θ) - 1
// = (exp(r) - 1) cos(θ) + (cos(θ) - 1)
// = expMinusOne(r) cos(θ) + cosMinusOne(θ)
// ```
//
// See `expMinusOne` on complex numbers for error bounds.
guard q.isFinite else { return q }
let (â, θ) = q.imaginary.unitAxisAndLength
// If exp(q) is close to the overflow boundary, we don't need to
// worry about the "MinusOne" part of this function; we're just
// computing exp(q). (Even when θ is near a multiple of π/2,
// it can't be close enough to overcome the scaling from exp(r),
// so the -1 term is _always_ negligable).
guard q.real < RealType.log(.greatestFiniteMagnitude) - 1 else {
let halfScale = RealType.exp(q.real/2)
let rotation = Quaternion(halfAngle: θ, unitAxis: â)
return rotation.multiplied(by: halfScale).multiplied(by: halfScale)
}
return Quaternion(
real: RealType._mulAdd(.cos(θ), .expMinusOne(q.real), .cosMinusOne(θ)),
imaginary: â * .exp(q.real) * .sin(θ)
)
}
@inlinable
public static func cosh(_ q: Quaternion) -> Quaternion {
// Mathematically, this operation can be expanded in terms of
// trigonometric `Real` operations as follows (`let θ = ||v||`):
//
// ```
// cosh(q) = (exp(q) + exp(-q)) / 2
// = cosh(r) cos(θ) + (v/θ) sinh(r) sin(θ)
// ```
//
// Like exp, cosh is entire, so we do not need to worry about where
// branch cuts fall. Also like exp, cancellation never occurs in the
// evaluation of the naive expression, so all we need to be careful
// about is the behavior near the overflow boundary.
//
// Fortunately, if |r| >= -log(ulpOfOne), cosh(r) and sinh(r) are
// both just exp(|r|)/2, and we already know how to compute that.
//
// This function and sinh should stay in sync; if you make a
// modification here, you should almost surely make a parallel
// modification to sinh below.
guard q.isFinite else { return q }
let (â, θ) = q.imaginary.unitAxisAndLength
guard q.real.magnitude < -RealType.log(.ulpOfOne) else {
let rotation = Quaternion(halfAngle: θ, unitAxis: â)
let firstScale = RealType.exp(q.real.magnitude/2)
return rotation.multiplied(by: firstScale).multiplied(by: firstScale/2)
}
return Quaternion(
real: .cosh(q.real) * .cos(θ),
imaginary: â * .sinh(q.real) * .sin(θ)
)
}
@inlinable
public static func sinh(_ q: Quaternion) -> Quaternion {
// Mathematically, this operation can be expanded in terms of
// trigonometric `Real` operations as follows (`let θ = ||v||`):
//
// ```
// sinh(q) = (exp(q) - exp(-q)) / 2
// = sinh(r) cos(θ) + (v/θ) cosh(r) sin(θ)
// ```
guard q.isFinite else { return q }
let (â, θ) = q.imaginary.unitAxisAndLength
guard q.real.magnitude < -RealType.log(.ulpOfOne) else {
let rotation = Quaternion(halfAngle: θ, unitAxis: â)
let firstScale = RealType.exp(q.real.magnitude/2)
let secondScale = RealType(signOf: q.real, magnitudeOf: firstScale/2)
return rotation.multiplied(by: firstScale).multiplied(by: secondScale)
}
return Quaternion(
real: .sinh(q.real) * .cos(θ),
imaginary: â * .cosh(q.real) * .sin(θ)
)
}
@inlinable
public static func tanh(_ q: Quaternion) -> Quaternion {
// Mathematically, this operation can be expanded in terms of
// trigonometric `Real` operations as follows (`let θ = ||v||`):
//
// ```
// tanh(q) = sinh(q) / cosh(q)
// ```
guard q.isFinite else { return q }
// Note that when |r| is larger than -log(.ulpOfOne),
// sinh(r + v) == ±cosh(r + v), so tanh(r + v) is just ±1.
guard q.real.magnitude < -RealType.log(.ulpOfOne) else {
return Quaternion(
real: RealType(signOf: q.real, magnitudeOf: 1),
imaginary:
RealType(signOf: q.components.x, magnitudeOf: 0),
RealType(signOf: q.components.y, magnitudeOf: 0),
RealType(signOf: q.components.z, magnitudeOf: 0)
)
}
return sinh(q) / cosh(q)
}
@inlinable
public static func cos(_ q: Quaternion) -> Quaternion {
// cos(q) = cosh(q * (v/θ)))
let (â,_) = q.imaginary.unitAxisAndLength
let p = Quaternion(imaginary: â)
return cosh(q * p)
}
@inlinable
public static func sin(_ q: Quaternion) -> Quaternion {
// sin(q) = -(v/θ) * sinh(q * (v/θ)))
let (â,_) = q.imaginary.unitAxisAndLength
let p = Quaternion(imaginary: â)
return -p * sinh(q * p)
}
@inlinable
public static func tan(_ q: Quaternion) -> Quaternion {
// tan(q) = -(v/θ) * tanh(q * (v/θ)))
let (â,_) = q.imaginary.unitAxisAndLength
let p = Quaternion(imaginary: â)
return -p * tanh(q * p)
}
}
extension SIMD3 where Scalar: FloatingPoint {
/// Returns the normalized axis and the length of this vector.
@usableFromInline @inline(__always)
internal var unitAxisAndLength: (Self, Scalar) {
if self == .zero {
return (SIMD3(
Scalar(signOf: x, magnitudeOf: 0),
Scalar(signOf: y, magnitudeOf: 0),
Scalar(signOf: z, magnitudeOf: 0)
), .zero)
}
return (self/length, length)
}
}
@@ -1,72 +0,0 @@
//===--- Quaternion+Hashable.swift ----------------------------*- swift -*-===//
//
// This source file is part of the Swift Numerics open source project
//
// Copyright (c) 2019 - 2022 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 Quaternion: Hashable {
/// Returns a Boolean value indicating whether two values are equal.
///
/// - Important:
/// Quaternions are frequently used to represent 3D transformations. It's
/// important to be aware that, when used this way, any quaternion and its
/// negation represent the same transformation, but they do not compare
/// equal using `==` because they are not the same quaternion. You can
/// compare quaternions as 3D transformations using `equals(as3DTransform:)`.
@_transparent
public static func == (lhs: Quaternion, rhs: Quaternion) -> Bool {
// Identify all numbers with either component non-finite as a single "point at infinity".
guard lhs.isFinite || rhs.isFinite else { return true }
// For finite numbers, equality is defined componentwise. Cases where
// only one of lhs or rhs 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 lhs.components == rhs.components
}
/// Returns a Boolean value indicating whether the 3D transformation of the
/// two quaternions are equal.
///
/// Use this method to test for equality of the 3D transformation properties
/// of quaternions; where for any quaternion `q`, its negation represent the
/// same 3D transformation; i.e. `q.equals(as3DTransform: q)` as well as
/// `q.equals(as3DTransform: -q)` are both `true`.
///
/// - Parameter other: The value to compare.
/// - Returns: True if the 3D transformation of this quaternion equals `other`.
@_transparent
public func equals(as3DTransform other: Quaternion) -> Bool {
// Identify all numbers with either component non-finite as a single "point at infinity".
guard isFinite || other.isFinite else { return true }
// For finite numbers, equality is defined componentwise. Cases where only
// one of lhs or rhs 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 components == other.components || components == -other.components
}
@_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.
// For any normal values we use the "canonical transform" representation,
// where real is always non-negative. This allows people who are using
// quaternions as rotations to get the expected semantics out of collections
// (while unfortunately producing some collisions for people who are not,
// but not in too catastrophic of a fashion).
if isFinite {
canonicalizedTransform.components.hash(into: &hasher)
} else {
hasher.combine(RealType.infinity)
}
}
}
@@ -1,19 +0,0 @@
//===--- Quaternion+IntegerLiteral.swift ----------------------*- swift -*-===//
//
// This source file is part of the Swift Numerics open source project
//
// Copyright (c) 2019 - 2022 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 Quaternion: ExpressibleByIntegerLiteral {
public typealias IntegerLiteralType = RealType.IntegerLiteralType
@inlinable
public init(integerLiteral value: IntegerLiteralType) {
self.init(RealType(integerLiteral: value))
}
}
@@ -1,66 +0,0 @@
//===--- Quaternion+Numeric.swift -----------------------------*- swift -*-===//
//
// This source file is part of the Swift Numerics open source project
//
// Copyright (c) 2019 - 2022 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 Quaternion: Numeric {
@_transparent
public static func * (lhs: Quaternion, rhs: Quaternion) -> Quaternion {
let rhsX = SIMD4(+rhs.components.w, +rhs.components.z, -rhs.components.y, +rhs.components.x)
let rhsY = SIMD4(-rhs.components.z, +rhs.components.w, +rhs.components.x, +rhs.components.y)
let rhsZ = SIMD4(+rhs.components.y, -rhs.components.x, +rhs.components.w, +rhs.components.z)
let rhsR = SIMD4(-rhs.components.x, -rhs.components.y, -rhs.components.z, +rhs.components.w)
let x = (lhs.components * rhsX).sum()
let y = (lhs.components * rhsY).sum()
let z = (lhs.components * rhsZ).sum()
let r = (lhs.components * rhsR).sum()
return Quaternion(from: SIMD4(x,y,z,r))
}
@_transparent
public static func *= (lhs: inout Quaternion, rhs: Quaternion) {
lhs = lhs * rhs
}
/// The quaternion with specified real part and zero imaginary part.
///
/// Equivalent to `Quaternion(RealType(real))`.
@inlinable
public init<Other: BinaryInteger>(_ real: Other) {
self.init(RealType(real))
}
/// The quaternion 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)
}
/// The ∞-norm of the value (`max(abs(r), abs(x), abs(y), abs(z))`).
///
/// If you need the Euclidean norm (a.k.a. 2-norm) use the `length` or `lengthSquared`
/// properties instead.
///
/// Edge cases:
/// - If `q` is not finite, `q.magnitude` is `.infinity`.
/// - If `q` is zero, `q.magnitude` is `0`.
/// - Otherwise, `q.magnitude` is finite and non-zero.
///
/// See also `.length` and `.lengthSquared`
@_transparent
public var magnitude: RealType {
guard isFinite else { return .infinity }
return max(abs(components.max()), abs(components.min()))
}
}
@@ -1,118 +0,0 @@
//===--- Quaternion+SignedNumeric.swift -----------------------*- swift -*-===//
//
// This source file is part of the Swift Numerics open source project
//
// Copyright (c) 2019 - 2022 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 Quaternion: SignedNumeric {
/// The multiplicative identity, with real part one and *all* imaginary parts
/// zero, i.e.: `1 + 0i + 0j + 0k`
///
/// See also: `zero`, `i`, `j`, `k`, `infinity`
@_transparent
public static var one: Quaternion {
Quaternion(from: SIMD4(0,0,0,1))
}
/// The [conjugate][conj] of this value.
///
/// [conj]: https://en.wikipedia.org/wiki/Quaternion#Conjugation,_the_norm,_and_reciprocal
@_transparent
public var conjugate: Quaternion {
Quaternion(from: components * [-1, -1, -1, 1])
}
@_transparent
public static func / (lhs: Quaternion, rhs: Quaternion) -> Quaternion {
// Try the naive expression lhs/rhs = lhs*conj(rhs) / |rhs|^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 lengthSquared = rhs.lengthSquared
guard lengthSquared.isNormal else { return rescaledDivide(lhs, rhs) }
return lhs * (rhs.conjugate.divided(by: lengthSquared))
}
@_transparent
public static func /= (lhs: inout Quaternion, rhs: Quaternion) {
lhs = lhs / rhs
}
@usableFromInline @_alwaysEmitIntoClient @inline(never)
internal static func rescaledDivide(_ lhs: Quaternion, _ rhs: Quaternion) -> Quaternion {
if rhs.isZero { return .infinity }
if lhs.isZero || !rhs.isFinite { return .zero }
// TODO: detect when RealType is Float and just promote to Double, then
// use the naive algorithm.
let lhsScale = lhs.magnitude
let rhsScale = rhs.magnitude
let lhsNorm = lhs.divided(by: lhsScale)
let rhsNorm = rhs.divided(by: rhsScale)
let r = (lhsNorm * rhsNorm.conjugate).divided(by: rhsNorm.lengthSquared)
// At this point, the result is (r * lhsScale)/rhsScale 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 * (lhsScale / rhsScale)
// - (r * lhsScale) / rhsScale
// - (r / rhsScale) * lhsScale
//
// The simplest case is when lhsScale / rhsScale is normal:
if (lhsScale / rhsScale).isNormal {
return r.multiplied(by: lhsScale / rhsScale)
}
// Otherwise, we need to compute either rNorm * lhsScale or rNorm / rhsScale
// first. Choose the first if the first scaling behaves well, otherwise
// choose the other one.
if (r.magnitude * lhsScale).isNormal {
return r.multiplied(by: lhsScale).divided(by: rhsScale)
}
return r.divided(by: rhsScale).multiplied(by: lhsScale)
}
/// A normalized quaternion with the same direction and phase as this value.
///
/// If such a value cannot be produced, `nil` is returned.
@inlinable
public var normalized: Quaternion? {
if length.isNormal {
return divided(by: length)
}
if isZero || !isFinite {
return nil
}
return 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.
///
/// Typical use looks like this:
/// ```
/// func divide<T: Real>(data: [Quaternion<T>], by divisor: Quaternion<T>) -> [Quaternion<T>] {
/// // If divisor is well-scaled, use multiply by reciprocal.
/// if let recip = divisor.reciprocal {
/// return data.map { $0 * recip }
/// }
/// // Fallback on using division.
/// return data.map { $0 / divisor }
/// }
/// ```
@inlinable
public var reciprocal: Quaternion? {
let recip = Quaternion(1)/self
if recip.isNormal || isZero || !isFinite {
return recip
}
return nil
}
}
@@ -1,28 +0,0 @@
//===--- Quaternion+StringConvertible.swift -------------------*- swift -*-===//
//
// This source file is part of the Swift Numerics open source project
//
// Copyright (c) 2019 - 2022 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 Quaternion: CustomStringConvertible {
public var description: String {
guard isFinite else { return "inf" }
return "(\(components.w), \(components.x), \(components.y), \(components.z))"
}
}
extension Quaternion: CustomDebugStringConvertible {
public var debugDescription: String {
let x = String(reflecting: components.x)
let y = String(reflecting: components.y)
let z = String(reflecting: components.z)
let r = String(reflecting: components.w)
return "Quaternion<\(RealType.self)>(\(r), \(x), \(y), \(z))"
}
}
-302
View File
@@ -1,302 +0,0 @@
//===--- Quaternion.swift -------------------------------------*- swift -*-===//
//
// This source file is part of the Swift Numerics open source project
//
// Copyright (c) 2019 - 2022 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
/// A quaternion represented by a real (or scalar) part and three imaginary (or vector) parts.
///
/// TODO: introductory text on quaternions
///
/// Implementation notes:
/// -
/// This type does not provide heterogeneous real/quaternion arithmetic,
/// not even the natural vector-space operations like real * quaternion.
/// 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).
///
/// `.magnitude` does not return the Euclidean norm; it uses the "infinity
/// norm" (`max(|r|,|x|,|y|,|z|)`) 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.
/// Using the infinity norm avoids this problem entirely without significant
/// downsides. You can access the Euclidean norm using the `length` property.
/// See `Complex` type of the swift-numerics package for additional details.
///
/// Quaternions are frequently used to represent 3D transformations. It's
/// important to be aware that, when used this way, any quaternion and its
/// negation represent the same transformation, but they do not compare equal
/// using `==` because they are not the same quaternion.
/// You can compare quaternions as 3D transformations using `equals(as3DTransform:)`.
public struct Quaternion<RealType> where RealType: Real & SIMDScalar {
/// The components of the 4-dimensional vector space of the quaternion.
///
/// Components are stored within a 4-dimensional SIMD vector with the
/// scalar part last, i.e. in the form of:
///
/// xi + yj + zk + r // SIMD(x,y,z,r)
@usableFromInline @inline(__always)
internal var components: SIMD4<RealType>
/// A quaternion constructed from given 4-dimensional SIMD vector.
///
/// Creates a new quaternion by reading the values of the SIMD vector
/// as components of a quaternion with the scalar part last, i.e. in the form of:
///
/// xi + yj + zk + r // SIMD(x,y,z,r)
@usableFromInline @inline(__always)
internal init(from components: SIMD4<RealType>) {
self.components = components
}
}
// MARK: - Basic Property
extension Quaternion {
/// The real part of this quaternion.
///
/// If `q` is not finite, `q.real` is `.nan`.
public var real: RealType {
@_transparent
get { isFinite ? components[3] : .nan }
@_transparent
set { components[3] = newValue }
}
/// The imaginary part of this quaternion.
///
/// If `q` is not finite, `q.imaginary` is `.nan` in all lanes.
public var imaginary: SIMD3<RealType> {
@_transparent
get { isFinite ? components[SIMD3(0,1,2)] : SIMD3(repeating: .nan) }
@_transparent
set {
components = SIMD4(newValue, components[3])
}
}
/// The quaternion with the imaginary unit **i** one, i.e. `0 + i + 0j + 0k`.
///
/// See also `.zero`, `.one`, `.j`, `.k` and `.infinity`.
@_transparent
public static var i: Quaternion {
Quaternion(imaginary: SIMD3(1,0,0))
}
/// The quaternion with the imaginary unit **j** one, i.e. `0 + 0i + j + 0k`.
///
/// See also `.zero`, `.one`, `.i`, `.k` and `.infinity`.
@_transparent
public static var j: Quaternion {
Quaternion(imaginary: SIMD3(0,1,0))
}
/// The quaternion with the imaginary unit **k** one, i.e. `0 + 0i + 0j + k`.
///
/// See also `.zero`, `.one`, `.i`, `.j` and `.infinity`.
@_transparent
public static var k: Quaternion {
Quaternion(imaginary: SIMD3(0,0,1))
}
/// The point at infinity.
///
/// See also `.zero`, `.one`, `.i`, `.j` and `.k`.
@_transparent
public static var infinity: Quaternion {
Quaternion(.infinity)
}
/// True if this value is finite.
///
/// A quaternion is finite if neither component is an infinity or nan.
///
/// See also `.isNormal`, `.isSubnormal`, `.isZero`, `.isReal`, `.isPure`.
@_transparent
public var isFinite: Bool {
return components.x.isFinite
&& components.y.isFinite
&& components.z.isFinite
&& components.w.isFinite
}
/// True if this value is normal.
///
/// A quaternion is normal if it is finite and *any* of its real or imaginary components
/// are normal. A floating-point number representing one of the components is normal
/// if its exponent allows a full-precision representation.
///
/// See also `.isFinite`, `.isSubnormal`, `.isZero`, `.isReal`, `.isPure`.
@_transparent
public var isNormal: Bool {
return isFinite && (
components.x.isNormal ||
components.y.isNormal ||
components.z.isNormal ||
components.w.isNormal
)
}
/// True if this value is subnormal.
///
/// A quaternion is subnormal if it is finite, not normal, and not zero. When the result of a
/// computation is subnormal, underflow has occurred and the result generally does not have full
/// precision.
///
/// See also `.isFinite`, `.isNormal`, `.isZero`, `.isReal`, `.isPure`.
@_transparent
public var isSubnormal: Bool {
isFinite && !isNormal && !isZero
}
/// True if this value is zero.
///
/// A quaternion is zero if the real and *all* imaginary components are zero.
///
/// See also `.isFinite`, `.isNormal`, `.isSubnormal`, `.isReal`, `.isPure`.
@_transparent
public var isZero: Bool {
components == .zero
}
/// True if this quaternion is real.
///
/// A quaternion is real if *all* imaginary components are zero.
///
/// See also `.isFinite`, `.isNormal`, `.isSubnormal`, `.isZero`, `.isPure`.
@_transparent
public var isReal: Bool {
imaginary == .zero
}
/// True if this quaternion is pure.
///
/// A quaternion is pure if the real component is zero.
///
/// See also `.isFinite`, `.isNormal`, `.isSubnormal`, `.isZero`, `.isReal`.
@_transparent
public var isPure: Bool {
real.isZero
}
/// A "canonical" representation of the value.
///
/// For normal quaternion instances with a RealType conforming to
/// BinaryFloatingPoint (the common case), the result is simply this value
/// unmodified. For zeros, the result has the representation (+0, +0, +0, +0).
/// For infinite values, the result has the representation (+inf, +0, +0, +0).
///
/// If the RealType admits non-canonical representations, the x, y, z and r
/// components are canonicalized in the result.
///
/// This is mainly useful for interoperation with other languages, where
/// you may want to reduce each equivalence class to a single representative
/// before passing across language boundaries, but it may also be useful
/// for some serialization tasks. It's also a useful implementation detail for
/// some primitive operations.
///
/// See also `.canonicalizedTransform`.
@_transparent
public var canonicalized: Self {
guard !isZero else { return .zero }
guard isFinite else { return .infinity }
return self.multiplied(by: 1)
}
/// A "canonical transformation" representation of the value.
///
/// For normal quaternion instances with a RealType conforming to
/// BinaryFloatingPoint (the common case) and a non-negative real component,
/// the result is simply this value unmodified. For instances with a negative
/// real component, the result is this quaternion negated -(r, x, y, z); so
/// the real component is always positive.
/// For zeros, the result has the representation (+0, +0, +0, +0). For
/// infinite values, the result has the representation (+inf, +0, +0, +0).
///
/// If the RealType admits non-canonical representations, the x, y, z and r
/// components are canonicalized in the result.
///
/// See also `.canonicalized`.
@_transparent
public var canonicalizedTransform: Self {
let canonical = canonicalized
if canonical.real.sign == .plus { return canonical }
return -canonical
}
}
// MARK: - Additional Initializers
extension Quaternion {
/// The quaternion with specified real part and zero imaginary part.
///
/// Equivalent to `Quaternion(real: real, imaginary: SIMD3(repeating: 0))`.
@inlinable
public init(_ real: RealType) {
self.init(real: real, imaginary: SIMD3(repeating: 0))
}
/// The quaternion with specified imaginary part and zero real part.
///
/// Equivalent to `Quaternion(real: 0, imaginary: imaginary)`.
@inlinable
public init(imaginary: SIMD3<RealType>) {
self.init(real: 0, imaginary: imaginary)
}
/// The quaternion with specified imaginary part and zero real part.
///
/// Equivalent to `Quaternion(real: 0, imaginary: imaginary)`.
@inlinable
public init(imaginary x: RealType, _ y: RealType, _ z: RealType) {
self.init(imaginary: SIMD3(x, y, z))
}
/// The quaternion with specified real part and imaginary parts.
@inlinable
public init(real: RealType, imaginary: SIMD3<RealType>) {
self.init(from: SIMD4(imaginary, real))
}
/// The quaternion with specified real part and imaginary parts.
@inlinable
public init(real: RealType, imaginary x: RealType, _ y: RealType, _ z: RealType) {
self.init(real: real, imaginary: SIMD3(x, y, z))
}
}
extension Quaternion where RealType: BinaryFloatingPoint {
/// `other` rounded to the nearest representable value of this type.
@inlinable
public init<Other: BinaryFloatingPoint>(_ other: Quaternion<Other>) {
self.init(from: SIMD4(
RealType(other.components.x),
RealType(other.components.y),
RealType(other.components.z),
RealType(other.components.w)
))
}
/// `other`, if it can be represented exactly in this type; otherwise `nil`.
@inlinable
public init?<Other: BinaryFloatingPoint>(exactly other: Quaternion<Other>) {
guard
let x = RealType(exactly: other.components.x),
let y = RealType(exactly: other.components.y),
let z = RealType(exactly: other.components.z),
let r = RealType(exactly: other.components.w)
else { return nil }
self.init(from: SIMD4(x, y, z, r))
}
}
-30
View File
@@ -1,30 +0,0 @@
# Quaternion
This module provides a `Quaternion` type generic over an underlying `RealType`:
```swift
1> import QuaternionModule
2> let q = Quaternion(real: 1, imaginary: 1, 1, 1) // q = 1 + i + j + k
```
The usual arithmetic operators are provided for Quaternions, 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`.
### The magnitude property
The `Numeric` protocol requires a `.magnitude` property, but (deliberately) does not fully specify the semantics.
The most obvious choice for `Quaternion` would be to use the Euclidean norm (aka the "2-norm", given by `sqrt(real*real + i*i + k*k + j*j)`).
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 `q = Quaternion(big, (big, big, big))`, where `big` is `Double.greatestFiniteMagnitude`. The 1-norm and 2-norm of `q` both overflow (the 1-norm would be `4*big`, and the 2-norm would be `sqrt(4)*big`, neither of which are representable as `Double`), but the ∞-norm is always equal to either `real`, `i`, `j` or `k`, 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.
The 2-norm still needs to be available, of course, because sometimes you need it.
This functionality is accessed via the `.length` and `.lengthSquared` properties.
-39
View File
@@ -1,39 +0,0 @@
//===--- Scale.swift ------------------------------------------*- swift -*-===//
//
// This source file is part of the Swift Numerics open source project
//
// Copyright (c) 2019-2022 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*p; is
// that Quaternion(2) * p or is it RealType(2) * p? 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 Quaternion type context, then b will be inferred to have type
// Quaternion! 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 Quaternion {
/// `self` scaled by `scalar`.
@usableFromInline @_transparent
internal func multiplied(by scalar: RealType) -> Quaternion {
Quaternion(from: components * scalar)
}
/// `self` unscaled by `scalar`.
@usableFromInline @_transparent
internal func divided(by scalar: RealType) -> Quaternion {
Quaternion(from: components / scalar)
}
}
@@ -1,25 +0,0 @@
# Transformation
In computer science, quaternions are frequently used to represent three-dimensional rotations; as quaternions have some dvantages over other representations][advantages].
`Transformation.swift` encapsulates an API to interact with the three-dimensional transformation properties of quaternions. It provides conversions to and from other rotation representations, namely [*Angle-Axis*][angle_axis_wiki], [*Rotation Vector*][rotation_vector_wiki] and [*Polar decomposition*][polar_wiki], as well as it provides methods to directly transform arbitrary vectors by quaternions.
## Policies
- zero and non-finite quaternions have indeterminate transformation properties and can not be converted to other representations. Thus,
- The `angle` of `.zero` or `.infinity` is `RealType.nan`.
- The `axis` of `.zero` or `.infinity` is `RealType.nan` in all lanes.
- The `rotationVector` of `.zero` or `.infinity` is `RealType.nan` in all lanes.
- The polar `phase` of `.zero` or `.infinity` is `RealType.nan`
- Quaternions with an `angle` of `.zero` have an indeterminate rotation axis. Thus,
- the `axis` of `angle == .zero` is `RealType.nan` in all lanes.
- the `rotationVector` of `angle == .zero` is `RealType.nan` in all lanes.
[advantages]: https://en.wikipedia.org/wiki/Quaternions_and_spatial_rotation#Advantages_of_quaternions
[angle_axis_wiki]: https://en.wikipedia.org/wiki/Quaternions_and_spatial_rotation#Recovering_the_axis-angle_representation
[polar_wiki]: https://en.wikipedia.org/wiki/Polar_decomposition#Quaternion_polar_decomposition
[rotation_vector_wiki]: https://en.wikipedia.org/wiki/Axis–angle_representation#Rotation_vector
@@ -1,271 +0,0 @@
//===--- Transformation.swift ---------------------------------*- swift -*-===//
//
// This source file is part of the Swift Numerics open source project
//
// Copyright (c) 2020 - 2022 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 Quaternion {
/// The [rotation angle][wiki] of the Angle-Axis representation.
///
/// Returns the rotation angle about the rotation *axis* in radians
/// within *[0, 2π]* range.
///
/// Edge cases:
/// - If the quaternion is zero or non-finite, angle is `nan`.
///
/// See also `.axis`, `.angleAxis`, `.rotationVector`,
/// `init(length:angle:axis:)` and `init(rotation:)`.
///
/// [wiki]: https://en.wikipedia.org/wiki/Quaternions_and_spatial_rotation#Recovering_the_axis-angle_representation
@inlinable
public var angle: RealType {
2 * halfAngle
}
/// The [rotation axis][wiki] of the Angle-Axis representation.
///
/// Returns the *(x,y,z)* rotation axis encoded in the quaternion
/// as SIMD3 vector of unit length.
///
/// Edge cases:
/// - If the quaternion is zero or non-finite, axis is `nan` in all lanes.
/// - If the rotation angle is zero, axis is `nan` in all lanes.
///
/// See also `.angle`, `.angleAxis`, `.rotationVector`,
/// `init(length:angle:axis:)` and `init(rotation:)`.
///
/// [wiki]: https://en.wikipedia.org/wiki/Quaternions_and_spatial_rotation#Recovering_the_axis-angle_representation
@inlinable
public var axis: SIMD3<RealType> {
guard isFinite, imaginary != .zero else { return SIMD3(repeating: .nan) }
// If lengthSquared computes without over/underflow, everything is fine
// and the result is correct. If not, we have to do the computation
// carefully and unscale the quaternion first.
let lenSq = imaginary.lengthSquared
guard lenSq.isNormal else { return divided(by: magnitude).axis }
return imaginary / .sqrt(lenSq)
}
/// The [Angle-Axis][wiki] representation.
///
/// Returns the length of the quaternion, the rotation angle in radians
/// within *[0, 2π]* and the rotation axis as SIMD3 vector of unit length.
///
/// Edge cases:
/// - If the quaternion is zero or non-finite, angle and axis are `nan`.
/// - If the angle is zero, axis is `nan` in all lanes.
///
/// See also `.angle`, `.axis`, `.rotationVector`, `init(length:angle:axis:)`
/// and `init(rotation:)`.
///
/// [wiki]: https://en.wikipedia.org/wiki/Quaternions_and_spatial_rotation#Recovering_the_axis-angle_representation
public var angleAxis: (length: RealType, angle: RealType, axis: SIMD3<RealType>) {
(length, angle, axis)
}
/// The [rotation vector][rotvector].
///
/// A rotation vector is a vector of same direction as the rotation axis,
/// whose length is the rotation angle of an Angle-Axis representation. It
/// is effectively the product of multiplying the rotation `axis` by the
/// rotation `angle`. Rotation vectors are often called "scaled axis" — this
/// is a different name for the same concept.
///
/// Edge cases:
/// - If the quaternion is zero or non-finite, the rotation vector is `nan`
/// in all lanes.
/// - If the rotation angle is zero, the rotation vector is `nan`
/// in all lanes.
///
/// See also `.angle`, `.axis`, `.angleAxis`, `init(length:angle:axis:)`
/// and `init(rotation:)`.
///
/// [rotvector]: https://en.wikipedia.org/wiki/Axis–angle_representation#Rotation_vector
@_transparent
public var rotationVector: SIMD3<RealType> {
axis * angle
}
/// Creates a unit quaternion specified with [Angle-Axis][wiki] values.
///
/// Angle-Axis is a representation of a three-dimensional rotation using two
/// different quantities: an angle describing the magnitude of rotation, and
/// a vector of unit length indicating the axis direction to rotate along.
/// The optional length parameter scales the quaternion after the conversion.
///
/// This initializer reads given `length`, `angle` and `axis` values and
/// creates a quaternion of equal rotation properties and of specified length
/// using the following equation:
///
/// Q = (cos(angle/2), axis * sin(angle/2)) * length
///
/// If `length` is not specified, it defaults to *1*; and the final
/// quaternion is of unit length.
///
/// - Note: `axis` must be of unit length, or an assertion failure occurs.
///
/// Edge cases:
/// - Negative lengths are interpreted as reflecting the point through the origin, i.e.:
/// ```
/// Quaternion(length: -r, angle: θ, axis: axis) == -Quaternion(length: r, angle: θ, axis: axis)
/// ```
/// - For any `θ` and any `axis`, even `.infinity` or `.nan`:
/// ```
/// Quaternion(length: .zero, angle: θ, axis: axis) == .zero
/// ```
/// - For any `θ` and any `axis`, even `.infinity` or `.nan`:
/// ```
/// Quaternion(length: .infinity, angle: θ, axis: axis) == .infinity
/// ```
/// - Otherwise, `θ` must be finite, or a precondition failure occurs.
///
/// See also `.angle`, `.axis`, `.angleAxis`, `.rotationVector`
/// and `init(rotation:)`.
///
/// - Parameter length: The length of the quaternion. Defaults to `1`.
/// - Parameter angle: The rotation angle about the rotation axis in radians.
/// - Parameter axis: The rotation axis. Must be of unit length.
///
/// [wiki]: https://en.wikipedia.org/wiki/Quaternions_and_spatial_rotation#Recovering_the_axis-angle_representation
@inlinable
public init(length: RealType = 1, angle: RealType, axis: SIMD3<RealType>) {
guard !length.isZero, length.isFinite else {
self = Quaternion(length)
return
}
// Length is finite and non-zero, therefore
// 1. `angle` must be finite or a precondition failure needs to occur; as
// this is not representable.
// 2. `axis` must be of unit length or an assertion failure occurs; while
// "wrong" by definition, it is representable.
precondition(
angle.isFinite,
"Either angle must be finite, or length must be zero or infinite."
)
assert(
// TODO: Replace with `approximateEquality()`
abs(.sqrt(axis.lengthSquared)-1) < max(.sqrt(axis.lengthSquared), 1)*RealType.ulpOfOne.squareRoot(),
"Given axis must be of unit length."
)
self = Quaternion(halfAngle: angle/2, unitAxis: axis).multiplied(by: length)
}
/// Creates a unit quaternion specified with given [rotation vector][wiki].
///
/// A rotation vector is a vector of same direction as the rotation axis,
/// whose length is the rotation angle of an Angle-Axis representation. It
/// is effectively the product of multiplying the rotation `axis` by the
/// rotation `angle`.
///
/// This initializer reads the angle and axis values of given rotation vector
/// and creates a quaternion of equal rotation properties using the following
/// equation:
///
/// Q = (cos(angle/2), axis * sin(angle/2))
///
/// Rotation vectors are sometimes referred to as *scaled axis* — this is a
/// different name for the same concept.
///
/// The final quaternion is of unit length.
///
/// Edge cases:
/// - If `vector` is `.zero`, the quaternion is `.zero`:
/// ```
/// Quaternion(rotation: .zero) == .zero
/// ```
/// - If `vector` is `.infinity` or `-.infinity`, the quaternion is `.infinity`:
/// ```
/// Quaternion(rotation: -.infinity) == .infinity
/// ```
///
/// See also `.angle`, `.axis`, `.angleAxis`, `.rotationVector`
/// and `init(length:angle:axis:)`.
///
/// - Parameter vector: The rotation vector.
///
/// [wiki]: https://en.wikipedia.org/wiki/Axis–angle_representation#Rotation_vector
@inlinable
public init(rotation vector: SIMD3<RealType>) {
let angle: RealType = .sqrt(vector.lengthSquared)
if !angle.isZero, angle.isFinite {
self = Quaternion(halfAngle: angle/2, unitAxis: vector/angle)
} else {
self = Quaternion(angle)
}
}
/// Transforms a vector by this quaternion.
///
/// Quaternions are frequently used to represent three-dimensional
/// transformations, and thus are used to transform vectors in
/// three-dimensional space. The transformation of an arbitrary vector
/// by a quaternion is known as an action.
///
/// The canonical way of transforming an arbitrary three-dimensional vector
/// `v` by a quaternion `q` is given by the following [formula][wiki]
///
/// p' = qpq⁻¹
///
/// where `p` is a *pure* quaternion (`real == .zero`) with imaginary part
/// equal to vector `v`, and where `p'` is another pure quaternion with
/// imaginary part equal to the transformed vector `v'`. The implementation
/// uses this formular but boils down to a simpler and faster implementation
/// as `p` is known to be pure and `q` is assumed to have unit length – which
/// allows for simplification.
///
/// - Note: This method assumes this quaternion is of unit length.
///
/// Edge cases:
/// - For any quaternion `q`, even `.zero` or `.infinity`, if `vector` is
/// `.infinity` or `-.infinity` in any of the lanes or all, the returning
/// vector is `.infinity` in all lanes:
/// ```
/// SIMD3(-.infinity,0,0) * q == SIMD3(.infinity,.infinity,.infinity)
/// ```
/// - For any quaternion `q`, even `.zero` or `.infinity`, if `vector` is
/// `.zero`, the returning vector is also `.zero`.
/// ```
/// SIMD3(0,0,0) * q == .zero
/// ```
///
/// - Parameter vector: A vector to rotate by this quaternion
/// - Returns: The vector rotated by this quaternion
///
/// [wiki]: https://en.wikipedia.org/wiki/Quaternions_and_spatial_rotation#Using_quaternion_as_rotations
@inlinable
public func act(on vector: SIMD3<RealType>) -> SIMD3<RealType> {
guard vector.isFinite else { return .infinity }
guard vector != .zero else { return .zero }
// The following expression have been split up so the type-checker
// can resolve them in a reasonable time.
let p1 = vector * (real*real - imaginary.lengthSquared)
let p2 = imaginary * imaginary.dot(vector)
let p3 = imaginary.cross(vector) * real
let rotatedVector = p1 + (p2 + p3) * 2
// If the rotation computes without over/underflow, everything is fine
// and the result is correct. If not, we have to do the computation
// carefully and first unscale the vector, rotate it again and then
// rescale the vector
if
(rotatedVector.x.isNormal || rotatedVector.x.isZero) &&
(rotatedVector.y.isNormal || rotatedVector.y.isZero) &&
(rotatedVector.z.isNormal || rotatedVector.z.isZero)
{
return rotatedVector
}
let scale = max(abs(vector.max()), abs(vector.min()))
return act(on: vector/scale) * scale
}
}
+4 -5
View File
@@ -109,11 +109,10 @@ extension Augmented {
/// 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 ``sum(large:small:)``, the magnitude of the summands does not
/// matter. If you know statically that `a.magnitude >= b.magnitude`, you
/// should use ``sum(large:small:)``. If you do not have such a static
/// bound, you should use this function instead.
///
/// Unlike ``product(_:_:)``, the rounding error of `sum` never underflows.
///
@@ -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,67 +0,0 @@
//===--- ArithmeticTests.swift --------------------------------*- swift -*-===//
//
// This source file is part of the Swift Numerics open source project
//
// Copyright (c) 2019 - 2020 Apple Inc. and the Swift Numerics project authors
// Licensed under Apache License v2.0 with Runtime Library Exception
//
// See https://swift.org/LICENSE.txt for license information
//
//===----------------------------------------------------------------------===//
import XCTest
import RealModule
@testable import QuaternionModule
final class ArithmeticTests: XCTestCase {
func testMultiplication<T: Real & SIMDScalar>(_ type: T.Type) {
for value: T in [-3, -2, -1, +1, +2, +3] {
let q = Quaternion<T>(real: value, imaginary: value, value, value)
XCTAssertEqual(q * .one, q)
XCTAssertEqual(q * 1, q)
XCTAssertEqual(1 * q, q)
}
}
func testMultiplication() {
testMultiplication(Float32.self)
testMultiplication(Float64.self)
}
func testDivision<T: Real & SIMDScalar>(_ type: T.Type) {
for value: T in [-3, -2, -1, +1, +2, +3] {
let q = Quaternion<T>(real: value, imaginary: value, value, value)
XCTAssertEqual(q/q, .one)
XCTAssertEqual(0/q, .zero)
for q2: Quaternion<T> in [-3, -2, -1, 0, +1, +2, +3] {
XCTAssertEqual(q2/q, q2 * q.reciprocal!)
}
for q2: T in [-3, -2, -1, +1, +2, +3] {
XCTAssertEqual(q.divided(by: q2), q.multiplied(by: 1/q2))
}
}
}
func testDivision() {
testDivision(Float32.self)
testDivision(Float64.self)
}
func testDivisionByZero<T: Real & SIMDScalar>(_ type: T.Type) {
XCTAssertFalse((Quaternion<T>(real: 0, imaginary: 0, 0, 0) / Quaternion<T>(real: 0, imaginary: 0, 0, 0)).isFinite)
XCTAssertFalse((Quaternion<T>(real: 1, imaginary: 1, 1, 1) / Quaternion<T>(real: 0, imaginary: 0, 0, 0)).isFinite)
XCTAssertFalse((Quaternion<T>.infinity / Quaternion<T>(real: 0, imaginary: 0, 0, 0)).isFinite)
XCTAssertFalse((Quaternion<T>.i / Quaternion<T>(real: 0, imaginary: 0, 0, 0)).isFinite)
XCTAssertFalse((Quaternion<T>.j / Quaternion<T>(real: 0, imaginary: 0, 0, 0)).isFinite)
XCTAssertFalse((Quaternion<T>.k / Quaternion<T>(real: 0, imaginary: 0, 0, 0)).isFinite)
}
func testDivisionByZero() {
testDivisionByZero(Float32.self)
testDivisionByZero(Float64.self)
}
}
@@ -1,252 +0,0 @@
//===--- ElementaryFunctionTests.swift ------------------------*- swift -*-===//
//
// This source file is part of the Swift Numerics open source project
//
// Copyright (c) 2019 - 2021 Apple Inc. and the Swift Numerics project authors
// Licensed under Apache License v2.0 with Runtime Library Exception
//
// See https://swift.org/LICENSE.txt for license information
//
//===----------------------------------------------------------------------===//
import XCTest
import RealModule
import _TestSupport
@testable import QuaternionModule
final class ElementaryFunctionTests: XCTestCase {
// MARK: - exp-like functions
func testExp<T: Real & FixedWidthFloatingPoint & SIMDScalar>(_ type: T.Type) {
// exp(0) = 1
XCTAssertEqual(1, Quaternion<T>.exp(Quaternion(real: 0, imaginary: 0, 0, 0)))
XCTAssertEqual(1, Quaternion<T>.exp(Quaternion(real:-0, imaginary: 0, 0, 0)))
XCTAssertEqual(1, Quaternion<T>.exp(Quaternion(real:-0, imaginary:-0,-0,-0)))
XCTAssertEqual(1, Quaternion<T>.exp(Quaternion(real: 0, imaginary:-0,-0,-0)))
// In general, exp(Quaternion(r,0,0,0)) should be exp(r), but that breaks
// down when r is infinity or NaN, because we want all non-finite
// quaternions to be semantically a single point at infinity. This is fine
// for most inputs, but exp(Quaternion(-.infinity, 0, 0, 0)) would produce
// 0 if we evaluated it in the usual way.
XCTAssertFalse(Quaternion<T>.exp(Quaternion(real: .infinity, imaginary: .zero)).isFinite)
XCTAssertFalse(Quaternion<T>.exp(Quaternion(real: .infinity, imaginary: .infinity)).isFinite)
XCTAssertFalse(Quaternion<T>.exp(Quaternion(real: 0, imaginary: .infinity)).isFinite)
XCTAssertFalse(Quaternion<T>.exp(Quaternion(real: -.infinity, imaginary: .infinity)).isFinite)
XCTAssertFalse(Quaternion<T>.exp(Quaternion(real: -.infinity, imaginary: .zero)).isFinite)
XCTAssertFalse(Quaternion<T>.exp(Quaternion(real: -.infinity, imaginary: -.infinity)).isFinite)
XCTAssertFalse(Quaternion<T>.exp(Quaternion(real: 0, imaginary: -.infinity)).isFinite)
XCTAssertFalse(Quaternion<T>.exp(Quaternion(real: .infinity, imaginary: -.infinity)).isFinite)
XCTAssertFalse(Quaternion<T>.exp(Quaternion(real: .nan, imaginary: .nan)).isFinite)
XCTAssertFalse(Quaternion<T>.exp(Quaternion(real: .infinity, imaginary: .nan)).isFinite)
XCTAssertFalse(Quaternion<T>.exp(Quaternion(real: .nan, imaginary: .infinity)).isFinite)
XCTAssertFalse(Quaternion<T>.exp(Quaternion(real: -.infinity, imaginary: .nan)).isFinite)
XCTAssertFalse(Quaternion<T>.exp(Quaternion(real: .nan, imaginary: -.infinity)).isFinite)
// Find a value of x such that exp(x) just overflows. Then exp((x, π/4))
// should not overflow, but will do so if it is not computed carefully.
// The correct value is:
//
// exp((log(gfm) + log(9/8), π/4) = exp((log(gfm*9/8), π/4))
// = gfm*9/8 * (1/sqrt(2), 1/(sqrt(2))
let x = T.log(.greatestFiniteMagnitude) + T.log(9/8)
let huge = Quaternion<T>.exp(Quaternion(real: x, imaginary: SIMD3(.pi/4, 0, 0)))
let mag = T.greatestFiniteMagnitude/T.sqrt(2) * (9/8)
XCTAssert(huge.real.isApproximatelyEqual(to: mag))
XCTAssert(huge.imaginary.x.isApproximatelyEqual(to: mag))
XCTAssertEqual(huge.imaginary.y, .zero)
XCTAssertEqual(huge.imaginary.z, .zero)
// For randomly-chosen well-scaled finite values, we expect to have the
// usual identities:
//
// exp(z + w) = exp(z) * exp(w)
// exp(z - w) = exp(z) / exp(w)
var g = SystemRandomNumberGenerator()
let values: [Quaternion<T>] = (0..<100).map { _ in
Quaternion(
real: T.random(in: -1 ... 1, using: &g),
imaginary: SIMD3(repeating: T.random(in: -.pi ... .pi, using: &g) / 3))
}
for z in values {
for w in values {
let p = Quaternion.exp(z) * Quaternion.exp(w)
let q = Quaternion.exp(z) / Quaternion.exp(w)
XCTAssert(Quaternion.exp(z + w).isApproximatelyEqual(to: p))
XCTAssert(Quaternion.exp(z - w).isApproximatelyEqual(to: q))
}
}
}
func testExpMinusOne<T: Real & FixedWidthFloatingPoint & SIMDScalar>(_ type: T.Type) {
// expMinusOne(0) = 0
XCTAssertEqual(0, Quaternion<T>.expMinusOne(Quaternion(real: 0, imaginary: 0, 0, 0)))
XCTAssertEqual(0, Quaternion<T>.expMinusOne(Quaternion(real:-0, imaginary: 0, 0, 0)))
XCTAssertEqual(0, Quaternion<T>.expMinusOne(Quaternion(real:-0, imaginary:-0,-0,-0)))
XCTAssertEqual(0, Quaternion<T>.expMinusOne(Quaternion(real: 0, imaginary:-0,-0,-0)))
// In general, expMinusOne(Quaternion(r,0,0,0)) should be expMinusOne(r),
// but that breaks down when r is infinity or NaN, because we want all non-
// finite Quaternion values to be semantically a single point at infinity.
// This is fine for most inputs, but expMinusOne(Quaternion(-.infinity,0,0,0))
// would produce 0 if we evaluated it in the usual way.
XCTAssertFalse(Quaternion<T>.expMinusOne(Quaternion(real: .infinity, imaginary: .zero)).isFinite)
XCTAssertFalse(Quaternion<T>.expMinusOne(Quaternion(real: .infinity, imaginary: .infinity)).isFinite)
XCTAssertFalse(Quaternion<T>.expMinusOne(Quaternion(real: 0, imaginary: .infinity)).isFinite)
XCTAssertFalse(Quaternion<T>.expMinusOne(Quaternion(real: -.infinity, imaginary: .infinity)).isFinite)
XCTAssertFalse(Quaternion<T>.expMinusOne(Quaternion(real: -.infinity, imaginary: .zero)).isFinite)
XCTAssertFalse(Quaternion<T>.expMinusOne(Quaternion(real: -.infinity, imaginary: -.infinity)).isFinite)
XCTAssertFalse(Quaternion<T>.expMinusOne(Quaternion(real: 0, imaginary: -.infinity)).isFinite)
XCTAssertFalse(Quaternion<T>.expMinusOne(Quaternion(real: .infinity, imaginary: -.infinity)).isFinite)
XCTAssertFalse(Quaternion<T>.expMinusOne(Quaternion(real: .nan, imaginary: .nan)).isFinite)
XCTAssertFalse(Quaternion<T>.expMinusOne(Quaternion(real: .infinity, imaginary: .nan)).isFinite)
XCTAssertFalse(Quaternion<T>.expMinusOne(Quaternion(real: .nan, imaginary: .infinity)).isFinite)
XCTAssertFalse(Quaternion<T>.expMinusOne(Quaternion(real: -.infinity, imaginary: .nan)).isFinite)
XCTAssertFalse(Quaternion<T>.expMinusOne(Quaternion(real: .nan, imaginary: -.infinity)).isFinite)
// Near-overflow test, same as exp() above.
let x = T.log(.greatestFiniteMagnitude) + T.log(9/8)
let huge = Quaternion<T>.expMinusOne(Quaternion(real: x, imaginary: SIMD3(.pi/4, 0, 0)))
let mag = T.greatestFiniteMagnitude/T.sqrt(2) * (9/8)
XCTAssert(huge.real.isApproximatelyEqual(to: mag))
XCTAssert(huge.imaginary.x.isApproximatelyEqual(to: mag))
XCTAssertEqual(huge.imaginary.y, .zero)
XCTAssertEqual(huge.imaginary.z, .zero)
// For small values, expMinusOne should be approximately the identity.
var g = SystemRandomNumberGenerator()
let small = T.ulpOfOne
for _ in 0 ..< 100 {
let q = Quaternion<T>(
real: T.random(in: -small ... small, using: &g),
imaginary:
T.random(in: -small ... small, using: &g),
T.random(in: -small ... small, using: &g),
T.random(in: -small ... small, using: &g)
)
XCTAssert(q.isApproximatelyEqual(to: Quaternion.expMinusOne(q), relativeTolerance: 16 * .ulpOfOne))
}
}
func testCosh<T: Real & FixedWidthFloatingPoint & SIMDScalar>(_ type: T.Type) {
// cosh(0) = 1
XCTAssertEqual(1, Quaternion<T>.cosh(Quaternion(real: 0, imaginary: 0, 0, 0)))
XCTAssertEqual(1, Quaternion<T>.cosh(Quaternion(real:-0, imaginary: 0, 0, 0)))
XCTAssertEqual(1, Quaternion<T>.cosh(Quaternion(real:-0, imaginary:-0,-0,-0)))
XCTAssertEqual(1, Quaternion<T>.cosh(Quaternion(real: 0, imaginary:-0,-0,-0)))
// cosh is the identity at infinity.
XCTAssertFalse(Quaternion<T>.cosh(Quaternion(real: .infinity, imaginary: .zero)).isFinite)
XCTAssertFalse(Quaternion<T>.cosh(Quaternion(real: .infinity, imaginary: .infinity)).isFinite)
XCTAssertFalse(Quaternion<T>.cosh(Quaternion(real: 0, imaginary: .infinity)).isFinite)
XCTAssertFalse(Quaternion<T>.cosh(Quaternion(real: -.infinity, imaginary: .infinity)).isFinite)
XCTAssertFalse(Quaternion<T>.cosh(Quaternion(real: -.infinity, imaginary: .zero)).isFinite)
XCTAssertFalse(Quaternion<T>.cosh(Quaternion(real: -.infinity, imaginary: -.infinity)).isFinite)
XCTAssertFalse(Quaternion<T>.cosh(Quaternion(real: 0, imaginary: -.infinity)).isFinite)
XCTAssertFalse(Quaternion<T>.cosh(Quaternion(real: .infinity, imaginary: -.infinity)).isFinite)
XCTAssertFalse(Quaternion<T>.cosh(Quaternion(real: .nan, imaginary: .nan)).isFinite)
XCTAssertFalse(Quaternion<T>.cosh(Quaternion(real: .infinity, imaginary: .nan)).isFinite)
XCTAssertFalse(Quaternion<T>.cosh(Quaternion(real: .nan, imaginary: .infinity)).isFinite)
XCTAssertFalse(Quaternion<T>.cosh(Quaternion(real: -.infinity, imaginary: .nan)).isFinite)
XCTAssertFalse(Quaternion<T>.cosh(Quaternion(real: .nan, imaginary: -.infinity)).isFinite)
// Near-overflow test, same as exp() above, but it happens later, because
// for large x, cosh(x + v) ~ exp(x + v)/2.
let x = T.log(.greatestFiniteMagnitude) + T.log(18/8)
let mag = T.greatestFiniteMagnitude/T.sqrt(2) * (9/8)
var huge = Quaternion<T>.cosh(Quaternion(real: x, imaginary: SIMD3(.pi/4, 0, 0)))
XCTAssert(huge.real.isApproximatelyEqual(to: mag))
XCTAssert(huge.imaginary.x.isApproximatelyEqual(to: mag))
XCTAssertEqual(huge.imaginary.y, .zero)
XCTAssertEqual(huge.imaginary.z, .zero)
huge = Quaternion<T>.cosh(Quaternion(real: -x, imaginary: SIMD3(.pi/4, 0, 0)))
XCTAssert(huge.real.isApproximatelyEqual(to: mag))
XCTAssert(huge.imaginary.x.isApproximatelyEqual(to: mag))
XCTAssertEqual(huge.imaginary.y, .zero)
XCTAssertEqual(huge.imaginary.z, .zero)
}
func testSinh<T: Real & FixedWidthFloatingPoint & SIMDScalar>(_ type: T.Type) {
// sinh(0) = 0
XCTAssertEqual(0, Quaternion<T>.sinh(Quaternion(real: 0, imaginary: 0, 0, 0)))
XCTAssertEqual(0, Quaternion<T>.sinh(Quaternion(real:-0, imaginary: 0, 0, 0)))
XCTAssertEqual(0, Quaternion<T>.sinh(Quaternion(real:-0, imaginary:-0,-0,-0)))
XCTAssertEqual(0, Quaternion<T>.sinh(Quaternion(real: 0, imaginary:-0,-0,-0)))
// sinh is the identity at infinity.
XCTAssertFalse(Quaternion<T>.sinh(Quaternion(real: .infinity, imaginary: .zero)).isFinite)
XCTAssertFalse(Quaternion<T>.sinh(Quaternion(real: .infinity, imaginary: .infinity)).isFinite)
XCTAssertFalse(Quaternion<T>.sinh(Quaternion(real: 0, imaginary: .infinity)).isFinite)
XCTAssertFalse(Quaternion<T>.sinh(Quaternion(real: -.infinity, imaginary: .infinity)).isFinite)
XCTAssertFalse(Quaternion<T>.sinh(Quaternion(real: -.infinity, imaginary: .zero)).isFinite)
XCTAssertFalse(Quaternion<T>.sinh(Quaternion(real: -.infinity, imaginary: -.infinity)).isFinite)
XCTAssertFalse(Quaternion<T>.sinh(Quaternion(real: 0, imaginary: -.infinity)).isFinite)
XCTAssertFalse(Quaternion<T>.sinh(Quaternion(real: .infinity, imaginary: -.infinity)).isFinite)
XCTAssertFalse(Quaternion<T>.sinh(Quaternion(real: .nan, imaginary: .nan)).isFinite)
XCTAssertFalse(Quaternion<T>.sinh(Quaternion(real: .infinity, imaginary: .nan)).isFinite)
XCTAssertFalse(Quaternion<T>.sinh(Quaternion(real: .nan, imaginary: .infinity)).isFinite)
XCTAssertFalse(Quaternion<T>.sinh(Quaternion(real: -.infinity, imaginary: .nan)).isFinite)
XCTAssertFalse(Quaternion<T>.sinh(Quaternion(real: .nan, imaginary: -.infinity)).isFinite)
// Near-overflow test, same as exp() above, but it happens later, because
// for large x, sinh(x + v) ~ ±exp(x + v)/2.
let x = T.log(.greatestFiniteMagnitude) + T.log(18/8)
let mag = T.greatestFiniteMagnitude/T.sqrt(2) * (9/8)
var huge = Quaternion<T>.sinh(Quaternion(real: x, imaginary: SIMD3(.pi/4, 0, 0)))
XCTAssert(huge.real.isApproximatelyEqual(to: mag))
XCTAssert(huge.imaginary.x.isApproximatelyEqual(to: mag))
XCTAssertEqual(huge.imaginary.y, .zero)
XCTAssertEqual(huge.imaginary.z, .zero)
huge = Quaternion<T>.sinh(Quaternion(real: -x, imaginary: SIMD3(.pi/4, 0, 0)))
XCTAssert(huge.real.isApproximatelyEqual(to: -mag))
XCTAssert(huge.imaginary.x.isApproximatelyEqual(to: -mag))
XCTAssertEqual(huge.imaginary.y, .zero)
XCTAssertEqual(huge.imaginary.z, .zero)
// For randomly-chosen well-scaled finite values, we expect to have
// cosh² - sinh² ≈ 1. Note that this test would break down due to
// catastrophic cancellation as we get further away from the origin.
var g = SystemRandomNumberGenerator()
let values: [Quaternion<T>] = (0..<1000).map { _ in
Quaternion(
real: T.random(in: -2 ... 2, using: &g),
imaginary:
T.random(in: -2 ... 2, using: &g),
T.random(in: -2 ... 2, using: &g),
T.random(in: -2 ... 2, using: &g)
)
}
for q in values {
let c = Quaternion.cosh(q)
let s = Quaternion.sinh(q)
XCTAssert((c*c - s*s).isApproximatelyEqual(to: .one))
}
}
func testCosSin<T: Real & FixedWidthFloatingPoint & SIMDScalar>(_ type: T.Type) {
var g = SystemRandomNumberGenerator()
let values: [Quaternion<T>] = (0..<1000).map { _ in
Quaternion(
real: T.random(in: -2 ... 2, using: &g),
imaginary:
T.random(in: -2 ... 2, using: &g),
T.random(in: -2 ... 2, using: &g),
T.random(in: -2 ... 2, using: &g)
)
}
for q in values {
// For randomly-chosen well-scaled finite values, we expect to have
// cos² + sin² ≈ 1
let s = Quaternion.sin(q)
let c = Quaternion.cos(q)
XCTAssert((c*c + s*s).isApproximatelyEqual(to: .one))
}
}
func testFloat() {
testExp(Float32.self)
testExpMinusOne(Float32.self)
testCosh(Float32.self)
testSinh(Float32.self)
testCosSin(Float32.self)
}
func testDouble() {
testExp(Float64.self)
testExpMinusOne(Float64.self)
testCosh(Float64.self)
testSinh(Float64.self)
testCosSin(Float64.self)
}
}
-236
View File
@@ -1,236 +0,0 @@
//===--- PropertyTests.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 XCTest
import RealModule
@testable import QuaternionModule
final class PropertyTests: XCTestCase {
func testProperties<T: Real & SIMDScalar>(_ type: T.Type) {
// The real and imaginary parts of a non-finite value should be nan.
XCTAssertTrue(Quaternion<T>.infinity.real.isNaN)
XCTAssertTrue(Quaternion<T>.infinity.imaginary.x.isNaN)
XCTAssertTrue(Quaternion<T>.infinity.imaginary.y.isNaN)
XCTAssertTrue(Quaternion<T>.infinity.imaginary.z.isNaN)
XCTAssertTrue(Quaternion<T>(real: .infinity, imaginary: .nan, .nan, .nan).real.isNaN)
XCTAssertTrue(Quaternion<T>(real: .nan, imaginary: 0, 0, 0).imaginary.x.isNaN)
XCTAssertTrue(Quaternion<T>(real: .nan, imaginary: 0, 0, 0).imaginary.y.isNaN)
XCTAssertTrue(Quaternion<T>(real: .nan, imaginary: 0, 0, 0).imaginary.z.isNaN)
// The length of a non-finite value should be infinity.
XCTAssertEqual(Quaternion<T>.infinity.length, .infinity)
XCTAssertEqual(Quaternion<T>(real: .infinity, imaginary: .nan, .nan, .nan).length, .infinity)
XCTAssertEqual(Quaternion<T>(real: .nan, imaginary: 0, 0, 0).length, .infinity)
// The length of a zero value should be zero.
XCTAssertEqual(Quaternion<T>.zero.length, .zero)
XCTAssertEqual(Quaternion<T>(real: .zero, imaginary: -.zero).length, .zero)
XCTAssertEqual(Quaternion<T>(real: -.zero, imaginary: -.zero).length, .zero)
// Check for overflow and underflow when calculating the length
XCTAssertEqual(Quaternion<T>(real: .greatestFiniteMagnitude, imaginary: 0, 0, 0).length, .greatestFiniteMagnitude)
XCTAssertEqual(Quaternion<T>(real: 0, imaginary: -.greatestFiniteMagnitude, 0, 0).length, .greatestFiniteMagnitude)
XCTAssertEqual(Quaternion<T>(real: 0, imaginary: 0, .leastNormalMagnitude, 0).length, .leastNormalMagnitude)
XCTAssertEqual(Quaternion<T>(real: 0, imaginary: 0, 0, -.leastNormalMagnitude).length, .leastNormalMagnitude)
// The properties of pure and real
XCTAssertTrue(Quaternion<T>.zero.isPure) // zero quaternion is both, pure...
XCTAssertTrue(Quaternion<T>.zero.isReal) // and real
XCTAssertFalse(Quaternion<T>(1).isPure)
XCTAssertTrue(Quaternion<T>(1).isReal)
XCTAssertTrue(Quaternion<T>(real: .zero, imaginary: 1, 0, 0).isPure)
XCTAssertFalse(Quaternion<T>(real: .zero, imaginary: 1, 0, 0).isReal)
XCTAssertFalse(Quaternion<T>(from: SIMD4(repeating: 1)).isPure)
XCTAssertFalse(Quaternion<T>(from: SIMD4(repeating: 1)).isReal)
}
func testProperties() {
testProperties(Float32.self)
testProperties(Float64.self)
}
func testEquatableHashable<T: Real & SIMDScalar>(_ type: T.Type) {
// Validate that all zeros compare and hash equal, and all non-finites
// do too.
let zeros = [
Quaternion<T>(real: .zero, imaginary: .zero, .zero, .zero),
Quaternion<T>(real: .zero, imaginary: -.zero, .zero, .zero),
Quaternion<T>(real: .zero, imaginary: .zero, -.zero, .zero),
Quaternion<T>(real: .zero, imaginary: .zero, .zero, -.zero),
Quaternion<T>(real: .zero, imaginary: -.zero, -.zero, .zero),
Quaternion<T>(real: .zero, imaginary: -.zero, .zero, -.zero),
Quaternion<T>(real: .zero, imaginary: .zero, -.zero, -.zero),
Quaternion<T>(real: .zero, imaginary: -.zero, -.zero, -.zero),
Quaternion<T>(real: -.zero, imaginary: .zero, .zero, .zero),
Quaternion<T>(real: -.zero, imaginary: -.zero, .zero, .zero),
Quaternion<T>(real: -.zero, imaginary: .zero, -.zero, .zero),
Quaternion<T>(real: -.zero, imaginary: .zero, .zero, -.zero),
Quaternion<T>(real: -.zero, imaginary: -.zero, -.zero, .zero),
Quaternion<T>(real: -.zero, imaginary: -.zero, .zero, -.zero),
Quaternion<T>(real: -.zero, imaginary: .zero, -.zero, -.zero),
Quaternion<T>(real: -.zero, imaginary: -.zero, -.zero, -.zero)
]
for z in zeros[1...] {
XCTAssertEqual(zeros[0], z)
XCTAssertEqual(zeros[0].hashValue, z.hashValue)
}
let infs = [
Quaternion<T>(real: .nan, imaginary: .nan, .nan, .nan),
Quaternion<T>(real: -.infinity, imaginary: .nan, .nan, .nan),
Quaternion<T>(real: -.ulpOfOne, imaginary: .nan, .nan, .nan),
Quaternion<T>(real: .zero, imaginary: .nan, .nan, .nan),
Quaternion<T>(real: .pi, imaginary: .nan, .nan, .nan),
Quaternion<T>(real: .infinity, imaginary: .nan, .nan, .nan),
Quaternion<T>(real: .nan, imaginary: -.infinity, -.infinity, -.infinity),
Quaternion<T>(real: -.infinity, imaginary: -.infinity, -.infinity, -.infinity),
Quaternion<T>(real: -.ulpOfOne, imaginary: -.infinity, -.infinity, -.infinity),
Quaternion<T>(real: .zero, imaginary: -.infinity, -.infinity, -.infinity),
Quaternion<T>(real: .pi, imaginary: -.infinity, -.infinity, -.infinity),
Quaternion<T>(real: .infinity, imaginary: -.infinity, -.infinity, -.infinity),
Quaternion<T>(real: .nan, imaginary: -.ulpOfOne, -.ulpOfOne, -.ulpOfOne),
Quaternion<T>(real: -.infinity, imaginary: -.ulpOfOne, -.ulpOfOne, -.ulpOfOne),
Quaternion<T>(real: .infinity, imaginary: -.ulpOfOne, -.ulpOfOne, -.ulpOfOne),
Quaternion<T>(real: .nan, imaginary: .zero, .zero, .zero),
Quaternion<T>(real: -.infinity, imaginary: .zero, .zero, .zero),
Quaternion<T>(real: .infinity, imaginary: .zero, .zero, .zero),
Quaternion<T>(real: .nan, imaginary: .pi, .pi, .pi),
Quaternion<T>(real: -.infinity, imaginary: .pi, .pi, .pi),
Quaternion<T>(real: .infinity, imaginary: .pi, .pi, .pi),
Quaternion<T>(real: .nan, imaginary: .infinity, .infinity, .infinity),
Quaternion<T>(real: -.infinity, imaginary: .infinity, .infinity, .infinity),
Quaternion<T>(real: -.ulpOfOne, imaginary: .infinity, .infinity, .infinity),
Quaternion<T>(real: .zero, imaginary: .infinity, .infinity, .infinity),
Quaternion<T>(real: .pi, imaginary: .infinity, .infinity, .infinity),
Quaternion<T>(real: .infinity, imaginary: .infinity, .infinity, .infinity),
]
for i in infs[1...] {
XCTAssertEqual(infs[0], i)
XCTAssertEqual(infs[0].hashValue, i.hashValue)
}
// Validate that all *normal* values hash their absolute components, so
// that rotations in *R³* of `q` and `-q` will hash to same value.
let pairs: [(lhs: Quaternion<T>, rhs: Quaternion<T>)] = [
(
Quaternion<T>(real: -.pi, imaginary: .pi, .pi, .pi),
Quaternion<T>(real: .pi, imaginary: -.pi, -.pi, -.pi)
), (
Quaternion<T>(real: .pi, imaginary: -.pi, .pi, .pi),
Quaternion<T>(real: -.pi, imaginary: .pi, -.pi, -.pi)
), (
Quaternion<T>(real: .pi, imaginary: .pi, -.pi, .pi),
Quaternion<T>(real: -.pi, imaginary: -.pi, .pi, -.pi)
), (
Quaternion<T>(real: .pi, imaginary: .pi, .pi, -.pi),
Quaternion<T>(real: -.pi, imaginary: -.pi, -.pi, .pi)
), (
Quaternion<T>(real: -.pi, imaginary: -.pi, .pi, .pi),
Quaternion<T>(real: .pi, imaginary: .pi, -.pi, -.pi)
), (
Quaternion<T>(real: .pi, imaginary: -.pi, -.pi, .pi),
Quaternion<T>(real: -.pi, imaginary: .pi, .pi, -.pi)
), (
Quaternion<T>(real: .pi, imaginary: .pi, -.pi, -.pi),
Quaternion<T>(real: -.pi, imaginary: -.pi, .pi, .pi)
), (
Quaternion<T>(real: .pi, imaginary: .pi, .pi, .pi),
Quaternion<T>(real: -.pi, imaginary: -.pi, -.pi, -.pi)
)
]
for pair in pairs {
XCTAssertEqual(pair.lhs.hashValue, pair.rhs.hashValue)
}
}
func testEquatableHashable() {
testEquatableHashable(Float32.self)
testEquatableHashable(Float64.self)
}
func testTransformationEquals<T: Real & SIMDScalar>(_ type: T.Type) {
let rotations: [(lhs: Quaternion<T>, rhs: Quaternion<T>)] = [
(
Quaternion<T>(real: -.pi, imaginary: -.pi, -.pi, -.pi),
Quaternion<T>(real: .pi, imaginary: .pi, .pi, .pi)
), (
Quaternion<T>(real: .ulpOfOne, imaginary: .ulpOfOne, .ulpOfOne, .ulpOfOne),
Quaternion<T>(real: -.ulpOfOne, imaginary: -.ulpOfOne, -.ulpOfOne, -.ulpOfOne)
), (
Quaternion<T>(real: .pi, imaginary: -.pi, .pi, -.pi),
Quaternion<T>(real: -.pi, imaginary: .pi, -.pi, .pi)
), (
Quaternion<T>(real: -.ulpOfOne, imaginary: -.ulpOfOne, .ulpOfOne, .ulpOfOne),
Quaternion<T>(real: .ulpOfOne, imaginary: .ulpOfOne, -.ulpOfOne, -.ulpOfOne)
),
// Zero and infinity must have equal rotations too
(
Quaternion<T>.zero,
-Quaternion<T>.zero
), (
-Quaternion<T>.infinity,
Quaternion<T>.infinity
),
]
for (lhs, rhs) in rotations {
XCTAssertTrue(lhs.equals(as3DTransform: rhs))
}
let signDifferentAxis: [(lhs: Quaternion<T>, rhs: Quaternion<T>)] = [
(
Quaternion<T>(real: -.pi, imaginary: -.pi, -.pi, -.pi),
Quaternion<T>(real: -.pi, imaginary: .pi, .pi, .pi)
), (
Quaternion<T>(real: -.ulpOfOne, imaginary: .ulpOfOne, .ulpOfOne, .ulpOfOne),
Quaternion<T>(real: -.ulpOfOne, imaginary: -.ulpOfOne, -.ulpOfOne, -.ulpOfOne)
), (
Quaternion<T>(real: -.pi, imaginary: -.pi, .pi, -.pi),
Quaternion<T>(real: -.pi, imaginary: .pi, -.pi, .pi)
), (
Quaternion<T>(real: -.ulpOfOne, imaginary: -.ulpOfOne, .ulpOfOne, .ulpOfOne),
Quaternion<T>(real: -.ulpOfOne, imaginary: .ulpOfOne, -.ulpOfOne, -.ulpOfOne)
)
]
for (lhs, rhs) in signDifferentAxis {
XCTAssertFalse(lhs.equals(as3DTransform: rhs))
}
}
func testTransformationEquals() {
testTransformationEquals(Float32.self)
testTransformationEquals(Float64.self)
}
func testCodable<T: Real & SIMDScalar>(_ type: T.Type) throws {
let encoder = JSONEncoder()
encoder.nonConformingFloatEncodingStrategy = .convertToString(
positiveInfinity: "inf",
negativeInfinity: "-inf",
nan: "nan"
)
let decoder = JSONDecoder()
decoder.nonConformingFloatDecodingStrategy = .convertFromString(
positiveInfinity: "inf",
negativeInfinity: "-inf",
nan: "nan"
)
for expected: Quaternion<T> in [.zero, .one, .i, .infinity] {
let data = try encoder.encode(expected)
let actual = try decoder.decode(Quaternion<T>.self, from: data)
XCTAssertEqual(actual, expected)
}
}
func testCodable() throws {
try testCodable(Float32.self)
try testCodable(Float64.self)
}
}
@@ -1,379 +0,0 @@
//===--- TransformationTests.swift ----------------------------*- swift -*-===//
//
// This source file is part of the Swift Numerics open source project
//
// Copyright (c) 2020 Apple Inc. and the Swift Numerics project authors
// Licensed under Apache License v2.0 with Runtime Library Exception
//
// See https://swift.org/LICENSE.txt for license information
//
//===----------------------------------------------------------------------===//
import XCTest
import RealModule
@testable import QuaternionModule
final class TransformationTests: XCTestCase {
// MARK: Angle/Axis
func testAngleAxis<T: Real & SIMDScalar>(_ type: T.Type) {
let xAxis = SIMD3<T>(1,0,0)
// Positive angle, positive axis
XCTAssertEqual(Quaternion<T>(angle: .pi, axis: xAxis).angle, .pi)
XCTAssertEqual(Quaternion<T>(angle: .pi, axis: xAxis).axis, xAxis)
// Negative angle, positive axis
XCTAssertEqual(Quaternion<T>(angle: -.pi, axis: xAxis).angle, .pi)
XCTAssertEqual(Quaternion<T>(angle: -.pi, axis: xAxis).axis, -xAxis)
// Positive angle, negative axis
XCTAssertEqual(Quaternion<T>(angle: .pi, axis: -xAxis).angle, .pi)
XCTAssertEqual(Quaternion<T>(angle: .pi, axis: -xAxis).axis, -xAxis)
// Negative angle, negative axis
XCTAssertEqual(Quaternion<T>(angle: -.pi, axis: -xAxis).angle, .pi)
XCTAssertEqual(Quaternion<T>(angle: -.pi, axis: -xAxis).axis, xAxis)
}
func testAngleAxis() {
testAngleAxis(Float32.self)
testAngleAxis(Float64.self)
}
func testAngleAxisMultipleOfPi<T: Real & SIMDScalar>(_ type: T.Type) {
let xAxis = SIMD3<T>(1,0,0)
// 2π
let pi2 = Quaternion<T>(angle: .pi * 2, axis: xAxis)
XCTAssertEqual(pi2.angle, .pi * 2)
XCTAssertEqual(pi2.axis, xAxis)
// 3π - axis inverted
let pi3 = Quaternion<T>(angle: .pi * 3, axis: xAxis)
XCTAssertTrue(closeEnough(pi3.angle, .pi, ulps: 1))
XCTAssertEqual(pi3.axis, -xAxis)
// 5π - axis restored
let pi5 = Quaternion<T>(angle: .pi * 5, axis: xAxis)
XCTAssertTrue(closeEnough(pi5.angle, .pi, ulps: 5))
XCTAssertEqual(pi5.axis, xAxis)
}
func testAngleAxisMultipleOfPi() {
testAngleAxisMultipleOfPi(Float32.self)
testAngleAxisMultipleOfPi(Float64.self)
}
func testAngleAxisEdgeCases<T: Real & SIMDScalar>(_ type: T.Type) {
// Zero/Zero
XCTAssertTrue(Quaternion<T>(length: .zero, angle: .zero, axis: .zero).axis.isNaN)
XCTAssertTrue(Quaternion<T>(length: .zero, angle: .zero, axis: .zero).angle.isNaN)
XCTAssertEqual(Quaternion<T>(length: .zero, angle: .zero, axis: .zero), .zero)
// Inf/Zero
XCTAssertTrue(Quaternion<T>(length: .zero, angle: .infinity, axis: .infinity).axis.isNaN)
XCTAssertTrue(Quaternion<T>(length: .zero, angle: .infinity, axis: .infinity).angle.isNaN)
XCTAssertEqual(Quaternion<T>(length: .zero, angle: .infinity, axis: .infinity), .zero)
// -Inf/Zero
XCTAssertTrue(Quaternion<T>(length: .zero, angle: -.infinity, axis: -.infinity).axis.isNaN)
XCTAssertTrue(Quaternion<T>(length: .zero, angle: -.infinity, axis: -.infinity).angle.isNaN)
XCTAssertEqual(Quaternion<T>(length: .zero, angle: -.infinity, axis: -.infinity), .zero)
// NaN/Zero
XCTAssertTrue(Quaternion<T>(length: .zero, angle: .nan, axis: .nan).axis.isNaN)
XCTAssertTrue(Quaternion<T>(length: .zero, angle: .nan, axis: .nan).angle.isNaN)
XCTAssertEqual(Quaternion<T>(length: .zero, angle: .nan, axis: .nan), .zero)
// Zero/Inf
XCTAssertTrue(Quaternion<T>(length: .infinity, angle: .zero, axis: .zero).axis.isNaN)
XCTAssertTrue(Quaternion<T>(length: .infinity, angle: .zero, axis: .zero).angle.isNaN)
XCTAssertEqual(Quaternion<T>(length: .infinity, angle: .zero, axis: .zero), .infinity)
// Inf/Inf
XCTAssertTrue(Quaternion<T>(length: .infinity, angle: .infinity, axis: .infinity).axis.isNaN)
XCTAssertTrue(Quaternion<T>(length: .infinity, angle: .infinity, axis: .infinity).angle.isNaN)
XCTAssertEqual(Quaternion<T>(length: .infinity, angle: .infinity, axis: .infinity), .infinity)
// -Inf/Inf
XCTAssertTrue(Quaternion<T>(length: .infinity, angle: -.infinity, axis: -.infinity).axis.isNaN)
XCTAssertTrue(Quaternion<T>(length: .infinity, angle: -.infinity, axis: -.infinity).angle.isNaN)
XCTAssertEqual(Quaternion<T>(length: .infinity, angle: -.infinity, axis: -.infinity), .infinity)
// NaN/Inf
XCTAssertTrue(Quaternion<T>(length: .infinity, angle: .nan, axis: .nan).axis.isNaN)
XCTAssertTrue(Quaternion<T>(length: .infinity, angle: .nan, axis: .nan).angle.isNaN)
XCTAssertEqual(Quaternion<T>(length: .infinity, angle: .nan, axis: .nan), .infinity)
// Zero/-Inf
XCTAssertTrue(Quaternion<T>(length: -.infinity, angle: .zero, axis: .zero).axis.isNaN)
XCTAssertTrue(Quaternion<T>(length: -.infinity, angle: .zero, axis: .zero).angle.isNaN)
XCTAssertEqual(Quaternion<T>(length: -.infinity, angle: .zero, axis: .zero), .infinity)
// Inf/-Inf
XCTAssertTrue(Quaternion<T>(length: -.infinity, angle: .infinity, axis: .infinity).axis.isNaN)
XCTAssertTrue(Quaternion<T>(length: -.infinity, angle: .infinity, axis: .infinity).angle.isNaN)
XCTAssertEqual(Quaternion<T>(length: -.infinity, angle: .infinity, axis: .infinity), .infinity)
// -Inf/-Inf
XCTAssertTrue(Quaternion<T>(length: -.infinity, angle: -.infinity, axis: -.infinity).axis.isNaN)
XCTAssertTrue(Quaternion<T>(length: -.infinity, angle: -.infinity, axis: -.infinity).angle.isNaN)
XCTAssertEqual(Quaternion<T>(length: -.infinity, angle: -.infinity, axis: -.infinity), .infinity)
// NaN/-Inf
XCTAssertTrue(Quaternion<T>(length: -.infinity, angle: .nan, axis: .nan).axis.isNaN)
XCTAssertTrue(Quaternion<T>(length: -.infinity, angle: .nan, axis: .nan).angle.isNaN)
XCTAssertEqual(Quaternion<T>(length: -.infinity, angle: .nan, axis: .nan), .infinity)
}
func testAngleAxisEdgeCases() {
testAngleAxisEdgeCases(Float32.self)
testAngleAxisEdgeCases(Float64.self)
}
func testHalfAngleAndAxisOverflow<T: Real & SIMDScalar>(_ type: T.Type) {
let unscaled = Quaternion<T>(real: 1, imaginary: .one)
let scaled = Quaternion<T>(
real: .greatestFiniteMagnitude,
imaginary: SIMD3(repeating: .greatestFiniteMagnitude)
)
XCTAssertEqual(scaled.angle, unscaled.angle)
XCTAssertEqual(scaled.axis, unscaled.axis)
}
func testHalfAngleAndAxisOverflow() {
testHalfAngleAndAxisOverflow(Float32.self)
testHalfAngleAndAxisOverflow(Float64.self)
}
func testHalfAngleAndAxisUnderflow<T: Real & SIMDScalar>(_ type: T.Type) {
let unscaled = Quaternion<T>(real: 1, imaginary: .one)
let scaled = Quaternion<T>(
real: .leastNormalMagnitude,
imaginary: SIMD3(repeating: .leastNormalMagnitude)
)
XCTAssertEqual(scaled.angle, unscaled.angle)
XCTAssertEqual(scaled.axis, unscaled.axis)
}
func testHalfAngleAndAxisUnderflow() {
testHalfAngleAndAxisUnderflow(Float32.self)
testHalfAngleAndAxisUnderflow(Float64.self)
}
// MARK: Rotation Vector
func testRotationVector<T: Real & SIMDScalar>(_ type: T.Type) {
let vector = SIMD3<T>(0,-1,0) * .pi
XCTAssertEqual(Quaternion<T>(rotation: vector).rotationVector.x, .zero)
XCTAssertEqual(Quaternion<T>(rotation: vector).rotationVector.y, -.pi)
XCTAssertEqual(Quaternion<T>(rotation: vector).rotationVector.z, .zero)
XCTAssertEqual(Quaternion<T>(rotation: vector).axis, SIMD3(0,-1,0))
XCTAssertEqual(Quaternion<T>(rotation: vector).angle, .pi)
}
func testRotationVector() {
testRotationVector(Float32.self)
testRotationVector(Float64.self)
}
func testRotationVectorEdgeCases<T: Real & SIMDScalar>(_ type: T.Type) {
XCTAssertEqual(Quaternion<T>(rotation: .zero), .zero)
XCTAssertEqual(Quaternion<T>(rotation: .infinity), .infinity)
XCTAssertEqual(Quaternion<T>(rotation: -.infinity), .infinity)
XCTAssertTrue(Quaternion<T>(rotation: .nan).real.isNaN)
XCTAssertTrue(Quaternion<T>(rotation: .nan).imaginary.isNaN)
}
func testRotationVectorEdgeCases() {
testRotationVectorEdgeCases(Float32.self)
testRotationVectorEdgeCases(Float64.self)
}
// MARK: Polar Decomposition
func testPolarDecomposition<T: Real & SIMDScalar>(_ type: T.Type) {
let axis = SIMD3<T>(0,-1,0)
let q = Quaternion<T>(length: 5, halfAngle: .pi, axis: axis)
XCTAssertEqual(q.axis, axis)
XCTAssertEqual(q.angle, .pi * 2)
XCTAssertEqual(q.polar.length, 5)
XCTAssertEqual(q.polar.halfAngle, .pi)
XCTAssertEqual(q.polar.axis, axis)
}
func testPolarDecomposition() {
testPolarDecomposition(Float32.self)
testPolarDecomposition(Float64.self)
}
func testPolarDecompositionEdgeCases<T: Real & SIMDScalar>(_ type: T.Type) {
XCTAssertEqual(Quaternion<T>(length: .zero, halfAngle: .zero, axis: .zero), .zero)
XCTAssertEqual(Quaternion<T>(length: .zero, halfAngle: .infinity, axis: .infinity), .zero)
XCTAssertEqual(Quaternion<T>(length: .zero, halfAngle:-.infinity, axis:-.infinity), .zero)
XCTAssertEqual(Quaternion<T>(length: .zero, halfAngle: .nan, axis: .nan), .zero)
XCTAssertEqual(Quaternion<T>(length: .infinity, halfAngle: .zero, axis: .zero), .infinity)
XCTAssertEqual(Quaternion<T>(length: .infinity, halfAngle: .infinity, axis: .infinity), .infinity)
XCTAssertEqual(Quaternion<T>(length: .infinity, halfAngle:-.infinity, axis:-.infinity), .infinity)
XCTAssertEqual(Quaternion<T>(length: .infinity, halfAngle: .nan, axis: .infinity), .infinity)
XCTAssertEqual(Quaternion<T>(length:-.infinity, halfAngle: .zero, axis: .zero), .infinity)
XCTAssertEqual(Quaternion<T>(length:-.infinity, halfAngle: .infinity, axis: .infinity), .infinity)
XCTAssertEqual(Quaternion<T>(length:-.infinity, halfAngle:-.infinity, axis:-.infinity), .infinity)
XCTAssertEqual(Quaternion<T>(length:-.infinity, halfAngle: .nan, axis: .infinity), .infinity)
}
func testPolarDecompositionEdgeCases() {
testPolarDecompositionEdgeCases(Float32.self)
testPolarDecompositionEdgeCases(Float64.self)
}
// MARK: Act on Vector
func testActOnVector<T: Real & SIMDScalar>(_ type: T.Type) {
let vector = SIMD3<T>(1,1,1)
let xAxis = SIMD3<T>(1,0,0)
let singleAxis = Quaternion<T>(angle: .pi/2, axis: SIMD3(0, 1, 0))
XCTAssertTrue(singleAxis.act(on: xAxis).x.isApproximatelyEqual(
to: .zero, absoluteTolerance: T.ulpOfOne.squareRoot()
))
XCTAssertTrue(singleAxis.act(on: xAxis).y.isApproximatelyEqual(
to: .zero, absoluteTolerance: T.ulpOfOne.squareRoot()
))
XCTAssertEqual(singleAxis.act(on: xAxis).z, -1)
let piHalf = Quaternion<T>(angle: .pi/2, axis: xAxis)
XCTAssertTrue(closeEnough(piHalf.act(on: vector).x, 1, ulps: 0))
XCTAssertTrue(closeEnough(piHalf.act(on: vector).y, -1, ulps: 1))
XCTAssertTrue(closeEnough(piHalf.act(on: vector).z, 1, ulps: 1))
let pi = Quaternion<T>(angle: .pi, axis: xAxis)
XCTAssertTrue(closeEnough(pi.act(on: vector).x, 1, ulps: 0))
XCTAssertTrue(closeEnough(pi.act(on: vector).y, -1, ulps: 2))
XCTAssertTrue(closeEnough(pi.act(on: vector).z, -1, ulps: 2))
let twoPi = Quaternion<T>(angle: .pi * 2, axis: xAxis)
XCTAssertTrue(closeEnough(twoPi.act(on: vector).x, 1, ulps: 0))
XCTAssertTrue(closeEnough(twoPi.act(on: vector).y, 1, ulps: 3))
XCTAssertTrue(closeEnough(twoPi.act(on: vector).z, 1, ulps: 3))
}
func testActOnVector() {
testActOnVector(Float32.self)
testActOnVector(Float64.self)
}
func testActOnVectorRandom<T>(_ type: T.Type)
where T: Real, T: BinaryFloatingPoint, T: SIMDScalar,
T.Exponent: FixedWidthInteger, T.RawSignificand: FixedWidthInteger
{
// Generate random angles, axis and vector to test rotation properties
// - angle are selected from range -π to π
// - axis values are selected from -1 to 1; axis length is unity
// - vector values are selected from 10 to 10000
let inputs: [(angle: T, axis: SIMD3<T>, vector: SIMD3<T>)] = (0..<100).map { _ in
let angle = T.random(in: -.pi ... .pi)
var axis = SIMD3<T>.random(in: -1 ... 1)
axis /= .sqrt((axis * axis).sum()) // Normalize
var vector = SIMD3<T>.random(in: -1 ... 1)
vector /= .sqrt((vector * vector).sum()) // Normalize
vector *= T.random(in: 10 ... 10000) // Scale
return (angle, axis, vector)
}
for (angle, axis, vector) in inputs {
let q = Quaternion(angle: angle, axis: axis)
// The following equation in the form of v' = qvq⁻¹ is the mathmatical
// definition for how a quaternion rotates a vector (by promoting it to
// a quaternion) and goes "the full and long way" to calculate the
// rotation of vector by a quaternion. The result is used to test the
// rotation properties of "act(on:)"
let vrot = (q // q
* Quaternion(imaginary: vector) // v (pure quaternion)
* q.conjugate // q⁻¹ (as q is of unit length, q⁻¹ == q*)
).imaginary // the result is a pure quaternion with v' == imaginary
XCTAssertTrue(q.act(on: vector).x.isFinite)
XCTAssertTrue(q.act(on: vector).y.isFinite)
XCTAssertTrue(q.act(on: vector).z.isFinite)
// Test for sign equality on the components to see if the vector rotated
// to the correct quadrant and if the vector is of equal length, instead
// of testing component equality – as they are hard to compare with
// proper tolerance
XCTAssertEqual(q.act(on: vector).x.sign, vrot.x.sign)
XCTAssertEqual(q.act(on: vector).y.sign, vrot.y.sign)
XCTAssertEqual(q.act(on: vector).z.sign, vrot.z.sign)
XCTAssertTrue(closeEnough(q.act(on: vector).lengthSquared, vrot.lengthSquared, ulps: 16))
}
}
func testActOnVectorRandom() {
testActOnVectorRandom(Float32.self)
testActOnVectorRandom(Float64.self)
}
func testActOnVectorEdgeCase<T: Real & SIMDScalar>(_ type: T.Type) {
/// Test for zero, infinity
let q = Quaternion(angle: .pi, axis: SIMD3(1,0,0))
XCTAssertEqual(q.act(on: .zero), .zero)
XCTAssertEqual(q.act(on: -.zero), .zero)
XCTAssertEqual(q.act(on: .nan ), .infinity)
XCTAssertEqual(q.act(on: .infinity), .infinity)
XCTAssertEqual(q.act(on: -.infinity), .infinity)
}
func testActOnVectorEdgeCase() {
testActOnVectorEdgeCase(Float32.self)
testActOnVectorEdgeCase(Float64.self)
}
func testActOnVectorOverflow<T: Real & ExpressibleByFloatLiteral & SIMDScalar>(_ type: T.Type) {
// Create a vector (somewhat) close to greatestFiniteMagnitude on all lanes.
// We can not use greatestFiniteMagnitude here to test the careful rotation
// path, as we lose some precision in the process and it will overflow after
// rescaling the vector.
let scalar = T(
sign: .plus, exponent: T.greatestFiniteMagnitude.exponent,
significand: 1.999999
)
let closeToBounds = SIMD3<T>(repeating: scalar)
// An axis perpendicular to the vector, so all lanes change equally
let axis = SIMD3<T>(1,0,-1) / .sqrt(2)
// Perform a 180° rotation on all components
let pi = Quaternion(angle: .pi, axis: axis).act(on: closeToBounds)
// Must be finite after the rotation
XCTAssertTrue(pi.x.isFinite)
XCTAssertTrue(pi.y.isFinite)
XCTAssertTrue(pi.z.isFinite)
XCTAssertTrue(closeEnough(pi.x, -scalar, ulps: 4))
XCTAssertTrue(closeEnough(pi.y, -scalar, ulps: 4))
XCTAssertTrue(closeEnough(pi.z, -scalar, ulps: 4))
}
func testActOnVectorOverflow() {
testActOnVectorOverflow(Float32.self)
testActOnVectorOverflow(Float64.self)
}
func testActOnVectorUnderflow<T: Real & ExpressibleByFloatLiteral & SIMDScalar>(_ type: T.Type) {
let scalar = T.leastNormalMagnitude
let closeToZero = SIMD3<T>(repeating: scalar)
// An axis perpendicular to the vector, so all lanes change equally
let axis = SIMD3<T>(1,0,-1) / .sqrt(2)
// Perform a 180° rotation on all components
let pi = Quaternion(angle: .pi, axis: axis).act(on: closeToZero)
// Must be finite after the rotation
XCTAssertTrue(!pi.x.isZero)
XCTAssertTrue(!pi.y.isZero)
XCTAssertTrue(!pi.z.isZero)
XCTAssertTrue(closeEnough(pi.x, -scalar, ulps: 2))
XCTAssertTrue(closeEnough(pi.y, -scalar, ulps: 2))
XCTAssertTrue(closeEnough(pi.z, -scalar, ulps: 2))
}
func testActOnVectorUnderflow() {
testActOnVectorUnderflow(Float32.self)
testActOnVectorUnderflow(Float64.self)
}
}
// MARK: - Helper
extension SIMD3 where Scalar: FloatingPoint {
fileprivate var isNaN: Bool { x.isNaN && y.isNaN && z.isNaN }
}
// TODO: replace with approximately equals
func closeEnough<T: Real>(_ a: T, _ b: T, ulps allowed: T) -> Bool {
let scale = max(a.magnitude, b.magnitude, T.leastNormalMagnitude).ulp
return (a - b).magnitude <= allowed * scale
}