Add format action (#254)

Author: blegat

.JuliaFormatter.toml

@@ -0,0 +1,8 @@
+# Configuration file for JuliaFormatter.jl
+# For more information, see: https://domluna.github.io/JuliaFormatter.jl/stable/config/
+
+always_for_in = true
+always_use_return = true
+margin = 80
+remove_extra_newlines = true
+short_to_long_function_def = true

.github/workflows/format_check.yml

@@ -0,0 +1,32 @@
+
+name: format-check
+on:
+  push:
+    branches:
+      - master
+      - release-*
+  pull_request:
+    types: [opened, synchronize, reopened]
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: julia-actions/setup-julia@latest
+        with:
+          version: '1'
+      - uses: actions/checkout@v3
+      - name: Format check
+        shell: julia --color=yes {0}
+        run: |
+          using Pkg
+          Pkg.add(PackageSpec(name="JuliaFormatter", version="1"))
+          using JuliaFormatter
+          format("src", verbose=true)
+          format("test", verbose=true)
+          out = String(read(Cmd(`git diff`)))
+          if isempty(out)
+              exit(0)
+          end
+          @error "Some files have not been formatted !!!"
+          write(stdout, out)
+          exit(1)

src/antidifferentiation.jl

@@ -28,16 +28,24 @@ function antidifferentiate end
 
 # Fallback for everything else
 antidifferentiate(α::T, v::AbstractVariable) where {T} = α * v
-antidifferentiate(v1::AbstractVariable, v2::AbstractVariable) = v1 == v2 ? 1 // 2 * v1 * v2 : v1 * v2
-antidifferentiate(t::AbstractTermLike, v::AbstractVariable) = coefficient(t) * antidifferentiate(monomial(t), v)
-antidifferentiate(p::APL, v::AbstractVariable) = polynomial!(antidifferentiate.(terms(p), v), SortedState())
+function antidifferentiate(v1::AbstractVariable, v2::AbstractVariable)
+    return v1 == v2 ? 1 // 2 * v1 * v2 : v1 * v2
+end
+function antidifferentiate(t::AbstractTermLike, v::AbstractVariable)
+    return coefficient(t) * antidifferentiate(monomial(t), v)
+end
+function antidifferentiate(p::APL, v::AbstractVariable)
+    return polynomial!(antidifferentiate.(terms(p), v), SortedState())
+end
 
 # TODO: this signature is probably too wide and creates the potential
 # for stack overflows
 antidifferentiate(p::APL, xs) = [antidifferentiate(p, x) for x in xs]
 
 # antidifferentiate(p, [x, y]) with TypedPolynomials promote x to a Monomial
-antidifferentiate(p::APL, m::AbstractMonomial) = antidifferentiate(p, variable(m))
+function antidifferentiate(p::APL, m::AbstractMonomial)
+    return antidifferentiate(p, variable(m))
+end
 
 # The `R` argument indicates a desired result type. We use this in order
 # to attempt to preserve type-stability even though the value of `deg` cannot
@@ -55,11 +63,27 @@ function (_antidifferentiate_recursive(p, x, deg::Int, ::Type{R})::R) where {R}
     end
 end
 
-antidifferentiate(p, x, deg::Int) = _antidifferentiate_recursive(p, x, deg, Base.promote_op(antidifferentiate, typeof(p), typeof(x)))
-antidifferentiate(p::AbstractArray, x, deg::Int) = _antidifferentiate_recursive(p, x, deg, Any)
-antidifferentiate(p, x::Union{AbstractArray,Tuple}, deg::Int) = _antidifferentiate_recursive(p, x, deg, Any)
-antidifferentiate(p::AbstractArray, x::Union{AbstractArray,Tuple}, deg::Int) = _antidifferentiate_recursive(p, x, deg, Any)
-
+function antidifferentiate(p, x, deg::Int)
+    return _antidifferentiate_recursive(
+        p,
+        x,
+        deg,
+        Base.promote_op(antidifferentiate, typeof(p), typeof(x)),
+    )
+end
+function antidifferentiate(p::AbstractArray, x, deg::Int)
+    return _antidifferentiate_recursive(p, x, deg, Any)
+end
+function antidifferentiate(p, x::Union{AbstractArray,Tuple}, deg::Int)
+    return _antidifferentiate_recursive(p, x, deg, Any)
+end
+function antidifferentiate(
+    p::AbstractArray,
+    x::Union{AbstractArray,Tuple},
+    deg::Int,
+)
+    return _antidifferentiate_recursive(p, x, deg, Any)
+end
 
 # This is alternative, Val-based interface for nested antidifferentiation.
 # It has the advantage of not requiring an conversion or calls to

src/chain_rules.jl

@@ -22,7 +22,9 @@ function ChainRulesCore.frule((_, Δp, _), ::typeof(differentiate), p, x)
     return differentiate(p, x), differentiate(Δp, x)
 end
 function pullback(Δdpdx, x)
-    return ChainRulesCore.NoTangent(), x * differentiate(x * Δdpdx, x), ChainRulesCore.NoTangent()
+    return ChainRulesCore.NoTangent(),
+    x * differentiate(x * Δdpdx, x),
+    ChainRulesCore.NoTangent()
 end
 function ChainRulesCore.rrule(::typeof(differentiate), p, x)
     dpdx = differentiate(p, x)

src/comparison.jl

@@ -109,35 +109,63 @@ end
 #    end
 #    return true
 #end
-Base.:(==)(p1::AbstractPolynomial, p2::AbstractPolynomial) = compare_terms(p1, p2, iszero, ==)
+function Base.:(==)(p1::AbstractPolynomial, p2::AbstractPolynomial)
+    return compare_terms(p1, p2, iszero, ==)
+end
 
-Base.:(==)(p::RationalPoly, q::RationalPoly) = p.num*q.den == q.num*p.den
+Base.:(==)(p::RationalPoly, q::RationalPoly) = p.num * q.den == q.num * p.den
 # Solve ambiguity with (::PolyType, ::Any)
-Base.:(==)(p::APL, q::RationalPoly) = p*q.den == q.num
+Base.:(==)(p::APL, q::RationalPoly) = p * q.den == q.num
 Base.:(==)(q::RationalPoly, p::APL) = p == q
-Base.:(==)(α, q::RationalPoly) = α*q.den == q.num
+Base.:(==)(α, q::RationalPoly) = α * q.den == q.num
 Base.:(==)(q::RationalPoly, α) = α == q
 
 # α could be a JuMP affine expression
-isapproxzero(α; ztol::Real=0.) = false
-function isapproxzero(α::Number; ztol::Real=Base.rtoldefault(α, α, 0))
-    abs(α) <= ztol
+isapproxzero(α; ztol::Real = 0.0) = false
+function isapproxzero(α::Number; ztol::Real = Base.rtoldefault(α, α, 0))
+    return abs(α) <= ztol
 end
 
 isapproxzero(m::AbstractMonomialLike; kwargs...) = false
-isapproxzero(t::AbstractTermLike; kwargs...) = isapproxzero(coefficient(t); kwargs...)
-isapproxzero(p::APL; kwargs...) = all(term -> isapproxzero(term; kwargs...), terms(p))
+function isapproxzero(t::AbstractTermLike; kwargs...)
+    return isapproxzero(coefficient(t); kwargs...)
+end
+function isapproxzero(p::APL; kwargs...)
+    return all(term -> isapproxzero(term; kwargs...), terms(p))
+end
 isapproxzero(p::RationalPoly; kwargs...) = isapproxzero(p.num; kwargs...)
 
-Base.isapprox(t1::AbstractTerm, t2::AbstractTerm; kwargs...) = isapprox(coefficient(t1), coefficient(t2); kwargs...) && monomial(t1) == monomial(t2)
-function Base.isapprox(p1::AbstractPolynomial{S}, p2::AbstractPolynomial{T};
-                       atol=0, ztol::Real=iszero(atol) ? Base.rtoldefault(S, T, 0) : atol, kwargs...) where {S, T}
-    return compare_terms(p1, p2, t -> isapproxzero(t; ztol=ztol),
-                         (x, y) -> isapprox(x, y; atol=atol, kwargs...))
+function Base.isapprox(t1::AbstractTerm, t2::AbstractTerm; kwargs...)
+    return isapprox(coefficient(t1), coefficient(t2); kwargs...) &&
+           monomial(t1) == monomial(t2)
+end
+function Base.isapprox(
+    p1::AbstractPolynomial{S},
+    p2::AbstractPolynomial{T};
+    atol = 0,
+    ztol::Real = iszero(atol) ? Base.rtoldefault(S, T, 0) : atol,
+    kwargs...,
+) where {S,T}
+    return compare_terms(
+        p1,
+        p2,
+        t -> isapproxzero(t; ztol = ztol),
+        (x, y) -> isapprox(x, y; atol = atol, kwargs...),
+    )
 end
 
-Base.isapprox(p::RationalPoly, q::RationalPoly; kwargs...) = isapprox(p.num*q.den, q.num*p.den; kwargs...)
-Base.isapprox(p::RationalPoly, q::APL; kwargs...) = isapprox(p.num, q*p.den; kwargs...)
-Base.isapprox(p::APL, q::RationalPoly; kwargs...) = isapprox(p*q.den, q.num; kwargs...)
-Base.isapprox(q::RationalPoly{C}, α; kwargs...) where {C} = isapprox(q, constant_term(α, q.den); kwargs...)
-Base.isapprox(α, q::RationalPoly{C}; kwargs...) where {C} = isapprox(constant_term(α, q.den), q; kwargs...)
+function Base.isapprox(p::RationalPoly, q::RationalPoly; kwargs...)
+    return isapprox(p.num * q.den, q.num * p.den; kwargs...)
+end
+function Base.isapprox(p::RationalPoly, q::APL; kwargs...)
+    return isapprox(p.num, q * p.den; kwargs...)
+end
+function Base.isapprox(p::APL, q::RationalPoly; kwargs...)
+    return isapprox(p * q.den, q.num; kwargs...)
+end
+function Base.isapprox(q::RationalPoly{C}, α; kwargs...) where {C}
+    return isapprox(q, constant_term(α, q.den); kwargs...)
+end
+function Base.isapprox(α, q::RationalPoly{C}; kwargs...) where {C}
+    return isapprox(constant_term(α, q.den), q; kwargs...)
+end

src/conversion.jl

@@ -1,18 +1,21 @@
 export variable, convert_to_constant
 
 function convert_constant end
-Base.convert(::Type{P}, α) where P<:APL = convert_constant(P, α)
+Base.convert(::Type{P}, α) where {P<:APL} = convert_constant(P, α)
 function convert_constant(::Type{TT}, α) where {T,TT<:AbstractTerm{T}}
     return term(convert(T, α), constant_monomial(TT))
 end
 function convert_constant(::Type{PT}, α) where {PT<:AbstractPolynomial}
     return convert(PT, convert(term_type(PT), α))
 end
-function Base.convert(::Type{P}, p::APL) where {T, P<:AbstractPolynomial{T}}
-    error("`convert` not implemented for $P")
+function Base.convert(::Type{P}, p::APL) where {T,P<:AbstractPolynomial{T}}
+    return error("`convert` not implemented for $P")
 end
 
-function Base.convert(::Type{V}, mono::AbstractMonomial) where V <: AbstractVariable
+function Base.convert(
+    ::Type{V},
+    mono::AbstractMonomial,
+) where {V<:AbstractVariable}
     variable = nothing
     for v in variables(mono)
         d = degree(mono, v)
@@ -32,27 +35,42 @@ function Base.convert(::Type{V}, mono::AbstractMonomial) where V <: AbstractVari
     return variable
 end
 
-function Base.convert(::Type{M}, t::AbstractTerm) where M <: AbstractMonomialLike
+function Base.convert(
+    ::Type{M},
+    t::AbstractTerm,
+) where {M<:AbstractMonomialLike}
     if isone(coefficient(t))
         return convert(M, monomial(t))
     else
         throw(InexactError(:convert, M, t))
     end
 end
-function Base.convert(TT::Type{<:AbstractTerm{T}}, m::AbstractMonomialLike) where T
+function Base.convert(
+    TT::Type{<:AbstractTerm{T}},
+    m::AbstractMonomialLike,
+) where {T}
     return convert(TT, term(one(T), convert(monomial_type(TT), m)))
 end
-function Base.convert(TT::Type{<:AbstractTerm{T}}, t::AbstractTerm) where T
-    return convert(TT, term(convert(T, coefficient(t)), convert(monomial_type(TT), monomial(t))))
+function Base.convert(TT::Type{<:AbstractTerm{T}}, t::AbstractTerm) where {T}
+    return convert(
+        TT,
+        term(
+            convert(T, coefficient(t)),
+            convert(monomial_type(TT), monomial(t)),
+        ),
+    )
 end
 
 # Base.convert(::Type{T}, t::T) where {T <: AbstractTerm} is ambiguous with above method.
 # we need the following:
-function Base.convert(::Type{TT}, t::TT) where {T, TT <: AbstractTerm{T}}
+function Base.convert(::Type{TT}, t::TT) where {T,TT<:AbstractTerm{T}}
     return t
 end
 
-function Base.convert(::Type{T}, p::AbstractPolynomial) where T <: AbstractTermLike
+function Base.convert(
+    ::Type{T},
+    p::AbstractPolynomial,
+) where {T<:AbstractTermLike}
     if iszero(nterms(p))
         convert(T, zero_term(p))
     elseif isone(nterms(p))
@@ -66,7 +84,7 @@ MA.scaling(p::AbstractPolynomialLike{T}) where {T} = convert(T, p)
 # Conversion polynomial -> constant
 # We don't define a method for `Base.convert` to reduce invalidations;
 # see https://github.com/JuliaAlgebra/MultivariatePolynomials.jl/pull/172
-function convert_to_constant(::Type{S}, p::APL) where S
+function convert_to_constant(::Type{S}, p::APL) where {S}
     s = zero(S)
     for t in terms(p)
         if !isconstant(t)
@@ -77,7 +95,7 @@ function convert_to_constant(::Type{S}, p::APL) where S
     end
     return s
 end
-Base.convert(::Type{T}, p::APL) where T<:Number = convert_to_constant(T, p)
+Base.convert(::Type{T}, p::APL) where {T<:Number} = convert_to_constant(T, p)
 function convert_to_constant(p::APL{S}) where {S}
     return convert_to_constant(S, p)
 end