monolith

/// Rectangle edges as (left, right, top, bottom).

pub type Edges = [f64; 4];

/// Initial progress slope for the first phase of a replanned motion group.

///

/// Each item is a window's current edge velocity (units per second) and its

/// edge displacement over the new first phase. The fastest mover with a real

/// displacement decides the slope, because windows sharing an edge must share

/// a curve. Returns `None` when that mover would have to reverse, so the group

/// starts from rest instead.

pub fn group_initial_slope(

    movers: impl IntoIterator<Item = (Edges, Edges)>,

    phase_secs: f64,

) -> Option<f64> {

    let mut best: Option<(f64, Edges, Edges)> = None;

    for (velocity, displacement) in movers {

        if dot(&displacement, &displacement) < 1.0 {

            continue;

        }

        let speed = dot(&velocity, &velocity);

        if best.is_none_or(|(s, _, _)| speed > s) {

            best = Some((speed, velocity, displacement));

        }

    }

    let (_, velocity, displacement) = best?;

    let slope = dot(&velocity, &displacement) / dot(&displacement, &displacement) * phase_secs;

    (slope > 0.05).then_some(slope)

}

fn dot(a: &Edges, b: &Edges) -> f64 {

    a.iter().zip(b).map(|(x, y)| x * y).sum()

}

#[cfg(test)]

mod tests {

    use super::*;

    #[test]

    fn continues_same_direction() {

        let slope = group_initial_slope([([100.0, 100.0, 0.0, 0.0], [50.0, 50.0, 0.0, 0.0])], 0.5);

        assert_eq!(slope, Some(1.0));

    }

    #[test]

    fn reversal_starts_from_rest() {

        let slope =

            group_initial_slope([([100.0, 100.0, 0.0, 0.0], [-50.0, -50.0, 0.0, 0.0])], 0.5);

        assert_eq!(slope, None);

    }

    #[test]

    fn ignores_windows_that_do_not_move_this_phase() {

        let movers = [

            ([500.0, 500.0, 0.0, 0.0], [0.0; 4]),

            ([10.0, 10.0, 0.0, 0.0], [20.0, 20.0, 0.0, 0.0]),

        ];

        assert_eq!(group_initial_slope(movers, 1.0), Some(0.5));

    }

}