More findings: The reason that the Clojure's original sort is  8 times
slower than sorted-vec2 is only because  Clojure uses its own
comparator by default, instead of using Java's default comparator.
Otherwise it's same performance.

;Modified clojure.core.clj sort
(defn sort2
  "Returns a sorted sequence of the items in coll. If no comparator is
  supplied, uses compare. comparator must
  implement java.util.Comparator."
  ([coll]
   (if (seq coll)
     (let [a (to-array coll)]
       (java.util.Arrays/sort a)
       (seq a))
     ()))
  ([#^java.util.Comparator comp coll]
   (if (seq coll)
     (let [a (to-array coll)]
       (. java.util.Arrays (sort a comp))
       (seq a))
     ())))

;Modified sort
user=> (time (dotimes[_ 1000](sort2 v)))
"Elapsed time: 3510.047755 msecs"

;Original sort
user=> (time (dotimes[_ 1000](sort v)))
"Elapsed time: 23872.07338 msecs"

;Sorted vec. Returns vector, not sequence
user=> (time (dotimes[_ 1000](sorted-vec2 v)))
"Elapsed time: 3534.578648 msecs"

On Jan 3, 1:54 pm, Gabi <bugspy...@gmail.com> wrote:
> I investigated a little bit more. Seems that (into-array) is slows
> things down because it seqs (un-necessarily?) that vector before
> passing to clojure.lang.RT/seqToTypedArray.
>
> I almost doubled the speed of sorted-vec by using clojure.lang.RT/
> toArray:
>
> (defn sorted-vec2
>   [coll]
>   (let [arr (clojure.lang.RT/toArray coll)]
>     (java.util.Arrays/sort arr)
>     (vec arr)))
>
> user=>  (time(dotimes [_ 1000] (sorted-vec2 v)))
> "Elapsed time: 3502.369933 msecs"
>
> user=>  (time(dotimes [_ 1000] (sorted-vec v)))
> "Elapsed time: 5874.088425 msecs"
>
> On Jan 3, 10:29 am, Gabi <bugspy...@gmail.com> wrote:
>
> > The sorted-vec is ~4 times faster than Clojure's sort (on my humble
> > old machine):
>
> > user=> (def v (vec (take 10000 (repeatedly #(rand-int 100000)))))
> > #'user/v
> > user=> (time(dotimes [_ 1000] (sort v)))
> > "Elapsed time: 23945.682336 msecs"
> > nil
> > user=> (time(dotimes [_ 1000] (sorted-vec v)))
> > "Elapsed time: 6030.585433 msecs"
>
> > BTW we have state here (the native Java array). Is it thread safe ?
>
> > On Jan 2, 11:04 pm, Meikel Brandmeyer <m...@kotka.de> wrote:
>
> > > Hi,
>
> > > Am 02.01.2010 um 20:17 schrieb ianp:
>
> > > >> A bit uglier, but ought to be quite fast.
>
> > > > Doesn't need to be that ugly, this looks OK to me at least:
>
> > > > (defn sorted-vec [coll]
> > > >  (doto (into-array coll)
> > > >    (java.util.Arrays/sort)
> > > >    (vec)))
>
> > > > It'd also be possible to generalise the return type by passing in a fn
> > > > to apply to the sorted array.
>
> > > Unfortunately the above code does not work, because it returns the array 
> > > and not the vector.
>
> > > (defn sorted-vec
> > >   [coll]
> > >   (let [arr (into-array coll)]
> > >     (java.util.Array/sort arr)
> > >     (vec arr)))
>
> > > How fast is vec on an array? Isn't there a LazilyPersistentVector which 
> > > just wraps the array?
>
> > > Sincerely
> > > Meikel

-- 
You received this message because you are subscribed to the Google
Groups "Clojure" group.
To post to this group, send email to clojure@googlegroups.com
Note that posts from new members are moderated - please be patient with your 
first post.
To unsubscribe from this group, send email to
clojure+unsubscr...@googlegroups.com
For more options, visit this group at
http://groups.google.com/group/clojure?hl=en

Reply via email to