frequency and modified RSset to use BTreeSet

src/rsprocess/frequency.rs

@@ -0,0 +1,137 @@
+#![allow(dead_code)]
+
+use std::collections::HashMap;
+use crate::rsprocess::perpetual::lollipops_only_loop_decomposed_q;
+
+use super::perpetual::{lollipops_decomposed_named, lollipops_only_loop_decomposed_named, lollipops_only_loop_named};
+use super::structure::{RSenvironment, RSreaction, RSset, RSsystem};
+use super::transitions::run_separated;
+use super::translator::IdType;
+
+#[derive(Debug, Clone)]
+pub struct Frequency {
+    pub frequency_map: HashMap<IdType, u32>,
+    pub total_runs: usize,
+    pub weight: u32
+}
+
+impl Frequency {
+    pub fn new(weight: u32) -> Self {
+	Frequency { frequency_map: HashMap::new(), total_runs: 0, weight }
+    }
+
+    pub fn add(&mut self, e: &RSset) {
+	for &el in e.iter() {
+	    *self.frequency_map.entry(el).or_default() += 1
+	}
+	self.total_runs += 1
+    }
+
+    pub fn merge(&mut self, other: Frequency) {
+	let mut count = 0;
+	other.frequency_map.iter().for_each(
+	    |(&k, &v)| {
+		*self.frequency_map.entry(k)
+		    .or_insert_with(|| {count+=1; 0}) += v;
+	    }
+	);
+	self.total_runs += count;
+	// FIXME: ???
+	self.weight += other.weight;
+    }
+}
+
+
+// -----------------------------------------------------------------------------
+
+// see naiveFreq
+pub fn naive_frequency(system: &RSsystem) -> Result<Frequency, String> {
+    let ect = run_separated(system)?;
+    let es = ect.iter().map(|(e, _, _)| e).collect::<Vec<_>>();
+
+    let mut freq = Frequency::new(1);
+
+    es.iter().for_each(|e| freq.add(e));
+
+    Ok(freq)
+}
+
+// see naiveFreq
+pub fn naive_frequency_weighted(system: &RSsystem, weight: u32) -> Result<Frequency, String> {
+    let ect = run_separated(system)?;
+    let es = ect.iter().map(|(e, _, _)| e).collect::<Vec<_>>();
+
+    let mut freq = Frequency::new(weight);
+
+    es.iter().for_each(|e| freq.add(e));
+
+    Ok(freq)
+}
+
+// see loopFreq
+pub fn loop_frequency(system: &RSsystem, symb: IdType, weight: u32) -> Frequency {
+    // FIXME: we return the empty frequency or do we not return anything?
+    let mut freq = Frequency::new(weight);
+
+    if let Some(hoop) = lollipops_only_loop_named(system.clone(), symb) {
+	hoop.iter().for_each(|e| freq.add(e));
+    }
+    freq
+}
+
+// see limitFreq
+pub fn limit_frequency(
+    q: &[RSset],
+    reaction_rules: &[RSreaction],
+    available_entities: &RSset,
+    weight: u32
+) -> Option<Frequency> {
+    let mut available_entities = available_entities.clone();
+    for q in q.iter().rev().skip(1).rev() {
+	let res = lollipops_only_loop_decomposed_q(q,
+						   reaction_rules,
+						   &available_entities);
+	available_entities = res.into_iter().next()?;
+    }
+
+    let mut freq = Frequency::new(weight);
+
+    lollipops_only_loop_decomposed_q(q.last().unwrap(),
+				     reaction_rules,
+				     &available_entities)
+	.iter().for_each(|e| freq.add(e));
+    Some(freq)
+}
+
+
+// see fastFreq
+pub fn fast_frequency(
+    q: &[&[RSset]],
+    reaction_rules: &[RSreaction],
+    available_entities: &RSset,
+    weights: &[u32]
+) -> Option<Frequency> {
+    // FIXME: we return the empty frequency or do we not return anything?
+    let mut available_entities = available_entities.clone();
+
+    let mut freq = Frequency::new(1);
+
+    for (&q, &w) in q.iter().zip(weights) {
+	let mut new_freq = Frequency::new(w);
+	for q in q.iter().rev().skip(1).rev() {
+	    let hoop = lollipops_only_loop_decomposed_q(q,
+							reaction_rules,
+							&available_entities);
+	    hoop.iter().for_each(|e| freq.add(e));
+	    available_entities = hoop.into_iter().next()?;
+	}
+
+	lollipops_only_loop_decomposed_q(q.last().unwrap(),
+					 reaction_rules,
+					 &available_entities)
+	    .iter().for_each(|e| new_freq.add(e));
+
+	freq.merge(new_freq);
+    }
+    Some(freq)
+}