New ambiguity on Julia 1.3

[KristofferC]

While running the package tests for the upcoming 1.3, a new ambiguity in "HybridSystems.jl" was detected but it seems to originate from this package:

Cholesky and LDL: Error During Test at /root/.julia/packages/LinearOperators/M4IRn/test/test_linop.jl:369
  Got exception outside of a @test
  MethodError: hvcat(::Tuple{Int64,Int64}, ::Array{Float64,2}, ::Adjoint{Float64,Array{Float64,2}}, ::Array{Float64,2}, ::Array{Float64,2}) is ambiguous. Candidates:
    hvcat(rows::Tuple{Vararg{Int64,N} where N}, xs::Union{AbstractArray{T,1}, AbstractArray{T,2}}...) where T in Base at abstractarray.jl:1634
    hvcat(rows::Tuple{Vararg{Int64,N} where N}, ops::Union{AbstractArray{T,2} where T, AbstractLinearOperator}...) in LinearOperators at /root/.julia/packages/LinearOperators/M4IRn/src/LinearOperators.jl:697
    hvcat(rows::Tuple{Vararg{Int64,N} where N}, xs::Union{AbstractArray{T,1}, AbstractArray{T,2}} where T...) in Base at abstractarray.jl:1633
  Possible fix, define
    hvcat(::Tuple{Vararg{Int64,N} where N}, ::Vararg{Union{AbstractArray{T,1}, AbstractArray{T,2}},N} where N)

We believe this is a real ambiguity that got detected due to improvements in the Julia type system and thus needs to be fixed in this package.

[abelsiqueira]

This also happens with hcat:

