Make SparseArrays an extension #570

ChrisRackauckas · 2025-02-01T18:37:48Z

We shouldn't need to load all of the sparse arrays infrastructure unless the user is using sparse arrays. There are a few things that need to be done here:

KLU.jl code needs to be copied so we can default to KLU calls without requiring a user-level using KLU
Some functions are made which only get a useful dispatch after using SparseArrays is loaded, but that should be sufficiently safe

But one big issue is that Krylov.jl has a dependency on SparseArrays, so we'd either need to drop it as a dependency and a new Krylov library, or fix Krylov.jl to make it an extension.

github-actions

Remaining comments which cannot be posted as a review comment to avoid GitHub Rate Limit

JuliaFormatter

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/klu.jl

Line 304 in e263444

for i ∈ 1:(length(Fp) - 1)

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/klu.jl

Line 307 in e263444

last = Fp[i+1]

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/klu.jl

Line 353 in e263444

    
           return SparseMatrixCSC(klu.n, klu.n, increment!(p), increment!(i), Complex.(x, z))

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/klu.jl

Lines 358 to 359 in e263444

    
           function LinearAlgebra.issuccess(K::AbstractKLUFactorization; allowsingular=false) 
        
               return (allowsingular ? K.common.status >= KLU_OK : K.common.status == KLU_OK) && K._numeric != C_NULL

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/klu.jl

Line 362 in e263444

summary(io, K); println(io)

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/klu.jl

Lines 378 to 379 in e263444

    
           function klu_analyze!(K::KLUFactorization{Tv, Ti}; check=true) where {Tv, Ti<:KLUITypes} 
        
               if K._symbolic != C_NULL return K end

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/klu.jl

Lines 394 to 395 in e263444

    
           function klu_analyze!(K::KLUFactorization{Tv, Ti}, P::Vector{Ti}, Q::Vector{Ti}; check=true) where {Tv, Ti<:KLUITypes} 
        
               if K._symbolic != C_NULL return K end

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/klu.jl

Line 409 in e263444

for Tv ∈ KLUValueTypes, Ti ∈ KLUIndexTypes

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/klu.jl

Line 412 in e263444

    
           function klu_factor!(K::KLUFactorization{$Tv, $Ti}; check=true, allowsingular=false)

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/klu.jl

Line 436 in e263444

for Tv ∈ KLUValueTypes, Ti ∈ KLUIndexTypes

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/klu.jl

Line 448 in e263444

    
           ok = $rgrowth(K.colptr, K.rowval, K.nzval, K._symbolic, K._numeric, Ref(K.common))

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/klu.jl

Line 488 in e263444

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/klu.jl

Line 497 in e263444

- `K::KLUFactorization`: The matrix factorization object to be factored.

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/klu.jl

Line 500 in e263444

    
             silent divide by zero errors in subsequent `solve!` or `ldiv!` calls if singularity is not checked by the user with `klu.common.status == KLU.KLU_SINGULAR`

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/klu.jl

Line 518 in e263444

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/klu.jl

Line 522 in e263444

    
           |:----------|:-----------------------------------------------------------------|

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/klu.jl

Line 536 in e263444

- `LinearAlgebra.\\`

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/klu.jl

Line 539 in e263444

    
             - `A::SparseMatrixCSC` or `n::Integer`, `colptr::Vector{Ti}`, `rowval::Vector{Ti}`, `nzval::Vector{Tv}`: The sparse matrix or the zero-based sparse matrix components to be factored.

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/klu.jl

Line 542 in e263444

    
             silent divide by zero errors in subsequent `solve!` or `ldiv!` calls if singularity is not checked by the user with `klu.common.status == KLU.KLU_SINGULAR`

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/klu.jl

Line 545 in e263444

`klu(A::SparseMatrixCSC)` uses the KLU[^ACM907] library that is part of

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/klu.jl

Line 552 in e263444

    
           function klu(n, colptr::Vector{Ti}, rowval::Vector{Ti}, nzval::Vector{Tv}; check=true, allowsingular=false) where {Ti<:KLUITypes, Tv<:AbstractFloat}

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/klu.jl

Line 560 in e263444

    
           function klu(n, colptr::Vector{Ti}, rowval::Vector{Ti}, nzval::Vector{Tv}; check=true, allowsingular=false) where {Ti<:KLUITypes, Tv<:Complex}

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/klu.jl

Line 568 in e263444

    
           function klu(A::SparseMatrixCSC{Tv, Ti}; check=true, allowsingular=false) where {Tv<:Union{AbstractFloat, Complex}, Ti<:KLUITypes}

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/klu.jl

Line 579 in e263444

matrix used to create `K` must match the pattern of `A`.

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/klu.jl

Line 588 in e263444

    
             - `K::KLUFactorization`: The matrix factorization object, previously created by a call to `klu`, to be re-factored.

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/klu.jl

Line 592 in e263444

    
             silent divide by zero errors in subsequent `solve!` or `ldiv!` calls if singularity is not checked by the user with `klu.common.status == KLU.KLU_SINGULAR`

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/klu.jl

Line 595 in e263444

`klu(A::SparseMatrixCSC)` uses the KLU[^ACM907] library that is part of

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/klu.jl

Line 604 in e263444

for Tv ∈ KLUValueTypes, Ti ∈ KLUIndexTypes

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/klu.jl

Lines 607 to 608 in e263444

    
           function klu!(K::KLUFactorization{$Tv, $Ti}, nzval::Vector{$Tv}; check=true, allowsingular=false) 
        
               length(nzval) != length(K.nzval)  && throw(DimensionMismatch())

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/klu.jl

Line 611 in e263444

    
           ok = $refactor(K.colptr, K.rowval, K.nzval, K._symbolic, K._numeric, Ref(K.common))

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/klu.jl

Line 622 in e263444

    
           function klu!(K::AbstractKLUFactorization{ComplexF64}, nzval::Vector{U}; check=true, allowsingular=false) where {U<:Complex}

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/klu.jl

Line 626 in e263444

    
           function klu!(K::AbstractKLUFactorization{Float64}, nzval::Vector{U}; check=true, allowsingular=false) where {U<:AbstractFloat}

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/klu.jl

Line 630 in e263444

    
           function klu!(K::KLUFactorization{U}, S::SparseMatrixCSC{U}; check=true, allowsingular=false) where {U}

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/klu.jl

Line 636 in e263444

(decrement!(K.colptr); decrement!(K.rowval);

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/klu.jl

Line 657 in e263444

    
             - `klu::KLUFactorization`: The matrix factorization of `A` to use in the solution.

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/klu.jl

Line 662 in e263444

    
               If the factorization object `klu` has `klu.common.status == KLU.KLU_SINGULAR` then the `solve!` or `ldiv!` will result in a silent divide by zero error.

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/klu.jl

Line 667 in e263444

for Tv ∈ KLUValueTypes, Ti ∈ KLUIndexTypes

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/klu.jl

Line 670 in e263444

    
           function solve!(klu::AbstractKLUFactorization{$Tv, $Ti}, B::StridedVecOrMat{$Tv}; check=true)

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/klu.jl

Line 674 in e263444

    
           isok = $solve(klu._symbolic, klu._numeric, size(B, 1), size(B, 2), B, Ref(klu.common))

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/klu.jl

Line 681 in e263444

for Tv ∈ KLUValueTypes, Ti ∈ KLUIndexTypes

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/klu.jl

Line 684 in e263444

    
           call = :($tsolve(klu._symbolic, klu._numeric, size(B, 1), size(B, 2), B, conj, Ref(klu.common)))

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/klu.jl

Line 686 in e263444

    
           call = :($tsolve(klu._symbolic, klu._numeric, size(B, 1), size(B, 2), B, Ref(klu.common)))

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/klu.jl

Line 689 in e263444

    
           function solve!(klu::AdjointFact{$Tv, K}, B::StridedVecOrMat{$Tv}; check=true) where {K<:AbstractKLUFactorization{$Tv, $Ti}}

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/klu.jl

Line 699 in e263444

    
           function solve!(klu::TransposeFact{$Tv, K}, B::StridedVecOrMat{$Tv}; check=true) where {K<: AbstractKLUFactorization{$Tv, $Ti}}

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/klu.jl

Line 712 in e263444

function solve(klu, B; check=true)

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/klu.jl

Line 718 in e263444

    
           LinearAlgebra.ldiv!(klu::AbstractKLUFactorization{Tv}, B::StridedVecOrMat{Tv}) where {Tv<:KLUTypes} =

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/klu.jl

Line 720 in e263444

    
           LinearAlgebra.ldiv!(klu::Union{AdjointFact{Tv, K},TransposeFact{Tv, K}}, B::StridedVecOrMat{Tv}) where {Tv, Ti, K<:AbstractKLUFactorization{Tv, Ti}} =

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/klu.jl

Line 722 in e263444

    
           function LinearAlgebra.ldiv!(klu::AbstractKLUFactorization{<:AbstractFloat}, B::StridedVecOrMat{<:Complex})

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/klu.jl

Line 728 in e263444

    
           function LinearAlgebra.ldiv!(klu::Union{AdjointFact{Tv, K},TransposeFact{Tv, K}}, B::StridedVecOrMat{<:Complex}) where {Tv<:AbstractFloat, Ti, K<:AbstractKLUFactorization{Tv, Ti}}

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/klu.jl

Line 734 in e263444

end

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/wrappers.jl

Line 30 in e263444

    
           ccall((:SuiteSparse_config_malloc_func_set, libsuitesparseconfig), Cvoid, (Ptr{Cvoid},), malloc_func)

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/wrappers.jl

Line 34 in e263444

    
           ccall((:SuiteSparse_config_calloc_func_set, libsuitesparseconfig), Cvoid, (Ptr{Cvoid},), calloc_func)

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/wrappers.jl

Line 38 in e263444

    
           ccall((:SuiteSparse_config_realloc_func_set, libsuitesparseconfig), Cvoid, (Ptr{Cvoid},), realloc_func)

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/wrappers.jl

Line 42 in e263444

    
           ccall((:SuiteSparse_config_free_func_set, libsuitesparseconfig), Cvoid, (Ptr{Cvoid},), free_func)

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/wrappers.jl

Line 46 in e263444

    
           ccall((:SuiteSparse_config_printf_func_set, libsuitesparseconfig), Cvoid, (Ptr{Cvoid},), printf_func)

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/wrappers.jl

Line 50 in e263444

    
           ccall((:SuiteSparse_config_hypot_func_set, libsuitesparseconfig), Cvoid, (Ptr{Cvoid},), hypot_func)

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/wrappers.jl

Line 54 in e263444

    
           ccall((:SuiteSparse_config_divcomplex_func_set, libsuitesparseconfig), Cvoid, (Ptr{Cvoid},), divcomplex_func)

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/wrappers.jl

Line 62 in e263444

    
           ccall((:SuiteSparse_config_calloc, libsuitesparseconfig), Ptr{Cvoid}, (Csize_t, Csize_t), n, s)

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/wrappers.jl

Line 66 in e263444

    
           ccall((:SuiteSparse_config_realloc, libsuitesparseconfig), Ptr{Cvoid}, (Ptr{Cvoid}, Csize_t), arg1, s)

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/wrappers.jl

Line 74 in e263444

    
           ccall((:SuiteSparse_config_hypot, libsuitesparseconfig), Cdouble, (Cdouble, Cdouble), x, y)

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/wrappers.jl

Line 78 in e263444

    
           ccall((:SuiteSparse_config_divcomplex, libsuitesparseconfig), Cint, (Cdouble, Cdouble, Cdouble, Cdouble, Ptr{Cdouble}, Ptr{Cdouble}), xr, xi, yr, yi, zr, zi)

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/wrappers.jl

Line 90 in e263444

    
           ccall((:SuiteSparse_malloc, libsuitesparseconfig), Ptr{Cvoid}, (Csize_t, Csize_t), nitems, size_of_item)

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/wrappers.jl

Line 94 in e263444

    
           ccall((:SuiteSparse_calloc, libsuitesparseconfig), Ptr{Cvoid}, (Csize_t, Csize_t), nitems, size_of_item)

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/wrappers.jl

Line 98 in e263444

    
           ccall((:SuiteSparse_realloc, libsuitesparseconfig), Ptr{Cvoid}, (Csize_t, Csize_t, Csize_t, Ptr{Cvoid}, Ptr{Cint}), nitems_new, nitems_old, size_of_item, p, ok)

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/wrappers.jl

Line 122 in e263444

    
           ccall((:SuiteSparse_divcomplex, libsuitesparseconfig), Cint, (Cdouble, Cdouble, Cdouble, Cdouble, Ptr{Cdouble}, Ptr{Cdouble}), ar, ai, br, bi, cr, ci)

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/wrappers.jl

Line 138 in e263444

    
           ccall((:amd_order, libamd), Cint, (Int32, Ptr{Int32}, Ptr{Int32}, Ptr{Int32}, Ptr{Cdouble}, Ptr{Cdouble}), n, Ap, Ai, P, Control, Info)

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/wrappers.jl

Lines 142 to 150 in e263444

    
               ccall((:amd_l_order, libamd), Cint, (Int64, Ptr{Int64}, Ptr{Int64}, Ptr{Int64}, Ptr{Cdouble}, Ptr{Cdouble}), n, Ap, Ai, P, Control, Info) 
        
           end 
        
           function amd_2(n, Pe, Iw, Len, iwlen, pfree, Nv, Next, Last, Head, Elen, Degree, W, Control, Info) 
        
               ccall((:amd_2, libamd), Cvoid, (Int32, Ptr{Int32}, Ptr{Int32}, Ptr{Int32}, Int32, Int32, Ptr{Int32}, Ptr{Int32}, Ptr{Int32}, Ptr{Int32}, Ptr{Int32}, Ptr{Int32}, Ptr{Int32}, Ptr{Cdouble}, Ptr{Cdouble}), n, Pe, Iw, Len, iwlen, pfree, Nv, Next, Last, Head, Elen, Degree, W, Control, Info) 
        
           end 
        
           function amd_l2(n, Pe, Iw, Len, iwlen, pfree, Nv, Next, Last, Head, Elen, Degree, W, Control, Info) 
        
               ccall((:amd_l2, libamd), Cvoid, (Int64, Ptr{Int64}, Ptr{Int64}, Ptr{Int64}, Int64, Int64, Ptr{Int64}, Ptr{Int64}, Ptr{Int64}, Ptr{Int64}, Ptr{Int64}, Ptr{Int64}, Ptr{Int64}, Ptr{Cdouble}, Ptr{Cdouble}), n, Pe, Iw, Len, iwlen, pfree, Nv, Next, Last, Head, Elen, Degree, W, Control, Info)

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/wrappers.jl

Line 154 in e263444

    
           ccall((:amd_valid, libamd), Cint, (Int32, Int32, Ptr{Int32}, Ptr{Int32}), n_row, n_col, Ap, Ai)

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/wrappers.jl

Line 158 in e263444

    
           ccall((:amd_l_valid, libamd), Cint, (Int64, Int64, Ptr{Int64}, Ptr{Int64}), n_row, n_col, Ap, Ai)

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/wrappers.jl

Line 190 in e263444

    
           ccall((:colamd_l_recommended, libamd), Csize_t, (Int64, Int64, Int64), nnz, n_row, n_col)

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/wrappers.jl

Line 202 in e263444

    
           ccall((:colamd, libamd), Cint, (Int32, Int32, Int32, Ptr{Int32}, Ptr{Int32}, Ptr{Cdouble}, Ptr{Int32}), n_row, n_col, Alen, A, p, knobs, stats)

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/wrappers.jl

Line 206 in e263444

    
           ccall((:colamd_l, libamd), Cint, (Int64, Int64, Int64, Ptr{Int64}, Ptr{Int64}, Ptr{Cdouble}, Ptr{Int64}), n_row, n_col, Alen, A, p, knobs, stats)

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/wrappers.jl

Line 210 in e263444

    
           ccall((:symamd, libamd), Cint, (Int32, Ptr{Int32}, Ptr{Int32}, Ptr{Int32}, Ptr{Cdouble}, Ptr{Int32}, Ptr{Cvoid}, Ptr{Cvoid}), n, A, p, perm, knobs, stats, allocate, release)

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/wrappers.jl

Line 214 in e263444

    
           ccall((:symamd_l, libamd), Cint, (Int64, Ptr{Int64}, Ptr{Int64}, Ptr{Int64}, Ptr{Cdouble}, Ptr{Int64}, Ptr{Cvoid}, Ptr{Cvoid}), n, A, p, perm, knobs, stats, allocate, release)

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/wrappers.jl

Line 234 in e263444

    
           ccall((:btf_maxtrans, libbtf), Int32, (Int32, Int32, Ptr{Int32}, Ptr{Int32}, Cdouble, Ptr{Cdouble}, Ptr{Int32}, Ptr{Int32}), nrow, ncol, Ap, Ai, maxwork, work, Match, Work)

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/wrappers.jl

Line 238 in e263444

    
           ccall((:btf_l_maxtrans, libbtf), Int64, (Int64, Int64, Ptr{Int64}, Ptr{Int64}, Cdouble, Ptr{Cdouble}, Ptr{Int64}, Ptr{Int64}), arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8)

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/wrappers.jl

Line 242 in e263444

    
           ccall((:btf_strongcomp, libbtf), Int32, (Int32, Ptr{Int32}, Ptr{Int32}, Ptr{Int32}, Ptr{Int32}, Ptr{Int32}, Ptr{Int32}), n, Ap, Ai, Q, P, R, Work)

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/wrappers.jl

Line 246 in e263444

    
           ccall((:btf_l_strongcomp, libbtf), Int64, (Int64, Ptr{Int64}, Ptr{Int64}, Ptr{Int64}, Ptr{Int64}, Ptr{Int64}, Ptr{Int64}), arg1, arg2, arg3, arg4, arg5, arg6, arg7)

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/wrappers.jl

Line 250 in e263444

    
           ccall((:btf_order, libbtf), Int32, (Int32, Ptr{Int32}, Ptr{Int32}, Cdouble, Ptr{Cdouble}, Ptr{Int32}, Ptr{Int32}, Ptr{Int32}, Ptr{Int32}, Ptr{Int32}), n, Ap, Ai, maxwork, work, P, Q, R, nmatch, Work)

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/wrappers.jl

Line 254 in e263444

    
           ccall((:btf_l_order, libbtf), Int64, (Int64, Ptr{Int64}, Ptr{Int64}, Cdouble, Ptr{Cdouble}, Ptr{Int64}, Ptr{Int64}, Ptr{Int64}, Ptr{Int64}, Ptr{Int64}), arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10)

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/wrappers.jl

Line 422 in e263444

    
           ccall((:klu_analyze, libklu), Ptr{klu_symbolic}, (Int32, Ptr{Int32}, Ptr{Int32}, Ptr{klu_common}), n, Ap, Ai, Common)

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/wrappers.jl

Line 426 in e263444

    
           ccall((:klu_l_analyze, libklu), Ptr{klu_l_symbolic}, (Int64, Ptr{Int64}, Ptr{Int64}, Ptr{klu_l_common}), arg1, arg2, arg3, Common)

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/wrappers.jl

Line 430 in e263444

    
           ccall((:klu_analyze_given, libklu), Ptr{klu_symbolic}, (Int32, Ptr{Int32}, Ptr{Int32}, Ptr{Int32}, Ptr{Int32}, Ptr{klu_common}), n, Ap, Ai, P, Q, Common)

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/wrappers.jl

Line 434 in e263444

    
           ccall((:klu_l_analyze_given, libklu), Ptr{klu_l_symbolic}, (Int64, Ptr{Int64}, Ptr{Int64}, Ptr{Int64}, Ptr{Int64}, Ptr{klu_l_common}), arg1, arg2, arg3, arg4, arg5, arg6)

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/wrappers.jl

Line 438 in e263444

    
           ccall((:klu_factor, libklu), Ptr{klu_numeric}, (Ptr{Int32}, Ptr{Int32}, Ptr{Cdouble}, Ptr{klu_symbolic}, Ptr{klu_common}), Ap, Ai, Ax, Symbolic, Common)

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/wrappers.jl

Line 442 in e263444

    
           ccall((:klu_z_factor, libklu), Ptr{klu_numeric}, (Ptr{Int32}, Ptr{Int32}, Ptr{Cdouble}, Ptr{klu_symbolic}, Ptr{klu_common}), Ap, Ai, Ax, Symbolic, Common)

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/wrappers.jl

Line 446 in e263444

    
           ccall((:klu_l_factor, libklu), Ptr{klu_l_numeric}, (Ptr{Int64}, Ptr{Int64}, Ptr{Cdouble}, Ptr{klu_l_symbolic}, Ptr{klu_l_common}), arg1, arg2, arg3, arg4, arg5)

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/wrappers.jl

Line 450 in e263444

    
           ccall((:klu_zl_factor, libklu), Ptr{klu_l_numeric}, (Ptr{Int64}, Ptr{Int64}, Ptr{Cdouble}, Ptr{klu_l_symbolic}, Ptr{klu_l_common}), arg1, arg2, arg3, arg4, arg5)

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/wrappers.jl

Line 454 in e263444

    
           ccall((:klu_solve, libklu), Cint, (Ptr{klu_symbolic}, Ptr{klu_numeric}, Int32, Int32, Ptr{Cdouble}, Ptr{klu_common}), Symbolic, Numeric, ldim, nrhs, B, Common)

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/wrappers.jl

Line 458 in e263444

    
           ccall((:klu_z_solve, libklu), Cint, (Ptr{klu_symbolic}, Ptr{klu_numeric}, Int32, Int32, Ptr{Cdouble}, Ptr{klu_common}), Symbolic, Numeric, ldim, nrhs, B, Common)

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/wrappers.jl

Line 462 in e263444

    
           ccall((:klu_l_solve, libklu), Cint, (Ptr{klu_l_symbolic}, Ptr{klu_l_numeric}, Int64, Int64, Ptr{Cdouble}, Ptr{klu_l_common}), arg1, arg2, arg3, arg4, arg5, arg6)

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/wrappers.jl

Line 466 in e263444

    
           ccall((:klu_zl_solve, libklu), Cint, (Ptr{klu_l_symbolic}, Ptr{klu_l_numeric}, Int64, Int64, Ptr{Cdouble}, Ptr{klu_l_common}), arg1, arg2, arg3, arg4, arg5, arg6)

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/wrappers.jl

Line 470 in e263444

    
           ccall((:klu_tsolve, libklu), Cint, (Ptr{klu_symbolic}, Ptr{klu_numeric}, Int32, Int32, Ptr{Cdouble}, Ptr{klu_common}), Symbolic, Numeric, ldim, nrhs, B, Common)

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/wrappers.jl

Line 474 in e263444

    
           ccall((:klu_z_tsolve, libklu), Cint, (Ptr{klu_symbolic}, Ptr{klu_numeric}, Int32, Int32, Ptr{Cdouble}, Cint, Ptr{klu_common}), Symbolic, Numeric, ldim, nrhs, B, conj_solve, Common)

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/wrappers.jl

Line 478 in e263444

    
           ccall((:klu_l_tsolve, libklu), Cint, (Ptr{klu_l_symbolic}, Ptr{klu_l_numeric}, Int64, Int64, Ptr{Cdouble}, Ptr{klu_l_common}), arg1, arg2, arg3, arg4, arg5, arg6)

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/wrappers.jl

Line 482 in e263444

    
           ccall((:klu_zl_tsolve, libklu), Cint, (Ptr{klu_l_symbolic}, Ptr{klu_l_numeric}, Int64, Int64, Ptr{Cdouble}, Cint, Ptr{klu_l_common}), arg1, arg2, arg3, arg4, arg5, arg6, arg7)

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/wrappers.jl

Line 486 in e263444

    
           ccall((:klu_refactor, libklu), Cint, (Ptr{Int32}, Ptr{Int32}, Ptr{Cdouble}, Ptr{klu_symbolic}, Ptr{klu_numeric}, Ptr{klu_common}), Ap, Ai, Ax, Symbolic, Numeric, Common)

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/wrappers.jl

Line 490 in e263444

    
           ccall((:klu_z_refactor, libklu), Cint, (Ptr{Int32}, Ptr{Int32}, Ptr{Cdouble}, Ptr{klu_symbolic}, Ptr{klu_numeric}, Ptr{klu_common}), Ap, Ai, Ax, Symbolic, Numeric, Common)

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/wrappers.jl

Line 494 in e263444

    
           ccall((:klu_l_refactor, libklu), Cint, (Ptr{Int64}, Ptr{Int64}, Ptr{Cdouble}, Ptr{klu_l_symbolic}, Ptr{klu_l_numeric}, Ptr{klu_l_common}), arg1, arg2, arg3, arg4, arg5, arg6)

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/wrappers.jl

Line 498 in e263444

    
           ccall((:klu_zl_refactor, libklu), Cint, (Ptr{Int64}, Ptr{Int64}, Ptr{Cdouble}, Ptr{klu_l_symbolic}, Ptr{klu_l_numeric}, Ptr{klu_l_common}), arg1, arg2, arg3, arg4, arg5, arg6)

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/wrappers.jl

Line 502 in e263444

    
           ccall((:klu_free_symbolic, libklu), Cint, (Ptr{Ptr{klu_symbolic}}, Ptr{klu_common}), Symbolic, Common)

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/wrappers.jl

Line 506 in e263444

    
           ccall((:klu_l_free_symbolic, libklu), Cint, (Ptr{Ptr{klu_l_symbolic}}, Ptr{klu_l_common}), arg1, arg2)

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/wrappers.jl

Line 510 in e263444

    
           ccall((:klu_free_numeric, libklu), Cint, (Ptr{Ptr{klu_numeric}}, Ptr{klu_common}), Numeric, Common)

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/wrappers.jl

Line 514 in e263444

    
           ccall((:klu_z_free_numeric, libklu), Cint, (Ptr{Ptr{klu_numeric}}, Ptr{klu_common}), Numeric, Common)

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/wrappers.jl

Line 518 in e263444

    
           ccall((:klu_l_free_numeric, libklu), Cint, (Ptr{Ptr{klu_l_numeric}}, Ptr{klu_l_common}), arg1, arg2)

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/wrappers.jl

Line 522 in e263444

    
           ccall((:klu_zl_free_numeric, libklu), Cint, (Ptr{Ptr{klu_l_numeric}}, Ptr{klu_l_common}), arg1, arg2)

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/wrappers.jl

Line 526 in e263444

    
           ccall((:klu_sort, libklu), Cint, (Ptr{klu_symbolic}, Ptr{klu_numeric}, Ptr{klu_common}), Symbolic, Numeric, Common)

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/wrappers.jl

Line 530 in e263444

    
           ccall((:klu_z_sort, libklu), Cint, (Ptr{klu_symbolic}, Ptr{klu_numeric}, Ptr{klu_common}), Symbolic, Numeric, Common)

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/wrappers.jl

Line 534 in e263444

    
           ccall((:klu_l_sort, libklu), Cint, (Ptr{klu_l_symbolic}, Ptr{klu_l_numeric}, Ptr{klu_l_common}), arg1, arg2, arg3)

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/wrappers.jl

Line 538 in e263444

    
           ccall((:klu_zl_sort, libklu), Cint, (Ptr{klu_l_symbolic}, Ptr{klu_l_numeric}, Ptr{klu_l_common}), arg1, arg2, arg3)

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/wrappers.jl

Line 542 in e263444

    
           ccall((:klu_flops, libklu), Cint, (Ptr{klu_symbolic}, Ptr{klu_numeric}, Ptr{klu_common}), Symbolic, Numeric, Common)

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/wrappers.jl

Line 546 in e263444

    
           ccall((:klu_z_flops, libklu), Cint, (Ptr{klu_symbolic}, Ptr{klu_numeric}, Ptr{klu_common}), Symbolic, Numeric, Common)

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/wrappers.jl

Line 550 in e263444

    
           ccall((:klu_l_flops, libklu), Cint, (Ptr{klu_l_symbolic}, Ptr{klu_l_numeric}, Ptr{klu_l_common}), arg1, arg2, arg3)

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/wrappers.jl

Line 554 in e263444

    
           ccall((:klu_zl_flops, libklu), Cint, (Ptr{klu_l_symbolic}, Ptr{klu_l_numeric}, Ptr{klu_l_common}), arg1, arg2, arg3)

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/wrappers.jl

Line 558 in e263444

    
           ccall((:klu_rgrowth, libklu), Cint, (Ptr{Int32}, Ptr{Int32}, Ptr{Cdouble}, Ptr{klu_symbolic}, Ptr{klu_numeric}, Ptr{klu_common}), Ap, Ai, Ax, Symbolic, Numeric, Common)

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/wrappers.jl

Line 562 in e263444

    
           ccall((:klu_z_rgrowth, libklu), Cint, (Ptr{Int32}, Ptr{Int32}, Ptr{Cdouble}, Ptr{klu_symbolic}, Ptr{klu_numeric}, Ptr{klu_common}), Ap, Ai, Ax, Symbolic, Numeric, Common)

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/wrappers.jl

Line 566 in e263444

    
           ccall((:klu_l_rgrowth, libklu), Cint, (Ptr{Int64}, Ptr{Int64}, Ptr{Cdouble}, Ptr{klu_l_symbolic}, Ptr{klu_l_numeric}, Ptr{klu_l_common}), arg1, arg2, arg3, arg4, arg5, arg6)

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/wrappers.jl

Line 570 in e263444

    
           ccall((:klu_zl_rgrowth, libklu), Cint, (Ptr{Int64}, Ptr{Int64}, Ptr{Cdouble}, Ptr{klu_l_symbolic}, Ptr{klu_l_numeric}, Ptr{klu_l_common}), arg1, arg2, arg3, arg4, arg5, arg6)

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/wrappers.jl

Line 574 in e263444

    
           ccall((:klu_condest, libklu), Cint, (Ptr{Int32}, Ptr{Cdouble}, Ptr{klu_symbolic}, Ptr{klu_numeric}, Ptr{klu_common}), Ap, Ax, Symbolic, Numeric, Common)

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/wrappers.jl

Line 578 in e263444

    
           ccall((:klu_z_condest, libklu), Cint, (Ptr{Int32}, Ptr{Cdouble}, Ptr{klu_symbolic}, Ptr{klu_numeric}, Ptr{klu_common}), Ap, Ax, Symbolic, Numeric, Common)

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/wrappers.jl

Line 582 in e263444

    
           ccall((:klu_l_condest, libklu), Cint, (Ptr{Int64}, Ptr{Cdouble}, Ptr{klu_l_symbolic}, Ptr{klu_l_numeric}, Ptr{klu_l_common}), arg1, arg2, arg3, arg4, arg5)

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/wrappers.jl

Line 586 in e263444

    
           ccall((:klu_zl_condest, libklu), Cint, (Ptr{Int64}, Ptr{Cdouble}, Ptr{klu_l_symbolic}, Ptr{klu_l_numeric}, Ptr{klu_l_common}), arg1, arg2, arg3, arg4, arg5)

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/wrappers.jl

Line 590 in e263444

    
           ccall((:klu_rcond, libklu), Cint, (Ptr{klu_symbolic}, Ptr{klu_numeric}, Ptr{klu_common}), Symbolic, Numeric, Common)

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/wrappers.jl

Line 594 in e263444

    
           ccall((:klu_z_rcond, libklu), Cint, (Ptr{klu_symbolic}, Ptr{klu_numeric}, Ptr{klu_common}), Symbolic, Numeric, Common)

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/wrappers.jl

Line 598 in e263444

    
           ccall((:klu_l_rcond, libklu), Cint, (Ptr{klu_l_symbolic}, Ptr{klu_l_numeric}, Ptr{klu_l_common}), arg1, arg2, arg3)

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/wrappers.jl

Line 602 in e263444

    
           ccall((:klu_zl_rcond, libklu), Cint, (Ptr{klu_l_symbolic}, Ptr{klu_l_numeric}, Ptr{klu_l_common}), arg1, arg2, arg3)

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/wrappers.jl

Line 606 in e263444

    
           ccall((:klu_scale, libklu), Cint, (Cint, Int32, Ptr{Int32}, Ptr{Int32}, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Int32}, Ptr{klu_common}), scale, n, Ap, Ai, Ax, Rs, W, Common)

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/wrappers.jl

