Struct biodivine_sketchbook::sketchbook::observations::_dataset::Dataset

pub struct Dataset {
    name: String,
    annotation: String,
    observations: Vec<Observation>,
    variables: Vec<VarId>,
    index_map: HashMap<ObservationId, usize>,
}

An ordered list of observations for given variables. The order is important for some datasets, for example, to be able to capture time series.

Dataset provides classical Rust API for modifications. It also manages its observations through event-based API. However, this API is limited, and only serves as an extension to that of the ObservationManager.

Fields

name: String

annotation: String

observations: Vec<Observation>

List of binarized observations.

variables: Vec<VarId>

Variables captured by the observations.

index_map: HashMap<ObservationId, usize>

Index map from observation IDs to their index in vector, for faster searching.

Implementations

impl Dataset

Creating new Dataset instances.

pub fn new( name: &str, observations: Vec<Observation>, var_names: Vec<&str>, ) -> Result<Self, String>

Create new dataset from a list of observations and variables.

Length of each observation and number of variables must match. Observation IDs must be valid identifiers and must be unique. Annotation is empty (for annotated version, check Dataset::new_annotated)

pub fn new_annotated( name: &str, annotation: &str, observations: Vec<Observation>, var_names: Vec<&str>, ) -> Result<Self, String>

Create new dataset from a list of observations and variables.

Length of each observation and number of variables must match. Observation IDs must be valid identifiers and must be unique.

pub fn new_empty(name: &str, var_names: Vec<&str>) -> Result<Self, String>

Shorthand to create new empty dataset over given variables, with empty annotation.

pub fn default(name: &str) -> Dataset

Default dataset instance with no Variables or Observations, and with an empty annotation.

fn try_convert_vars(var_names: &[&str]) -> Result<Vec<VarId>, String>

(internal) Try converting variables string slices into VarIDs.

impl Dataset

Editing Dataset instances.

pub fn set_name(&mut self, name: &str) -> Result<(), String>

Set dataset’s name.

pub fn set_annotation(&mut self, annotation: &str)

Set dataset’s annotation string.

pub fn push_obs(&mut self, obs: Observation) -> Result<(), String>

Add observation at the end of the dataset.

The observation must have the same length as is the number of dataset’s variables, and its id must not be already present in the dataset.

pub fn pop_obs(&mut self)

Remove observation from the end of the dataset. If no observations, nothing happens.

pub fn remove_obs(&mut self, id: &ObservationId) -> Result<(), String>

Remove observation with given ID from the dataset. The ID must be valid

This operation might be very costly, as we must reindex all subsequent observations.

pub fn insert_obs( &mut self, index: usize, obs: Observation, ) -> Result<(), String>

Add observation to a given index in the dataset.

This operation might be very costly, as we must reindex all subsequent observations.

pub fn remove_var(&mut self, var_id: &VarId) -> Result<(), String>

Remove variable and all the values corresponding to it (decrementing dimension of the dataset in process).

pub fn remove_var_by_str(&mut self, id: &str) -> Result<(), String>

Remove variable and all the values corresponding to it (decrementing dimension of the dataset in process).

pub fn add_var_default( &mut self, var_id: VarId, index: usize, ) -> Result<(), String>

Add variable to a specific index, and fill its values in all observations with “*” placeholders.

pub fn add_var_default_by_str( &mut self, id: &str, index: usize, ) -> Result<(), String>

Add variable to a specific index, and fill its values in all observations with “*” placeholders.

pub fn set_observation_raw( &mut self, id: &ObservationId, obs: Observation, ) -> Result<(), String>

Swap the whole observation data for given ID.

pub fn swap_obs_values( &mut self, id: &ObservationId, new_values: Vec<VarValue>, ) -> Result<(), String>

Swap value vector for an observation with given ID. The new vector of values must be of the same length as the original.

pub fn set_var_id( &mut self, original_id: &VarId, new_id: VarId, ) -> Result<(), String>

Set the id of variable with original_id to new_id.

pub fn set_var_id_by_str( &mut self, original_id: &str, new_id: &str, ) -> Result<(), String>

Set the id of variable given by string original_id to new_id.

pub fn set_all_variables( &mut self, new_variables_list: Vec<VarId>, ) -> Result<(), String>

Set the list of all variable IDs (essentially renaming some/all of them). The length of the new list must be the same as existing one (only renaming, not adding/removing variables).

