Struct biodivine_sketchbook::sketchbook::model::_regulation::Regulation

pub struct Regulation {
    regulator: VarId,
    target: VarId,
    essential: Essentiality,
    regulation_sign: Monotonicity,
}

Describes an interaction between two variables, regulator and target. Every regulation can be monotonous and can be set as essential:

Monotonicity is positive, negative, dual, or unknown. The monotonicity signifies how the presence of the regulator affects the value of the target:

• if the regulation is positive, it might only increase the target value
• if the regulation is negative, it might only decrease the target value
• if the regulation is dual, it might both increase or decrease the target value (in different contexts)

If essentiality is set to true, the regulator must have influence on the outcome of the target update function in some context. If set to False, this regulation must have no effect. If it is Unknown, the essentiality is not enforced (i.e. the regulator can have an influence on the target, but it is not required).

Regulations can be represented as strings in the form "regulator_name 'relationship' target_name". The ‘relationship’ starts with -, which is followed by > for activation (positive monotonicity), | for inhibition (negative monotonicity), * for dual effect (non-monotonic) or ? for unspecified monotonicity. Finally, an additional X, ? at the end of ‘relationship’ signifies that the the regulation is non-essential (non-essential) or the essentiality is unknown, respectively. Together, this gives the following options: ->, ->?, -|, -|?, -*, -*?, -?, -??.

Fields

regulator: VarId

target: VarId

essential: Essentiality

regulation_sign: Monotonicity

Implementations

impl Regulation

Methods for safely generating new Regulations.

pub fn new( regulator: VarId, target: VarId, essential: Essentiality, regulation_sign: Monotonicity, ) -> Regulation

Create new Regulation given all the components.

pub fn try_from_string(regulation_str: &str) -> Result<Regulation, String>

Try to read the regulation from a given string in the standard format. Returns error if the string is invalid.

pub fn try_components_from_string( regulation_str: &str, ) -> Result<(String, Monotonicity, Essentiality, String), String>

Try to read all available information about a regulation from a given string in the standard format.

The returned data correspond to the items as they appear in the string, i.e. regulator, regulation_sign, essentiality and target. If the string is not valid, returns None.

impl Regulation

Basic getters and other non-modifying methods.

pub fn is_essential(&self) -> bool

Check if the regulation is marked as essential.

Note that both negative or unknown essentiality results in false.

pub fn get_essentiality(&self) -> &Essentiality

Get the essentiality of the regulation.

pub fn get_sign(&self) -> &Monotonicity

Get the sign of the regulation.

pub fn get_regulator(&self) -> &VarId

Get the VarId of the regulator.

pub fn get_target(&self) -> &VarId

Get the VarId of the target.

impl Regulation

Methods for editing Regulations.

pub fn swap_regulator(&mut self, new_regulator: VarId)

Directly swap original regulator with a given one.

pub fn swap_target(&mut self, new_target: VarId)

Directly swap original target with a given one.

pub fn swap_sign(&mut self, new_sign: Monotonicity)

Directly swap original sign with a given one.

pub fn swap_essentiality(&mut self, new_essentiality: Essentiality)

Directly swap original essentiality with a given one.

Trait Implementations

impl Clone for Regulation

fn clone(&self) -> Regulation

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Regulation

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Regulation

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for Regulation

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

Standard format that can be parsed back.

impl Hash for Regulation

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for Regulation

fn eq(&self, other: &Regulation) -> 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 Serialize for Regulation

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Eq for Regulation

impl StructuralPartialEq for Regulation