fix ==(::AbstractInterpolation, ::AbstractInterpolation) (#334)

Fixes #333

Author: jw3126

src/Interpolations.jl

@@ -50,6 +50,14 @@ abstract type AbstractInterpolation{T,N,IT<:DimSpec{InterpolationType}} <: Abstr
 abstract type AbstractInterpolationWrapper{T,N,ITPT,IT} <: AbstractInterpolation{T,N,IT} end
 abstract type AbstractExtrapolation{T,N,ITPT,IT} <: AbstractInterpolationWrapper{T,N,ITPT,IT} end
 
+function Base.:(==)(itp1::AbstractInterpolation, itp2::AbstractInterpolation)
+    propertynames(itp1) == propertynames(itp2) || return false
+    for pname in propertynames(itp1)
+        getproperty(itp1, pname) == getproperty(itp2, pname) || return false
+    end
+    return true
+end
+
 """
     BoundaryCondition
 

src/b-splines/b-splines.jl

@@ -43,6 +43,13 @@ struct BSplineInterpolation{T,N,TCoefs<:AbstractArray,IT<:DimSpec{BSpline},Axs<:
     parentaxes::Axs
     it::IT
 end
+
+function Base.:(==)(o1::BSplineInterpolation, o2::BSplineInterpolation)
+    o1.it == o2.it &&
+    o1.parentaxes == o2.parentaxes &&
+    o1.coefs == o2.coefs
+end
+
 function BSplineInterpolation(::Type{TWeights}, A::AbstractArray{Tel,N}, it::IT, axs) where {N,Tel,TWeights<:Real,IT<:DimSpec{BSpline}}
     # String interpolation causes allocation, noinline avoids that unless they get called
     @noinline err_concrete(IT) = error("The b-spline type must be a concrete type (was $IT)")

src/extrapolation/extrapolation.jl

@@ -3,6 +3,11 @@ struct Extrapolation{T,N,ITPT,IT,ET} <: AbstractExtrapolation{T,N,ITPT,IT}
     et::ET
 end
 
+function Base.:(==)(o1::Extrapolation, o2::Extrapolation)
+    o1.et == o2.et &&
+    o1.itp == o2.itp
+end
+
 Base.parent(A::Extrapolation) = A.itp
 itpflag(etp::Extrapolation) = itpflag(etp.itp)
 

src/extrapolation/filled.jl

@@ -3,6 +3,11 @@ mutable struct FilledExtrapolation{T,N,ITP<:AbstractInterpolation,IT,FT} <: Abst
     fillvalue::FT
 end
 
+function Base.:(==)(o1::FilledExtrapolation, o2::FilledExtrapolation)
+    o1.fillvalue == o2.fillvalue &&
+    o1.itp == o2.itp
+end
+
 function FilledExtrapolation(itp::AbstractInterpolation{T,N,IT}, fillvalue) where {T,N,IT}
     Te = promote_type(T,typeof(fillvalue))
     FilledExtrapolation{Te,N,typeof(itp),IT,typeof(fillvalue)}(itp, fillvalue)

src/gridded/gridded.jl

@@ -17,6 +17,13 @@ struct GriddedInterpolation{T,N,TCoefs,IT<:DimSpec{Gridded},K<:Tuple{Vararg{Abst
     coefs::Array{TCoefs,N}
     it::IT
 end
+
+function Base.:(==)(o1::GriddedInterpolation, o2::GriddedInterpolation)
+    o1.it == o2.it &&
+    o1.knots == o2.knots &&
+    o1.coefs == o2.coefs
+end
+
 function GriddedInterpolation(::Type{TWeights}, knots::NTuple{N,GridIndex}, A::AbstractArray{TCoefs,N}, it::IT) where {N,TCoefs,TWeights<:Real,IT<:DimSpec{Gridded},pad}
     isconcretetype(IT) || error("The b-spline type must be a leaf type (was $IT)")
     isconcretetype(TCoefs) || @warn("For performance reasons, consider using an array of a concrete type (eltype(A) == $(eltype(A)))")

src/monotonic/monotonic.jl

@@ -118,6 +118,14 @@ struct MonotonicInterpolation{T, TCoeffs, TEl, TInterpolationType<:MonotonicInte
     d::Vector{TCoeffs} # coefficients of cubic parts of piecewise polynomials
 end
 
+function Base.:(==)(o1::MonotonicInterpolation, o2::MonotonicInterpolation)
+    o1.it == o2.it &&
+    o1.knots == o2.knots &&
+    o1.A == o2.A &&
+    o1.m == o2.m &&
+    o1.c == o2.c &&
+    o1.d == o2.d
+end
 
 size(A::MonotonicInterpolation) = size(A.knots)
 axes(A::MonotonicInterpolation) = axes(A.knots)

src/scaling/scaling.jl

@@ -7,6 +7,11 @@ struct ScaledInterpolation{T,N,ITPT,IT,RT} <: AbstractInterpolationWrapper{T,N,I
     ranges::RT
 end
 
+function Base.:(==)(o1::ScaledInterpolation, o2::ScaledInterpolation)
+    o1.ranges == o2.ranges &&
+    o1.itp == o2.itp
+end
+
 Base.parent(A::ScaledInterpolation) = A.itp
 count_interp_dims(::Type{<:ScaledInterpolation{T,N,ITPT}}, n) where {T,N,ITPT} = count_interp_dims(ITPT, n)
 BoundsCheckStyle(sitp::ScaledInterpolation) = BoundsCheckStyle(sitp.itp)

test/core.jl

@@ -1,5 +1,32 @@
 using Interpolations, Test
 
+@testset "==" begin
+
+    # issue #333
+    knots = ([1,1.2],)
+    vals = [1.0, 2.0]
+    scheme = Gridded(Linear())
+    itp = interpolate(knots, vals , scheme)
+    @test itp == itp
+    @test itp == deepcopy(itp)
+    @test itp != interpolate(([1,1.3],), vals, scheme)
+    @test itp != interpolate(knots, [1.0, 3.0], scheme)
+    @test itp != interpolate(knots, vals, Gridded(Constant()))
+
+    scheme = BSpline(Quadratic(Reflect(OnCell())))
+    vals = [1.0, 2.0]
+    itp = interpolate(vals, scheme)
+    @test itp == itp
+    @test itp == deepcopy(itp)
+    @test itp != interpolate(vals, BSpline(Linear()))
+    @test itp != interpolate(randn(2), scheme)
+
+    vals = rand(Float64, 2,3)
+    itp1 = interpolate(vals, BSpline(Quadratic(Flat(OnGrid()))))
+    itp2 = interpolate(Float64.(vals), BSpline(Quadratic(Flat(OnGrid()))))
+    @test itp1 == itp2
+end
+
 @testset "Core" begin
     A = reshape([0], 1, 1, 1, 1, 1)
     wis = ntuple(d->Interpolations.WeightedAdjIndex(1, (1,)), ndims(A))

test/io.jl

@@ -46,12 +46,14 @@ using Test
         itp = interpolate((range(0.0, stop=0.3, length=4),), A, Gridded(Linear()))
         io = IOBuffer()
         show(io, MIME("text/plain"), itp)
-        str = String(take!(io))
-        @test str == "4-element interpolate((0.0:0.1:0.3,), ::Array{Float64,1}, Gridded(Linear())) with element type Float64:\n 0.25\n 0.5 \n 0.75\n 1.0 "
+        str1 = String(take!(io))
+        str2 = "4-element interpolate((0.0:0.1:0.3,), ::Array{Float64,1}, Gridded(Linear())) with element type Float64:\n 0.25\n 0.5 \n 0.75\n 1.0"
+        @test filter(!isspace, str1) == filter(!isspace, str2)
         io2 = IOBuffer()
         show(io2, itp)
-        str2 = String(take!(io2))
-        @test str2 == "4-element interpolate((0.0:0.1:0.3,), ::Array{Float64,1}, Gridded(Linear())) with element type Float64:\n 0.25\n 0.5 \n 0.75\n 1.0 "
+        str1 = String(take!(io2))
+        str2 = "4-element interpolate((0.0:0.1:0.3,), ::Array{Float64,1}, Gridded(Linear())) with element type Float64:\n 0.25\n 0.5 \n 0.75\n 1.0"
+        @test filter(!isspace, str1) == filter(!isspace, str2)
     end
 
     @testset "scaled" begin