Line 610 in e263444

    
           ccall((:klu_z_scale, libklu), Cint, (Cint, Int32, Ptr{Int32}, Ptr{Int32}, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Int32}, Ptr{klu_common}), scale, n, Ap, Ai, Ax, Rs, W, Common)

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/wrappers.jl

Line 614 in e263444

    
           ccall((:klu_l_scale, libklu), Cint, (Cint, Int64, Ptr{Int64}, Ptr{Int64}, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Int64}, Ptr{klu_l_common}), arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8)

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/wrappers.jl

Lines 618 to 634 in e263444

    
               ccall((:klu_zl_scale, libklu), Cint, (Cint, Int64, Ptr{Int64}, Ptr{Int64}, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Int64}, Ptr{klu_l_common}), arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8) 
        
           end 
        
           function klu_extract(Numeric, Symbolic, Lp, Li, Lx, Up, Ui, Ux, Fp, Fi, Fx, P, Q, Rs, R, Common) 
        
               ccall((:klu_extract, libklu), Cint, (Ptr{klu_numeric}, Ptr{klu_symbolic}, Ptr{Int32}, Ptr{Int32}, Ptr{Cdouble}, Ptr{Int32}, Ptr{Int32}, Ptr{Cdouble}, Ptr{Int32}, Ptr{Int32}, Ptr{Cdouble}, Ptr{Int32}, Ptr{Int32}, Ptr{Cdouble}, Ptr{Int32}, Ptr{klu_common}), Numeric, Symbolic, Lp, Li, Lx, Up, Ui, Ux, Fp, Fi, Fx, P, Q, Rs, R, Common) 
        
           end 
        
           function klu_z_extract(Numeric, Symbolic, Lp, Li, Lx, Lz, Up, Ui, Ux, Uz, Fp, Fi, Fx, Fz, P, Q, Rs, R, Common) 
        
               ccall((:klu_z_extract, libklu), Cint, (Ptr{klu_numeric}, Ptr{klu_symbolic}, Ptr{Int32}, Ptr{Int32}, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Int32}, Ptr{Int32}, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Int32}, Ptr{Int32}, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Int32}, Ptr{Int32}, Ptr{Cdouble}, Ptr{Int32}, Ptr{klu_common}), Numeric, Symbolic, Lp, Li, Lx, Lz, Up, Ui, Ux, Uz, Fp, Fi, Fx, Fz, P, Q, Rs, R, Common) 
        
           end 
        
           function klu_l_extract(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14, arg15, arg16) 
        
               ccall((:klu_l_extract, libklu), Cint, (Ptr{klu_l_numeric}, Ptr{klu_l_symbolic}, Ptr{Int64}, Ptr{Int64}, Ptr{Cdouble}, Ptr{Int64}, Ptr{Int64}, Ptr{Cdouble}, Ptr{Int64}, Ptr{Int64}, Ptr{Cdouble}, Ptr{Int64}, Ptr{Int64}, Ptr{Cdouble}, Ptr{Int64}, Ptr{klu_l_common}), arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14, arg15, arg16) 
        
           end 
        
           function klu_zl_extract(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14, arg15, arg16, arg17, arg18, arg19) 
        
               ccall((:klu_zl_extract, libklu), Cint, (Ptr{klu_l_numeric}, Ptr{klu_l_symbolic}, Ptr{Int64}, Ptr{Int64}, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Int64}, Ptr{Int64}, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Int64}, Ptr{Int64}, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Int64}, Ptr{Int64}, Ptr{Cdouble}, Ptr{Int64}, Ptr{klu_l_common}), arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14, arg15, arg16, arg17, arg18, arg19)

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/wrappers.jl

Line 638 in e263444

    
           ccall((:klu_malloc, libklu), Ptr{Cvoid}, (Csize_t, Csize_t, Ptr{klu_common}), n, size, Common)

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/wrappers.jl

Line 642 in e263444

    
           ccall((:klu_free, libklu), Ptr{Cvoid}, (Ptr{Cvoid}, Csize_t, Csize_t, Ptr{klu_common}), p, n, size, Common)

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/wrappers.jl

Line 646 in e263444

    
           ccall((:klu_realloc, libklu), Ptr{Cvoid}, (Csize_t, Csize_t, Csize_t, Ptr{Cvoid}, Ptr{klu_common}), nnew, nold, size, p, Common)

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/wrappers.jl

Line 650 in e263444

    
           ccall((:klu_l_malloc, libklu), Ptr{Cvoid}, (Csize_t, Csize_t, Ptr{klu_l_common}), arg1, arg2, arg3)

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/wrappers.jl

Line 654 in e263444

    
           ccall((:klu_l_free, libklu), Ptr{Cvoid}, (Ptr{Cvoid}, Csize_t, Csize_t, Ptr{klu_l_common}), arg1, arg2, arg3, arg4)

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/wrappers.jl

Line 658 in e263444

    
           ccall((:klu_l_realloc, libklu), Ptr{Cvoid}, (Csize_t, Csize_t, Csize_t, Ptr{Cvoid}, Ptr{klu_l_common}), arg1, arg2, arg3, arg4, arg5)

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/wrappers.jl

Line 693 in e263444

    
           const SUITESPARSE_VERSION = SUITESPARSE_VER_CODE(SUITESPARSE_MAIN_VERSION, SUITESPARSE_SUB_VERSION)

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/wrappers.jl

Line 845 in e263444

const KLU_VERSION = KLU_VERSION_CODE(KLU_MAIN_VERSION, KLU_SUB_VERSION)

github-actions · 2025-02-01T18:39:14Z

src/KLU/klu.jl

+function decrement!(A::AbstractArray{T}) where T<:Integer
+    for i in eachindex(A); A[i] -= oneunit(T) end


[JuliaFormatter] _{reported by reviewdog 🐶}

Suggested change

function decrement!(A::AbstractArray{T}) where T<:Integer

for i in eachindex(A); A[i] -= oneunit(T) end

function decrement!(A::AbstractArray{T}) where {T <: Integer}

for i in eachindex(A)

A[i] -= oneunit(T)

end

github-actions · 2025-02-01T18:39:14Z

src/KLU/klu.jl

+function increment!(A::AbstractArray{T}) where T<:Integer
+    for i in eachindex(A); A[i] += oneunit(T) end


[JuliaFormatter] _{reported by reviewdog 🐶}

Suggested change

function increment!(A::AbstractArray{T}) where T<:Integer

for i in eachindex(A); A[i] += oneunit(T) end

function increment!(A::AbstractArray{T}) where {T <: Integer}

for i in eachindex(A)

A[i] += oneunit(T)

end

github-actions · 2025-02-01T18:39:14Z

src/KLU/klu.jl

+const AdjointFact = isdefined(LinearAlgebra, :AdjointFactorization) ? LinearAlgebra.AdjointFactorization : Adjoint
+const TransposeFact = isdefined(LinearAlgebra, :TransposeFactorization) ? LinearAlgebra.TransposeFactorization : Transpose


[JuliaFormatter] _{reported by reviewdog 🐶}

Suggested change

const AdjointFact = isdefined(LinearAlgebra, :AdjointFactorization) ? LinearAlgebra.AdjointFactorization : Adjoint

const TransposeFact = isdefined(LinearAlgebra, :TransposeFactorization) ? LinearAlgebra.TransposeFactorization : Transpose

const AdjointFact = isdefined(LinearAlgebra, :AdjointFactorization) ?

LinearAlgebra.AdjointFactorization : Adjoint

const TransposeFact = isdefined(LinearAlgebra, :TransposeFactorization) ?

LinearAlgebra.TransposeFactorization : Transpose

github-actions · 2025-02-01T18:39:14Z

src/KLU/klu.jl

+- `tol::Float64`: Partial pivoting tolerance for diagonal preference
+- `btf::Int64`: If `btf != 0` use BTF pre-ordering
+- `ordering::Int64`: If `ordering == 0` use AMD to permute, if `ordering == 1` use COLAMD,
+if `ordering == 3` use the user provided ordering function.
+- `scale::Int64`: If `scale == 1` then `A[:,i] ./= sum(abs.(A[:,i]))`, if `scale == 2` then
+`A[:,i] ./= maximum(abs.(A[:,i]))`. If `scale == 0` no scaling is done, and the input is
+checked for errors if `scale >= 0`.


[JuliaFormatter] _{reported by reviewdog 🐶}

Suggested change

- `tol::Float64`: Partial pivoting tolerance for diagonal preference

- `btf::Int64`: If `btf != 0` use BTF pre-ordering

- `ordering::Int64`: If `ordering == 0` use AMD to permute, if `ordering == 1` use COLAMD,

if `ordering == 3` use the user provided ordering function.

- `scale::Int64`: If `scale == 1` then `A[:,i] ./= sum(abs.(A[:,i]))`, if `scale == 2` then

`A[:,i] ./= maximum(abs.(A[:,i]))`. If `scale == 0` no scaling is done, and the input is

checked for errors if `scale >= 0`.

- `tol::Float64`: Partial pivoting tolerance for diagonal preference

- `btf::Int64`: If `btf != 0` use BTF pre-ordering

- `ordering::Int64`: If `ordering == 0` use AMD to permute, if `ordering == 1` use COLAMD,

if `ordering == 3` use the user provided ordering function.

- `scale::Int64`: If `scale == 1` then `A[:,i] ./= sum(abs.(A[:,i]))`, if `scale == 2` then

`A[:,i] ./= maximum(abs.(A[:,i]))`. If `scale == 0` no scaling is done, and the input is

checked for errors if `scale >= 0`.

github-actions · 2025-02-01T18:39:14Z

src/KLU/klu.jl

+
+function _klu_name(name, Tv, Ti)
+    outname = "klu_" * (Tv === :Float64 ? "" : "z") * (Ti === :Int64 ? "l_" : "_") * name
+    return Symbol(replace(outname, "__"=>"_"))


[JuliaFormatter] _{reported by reviewdog 🐶}

Suggested change

return Symbol(replace(outname, "__"=>"_"))

return Symbol(replace(outname, "__" => "_"))

