On Jun 24, 12:28 pm, Four of Seventeen wrote:
> user=> (defmacro nanotime [& body] `(let [start (System/nanotime)]
> ~...@body (- (System/nanotime) start)))
> #'user/nanotime
user=> (defmacro nanotime [& body] `(let [start# (System/nanotime)]
~...@body (- (System/nanotime) start#)))
#'user/nanot
On Jun 24, 2:43 am, Christophe Grand wrote:
> On Wed, Jun 24, 2009 at 7:53 AM, Richard Newman wrote:
>
> > > Even with the optimization, sort somehow beats top for speed. It looks
> > > like top is best used to avoid major memory consumption for long seqs;
> > > if you have the memory and need t
On Wed, Jun 24, 2009 at 1:43 AM, Christophe Grand wrote:
> On Wed, Jun 24, 2009 at 7:02 AM, Four of Seventeen
> wrote:
>>
>> (defn top [n comptr coll]
>> (let [m (reduce #(assoc %1 %2 true) (sorted-map-by comptr)
>> (take n coll))]
>> (keys
>> (reduce #(let [t (assoc %1 %2 tru
On Wed, Jun 24, 2009 at 7:53 AM, Richard Newman wrote:
>
> > Even with the optimization, sort somehow beats top for speed. It looks
> > like top is best used to avoid major memory consumption for long seqs;
> > if you have the memory and need the speed, sort's better.
>
> This is an interesting c
> Even with the optimization, sort somehow beats top for speed. It looks
> like top is best used to avoid major memory consumption for long seqs;
> if you have the memory and need the speed, sort's better.
This is an interesting characteristic I've noticed in sorting code. In
the past (I'm thin
On Wed, Jun 24, 2009 at 7:02 AM, Four of Seventeen wrote:
> (defn top [n comptr coll]
> (let [m (reduce #(assoc %1 %2 true) (sorted-map-by comptr)
>(take n coll))]
>(keys
> (reduce #(let [t (assoc %1 %2 true)]
> (dissoc t (first (last t m (drop n coll)
On Jun 23, 10:46 pm, Bradbev wrote:
> A further optimization would be to keep track of the lowest value in
> your "keep" set. A simple compare against that value will eliminate
> many of the add/removes from the keep set.
(defn top [n comptr coll]
(let [m (reduce #(assoc %1 %2 true) (sorted-m
On Jun 23, 4:25 am, Jules wrote:
> Let N be the total number of elements in your collection (e.g.
> 1000,000), and n the number of elements that you want to take out of
> this collection (e.g 10).
>
> By sorting the collection of N elements you spend N log N time. By
> repeatedly adding an to the
A further optimization would be to keep track of the lowest value in
your "keep" set. A simple compare against that value will eliminate
many of the add/removes from the keep set.
Brad
On Jun 23, 1:35 am, Christophe Grand wrote:
> On Tue, Jun 23, 2009 at 10:14 AM, Daniel Lyons wrote:
>
> > I
On Tue, Jun 23, 2009 at 10:14 AM, Daniel Lyons wrote:
> I have to admit I don't really understand your code, so my apologies if
> I've missed something obvious.
>
> I think if you consider each element of N and do an operation that costs
> sqrt(N) with it, you'd arrive at O(N*sqrt(N)), which I thi
Jules,
On Jun 23, 2009, at 2:25 AM, Jules wrote:
> Let N be the total number of elements in your collection (e.g.
> 1,000,000), and n the number of elements that you want to take out of
> this collection (e.g 10).
>
> By sorting the collection of N elements you spend N log N time. By
> repeatedl
On Jun 23, 7:36 am, Christophe Grand wrote:
> Hi all,
>
> On Tue, Jun 23, 2009 at 4:16 AM, Four of Seventeen
> wrote:
>
>
>
> > On Jun 22, 6:46 pm, "beatle...@gmail.com" wrote:
> > > (take 10 (sort (for [x (range 100)] (rand)
>
> > > Now the problem is the memory usage, as it does not
Let N be the total number of elements in your collection (e.g.
1000,000), and n the number of elements that you want to take out of
this collection (e.g 10).
By sorting the collection of N elements you spend N log N time. By
repeatedly adding an to the small collection and removing the minimum
yo
On Jun 23, 4:16 am, Four of Seventeen wrote:
> On Jun 22, 6:46 pm, "beatle...@gmail.com" wrote:
>
> > (take 10 (sort (for [x (range 100)] (rand)
>
> > Now the problem is the memory usage, as it does not merely uses memory
> > space for 10 items, but it keeps a reference to the entire seq
On Jun 23, 2009, at 1:47 AM, Christophe Grand wrote:
> I don't know if it has an official name but basically it's a
> modified tree-sort: for each item you insert a value in a sorted
> coll of size N and remove one item from this sorted coll, both ops
> are O(sqrt(N)) thus O(n*sqrt(N)) for
(assoc % (dec n)) should read: (assoc % min (dec n))
2009/6/23 Christophe Grand
> I don't know if it has an official name but basically it's a modified
> tree-sort: for each item you insert a value in a sorted coll of size N and
> remove one item from this sorted coll, both ops are O(sqrt(N)) th
I don't know if it has an official name but basically it's a modified
tree-sort: for each item you insert a value in a sorted coll of size N and
remove one item from this sorted coll, both ops are O(sqrt(N)) thus
O(n*sqrt(N)) for processing an input whose length is n.
I'm away from a REPL but I ha
On Jun 22, 2009, at 11:36 PM, Christophe Grand wrote:
> Selecting the top N out of n items is a O(n*sqrt(N)) operation so
> it's linear when n dominates N and thus must beat take + sort. Plus
> it won't retain the whole realized seq in memory.
Just because I'm curious, I can see how to do m
Hi all,
On Tue, Jun 23, 2009 at 4:16 AM, Four of Seventeen wrote:
>
> On Jun 22, 6:46 pm, "beatle...@gmail.com" wrote:
> > (take 10 (sort (for [x (range 100)] (rand)
> >
> > Now the problem is the memory usage, as it does not merely uses memory
> > space for 10 items, but it keeps a refe
On Jun 22, 6:46 pm, "beatle...@gmail.com" wrote:
> (take 10 (sort (for [x (range 100)] (rand)
>
> Now the problem is the memory usage, as it does not merely uses memory
> space for 10 items, but it keeps a reference to the entire sequence.
> If I leave out the sort its all ok, and done la
> Does anyone know how to sort and avoid large memory consumptions?
well, presumably the sort needs to look at all the data in order to be
able to sort it, no?! so it is kinda just a tough cookie reality that
the memory will be used.
on the other hand, maybe you can do some form of the Schwartzi
Dear all,
I really love programming in Clojure, and have done so for the past
couple of months, building my company's software recommendation engine
in Clojure (not in production yet), which I originally wrote in Ruby.
However I have run into the following a memory problem, which actually
was poi
22 matches
Mail list logo
