Module Utilities

module Utilities: sig .. end

High-level elementary primitives to generate stories

module S: Generic_branch_and_cut_solver.Solver

type error_log = Exception.method_handler

val error_init : error_log

error_init is an empty log of errors

type parameter = S.PH.B.PB.CI.Po.K.H.parameter

type kappa_handler = S.PH.B.PB.CI.Po.K.H.handler

type profiling_info = StoryProfiling.StoryStats.log_info

type shall_we = parameter -> bool

enriched types for functions:

type 'a with_handlers = parameter ->
       ?shall_we_compute:shall_we ->
       ?shall_we_compute_profiling_information:shall_we ->
       ?print_if_zero:shall_we ->
       kappa_handler ->
       profiling_info -> error_log -> 'a

type 'a zeroary = (error_log * profiling_info * 'a) with_handlers

type ('a, 'b) unary = ('a -> error_log * profiling_info * 'b)
       with_handlers

type ('a, 'b, 'c) binary = ('a -> 'b -> error_log * profiling_info * 'c)
       with_handlers

type ('a, 'b, 'c, 'd) ternary = ('a -> 'b -> 'c -> error_log * profiling_info * 'd)
       with_handlers

type ('a, 'b, 'c, 'd, 'e) quaternary = ('a -> 'b -> 'c -> 'd -> error_log * profiling_info * 'e)
       with_handlers

