Thank you, Joey and Fraser. Here is a summary so far.
It shows #/.~ is a powerful feature. It might even do indexing.
tz=: ] ; 6!:2 ; 7!:[EMAIL PROTECTED]
vt=: ,.&.:>"1@|:
N=: 1
]B=: 100+ i.N*10
100 101 102 103 104 105 106 107 108 109
]A1=: 100+ ?.2 8$&(N&*)10
106 105 109 102 104 109 100 107
100 104 106 108 103 108 101 102
vt 3&tz ;._2 (0 : 0)
B +/ . (=/)~"1 A1
((B e. ~.) #^:_1 #/.~)@/:~"1 A1
B +/@:="0 1"1 A1
B +/"2 . (=/)~ A1
+/"2 A1 =/ B
+/"2 B (=/)~ A1
B +/"2 @ (=/)~ A1
B #/[EMAIL PROTECTED](i. ~.)`([EMAIL PROTECTED] # 0:)}"1 A1
)
+---------------------------------+----------+----+
|B +/ . (=/)~"1 A1 |1.42476e_5|3520|
|((B e. ~.) #^:_1 #/.~)@/:~"1 A1 | 1.8345e_5|3648|
|B +/@:="0 1"1 A1 |1.55513e_5|2944|
|B +/"2 . (=/)~ A1 |9.96402e_6|2944|
|+/"2 A1 =/ B |8.00847e_6|2304|
|+/"2 B (=/)~ A1 |8.75344e_6|2432|
|B +/"2 @ (=/)~ A1 |9.31217e_6|2560|
|B #/[EMAIL PROTECTED](i. ~.)`([EMAIL PROTECTED] # 0:)}"1 A1|3.26857e_5|7808|
+---------------------------------+----------+----+
N=: 10
+---------------------------------+-----------+------+
|B +/ . (=/)~"1 A1 |0.000457134| 21248|
|((B e. ~.) #^:_1 #/.~)@/:~"1 A1 |0.000204123| 13824|
|B +/@:="0 1"1 A1 |0.000585829| 12928|
|B +/"2 . (=/)~ A1 |0.000392229|273088|
|+/"2 A1 =/ B | 0.00041048|272448|
|+/"2 B (=/)~ A1 |0.000374442|272576|
|B +/"2 @ (=/)~ A1 |0.000372952|272704|
|B #/[EMAIL PROTECTED](i. ~.)`([EMAIL PROTECTED] # 0:)}"1 A1|0.000213714| 19840|
+---------------------------------+-----------+------+
N=: 100
+---------------------------------+---------+---------+
|B +/ . (=/)~"1 A1 | 0.559677| 2118144|
|((B e. ~.) #^:_1 #/.~)@/:~"1 A1 |0.0154478| 1075712|
|B +/@:="0 1"1 A1 | 0.237633| 1071232|
|B +/"2 . (=/)~ A1 | 0.511746|269488576|
|+/"2 A1 =/ B | 0.516047|269487936|
|+/"2 B (=/)~ A1 | 0.516758|269488064|
|B +/"2 @ (=/)~ A1 | 0.513965|269488192|
|B #/[EMAIL PROTECTED](i. ~.)`([EMAIL PROTECTED] # 0:)}"1 A1| 0.015995|
1099904|
+---------------------------------+---------+---------+
NB. =========================================================
NB. Now boxed strings!
]B=: <@":"0] 100+ i.N*10
]A1=: <@":"0] 100+ ?.2 8$&(N&*)10
N=: 1
+---------------------------------+----------+----+
|B +/ . (=/)~"1 A1 | 3.8273e_5|3520|
|((B e. ~.) #^:_1 #/.~)@/:~"1 A1 |4.40466e_5|3648|
|B +/@:="0 1"1 A1 |5.03788e_5|3008|
|B +/"2 . (=/)~ A1 |3.27788e_5|2944|
|+/"2 A1 =/ B |3.08233e_5|2304|
|+/"2 B (=/)~ A1 |3.11958e_5|2432|
|B +/"2 @ (=/)~ A1 |3.20339e_5|2560|
|B #/[EMAIL PROTECTED](i. ~.)`([EMAIL PROTECTED] # 0:)}"1 A1|5.07513e_5|7808|
+---------------------------------+----------+----+
N=: 10
+---------------------------------+----------+------+
|B +/ . (=/)~"1 A1 | 0.0228696| 21248|
|((B e. ~.) #^:_1 #/.~)@/:~"1 A1 |0.00201543| 14592|
|B +/@:="0 1"1 A1 | 0.02424| 13056|
|B +/"2 . (=/)~ A1 | 0.0226484|273088|
|+/"2 A1 =/ B | 0.0237572|272448|
|+/"2 B (=/)~ A1 | 0.0226425|272576|
|B +/"2 @ (=/)~ A1 | 0.0232448|272704|
|B #/[EMAIL PROTECTED](i. ~.)`([EMAIL PROTECTED] # 0:)}"1 A1|0.00135036| 19840|
+---------------------------------+----------+------+
N=: 50
+---------------------------------+---------+--------+
|B +/ . (=/)~"1 A1 | 2.82656| 536064|
|((B e. ~.) #^:_1 #/.~)@/:~"1 A1 |0.0537835| 280064|
|B +/@:="0 1"1 A1 | 2.91736| 275072|
|B +/"2 . (=/)~ A1 | 2.86025|33820096|
|+/"2 A1 =/ B | 2.83257|33819456|
|+/"2 B (=/)~ A1 | 2.8513|33819584|
|B +/"2 @ (=/)~ A1 | 2.96736|33819712|
|B #/[EMAIL PROTECTED](i. ~.)`([EMAIL PROTECTED] # 0:)}"1 A1|0.0371492| 290944|
+---------------------------------+---------+--------+
--- Joey K Tuttle <[EMAIL PROTECTED]> wrote:
> How about -
>
> +/"2 A =/ B
> 2 0 1 0 1 2 0 0 0 2
>
> +/"2 A1 =/ B
> 1 0 1 0 1 1 1 1 0 2
> 1 1 1 1 1 0 1 0 2 0
It's a winner on small input and start to lag on large.
--- Fraser Jackson <[EMAIL PROTECTED]> wrote:
> I would use indexing into B. Either using nub A first and then indexing
> or indexing first into B and then nub
>
>
> enub =: 4 : 0
> bi =. x i. y
> ((~.bi){x),:bi #/.bi
> )
>
> B enub A
> 105 102 109 104 100
> 2 1 2 1 2
>
> Indexing is fast and scalable
>
> Fraser
But that's "internal" frequencies. However,
I incorporated the idea in the last sentence of the table.
It's a little slower but close to simply #/.~ on integers.
But it gives some time improvement for strings.
> ----- Original Message -----
> From: "Oleg Kobchenko" <[EMAIL PROTECTED]>
> To: "Programming forum" <[email protected]>
> Sent: Thursday, August 24, 2006 5:20 PM
> Subject: [Jprogramming] External frequencies
>
>
> > Nub operations in J work on "internal" nub,
> > ordered complete list of unique first occurences.
> >
> > But how does one go about getting frequencies of an
> > "external" nub, an ordered unique list
> > containing items in given list?
> >
> > ]A=: 100+ 5 2 9 5 4 0 9 0 NB. given list
> > 105 102 109 105 104 100 109 100
> > ]B=: 100+ i.10 NB. external nub
> > 100 101 102 103 104 105 106 107 108 109
> >
> > ~.A NB. internal nub
> > 105 102 109 104 100
> > /:~~.A NB. sorted
> > 100 102 104 105 109
> >
> > B +/ . (=/)~ A NB. Ext. freq. 1
> > 2 0 1 0 1 2 0 0 0 2
> >
> > #/.~ A NB. internal freq.
> > 2 1 2 1 2
> > (#/.~ ,: ~.) A
> > 2 1 2 1 2
> > 105 102 109 104 100
> >
> > ((B e. ~.) #^:_1 #/.~) /:~A NB. Ext. freq. 2
> > 2 0 1 0 1 2 0 0 0 2
> >
> > Any other ways? Also it's good to be scalable to higher ranks.
> >
> > ]A1=: 100+ ?.2 8$10
> > 106 105 109 102 104 109 100 107
> > 100 104 106 108 103 108 101 102
> >
> > B +/ . (=/)~"1 A1
> > 1 0 1 0 1 1 1 1 0 2
> > 1 1 1 1 1 0 1 0 2 0
> >
> > ((B e. ~.) #^:_1 #/.~)@/:~"1 A1
> > 1 0 1 0 1 1 1 1 0 2
> > 1 1 1 1 1 0 1 0 2 0
__________________________________________________
Do You Yahoo!?
Tired of spam? Yahoo! Mail has the best spam protection around
http://mail.yahoo.com
----------------------------------------------------------------------
For information about J forums see http://www.jsoftware.com/forums.htm
