Ask versus foreach
323 views
Skip to first unread message
Era V
Mar 5, 2014, 4:35:14 PM3/5/14
to netlog...@googlegroups.com
Hi everyone,
At my work, we've begun a debate on Netlogo and what is better to use. I was wondering if you could settle this debate for us. What is the computational order of magnitude of "ask" versus "foreach" with a list of one item? Foreach should just loop, so I assume that it is O(n). Is "ask" a one step process or does it do some computation to grab the object and return itself?
Another question that has arisen is how to get an unordered list from an agentset. Sort on an agentset does give us this, but it orders it; we want to keep our computation as lightweight as possible, so how do we go about converting an agentset to a list of agents? Value-of seems to not exist anymore, so should we use (list <agentset>) or [self] of agentset, which also seems to work (I'm still intrigues by this, since it should not give us back a list, but it does work with a foreach loop)? Which one is less computationally intensive?
What do you guys suggest?
Thanks!
EV
At my work, we've begun a debate on Netlogo and what is better to use. I was wondering if you could settle this debate for us. What is the computational order of magnitude of "ask" versus "foreach" with a list of one item? Foreach should just loop, so I assume that it is O(n). Is "ask" a one step process or does it do some computation to grab the object and return itself?
Another question that has arisen is how to get an unordered list from an agentset. Sort on an agentset does give us this, but it orders it; we want to keep our computation as lightweight as possible, so how do we go about converting an agentset to a list of agents? Value-of seems to not exist anymore, so should we use (list <agentset>) or [self] of agentset, which also seems to work (I'm still intrigues by this, since it should not give us back a list, but it does work with a foreach loop)? Which one is less computationally intensive?
What do you guys suggest?
Thanks!
EV
Jason Bertsche
Mar 6, 2014, 4:29:02 PM3/6/14
to Era V, netlog...@googlegroups.com
What is the computational order of magnitude of "ask" versus "foreach" with a list of one item? Foreach should just loop, so I assume that it is O(n). Is "ask" a one step process or does it do some computation to grab the object and return itself?
They are both O(n). `ask`, once it is given a turtleset, is
essentially just `foreach` upon that turtleset—aside from the fact
that turtlesets are randomly-orderered and, thus, cause you to
incur a pretty slight performance penalty in order to iterate over
that collection randomly, but with the added benefit of behaving
more so within the NetLogo paradigm.
Getting a handle on the agentset that you're `ask`ing, though, is not necessarily a constant-time operation like retrieving the list over which to `foreach` is. If you do something like `ask turtles with [who mod 2 = 0] [print who]`, the `turtles with [who mod 2 = 0]` is going to be O(n) for figuring out which turtles are included in the desired turtleset and which aren't. Then, `ask`ing the resulting turtleset will also be O(n), but O(n) + O(n) is still O(n).
There's not really a way to get around the performance cost of building an agentset, though. If you turn the agentset into a list (as described below), you still need to compute the agentset, in the first place. If you don't want to keep computing the agentset over and over, you can do `let my-agentset turtles with [who mod 2 = 0]` just as well as you can do `let my-agentlist [self] of turtles with [who mod 2 = 0]`. The former is actually faster, because converting that agentset to a list is, of course, going to take some amount of time—an amount greater than 0. If you want an unordered list of agents, I think you pretty much always want to just keep your agentset.
Getting a handle on the agentset that you're `ask`ing, though, is not necessarily a constant-time operation like retrieving the list over which to `foreach` is. If you do something like `ask turtles with [who mod 2 = 0] [print who]`, the `turtles with [who mod 2 = 0]` is going to be O(n) for figuring out which turtles are included in the desired turtleset and which aren't. Then, `ask`ing the resulting turtleset will also be O(n), but O(n) + O(n) is still O(n).
There's not really a way to get around the performance cost of building an agentset, though. If you turn the agentset into a list (as described below), you still need to compute the agentset, in the first place. If you don't want to keep computing the agentset over and over, you can do `let my-agentset turtles with [who mod 2 = 0]` just as well as you can do `let my-agentlist [self] of turtles with [who mod 2 = 0]`. The former is actually faster, because converting that agentset to a list is, of course, going to take some amount of time—an amount greater than 0. If you want an unordered list of agents, I think you pretty much always want to just keep your agentset.
Another question that has arisen is how to get an unordered list from an agentset.
Well, pedantically speaking, there's no such thing as an unordered
list, but I believe what you're looking for is described here.
so should we use (list <agentset>) or [self] of agentset, which also seems to work (I'm still intrigues by this, since it should not give us back a list, but it does work with a foreach loop)? Which one is less computationally intensive?
`list turtles` doesn't work, as it just returns a one-item list
containing the value of `turtles`. The recommended style for
turning an agentset into a list is is `[self] of turtles`, as
stated in the link above. There might be other ways to get a list
from an agentset, but they're certainly not going to be faster in
any significant way. No matter what you do within NetLogo, it's
going to be O(n) (at best) to convert that set to a list.
Regarding `[self] of turtles` returning a list (rather than an agentset), though, I think it makes a good deal of sense when you think about it. If you want to build a new agentset, you generally use `with`; if you want to get values out of each agent in an agentset, you use `of`. With `of`, there's no guarantee that whatever that reporter block reports is going to evaluate to an agent for each of the agents in the agentset—in fact, it very usually doesn't (e.g. `[who] of turtles`)—so it doesn't make much set for `of` to always return an agentset (since that's impossible), nor does it make sense for it to sometimes return a list and sometimes return an agentset. It should return one type of thing, ideally. Generally speaking, the only thing that we can know it will return is a collection of somethings, and the only structures that NetLogo has for collections of somethings are lists. Thus, `of` should return a list.
Regarding `[self] of turtles` returning a list (rather than an agentset), though, I think it makes a good deal of sense when you think about it. If you want to build a new agentset, you generally use `with`; if you want to get values out of each agent in an agentset, you use `of`. With `of`, there's no guarantee that whatever that reporter block reports is going to evaluate to an agent for each of the agents in the agentset—in fact, it very usually doesn't (e.g. `[who] of turtles`)—so it doesn't make much set for `of` to always return an agentset (since that's impossible), nor does it make sense for it to sometimes return a list and sometimes return an agentset. It should return one type of thing, ideally. Generally speaking, the only thing that we can know it will return is a collection of somethings, and the only structures that NetLogo has for collections of somethings are lists. Thus, `of` should return a list.
Jason Bertsche Senior Software Developer - NetLogo
--
You received this message because you are subscribed to the Google Groups "netlogo-devel" group.
To unsubscribe from this group and stop receiving emails from it, send an email to netlogo-deve...@googlegroups.com.
For more options, visit https://groups.google.com/groups/opt_out.
Reply all
Reply to author
Forward
0 new messages