package zelus

You can search for identifiers within the package.

in-package search v0.2.0

package zelus

zelus
- Basics
- Defaultsolver
- Dump
- Illinois
- Lift
- Node
  - Ode23Solver
  - Ode45Solver
- Node_base
  - Make
    
    SSolver
    
    ZSolver
  - Ode23Solver
  - Ode45Solver
- Odexx
  - BUTCHER_TABLEAU
  - GenericODE
    
    Butcher
  - Ode23
  - Ode45
- Run
- Solvers
- Zls
- Zlsolve
  - Make
    
    _
  - ZELUS_SOLVER
- Zlsrun
  - Make
    
    _
- Ztypes
zelus.zlcompilerlibs
- Activate
- Add_copy_for_last
- Aform
- Automata
  - TableOfTypes
- Causal
  - K
  - M
  - S
- Causality
- Compiler
- Complete
- Control
- Copy
- Cost
- Cse
- Defcaus
- Definit
- Deftypes
- Dependences
- Deps_tools
- Disc
- Encore
- Fixstep
- Global
- Graph
  - E
  - S
- Horizon
- Init
  - M
  - S
- Initial
- Initialization
- Inline
- Inout
- Interface
- Letin
- Lident
- Lmm
- Markfunctions
- Match2condition
- Modules
  - E
- Oaux
- Obc
- Ocamlprinter
- Oprinter
- Patternsig
  - C
    
    SSet
  - LANG
- Pcaus
  - M
  - S
- Period
- Pinit
- Plmm
- Pp_tools
- Pre
- Present
- Printer
- Proba
- Ptypes
- Reduce
- Remove_last_in_patterns
- Reset
- Schedule
- Scoping
  - Error
  - Rename
  - S
- Shared
- Simulator
- Static
- Total
  - Automaton
- Translate
- Typerrors
- Typing
- Unsafe
- Vars
- Write
- Zaux
- Zconfig
- Zdeadcode
- Zdepend
  - StringSet
- Zelus
- Zident
  - Env
  - M
  - S
- Zlexer
- Zlocation
- Zlus2lmm
- Zmatching
  - PATTERN_CHECKER
    
    S
    
    SSet
  - SIG
- Zmisc
  - Env
  - S
  - State
  - name_assoc_table
  - name_generator
- Zopt
- Zparser
  - Incremental
  - MenhirInterpreter
- Zparsetree
- Ztypes

Legend:
Library
Module
Module type
Parameter
Class
Class type

module S : sig ... end

a set of causality names

module M : sig ... end

module K : sig ... end

val fprint_t : Format.formatter -> S.t -> unit

val fprint_tt : Format.formatter -> S.t M.t -> unit

type cycle = Defcaus.t list

type error = cycle

exception Clash of error

val new_var : unit -> Defcaus.t

val new_var_with_info : Defcaus.t -> Defcaus.t

val new_gen_var : unit -> Defcaus.t

val product : Defcaus.tc list -> Defcaus.tc

val funtype : Defcaus.tc -> Defcaus.tc -> Defcaus.tc

val funtype_list : Defcaus.tc list -> Defcaus.tc -> Defcaus.tc

val atom : Defcaus.t -> Defcaus.tc

val crepr : Defcaus.t -> Defcaus.t

val equal : Defcaus.t -> Defcaus.t -> bool

val add : Defcaus.t -> Defcaus.t list -> Defcaus.t list

val remove : Defcaus.t -> Defcaus.t list -> Defcaus.t list

val mem : Defcaus.t -> Defcaus.t list -> bool

val union : Defcaus.t list -> Defcaus.t list -> Defcaus.t list

val set : Defcaus.t list -> Defcaus.t list

val sups : Defcaus.t -> Defcaus.t list

val allsups : Defcaus.t list -> Defcaus.t -> Defcaus.t list

val annotate : Defcaus.info -> Defcaus.tc -> Defcaus.tc

val cannotate : Defcaus.info -> Defcaus.t -> Defcaus.t

val vars : S.t -> Defcaus.tc -> S.t

val vars_c : S.t -> S.elt -> S.t

val polarity : bool -> Defcaus.tc -> unit

Sets the polarity of a type.

val polarity_c : bool -> Defcaus.t -> unit

val increase_polarity : Defcaus.polarity -> Defcaus.t -> unit

val occur_check : Defcaus.t -> Defcaus.t -> unit

