Documentation: update exported, fix formatting

Author: luke-kiernan

docs/src/index.md

@@ -46,4 +46,8 @@ Please cite both [SuiteSparse](https://github.com/DrTimothyAldenDavis/SuiteSpars
 
 ```@docs
 klu
+klu!
+klu_refactor!
+nonzeros
+solve!
 ```

src/KLU.jl

@@ -5,7 +5,7 @@ using SparseArrays: SparseMatrixCSC
 import SparseArrays: nnz, nonzeros
 
 export klu, klu!
-export klu_analyze!, klu_factor!, klu_refactor!, solve!
+export klu_factor!, klu_refactor!, solve!
 export nonzeros
 
 const libklu = :libklu
@@ -68,10 +68,10 @@ Data structure for parameters of and statistics generated by KLU functions.
 # Fields
 - `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,
+- `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
+- `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`.
 
 See the [KLU User Guide](https://github.com/DrTimothyAldenDavis/SuiteSparse/raw/master/KLU/Doc/KLU_UserGuide.pdf)
@@ -184,12 +184,12 @@ end
 
 nnz(K::AbstractKLUFactorization) = K.lnz + K.unz + K.nzoff
 """The nonzeros of the factorization `K`.
-!!! warning "`nonzeros(K)` may or may not point to `nonzeros(A)`"
-    After `K = klu(A)`, it may or may not be the case that `nonzeros(K) === nonzeros(A)`.
-    If `A` is of type `SparseMatrixCSC{Float32, Int64}`, then `nonzeros(F)` will be 
-    a `Vector{Float64}`, while `nonzeros(A)` is a `Vector{Float32}`, so they're definitely distinct.
-    On the other hand, if `A` has value type `Float64`, then changing the values in `nonzeros(A)` 
-    will change `nonzeros(F)` as well.
+!!! warning "nonzeros(K) may or may not point to nonzeros(A)"
+    After `K = klu(A)`, it may or may not be the case that `nonzeros(K) === nonzeros(A)`. \
+    If `A` is of type `SparseMatrixCSC{Float32, Int64}`, then `nonzeros(K)` will be \
+    a `Vector{Float64}`, while `nonzeros(A)` is a `Vector{Float32}`, so they're definitely distinct. \
+    On the other hand, if `A` has value type `Float64`, then changing the values in `nonzeros(A)` \
+    will change `nonzeros(K)` as well.
 """
 nonzeros(K::AbstractKLUFactorization) = K.nzval
 
@@ -383,7 +383,10 @@ function show(io::IO, mime::MIME{Symbol("text/plain")}, K::AbstractKLUFactorizat
     end
 end
 
-"""Compute and store (as `K._symbolic`) a symbolic factorization of the sparse matrix 
+"""
+    klu_analyze!(K::KLUFactorization; check = true)
+
+Compute and store (as `K._symbolic`) a symbolic factorization of the sparse matrix \
 represented by the fields of `K`."""
 function klu_analyze!(K::KLUFactorization{Tv, Ti}; check=true) where {Tv, Ti<:KLUITypes}
     if K._symbolic != C_NULL return K end
@@ -396,7 +399,10 @@ function klu_analyze!(K::KLUFactorization{Tv, Ti}; check=true) where {Tv, Ti<:KL
     return K
 end
 
-"""Variant of `klu_analyze!` that allows for user-provided permutation permutation vectors `P` and `Q`."""
+"""
+    klu_analyze!(K::KLUFactorization{Tv, Ti}, P::Vector{Ti}, Q::Vector{Ti}; check = true)
+
+Variant of `klu_analyze!` that allows for user-provided permutation permutation vectors `P` and `Q`."""
 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
     sym = __analyze!(K.n, K.colptr, K.rowval, P, Q, Ref(K.common))
@@ -487,11 +493,11 @@ existing `KLUFactorization` instance.
 # Arguments
   - `K::KLUFactorization`: The matrix factorization object 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`
+  - `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`
 
-The `K.common` struct can be used to modify certain options and parameters, see the
-[KLU documentation](https://github.com/DrTimothyAldenDavis/SuiteSparse/raw/master/KLU/Doc/KLU_UserGuide.pdf)
+The `K.common` struct can be used to modify certain options and parameters, see the \
+[KLU documentation](https://github.com/DrTimothyAldenDavis/SuiteSparse/raw/master/KLU/Doc/KLU_UserGuide.pdf) \
 or [`klu_common`](@ref) for more information.
 """
 klu_factor!
@@ -529,9 +535,9 @@ The relation between `K` and `A` is
 # Arguments
   - `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`
-  - `full_factor::Bool`: if `true` (default), perform both numeric and symbolic factorization. If `false`, only perform symbolic factorization. 
+  - `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`
+  - `full_factor::Bool`: if `true` (default), perform both numeric and symbolic factorization. If `false`, only perform symbolic factorization. \
   Useful for cases where only the sparse structure of `A` is known at time of construction.
 
 !!! note
@@ -607,7 +613,7 @@ See also: [`klu`](@ref)
   - `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`
+    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