type ('a, 'b, 'c, 'd, 'e, 'f) quinternary = ('a ->
        'b -> 'c -> 'd -> 'e -> error_log * profiling_info * 'f)
       with_handlers

type ('a, 'b, 'c, 'd, 'e, 'f, 'g) sexternary = ('a ->
        'b ->
        'c -> 'd -> 'e -> 'f -> error_log * profiling_info * 'g)
       with_handlers

val fold_left_with_progress_bar : ?event:StoryProfiling.step_kind ->
       (('a, 'b, 'a) binary, 'a, 'b list, 'a) ternary

val pop_json : parameter -> Yojson.Basic.json option

val profiling_state_to_json : parameter -> Yojson.Basic.json

val error_list_to_json : parameter -> Yojson.Basic.json

val computation_steps_to_json : parameter -> Yojson.Basic.json

type on_the_fly_cut_state

val on_the_fly_cut_init : on_the_fly_cut_state

val on_the_fly_cut_step : on_the_fly_cut_state ->
       Trace.step -> on_the_fly_cut_state

val on_the_fly_cut_finalize : on_the_fly_cut_state -> Trace.step list

val cut_rev_trace : Trace.step list -> Trace.step list

type trace

traces

type trace_runtime_info = profiling_info Trace.Simulation_info.t

Runtime information about a trace provided by the simulator

val size_of_pretrace : trace -> int

val last_eid_in_pretrace : trace -> int

val print_trace : parameter -> kappa_handler -> trace -> unit

val has_obs : trace -> bool

check wether there is an observable in a trace

val trace_of_pretrace : Trace.t -> trace

convert a list of refined steps into a trace

val get_pretrace_of_trace : trace -> Trace.t

conversely, convert a trace in a list of refined steps

val get_simulation_time_of_event : Trace.step -> float option

get the date of an event in the simulation (only proper events have a time)

val get_id_of_event : Trace.step -> int option

get the id of an event in the simulation (only proper events have an id)

val remove_events_after_last_obs : (trace, trace) unary

remove the events after the last observable

val split_init : (trace, trace) unary

split_init split init event agent-wise

val fill_siphon : (trace, trace) unary

fill_siphon adds spurious init event, to break causal dependences; Currently, it inserts an init event when an agent return to its initial state; other heuristics may be considered; The output has to be disanbiguated, otherwise it is useless (compression will remove the ficitious init events) It should work in quasi linear time (I think)

val cut : (trace, trace) unary

cut performs partial order reduction and remove orthogonal events

val remove_pseudo_inverse_events : (trace, trace) unary

remove_pseudo_inverse_events removes pseudo inverse events

val remove_obs_before : (trace_runtime_info list option, trace, trace)
       binary

remove_obs_before removes the observable_hits before the simulation info prodided as a first argument

val make_unambiguous : (trace, trace) unary

reallocate agent id to avoid conflict (implicitly called by cut and fill_siphon)

val weakly_compress : ?heuristic:Priority.priorities ->
       (trace, trace list) unary

compute the weak compression of a given trace, if parameter.compute_all_stories, then each minimal stories is computed, otherwise, only the first found one is provided; the optional argument heuristic can be used to redefined the heuristic that select which event to try to discard first.

val strongly_compress : ?heuristic:Priority.priorities ->
       (trace, trace list) unary

compute the strong compression of a given trace, if parameter.compute_all_stories, then each minimal stories is computed, otherwise, only the first found one is provided; the optional argument heuristic can be used to redefined the heuristic that select which event to try to discard first.

val fold_over_the_causal_past_of_observables_with_a_progress_bar : (shall_we, shall_we, int,
        (trace, trace_runtime_info list, 'a, ('a, 'b) Stop.stop)
        ternary, trace, 'a, ('a, 'b * int) Stop.stop)
       sexternary

fold over the causal past of each observable in a given trace, the first argument indicates whether we display the current steps on the err output; the second arfument indicated whether the function is launched in debug mode or not

type black_list

val create_black_list : int -> black_list

val black_list : (trace, black_list, black_list)
       binary

val remove_blacklisted_event : (black_list, trace, trace) binary

type story_table

Story table

val create_story_table : story_table zeroary

Initialization

val count_stories : story_table -> int

Give the number of stories (up to isomorphism classes) stored in a table

val store_trace : (trace, trace_runtime_info list, story_table,
        story_table)
       ternary

Store trace in story table

Apply a function on each trace (and each list of runtime information associated to this trace), the string contains the message to display in case of faillure of one call of the ternary function

val fold_story_table_with_progress_bar : (string,
        (trace, trace_runtime_info list, 'a, 'a)
        ternary, story_table, 'a, 'a)
       quaternary

val fold_story_table_without_progress_bar : (string,
        (trace, trace_runtime_info list, 'a, 'a)
        ternary, story_table, 'a, 'a)
       quaternary

Apply a function on each trace (and each list of runtime information associated to this trace), the string contains the message to display in case of faillure of one call of the ternary function

val flatten_story_table : (story_table, story_table) unary

put together the stories having the same canonic form, this has do be done explicitely on the moment, I will improve this soon

val export_story_table : (story_table,
        (Trace.t * Causal.grid * trace_runtime_info list) list)
       unary

convert a table into a list of grid (with runtime information)

The following functions are for expert only

val compress : ?heuristic:Priority.priorities ->
       (trace, trace list) unary

compress a trace with the level of abstraction defined in the argument parameter. The optional argument heuristic can be used to tune the heuristic that select which event will be tried to be discarded first.

val copy_log_info : StoryProfiling.StoryStats.log_info -> StoryProfiling.StoryStats.log_info

type cflow_grid = Causal.grid

type enriched_cflow_grid = Causal.enriched_grid

val convert_trace_into_grid : trace -> kappa_handler -> cflow_grid

val enrich_grid_with_transitive_past_of_observables_with_a_progress_bar : (cflow_grid, enriched_cflow_grid) unary

compute transitive closure with different parameters (progress_bar, gc)

val enrich_grid_with_transitive_past_of_observables_without_a_progress_bar : (cflow_grid, enriched_cflow_grid) unary

val enrich_grid_with_transitive_past_of_each_node_without_a_progress_bar : (cflow_grid, enriched_cflow_grid) unary

type canonical_form

Cannonic forms

val compare_canonical_form : canonical_form -> canonical_form -> int

val compute_canonical_form : (trace, canonical_form) unary

type musical_grid

Blackboard with debugging utilities

type observable_hit

val get_runtime_info_from_observable_hit : observable_hit -> unit Trace.Simulation_info.t option

Musical processing

val convert_trace_into_musical_notation : (trace, musical_grid) unary

val extract_observable_hits_from_musical_notation : (musical_grid, observable_hit list) unary

val extract_observable_hit_from_musical_notation : (string, musical_grid, observable_hit) binary

val causal_prefix_of_an_observable_hit : (string, musical_grid, enriched_cflow_grid,
        observable_hit, trace)
       quaternary

val export_musical_grid_to_xls : (string, int, int, musical_grid, unit) quaternary

Show the current status of the branch and cut assumptions in a libreoffice macro file

Show the current status of the branch and cut assumptions in ASCII

val print_musical_grid : (musical_grid, unit) unary

val get_counter : story_table -> int