pub mod apo;
pub mod branchswap;
pub mod ccode;
pub mod consensus;
pub mod dataset;
pub mod ie;
pub mod resample;
pub(crate) mod rng;
pub mod search;
pub mod tplot;
pub mod trees;
pub mod util;
pub mod xsteps;
pub mod xx;
use crate::error::Result;
const TREE_BUFFER_LIMIT: usize = 100;
const MHENNIG_REPS: usize = 10;
pub struct Engine;
impl Engine {
pub fn new() -> Self {
Self
}
pub fn hennig(
&self,
ds: &dataset::Dataset,
cfg: &ccode::CharConfig,
multi: bool,
star: bool,
outgroup: usize,
) -> Result<search::SearchOutcome> {
if ds.ntax < 3 {
return Err(crate::error::Error::runtime("hennig: ntax must be >= 3", None, None));
}
if cfg.len() != ds.nchar {
return Err(crate::error::Error::runtime(
format!("hennig: char_config nchar={} != dataset nchar={}", cfg.len(), ds.nchar),
None,
None,
));
}
if outgroup >= ds.ntax {
return Err(crate::error::Error::runtime(
format!("hennig: outgroup {outgroup} out of range for ntax={}", ds.ntax),
None,
None,
));
}
let seed = search::entropy_seed();
if !star {
return Ok(if !multi {
search::hennig(ds, cfg, seed, outgroup)
} else {
search::mhennig_limited(
ds,
cfg,
MHENNIG_REPS,
seed,
outgroup,
Some(TREE_BUFFER_LIMIT),
)
});
}
let reps = if multi { MHENNIG_REPS } else { 1 };
let starts: Vec<crate::engines::trees::Tree> = (0..reps)
.map(|rep| {
let rep_seed = if rep == 0 { seed } else { search::entropy_seed() };
search::hennig(ds, cfg, rep_seed, outgroup).trees.remove(0)
})
.collect();
let swapped: std::result::Result<Vec<_>, String> = std::thread::scope(|scope| {
let handles: Vec<_> = starts
.iter()
.map(|start| {
scope.spawn(move || branchswap::branch_swap_one(ds, cfg, start, outgroup))
})
.collect();
handles
.into_iter()
.map(|h| h.join().map_err(|_| "mhennig*: TBR worker panicked".to_string())?)
.collect()
});
let swapped = swapped.map_err(|m| crate::error::Error::runtime(m, None, None))?;
let mut trees = Vec::new();
let mut seen = std::collections::BTreeSet::new();
let mut best_len = u64::MAX;
for (mut tree, len) in swapped {
tree.canonicalize();
if len < best_len {
best_len = len;
trees.clear();
seen.clear();
}
if len == best_len {
let key = tree.to_storage_string();
if seen.insert(key) {
trees.push(tree);
}
}
}
Ok(search::search_outcome(ds, cfg, trees, best_len))
}
pub fn bb(
&self,
ds: &dataset::Dataset,
cfg: &ccode::CharConfig,
start_trees: &[crate::engines::trees::Tree],
outgroup: usize,
star: bool,
) -> Result<(Vec<crate::engines::trees::Tree>, u64)> {
let keep_limit = if star { None } else { Some(TREE_BUFFER_LIMIT) };
let (trees, best_len) =
branchswap::branch_break_closure(ds, cfg, start_trees, outgroup, keep_limit)
.map_err(|m| crate::error::Error::runtime(m, None, None))?;
Ok((trees, best_len))
}
pub fn ie(
&self,
ds: &dataset::Dataset,
cfg: &ccode::CharConfig,
outgroup: usize,
mode: ie::IeMode,
) -> Result<ie::IeOutcome> {
let out = ie::ie_exact(ds, cfg, outgroup, mode)
.map_err(|m| crate::error::Error::runtime(m, None, None))?;
Ok(out)
}
pub fn nelsen_consensus(
&self,
ds: &dataset::Dataset,
cfg: &ccode::CharConfig,
trees: &[crate::engines::trees::Tree],
outgroups: &[usize],
) -> Result<consensus::ConsensusOutcome> {
crate::engines::consensus::nelsen_consensus(ds, cfg, trees, outgroups)
.map_err(|m| crate::error::Error::runtime(m, None, None))
}
}