The class of “observation_time” is:
What’s the ruby way? ï¿½Obviously, I can’t use Array.include? but
beware, though, since (d…e).include?(e) is false, but
(d…e).include?(d) is true.

Todd

shouldnt you do this kind of filtering on the ActiveRecord#find call?

First, thank you for the varied and interesting suggestions. I always
learn a lot here!

My motivation is to present an inventory summary for scientific
observations. A sample is attached. From that motivation, I got
thinking about array processing in general and thus my question.

To create this view, I am greedily calling ActiveRecord#find many times
to essentially work with the same (24 * 366) rows. To me one call to
retrieve all of these rows and then pivot and filter them in local
memory makes more sense; it would be especially cool if I could use the
same “find” like calls without regard to whether the rows really came
from an AR connection or an already available resulset. Being used to
scientific analysis programming where we are always dealing with
multidimensional arrays, I wondered, isn’t there a mechanism to operate
on an entire array, filtering on components which are “comparable”?
Consider the following IDL as pseudocode (Matlab would be similar).
This filter which gives data in the time range of “1990-1-1 12:00:00” to
“1990-1-1 12:59:59” would look like:

indices = where( data.observation_time >= julday( 1, 1, 1990, 12, 0,

) and data.observation_time < julday( 1, 1, 1990, 13, 0, 0 ) )

However, it seems from these examples, I must implement this
functionality myself (when it becomes necessary). It seems to me I’ll
need to write a function for each possible expression I might have which
essentially just iterates and performs that expression. Consider a
compound filter like (again in IDL):

This certainly maps very well to an ActiveRecord#find statement. But
what if I already have my resultset available? Or what if I’m not using
a database at all and I simply have an array of objects? For now, in
this database example, I am using ActiveRecord#find, but this situation
had me wondering about Ruby Array filtering in general. I recall way
back when I was in school and programming C++ for engineering analysis.
I wrote a sparse matrix library which overloaded “<” and “&&” to yield
the functionality above. Aren’t usual comparison tokens already
overloaded somewhere to operate on arrays?

Joel’s select/include? implementation is the normal way to solve this
particular problem, but if you’re looking for a more general approach
to dealing with arrays and other ruby data structures, you might look
at Reg, my declarative language for matching ruby data structures.
With Reg, I would use this variation on Joel’s code: