Most efficient way to implement matrix functions? - arrays

Question

I've been trying for a while to figure out the most efficient way of handling a two dimensional array (i.e. a matrix) that contains a variable.
I construct a large matrix by concatenating smaller arrays, weighted with a variable. As a simplified example, this is what I currently do.
function myMatrix(x::Float64)
M = vcat(hcat(x*A, C), hcat(C, 2*x*B))
return M
end
const A = ones(2,2)
const B = ones(2,2)
const C = zeros(2,2)
y_values = collect(0:0.01:10)
for y in y_values
eivals, eivecs = eig(myMatrix(y))
dosomething(eivals,eivecs)
end
The problem: I have more (and more complex, non-diagonal) matrices and the final size is pretty large. At this moment, I call the function a few hundred times. Does anyone have a suggestion on what to do to make this process more efficient in terms of runtime?
Thanks in advance

Answer 1

EDIT: Based on the comment below, this does not answer the question.
Do you mean constructing the Matrix? One way of doing that which is ideomatic is to use a block Matrix:
M = [x*A C
C 2x*B]
Not sure if that's the most efficient in terms of runtime, sorry.

Answer 2

This solution, using preallocation as proposed somewhere in the comments, does not solve my problem directly (because of the way I construct the matrices) but it may still be useful for some people reading this. Also I don't guarantee for the initially used statement of "most efficient", as this seems to widely depend on your purposes, size of the matrices and so on. The method is also mentioned in the Performance Tips section of Julia.
Because there has been some confusion, consider the following example:
function myMatrix(x::Float64)
M = vcat(hcat(x*A, C), hcat(D, 2*x*B))
return M
end
function doSomething(A::Array{Float64,2})
nothing
end
const ArraySize = 1000
const A = ones(ArraySize,ArraySize)
const B = ones(ArraySize,ArraySize)
const C = rand(ArraySize,ArraySize)
const D = rand(ArraySize,ArraySize)
for i = 1:1000
ret = myMatrix( convert(Float64,i) )
doSomething(ret)
end
This does literally nothing but construct a BlockMatrix(function) from initial matrices depending on one parameter. I was thinking this repeated construction is redundant and indeed, one can preallocate the memory for the matrix by writing:
function xinc!(ret::Array{T,2}, x::T) where T
ret[1:ArraySize, 1:ArraySize] = x*A
ret[1:ArraySize, ArraySize+1:2*ArraySize] = C
ret[ArraySize+1:2*ArraySize, 1:ArraySize] = D
ret[ArraySize+1:2*ArraySize, ArraySize+1:2*ArraySize] = 2*x*B
nothing
end
function doSomething(A::Array{Float64,2})
nothing
end
const ArraySize = 1000
const A = ones(ArraySize,ArraySize)
const B = ones(ArraySize,ArraySize)
const C = rand(ArraySize,ArraySize)
const D = rand(ArraySize,ArraySize)
ret = Array{Float64}(2*ArraySize, 2*ArraySize)
for i = 1:1000
xinc!(ret, convert(Float64,i))
doSomething(ret)
end
For me, the second code executes in 9.866s while the first takes up 38.076s.
Edit: In response to the previous comment, if i write
function xinc!(ret::Array{T,2}, x::T) where T
ret = [x*A C
D 2*x*B]
nothing
end
the code takes 16.173s to execute. I don't know why, but this way of assigning the matrix is substantially slower.