From eb01eb415a5304d98c55f844188bb0defac90c67 Mon Sep 17 00:00:00 2001 From: Marshall Lochbaum Date: Fri, 17 Jul 2020 12:04:34 -0400 Subject: Character entity escaping for "&<> --- docs/depth.html | 30 +++++++++++++++--------------- 1 file changed, 15 insertions(+), 15 deletions(-) (limited to 'docs/depth.html') diff --git a/docs/depth.html b/docs/depth.html index a365212a..93234609 100644 --- a/docs/depth.html +++ b/docs/depth.html @@ -5,21 +5,21 @@

To find the depth of an array, use Depth (≡). For example, the depth of a list of numbers or characters is 1:

    ≡ 2‿3‿4
 1
-    ≡ "a string is a list of characters"
+    ≡ "a string is a list of characters"
 1
-

Depth is somewhat analogous to an array's rank ≠≢𝕩, and in fact rank can be "converted" to depth by splitting rows with <⎉1, reducing the rank by 1 and increasing the depth. Unlike rank, Depth doesn't care at all about its argument's shape:

-
    ≡ 3‿4⥊"characters"
+
Depth is somewhat analogous to an array's rank ≠≢𝕩, and in fact rank can be "converted" to depth by splitting rows with <⎉1, reducing the rank by 1 and increasing the depth. Unlike rank, Depth doesn't care at all about its argument's shape:

+
    ≡ 3‿4⥊"characters"
 1
-    ≡ (1+↕10)⥊"characters"
+    ≡ (1+↕10)⥊"characters"
 1
 

 
Also unlike rank, Depth does care about the elements of its argument: in fact, to find the depth of an array, every element must be inspected.

 
    ≡ ⟨2,3,4,5⟩
 1
-    ≡ ⟨2,<3,4,5⟩
+    ≡ ⟨2,<3,4,5⟩
 2
-    ≡ ⟨2,<3,4,<<<5⟩
+    ≡ ⟨2,<3,4,<<<5⟩
 4
 

 
As the above expressions suggest, the depth of an array is the maximum of its elements, plus one. The base case, a non-array (including a function, modifier, or combinator), has depth 0.

@@ -62,9 +62,9 @@
 
 
 
Functions such as Take and Drop use a single number per axis. When the left argument is a list of numbers, they apply to initial axes. But for convenience, a single number is also accepted, and applied to the first axis only. This is equivalent to ravelling the left argument before applying the function.

-
    ≢2↑7‿7‿7‿7⥊"abc"
+
    ≢2↑7‿7‿7‿7⥊"abc"
 [ 2 7 7 7 ]
-    ≢2‿1‿1↑7‿7‿7‿7⥊"abc"
+    ≢2‿1‿1↑7‿7‿7‿7⥊"abc"
 [ 2 1 1 7 ]
 

 
In these cases the flexibility seems trivial because the left argument has depth 1 or 0: it is an array or isn't, and it's obvious what a plain number should do. But for the second row in the table, the left argument is always an array. The general case is that the left argument is a vector and its elements correspond to right argument axes:

@@ -75,21 +75,21 @@
                           ┘
 

 
This means the left argument is homogeneous of depth 2. What should an argument of depth 1, or an argument that contains non-arrays, do? One option is to continue to require the left argument to be a vector, and convert any non-array argument into an array by boxing it:

-
    ⟨3‿2,1⟩ <⍟(0=≡)¨⊸⊏ ↕6‿7
+
    ⟨3‿2,1⟩ <⍟(0=≡)¨⊸⊏ ↕6‿7
 [ [ 3 1 ] [ 2 1 ] ]
 

 
While very consistent, this extension represents a small convenience and makes it difficult to act on a single axis, which for Replicate and Group is probably the most common way the primitive is used:

-
    3‿2‿1‿2‿3 / "abcde"
+
    3‿2‿1‿2‿3 / "abcde"
 [ aaabbcddeee ]
 

-
With the extension above, every case like this would have to use <⊸/ instead of just /. BQN avoids this difficulty by testing the left argument's depth. A depth-1 argument applies to the first axis only, giving the behavior above.

-
For Select, the depth-1 case is still quite useful, but it may also be desirable to choose a single cell using a list of numbers. In this case the left argument depth can be increased from the bottom using <¨.

-
    2‿1‿4 <¨⊸⊏ ↕3‿4‿5‿2
+
With the extension above, every case like this would have to use <⊸/ instead of just /. BQN avoids this difficulty by testing the left argument's depth. A depth-1 argument applies to the first axis only, giving the behavior above.

+
For Select, the depth-1 case is still quite useful, but it may also be desirable to choose a single cell using a list of numbers. In this case the left argument depth can be increased from the bottom using <¨.

+
    2‿1‿4 <¨⊸⊏ ↕3‿4‿5‿2
 [ [ 2 1 4 0 ] [ 2 1 4 1 ] ]
 

 
The Depth composition

 
The Depth composition (⚇) is a generalization of Each that allows diving deeper into an array. To illustrate it we'll use a shape 4‿3 array of lists of lists.

-
    ⊢ n ← <⎉1⍟2 4‿3‿2‿2⥊↕48
+
    ⊢ n ← <⎉1⍟2 4‿3‿2‿2⥊↕48
 ┌
   [ [ 0 1 ] [ 2 3 ] ]     [ [ 4 5 ] [ 6 7 ] ]     [ [ 8 9 ] [ 10 11 ] ]
   [ [ 12 13 ] [ 14 15 ] ] [ [ 16 17 ] [ 18 19 ] ] [ [ 20 21 ] [ 22 23 ] ]
@@ -125,7 +125,7 @@
                                                                           ┘
 

 
While a negative depth tells how many levels to go down, a non-negative depth gives the maximum depth of the argument before applying the left operand. On a depth-3 array like above, depth 2 is equivalent to ¯1 and depth 1 is equivalent to ¯2. A depth of 0 means to loop until non-arrays are reached, that is, apply pervasively, like a scalar function.

-
    ⟨'a',"bc"⟩ ≍⚇0 ⟨2‿3,4⟩
+
    ⟨'a',"bc"⟩ ≍⚇0 ⟨2‿3,4⟩
 [ [ [ a 2 ] [ a 3 ] ] [ [ b 4 ] [ c 4 ] ] ]
 

 
With a positive operand, Depth doesn't have to use the same depth everywhere. Here, Length is applied as soon as the depth for a particular element is 1 or less, including if the argument has depth 0. For example, it maps over ⟨2,⟨3,4⟩⟩, but not over ⟨11,12⟩, even though these are elements of the same array.

-- 
cgit v1.2.3