feat: add [Double] and [Float] array serialization extensions

Add array extensions following the FixedWidthInteger pattern from Standards library:
- [Double].swift - Deserialize byte collections to Double arrays
- [Float].swift - Deserialize byte collections to Float arrays

Features:
- Convert flat byte collections to typed arrays
- Support for both little-endian and big-endian
- Validates byte count is multiple of element size
- Preserves special values (infinity, NaN, signed zero)

Tests:
- 9 tests for [Double] covering single/multiple values, endianness, special values, large arrays
- 10 tests for [Float] with same coverage plus mixed values

Total: 200 tests passing (was 181)

Author: coenttb

Sources/IEEE_754/[Double].swift

@@ -0,0 +1,49 @@
+// [Double].swift
+// swift-ieee-754
+//
+// Array extensions for Swift standard library Double (IEEE 754 binary64)
+
+import Standards
+
+extension [Double] {
+    /// Creates an array of Doubles from a flat byte collection
+    ///
+    /// Converts a collection of bytes in IEEE 754 binary64 format to an array
+    /// of Double values. Each Double requires exactly 8 bytes.
+    ///
+    /// - Parameters:
+    ///   - bytes: Collection of bytes representing multiple Doubles
+    ///   - endianness: Byte order of the input bytes (defaults to little-endian)
+    /// - Returns: Array of Doubles, or nil if byte count is not a multiple of 8
+    ///
+    /// Example:
+    /// ```swift
+    /// let bytes: [UInt8] = [
+    ///     0x6E, 0x86, 0x1B, 0xF0, 0xF9, 0x21, 0x09, 0x40,  // 3.14159
+    ///     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xF0, 0x3F   // 1.0
+    /// ]
+    /// let doubles = [Double](bytes: bytes)
+    /// // [3.14159, 1.0]
+    /// ```
+    ///
+    /// - Note: Uses ``Double/init(bytes:endianness:)`` under the hood
+    public init?<C: Collection>(bytes: C, endianness: [UInt8].Endianness = .little)
+    where C.Element == UInt8 {
+        let elementSize = MemoryLayout<Element>.size
+        guard bytes.count % elementSize == 0 else { return nil }
+
+        var result: [Element] = []
+        result.reserveCapacity(bytes.count / elementSize)
+
+        let byteArray: [UInt8] = .init(bytes)
+        for i in stride(from: 0, to: byteArray.count, by: elementSize) {
+            let chunk: [UInt8] = .init(byteArray[i..<i + elementSize])
+            guard let element = Element(bytes: chunk, endianness: endianness) else {
+                return nil
+            }
+            result.append(element)
+        }
+
+        self = result
+    }
+}

Sources/IEEE_754/[Float].swift

@@ -0,0 +1,49 @@
+// [Float].swift
+// swift-ieee-754
+//
+// Array extensions for Swift standard library Float (IEEE 754 binary32)
+
+import Standards
+
+extension [Float] {
+    /// Creates an array of Floats from a flat byte collection
+    ///
+    /// Converts a collection of bytes in IEEE 754 binary32 format to an array
+    /// of Float values. Each Float requires exactly 4 bytes.
+    ///
+    /// - Parameters:
+    ///   - bytes: Collection of bytes representing multiple Floats
+    ///   - endianness: Byte order of the input bytes (defaults to little-endian)
+    /// - Returns: Array of Floats, or nil if byte count is not a multiple of 4
+    ///
+    /// Example:
+    /// ```swift
+    /// let bytes: [UInt8] = [
+    ///     0xD0, 0x0F, 0x49, 0x40,  // 3.14159
+    ///     0x00, 0x00, 0x80, 0x3F   // 1.0
+    /// ]
+    /// let floats = [Float](bytes: bytes)
+    /// // [3.14159, 1.0]
+    /// ```
+    ///
+    /// - Note: Uses ``Float/init(bytes:endianness:)`` under the hood
+    public init?<C: Collection>(bytes: C, endianness: [UInt8].Endianness = .little)
+    where C.Element == UInt8 {
+        let elementSize = MemoryLayout<Element>.size
+        guard bytes.count % elementSize == 0 else { return nil }
+
+        var result: [Element] = []
+        result.reserveCapacity(bytes.count / elementSize)
+
+        let byteArray: [UInt8] = .init(bytes)
+        for i in stride(from: 0, to: byteArray.count, by: elementSize) {
+            let chunk: [UInt8] = .init(byteArray[i..<i + elementSize])
+            guard let element = Element(bytes: chunk, endianness: endianness) else {
+                return nil
+            }
+            result.append(element)
+        }
+
+        self = result
+    }
+}

Tests/IEEE_754 Tests/[Double] Tests.swift

