commit 8aab7a90f82dce2d45f88a5e5030b45dacef1865 Author: Steve (Numerics) Canon Date: Sat Jul 6 15:27:21 2019 -0400 Initial project setup for swift-numerics Two modules to begin with: - ElementaryFunctions - Complex Added README.md files describing each module very roughly, and a project README to describe goals and process. diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..504eed0 --- /dev/null +++ b/.gitignore @@ -0,0 +1,5 @@ +.DS_Store +/.build +/Packages +/*.xcodeproj +/.swiftpm diff --git a/LICENSE.txt b/LICENSE.txt new file mode 100644 index 0000000..61b0c78 --- /dev/null +++ b/LICENSE.txt @@ -0,0 +1,211 @@ + Apache License + Version 2.0, January 2004 + http://www.apache.org/licenses/ + + TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + + 1. Definitions. + + "License" shall mean the terms and conditions for use, reproduction, + and distribution as defined by Sections 1 through 9 of this document. + + "Licensor" shall mean the copyright owner or entity authorized by + the copyright owner that is granting the License. + + "Legal Entity" shall mean the union of the acting entity and all + other entities that control, are controlled by, or are under common + control with that entity. For the purposes of this definition, + "control" means (i) the power, direct or indirect, to cause the + direction or management of such entity, whether by contract or + otherwise, or (ii) ownership of fifty percent (50%) or more of the + outstanding shares, or (iii) beneficial ownership of such entity. + + "You" (or "Your") shall mean an individual or Legal Entity + exercising permissions granted by this License. + + "Source" form shall mean the preferred form for making modifications, + including but not limited to software source code, documentation + source, and configuration files. + + "Object" form shall mean any form resulting from mechanical + transformation or translation of a Source form, including but + not limited to compiled object code, generated documentation, + and conversions to other media types. + + "Work" shall mean the work of authorship, whether in Source or + Object form, made available under the License, as indicated by a + copyright notice that is included in or attached to the work + (an example is provided in the Appendix below). + + "Derivative Works" shall mean any work, whether in Source or Object + form, that is based on (or derived from) the Work and for which the + editorial revisions, annotations, elaborations, or other modifications + represent, as a whole, an original work of authorship. For the purposes + of this License, Derivative Works shall not include works that remain + separable from, or merely link (or bind by name) to the interfaces of, + the Work and Derivative Works thereof. + + "Contribution" shall mean any work of authorship, including + the original version of the Work and any modifications or additions + to that Work or Derivative Works thereof, that is intentionally + submitted to Licensor for inclusion in the Work by the copyright owner + or by an individual or Legal Entity authorized to submit on behalf of + the copyright owner. For the purposes of this definition, "submitted" + means any form of electronic, verbal, or written communication sent + to the Licensor or its representatives, including but not limited to + communication on electronic mailing lists, source code control systems, + and issue tracking systems that are managed by, or on behalf of, the + Licensor for the purpose of discussing and improving the Work, but + excluding communication that is conspicuously marked or otherwise + designated in writing by the copyright owner as "Not a Contribution." + + "Contributor" shall mean Licensor and any individual or Legal Entity + on behalf of whom a Contribution has been received by Licensor and + subsequently incorporated within the Work. + + 2. Grant of Copyright License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + copyright license to reproduce, prepare Derivative Works of, + publicly display, publicly perform, sublicense, and distribute the + Work and such Derivative Works in Source or Object form. + + 3. Grant of Patent License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + (except as stated in this section) patent license to make, have made, + use, offer to sell, sell, import, and otherwise transfer the Work, + where such license applies only to those patent claims licensable + by such Contributor that are necessarily infringed by their + Contribution(s) alone or by combination of their Contribution(s) + with the Work to which such Contribution(s) was submitted. If You + institute patent litigation against any entity (including a + cross-claim or counterclaim in a lawsuit) alleging that the Work + or a Contribution incorporated within the Work constitutes direct + or contributory patent infringement, then any patent licenses + granted to You under this License for that Work shall terminate + as of the date such litigation is filed. + + 4. Redistribution. You may reproduce and distribute copies of the + Work or Derivative Works thereof in any medium, with or without + modifications, and in Source or Object form, provided that You + meet the following conditions: + + (a) You must give any other recipients of the Work or + Derivative Works a copy of this License; and + + (b) You must cause any modified files to carry prominent notices + stating that You changed the files; and + + (c) You must retain, in the Source form of any Derivative Works + that You distribute, all copyright, patent, trademark, and + attribution notices from the Source form of the Work, + excluding those notices that do not pertain to any part of + the Derivative Works; and + + (d) If the Work includes a "NOTICE" text file as part of its + distribution, then any Derivative Works that You distribute must + include a readable copy of the attribution notices contained + within such NOTICE file, excluding those notices that do not + pertain to any part of the Derivative Works, in at least one + of the following places: within a NOTICE text file distributed + as part of the Derivative Works; within the Source form or + documentation, if provided along with the Derivative Works; or, + within a display generated by the Derivative Works, if and + wherever such third-party notices normally appear. The contents + of the NOTICE file are for informational purposes only and + do not modify the License. You may add Your own attribution + notices within Derivative Works that You distribute, alongside + or as an addendum to the NOTICE text from the Work, provided + that such additional attribution notices cannot be construed + as modifying the License. + + You may add Your own copyright statement to Your modifications and + may provide additional or different license terms and conditions + for use, reproduction, or distribution of Your modifications, or + for any such Derivative Works as a whole, provided Your use, + reproduction, and distribution of the Work otherwise complies with + the conditions stated in this License. + + 5. Submission of Contributions. Unless You explicitly state otherwise, + any Contribution intentionally submitted for inclusion in the Work + by You to the Licensor shall be under the terms and conditions of + this License, without any additional terms or conditions. + Notwithstanding the above, nothing herein shall supersede or modify + the terms of any separate license agreement you may have executed + with Licensor regarding such Contributions. + + 6. Trademarks. This License does not grant permission to use the trade + names, trademarks, service marks, or product names of the Licensor, + except as required for reasonable and customary use in describing the + origin of the Work and reproducing the content of the NOTICE file. + + 7. Disclaimer of Warranty. Unless required by applicable law or + agreed to in writing, Licensor provides the Work (and each + Contributor provides its Contributions) on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied, including, without limitation, any warranties or conditions + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A + PARTICULAR PURPOSE. You are solely responsible for determining the + appropriateness of using or redistributing the Work and assume any + risks associated with Your exercise of permissions under this License. + + 8. Limitation of Liability. In no event and under no legal theory, + whether in tort (including negligence), contract, or otherwise, + unless required by applicable law (such as deliberate and grossly + negligent acts) or agreed to in writing, shall any Contributor be + liable to You for damages, including any direct, indirect, special, + incidental, or consequential damages of any character arising as a + result of this License or out of the use or inability to use the + Work (including but not limited to damages for loss of goodwill, + work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses), even if such Contributor + has been advised of the possibility of such damages. + + 9. Accepting Warranty or Additional Liability. While redistributing + the Work or Derivative Works thereof, You may choose to offer, + and charge a fee for, acceptance of support, warranty, indemnity, + or other liability obligations and/or rights consistent with this + License. However, in accepting such obligations, You may act only + on Your own behalf and on Your sole responsibility, not on behalf + of any other Contributor, and only if You agree to indemnify, + defend, and hold each Contributor harmless for any liability + incurred by, or claims asserted against, such Contributor by reason + of your accepting any such warranty or additional liability. + + END OF TERMS AND CONDITIONS + + APPENDIX: How to apply the Apache License to your work. + + To apply the Apache License to your work, attach the following + boilerplate notice, with the fields enclosed by brackets "[]" + replaced with your own identifying information. (Don't include + the brackets!) The text should be enclosed in the appropriate + comment syntax for the file format. We also recommend that a + file or class name and description of purpose be included on the + same "printed page" as the copyright notice for easier + identification within third-party archives. + + Copyright [yyyy] [name of copyright owner] + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + + + +## Runtime Library Exception to the Apache 2.0 License: ## + + + As an exception, if you use this Software to compile your source code and + portions of this Software are embedded into the binary product as a result, + you may redistribute such product without providing attribution as would + otherwise be required by Sections 4(a), 4(b) and 4(d) of the License. diff --git a/Package.swift b/Package.swift new file mode 100644 index 0000000..7f009ac --- /dev/null +++ b/Package.swift @@ -0,0 +1,32 @@ +// swift-tools-version:5.0 +//===--- Package.swift ----------------------------------------*- swift -*-===// +// +// This source file is part of the Swift.org open source project +// +// Copyright (c) 2019 Apple Inc. and the Swift project authors +// Licensed under Apache License v2.0 with Runtime Library Exception +// +// See https://swift.org/LICENSE.txt for license information +// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors +// +//===----------------------------------------------------------------------===// + +import PackageDescription + +let package = Package( + name: "swift-numerics", + products: [ + .library(name: "Complex", targets: ["Complex"]), + .library(name: "ElementaryFunctions", targets: ["ElementaryFunctions"]), + ], + dependencies: [ + ], + targets: [ + .target(name: "Complex", dependencies: ["ElementaryFunctions"]), + .target(name: "ElementaryFunctions", dependencies: ["NumericsShims"]), + .target(name: "NumericsShims", dependencies: []), + + .testTarget(name: "ComplexTests", dependencies: ["Complex"]), + .testTarget(name: "ElementaryFunctionTests", dependencies: ["ElementaryFunctions"]), + ] +) diff --git a/README.md b/README.md new file mode 100644 index 0000000..67bf4bb --- /dev/null +++ b/README.md @@ -0,0 +1,62 @@ +# Swift-Numerics + +## Introduction +Swift-numerics provides a set of modules that support numerical computing in Swift. +These modules fall broadly in two categories: + +- API that is too specialized to go into the standard library, but which is sufficiently +general to be centralized in a single common package. +- API that is under active development toward possible future inclusion in the +standard library. + +There is some overlap between these two categories, and API that begins in the first +category may migrate to the second as it matures and new uses are discovered. + +Swift-numerics modules are fine-grained; if a user needs support for Complex numbers, +they can import the Complex module without pulling in a module for linear algebra as well. + +Swift-numerics modules have minimal dependencies on other projects. It assumes only +the availability of the Swift and C standard libraries, and the runtime support provided +by compiler-rt. Future expansion may assume the availability of other standard +interfaces such as BLAS and LAPACK, but modules with more specialized +dependencies probably belong in a separate package. + +## Process +Swift-numerics changes are not expected to go through swift-evolution. For some +modules, swift-numerics may act as a staging area for the standard library, but in +those cases, the expectation is that swift-evolution review will take place at the point +that the module is proposed for inclusion. It's good to keep that process in mind, +however, and document *why* you're making the decisions that you are, so that +reviewers can refer to those rationales when a module comes up for swift-evolution. + +Swift-numerics uses github issues to track bugs and features, and pull requests for +development. + +To propose a new module: +1. Raise an issue with the [new module] tag. +2. Raise a PR with an implementation sketch. +3. Once you have some consensus, ask an admin to create a feature branch against +which PRs can be raised. +4. When the design has stabilized and is functional enough to be useful, raise a PR +to merge the new module to master. + +To propose a new feature for an existing module: +1. Raise an issue with the [enhancement] tag. +2. Raise a PR with an implementation, and discuss the implementation there. +3. Once there is consensus that the new feature is desirable and the design is suitable, +it can be merged. + +To fix a bug, or make smaller improvements: +1. Raise a PR with your change. Be sure to add test coverage for whatever changes you are making. + +## Modules +1. [ElementaryFunctions](Sources/ElementaryFunctions/README.md) +2. [Complex](Sources/Complex/README.md) + +## Future expansion +1. [Approximate Equality](https://github.com/apple/swift-numerics/issues/3) +2. [Large Fixed-Width Integers](https://github.com/apple/swift-numerics/issues/4) +3. [Arbitrary-Precision Integers](https://github.com/apple/swift-numerics/issues/5) +4. [Shaped Arrays](https://github.com/apple/swift-numerics/issues/6) +4. [Decimal Floating-point](https://github.com/apple/swift-numerics/issues/7) +5. [Float16](https://github.com/apple/swift-numerics/issues/8) diff --git a/Sources/Complex/Arithmetic.swift b/Sources/Complex/Arithmetic.swift new file mode 100644 index 0000000..b3213b2 --- /dev/null +++ b/Sources/Complex/Arithmetic.swift @@ -0,0 +1,136 @@ +//===--- Arithmetic.swift -------------------------------------*- swift -*-===// +// +// This source file is part of the Swift.org open source project +// +// Copyright (c) 2019 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 +// +//===----------------------------------------------------------------------===// + +// MARK: - Additive structure +extension Complex: AdditiveArithmetic { + @_transparent + public static func +(z: Complex, w: Complex) -> Complex { + return Complex(z.x + w.x, z.y + w.y) + } + + @_transparent + public static func -(z: Complex, w: Complex) -> Complex { + return Complex(z.x - w.x, z.y - w.y) + } + + @_transparent + public static func +=(z: inout Complex, w: Complex) { + z = z + w + } + + @_transparent + public static func -=(z: inout Complex, w: Complex) { + z = z - w + } +} + +// MARK: - Vector space structure +// +// Policy: deliberately not using the * and / operators for these at the +// moment, because then there's an ambiguity in expressions like 2*z; is +// that Complex(2) * z or is it RealType(2) * z? This is especially +// problematic in type inference: suppose we have: +// +// let a: RealType = 1 +// let b = 2*a +// +// what is the type of b? If we don't have a type context, it's ambiguous. +// If we have a Complex type context, then b will be inferred to have type +// Complex! Obviously, that doesn't help anyone. +// +// TODO: figure out if there's some way to avoid these surprising results +// and turn these into operators if/when we have it. +// (https://github.com/apple/swift-numerics/issues/12) +extension Complex { + @inline(__always) @usableFromInline + internal func multiplied(by a: RealType) -> Complex { + Complex(x*a, y*a) + } + + @inline(__always) @usableFromInline + internal func divided(by a: RealType) -> Complex { + Complex(x/a, y/a) + } +} + +// MARK: - Multiplicative structure +extension Complex: Numeric { + @inlinable + public static func *(z: Complex, w: Complex) -> Complex { + return Complex(z.x*w.x - z.y*w.y, z.x*w.y + z.y*w.x) + } + + @inlinable + public static func /(z: Complex, w: Complex) -> Complex { + // Try the naive expression z/w = z*conj(w) / |w|^2; if the result is + // normal, then everything was fine, and we can simply return the result. + let naive = z * w.conjugate.divided(by: w.unsafeLengthSquared) + guard naive.isNormal else { return carefulDivide(z, w) } + return naive + } + + @inlinable + public static func *=(z: inout Complex, w: Complex) { + z = z * w + } + + @inlinable + public static func /=(z: inout Complex, w: Complex) { + z = z / w + } + + @usableFromInline + internal static func carefulDivide(_ z: Complex, _ w: Complex) -> Complex { + if z.isZero || !w.isFinite { return .zero } + let zScale = z.magnitude + let wScale = w.magnitude + let zNorm = z.divided(by: zScale) + let wNorm = w.divided(by: wScale) + let r = (zNorm * wNorm.conjugate).divided(by: wNorm.unsafeLengthSquared) + let rScale = r.magnitude + // At this point, the result is (r * zScale)/wScale computed without + // undue overflow or underflow. We know that r is close to unity, so + // the question is simply what order in which to do this computation + // to avoid spurious overflow or underflow. There are three options + // to choose from: + // + // - r * (zScale / wScale) + // - (r * zScale) / wScale + // - (r / wScale) * zScale + // + // The simplest case is when zScale / wScale is normal: + if (zScale / wScale).isNormal { + return r.multiplied(by: zScale / wScale) + } + // Otherwise, we need to compute either rNorm * zScale or rNorm / wScale + // first. Choose the first if the first scaling behaves well, otherwise + // choose the other one. + if (rScale * zScale).isNormal { + return r.multiplied(by: zScale).divided(by: wScale) + } + return r.divided(by: wScale).multiplied(by: zScale) + } + + /// A normalized complex number with the same phase as this value. + /// + /// If such a value cannot be produced (because the phase of zero and infinity is undefined), + /// `nil` is returned. + public var normalized: Complex? { + if length.isNormal { + return self.divided(by: length) + } + if isZero || !isFinite { + return nil + } + return self.divided(by: magnitude).normalized + } +} diff --git a/Sources/Complex/Complex.swift b/Sources/Complex/Complex.swift new file mode 100644 index 0000000..f30a35d --- /dev/null +++ b/Sources/Complex/Complex.swift @@ -0,0 +1,400 @@ +//===--- Complex.swift ----------------------------------------*- swift -*-===// +// +// This source file is part of the Swift.org open source project +// +// Copyright (c) 2019 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 +// +//===----------------------------------------------------------------------===// + +@_exported import ElementaryFunctions + +/// A complex number represented by real and imaginary parts. +/// +/// TODO: introductory text on complex numbers +/// +/// Implementation notes: +/// +/// Unlike C _Complex and C++ std::complex<> types, which attempt to define +/// meaningful fine-grained semantics for complex values with one or both +/// components infinite or nan, we simply treat all such values as a single +/// equivalence class. This simplifies defining multiplication and division +/// considerably, with almost no loss in expressive power. +@_fixed_layout +public struct Complex where RealType: Real { + /// The real part of this complex value. + @usableFromInline + internal var x: RealType + + /// The imaginary part of this complex value. + @usableFromInline + internal var y: RealType + + /// A complex number constructed by specifying the real and imaginary parts. + @inlinable + public init(_ real: RealType, _ imag: RealType) { + x = real + y = imag + } + + /// The real part of this complex value if it is a finite number, or `nan` if it is not. + public var real: RealType { + @inlinable + get { isFinite ? x : .nan } + } + + /// The imaginary part of this complex value if it is a finite number, or `nan` if it is not. + public var imag: RealType { + @inlinable + get { isFinite ? y : .nan } + } +} + +// MARK: - Additional Initializers +extension Complex { + /// The complex number with specified real part and zero imaginary part. + @inlinable + public init(_ real: RealType) { + self.init(real, 0) + } + + /// The complex number with specified imaginary part and zero real part. + @inlinable + public init(imag: RealType) { + self.init(0, imag) + } + + /// The complex number with specified real part and zero imaginary part. + @inlinable + public init(_ real: Other) { + self.init(RealType(real), 0) + } + + /// The complex number with specified real part and zero imaginary part, + /// if it can be constructed without rounding. + @inlinable + public init?(exactly real: Other) { + guard let real = RealType(exactly: real) else { return nil } + self.init(real, 0) + } + + public typealias IntegerLiteralType = Int + + @inlinable + public init(integerLiteral value: Int) { + self.init(RealType(value)) + } +} + +extension Complex where RealType: BinaryFloatingPoint { + /// `other` rounded to the nearest representable value of this type. + @inlinable + public init(_ other: Complex) { + self.init(RealType(other.x), RealType(other.y)) + } + + /// `other`, if it can be represented exactly in this type; otherwise `nil`. + @inlinable + public init?(exactly other: Complex) { + guard let real = RealType(exactly: other.x), + let imag = RealType(exactly: other.y) else { return nil } + self.init(real, imag) + } +} + +// MARK: - Conformance to Hashable and Equatable +// +// The Complex type identifies all non-finite points (waving hands slightly, +// we identify all NaNs and infinites as the point at infinity on the Riemann +// sphere). +extension Complex: Hashable { + @inlinable + public static func ==(a: Complex, b: Complex) -> Bool { + // Identify all numbers with either component non-finite as a single + // "point at infinity". + guard a.isFinite || b.isFinite else { return true } + // For finite numbers, equality is defined componentwise. Cases where + // only one of a or b is infinite fall through to here as well, but this + // expression correctly returns false for them so we don't need to handle + // them explicitly. + return a.x == b.x && a.y == b.y + } + + @inlinable + public func hash(into hasher: inout Hasher) { + // There are two equivalence classes to which we owe special attention: + // All zeros should hash to the same value, regardless of sign, and all + // non-finite numbers should hash to the same value, regardless of + // representation. The correct behavior for zero falls out for free from + // the hash behavior of floating-point, but we need to use a + // representative member for any non-finite values. + if isFinite { + hasher.combine(x) + hasher.combine(y) + } else { + hasher.combine(RealType.infinity) + } + } +} + +// MARK: - Conformance to Codable +// The synthesized conformance works correction for this protocol, unlike +// Hashable and Equatable; all we need to do is specify that we conform. +// FloatingPoint does not refine Codable, so this is a conditional conformance. +extension Complex: Codable where RealType: Codable { +} + +// MARK: - Formatting +extension Complex: CustomStringConvertible { + public var description: String { + guard isFinite else { + return "inf" + } + return "(\(x), \(y))" + } +} + +extension Complex: CustomDebugStringConvertible where RealType: CustomDebugStringConvertible { + public var debugDescription: String { + "Complex<\(RealType.self)>(\(x.debugDescription), \(y.debugDescription))" + } +} + +// MARK: - Basic properties +extension Complex { + @inlinable + public static var zero: Complex { + Complex(0, 0) + } + + @inlinable + public static var one: Complex { + Complex(1, 0) + } + + /// The imaginary unit. + /// + /// See also: + /// - + /// - .zero + /// - .one + /// - .infinity + @inlinable + public static var i: Complex { + Complex(0, 1) + } + + /// A value representing the point at infinity. + @inlinable + public static var infinity: Complex { + Complex(.infinity, 0) + } + + /// The complex conjugate of this value. + @inlinable + public var conjugate: Complex { + Complex(x, -y) + } + + /// True if this value is finite. + /// + /// A complex value is finite if neither component is an infinity or nan. + /// + /// See also: + /// - + /// - `.isNormal` + /// - `.isSubnormal` + /// - `.isZero` + @inlinable + public var isFinite: Bool { + x.isFinite && y.isFinite + } + + /// True if this value is normal. + /// + /// A complex number is normal if it is finite and *either* the real or imaginary component is 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` + @inlinable + public var isNormal: Bool { + isFinite && (x.isNormal || y.isNormal) + } + + /// True if this value is subnormal. + /// + /// A complex number is subnormal if it is finite, not normal, and not zero. When the result of a + /// computation is subnormal, underflow has occured and the result generally does not have full + /// precision. + /// See also: + /// - + /// - `.isFinite` + /// - `.isNormal` + /// - `.isZero` + @inlinable + public var isSubnormal: Bool { + isFinite && !isNormal && !isZero + } + + /// True if this value is zero. + /// + /// A complex number is zero if *both* the real and imaginary components are zero. + /// + /// See also: + /// - + /// - `.isFinite` + /// - `.isNormal` + /// - `.isSubnormal` + @inlinable + public var isZero: Bool { + x == 0 && y == 0 + } + + /// The ∞-norm of the value (`max(abs(real), abs(imag))`). + /// + /// If you need the euclidean norm (a.k.a. 2-norm) use the `length` or `unsafeLengthSquared` + /// properties instead. + /// + /// Edge cases: + /// - + /// If a complex value is not finite, `.magnitude` is `infinity`. + /// + /// See also: + /// - + /// - `.length` + /// - `.unsafeLengthSquared` + @inlinable + public var magnitude: RealType { + guard isFinite else { return .infinity } + return max(abs(x), abs(y)) + } +} + +// MARK: - Operations for working with polar form +extension Complex { + + /// The euclidean norm (a.k.a. 2-norm, `sqrt(real*real + imag*imag)`). + /// + /// This property takes care to avoid spurious over- or underflow in this computation. For example: + /// + /// let x: Float = 3.0e+20 + /// let x: Float = 4.0e+20 + /// let naive = sqrt(x*x + y*y) // +Inf + /// let careful = Complex(x, y).length // 5.0e+20 + /// + /// Note that it *is* still possible for this property to overflow, because the length can be as much + /// as sqrt(2) times larger than either component, and thus may not be representable in the real type. + /// + /// For most use cases, you can use the cheaper `.magnitude` property (which computes the + /// ∞-norm) instead, which always produces a representable result. + /// + /// Edge cases: + /// - + /// If a complex value is not finite, its `.length` is `infinity`. + /// + /// See also: + /// - + /// - `.magnitude` + /// - `.unsafeLengthSquared` + /// - `.phase` + /// - `.polar` + /// - `init(r:θ:)` + @inlinable + public var length: RealType { + let naive = unsafeLengthSquared + guard naive.isNormal else { return carefulLength } + return .sqrt(naive) + } + + @usableFromInline + internal var carefulLength: RealType { + guard isFinite else { return .infinity } + return .hypot(x, y) + } + + /// The squared length `(real*real + imag*imag)`. + /// + /// This property is more efficient to compute than `length`, but is prone to overflow or underflow; + /// for finite values that are not well-scaled, `unsafeLengthSquared` is often either zero or + /// infinity, even when `length` is a finite number. Use this property only when you are certain that + /// this value is well-scaled. + /// + /// For many cases, `.magnitude` can be used instead, which is also cheap to compute and always + /// returns a representable value. + /// + /// See also: + /// - + /// - `.length` + /// - `.magnitude` + @inlinable + public var unsafeLengthSquared: RealType { + x*x + y*y + } + + /// The phase (angle, or "argument"). + /// + /// Returns the angle (measured above the real axis) in radians. If the complex value is zero + /// or infinity, the phase is not defined, and `nan` is returned. + /// + /// Edge cases: + /// - + /// If the complex value is zero or non-finite, phase is `nan`. + /// + /// See also: + /// - + /// - `.length` + /// - `.polar` + /// - `init(r:θ:)` + @inlinable + public var phase: RealType { + guard isFinite && !isZero else { return .nan } + return .atan2(y: y, x: x) + } + + /// The length and phase (or polar coordinates) of this value. + /// + /// Edge cases: + /// - + /// If the complex value is zero or non-finite, phase is `.nan`. If the complex value is non-finite, + /// the length is `.infinity`. + /// + /// See also: + /// - + /// - `.length` + /// - `.phase` + /// - `init(r:θ:)` + public var polar: (length: RealType, phase: RealType) { + (length, phase) + } + + /// Constructs a complex value from polar coordinates. + /// + /// Edge cases: + /// - + /// If the phase is non-finite, but length is finite, this initializer fails and returns nil. In all other cases, + /// a non-nil value is constructed. + /// + /// See also: + /// - + /// - `.length` + /// - `.phase` + /// - `.polar` + public init?(length: RealType, phase: RealType) { + guard phase.isFinite else { + // There's no way to make sense of finite magnitude and non-finite phase. + if length.isFinite { return nil } + // r is infinite so phase doesn't matter. + self = .infinity + return + } + self.init(length * .cos(phase), length * .sin(phase)) + } +} diff --git a/Sources/Complex/README.md b/Sources/Complex/README.md new file mode 100644 index 0000000..bcf9c0d --- /dev/null +++ b/Sources/Complex/README.md @@ -0,0 +1,82 @@ +# Complex Numbers + +This module provides a `Complex` number type generic over an underlying `RealType`: +```swift +1> import Complex +2> let z = Complex(1,1) // z = 1 + i +``` +This module provides approximate feature parity and memory layout compatibility with C, +Fortran, and C++ complex types (although the importer cannot map the types for you, +buffers may be reinterpreted to shim API defined in other languages). + +The usual arithmetic operators are provided for Complex numbers, as well as +conversion to and from polar coordinates and many useful properties, plus +conformances to the obvious usual protocols: `Equatable`, `Hashable`, `Codable` +(if the underlying `RealType` is), and `Numeric` (hence `AdditiveArithmetic`). + +### Dependencies: +- The `ElementaryFunctions` module. + +## Design notes + +### Mixed real-complex arithmetic. +It is tempting to define real-complex arithmetic operators, because we use them as +shorthand all the time in mathematics: `z + x` or `2w`. They are not provided by the +Complex module for two reasons: +- Swift generally avoids heterogenous arithmetic operators +- They lead to counter-intuitive behavior of type inference. +For a concrete example of the second point, suppose that heterogeneous arithmetic +operators existed, and consider the following snippet: +```swift +let a: RealType = 1 +let b = 2*a +``` +what is the type of `b`? + +If there is no type context, `b` is ambiguous; `2*a` could be interpreted as +`Complex(2)*a` or as `RealType(2)*a`. That's fairly annoying on its own. However, +suppose that we're in a `Complex` type context: +```swift +extension Complex { + static func doSomething() { + let a: RealType = 1 + let b = 2*a // type is inferred as Complex 🤪 + } +} +``` +This is a show-stopper for heterogeneous arithmetic operators in the short term. + +### Infinity and nan +C and C++ attempt to define precise semantics that interpret the sign of infinity and zero. +This is occasionally useful, but it also results in a lot of extra work. The swift-numerics +`Complex` type does not assign any semantic meaning to the sign of zero and infinity; +`(±0,±0)`, are all considered to be encodings of the value zero. Similarly, `(±inf, y)`, +`(x, ±inf)`, `(nan, y)` and `(x, nan)` are all considered to be encodings of a single +exceptional value with infinite magnitude and undefined phase. + +Because the phase is undefined, the `.real` and `.imag` properties return `.nan` + +This decision may be revisited once users gain some experience working with the type +to make sure that it's a tradeoff that we're happy with, but early experiments show that +it greatly simplifies the implementation of some operations without significant tradeoffs +in usability. + +### The magnitude property +The `Numeric` protocol requires a `.magnitude` property, but (deliberately) does not +fully specify the semantics. The most obvious choice would be to use the Euclidean +norm (`sqrt(real*real + imag*imag)`). However, in practice there are good reasons +to use something else instead: + +- The two-norm requires special care to avoid spurious overflow/underflow, but the +naive expressions for the 1-norm or ∞-norm are always correct. +- Even when care is used, near the overflow boundary the two-norm may not be +representable. The ∞-norm in particular is always representable (because of this, +the ∞-norm would seem to be the obvious alternative; it gives the nicest API surface). +- Both the 1-norm and ∞-norm are much easier to compute for operators than the +2-norm (O(n) vs. "no closed form expression, but usually O(n^3) iterative methods"), +so it would be nice to establish a precedent of .magnitude binding one of these +cheaper-to-compute norms. + +The 2-norm still needs to be available, of course, because sometimes you need it. +Presently, this functionality is accessed via the `.length` and `.unsafeLengthSquared` +properties, but I expect that we will end up iterating on this aspect of the design. diff --git a/Sources/ElementaryFunctions/ElementaryFunctions.swift b/Sources/ElementaryFunctions/ElementaryFunctions.swift new file mode 100644 index 0000000..a60a3ad --- /dev/null +++ b/Sources/ElementaryFunctions/ElementaryFunctions.swift @@ -0,0 +1,414 @@ +//===--- ElementaryFunctions.swift ----------------------------*- swift -*-===// +// +// This source file is part of the Swift.org open source project +// +// Copyright (c) 2019 Apple Inc. and the Swift project authors +// Licensed under Apache License v2.0 with Runtime Library Exception +// +// See https://swift.org/LICENSE.txt for license information +// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors +// +//===----------------------------------------------------------------------===// + +/// A type that has elementary functions available. +/// +/// An ["elementary function"][elfn] is a function built up from powers, roots, +/// exponentials, logarithms, trigonometric functions (sin, cos, tan) and +/// their inverses, and the hyperbolic functions (sinh, cosh, tanh) and their +/// inverses. +/// +/// Conformance to this protocol means that all of these building blocks are +/// available as static functions on the type. +/// +/// ```swift +/// let x: Float = 1 +/// let y = Float.sin(x) // 0.84147096 +/// ``` +/// +/// There are three broad families of functions defined by `ElementaryFunctions`: +/// - Exponential, trigonometric, and hyperbolic functions: +/// `exp`, `expm1`, `cos`, `sin`, `tan`, `cosh`, `sinh`, and `tanh`. +/// - Logarithmic, inverse trigonometric, and inverse hyperbolic functions: +/// `log`, `log1p`, `acos`, `asin`, `atan`, `acosh`, `asinh`, and `atanh`. +/// - Power and root functions: +/// `pow`, `sqrt`, and `root`. +/// +/// There is a second protocol, `RealFunctions`, which refines `ElementaryFunctions` +/// and includes additional operations which are more commonly used specifically with real +/// number types. +/// +/// See Also: +/// - +/// - `RealFunctions` +/// +/// [elfn]: http://en.wikipedia.org/wiki/Elementary_function +public protocol ElementaryFunctions { + /// The [exponential function][wiki] e^x whose base `e` is the base of the natural logarithm. + /// + /// See also: + /// - + /// - `expm1()` + /// - `exp2()` (for types conforming to `RealFunctions`) + /// - `exp10()` (for types conforming to `RealFunctions`) + /// + /// [wiki]: https://en.wikipedia.org/wiki/Exponential_function + static func exp(_ x: Self) -> Self + + /// exp(x) - 1, computed in such a way as to maintain accuracy for small x. + /// + /// When `x` is close to zero, the expression `.exp(x) - 1` suffers from catastrophic + /// cancellation and the result will not have full accuracy. The `.expm1(x)` function gives + /// you a means to address this problem. + /// + /// As an example, consider the expression `(x + 1)*exp(x) - 1`. When `x` is smaller + /// than `.ulpOfOne`, this expression evaluates to `0.0`, when it should actually round to + /// `2*x`. We can get a full-accuracy result by using the following instead: + /// ``` + /// let expm1x = .expm1(x) + /// return x*(expm1x + 1) + expm1x + /// ``` + /// This re-written expression delivers an accurate result for all values of `x`, not just for + /// small values. + /// + /// See also: + /// - + /// - `exp()` + /// - `exp2()` (for types conforming to `RealFunctions`) + /// - `exp10()` (for types conforming to `RealFunctions`) + static func expm1(_ x: Self) -> Self + + /// The [hyperbolic cosine][wiki] of `x`. + /// ``` + /// e^x + e^-x + /// cosh(x) = ------------ + /// 2 + /// ``` + /// + /// See also: + /// - + /// - `sinh()` + /// - `tanh()` + /// - `acosh()` + /// + /// [wiki]: https://en.wikipedia.org/wiki/Hyperbolic_function + static func cosh(_ x: Self) -> Self + + /// The [hyperbolic sine][wiki] of `x`. + /// ``` + /// e^x - e^-x + /// sinh(x) = ------------ + /// 2 + /// ``` + /// + /// See also: + /// - + /// - `cosh()` + /// - `tanh()` + /// - `asinh()` + /// + /// [wiki]: https://en.wikipedia.org/wiki/Hyperbolic_function + static func sinh(_ x: Self) -> Self + + /// The [hyperbolic tangent][wiki] of `x`. + /// ``` + /// sinh(x) + /// tanh(x) = --------- + /// cosh(x) + /// ``` + /// + /// See also: + /// - + /// - `cosh()` + /// - `sinhh()` + /// - `atanh()` + /// + /// [wiki]: https://en.wikipedia.org/wiki/Hyperbolic_function + static func tanh(_ x: Self) -> Self + + /// The [cosine][wiki] of `x`. + /// + /// For real types, `x` may be interpreted as an angle measured in radians. + /// + /// See also: + /// - + /// - `sin()` + /// - `tan()` + /// - `acos()` + /// + /// [wiki]: https://en.wikipedia.org/wiki/Cosine + static func cos(_ x: Self) -> Self + + + /// The [sine][wiki] of `x`. + /// + /// For real types, `x` may be interpreted as an angle measured in radians. + /// + /// See also: + /// - + /// - `cos()` + /// - `tan()` + /// - `asin()` + /// + /// [wiki]: https://en.wikipedia.org/wiki/Sine + static func sin(_ x: Self) -> Self + + /// The [tangent][wiki] of `x`. + /// + /// For real types, `x` may be interpreted as an angle measured in radians. + /// + /// See also: + /// - + /// - `cos()` + /// - `sin()` + /// - `atan()` + /// - `atan2(y:x:)` (for types conforming to `RealFunctions`) + /// ``` + /// sin(x) + /// tan(x) = -------- + /// cos(x) + /// ``` + /// [wiki]: https://en.wikipedia.org/wiki/Tangent + static func tan(_ x: Self) -> Self + + /// The [natural logarithm][wiki] of `x`. + /// + /// See also: + /// - + /// - `log1p()` + /// - `log2()` (for types conforming to `RealFunctions`) + /// - `log10()` (for types conforming to `RealFunctions`) + /// + /// [wiki]: https://en.wikipedia.org/wiki/Logarithm + static func log(_ x: Self) -> Self + + /// log(1 + x), computed in such a way as to maintain accuracy for small x. + /// + /// See also: + /// - + /// - `log()` + /// - `log2()` (for types conforming to `RealFunctions`) + /// - `log10()` (for types conforming to `RealFunctions`) + static func log1p(_ x: Self) -> Self + + /// The [inverse hyperbolic cosine][wiki] of `x`. + /// ``` + /// cosh(acosh(x)) ≅ x + /// ``` + /// See also: + /// - + /// - `asinh()` + /// - `atanh()` + /// - `cosh()` + /// + /// [wiki]: https://en.wikipedia.org/wiki/Inverse_hyperbolic_function + static func acosh(_ x: Self) -> Self + + /// The [inverse hyperbolic sine][wiki] of `x`. + /// ``` + /// sinh(asinh(x)) ≅ x + /// ``` + /// See also: + /// - + /// - `acosh()` + /// - `atanh()` + /// - `sinh()` + /// + /// [wiki]: https://en.wikipedia.org/wiki/Inverse_hyperbolic_function + static func asinh(_ x: Self) -> Self + + /// The [inverse hyperbolic tangent][wiki] of `x`. + /// ``` + /// tanh(atanh(x)) ≅ x + /// ``` + /// See also: + /// - + /// - `acosh()` + /// - `asinh()` + /// - `tanh()` + /// + /// [wiki]: https://en.wikipedia.org/wiki/Inverse_hyperbolic_function + static func atanh(_ x: Self) -> Self + + /// The [arccosine][wiki] (inverse cosine) of `x`. + /// + /// For real types, the result may be interpreted as an angle measured in radians. + /// ``` + /// cos(acos(x)) ≅ x + /// ``` + /// See also: + /// - + /// - `asin()` + /// - `atan()` + /// - `cos()` + /// + /// [wiki]: https://en.wikipedia.org/wiki/Inverse_trigonometric_functions + static func acos(_ x: Self) -> Self + + /// The [arcsine][wiki] (inverse sine) of `x`. + /// + /// For real types, the result may be interpreted as an angle measured in radians. + /// ``` + /// sin(asin(x)) ≅ x + /// ``` + /// See also: + /// - + /// - `acos()` + /// - `atan()` + /// - `sin()` + /// + /// [wiki]: https://en.wikipedia.org/wiki/Inverse_trigonometric_functions + static func asin(_ x: Self) -> Self + + /// The [arctangent][wiki] (inverse tangent) of `x`. + /// + /// For real types, the result may be interpreted as an angle measured in radians. + /// ``` + /// tan(atan(x)) ≅ x + /// ``` + /// See also: + /// - + /// - `acos()` + /// - `asin()` + /// - `atan2()` (for types conforming to `RealFunctions`) + /// - `tan()` + /// + /// [wiki]: https://en.wikipedia.org/wiki/Inverse_trigonometric_functions + static func atan(_ x: Self) -> Self + + /// exp(y * log(x)) computed with additional internal precision. + /// + /// See also: + /// - + /// - `sqrt()` + /// - `root()` + /// + static func pow(_ x: Self, _ y: Self) -> Self + + /// `x` raised to the nth power. + /// + /// See also: + /// - + /// - `sqrt()` + /// - `root()` + /// + static func pow(_ x: Self, _ n: Int) -> Self + + /// The [square root][wiki] of `x`. + /// + /// See also: + /// - + /// - `pow()` + /// - `root()` + /// + /// [wiki]: https://en.wikipedia.org/wiki/Square_root + static func sqrt(_ x: Self) -> Self + + /// The nth root of `x`. + /// + /// See also: + /// - + /// - `pow()` + /// - `sqrt()` + /// + static func root(_ x: Self, _ n: Int) -> Self +} + +public protocol RealFunctions: ElementaryFunctions { + /// `atan(y/x)`, with sign selected according to the quadrant of `(x, y)`. + /// + /// See also: + /// - + /// - `atan()` + static func atan2(y: Self, x: Self) -> Self + + /// The error function evaluated at `x`. + /// + /// See also: + /// - + /// - `erfc()` + static func erf(_ x: Self) -> Self + + /// The complimentary error function evaluated at `x`. + /// + /// See also: + /// - + /// - `erf()` + static func erfc(_ x: Self) -> Self + + /// 2^x + /// + /// See also: + /// - + /// - `exp()` + /// - `expm1()` + /// - `exp10()` + /// - `log2()` + /// - `pow()` + static func exp2(_ x: Self) -> Self + + /// 10^x + /// + /// See also: + /// - + /// - `exp()` + /// - `expm1()` + /// - `exp2()` + /// - `log10()` + /// - `pow()` + static func exp10(_ x: Self) -> Self + + /// `sqrt(x*x + y*y)`, computed in a manner that avoids spurious overflow or underflow. + static func hypot(_ x: Self, _ y: Self) -> Self + + /// The gamma function Γ(x). + /// + /// See also: + /// - + /// - `logGamma()` + /// - `signGamma()` + static func gamma(_ x: Self) -> Self + + /// The base-2 logarithm of `x`. + /// + /// See also: + /// - + /// - `exp2()` + /// - `log()` + /// - `log1p()` + /// - `log10()` + static func log2(_ x: Self) -> Self + + /// The base-10 logarithm of `x`. + /// + /// See also: + /// - + /// - `exp10()` + /// - `log()` + /// - `log1p()` + /// - `log2()` + static func log10(_ x: Self) -> Self + + /// The logarithm of the absolute value of the gamma function, log(|Γ(x)|). + /// + /// See also: + /// - + /// - `gamma()` + /// - `signGamma()` + static func logGamma(_ x: Self) -> Self +} + +/// A type that models the real numbers. +/// +/// Types conforming to this protocol provide the arithmetic and utility operations defined by +/// the `FloatingPoint` protocol, and provide all of the math functions defined by the +/// `ElementaryFunctions` and `RealFunctions` protocols. This protocol does not +/// add any additional conformances itself, but is very useful as a protocol against which to +/// write generic code. For example, we can naturally write a generic version of the a sigmoid +/// function: +/// ``` +/// func sigmoid(_ x: T) -> T { +/// return 1/(1 + .exp(-x)) +/// } +/// ``` +public protocol Real: FloatingPoint, RealFunctions { +} diff --git a/Sources/ElementaryFunctions/Implementations.swift b/Sources/ElementaryFunctions/Implementations.swift new file mode 100644 index 0000000..2b890eb --- /dev/null +++ b/Sources/ElementaryFunctions/Implementations.swift @@ -0,0 +1,83 @@ +//===--- Implementations.swift --------------------------------*- swift -*-===// +// +// This source file is part of the Swift.org open source project +// +// Copyright (c) 2019 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 +// +//===----------------------------------------------------------------------===// + +// While `Real` does not provide any additional customization points, +// it does allow us to default the implementation of a few operations, +// and also provides `signGamma`. +extension Real { + // Most math libraries do not provide exp10, so we need a default impl. + @_transparent + public static func exp10(_ x: Self) -> Self { + return pow(10, x) + } + + @_transparent + public static func root(_ x: Self, _ n: Int) -> Self { + guard x >= 0 || n % 2 != 0 else { return .nan } + // TODO: this implementation is not quite correct, because n may be + // rounded in conversion to Self. This only effects very extreme cases, + // so we'll leave it alone for now. + return Self(signOf: x, magnitudeOf: pow(x.magnitude, 1/Self(n))) + } + + /// The sign of the gamma function, Γ(x). + /// + /// For `x >= 0`, `signGamma(x)` is `.plus`. For negative `x`, `signGamma(x)` is `.plus` + /// when `x` is an integer, and otherwise it is `.minus` whenver `trunc(x)` is even, and `.plus` + /// when `trunc(x)` is odd. + /// + /// This function is mainly used together with `logGamma`, which computes the logarithm of the + /// absolute value of Γ(x), to recover the sign information. + /// + /// See also: + /// - + /// - `gamma()` + /// - `logGamma()` + public static func signGamma(_ x: Self) -> FloatingPointSign { + // Gamma is strictly positive for x >= 0. + if x >= 0 { return .plus } + // For negative x, we arbitrarily choose to assign a sign of .plus to the + // poles. + let trunc = x.rounded(.towardZero) + if x == trunc { return .plus } + // Otherwise, signGamma is .minus if the integral part of x is even. + return trunc.isEven ? .minus : .plus + } + + // Determines if this value is even, assuming that it is an integer. + @inline(__always) + private var isEven: Bool { + if Self.radix == 2 { + // For binary types, we can just check if x/2 is an integer. This works + // because x/2 is always computed exactly. + let half = self/2 + return half == half.rounded(.towardZero) + } else { + // For decimal types, it's not quite that simple, because x/2 is not + // necessarily computed exactly. As an example, suppose that we had a + // decimal type with a one digit significand, and self = 7. Then self/2 + // would round to 4, and we would (wrongly) conclude that it was an + // integer, and hence that self was even. + // + // Instead, for decimal types, we check if 2*trunc(self/2) == self, + // using an FMA; this is always correct; this approach works for any + // radix, but the previous method is more efficient for radix == 2. + let half = self/2 + return self.addingProduct(-2, half.rounded(.towardZero)) == 0 + } + } + + @_transparent + public static func sqrt(_ x: Self) -> Self { + return x.squareRoot() + } +} diff --git a/Sources/ElementaryFunctions/README.md b/Sources/ElementaryFunctions/README.md new file mode 100644 index 0000000..7c30719 --- /dev/null +++ b/Sources/ElementaryFunctions/README.md @@ -0,0 +1,31 @@ +# Elementary Functions + +This module implements [SE-0246]. It is being implemented here first to work around a +few difficulties that blocked adding these operations to the standard library for 5.1: + +- Swift does not yet have a way to back-deploy protocol conformances; this prevents +making this useful feature available on older Apple OS targets. + +- The lack of means to back-deploy prevents obsoleting the existing concrete +math functions defined in the Darwin (Apple platforms), Glibc (Linux), and MSVCRT +(Windows) modules. + +- There is an outstanding bug with name resolution, which causes the new static functions +(`Float.sin`) to shadow the existing free functions (`sin(_ x: Float) -> Float`) even +in contexts where static functions are not allowed, leading to a number of spurious errors. +See https://github.com/apple/swift/pull/25316 for discussion of how to fix this. + +- There are some typechecker performance regressions (partially resulting from the issues +described above). + +Placing this module in swift-numerics first gives the community a chance to address +some of the compiler limitations that this feature ran into *before* it lands in the standard +library (avoiding unnecessary source churn for projects that use these features), while also +making it available *now*, including back-deployment to older Apple OS targets. + +Further details can be found in the [SE-0246 proposal document][SE-0246]. + +[SE-0246]: https://github.com/apple/swift-evolution/blob/master/proposals/0246-mathable.md + +### Dependencies: +- The C standard math library (`libm`) via the `NumericShims` target. diff --git a/Sources/ElementaryFunctions/ScalarConformances.swift b/Sources/ElementaryFunctions/ScalarConformances.swift new file mode 100644 index 0000000..4bc3938 --- /dev/null +++ b/Sources/ElementaryFunctions/ScalarConformances.swift @@ -0,0 +1,138 @@ +//===--- ScalarConformances.swift -----------------------------*- swift -*-===// +// +// This source file is part of the Swift.org open source project +// +// Copyright (c) 2019 Apple Inc. and the Swift project authors +// Licensed under Apache License v2.0 with Runtime Library Exception +// +// See https://swift.org/LICENSE.txt for license information +// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors +// +//===----------------------------------------------------------------------===// + +import NumericsShims + +extension Float: Real { + @_transparent public static func cos(_ x: Float) -> Float { return swift_cosf(x) } + @_transparent public static func sin(_ x: Float) -> Float { return swift_sinf(x) } + @_transparent public static func tan(_ x: Float) -> Float { return swift_tanf(x) } + @_transparent public static func acos(_ x: Float) -> Float { return swift_acosf(x) } + @_transparent public static func asin(_ x: Float) -> Float { return swift_asinf(x) } + @_transparent public static func atan(_ x: Float) -> Float { return swift_atanf(x) } + @_transparent public static func cosh(_ x: Float) -> Float { return swift_coshf(x) } + @_transparent public static func sinh(_ x: Float) -> Float { return swift_sinhf(x) } + @_transparent public static func tanh(_ x: Float) -> Float { return swift_tanhf(x) } + @_transparent public static func acosh(_ x: Float) -> Float { return swift_acoshf(x) } + @_transparent public static func asinh(_ x: Float) -> Float { return swift_asinhf(x) } + @_transparent public static func atanh(_ x: Float) -> Float { return swift_atanhf(x) } + @_transparent public static func exp(_ x: Float) -> Float { return swift_expf(x) } + @_transparent public static func expm1(_ x: Float) -> Float { return swift_expm1f(x) } + @_transparent public static func log(_ x: Float) -> Float { return swift_logf(x) } + @_transparent public static func log1p(_ x: Float) -> Float { return swift_log1pf(x) } + @_transparent public static func pow(_ x: Float, _ y: Float) -> Float { + guard x >= 0 else { return .nan } + return swift_powf(x, y) + } + @_transparent public static func pow(_ x: Float, _ n: Int) -> Float { + // TODO: this implementation is not quite correct, because n may be + // rounded in conversion to Float. This only effects very extreme cases, + // so we'll leave it alone for now; however, it gets the sign wrong if + // it rounds an odd number to an even number, so we should fix it soon. + return swift_powf(x, Float(n)) + } + @_transparent public static func atan2(y: Float, x: Float) -> Float { return swift_atan2f(y, x) } + @_transparent public static func erf(_ x: Float) -> Float { return swift_erff(x) } + @_transparent public static func erfc(_ x: Float) -> Float { return swift_erfcf(x) } + @_transparent public static func exp2(_ x: Float) -> Float { return swift_exp2f(x) } + #if os(macOS) || os(iOS) || os(tvOS) || os(watchOS) + @_silgen_name("__exp10f") public static func exp10(_ x: Float) -> Float + #endif + @_transparent public static func hypot(_ x: Float, _ y: Float) -> Float { return swift_hypotf(x, y) } + @_transparent public static func gamma(_ x: Float) -> Float { return swift_gammaf(x) } + @_transparent public static func log2(_ x: Float) -> Float { return swift_log2f(x) } + @_transparent public static func log10(_ x: Float) -> Float { return swift_log10f(x) } + #if !os(Windows) + @_transparent public static func logGamma(_ x: Float) -> Float { return swift_lgammaf(x) } + #endif +} + +extension Double: Real { + @_transparent public static func cos(_ x: Double) -> Double { return swift_cos(x) } + @_transparent public static func sin(_ x: Double) -> Double { return swift_sin(x) } + @_transparent public static func tan(_ x: Double) -> Double { return swift_tan(x) } + @_transparent public static func acos(_ x: Double) -> Double { return swift_acos(x) } + @_transparent public static func asin(_ x: Double) -> Double { return swift_asin(x) } + @_transparent public static func atan(_ x: Double) -> Double { return swift_atan(x) } + @_transparent public static func cosh(_ x: Double) -> Double { return swift_cosh(x) } + @_transparent public static func sinh(_ x: Double) -> Double { return swift_sinh(x) } + @_transparent public static func tanh(_ x: Double) -> Double { return swift_tanh(x) } + @_transparent public static func acosh(_ x: Double) -> Double { return swift_acosh(x) } + @_transparent public static func asinh(_ x: Double) -> Double { return swift_asinh(x) } + @_transparent public static func atanh(_ x: Double) -> Double { return swift_atanh(x) } + @_transparent public static func exp(_ x: Double) -> Double { return swift_exp(x) } + @_transparent public static func expm1(_ x: Double) -> Double { return swift_expm1(x) } + @_transparent public static func log(_ x: Double) -> Double { return swift_log(x) } + @_transparent public static func log1p(_ x: Double) -> Double { return swift_log1p(x) } + @_transparent public static func pow(_ x: Double, _ y: Double) -> Double { + guard x >= 0 else { return .nan } + return swift_pow(x, y) + } + @_transparent public static func pow(_ x: Double, _ n: Int) -> Double { + // TODO: this implementation is not quite correct, because n may be + // rounded in conversion to Double. This only effects very extreme cases, + // so we'll leave it alone for now; however, it gets the sign wrong if + // it rounds an odd number to an even number, so we should fix it soon. + return swift_pow(x, Double(n)) + } + @_transparent public static func atan2(y: Double, x: Double) -> Double { return swift_atan2(y, x) } + @_transparent public static func erf(_ x: Double) -> Double { return swift_erf(x) } + @_transparent public static func erfc(_ x: Double) -> Double { return swift_erfc(x) } + @_transparent public static func exp2(_ x: Double) -> Double { return swift_exp2(x) } + #if os(macOS) || os(iOS) || os(tvOS) || os(watchOS) + @_silgen_name("__exp10") public static func exp10(_ x: Double) -> Double + #endif + @_transparent public static func hypot(_ x: Double, _ y: Double) -> Double { return swift_hypot(x, y) } + @_transparent public static func gamma(_ x: Double) -> Double { return swift_gamma(x) } + @_transparent public static func log2(_ x: Double) -> Double { return swift_log2(x) } + @_transparent public static func log10(_ x: Double) -> Double { return swift_log10(x) } + #if !os(Windows) + @_transparent public static func logGamma(_ x: Double) -> Double { return swift_lgamma(x) } + #endif +} + +#if (arch(i386) || arch(x86_64)) && !os(Windows) && !os(Android) +extension Float80: Real { + @_transparent public static func cos(_ x: Float80) -> Float80 { return swift_cosl(x) } + @_transparent public static func sin(_ x: Float80) -> Float80 { return swift_sinl(x) } + @_transparent public static func tan(_ x: Float80) -> Float80 { return swift_tanl(x) } + @_transparent public static func acos(_ x: Float80) -> Float80 { return swift_acosl(x) } + @_transparent public static func asin(_ x: Float80) -> Float80 { return swift_asinl(x) } + @_transparent public static func atan(_ x: Float80) -> Float80 { return swift_atanl(x) } + @_transparent public static func cosh(_ x: Float80) -> Float80 { return swift_coshl(x) } + @_transparent public static func sinh(_ x: Float80) -> Float80 { return swift_sinhl(x) } + @_transparent public static func tanh(_ x: Float80) -> Float80 { return swift_tanhl(x) } + @_transparent public static func acosh(_ x: Float80) -> Float80 { return swift_acoshl(x) } + @_transparent public static func asinh(_ x: Float80) -> Float80 { return swift_asinhl(x) } + @_transparent public static func atanh(_ x: Float80) -> Float80 { return swift_atanhl(x) } + @_transparent public static func exp(_ x: Float80) -> Float80 { return swift_expl(x) } + @_transparent public static func expm1(_ x: Float80) -> Float80 { return swift_expm1l(x) } + @_transparent public static func log(_ x: Float80) -> Float80 { return swift_logl(x) } + @_transparent public static func log1p(_ x: Float80) -> Float80 { return swift_log1pl(x) } + @_transparent public static func pow(_ x: Float80, _ y: Float80) -> Float80 { + guard x >= 0 else { return .nan } + return swift_powl(x, y) + } + @_transparent public static func pow(_ x: Float80, _ n: Int) -> Float80 { + return swift_powl(x, Float80(n)) + } + @_transparent public static func atan2(y: Float80, x: Float80) -> Float80 { return swift_atan2l(y, x) } + @_transparent public static func erf(_ x: Float80) -> Float80 { return swift_erfl(x) } + @_transparent public static func erfc(_ x: Float80) -> Float80 { return swift_erfcl(x) } + @_transparent public static func exp2(_ x: Float80) -> Float80 { return swift_exp2l(x) } + @_transparent public static func hypot(_ x: Float80, _ y: Float80) -> Float80 { return swift_hypotl(x, y) } + @_transparent public static func gamma(_ x: Float80) -> Float80 { return swift_gammal(x) } + @_transparent public static func log2(_ x: Float80) -> Float80 { return swift_log2l(x) } + @_transparent public static func log10(_ x: Float80) -> Float80 { return swift_log10l(x) } + @_transparent public static func logGamma(_ x: Float80) -> Float80 { return swift_lgammal(x) } +} +#endif diff --git a/Sources/NumericsShims/NumericsShims.c b/Sources/NumericsShims/NumericsShims.c new file mode 100644 index 0000000..11583f7 --- /dev/null +++ b/Sources/NumericsShims/NumericsShims.c @@ -0,0 +1,20 @@ +//===--- NumericsShims.c --------------------------------------*- swift -*-===// +// +// This source file is part of the Swift.org open source project +// +// Copyright (c) 2019 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 +// +//===----------------------------------------------------------------------===// + +// This file exists only to trigger the NumericShims module to build; without +// it swiftpm won't build anything, and then the shims are not available for +// the modules that need them. + +// If any shims are added that are not pure header inlines, whatever runtime +// support they require can be added to this file. + +#include "NumericsShims.h" diff --git a/Sources/NumericsShims/include/NumericsShims.h b/Sources/NumericsShims/include/NumericsShims.h new file mode 100644 index 0000000..4e0e3ed --- /dev/null +++ b/Sources/NumericsShims/include/NumericsShims.h @@ -0,0 +1,351 @@ +//===--- NumericsShims.h --------------------------------------*- swift -*-===// +// +// This source file is part of the Swift.org open source project +// +// Copyright (c) 2019 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 +// +//===----------------------------------------------------------------------===// + +#define HEADER_SHIM static inline __attribute__((__always_inline__)) + +// MARK: - math functions for float + +HEADER_SHIM float swift_cosf(float x) { + return __builtin_cosf(x); +} + +HEADER_SHIM float swift_sinf(float x) { + return __builtin_sinf(x); +} + +HEADER_SHIM float swift_tanf(float x) { + return __builtin_tanf(x); +} + +HEADER_SHIM float swift_acosf(float x) { + return __builtin_acosf(x); +} + +HEADER_SHIM float swift_asinf(float x) { + return __builtin_asinf(x); +} + +HEADER_SHIM float swift_atanf(float x) { + return __builtin_atanf(x); +} + +HEADER_SHIM float swift_coshf(float x) { + return __builtin_coshf(x); +} + +HEADER_SHIM float swift_sinhf(float x) { + return __builtin_sinhf(x); +} + +HEADER_SHIM float swift_tanhf(float x) { + return __builtin_tanhf(x); +} + +HEADER_SHIM float swift_acoshf(float x) { + return __builtin_acoshf(x); +} + +HEADER_SHIM float swift_asinhf(float x) { + return __builtin_asinhf(x); +} + +HEADER_SHIM float swift_atanhf(float x) { + return __builtin_atanhf(x); +} + +HEADER_SHIM float swift_expf(float x) { + return __builtin_expf(x); +} + +HEADER_SHIM float swift_expm1f(float x) { + return __builtin_expm1f(x); +} + +HEADER_SHIM float swift_logf(float x) { + return __builtin_logf(x); +} + +HEADER_SHIM float swift_log1pf(float x) { + return __builtin_log1pf(x); +} + +HEADER_SHIM float swift_powf(float x, float y) { + return __builtin_powf(x, y); +} + +HEADER_SHIM float swift_atan2f(float y, float x) { + return __builtin_atan2f(y, x); +} + +HEADER_SHIM float swift_erff(float x) { + return __builtin_erff(x); +} + +HEADER_SHIM float swift_erfcf(float x) { + return __builtin_erfcf(x); +} + +HEADER_SHIM float swift_exp2f(float x) { + return __builtin_exp2f(x); +} + +HEADER_SHIM float swift_hypotf(float x, float y) { +#if defined(_WIN32) + extern float _hypotf(float, float); + return _hypotf(x, y); +#else + return __builtin_hypotf(x, y); +#endif +} + +HEADER_SHIM float swift_gammaf(float x) { + return __builtin_tgammaf(x); +} + +HEADER_SHIM float swift_log2f(float x) { + return __builtin_log2f(x); +} + +HEADER_SHIM float swift_log10f(float x) { + return __builtin_log10f(x); +} + +#if !defined _WIN32 +HEADER_SHIM float swift_lgammaf(float x) { +#if __APPLE__ + extern float lgammaf_r(float, int *); +#endif + int _; + return lgammaf_r(x, &_); +} +#endif + +// MARK: - math functions for double + +HEADER_SHIM double swift_cos(double x) { + return __builtin_cos(x); +} + +HEADER_SHIM double swift_sin(double x) { + return __builtin_sin(x); +} + +HEADER_SHIM double swift_tan(double x) { + return __builtin_tan(x); +} + +HEADER_SHIM double swift_acos(double x) { + return __builtin_acos(x); +} + +HEADER_SHIM double swift_asin(double x) { + return __builtin_asin(x); +} + +HEADER_SHIM double swift_atan(double x) { + return __builtin_atan(x); +} + +HEADER_SHIM double swift_cosh(double x) { + return __builtin_cosh(x); +} + +HEADER_SHIM double swift_sinh(double x) { + return __builtin_sinh(x); +} + +HEADER_SHIM double swift_tanh(double x) { + return __builtin_tanh(x); +} + +HEADER_SHIM double swift_acosh(double x) { + return __builtin_acosh(x); +} + +HEADER_SHIM double swift_asinh(double x) { + return __builtin_asinh(x); +} + +HEADER_SHIM double swift_atanh(double x) { + return __builtin_atanh(x); +} + +HEADER_SHIM double swift_exp(double x) { + return __builtin_exp(x); +} + +HEADER_SHIM double swift_expm1(double x) { + return __builtin_expm1(x); +} + +HEADER_SHIM double swift_log(double x) { + return __builtin_log(x); +} + +HEADER_SHIM double swift_log1p(double x) { + return __builtin_log1p(x); +} + +HEADER_SHIM double swift_pow(double x, double y) { + return __builtin_pow(x, y); +} + +HEADER_SHIM double swift_atan2(double y, double x) { + return __builtin_atan2(y, x); +} + +HEADER_SHIM double swift_erf(double x) { + return __builtin_erf(x); +} + +HEADER_SHIM double swift_erfc(double x) { + return __builtin_erfc(x); +} + +HEADER_SHIM double swift_exp2(double x) { + return __builtin_exp2(x); +} + +HEADER_SHIM double swift_hypot(double x, double y) { + return __builtin_hypot(x, y); +} + +HEADER_SHIM double swift_gamma(double x) { + return __builtin_tgamma(x); +} + +HEADER_SHIM double swift_log2(double x) { + return __builtin_log2(x); +} + +HEADER_SHIM double swift_log10(double x) { + return __builtin_log10(x); +} + +#if !defined _WIN32 +HEADER_SHIM double swift_lgamma(double x) { +#if __APPLE__ + extern double lgamma_r(double, int *); +#endif + int _; + return lgamma_r(x, &_); +} +#endif + +// MARK: - math functions for float80 +#if !defined _WIN32 && (defined __i386__ || defined __x86_64__) +HEADER_SHIM long double swift_cosl(long double x) { + return __builtin_cosl(x); +} + +HEADER_SHIM long double swift_sinl(long double x) { + return __builtin_sinl(x); +} + +HEADER_SHIM long double swift_tanl(long double x) { + return __builtin_tanl(x); +} + +HEADER_SHIM long double swift_acosl(long double x) { + return __builtin_acosl(x); +} + +HEADER_SHIM long double swift_asinl(long double x) { + return __builtin_asinl(x); +} + +HEADER_SHIM long double swift_atanl(long double x) { + return __builtin_atanl(x); +} + +HEADER_SHIM long double swift_coshl(long double x) { + return __builtin_coshl(x); +} + +HEADER_SHIM long double swift_sinhl(long double x) { + return __builtin_sinhl(x); +} + +HEADER_SHIM long double swift_tanhl(long double x) { + return __builtin_tanhl(x); +} + +HEADER_SHIM long double swift_acoshl(long double x) { + return __builtin_acoshl(x); +} + +HEADER_SHIM long double swift_asinhl(long double x) { + return __builtin_asinhl(x); +} + +HEADER_SHIM long double swift_atanhl(long double x) { + return __builtin_atanhl(x); +} + +HEADER_SHIM long double swift_expl(long double x) { + return __builtin_expl(x); +} + +HEADER_SHIM long double swift_expm1l(long double x) { + return __builtin_expm1l(x); +} + +HEADER_SHIM long double swift_logl(long double x) { + return __builtin_logl(x); +} + +HEADER_SHIM long double swift_log1pl(long double x) { + return __builtin_log1pl(x); +} + +HEADER_SHIM long double swift_powl(long double x, long double y) { + return __builtin_powl(x, y); +} + +HEADER_SHIM long double swift_atan2l(long double y, long double x) { + return __builtin_atan2l(y, x); +} + +HEADER_SHIM long double swift_erfl(long double x) { + return __builtin_erfl(x); +} + +HEADER_SHIM long double swift_erfcl(long double x) { + return __builtin_erfcl(x); +} + +HEADER_SHIM long double swift_exp2l(long double x) { + return __builtin_exp2l(x); +} + +HEADER_SHIM long double swift_hypotl(long double x, long double y) { + return __builtin_hypotl(x, y); +} + +HEADER_SHIM long double swift_gammal(long double x) { + return __builtin_tgammal(x); +} + +HEADER_SHIM long double swift_log2l(long double x) { + return __builtin_log2l(x); +} + +HEADER_SHIM long double swift_log10l(long double x) { + return __builtin_log10l(x); +} + +HEADER_SHIM long double swift_lgammal(long double x) { + extern long double lgammal_r(long double, int *); + int _; + return lgammal_r(x, &_); +} +#endif diff --git a/Tests/ComplexTests/ComplexTests.swift b/Tests/ComplexTests/ComplexTests.swift new file mode 100644 index 0000000..a4b936c --- /dev/null +++ b/Tests/ComplexTests/ComplexTests.swift @@ -0,0 +1,64 @@ +//===--- ComplexTests.swift -----------------------------------*- swift -*-===// +// +// This source file is part of the Swift.org open source project +// +// Copyright (c) 2019 Apple Inc. and the Swift project authors +// Licensed under Apache License v2.0 with Runtime Library Exception +// +// See https://swift.org/LICENSE.txt for license information +// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors +// +//===----------------------------------------------------------------------===// + +import XCTest +import Complex + +final class ComplexTests: XCTestCase { + + // Double-precision test cases from Baudin & Smith's "A Robust Complex Division in Scilab". + func testDivide_BaudinSmith() { + XCTAssertEqual(Complex(1,1)/Complex(1, 0x1p1023), + Complex(0x1p-1023, -0x1p-1023)) + XCTAssertEqual(Complex(1,1)/Complex(0x1p-1023, 0x1p-1023), + Complex(0x1p1023)) + XCTAssertEqual(Complex(0x1p1023, 0x1p1023)/Complex(1,1), + Complex(0x1.0p1023)) + XCTAssertEqual(Complex(0x1p-347, 0x1p-54)/Complex(0x1p-1037, 0x1p-1058), + Complex(3.8981256045591133e289, 8.174961907852353577e295)) + XCTAssertEqual(Complex(0x1p-1074, 0x1p-1074)/Complex(0x1p-1073, 0x1p-1074), + Complex(0.6, 0.2)) + XCTAssertEqual(Complex(0x1p1015, 0x1p-989)/Complex(0x1p1023, 0x1p1023), + Complex(0.001953125, -0.001953125)) + XCTAssertEqual(Complex(0x1p-622, 0x1p-1071)/Complex(0x1p-343, 0x1p-798), + Complex(1.02951151789360578e-84, 6.97145987515076231e-220)) + } + + func testDivide_BaudinSmithApprox() { + // Policy: we deliberately do not try to get these cases from Baudin and + // Smith "right"; instead we simply want an answer that's as accurate + // (in the complex norm) as can be expected. We don't care what happens + // to the tiny component of the result. + func closeEnough(_ a: Complex, _ b: Complex) -> Bool { + return (a - b).magnitude < max(a.magnitude, b.magnitude) * 0x1p-50 + } + XCTAssert(closeEnough(Complex(0x1p1023, 0x1p-1023)/Complex(0x1p677, 0x1p-677), + Complex(0x1p346, -0x1p-1008))) + XCTAssert(closeEnough(Complex(0x1p1020, 0x1p-844)/Complex(0x1p656, 0x1p-780), + Complex(0x1p364, -0x1p-1072))) + XCTAssert(closeEnough(Complex(0x1p-71, 0x1p1021)/Complex(0x1p1001, 0x1p-323), + Complex(0x1p-1072, 0x1p20))) + } + + static var allTests = [ + ("testDivide_BaudinSmith", testDivide_BaudinSmith), + ("testDivide_BaudinSmithApprox", testDivide_BaudinSmithApprox), + ] +} + +#if !(os(macOS) || os(iOS) || os(watchOS) || os(tvOS)) +public func allTests() -> [XCTestCaseEntry] { + return [ + testCase(ComplexTests.allTests), + ] +} +#endif diff --git a/Tests/ComplexTests/XCTestManifests.swift b/Tests/ComplexTests/XCTestManifests.swift new file mode 100644 index 0000000..afb0b8c --- /dev/null +++ b/Tests/ComplexTests/XCTestManifests.swift @@ -0,0 +1,18 @@ +#if !canImport(ObjectiveC) +import XCTest + +extension ComplexTests { + // DO NOT MODIFY: This is autogenerated, use: + // `swift test --generate-linuxmain` + // to regenerate. + static let __allTests__ComplexTests = [ + ("testEquality", testEquality), + ] +} + +public func __allTests() -> [XCTestCaseEntry] { + return [ + testCase(ComplexTests.__allTests__ComplexTests), + ] +} +#endif diff --git a/Tests/ElementaryFunctionTests/ElementaryFunctionTests.swift b/Tests/ElementaryFunctionTests/ElementaryFunctionTests.swift new file mode 100644 index 0000000..6ad4e15 --- /dev/null +++ b/Tests/ElementaryFunctionTests/ElementaryFunctionTests.swift @@ -0,0 +1,128 @@ +//===--- ElementaryFunctionTests.swift ------------------------*- swift -*-===// +// +// This source file is part of the Swift.org open source project +// +// Copyright (c) 2019 Apple Inc. and the Swift project authors +// Licensed under Apache License v2.0 with Runtime Library Exception +// +// See https://swift.org/LICENSE.txt for license information +// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors +// +//===----------------------------------------------------------------------===// + +import XCTest +import ElementaryFunctions + +#if (arch(i386) || arch(x86_64)) && !os(Windows) && !os(Android) +typealias TestLiteralType = Float80 +#else +typealias TestLiteralType = Double +#endif + +func sanityCheck(_ expected: TestLiteralType, _ actual: T, + ulps allowed: T = 16, + file: StaticString = #file, line: UInt = #line) + where T: BinaryFloatingPoint { + // Default tolerance is 16 ulps; It's OK to relax this as needed for new + // platforms, as these tests are *not* intended to validate the math + // library--they are only intended to check that the Swift bindings are + // calling the right functions in the math library. It's important, however + // not to relax the tolerance beyond a few hundred ulps, because these tests + // need to detect errors where the *wrong function* is being called; e.g. + // we need to flag an implentation that inadvertently called the C hypotf + // function instead of hypot. This is especially important because the C + // shims that we're calling through will allow silent type conversions. + if actual == T(expected) || actual.isNaN && expected.isNaN { + return + } + // Compute error in ulp, compare to tolerance. + let absoluteError = T(abs(TestLiteralType(actual) - expected)) + let ulpError = absoluteError / T(expected).ulp + XCTAssert(ulpError <= allowed, "\(actual) != \(expected) as \(T.self)" + + "\n \(ulpError)-ulp error exceeds \(allowed)-ulp tolerance.", + file: file, line: line) +} + +internal extension ElementaryFunctions where Self: BinaryFloatingPoint { + static func elementaryFunctionTests() { + sanityCheck(1.1863995522992575361931268186727044683, Self.acos(0.375)) + sanityCheck(0.3843967744956390830381948729670469737, Self.asin(0.375)) + sanityCheck(0.3587706702705722203959200639264604997, Self.atan(0.375)) + sanityCheck(0.9305076219123142911494767922295555080, Self.cos(0.375)) + sanityCheck(0.3662725290860475613729093517162641571, Self.sin(0.375)) + sanityCheck(0.3936265759256327582294137871012180981, Self.tan(0.375)) + sanityCheck(0.4949329230945269058895630995767185785, Self.acosh(1.125)) + sanityCheck(0.9670596312833237113713762009167286709, Self.asinh(1.125)) + sanityCheck(0.7331685343967135223291211023213964500, Self.atanh(0.625)) + sanityCheck(1.0711403467045867672994980155670160493, Self.cosh(0.375)) + sanityCheck(0.3838510679136145687542956764205024589, Self.sinh(0.375)) + sanityCheck(0.3583573983507859463193602315531580424, Self.tanh(0.375)) + sanityCheck(1.4549914146182013360537936919875185083, Self.exp(0.375)) + sanityCheck(0.4549914146182013360537936919875185083, Self.expm1(0.375)) + sanityCheck(-0.980829253011726236856451127452003999, Self.log(0.375)) + sanityCheck(0.3184537311185346158102472135905995955, Self.log1p(0.375)) + sanityCheck(-0.7211247851537041911608191553900547941, Self.root(-0.375, 3)) + sanityCheck(0.6123724356957945245493210186764728479, Self.sqrt(0.375)) + sanityCheck(0.54171335479545025876069682133938570, Self.pow(0.375, 0.625)) + sanityCheck(-0.052734375, Self.pow(-0.375, 3)) + } +} + +internal extension Real where Self: BinaryFloatingPoint { + static func realFunctionTests() { + sanityCheck(1.2968395546510096659337541177924511598, Self.exp2(0.375)) + sanityCheck(2.3713737056616552616517527574788898386, Self.exp10(0.375)) + sanityCheck(-1.415037499278843818546261056052183491, Self.log2(0.375)) + sanityCheck(-0.425968732272281148346188780918363771, Self.log10(0.375)) + sanityCheck(0.54041950027058415544357836460859991, Self.atan2(y: 0.375, x: 0.625)) + sanityCheck(0.72886898685566255885926910969319788, Self.hypot(0.375, 0.625)) + sanityCheck(0.4041169094348222983238250859191217675, Self.erf(0.375)) + sanityCheck(0.5958830905651777016761749140808782324, Self.erfc(0.375)) + sanityCheck(2.3704361844166009086464735041766525098, Self.gamma(0.375)) + #if !os(Windows) + sanityCheck( -0.11775527074107877445136203331798850, Self.logGamma(1.375)) + XCTAssertEqual(.plus, Self.signGamma(1.375)) + XCTAssertEqual(.minus, Self.signGamma(-2.375)) + #endif + } +} + +final class ElementaryFunctionTests: XCTestCase { + + func testFloat() { + Float.elementaryFunctionTests() + Float.realFunctionTests() + } + + func testDouble() { + Double.elementaryFunctionTests() + Double.realFunctionTests() + } + + + #if (arch(i386) || arch(x86_64)) && !os(Windows) && !os(Android) + func testFloat80() { + Float80.elementaryFunctionTests() + Float80.realFunctionTests() + } + + static var allTests = [ + ("testFloat", testFloat), + ("testDouble", testDouble), + ("testFloat80", testFloat80), + ] + #else + static var allTests = [ + ("testFloat", testFloat), + ("testDouble", testDouble), + ] + #endif +} + +#if !(os(macOS) || os(iOS) || os(watchOS) || os(tvOS)) +public func allTests() -> [XCTestCaseEntry] { + return [ + testCase(ComplexTests.allTests), + ] +} +#endif diff --git a/Tests/ElementaryFunctionTests/XCTestManifests.swift b/Tests/ElementaryFunctionTests/XCTestManifests.swift new file mode 100644 index 0000000..008b632 --- /dev/null +++ b/Tests/ElementaryFunctionTests/XCTestManifests.swift @@ -0,0 +1,20 @@ +#if !canImport(ObjectiveC) +import XCTest + +extension ElementaryFunctionTests { + // DO NOT MODIFY: This is autogenerated, use: + // `swift test --generate-linuxmain` + // to regenerate. + static let __allTests__ElementaryFunctionTests = [ + ("testDouble", testDouble), + ("testFloat", testFloat), + ("testFloat80", testFloat80), + ] +} + +public func __allTests() -> [XCTestCaseEntry] { + return [ + testCase(ElementaryFunctionTests.__allTests__ElementaryFunctionTests), + ] +} +#endif diff --git a/Tests/LinuxMain.swift b/Tests/LinuxMain.swift new file mode 100644 index 0000000..d8378f7 --- /dev/null +++ b/Tests/LinuxMain.swift @@ -0,0 +1,10 @@ +import XCTest + +import ComplexTests +import ElementaryFunctionTests + +var tests = [XCTestCaseEntry]() +tests += ComplexTests.__allTests() +tests += ElementaryFunctionTests.__allTests() + +XCTMain(tests)