rrtk 0.7.0-beta.0

// SPDX-License-Identifier: BSD-3-Clause
// Copyright 2024-2026 UxuginPython
//!Streams that perform mathematical operations.
use crate::streams::*;
use core::mem::MaybeUninit;
//TODO: The behavior of SumStream and friends in relation to Ok(None) is maximally unhelpful for
//everyone. Either require Default and return that when all inputs return Ok(None) or return
//Ok(None) when any input returns Ok(None). This is the worst possible combination.
//Probably make them return Ok(None) if any inputs do to match Sum2 etc.
///A stream that adds all its inputs. If one input returns `Ok(None)`, it is excluded. If all inputs
///return `Ok(None)`, returns `Ok(None)`. If this is not the desired behavior, use
///[`NoneToValue`](converters::NoneToValue) or [`NoneToError`](converters::NoneToError).
///[`Sum2`] may also be a bit faster if you are only adding the outputs of two streams.
pub struct SumStream<T, const N: usize, G, E>
where
    T: AddAssign + Copy,
    G: Getter<T, E>,
    E: Clone + Debug,
{
    addends: [G; N],
    //TODO: If you do decide to remove a bunch of bounds, including G: Getter<T, E>, the T and E
    //parameters may be able to be removed from the struct itself. Do note that there may be others
    //for which this is the case that may not have a note like this.
    phantom_t: PhantomData<T>,
    phantom_e: PhantomData<E>,
}
impl<T, const N: usize, G, E> SumStream<T, N, G, E>
where
    T: AddAssign + Copy,
    G: Getter<T, E>,
    E: Clone + Debug,
{
    ///Constructor for [`SumStream`].
    pub const fn new(addends: [G; N]) -> Self {
        if N < 1 {
            panic!("rrtk::streams::SumStream must have at least one input stream");
        }
        Self {
            addends,
            phantom_t: PhantomData,
            phantom_e: PhantomData,
        }
    }
}
impl<T, const N: usize, G, E> Getter<T, E> for SumStream<T, N, G, E>
where
    T: AddAssign + Copy,
    G: Getter<T, E>,
    E: Clone + Debug,
{
    fn get(&self) -> Output<T, E> {
        //Err(...) -> return Err immediately
        //Ok(None) -> skip
        //Ok(Some(...)) -> add to value
        let mut outputs = [MaybeUninit::uninit(); N];
        //This is always equal to the index of the next uninitialized slot if there is one.
        let mut outputs_filled = 0;
        for i in &self.addends {
            if let Some(x) = i.get()? {
                outputs[outputs_filled].write(x);
                outputs_filled += 1;
            }
        }
        if outputs_filled == 0 {
            return Ok(None);
        }
        //We can safely assume_init on outputs indexes within 0..outputs_filled.
        unsafe {
            let mut value = outputs[0].assume_init();
            for i in 1..outputs_filled {
                value += outputs[i].assume_init();
            }
            Ok(Some(value))
        }
    }
}
impl<T, const N: usize, G, E> Updatable<E> for SumStream<T, N, G, E>
where
    T: AddAssign + Copy,
    G: Getter<T, E>,
    E: Clone + Debug,
{
    fn update(&mut self) -> NothingOrError<E> {
        for getter in &mut self.addends {
            getter.update()?;
        }
        Ok(())
    }
}
///A stream that adds two inputs. This should be a bit faster than [`SumStream`], which adds any
///number of inputs. Returns `Ok(None)` if either input does. If this is not the desired behavior,
///[`NoneToValue`](converters::NoneToValue) may be of interest.
pub struct Sum2<T1, T2, G1, G2, E>
where
    T1: Add<T2>,
    G1: Getter<T1, E>,
    G2: Getter<T2, E>,
    E: Clone + Debug,
{
    addend1: G1,
    addend2: G2,
    phantom_t1: PhantomData<T1>,
    phantom_t2: PhantomData<T2>,
    phantom_e: PhantomData<E>,
}
impl<T1, T2, G1, G2, E> Sum2<T1, T2, G1, G2, E>
where
    T1: Add<T2>,
    G1: Getter<T1, E>,
    G2: Getter<T2, E>,
    E: Clone + Debug,
{
    ///Constructor for [`Sum2`].
    pub const fn new(addend1: G1, addend2: G2) -> Self {
        Self {
            addend1,
            addend2,
            phantom_t1: PhantomData,
            phantom_t2: PhantomData,
            phantom_e: PhantomData,
        }
    }
}
impl<T1, T2, TO, G1, G2, E> Getter<TO, E> for Sum2<T1, T2, G1, G2, E>
where
    T1: Add<T2, Output = TO>,
    G1: Getter<T1, E>,
    G2: Getter<T2, E>,
    E: Clone + Debug,
{
    fn get(&self) -> Output<TO, E> {
        let x = self.addend1.get()?;
        let x = match x {
            Some(x) => x,
            None => {
                return Ok(None);
            }
        };
        let y = self.addend2.get()?;
        let y = match y {
            Some(y) => y,
            None => return Ok(None),
        };
        Ok(Some(Datum::new(
            core::cmp::max(x.time, y.time),
            x.value + y.value,
        )))
    }
}
impl<T1, T2, G1, G2, E> Updatable<E> for Sum2<T1, T2, G1, G2, E>
where
    T1: Add<T2>,
    G1: Getter<T1, E>,
    G2: Getter<T2, E>,
    E: Clone + Debug,
{
    fn update(&mut self) -> NothingOrError<E> {
        self.addend1.update()?;
        self.addend2.update()?;
        Ok(())
    }
}
///A stream that subtracts one of its inputs from the other. Returns `Ok(None)` if either input
///does. [`NoneToValue`](converters::NoneToValue) may be of interest if this is not the desired
///behavior.
pub struct DifferenceStream<TM, TS, GM, GS, E>
where
    TM: Sub<TS>,
    GM: Getter<TM, E>,
    GS: Getter<TS, E>,
    E: Clone + Debug,
{
    minuend: GM,
    subtrahend: GS,
    phantom_tm: PhantomData<TM>,
    phantom_ts: PhantomData<TS>,
    phantom_e: PhantomData<E>,
}
impl<TM, TS, GM, GS, E> DifferenceStream<TM, TS, GM, GS, E>
where
    TM: Sub<TS>,
    GM: Getter<TM, E>,
    GS: Getter<TS, E>,
    E: Clone + Debug,
{
    ///Constructor for [`DifferenceStream`].
    pub const fn new(minuend: GM, subtrahend: GS) -> Self {
        Self {
            minuend,
            subtrahend,
            phantom_tm: PhantomData,
            phantom_ts: PhantomData,
            phantom_e: PhantomData,
        }
    }
}
impl<TM, TS, TO, GM, GS, E> Getter<TO, E> for DifferenceStream<TM, TS, GM, GS, E>
where
    TM: Sub<TS, Output = TO>,
    GM: Getter<TM, E>,
    GS: Getter<TS, E>,
    E: Clone + Debug,
{
    fn get(&self) -> Output<TO, E> {
        let minuend_output = self.minuend.get()?;
        let subtrahend_output = self.subtrahend.get()?;
        match minuend_output {
            Some(_) => {}
            None => {
                return Ok(None);
            }
        }
        let minuend_output = minuend_output.unwrap();
        match subtrahend_output {
            Some(_) => {}
            None => {
                return Ok(None);
            }
        }
        let subtrahend_output = subtrahend_output.unwrap();
        let value = minuend_output.value - subtrahend_output.value;
        let time = if minuend_output.time > subtrahend_output.time {
            minuend_output.time
        } else {
            subtrahend_output.time
        };
        Ok(Some(Datum::new(time, value)))
    }
}
impl<TM, TS, GM, GS, E> Updatable<E> for DifferenceStream<TM, TS, GM, GS, E>
where
    TM: Sub<TS>,
    GM: Getter<TM, E>,
    GS: Getter<TS, E>,
    E: Clone + Debug,
{
    fn update(&mut self) -> NothingOrError<E> {
        self.minuend.update()?;
        self.subtrahend.update()?;
        Ok(())
    }
}
///A stream that multiplies its inputs. If an input returns `Ok(None)`, it is excluded from the
///calculation, effectively treating it as though it had returned 1. If this is not the desired
///behavior, use [`rrtk::streams::converters::NoneToValue`](streams::converters::NoneToValue) or
///[`rrtk::streams::converters::NoneToError`](streams::converters::NoneToError). [`Product2`] may
///also be a bit faster if you are only multiplying the outputs of two streams.
pub struct ProductStream<T, const N: usize, G, E>
where
    T: MulAssign + Copy,
    G: Getter<T, E>,
    E: Clone + Debug,
{
    factors: [G; N],
    phantom_t: PhantomData<T>,
    phantom_e: PhantomData<E>,
}
impl<T, const N: usize, G, E> ProductStream<T, N, G, E>
where
    T: MulAssign + Copy,
    G: Getter<T, E>,
    E: Clone + Debug,
{
    ///Constructor for [`ProductStream`].
    pub const fn new(factors: [G; N]) -> Self {
        if N < 1 {
            panic!("rrtk::streams::ProductStream must have at least one input stream");
        }
        Self {
            factors,
            phantom_t: PhantomData,
            phantom_e: PhantomData,
        }
    }
}
impl<T, const N: usize, G, E> Getter<T, E> for ProductStream<T, N, G, E>
where
    T: MulAssign + Copy,
    G: Getter<T, E>,
    E: Clone + Debug,
{
    fn get(&self) -> Output<T, E> {
        let mut outputs = [MaybeUninit::uninit(); N];
        let mut outputs_filled = 0;
        for i in &self.factors {
            if let Some(x) = i.get()? {
                outputs[outputs_filled].write(x);
                outputs_filled += 1;
            }
        }
        if outputs_filled == 0 {
            return Ok(None);
        }
        unsafe {
            let mut value = outputs[0].assume_init();
            for i in 1..outputs_filled {
                value *= outputs[i].assume_init();
            }
            Ok(Some(value))
        }
    }
}
impl<T, const N: usize, G, E> Updatable<E> for ProductStream<T, N, G, E>
where
    T: MulAssign + Copy,
    G: Getter<T, E>,
    E: Clone + Debug,
{
    fn update(&mut self) -> NothingOrError<E> {
        for getter in &mut self.factors {
            getter.update()?;
        }
        Ok(())
    }
}
///A stream that multiplies two inputs. It should be a bit faster than [`ProductStream`], which
///adds any number of inputs. Returns `Ok(None)` if either of its inputs does. If this is not the
///desired behavior, [`NoneToValue`](converters::NoneToValue) may be of interest.
pub struct Product2<T1, T2, G1, G2, E>
where
    T1: Mul<T2>,
    G1: Getter<T1, E>,
    G2: Getter<T2, E>,
    E: Clone + Debug,
{
    factor1: G1,
    factor2: G2,
    phantom_t1: PhantomData<T1>,
    phantom_t2: PhantomData<T2>,
    phantom_e: PhantomData<E>,
}
impl<T1, T2, G1, G2, E> Product2<T1, T2, G1, G2, E>
where
    T1: Mul<T2>,
    G1: Getter<T1, E>,
    G2: Getter<T2, E>,
    E: Clone + Debug,
{
    ///Constructor for [`Product2`].
    pub const fn new(factor1: G1, factor2: G2) -> Self {
        Self {
            factor1,
            factor2,
            phantom_t1: PhantomData,
            phantom_t2: PhantomData,
            phantom_e: PhantomData,
        }
    }
}
impl<T1, T2, TO, G1, G2, E> Getter<TO, E> for Product2<T1, T2, G1, G2, E>
where
    T1: Mul<T2, Output = TO>,
    G1: Getter<T1, E>,
    G2: Getter<T2, E>,
    E: Clone + Debug,
{
    fn get(&self) -> Output<TO, E> {
        let x = self.factor1.get()?;
        let x = match x {
            Some(x) => x,
            None => return Ok(None),
        };
        let y = self.factor2.get()?;
        let y = match y {
            Some(y) => y,
            None => return Ok(None),
        };
        Ok(Some(Datum::new(
            core::cmp::max(x.time, y.time),
            x.value * y.value,
        )))
    }
}
impl<T1, T2, G1, G2, E> Updatable<E> for Product2<T1, T2, G1, G2, E>
where
    T1: Mul<T2>,
    G1: Getter<T1, E>,
    G2: Getter<T2, E>,
    E: Clone + Debug,
{
    fn update(&mut self) -> NothingOrError<E> {
        self.factor1.update()?;
        self.factor2.update()?;
        Ok(())
    }
}
///A stream that divides one if its inputs by the other. Returns `Ok(None)` if either input does.
pub struct QuotientStream<TD, TS, GD, GS, E>
where
    TD: Div<TS>,
    GD: Getter<TD, E>,
    GS: Getter<TS, E>,
    E: Clone + Debug,
{
    dividend: GD,
    divisor: GS,
    phantom_td: PhantomData<TD>,
    phantom_ts: PhantomData<TS>,
    phantom_e: PhantomData<E>,
}
impl<TD, TS, GD, GS, E> QuotientStream<TD, TS, GD, GS, E>
where
    TD: Div<TS>,
    GD: Getter<TD, E>,
    GS: Getter<TS, E>,
    E: Clone + Debug,
{
    ///Constructor for [`QuotientStream`].
    pub const fn new(dividend: GD, divisor: GS) -> Self {
        Self {
            dividend,
            divisor,
            phantom_td: PhantomData,
            phantom_ts: PhantomData,
            phantom_e: PhantomData,
        }
    }
}
impl<TD, TS, TO, GD, GS, E> Getter<TO, E> for QuotientStream<TD, TS, GD, GS, E>
where
    TD: Div<TS, Output = TO>,
    GD: Getter<TD, E>,
    GS: Getter<TS, E>,
    E: Clone + Debug,
{
    fn get(&self) -> Output<TO, E> {
        let dividend_output = self.dividend.get()?;
        let divisor_output = self.divisor.get()?;
        match dividend_output {
            Some(_) => {}
            None => {
                return Ok(None);
            }
        }
        let dividend_output = dividend_output.unwrap();
        match divisor_output {
            Some(_) => {}
            None => {
                return Ok(None);
            }
        }
        let divisor_output = divisor_output.unwrap();
        let value = dividend_output.value / divisor_output.value;
        let time = if dividend_output.time > divisor_output.time {
            dividend_output.time
        } else {
            divisor_output.time
        };
        Ok(Some(Datum::new(time, value)))
    }
}
impl<TD, TS, GD, GS, E> Updatable<E> for QuotientStream<TD, TS, GD, GS, E>
where
    TD: Div<TS>,
    GD: Getter<TD, E>,
    GS: Getter<TS, E>,
    E: Clone + Debug,
{
    fn update(&mut self) -> NothingOrError<E> {
        self.dividend.update()?;
        self.divisor.update()?;
        Ok(())
    }
}
///A stream that exponentiates one of its inputs to the other. If the exponent input returns
///`Ok(None)`, the base's value is returned directly. Only available with `std`.
#[cfg(feature = "internal_enhanced_float")]
pub struct ExponentStream<GB, GE, E>
where
    GB: Getter<f32, E>,
    GE: Getter<f32, E>,
    E: Clone + Debug,
{
    base: GB,
    exponent: GE,
    phantom_e: PhantomData<E>,
}
#[cfg(feature = "internal_enhanced_float")]
impl<GB, GE, E> ExponentStream<GB, GE, E>
where
    GB: Getter<f32, E>,
    GE: Getter<f32, E>,
    E: Clone + Debug,
{
    ///Constructor for [`ExponentStream`].
    pub const fn new(base: GB, exponent: GE) -> Self {
        Self {
            base,
            exponent,
            phantom_e: PhantomData,
        }
    }
}
#[cfg(feature = "internal_enhanced_float")]
impl<GB, GE, E> Getter<f32, E> for ExponentStream<GB, GE, E>
where
    GB: Getter<f32, E>,
    GE: Getter<f32, E>,
    E: Clone + Debug,
{
    fn get(&self) -> Output<f32, E> {
        let base_output = self.base.get()?;
        let exponent_output = self.exponent.get()?;
        match base_output {
            Some(_) => {}
            None => {
                return Ok(None);
            }
        }
        let base_output = base_output.unwrap();
        match exponent_output {
            Some(_) => {}
            None => {
                return Ok(Some(base_output));
            }
        }
        let exponent_output = exponent_output.unwrap();
        let value = powf(base_output.value, exponent_output.value);
        let time = if base_output.time > exponent_output.time {
            base_output.time
        } else {
            exponent_output.time
        };
        Ok(Some(Datum::new(time, value)))
    }
}
#[cfg(feature = "internal_enhanced_float")]
impl<GB, GE, E> Updatable<E> for ExponentStream<GB, GE, E>
where
    GB: Getter<f32, E>,
    GE: Getter<f32, E>,
    E: Clone + Debug,
{
    fn update(&mut self) -> NothingOrError<E> {
        self.base.update()?;
        self.exponent.update()?;
        Ok(())
    }
}
///A stream that computes the numerical derivative of its input.
pub struct DerivativeStream<T, O, G: Getter<T, E>, E: Clone + Debug> {
    input: G,
    value: Output<O, E>,
    //doesn't matter if this is an Err or Ok(None) - we can't use it either way if it's not Some
    prev_output: Option<Datum<T>>,
}
impl<T, O, G: Getter<T, E>, E: Clone + Debug> DerivativeStream<T, O, G, E> {
    ///Constructor for [`DerivativeStream`].
    pub const fn new(input: G) -> Self {
        Self {
            input,
            value: Ok(None),
            prev_output: None,
        }
    }
}
impl<T, O, G, E> Getter<O, E> for DerivativeStream<T, O, G, E>
where
    DerivativeStream<T, O, G, E>: Updatable<E>,
    O: Clone,
    G: Getter<T, E>,
    E: Clone + Debug,
{
    fn get(&self) -> Output<O, E> {
        self.value.clone()
    }
}
impl<T, N1, O, G, E> Updatable<E> for DerivativeStream<T, O, G, E>
where
    T: Copy + Sub<Output = N1>,
    N1: Div<Time, Output = O>,
    G: Getter<T, E>,
    E: Clone + Debug,
{
    fn update(&mut self) -> NothingOrError<E> {
        self.input.update()?;
        let output = self.input.get();
        let output = match output {
            Ok(ok) => ok,
            Err(error) => {
                //XXX: This may change when you standardize when Updatable::update errors.
                //Remove this clone if you don't return the error.
                self.value = Err(error.clone());
                self.prev_output = None;
                return Err(error);
            }
        };
        let output = match output {
            Some(some) => some,
            None => {
                self.value = Ok(None);
                self.prev_output = None;
                return Ok(());
            }
        };
        let prev_output = match self.prev_output {
            Some(some) => some,
            None => {
                self.prev_output = Some(output);
                return Ok(());
            }
        };
        let value = (output.value - prev_output.value) / (output.time - prev_output.time);
        self.value = Ok(Some(Datum::new(output.time, value)));
        self.prev_output = Some(output);
        Ok(())
    }
}
///A stream that computes the trapezoidal numerical integral of its input.
pub struct IntegralStream<T, O, G: Getter<T, E>, E: Clone + Debug> {
    input: G,
    value: Output<O, E>,
    prev_output: Option<Datum<T>>,
}
impl<T, O, G: Getter<T, E>, E: Clone + Debug> IntegralStream<T, O, G, E> {
    ///Constructor for [`IntegralStream`].
    pub const fn new(input: G) -> Self {
        Self {
            input,
            value: Ok(None),
            prev_output: None,
        }
    }
}
impl<T, O, G, E> Getter<O, E> for IntegralStream<T, O, G, E>
where
    IntegralStream<T, O, G, E>: Updatable<E>,
    O: Clone,
    G: Getter<T, E>,
    E: Clone + Debug,
{
    fn get(&self) -> Output<O, E> {
        self.value.clone()
    }
}
impl<T, O, N1, G, E> Updatable<E> for IntegralStream<T, O, G, E>
where
    T: Copy + Add<Output = N1>,
    Time: Mul<N1, Output = O>,
    O: Copy + stulta::Half + Add<O, Output = O>,
    G: Getter<T, E>,
    E: Clone + Debug,
{
    fn update(&mut self) -> NothingOrError<E> {
        self.input.update()?;
        let output = self.input.get();
        let output = match output {
            Ok(ok) => ok,
            Err(error) => {
                //XXX: This may change when you standardize when Updatable::update errors.
                //Remove this clone if you don't return the error.
                self.value = Err(error.clone());
                self.prev_output = None;
                return Err(error);
            }
        };
        let output = match output {
            Some(some) => some,
            None => {
                self.value = Ok(None);
                self.prev_output = None;
                return Ok(());
            }
        };
        let prev_output = match self.prev_output {
            Some(some) => some,
            None => {
                self.prev_output = Some(output);
                return Ok(());
            }
        };
        let delta_time = output.time - prev_output.time;
        let value_addend = (delta_time * (prev_output.value + output.value)).half();
        let value = match &self.value {
            Ok(Some(real_value)) => value_addend + real_value.value,
            _ => value_addend,
        };
        self.value = Ok(Some(Datum::new(output.time, value)));
        self.prev_output = Some(output);
        Ok(())
    }
}