@@ -0,0 +1,128 @@
+// [Double] Tests.swift
+// swift-ieee-754
+//
+// Tests for [Double] array extensions
+
+import Testing
+@testable import IEEE_754
+
+@Suite("Array<Double> - Deserialization")
+struct DoubleArrayTests {
+
+    @Test("Single Double from 8 bytes")
+    func singleDouble() {
+        let bytes: [UInt8] = [0x6E, 0x86, 0x1B, 0xF0, 0xF9, 0x21, 0x09, 0x40]
+        let doubles = [Double](bytes: bytes)
+        #expect(doubles != nil)
+        #expect(doubles?.count == 1)
+        #expect(doubles?[0] == 3.14159)
+    }
+
+    @Test("Multiple Doubles from bytes")
+    func multipleDoubles() {
+        let bytes: [UInt8] = [
+            0x6E, 0x86, 0x1B, 0xF0, 0xF9, 0x21, 0x09, 0x40,  // 3.14159
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xF0, 0x3F,  // 1.0
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x40   // 2.0
+        ]
+        let doubles = [Double](bytes: bytes)
+        #expect(doubles != nil)
+        #expect(doubles?.count == 3)
+        #expect(doubles?[0] == 3.14159)
+        #expect(doubles?[1] == 1.0)
+        #expect(doubles?[2] == 2.0)
+    }
+
+    @Test("Empty bytes returns empty array")
+    func emptyBytes() {
+        let bytes: [UInt8] = []
+        let doubles = [Double](bytes: bytes)
+        #expect(doubles != nil)
+        #expect(doubles?.isEmpty == true)
+    }
+
+    @Test("Invalid byte count returns nil")
+    func invalidByteCount() {
+        // 7 bytes - not a multiple of 8
+        let bytes: [UInt8] = [0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07]
+        let doubles = [Double](bytes: bytes)
+        #expect(doubles == nil)
+    }
+
+    @Test("Big-endian deserialization")
+    func bigEndian() {
+        let bytes: [UInt8] = [
+            0x40, 0x09, 0x21, 0xFB, 0x54, 0x44, 0x2D, 0x18,  // 3.141592653589793 (big-endian)
+            0x3F, 0xF0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00   // 1.0 (big-endian)
+        ]
+        let doubles = [Double](bytes: bytes, endianness: .big)
+        #expect(doubles != nil)
+        #expect(doubles?.count == 2)
+        #expect(doubles?[0] == 3.141592653589793)
+        #expect(doubles?[1] == 1.0)
+    }
+
+    @Test("Special values - infinity and NaN")
+    func specialValues() {
+        let infBytes = Double.infinity.bytes()
+        let negInfBytes = (-Double.infinity).bytes()
+        let nanBytes = Double.nan.bytes()
+
+        let bytes = infBytes + negInfBytes + nanBytes
+        let doubles = [Double](bytes: bytes)
+
+        #expect(doubles != nil)
+        #expect(doubles?.count == 3)
+        #expect(doubles?[0] == .infinity)
+        #expect(doubles?[1] == -.infinity)
+        #expect(doubles?[2].isNaN == true)
+    }
+
+    @Test("Special values - signed zero")
+    func signedZero() {
+        let posZeroBytes = (0.0 as Double).bytes()
+        let negZeroBytes = (-0.0 as Double).bytes()
+
+        let bytes = posZeroBytes + negZeroBytes
+        let doubles = [Double](bytes: bytes)
+
+        #expect(doubles != nil)
+        #expect(doubles?.count == 2)
+        #expect(doubles?[0] == 0.0)
+        #expect(doubles?[1] == -0.0)
+
+        // Verify sign bit is preserved
+        #expect(doubles?[0].sign == .plus)
+        #expect(doubles?[1].sign == .minus)
+    }
+
+    @Test("Large array of Doubles")
+    func largeArray() {
+        let count = 1000
+        let originalDoubles = (0..<count).map { Double($0) }
+
+        var allBytes: [UInt8] = []
+        for double in originalDoubles {
+            allBytes += double.bytes()
+        }
+
+        let deserializedDoubles = [Double](bytes: allBytes)
+        #expect(deserializedDoubles != nil)
+        #expect(deserializedDoubles?.count == count)
+        #expect(deserializedDoubles == originalDoubles)
+    }
+
+    @Test("Round-trip through array serialization")
+    func roundTrip() {
+        let original: [Double] = [3.14159, 2.71828, 1.41421, 1.61803]
+
+        var bytes: [UInt8] = []
+        for double in original {
+            bytes += double.bytes()
+        }
+
+        let roundtripped = [Double](bytes: bytes)
+        #expect(roundtripped != nil)
+        #expect(roundtripped == original)
+    }
+}

Tests/IEEE_754 Tests/[Float] Tests.swift