check for cycles. Does left_c appears in right_c and its

val check_type : Defcaus.tc -> unit

val less : Defcaus.tc -> Defcaus.tc -> unit

order < between types

val less_c : Defcaus.t -> Defcaus.t -> unit

val intro_less_c : Defcaus.t -> Defcaus.t

val strict_path : Defcaus.t -> Defcaus.t -> bool

val path : Defcaus.t -> Defcaus.t -> bool

val fresh : Defcaus.tc -> Defcaus.tc

val fresh_on_c : Defcaus.t -> Defcaus.tc -> Defcaus.tc

val suptype : bool -> Defcaus.tc -> Defcaus.tc -> Defcaus.tc

val sup_c : bool -> Defcaus.t -> Defcaus.t -> Defcaus.t

val suptype_list : bool -> Defcaus.tc list -> Defcaus.tc

val skeleton : Deftypes.typ -> Defcaus.tc

Computing a causality type from a type

val skeleton_on_c : Defcaus.t -> Deftypes.typ -> Defcaus.tc

val skeleton_for_variables : Deftypes.typ -> Defcaus.tc

val on_c : Defcaus.tc -> S.elt -> Defcaus.tc

val mark : Defcaus.tc -> unit

Simplification of types

val mark_c : Defcaus.t -> unit

val mark_and_polarity : bool -> Defcaus.tc -> unit

val is_an_output : Defcaus.t -> bool

val ins_and_outs : S.t -> S.t * S.t

val ins_and_outs_of_a_type : bool -> (S.t * S.t) -> Defcaus.tc -> S.t * S.t

val outrec : S.t -> S.elt -> S.t

val out : S.elt -> S.t

val outset : S.t -> S.t

val io : S.t -> S.t M.t -> M.key -> S.t

val build_o_table : S.t -> S.t M.t -> S.t M.t

val build_io_table : S.t -> S.t M.t -> S.t -> S.t M.t -> S.t M.t

val build_ki_table : K.key M.t -> Defcaus.t K.t * S.t M.t

val filter : S.t M.t -> S.t M.t

val simplify_by_io : Defcaus.tc -> Defcaus.tc

val shorten : Defcaus.tc -> unit

val shorten_c : Defcaus.t -> unit

val short_list : bool -> Defcaus.t list -> Defcaus.t list -> Defcaus.t list

val remove_polarity : Defcaus.polarity -> Defcaus.t list -> Defcaus.t list

val short : bool -> Defcaus.t list -> Defcaus.t -> Defcaus.t list

val csimplify : bool -> Defcaus.t -> Defcaus.t

val simplify : bool -> Defcaus.tc -> Defcaus.tc

val shrink_cycle : S.t -> S.elt list -> S.elt list

val keep_names_in_cycle : S.t -> S.elt list -> S.elt list

val reduce : S.t -> unit

val relation : (S.t * 'a) -> S.t -> S.t * (S.elt * Defcaus.t list) list

Computes the dependence relation from a list of causality variables

val list_of_vars : Defcaus.t list ref

Generalisation of a type

val gen : Defcaus.tc -> unit

val cgen : Defcaus.t -> int

val gen_set : Defcaus.t list -> int

val generalise : Defcaus.tc -> Defcaus.tc_scheme

Main generalisation function

val links : Defcaus.t list ref

Instantiation of a type

val save : Defcaus.t -> unit

val cleanup : unit -> unit

val copy : Defcaus.tc -> Defcaus.tc

val subtype : bool -> Defcaus.tc -> Defcaus.tc

val instance : Global.value_desc -> Deftypes.typ -> Defcaus.tc

Type instance

val filter_product : int -> Defcaus.tc -> Defcaus.tc list

val filter_arrow : Defcaus.tc -> Defcaus.tc * Defcaus.tc

type tentry = {

t_typ : Defcaus.tc;
t_last_typ : Defcaus.tc option;

}

val simplify_by_io_env : 
  tentry Zident.Env.t ->
  Defcaus.tc ->
  Defcaus.tc ->
  tentry Zident.Env.t
  * S.t
  * (S.elt * Defcaus.t list) list
  * Defcaus.tc
  * Defcaus.tc

val prel : Format.formatter -> (Defcaus.t * Defcaus.t list) list -> unit

val penv : Format.formatter -> tentry Zident.Env.t -> unit