AppleScript repeats; Why is there such a difference in time to run? - applescript

Question

I'm trying to understand why the following AppleScript handlers complete in such different amounts of time. I have started (!) reading a little about Big O and complexity, but am struggling to apply my thus far limited understanding to these cases:
Handler 1:
on ranger1(n)
set outList to {}
repeat with i from 1 to n
set end of outList to i
end repeat
return outList
end ranger1
Handler 2:
on ranger2(n)
set outList to {}
set i to 1
repeat n times
set end of outList to i
set i to i+1
end repeat
return outList
end ranger2
I've tried these handlers out with values for n of up to 1 000 000. (If anyone reading plans on trying these out, stick to values <= 100 000!)
Timing a call of ranger1(100000):
set timeStart to (time of (current date))
ranger1(100000)
log (time of (current date)) - timeStart
is giving me a time of between 8-10 secs to complete.
However, timing a call of ranger2(100000) results in about 240 secs to complete.
I'm assuming that in ranger2() it is the statement set i to i+1 that is increasing the "complexity" of the handler. I might be wrong, I might be right; I honestly don't know.
So, I guess my question is (!) - Am i wrong?
I will be extremely appreciative of any explanation that can help me understand the real difference between these handlers. Particularly one that can help me move towards applying concepts of "complexity" to such simple functions.
Cheers :)

Answer 1

Big O tells you how the run time will develop, as the size of the data increases.
So it is really nothing practical in it, except that, a rules of thumb.
Your findings suggests that it is a little bit faster to use the repeat with i from 1 to n loop, since the counter is then increased behind the scenes. If you try to measure stuff theoretically, then the i+1 of course also counts as an extra statement. :)

Answer 2

For comparison, here's the equivalent in Python (which took me a week to get into coming from AppleScript, and I'm a slow learner):
#!/usr/bin/python
from time import time
def ranger3(n):
outlist = []
i = 1
for _ in range(n):
outlist.append(i)
i += 1
return outlist
def ranger4(n):
outlist = []
for i in range(1, n+1):
outlist.append(i)
return outlist
n = 10000000 # 10 million
t = time()
ranger3(n)
print(time()-t) # 2.2633600235
t = time()
ranger4(n)
print(time()-t) # 1.52647018433
Needless to say, both are O(n) as you'd expect, in addition to being one or two magnitudes faster than AS - and Python is considered slow compared to most mainstream languages. Just to show how pointless it is obssessing over "performance-optimizing" AppleScript, when every other language leaves it in the dust straight out of the box.

Answer 3

I ran the following timer loops on the AS ranger code supplied above:
set minIter to 0
set maxIter to 200000
set incIter to 50000
repeat with iters from minIter to maxIter by incIter
set timeStart to (time of (current date))
ranger1(iters)
log (" ranger1(" & iters & ") took seconds:" & (time of (current date)) - timeStart) & " seconds "
end repeat
repeat with iters from minIter to maxIter by incIter
set timeStart to (time of (current date))
ranger2(iters)
log (" ranger2(" & iters & ") took seconds:" & (time of (current date)) - timeStart) & " seconds "
end repeat
with these results:
(* ranger1(0) took seconds:0 seconds *)
(* ranger1(50000) took seconds:1 seconds *)
(* ranger1(100000) took seconds:3 seconds *)
(* ranger1(150000) took seconds:8 seconds *)
(* ranger1(200000) took seconds:13 seconds *)
(* ranger2(0) took seconds:0 seconds *)
(* ranger2(50000) took seconds:74 seconds *)
(* ranger2(100000) took seconds:262 seconds *)
(* ranger2(150000) took seconds:471 seconds *)
(* ranger2(200000) took seconds:734 seconds *)
Certainly ranger1 is (relatively) faster, but definitely not linear, and ranger2 is downright glacial.