github-actions · 2025-02-01T18:39:15Z

src/KLU/klu.jl

+    end
+end
+
+function getproperty(klu::AbstractKLUFactorization{Tv, Ti}, s::Symbol) where {Tv<:KLUTypes, Ti<:KLUITypes}


[JuliaFormatter] _{reported by reviewdog 🐶}

Suggested change

function getproperty(klu::AbstractKLUFactorization{Tv, Ti}, s::Symbol) where {Tv<:KLUTypes, Ti<:KLUITypes}

function getproperty(klu::AbstractKLUFactorization{Tv, Ti},

s::Symbol) where {Tv <: KLUTypes, Ti <: KLUITypes}

github-actions · 2025-02-01T18:39:15Z

src/KLU/klu.jl

+function getproperty(klu::AbstractKLUFactorization{Tv, Ti}, s::Symbol) where {Tv<:KLUTypes, Ti<:KLUITypes}
+    # Forwards to the numeric struct:
+    if s ∈ (:lnz, :unz, :nzoff)
+        klu._numeric == C_NULL && throw(ArgumentError("This KLUFactorization has not yet been factored. Try `klu_factor!`."))


[JuliaFormatter] _{reported by reviewdog 🐶}

Suggested change

klu._numeric == C_NULL && throw(ArgumentError("This KLUFactorization has not yet been factored. Try `klu_factor!`."))

klu._numeric == C_NULL &&

throw(ArgumentError("This KLUFactorization has not yet been factored. Try `klu_factor!`."))

github-actions · 2025-02-01T18:39:16Z

src/KLU/klu.jl

+        return getproperty(klu.numeric, s)
+    end
+    if s ∈ (:nblocks, :maxblock)
+        klu._symbolic == C_NULL && throw(ArgumentError("This KLUFactorization has not yet been analyzed. Try `klu_analyze!`."))


[JuliaFormatter] _{reported by reviewdog 🐶}

Suggested change

klu._symbolic == C_NULL && throw(ArgumentError("This KLUFactorization has not yet been analyzed. Try `klu_analyze!`."))

klu._symbolic == C_NULL &&

throw(ArgumentError("This KLUFactorization has not yet been analyzed. Try `klu_analyze!`."))

github-actions · 2025-02-01T18:39:16Z

src/KLU/klu.jl

+        return getproperty(klu.symbolic, s)
+    end
+    if s === :symbolic
+        klu._symbolic == C_NULL && throw(ArgumentError("This KLUFactorization has not yet been analyzed. Try `klu_analyze!`."))


[JuliaFormatter] _{reported by reviewdog 🐶}

Suggested change

klu._symbolic == C_NULL && throw(ArgumentError("This KLUFactorization has not yet been analyzed. Try `klu_analyze!`."))

klu._symbolic == C_NULL &&

throw(ArgumentError("This KLUFactorization has not yet been analyzed. Try `klu_analyze!`."))

github-actions · 2025-02-01T18:39:16Z

src/KLU/klu.jl

+        end
+    end
+    if s === :numeric
+        klu._numeric == C_NULL && throw(ArgumentError("This KLUFactorization has not yet been factored. Try `klu_factor!`."))


[JuliaFormatter] _{reported by reviewdog 🐶}

Suggested change

klu._numeric == C_NULL && throw(ArgumentError("This KLUFactorization has not yet been factored. Try `klu_factor!`."))

klu._numeric == C_NULL &&

throw(ArgumentError("This KLUFactorization has not yet been factored. Try `klu_factor!`."))

While this may seem a bit weird since the most normal case for Krylov subspace methods is on sparse arrays, there are multiple reasons for this. 1. SparseArrays pulls in SuiteSparse and thus GPL dependencies 2. This is by far the biggest part of the load. Normal Krylov.jl loads in about 8ms, but the SparseArrays part is ~150ms. So if you want to just work on operators, then you'd taking a decently sized hit. 3. This is required for downstream dependency reduction SciML/LinearSolve.jl#570

github-actions

Remaining comments which cannot be posted as a review comment to avoid GitHub Rate Limit

JuliaFormatter

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/klu.jl

Line 611 in 0bf2e46

    
           ok = $refactor(K.colptr, K.rowval, K.nzval, K._symbolic, K._numeric, Ref(K.common))

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/klu.jl

Line 622 in 0bf2e46

    
           function klu!(K::AbstractKLUFactorization{ComplexF64}, nzval::Vector{U}; check=true, allowsingular=false) where {U<:Complex}

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/klu.jl

Line 626 in 0bf2e46

    
           function klu!(K::AbstractKLUFactorization{Float64}, nzval::Vector{U}; check=true, allowsingular=false) where {U<:AbstractFloat}

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/klu.jl

Line 630 in 0bf2e46

    
           function klu!(K::KLUFactorization{U}, S::SparseMatrixCSC{U}; check=true, allowsingular=false) where {U}

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/klu.jl

Line 636 in 0bf2e46

(decrement!(K.colptr); decrement!(K.rowval);

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/klu.jl

Line 657 in 0bf2e46

    
             - `klu::KLUFactorization`: The matrix factorization of `A` to use in the solution.

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/klu.jl

Line 662 in 0bf2e46

    
               If the factorization object `klu` has `klu.common.status == KLU.KLU_SINGULAR` then the `solve!` or `ldiv!` will result in a silent divide by zero error.

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/klu.jl

Line 667 in 0bf2e46

for Tv ∈ KLUValueTypes, Ti ∈ KLUIndexTypes

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/klu.jl

Line 670 in 0bf2e46

    
           function solve!(klu::AbstractKLUFactorization{$Tv, $Ti}, B::StridedVecOrMat{$Tv}; check=true)

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/klu.jl

Line 674 in 0bf2e46

    
           isok = $solve(klu._symbolic, klu._numeric, size(B, 1), size(B, 2), B, Ref(klu.common))

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/klu.jl

Line 681 in 0bf2e46

for Tv ∈ KLUValueTypes, Ti ∈ KLUIndexTypes

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/klu.jl

Line 684 in 0bf2e46

    
           call = :($tsolve(klu._symbolic, klu._numeric, size(B, 1), size(B, 2), B, conj, Ref(klu.common)))

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/klu.jl

Line 686 in 0bf2e46

    
           call = :($tsolve(klu._symbolic, klu._numeric, size(B, 1), size(B, 2), B, Ref(klu.common)))

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/klu.jl

Line 689 in 0bf2e46

    
           function solve!(klu::AdjointFact{$Tv, K}, B::StridedVecOrMat{$Tv}; check=true) where {K<:AbstractKLUFactorization{$Tv, $Ti}}

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/klu.jl

Line 699 in 0bf2e46

    
           function solve!(klu::TransposeFact{$Tv, K}, B::StridedVecOrMat{$Tv}; check=true) where {K<: AbstractKLUFactorization{$Tv, $Ti}}

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/klu.jl

Line 712 in 0bf2e46

function solve(klu, B; check=true)

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/klu.jl

Line 718 in 0bf2e46

    
           LinearAlgebra.ldiv!(klu::AbstractKLUFactorization{Tv}, B::StridedVecOrMat{Tv}) where {Tv<:KLUTypes} =

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/klu.jl

Line 720 in 0bf2e46

    
           LinearAlgebra.ldiv!(klu::Union{AdjointFact{Tv, K},TransposeFact{Tv, K}}, B::StridedVecOrMat{Tv}) where {Tv, Ti, K<:AbstractKLUFactorization{Tv, Ti}} =

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/klu.jl

Line 722 in 0bf2e46

    
           function LinearAlgebra.ldiv!(klu::AbstractKLUFactorization{<:AbstractFloat}, B::StridedVecOrMat{<:Complex})

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/klu.jl

Line 728 in 0bf2e46

    
           function LinearAlgebra.ldiv!(klu::Union{AdjointFact{Tv, K},TransposeFact{Tv, K}}, B::StridedVecOrMat{<:Complex}) where {Tv<:AbstractFloat, Ti, K<:AbstractKLUFactorization{Tv, Ti}}

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/klu.jl

Line 734 in 0bf2e46

end

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/wrappers.jl

Line 30 in 0bf2e46

    
           ccall((:SuiteSparse_config_malloc_func_set, libsuitesparseconfig), Cvoid, (Ptr{Cvoid},), malloc_func)

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/wrappers.jl

Line 34 in 0bf2e46

    
           ccall((:SuiteSparse_config_calloc_func_set, libsuitesparseconfig), Cvoid, (Ptr{Cvoid},), calloc_func)

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/wrappers.jl

Line 38 in 0bf2e46

    
           ccall((:SuiteSparse_config_realloc_func_set, libsuitesparseconfig), Cvoid, (Ptr{Cvoid},), realloc_func)

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/wrappers.jl

Line 42 in 0bf2e46

    
           ccall((:SuiteSparse_config_free_func_set, libsuitesparseconfig), Cvoid, (Ptr{Cvoid},), free_func)

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/wrappers.jl

Line 46 in 0bf2e46

    
           ccall((:SuiteSparse_config_printf_func_set, libsuitesparseconfig), Cvoid, (Ptr{Cvoid},), printf_func)

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/wrappers.jl

Line 50 in 0bf2e46

    
           ccall((:SuiteSparse_config_hypot_func_set, libsuitesparseconfig), Cvoid, (Ptr{Cvoid},), hypot_func)

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/wrappers.jl

Line 54 in 0bf2e46

    
           ccall((:SuiteSparse_config_divcomplex_func_set, libsuitesparseconfig), Cvoid, (Ptr{Cvoid},), divcomplex_func)

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/wrappers.jl

Line 62 in 0bf2e46

    
           ccall((:SuiteSparse_config_calloc, libsuitesparseconfig), Ptr{Cvoid}, (Csize_t, Csize_t), n, s)

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/wrappers.jl

Line 66 in 0bf2e46

    
           ccall((:SuiteSparse_config_realloc, libsuitesparseconfig), Ptr{Cvoid}, (Ptr{Cvoid}, Csize_t), arg1, s)

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/wrappers.jl

Line 74 in 0bf2e46

    
           ccall((:SuiteSparse_config_hypot, libsuitesparseconfig), Cdouble, (Cdouble, Cdouble), x, y)

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/wrappers.jl

Line 78 in 0bf2e46

    
           ccall((:SuiteSparse_config_divcomplex, libsuitesparseconfig), Cint, (Cdouble, Cdouble, Cdouble, Cdouble, Ptr{Cdouble}, Ptr{Cdouble}), xr, xi, yr, yi, zr, zi)

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/wrappers.jl

Line 90 in 0bf2e46

    
           ccall((:SuiteSparse_malloc, libsuitesparseconfig), Ptr{Cvoid}, (Csize_t, Csize_t), nitems, size_of_item)

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/wrappers.jl

Line 94 in 0bf2e46

    
           ccall((:SuiteSparse_calloc, libsuitesparseconfig), Ptr{Cvoid}, (Csize_t, Csize_t), nitems, size_of_item)

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/wrappers.jl

Line 98 in 0bf2e46

    
           ccall((:SuiteSparse_realloc, libsuitesparseconfig), Ptr{Cvoid}, (Csize_t, Csize_t, Csize_t, Ptr{Cvoid}, Ptr{Cint}), nitems_new, nitems_old, size_of_item, p, ok)

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/wrappers.jl

Line 122 in 0bf2e46

    
           ccall((:SuiteSparse_divcomplex, libsuitesparseconfig), Cint, (Cdouble, Cdouble, Cdouble, Cdouble, Ptr{Cdouble}, Ptr{Cdouble}), ar, ai, br, bi, cr, ci)

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/wrappers.jl

Line 138 in 0bf2e46

    
           ccall((:amd_order, libamd), Cint, (Int32, Ptr{Int32}, Ptr{Int32}, Ptr{Int32}, Ptr{Cdouble}, Ptr{Cdouble}), n, Ap, Ai, P, Control, Info)

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/wrappers.jl

Lines 142 to 150 in 0bf2e46

    
               ccall((:amd_l_order, libamd), Cint, (Int64, Ptr{Int64}, Ptr{Int64}, Ptr{Int64}, Ptr{Cdouble}, Ptr{Cdouble}), n, Ap, Ai, P, Control, Info) 
        
           end 
        
           function amd_2(n, Pe, Iw, Len, iwlen, pfree, Nv, Next, Last, Head, Elen, Degree, W, Control, Info) 
        
               ccall((:amd_2, libamd), Cvoid, (Int32, Ptr{Int32}, Ptr{Int32}, Ptr{Int32}, Int32, Int32, Ptr{Int32}, Ptr{Int32}, Ptr{Int32}, Ptr{Int32}, Ptr{Int32}, Ptr{Int32}, Ptr{Int32}, Ptr{Cdouble}, Ptr{Cdouble}), n, Pe, Iw, Len, iwlen, pfree, Nv, Next, Last, Head, Elen, Degree, W, Control, Info) 
        
           end 
        
           function amd_l2(n, Pe, Iw, Len, iwlen, pfree, Nv, Next, Last, Head, Elen, Degree, W, Control, Info) 
        
               ccall((:amd_l2, libamd), Cvoid, (Int64, Ptr{Int64}, Ptr{Int64}, Ptr{Int64}, Int64, Int64, Ptr{Int64}, Ptr{Int64}, Ptr{Int64}, Ptr{Int64}, Ptr{Int64}, Ptr{Int64}, Ptr{Int64}, Ptr{Cdouble}, Ptr{Cdouble}), n, Pe, Iw, Len, iwlen, pfree, Nv, Next, Last, Head, Elen, Degree, W, Control, Info)

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/wrappers.jl

Line 154 in 0bf2e46

    
           ccall((:amd_valid, libamd), Cint, (Int32, Int32, Ptr{Int32}, Ptr{Int32}), n_row, n_col, Ap, Ai)

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/wrappers.jl

Line 158 in 0bf2e46

    
           ccall((:amd_l_valid, libamd), Cint, (Int64, Int64, Ptr{Int64}, Ptr{Int64}), n_row, n_col, Ap, Ai)

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/wrappers.jl

Line 190 in 0bf2e46

    
           ccall((:colamd_l_recommended, libamd), Csize_t, (Int64, Int64, Int64), nnz, n_row, n_col)

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/wrappers.jl

Line 202 in 0bf2e46

    
           ccall((:colamd, libamd), Cint, (Int32, Int32, Int32, Ptr{Int32}, Ptr{Int32}, Ptr{Cdouble}, Ptr{Int32}), n_row, n_col, Alen, A, p, knobs, stats)

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/wrappers.jl

Line 206 in 0bf2e46

    
           ccall((:colamd_l, libamd), Cint, (Int64, Int64, Int64, Ptr{Int64}, Ptr{Int64}, Ptr{Cdouble}, Ptr{Int64}), n_row, n_col, Alen, A, p, knobs, stats)

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/wrappers.jl

Line 210 in 0bf2e46

    
           ccall((:symamd, libamd), Cint, (Int32, Ptr{Int32}, Ptr{Int32}, Ptr{Int32}, Ptr{Cdouble}, Ptr{Int32}, Ptr{Cvoid}, Ptr{Cvoid}), n, A, p, perm, knobs, stats, allocate, release)

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/wrappers.jl

Line 214 in 0bf2e46

    
           ccall((:symamd_l, libamd), Cint, (Int64, Ptr{Int64}, Ptr{Int64}, Ptr{Int64}, Ptr{Cdouble}, Ptr{Int64}, Ptr{Cvoid}, Ptr{Cvoid}), n, A, p, perm, knobs, stats, allocate, release)

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/wrappers.jl

Line 234 in 0bf2e46

    
           ccall((:btf_maxtrans, libbtf), Int32, (Int32, Int32, Ptr{Int32}, Ptr{Int32}, Cdouble, Ptr{Cdouble}, Ptr{Int32}, Ptr{Int32}), nrow, ncol, Ap, Ai, maxwork, work, Match, Work)

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/wrappers.jl

Line 238 in 0bf2e46

    
           ccall((:btf_l_maxtrans, libbtf), Int64, (Int64, Int64, Ptr{Int64}, Ptr{Int64}, Cdouble, Ptr{Cdouble}, Ptr{Int64}, Ptr{Int64}), arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8)

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/wrappers.jl

Line 242 in 0bf2e46

    
           ccall((:btf_strongcomp, libbtf), Int32, (Int32, Ptr{Int32}, Ptr{Int32}, Ptr{Int32}, Ptr{Int32}, Ptr{Int32}, Ptr{Int32}), n, Ap, Ai, Q, P, R, Work)

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/wrappers.jl

Line 246 in 0bf2e46

    
           ccall((:btf_l_strongcomp, libbtf), Int64, (Int64, Ptr{Int64}, Ptr{Int64}, Ptr{Int64}, Ptr{Int64}, Ptr{Int64}, Ptr{Int64}), arg1, arg2, arg3, arg4, arg5, arg6, arg7)

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/wrappers.jl

Line 250 in 0bf2e46

    
           ccall((:btf_order, libbtf), Int32, (Int32, Ptr{Int32}, Ptr{Int32}, Cdouble, Ptr{Cdouble}, Ptr{Int32}, Ptr{Int32}, Ptr{Int32}, Ptr{Int32}, Ptr{Int32}), n, Ap, Ai, maxwork, work, P, Q, R, nmatch, Work)

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/wrappers.jl

Line 254 in 0bf2e46

    
           ccall((:btf_l_order, libbtf), Int64, (Int64, Ptr{Int64}, Ptr{Int64}, Cdouble, Ptr{Cdouble}, Ptr{Int64}, Ptr{Int64}, Ptr{Int64}, Ptr{Int64}, Ptr{Int64}), arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10)

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/wrappers.jl

Line 422 in 0bf2e46

    
           ccall((:klu_analyze, libklu), Ptr{klu_symbolic}, (Int32, Ptr{Int32}, Ptr{Int32}, Ptr{klu_common}), n, Ap, Ai, Common)

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/wrappers.jl

Line 426 in 0bf2e46

    
           ccall((:klu_l_analyze, libklu), Ptr{klu_l_symbolic}, (Int64, Ptr{Int64}, Ptr{Int64}, Ptr{klu_l_common}), arg1, arg2, arg3, Common)

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/wrappers.jl

Line 430 in 0bf2e46

    
           ccall((:klu_analyze_given, libklu), Ptr{klu_symbolic}, (Int32, Ptr{Int32}, Ptr{Int32}, Ptr{Int32}, Ptr{Int32}, Ptr{klu_common}), n, Ap, Ai, P, Q, Common)

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/wrappers.jl

Line 434 in 0bf2e46

    
           ccall((:klu_l_analyze_given, libklu), Ptr{klu_l_symbolic}, (Int64, Ptr{Int64}, Ptr{Int64}, Ptr{Int64}, Ptr{Int64}, Ptr{klu_l_common}), arg1, arg2, arg3, arg4, arg5, arg6)

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/wrappers.jl

Line 438 in 0bf2e46

    
           ccall((:klu_factor, libklu), Ptr{klu_numeric}, (Ptr{Int32}, Ptr{Int32}, Ptr{Cdouble}, Ptr{klu_symbolic}, Ptr{klu_common}), Ap, Ai, Ax, Symbolic, Common)

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/wrappers.jl

Line 442 in 0bf2e46

    
           ccall((:klu_z_factor, libklu), Ptr{klu_numeric}, (Ptr{Int32}, Ptr{Int32}, Ptr{Cdouble}, Ptr{klu_symbolic}, Ptr{klu_common}), Ap, Ai, Ax, Symbolic, Common)

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/wrappers.jl

Line 446 in 0bf2e46

    
           ccall((:klu_l_factor, libklu), Ptr{klu_l_numeric}, (Ptr{Int64}, Ptr{Int64}, Ptr{Cdouble}, Ptr{klu_l_symbolic}, Ptr{klu_l_common}), arg1, arg2, arg3, arg4, arg5)

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/wrappers.jl

Line 450 in 0bf2e46

    
           ccall((:klu_zl_factor, libklu), Ptr{klu_l_numeric}, (Ptr{Int64}, Ptr{Int64}, Ptr{Cdouble}, Ptr{klu_l_symbolic}, Ptr{klu_l_common}), arg1, arg2, arg3, arg4, arg5)

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/wrappers.jl

Line 454 in 0bf2e46

    
           ccall((:klu_solve, libklu), Cint, (Ptr{klu_symbolic}, Ptr{klu_numeric}, Int32, Int32, Ptr{Cdouble}, Ptr{klu_common}), Symbolic, Numeric, ldim, nrhs, B, Common)

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/wrappers.jl

Line 458 in 0bf2e46

    
           ccall((:klu_z_solve, libklu), Cint, (Ptr{klu_symbolic}, Ptr{klu_numeric}, Int32, Int32, Ptr{Cdouble}, Ptr{klu_common}), Symbolic, Numeric, ldim, nrhs, B, Common)

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/wrappers.jl

Line 462 in 0bf2e46

    
           ccall((:klu_l_solve, libklu), Cint, (Ptr{klu_l_symbolic}, Ptr{klu_l_numeric}, Int64, Int64, Ptr{Cdouble}, Ptr{klu_l_common}), arg1, arg2, arg3, arg4, arg5, arg6)

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/wrappers.jl

Line 466 in 0bf2e46

    
           ccall((:klu_zl_solve, libklu), Cint, (Ptr{klu_l_symbolic}, Ptr{klu_l_numeric}, Int64, Int64, Ptr{Cdouble}, Ptr{klu_l_common}), arg1, arg2, arg3, arg4, arg5, arg6)

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/wrappers.jl

Line 470 in 0bf2e46

    
           ccall((:klu_tsolve, libklu), Cint, (Ptr{klu_symbolic}, Ptr{klu_numeric}, Int32, Int32, Ptr{Cdouble}, Ptr{klu_common}), Symbolic, Numeric, ldim, nrhs, B, Common)

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/wrappers.jl

Line 474 in 0bf2e46

    
           ccall((:klu_z_tsolve, libklu), Cint, (Ptr{klu_symbolic}, Ptr{klu_numeric}, Int32, Int32, Ptr{Cdouble}, Cint, Ptr{klu_common}), Symbolic, Numeric, ldim, nrhs, B, conj_solve, Common)

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/wrappers.jl

Line 478 in 0bf2e46

    
           ccall((:klu_l_tsolve, libklu), Cint, (Ptr{klu_l_symbolic}, Ptr{klu_l_numeric}, Int64, Int64, Ptr{Cdouble}, Ptr{klu_l_common}), arg1, arg2, arg3, arg4, arg5, arg6)

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/wrappers.jl

Line 482 in 0bf2e46

    
           ccall((:klu_zl_tsolve, libklu), Cint, (Ptr{klu_l_symbolic}, Ptr{klu_l_numeric}, Int64, Int64, Ptr{Cdouble}, Cint, Ptr{klu_l_common}), arg1, arg2, arg3, arg4, arg5, arg6, arg7)

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/wrappers.jl

Line 486 in 0bf2e46

    
           ccall((:klu_refactor, libklu), Cint, (Ptr{Int32}, Ptr{Int32}, Ptr{Cdouble}, Ptr{klu_symbolic}, Ptr{klu_numeric}, Ptr{klu_common}), Ap, Ai, Ax, Symbolic, Numeric, Common)

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/wrappers.jl

Line 490 in 0bf2e46

    
           ccall((:klu_z_refactor, libklu), Cint, (Ptr{Int32}, Ptr{Int32}, Ptr{Cdouble}, Ptr{klu_symbolic}, Ptr{klu_numeric}, Ptr{klu_common}), Ap, Ai, Ax, Symbolic, Numeric, Common)

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/wrappers.jl

Line 494 in 0bf2e46

    
           ccall((:klu_l_refactor, libklu), Cint, (Ptr{Int64}, Ptr{Int64}, Ptr{Cdouble}, Ptr{klu_l_symbolic}, Ptr{klu_l_numeric}, Ptr{klu_l_common}), arg1, arg2, arg3, arg4, arg5, arg6)

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/wrappers.jl

Line 498 in 0bf2e46

    
           ccall((:klu_zl_refactor, libklu), Cint, (Ptr{Int64}, Ptr{Int64}, Ptr{Cdouble}, Ptr{klu_l_symbolic}, Ptr{klu_l_numeric}, Ptr{klu_l_common}), arg1, arg2, arg3, arg4, arg5, arg6)

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/wrappers.jl

Line 502 in 0bf2e46

    
           ccall((:klu_free_symbolic, libklu), Cint, (Ptr{Ptr{klu_symbolic}}, Ptr{klu_common}), Symbolic, Common)

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/wrappers.jl

Line 506 in 0bf2e46

    
           ccall((:klu_l_free_symbolic, libklu), Cint, (Ptr{Ptr{klu_l_symbolic}}, Ptr{klu_l_common}), arg1, arg2)

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/wrappers.jl

Line 510 in 0bf2e46

    
           ccall((:klu_free_numeric, libklu), Cint, (Ptr{Ptr{klu_numeric}}, Ptr{klu_common}), Numeric, Common)

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/wrappers.jl

Line 514 in 0bf2e46

    
           ccall((:klu_z_free_numeric, libklu), Cint, (Ptr{Ptr{klu_numeric}}, Ptr{klu_common}), Numeric, Common)

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/wrappers.jl

Line 518 in 0bf2e46

    
           ccall((:klu_l_free_numeric, libklu), Cint, (Ptr{Ptr{klu_l_numeric}}, Ptr{klu_l_common}), arg1, arg2)

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/wrappers.jl

Line 522 in 0bf2e46

    
           ccall((:klu_zl_free_numeric, libklu), Cint, (Ptr{Ptr{klu_l_numeric}}, Ptr{klu_l_common}), arg1, arg2)

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/wrappers.jl

Line 526 in 0bf2e46

    
           ccall((:klu_sort, libklu), Cint, (Ptr{klu_symbolic}, Ptr{klu_numeric}, Ptr{klu_common}), Symbolic, Numeric, Common)

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/wrappers.jl

Line 530 in 0bf2e46

    
           ccall((:klu_z_sort, libklu), Cint, (Ptr{klu_symbolic}, Ptr{klu_numeric}, Ptr{klu_common}), Symbolic, Numeric, Common)

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/wrappers.jl

Line 534 in 0bf2e46

    
           ccall((:klu_l_sort, libklu), Cint, (Ptr{klu_l_symbolic}, Ptr{klu_l_numeric}, Ptr{klu_l_common}), arg1, arg2, arg3)

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/wrappers.jl

Line 538 in 0bf2e46

    
           ccall((:klu_zl_sort, libklu), Cint, (Ptr{klu_l_symbolic}, Ptr{klu_l_numeric}, Ptr{klu_l_common}), arg1, arg2, arg3)

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/wrappers.jl

Line 542 in 0bf2e46

    
           ccall((:klu_flops, libklu), Cint, (Ptr{klu_symbolic}, Ptr{klu_numeric}, Ptr{klu_common}), Symbolic, Numeric, Common)

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/wrappers.jl

Line 546 in 0bf2e46

    
           ccall((:klu_z_flops, libklu), Cint, (Ptr{klu_symbolic}, Ptr{klu_numeric}, Ptr{klu_common}), Symbolic, Numeric, Common)

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/wrappers.jl

Line 550 in 0bf2e46

    
           ccall((:klu_l_flops, libklu), Cint, (Ptr{klu_l_symbolic}, Ptr{klu_l_numeric}, Ptr{klu_l_common}), arg1, arg2, arg3)

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/wrappers.jl

Line 554 in 0bf2e46

    
           ccall((:klu_zl_flops, libklu), Cint, (Ptr{klu_l_symbolic}, Ptr{klu_l_numeric}, Ptr{klu_l_common}), arg1, arg2, arg3)

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/wrappers.jl

Line 558 in 0bf2e46

    
           ccall((:klu_rgrowth, libklu), Cint, (Ptr{Int32}, Ptr{Int32}, Ptr{Cdouble}, Ptr{klu_symbolic}, Ptr{klu_numeric}, Ptr{klu_common}), Ap, Ai, Ax, Symbolic, Numeric, Common)

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/wrappers.jl

Line 562 in 0bf2e46

    
           ccall((:klu_z_rgrowth, libklu), Cint, (Ptr{Int32}, Ptr{Int32}, Ptr{Cdouble}, Ptr{klu_symbolic}, Ptr{klu_numeric}, Ptr{klu_common}), Ap, Ai, Ax, Symbolic, Numeric, Common)

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/wrappers.jl

Line 566 in 0bf2e46

    
           ccall((:klu_l_rgrowth, libklu), Cint, (Ptr{Int64}, Ptr{Int64}, Ptr{Cdouble}, Ptr{klu_l_symbolic}, Ptr{klu_l_numeric}, Ptr{klu_l_common}), arg1, arg2, arg3, arg4, arg5, arg6)

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/wrappers.jl

Line 570 in 0bf2e46

    
           ccall((:klu_zl_rgrowth, libklu), Cint, (Ptr{Int64}, Ptr{Int64}, Ptr{Cdouble}, Ptr{klu_l_symbolic}, Ptr{klu_l_numeric}, Ptr{klu_l_common}), arg1, arg2, arg3, arg4, arg5, arg6)

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/wrappers.jl

Line 574 in 0bf2e46

    
           ccall((:klu_condest, libklu), Cint, (Ptr{Int32}, Ptr{Cdouble}, Ptr{klu_symbolic}, Ptr{klu_numeric}, Ptr{klu_common}), Ap, Ax, Symbolic, Numeric, Common)

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/wrappers.jl

Line 578 in 0bf2e46

    
           ccall((:klu_z_condest, libklu), Cint, (Ptr{Int32}, Ptr{Cdouble}, Ptr{klu_symbolic}, Ptr{klu_numeric}, Ptr{klu_common}), Ap, Ax, Symbolic, Numeric, Common)

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/wrappers.jl

Line 582 in 0bf2e46

    
           ccall((:klu_l_condest, libklu), Cint, (Ptr{Int64}, Ptr{Cdouble}, Ptr{klu_l_symbolic}, Ptr{klu_l_numeric}, Ptr{klu_l_common}), arg1, arg2, arg3, arg4, arg5)

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/wrappers.jl

Line 586 in 0bf2e46

    
           ccall((:klu_zl_condest, libklu), Cint, (Ptr{Int64}, Ptr{Cdouble}, Ptr{klu_l_symbolic}, Ptr{klu_l_numeric}, Ptr{klu_l_common}), arg1, arg2, arg3, arg4, arg5)

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/wrappers.jl

Line 590 in 0bf2e46

    
           ccall((:klu_rcond, libklu), Cint, (Ptr{klu_symbolic}, Ptr{klu_numeric}, Ptr{klu_common}), Symbolic, Numeric, Common)

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/wrappers.jl

Line 594 in 0bf2e46

    
           ccall((:klu_z_rcond, libklu), Cint, (Ptr{klu_symbolic}, Ptr{klu_numeric}, Ptr{klu_common}), Symbolic, Numeric, Common)

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/wrappers.jl

Line 598 in 0bf2e46

    
           ccall((:klu_l_rcond, libklu), Cint, (Ptr{klu_l_symbolic}, Ptr{klu_l_numeric}, Ptr{klu_l_common}), arg1, arg2, arg3)

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/wrappers.jl

Line 602 in 0bf2e46

    
           ccall((:klu_zl_rcond, libklu), Cint, (Ptr{klu_l_symbolic}, Ptr{klu_l_numeric}, Ptr{klu_l_common}), arg1, arg2, arg3)

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/wrappers.jl

Line 606 in 0bf2e46

    
           ccall((:klu_scale, libklu), Cint, (Cint, Int32, Ptr{Int32}, Ptr{Int32}, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Int32}, Ptr{klu_common}), scale, n, Ap, Ai, Ax, Rs, W, Common)

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/wrappers.jl

