piracy in `Base.minimum`, `Base.maximum`, `Base.extrema`

[adienes]

in these methods

GMT.jl/src/utils.jl

Lines 354 to 369 in 91d3891

	Base.minimum(A::Array{<:Complex{<:Integer}}) = minimum(real(A)), minimum(imag(A))
	Base.maximum(A::Array{<:Complex{<:Integer}}) = maximum(real(A)), maximum(imag(A))
	Base.minimum(A::Array{<:Complex{<:AbstractFloat}}) = minimum(real(A)), minimum(imag(A))
	Base.maximum(A::Array{<:Complex{<:AbstractFloat}}) = maximum(real(A)), maximum(imag(A))
	function Base.extrema(A::Array{<:Complex{<:Integer}}) # Returns real_min, real_max, imag_min, imag_max
	mi_r, mi_i = minimum(A), maximum(A)
	return mi_r[1], mi_i[1], mi_r[2], mi_i[2]
	end
	function Base.extrema(A::Array{<:Complex{<:Real}})
	mi_r, mi_i = minimum_nan(A), maximum_nan(A)
	return mi_r[1], mi_i[1], mi_r[2], mi_i[2]
	end
	# --------------------------------------------------------------------------------------------------
	"""
	doy2date(doy[, year]) -> Date

[vchuravy]

A likely fix would be to just call these GMT.minimum instead of overloading the Base.minimum functions.

minimum(x) = Base.minimum(x)
minimum(A::Array{<:Complex{<:Integer}}) = minimum(real(A)), minimum(imag(A)) 

That kind of thing is fine, since you own the new name.

What is not fine is:

julia> minimum([1+2im, 2+1im])
ERROR: MethodError: no method matching isless(::Complex{Int64}, ::Complex{Int64})
The function `isless` exists, but no method is defined for this combination of argument types.

Closest candidates are:
  isless(::Missing, ::Any)
   @ Base missing.jl:87
  isless(::Any, ::Missing)
   @ Base missing.jl:88
  isless(::Base.Filesystem.DirEntry, ::Base.Filesystem.DirEntry)
   @ Base file.jl:951
  ...

Stacktrace:
 [1] min(x::Complex{Int64}, y::Complex{Int64})
   @ Base ./operators.jl:499
 [2] _mapreduce
   @ ./reduce.jl:437 [inlined]
 [3] _mapreduce_dim
   @ ./reducedim.jl:337 [inlined]
 [4] mapreduce
   @ ./reducedim.jl:329 [inlined]
 [5] _minimum
   @ ./reducedim.jl:987 [inlined]
 [6] _minimum
   @ ./reducedim.jl:986 [inlined]
 [7] minimum(a::Vector{Complex{Int64}})
   @ Base ./reducedim.jl:982
 [8] top-level scope
   @ REPL[3]:1

julia> using GMT

julia> minimum([1+2im, 2+1im])
(1, 1)

Which doesn't even follow the convention of minimum(x) isa eltype(x)

[joa-quim]

OK, will need to revise carefully this ofc but I remember that I added this ~2 years ago when dealing with (satellite) Sentinel 1 Radar images. Must recreate the situation to see if a fix won't break what's in right now.

[joa-quim]

Is this what you meant?
Because now is JETLS that is accusing me of doing type piracy.

[adienes]

make sure you have not done import Base: minimum, maximum otherwise the function will still be Base.minimum rather than GMT.minimum

[joa-quim]

What is not fine is:

julia> minimum([1+2im, 2+1im])
ERROR: MethodError: no method matching isless(::Complex{Int64}, ::Complex{Int64})
The function isless exists, but no method is defined for this combination of argument types.

A little side note, but I think this is really the crux of the situation. Julia shouldn't error on this. For comparison, Matlab's answer is

>> min([1+2i 2+3i])

ans =

   1.0000 + 2.0000i

[adienes]

complex numbers cannot be ordered though. all that means is that matlab chose to give up the correspondence between min and < , which is not a choice Julia is willing to make

[joa-quim]

Very arguably that it's better to error than to give an answer to the question "what is the minimum of this set of complex numbers" when that is needed for some use, but this is certainly not the place to discuss it.

I worked around the situation by defining new functions https://github.com/GenericMappingTools/GMT.jl/blob/master/src/utils.jl#L355-L366 so the type piracy issue should be solved. Thanks a lot for having looked into this and the advice provided.

[adienes]

hopefully it helps with the invalidations / load time as well!

[joa-quim]

Unfortunately no, this was completely unrelated.

[araujoms]

Sorry for creeping around in your repository, but MATLAB did not break the link between min and <, it defined < for complex numbers. Which, IMHO, is what Julia should do, it's much more useful to use the lexicographical ordering than throw an error.