isapprox not defined for Tuple arguments

[dbeach24]

Seems like it would make sense to have isapprox be defined for Tuples.

julia> isapprox((1,2),(1,2))
ERROR: MethodError: no method matching isapprox(::Tuple{Int64,Int64}, ::Tuple{Int64,Int64})

This should at least hold for tuples of matching type, although perhaps a more permissive rule would be useful. Candidate implementation:

Base.isapprox{T <: Tuple}(x::T, y::T) = all(isapprox(a,b) for (a,b) in zip(x,y))

[stevengj]

I would just do Base.isapprox(x::Tuple, y::Tuple; kws...) = isapprox(collect(x), collect(y); kws...)

[dbeach24]

Definitely agree about adding kws.

Isn't materializing the tuples to arrays more work than necessary? (Or is there a benefit to handing these to isapprox as arrays?)

[stevengj]

Yes, because as arrays you can look at the norm of the whole thing, e.g. (1,1e-16) ≈ (1,0) will return true, whereas elementwise it would be false.

[stevengj]

Also, I think that treatment of isapprox for tuples should have the same semantics as passing arrays.

[dbeach24]

Would it make sense to define it (more generally) for Collection{T} ?

Base.isapprox(x::Collection{T}, y::Collection{T}; kws...) = isapprox(collect(x), collect(y), kws...)

[stevengj]

@dbeach24, there is no Collection type that all collections inherit from. It might make sense to define it for all iterables as: Base.isapprox(x, y; kws...) = isapprox(collect(x), collect(y), kws...)

[stevengj]

However, I think the behavior for non-numeric collections is a little unclear. (Currently it would just throw a MethodError.) collect is also arguably the wrong thing for unordered collections like Set. For now, I would prefer to just define it for tuples.

[dbeach24]

@stevengj How embarrassing! I really should have known that.

Okay, tuples only then.

[andyferris]

I would just do Base.isapprox(x::Tuple, y::Tuple; kws...) = isapprox(collect(x), collect(y); kws...)

Yes, because as arrays you can look at the norm of the whole thing, e.g. (1,1e-16) ≈ (1,0) will return true, whereas elementwise it would be false.

I'm not sure about treating a Tuple as an Array w.r.t. approximation. A Tuple can be any collection of objects (e.g. the arguments to a function) and it's bad form to assume that their relative magnitude might have any specific meaning. I think for Tuple the only thing you can do is element-wise, e.g. all(map((i,j) -> isapprox(i, j; kws...), x, y))

[stevengj]

@andyferris, fair enough.

[alhirzel]

Would it also make sense to define this for pairs? Something like:

Base.isapprox(a::Pair{T,U}, b::Pair{T,U}) where {T, U} = (first(a) ≈ first(b)) && (last(a) ≈ last(b))

[KristofferC]

Seems easiest to just explicitly collect here since it is a bit unclear what this should do for tuples.