Line 610 in 0bf2e46

    
           ccall((:klu_z_scale, libklu), Cint, (Cint, Int32, Ptr{Int32}, Ptr{Int32}, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Int32}, Ptr{klu_common}), scale, n, Ap, Ai, Ax, Rs, W, Common)

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/wrappers.jl

Line 614 in 0bf2e46

    
           ccall((:klu_l_scale, libklu), Cint, (Cint, Int64, Ptr{Int64}, Ptr{Int64}, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Int64}, Ptr{klu_l_common}), arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8)

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/wrappers.jl

Lines 618 to 634 in 0bf2e46

    
               ccall((:klu_zl_scale, libklu), Cint, (Cint, Int64, Ptr{Int64}, Ptr{Int64}, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Int64}, Ptr{klu_l_common}), arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8) 
        
           end 
        
           function klu_extract(Numeric, Symbolic, Lp, Li, Lx, Up, Ui, Ux, Fp, Fi, Fx, P, Q, Rs, R, Common) 
        
               ccall((:klu_extract, libklu), Cint, (Ptr{klu_numeric}, Ptr{klu_symbolic}, Ptr{Int32}, Ptr{Int32}, Ptr{Cdouble}, Ptr{Int32}, Ptr{Int32}, Ptr{Cdouble}, Ptr{Int32}, Ptr{Int32}, Ptr{Cdouble}, Ptr{Int32}, Ptr{Int32}, Ptr{Cdouble}, Ptr{Int32}, Ptr{klu_common}), Numeric, Symbolic, Lp, Li, Lx, Up, Ui, Ux, Fp, Fi, Fx, P, Q, Rs, R, Common) 
        
           end 
        
           function klu_z_extract(Numeric, Symbolic, Lp, Li, Lx, Lz, Up, Ui, Ux, Uz, Fp, Fi, Fx, Fz, P, Q, Rs, R, Common) 
        
               ccall((:klu_z_extract, libklu), Cint, (Ptr{klu_numeric}, Ptr{klu_symbolic}, Ptr{Int32}, Ptr{Int32}, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Int32}, Ptr{Int32}, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Int32}, Ptr{Int32}, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Int32}, Ptr{Int32}, Ptr{Cdouble}, Ptr{Int32}, Ptr{klu_common}), Numeric, Symbolic, Lp, Li, Lx, Lz, Up, Ui, Ux, Uz, Fp, Fi, Fx, Fz, P, Q, Rs, R, Common) 
        
           end 
        
           function klu_l_extract(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14, arg15, arg16) 
        
               ccall((:klu_l_extract, libklu), Cint, (Ptr{klu_l_numeric}, Ptr{klu_l_symbolic}, Ptr{Int64}, Ptr{Int64}, Ptr{Cdouble}, Ptr{Int64}, Ptr{Int64}, Ptr{Cdouble}, Ptr{Int64}, Ptr{Int64}, Ptr{Cdouble}, Ptr{Int64}, Ptr{Int64}, Ptr{Cdouble}, Ptr{Int64}, Ptr{klu_l_common}), arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14, arg15, arg16) 
        
           end 
        
           function klu_zl_extract(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14, arg15, arg16, arg17, arg18, arg19) 
        
               ccall((:klu_zl_extract, libklu), Cint, (Ptr{klu_l_numeric}, Ptr{klu_l_symbolic}, Ptr{Int64}, Ptr{Int64}, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Int64}, Ptr{Int64}, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Int64}, Ptr{Int64}, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Int64}, Ptr{Int64}, Ptr{Cdouble}, Ptr{Int64}, Ptr{klu_l_common}), arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14, arg15, arg16, arg17, arg18, arg19)

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/wrappers.jl

Line 638 in 0bf2e46

    
           ccall((:klu_malloc, libklu), Ptr{Cvoid}, (Csize_t, Csize_t, Ptr{klu_common}), n, size, Common)

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/wrappers.jl

Line 642 in 0bf2e46

    
           ccall((:klu_free, libklu), Ptr{Cvoid}, (Ptr{Cvoid}, Csize_t, Csize_t, Ptr{klu_common}), p, n, size, Common)

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/wrappers.jl

Line 646 in 0bf2e46

    
           ccall((:klu_realloc, libklu), Ptr{Cvoid}, (Csize_t, Csize_t, Csize_t, Ptr{Cvoid}, Ptr{klu_common}), nnew, nold, size, p, Common)

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/wrappers.jl

Line 650 in 0bf2e46

    
           ccall((:klu_l_malloc, libklu), Ptr{Cvoid}, (Csize_t, Csize_t, Ptr{klu_l_common}), arg1, arg2, arg3)

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/wrappers.jl

Line 654 in 0bf2e46

    
           ccall((:klu_l_free, libklu), Ptr{Cvoid}, (Ptr{Cvoid}, Csize_t, Csize_t, Ptr{klu_l_common}), arg1, arg2, arg3, arg4)

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/wrappers.jl

Line 658 in 0bf2e46

    
           ccall((:klu_l_realloc, libklu), Ptr{Cvoid}, (Csize_t, Csize_t, Csize_t, Ptr{Cvoid}, Ptr{klu_l_common}), arg1, arg2, arg3, arg4, arg5)

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/wrappers.jl

Line 693 in 0bf2e46

    
           const SUITESPARSE_VERSION = SUITESPARSE_VER_CODE(SUITESPARSE_MAIN_VERSION, SUITESPARSE_SUB_VERSION)

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/wrappers.jl

Line 845 in 0bf2e46

const KLU_VERSION = KLU_VERSION_CODE(KLU_MAIN_VERSION, KLU_SUB_VERSION)

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/default.jl

Line 174 in 0bf2e46

Base.get_extension(@__MODULE__, :LinearSolveRecursiveFactorizationExt)

github-actions · 2025-02-05T03:50:05Z

src/KLU/klu.jl

+            Fz = Tv == Float64 ? C_NULL : Vector{Float64}(undef, fnz)
+            _extract!(klu; Fp, Fi, Fx, Fz)
+            # F is *not* sorted on output, so we'll have to do it here:
+            for i ∈ 1:(length(Fp) - 1)


[JuliaFormatter] _{reported by reviewdog 🐶}

Suggested change

for i ∈ 1:(length(Fp) - 1)

for i in 1:(length(Fp) - 1)

github-actions · 2025-02-05T03:50:05Z

src/KLU/klu.jl

+            for i ∈ 1:(length(Fp) - 1)
+                # find each segment
+                first = Fp[i] + 1
+                last = Fp[i+1]


[JuliaFormatter] _{reported by reviewdog 🐶}

Suggested change

last = Fp[i+1]

last = Fp[i + 1]

github-actions · 2025-02-05T03:50:05Z

src/KLU/klu.jl

+        if Tv == Float64
+            return SparseMatrixCSC(klu.n, klu.n, increment!(p), increment!(i), x)
+        else
+            return SparseMatrixCSC(klu.n, klu.n, increment!(p), increment!(i), Complex.(x, z))


[JuliaFormatter] _{reported by reviewdog 🐶}

Suggested change

return SparseMatrixCSC(klu.n, klu.n, increment!(p), increment!(i), Complex.(x, z))

return SparseMatrixCSC(

klu.n, klu.n, increment!(p), increment!(i), Complex.(x, z))

github-actions · 2025-02-05T03:50:05Z

src/KLU/klu.jl

+function LinearAlgebra.issuccess(K::AbstractKLUFactorization; allowsingular=false)
+    return (allowsingular ? K.common.status >= KLU_OK : K.common.status == KLU_OK) && K._numeric != C_NULL


[JuliaFormatter] _{reported by reviewdog 🐶}

Suggested change

function LinearAlgebra.issuccess(K::AbstractKLUFactorization; allowsingular=false)

return (allowsingular ? K.common.status >= KLU_OK : K.common.status == KLU_OK) && K._numeric != C_NULL

function LinearAlgebra.issuccess(K::AbstractKLUFactorization; allowsingular = false)

return (allowsingular ? K.common.status >= KLU_OK : K.common.status == KLU_OK) &&

K._numeric != C_NULL

github-actions · 2025-02-05T03:50:06Z

src/KLU/klu.jl

+    return (allowsingular ? K.common.status >= KLU_OK : K.common.status == KLU_OK) && K._numeric != C_NULL
+end
+function show(io::IO, mime::MIME{Symbol("text/plain")}, K::AbstractKLUFactorization)
+    summary(io, K); println(io)


[JuliaFormatter] _{reported by reviewdog 🐶}

Suggested change

summary(io, K); println(io)

summary(io, K)

println(io)

github-actions · 2025-02-05T03:50:08Z

src/KLU/klu.jl

+See also: [`klu`](@ref)
+
+# Arguments
+  - `K::KLUFactorization`: The matrix factorization object, previously created by a call to `klu`, to be re-factored.


[JuliaFormatter] _{reported by reviewdog 🐶}

Suggested change

- `K::KLUFactorization`: The matrix factorization object, previously created by a call to `klu`, to be re-factored.

- `K::KLUFactorization`: The matrix factorization object, previously created by a call to `klu`, to be re-factored.

github-actions · 2025-02-05T03:50:08Z

src/KLU/klu.jl

+  - `A::SparseMatrixCSC` or `n::Integer`, `colptr::Vector{Ti}`, `rowval::Vector{Ti}`, `nzval::Vector{Tv}`: The sparse matrix or the zero-based sparse matrix components to be factored.
+  - `check::Bool`: If `true` (default) check for errors after the factorization. If `false` errors must be checked by the user with `klu.common.status`.
+  - `allowsingular::Bool`: If `true` (default `false`) allow the factorization to proceed even if the matrix is singular. Note that this will allow for
+  silent divide by zero errors in subsequent `solve!` or `ldiv!` calls if singularity is not checked by the user with `klu.common.status == KLU.KLU_SINGULAR`


[JuliaFormatter] _{reported by reviewdog 🐶}

Suggested change

silent divide by zero errors in subsequent `solve!` or `ldiv!` calls if singularity is not checked by the user with `klu.common.status == KLU.KLU_SINGULAR`

silent divide by zero errors in subsequent `solve!` or `ldiv!` calls if singularity is not checked by the user with `klu.common.status == KLU.KLU_SINGULAR`

github-actions · 2025-02-05T03:50:08Z

src/KLU/klu.jl

+  silent divide by zero errors in subsequent `solve!` or `ldiv!` calls if singularity is not checked by the user with `klu.common.status == KLU.KLU_SINGULAR`
+
+!!! note
+    `klu(A::SparseMatrixCSC)` uses the KLU[^ACM907] library that is part of


