The APL Orchard

A non-empty array is simple if and only if it has a depth of 0 (which makes it a scalar) or 1.

Can't the non-empty part be removed? Arrays are still simple if they're empty and have depth 0 or 1, correct?

Adám

@FawnLocke Yeah, empty or not is irrelevant. Simple ←→ 1≥|⍤≡

Fawn Locke

Okay, gotcha

Adám

This particular formulation is not on APLcart because 1=≡,Y is optimised.

Oh, and because I came up with ⊂≡⊆ when we added ⊆

Fawn Locke

Is the |⍤ necessary? When will an array be simple and have elements of differing depth?

Adám

It won't, but 1≥¯2

Fawn Locke

11:43 AM

Ah, right.

Thanks for clarifying, perhaps it's useful to remove irrelevant information? Or is that better suited to a more friendly yet comprehensive resource

Adám

11:54 AM

@FawnLocke Not sure what you're suggesting?

Fawn Locke

Well, the aplwiki intends to comment on history, implementation differences, differing models, etc - which is good.

And the Dyalog docs are subpar in areas, besides being unable to contribute to them.

I'm just curious if it'd be a good idea to create a middle-ground

Adám

I think apl.wiki/Simple_array is the right place to include definitions/formulas/equivalences like these.

Btw, about not being able to contribute to the Dyalog docs: I am planning on lobbying for migration to an open GitHub-based system, so contributions can become possible.

Fawn Locke

Good to know

I think that'd solve my current qualm

Adám

Go for it!

Marshall

1:42 PM

@Adám The point was that for example ≡0⍴⊂⊂⊂'abc' is 4, but should be considered simple (it's a valid left argument to reshape).

Adám

@Marshall OK, that's a good point.

Maybe (1=≡0,⊢) would be a better test.

So in BQN, you cannot have a non-simple empty array?

Fawn Locke

I see

Adám

In other words, in BQN, ≡¨(⥊¨↕0)‿(⥊¨↕1)‿(⥊¨↕2)‿(⥊¨↕3) gives 1‿2‿2‿2

The corresponding APL, ≡¨(,¨⍳0)(,¨⍳1)(,¨⍳2)(,¨⍳3) gives 2 2 2 2

PyGamer0

@Adám is it "depth foreach (deshape it over 0)(deshape it over 0,1)etc"

Adám

Correct.

Fawn Locke

1:51 PM

@Adám What is this supposed to do?

Adám

Test if empty or simple.

Probably much better to do (⊂≡⊆)∨0∊⍴

Fawn Locke

Do you mean (1=∘≡0,⊢)?

(1=≡0,⊢) isn't a valid train

Maybe I'm low on caffeine :^)

Adám

Yes, my bad.

Marshall

2:15 PM

@Adám BQN doesn't have any concept of "simple array" (it uses "array of numbers" or "array of characters" when necessary), but any empty array has depth 1. Things don't depend on fills unless they really have to.

justin2004

4:41 PM

hey, are there any values of m that wouldn't make these two expressions produce the same result?

⌽m
(⊖⍤1)m

and if not, does that hold for any pair of functions where one operates on the first axis and the other operates on the last?

Adám

@justin2004 No, ⌽ and ⊖⍤1 is completely equivalent, and so too for all such pairs.

justin2004

@Adám i thought so but the performance difference in dyalog made me think there might be some checks being done:
https://github.com/phantomics/april/issues/208#issuecomment-1030741818

do you know what accounts for that performance difference?

Adám

@justin2004 Operators have overhead, and the array in question is tiny:

      size←4000 ⋄ m← size size ⍴ ⍳size×size
      cmpx     '⌽m'      '(⊖⍤1)m'
  ⌽m     → 8.8E¯3 |  0% ⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕
  (⊖⍤1)m → 8.9E¯3 | +1% ⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕

justin2004

oh, yesterday i couldn't increase size beyond 4 without it taking a very long time. let me try again. i was also using diamond but i read cmpx doesn't like diamond.

dzaima

if Dyalog can't reverse a 16 item array, something is definitely very wrong

justin2004

4:57 PM

ok i just tried again with 4000 and it runs quickly... i must have done something silly... or i was still using diamond. thanks @Adám

Adám

No worries.

justin2004

so if ⌽ and ⊖⍤1 are equivalent -- does that generalize to all pairs of functions where one operates on the first axis and the other on the last axis?

Adám

Yes.

justin2004

nice! i think that'll make a nice optimization for april... well "an" optimization at least.

Adám

@justin2004 The markdown of your last message in that issue is mangled. You have link markdown inside your code block.

justin2004

5:04 PM

@Adám fixed it. ty.

Kamila Szewczyk

6:59 PM

@Adám how was the dyadic circle function designed?

i feel like a lot of these functions don't serve a particular use

10, -10, -11 to name a few

Adám

Let me find the paper…

@KamilaSzewczyk The story of ○ — will you add it to the wiki's page or shall I?

LdBeth

7:59 PM

@KamilaSzewczyk notice that the left argument can also be any array of matching rank. So you can do (2 2⍴¯9 ¯11 9 10)○(2 2⍴1 2j2 ¯3 4j2) instead of figuring out how to apply different functions to different cells of an array

While this kind of computation is common to be seen on books about linear algebra

so even for example ¯9○ is just identity function, it is still useful to include that.

So the design of ○ is trying to avoid the "array of functions" concept.

$$\left(
\begin{array}{cc}
\cos\theta&-\sin\theta\\
\sin\theta&\cos\theta
\end{array}
\right)$$

for example, you will find ○ is handy for computing the above matrix that can be used to rotate a 2D vector.

Brian BED

8:19 PM

i used the ○'s features a lot when i did a challenge someone sent of calculating the angle from one entity in a 3d space to another. it was fun, lots of sins, tans and cosines, esspecially the arctan was useful

Brian BED

8:53 PM

screen←{(⍳⍺)+¨⍨⊂⍵}
is there a tacit version of this function? i watched a dyalog webinar on how to spot trains and such so i tried with this function and i have been so close so many times but i can't get it to work

like i got this to work: screen←((⍳z)+¨⍨⊂)
but obviously i hid the left argument in a variable instead of actually having it as a left operand

dzaima

+¨⍨ is just +

it'd be (⍳⍤⊣ + ⊂⍤⊢), not much better than {(⍳⍺) + ⊂⍵}

with reverse compose, it could be ⍳⍛+∘⊂

Brian BED

@dzaima huh thanks, thats neat i should learn how to use ⍤. but yea not much better i suppose

@dzaima huh what's reverse compose? is it a thing from another version or?

Fawn Locke

⍤ is just a 2-train (f g)

X f⍤g Y ←→ f (X g Y)
f⍤g Y ←→ f (g Y)

here it's evaluated as (⍳ ⍺⊣⍵) + (⊂⍺⊢⍵)

dzaima

@BrianBED it's {(⍺⍺ ⍺) ⍵⍵ ⍵} - pre-process left argument by the left operand before giving it to the right