[rand(3,3) rand(2,3)']

The problem seems to be that hcat(Matrix, Adjoint{Matrix}) considers our hcat(OperatorOrMatrix...) a possibility.

A simple solution would be to forbid cating operators and matrices and operators in large quantities:

A = rand(3,3)
opA = LinearOperator(A)
[A opA] # ok
[opA A] # ok
[opA opA opA] # ok
[opA A A] # not ok

[dpo]

Instead of

function hcat(ops :: OperatorOrMatrix...)
  op = ops[1]
  for i = 2:length(ops)
    op = [op ops[i]]
  end
  return op
end

we might be able to simply say

function hcat(ops...)
  op = ops[1]
  for i = 2:length(ops)
    op = [op ops[i]]  # <--- types will be checked here
  end
  return op
end

[andreasvarga]

The same errors occur already in Julia 1.1 in the commands below involving hcat, vcat and hvcat:

[I rand(2,3)']
ERROR: MethodError: hcat(::Array{Bool,2}, ::Adjoint{Float64,Array{Float64,2}}) is ambiguous. Candidates:
hcat(ops::Union{AbstractArray{T,2} where T, AbstractLinearOperator}...) in LinearOperators at C:\Users\Andreas.julia\packages\LinearOperators\M4IRn\src\LinearOperators.jl:659
hcat(A::Union{AbstractArray{T,2}, AbstractArray{T,1}} where T...) in Base at abstractarray.jl:1259
Possible fix, define
hcat(::Vararg{AbstractArray{T,2} where T,N} where N)
Stacktrace:
[1] hcat(::UniformScaling{Bool}, ::Adjoint{Float64,Array{Float64,2}}) at C:\cygwin\home\Administrator\buildbot\worker\package_win64\build\usr\share\julia\stdlib\v1.1\LinearAlgebra\src\uniformscaling.jl:270
[2] top-level scope at none:0

[I; rand(2,3)']
ERROR: MethodError: vcat(::Array{Bool,2}, ::Adjoint{Float64,Array{Float64,2}}) is ambiguous. Candidates:
vcat(ops::Union{AbstractArray{T,2} where T, AbstractLinearOperator}...) in LinearOperators at C:\Users\Andreas.julia\packages\LinearOperators\M4IRn\src\LinearOperators.jl:688
vcat(A::Union{AbstractArray{T,2}, AbstractArray{T,1}} where T...) in Base at abstractarray.jl:1296
Possible fix, define
vcat(::Vararg{AbstractArray{T,2} where T,N} where N)
Stacktrace:
[1] vcat(::UniformScaling{Bool}, ::Adjoint{Float64,Array{Float64,2}}) at C:\cygwin\home\Administrator\buildbot\worker\package_win64\build\usr\share\julia\stdlib\v1.1\LinearAlgebra\src\uniformscaling.jl:270
[2] top-level scope at none:0

[I rand(2,3)'; rand(1,5)]
ERROR: MethodError: hvcat(::Tuple{Int64,Int64}, ::Array{Bool,2}, ::Adjoint{Float64,Array{Float64,2}}, ::Array{Float64,2}) is ambiguous. Candidates:
hvcat(rows::Tuple{Vararg{Int64,N} where N}, ops::Union{AbstractArray{T,2} where T, AbstractLinearOperator}...) in LinearOperators at C:\Users\Andreas.julia\packages\LinearOperators\M4IRn\src\LinearOperators.jl:697
hvcat(rows::Tuple{Vararg{Int64,N} where N}, xs::Union{AbstractArray{T,2}, AbstractArray{T,1}} where T...) in Base at abstractarray.jl:1579
Possible fix, define
hvcat(::Tuple{Vararg{Int64,N} where N}, ::Vararg{AbstractArray{T,2} where T,N} where N)
Stacktrace:
[1] hvcat(::Tuple{Int64,Int64}, ::UniformScaling{Bool}, ::Vararg{Union{UniformScaling, Union{AbstractArray{T,2}, AbstractArray{T,1}} where T},N} where N) at C:\cygwin\home\Administrator\buildbot\worker\package_win64\build\usr\share\julia\stdlib\v1.1\LinearAlgebra\src\uniformscaling.jl:328
[2] top-level scope at none:0

[dpo]

It's interesting that [I rand(3,3)'] is ambiguous while [I rand(3,3)] is not...

[dpo]

The change

diff --git a/src/LinearOperators.jl b/src/LinearOperators.jl
index 57b4978..cdf7f5f 100644
--- a/src/LinearOperators.jl
+++ b/src/LinearOperators.jl
@@ -655,7 +655,7 @@ function hcat(A :: AbstractLinearOperator, B :: AbstractLinearOperator)
   LinearOperator{S,F1,F2,F3}(nrow, ncol, false, false, prod, tprod, ctprod)
 end

-function hcat(ops :: OperatorOrMatrix...)
+function hcat(ops :: AbstractLinearOperator...)
   op = ops[1]
   for i = 2:length(ops)
     op = [op ops[i]]

and a similar change for vcat do it for the examples above, but strangely,

julia> [Matrix(1.0I, 2, 2) opZeros(2,3) ; opZeros(3,2) opEye(3)]
ERROR: DimensionMismatch("mismatch in dimension 1 (expected 2 got 1)")
Stacktrace:
 [1] cat_shape(::Tuple{Bool,Bool}, ::Tuple{}, ::Tuple{Int64,Int64}, ::Tuple{Int64}) at ./abstractarray.jl:1421
 [2] _cat_t(::Val{2}, ::Type, ::Array{Float64,2}, ::Vararg{Any,N} where N) at ./abstractarray.jl:1441
 [3] #cat_t#103(::Val{2}, ::typeof(Base.cat_t), ::Type{Any}, ::Array{Float64,2}, ::Vararg{Any,N} where N) at ./abstractarray.jl:1438
 [4] (::Base.var"#kw##cat_t")(::NamedTuple{(:dims,),Tuple{Val{2}}}, ::typeof(Base.cat_t), ::Type{Any}, ::Array{Float64,2}, ::Vararg{Any,N} where N) at ./none:0
 [5] typed_hcat(::Type, ::Array{Float64,2}, ::LinearOperator{Float64,LinearOperators.var"##76#78"{DataType,Int64},LinearOperators.var"##77#79"{DataType,Int64},LinearOpe
rators.var"##77#79"{DataType,Int64}}) at ./abstractarray.jl:1548
 [6] typed_hvcat(::Type{Any}, ::Tuple{Int64,Int64}, ::Array{Float64,2}, ::Vararg{Any,N} where N) at ./abstractarray.jl:1738
 [7] hvcat(::Tuple{Int64,Int64}, ::Array{Float64,2}, ::Vararg{Any,N} where N) at ./abstractarray.jl:1716
 [8] top-level scope at REPL[4]:1

although the dimensions are cat-able.

This works though:

julia> K1 = [Matrix(1.0I, 2, 2) opZeros(2,3)];

julia> K2 = [opZeros(3,2) opEye(3)];

julia> [K1 ; K2]
Linear operator
  nrow: 5
  ncol: 5
  eltype: Float64
  symmetric: false
  hermitian: false

[dpo]

Also if I simply remove hcat(ops...) and vcat(ops...) to try and fall back on the default implementation, I get

julia> [opEye(3) Matrix(1.0I, 3, 3) rand(3,3)']
ERROR: DimensionMismatch("mismatch in dimension 1 (expected 1 got 3)")
Stacktrace:
 [1] _cs at ./abstractarray.jl:1421 [inlined]
 [2] _cshp at ./abstractarray.jl:1417 [inlined]
 [3] cat_shape(::Tuple{Bool,Bool}, ::Tuple{Int64,Int64}, ::Tuple{Int64,Int64}, ::Tuple{Int64,Int64}) at ./abstractarray.jl:1396 (repeats 2 times)
 [4] _cat_t(::Val{2}, ::Type, ::LinearOperator{Float64,LinearOperators.var"##62#63",LinearOperators.var"##62#63",LinearOperators.var"##62#63"}, ::Vararg{Any,N} where N) at ./abstractarray.jl:1441
 [5] #cat_t#103(::Val{2}, ::typeof(Base.cat_t), ::Type{Any}, ::LinearOperator{Float64,LinearOperators.var"##62#63",LinearOperators.var"##62#63",LinearOperators.var"##62#63"}, ::Vararg{Any,N} where N) at ./abstractarray.jl:1438
 [6] (::Base.var"#kw##cat_t")(::NamedTuple{(:dims,),Tuple{Val{2}}}, ::typeof(Base.cat_t), ::Type{Any}, ::LinearOperator{Float64,LinearOperators.var"##62#63",LinearOperators.var"##62#63",LinearOperators.var"##62#63"}, ::Vararg{Any,N} where N) at ./none:0
 [7] _cat at ./abstractarray.jl:1436 [inlined]
 [8] #cat#104 at ./abstractarray.jl:1565 [inlined]
 [9] #cat at ./none:0 [inlined]
 [10] hcat(::LinearOperator{Float64,LinearOperators.var"##62#63",LinearOperators.var"##62#63",LinearOperators.var"##62#63"}, ::Array{Float64,2}, ::Adjoint{Float64,Array
{Float64,2}}) at ./abstractarray.jl:1545
 [11] top-level scope at REPL[18]:1

which doesn't make sense?!?! The Base code is so contrived I'm having a hard time following it. @KristofferC Any ideas why such an error would come up?

[KristofferC]

Sorry, I'm not very familiar with that particular code in question.

[andreasvarga]

I can also confirm that the "nightly" version (I assume Julia 1.3) produces errors of the type

MethodError: hvcat(::Tuple{Int64,Int64}, ::LinearAlgebra.Adjoint{Float64,Array{Float64,2}}, ::Array{Float64,2}, ::Array{Float64,2}, ::Array{Float64,2}) is ambiguous. Candidates:

when adjoints are involved. There are no such errors with Julia 1.2.