Refactored ks_twosample to take in two slices instead of a mutable owned Vec<f64>

src/lib.rs

@@ -65,5 +65,7 @@ pub mod euclid;
 pub mod function;
 pub mod generate;
 pub mod prec;
+pub mod sorted_iterator;
+pub mod sorted_slice;
 pub mod statistics;
 pub mod stats_tests;

src/sorted_collection.rs

@@ -0,0 +1,118 @@
+use std::{
+    cmp::Ordering,
+    ops::{Deref, Index},
+    slice::SliceIndex,
+};
+
+pub enum SortError {
+    NotSorted,
+}
+
+#[derive(Clone, Debug)]
+pub enum Collection<'a, T> {
+    Ref(&'a [T]),
+    Owned(Vec<T>),
+}
+
+#[derive(Clone, Debug)]
+pub struct SortedCollection<'a, T> {
+    sorted: Collection<'a, T>,
+}
+
+impl<'a, T> SortedCollection<'a, T>
+where
+    T: Ord,
+{
+    pub fn from_slice(coll: &'a [T]) -> Result<Self, SortError> {
+        match coll
+            .windows(2)
+            .all(|sl| sl[0].cmp(&sl[1]) == Ordering::Less)
+        {
+            true => Ok(Self {
+                sorted: Collection::Ref(coll),
+            }),
+            false => Err(SortError::NotSorted),
+        }
+    }
+    pub fn from_mut_vec(mut coll: Vec<T>) -> Self {
+        coll.sort();
+        Self {
+            sorted: Collection::Owned(coll),
+        }
+    }
+    pub fn iter(&'a self) -> std::slice::Iter<'a, T> {
+        match self.sorted {
+            Collection::Ref(items) => items.iter(),
+            Collection::Owned(ref items) => items.iter(),
+        }
+    }
+}
+
+impl<'a, T> TryFrom<&'a [T]> for SortedCollection<'a, T>
+where
+    T: Ord,
+{
+    type Error = SortError;
+
+    fn try_from(value: &'a [T]) -> Result<Self, Self::Error> {
+        Self::from_slice(value)
+    }
+}
+
+impl<'a, T> TryFrom<&'a Box<[T]>> for SortedCollection<'a, T>
+where
+    T: Ord,
+{
+    type Error = SortError;
+
+    fn try_from(value: &'a Box<[T]>) -> Result<Self, Self::Error> {
+        Self::from_slice(value.as_ref())
+    }
+}
+
+impl<'a, T> AsRef<[T]> for SortedCollection<'a, T> {
+    fn as_ref(&self) -> &[T] {
+        match self.sorted {
+            Collection::Ref(items) => items,
+            Collection::Owned(ref items) => items.as_ref(),
+        }
+    }
+}
+
+pub struct SortedSlice<'a, T>(&'a [T]);
+
+impl<'a, T> TryInto<SortedSlice<'a, T>> for &'a [T]
+where
+    T: Ord,
+{
+    type Error = SortError;
+
+    fn try_into(self) -> Result<SortedSlice<'a, T>, Self::Error> {
+        match self.is_sorted() {
+            true => Ok(SortedSlice(self)),
+            false => Err(SortError::NotSorted),
+        }
+    }
+}
+
+impl<'a, T, I> Index<I> for SortedSlice<'a, T>
+where
+    T: Ord,
+    I: SliceIndex<[T]>,
+{
+    type Output = <I as SliceIndex<[T]>>::Output;
+
+    fn index(&self, index: I) -> &Self::Output {
+        self.0.index(index)
+    }
+}
+impl<'a, T> Deref for SortedSlice<'a, T>
+where
+    T: Ord,
+{
+    type Target = [T];
+
+    fn deref(&self) -> &Self::Target {
+        self.0
+    }
+}

src/sorted_iterator.rs

@@ -0,0 +1,38 @@
+use std::marker::PhantomData;
+
+use crate::stats_tests::NaNPolicy;
+
+pub trait SortedIterator {
+    fn sorted_iter(&self, policy: NaNPolicy) -> Sorted;
+}
+
+impl SortedIterator for Vec<f64> {
+    fn sorted_iter(&self, policy: NaNPolicy) -> Sorted {
+        Sorted::new(self, policy)
+    }
+}
+
+/// TODO iron out implementation details later because this is not optimal retrieval of sorted data
+pub struct Sorted {
+    sorted_iter: std::vec::IntoIter<f64>,
+    policy: NaNPolicy,
+}
+
+impl Sorted {
+    pub fn new(data: &[f64], policy: NaNPolicy) -> Self {
+        let mut cloned = Vec::from(data);
+        cloned.sort_by(|a, b| a.total_cmp(b));
+        Self {
+            sorted_iter: cloned.into_iter(),
+            policy,
+        }
+    }
+}
+
+impl Iterator for Sorted {
+    type Item = f64;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        self.sorted_iter.next()
+    }
+}

src/sorted_slice.rs

@@ -0,0 +1,65 @@
+use std::{
+    cmp::Ordering,
+    ops::{Deref, Index},
+    slice::SliceIndex,
+};
+
+#[derive(Copy, Clone, PartialEq, Eq, Debug, Hash)]
+pub enum SortError {
+    NotSorted,
+}
+impl core::fmt::Display for SortError {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            SortError::NotSorted => write!(f, "Sample is not sorted."),
+        }
+    }
+}
+
+pub struct SortedSlice<'a, T>(&'a [T]);
+
+impl<'a, T> SortedSlice<'a, T> {
+    pub fn iter(&self) -> std::slice::Iter<'_, T> {
+        self.0.iter()
+    }
+    pub fn into_iter(self) -> std::slice::Iter<'a, T> {
+        self.0.into_iter()
+    }
+}
+
+impl<'a> TryInto<SortedSlice<'a, f64>> for &'a [f64] {
+    type Error = SortError;
+
+    fn try_into(self) -> Result<SortedSlice<'a, f64>, Self::Error> {
+        match (
+            self.is_sorted_by(|a, b| a.total_cmp(b) != Ordering::Greater),
+            self.is_empty(),
+        ) {
+            (_, true) => Ok(SortedSlice(self)),
+            (true, false) => Ok(SortedSlice(self)),
+            (false, false) => Err(SortError::NotSorted),
+        }
+    }
+}
+
+impl<'a, T, I> Index<I> for SortedSlice<'a, T>
+where
+    T: Ord,
+    I: SliceIndex<[T]>,
+{
+    type Output = <I as SliceIndex<[T]>>::Output;
+
+    fn index(&self, index: I) -> &Self::Output {
+        self.0.index(index)
+    }
+}
+impl<'a, T> Deref for SortedSlice<'a, T>
+where
+    T: Ord,
+{
+    type Target = [T];
+
+    fn deref(&self) -> &Self::Target {
+        self.0
+    }
+}