Re-posted from: https://bkamins.github.io/julialang/2022/06/24/broadcasting.html
Introduction
Recently I have written a post about @view and @views macros.
In what followed I got a feedback, that the topic I touched there was
indeed useful. Therefore for today I decided to write about another macro.
This time I will share my thoughts on the @. macro.
This post was written under Julia 1.7.2.
Understanding what @. macro does
The @. macro is used to inject broadcasting into every function call
in an expression passed to it.
Let us have a look at its docstring:
Convert every function call or operator in expr into a “dot call”
(e.g. convert f(x) to f.(x)), and convert every
assignment in expr to a “dot assignment” (e.g. convert += to .+=).
If you want to avoid adding dots for selected function calls in expr, splice
those function calls in with $. For example,
@. sqrt(abs($sort(x))) is equivalent to sqrt.(abs.(sort(x))) (no dot for sort).
The @. marco is quite useful when we work with long expressions that
involve several operations that we want to be broadcasted together. Here
is a minimal example:
julia> using Statistics
julia> x = 1:10
1:10
julia> @. sin(x)^2 + cos(x)^2
10-element Vector{Float64}:
1.0
1.0
0.9999999999999999
1.0
0.9999999999999999
0.9999999999999999
0.9999999999999999
1.0
0.9999999999999999
1.0
Writing @. sin(x)^2 + cos(x)^2 is much more convenient than writing
sin.(x).^2 .+ cos.(x).^2.
However, what if we wanted to compute variance of x? A direct approach
would be to write this operation as:
julia> sum((x .- mean(x)) .^ 2) / (length(x) - 1)
9.166666666666666
As you can see I use broadcasting in only two places, while most of the
operations are not broadcasted. If we wanted to use @. macro we would
need to use $ escaping and write something like:
julia> @. $/($sum((x - $mean(x)) ^ 2), $-($length(x), 1))
9.166666666666666
which is equivalent and ugly. You can check it by using @macroexpand:
julia> @macroexpand @. $/($sum((x - $mean(x))^2), $-($length(x), 1))
:(sum((^).((-).(x, mean(x)), 2)) / (length(x) - 1))
In this case also correct (but not equivalent) and simpler way would be:
julia> @. $sum((x - $mean(x))^2) / ($length(x) - 1)
9.166666666666666
However, in this case you need to know and be sure that by not escaping-out the
/ and - function calls in the second part of the expression you will not
affect the correctness of your calculation.
In summary, I do not use @. in complex expressions as it is usually hard to
reason about it.
Let us now switch to some special cases of using @..
Be careful with broadcasted assignment
Other common source of bugs when using @. is broadcasted assignment.
Let us analyze the following code:
julia> x = ["a", "b"]
2-element Vector{String}:
"a"
"b"
julia> x = @. length(x)
2-element Vector{Int64}:
1
1
julia> x
2-element Vector{Int64}:
1
1
julia> y = ["a", "b"]
2-element Vector{String}:
"a"
"b"
julia> @. y = length(y)
ERROR: MethodError: Cannot `convert` an object of type Int64 to an object of type String
In the case of x variable the @. macro is on the right hand side of the
assignment. In this case we get a fresh binding of value to variable x.
In the case of y the @. encompasses the left hand side of the assignment.
In this case the operation is in-place. Therefore in this case we get an error,
because you cannot store integers in a vector of strings.
Things, of course, can be silently wrong, as in the following example of
Vector{Char}, as Char supports conversion from integer:
julia> z = ['a', 'b']
2-element Vector{Char}:
'a': ASCII/Unicode U+0061 (category Ll: Letter, lowercase)
'b': ASCII/Unicode U+0062 (category Ll: Letter, lowercase)
julia> @. z = length(z)
2-element Vector{Char}:
'\x01': ASCII/Unicode U+0001 (category Cc: Other, control)
'\x01': ASCII/Unicode U+0001 (category Cc: Other, control)
julia> z
2-element Vector{Char}:
'\x01': ASCII/Unicode U+0001 (category Cc: Other, control)
'\x01': ASCII/Unicode U+0001 (category Cc: Other, control)
Incorrect handling of named tuples
Consider the following code:
julia> v = 1:3
1:3
julia> [x in (a=1, c=3) for x in v]
3-element Vector{Bool}:
1
0
1
We can rewrite it using broadcasting as:
julia> in.(v, Ref((a=1, c=3)))
3-element BitVector:
1
0
1
Now we think we could use the @. here as follows:
julia> @. in(v, $Ref((a=1, c=3)))
ERROR: UndefVarError: c not defined
However, this fails as @. macro incorrectly handles = inside NamedTuple
definition. We have to write:
julia> @. in(v, $Ref((; a=1, c=3)))
3-element BitVector:
1
0
1
The ; at the beginning of NamedTuple definition gives an equivalent object
but changes how the code expression is transformed by the Julia compiler
and it works. Here is how we can check the difference in the representation
of (a=1, c=3) and (; a=1, c=3):
julia> dump(:(a=1, c=3))
Expr
head: Symbol tuple
args: Array{Any}((2,))
1: Expr
head: Symbol =
args: Array{Any}((2,))
1: Symbol a
2: Int64 1
2: Expr
head: Symbol =
args: Array{Any}((2,))
1: Symbol c
2: Int64 3
julia> dump(:(; a=1, c=3))
Expr
head: Symbol tuple
args: Array{Any}((1,))
1: Expr
head: Symbol parameters
args: Array{Any}((2,))
1: Expr
head: Symbol kw
args: Array{Any}((2,))
1: Symbol a
2: Int64 1
2: Expr
head: Symbol kw
args: Array{Any}((2,))
1: Symbol c
2: Int64 3
Fortunately the case of NamedTuple is not likely to be problematic in practice
as it is extremely rare.
Conclusions
The @. macro can be very convenient. However, in my experience, you
need to be careful when you use it as it is easy to get surprising results
if you work with complex expressions. Out of the possible problematic situations
I have covered in my post a most common one is forgetting to add $ to avoid
broadcasting of some function calls in a complex expression.
I hope that you will find this post useful and it will help you to avoid
bugs in your Julia code using broadcasting!
