Format with Runic (#220)

* Add Runic workflow and badge

* Run Runic

* Adjust allocation tests on Mac

Author: devmotion

.github/workflows/Format.yml

@@ -0,0 +1,22 @@
+name: Check formatting
+on:
+  push:
+    branches:
+      - 'master'
+      - 'release-'
+    tags:
+      - '*'
+  pull_request:
+jobs:
+  runic:
+    name: Runic
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: julia-actions/setup-julia@v2
+        with:
+          version: '1'
+      - uses: julia-actions/cache@v2
+      - uses: fredrikekre/runic-action@v1
+        with:
+          version: '1'

README.md

@@ -4,6 +4,7 @@ Uniform interface for positive definite matrices of various structures.
 
 [![CI](https://github.com/JuliaStats/PDMats.jl/actions/workflows/ci.yml/badge.svg)](https://github.com/JuliaStats/PDMats.jl/actions/workflows/ci.yml)
 [![Coverage Status](https://img.shields.io/coveralls/JuliaStats/PDMats.jl.svg)](https://coveralls.io/r/JuliaStats/PDMats.jl?branch=master)
+[![code style: runic](https://img.shields.io/badge/code_style-%E1%9A%B1%E1%9A%A2%E1%9A%BE%E1%9B%81%E1%9A%B2-black)](https://github.com/fredrikekre/Runic.jl)
 
 --------------
 

src/PDMats.jl

@@ -1,59 +1,59 @@
 module PDMats
 
-    using LinearAlgebra, SparseArrays, SuiteSparse
+using LinearAlgebra, SparseArrays, SuiteSparse
 
-    import Base: +, *, \, /, ==, convert, inv, Matrix, kron
+import Base: +, *, \, /, ==, convert, inv, Matrix, kron
 
-    export
-        # Types
-        AbstractPDMat,
-        PDMat,
-        PDSparseMat,
-        PDiagMat,
-        ScalMat,
+export
+    # Types
+    AbstractPDMat,
+    PDMat,
+    PDSparseMat,
+    PDiagMat,
+    ScalMat,
 
-        # Functions
-        dim,
-        whiten,
-        whiten!,
-        unwhiten,
-        unwhiten!,
-        pdadd,
-        pdadd!,
-        quad,
-        quad!,
-        invquad,
-        invquad!,
-        X_A_Xt,
-        Xt_A_X,
-        X_invA_Xt,
-        Xt_invA_X
+    # Functions
+    dim,
+    whiten,
+    whiten!,
+    unwhiten,
+    unwhiten!,
+    pdadd,
+    pdadd!,
+    quad,
+    quad!,
+    invquad,
+    invquad!,
+    X_A_Xt,
+    Xt_A_X,
+    X_invA_Xt,
+    Xt_invA_X
 
 
-    """
-    The base type for positive definite matrices.
-    """
-    abstract type AbstractPDMat{T<:Real} <: AbstractMatrix{T} end
+"""
+The base type for positive definite matrices.
+"""
+abstract type AbstractPDMat{T <: Real} <: AbstractMatrix{T} end
 
-    const HAVE_CHOLMOD = isdefined(SuiteSparse, :CHOLMOD)
+const HAVE_CHOLMOD = isdefined(SuiteSparse, :CHOLMOD)
 
-    # source files
+# source files
 
-    include("utils.jl")
-    include("chol.jl")
+include("utils.jl")
+include("chol.jl")
 
-    include("pdmat.jl")
+include("pdmat.jl")
 
-    if HAVE_CHOLMOD
-        include("pdsparsemat.jl")
-    end
+if HAVE_CHOLMOD
+    include("pdsparsemat.jl")
+end
 
-    include("pdiagmat.jl")
-    include("scalmat.jl")
+include("pdiagmat.jl")
+include("scalmat.jl")
 
-    include("generics.jl")
-    include("addition.jl")
+include("generics.jl")
+include("addition.jl")
 
-    include("deprecates.jl")
+include("deprecates.jl")
 
 end # module

src/addition.jl

@@ -1,4 +1,3 @@
-
 # between pdmat and pdmat
 
 +(a::PDMat, b::AbstractPDMat) = PDMat(a.mat + Matrix(b))

src/chol.jl

@@ -53,7 +53,7 @@ end
 function quad(A::Cholesky, X::AbstractMatrix)
     @check_argdims size(A, 1) == size(X, 1)
     Z = chol_upper(A) * X
-    return vec(sum(abs2, Z; dims=1))
+    return vec(sum(abs2, Z; dims = 1))
 end
 function quad!(r::AbstractArray, A::Cholesky, X::AbstractMatrix)
     @check_argdims eachindex(r) == axes(X, 2)
@@ -75,7 +75,7 @@ end
 function invquad(A::Cholesky, X::AbstractMatrix)
     @check_argdims size(A, 1) == size(X, 1)
     Z = chol_lower(A) \ X
-    return vec(sum(abs2, Z; dims=1))
+    return vec(sum(abs2, Z; dims = 1))
 end
 function invquad!(r::AbstractArray, A::Cholesky, X::AbstractMatrix)
     @check_argdims eachindex(r) == axes(X, 2)

src/deprecates.jl

@@ -17,8 +17,7 @@ using Base: @deprecate
 
 @deprecate dim(a::AbstractMatrix) LinearAlgebra.checksquare(a)
 
-@deprecate PDMat{T,S}(d::Int, m::AbstractMatrix{T}, c::Cholesky{T,S}) where {T,S} PDMat{T,S}(m, c)
+@deprecate PDMat{T, S}(d::Int, m::AbstractMatrix{T}, c::Cholesky{T, S}) where {T, S} PDMat{T, S}(m, c)
 
 @deprecate PDiagMat(dim::Int, diag::AbstractVector{<:Real}) PDiagMat(diag)
-@deprecate PDiagMat{T,V}(dim, diag) where {T<:Real, V<:AbstractVector{T}} PDiagMat{T,V}(diag)
-
+@deprecate PDiagMat{T, V}(dim, diag) where {T <: Real, V <: AbstractVector{T}} PDiagMat{T, V}(diag)

src/generics.jl

@@ -5,25 +5,25 @@ AbstractPDMat(A::AbstractPDMat) = A
 AbstractPDMat(A::AbstractMatrix) = PDMat(A)
 
 ## convert
-Base.convert(::Type{AbstractMatrix{T}}, a::AbstractPDMat) where {T<:Real} = convert(AbstractPDMat{T}, a)
-Base.convert(::Type{AbstractArray{T}}, a::AbstractPDMat) where {T<:Real} = convert(AbstractMatrix{T}, a)
+Base.convert(::Type{AbstractMatrix{T}}, a::AbstractPDMat) where {T <: Real} = convert(AbstractPDMat{T}, a)
+Base.convert(::Type{AbstractArray{T}}, a::AbstractPDMat) where {T <: Real} = convert(AbstractMatrix{T}, a)
 
 ## arithmetics
 
-pdadd!(r::Matrix, a::Matrix, b::AbstractPDMat{T}) where {T<:Real} = pdadd!(r, a, b, one(T))
+pdadd!(r::Matrix, a::Matrix, b::AbstractPDMat{T}) where {T <: Real} = pdadd!(r, a, b, one(T))
 
 pdadd!(a::Matrix, b::AbstractPDMat, c) = pdadd!(a, a, b, c)
-pdadd!(a::Matrix, b::AbstractPDMat{T}) where {T<:Real} = pdadd!(a, a, b, one(T))
+pdadd!(a::Matrix, b::AbstractPDMat{T}) where {T <: Real} = pdadd!(a, a, b, one(T))
 
-pdadd(a::Matrix{T}, b::AbstractPDMat{S}, c::R) where {T<:Real, S<:Real, R<:Real} = pdadd!(similar(a, promote_type(T, S, R)), a, b, c)
-pdadd(a::Matrix{T}, b::AbstractPDMat{S}) where {T<:Real, S<:Real} = pdadd!(similar(a, promote_type(T, S)), a, b, one(T))
+pdadd(a::Matrix{T}, b::AbstractPDMat{S}, c::R) where {T <: Real, S <: Real, R <: Real} = pdadd!(similar(a, promote_type(T, S, R)), a, b, c)
+pdadd(a::Matrix{T}, b::AbstractPDMat{S}) where {T <: Real, S <: Real} = pdadd!(similar(a, promote_type(T, S)), a, b, one(T))
 
 +(a::Matrix, b::AbstractPDMat) = pdadd(a, b)
 +(a::AbstractPDMat, b::Matrix) = pdadd(b, a)
 
-*(a::AbstractPDMat, c::T) where {T<:Real} = a * c
-*(c::T, a::AbstractPDMat) where {T<:Real} = a * c
-/(a::AbstractPDMat, c::T) where {T<:Real} = a * inv(c)
+*(a::AbstractPDMat, c::T) where {T <: Real} = a * c
+*(c::T, a::AbstractPDMat) where {T <: Real} = a * c
+/(a::AbstractPDMat, c::T) where {T <: Real} = a * inv(c)
 Base.kron(A::AbstractPDMat, B::AbstractPDMat) = PDMat(kron(Matrix(A), Matrix(B)))
 
 # LinearAlgebra
@@ -140,4 +140,3 @@ Overwrite `r` with the value of the quadratic form defined by `inv(a)` applied c
 function invquad!(r::AbstractArray, a::AbstractMatrix{<:Real}, x::AbstractMatrix)
     return invquad!(r, AbstractPDMat(a), x)
 end
-

src/pdiagmat.jl

@@ -1,7 +1,7 @@
 """
 Positive definite diagonal matrix.
 """
-struct PDiagMat{T<:Real,V<:AbstractVector{T}} <: AbstractPDMat{T}
+struct PDiagMat{T <: Real, V <: AbstractVector{T}} <: AbstractPDMat{T}
     diag::V
 end
 
@@ -14,16 +14,16 @@ end
 Base.propertynames(::PDiagMat) = (:diag, :dim)
 
 AbstractPDMat(A::Diagonal{<:Real}) = PDiagMat(A.diag)
-AbstractPDMat(A::Symmetric{<:Real,<:Diagonal{<:Real}}) = PDiagMat(A.data.diag)
-AbstractPDMat(A::Hermitian{<:Real,<:Diagonal{<:Real}}) = PDiagMat(A.data.diag)
+AbstractPDMat(A::Symmetric{<:Real, <:Diagonal{<:Real}}) = PDiagMat(A.data.diag)
+AbstractPDMat(A::Hermitian{<:Real, <:Diagonal{<:Real}}) = PDiagMat(A.data.diag)
 
 ### Conversion
-Base.convert(::Type{PDiagMat{T}}, a::PDiagMat{T}) where {T<:Real} = a
-function Base.convert(::Type{PDiagMat{T}}, a::PDiagMat) where {T<:Real}
+Base.convert(::Type{PDiagMat{T}}, a::PDiagMat{T}) where {T <: Real} = a
+function Base.convert(::Type{PDiagMat{T}}, a::PDiagMat) where {T <: Real}
     diag = convert(AbstractVector{T}, a.diag)
-    return PDiagMat{T,typeof(diag)}(diag)
+    return PDiagMat{T, typeof(diag)}(diag)
 end
-Base.convert(::Type{AbstractPDMat{T}}, a::PDiagMat) where {T<:Real} = convert(PDiagMat{T}, a)
+Base.convert(::Type{AbstractPDMat{T}}, a::PDiagMat) where {T <: Real} = convert(PDiagMat{T}, a)
 
 ### Basics
 
@@ -125,11 +125,11 @@ function quad!(r::AbstractArray, a::PDiagMat, x::AbstractMatrix)
     @inbounds for j in axes(x, 2)
         s = zero(promote_type(eltype(ad), eltype(x)))
         for i in axes(x, 1)
-            s += ad[i] * abs2(x[i,j])
+            s += ad[i] * abs2(x[i, j])
         end
         r[j] = s
     end
-    r
+    return r
 end
 
 function invquad(a::PDiagMat, x::AbstractVecOrMat)
@@ -150,11 +150,11 @@ function invquad!(r::AbstractArray, a::PDiagMat, x::AbstractMatrix)
     @inbounds for j in axes(x, 2)
         s = zero(zero(eltype(x)) / zero(eltype(ad)))
         for i in axes(x, 1)
-            s += abs2(x[i,j]) / ad[i]
+            s += abs2(x[i, j]) / ad[i]
         end
         r[j] = s
     end
-    r
+    return r
 end
 
 
@@ -186,15 +186,14 @@ end
 
 ### Specializations for `Array` arguments with reduced allocations
 
-function quad(a::PDiagMat{<:Real,<:Vector}, x::Matrix)
+function quad(a::PDiagMat{<:Real, <:Vector}, x::Matrix)
     @check_argdims a.dim == size(x, 1)
     T = typeof(zero(eltype(a)) * abs2(zero(eltype(x))))
     return quad!(Vector{T}(undef, size(x, 2)), a, x)
 end
 
-function invquad(a::PDiagMat{<:Real,<:Vector}, x::Matrix)
+function invquad(a::PDiagMat{<:Real, <:Vector}, x::Matrix)
     @check_argdims a.dim == size(x, 1)
     T = typeof(abs2(zero(eltype(x))) / zero(eltype(a)))
     return invquad!(Vector{T}(undef, size(x, 2)), a, x)
 end
-