In reply to @jasonjckn:matrix.org
sent an image.

Is there a best practice in Julia for views?
I find myself putting a @views in front of almost every line to avoid needles allocations.

It feels like there should be a smarter way for a modern language.

In reply to @wehandre:matrix.physik.uni-augsburg.de

Is there a best practice in Julia for views?
I find myself putting a @views in front of almost every line to avoid needles allocations.

It feels like there should be a smarter way for a modern language.

In reply to @neoabs:matrix.org
X = view(array, dims)

try:

A = ones(10,10)
a = view(A,1:10,1)
a *= 2
A[1:10,1:2]

try:

A = ones(10,10)
a = view(A,1:10,1)
a *= 2
A[1:10,1:2]
a = view(A,1:10,1)

try:

A = ones(10,10)
a = view(A,1:10,1)
a *= 2
A[1:10,1:2]
a = view(A,1:10,1)
a[:] = a*2
A[1:10,1:2]

# after above
a[:] *=2 
print(A[:,1:2])

Wonder if it is a bug or feature

Is there a fast way to count over SubArrays?
I had to put @views everywhere to avoid excessive copies, but this slowed count down, becoming my bottleneck (I think due to excessive bound checks).
Consider the following two functions

function test1(x, b, pad)
    _x = @view(x[begin+pad:end-pad])
    return count(>(b), _x)
end

function test2(x, b, pad)
    return sum(x[idx] > b for idx in 1+pad:length(x)-pad)
end

I get the following timings

julia> x = randn(10000);

julia> @btime test1($x, $0.5, $1);
  9.156 μs (0 allocations: 0 bytes)

julia> @btime test2($x, $0.5, $1);
  1.498 μs (0 allocations: 0 bytes)

Avoiding SubArrays gives me a six-fold speedup, but makes my code exceedingly ugly.

Is there a fast way to count over SubArrays?
I had to put @views everywhere to avoid excessive copies, but this slowed count down, becoming my bottleneck (I think due to excessive bound checks).
Consider the following two functions

function test1(x, b, pad)
    _x = @view(x[begin+pad:end-pad])
    return count(>(b), _x)
end

function test2(x, b, pad)
    return sum(x[idx] > b for idx in 1+pad:length(x)-pad)
end

I get the following timings

julia> x = randn(10000);

julia> @btime test1($x, $0.5, $1);
  9.156 μs (0 allocations: 0 bytes)

julia> @btime test2($x, $0.5, $1);
  1.498 μs (0 allocations: 0 bytes)

Avoiding SubArrays gives me a six-fold speedup, but makes my code exceedingly ugly.

The following issue seems to contain some hints:
https://github.com/JuliaLang/julia/issues/43295

The following code doesn't perform as bad as count

function test3(a, b, pad)
       _x = @view(x[begin+pad:end-pad])
       return sum(@inbounds _x[idx] > b for idx in eachindex(_x), 0)
end

but it is still slower and contains some allocations:

julia> @btime test3($x, $0.5, $1);
  2.040 μs (9 allocations: 288 bytes)

The following issue seems to contain some hints:
https://github.com/JuliaLang/julia/issues/43295

The following code doesn't perform as bad as count

function test3(a, b, pad)
       _x = @view(x[begin+pad:end-pad])
       return sum(@inbounds _x[idx] > b for idx in eachindex(_x))
end

but it is still slower and contains some allocations:

julia> @btime test3($x, $0.5, $1);
  2.040 μs (9 allocations: 288 bytes)