Attempt Swift 5.9 compatibility.

Package.resolved

@@ -1,5 +1,4 @@
 {
-  "originHash" : "d50b9049eb671b1ad14bc8ba592c78735f9e357a6b59835343af6e20e8be4701",
   "pins" : [
     {
       "identity" : "swift-numerics",
@@ -11,5 +10,5 @@
       }
     }
   ],
-  "version" : 3
+  "version" : 2
 }

Package.swift

@@ -1,4 +1,4 @@
-// swift-tools-version: 6.0
+// swift-tools-version: 5.9
 // The swift-tools-version declares the minimum version of Swift required to build this package.
 
 import PackageDescription
@@ -22,12 +22,12 @@ let package = Package(
                 .define("PFFFT_SCALVEC_ENABLED", to: "1"),
                 .define("_USE_MATH_DEFINES"),
                 .define("NDEBUG"),
-                .unsafeFlags(["-O3"]),
             ]
         ),
         .target(
             name: "PFFFT",
-            dependencies: ["PFFFTLib", .product(name: "Numerics", package: "swift-numerics")]
+            dependencies: ["PFFFTLib", .product(name: "Numerics", package: "swift-numerics")],
+            swiftSettings: [.enableExperimentalFeature("AccessLevelOnImport")]
         ),
         .testTarget(
             name: "PFFFTTests",

Sources/PFFFT/FFT.swift

@@ -159,14 +159,20 @@ public struct FFT<T: FFTElement>: ~Copyable {
 
     let ptr: OpaquePointer
     let n: Int
-    let work: Buffer<ScalarType>?
+    let work: Buffer<ScalarType>
     let setup: Setup
 
     public init(setup: Setup) {
         self.setup = setup
         ptr = setup.ptr
         n = setup.n
-        work = n > 4096 ? Buffer<ScalarType>(capacity: T.self == ComplexType.self ? 2 * n : n) : nil
+
+        let workCapacity = if n > 4096 {
+            T.self == ComplexType.self ? 2 * n : n
+        } else {
+            0
+        }
+        work = Buffer(capacity: workCapacity)
     }
 
     /// Initialize the FFT implementation with the given size and type.
@@ -202,10 +208,11 @@ public struct FFT<T: FFTElement>: ~Copyable {
     }
 
     @inline(__always)
-    func toAddress(_ work: borrowing Buffer<ScalarType>?) -> UnsafeMutablePointer<ScalarType>? {
-        switch work {
-        case let .some(b): return b.baseAddress
-        case .none: return nil
+    var workPtr: UnsafeMutablePointer<ScalarType>? {
+        if work.count > 0 {
+            return work.baseAddress
+        } else {
+            return nil
         }
     }
 
@@ -271,12 +278,12 @@ public struct FFT<T: FFTElement>: ~Copyable {
     ///  - sign: The direction of the FFT.
     public func forward(signal: borrowing Buffer<T>, spectrum: borrowing Buffer<ComplexType>) {
         checkFftBufferCounts(signal: signal, spectrum: spectrum)
-        ScalarType.pffftTransformOrdered(ptr, rebind(signal), rebind(spectrum), toAddress(work), .forward)
+        ScalarType.pffftTransformOrdered(ptr, rebind(signal), rebind(spectrum), workPtr, .forward)
     }
 
     public func inverse(spectrum: borrowing Buffer<ComplexType>, signal: borrowing Buffer<T>) {
         checkFftBufferCounts(signal: signal, spectrum: spectrum)
-        ScalarType.pffftTransformOrdered(ptr, rebind(spectrum), rebind(signal), toAddress(work), .backward)
+        ScalarType.pffftTransformOrdered(ptr, rebind(spectrum), rebind(signal), workPtr, .backward)
     }
 
     /// Perform a forward FFT on the input buffer, with implementation defined order.
@@ -290,12 +297,12 @@ public struct FFT<T: FFTElement>: ~Copyable {
     ///  - sign: The direction of the FFT.
     public func forwardToInternalLayout(signal: borrowing Buffer<T>, spectrum: borrowing Buffer<ScalarType>) {
         checkFftInternalLayoutBufferCounts(signal: signal, spectrum: spectrum)
-        ScalarType.pffftTransform(ptr, rebind(signal), spectrum.baseAddress, toAddress(work), .forward)
+        ScalarType.pffftTransform(ptr, rebind(signal), spectrum.baseAddress, workPtr, .forward)
     }
 
     public func inverseFromInternalLayout(spectrum: borrowing Buffer<ScalarType>, signal: borrowing Buffer<T>) {
         checkFftInternalLayoutBufferCounts(signal: signal, spectrum: spectrum)
-        ScalarType.pffftTransform(ptr, spectrum.baseAddress, rebind(signal), toAddress(work), .backward)
+        ScalarType.pffftTransform(ptr, spectrum.baseAddress, rebind(signal), workPtr, .backward)
     }
 
     public func reorder(spectrum: borrowing Buffer<ScalarType>, output: borrowing Buffer<ComplexType>) {

Tests/PFFFTTests/PFFFTTests.swift

@@ -1,14 +1,14 @@
-import Testing
 import ComplexModule
 @testable import PFFFT
+import XCTest
 
-@Test func fftFloat() async throws {
-
+final class FFTTests: XCTestCase {
+    func testFftFloat() throws {
         let fft = try FFT<Complex<Float>>(n: 16)
         let signal = fft.makeSignalBuffer()
         let spectrum = fft.makeSpectrumBuffer()
 
-    signal.mutateEach { (i, v) in
+        signal.mapInPlace { i, v in
             v = Complex(Float(i) + 1.0, Float(i) - 2.0)
         }
 
@@ -33,8 +33,8 @@ import ComplexModule
             .init(11.313707, -27.31371),
             .init(32.218716, -48.218716),
         ]
-    zip(result, expected).forEach { r, e in
-        #expect(r.isApproximatelyEqual(to: e))
+        for (r, e) in zip(result, expected) {
+            XCTAssert(r.isApproximatelyEqual(to: e))
         }
 
         fft.inverse(spectrum: spectrum, signal: signal)
@@ -44,7 +44,8 @@ import ComplexModule
             Complex(Float(i) + 1.0, Float(i) - 2.0) * 16
         }
 
-    zip(signalResult, signalExpected).forEach { r, e in
-        #expect(r.isApproximatelyEqual(to: e))
+        for (r, e) in zip(signalResult, signalExpected) {
+            XCTAssert(r.isApproximatelyEqual(to: e))
+        }
     }
 }