THANKS! That clears up my query very nicely!
Don
On 05/03/2014 5:44 PM, Roger Hui wrote:
It's necessary to have the g because I asked for both the sort (s) and the
grade, which would be the g.
The problem arose in an application where the sort and the grade are used
for something else.
On Wed, Mar 5, 2014 at 4:32 PM, Don Kelly <d...@shaw.ca> wrote:
Why is it necessary to have 'g'
repeating the process on my machine which is obviously slower gives an
insignifcant time difference.
20 timer 's=:/:~x [ /:x'
0.172937
20 timer 's=:/:~x [ g=:/:x'
0.173672
Is it because storage is necessary and it is just as fast to store to a
named location rather than to some temporary storage?
Space differences seem small.
Don Kelly
On 05/03/2014 12:11 PM, Joe Bogner wrote:
Yes, the grade is done regardless. Here's my reasoning: In the
incumbent version, s is taken from the grade with from { which is
slower than just resorting.
It seems like the difference between sorting and selecting by indexes.
I am surprised if that's the answer though because selecting by index
should be fast since it's a contiguous array.
jtifrom looks more complicated than jtsortc but I haven't been able to
figure out how jtsortc works.
On Wed, Mar 5, 2014 at 2:50 PM, Roger Hui <rogerhui.can...@gmail.com>
wrote:
x=: a.{~ 1e7 ?@$ 256
timer=: 6!:2
10 timer 's=:x{~g=:/:x'
0.136961
10 timer 's=:/:~x [ g=:/:x'
0.0765459
10 timer '/:~x'
0.012887
10 timer 'x{~g'
0.065751
10 timer '/:x'
0.0606987
On Wed, Mar 5, 2014 at 11:45 AM, Roger Hui <rogerhui.can...@gmail.com>
wrote:
That's my alternative faster expression as well. But the more
interesting
question is, why is it faster? Since we do the grade in both cases, the
comparison is between /:~x and g{x (or x{~g) with g pre-computed. The
answer does not depend knowledge specific to J.
On Wed, Mar 5, 2014 at 11:38 AM, Joe Bogner <joebog...@gmail.com>
wrote:
Sorting and grading separately seems faster
timer=: 6!:2
x=:(1e7 $ 26?26) { 'abcdefghijklmnopqrstuvwxyz'
NB. incumbent
timer 's=: x{~g=: /:x'
0.0914002
NB. alternate
timer 'S=: /:~x[G=: /:x'
0.0668677
s-:S
1
G-:g
1
I am speculating that sorting does it in place? which is faster than
the selection from the grade
On Wed, Mar 5, 2014 at 2:02 PM, Raul Miller <rauldmil...@gmail.com>
wrote:
Hmm...
G=:a.i.S=:/:~x
is faster.
But while s-:S, g and G are different.
So I'm drawing a blank here, on how to make the grade.
Thanks,
--
Raul
On Wed, Mar 5, 2014 at 1:52 PM, Roger Hui <rogerhui.can...@gmail.com>
wrote:
Suppose x is a long vector of characters and you need both its sort
and its
grade. Can you do it faster than s=: x{~g=: /:x ?
Posed this way, the answer is of course yes. But how, and why is it
faster?
------------------------------------------------------------
----------
For information about J forums see http://www.jsoftware.com/
forums.htm
------------------------------------------------------------
----------
For information about J forums see http://www.jsoftware.com/
forums.htm
----------------------------------------------------------------------
For information about J forums see http://www.jsoftware.com/forums.htm
----------------------------------------------------------------------
For information about J forums see http://www.jsoftware.com/forums.htm
----------------------------------------------------------------------
For information about J forums see http://www.jsoftware.com/forums.htm
----------------------------------------------------------------------
For information about J forums see http://www.jsoftware.com/forums.htm
----------------------------------------------------------------------
For information about J forums see http://www.jsoftware.com/forums.htm
----------------------------------------------------------------------
For information about J forums see http://www.jsoftware.com/forums.htm
