use crate::Vec1;
#[cfg(not(feature = "std"))]
use alloc::vec::Vec;
#[cfg(feature = "std")]
use std::vec::Vec;
impl<T> Vec1<T>
where
T: Copy + PartialOrd,
{
pub fn min_element(&self) -> Option<T> {
self.iter().copied().reduce(|a, b| if b < a { b } else { a })
}
pub fn max_element(&self) -> Option<T> {
self.iter().copied().reduce(|a, b| if b > a { b } else { a })
}
pub fn range(&self) -> Option<T>
where
T: core::ops::Sub<Output = T>,
{
match (self.min_element(), self.max_element()) {
(Some(lo), Some(hi)) => Some(hi - lo),
_ => None,
}
}
}
impl Vec1<f64> {
pub fn median(&self) -> Option<f64> {
if self.is_empty() {
return None;
}
let mut buf: Vec<f64> = self.iter().copied().collect();
buf.sort_by(|a, b| a.partial_cmp(b).unwrap_or(core::cmp::Ordering::Equal));
Some(buf[(buf.len() - 1) / 2])
}
pub fn quantile(&self, q: f64) -> Option<f64> {
if self.is_empty() {
return None;
}
let mut buf: Vec<f64> = self.iter().copied().collect();
buf.sort_by(|a, b| a.partial_cmp(b).unwrap_or(core::cmp::Ordering::Equal));
let n = buf.len();
if n == 1 {
return Some(buf[0]);
}
let q = q.clamp(0.0, 1.0);
let pos = q * (n - 1) as f64;
let lo = libm::floor(pos) as usize;
let hi = libm::ceil(pos) as usize;
if lo == hi {
return Some(buf[lo]);
}
let frac = pos - lo as f64;
Some(buf[lo] + frac * (buf[hi] - buf[lo]))
}
pub fn mode(&self) -> Option<f64> {
if self.is_empty() {
return None;
}
let mut buf: Vec<f64> = self.iter().copied().collect();
buf.sort_by(|a, b| a.partial_cmp(b).unwrap_or(core::cmp::Ordering::Equal));
let mut best = buf[0];
let mut best_count = 1usize;
let mut cur = buf[0];
let mut cur_count = 1usize;
for &x in &buf[1..] {
if x == cur {
cur_count += 1;
} else {
if cur_count > best_count {
best = cur;
best_count = cur_count;
}
cur = x;
cur_count = 1;
}
}
if cur_count > best_count {
best = cur;
}
Some(best)
}
}
impl<T> Vec1<T>
where
T: Copy + PartialOrd + Default,
{
pub fn sliding_window_max(&self, n: usize) -> Vec1<T> {
assert!(n > 0, "sliding_window_max: window size must be > 0");
if self.len() < n {
return Vec1::new();
}
let mut result = Vec1::with_capacity(self.len() - n + 1);
let mut deque: Vec<usize> = Vec::with_capacity(n);
for i in 1..=self.len() {
if let Some(&front) = deque.first() {
if front + n <= i {
deque.remove(0);
}
}
while let Some(&last) = deque.last() {
if self[last] <= self[i] {
deque.pop();
} else {
break;
}
}
deque.push(i);
if i >= n {
result.push(self[deque[0]]);
}
}
result
}
pub fn sliding_window_min(&self, n: usize) -> Vec1<T> {
assert!(n > 0, "sliding_window_min: window size must be > 0");
if self.len() < n {
return Vec1::new();
}
let mut result = Vec1::with_capacity(self.len() - n + 1);
let mut deque: Vec<usize> = Vec::with_capacity(n);
for i in 1..=self.len() {
if let Some(&front) = deque.first() {
if front + n <= i {
deque.remove(0);
}
}
while let Some(&last) = deque.last() {
if self[last] >= self[i] {
deque.pop();
} else {
break;
}
}
deque.push(i);
if i >= n {
result.push(self[deque[0]]);
}
}
result
}
}
impl Vec1<f64> {
pub fn sliding_window_median(&self, n: usize) -> Vec1<f64> {
assert!(n > 0, "sliding_window_median: window size must be > 0");
if self.len() < n {
return Vec1::new();
}
let mut result = Vec1::with_capacity(self.len() - n + 1);
let mut buf: Vec<f64> = Vec::with_capacity(n);
for start in 1..=self.len() - n + 1 {
buf.clear();
for i in start..start + n {
buf.push(self[i]);
}
buf.sort_by(|a, b| a.partial_cmp(b).unwrap_or(core::cmp::Ordering::Equal));
result.push(buf[(n - 1) / 2]);
}
result
}
}
impl Vec1<f64> {
pub fn ewma(&self, alpha: f64) -> Vec1<f64> {
assert!(alpha > 0.0 && alpha <= 1.0, "ewma: alpha must be in (0, 1]");
if self.is_empty() {
return Vec1::new();
}
let mut result = Vec1::with_capacity(self.len());
let mut e = self[1];
result.push(e);
for i in 2..=self.len() {
e = alpha * self[i] + (1.0 - alpha) * e;
result.push(e);
}
result
}
pub fn ewma_with_initial(&self, alpha: f64, initial: f64) -> Vec1<f64> {
assert!(alpha > 0.0 && alpha <= 1.0, "ewma_with_initial: alpha must be in (0, 1]");
if self.is_empty() {
return Vec1::new();
}
let mut result = Vec1::with_capacity(self.len());
let mut e = alpha * self[1] + (1.0 - alpha) * initial;
result.push(e);
for i in 2..=self.len() {
e = alpha * self[i] + (1.0 - alpha) * e;
result.push(e);
}
result
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::vec1;
#[test]
fn min_max_range() {
let v = vec1![3, 1, 4, 1, 5];
assert_eq!(v.min_element(), Some(1));
assert_eq!(v.max_element(), Some(5));
assert_eq!(v.range(), Some(4));
}
#[test]
fn min_max_empty() {
let v: Vec1<i32> = Vec1::new();
assert_eq!(v.min_element(), None);
assert_eq!(v.max_element(), None);
assert_eq!(v.range(), None);
}
#[test]
fn min_max_single() {
let v = vec1![7];
assert_eq!(v.min_element(), Some(7));
assert_eq!(v.max_element(), Some(7));
assert_eq!(v.range(), Some(0));
}
#[test]
fn median_odd() {
let v = vec1![3.0, 1.0, 4.0, 1.0, 5.0];
assert_eq!(v.median(), Some(3.0));
}
#[test]
fn median_even() {
let v = vec1![1.0, 2.0, 3.0, 4.0];
assert_eq!(v.median(), Some(2.0));
}
#[test]
fn median_empty() {
let v: Vec1<f64> = Vec1::new();
assert_eq!(v.median(), None);
}
#[test]
fn quantile_basic() {
let v = vec1![1.0, 2.0, 3.0, 4.0, 5.0];
assert!((v.quantile(0.5).unwrap() - 3.0).abs() < 1e-10);
assert!((v.quantile(0.0).unwrap() - 1.0).abs() < 1e-10);
assert!((v.quantile(1.0).unwrap() - 5.0).abs() < 1e-10);
}
#[test]
fn quantile_quarter() {
let v = vec1![0.0, 1.0, 2.0, 3.0, 4.0];
assert!((v.quantile(0.25).unwrap() - 1.0).abs() < 1e-10);
assert!((v.quantile(0.75).unwrap() - 3.0).abs() < 1e-10);
}
#[test]
fn quantile_empty() {
let v: Vec1<f64> = Vec1::new();
assert_eq!(v.quantile(0.5), None);
}
#[test]
fn mode_basic() {
let v = vec1![1.0, 2.0, 2.0, 3.0, 3.0, 3.0, 4.0];
assert_eq!(v.mode(), Some(3.0));
}
#[test]
fn mode_empty() {
let v: Vec1<f64> = Vec1::new();
assert_eq!(v.mode(), None);
}
#[test]
fn sliding_max_basic() {
let v = vec1![1, 3, -1, -3, 5, 3, 6, 7];
assert_eq!(v.sliding_window_max(3).as_slice(), &[3, 3, 5, 5, 6, 7]);
}
#[test]
fn sliding_max_window_one() {
let v = vec1![1, 2, 3, 4];
assert_eq!(v.sliding_window_max(1).as_slice(), &[1, 2, 3, 4]);
}
#[test]
fn sliding_max_window_too_large() {
let v = vec1![1, 2];
assert!(v.sliding_window_max(5).is_empty());
}
#[test]
fn sliding_min_basic() {
let v = vec1![1, 3, -1, -3, 5, 3, 6, 7];
assert_eq!(v.sliding_window_min(3).as_slice(), &[-1, -3, -3, -3, 3, 3]);
}
#[test]
fn sliding_median_basic() {
let v = vec1![1.0, 3.0, 2.0, 4.0, 5.0, 6.0, 7.0, 8.0];
assert_eq!(v.sliding_window_median(3).as_slice(), &[2.0, 3.0, 4.0, 5.0, 6.0, 7.0]);
}
#[test]
fn sliding_median_too_large() {
let v = vec1![1.0, 2.0];
assert!(v.sliding_window_median(5).is_empty());
}
#[test]
fn ewma_basic() {
let v = vec1![1.0, 2.0, 3.0, 4.0, 5.0];
let e = v.ewma(0.3);
assert!((e[1] - 1.0).abs() < 1e-10);
assert!((e[2] - 1.3).abs() < 1e-10);
assert!((e[3] - 1.81).abs() < 1e-10);
}
#[test]
fn ewma_alpha_one() {
let v = vec1![1.0, 2.0, 3.0];
let e = v.ewma(1.0);
assert!((e[1] - 1.0).abs() < 1e-10);
assert!((e[2] - 2.0).abs() < 1e-10);
assert!((e[3] - 3.0).abs() < 1e-10);
}
#[test]
fn ewma_with_initial_basic() {
let v = vec1![1.0, 2.0, 3.0];
let e = v.ewma_with_initial(0.5, 10.0);
assert!((e[1] - 5.5).abs() < 1e-10);
}
#[test]
fn ewma_empty() {
let v: Vec1<f64> = Vec1::new();
assert!(v.ewma(0.5).is_empty());
}
#[test]
#[should_panic(expected = "alpha must be in (0, 1]")]
fn ewma_invalid_alpha_panics() {
let v = vec1![1.0, 2.0];
let _ = v.ewma(0.0);
}
}