I would like to label the columns and rows of a matrix (e.g. I, J, K, L and M) and ideally also provide an overall label for the rows (winner) and the columns (loser).
The corresponding functionality (at least for the column and row labels) seems to be in LaTeX through a variety of packages, e.g. matrices - Matrix with rows and columns labeled - TeX - LaTeX Stack Exchange
You may use table to recreate the matrix structure.
$
#table(
columns: (auto,)+(3pt,)+(auto,)*5+(3pt,),
stroke: none,
align: (right + horizon,) + (center + horizon,)*7,
[],[], $I$, $J$, $K$, $L$, $M$, [],
$I$, table.cell(rowspan: 5, box(stroke: none, inset: (top: -0.5em), $lr("[", size: #875%)$)), $0$, $1$, $0$, $1$, $0$, table.cell(rowspan: 5, box(stroke: none, inset: (top: -0.5em), $lr("]", size: #875%)$)),
$J$, $0$, $0$, $1$, $0$, $1$,
[winner $K$], $1$, $0$, $0$, $1$, $1$,
$L$, $0$, $1$, $0$, $0$, $0$,
$M$, $0$, $0$, $0$, $1$, $0$,
)
$
I don’t know a method that can automatically adjust the size of delimiters.
Thanks for this solution; it does add the ‘winner’ but not the ‘loser’ (but presumably I could do that above the ‘K’ somehow).
It hadn’t occurred to me that I would be able to get the delimiters using a table but your solution is interesting and I could possibly adapt it so the size is calculated programmatically.
There is another solution using the pin-it package. Please check out my reply How to input an excess matrix, where elements "overflow" the parentheses? - #7 by Fe_Y.
Going off of @Fe_Y’s code, you might dynamically set the delimiter height with an approach like this:
#let labelmat(
collabels,
rowlabels,
..args
) = context {
let numcols = collabels.len()
let numrows = rowlabels.len()
let matentries = args.pos().chunks(numcols)
let matheight = matentries.map(
row => calc.max(..row.map(i => measure(i).height))
).sum() + 10pt * numrows
let delimcell(delim) = table.cell(
rowspan: numrows,
box(inset: (top: -5pt, left: -5pt), $lr(delim, size: #matheight)$)
)
table(
columns: (auto, 7pt, ..(auto,) * numcols, 7pt),
stroke: none,
..args.named(),
[], [], ..collabels, [],
..for (rowindx, (rowlab, rowentries)) in rowlabels.zip(matentries).enumerate() {(
rowlab,
..if rowindx == 0 {(delimcell($\[$),)},
..rowentries,
..if rowindx == 0 {(delimcell($\]$),)},
)},
)
}
#labelmat(
("a", "b", "c"),
("d", "e", "f"),
$alpha_r display(beta_s / delta)$, $0$, $1$,
$1$, $2$, $display(sum_2^n i^2)$,
$1$, $2$, $3$,
align: center + horizon
)
Here is an alternate solution using mannot.
First we define a helper function that marks every matrix element with mannot.mark. This allows us to annotate any matrix element.
Then we define annotations for the top row and leftmost column elements.
#import "@preview/mannot:0.3.0" as mannot: mark, annot
/// Like math.mat but mark every element of the matrix with the
/// label `tagij` where `i` and `j` are 1-based row and column indexes respectively.
/// The separator between `tag`, `i` and `j` is configured by `tagsep`.
///
/// Every element is marked using the function `mark`, which is `mannot.mark` by default.
#let markmat(..args, tag: <mat>, tagsep: "", mark: mark) = {
let mktag(i, j) = label(str(tag) + tagsep + str(i + 1) + tagsep + str(j + 1))
math.mat(
..args.named(),
..args.pos().enumerate().map(((i, arr)) => {
arr.enumerate().map(((j, elt)) => mark(elt, tag: mktag(i, j)))
}))
}
$
markmat(
delim: "[",
0, 1, 0, 1, 0;
0, 0, 1, 0, 1;
1, 0, 0, 1, 1;
0, 1, 0, 0, 0;
0, 0, 0, 1, 0;
tag: #<m>)
#let m = ((..args) => label(args.pos().map(str).join())).with("m")
#let leftannot = annot.with(pos: left, dx: -0.85em, leader: false)
#let topannot = annot.with(pos: top, dy: -0.40em, leader: false)
#for (i, txt) in "IJKLM".codepoints().enumerate(start: 1) {
leftannot(m(i, 1))[#txt]
topannot(m(1, i))[#txt]
}
#topannot(m(1, 3), dy: -1.5em)[loser]
#leftannot(m(3, 1), dx: -2em)[winner]
$
This markmat function is so useful that it might be a good candidate for inclusion into mannot itself? Or can be copied as needed.
What about this:
#import "@preview/mannot:0.3.1": *
#let labelmat(..args, dx:2em, dy:1em) = {
let mat = args.pos().at(0)
let labels = args.pos().slice(1)
let data = ()
let augment = (:)
if mat.has("augment") {
augment = mat.augment
if augment.at("stroke") == auto {
let _ = augment.remove("stroke")
}
}
let nrows = mat.rows.len()
let ncols = mat.rows.at(1).len()
if labels.len() != nrows + ncols {
panic("Number of labels must be equal to number of rows plus number of columns")
}
for i in range(nrows) {
let row = ()
for j in range(ncols) {
let elem = mat.rows.at(i).at(j)
if i == 0 {
elem = mark(elem, tag:label("c" + str(j)))
}
if j == 0 {
elem = mark(elem, tag:label("r" + str(i)))
}
row.push(elem)
}
data.push(row)
}
std.math.mat(augment:augment, ..data)
for i in range(nrows) {
annot(label("r" + str(i)), pos:center, dx:-dx, leader:false, labels.at(i))
}
for j in range(ncols) {
annot(label("c" + str(j)), pos:center, dy:-dy, leader:false, labels.at(nrows+j))
}
}
$
labelmat(
mat( augment:#(hline:4, vline:4),
1215.542, -357.771, -715.542, 357.771, -500.000, 0.000, 0.000, 0.000;
-357.771, 178.885, 357.771, -178.885, 0.000, 0.000, 0.000, 0.000;
-715.542, 357.771, 2146.625, -357.771, -715.542, -357.771, -715.542, 357.771;
357.771, -178.885, -357.771, 536.656, -357.771, -178.885, 357.771, -178.885;
-500.000, 0.000, -715.542, -357.771, 1215.542, 357.771, 0.000, 0.000;
0.000, 0.000, -357.771, -178.885, 357.771, 178.885, 0.000, 0.000;
0.000, 0.000, -715.542, 357.771, 0.000, 0.000, 715.542, -357.771;
0.000, 0.000, 357.771, -178.885, 0.000, 0.000, -357.771, 178.885 ),
f_(1x), f_(1y), f_(2x), f_(2y), f_(3x), f_(3y), f_(4x), f_(4y),
u_(1x), u_(1y), u_(2x), u_(2y), u_(3x), u_(3y), u_(4x), u_(4y),
dx:#{3.6em}, dy:#{1.3em},
)
mat( augment:#(hline:4), u_(1x); u_(1y); u_(2x); u_(2y); 0; 0; 0; 0 )
= mat( augment:#(hline:4), 0; -1; 0; -1; f_(3x); f_(3y); f_(4x); f_(4y) )
$
