@Adám i'd agree with this more if the letters snapped to the curves of their edges

Why do some recommend to set index origin to 0 in Dyalog APL? What is the advantage or problem solved by using this?

@GreenSaguaro Some people strongly prefer thinking in 0-origin, and for some problem domains, expressions become simpler using it. See also apl.wiki/Index_origin

@Adám Thank you

@Razetime You mean that the A would have a curved left side, and the L as slanted end of the bottom bar? That'd break the bitmappy look.

@Adám yup

⎕←42

@hyper-neutrino 42

bot is back

Hi @hyper-neutrino, how are you doing?

Can I trouble you for your mod powers?

I just need to ask for write permissions for a new user: chat.stackexchange.com/users/545352/user18785038

done

@user18785038 Welcome to The APL Orchard! You should have write access now :)

Thanks @RGS, really excited to learn from you all.

Why does {⍺,⍺}/⍳9 output 1 1 instead of 1 1 1 1 1 1 1 1 1?

...well ...I don't know what exactly I am expecting it to output precisely, but I am expecting an append to happen 9 times

@GreenSaguaro Notice that your dfn {⍺,⍺} has ⍺ twice! Maybe you meant to use ⍺ and ⍵?

Or, maybe, think of it this way:

{⍺,⍺}/⍳9 is more or less the same as 1 {⍺,⍺} 2 {⍺,⍺} 3 {⍺,⍺} 4 {⍺,⍺} 5 {⍺,⍺} 6 {⍺,⍺} 7 {⍺,⍺} 8 {⍺,⍺} 9. What's the result of the longer expression?

@RGS I have {⍺,⍺} intentionally.

I was expecting the result to grow in size as it is an append

But “it is an append” says nothing about what is being catenated.

⋄ 3 {⍺,⍺} ⍳10000

@RGS 3 3

I have a huge vector on the right, but {⍺,⍺} ignores the right argument entirely, and just catenates the left argument with itself, returning a 2-item vector.

The reason I am toying with this is because I have an array in which I need to add elements to it by working with it X number of times. It will start with two elements, and the elements added to it will be a calculation based on previous elements. The initial idea I had was to have an array like this: (⊂1 2), ⍳9, then I would do a fold only using ⍺ to extract values from and append to the first nested array, using it as an accumulator. Basically doing an unfold type of operation.

But this did not work obviously, demonstrated by my previous {⍺,⍺} confusion.

What would be the "correct" strategy to grow an array by appending in which the appended elements are based on previous values, and to do this N times?

@GreenSaguaro aplcart.info?q=fold%20from%20the%20left

⋄ (2){⍺+⍵}{↑⍺⍺⍨/(⌽⍵),⊂⍺}⍳3

@LdBeth 8

⋄ 2{⍺,⍺}{↑⍺⍺⍨/(⌽⍵),⊂⍺}1 1 1.2

@LdBeth 2 2 2 2 2 2 2 2

Which is same as ⋄ {⍵,⍵}⍣3⊢2

@LdBeth 2 2 2 2 2 2 2 2

it is unintuitive to new comers of APL from FP communities like Haskell, but the fold in apl is from right to left by default, to get the desired the similar fold from Haskell you need to reverse it.

And what you intended to do would probably be ⋄ {⍺,⊃⍺}{↑⍺⍺⍨/(⌽⍵)}⍳9

@LdBeth 1 1 1 1 1 1 1 1 1

is there a way to do a right-to-left scan, or one that otherwise uses the previous result at each stage?

⋄{2×⍺}\1 1 1 1

@att 1 2 2 2

⋄{2×⍺}\⍳5 might be a better demonstration

@att 1 2 2 2 2

I can see why the result is what it is, but is there a way to get 2 4 6 8 5 or 1 2 4 8 16?