Add VcatAtom

[odow]

x-ref #603

[codecov]

Codecov Report

All modified and coverable lines are covered by tests ✅

Project coverage is 97.84%. Comparing base (0bd470b) to head (159b1be).

Additional details and impacted files

@@           Coverage Diff           @@
##           master     #607   +/-   ##
=======================================
  Coverage   97.84%   97.84%           
=======================================
  Files          87       88    +1     
  Lines        5050     5066   +16     
=======================================
+ Hits         4941     4957   +16     
  Misses        109      109           

☔ View full report in Codecov by Sentry.
📢 Have feedback on the report? Share it here.

[odow]

This part is not nice, but I don't know an alternative.

[ericphanson]

One option is to manually build the operator we want to do:

Convex.jl/src/reformulations/partialtranspose.jl

Line 44 in 0bd470b

return reshape(P * vec(x), size(x)...)

[ericphanson]

actually, I think that permutedims_matrix function already does what we need:

julia> x = [1 3; 2 4]
2×2 Matrix{Int64}:
 1  3
 2  4

julia> y = [5 7; 6 8]
2×2 Matrix{Int64}:
 5  7
 6  8

julia> M = permutedims_matrix((size(x, 1),size(x,2),size(y,1)), (1,3,2))
8×8 SparseMatrixCSC{Bool, Int64} with 8 stored entries:
 1  ⋅  ⋅  ⋅  ⋅  ⋅  ⋅  ⋅
 ⋅  1  ⋅  ⋅  ⋅  ⋅  ⋅  ⋅
 ⋅  ⋅  ⋅  ⋅  1  ⋅  ⋅  ⋅
 ⋅  ⋅  ⋅  ⋅  ⋅  1  ⋅  ⋅
 ⋅  ⋅  1  ⋅  ⋅  ⋅  ⋅  ⋅
 ⋅  ⋅  ⋅  1  ⋅  ⋅  ⋅  ⋅
 ⋅  ⋅  ⋅  ⋅  ⋅  ⋅  1  ⋅
 ⋅  ⋅  ⋅  ⋅  ⋅  ⋅  ⋅  1

julia> reshape(M * vcat(vec(x),vec(y)), size(x,1) + size(y,1), size(x,2))
4×2 Matrix{Int64}:
 1  3
 2  4
 5  7
 6  8

Here I'm using the fact that permutedims_matrix is actually the matrix implementation of X -> vec(permutedims(reshape(X, dims), p)) where here dims = (size(x, 1),size(x,2),size(y,1) which corresponds to concatenating x and y in a new 3rd dimension, then (1,3,2) does the transposing business to swap the last 2 dimensions. We end up with a vector of course, but I reshape it to the intended output dimensions to show we got it right.

To actually operate on the vectorized level in Convex IIIC we'd need to do something like z = operate(vcat, x, y), then generate M and apply it on the vectorized level with operate(*, M, z), I think. We don't need to bother with the final reshaping since the dimensions are stored on the AbstractExpr level not the vectorized level.

[odow]

I've kept as-is for now. It wasn't obvious how to generalize this to the n-ary case, and what we currently have works.

[blegat]

We can try this refactoring in a separate PR