Order of operations in an expression

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

IDL> y1 = 2.0 * x / 3.0
IDL> y2 = x * (2.0 / 3.0)

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:

pro test_orderofoperations
   compile_opt idl2

   n_iter = 1e2
   x = findgen(1e6)

   t0 = systime(/seconds)
   for i=1, n_iter do y1 = 2.0 * x / 3.0
   t1 = systime(/seconds) - t0
   print, t1, format='("Execution time for [2.0 * x / 3.0]:   ",f5.2," s")'

   t0 = systime(/seconds)
   for i=1, n_iter do y2 = x * (2.0 / 3.0)
   t2 = systime(/seconds) - t0
   print, t2, format='("Execution time for [x * (2.0 / 3.0)]: ",f5.2," s")'

   print, t1/t2, format='("Ratio : ",f5.2)'
end 

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):

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.