X_eTaL documentation

Files

library libs/Kit/src/Kit.xtl: Kit: the experiment kit's data sets, each with a known structure and made from its own seed: flat (Gaussian clusters), directional (classes that differ by direction, not length) and hierarchical (a tree, its distances along the tree, a class per branch, and a plain layout of it in the plane); and the seeded numbers they are made of. Import it with an alias of your choice: "kt:" u_se< "Kit". Put libs/Kit/src on XETAL_PATH ("just path"); the reference is libs/Kit/docs. Names with l: are exported; those under h: are private to this file.
library libs/Manifold/src/Manifold.xtl: Manifold: the unit sphere, the Poincare ball, and the pictures of the circle, the sphere, the torus and the Swiss roll: the distance measured along the space, putting a point onto it, the tangent part of a vector at a point, a step from a point along a tangent vector that stays on the space and the arrow that undoes it, a mean that stays on the space, how far off it a point is; the points of each space at given coordinates of its map, for drawing it; and the distortion of an embedding's distances against those it should keep. Import it with an alias of your choice: "mf:" u_se< "Manifold". Put libs/Manifold/src on XETAL_PATH ("just path"); the reference is libs/Manifold/docs. Names with l: are exported; those under h: are private to this file.
library work/xetal-libraries/libs/Trig/src/Trig.xtl: Trig: trigonometric and hyperbolic functions not in the base language, written in closed form from its builtins (s_in, c_os, a_tan, s_qrt, e_xp, e_xpm1, l_og, l_og1p). The hyperbolic tangent is the builtin t_anh; Trig keeps no copy of it. Import it with an alias of your choice: "tr:" u_se< "Trig". Put libs/Trig/src on XETAL_PATH ("just path"); the reference is libs/Trig/docs. Names with l: are exported; those under h: are private to this file.
library work/xetal-libraries/libs/Graphs/src/Graphs.xtl: Graphs: graphs as adjacency matrices -- from edges, degrees, reachability, shortest paths, breadth-first levels, connected components. Import it with an alias of your choice: "g:" u_se< "Graphs". Put libs/Graphs/src on XETAL_PATH ("just path"); the reference is libs/Graphs/docs. Names with l: are exported; those under h: are private to this file.
macro library work/xetal-libraries/libs/Graphs/src/Graphs.xtlm: Graphs: its macro library -- g_raph<, a graph written by its names. Imported with the functions, under one alias: "g:" u_se< "Graphs". A macro is a function from the source text written left and right of its call to the source that replaces the call, run before the program is compiled (X_eTaL MC10). Names with m: are macros; those under h: are private to this file.
system macros std/System.xtlm: The system macros (lang-choices MC18, MC19, MC24), loaded before every file with no import and no alias: each is called unprefixed, as "c" i_f< "a; b". A macro is a function of the source text on each side of its call; the text it gives replaces the call. @ on a side means the macro takes nothing there (MC22). What only the compiler knows comes from hooks (MC20), usable only in a macro body.
program libs/Kit/demos/example.xtl
program libs/Manifold/demos/sphere.xtl
program libs/Manifold/demos/tour.xtl
program demos/baseline-knn/baseline-knn.xtl: Baseline, nearest neighbors: k nearest neighbors under the straight-line distance on the three data sets of the kit (flat clusters, directions, a tree), each split the same seeded way, the held-out accuracy and the cost of each run recorded as the experiment schema says; and for the tree, how badly a plain layout of it keeps its distances. The row every comparison of H1 is set against: no geometry chosen yet.
library work/xetal-ml/libs/Learn/src/Learn.xtl: Learn: classic machine learning: k-means, k nearest neighbors, PCA, logistic regression
library work/xetal-ml/libs/NN/src/NN.xtl: NN: neural-network building blocks -- softmax by row, dense layers, one-hot, loss, accuracy
library work/xetal-libraries/libs/Check/src/Check.xtl: Check: assertions that report as text, for tests and teaching. Import it with an alias of your choice: "ch:" u_se< "Check". Put libs/Check/src on XETAL_PATH ("just path"); the reference is libs/Check/docs. Names with l: are exported; those under h: are private to this file.
macro library work/xetal-libraries/libs/Check/src/Check.xtlm: Check: its macro library -- c_ases<, table-driven checks named by their own source text. Imported with the functions, under one alias: "ch:" u_se< "Check". A macro is a function from the source text written left and right of its call to the source that replaces the call, run before the program is compiled (X_eTaL MC10). Names with m: are macros; those under h: are private to this file.
program demos/manifold-tour/manifold-tour.xtl: Manifold tour: five spaces this repository's experiments live on, the circle, the sphere, the torus, the Swiss roll and the Poincare disk, each drawn from its map (its own coordinates) into the space around it, and on each one measurement of what a manifold is: two points near each other are nearly as far apart along the space as through it (locally flat), two points far apart are not; on the roll, near through the air can be far along the sheet; on the disk, near the rim a small step on paper is a long way. Nothing is trained.
program demos/sphere-hello/sphere-hello.xtl: Sphere hello: a handful of points on the unit sphere. Two ways to measure how far apart two of them are, the straight line through the sphere and the great circle along it, order every point's neighbors the same way; and the plain average of the points is not on the sphere, where the mean along it is.