pub fn set_all_variables_by_str( &mut self, new_variables_list: Vec<&str>, ) -> Result<(), String>

Set the list with all variable IDs (essentially renaming some/all of them) using string names. The length of the new list must be the same as existing one (only renaming, not adding/removing variables).

pub fn set_obs_id( &mut self, original_id: &ObservationId, new_id: ObservationId, ) -> Result<(), String>

Set the id of an observation with original_id to new_id.

pub fn set_obs_id_by_str( &mut self, original_id: &str, new_id: &str, ) -> Result<(), String>

Set the id of observation given by string original_id to new_id.

pub fn set_obs_name( &mut self, id: &ObservationId, new_name: &str, ) -> Result<(), String>

Set name of a given observation.

pub fn set_obs_annot( &mut self, id: &ObservationId, new_annot: &str, ) -> Result<(), String>

Set annotation of a given observation.

impl Dataset

Observing Dataset instances.

pub fn get_name(&self) -> &str

Name of the dataset.

pub fn get_annotation(&self) -> &str

Annotation string of the dataset.

pub fn num_observations(&self) -> usize

Number of observations in the dataset.

pub fn num_variables(&self) -> usize

Number of variables tracked by the dataset.

pub fn is_valid_variable(&self, var: &VarId) -> bool

Check if variable is tracked in this dataset.

pub fn is_valid_obs(&self, id: &ObservationId) -> bool

Check if observation is present in this dataset.

pub fn get_obs_on_idx(&self, index: usize) -> Result<&Observation, String>

Observation on given index (indexing starts at 0).

pub fn get_obs(&self, id: &ObservationId) -> Result<&Observation, String>

Observation with given ID.

pub fn get_obs_id(&self, index: usize) -> &ObservationId

ID of an observation on given index.

pub fn get_obs_id_by_str(&self, id: &str) -> Result<ObservationId, String>

ID of an observation on given index.

pub fn get_obs_index(&self, id: &ObservationId) -> Result<usize, String>

Get index of given observation, or None (if not present). Indexing starts at 0.

pub fn observations(&self) -> &Vec<Observation>

Vector of all observations.

pub fn variables(&self) -> &Vec<VarId>

Vector of all variables.

pub fn variable_names(&self) -> Vec<String>

Vector of all variable names.

pub fn get_var_id(&self, id: &str) -> Result<&VarId, String>

Get VarId for a corresponding string identifier, if it is valid.

pub fn get_var_on_idx(&self, index: usize) -> Result<&VarId, String>

Variable on given index.

pub fn get_idx_of_var(&self, var_id: &VarId) -> Result<usize, String>

Index of given variable.

pub fn to_debug_string(&self, list_all: bool) -> String

Make a string describing this Dataset in a human-readable format. If list_all is set to true, all observation vectors are listed. Otherwise, just a summary is given (number of observations).

This is mainly for debug purposes, as it is different than classical string serialization.

fn assert_no_obs(&self, id: &ObservationId) -> Result<(), String>

(internal) Utility method to ensure there is no observation with given ID yet.

fn assert_valid_obs(&self, id: &ObservationId) -> Result<(), String>

(internal) Utility method to ensure there is a observation with given ID.

fn assert_no_variable(&self, var_id: &VarId) -> Result<(), String>

(internal) Utility method to ensure there is no variable with given Id yet.

fn assert_valid_variable(&self, var_id: &VarId) -> Result<(), String>

(internal) Utility method to ensure there is a variable with given Id.

impl Dataset

Implementation for events related to modifying observations in a particular Dataset. Dataset does not implement SessionState trait directly. Instead, it just offers methods to perform certain events, after the preprocessing is done by ObservationManager.

pub(in sketchbook::observations) fn event_push_observation( &mut self, event: &Event, dataset_id: DatasetId, ) -> Result<Consumed, DynError>

Perform event of adding a new observation to the end of this Dataset.

pub(in sketchbook::observations) fn event_push_empty_observation( &mut self, event: &Event, dataset_id: DatasetId, ) -> Result<Consumed, DynError>

Perform event of adding a completely new “empty” observation to the end of this Dataset.

All its values are unspecified and its Id is newly generated.

pub(in sketchbook::observations) fn event_pop_observation( &mut self, event: &Event, dataset_id: DatasetId, ) -> Result<Consumed, DynError>

Perform event of removing the last observation from this Dataset.

