DOC: Use box drawing art for illustrating an example for ArrayView::split_at

This is a proof of concept.

Box drawings are relatively easy to produce, easy to distribute and
maintain in all places rustdoc renders, readable in plain text and
when rendered, and they have a consistent style.

The biggest positive is that it enables us to produce many
illustrations.

They have the drawback that they restrict us to mostly 2-D (but that makes
for easier to understand illustrations anyway), and it doesn't look very
impressive.

Author: bluss

src/impl_views.rs

@@ -123,11 +123,74 @@ where
     /// split and one view after the split.
     ///
     /// **Panics** if `axis` or `index` is out of bounds.
+    /// 
+    /// **Examples:**
+    /// ```rust
+    /// # use ndarray::prelude::*;
+    /// let a = array![[0, 1, 2, 3],
+    ///                [4, 5, 6, 7],
+    ///                [8, 9, 0, 1]];
     ///
-    /// Below, an illustration of `.split_at(Axis(2), 2)` on
-    /// an array with shape 3 × 5 × 5.
+    /// ```
+    /// The array `a` has two axes and shape 3 × 4:
+    /// ```text
+    ///          ─> Axis(1)
+    ///         ┌───┬───┬───┬───┐  0
+    ///       │ │ 0 │ 1 │ 2 │ 3 │
+    ///       v ├───┼───┼───┼───┤  1
+    ///  Axis(0)│ 4 │ 5 │ 6 │ 7 │
+    ///         ├───┼───┼───┼───┤  2
+    ///         │ 8 │ 9 │ 0 │ 1 │
+    ///         └───┴───┴───┴───┘  3 ↑
+    ///         0   1   2   3   4  ← possible split_at indices.
+    /// ```
+    ///
+    /// Row indices increase along `Axis(0)`, and column indices increase along
+    /// `Axis(1)`. Note that we split “before” an element index, and that
+    /// both 0 and the endpoint are valid split indices.
+    ///
+    /// **Example 1**: Split `a` along the first axis, in this case the rows, at
+    /// index 1.<br>
+    /// This produces views v1 and v2 of shapes 1 × 4 and 2 × 4:
+    /// 
+    /// ```rust
+    /// # use ndarray::prelude::*;
+    /// # let a = Array::from_elem((3, 3), 0);
+    /// let (v1, v2) = a.view().split_at(Axis(0), 1);
+    /// ```
+    /// ```text
+    ///         ┌───┬───┬───┬───┐       0  ↓ indices
+    ///       │ │ 0 │ 1 │ 2 │ 3 │ v1
+    ///       v └───┴───┴───┴───┘       1
+    ///  Axis(0)┌───┬───┬───┬───┐        
+    ///         │ 4 │ 5 │ 6 │ 7 │
+    ///         ├───┼───┼───┼───┤ v2    2
+    ///         │ 8 │ 9 │ 0 │ 1 │
+    ///         └───┴───┴───┴───┘       3
+    /// ```
+    /// 
+    /// **Example 2**: Split `a` along the second axis, in this case the
+    /// columns, at index 2.<br>
+    /// This produces views u1 and u2 of shapes 3 × 2 and 3 × 2:
+    ///
+    /// ```rust
+    /// # use ndarray::prelude::*;
+    /// # let a = Array::from_elem((3, 3), 0);
+    /// let (u1, u2) = a.view().split_at(Axis(1), 2);
     ///
-    /// <img src="https://rust-ndarray.github.io/ndarray/images/split_at.svg" width="300px" height="271px">
+    /// ```
+    /// ```text
+    ///             u1        u2
+    ///         0   1    2    3   4  indices →
+    ///         ┌───┬───┐ ┌───┬───┐
+    ///         │ 0 │ 1 │ │ 2 │ 3 │
+    ///         ├───┼───┤ ├───┼───┤
+    ///         │ 4 │ 5 │ │ 6 │ 7 │
+    ///         ├───┼───┤ ├───┼───┤
+    ///         │ 8 │ 9 │ │ 0 │ 1 │
+    ///         └───┴───┘ └───┴───┘
+    ///          ─> Axis(1)
+    /// ```
     pub fn split_at(self, axis: Axis, index: Ix) -> (Self, Self) {
         unsafe {
             let (left, right) = self.into_raw_view().split_at(axis, index);