Require Julia 1.12 and fix memory-safety and failure-path problems

Project.toml

@@ -1,22 +1,24 @@
 name = "KLU"
 uuid = "ef3ab10e-7fda-4108-b977-705223b18434"
 authors = ["Raye Kimmerer <kimmerer@mit.edu> and contributors"]
-version = "0.6.0"
+version = "0.7.0"
 
 [deps]
 LinearAlgebra = "37e2e46d-f89d-539d-b4ee-838fcccc9c8e"
 SparseArrays = "2f01184e-e22b-5df5-ae63-d93ebab69eaf"
 SuiteSparse_jll = "bea87d4a-7f5b-5778-9afe-8cc45184846c"
 
 [compat]
-LinearAlgebra = "1.10"
+LinearAlgebra = "1.12"
+Serialization = "1.11"
 SuiteSparse_jll = "7.2"
 Test = "1.10"
-SparseArrays = "1.10"
-julia = "1.10"
+SparseArrays = "1.12"
+julia = "1.12"
 
 [extras]
+Serialization = "9e88b42a-f829-5b0c-bbe9-9e923198166b"
 Test = "8dfed614-e22c-5e08-85e1-65c5234f0b40"
 
 [targets]
-test = ["Test"]
+test = ["Serialization", "Test"]

README.md

@@ -48,6 +48,14 @@ julia> klu!(factor, B);          # B has the same pattern as A
 julia> klu!(factor, nonzeros(B)); # or just its values
 ```
 
+If `klu!` throws a `SingularException`, `factor` has no numeric factorization until a later
+`klu!` or `klu_factor!` succeeds, and solving with it throws as well.
+
+To avoid using more memory, `factor` shares the vectors it is given: after `klu(A)` or
+`klu!(factor, B)` with `Float64` or `ComplexF64` values, `nonzeros(factor)` is the vector of `A`
+or `B`. It is the caller's responsibility not to change them in a way that breaks `factor`, as
+described in the docstring of `klu`.
+
 `klu(A; full_factor = false)` only analyzes the pattern of `A`, and `klu!` then computes the
 first numeric factorization. Use `copy(factor)` to get an independent factorization, for
 example to refactor it without affecting the original. This costs as much as a new
@@ -56,7 +64,8 @@ factorization.
 ## Checking a factorization
 
 `rcond` is a cheap estimate of the reciprocal condition number, `condest` is a more accurate
-estimate of the 1-norm condition number, and `rgrowth` is the reciprocal pivot growth.
+estimate of the 1-norm condition number, and `rgrowth` is the reciprocal pivot growth. `det`,
+`logabsdet`, and `logdet` give the determinant of the factored matrix.
 
 ## Thread safety
 

docs/Project.toml

@@ -3,4 +3,4 @@ Documenter = "e30172f5-a6a5-5a46-863b-614d45cd2de4"
 
 [compat]
 Documenter = "1"
-julia = "1.10"
+julia = "1.12"

docs/src/index.md

@@ -49,6 +49,14 @@ julia> klu!(factor, B);          # B has the same pattern as A
 julia> klu!(factor, nonzeros(B)); # or just its values
 ```
 
+If `klu!` throws a `SingularException`, `factor` has no numeric factorization until a later
+`klu!` or `klu_factor!` succeeds, and solving with it throws as well.
+
+To avoid using more memory, `factor` shares the vectors it is given: after `klu(A)` or
+`klu!(factor, B)` with `Float64` or `ComplexF64` values, `nonzeros(factor)` is the vector of `A`
+or `B`. It is the caller's responsibility not to change them in a way that breaks `factor`, as
+described in the docstring of [`klu`](@ref).
+
 `klu(A; full_factor = false)` only analyzes the pattern of `A`, and `klu!` then computes the
 first numeric factorization. Use `copy(factor)` to get an independent factorization, for
 example to refactor it without affecting the original. This costs as much as a new
@@ -57,7 +65,8 @@ factorization.
 ## Checking a factorization
 
 `rcond` is a cheap estimate of the reciprocal condition number, `condest` is a more accurate
-estimate of the 1-norm condition number, and `rgrowth` is the reciprocal pivot growth.
+estimate of the 1-norm condition number, and `rgrowth` is the reciprocal pivot growth. `det`,
+`logabsdet`, and `logdet` give the determinant of the factored matrix.
 
 ## Thread safety
 
@@ -91,6 +100,7 @@ solve!
 rcond
 condest
 rgrowth
+KLU.LinearAlgebra.logabsdet(::KLU.KLUFactorization)
 KLU.KLUFactorization
 Base.copy(::KLU.KLUFactorization)
 ```