pub(in sketchbook::observations) fn event_modify_observation( &mut self, event: &Event, action: &str, dataset_id: DatasetId, obs_id: ObservationId, ) -> Result<Consumed, DynError>

impl Dataset

Methods for safely generating new valid (unique) instances of identifiers for the current Dataset.

pub fn generate_obs_id( &self, ideal_id: &str, start_index: Option<usize>, ) -> ObservationId

Generate valid ObservationId that’s currently not used by any observation in this Dataset.

First, the given ideal_id and its transformation by replacing invalid characters are tried. If they are both invalid (non-unique), a numerical identifier is added at the end. By specifying start_index, the index search starts directly at that number (e.g., when ideal ID is “obs” and start index is 3, search for ID starts with “obs_3”, “obs_4”, …)

Warning: Do not use this to pre-generate more than one id at a time, as the process is deterministic and might generate the same IDs. Always generate an Id, add that observation, and then repeat for other observations.

pub fn generate_var_id( &self, ideal_id: &str, start_index: Option<usize>, ) -> VarId

Generate valid VarId that’s currently not used by any variable in this Dataset.

First, the given ideal_id and its transformation by replacing invalid characters are tried. If they are both invalid (non-unique), a numerical identifier is added at the end. By specifying start_index, the index search starts directly at that number (e.g., when ideal ID is “var” and start index is 3, search for ID starts with “var_3”, “var_4”, …)

Warning: Do not use this to pre-generate more than one id at a time, as the process is deterministic and might generate the same IDs. Always generate an Id, add that variable, and then repeat for other variables.

Trait Implementations

impl Clone for Dataset

fn clone(&self) -> Dataset

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Dataset

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Manager for Dataset

fn generate_id<T>( &self, ideal_id: &str, is_taken: &dyn Fn(&Self, &T) -> bool, num_indices: usize, start_index: Option<usize>, ) -> T

where T: FromStr, <T as FromStr>::Err: Debug,

Generate an ID of type T for a certain component of a manager (e.g., generate a VariableId for a Variable in a ModelState).

fn assert_ids_unique_and_used<T>( &self, id_list: &Vec<&str>, assert_id_is_managed: &dyn Fn(&Self, &T) -> Result<(), String>, ) -> Result<(), String>

where T: Eq + Hash + Debug + FromStr, <T as FromStr>::Err: Debug,

Check that the list of (typesafe or string) IDs contains only unique IDs (no duplicates), and check that all of the IDs are already managed by the manager instance (this is important, for instance, when we need to change already existing elements).

fn assert_ids_unique_and_new<T>( &self, id_list: &Vec<&str>, assert_id_is_new: &dyn Fn(&Self, &T) -> Result<(), String>, ) -> Result<(), String>

where T: Eq + Hash + Debug + FromStr, <T as FromStr>::Err: Debug,

Check that the list of (typesafe or string) IDs contains only unique IDs (no duplicates), and check that all of the IDs are NOT yet managed by the manager instance, i.e., they are fresh new values (this is important, for instance, when we need to add several new elements).

impl PartialEq for Dataset

fn eq(&self, other: &Dataset) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl SessionHelper for Dataset

fn starts_with<'a, 'b>( prefix: &str, at_path: &'a [&'b str], ) -> Option<&'a [&'b str]>

A utility function which checks if at_path starts with a specific first segment. If yes, returns the remaining part of the path.

fn matches(expected: &[&str], at_path: &[&str]) -> bool

A utility function which checks if at_path is exactly

fn invalid_path_error_generic<T>(at_path: &[&str]) -> Result<T, DynError>

A utility function which emits a generic “invalid path” error.

fn invalid_path_error_specific<T>( path: &[&str], component: &str, ) -> Result<T, DynError>

A utility function which emits a “invalid path” error mentioning specific state’s component.

fn clone_payload_str(event: &Event, component: &str) -> Result<String, DynError>

A utility function to get and clone a payload of an event. Errors if payload is empty.

fn assert_path_length( path: &[&str], length: usize, component: &str, ) -> Result<(), DynError>

A utility function to assert that path has a given length, or emit a DynError otherwise.

fn assert_payload_empty(event: &Event, component: &str) -> Result<(), DynError>

A utility function to assert that payload is empty - otherwise, DynError is emitted.

impl Eq for Dataset

impl StructuralPartialEq for Dataset