Items

name	kind	type
ˡu̲niform	function	`(Int, Int) -> Float`
ˡn̲ormal	function	`(Int, Int) -> Float`
ʰn̲ormals	function	`(Int, Int, Int) -> Float`
ˡf̲lat	function	`Num a => (Int, Int, Int, Int, a) -> (Float, Int)`
ʰe̲ach	function	`Int -> Int -> Int`
ˡd̲irections	function	`Num a => (Int, Int, Int, a) -> (Float, Int)`
ʰs̲caleRows	function	`Float -> Float -> Float`
ˡt̲ree	function	`(Int, Int) -> Int`
ʰn̲odes	function	`(Int, Int) -> Int`
ˡt̲reeDistances	function	`(Int, Int) -> Float`
ˡt̲reeClasses	function	`(Int, Int) -> Int`
ʰu̲p	function	`Int -> Int -> Int`
ˡt̲reeLayout	function	`(Int, Int) -> Float`
ʰd̲ot	function	`(Num a, Num b) => a -> b -> Float`
ʰn̲orm	function	`Num a => a -> Float`
ʰs̲caleRows	function	`Num a => a -> a -> a`
ʰa̲ngle	function	`(Num a, Num b) => a -> b -> Float`
ʰa̲part	function	`(Num a, Num b) => a -> b -> (Float, Float)`
ʰa̲partRows	function	`(Num a, Num b) => a -> b -> (Float, Float)`
ʰa̲partPairs	function	`Num a => a -> (Float, Float)`
ˡs̲phereProject	function	`Num a => a -> Float`
ʰp̲rojectRows	function	`Num a => a -> Float`
ˡs̲phereDistance	function	`(Num a, Num b) => a -> b -> Float`
ˡs̲phereDistances	function	`Num a => a -> Float`
ˡs̲phereTangent	function	`(Num a, Num b) => a -> b -> Float`
ˡs̲phereStep	function	`(Num a, Num b) => a -> b -> Float`
ˡs̲phereArrow	function	`(Num a, Num b) => a -> b -> Float`
ʰa̲rrows	function	`(Num a, Num b) => a -> b -> Float`
ˡs̲phereMean	function	`Num a => a -> Float`
ˡs̲phereOff	function	`Num a => a -> Float`
ʰc̲oordinate	function	`Num a => Int -> a -> Float`
ʰc̲olumns	function	`Int -> a -> a`
ˡs̲pherePoints	function	`Num a => a -> Float`
ˡs̲phereArc	function	`(Num a, Num b) => (a, b) -> Int -> Float`
ˡc̲irclePoints	function	`Num a => a -> Float`
ˡt̲orusPoints	function	`(Num a, Num b) => a -> b -> Float`
ˡt̲orusOff	function	`(Num a, Num b) => a -> b -> Float`
ˡr̲ollPoints	function	`Num a => a -> Float`
ˡr̲ollAlong	function	`Num a => a -> Float`
ˡr̲ollDistance	function	`(Num a, Num b) => a -> b -> Float`
ʰm̲obius	function	`(Num a, Num b) => a -> b -> Float`
ˡb̲allDistance	function	`(Num a, Num b) => a -> b -> Float`
ˡb̲allGeodesic	function	`(Num a, Num b) => (a, b) -> Int -> Float`
ˡd̲istortion	function	`(Num a, Num b) => a -> b -> Float`
ʰq̲uarter	function	`Unit -> Float`
ˡt̲an	function	`Num a => a -> Float`
ˡa̲sin	function	`Num a => a -> Float`
ˡa̲cos	function	`Num a => a -> Float`
ˡa̲tan2	function	`(Num a, Num b) => a -> b -> Float`
ʰp̲ick	function	`Float -> Float -> Float -> Float`
ʰs̲ign	function	`Float -> Float`
ʰb̲ig	function	`Any a => a -> Float`
ʰh̲alfExp	function	`Float -> Float`
ˡs̲inh	function	`Num a => a -> Float`
ˡc̲osh	function	`Num a => a -> Float`
ʰh̲uge	function	`Any a => a -> Float`
ʰl̲ogTwice	function	`Num a => a -> Float`
ˡa̲sinh	function	`Num a => a -> Float`
ˡa̲cosh	function	`Num a => a -> Float`
ˡa̲tanh	function	`Num a => a -> Float`
ˡd̲egrees	function	`Num a => a -> Float`
ˡr̲adians	function	`Num a => a -> Float`
ˡh̲ypot	function	`(Num a, Num b) => a -> b -> Float`
far	value	`Float`
ˡa̲djacency	function	`(Num a, Truthy a) => Int -> Int -> a`
ˡw̲eighted	function	`Int -> Int -> Int`
ˡu̲ndirected	function	`(Truthy a, Truthy b) => a -> b`
ˡo̲utDegree	function	`Num a => a -> a`
ˡi̲nDegree	function	`Num a => a -> a`
ʰc̲lose	function	`Truthy a => a -> a`
ˡr̲each	function	`(Num a, Truthy b) => a -> b`
ʰr̲elax	function	`Num a => a -> a`
ˡs̲hortest	function	`Num a => a -> Float`
ʰb̲fs	function	`(Num a, Truthy a) => a -> a -> a -> a -> a -> a`
ˡl̲evels	function	`Int -> Int -> Int`
ˡc̲omponents	function	`Truthy a => a -> Int`
ʰr̲aze	function	`Box a -> a`
ʰp̲aths	function	`Char -> Box (Box Char)`
ᵐg̲raph<	macro	`Char -> Char -> Char`
ˢu̲se<	built-in macro	`Char -> Char -> Unit`
ˢi̲f<	macro	`Char -> Char -> Char`
ˢu̲nless<	macro	`Char -> Char -> Char`
ˢe̲ach<	macro	`Char -> Char -> Char`
ˢl̲ine<	macro	`Unit -> Unit -> Char`
ˢf̲ile<	macro	`Unit -> Unit -> Char`
ˢi̲nclude<	macro	`Unit -> Char -> Char`
ˢc̲fg<	macro	`Unit -> Char -> Char`
ˢe̲rror<	macro	`Char -> Char -> Char`
ˢd̲bg<	macro	`Unit -> Char -> Char`
ˢa̲ssert<	macro	`Char -> a -> Char`
ˢf̲ormat<	macro	`Unit -> Char -> Char`
ˢp̲anic<	macro	`Unit -> Char -> Char`
ˢt̲odo<	macro	`Unit -> Char -> Char`
ˢt̲ry<	macro	`Char -> Char -> Char`
ˢc̲atch<	macro	`Char -> Char -> Char`
ˢf̲inally<	macro	`Char -> Char -> Char`
ˢr̲ecover<	macro	`Unit -> Char -> Char`
ˢr̲etry<	macro	`Unit -> Unit -> Char`
ˢh̲alt<	macro	`Unit -> Unit -> Char`
ˢc̲ontinue<	macro	`Unit -> Unit -> Char`
catchCodes	value	`Char`
ʰm̲atchCode	function	`Char -> Char`
ifArgs	value	`Char`
eachAlone	value	`Char`
eachHole	value	`Char`
ʰt̲rim	function	`Char -> Char`
ʰw̲ords	function	`Char -> Box Char`
ʰs̲eps	function	`Truthy a => Char -> a`
ʰh̲oles	function	`(Num a, Truthy a) => Char -> a`
ʰj̲oin	function	`Box Char -> Char`
ʰq̲uote	function	`Char -> Char`
ʰc̲opy	function	`Char -> Char -> Char`
ʰw̲hy	function	`Char -> Char`
ʰo̲rEmpty	function	`Char -> Char`
ʰl̲it	function	`Char -> Char`
ʰc̲j	function	`Char -> Char -> Char`
ʰp̲ieces	function	`Char -> Char`
X	value	`Float`
y	value	`Int`
D	value	`Float`
c	value	`Int`
P	value	`Float`
p	value	`Float`
q	value	`Float`
v	value	`Float`
m	value	`Float`
Pi	value	`Float`
near	value	`Float`
far	value	`Float`
a	value	`Float`
b	value	`Float`
W	value	`Float`
ᵘs̲plit	function	`(Int, Int) -> (Int, Int)`
ᵘr̲un	function	`(Float, Int, Int, Int) -> Float`
ᵘc̲ompare	function	`(Num a, Num b) => a -> b -> Float`
ᵘc̲hords	function	`Float -> Float`
k	value	`Int`
splitSeed	value	`Int`
F	value	`Float`
fy	value	`Int`
flat	value	`Float`
F5	value	`Float`
f5y	value	`Int`
flat5	value	`Float`
D	value	`Float`
dy	value	`Int`
directions	value	`Float`
unit	value	`Float`
T	value	`Float`
L	value	`Float`
ty	value	`Int`
tree	value	`Float`
distortion	value	`Float`
ʰd̲ist	function	`Float -> Float -> Float`
ʰo̲nes	function	`Float -> Float`
ˡa̲ssign	function	`Float -> Float -> Int`
ˡk̲step	function	`Float -> Float -> Float`
ˡi̲nertia	function	`Float -> Float -> Float`
ˡf̲arthest	function	`Int -> Float -> Float`
ˡk̲means	function	`(Int, Int) -> Float -> Float`
ˡk̲nn	function	`(Int, Float, Int) -> Float -> Int`
ˡp̲ca	function	`Int -> Float -> (Float, Float, Float)`
ˡp̲roject	function	`(Num a, Any b) => (a, a, b) -> a -> a`
ˡl̲ogistic	function	`(Int, Float) -> (Float, Int) -> Float`
ˡp̲redict	function	`Num a => a -> a -> Int`
ʰs̲pread	function	`a -> b -> a`
ʰr̲ows	function	`a -> a`
ˡs̲oftmax	function	`Num a => a -> Float`
ˡl̲ogSoftmax	function	`Float -> Float`
ˡd̲ense	function	`Num a => a -> a -> a`
ˡa̲ddAxis	function	`Num a => (Int, a) -> a -> a`
ʰa̲xisChecked	function	`Num a => (Int, a) -> Int -> Char`
ˡb̲ias	function	`Num a => a -> a -> a`
ˡa̲rgmax	function	`Num a => a -> Int`
ˡo̲neHot	function	`Int -> Int -> Float`
ˡc̲rossEntropy	function	`Float -> Float -> Float`
ˡm̲se	function	`Float -> Float -> Float`
ˡa̲ccuracy	function	`Num a => Int -> a -> Float`
ʰn̲l	function	`Unit -> Char`
ʰo̲neLine	function	`Char -> Char`
ʰs̲hown	function	`a -> Char`
ʰf̲ail	function	`a -> b -> Char`
ˡi̲s	function	`Match a => a -> a -> Char`
ˡn̲ear	function	`Num a => a -> a -> Char`
ˡt̲rue	function	`Truthy a => a -> Char`
ˡt̲est	function	`Char -> Char -> Char`
ˡa̲nd	function	`Char -> Char -> Char`
ˡc̲ount	function	`Char -> Int`
ˡf̲ailures	function	`Char -> Int`
ˡp̲assed?	function	`Truthy a => Char -> a`
ˡr̲eport	function	`Char -> Char`
bs	value	`Char`
dq	value	`Char`
ʰe̲scaped	function	`Char -> Char`
ʰr̲ow?	function	`Truthy a => Char -> a`
ʰc̲heck	function	`Char -> Char -> Char`
ᵐc̲ases<	macro	`Char -> Char -> Char`
Pi	value	`Float`
deg	value	`Float`
ᵘp̲airs	function	`(Num a, Num b) => a -> b -> Float`
ᵘr̲ound	function	`Int -> Float`
ᵘe̲ach	function	`Int -> a -> a`
ᵘt̲imes	function	`Int -> a -> a`
ᵘl̲ength	function	`Float -> Float`
ᵘs̲traight	function	`(Num a, Num b) => a -> b -> Float`
ᵘt̲wo	function	`Num a => a -> Float`
ᵘl̲onLat	function	`Num a => a -> Float`
circleAngles	value	`Float`
circle	value	`Float`
circleNearA	value	`Float`
circleFarA	value	`Float`
circleNear	value	`Float`
circleFar	value	`Float`
circleNearD	value	`Float`
circleFarD	value	`Float`
parallelLL	value	`Float`
meridianLL	value	`Float`
parallels	value	`Float`
meridians	value	`Float`
sphereDeg	value	`Float`
sphereLL	value	`Float`
spherePts	value	`Float`
sphereNearD	value	`Float`
sphereFarD	value	`Float`
sphereNearArc	value	`Float`
sphereFarArc	value	`Float`
sphereNearArcLL	value	`Float`
sphereFarArcLL	value	`Float`
workedDiff	value	`Float`
workedSq	value	`Float`
workedSum	value	`Float`
workedPlus	value	`Float`
radii	value	`Float`
torusRingsUV	value	`Float`
torusTubesUV	value	`Float`
torusRings	value	`Float`
torusTubes	value	`Float`
torusRimLengths	value	`Float`
rollT	value	`Float`
rollAlongTH	value	`Float`
rollAcrossTH	value	`Float`
rollAlong	value	`Float`
rollAcross	value	`Float`
rollAlongMap	value	`Float`
rollAcrossMap	value	`Float`
rollTH	value	`Float`
rollPts	value	`Float`
rollMap	value	`Float`
rollNearD	value	`Float`
rollFarD	value	`Float`
rim	value	`Float`
ruler	value	`Float`
rulerD	value	`Float`
diskFar	value	`Float`
diskNear	value	`Float`
diskFarD	value	`Float`
diskNearD	value	`Float`
diskFarGeo	value	`Float`
diskNearGeo	value	`Float`
geo1	value	`Float`
geo2	value	`Float`
geo3	value	`Float`
dims	value	`Float`
P	value	`Float`
ᵘc̲hords	function	`Float -> Float`
chord	value	`Float`
arc	value	`Float`
ᵘo̲rders	function	`Ord a => a -> Int`
byChord	value	`Int`
byArc	value	`Int`
plain	value	`Float`
onSphere	value	`Float`