@@ -0,0 +1,151 @@
+// [Float] Tests.swift
+// swift-ieee-754
+//
+// Tests for [Float] array extensions
+
+import Testing
+@testable import IEEE_754
+
+@Suite("Array<Float> - Deserialization")
+struct FloatArrayTests {
+
+    @Test("Single Float from 4 bytes")
+    func singleFloat() {
+        let bytes: [UInt8] = [0xD0, 0x0F, 0x49, 0x40]
+        let floats = [Float](bytes: bytes)
+        #expect(floats != nil)
+        #expect(floats?.count == 1)
+        #expect(floats?[0] == 3.14159)
+    }
+
+    @Test("Multiple Floats from bytes")
+    func multipleFloats() {
+        let bytes: [UInt8] = [
+            0xD0, 0x0F, 0x49, 0x40,  // 3.14159
+            0x00, 0x00, 0x80, 0x3F,  // 1.0
+            0x00, 0x00, 0x00, 0x40   // 2.0
+        ]
+        let floats = [Float](bytes: bytes)
+        #expect(floats != nil)
+        #expect(floats?.count == 3)
+        #expect(floats?[0] == 3.14159)
+        #expect(floats?[1] == 1.0)
+        #expect(floats?[2] == 2.0)
+    }
+
+    @Test("Empty bytes returns empty array")
+    func emptyBytes() {
+        let bytes: [UInt8] = []
+        let floats = [Float](bytes: bytes)
+        #expect(floats != nil)
+        #expect(floats?.isEmpty == true)
+    }
+
+    @Test("Invalid byte count returns nil")
+    func invalidByteCount() {
+        // 3 bytes - not a multiple of 4
+        let bytes: [UInt8] = [0x01, 0x02, 0x03]
+        let floats = [Float](bytes: bytes)
+        #expect(floats == nil)
+    }
+
+    @Test("Big-endian deserialization")
+    func bigEndian() {
+        let bytes: [UInt8] = [
+            0x40, 0x49, 0x0F, 0xD0,  // 3.14159 (big-endian)
+            0x3F, 0x80, 0x00, 0x00   // 1.0 (big-endian)
+        ]
+        let floats = [Float](bytes: bytes, endianness: .big)
+        #expect(floats != nil)
+        #expect(floats?.count == 2)
+        #expect(floats?[0] == 3.14159)
+        #expect(floats?[1] == 1.0)
+    }
+
+    @Test("Special values - infinity and NaN")
+    func specialValues() {
+        let infBytes = Float.infinity.bytes()
+        let negInfBytes = (-Float.infinity).bytes()
+        let nanBytes = Float.nan.bytes()
+
+        let bytes = infBytes + negInfBytes + nanBytes
+        let floats = [Float](bytes: bytes)
+
+        #expect(floats != nil)
+        #expect(floats?.count == 3)
+        #expect(floats?[0] == .infinity)
+        #expect(floats?[1] == -.infinity)
+        #expect(floats?[2].isNaN == true)
+    }
+
+    @Test("Special values - signed zero")
+    func signedZero() {
+        let posZeroBytes = (0.0 as Float).bytes()
+        let negZeroBytes = (-0.0 as Float).bytes()
+
+        let bytes = posZeroBytes + negZeroBytes
+        let floats = [Float](bytes: bytes)
+
+        #expect(floats != nil)
+        #expect(floats?.count == 2)
+        #expect(floats?[0] == 0.0)
+        #expect(floats?[1] == -0.0)
+
+        // Verify sign bit is preserved
+        #expect(floats?[0].sign == .plus)
+        #expect(floats?[1].sign == .minus)
+    }
+
+    @Test("Large array of Floats")
+    func largeArray() {
+        let count = 1000
+        let originalFloats = (0..<count).map { Float($0) }
+
+        var allBytes: [UInt8] = []
+        for float in originalFloats {
+            allBytes += float.bytes()
+        }
+
+        let deserializedFloats = [Float](bytes: allBytes)
+        #expect(deserializedFloats != nil)
+        #expect(deserializedFloats?.count == count)
+        #expect(deserializedFloats == originalFloats)
+    }
+
+    @Test("Round-trip through array serialization")
+    func roundTrip() {
+        let original: [Float] = [3.14159, 2.71828, 1.41421, 1.61803]
+
+        var bytes: [UInt8] = []
+        for float in original {
+            bytes += float.bytes()
+        }
+
+        let roundtripped = [Float](bytes: bytes)
+        #expect(roundtripped != nil)
+        #expect(roundtripped == original)
+    }
+
+    @Test("Mixed positive and negative values")
+    func mixedValues() {
+        let original: [Float] = [-100.5, 0.0, 100.5, -0.0, Float.infinity, -Float.infinity]
+
+        var bytes: [UInt8] = []
+        for float in original {
+            bytes += float.bytes()
+        }
+
+        let deserialized = [Float](bytes: bytes)
+        #expect(deserialized != nil)
+        #expect(deserialized?.count == 6)
+
+        if let deserialized = deserialized {
+            #expect(deserialized[0] == -100.5)
+            #expect(deserialized[1] == 0.0)
+            #expect(deserialized[2] == 100.5)
+            #expect(deserialized[3] == -0.0)
+            #expect(deserialized[4] == .infinity)
+            #expect(deserialized[5] == -.infinity)
+        }
+    }
+}