elvis/ReactionSystems
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

formatting with rustfmt

Browse Source
This commit is contained in:
elvis
2025-07-01 19:22:50 +02:00
parent dcb4cbecb0
commit eba5d1266d
14 changed files with 796 additions and 639 deletions
Download Patch File Download Diff File Expand all files Collapse all files

176
src/rsprocess/perpetual.rs
View File

@ -1,15 +1,14 @@
#![allow(dead_code)]
use super::classical::compute_all_owned;
use super::translator::IdType;
use super::structure::{RSenvironment, RSprocess, RSreaction, RSset, RSsystem};
use super::translator::IdType;
// returns the prefix and the loop from a trace
fn split<'a>(
set: &'a RSset,
trace: &'a [RSset]
) -> Option<(&'a[RSset], &'a[RSset])> {
) -> Option<(&'a [RSset], &'a [RSset])> {
let position = trace.iter().rposition(|x| x == set);
position.map(|pos| trace.split_at(pos))
}
@ -23,35 +22,37 @@ fn find_loop(
let mut entities = entities;
let mut trace = vec![];
loop {
if let Some((prefix, hoop)) = split(&entities, &trace) {
return (prefix.to_vec(), hoop.to_vec());
} else {
let t = entities.union(q);
let products = compute_all_owned(&t, rs);
trace.push(entities.clone());
entities = products;
}
if let Some((prefix, hoop)) = split(&entities, &trace) {
return (prefix.to_vec(), hoop.to_vec());
} else {
let t = entities.union(q);
let products = compute_all_owned(&t, rs);
trace.push(entities.clone());
entities = products;
}
}
}
// finds the loops by simulating the system
fn find_only_loop(rs: &[RSreaction], entities: RSset, q: &RSset) -> Vec<RSset> {
fn find_only_loop(
rs: &[RSreaction],
entities: RSset,
q: &RSset
) -> Vec<RSset> {
let mut entities = entities;
let mut trace = vec![];
loop {
if let Some((_prefix, hoop)) = split(&entities, &trace) {
return hoop.to_vec();
} else {
let t = entities.union(q);
let products = compute_all_owned(&t, rs);
trace.push(entities.clone());
entities = products;
}
if let Some((_prefix, hoop)) = split(&entities, &trace) {
return hoop.to_vec();
} else {
let t = entities.union(q);
let products = compute_all_owned(&t, rs);
trace.push(entities.clone());
entities = products;
}
}
}
// finds the loops and the length of the prefix by simulating the system
fn find_prefix_len_loop(
rs: &[RSreaction],
@ -61,14 +62,14 @@ fn find_prefix_len_loop(
let mut entities = entities;
let mut trace = vec![];
loop {
if let Some((prefix, hoop)) = split(&entities, &trace) {
return (prefix.len(), hoop.to_vec());
} else {
let t = entities.union(q);
let products = compute_all_owned(&t, rs);
trace.push(entities.clone());
entities = products;
}
if let Some((prefix, hoop)) = split(&entities, &trace) {
return (prefix.len(), hoop.to_vec());
} else {
let t = entities.union(q);
let products = compute_all_owned(&t, rs);
trace.push(entities.clone());
entities = products;
}
}
}
@ -80,22 +81,25 @@ fn filter_delta<'a>(x: (&IdType, &'a RSprocess)) -> Option<&'a RSset> {
use super::structure::RSprocess::*;
let (id, rest) = x;
if let EntitySet{ entities, next_process} = rest {
if let RecursiveIdentifier{ identifier } = &**next_process {
if identifier == id {
return Some(entities);
}
}
if let EntitySet {
entities,
next_process,
} = rest
{
if let RecursiveIdentifier { identifier } = &**next_process {
if identifier == id {
return Some(entities);
}
}
}
None
}
// see lollipop
pub fn lollipops_decomposed(
delta: &RSenvironment,
reaction_rules: &[RSreaction],
available_entities: &RSset
available_entities: &RSset,
) -> Vec<(Vec<RSset>, Vec<RSset>)> {
// FIXME: i think we are only interested in "x", not all symbols that
// satisfy X = pre(Q, rec(X))
@ -110,9 +114,11 @@ pub fn lollipops_decomposed(
// see lollipop
pub fn lollipops(system: RSsystem) -> Vec<(Vec<RSset>, Vec<RSset>)> {
lollipops_decomposed(system.get_delta(),
system.get_reaction_rules(),
system.get_available_entities())
lollipops_decomposed(
system.get_delta(),
system.get_reaction_rules(),
system.get_available_entities(),
)
}
// see loop
@ -121,18 +127,21 @@ pub fn lollipops_only_loop(system: RSsystem) -> Vec<Vec<RSset>> {
// satisfy X = pre(Q, rec(X))
let filtered = system.get_delta().iter().filter_map(filter_delta);
let find_loop_fn = |q| find_only_loop(system.get_reaction_rules(),
system.get_available_entities().clone(),
q);
let find_loop_fn = |q| {
find_only_loop(
system.get_reaction_rules(),
system.get_available_entities().clone(),
q,
)
};
filtered.map(find_loop_fn).collect::<Vec<_>>()
}
pub fn lollipops_prefix_len_loop_decomposed(
delta: &RSenvironment,
reaction_rules: &[RSreaction],
available_entities: &RSset
available_entities: &RSset,
) -> Vec<(usize, Vec<RSset>)> {
// FIXME: i think we are only interested in "x", not all symbols that
// satisfy X = pre(Q, rec(X))
@ -149,15 +158,15 @@ pub fn lollipops_prefix_len_loop_decomposed(
pub fn lollipops_only_loop_decomposed(
delta: &RSenvironment,
reaction_rules: &[RSreaction],
available_entities: &RSset
available_entities: &RSset,
) -> Vec<Vec<RSset>> {
// FIXME: i think we are only interested in "x", not all symbols that
// satisfy X = pre(Q, rec(X))
let filtered = delta.iter().filter_map(filter_delta);
let find_loop_fn = |q| find_only_loop(reaction_rules,
available_entities.clone(),
q);
available_entities.clone(),
q);
filtered.map(find_loop_fn).collect::<Vec<_>>()
}
@ -175,15 +184,19 @@ fn filter_delta_named<'a>(
use super::structure::RSprocess::*;
let (id, rest) = x;
if id != symb {
return None;
return None;
}
if let EntitySet{ entities, next_process} = rest {
if let RecursiveIdentifier{ identifier } = &**next_process {
if identifier == id {
return Some(entities);
}
}
if let EntitySet {
entities,
next_process,
} = rest
{
if let RecursiveIdentifier { identifier } = &**next_process {
if identifier == id {
return Some(entities);
}
}
}
None
}
@ -193,9 +206,12 @@ pub fn lollipops_decomposed_named(
delta: &RSenvironment,
reaction_rules: &[RSreaction],
available_entities: &RSset,
symb: IdType
symb: IdType,
) -> Option<(Vec<RSset>, Vec<RSset>)> {
let filtered = delta.iter().filter_map(|x| filter_delta_named(x, &symb)).next();
let filtered = delta
.iter()
.filter_map(|x| filter_delta_named(x, &symb))
.next();
let find_loop_fn = |q| find_loop(reaction_rules,
available_entities.clone(),
@ -209,10 +225,12 @@ pub fn lollipops_named(
system: RSsystem,
symb: IdType
) -> Option<(Vec<RSset>, Vec<RSset>)> {
lollipops_decomposed_named(system.get_delta(),
system.get_reaction_rules(),
system.get_available_entities(),
symb)
lollipops_decomposed_named(
system.get_delta(),
system.get_reaction_rules(),
system.get_available_entities(),
symb,
)
}
// see loop
@ -220,13 +238,19 @@ pub fn lollipops_only_loop_named(
system: RSsystem,
symb: IdType
) -> Option<Vec<RSset>> {
let filtered = system.get_delta().iter()
.filter_map(|x| filter_delta_named(x, &symb)).next();
let filtered = system
.get_delta()
.iter()
.filter_map(|x| filter_delta_named(x, &symb))
.next();
let find_loop_fn =
|q| find_only_loop(system.get_reaction_rules(),
system.get_available_entities().clone(),
q);
let find_loop_fn = |q| {
find_only_loop(
system.get_reaction_rules(),
system.get_available_entities().clone(),
q,
)
};
filtered.map(find_loop_fn)
}
@ -235,10 +259,12 @@ pub fn lollipops_prefix_len_loop_decomposed_named(
delta: &RSenvironment,
reaction_rules: &[RSreaction],
available_entities: &RSset,
symb: IdType
symb: IdType,
) -> Option<(usize, Vec<RSset>)> {
let filtered = delta.iter()
.filter_map(|x| filter_delta_named(x, &symb)).next();
let filtered = delta
.iter()
.filter_map(|x| filter_delta_named(x, &symb))
.next();
let find_loop_fn = |q| find_prefix_len_loop(reaction_rules,
available_entities.clone(),
@ -252,10 +278,12 @@ pub fn lollipops_only_loop_decomposed_named(
delta: &RSenvironment,
reaction_rules: &[RSreaction],
available_entities: &RSset,
symb: IdType
symb: IdType,
) -> Option<Vec<RSset>> {
let filtered = delta.iter()
.filter_map(|x| filter_delta_named(x, &symb)).next();
let filtered = delta
.iter()
.filter_map(|x| filter_delta_named(x, &symb))
.next();
let find_loop_fn = |q| find_only_loop(reaction_rules,
available_entities.clone(),