now workspaces for modular compilation (maybe faster)

rsprocess/src/reaction.rs

@@ -0,0 +1,291 @@
+//! Definitions for the 'classical' mechanism for computation.
+//!
+//! Allows to define the 'classical' mechanism to compute in a Reaction System
+//! (RS) Framework.
+
+use std::hash::Hash;
+
+use serde::{Deserialize, Serialize};
+
+use super::element::{IdState, IdType};
+use super::set::{BasicSet, ExtensionsSet, PositiveSet, Set};
+use super::translator::{Formatter, PrintableWithTranslator, Translator};
+
+pub trait BasicReaction:
+    Clone + Default + Eq + Hash + Serialize + PrintableWithTranslator
+where
+    for<'de> Self: Deserialize<'de>,
+{
+    type Set: BasicSet;
+    fn enabled(&self, state: &Self::Set) -> bool;
+    fn compute_step(&self, state: &Self::Set) -> Option<&Self::Set>;
+}
+
+pub trait ExtensionReaction: Sized {
+    type Set: BasicSet;
+
+    fn compute_all(reactions: &[Self], state: &Self::Set) -> Self::Set;
+
+    fn find_loop(
+        reactions: &[Self],
+        entities: Self::Set,
+        q: &Self::Set,
+    ) -> (Vec<Self::Set>, Vec<Self::Set>);
+
+    fn find_only_loop(
+        reactions: &[Self],
+        entities: &Self::Set,
+        q: &Self::Set,
+    ) -> Vec<Self::Set>;
+
+    fn find_prefix_len_loop(
+        reactions: &[Self],
+        entities: Self::Set,
+        q: &Self::Set,
+    ) -> (usize, Vec<Self::Set>);
+
+    fn lollipops_only_loop_decomposed_q(
+        reactions: &[Self],
+        entities: &Self::Set,
+        q: &Self::Set,
+    ) -> Vec<Self::Set>;
+}
+
+/// Implementations for all reactions.
+impl<T: BasicReaction<Set = Set>, Set: BasicSet> ExtensionReaction for T {
+    type Set = Set;
+
+    /// Computes the result of a series of reactions. Returns the union of all
+    /// products.
+    /// see result
+    fn compute_all(reactions: &[Self], state: &Set) -> Set
+    where
+        Self: Sized,
+    {
+        reactions.iter().fold(Set::default(), |mut acc: Set, r| {
+            acc.extend(r.compute_step(state));
+            acc
+        })
+    }
+
+    /// Finds the loops by simulating the system.
+    fn find_loop(
+        reactions: &[Self],
+        entities: Set,
+        q: &Set,
+    ) -> (Vec<Set>, Vec<Set>) {
+        let mut entities = entities;
+        let mut trace = vec![];
+        loop {
+            if let Some((prefix, hoop)) = entities.split(&trace) {
+                return (prefix.to_vec(), hoop.to_vec());
+            } else {
+                let t = entities.union(q);
+                let products = Self::compute_all(reactions, &t);
+                trace.push(entities.clone());
+                entities = products;
+            }
+        }
+    }
+
+    /// Finds the loops by simulating the system.
+    fn find_only_loop(reactions: &[Self], entities: &Set, q: &Set) -> Vec<Set> {
+        let mut entities = entities.clone();
+        let mut trace = vec![];
+        loop {
+            if let Some((_prefix, hoop)) = entities.split(&trace) {
+                return hoop.to_vec();
+            } else {
+                let t = entities.union(q);
+                let products = Self::compute_all(reactions, &t);
+                trace.push(entities.clone());
+                entities = products;
+            }
+        }
+    }
+
+    /// Finds the loops and the length of the prefix by simulating the system.
+    fn find_prefix_len_loop(
+        reactions: &[Self],
+        entities: Set,
+        q: &Set,
+    ) -> (usize, Vec<Set>) {
+        let mut entities = entities;
+        let mut trace = vec![];
+        loop {
+            if let Some((prefix, hoop)) = entities.split(&trace) {
+                return (prefix.len(), hoop.to_vec());
+            } else {
+                let t = entities.union(q);
+                let products = Self::compute_all(reactions, &t);
+                trace.push(entities.clone());
+                entities = products;
+            }
+        }
+    }
+
+    /// see loop/5
+    fn lollipops_only_loop_decomposed_q(
+        reactions: &[Self],
+        entities: &Set,
+        q: &Set,
+    ) -> Vec<Set> {
+        let find_loop_fn = |q| Self::find_only_loop(reactions, entities, q);
+        find_loop_fn(q)
+    }
+}
+
+// -----------------------------------------------------------------------------
+
+/// Basic structure for a reaction.
+#[derive(
+    Clone, Debug, Default, Serialize, Deserialize, PartialEq, Eq, Hash,
+)]
+pub struct Reaction {
+    pub reactants:  Set,
+    pub inhibitors: Set,
+    pub products:   Set,
+}
+
+impl BasicReaction for Reaction {
+    type Set = Set;
+
+    /// returns true if ```current_state``` enables the reaction
+    /// see enable
+    fn enabled(&self, current_state: &Self::Set) -> bool {
+        self.reactants.is_subset(current_state)
+            && self.inhibitors.is_disjoint(current_state)
+    }
+
+    /// Computes the result of a single reaction (if enabled returns the
+    /// products) otherwise returns None.
+    /// see result
+    fn compute_step(&self, state: &Self::Set) -> Option<&Self::Set> {
+        if self.enabled(state) {
+            Some(&self.products)
+        } else {
+            None
+        }
+    }
+}
+
+impl PrintableWithTranslator for Reaction {
+    fn print(
+        &self,
+        f: &mut std::fmt::Formatter,
+        translator: &Translator,
+    ) -> std::fmt::Result {
+        write!(
+            f,
+            "(r: {}, i: {}, p: {})",
+            Formatter::from(translator, &self.reactants),
+            Formatter::from(translator, &self.inhibitors),
+            Formatter::from(translator, &self.products)
+        )
+    }
+}
+
+impl Reaction {
+    pub fn from(reactants: Set, inhibitors: Set, products: Set) -> Self {
+        Reaction {
+            reactants,
+            inhibitors,
+            products,
+        }
+    }
+
+    pub fn all_products(reactions: &[Self]) -> Set {
+        reactions
+            .iter()
+            .fold(Set::default(), |acc, r| acc.union(&r.products))
+    }
+
+    pub fn all_reactions_with_product<'a>(
+        reactions: &'a [Self],
+        el: &IdType,
+    ) -> Vec<&'a Self> {
+        reactions.iter().fold(vec![], |mut acc, r| {
+            if r.products.contains(el) {
+                acc.push(r);
+            }
+            acc
+        })
+    }
+}
+
+// -----------------------------------------------------------------------------
+
+#[derive(
+    Clone, Debug, Default, Serialize, Deserialize, PartialEq, Eq, Hash,
+)]
+pub struct PositiveReaction {
+    pub reactants: PositiveSet,
+    pub products:  PositiveSet,
+}
+
+impl BasicReaction for PositiveReaction {
+    type Set = PositiveSet;
+
+    fn enabled(&self, state: &Self::Set) -> bool {
+        self.reactants.is_subset(state)
+    }
+
+    fn compute_step(&self, state: &Self::Set) -> Option<&Self::Set> {
+        if self.enabled(state) {
+            Some(&self.products)
+        } else {
+            None
+        }
+    }
+}
+
+impl PrintableWithTranslator for PositiveReaction {
+    fn print(
+        &self,
+        f: &mut std::fmt::Formatter,
+        translator: &Translator,
+    ) -> std::fmt::Result {
+        write!(
+            f,
+            "(r: {}, p: {})",
+            Formatter::from(translator, &self.reactants),
+            Formatter::from(translator, &self.products),
+        )
+    }
+}
+
+impl PositiveReaction {
+    pub fn from(reactants: PositiveSet, products: PositiveSet) -> Self {
+        Self {
+            reactants,
+            products,
+        }
+    }
+
+    pub fn create(reactants: Set, inhibitors: Set, products: Set) -> Self {
+        Self {
+            reactants: reactants
+                .to_positive_set(IdState::Positive)
+                .union(&inhibitors.to_positive_set(IdState::Negative)),
+            products:  products.to_positive_set(IdState::Positive),
+        }
+    }
+
+    /// returns the reactants that are equal
+    pub fn differ_only_one_element(&self, other: &Self) -> Option<PositiveSet> {
+        if self.products != other.products {
+            return None;
+        }
+        let mut found = false;
+        for el in self.reactants.iter() {
+            match other.reactants.identifiers.get(el.0) {
+                | None => return None,
+                | Some(s) =>
+                    if s != el.1 {
+                        if found { return None } else { found = true }
+                    },
+            }
+        }
+        Some(self.reactants.intersection(&other.reactants))
+    }
+}