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

Reply via email to