mop-blocks 0.2.0

Foundation blocks for MOP
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83

use crate::dr_matrix::DrMatrixVec;
use crate::{
  mph::{MphDefinitions, MphOrMut, MphOrRef, MphOrs},
  Cstr, Obj,
};
use alloc::string::String;
use core::{fmt::Debug, marker::PhantomData, ops::Div};
#[cfg(feature = "with_futures")]
use futures::stream::{self, StreamExt};
use mop_common_defs::TraitCfg;
use num_traits::{NumCast, Zero};

#[derive(Debug)]
pub struct MphOrsEvaluators<C, O, OR, S, SD> {
  phantom: PhantomData<(C, O, OR, S, SD)>,
}

impl<C, O, OR, S, SD> MphOrsEvaluators<C, O, OR, S, SD>
where
  C: Cstr<S> + TraitCfg,
  O: Obj<OR, S> + TraitCfg,
  OR: Copy + Debug + Div<OR, Output = OR> + NumCast + TraitCfg + Zero,
{
  pub async fn eval_cstrs_reasons(
    defs: &MphDefinitions<C, O, SD>,
    rslts: &MphOrs<OR, S>,
  ) -> DrMatrixVec<String> {
    let func = |(reasons, r)| Self::eval_cstrs_reasons_for_solution(defs.hard_cstrs(), reasons, &r);
    let mut reasons = DrMatrixVec::with_capacity(rslts.hard_cstrs.rows(), rslts.hard_cstrs.cols());
    reasons.fill(|_, _| String::with_capacity(256));
    let iter = reasons.row_iter_mut().zip(rslts.iter());
    #[cfg(not(feature = "with_futures"))]
    iter.for_each(func);
    #[cfg(feature = "with_futures")]
    stream::iter(iter)
      .for_each_concurrent(None, |(reasons, r)| async move { func((reasons, r)) })
      .await;
    reasons
  }

  pub async fn eval_cstrs_violations(defs: &MphDefinitions<C, O, SD>, rslts: &mut MphOrs<OR, S>) {
    let func = |r| Self::eval_cstrs_violations_for_solution(defs.hard_cstrs(), r);
    #[cfg(not(feature = "with_futures"))]
    rslts.iter_mut().for_each(func);
    #[cfg(feature = "with_futures")]
    stream::iter(rslts.iter_mut()).for_each_concurrent(None, |r| async { func(r) }).await;
  }

  pub async fn eval_objs(defs: &MphDefinitions<C, O, SD>, rslts: &mut MphOrs<OR, S>) {
    let func = |r| Self::eval_objs_for_solution(defs.objs(), r);
    #[cfg(not(feature = "with_futures"))]
    rslts.iter_mut().for_each(func);
    #[cfg(feature = "with_futures")]
    stream::iter(rslts.iter_mut()).for_each_concurrent(None, |r| async { func(r) }).await;
  }

  fn eval_cstrs_reasons_for_solution(
    cstrs: &[C],
    reasons: &mut [String],
    rslt: &MphOrRef<'_, OR, S>,
  ) {
    for (c, r) in cstrs.iter().zip(reasons.iter_mut()) {
      *r = c.reasons(rslt.solution);
    }
  }

  fn eval_cstrs_violations_for_solution(cstrs: &[C], rslt: MphOrMut<'_, OR, S>) {
    for (c, cr) in cstrs.iter().zip(rslt.hard_cstrs.iter_mut()) {
      *cr = c.violations(rslt.solution);
    }
  }

  fn eval_objs_for_solution(objs: &[O], rslt: MphOrMut<'_, OR, S>) {
    let mut objs_avg = OR::zero();
    for (obj, obj_rslts) in objs.iter().zip(rslt.objs.iter_mut()) {
      let rslt = obj.result(&rslt.solution);
      *obj_rslts = rslt;
      objs_avg = objs_avg + rslt;
    }
    let cast = NumCast::from(objs.len()).unwrap();
    *rslt.objs_avg = objs_avg / cast;
  }
}