#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub(crate) enum ContrastKind {
Treatment,
Poly,
Sum,
Helmert,
Diff,
}
impl ContrastKind {
pub(crate) fn from_name(name: &str) -> Option<Self> {
match name {
"Treatment" => Some(ContrastKind::Treatment),
"Poly" => Some(ContrastKind::Poly),
"Sum" => Some(ContrastKind::Sum),
"Helmert" => Some(ContrastKind::Helmert),
"Diff" => Some(ContrastKind::Diff),
_ => None,
}
}
}
pub(crate) struct Coding {
pub matrix: Vec<Vec<f64>>,
pub suffixes: Vec<String>,
}
impl ContrastKind {
pub(crate) fn coding(&self, levels: &[String], full: bool) -> Coding {
match self {
ContrastKind::Treatment => treatment(levels, full),
ContrastKind::Poly => poly(levels, full),
ContrastKind::Sum => sum(levels, full),
ContrastKind::Helmert => helmert(levels, full),
ContrastKind::Diff => diff(levels, full),
}
}
}
fn treatment(levels: &[String], full: bool) -> Coding {
let k = levels.len();
if full {
let mut matrix = vec![vec![0.0; k]; k];
for (i, row) in matrix.iter_mut().enumerate() {
row[i] = 1.0;
}
let suffixes = levels.iter().map(|l| format!("[{l}]")).collect();
Coding { matrix, suffixes }
} else {
let mut matrix = vec![vec![0.0; k - 1]; k];
for (i, row) in matrix.iter_mut().enumerate().skip(1) {
row[i - 1] = 1.0;
}
let suffixes = levels[1..].iter().map(|l| format!("[T.{l}]")).collect();
Coding { matrix, suffixes }
}
}
#[allow(clippy::needless_range_loop)]
fn sum_contrast(k: usize) -> Vec<Vec<f64>> {
let omit = k - 1;
let mut out = vec![vec![0.0; k - 1]; k];
for i in 0..omit {
out[i][i] = 1.0;
}
for c in out[omit].iter_mut() {
*c = -1.0;
}
out
}
fn sum(levels: &[String], full: bool) -> Coding {
let k = levels.len();
let contrast = sum_contrast(k);
let included = &levels[..k - 1];
if full {
let mut matrix = vec![Vec::with_capacity(k); k];
for (i, row) in matrix.iter_mut().enumerate() {
row.push(1.0);
row.extend_from_slice(&contrast[i]);
}
let mut suffixes = vec!["[mean]".to_string()];
suffixes.extend(included.iter().map(|l| format!("[S.{l}]")));
Coding { matrix, suffixes }
} else {
let suffixes = included.iter().map(|l| format!("[S.{l}]")).collect();
Coding {
matrix: contrast,
suffixes,
}
}
}
#[allow(clippy::needless_range_loop)]
fn helmert_contrast(k: usize) -> Vec<Vec<f64>> {
let mut contr = vec![vec![0.0; k - 1]; k];
for j in 0..k - 1 {
contr[j + 1][j] = (j + 1) as f64;
}
for r in 0..k - 1 {
for c in r..k - 1 {
contr[r][c] = -1.0;
}
}
contr
}
fn helmert(levels: &[String], full: bool) -> Coding {
let k = levels.len();
let contrast = helmert_contrast(k);
if full {
let mut matrix = vec![Vec::with_capacity(k); k];
for (i, row) in matrix.iter_mut().enumerate() {
row.push(1.0);
row.extend_from_slice(&contrast[i]);
}
let mut suffixes = vec!["[H.intercept]".to_string()];
suffixes.extend(levels[1..].iter().map(|l| format!("[H.{l}]")));
Coding { matrix, suffixes }
} else {
let suffixes = levels[1..].iter().map(|l| format!("[H.{l}]")).collect();
Coding {
matrix: contrast,
suffixes,
}
}
}
#[allow(clippy::needless_range_loop)]
fn diff_contrast(k: usize) -> Vec<Vec<f64>> {
let n = k;
let mut contr = vec![vec![0.0; n - 1]; n];
let mut upper_int: Vec<f64> = Vec::new();
for v in 1..n {
for _ in 0..v {
upper_int.push(v as f64);
}
}
let mut idx = 0usize;
for c in 0..n - 1 {
for r in 0..=c {
contr[r][c] = (upper_int[idx] - n as f64) / n as f64;
idx += 1;
}
}
let int_range: Vec<usize> = (1..n).collect();
let rev: Vec<usize> = int_range.iter().rev().cloned().collect();
let mut lower_int: Vec<f64> = Vec::new();
for (v, ×) in int_range.iter().zip(rev.iter()) {
for _ in 0..times {
lower_int.push(*v as f64);
}
}
let mut jdx = 0usize;
for c in 0..n - 1 {
for r in c..n - 1 {
contr[r + 1][c] = lower_int[jdx] / n as f64;
jdx += 1;
}
}
contr
}
fn diff(levels: &[String], full: bool) -> Coding {
let k = levels.len();
let contrast = diff_contrast(k);
if full {
let mut matrix = vec![Vec::with_capacity(k); k];
for (i, row) in matrix.iter_mut().enumerate() {
row.push(1.0);
row.extend_from_slice(&contrast[i]);
}
let suffixes = levels.iter().map(|l| format!("[D.{l}]")).collect();
Coding { matrix, suffixes }
} else {
let suffixes = levels[..k - 1].iter().map(|l| format!("[D.{l}]")).collect();
Coding {
matrix: contrast,
suffixes,
}
}
}
#[allow(clippy::needless_range_loop)]
fn poly(levels: &[String], full: bool) -> Coding {
let n = levels.len();
let mean = (n as f64 - 1.0) / 2.0;
let scores: Vec<f64> = (0..n).map(|i| i as f64 - mean).collect();
let mut raw = vec![vec![0.0; n]; n];
for (i, &s) in scores.iter().enumerate() {
let mut p = 1.0;
for j in 0..n {
raw[i][j] = p;
p *= s;
}
}
let (mut q, rdiag) = mgs_qr(&raw, n);
for j in 0..n {
let s = if rdiag[j] < 0.0 { -1.0 } else { 1.0 };
if s < 0.0 {
for row in q.iter_mut() {
row[j] = -row[j];
}
}
}
for row in q.iter_mut() {
row[0] = 1.0;
}
let names = poly_suffixes(n);
if full {
Coding {
matrix: q,
suffixes: names,
}
} else {
let matrix = q
.into_iter()
.map(|row| row[1..].to_vec())
.collect::<Vec<_>>();
Coding {
matrix,
suffixes: names[1..].to_vec(),
}
}
}
fn poly_suffixes(n: usize) -> Vec<String> {
let base = [".Constant", ".Linear", ".Quadratic", ".Cubic"];
let mut out = Vec::with_capacity(n);
for i in 0..n {
if i < base.len() {
out.push(base[i].to_string());
} else {
out.push(format!("^{i}"));
}
}
out
}
fn mgs_qr(a: &[Vec<f64>], n: usize) -> (Vec<Vec<f64>>, Vec<f64>) {
let cols: Vec<Vec<f64>> = (0..n)
.map(|j| (0..n).map(|i| a[i][j]).collect::<Vec<f64>>())
.collect();
let mut q_cols: Vec<Vec<f64>> = vec![vec![0.0; n]; n];
let mut rdiag = vec![0.0; n];
for j in 0..n {
let mut v = cols[j].clone();
for q_prev in q_cols.iter().take(j) {
let r_ij: f64 = (0..n).map(|i| q_prev[i] * cols[j][i]).sum();
for i in 0..n {
v[i] -= r_ij * q_prev[i];
}
}
let norm: f64 = v.iter().map(|x| x * x).sum::<f64>().sqrt();
rdiag[j] = norm;
for i in 0..n {
q_cols[j][i] = v[i] / norm;
}
}
let mut q = vec![vec![0.0; n]; n];
for j in 0..n {
for i in 0..n {
q[i][j] = q_cols[j][i];
}
}
(q, rdiag)
}