Add code and readme

Author: Priva28

Package.swift

@@ -0,0 +1,23 @@
+// swift-tools-version: 5.9
+// The swift-tools-version declares the minimum version of Swift required to build this package.
+
+import PackageDescription
+
+let package = Package(
+    name: "SwiftLPC",
+    products: [
+        // Products define the executables and libraries a package produces, making them visible to other packages.
+        .library(
+            name: "SwiftLPC",
+            targets: ["SwiftLPC"]),
+    ],
+    targets: [
+        // Targets are the basic building blocks of a package, defining a module or a test suite.
+        // Targets can depend on other targets in this package and products from dependencies.
+        .target(
+            name: "SwiftLPC"),
+        .testTarget(
+            name: "SwiftLPCTests",
+            dependencies: ["SwiftLPC"]),
+    ]
+)

README.md

@@ -0,0 +1,20 @@
+# SwiftLPC: High-Performance Linear Predictive Coding in Swift
+
+SwiftLPC is a small library that performs Linear Predictive Coding. LPC is a powerful tool in speech processing, used for efficiently encoding the spectral characteristics of speech. 
+
+This implementation uses Burg’s method and is essentially a conversion of the existing implementation in the (librosa)[https://librosa.org/doc/0.10.1/generated/librosa.lpc.html#librosa.lpc] python library.
+
+With a native Swift implementation of this algorithm we can get significantly improved performance however, and the ability to run the analysis on large audio files directly on mobile devices. SwiftLPC takes full advantage of the Accelerate framework for optimal performance.
+
+### Example Usage
+
+```swift
+let lpc = LinearPredictiveCoding()
+
+let audioSignal: [Float] = [...]
+let predictedCoefficents = lpc.computeLpc(audioSignal, order: 31)
+```
+
+### Author
+
+- (Christian Privitelli)[https://github.com/Priva28]

Sources/SwiftLPC/SwiftLPC.swift

@@ -0,0 +1,85 @@
+// created by christian privitelli on 20/10/2023
+
+import Accelerate
+import Foundation
+
+public class LinearPredictiveCoding {
+    public func computeLpc(_ y: [Float], order: Int) -> [Float] {
+        var arCoeffs = [Float](repeating: 0.0, count: order + 1)
+        var arCoeffsPrev = [Float](repeating: 0.0, count: order + 1)
+
+        arCoeffs[0] = 1
+        arCoeffsPrev[0] = 1
+
+        // forward and backward prediction error. used to calculate reflection coefficient.
+        var fwdError = Array(y.dropFirst())
+        var bwdError = Array(y.dropLast())
+
+        var den = computeInitialDen(fwdError: fwdError, bwdError: bwdError)
+        var reflectionCoefficient: Float = 0
+
+        for i in 0 ..< order {
+            reflectionCoefficient = computeReflectionCoefficient(fwdError: fwdError, bwdError: bwdError, den: den)
+
+            swap(&arCoeffsPrev, &arCoeffs)
+
+            for j in 1 ... (i + 1) where j < arCoeffsPrev.count && (i - j + 1) < arCoeffsPrev.count {
+                var values: [Float] = [arCoeffsPrev[j], arCoeffsPrev[i - j + 1]]
+                var result: Float = 0.0
+
+                vDSP_dotpr(&values, 1, [1.0, reflectionCoefficient], 1, &result, vDSP_Length(2))
+
+                arCoeffs[j] = result
+            }
+
+            computePredictionErrors(fwdError: &fwdError, bwdError: &bwdError, reflectionCoefficient: &reflectionCoefficient)
+
+            den = computeUpdatedDen(
+                fwdError: fwdError,
+                bwdError: bwdError,
+                reflectionCoefficient: reflectionCoefficient,
+                den: den
+            )
+
+            // shift up forward error
+            fwdError = Array(fwdError.dropFirst())
+            bwdError = Array(bwdError.dropLast())
+        }
+
+        return arCoeffs
+    }
+
+    private func computeInitialDen(fwdError: [Float], bwdError: [Float]) -> Float {
+        var fwdSq: Float = 0.0
+        var bwdSq: Float = 0.0
+        vDSP_dotpr(fwdError, 1, fwdError, 1, &fwdSq, vDSP_Length(fwdError.count))
+        vDSP_dotpr(bwdError, 1, bwdError, 1, &bwdSq, vDSP_Length(bwdError.count))
+        return fwdSq + bwdSq
+    }
+
+    private func computeUpdatedDen(fwdError: [Float], bwdError: [Float], reflectionCoefficient: Float, den: Float) -> Float {
+        let q = 1.0 - reflectionCoefficient * reflectionCoefficient
+        let lastElementBwd = bwdError.last! * bwdError.last!
+        let firstElementFwd = fwdError.first! * fwdError.first!
+        return q * den - (lastElementBwd + firstElementFwd)
+    }
+
+    private func computeReflectionCoefficient(fwdError: [Float], bwdError: [Float], den: Float) -> Float {
+        let epsilon = Float.leastNonzeroMagnitude
+
+        var result: Float = 0.0
+        vDSP_dotpr(bwdError, 1, fwdError, 1, &result, vDSP_Length(bwdError.count))
+        return -2 * result / (den + epsilon)
+    }
+
+    private func computePredictionErrors(fwdError: inout [Float], bwdError: inout [Float], reflectionCoefficient: inout Float) {
+        // We need to pass the state before fwdError is modified in the first vDSP_vsma into the second vDSP_vsma that modifies bwdError.
+        let fwdErrorTemp = fwdError
+
+        /// vDSP_vsma
+        // for (n = 0; n < N; ++n)
+        //     D[n] = A[n]*B + C[n];
+        vDSP_vsma(bwdError, 1, &reflectionCoefficient, fwdError, 1, &fwdError, 1, vDSP_Length(fwdError.count))
+        vDSP_vsma(fwdErrorTemp, 1, &reflectionCoefficient, bwdError, 1, &bwdError, 1, vDSP_Length(bwdError.count))
+    }
+}

Tests/SwiftLPCTests/SwiftLPCTests.swift

@@ -0,0 +1,17 @@
+import XCTest
+@testable import SwiftLPC
+
+final class SwiftLPCTests: XCTestCase {
+    let lpc = LinearPredictiveCoding()
+    
+    func testLpc() throws {
+        let input: [Float] = [0.0, 1, 2]
+        
+        let output = lpc.computeLpc(input, order: 2)
+        let expectedOutput: [Float] = [1, -1.2, 0.8]
+        
+        for (index, value) in output.enumerated() {
+            XCTAssertEqual(value, expectedOutput[index], accuracy: 1e-6)
+        }
+    }
+}