# Order of operations in an expression

Given a floating-point array*x*, which of these two statements:

IDL> y1 =executes faster, the first or the second? Note that both statements produce the same result to within floating-point precision. We can test the execution time of IDL code with the built-in SYSTIME function. Here’s an example program that demonstrates a technique for doing so:2.0* x /3.0IDL> y2 = x * (2.0/3.0)

Note that I chose a smallish array size to avoid memory issues (this is another performance topic) and I looped over the statements many times to attempt to average out any transient effects. Here’s the result from running this program on my laptop (YMMV):protest_orderofoperationscompile_optidl2 n_iter =1e2x =findgen(1e6) t0 =systime(/seconds)fori=1, n_iterdoy1 =2.0* x /3.0t1 =systime(/seconds) - t0systime(/seconds)fori=1, n_iterdoy2 = x * (2.0/3.0) t2 =systime(/seconds) - t0end

`IDL> `**test_orderofoperations**
Execution time for [2.0 * x / 3.0]: 0.77 s
Execution time for [x * (2.0 / 3.0)]: 0.30 s
Ratio : 2.58

Why does the execution time of these statements differ?
In the first statement, there’s a multiplication and a division. Since both are at the same level in the operator hierarchy, IDL works from left to right, calculating *(2.0 * x)*, then dividing the result by the value

*3.0*. The key here is that the expression

*(2.0 * x)*is an array operation, so under the hood, at the C level of IDL, every element of the array

*x*is multiplied by the value

*2.0*. The result is a new array, held temporarily in memory. Every element of this array is then divided by the scalar value

*3.0*. Compare this order of operation with that in the second statement. Here, because of the parentheses, the scalar operation

*(2.0 / 3.0)*is performed first, with another scalar as a result. This scalar is then multiplied, element-by-element, with the array

*x*. So, the difference between these two statements is that the first uses two array operations, whereas the second uses only one. The lesson is then: group scalar operations in an expression. This is a simple performance tweak that will help your IDL code run faster. For more information on code performance, including demonstrations of techniques similar to this, see Mike Galloy's book,

*Modern IDL*. We also experiment with several performance techniques in our Scientific Programming with IDL course.