use solow_core::{Error, Result};
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Clone, Debug, PartialEq, Eq)]
pub struct Split {
pub train: Vec<usize>,
pub test: Vec<usize>,
}
pub trait Splitter {
fn n_splits(&self, n: usize) -> Result<usize>;
fn split(&self, n: usize) -> Result<Vec<Split>>;
}
fn lcg_next(state: &mut u64) -> u64 {
*state = state
.wrapping_mul(6_364_136_223_846_793_005)
.wrapping_add(1_442_695_040_888_963_407);
*state
}
fn shuffle_indices_in_place(idx: &mut [usize], seed: u64) {
let mut state = seed.wrapping_add(0x9E37_79B9_7F4A_7C15);
for i in (1..idx.len()).rev() {
let range = (i as u64) + 1;
let max = u64::MAX - (u64::MAX % range);
let mut r = lcg_next(&mut state);
while r >= max {
r = lcg_next(&mut state);
}
let j = (r % range) as usize;
idx.swap(i, j);
}
}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Clone, Debug)]
pub struct KFold {
n_splits: usize,
shuffle: bool,
seed: u64,
}
impl KFold {
pub fn new(n_splits: usize) -> Result<Self> {
if n_splits < 2 {
return Err(Error::Value(format!(
"KFold requires n_splits ≥ 2, got {n_splits}"
)));
}
Ok(Self {
n_splits,
shuffle: false,
seed: 0,
})
}
pub fn shuffle(mut self, shuffle: bool) -> Self {
self.shuffle = shuffle;
self
}
pub fn seed(mut self, seed: u64) -> Self {
self.seed = seed;
self
}
}
impl Splitter for KFold {
fn n_splits(&self, n: usize) -> Result<usize> {
if n < self.n_splits {
return Err(Error::Value(format!(
"KFold: n = {n} must be ≥ n_splits = {}",
self.n_splits
)));
}
Ok(self.n_splits)
}
fn split(&self, n: usize) -> Result<Vec<Split>> {
let k = self.n_splits(n)?;
let mut indices: Vec<usize> = (0..n).collect();
if self.shuffle {
shuffle_indices_in_place(&mut indices, self.seed);
}
let base = n / k;
let extra = n % k;
let mut folds: Vec<Vec<usize>> = Vec::with_capacity(k);
let mut start = 0usize;
for i in 0..k {
let size = base + if i < extra { 1 } else { 0 };
folds.push(indices[start..start + size].to_vec());
start += size;
}
let mut out = Vec::with_capacity(k);
for i in 0..k {
let test = folds[i].clone();
let mut train: Vec<usize> = Vec::with_capacity(n - test.len());
for (j, fold) in folds.iter().enumerate() {
if j != i {
train.extend_from_slice(fold);
}
}
out.push(Split { train, test });
}
Ok(out)
}
}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Clone, Debug)]
pub struct StratifiedKFold {
n_splits: usize,
shuffle: bool,
seed: u64,
}
impl StratifiedKFold {
pub fn new(n_splits: usize) -> Result<Self> {
if n_splits < 2 {
return Err(Error::Value(format!(
"StratifiedKFold requires n_splits ≥ 2, got {n_splits}"
)));
}
Ok(Self {
n_splits,
shuffle: false,
seed: 0,
})
}
pub fn shuffle(mut self, shuffle: bool) -> Self {
self.shuffle = shuffle;
self
}
pub fn seed(mut self, seed: u64) -> Self {
self.seed = seed;
self
}
pub fn split(&self, y: &[usize]) -> Result<Vec<Split>> {
let n = y.len();
if n < self.n_splits {
return Err(Error::Value(format!(
"StratifiedKFold: n = {n} must be ≥ n_splits = {}",
self.n_splits
)));
}
let mut classes: Vec<usize> = y.to_vec();
classes.sort();
classes.dedup();
let mut buckets: Vec<Vec<usize>> = vec![Vec::new(); classes.len()];
let class_index = |c: usize| classes.binary_search(&c).unwrap();
for (i, &c) in y.iter().enumerate() {
buckets[class_index(c)].push(i);
}
for (ci, bucket) in buckets.iter().enumerate() {
if bucket.len() < self.n_splits {
return Err(Error::Value(format!(
"StratifiedKFold: class {} has {} samples, needs ≥ n_splits = {}",
classes[ci],
bucket.len(),
self.n_splits
)));
}
}
if self.shuffle {
for bucket in buckets.iter_mut() {
shuffle_indices_in_place(bucket, self.seed);
}
}
let mut folds: Vec<Vec<usize>> = vec![Vec::new(); self.n_splits];
for bucket in &buckets {
for (i, &idx) in bucket.iter().enumerate() {
folds[i % self.n_splits].push(idx);
}
}
for fold in folds.iter_mut() {
fold.sort();
}
let mut out = Vec::with_capacity(self.n_splits);
for i in 0..self.n_splits {
let test = folds[i].clone();
let mut train: Vec<usize> = Vec::with_capacity(n - test.len());
for (j, fold) in folds.iter().enumerate() {
if j != i {
train.extend_from_slice(fold);
}
}
train.sort();
out.push(Split { train, test });
}
Ok(out)
}
}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Clone, Debug)]
pub struct TimeSeriesSplit {
n_splits: usize,
test_size: Option<usize>,
gap: usize,
max_train_size: Option<usize>,
}
impl TimeSeriesSplit {
pub fn new(n_splits: usize) -> Result<Self> {
if n_splits < 2 {
return Err(Error::Value(format!(
"TimeSeriesSplit requires n_splits ≥ 2, got {n_splits}"
)));
}
Ok(Self {
n_splits,
test_size: None,
gap: 0,
max_train_size: None,
})
}
pub fn test_size(mut self, test_size: usize) -> Self {
self.test_size = Some(test_size);
self
}
pub fn gap(mut self, gap: usize) -> Self {
self.gap = gap;
self
}
pub fn max_train_size(mut self, max_train_size: usize) -> Self {
self.max_train_size = Some(max_train_size);
self
}
}
impl Splitter for TimeSeriesSplit {
fn n_splits(&self, _n: usize) -> Result<usize> {
Ok(self.n_splits)
}
fn split(&self, n: usize) -> Result<Vec<Split>> {
let test_size = self.test_size.unwrap_or(n / (self.n_splits + 1));
if test_size == 0 {
return Err(Error::Value(format!(
"TimeSeriesSplit: computed test_size = 0 for n = {n}, n_splits = {}",
self.n_splits
)));
}
let required = 1 + self.n_splits * (test_size + self.gap);
if n < required {
return Err(Error::Value(format!(
"TimeSeriesSplit: n = {n} is too small; needs ≥ {required} for {} splits at test_size {test_size} (gap {})",
self.n_splits, self.gap
)));
}
let mut out = Vec::with_capacity(self.n_splits);
for i in 0..self.n_splits {
let test_start = n - (self.n_splits - i) * test_size;
let test_end = test_start + test_size;
let train_end = test_start - self.gap;
if train_end == 0 {
return Err(Error::Value(
"TimeSeriesSplit: gap consumed all training data at some fold".into(),
));
}
let train_start = match self.max_train_size {
Some(m) if train_end > m => train_end - m,
_ => 0,
};
let train: Vec<usize> = (train_start..train_end).collect();
let test: Vec<usize> = (test_start..test_end).collect();
out.push(Split { train, test });
}
Ok(out)
}
}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Clone, Copy, Debug, Default)]
pub struct LeaveOneOut;
impl LeaveOneOut {
pub fn new() -> Self {
LeaveOneOut
}
}
impl Splitter for LeaveOneOut {
fn n_splits(&self, n: usize) -> Result<usize> {
if n < 2 {
return Err(Error::Value(format!("LeaveOneOut requires n ≥ 2, got {n}")));
}
Ok(n)
}
fn split(&self, n: usize) -> Result<Vec<Split>> {
let _ = self.n_splits(n)?;
let mut out = Vec::with_capacity(n);
for i in 0..n {
let mut train: Vec<usize> = Vec::with_capacity(n - 1);
for j in 0..n {
if j != i {
train.push(j);
}
}
out.push(Split {
train,
test: vec![i],
});
}
Ok(out)
}
}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Clone, Debug)]
pub struct ShuffleSplit {
n_splits: usize,
test_fraction: f64,
seed: u64,
}
impl ShuffleSplit {
pub fn new(n_splits: usize, test_fraction: f64) -> Result<Self> {
if n_splits == 0 {
return Err(Error::Value("ShuffleSplit requires n_splits ≥ 1".into()));
}
if !(0.0 < test_fraction && test_fraction < 1.0) {
return Err(Error::Value(format!(
"ShuffleSplit: test_fraction must be in (0, 1), got {test_fraction}"
)));
}
Ok(Self {
n_splits,
test_fraction,
seed: 0,
})
}
pub fn seed(mut self, seed: u64) -> Self {
self.seed = seed;
self
}
}
impl Splitter for ShuffleSplit {
fn n_splits(&self, _n: usize) -> Result<usize> {
Ok(self.n_splits)
}
fn split(&self, n: usize) -> Result<Vec<Split>> {
if n < 2 {
return Err(Error::Value(format!("ShuffleSplit: n = {n} must be ≥ 2")));
}
let test_size = ((n as f64) * self.test_fraction).round() as usize;
if test_size == 0 || test_size >= n {
return Err(Error::Value(format!(
"ShuffleSplit: test_fraction = {} gives test_size = {test_size} on n = {n}",
self.test_fraction
)));
}
let mut out = Vec::with_capacity(self.n_splits);
for r in 0..self.n_splits {
let mut idx: Vec<usize> = (0..n).collect();
shuffle_indices_in_place(
&mut idx,
self.seed
.wrapping_add(0xA0761D6478BD642F_u64.wrapping_mul((r as u64).wrapping_add(1))),
);
let (test_part, train_part) = idx.split_at(test_size);
let mut test = test_part.to_vec();
let mut train = train_part.to_vec();
test.sort();
train.sort();
out.push(Split { train, test });
}
Ok(out)
}
}