package kappa-library

  1. Overview
  2. Docs
package kappa-library
Legend:
Library
Module
Module type
Parameter
Class
Class type

Parameters

Signature

type t

Abstract graph

type instance
type result =
  1. | Clash
  2. | Corrected
  3. | Blocked
  4. | Success of t
    (*

    Clash means rectangular approximation failure Corrected means molecular ambiguity failure

    *)

Initialisation

val empty : outputs:(Data.t -> unit) -> with_trace:bool -> Random.State.t -> Kappa_terms.Model.t -> Counter.t -> t

algebraic expression computation

get_alg is by default Model.get_alg but it is not hard wired because perturbations can redefined alg_expr.

val value_bool : Counter.t -> t -> (Kappa_terms.Pattern.id array list, int) Kappa_terms.Alg_expr.bool -> bool
val activity : t -> float
val get_edges : t -> Kappa_site_graphs.Edges.t

Core

val apply_given_rule : debug_mode:bool -> outputs:(Data.t -> unit) -> ?rule_id:int -> Kappa_terms.Model.t -> Counter.t -> t -> Trace.event_kind -> Kappa_terms.Primitives.elementary_rule -> result

Returns the graph obtained by applying the rule. rule_id is mandatory if the rule has an unary rate.

val pick_an_instance : debug_mode:bool -> Kappa_terms.Model.t -> t -> instance
val is_correct_instance : Kappa_terms.Model.t -> t -> instance -> bool
val apply_instance : debug_mode:bool -> outputs:(Data.t -> unit) -> ?maxConsecutiveBlocked:int -> maxConsecutiveClash:int -> Kappa_terms.Model.t -> Counter.t -> t -> instance -> int option * bool * t

apply_rule ~outputs ~maxConsecutiveClash ?is_blocked model counter st Returns (corresponding_syntactic_rule, is_final_step, new_state). is_final_step is determined by the counter. corresponding_syntactic_rule is equal to None if and only if a null event occured

val force_rule : debug_mode:bool -> outputs:(Data.t -> unit) -> Kappa_terms.Model.t -> Counter.t -> t -> Trace.event_kind -> ?rule_id:int -> Kappa_terms.Primitives.elementary_rule -> t option

Apply the rule for sure if it is possible. Try apply_rule but in case of null_event, it computes the exact injections of the left hand side to do apply the rule and returns the remaining exact injections.

val incorporate_extra_pattern : debug_mode:bool -> Kappa_terms.Pattern.Env.t -> t -> Kappa_terms.Pattern.id -> t
val overwrite_var : int -> Counter.t -> t -> Kappa_terms.Primitives.alg_expr -> t
val update_outdated_activities : debug_mode:bool -> (int -> float -> float -> unit) -> Kappa_terms.Model.t -> Counter.t -> t -> int list -> t * int list

Resynchronize the state after a rule application.

It takes the function to store the new activities as an argument whose signature is store rule_id syntactic_rule_id new_activity.

As long as you don't use any algebraic variable (that include don't pick a rule randomly), you can apply several rules in row before resynchronizing. (This is what initial state does.)

takes the list of perturbations to be tried and returns it updated

val snapshot : debug_mode:bool -> raw:bool -> Kappa_terms.Model.t -> Counter.t -> t -> Data.snapshot
val print : Kappa_terms.Model.t -> Format.formatter -> t -> unit
val get_random_state : t -> Random.State.t
val send_instances_message : Instances.message -> t -> t

Blocking events

val set_events_to_block : event_predicate option -> t -> t

Stories

val add_tracked : outputs:(Data.t -> unit) -> Kappa_terms.Pattern.id array -> string -> Kappa_terms.Instantiation.abstract Kappa_terms.Instantiation.test list list -> t -> t
val remove_tracked : Kappa_terms.Pattern.id array -> string option -> t -> t

Species

val add_tracked_species : Kappa_terms.Pattern.id array -> string -> Kappa_terms.Instantiation.abstract Kappa_terms.Instantiation.test list list -> t -> t
val remove_tracked_species : string -> t -> t

Debugging

type stats = {
  1. mixture_stats : Kappa_site_graphs.Edges.stats;
}
val stats : t -> stats
val print_stats : Format.formatter -> t -> unit
val debug_print : Format.formatter -> t -> unit

Internals

obs_from_transformations domain state transformations

  • returns

    (obs, deps)

val add_outdated_dependencies : Kappa_data_structures.Operator.DepSet.t -> t -> t
val debug_print_instances : Format.formatter -> t -> unit
OCaml

Innovation. Community. Security.

GitHub Discord Twitter Peertube RSS
About
Changelog Releases Industrial Users Academic Users Why OCaml
Ecosystem
Packages Community Events OCaml Planet Jobs
Resources
Install OCaml Get Started Platform Tools Language Manual Standard Library API Books Exercises Papers OCaml Playground Logo
Policies
Carbon Footprint Governance Privacy Code of Conduct