Struct MultilinearInfo 

pub struct MultilinearInfo { /* private fields */ }

Represents the information for a multilinear system.

Implementations

impl MultilinearInfo

pub fn iter(&self) -> impl Iterator<Item = (Event, &EventNode)>

Returns an iterator over the events and the event nodes containing the changes.

impl MultilinearInfo

pub fn new() -> Self

Creates a new instance of MultilinearInfo.

Examples found in repository

examples/example.rs (line 5)

fn main() {
    let mut story = MultilinearInfo::new();

    // Create aspects
    let place = story.add_aspect();
    let clothes = story.add_aspect();

    // Define event: Move from bedroom to living room
    let event_move = story
        .add_event()
        .with_change(&[Change::transition(place, 0, 1)])
        .unwrap()
        .event();

    // Define event: Change clothes in bedroom
    let event_clothes = story
        .add_event()
        .with_change(&[
            Change::condition(place, 0),
            Change::transition(clothes, 1, 0),
        ])
        .unwrap()
        .event();

    let mut simulation = MultilinearSimulation::new(story);
    simulation.try_call(event_clothes);
    simulation.try_call(event_move);
    simulation.try_revert(event_move);
}

pub fn add_aspect(&mut self) -> Aspect

Adds a new aspect to the multilinear system.

Examples found in repository

examples/example.rs (line 8)

fn main() {
    let mut story = MultilinearInfo::new();

    // Create aspects
    let place = story.add_aspect();
    let clothes = story.add_aspect();

    // Define event: Move from bedroom to living room
    let event_move = story
        .add_event()
        .with_change(&[Change::transition(place, 0, 1)])
        .unwrap()
        .event();

    // Define event: Change clothes in bedroom
    let event_clothes = story
        .add_event()
        .with_change(&[
            Change::condition(place, 0),
            Change::transition(clothes, 1, 0),
        ])
        .unwrap()
        .event();

    let mut simulation = MultilinearSimulation::new(story);
    simulation.try_call(event_clothes);
    simulation.try_call(event_move);
    simulation.try_revert(event_move);
}

pub fn add_event(&mut self) -> EventEdit<'_>

Adds a new event to the multilinear system and returns an editalbe event info.

Examples found in repository

examples/example.rs (line 13)

fn main() {
    let mut story = MultilinearInfo::new();

    // Create aspects
    let place = story.add_aspect();
    let clothes = story.add_aspect();

    // Define event: Move from bedroom to living room
    let event_move = story
        .add_event()
        .with_change(&[Change::transition(place, 0, 1)])
        .unwrap()
        .event();

    // Define event: Change clothes in bedroom
    let event_clothes = story
        .add_event()
        .with_change(&[
            Change::condition(place, 0),
            Change::transition(clothes, 1, 0),
        ])
        .unwrap()
        .event();

    let mut simulation = MultilinearSimulation::new(story);
    simulation.try_call(event_clothes);
    simulation.try_call(event_move);
    simulation.try_revert(event_move);
}

pub fn edit_event(&mut self, Event: Event) -> Option<EventEdit<'_>>

Returns an editalbe event info if the event exists.

pub unsafe fn edit_event_unchecked(&mut self, Event: Event) -> EventEdit<'_>

Returns an editalbe event info.

Safety

Ensure that this event exists

Trait Implementations

impl Clone for MultilinearInfo

fn clone(&self) -> MultilinearInfo

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Default for MultilinearInfo

fn default() -> MultilinearInfo

Returns the “default value” for a type.

impl SimulationInfo for MultilinearInfo

type StateLoadingError = Infallible

The error type returned when loading the simulation state fails.

type State = MultilinearState

The type of the simulation state.

type AccessData = [usize]

The type used to access the current state.

type LoadData = Vec<usize>

The type of data used to load the simulation state.

type Event = Event

The type of events that can be called or reverted in the simulation.

type EventContainer<'a> = EventContainer<'a> where Self: 'a

The type of container used to access the available events.

fn default_state(&self) -> MultilinearState

Creates a new default state compatible with this SimulationInfo instance.

fn load_state(&self, data: Vec<usize>) -> Result<MultilinearState, Infallible>

Loads a state from the provided data, returning a Result with the loaded state or an error.

unsafe fn clone_state(&self, state: &MultilinearState) -> MultilinearState

Clones the provided state, assuming it is compatible with this SimulationInfo instance.

unsafe fn data<'a>(&self, state: &'a MultilinearState) -> &'a [usize]

Returns a reference to the data which repsesents the state.

fn callables(state: &MultilinearState) -> EventContainer<'_>

Returns the events that can be called for the provided state.

fn callable(state: &MultilinearState, event: Event) -> bool

Checks if the provided event can be called for the given state.

unsafe fn call(&self, state: &mut MultilinearState, event: Event)

Calls the provided event on the given mutable state.

fn revertables(state: &MultilinearState) -> EventContainer<'_>

Returns the events that can be reverted for the provided state.

fn revertable(state: &MultilinearState, event: Event) -> bool

Checks if the provided event can be reverted for the given state.

unsafe fn revert(&self, state: &mut MultilinearState, event: Event)

Reverts the provided event on the given mutable state.