use num_traits::Float;
pub fn binary_search_interval<T: Float>(
size: usize,
sval: &T,
locator: impl Fn(usize) -> T,
) -> Option<usize> {
if _check_float(sval) {
return None;
}
let mut n0 = 0;
let mut n1 = size - 1;
let mut v0 = locator(n0);
let v1 = locator(n1);
if _check_float(&v0) || _check_float(&v1) {
return None;
}
if !interval_inside(sval, (&v0, &v1)) {
return None;
}
while (n1 - n0) > 1 {
let n = (n0 + n1) / 2;
let v = locator(n);
if _check_float(&v) {
return None;
}
if interval_inside(sval, (&v0, &v)) {
n1 = n;
} else {
n0 = n;
v0 = v;
}
}
Some(n0)
}
fn _check_float<T: Float>(val: &T) -> bool {
val.is_nan() || val.is_infinite()
}
fn _check_floats<T: Float, const N: usize>(vals: &[T; N]) -> bool {
for val in vals.iter() {
if val.is_nan() || val.is_infinite() {
return true;
}
}
false
}
pub fn diff<T: Float>(slc: &[T]) -> impl Iterator<Item = T> + '_ {
slc.windows(2).map(|w| w[1] - w[0])
}
pub fn kernel_conv<'a, T: Float>(slc: &'a [T], kernel: &'a [T]) -> impl Iterator<Item = T> + 'a {
slc.windows(kernel.len()).map(|w| _kernel_mult(w, kernel))
}
fn _kernel_mult<T: Float>(window: &[T], kernel: &[T]) -> T {
window
.iter()
.zip(kernel.iter())
.map(|(w, k)| *w * *k)
.fold(T::zero(), |acc, num| acc + num)
}
pub fn interval_inside<T: Float>(val: &T, vals: (&T, &T)) -> bool {
if val == vals.0 || val == vals.1 {
return true;
}
let b1 = val > vals.0;
let b2 = val > vals.1;
(vals.1 > vals.0 && b1 && !b2) || (vals.0 > vals.1 && b2 && !b1)
}
pub fn slice_locator<T: Float>(slc: &[T], loc: usize) -> T {
slc[loc]
}