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

Reply via email to