btw not correct, but at least its valid apl, which is a start.
On Thu, Oct 10, 2019 at 12:34 PM Rowan Cannaday <[email protected]> wrote:
> Thank you Jürgen.
>
> I found translating the late John Scholes APL videos on youtube from
> dyalog specific syntax to gnu-apl helpful.
>
> For example, here is his "naive" algorithm for counting all the leaf nodes
> in a tree:
> dfs ← {⊃∇⍨/⌽(⊂⍺ ⍺⍺ ⍵),⍺ ⍵⍵ ⍵}
> 0 {⍺+0=≡⍵} dfs {(0=≡⍵)↓,⍵} (1 2)(3 4)
> 4
>
> I had a longer write up, but I seem to have solved it whilst
> troubleshooting.
> Here is the translation if anybody else is interested:
> dfs ← {⊃(⍶ {⍺(⍶ dfs ⍹)⍵} ⍹)/⌽(⊂⍺ ⍶ ⍵),⍺ ⍹ ⍵}
> 0 ({⍺+0=≡⍵} dfs {⍺⊢(0=≡⍵)↓,⍵}) (1 2)(3 4)
> 4
>
> It seems dyalog does some implicit argument passing with the '∇'operator,
> as well seems to be less stringent than gnu-apl with regards to
> uninitialized arguments (needing '⍺⊢' in right operator function). No
> complaints by me, I prefer explicit to implicit.
>
> I will likely continue on with this at some point, so don't be surprised
> if I use this thread as a journal.
>
> - Rowan
>
> On Thu, Oct 10, 2019 at 11:22 AM Dr. Jürgen Sauermann <
> mail@jürgen-sauermann.de> wrote:
>
>> Hi Rowan,
>>
>> not sure if it helps, but the term accumulator makes me think of the
>> reduction
>> operator rather than the rank operator:
>>
>>
>>
>> * {⍺,1+⍵} / 1 2 3 1 3 5 *
>> Not sure, though what you want to compute.
>>
>> The syntax of the rank operator in the ISO standard is IMHO broken. The
>> syntax:
>>
>> Z←f ⍤ y B
>>
>> has a rather ambiguous right argument *j B* with no rules as to where *j*
>> end and *B* begins.
>> For example:
>>
>> Z←f⍤1 2 3 4 5
>>
>> could mean:
>>
>> j = 1 and B = 2 3 4 5 or:
>> j = 1 2 and B = 3 4 5 or even:
>> j = 1 2 3 and B = 4 5
>>
>> GNU APL uses some crude rules to resolve such cases, but in order
>> to get a predictable result, you need to properly use parentheses like
>> this:
>>
>> Z←(f⍤1) 2 3 4 5
>>
>> or, as a cleaner though non-standard alternative syntax, make *j* an
>> axis argument:
>>
>> Z←f⍤[1] 2 3 4 5
>>
>> It is very difficult to get all that right, therefore I never use ⍤.
>>
>> Best Regards,
>> Jürgen Sauermann
>>
>>
>> On 10/9/19 9:44 PM, Rowan Cannaday wrote:
>>
>> this seems to be behaving much better:
>> foo ← {⍺,{((1+1↑⍵) foo 1↓⍵)}⍣(~0=⍴⍵)⊢⍵}
>> ⍬ foo 1 2 3
>> 2 3 4
>> 5 4 3 foo 1 2 3
>> 5 4 3 2 3 4
>>
>> On Wed, Oct 9, 2019 at 3:40 PM Rowan Cannaday <[email protected]>
>> wrote:
>>
>>> somebody pointed out that the previous fn was failing because i wasn't
>>> calling 'foo' w/ dyadic arguments in the inner dfn
>>>
>>> On Wed, Oct 9, 2019 at 2:16 PM Rowan Cannaday <[email protected]>
>>> wrote:
>>>
>>>> interestingly enough this is ok:
>>>> foo ← {⍬{⍺,(1+1↑⍵),(foo 1↓⍵)}⍣(~0=⍴⍵)⍵}
>>>> foo 1 2 3
>>>> 2 3 4
>>>>
>>>> but this isnt:
>>>> foo ← {⍺{⍺,(1+1↑⍵),(foo 1↓⍵)}⍣(~0=⍴⍵)⍵}
>>>> ⍬ foo 1 2 3
>>>> VALUE ERROR
>>>> foo[1] λ←⍺ λ1⍣(∼0=⍴⍵)⍵
>>>> ^
>>>> ⎕CR 'foo'
>>>> λ←⍺ λ1 ⍵
>>>> λ←⍺{⍺,(1+1↑⍵),(foo 1↓⍵)}⍣(~0=⍴⍵)⍵
>>>>
>>>> On Wed, Oct 9, 2019 at 1:29 PM Rowan Cannaday <[email protected]>
>>>> wrote:
>>>>
>>>>> making progress...
>>>>>
>>>>> foo ← {{(1+1↑⍵),(foo 1↓⍵)}⍣(~0=⍴⍵)⍵}
>>>>> foo 1 2 3
>>>>> 2 3 4
>>>>>
>>>>> On Wed, Oct 9, 2019 at 12:47 PM Rowan Cannaday <[email protected]>
>>>>> wrote:
>>>>>
>>>>>> this is a slightly better way of writing my (still broken)
>>>>>> accumulator:
>>>>>> acc←{⍺{⍺ acc 1↑⍵}⍣(0=⍴⍵)⊢⍵}
>>>>>>
>>>>>> On Wed, Oct 9, 2019 at 12:40 PM Rowan Cannaday <[email protected]>
>>>>>> wrote:
>>>>>>
>>>>>>> Given a recursive factorial definition:
>>>>>>> fact←{{⍵ × fact ⍵-1}⍣(⍵>2)⊢1⌈⍵}
>>>>>>>
>>>>>>> [written by Kacper Gutowski in the 'Recursive Lambda' thread]
>>>>>>>
>>>>>>> I am attempting to write a basic accumulator. This should take an
>>>>>>> empty vector as the left value argument, and a rank 1 array as the right
>>>>>>> value argument.
>>>>>>> Every iteration it should drop a value from the right value, and
>>>>>>> append it to the left, until the right value is an empty vector.
>>>>>>>
>>>>>>> I thought I'd be able to do something like the following:
>>>>>>> acc←{⍺,{acc 1↑⍵}⍣(0=⍴⍵)⊢⍵}
>>>>>>> ⍬ acc 1 2 3
>>>>>>>
>>>>>>> But modifying this to say, add a 1 to every number, still returns
>>>>>>> the input vector ⍵.
>>>>>>>
>>>>>>> Thoughts?
>>>>>>>
>>>>>>>
>>>>>>> On Fri, Sep 27, 2019 at 3:44 PM Rowan Cannaday <[email protected]>
>>>>>>> wrote:
>>>>>>>
>>>>>>>> Hello y'all.
>>>>>>>>
>>>>>>>> I have been attempting to learn function composition & higher-order
>>>>>>>> functions in gnu-apl, and how to use it to perform tree traversal.
>>>>>>>>
>>>>>>>>
>>>>>>>> https://en.wikipedia.org/wiki/Function_composition_(computer_science)#APL
>>>>>>>> https://en.wikipedia.org/wiki/Higher-order_function#APL
>>>>>>>> https://rosettacode.org/wiki/Tree_traversal#APL
>>>>>>>>
>>>>>>>> Unfortunately a lot of the syntax used is dyalog & dfn specific, so
>>>>>>>> working out some of the examples is a bit tricky for myself.
>>>>>>>> (the main inconsistencies are '∇' as a recursive function
>>>>>>>> definition, ⍺⍺ & ⍵⍵ to refer to left and right operands, '@' as the
>>>>>>>> 'at'
>>>>>>>> operator, '⍣' operator differences, as well as possibly others).
>>>>>>>>
>>>>>>>> Has anybody done 'idiomatic' tree traversal in gnu-apl? Does
>>>>>>>> anybody use primitive composition functions in their code?
>>>>>>>>
>>>>>>>> Trying to figure out what works and feels natural in the language.
>>>>>>>> Any examples or guidance would be appreciated.
>>>>>>>>
>>>>>>>> Examples:
>>>>>>>>
>>>>>>>> Higher order fns in gnu-apl:
>>>>>>>> ∇Z ← (L twice) B
>>>>>>>> Z ← L L B
>>>>>>>> ∇
>>>>>>>>
>>>>>>>> ∇Z ← plusthree B
>>>>>>>> Z ← B + 3
>>>>>>>> ∇
>>>>>>>>
>>>>>>>> ∇Z ← g B
>>>>>>>> Z ← plusthree twice B
>>>>>>>> ∇
>>>>>>>>
>>>>>>>
>>
