binary

Author: ay42

.gitignore

@@ -0,0 +1,6 @@
+.DS_Store
+/.build
+/Packages
+/*.xcodeproj
+xcuserdata/
+.swiftpm

Package.resolved

@@ -0,0 +1,18 @@
+// swift-tools-version:5.4
+// The swift-tools-version declares the minimum version of Swift required to build this package.
+
+import PackageDescription
+
+let package = Package(
+    name: "Binary",
+    products: [
+        .library(name: "Binary", targets: ["Binary"]),
+    ],
+    dependencies: [
+        .package(name: "List", url: "[email protected]:spacenation/swift-list.git", .upToNextMajor(from: "1.0.0")),
+    ],
+    targets: [
+        .target(name: "Binary", dependencies: ["List"]),
+        .testTarget(name: "BinaryTests", dependencies: ["Binary"])
+    ]
+)

Package.swift

@@ -1 +1 @@
-# swift-binary
+### Binary

README.md

@@ -0,0 +1,2 @@
+import Foundation
+@_exported import List

Sources/Binary/Binary.swift

@@ -0,0 +1,19 @@
+import Foundation
+
+extension BinaryFloatingPoint {
+    public func scaled<T: FixedWidthInteger>(in range: ClosedRange<Self>) -> T {
+        T(Self(T.max) * self.normalized(in: range))
+    }
+}
+
+extension BinaryFloatingPoint {
+    public func normalized(in range: ClosedRange<Self> = .unitInterval) -> Self {
+        guard range.upperBound - range.lowerBound > 0 else { return 0 }
+        let value = Swift.min(Swift.max(self, range.lowerBound), range.upperBound)
+        return Self(value - range.lowerBound) / Self(range.upperBound - range.lowerBound)
+    }
+}
+
+extension ClosedRange where Bound : BinaryFloatingPoint {
+    public static var unitInterval: Self { 0.0...1.0 }
+}

Sources/Binary/BinaryFloatingPoint+Scale.swift

@@ -0,0 +1,53 @@
+import Foundation
+
+public enum Bit {
+    case zero
+    case one
+}
+
+public extension Bit {
+    init(_ int: UInt8) {
+        self = int == 0 ? .zero : .one
+    }
+    
+    init?(_ character: Character) {
+        switch character {
+        case "0":
+            self = .zero
+        case "1":
+            self = .one
+        default:
+            return nil 
+        }
+    }
+}
+
+public extension Bool {
+    init(bit: Bit) {
+        switch bit {
+        case .zero:
+            self = false
+        case .one:
+            self = true
+        }
+    }
+}
+
+public extension UInt8 {
+    var bits: [Bit] {
+        Array((0...7)).reversed().map { self.bit(at: $0) }
+    }
+}
+
+public extension UInt8 {
+    func bit(at index: Int) -> Bit {
+        let bits = (0...7).map { UInt8(1) << $0 }
+        return (self & bits[index] != 0) ? .one : .zero
+    }
+}
+
+public extension Collection where Element == UInt8 {
+    var bits: [Bit] {
+        self.flatMap { $0.bits }
+    }
+}

Sources/Binary/Bit.swift

@@ -0,0 +1,8 @@
+import Foundation
+
+public enum BitsExtensionStrategy: Equatable {
+    case fixed
+    case signExtended(UInt)
+    case zeroExtended(UInt)
+    case zeroBackfill(UInt)
+}

Sources/Binary/BitsExtensionStrategy.swift

@@ -0,0 +1,6 @@
+import Foundation
+
+public enum ByteOrder: Equatable {
+    case littleEndian
+    case bigEndian
+}

Sources/Binary/ByteOrder.swift

@@ -0,0 +1,53 @@
+import Foundation
+
+extension FixedWidthInteger {
+    public func scaled<T: FixedWidthInteger>() -> T {
+        let sizeDelta = MemoryLayout<Self>.size * 8 - MemoryLayout<T>.size * 8
+        if sizeDelta > 0 {
+            return T(self >> sizeDelta)
+        }
+        if sizeDelta < 0 {
+            return T(self) >> sizeDelta
+        }
+        return T(self)
+    }
+    
+    public func scaled<T: BinaryFloatingPoint>() -> T {
+        T(self) / T(Self.max)
+    }
+}
+
+extension FixedWidthInteger where Self: UnsignedInteger {
+    public func scalingDown(factor: Self) -> Self {
+        let portion: Float = Float(factor) / Float(Self.max)
+        let newValue = Float(self) * portion
+        return Self.init(Swift.max(0, Swift.min(newValue, Float(Self.max))))
+    }
+    
+    public func scalingUp(factor: Self) -> Self {
+        guard factor > 0 else { return self }
+        let portion: Float = Float(Self.max) / Float(factor)
+        let newValue = Float(self) * portion
+        return Self.init(Swift.max(0, Swift.min(newValue, Float(Self.max))))
+    }
+}
+
+extension FixedWidthInteger {
+    public func normalized(in range: ClosedRange<Self> = .maxRange) -> Float {
+        guard range.upperBound - range.lowerBound > 0 else { return 0 }
+        let value = Swift.min(Swift.max(self, range.lowerBound), range.upperBound)
+        return Float(value - range.lowerBound) / Float(range.upperBound - range.lowerBound)
+    }
+}
+
+extension Range where Bound: FixedWidthInteger {
+    public static var maxRange: Self {
+        Bound.min..<Bound.max
+    }
+}
+
+extension ClosedRange where Bound: FixedWidthInteger {
+    public static var maxRange: Self {
+        Bound.min...Bound.max
+    }
+}