# SparseSolve(_:_:_:_:) Solves the system *AX = B* using the supplied double-precision factorization of *A*, without any internal memory allocations. ``` func SparseSolve(_ Factored: SparseOpaqueFactorization_Double, _ B: DenseMatrix_Double, _ X: DenseMatrix_Double, _ workspace: UnsafeMutableRawPointer) ``` ## Parameters `Factored` The factorization of *A*. `B` The right-hand-side, B. `X` The matrix for returning solutions. `workspace` The scratch space of size [`solveWorkspaceRequiredStatic`](/documentation/Accelerate/SparseOpaqueFactorization_Double/solveWorkspaceRequiredStatic) `+` `nrhs` `*` [`solveWorkspaceRequiredPerRHS`](/documentation/Accelerate/SparseOpaqueFactorization_Double/solveWorkspaceRequiredPerRHS), where `nrhs` is the number of right-hand-sides to find solutions for. ## Discussion Use this function to solve a system of linear equations using a factored coefficient matrix. In cases where your code calls the function frequently, create and manage the workspace that the Sparse Solvers library uses and reuse it across function calls. Reusing a workspace prevents the Sparse Solvers library from allocating the temporary storage with each call. The following figure shows two systems of equations where the coefficient matrix is sparse:  The following code solves this system with a QR factorization of the coefficient matrix: ```swift /// Create the coefficient matrix _A_. let rowIndices: [Int32] = [ 0, 1, 1, 2] let columnIndices: [Int32] = [ 2, 0, 2, 1] let aValues: [Double] = [10, 20, 5, 50] let A = SparseConvertFromCoordinate(3, 3, 4, 1, SparseAttributes_t(), rowIndices, columnIndices, aValues) /// Factorize _A_. let factorization = SparseFactor(SparseFactorizationQR, A) defer { SparseCleanup(A) SparseCleanup(factorization) } /// Create the workspace. let nrhs = Int(A.structure.columnCount) let byteCount = factorization.solveWorkspaceRequiredStatic + nrhs * factorization.solveWorkspaceRequiredPerRHS let workspace = UnsafeMutableRawPointer.allocate( byteCount: byteCount, alignment: MemoryLayout.alignment) defer { workspace.deallocate() } /// Create the right-hand-side matrix, _B_. var bValues: [Double] = [30, 35, 100, 300, 350, 1000] let n = bValues.count /// Solve the system. let xValues = [Double](unsafeUninitializedCapacity: n) { buffer, count in bValues.withUnsafeMutableBufferPointer { bPtr in let B = DenseMatrix_Double(rowCount: 3, columnCount: 2, columnStride: 3, attributes: SparseAttributes_t(), data: bPtr.baseAddress!) let X = DenseMatrix_Double(rowCount: 3, columnCount: 2, columnStride: 3, attributes: SparseAttributes_t(), data: buffer.baseAddress!) SparseSolve(factorization, B, X, workspace) count = n } ``` On return, `xValues` contains the values `[1.0, 2.0, 3.0, 10.0, 20.0, 30.0]`. If the factorization is *A = QR*, the function returns the solution of minimum norm *‖ x ‖₂* for underdetermined systems. If the factorization is *A = QR*, the function returns the least squares solution *minₓ ‖ AX - B ‖₂* for overdetermined systems. If the factorization is [`SparseFactorizationCholeskyAtA`](/documentation/Accelerate/SparseFactorizationCholeskyAtA), the factorization is of *AᵀA*, and the solution that returns is for the system *AᵀAX = B*. --- Copyright © 2026 Apple Inc. All rights reserved. | [Terms of Use](https://www.apple.com/legal/internet-services/terms/site.html) | [Privacy Policy](https://www.apple.com/privacy/privacy-policy)