Thanks Allin.
Following your suggestion for
<hansl>
#case 1
X = zeros(N, 3)
set stopwatch
loop i = 1..N
X[i,1] = sqrt(i)
X[i,2] = sqrt(i)
X[i,3] = sqrt(i)
endloop
t1 = $stopwatch
#case 2
X1 = zeros(N, 1)
X2 = zeros(N, 1)
X3 = zeros(N, 1)
set stopwatch
loop i = 1..N
X1[i] = sqrt(i)
X2[i] = sqrt(i)
X3[i] = sqrt(i)
endloop
t2 = $stopwatch
</hansl>
I got
t1 = 0.642304
t2 = 0.544143
which is a visible 1/10 of a second faster when we do slice down to N X
1 vectors (enthusiasts of sprinting races would be thrilled, at least).
When I first run case 2 and then case 1
I got
t2 = 0.563818
t1 = 0.6347
which is comparable.
But the crucial additional point is that, we have some gains if we go
down to N X 1 matrices i.e. vectors, so that we can skip the column index.
Alecos Papadopoulos PhD
Athens University of Economics and Business
web:
On Fri, 23 Apr 2021, Alecos Papadopoulos wrote:
> Thanks for both good advises, fortunately I have been following them
> all along, namely, declare the matrices before hand, and if slice,
> then slice by column.
>
> However, none replies to my question. So I run an experiment based on
> Jack's example
>
> <hansl>
> #case 1
> X = zeros(N, 3)
> set stopwatch
> loop i = 1..N
> X[i,1] = sqrt(i)
> X[i,2] = sqrt(i)
> X[i,3] = sqrt(i)
> endloop
> t1 = $stopwatch
>
> #case 2
> X1 = zeros(N, 1)
> X2 = zeros(N, 1)
> X3 = zeros(N, 1)
> set stopwatch
> loop i = 1..N
> X1[i,1] = sqrt(i)
> X2[i,1] = sqrt(i)
> X3[i,1] = sqrt(i)
> endloop
> t2 = $stopwatch
> </hansl>
>
> and I got
>
> <output>
> t1 = 0.641354
> t2 = 0.653886
> </output>
>
> So, perhaps contrary to first a priori impressions, it appears that
> slicing down the column dimension, if anything, makes gretl slow down
> a bit.
When timings are as close as in this case, you should try executing
the two variants in both orders. With very intensive computation the
registers will heat up and run faster by the time you get to the
second variant.
Cutting your big matrix into a set of column vectors can simplify the
indexation, but you're (partially) missing out on that by providing a
redundant second index: skip that, and you may find the column-vectors
case runs slightly faster.
I replicated your example with N = 100000; gave just the row index in
the column-vectors case, as in
X1[i] = sqrt(i)
and named the times t_mat (using a single matrix) and t_vec (using
per-column vectors). What I'm seeing is:
t_vec 0.423s
t_mat 0.441s
t_vec 0.420s
There's not much in it, but the set-of-vectors approach seems
marginally faster.
I very much doubt you'd see a speed-up if your "slicing" didn't yield
vectors (that is, if it just reduced an m x n matrix to a set of m x k
matrices with k > 1), since then there would be no reduction in
indexation overhead.
However, it we take the computational task to be literally what's in
your example (which we probably don't want to do!), there's a MUCH
faster way of doing it in whole-matrix mode: precompute a vectorized
solution:
matrix y = sqrt(seq(1,N))'
loop j = 1..3
X[,j] = y
endloop
The timing for that with N = 1000000 is 0.0149 seconds.
Allin
_______________________________________________
Gretl-users mailing list -- gretl-users(a)gretlml.univpm.it
To unsubscribe send an email to gretl-users-leave(a)gretlml.univpm.it
Website:
https://gretlml.univpm.it/postorius/lists/gretl-users.gretlml.univpm.it/