Add 2d tuple to a 2d array in Julia - matrix

Question

How to add a 2d tuple to a 2d matrix in Julia?
t1 = ((10,20),(30,40)); #2d immutable tuple
a = [1 2;3 4] #2d matrix
a .+ t1
throws an error:
MethodError: no method matching +(::Int64, ::Tuple{Int64, Int64})
Closest candidates are:
+(::Any, ::Any, ::Any, ::Any...) at operators.jl:560
+(::T, ::T) where T<:Union{Int128, Int16, Int32, Int64, Int8, UInt128, UInt16, UInt32, UInt64, UInt8} at int.jl:87
+(::Integer, ::Ptr) at pointer.jl:161
...
Stacktrace:
[1] _broadcast_getindex_evalf
# .\broadcast.jl:648 [inlined]
[2] _broadcast_getindex
# .\broadcast.jl:621 [inlined]
[3] getindex
# .\broadcast.jl:575 [inlined]
[4] copy
# .\broadcast.jl:922 [inlined]
[5] materialize(bc::Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{2}, Nothing, typeof(+), Tuple{Matrix{Int64}, Tuple{Tuple{Int64, Int64}, Tuple{Int64, Int64}}}})
# Base.Broadcast .\broadcast.jl:883
[6] top-level scope
# REPL[15]:1
Is there a vector/matrix addition method exists?
Obviously I can use a for loop for element by element addition.

Answer 1

Ah, so the problem here is that, while you call t1 a "2d tuple", it is really not; it is a nested tuple, a tuple-of-tuples, and is thus not really comparable to your 2d array (which really is a two-dimensional object and not just an array-of-arrays).
If you want to add a two-dimensional array to an immutable object that can be stack-allocated like a Tuple while being truly two-dimensional, then you can use the StaticArrays.jl package, which provides the immutable SArray type:
julia> a = [1 2; 3 4]
2×2 Matrix{Int64}:
1 2
3 4
julia> using StaticArrays
julia> t1 = SA[10 20; 30 40]
2×2 SMatrix{2, 2, Int64, 4} with indices SOneTo(2)×SOneTo(2):
10 20
30 40
julia> a + t1
2×2 SMatrix{2, 2, Int64, 4} with indices SOneTo(2)×SOneTo(2):
11 22
33 44
However, if for any reason you really want to stick with nesting instead of multidimensionality, then let's make the array nested as well
julia> t1 = ((10,20),(30,40)) #tuple-of-tuples
((10, 20), (30, 40))
julia> a = [[1,2],[3,4]] #vector-of-vectors
2-element Vector{Vector{Int64}}:
[1, 2]
[3, 4]
in which case you can easily solve by recursion
add(a,b) = a + b
add(a::Vector, b::NTuple{N}) where N = [add(a[i],b[i]) for i in 1:N]
add(a::NTuple{N}, b::Vector) where N = [add(a[i],b[i]) for i in 1:N]
julia> add(a,t1)
2-element Vector{Vector{Int64}}:
[11, 22]
[33, 44]
This approach will also scale to arbitrarily deeply nested objects:
julia> a = [[[1,2],[3,4]],[[5,6],[7,8]]]
2-element Vector{Vector{Vector{Int64}}}:
[[1, 2], [3, 4]]
[[5, 6], [7, 8]]
julia> t1 = (((10,20),(30,40)),((50,60),(70,80)))
(((10, 20), (30, 40)), ((50, 60), (70, 80)))
julia> add(a,t1)
2-element Vector{Vector{Vector{Int64}}}:
[[11, 22], [33, 44]]
[[55, 66], [77, 88]]
Unfortunately, there is widespread semantic confusion between true multidimensional arrays and the common hack of using a vector-of-vectors in languages which do not support real multidimensional arrays.

Answer 2

#cbk has already explained how nested arrays are not equivalent to multidimensional structures. But you can of course write your addition as a nested broadcast if your structure is already nested. Since (I belive) Julia 1.6, there is syntax for standalone "broadcasted operators", with which this is possible:
julia> t1 = ((10,20),(30,40))
((10, 20), (30, 40))
julia> a = [[1,2],[3,4]]
2-element Vector{Vector{Int64}}:
[1, 2]
[3, 4]
julia> broadcast(.+, a, t1)
2-element Vector{Vector{Int64}}:
[11, 22]
[33, 44]
If a is a Matrix, you can do the same on eachrow:
julia> a = [1 2;3 4]
2×2 Matrix{Int64}:
1 2
3 4
julia> broadcast(.+, eachrow(a), t1)
2-element Vector{Vector{Int64}}:
[11, 22]
[33, 44]
(In this specific case, map is equivalent to broadcast.)