710 lines
18 KiB
Rust
710 lines
18 KiB
Rust
//! Module that holds useful presets for interacting with other modules.
|
|
|
|
use std::env;
|
|
use std::fmt::Display;
|
|
use std::fs;
|
|
use std::io;
|
|
use std::io::prelude::*;
|
|
use std::rc::Rc;
|
|
|
|
use lalrpop_util::ParseError;
|
|
use petgraph::Graph;
|
|
|
|
// grammar is defined in lib.rs, calling lalrpop_mod! twice, generates twice
|
|
// the code
|
|
use crate::grammar;
|
|
|
|
use super::structure::RSlabel;
|
|
use super::structure::{RSset, RSsystem};
|
|
use super::translator::Translator;
|
|
use super::*;
|
|
|
|
|
|
// -----------------------------------------------------------------------------
|
|
// Structures
|
|
// -----------------------------------------------------------------------------
|
|
|
|
#[derive(Debug)]
|
|
pub struct SaveOptions {
|
|
pub print: bool,
|
|
pub save: Option<Vec<String>>
|
|
}
|
|
|
|
impl SaveOptions {
|
|
pub fn combine(&mut self, other: &mut Self) {
|
|
self.print = self.print || other.print;
|
|
match (self.save.is_some(), other.save.is_some()) {
|
|
(false, false) |
|
|
(true, false) => {}
|
|
(false, true) => {
|
|
self.save = other.save.to_owned();
|
|
},
|
|
(true, true) => {
|
|
self.save
|
|
.as_mut()
|
|
.unwrap()
|
|
.append(other.save.as_mut().unwrap());}
|
|
}
|
|
}
|
|
pub fn new() -> Self {
|
|
SaveOptions { print: false, save: None }
|
|
}
|
|
}
|
|
|
|
impl Default for SaveOptions {
|
|
fn default() -> Self {
|
|
SaveOptions::new()
|
|
}
|
|
}
|
|
|
|
#[derive(Debug)]
|
|
pub enum GraphSaveOptions {
|
|
Dot { so: SaveOptions },
|
|
GraphML { so: SaveOptions },
|
|
Serialize { path: String }
|
|
}
|
|
|
|
#[derive(Debug)]
|
|
pub enum Instruction {
|
|
Stats { so: SaveOptions },
|
|
Target { so: SaveOptions },
|
|
Run { so: SaveOptions },
|
|
Loop { symbol: String, so: SaveOptions },
|
|
Frequency { so: SaveOptions },
|
|
LimitFrequency { experiment: String, so: SaveOptions },
|
|
FastFrequency { experiment: String, so: SaveOptions },
|
|
Digraph { gso: Vec<GraphSaveOptions> },
|
|
}
|
|
|
|
#[derive(Debug)]
|
|
pub enum System {
|
|
Deserialize { path: String },
|
|
RSsystem { sys: RSsystem }
|
|
}
|
|
|
|
#[derive(Debug)]
|
|
pub enum EvaluatedSystem {
|
|
Graph { graph: Graph<RSsystem, RSlabel>,
|
|
translator: Translator },
|
|
System { sys: RSsystem,
|
|
translator: Translator }
|
|
}
|
|
|
|
|
|
impl System {
|
|
pub fn compute(
|
|
&self, translator: Translator
|
|
) -> Result<EvaluatedSystem, String>
|
|
{
|
|
match self {
|
|
Self::RSsystem { sys } => {
|
|
Ok(EvaluatedSystem::System { sys: sys.to_owned(), translator })
|
|
},
|
|
Self::Deserialize { path } => {
|
|
let (graph, translator) = deserialize(path.into())?;
|
|
Ok(EvaluatedSystem::Graph { graph, translator })
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
#[derive(Debug)]
|
|
pub struct Instructions {
|
|
pub system: System,
|
|
pub instructions: Vec<Instruction>
|
|
}
|
|
|
|
// -----------------------------------------------------------------------------
|
|
// Helper Functions
|
|
// -----------------------------------------------------------------------------
|
|
|
|
fn read_file<T, F>(
|
|
translator: &mut Translator,
|
|
path_string: String,
|
|
parser: F
|
|
) -> Result<T, String>
|
|
where
|
|
F: Fn(&mut Translator, String) -> Result<T, String>
|
|
{
|
|
// relative path
|
|
let mut path = match env::current_dir() {
|
|
Ok(p) => p,
|
|
Err(_) => return Err("Error getting current directory.".into())
|
|
};
|
|
path = path.join(path_string);
|
|
|
|
// we read the file with a buffer
|
|
let f = match fs::File::open(path) {
|
|
Ok(f) => f,
|
|
Err(_) => return Err("Error opening file.".into())
|
|
};
|
|
let mut buf_reader = io::BufReader::new(f);
|
|
let mut contents = String::new();
|
|
match buf_reader.read_to_string(&mut contents) {
|
|
Ok(_) => {},
|
|
Err(_) => return Err("Error reading file.".into())
|
|
}
|
|
|
|
// parse
|
|
let result = parser(translator, contents)?;
|
|
|
|
Ok(result)
|
|
}
|
|
|
|
fn reformat_error<T, S>(
|
|
e: ParseError<usize, T, &'static str>
|
|
) -> Result<S, String>
|
|
where
|
|
T: Display
|
|
{
|
|
match e {
|
|
ParseError::ExtraToken { token: (l, t, r) } => {
|
|
Err(format!(
|
|
"Unexpected token \"{t}\" \
|
|
between positions {l} and {r}."
|
|
))
|
|
},
|
|
ParseError::UnrecognizedEof { location: _, expected: _ } => {
|
|
Err("End of file encountered while parsing.".into())
|
|
},
|
|
ParseError::InvalidToken { location } => {
|
|
Err(format!("Invalid token at position {location}."))
|
|
},
|
|
ParseError::UnrecognizedToken { token: (l, t, r), expected }
|
|
=> {
|
|
Err(format!(
|
|
"Unrecognized token \"{t}\" \
|
|
between positions {l} and {r}. Expected: {expected:?}"
|
|
))
|
|
},
|
|
ParseError::User { error } => {
|
|
Err(error.to_string())
|
|
}
|
|
}
|
|
}
|
|
|
|
fn parser_experiment(
|
|
translator: &mut Translator,
|
|
contents: String
|
|
) -> Result<(Vec<u32>, Vec<RSset>), String>
|
|
{
|
|
match grammar::ExperimentParser::new()
|
|
.parse(translator, &contents)
|
|
{
|
|
Ok(sys) => Ok(sys),
|
|
Err(e) => reformat_error(e)
|
|
}
|
|
}
|
|
|
|
fn parser_instructions(
|
|
translator: &mut Translator,
|
|
contents: String
|
|
) -> Result<Instructions, String>
|
|
{
|
|
match grammar::RunParser::new()
|
|
.parse(translator, &contents)
|
|
{
|
|
Ok(sys) => Ok(sys),
|
|
Err(e) => reformat_error(e)
|
|
}
|
|
}
|
|
|
|
fn save_file(
|
|
contents: &String,
|
|
path_string: String
|
|
) -> Result<(), String>
|
|
{
|
|
// relative path
|
|
let mut path = match env::current_dir() {
|
|
Ok(p) => p,
|
|
Err(_) => return Err("Error getting current directory.".into())
|
|
};
|
|
path = path.join(path_string);
|
|
|
|
let mut f = match fs::File::create(&path) {
|
|
Ok(f) => f,
|
|
Err(_) => return Err(format!("Error creating file {}.",
|
|
path.to_str().unwrap()))
|
|
};
|
|
match write!(f, "{contents}") {
|
|
Ok(_) => {}
|
|
Err(_) => return Err("Error writing to file.".into())
|
|
}
|
|
Ok(())
|
|
}
|
|
|
|
|
|
|
|
// -----------------------------------------------------------------------------
|
|
// main_do
|
|
// -----------------------------------------------------------------------------
|
|
|
|
/// Prints statistics of the system.
|
|
/// Equivalent main_do(stat) or main_do(stat, MissingE)
|
|
pub fn stats(system: &EvaluatedSystem) -> Result<String, String> {
|
|
match system {
|
|
EvaluatedSystem::System { sys, translator } => {
|
|
Ok(statistics::of_RSsystem(translator, sys))
|
|
},
|
|
EvaluatedSystem::Graph { graph, translator } => {
|
|
let Some(sys) = graph.node_weights().next()
|
|
else {
|
|
return Err("No node found in graph".into());
|
|
};
|
|
Ok(statistics::of_RSsystem(translator, sys))
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
/// Prints a final set of entities in a terminating Reaction System.
|
|
/// The system needs to terminate to return.
|
|
/// Equivalent to main_do(target, E)
|
|
pub fn target(system: &EvaluatedSystem) -> Result<String, String> {
|
|
let (res, translator) = match system {
|
|
EvaluatedSystem::System { sys, translator } => {
|
|
(transitions::target(sys)?, translator)
|
|
},
|
|
EvaluatedSystem::Graph { graph, translator } => {
|
|
let Some(sys) = graph.node_weights().next()
|
|
else {
|
|
return Err("No node found in graph".into());
|
|
};
|
|
(transitions::target(sys)?, translator)
|
|
}
|
|
};
|
|
Ok(format!(
|
|
"After {} steps we arrive at state:\n{}",
|
|
res.0,
|
|
translator::RSsetDisplay::from(translator, &res.1)
|
|
))
|
|
}
|
|
|
|
|
|
/// Finds the list of traversed states in a (deterministic) terminating
|
|
/// reaction.
|
|
/// The system needs to terminate to return.
|
|
/// equivalent to main_do(run,Es)
|
|
pub fn traversed(system: &EvaluatedSystem) -> Result<String, String> {
|
|
let (res, translator) = match system {
|
|
EvaluatedSystem::System { sys, translator } => {
|
|
(transitions::run_separated(sys)?, translator)
|
|
},
|
|
EvaluatedSystem::Graph { graph, translator } => {
|
|
let Some(sys) = graph.node_weights().next()
|
|
else {
|
|
return Err("No node found in graph".into());
|
|
};
|
|
(transitions::run_separated(sys)?, translator)
|
|
}
|
|
};
|
|
|
|
let mut output = String::new();
|
|
|
|
output.push_str("The trace is composed by the set of entities:");
|
|
for (e, _c, _t) in res {
|
|
output.push_str(
|
|
&format!(
|
|
"{}",
|
|
translator::RSsetDisplay::from(translator, &e)
|
|
)
|
|
);
|
|
}
|
|
Ok(output)
|
|
}
|
|
|
|
|
|
|
|
/// Finds the looping list of states in a reaction system with a perpetual
|
|
/// context. IMPORTANT: for loops, we assume Delta defines the process constant
|
|
/// x = Q.x and the context process is x .
|
|
/// equivalent to main_do(loop,Es)
|
|
pub fn hoop(
|
|
system: &EvaluatedSystem, symbol: String
|
|
) -> Result<String, String>
|
|
{
|
|
let (res, translator) = match system {
|
|
EvaluatedSystem::System { sys, translator } => {
|
|
(sys, translator)
|
|
},
|
|
EvaluatedSystem::Graph { graph, translator } => {
|
|
let Some(sys) = graph.node_weights().next()
|
|
else {
|
|
return Err("No node found in graph".into());
|
|
};
|
|
(sys, translator)
|
|
}
|
|
};
|
|
// we retrieve the id for "x" and use it to find the corresponding loop
|
|
let Some(id) = translator.encode_not_mut(&symbol)
|
|
else {
|
|
return Err(format!("Symbol {symbol} not found"));
|
|
};
|
|
let res =
|
|
match perpetual::lollipops_only_loop_named(res, id) {
|
|
Some(o) => o,
|
|
None => {
|
|
return Err("No loop found.".into());
|
|
}
|
|
};
|
|
|
|
let mut output = String::new();
|
|
|
|
output.push_str("The loop is composed by the sets:");
|
|
for e in res {
|
|
output.push_str(
|
|
&format!( "{}", translator::RSsetDisplay::from(translator, &e))
|
|
);
|
|
}
|
|
|
|
Ok(output)
|
|
}
|
|
|
|
/// Finds the frequency of each entity in the traversed states for a
|
|
/// (deterministic) terminating Reaction System.
|
|
/// equivalent to main_do(freq, PairList)
|
|
pub fn freq(
|
|
system: &EvaluatedSystem
|
|
) -> Result<String, String> {
|
|
let (sys, translator) = match system {
|
|
EvaluatedSystem::System { sys, translator } => {
|
|
(sys, translator)
|
|
},
|
|
EvaluatedSystem::Graph { graph, translator } => {
|
|
let Some(sys) = graph.node_weights().next()
|
|
else {
|
|
return Err("No node found in graph".into());
|
|
};
|
|
(sys, translator)
|
|
}
|
|
};
|
|
|
|
let res = frequency::naive_frequency(sys)?;
|
|
|
|
Ok(format!(
|
|
"Frequency of encountered symbols:\n{}",
|
|
translator::FrequencyDisplay::from(translator, &res)
|
|
))
|
|
}
|
|
|
|
|
|
/// Finds the frequency of each entity in the limit loop of a nonterminating
|
|
/// Reaction System whose context has the form Q1 ... Q1.Q2 ... Q2 ... Qn ...
|
|
/// equivalent to main_do(limitfreq, PairList)
|
|
pub fn limit_freq(
|
|
system: &mut EvaluatedSystem,
|
|
experiment: String
|
|
) -> Result<String, String>
|
|
{
|
|
let (sys, translator): (&RSsystem, &mut Translator) = match system {
|
|
EvaluatedSystem::System { sys, translator } => {
|
|
(sys, translator)
|
|
},
|
|
EvaluatedSystem::Graph { graph, translator } => {
|
|
let Some(sys) = graph.node_weights().next()
|
|
else {
|
|
return Err("No node found in graph".into());
|
|
};
|
|
(sys, translator)
|
|
}
|
|
};
|
|
|
|
let (_, sets) = read_file(translator,
|
|
experiment,
|
|
parser_experiment)?;
|
|
|
|
let res = match frequency::limit_frequency(&sets,
|
|
&sys.reaction_rules,
|
|
&sys.available_entities) {
|
|
Some(e) => e,
|
|
None => {return Err("Error calculating frequency.".into());}
|
|
};
|
|
|
|
Ok(format!(
|
|
"Frequency of encountered symbols:\n{}",
|
|
translator::FrequencyDisplay::from(translator, &res)
|
|
))
|
|
}
|
|
|
|
|
|
/// Finds the frequency of each entity in the traversed loops of a terminating
|
|
/// reaction system whose context has the form
|
|
/// Q1 ... Q1.Q2 ... Q2 ... Qn ... Qn.nil and each Qi is repeated Wi times
|
|
/// read from a corresponding file.
|
|
/// equivalent to main_do(fastfreq, PairList)
|
|
pub fn fast_freq(
|
|
system: &mut EvaluatedSystem,
|
|
experiment: String
|
|
) -> Result<String, String>
|
|
{
|
|
let (sys, translator): (&RSsystem, &mut Translator) = match system {
|
|
EvaluatedSystem::System { sys, translator } => {
|
|
(sys, translator)
|
|
},
|
|
EvaluatedSystem::Graph { graph, translator } => {
|
|
let Some(sys) = graph.node_weights().next()
|
|
else {
|
|
return Err("No node found in graph".into());
|
|
};
|
|
(sys, translator)
|
|
}
|
|
};
|
|
|
|
let (weights, sets) = read_file(translator,
|
|
experiment,
|
|
parser_experiment)?;
|
|
|
|
let res = match frequency::fast_frequency(&sets,
|
|
&sys.reaction_rules,
|
|
&sys.available_entities,
|
|
&weights) {
|
|
Some(e) => e,
|
|
None => {return Err("Error calculating frequency.".into());}
|
|
};
|
|
|
|
Ok(format!(
|
|
"Frequency of encountered symbols:\n{}",
|
|
translator::FrequencyDisplay::from(translator, &res)
|
|
))
|
|
}
|
|
|
|
/// Computes the LTS.
|
|
/// equivalent to main_do(digraph, Arcs) or to main_do(advdigraph, Arcs)
|
|
pub fn digraph(
|
|
system: &mut EvaluatedSystem
|
|
) -> Result<(), String> {
|
|
*system = if let EvaluatedSystem::System { sys, translator } = system {
|
|
EvaluatedSystem::Graph {
|
|
graph: graph::digraph(sys.clone())?,
|
|
translator: translator.to_owned()
|
|
}
|
|
} else {
|
|
return Ok(());
|
|
};
|
|
Ok(())
|
|
}
|
|
|
|
|
|
// -----------------------------------------------------------------------------
|
|
// Output Functions
|
|
// -----------------------------------------------------------------------------
|
|
|
|
/// Writes the specified graph to a file in .dot format.
|
|
pub fn dot(system: &EvaluatedSystem) -> Result<String, String> {
|
|
match system {
|
|
EvaluatedSystem::System { sys:_, translator:_ } =>
|
|
Err("Supplied system is not a graph".into()),
|
|
EvaluatedSystem::Graph { graph, translator } => {
|
|
let rc_translator = Rc::new(translator.to_owned());
|
|
// map each value to the corresponding value we want to display
|
|
let modified_graph = graph.map(
|
|
|id, node|
|
|
graph::GraphMapNodesTy::from(
|
|
graph::GraphMapNodes::Entities,
|
|
Rc::clone(&rc_translator)
|
|
).get()(id, node)
|
|
+ "; " +
|
|
&graph::GraphMapNodesTy::from(
|
|
graph::GraphMapNodes::Context,
|
|
Rc::clone(&rc_translator)
|
|
).get()(id, node),
|
|
graph::GraphMapEdgesTy::from(
|
|
graph::GraphMapEdges::EntitiesAdded,
|
|
Rc::clone(&rc_translator)
|
|
).get()
|
|
);
|
|
|
|
let graph = Rc::new(graph.to_owned());
|
|
|
|
let edge_formatter = graph::default_edge_formatter(
|
|
Rc::clone(&graph)
|
|
);
|
|
let node_formatter = graph::default_node_formatter(
|
|
Rc::clone(&graph)
|
|
);
|
|
|
|
let dot = rsdot::RSDot::with_attr_getters(
|
|
&modified_graph,
|
|
&[],
|
|
&edge_formatter,
|
|
&node_formatter,
|
|
);
|
|
|
|
Ok(format!("{dot}"))
|
|
}
|
|
}
|
|
}
|
|
|
|
/// Writes the specified graph to a file in .graphml format.
|
|
pub fn graphml(system: &EvaluatedSystem) -> Result<String, String> {
|
|
match system {
|
|
EvaluatedSystem::System { sys:_, translator:_ } =>
|
|
Err("Supplied system is not a graph".into()),
|
|
EvaluatedSystem::Graph { graph, translator } => {
|
|
let rc_translator = Rc::new(translator.to_owned());
|
|
|
|
// map each value to the corresponding value we want to display
|
|
let modified_graph = graph.map(
|
|
|id, node|
|
|
graph::GraphMapNodesTy::from(
|
|
graph::GraphMapNodes::Entities,
|
|
Rc::clone(&rc_translator)
|
|
).get()(id, node)
|
|
+ "; " +
|
|
&graph::GraphMapNodesTy::from(
|
|
graph::GraphMapNodes::Context,
|
|
Rc::clone(&rc_translator)
|
|
).get()(id, node),
|
|
graph::GraphMapEdgesTy::from(graph::GraphMapEdges::EntitiesAdded,
|
|
Rc::clone(&rc_translator)).get()
|
|
);
|
|
|
|
use petgraph_graphml::GraphMl;
|
|
let graphml = GraphMl::new(&modified_graph)
|
|
.pretty_print(true)
|
|
.export_node_weights_display()
|
|
.export_edge_weights_display();
|
|
|
|
Ok(format!("{graphml}"))
|
|
}
|
|
}
|
|
}
|
|
|
|
/// Writes the specified graph, translator tuple to file.
|
|
/// N.B. graph size in memory might be much larger after serialization and
|
|
/// deserialization.
|
|
pub fn serialize(
|
|
system: &EvaluatedSystem,
|
|
path: String
|
|
) -> Result<(), String>
|
|
{
|
|
match system {
|
|
EvaluatedSystem::System { sys:_, translator:_ } =>
|
|
Err("Supplied system is not a graph".into()),
|
|
EvaluatedSystem::Graph { graph, translator } => {
|
|
// relative path
|
|
let mut path = std::path::PathBuf::from(path);
|
|
path.set_extension("cbor");
|
|
|
|
let f = match fs::File::create(&path) {
|
|
Ok(f) => f,
|
|
Err(_) => return Err(format!("Error creating file {}.",
|
|
path.to_str().unwrap()))
|
|
};
|
|
|
|
match serialize::ser(f, graph, translator) {
|
|
Ok(_) => Ok(()),
|
|
Err(_) => Err("Error during serialization.".into())
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/// Reads the specified serialized system from a file.
|
|
/// N.B. graph size in memory might be much larger after serialization and
|
|
/// deserialization
|
|
pub fn deserialize(
|
|
input_path: String
|
|
) -> Result<(Graph<RSsystem, RSlabel>, Translator), String>
|
|
{
|
|
// relative path
|
|
let mut path = match env::current_dir() {
|
|
Ok(p) => p,
|
|
Err(_) => return Err("Error getting current directory.".into())
|
|
};
|
|
path = path.join(input_path);
|
|
path.set_extension("cbor");
|
|
|
|
let f = match fs::File::open(&path) {
|
|
Ok(f) => f,
|
|
Err(_) => return Err(format!("Error opening file {}.",
|
|
path.to_str().unwrap()))
|
|
};
|
|
|
|
match serialize::de(f) {
|
|
Ok(a) => Ok(a),
|
|
Err(_) => Err("Error during deserialization.".into())
|
|
}
|
|
}
|
|
|
|
|
|
//------------------------------------------------------------------------------
|
|
// Interpreting Instructions
|
|
//------------------------------------------------------------------------------
|
|
|
|
macro_rules! save_options {
|
|
($assignment: expr, $so: ident) => {
|
|
let SaveOptions { print, save } = $so;
|
|
let output = $assignment;
|
|
if print {
|
|
println!("{output}");
|
|
}
|
|
if let Some(save) = save {
|
|
for file in save {
|
|
save_file(&output, file)?;
|
|
}
|
|
}
|
|
};
|
|
}
|
|
|
|
fn execute(
|
|
instruction: Instruction,
|
|
system: &mut EvaluatedSystem
|
|
) -> Result<(), String> {
|
|
match instruction {
|
|
Instruction::Stats { so } => {
|
|
save_options!(stats(system)?, so);
|
|
}
|
|
Instruction::Target { so } => {
|
|
save_options!(target(system)?, so);
|
|
},
|
|
Instruction::Run { so } => {
|
|
save_options!(traversed(system)?, so);
|
|
},
|
|
Instruction::Loop { symbol, so } => {
|
|
save_options!(hoop(system, symbol)?, so);
|
|
},
|
|
Instruction::Frequency { so } => {
|
|
save_options!(freq(system)?, so);
|
|
},
|
|
Instruction::LimitFrequency { experiment, so } => {
|
|
save_options!(limit_freq(system, experiment)?, so);
|
|
},
|
|
Instruction::FastFrequency { experiment, so } => {
|
|
save_options!(fast_freq(system, experiment)?, so);
|
|
},
|
|
Instruction::Digraph { gso } => {
|
|
for save in gso {
|
|
digraph(system)?;
|
|
match save {
|
|
GraphSaveOptions::Dot { so } => {
|
|
save_options!(dot(system)?, so);
|
|
},
|
|
GraphSaveOptions::GraphML { so } => {
|
|
save_options!(graphml(system)?, so);
|
|
},
|
|
GraphSaveOptions::Serialize { path } => {
|
|
serialize(system, path)?;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
Ok(())
|
|
}
|
|
|
|
pub fn run(path: String) -> Result<(), String> {
|
|
let mut translator = Translator::new();
|
|
|
|
let Instructions { system, instructions } =
|
|
read_file(&mut translator, path, parser_instructions)?;
|
|
|
|
let mut system = system.compute(translator)?;
|
|
|
|
for instr in instructions {
|
|
execute(instr, &mut system)?;
|
|
}
|
|
|
|
Ok(())
|
|
}
|