librarylibs/Kit/src/Kit.xtl

u̲niform (seed, n): n Floats in [0, 1), each a function of the seed and its place: the Park-Miller sequence x -> 16807 x mod (2^31 - 1) started from 1 + |seed| mod (2^31 - 2) (so seed 0 is a seed like any other and no seed is the sequence's fixed point 0), divided by 2^31 - 1. The same seed gives the same numbers in any run.

      "kt:" u̲se< "Kit"

      ᵏᵗu̲niform (42, 3)
0.00033653387815530127 0.6561248901561484 0.4910288543864288

n̲ormal (seed, n): n Floats from the standard normal distribution (mean 0, standard deviation 1), by Box and Muller from 2n uniform numbers of the seed.

      "kt:" u̲se< "Kit"

      ᵏᵗn̲ormal (42, 2)
-0.025904525013204074 -0.2561352551643429

n̲ormals (seed, rows, cols): a rows by cols matrix of standard normal numbers of the seed.

f̲lat (seed, k, n, d, spread): k Gaussian clusters of n points each in d dimensions: the k centers are standard normal numbers of the seed scaled by 4 (so clusters sit a few units apart), and each point is its center plus spread times a standard normal vector; (X, y), X of k n rows and y the cluster of each row, 1 to k, in order. The structure is flat: straight-line distance is the right one, and a point's nearest neighbors are mostly its own cluster when spread is well under the centers' spacing.

      "kt:" u̲se< "Kit"

      (X, y) ← ᵏᵗf̲lat (1, 2, 2, 2, 0.1)

      y
1 1 2 2

      s̲hape X
4 2

n e̲ach v: every item of v repeated n times, in order (a general word, written out until GL2 lands).

d̲irections (seed, k, n, cone): k classes of n points in three dimensions that differ by direction and not by length: each class has a direction (a seeded standard normal vector put onto the unit sphere) and each point is that direction plus cone times a standard normal vector, put back onto the sphere, then scaled by a length drawn between 0.5 and 2 (uniform), so the lengths carry nothing about the class; (X, y). The structure is directional: the angle between points is the right distance, and their straight-line distance mixes in the lengths.

      "kt:" u̲se< "Kit"

      (X, y) ← ᵏᵗd̲irections (7, 2, 2, 0.1)

      y
1 1 2 2

      s̲hape X
4 3

s v s̲caleRows M: each row of M scaled by the matching item of s.

t̲ree (depth, branching): the edges of a rooted tree in which every node but the leaves has branching children and every leaf is depth edges from the root: node 1 is the root and the nodes are numbered level by level, so node i's children are the nodes branching (i - 1) + 2 up to branching i + 1. The edges as Graphs takes them: two rows, from (the parent) over to (the child). Depth 4 and branching 2 give 31 nodes and 30 edges.

      "kt:" u̲se< "Kit"

      ᵏᵗt̲ree (2, 2)
1 1 2 2 3 3
2 3 4 5 6 7

The number of nodes of the tree: 1 + b + b^2 + ... + b^depth.

t̲reeDistances (depth, branching): the distance between every two nodes of the tree along it (the number of edges on the one path between them), by Graphs' shortest paths over the tree's edges taken both ways: an n by n matrix of Floats, 0 on the diagonal, 2 depth at most (leaf to leaf through the root).

      "kt:" u̲se< "Kit"

      ᵏᵗt̲reeDistances (1, 2)
0.0 1.0 1.0
1.0 0.0 2.0
1.0 2.0 0.0

t̲reeClasses (depth, branching): the class of each node, its branch: the child of the root it descends from, 1 to branching; the root itself, which is under no branch, is given class 1 (and a classifier is excused it: it is alone). So the hierarchical set's labels, one per node.

      "kt:" u̲se< "Kit"

      ᵏᵗt̲reeClasses (2, 2)
1 1 2 1 1 2 2

parent u̲p c: the parent of node c, unless that is the root (or c is), in which case c: one step up the tree that stops under the root.

t̲reeLayout (depth, branching): a plain picture of the tree in the plane, one row (x, y) per node: the root at the origin, each level a circle of radius its depth, the nodes of a level spread evenly round it in their order, so that each subtree is a wedge (the two children of the root at the top and the bottom, their x cos of a quarter turn, 0 up to the machine's rounding). It is a layout, not an embedding that keeps the tree's distances: the straight-line distance between two nodes of this picture is a poor copy of their distance along the tree (two leaves of neighboring branches are near in the picture and 2 depth apart in the tree), which is what the baseline measures.

      "kt:" u̲se< "Kit"

      ᵏᵗt̲reeLayout (1, 2)
                                0.0  0.0
 0.00000000000000006123233995736766  1.0
-0.00000000000000018369701987210297 -1.0