replace [x == nothing] with [isnothing(x)] (#443)

hyrodium · web-flow · commit bdce97f4a498 · 2022-08-13T16:23:36.000-04:00
diff --git a/src/common.jl b/src/common.jl
@@ -146,7 +146,7 @@ function _fit(P::Type{<:AbstractPolynomial},
              var = :x,) where {T}
     x = mapdomain(P, x)
     vand = vander(P, x, deg)
-    if weights !== nothing
+    if !isnothing(weights)
         coeffs = _wlstsq(vand, y, weights)
     else
         coeffs = vand \ y
@@ -462,7 +462,7 @@ _eltype(::Type{<:AbstractPolynomial}) = nothing
 _eltype(::Type{<:AbstractPolynomial{T}}) where {T} = T
 function _eltype(P::Type{<:AbstractPolynomial}, p::AbstractPolynomial)
     T′ = _eltype(P)
-    T = T′ === nothing ? eltype(p) : T′
+    T = isnothing(T′) ? eltype(p) : T′
     T
 end
 Base.iszero(p::AbstractPolynomial) = all(iszero, p)
@@ -706,7 +706,7 @@ Returns an iterator over the terms, `pᵢ⋅basis(p,i)`, of the polynomial for e
 monomials(p) = Monomials(p)
 function Base.iterate(v::Monomials, state...)
     y = iterate(pairs(v.p), state...)
-    y === nothing && return nothing
+    isnothing(y) && return nothing
     kv, s = y
     return (kv[2]*basis(v.p, kv[1]), s)
 end
@@ -723,18 +723,18 @@ _indeterminate(::Type{P}) where {P <: AbstractPolynomial} = nothing
 _indeterminate(::Type{P}) where {T, X, P <: AbstractPolynomial{T,X}} = X
 function indeterminate(::Type{P}) where {P <: AbstractPolynomial}
     X = _indeterminate(P)
-    X === nothing ? :x : X
+    isnothing(X) ? :x : X
 end
 indeterminate(p::P) where {P <: AbstractPolynomial} = _indeterminate(P)
 function indeterminate(PP::Type{P}, p::AbstractPolynomial{T,Y}) where {P <: AbstractPolynomial, T,Y}
     X = _indeterminate(PP)
-    X === nothing && return Y
+    isnothing(X) && return Y
     assert_same_variable(X,Y)
     return X
-    #X = _indeterminate(PP) === nothing ? indeterminate(p) :  _indeterminate(PP)
+    #X = isnothing(_indeterminate(PP)) ? indeterminate(p) :  _indeterminate(PP)
 end
 function indeterminate(PP::Type{P}, x::Symbol) where {P <: AbstractPolynomial}
-    X = _indeterminate(PP) === nothing ? x :  _indeterminate(PP)
+    X = isnothing(_indeterminate(PP)) ? x :  _indeterminate(PP)
 end
 
 #=
@@ -761,7 +761,7 @@ Base.zero(p::P, var=indeterminate(p)) where {P <: AbstractPolynomial} = zero(P,
 Returns a representation of 1 as the given polynomial.
 """
 Base.one(::Type{P}) where {P<:AbstractPolynomial} = throw(ArgumentError("No default method defined")) # no default method
-Base.one(::Type{P}, var::SymbolLike) where {P <: AbstractPolynomial} = one(⟒(P){eltype(P), Symbol(var === nothing ? :x : var)})
+Base.one(::Type{P}, var::SymbolLike) where {P <: AbstractPolynomial} = one(⟒(P){eltype(P), Symbol(isnothing(var) ? :x : var)})
 Base.one(p::P, var=indeterminate(p)) where {P <: AbstractPolynomial} = one(P, var)
 
 Base.oneunit(::Type{P}, args...) where {P <: AbstractPolynomial} = one(P, args...)
diff --git a/src/polynomials/ChebyshevT.jl b/src/polynomials/ChebyshevT.jl
@@ -48,7 +48,7 @@ struct ChebyshevT{T, X} <: AbstractPolynomial{T, X}
         end
 
         N = findlast(!iszero, coeffs)
-        N === nothing && return new{T,X}(zeros(T,1))
+        isnothing(N) && return new{T,X}(zeros(T,1))
         cs = T[coeffs[i] for i ∈ firstindex(coeffs):N]
         new{T,X}(cs)
     end
diff --git a/src/polynomials/ImmutablePolynomial.jl b/src/polynomials/ImmutablePolynomial.jl
@@ -83,15 +83,15 @@ function ImmutablePolynomial{T,X}(coeffs::AbstractVector{S})  where {T,X,S}
         @warn "ignoring the axis offset of the coefficient vector"
     end
     N = findlast(!iszero, coeffs)
-    N == nothing && return ImmutablePolynomial{R,X,0}(())
+    isnothing(N) && return ImmutablePolynomial{R,X,0}(())
     N′ = N + 1 - firstindex(coeffs)
     ImmutablePolynomial{T, X, N′}([coeffs[i] for i ∈ firstindex(coeffs):N])
 end
 
 ## -- Tuple arguments
 function ImmutablePolynomial{T,X}(coeffs::Tuple)  where {T,X}
     N = findlast(!iszero, coeffs)
-    N == nothing && return zero(ImmutablePolynomial{T,X})
+    isnothing(N) && return zero(ImmutablePolynomial{T,X})
     ImmutablePolynomial{T,X,N}(NTuple{N,T}(coeffs[i] for i in 1:N))
 end
 
@@ -124,8 +124,8 @@ for op in [:isequal, :(==)]
         (N == M  && $op(p1s,p2s)) &&  return  true
         n1 = findlast(!iszero, p1s) # now trim out zeros
         n2 = findlast(!iszero, p2s)
-        (n1 == nothing && n2 == nothing) && return true
-        (n1 == nothing || n2  == nothing) && return false
+        (isnothing(n1) && isnothing(n2)) && return true
+        (isnothing(n1) || isnothing(n2)) && return false
         $op(p1s[1:n1],p2s[1:n2]) &&  return true
         false
     end
diff --git a/src/polynomials/LaurentPolynomial.jl b/src/polynomials/LaurentPolynomial.jl
@@ -77,7 +77,7 @@ struct LaurentPolynomial{T, X} <: LaurentBasisPolynomial{T, X}
                                     m::Union{Int, Nothing}=nothing) where {T, X, S}
 
         fnz = findfirst(!iszero, coeffs)
-        fnz == nothing && return  new{T,X}(zeros(T,1), Ref(0), Ref(0))
+        isnothing(fnz) && return new{T,X}(zeros(T,1), Ref(0), Ref(0))
         lnz = findlast(!iszero, coeffs)
         if Base.has_offset_axes(coeffs)
             # if present, use axes
@@ -87,7 +87,7 @@ struct LaurentPolynomial{T, X} <: LaurentBasisPolynomial{T, X}
 
             c = convert(Vector{T}, coeffs[fnz:lnz])
 
-            m′ = fnz - 1 + (m == nothing ? 0 : m)
+            m′ = fnz - 1 + (isnothing(m) ? 0 : m)
             n = m′ + (lnz-fnz)
 
             (n - m′ + 1  == length(c)) || throw(ArgumentError("Lengths do not match"))
diff --git a/src/polynomials/Poly.jl b/src/polynomials/Poly.jl
@@ -30,7 +30,7 @@ struct Poly{T <: Number,X} <: Polynomials.StandardBasisPolynomial{T,X}
         else
         # determine the last nonzero element and truncate a accordingly
             last_nz = findlast(!iszero, a)
-            a_last = max(1, last_nz === nothing ? 0 : last_nz)
+            a_last = max(1, isnothing(last_nz) ? 0 : last_nz)
             new{T,X}(a[1:a_last])
         end
     end
diff --git a/src/polynomials/Polynomial.jl b/src/polynomials/Polynomial.jl
@@ -39,7 +39,7 @@ struct Polynomial{T, X} <: StandardBasisPolynomial{T, X}
             @warn "ignoring the axis offset of the coefficient vector"
         end
         N = findlast(!iszero, coeffs)
-        N == nothing && return new{T,X}(zeros(T,1))
+        isnothing(N) && return new{T,X}(zeros(T,1))
         cs = T[coeffs[i] for i ∈ firstindex(coeffs):N]
         new{T,X}(cs)
     end
diff --git a/src/polynomials/SparsePolynomial.jl b/src/polynomials/SparsePolynomial.jl
@@ -124,13 +124,13 @@ end
 # inherits order for underlying dictionary
 function Base.iterate(v::PolynomialKeys{SparsePolynomial{T,X}}, state...) where {T,X}
     y = iterate(v.p.coeffs, state...)
-    y == nothing && return nothing
+    isnothing(y) && return nothing
     return (y[1][1], y[2])
 end
 
 function Base.iterate(v::PolynomialValues{SparsePolynomial{T,X}}, state...) where {T,X}
     y = iterate(v.p.coeffs, state...)
-    y == nothing && return nothing
+    isnothing(y) && return nothing
     return (y[1][2], y[2])
 end
 
diff --git a/src/polynomials/factored_polynomial.jl b/src/polynomials/factored_polynomial.jl
@@ -92,7 +92,7 @@ end
 Base.convert(::Type{P}, p::P) where {P <: FactoredPolynomial} = p
 function Base.convert(P::Type{<:FactoredPolynomial}, p::FactoredPolynomial{T,X}) where {T,X}
     T′ = _eltype(P)
-    𝑻 = T′ == nothing ? T : T′
+    𝑻 = isnothing(T′) ? T : T′
     𝑿 = indeterminate(P, p)
     d = Dict{𝑻,Int}()
     copy!(d, p.coeffs)
diff --git a/src/polynomials/pi_n_polynomial.jl b/src/polynomials/pi_n_polynomial.jl
@@ -36,7 +36,7 @@ Base.copyto!(p::PnPolynomial{T, X}, x::S) where
 
 function Polynomials.degree(p::PnPolynomial)
     i = findlast(!iszero, p.coeffs)
-    i == nothing && return -1
+    isnothing(i) && return -1
     i - 1
 end
 
diff --git a/src/polynomials/standard-basis.jl b/src/polynomials/standard-basis.jl
@@ -116,7 +116,7 @@ end
     for i in 1 : N
         for j in 1 : M
             k = i + j - 1
-            if exprs[k] === nothing
+            if isnothing(exprs[k])
                 exprs[k] = :(p1[$i] * p2[$j])
             else
                 exprs[k] = :(muladd(p1[$i], p2[$j], $(exprs[k])))
@@ -334,10 +334,10 @@ function _gcd_noda_sasaki(a::Vector{T}, b::Vector{S};
     R = eltype(one(T)/one(S))
 
     na1 = findlast(!iszero,a) # degree(a) + 1
-    na1 === nothing && return(ones(R, 1))
+    isnothing(na1) && return(ones(R, 1))
 
     nb1 = findlast(!iszero,b) # degree(b) + 1
-    nb1 === nothing && return(ones(R, 1))
+    isnothing(nb1) && return(ones(R, 1))
 
     a1 = R[a[i] for i in 1:na1]
     b1 = R[b[i] for i in 1:nb1]
@@ -364,7 +364,7 @@ function _gcd_noda_sasaki(a::Vector{T}, b::Vector{S};
         end
         a1 ./= sc
         na1 = findlast(t -> (abs(t) > tol),a1[1:nb1-1])
-        na1 === nothing && (na1 = 0)
+        isnothing(na1) && (na1 = 0)
         resize!(a1, na1)
     end
 
@@ -472,7 +472,7 @@ function  roots(p::P; kwargs...)  where  {T, P <: StandardBasisPolynomial{T}}
 
     as = [p[i] for i in 0:d]
     K  = findlast(!iszero, as)
-    if K == nothing
+    if isnothing(K)
         return R[]
     end
     k =  findfirst(!iszero, as)
@@ -524,7 +524,7 @@ function fit(P::Type{<:StandardBasisPolynomial},
              weights = nothing,
              var = :x,) where {T}
 
-    if deg == length(x) -1 && weights == nothing
+    if deg == length(x) -1 && isnothing(weights)
         _polynomial_fit(P, x, y; var=var)
     else
         _fit(P, x, y, deg; weights=weights, var=var)
diff --git a/src/rational-functions/common.jl b/src/rational-functions/common.jl
@@ -66,7 +66,7 @@ end
 
 function Base.convert(::Type{PQ}, p::P) where {PQ <: AbstractRationalFunction, P<:AbstractPolynomial}
     T′ = _eltype(_eltype((PQ)))
-    T =  T′ == nothing ? eltype(p) : T′
+    T =  isnothing(T′) ? eltype(p) : T′
     X = indeterminate(PQ, p)
 
     𝐩 = convert(Polynomial{T,X}, p)
@@ -145,7 +145,7 @@ Base.denominator(pq::AbstractRationalFunction) = pq.den
 # Treat a RationalFunction as a tuple (num=p, den=q)
 Base.length(pq::AbstractRationalFunction) = 2
 function Base.iterate(pq::AbstractRationalFunction, state=nothing)
-    state == nothing && return (numerator(pq), 1)
+    isnothing(state) && return (numerator(pq), 1)
     state == 1 && return (denominator(pq), 2)
     nothing
 end
@@ -197,7 +197,7 @@ _indeterminate(::Type{PQ}) where {T,X,PQ<:AbstractRationalFunction{T,X}} = X
 indeterminate(pq::PQ) where {PQ<:AbstractRationalFunction} = indeterminate(PQ)
 function indeterminate(::Type{PQ}, var=:x) where {PQ<:AbstractRationalFunction}
     X′ = _indeterminate(PQ)
-    X = X′ == nothing ? Symbol(var) : X′
+    X = isnothing(X′) ? Symbol(var) : X′
     X
 end
 function indeterminate(PP::Type{P}, p::AbstractPolynomial{T,Y}) where {P <: AbstractRationalFunction, T,Y}
diff --git a/src/rational-functions/fit.jl b/src/rational-functions/fit.jl
@@ -68,10 +68,9 @@ julia> u(variable(pq)) # to see which polynomial is used
 """
 function Polynomials.fit(::Type{PQ}, xs::AbstractVector{S}, ys::AbstractVector{T}, m, n; var=:x) where {T,S, PQ<:RationalFunction}
 
-
     β₁,β₂ = gauss_newton(collect(xs), convert(Vector{float(T)}, ys), m, n)
     P = eltype(PQ)
-    T′ = Polynomials._eltype(P) == nothing ? eltype(β₁) : eltype(P)
+    T′ = isnothing(Polynomials._eltype(P)) ? eltype(β₁) : eltype(P)
     X = indeterminate(PQ, var)
     P′ = constructorof(P){T′,X}
     p = P′(β₁)
diff --git a/src/rational-functions/plot-recipes.jl b/src/rational-functions/plot-recipes.jl
@@ -3,7 +3,7 @@
 ## just sort of succesful
 @recipe function f(pq::AbstractRationalFunction{T}, a=nothing, b=nothing) where {T}
 
-    xlims = get(plotattributes, :xlims, (nothing,nothing))
+    xlims = get(plotattributes, :xlims, (nothing, nothing))
     ylims = get(plotattributes, :ylims, (nothing, nothing))
     rational_function_trim(pq, a, b, xlims, ylims)    
 
@@ -34,10 +34,10 @@ function rational_function_trim(pq, a, b, xlims, ylims)
     cps = isempty(cps) ? cps : real.(filter(isapproxreal, cps))
     cps = isempty(cps) ? cps : filter(!toobig(pq), cps)
 
-    a = a == nothing ? xlims[1] : a
-    b = b == nothing ? xlims[2] : b
+    a = isnothing(a) ? xlims[1] : a
+    b = isnothing(b) ? xlims[2] : b
     
-    if a==nothing && b==nothing
+    if isnothing(a) && isnothing(b)
         u= poly_interval(p)
         v= poly_interval(q)
         a,b = min(first(u), first(v)), max(last(u), last(v))
@@ -58,8 +58,8 @@ function rational_function_trim(pq, a, b, xlims, ylims)
     Mcps = isempty(cps) ? 5 : 3*maximum(abs, pq.(cps))
     M = max(5, Mcps, 1.25*maximum(abs, pq.((a,b))))
 
-    lo = ylims[1] == nothing ? -M : ylims[1]
-    hi = ylims[2] == nothing ?  M : ylims[2]
+    lo = isnothing(ylims[1]) ? -M : ylims[1]
+    hi = isnothing(ylims[2]) ?  M : ylims[2]
     ys′ = [lo <= yᵢ <= hi ? yᵢ : NaN for yᵢ ∈ ys]
     xs, ys′
 
diff --git a/src/rational-functions/rational-transfer-function.jl b/src/rational-functions/rational-transfer-function.jl
@@ -148,7 +148,7 @@ Compute the adjoint `rt(λ)` of the rational transfer function `r(λ)` such that
 function Base.adjoint(pq::PQ) where {PQ <: RationalTransferFunction}
     p,q = pqs(pq)
     Ts = sampling_time(pq)
-    if Ts != nothing && iszero(Ts)
+    if !isnothing(Ts) && iszero(Ts)
         # p(-λ)/q(-λ)
         p′ = poly_scale(p, -1)
         q′ = poly_scale(q, -1)
diff --git a/test/StandardBasis.jl b/test/StandardBasis.jl
@@ -7,7 +7,7 @@ import Polynomials: indeterminate
 function  upto_tz(as, bs)
     n,m = findlast.(!iszero, (as,bs))
     n == m || return false
-    n == nothing &&  return true
+    isnothing(n) &&  return true
     for i in 1:n
         !(as[i] ≈ bs[i]) && return false
     end
@@ -1456,7 +1456,7 @@ end
 
     p = ChebyshevT([1,1,1])
     rec = apply_recipe(Dict{Symbol,Any}(), p)
-    @test match(r"T_0", rec[1].plotattributes[:label]) !== nothing
+    @test !isnothing(match(r"T_0", rec[1].plotattributes[:label]))
     @test rec[1].plotattributes[:xlims] == (-1.0, 1.0) # uses domain(p)
 end
 