[JuliaFormatter] _{reported by reviewdog 🐶}

Suggested change

`klu(A::SparseMatrixCSC)` uses the KLU[^ACM907] library that is part of

`klu(A::SparseMatrixCSC)` uses the KLU[^ACM907] library that is part of

github-actions · 2025-02-05T03:50:08Z

src/KLU/klu.jl

+"""
+klu!
+
+for Tv ∈ KLUValueTypes, Ti ∈ KLUIndexTypes


[JuliaFormatter] _{reported by reviewdog 🐶}

Suggested change

for Tv ∈ KLUValueTypes, Ti ∈ KLUIndexTypes

for Tv in KLUValueTypes, Ti in KLUIndexTypes

github-actions · 2025-02-05T03:50:08Z

src/KLU/klu.jl

+        function klu!(K::KLUFactorization{$Tv, $Ti}, nzval::Vector{$Tv}; check=true, allowsingular=false)
+            length(nzval) != length(K.nzval)  && throw(DimensionMismatch())


[JuliaFormatter] _{reported by reviewdog 🐶}

Suggested change

function klu!(K::KLUFactorization{$Tv, $Ti}, nzval::Vector{$Tv}; check=true, allowsingular=false)

length(nzval) != length(K.nzval) && throw(DimensionMismatch())

function klu!(K::KLUFactorization{$Tv, $Ti}, nzval::Vector{$Tv};

check = true, allowsingular = false)

length(nzval) != length(K.nzval) && throw(DimensionMismatch())

RecrusiveFactorization.jl brings in the LoopVectorization.jl stack, and so it's not a small dependency. It is a good thing to default to often, but we can make it a bit more optional in order to greatly decrease load times.

Co-authored-by: github-actions[bot] <41898282+github-actions[bot]@users.noreply.github.com>

…RecursiveFactorizationExt.jl

Co-authored-by: github-actions[bot] <41898282+github-actions[bot]@users.noreply.github.com>

RecrusiveFactorization.jl brings in the LoopVectorization.jl stack, and so it's not a small dependency. It is a good thing to default to often, but we can make it a bit more optional in order to greatly decrease load times.

We shouldn't need to load all of the sparse arrays infrastructure unless the user is using sparse arrays. There are a few things that need to be done here: 1. KLU.jl code needs to be copied so we can default to KLU calls without requiring a user-level `using KLU` 2. Some functions are made which only get a useful dispatch after using SparseArrays is loaded, but that should be sufficiently safe But one big issue is that Krylov.jl has a dependency on SparseArrays, so we'd either need to drop it as a dependency and a new Krylov library, or fix Krylov.jl to make it an extension.

github-actions

Remaining comments which cannot be posted as a review comment to avoid GitHub Rate Limit

JuliaFormatter

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/wrappers.jl

Line 74 in 4f6225c

    
           ccall((:SuiteSparse_config_hypot, libsuitesparseconfig), Cdouble, (Cdouble, Cdouble), x, y)

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/wrappers.jl

Line 78 in 4f6225c

    
           ccall((:SuiteSparse_config_divcomplex, libsuitesparseconfig), Cint, (Cdouble, Cdouble, Cdouble, Cdouble, Ptr{Cdouble}, Ptr{Cdouble}), xr, xi, yr, yi, zr, zi)

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/wrappers.jl

Line 90 in 4f6225c

    
           ccall((:SuiteSparse_malloc, libsuitesparseconfig), Ptr{Cvoid}, (Csize_t, Csize_t), nitems, size_of_item)

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/wrappers.jl

Line 94 in 4f6225c

    
           ccall((:SuiteSparse_calloc, libsuitesparseconfig), Ptr{Cvoid}, (Csize_t, Csize_t), nitems, size_of_item)

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/wrappers.jl

Line 98 in 4f6225c

    
           ccall((:SuiteSparse_realloc, libsuitesparseconfig), Ptr{Cvoid}, (Csize_t, Csize_t, Csize_t, Ptr{Cvoid}, Ptr{Cint}), nitems_new, nitems_old, size_of_item, p, ok)

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/wrappers.jl

Line 122 in 4f6225c

    
           ccall((:SuiteSparse_divcomplex, libsuitesparseconfig), Cint, (Cdouble, Cdouble, Cdouble, Cdouble, Ptr{Cdouble}, Ptr{Cdouble}), ar, ai, br, bi, cr, ci)

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/wrappers.jl

Line 138 in 4f6225c

    
           ccall((:amd_order, libamd), Cint, (Int32, Ptr{Int32}, Ptr{Int32}, Ptr{Int32}, Ptr{Cdouble}, Ptr{Cdouble}), n, Ap, Ai, P, Control, Info)

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/wrappers.jl

Lines 142 to 150 in 4f6225c

    
               ccall((:amd_l_order, libamd), Cint, (Int64, Ptr{Int64}, Ptr{Int64}, Ptr{Int64}, Ptr{Cdouble}, Ptr{Cdouble}), n, Ap, Ai, P, Control, Info) 
        
           end 
        
           function amd_2(n, Pe, Iw, Len, iwlen, pfree, Nv, Next, Last, Head, Elen, Degree, W, Control, Info) 
        
               ccall((:amd_2, libamd), Cvoid, (Int32, Ptr{Int32}, Ptr{Int32}, Ptr{Int32}, Int32, Int32, Ptr{Int32}, Ptr{Int32}, Ptr{Int32}, Ptr{Int32}, Ptr{Int32}, Ptr{Int32}, Ptr{Int32}, Ptr{Cdouble}, Ptr{Cdouble}), n, Pe, Iw, Len, iwlen, pfree, Nv, Next, Last, Head, Elen, Degree, W, Control, Info) 
        
           end 
        
           function amd_l2(n, Pe, Iw, Len, iwlen, pfree, Nv, Next, Last, Head, Elen, Degree, W, Control, Info) 
        
               ccall((:amd_l2, libamd), Cvoid, (Int64, Ptr{Int64}, Ptr{Int64}, Ptr{Int64}, Int64, Int64, Ptr{Int64}, Ptr{Int64}, Ptr{Int64}, Ptr{Int64}, Ptr{Int64}, Ptr{Int64}, Ptr{Int64}, Ptr{Cdouble}, Ptr{Cdouble}), n, Pe, Iw, Len, iwlen, pfree, Nv, Next, Last, Head, Elen, Degree, W, Control, Info)

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/wrappers.jl

Line 154 in 4f6225c

    
           ccall((:amd_valid, libamd), Cint, (Int32, Int32, Ptr{Int32}, Ptr{Int32}), n_row, n_col, Ap, Ai)

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/wrappers.jl

Line 158 in 4f6225c

    
           ccall((:amd_l_valid, libamd), Cint, (Int64, Int64, Ptr{Int64}, Ptr{Int64}), n_row, n_col, Ap, Ai)

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/wrappers.jl

Line 190 in 4f6225c

    
           ccall((:colamd_l_recommended, libamd), Csize_t, (Int64, Int64, Int64), nnz, n_row, n_col)

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/wrappers.jl

Line 202 in 4f6225c

    
           ccall((:colamd, libamd), Cint, (Int32, Int32, Int32, Ptr{Int32}, Ptr{Int32}, Ptr{Cdouble}, Ptr{Int32}), n_row, n_col, Alen, A, p, knobs, stats)

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/wrappers.jl

Line 206 in 4f6225c

    
           ccall((:colamd_l, libamd), Cint, (Int64, Int64, Int64, Ptr{Int64}, Ptr{Int64}, Ptr{Cdouble}, Ptr{Int64}), n_row, n_col, Alen, A, p, knobs, stats)

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/wrappers.jl

Line 210 in 4f6225c

    
           ccall((:symamd, libamd), Cint, (Int32, Ptr{Int32}, Ptr{Int32}, Ptr{Int32}, Ptr{Cdouble}, Ptr{Int32}, Ptr{Cvoid}, Ptr{Cvoid}), n, A, p, perm, knobs, stats, allocate, release)

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/wrappers.jl

Line 214 in 4f6225c

    
           ccall((:symamd_l, libamd), Cint, (Int64, Ptr{Int64}, Ptr{Int64}, Ptr{Int64}, Ptr{Cdouble}, Ptr{Int64}, Ptr{Cvoid}, Ptr{Cvoid}), n, A, p, perm, knobs, stats, allocate, release)

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/wrappers.jl

Line 234 in 4f6225c

    
           ccall((:btf_maxtrans, libbtf), Int32, (Int32, Int32, Ptr{Int32}, Ptr{Int32}, Cdouble, Ptr{Cdouble}, Ptr{Int32}, Ptr{Int32}), nrow, ncol, Ap, Ai, maxwork, work, Match, Work)

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/wrappers.jl

Line 238 in 4f6225c

    
           ccall((:btf_l_maxtrans, libbtf), Int64, (Int64, Int64, Ptr{Int64}, Ptr{Int64}, Cdouble, Ptr{Cdouble}, Ptr{Int64}, Ptr{Int64}), arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8)

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/wrappers.jl

Line 242 in 4f6225c

    
           ccall((:btf_strongcomp, libbtf), Int32, (Int32, Ptr{Int32}, Ptr{Int32}, Ptr{Int32}, Ptr{Int32}, Ptr{Int32}, Ptr{Int32}), n, Ap, Ai, Q, P, R, Work)

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/wrappers.jl

Line 246 in 4f6225c

    
           ccall((:btf_l_strongcomp, libbtf), Int64, (Int64, Ptr{Int64}, Ptr{Int64}, Ptr{Int64}, Ptr{Int64}, Ptr{Int64}, Ptr{Int64}), arg1, arg2, arg3, arg4, arg5, arg6, arg7)

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/wrappers.jl

Line 250 in 4f6225c

    
           ccall((:btf_order, libbtf), Int32, (Int32, Ptr{Int32}, Ptr{Int32}, Cdouble, Ptr{Cdouble}, Ptr{Int32}, Ptr{Int32}, Ptr{Int32}, Ptr{Int32}, Ptr{Int32}), n, Ap, Ai, maxwork, work, P, Q, R, nmatch, Work)

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/wrappers.jl

Line 254 in 4f6225c

    
           ccall((:btf_l_order, libbtf), Int64, (Int64, Ptr{Int64}, Ptr{Int64}, Cdouble, Ptr{Cdouble}, Ptr{Int64}, Ptr{Int64}, Ptr{Int64}, Ptr{Int64}, Ptr{Int64}), arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10)

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/wrappers.jl

Line 422 in 4f6225c

    
           ccall((:klu_analyze, libklu), Ptr{klu_symbolic}, (Int32, Ptr{Int32}, Ptr{Int32}, Ptr{klu_common}), n, Ap, Ai, Common)

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/wrappers.jl

Line 426 in 4f6225c

    
           ccall((:klu_l_analyze, libklu), Ptr{klu_l_symbolic}, (Int64, Ptr{Int64}, Ptr{Int64}, Ptr{klu_l_common}), arg1, arg2, arg3, Common)

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/wrappers.jl

Line 430 in 4f6225c

    
           ccall((:klu_analyze_given, libklu), Ptr{klu_symbolic}, (Int32, Ptr{Int32}, Ptr{Int32}, Ptr{Int32}, Ptr{Int32}, Ptr{klu_common}), n, Ap, Ai, P, Q, Common)

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/wrappers.jl

Line 434 in 4f6225c

    
           ccall((:klu_l_analyze_given, libklu), Ptr{klu_l_symbolic}, (Int64, Ptr{Int64}, Ptr{Int64}, Ptr{Int64}, Ptr{Int64}, Ptr{klu_l_common}), arg1, arg2, arg3, arg4, arg5, arg6)

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/wrappers.jl

Line 438 in 4f6225c

    
           ccall((:klu_factor, libklu), Ptr{klu_numeric}, (Ptr{Int32}, Ptr{Int32}, Ptr{Cdouble}, Ptr{klu_symbolic}, Ptr{klu_common}), Ap, Ai, Ax, Symbolic, Common)

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/wrappers.jl

Line 442 in 4f6225c

    
           ccall((:klu_z_factor, libklu), Ptr{klu_numeric}, (Ptr{Int32}, Ptr{Int32}, Ptr{Cdouble}, Ptr{klu_symbolic}, Ptr{klu_common}), Ap, Ai, Ax, Symbolic, Common)

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/wrappers.jl

Line 446 in 4f6225c

    
           ccall((:klu_l_factor, libklu), Ptr{klu_l_numeric}, (Ptr{Int64}, Ptr{Int64}, Ptr{Cdouble}, Ptr{klu_l_symbolic}, Ptr{klu_l_common}), arg1, arg2, arg3, arg4, arg5)

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/wrappers.jl

Line 450 in 4f6225c

    
           ccall((:klu_zl_factor, libklu), Ptr{klu_l_numeric}, (Ptr{Int64}, Ptr{Int64}, Ptr{Cdouble}, Ptr{klu_l_symbolic}, Ptr{klu_l_common}), arg1, arg2, arg3, arg4, arg5)

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/wrappers.jl

Line 454 in 4f6225c

    
           ccall((:klu_solve, libklu), Cint, (Ptr{klu_symbolic}, Ptr{klu_numeric}, Int32, Int32, Ptr{Cdouble}, Ptr{klu_common}), Symbolic, Numeric, ldim, nrhs, B, Common)

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/wrappers.jl

Line 458 in 4f6225c

    
           ccall((:klu_z_solve, libklu), Cint, (Ptr{klu_symbolic}, Ptr{klu_numeric}, Int32, Int32, Ptr{Cdouble}, Ptr{klu_common}), Symbolic, Numeric, ldim, nrhs, B, Common)

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/wrappers.jl

Line 462 in 4f6225c

    
           ccall((:klu_l_solve, libklu), Cint, (Ptr{klu_l_symbolic}, Ptr{klu_l_numeric}, Int64, Int64, Ptr{Cdouble}, Ptr{klu_l_common}), arg1, arg2, arg3, arg4, arg5, arg6)

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/wrappers.jl

Line 466 in 4f6225c

    
           ccall((:klu_zl_solve, libklu), Cint, (Ptr{klu_l_symbolic}, Ptr{klu_l_numeric}, Int64, Int64, Ptr{Cdouble}, Ptr{klu_l_common}), arg1, arg2, arg3, arg4, arg5, arg6)

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/wrappers.jl

Line 470 in 4f6225c

    
           ccall((:klu_tsolve, libklu), Cint, (Ptr{klu_symbolic}, Ptr{klu_numeric}, Int32, Int32, Ptr{Cdouble}, Ptr{klu_common}), Symbolic, Numeric, ldim, nrhs, B, Common)

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/wrappers.jl

Line 474 in 4f6225c

    
           ccall((:klu_z_tsolve, libklu), Cint, (Ptr{klu_symbolic}, Ptr{klu_numeric}, Int32, Int32, Ptr{Cdouble}, Cint, Ptr{klu_common}), Symbolic, Numeric, ldim, nrhs, B, conj_solve, Common)

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/wrappers.jl

Line 478 in 4f6225c

    
           ccall((:klu_l_tsolve, libklu), Cint, (Ptr{klu_l_symbolic}, Ptr{klu_l_numeric}, Int64, Int64, Ptr{Cdouble}, Ptr{klu_l_common}), arg1, arg2, arg3, arg4, arg5, arg6)

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/wrappers.jl

Line 482 in 4f6225c

    
           ccall((:klu_zl_tsolve, libklu), Cint, (Ptr{klu_l_symbolic}, Ptr{klu_l_numeric}, Int64, Int64, Ptr{Cdouble}, Cint, Ptr{klu_l_common}), arg1, arg2, arg3, arg4, arg5, arg6, arg7)

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/wrappers.jl

Line 486 in 4f6225c

    
           ccall((:klu_refactor, libklu), Cint, (Ptr{Int32}, Ptr{Int32}, Ptr{Cdouble}, Ptr{klu_symbolic}, Ptr{klu_numeric}, Ptr{klu_common}), Ap, Ai, Ax, Symbolic, Numeric, Common)

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/wrappers.jl

Line 490 in 4f6225c

    
           ccall((:klu_z_refactor, libklu), Cint, (Ptr{Int32}, Ptr{Int32}, Ptr{Cdouble}, Ptr{klu_symbolic}, Ptr{klu_numeric}, Ptr{klu_common}), Ap, Ai, Ax, Symbolic, Numeric, Common)

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/wrappers.jl

Line 494 in 4f6225c

    
           ccall((:klu_l_refactor, libklu), Cint, (Ptr{Int64}, Ptr{Int64}, Ptr{Cdouble}, Ptr{klu_l_symbolic}, Ptr{klu_l_numeric}, Ptr{klu_l_common}), arg1, arg2, arg3, arg4, arg5, arg6)

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/wrappers.jl

Line 498 in 4f6225c

    
           ccall((:klu_zl_refactor, libklu), Cint, (Ptr{Int64}, Ptr{Int64}, Ptr{Cdouble}, Ptr{klu_l_symbolic}, Ptr{klu_l_numeric}, Ptr{klu_l_common}), arg1, arg2, arg3, arg4, arg5, arg6)

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/wrappers.jl

Line 502 in 4f6225c

    
           ccall((:klu_free_symbolic, libklu), Cint, (Ptr{Ptr{klu_symbolic}}, Ptr{klu_common}), Symbolic, Common)

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/wrappers.jl

Line 506 in 4f6225c

    
           ccall((:klu_l_free_symbolic, libklu), Cint, (Ptr{Ptr{klu_l_symbolic}}, Ptr{klu_l_common}), arg1, arg2)

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/wrappers.jl

Line 510 in 4f6225c

    
           ccall((:klu_free_numeric, libklu), Cint, (Ptr{Ptr{klu_numeric}}, Ptr{klu_common}), Numeric, Common)

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/wrappers.jl

Line 514 in 4f6225c

    
           ccall((:klu_z_free_numeric, libklu), Cint, (Ptr{Ptr{klu_numeric}}, Ptr{klu_common}), Numeric, Common)

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/wrappers.jl

Line 518 in 4f6225c

    
           ccall((:klu_l_free_numeric, libklu), Cint, (Ptr{Ptr{klu_l_numeric}}, Ptr{klu_l_common}), arg1, arg2)

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/wrappers.jl

Line 522 in 4f6225c

    
           ccall((:klu_zl_free_numeric, libklu), Cint, (Ptr{Ptr{klu_l_numeric}}, Ptr{klu_l_common}), arg1, arg2)

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/wrappers.jl

Line 526 in 4f6225c

    
           ccall((:klu_sort, libklu), Cint, (Ptr{klu_symbolic}, Ptr{klu_numeric}, Ptr{klu_common}), Symbolic, Numeric, Common)

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/wrappers.jl

Line 530 in 4f6225c

    
           ccall((:klu_z_sort, libklu), Cint, (Ptr{klu_symbolic}, Ptr{klu_numeric}, Ptr{klu_common}), Symbolic, Numeric, Common)

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/wrappers.jl

Line 534 in 4f6225c

    
           ccall((:klu_l_sort, libklu), Cint, (Ptr{klu_l_symbolic}, Ptr{klu_l_numeric}, Ptr{klu_l_common}), arg1, arg2, arg3)

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/wrappers.jl

Line 538 in 4f6225c

    
           ccall((:klu_zl_sort, libklu), Cint, (Ptr{klu_l_symbolic}, Ptr{klu_l_numeric}, Ptr{klu_l_common}), arg1, arg2, arg3)

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/wrappers.jl

Line 542 in 4f6225c

    
           ccall((:klu_flops, libklu), Cint, (Ptr{klu_symbolic}, Ptr{klu_numeric}, Ptr{klu_common}), Symbolic, Numeric, Common)

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/wrappers.jl

Line 546 in 4f6225c

    
           ccall((:klu_z_flops, libklu), Cint, (Ptr{klu_symbolic}, Ptr{klu_numeric}, Ptr{klu_common}), Symbolic, Numeric, Common)

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/wrappers.jl

Line 550 in 4f6225c

    
           ccall((:klu_l_flops, libklu), Cint, (Ptr{klu_l_symbolic}, Ptr{klu_l_numeric}, Ptr{klu_l_common}), arg1, arg2, arg3)

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/wrappers.jl

Line 554 in 4f6225c

    
           ccall((:klu_zl_flops, libklu), Cint, (Ptr{klu_l_symbolic}, Ptr{klu_l_numeric}, Ptr{klu_l_common}), arg1, arg2, arg3)

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/wrappers.jl

Line 558 in 4f6225c

    
           ccall((:klu_rgrowth, libklu), Cint, (Ptr{Int32}, Ptr{Int32}, Ptr{Cdouble}, Ptr{klu_symbolic}, Ptr{klu_numeric}, Ptr{klu_common}), Ap, Ai, Ax, Symbolic, Numeric, Common)

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/wrappers.jl

Line 562 in 4f6225c

    
           ccall((:klu_z_rgrowth, libklu), Cint, (Ptr{Int32}, Ptr{Int32}, Ptr{Cdouble}, Ptr{klu_symbolic}, Ptr{klu_numeric}, Ptr{klu_common}), Ap, Ai, Ax, Symbolic, Numeric, Common)

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/wrappers.jl

Line 566 in 4f6225c

    
           ccall((:klu_l_rgrowth, libklu), Cint, (Ptr{Int64}, Ptr{Int64}, Ptr{Cdouble}, Ptr{klu_l_symbolic}, Ptr{klu_l_numeric}, Ptr{klu_l_common}), arg1, arg2, arg3, arg4, arg5, arg6)

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/wrappers.jl

Line 570 in 4f6225c

    
           ccall((:klu_zl_rgrowth, libklu), Cint, (Ptr{Int64}, Ptr{Int64}, Ptr{Cdouble}, Ptr{klu_l_symbolic}, Ptr{klu_l_numeric}, Ptr{klu_l_common}), arg1, arg2, arg3, arg4, arg5, arg6)

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/wrappers.jl

Line 574 in 4f6225c

    
           ccall((:klu_condest, libklu), Cint, (Ptr{Int32}, Ptr{Cdouble}, Ptr{klu_symbolic}, Ptr{klu_numeric}, Ptr{klu_common}), Ap, Ax, Symbolic, Numeric, Common)

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/wrappers.jl

Line 578 in 4f6225c

    
           ccall((:klu_z_condest, libklu), Cint, (Ptr{Int32}, Ptr{Cdouble}, Ptr{klu_symbolic}, Ptr{klu_numeric}, Ptr{klu_common}), Ap, Ax, Symbolic, Numeric, Common)

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/wrappers.jl

Line 582 in 4f6225c

    
           ccall((:klu_l_condest, libklu), Cint, (Ptr{Int64}, Ptr{Cdouble}, Ptr{klu_l_symbolic}, Ptr{klu_l_numeric}, Ptr{klu_l_common}), arg1, arg2, arg3, arg4, arg5)

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/wrappers.jl

Line 586 in 4f6225c

    
           ccall((:klu_zl_condest, libklu), Cint, (Ptr{Int64}, Ptr{Cdouble}, Ptr{klu_l_symbolic}, Ptr{klu_l_numeric}, Ptr{klu_l_common}), arg1, arg2, arg3, arg4, arg5)

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/wrappers.jl

Line 590 in 4f6225c

    
           ccall((:klu_rcond, libklu), Cint, (Ptr{klu_symbolic}, Ptr{klu_numeric}, Ptr{klu_common}), Symbolic, Numeric, Common)

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/wrappers.jl

Line 594 in 4f6225c

    
           ccall((:klu_z_rcond, libklu), Cint, (Ptr{klu_symbolic}, Ptr{klu_numeric}, Ptr{klu_common}), Symbolic, Numeric, Common)

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/wrappers.jl

Line 598 in 4f6225c

    
           ccall((:klu_l_rcond, libklu), Cint, (Ptr{klu_l_symbolic}, Ptr{klu_l_numeric}, Ptr{klu_l_common}), arg1, arg2, arg3)

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/wrappers.jl

Line 602 in 4f6225c

    
           ccall((:klu_zl_rcond, libklu), Cint, (Ptr{klu_l_symbolic}, Ptr{klu_l_numeric}, Ptr{klu_l_common}), arg1, arg2, arg3)

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/wrappers.jl

Line 606 in 4f6225c

    
           ccall((:klu_scale, libklu), Cint, (Cint, Int32, Ptr{Int32}, Ptr{Int32}, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Int32}, Ptr{klu_common}), scale, n, Ap, Ai, Ax, Rs, W, Common)

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/wrappers.jl

Line 610 in 4f6225c

    
           ccall((:klu_z_scale, libklu), Cint, (Cint, Int32, Ptr{Int32}, Ptr{Int32}, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Int32}, Ptr{klu_common}), scale, n, Ap, Ai, Ax, Rs, W, Common)

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/wrappers.jl

Line 614 in 4f6225c

    
           ccall((:klu_l_scale, libklu), Cint, (Cint, Int64, Ptr{Int64}, Ptr{Int64}, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Int64}, Ptr{klu_l_common}), arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8)

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/wrappers.jl

Lines 618 to 634 in 4f6225c

    
               ccall((:klu_zl_scale, libklu), Cint, (Cint, Int64, Ptr{Int64}, Ptr{Int64}, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Int64}, Ptr{klu_l_common}), arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8) 
        
           end 
        
           function klu_extract(Numeric, Symbolic, Lp, Li, Lx, Up, Ui, Ux, Fp, Fi, Fx, P, Q, Rs, R, Common) 
        
               ccall((:klu_extract, libklu), Cint, (Ptr{klu_numeric}, Ptr{klu_symbolic}, Ptr{Int32}, Ptr{Int32}, Ptr{Cdouble}, Ptr{Int32}, Ptr{Int32}, Ptr{Cdouble}, Ptr{Int32}, Ptr{Int32}, Ptr{Cdouble}, Ptr{Int32}, Ptr{Int32}, Ptr{Cdouble}, Ptr{Int32}, Ptr{klu_common}), Numeric, Symbolic, Lp, Li, Lx, Up, Ui, Ux, Fp, Fi, Fx, P, Q, Rs, R, Common) 
        
           end 
        
           function klu_z_extract(Numeric, Symbolic, Lp, Li, Lx, Lz, Up, Ui, Ux, Uz, Fp, Fi, Fx, Fz, P, Q, Rs, R, Common) 
        
               ccall((:klu_z_extract, libklu), Cint, (Ptr{klu_numeric}, Ptr{klu_symbolic}, Ptr{Int32}, Ptr{Int32}, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Int32}, Ptr{Int32}, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Int32}, Ptr{Int32}, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Int32}, Ptr{Int32}, Ptr{Cdouble}, Ptr{Int32}, Ptr{klu_common}), Numeric, Symbolic, Lp, Li, Lx, Lz, Up, Ui, Ux, Uz, Fp, Fi, Fx, Fz, P, Q, Rs, R, Common) 
        
           end 
        
           function klu_l_extract(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14, arg15, arg16) 
        
               ccall((:klu_l_extract, libklu), Cint, (Ptr{klu_l_numeric}, Ptr{klu_l_symbolic}, Ptr{Int64}, Ptr{Int64}, Ptr{Cdouble}, Ptr{Int64}, Ptr{Int64}, Ptr{Cdouble}, Ptr{Int64}, Ptr{Int64}, Ptr{Cdouble}, Ptr{Int64}, Ptr{Int64}, Ptr{Cdouble}, Ptr{Int64}, Ptr{klu_l_common}), arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14, arg15, arg16) 
        
           end 
        
           function klu_zl_extract(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14, arg15, arg16, arg17, arg18, arg19) 
        
               ccall((:klu_zl_extract, libklu), Cint, (Ptr{klu_l_numeric}, Ptr{klu_l_symbolic}, Ptr{Int64}, Ptr{Int64}, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Int64}, Ptr{Int64}, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Int64}, Ptr{Int64}, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Int64}, Ptr{Int64}, Ptr{Cdouble}, Ptr{Int64}, Ptr{klu_l_common}), arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14, arg15, arg16, arg17, arg18, arg19)

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/wrappers.jl

Line 638 in 4f6225c

    
           ccall((:klu_malloc, libklu), Ptr{Cvoid}, (Csize_t, Csize_t, Ptr{klu_common}), n, size, Common)

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/wrappers.jl

Line 642 in 4f6225c

    
           ccall((:klu_free, libklu), Ptr{Cvoid}, (Ptr{Cvoid}, Csize_t, Csize_t, Ptr{klu_common}), p, n, size, Common)

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/wrappers.jl

Line 646 in 4f6225c

    
           ccall((:klu_realloc, libklu), Ptr{Cvoid}, (Csize_t, Csize_t, Csize_t, Ptr{Cvoid}, Ptr{klu_common}), nnew, nold, size, p, Common)

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/wrappers.jl

Line 650 in 4f6225c

    
           ccall((:klu_l_malloc, libklu), Ptr{Cvoid}, (Csize_t, Csize_t, Ptr{klu_l_common}), arg1, arg2, arg3)

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/wrappers.jl

Line 654 in 4f6225c

    
           ccall((:klu_l_free, libklu), Ptr{Cvoid}, (Ptr{Cvoid}, Csize_t, Csize_t, Ptr{klu_l_common}), arg1, arg2, arg3, arg4)

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/wrappers.jl

Line 658 in 4f6225c

    
           ccall((:klu_l_realloc, libklu), Ptr{Cvoid}, (Csize_t, Csize_t, Csize_t, Ptr{Cvoid}, Ptr{klu_l_common}), arg1, arg2, arg3, arg4, arg5)

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/wrappers.jl

Line 693 in 4f6225c

    
           const SUITESPARSE_VERSION = SUITESPARSE_VER_CODE(SUITESPARSE_MAIN_VERSION, SUITESPARSE_SUB_VERSION)

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/wrappers.jl

Line 845 in 4f6225c

const KLU_VERSION = KLU_VERSION_CODE(KLU_MAIN_VERSION, KLU_SUB_VERSION)

github-actions · 2025-02-05T16:27:10Z

src/KLU/klu.jl

+            length(nzval) != length(K.nzval)  && throw(DimensionMismatch())
+            K.nzval = nzval
+            K.common.halt_if_singular = !allowsingular && check
+            ok = $refactor(K.colptr, K.rowval, K.nzval, K._symbolic, K._numeric, Ref(K.common))


[JuliaFormatter] _{reported by reviewdog 🐶}

Suggested change

ok = $refactor(K.colptr, K.rowval, K.nzval, K._symbolic, K._numeric, Ref(K.common))

ok = $refactor(

K.colptr, K.rowval, K.nzval, K._symbolic, K._numeric, Ref(K.common))

github-actions · 2025-02-05T16:27:10Z

src/KLU/klu.jl

+    end
+end
+
+function klu!(K::AbstractKLUFactorization{ComplexF64}, nzval::Vector{U}; check=true, allowsingular=false) where {U<:Complex}


[JuliaFormatter] _{reported by reviewdog 🐶}

Suggested change

function klu!(K::AbstractKLUFactorization{ComplexF64}, nzval::Vector{U}; check=true, allowsingular=false) where {U<:Complex}

function klu!(K::AbstractKLUFactorization{ComplexF64}, nzval::Vector{U};

check = true, allowsingular = false) where {U <: Complex}

github-actions · 2025-02-05T16:27:10Z

src/KLU/klu.jl

+    return klu!(K, convert(Vector{ComplexF64}, nzval); check, allowsingular)
+end
+
+function klu!(K::AbstractKLUFactorization{Float64}, nzval::Vector{U}; check=true, allowsingular=false) where {U<:AbstractFloat}


[JuliaFormatter] _{reported by reviewdog 🐶}

Suggested change

function klu!(K::AbstractKLUFactorization{Float64}, nzval::Vector{U}; check=true, allowsingular=false) where {U<:AbstractFloat}

function klu!(K::AbstractKLUFactorization{Float64}, nzval::Vector{U};

check = true, allowsingular = false) where {U <: AbstractFloat}

github-actions · 2025-02-05T16:27:10Z

src/KLU/klu.jl

+    return klu!(K, convert(Vector{Float64}, nzval); check, allowsingular)
+end
+
+function klu!(K::KLUFactorization{U}, S::SparseMatrixCSC{U}; check=true, allowsingular=false) where {U}


[JuliaFormatter] _{reported by reviewdog 🐶}

Suggested change

function klu!(K::KLUFactorization{U}, S::SparseMatrixCSC{U}; check=true, allowsingular=false) where {U}

function klu!(K::KLUFactorization{U}, S::SparseMatrixCSC{U};

check = true, allowsingular = false) where {U}

github-actions · 2025-02-05T16:27:10Z

src/KLU/klu.jl

+    increment!(K.rowval)
+    # what should happen here when check = false? This is not really a KLU error code.
+    K.colptr == S.colptr && K.rowval == S.rowval ||
+        (decrement!(K.colptr); decrement!(K.rowval);


[JuliaFormatter] _{reported by reviewdog 🐶}

Suggested change

(decrement!(K.colptr); decrement!(K.rowval);

(decrement!(K.colptr);

decrement!(K.rowval);

github-actions · 2025-02-05T16:27:14Z

src/KLU/wrappers.jl

+end
+
+function SuiteSparse_config_printf_func_set(printf_func)
+    ccall((:SuiteSparse_config_printf_func_set, libsuitesparseconfig), Cvoid, (Ptr{Cvoid},), printf_func)


[JuliaFormatter] _{reported by reviewdog 🐶}

Suggested change

ccall((:SuiteSparse_config_printf_func_set, libsuitesparseconfig), Cvoid, (Ptr{Cvoid},), printf_func)

ccall((:SuiteSparse_config_printf_func_set, libsuitesparseconfig),

Cvoid, (Ptr{Cvoid},), printf_func)

github-actions · 2025-02-05T16:27:14Z

src/KLU/wrappers.jl

+end
+
+function SuiteSparse_config_hypot_func_set(hypot_func)
+    ccall((:SuiteSparse_config_hypot_func_set, libsuitesparseconfig), Cvoid, (Ptr{Cvoid},), hypot_func)


[JuliaFormatter] _{reported by reviewdog 🐶}

Suggested change

ccall((:SuiteSparse_config_hypot_func_set, libsuitesparseconfig), Cvoid, (Ptr{Cvoid},), hypot_func)

ccall((:SuiteSparse_config_hypot_func_set, libsuitesparseconfig),

Cvoid, (Ptr{Cvoid},), hypot_func)

github-actions · 2025-02-05T16:27:14Z

src/KLU/wrappers.jl

+end
+
+function SuiteSparse_config_divcomplex_func_set(divcomplex_func)
+    ccall((:SuiteSparse_config_divcomplex_func_set, libsuitesparseconfig), Cvoid, (Ptr{Cvoid},), divcomplex_func)


[JuliaFormatter] _{reported by reviewdog 🐶}

Suggested change

ccall((:SuiteSparse_config_divcomplex_func_set, libsuitesparseconfig), Cvoid, (Ptr{Cvoid},), divcomplex_func)

ccall((:SuiteSparse_config_divcomplex_func_set, libsuitesparseconfig),

Cvoid, (Ptr{Cvoid},), divcomplex_func)

github-actions · 2025-02-05T16:27:14Z

src/KLU/wrappers.jl

+end
+
+function SuiteSparse_config_calloc(n, s)
+    ccall((:SuiteSparse_config_calloc, libsuitesparseconfig), Ptr{Cvoid}, (Csize_t, Csize_t), n, s)


[JuliaFormatter] _{reported by reviewdog 🐶}

Suggested change

ccall((:SuiteSparse_config_calloc, libsuitesparseconfig), Ptr{Cvoid}, (Csize_t, Csize_t), n, s)

ccall((:SuiteSparse_config_calloc, libsuitesparseconfig),

Ptr{Cvoid}, (Csize_t, Csize_t), n, s)

github-actions · 2025-02-05T16:27:14Z

src/KLU/wrappers.jl

+end
+
+function SuiteSparse_config_realloc(arg1, s)
+    ccall((:SuiteSparse_config_realloc, libsuitesparseconfig), Ptr{Cvoid}, (Ptr{Cvoid}, Csize_t), arg1, s)


[JuliaFormatter] _{reported by reviewdog 🐶}

Suggested change

ccall((:SuiteSparse_config_realloc, libsuitesparseconfig), Ptr{Cvoid}, (Ptr{Cvoid}, Csize_t), arg1, s)

ccall((:SuiteSparse_config_realloc, libsuitesparseconfig),

Ptr{Cvoid}, (Ptr{Cvoid}, Csize_t), arg1, s)

github-actions

Remaining comments which cannot be posted as a review comment to avoid GitHub Rate Limit

JuliaFormatter

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/wrappers.jl

Line 214 in 536611a

    
           ccall((:symamd_l, libamd), Cint, (Int64, Ptr{Int64}, Ptr{Int64}, Ptr{Int64}, Ptr{Cdouble}, Ptr{Int64}, Ptr{Cvoid}, Ptr{Cvoid}), n, A, p, perm, knobs, stats, allocate, release)

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/wrappers.jl

Line 234 in 536611a

    
           ccall((:btf_maxtrans, libbtf), Int32, (Int32, Int32, Ptr{Int32}, Ptr{Int32}, Cdouble, Ptr{Cdouble}, Ptr{Int32}, Ptr{Int32}), nrow, ncol, Ap, Ai, maxwork, work, Match, Work)

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/wrappers.jl

Line 238 in 536611a

    
           ccall((:btf_l_maxtrans, libbtf), Int64, (Int64, Int64, Ptr{Int64}, Ptr{Int64}, Cdouble, Ptr{Cdouble}, Ptr{Int64}, Ptr{Int64}), arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8)

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/wrappers.jl

Line 242 in 536611a

    
           ccall((:btf_strongcomp, libbtf), Int32, (Int32, Ptr{Int32}, Ptr{Int32}, Ptr{Int32}, Ptr{Int32}, Ptr{Int32}, Ptr{Int32}), n, Ap, Ai, Q, P, R, Work)

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/wrappers.jl

Line 246 in 536611a

    
           ccall((:btf_l_strongcomp, libbtf), Int64, (Int64, Ptr{Int64}, Ptr{Int64}, Ptr{Int64}, Ptr{Int64}, Ptr{Int64}, Ptr{Int64}), arg1, arg2, arg3, arg4, arg5, arg6, arg7)

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/wrappers.jl

Line 250 in 536611a

    
           ccall((:btf_order, libbtf), Int32, (Int32, Ptr{Int32}, Ptr{Int32}, Cdouble, Ptr{Cdouble}, Ptr{Int32}, Ptr{Int32}, Ptr{Int32}, Ptr{Int32}, Ptr{Int32}), n, Ap, Ai, maxwork, work, P, Q, R, nmatch, Work)

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/wrappers.jl

Line 254 in 536611a

    
           ccall((:btf_l_order, libbtf), Int64, (Int64, Ptr{Int64}, Ptr{Int64}, Cdouble, Ptr{Cdouble}, Ptr{Int64}, Ptr{Int64}, Ptr{Int64}, Ptr{Int64}, Ptr{Int64}), arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10)

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/wrappers.jl

Line 422 in 536611a

    
           ccall((:klu_analyze, libklu), Ptr{klu_symbolic}, (Int32, Ptr{Int32}, Ptr{Int32}, Ptr{klu_common}), n, Ap, Ai, Common)

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/wrappers.jl

Line 426 in 536611a

    
           ccall((:klu_l_analyze, libklu), Ptr{klu_l_symbolic}, (Int64, Ptr{Int64}, Ptr{Int64}, Ptr{klu_l_common}), arg1, arg2, arg3, Common)

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/wrappers.jl

Line 430 in 536611a

    
           ccall((:klu_analyze_given, libklu), Ptr{klu_symbolic}, (Int32, Ptr{Int32}, Ptr{Int32}, Ptr{Int32}, Ptr{Int32}, Ptr{klu_common}), n, Ap, Ai, P, Q, Common)

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/wrappers.jl

Line 434 in 536611a

    
           ccall((:klu_l_analyze_given, libklu), Ptr{klu_l_symbolic}, (Int64, Ptr{Int64}, Ptr{Int64}, Ptr{Int64}, Ptr{Int64}, Ptr{klu_l_common}), arg1, arg2, arg3, arg4, arg5, arg6)

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/wrappers.jl

Line 438 in 536611a

    
           ccall((:klu_factor, libklu), Ptr{klu_numeric}, (Ptr{Int32}, Ptr{Int32}, Ptr{Cdouble}, Ptr{klu_symbolic}, Ptr{klu_common}), Ap, Ai, Ax, Symbolic, Common)

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/wrappers.jl

Line 442 in 536611a

    
           ccall((:klu_z_factor, libklu), Ptr{klu_numeric}, (Ptr{Int32}, Ptr{Int32}, Ptr{Cdouble}, Ptr{klu_symbolic}, Ptr{klu_common}), Ap, Ai, Ax, Symbolic, Common)

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/wrappers.jl

Line 446 in 536611a

    
           ccall((:klu_l_factor, libklu), Ptr{klu_l_numeric}, (Ptr{Int64}, Ptr{Int64}, Ptr{Cdouble}, Ptr{klu_l_symbolic}, Ptr{klu_l_common}), arg1, arg2, arg3, arg4, arg5)

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/wrappers.jl

Line 450 in 536611a

    
           ccall((:klu_zl_factor, libklu), Ptr{klu_l_numeric}, (Ptr{Int64}, Ptr{Int64}, Ptr{Cdouble}, Ptr{klu_l_symbolic}, Ptr{klu_l_common}), arg1, arg2, arg3, arg4, arg5)

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/wrappers.jl

Line 454 in 536611a

    
           ccall((:klu_solve, libklu), Cint, (Ptr{klu_symbolic}, Ptr{klu_numeric}, Int32, Int32, Ptr{Cdouble}, Ptr{klu_common}), Symbolic, Numeric, ldim, nrhs, B, Common)

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/wrappers.jl

Line 458 in 536611a

    
           ccall((:klu_z_solve, libklu), Cint, (Ptr{klu_symbolic}, Ptr{klu_numeric}, Int32, Int32, Ptr{Cdouble}, Ptr{klu_common}), Symbolic, Numeric, ldim, nrhs, B, Common)

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/wrappers.jl

Line 462 in 536611a

    
           ccall((:klu_l_solve, libklu), Cint, (Ptr{klu_l_symbolic}, Ptr{klu_l_numeric}, Int64, Int64, Ptr{Cdouble}, Ptr{klu_l_common}), arg1, arg2, arg3, arg4, arg5, arg6)

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/wrappers.jl

Line 466 in 536611a

    
           ccall((:klu_zl_solve, libklu), Cint, (Ptr{klu_l_symbolic}, Ptr{klu_l_numeric}, Int64, Int64, Ptr{Cdouble}, Ptr{klu_l_common}), arg1, arg2, arg3, arg4, arg5, arg6)

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/wrappers.jl

Line 470 in 536611a

    
           ccall((:klu_tsolve, libklu), Cint, (Ptr{klu_symbolic}, Ptr{klu_numeric}, Int32, Int32, Ptr{Cdouble}, Ptr{klu_common}), Symbolic, Numeric, ldim, nrhs, B, Common)

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/wrappers.jl

Line 474 in 536611a

    
           ccall((:klu_z_tsolve, libklu), Cint, (Ptr{klu_symbolic}, Ptr{klu_numeric}, Int32, Int32, Ptr{Cdouble}, Cint, Ptr{klu_common}), Symbolic, Numeric, ldim, nrhs, B, conj_solve, Common)

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/wrappers.jl

Line 478 in 536611a

    
           ccall((:klu_l_tsolve, libklu), Cint, (Ptr{klu_l_symbolic}, Ptr{klu_l_numeric}, Int64, Int64, Ptr{Cdouble}, Ptr{klu_l_common}), arg1, arg2, arg3, arg4, arg5, arg6)

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/wrappers.jl

Line 482 in 536611a

    
           ccall((:klu_zl_tsolve, libklu), Cint, (Ptr{klu_l_symbolic}, Ptr{klu_l_numeric}, Int64, Int64, Ptr{Cdouble}, Cint, Ptr{klu_l_common}), arg1, arg2, arg3, arg4, arg5, arg6, arg7)

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/wrappers.jl

Line 486 in 536611a

    
           ccall((:klu_refactor, libklu), Cint, (Ptr{Int32}, Ptr{Int32}, Ptr{Cdouble}, Ptr{klu_symbolic}, Ptr{klu_numeric}, Ptr{klu_common}), Ap, Ai, Ax, Symbolic, Numeric, Common)

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/wrappers.jl

Line 490 in 536611a

    
           ccall((:klu_z_refactor, libklu), Cint, (Ptr{Int32}, Ptr{Int32}, Ptr{Cdouble}, Ptr{klu_symbolic}, Ptr{klu_numeric}, Ptr{klu_common}), Ap, Ai, Ax, Symbolic, Numeric, Common)

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/wrappers.jl

Line 494 in 536611a

    
           ccall((:klu_l_refactor, libklu), Cint, (Ptr{Int64}, Ptr{Int64}, Ptr{Cdouble}, Ptr{klu_l_symbolic}, Ptr{klu_l_numeric}, Ptr{klu_l_common}), arg1, arg2, arg3, arg4, arg5, arg6)

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/wrappers.jl

Line 498 in 536611a

    
           ccall((:klu_zl_refactor, libklu), Cint, (Ptr{Int64}, Ptr{Int64}, Ptr{Cdouble}, Ptr{klu_l_symbolic}, Ptr{klu_l_numeric}, Ptr{klu_l_common}), arg1, arg2, arg3, arg4, arg5, arg6)

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/wrappers.jl

Line 502 in 536611a

    
           ccall((:klu_free_symbolic, libklu), Cint, (Ptr{Ptr{klu_symbolic}}, Ptr{klu_common}), Symbolic, Common)

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/wrappers.jl

Line 506 in 536611a

    
           ccall((:klu_l_free_symbolic, libklu), Cint, (Ptr{Ptr{klu_l_symbolic}}, Ptr{klu_l_common}), arg1, arg2)

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/wrappers.jl

Line 510 in 536611a

    
           ccall((:klu_free_numeric, libklu), Cint, (Ptr{Ptr{klu_numeric}}, Ptr{klu_common}), Numeric, Common)

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/wrappers.jl

Line 514 in 536611a

    
           ccall((:klu_z_free_numeric, libklu), Cint, (Ptr{Ptr{klu_numeric}}, Ptr{klu_common}), Numeric, Common)

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/wrappers.jl

Line 518 in 536611a

    
           ccall((:klu_l_free_numeric, libklu), Cint, (Ptr{Ptr{klu_l_numeric}}, Ptr{klu_l_common}), arg1, arg2)

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/wrappers.jl

Line 522 in 536611a

    
           ccall((:klu_zl_free_numeric, libklu), Cint, (Ptr{Ptr{klu_l_numeric}}, Ptr{klu_l_common}), arg1, arg2)

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/wrappers.jl

Line 526 in 536611a

    
           ccall((:klu_sort, libklu), Cint, (Ptr{klu_symbolic}, Ptr{klu_numeric}, Ptr{klu_common}), Symbolic, Numeric, Common)

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/wrappers.jl

Line 530 in 536611a

    
           ccall((:klu_z_sort, libklu), Cint, (Ptr{klu_symbolic}, Ptr{klu_numeric}, Ptr{klu_common}), Symbolic, Numeric, Common)

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/wrappers.jl

Line 534 in 536611a

    
           ccall((:klu_l_sort, libklu), Cint, (Ptr{klu_l_symbolic}, Ptr{klu_l_numeric}, Ptr{klu_l_common}), arg1, arg2, arg3)

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/wrappers.jl

Line 538 in 536611a

    
           ccall((:klu_zl_sort, libklu), Cint, (Ptr{klu_l_symbolic}, Ptr{klu_l_numeric}, Ptr{klu_l_common}), arg1, arg2, arg3)

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/wrappers.jl

Line 542 in 536611a

    
           ccall((:klu_flops, libklu), Cint, (Ptr{klu_symbolic}, Ptr{klu_numeric}, Ptr{klu_common}), Symbolic, Numeric, Common)

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/wrappers.jl

Line 546 in 536611a

    
           ccall((:klu_z_flops, libklu), Cint, (Ptr{klu_symbolic}, Ptr{klu_numeric}, Ptr{klu_common}), Symbolic, Numeric, Common)

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/wrappers.jl

Line 550 in 536611a

    
           ccall((:klu_l_flops, libklu), Cint, (Ptr{klu_l_symbolic}, Ptr{klu_l_numeric}, Ptr{klu_l_common}), arg1, arg2, arg3)

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/wrappers.jl

Line 554 in 536611a

    
           ccall((:klu_zl_flops, libklu), Cint, (Ptr{klu_l_symbolic}, Ptr{klu_l_numeric}, Ptr{klu_l_common}), arg1, arg2, arg3)

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/wrappers.jl

Line 558 in 536611a

    
           ccall((:klu_rgrowth, libklu), Cint, (Ptr{Int32}, Ptr{Int32}, Ptr{Cdouble}, Ptr{klu_symbolic}, Ptr{klu_numeric}, Ptr{klu_common}), Ap, Ai, Ax, Symbolic, Numeric, Common)

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/wrappers.jl

Line 562 in 536611a

    
           ccall((:klu_z_rgrowth, libklu), Cint, (Ptr{Int32}, Ptr{Int32}, Ptr{Cdouble}, Ptr{klu_symbolic}, Ptr{klu_numeric}, Ptr{klu_common}), Ap, Ai, Ax, Symbolic, Numeric, Common)

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/wrappers.jl

Line 566 in 536611a

    
           ccall((:klu_l_rgrowth, libklu), Cint, (Ptr{Int64}, Ptr{Int64}, Ptr{Cdouble}, Ptr{klu_l_symbolic}, Ptr{klu_l_numeric}, Ptr{klu_l_common}), arg1, arg2, arg3, arg4, arg5, arg6)

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/wrappers.jl

Line 570 in 536611a

    
           ccall((:klu_zl_rgrowth, libklu), Cint, (Ptr{Int64}, Ptr{Int64}, Ptr{Cdouble}, Ptr{klu_l_symbolic}, Ptr{klu_l_numeric}, Ptr{klu_l_common}), arg1, arg2, arg3, arg4, arg5, arg6)

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/wrappers.jl

Line 574 in 536611a

    
           ccall((:klu_condest, libklu), Cint, (Ptr{Int32}, Ptr{Cdouble}, Ptr{klu_symbolic}, Ptr{klu_numeric}, Ptr{klu_common}), Ap, Ax, Symbolic, Numeric, Common)

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/wrappers.jl

Line 578 in 536611a

    
           ccall((:klu_z_condest, libklu), Cint, (Ptr{Int32}, Ptr{Cdouble}, Ptr{klu_symbolic}, Ptr{klu_numeric}, Ptr{klu_common}), Ap, Ax, Symbolic, Numeric, Common)

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/wrappers.jl

Line 582 in 536611a

    
           ccall((:klu_l_condest, libklu), Cint, (Ptr{Int64}, Ptr{Cdouble}, Ptr{klu_l_symbolic}, Ptr{klu_l_numeric}, Ptr{klu_l_common}), arg1, arg2, arg3, arg4, arg5)

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/wrappers.jl

Line 586 in 536611a

    
           ccall((:klu_zl_condest, libklu), Cint, (Ptr{Int64}, Ptr{Cdouble}, Ptr{klu_l_symbolic}, Ptr{klu_l_numeric}, Ptr{klu_l_common}), arg1, arg2, arg3, arg4, arg5)

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/wrappers.jl

Line 590 in 536611a

    
           ccall((:klu_rcond, libklu), Cint, (Ptr{klu_symbolic}, Ptr{klu_numeric}, Ptr{klu_common}), Symbolic, Numeric, Common)

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/wrappers.jl

Line 594 in 536611a

    
           ccall((:klu_z_rcond, libklu), Cint, (Ptr{klu_symbolic}, Ptr{klu_numeric}, Ptr{klu_common}), Symbolic, Numeric, Common)

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/wrappers.jl

Line 598 in 536611a

    
           ccall((:klu_l_rcond, libklu), Cint, (Ptr{klu_l_symbolic}, Ptr{klu_l_numeric}, Ptr{klu_l_common}), arg1, arg2, arg3)

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/wrappers.jl

Line 602 in 536611a

    
           ccall((:klu_zl_rcond, libklu), Cint, (Ptr{klu_l_symbolic}, Ptr{klu_l_numeric}, Ptr{klu_l_common}), arg1, arg2, arg3)

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/wrappers.jl

Line 606 in 536611a

    
           ccall((:klu_scale, libklu), Cint, (Cint, Int32, Ptr{Int32}, Ptr{Int32}, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Int32}, Ptr{klu_common}), scale, n, Ap, Ai, Ax, Rs, W, Common)

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/wrappers.jl

Line 610 in 536611a

    
           ccall((:klu_z_scale, libklu), Cint, (Cint, Int32, Ptr{Int32}, Ptr{Int32}, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Int32}, Ptr{klu_common}), scale, n, Ap, Ai, Ax, Rs, W, Common)

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/wrappers.jl

Line 614 in 536611a

    
           ccall((:klu_l_scale, libklu), Cint, (Cint, Int64, Ptr{Int64}, Ptr{Int64}, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Int64}, Ptr{klu_l_common}), arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8)

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/wrappers.jl

Lines 618 to 634 in 536611a

    
               ccall((:klu_zl_scale, libklu), Cint, (Cint, Int64, Ptr{Int64}, Ptr{Int64}, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Int64}, Ptr{klu_l_common}), arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8) 
        
           end 
        
           function klu_extract(Numeric, Symbolic, Lp, Li, Lx, Up, Ui, Ux, Fp, Fi, Fx, P, Q, Rs, R, Common) 
        
               ccall((:klu_extract, libklu), Cint, (Ptr{klu_numeric}, Ptr{klu_symbolic}, Ptr{Int32}, Ptr{Int32}, Ptr{Cdouble}, Ptr{Int32}, Ptr{Int32}, Ptr{Cdouble}, Ptr{Int32}, Ptr{Int32}, Ptr{Cdouble}, Ptr{Int32}, Ptr{Int32}, Ptr{Cdouble}, Ptr{Int32}, Ptr{klu_common}), Numeric, Symbolic, Lp, Li, Lx, Up, Ui, Ux, Fp, Fi, Fx, P, Q, Rs, R, Common) 
        
           end 
        
           function klu_z_extract(Numeric, Symbolic, Lp, Li, Lx, Lz, Up, Ui, Ux, Uz, Fp, Fi, Fx, Fz, P, Q, Rs, R, Common) 
        
               ccall((:klu_z_extract, libklu), Cint, (Ptr{klu_numeric}, Ptr{klu_symbolic}, Ptr{Int32}, Ptr{Int32}, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Int32}, Ptr{Int32}, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Int32}, Ptr{Int32}, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Int32}, Ptr{Int32}, Ptr{Cdouble}, Ptr{Int32}, Ptr{klu_common}), Numeric, Symbolic, Lp, Li, Lx, Lz, Up, Ui, Ux, Uz, Fp, Fi, Fx, Fz, P, Q, Rs, R, Common) 
        
           end 
        
           function klu_l_extract(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14, arg15, arg16) 
        
               ccall((:klu_l_extract, libklu), Cint, (Ptr{klu_l_numeric}, Ptr{klu_l_symbolic}, Ptr{Int64}, Ptr{Int64}, Ptr{Cdouble}, Ptr{Int64}, Ptr{Int64}, Ptr{Cdouble}, Ptr{Int64}, Ptr{Int64}, Ptr{Cdouble}, Ptr{Int64}, Ptr{Int64}, Ptr{Cdouble}, Ptr{Int64}, Ptr{klu_l_common}), arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14, arg15, arg16) 
        
           end 
        
           function klu_zl_extract(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14, arg15, arg16, arg17, arg18, arg19) 
        
               ccall((:klu_zl_extract, libklu), Cint, (Ptr{klu_l_numeric}, Ptr{klu_l_symbolic}, Ptr{Int64}, Ptr{Int64}, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Int64}, Ptr{Int64}, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Int64}, Ptr{Int64}, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Int64}, Ptr{Int64}, Ptr{Cdouble}, Ptr{Int64}, Ptr{klu_l_common}), arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14, arg15, arg16, arg17, arg18, arg19)

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/wrappers.jl

Line 638 in 536611a

    
           ccall((:klu_malloc, libklu), Ptr{Cvoid}, (Csize_t, Csize_t, Ptr{klu_common}), n, size, Common)

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/wrappers.jl

Line 642 in 536611a

    
           ccall((:klu_free, libklu), Ptr{Cvoid}, (Ptr{Cvoid}, Csize_t, Csize_t, Ptr{klu_common}), p, n, size, Common)

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/wrappers.jl

Line 646 in 536611a

    
           ccall((:klu_realloc, libklu), Ptr{Cvoid}, (Csize_t, Csize_t, Csize_t, Ptr{Cvoid}, Ptr{klu_common}), nnew, nold, size, p, Common)

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/wrappers.jl

Line 650 in 536611a

    
           ccall((:klu_l_malloc, libklu), Ptr{Cvoid}, (Csize_t, Csize_t, Ptr{klu_l_common}), arg1, arg2, arg3)

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/wrappers.jl

Line 654 in 536611a

    
           ccall((:klu_l_free, libklu), Ptr{Cvoid}, (Ptr{Cvoid}, Csize_t, Csize_t, Ptr{klu_l_common}), arg1, arg2, arg3, arg4)

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/wrappers.jl

Line 658 in 536611a

    
           ccall((:klu_l_realloc, libklu), Ptr{Cvoid}, (Csize_t, Csize_t, Csize_t, Ptr{Cvoid}, Ptr{klu_l_common}), arg1, arg2, arg3, arg4, arg5)

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/wrappers.jl

Line 693 in 536611a

    
           const SUITESPARSE_VERSION = SUITESPARSE_VER_CODE(SUITESPARSE_MAIN_VERSION, SUITESPARSE_SUB_VERSION)

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/KLU/wrappers.jl

Line 845 in 536611a

const KLU_VERSION = KLU_VERSION_CODE(KLU_MAIN_VERSION, KLU_SUB_VERSION)

[JuliaFormatter] _{reported by reviewdog 🐶}

LinearSolve.jl/src/LinearSolve.jl

Line 94 in 536611a

issparsematrix(A) = false

github-actions · 2025-02-05T21:05:28Z

ext/LinearSolveSparseArraysExt.jl

+LinearSolve.make_SparseMatrixCSC(A::AbstractSparseArray) = SparseMatrixCSC(size(A)..., getcolptr(A), rowvals(A), nonzeros(A))
+LinearSolve.makeempty_SparaseMatrixCSC(A::AbstractSparseArray) = SparseMatrixCSC(0, 0, [1], Int[], eltype(A)[])


[JuliaFormatter] _{reported by reviewdog 🐶}

Suggested change

LinearSolve.make_SparseMatrixCSC(A::AbstractSparseArray) = SparseMatrixCSC(size(A)..., getcolptr(A), rowvals(A), nonzeros(A))

LinearSolve.makeempty_SparaseMatrixCSC(A::AbstractSparseArray) = SparseMatrixCSC(0, 0, [1], Int[], eltype(A)[])

function LinearSolve.make_SparseMatrixCSC(A::AbstractSparseArray)

SparseMatrixCSC(size(A)..., getcolptr(A), rowvals(A), nonzeros(A))

end

function LinearSolve.makeempty_SparaseMatrixCSC(A::AbstractSparseArray)

SparseMatrixCSC(0, 0, [1], Int[], eltype(A)[])

end

github-actions · 2025-02-05T21:05:29Z

ext/LinearSolveSparseArraysExt.jl

+    nothing, nothing
+end
+
+


[JuliaFormatter] _{reported by reviewdog 🐶}

Suggested change

github-actions · 2025-02-05T21:05:29Z

ext/LinearSolveSparseArraysExt.jl

+
+function LinearSolve.handle_sparsematrixcsc_lu(A::AbstractSparseMatrixCSC)
+    lu(SparseMatrixCSC(size(A)..., getcolptr(A), rowvals(A), nonzeros(A)),
+    check = false)


[JuliaFormatter] _{reported by reviewdog 🐶}

Suggested change

check = false)

check = false)

github-actions · 2025-02-05T21:05:29Z

ext/LinearSolveSparseArraysExt.jl

+
+function LinearSolve.defaultalg(
+        A::Symmetric{<:Number, <:SparseMatrixCSC}, b, ::OperatorAssumptions{Bool})
+        LinearSolve.DefaultLinearSolver(LinearSolve.DefaultAlgorithmChoice.CHOLMODFactorization)


[JuliaFormatter] _{reported by reviewdog 🐶}

Suggested change

LinearSolve.DefaultLinearSolver(LinearSolve.DefaultAlgorithmChoice.CHOLMODFactorization)

LinearSolve.DefaultLinearSolver(LinearSolve.DefaultAlgorithmChoice.CHOLMODFactorization)

github-actions · 2025-02-05T21:05:29Z

ext/LinearSolveSparseArraysExt.jl

+const PREALLOCATED_UMFPACK = SparseArrays.UMFPACK.UmfpackLU(SparseMatrixCSC(0, 0, [1],
+    Int[], Float64[]))
+
+function LinearSolve.init_cacheval(alg::UMFPACKFactorization, A::SparseMatrixCSC{Float64, Int}, b, u,


[JuliaFormatter] _{reported by reviewdog 🐶}

Suggested change

function LinearSolve.init_cacheval(alg::UMFPACKFactorization, A::SparseMatrixCSC{Float64, Int}, b, u,

function LinearSolve.init_cacheval(

alg::UMFPACKFactorization, A::SparseMatrixCSC{Float64, Int}, b, u,

github-actions · 2025-02-05T21:05:33Z

src/KLU/wrappers.jl

+end
+
+function amd_l_valid(n_row, n_col, Ap, Ai)
+    ccall((:amd_l_valid, libamd), Cint, (Int64, Int64, Ptr{Int64}, Ptr{Int64}), n_row, n_col, Ap, Ai)


[JuliaFormatter] _{reported by reviewdog 🐶}

Suggested change

ccall((:amd_l_valid, libamd), Cint, (Int64, Int64, Ptr{Int64}, Ptr{Int64}), n_row, n_col, Ap, Ai)

ccall((:amd_l_valid, libamd), Cint,

(Int64, Int64, Ptr{Int64}, Ptr{Int64}), n_row, n_col, Ap, Ai)

github-actions · 2025-02-05T21:05:33Z

src/KLU/wrappers.jl

+end
+
+function colamd_l_recommended(nnz, n_row, n_col)
+    ccall((:colamd_l_recommended, libamd), Csize_t, (Int64, Int64, Int64), nnz, n_row, n_col)


[JuliaFormatter] _{reported by reviewdog 🐶}

Suggested change

ccall((:colamd_l_recommended, libamd), Csize_t, (Int64, Int64, Int64), nnz, n_row, n_col)

ccall(

(:colamd_l_recommended, libamd), Csize_t, (Int64, Int64, Int64), nnz, n_row, n_col)

github-actions · 2025-02-05T21:05:33Z

src/KLU/wrappers.jl

+end
+
+function colamd(n_row, n_col, Alen, A, p, knobs, stats)
+    ccall((:colamd, libamd), Cint, (Int32, Int32, Int32, Ptr{Int32}, Ptr{Int32}, Ptr{Cdouble}, Ptr{Int32}), n_row, n_col, Alen, A, p, knobs, stats)


[JuliaFormatter] _{reported by reviewdog 🐶}

Suggested change

ccall((:colamd, libamd), Cint, (Int32, Int32, Int32, Ptr{Int32}, Ptr{Int32}, Ptr{Cdouble}, Ptr{Int32}), n_row, n_col, Alen, A, p, knobs, stats)

ccall((:colamd, libamd), Cint,

(Int32, Int32, Int32, Ptr{Int32}, Ptr{Int32}, Ptr{Cdouble}, Ptr{Int32}),

n_row, n_col, Alen, A, p, knobs, stats)

github-actions · 2025-02-05T21:05:33Z

src/KLU/wrappers.jl

+end
+
+function colamd_l(n_row, n_col, Alen, A, p, knobs, stats)
+    ccall((:colamd_l, libamd), Cint, (Int64, Int64, Int64, Ptr{Int64}, Ptr{Int64}, Ptr{Cdouble}, Ptr{Int64}), n_row, n_col, Alen, A, p, knobs, stats)


[JuliaFormatter] _{reported by reviewdog 🐶}

Suggested change

ccall((:colamd_l, libamd), Cint, (Int64, Int64, Int64, Ptr{Int64}, Ptr{Int64}, Ptr{Cdouble}, Ptr{Int64}), n_row, n_col, Alen, A, p, knobs, stats)

ccall((:colamd_l, libamd), Cint,

(Int64, Int64, Int64, Ptr{Int64}, Ptr{Int64}, Ptr{Cdouble}, Ptr{Int64}),

n_row, n_col, Alen, A, p, knobs, stats)

github-actions · 2025-02-05T21:05:33Z

src/KLU/wrappers.jl

+end
+
+function symamd(n, A, p, perm, knobs, stats, allocate, release)
+    ccall((:symamd, libamd), Cint, (Int32, Ptr{Int32}, Ptr{Int32}, Ptr{Int32}, Ptr{Cdouble}, Ptr{Int32}, Ptr{Cvoid}, Ptr{Cvoid}), n, A, p, perm, knobs, stats, allocate, release)


[JuliaFormatter] _{reported by reviewdog 🐶}

Suggested change

ccall((:symamd, libamd), Cint, (Int32, Ptr{Int32}, Ptr{Int32}, Ptr{Int32}, Ptr{Cdouble}, Ptr{Int32}, Ptr{Cvoid}, Ptr{Cvoid}), n, A, p, perm, knobs, stats, allocate, release)

ccall((:symamd, libamd),

Cint,

(Int32, Ptr{Int32}, Ptr{Int32}, Ptr{Int32},

Ptr{Cdouble}, Ptr{Int32}, Ptr{Cvoid}, Ptr{Cvoid}),

n,

A,

p,

perm,

knobs,

stats,

allocate,

release)

github-actions bot reviewed Feb 1, 2025

View reviewed changes

This was referenced Feb 1, 2025

Make SparseArrays an extension package JuliaSmoothOptimizers/Krylov.jl#955

Open

WIP: Make more libraries into an extension? #530

Closed

ChrisRackauckas force-pushed the sparsearraysext branch from e263444 to 0bf2e46 Compare February 5, 2025 03:41

github-actions bot reviewed Feb 5, 2025

View reviewed changes

ChrisRackauckas and others added 24 commits February 5, 2025 08:15

Make RecursiveFactorization.jl optional

2c0d8ab

RecrusiveFactorization.jl brings in the LoopVectorization.jl stack, and so it's not a small dependency. It is a good thing to default to often, but we can make it a bit more optional in order to greatly decrease load times.

get it working

75d2813

Update ext/LinearSolveRecursiveFactorization.jl

b62f277

Co-authored-by: github-actions[bot] <41898282+github-actions[bot]@users.noreply.github.com>

Update src/default.jl

d81e8a2

Co-authored-by: github-actions[bot] <41898282+github-actions[bot]@users.noreply.github.com>

Update src/factorization.jl

aa865ba

Co-authored-by: github-actions[bot] <41898282+github-actions[bot]@users.noreply.github.com>

Update src/extension_algs.jl

b8cd21b

Co-authored-by: github-actions[bot] <41898282+github-actions[bot]@users.noreply.github.com>

Update src/extension_algs.jl

1c2eae4

Co-authored-by: github-actions[bot] <41898282+github-actions[bot]@users.noreply.github.com>

Update src/extension_algs.jl

6606dd4

Co-authored-by: github-actions[bot] <41898282+github-actions[bot]@users.noreply.github.com>

Update src/default.jl

45d94fd

Co-authored-by: github-actions[bot] <41898282+github-actions[bot]@users.noreply.github.com>

add RecursiveFactorization in tests

cd3a29e

Update and rename LinearSolveRecursiveFactorization.jl to LinearSolve…

80e6614

…RecursiveFactorizationExt.jl

Update LinearSolveRecursiveFactorizationExt.jl

c280c46

Update LinearSolveRecursiveFactorizationExt.jl

50e8cbe

Update LinearSolveRecursiveFactorizationExt.jl

4e358f6

Update LinearSolveRecursiveFactorizationExt.jl

0278ecd

namespace PreallocatedLU

e18d864

one more

a689fd6

one more

8faa4e6

namespace

7d1f54a

namespace

c93a6b2

fix default

41a786b

fix inference on recfact load

7569440

don't double

8704062

Update src/extension_algs.jl

3ad68c7

ChrisRackauckas and others added 5 commits February 5, 2025 08:15

Update src/extension_algs.jl

4d3a346

Update src/default.jl

486d924

Co-authored-by: github-actions[bot] <41898282+github-actions[bot]@users.noreply.github.com>

Update ext/LinearSolveRecursiveFactorizationExt.jl

1fad945

Co-authored-by: github-actions[bot] <41898282+github-actions[bot]@users.noreply.github.com>

Make RecursiveFactorization.jl optional

e77fb72

RecrusiveFactorization.jl brings in the LoopVectorization.jl stack, and so it's not a small dependency. It is a good thing to default to often, but we can make it a bit more optional in order to greatly decrease load times.

ChrisRackauckas force-pushed the sparsearraysext branch from 0bf2e46 to 4f6225c Compare February 5, 2025 16:21

github-actions bot reviewed Feb 5, 2025

View reviewed changes

finishing touches

536611a

github-actions bot reviewed Feb 5, 2025

View reviewed changes

format

3f62e1b

ChrisRackauckas changed the title ~~WIP: Make SparseArrays an extension~~ Make SparseArrays an extension Feb 5, 2025

ChrisRackauckas merged commit 88dc1f6 into main Feb 5, 2025
18 of 27 checks passed

ChrisRackauckas deleted the sparsearraysext branch February 5, 2025 21:19

	function LinearAlgebra.issuccess(K::AbstractKLUFactorization; allowsingular=false)
	return (allowsingular ? K.common.status >= KLU_OK : K.common.status == KLU_OK) && K._numeric != C_NULL

	function klu_analyze!(K::KLUFactorization{Tv, Ti}; check=true) where {Tv, Ti<:KLUITypes}
	if K._symbolic != C_NULL return K end

	function klu!(K::KLUFactorization{$Tv, $Ti}, nzval::Vector{$Tv}; check=true, allowsingular=false)
	length(nzval) != length(K.nzval) && throw(DimensionMismatch())

	ccall((:amd_l_order, libamd), Cint, (Int64, Ptr{Int64}, Ptr{Int64}, Ptr{Int64}, Ptr{Cdouble}, Ptr{Cdouble}), n, Ap, Ai, P, Control, Info)
	end

	function amd_2(n, Pe, Iw, Len, iwlen, pfree, Nv, Next, Last, Head, Elen, Degree, W, Control, Info)
	ccall((:amd_2, libamd), Cvoid, (Int32, Ptr{Int32}, Ptr{Int32}, Ptr{Int32}, Int32, Int32, Ptr{Int32}, Ptr{Int32}, Ptr{Int32}, Ptr{Int32}, Ptr{Int32}, Ptr{Int32}, Ptr{Int32}, Ptr{Cdouble}, Ptr{Cdouble}), n, Pe, Iw, Len, iwlen, pfree, Nv, Next, Last, Head, Elen, Degree, W, Control, Info)
	end

	function amd_l2(n, Pe, Iw, Len, iwlen, pfree, Nv, Next, Last, Head, Elen, Degree, W, Control, Info)
	ccall((:amd_l2, libamd), Cvoid, (Int64, Ptr{Int64}, Ptr{Int64}, Ptr{Int64}, Int64, Int64, Ptr{Int64}, Ptr{Int64}, Ptr{Int64}, Ptr{Int64}, Ptr{Int64}, Ptr{Int64}, Ptr{Int64}, Ptr{Cdouble}, Ptr{Cdouble}), n, Pe, Iw, Len, iwlen, pfree, Nv, Next, Last, Head, Elen, Degree, W, Control, Info)

	ccall((:klu_zl_scale, libklu), Cint, (Cint, Int64, Ptr{Int64}, Ptr{Int64}, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Int64}, Ptr{klu_l_common}), arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8)
	end

	function klu_extract(Numeric, Symbolic, Lp, Li, Lx, Up, Ui, Ux, Fp, Fi, Fx, P, Q, Rs, R, Common)
	ccall((:klu_extract, libklu), Cint, (Ptr{klu_numeric}, Ptr{klu_symbolic}, Ptr{Int32}, Ptr{Int32}, Ptr{Cdouble}, Ptr{Int32}, Ptr{Int32}, Ptr{Cdouble}, Ptr{Int32}, Ptr{Int32}, Ptr{Cdouble}, Ptr{Int32}, Ptr{Int32}, Ptr{Cdouble}, Ptr{Int32}, Ptr{klu_common}), Numeric, Symbolic, Lp, Li, Lx, Up, Ui, Ux, Fp, Fi, Fx, P, Q, Rs, R, Common)
	end

	function klu_z_extract(Numeric, Symbolic, Lp, Li, Lx, Lz, Up, Ui, Ux, Uz, Fp, Fi, Fx, Fz, P, Q, Rs, R, Common)
	ccall((:klu_z_extract, libklu), Cint, (Ptr{klu_numeric}, Ptr{klu_symbolic}, Ptr{Int32}, Ptr{Int32}, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Int32}, Ptr{Int32}, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Int32}, Ptr{Int32}, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Int32}, Ptr{Int32}, Ptr{Cdouble}, Ptr{Int32}, Ptr{klu_common}), Numeric, Symbolic, Lp, Li, Lx, Lz, Up, Ui, Ux, Uz, Fp, Fi, Fx, Fz, P, Q, Rs, R, Common)
	end

	function klu_l_extract(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14, arg15, arg16)
	ccall((:klu_l_extract, libklu), Cint, (Ptr{klu_l_numeric}, Ptr{klu_l_symbolic}, Ptr{Int64}, Ptr{Int64}, Ptr{Cdouble}, Ptr{Int64}, Ptr{Int64}, Ptr{Cdouble}, Ptr{Int64}, Ptr{Int64}, Ptr{Cdouble}, Ptr{Int64}, Ptr{Int64}, Ptr{Cdouble}, Ptr{Int64}, Ptr{klu_l_common}), arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14, arg15, arg16)
	end

	function klu_zl_extract(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14, arg15, arg16, arg17, arg18, arg19)
	ccall((:klu_zl_extract, libklu), Cint, (Ptr{klu_l_numeric}, Ptr{klu_l_symbolic}, Ptr{Int64}, Ptr{Int64}, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Int64}, Ptr{Int64}, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Int64}, Ptr{Int64}, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Int64}, Ptr{Int64}, Ptr{Cdouble}, Ptr{Int64}, Ptr{klu_l_common}), arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14, arg15, arg16, arg17, arg18, arg19)

		function decrement!(A::AbstractArray{T}) where T<:Integer
		for i in eachindex(A); A[i] -= oneunit(T) end

		function increment!(A::AbstractArray{T}) where T<:Integer
		for i in eachindex(A); A[i] += oneunit(T) end

		const AdjointFact = isdefined(LinearAlgebra, :AdjointFactorization) ? LinearAlgebra.AdjointFactorization : Adjoint
		const TransposeFact = isdefined(LinearAlgebra, :TransposeFactorization) ? LinearAlgebra.TransposeFactorization : Transpose

	return Symbol(replace(outname, "__"=>"_"))
	return Symbol(replace(outname, "__" => "_"))

	function getproperty(klu::AbstractKLUFactorization{Tv, Ti}, s::Symbol) where {Tv<:KLUTypes, Ti<:KLUITypes}
	function getproperty(klu::AbstractKLUFactorization{Tv, Ti},
	s::Symbol) where {Tv <: KLUTypes, Ti <: KLUITypes}

	klu._numeric == C_NULL && throw(ArgumentError("This KLUFactorization has not yet been factored. Try `klu_factor!`."))
	klu._numeric == C_NULL &&
	throw(ArgumentError("This KLUFactorization has not yet been factored. Try `klu_factor!`."))

	klu._symbolic == C_NULL && throw(ArgumentError("This KLUFactorization has not yet been analyzed. Try `klu_analyze!`."))
	klu._symbolic == C_NULL &&
	throw(ArgumentError("This KLUFactorization has not yet been analyzed. Try `klu_analyze!`."))

	return SparseMatrixCSC(klu.n, klu.n, increment!(p), increment!(i), Complex.(x, z))
	return SparseMatrixCSC(
	klu.n, klu.n, increment!(p), increment!(i), Complex.(x, z))

	silent divide by zero errors in subsequent `solve!` or `ldiv!` calls if singularity is not checked by the user with `klu.common.status == KLU.KLU_SINGULAR`
	silent divide by zero errors in subsequent `solve!` or `ldiv!` calls if singularity is not checked by the user with `klu.common.status == KLU.KLU_SINGULAR`

	for Tv ∈ KLUValueTypes, Ti ∈ KLUIndexTypes
	for Tv in KLUValueTypes, Ti in KLUIndexTypes

	ok = $refactor(K.colptr, K.rowval, K.nzval, K._symbolic, K._numeric, Ref(K.common))
	ok = $refactor(
	K.colptr, K.rowval, K.nzval, K._symbolic, K._numeric, Ref(K.common))

	function klu!(K::AbstractKLUFactorization{ComplexF64}, nzval::Vector{U}; check=true, allowsingular=false) where {U<:Complex}
	function klu!(K::AbstractKLUFactorization{ComplexF64}, nzval::Vector{U};
	check = true, allowsingular = false) where {U <: Complex}

	function klu!(K::KLUFactorization{U}, S::SparseMatrixCSC{U}; check=true, allowsingular=false) where {U}
	function klu!(K::KLUFactorization{U}, S::SparseMatrixCSC{U};
	check = true, allowsingular = false) where {U}

	(decrement!(K.colptr); decrement!(K.rowval);
	(decrement!(K.colptr);
	decrement!(K.rowval);

	ccall((:SuiteSparse_config_printf_func_set, libsuitesparseconfig), Cvoid, (Ptr{Cvoid},), printf_func)
	ccall((:SuiteSparse_config_printf_func_set, libsuitesparseconfig),
	Cvoid, (Ptr{Cvoid},), printf_func)

Make SparseArrays an extension #570

Make SparseArrays an extension #570

Conversation

ChrisRackauckas commented Feb 1, 2025

github-actions bot left a comment

Choose a reason for hiding this comment

github-actions bot Feb 1, 2025

Choose a reason for hiding this comment

github-actions bot Feb 1, 2025

Choose a reason for hiding this comment

github-actions bot Feb 1, 2025

Choose a reason for hiding this comment

github-actions bot Feb 1, 2025

Choose a reason for hiding this comment

github-actions bot Feb 1, 2025

Choose a reason for hiding this comment

github-actions bot Feb 1, 2025

Choose a reason for hiding this comment

github-actions bot Feb 1, 2025

Choose a reason for hiding this comment

github-actions bot Feb 1, 2025

Choose a reason for hiding this comment

github-actions bot Feb 1, 2025

Choose a reason for hiding this comment

github-actions bot Feb 1, 2025

Choose a reason for hiding this comment

github-actions bot left a comment

Choose a reason for hiding this comment

github-actions bot Feb 5, 2025

Choose a reason for hiding this comment

github-actions bot Feb 5, 2025

Choose a reason for hiding this comment

github-actions bot Feb 5, 2025

Choose a reason for hiding this comment

github-actions bot Feb 5, 2025

Choose a reason for hiding this comment

github-actions bot Feb 5, 2025

Choose a reason for hiding this comment

github-actions bot Feb 5, 2025

Choose a reason for hiding this comment

github-actions bot Feb 5, 2025

Choose a reason for hiding this comment

github-actions bot Feb 5, 2025

Choose a reason for hiding this comment

github-actions bot Feb 5, 2025

Choose a reason for hiding this comment

github-actions bot Feb 5, 2025

Choose a reason for hiding this comment

github-actions bot left a comment

Choose a reason for hiding this comment

github-actions bot Feb 5, 2025

Choose a reason for hiding this comment

github-actions bot Feb 5, 2025

Choose a reason for hiding this comment

github-actions bot Feb 5, 2025

Choose a reason for hiding this comment

github-actions bot Feb 5, 2025

Choose a reason for hiding this comment

github-actions bot Feb 5, 2025

Choose a reason for hiding this comment

github-actions bot Feb 5, 2025

Choose a reason for hiding this comment

github-actions bot Feb 5, 2025

Choose a reason for hiding this comment

github-actions bot Feb 5, 2025

Choose a reason for hiding this comment

github-actions bot Feb 5, 2025

Choose a reason for hiding this comment

github-actions bot Feb 5, 2025

Choose a reason for hiding this comment

github-actions bot left a comment

Choose a reason for hiding this comment

github-actions bot Feb 5, 2025

Choose a reason for hiding this comment

github-actions bot Feb 5, 2025

Choose a reason for hiding this comment

github-actions bot Feb 5, 2025

Choose a reason for hiding this comment

github-actions bot Feb 5, 2025

Choose a reason for hiding this comment

	ccall((:SuiteSparse_config_hypot_func_set, libsuitesparseconfig), Cvoid, (Ptr{Cvoid},), hypot_func)
	ccall((:SuiteSparse_config_hypot_func_set, libsuitesparseconfig),
	Cvoid, (Ptr{Cvoid},), hypot_func)

	ccall((:SuiteSparse_config_divcomplex_func_set, libsuitesparseconfig), Cvoid, (Ptr{Cvoid},), divcomplex_func)
	ccall((:SuiteSparse_config_divcomplex_func_set, libsuitesparseconfig),
	Cvoid, (Ptr{Cvoid},), divcomplex_func)

	ccall((:SuiteSparse_config_calloc, libsuitesparseconfig), Ptr{Cvoid}, (Csize_t, Csize_t), n, s)
	ccall((:SuiteSparse_config_calloc, libsuitesparseconfig),
	Ptr{Cvoid}, (Csize_t, Csize_t), n, s)

	ccall((:SuiteSparse_config_realloc, libsuitesparseconfig), Ptr{Cvoid}, (Ptr{Cvoid}, Csize_t), arg1, s)
	ccall((:SuiteSparse_config_realloc, libsuitesparseconfig),
	Ptr{Cvoid}, (Ptr{Cvoid}, Csize_t), arg1, s)

		LinearSolve.make_SparseMatrixCSC(A::AbstractSparseArray) = SparseMatrixCSC(size(A)..., getcolptr(A), rowvals(A), nonzeros(A))
		LinearSolve.makeempty_SparaseMatrixCSC(A::AbstractSparseArray) = SparseMatrixCSC(0, 0, [1], Int[], eltype(A)[])

	LinearSolve.DefaultLinearSolver(LinearSolve.DefaultAlgorithmChoice.CHOLMODFactorization)
	LinearSolve.DefaultLinearSolver(LinearSolve.DefaultAlgorithmChoice.CHOLMODFactorization)

	function LinearSolve.init_cacheval(alg::UMFPACKFactorization, A::SparseMatrixCSC{Float64, Int}, b, u,
	function LinearSolve.init_cacheval(
	alg::UMFPACKFactorization, A::SparseMatrixCSC{Float64, Int}, b, u,

	ccall((:amd_l_valid, libamd), Cint, (Int64, Int64, Ptr{Int64}, Ptr{Int64}), n_row, n_col, Ap, Ai)
	ccall((:amd_l_valid, libamd), Cint,
	(Int64, Int64, Ptr{Int64}, Ptr{Int64}), n_row, n_col, Ap, Ai)

	ccall((:colamd_l_recommended, libamd), Csize_t, (Int64, Int64, Int64), nnz, n_row, n_col)
	ccall(
	(:colamd_l_recommended, libamd), Csize_t, (Int64, Int64, Int64), nnz, n_row, n_col)