Struct CtmpProcess 

pub struct CtmpProcess { /* private fields */ }

This structure represents a Continuous Time Markov process

• Arguments

• param - An Option containing the parameters of the process

 use std::collections::BTreeSet;
 use reCTBN::process::NetworkProcess;
 use reCTBN::params;
 use reCTBN::process::ctbn::*;
 use ndarray::arr3;

 //Create the domain for a discrete node
 let mut domain = BTreeSet::new();
 domain.insert(String::from("A"));
 domain.insert(String::from("B"));

 //Create the parameters for a discrete node using the domain
 let param = params::DiscreteStatesContinousTimeParams::new("X1".to_string(), domain);

 //Create the node using the parameters
 let X1 = params::Params::DiscreteStatesContinousTime(param);

 let mut domain = BTreeSet::new();
 domain.insert(String::from("A"));
 domain.insert(String::from("B"));
 let param = params::DiscreteStatesContinousTimeParams::new("X2".to_string(), domain);
 let X2 = params::Params::DiscreteStatesContinousTime(param);

 //Initialize a ctbn
 let mut net = CtbnNetwork::new();

 //Add nodes
 let X1 = net.add_node(X1).unwrap();
 let X2 = net.add_node(X2).unwrap();

 //Add an edge
 net.add_edge(X1, X2);
 match &mut net.get_node_mut(X1) {
     params::Params::DiscreteStatesContinousTime(param) => {
         assert_eq!(Ok(()), param.set_cim(arr3(&[[[-0.1, 0.1], [1.0, -1.0]]])));
     }
 }

 match &mut net.get_node_mut(X2) {
     params::Params::DiscreteStatesContinousTime(param) => {
         assert_eq!(
             Ok(()),
             param.set_cim(arr3(&[
                 [[-0.01, 0.01], [5.0, -5.0]],
                 [[-5.0, 5.0], [0.01, -0.01]]
             ]))
         );
     }
 }
 //Amalgamate the ctbn into a CtmpProcess
 let ctmp = net.amalgamation();

 //Extract the amalgamated params from the ctmp
let params::Params::DiscreteStatesContinousTime(p_ctmp) = &ctmp.get_node(0);
let p_ctmp = p_ctmp.get_cim().as_ref().unwrap();

 //The shape of the params for an amalgamated ctmp can be computed as a Cartesian product of the
 //domains variables of the ctbn
 assert_eq!(p_ctmp.shape()[1], 4);

Implementations

impl CtmpProcess

pub fn new() -> CtmpProcess

Trait Implementations

impl NetworkProcess for CtmpProcess

fn initialize_adj_matrix(&mut self)

fn add_node(&mut self, n: Params) -> Result<usize, NetworkError>

Add a node to the network

fn add_edge(&mut self, _parent: usize, _child: usize)

Add a directed edge between a two nodes of the network.

fn get_node_indices(&self) -> Range<usize>

Get all the indices of the nodes contained inside the network.

fn get_number_of_nodes(&self) -> usize

Get the numbers of nodes contained in the network.

fn get_node(&self, node_idx: usize) -> &Params

Get the node param.

fn get_node_mut(&mut self, node_idx: usize) -> &mut Params

Get the node param.

fn get_param_index_network( &self, node: usize, current_state: &NetworkProcessState, ) -> usize

Compute the index that must be used to access the parameters of a node, given a specific configuration of the network.

fn get_param_index_from_custom_parent_set( &self, _current_state: &NetworkProcessState, _parent_set: &BTreeSet<usize>, ) -> usize

Compute the index that must be used to access the parameters of a node, given a specific configuration of the network and a generic parent_set.

fn get_parent_set(&self, node: usize) -> BTreeSet<usize>

Get the parent set of a given node.

fn get_children_set(&self, node: usize) -> BTreeSet<usize>

Get the children set of a given node.