Sorry for spamming.

In fact my paranoid use of @: can be replaced with @ everywhere. Giving:

L3=. _3((|."1@#:@i.@(2^#)) (+./@#) ])\Y

So I should also say that the real goal is to minimize the number of
different operations used. Right now this stands at: #: i. 2^ # +. / @ # \
if we assume #: is implemented in reverse.

On Thu, Oct 13, 2016 at 12:05 AM, Michal Dobrogost <
michal.dobrog...@gmail.com> wrote:

> And +./"2@:# can be rewritten as +./@#.
>
> Anything else?
>
> On Wed, Oct 12, 2016 at 11:55 PM, Michal Dobrogost <
> michal.dobrog...@gmail.com> wrote:
>
>> You can rewrite *."0 1"1 _ as #
>>
>>    ]L3=. _3((|."1@:#:@:i.@:(2^#)) (+./"2 @: #) ])\Y
>> 0 0 0 0 0 NB. zero
>> 0 0 0 0 1 NB.         0 { Y
>> 0 0 0 1 0 NB.         1 { Y
>> 0 0 0 1 1 NB. +./   0 1 { Y
>> 0 0 1 0 0 NB.         2 { y
>> 0 0 1 0 1 NB.       0 2 { Y
>> 0 0 1 1 0 NB. +./   0 1 { Y
>> 0 0 1 1 1 NB. +./ 0 1 2 { Y
>>
>> 0 0 0 0 0 NB. zero
>> 0 1 0 0 0 NB.       3 { Y
>> 1 0 0 0 0 NB.       4 { Y
>> 1 1 0 0 0 NB. +./ 3 4 { Y
>> 0 0 0 0 0
>> 0 0 0 0 0
>> 0 0 0 0 0
>> 0 0 0 0 0
>>
>> On Wed, Oct 12, 2016 at 11:34 PM, Michal Dobrogost <
>> michal.dobrog...@gmail.com> wrote:
>>
>>> I've tried to clean up the code to be more explanatory. All we really
>>> care about is generating L2 given an arbitrary Y. Rewriting this has also
>>> helped me catch a subtle bug with arrays going left-to-right but #. and #:
>>> interpreting numbers right-to-left.
>>>
>>>    NB. X and Y are completely arbitary and are chosen to be
>>>    NB. easy to trace.
>>>    ] X =. 0 1 1 0 1
>>> 0 1 1 0 1
>>>    ] Y =. |.=/~i.5
>>> 0 0 0 0 1
>>> 0 0 0 1 0
>>> 0 0 1 0 0
>>> 0 1 0 0 0
>>> 1 0 0 0 0
>>>
>>>    NB. This is the final result but we are actually trying to
>>>    NB. generate lookup tables for highly optimized C++ code.
>>>    X (+./@:*.) Y
>>> 1 0 1 1 0
>>>
>>>    NB. Break up x into 2-bit chunks.
>>>    NB. Note: reversed with |. because #. below interprets right-most
>>>    NB.       digit as most significant but J's array has first
>>>    NB.       item as left-most.
>>>    X
>>> 0 1 1 0 1
>>>    _2<@|.\X
>>> ┌───┬───┬─┐
>>> │1 0│0 1│1│
>>> └───┴───┴─┘
>>>
>>>    NB. We convert 2-bit chunks of x into indices.
>>>    _2#.@|.\X
>>> 2 1 1
>>>
>>>    ]L2=. _2((|."1@:#:@:i.@:(2^#)) (+./"2 @: (*."0 1"1 _)) ])\Y
>>> 0 0 0 0 0 NB. zero
>>> 0 0 0 0 1 NB. 0 { y
>>> 0 0 0 1 0 NB. 1 { y
>>> 0 0 0 1 1 NB. +./ 0 1 { y
>>>
>>> 0 0 0 0 0 NB. zero
>>> 0 0 1 0 0 NB. 2 { y
>>> 0 1 0 0 0 NB. 3 { y
>>> 0 1 1 0 0 NB. +./ 2 3 { y
>>>
>>> 0 0 0 0 0 NB. zero
>>> 1 0 0 0 0 NB. 4 { y
>>> 0 0 0 0 0
>>> 0 0 0 0 0
>>>
>>>    NB. Compute by 2-bit lookups (same result as +./@:*. above).
>>>    NB. We don't really care, this just demonstrates that the LUT works.
>>>    +./ (_2#.@|.\x) {"0 2 L2
>>> 1 0 1 1 0
>>>
>>> Cheers,
>>>
>>> Mike
>>>
>>> On Wed, Oct 12, 2016 at 7:00 PM, Michal Dobrogost <
>>> michal.dobrog...@gmail.com> wrote:
>>>
>>>> Hi Raul,
>>>>
>>>> What is the definition of *inds*?
>>>>
>>>> I would describe the higher level operation as: select the rows of Y
>>>> where X is 1. Then take the column-wise OR of them.
>>>>
>>>> However the real thing I'm interested in is generating the lookup
>>>> tables which serve as an intermediate step in the higher level operation.
>>>>
>>>> On Wed, Oct 12, 2016 at 9:35 AM, Raul Miller <rauldmil...@gmail.com>
>>>> wrote:
>>>>
>>>>> I'm not quite sure I understand what you are doing here.
>>>>>
>>>>> Here's what I understand from your description:
>>>>>
>>>>> You're looking for rows where a bit set in X has a bit set in Y, and
>>>>> you want to split up X and Y into smaller pieces for your intermediate
>>>>> result, and you want to use indices rather than bit operations for
>>>>> your final operation.
>>>>>
>>>>> That gives me something like this.
>>>>>
>>>>>    X =: ? 5 $ 2
>>>>>    Y =: 30 > ? 5 6 $ 100
>>>>>    X
>>>>> 0 1 1 1 1
>>>>>    Y
>>>>> 0 0 0 0 0 0
>>>>> 1 0 0 0 0 0
>>>>> 1 1 1 0 0 1
>>>>> 1 0 0 1 0 0
>>>>> 0 0 0 0 0 1
>>>>>    (_2 {. X) inds _2 {. Y
>>>>> 0 3 5
>>>>>    (3 {. X) inds 3 {. Y
>>>>> 0 1 2 5
>>>>>    0 3 5 ([ -. -.) 0 1 2 5
>>>>> 0 5
>>>>>
>>>>> So maybe you would be looking at making an adverb along the lines of:
>>>>>
>>>>> L=: adverb define
>>>>> :
>>>>>    (m {. x) inds m {. y
>>>>> )
>>>>>
>>>>> Or, more concisely:
>>>>>
>>>>> L=: adverb define
>>>>>    inds&(m&{.)
>>>>> )
>>>>>
>>>>> But when I look at your calculations, I don't see anything like this.
>>>>>
>>>>> If I am off base here, could you describe how what you are looking for
>>>>> differs from what I am understanding?
>>>>>
>>>>> Thanks,
>>>>>
>>>>> --
>>>>> Raul
>>>>>
>>>>>
>>>>> On Wed, Oct 12, 2016 at 12:14 PM, Michal Dobrogost
>>>>> <michal.dobrog...@gmail.com> wrote:
>>>>> > Hi All,
>>>>> >
>>>>> > I've been mucking around generating look up tables in C++. Getting
>>>>> > frustrated, I wrote up this J single liner. Can you think of ways to
>>>>> > simplify the LUT computation (the expression we assign to L2 and L3
>>>>> below)?
>>>>> >
>>>>> > *Original Operator (no LUT)*
>>>>> >
>>>>> >    ] x =. ? 5 $ 2
>>>>> > 1 0 1 1 0
>>>>> >    ] y =. 30 > ? 5 6 $ 100
>>>>> > 1 0 0 0 0 0
>>>>> > 0 1 0 1 1 0
>>>>> > 0 1 0 0 0 1
>>>>> > 0 0 0 0 1 1
>>>>> > 0 1 1 1 0 1
>>>>> >    x (+./@:*.) y
>>>>> > 1 1 0 0 1 1
>>>>> >
>>>>> > *LUT Explanation*
>>>>> >
>>>>> > The idea is to break up x into smaller chunks (2-bits, 3-bits, etc)
>>>>> and
>>>>> > precompute the operation for the corresponding chunks of y. Then we
>>>>> just
>>>>> > convert the chunks into indices and look them up in the LUT.
>>>>> >
>>>>> >    _2<\x
>>>>> > ┌───┬───┬─┐
>>>>> > │1 0│1 1│0│
>>>>> > └───┴───┴─┘
>>>>> >    _2#.\x
>>>>> > 2 3 0
>>>>> >
>>>>> > *2-bit LUT*
>>>>> >
>>>>> >    ]L2=. _2((#:@:i.@:(2&^)@:#) (+./"2 @: (*."0 1"1 _)) ])\y
>>>>> > 0 0 0 0 0 0
>>>>> > 0 1 0 1 1 0
>>>>> > 1 0 0 0 0 0
>>>>> > 1 1 0 1 1 0
>>>>> >
>>>>> > 0 0 0 0 0 0
>>>>> > 0 0 0 0 1 1
>>>>> > 0 1 0 0 0 1
>>>>> > 0 1 0 0 1 1
>>>>> >
>>>>> > 0 0 0 0 0 0
>>>>> > 0 1 1 1 0 1
>>>>> > 0 0 0 0 0 0
>>>>> > 0 0 0 0 0 0
>>>>> >
>>>>> >    +./ (_2#.\x) {"0 2 L2    NB. Compute by 2-bit lookups
>>>>> > 1 1 0 0 1 1
>>>>> >
>>>>> > *3-Bit LUT*
>>>>> >
>>>>> >    ]L3=. _3((#:@:i.@:(2&^)@:#) (+./"2 @: (*."0 1"1 _)) ])\y
>>>>> > 0 0 0 0 0 0
>>>>> > 0 1 0 0 0 1
>>>>> > 0 1 0 1 1 0
>>>>> > 0 1 0 1 1 1
>>>>> > 1 0 0 0 0 0
>>>>> > 1 1 0 0 0 1
>>>>> > 1 1 0 1 1 0
>>>>> > 1 1 0 1 1 1
>>>>> >
>>>>> > 0 0 0 0 0 0
>>>>> > 0 1 1 1 0 1
>>>>> > 0 0 0 0 1 1
>>>>> > 0 1 1 1 1 1
>>>>> > 0 0 0 0 0 0
>>>>> > 0 0 0 0 0 0
>>>>> > 0 0 0 0 0 0
>>>>> > 0 0 0 0 0 0
>>>>> >
>>>>> >    +./ (_3#.\x) {"0 2 L3    NB. Compute by 3-bit lookups
>>>>> > 1 1 0 0 1 1
>>>>> > ------------------------------------------------------------
>>>>> ----------
>>>>> > For information about J forums see http://www.jsoftware.com/forum
>>>>> s.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