package grenier

You can search for identifiers within the package.

in-package search v0.2.0

package grenier

grenier.balmap
- Balmap
  - Map
    
    Make
    
    O
  - Set
    
    Make
    
    O
grenier.baltree
- Bt1
- Bt2
- Mbt
  - MEASURE
  - Make
    
    M
grenier.binpacking
- Maxrects
grenier.dbseq
- Dbseq
grenier.doubledouble
- Doubledouble
  - Infix
grenier.fastdom
- Fastdom
grenier.hll
- Hll
- Hll_consts
grenier.jmphash
- Jmphash
grenier.orderme
grenier.physh
- Physh
  - Map
  - Set
grenier.state_elimination
- State_elimination
  - Convert
    
    NFA
    
    Finals
    
    Initials
    
    States
    
    Transitions
    
    Regex
  - NFA
    
    Finals
    
    Initials
    
    States
    
    Transitions
  - Regex
grenier.strong
- Strong
  - Finite
    
    Array
    
    Of_array
    
    A
    
    T
    
    Elt
    
    Set
    
    Gensym
  - Natural
    
    Nth
    
    N
    
    T
  - Order
grenier.trope
- Trope
grenier.valmari
- Partition
- Valmari
  - DFA
  - INPUT
  - Minimize
    
    In
    
    Label

Legend:
Library
Module
Module type
Parameter
Class
Class type

include DFA with type label := Label.t

type states

val states : states Strong.Finite.set

The set of DFA nodes

type transitions

val transitions : transitions Strong.Finite.set

The set of DFA transitions

val label : transitions Strong.Finite.elt -> Label.t

Get the label associated with a transition

val source : transitions Strong.Finite.elt -> states Strong.Finite.elt

Get the source state of the transition

val target : transitions Strong.Finite.elt -> states Strong.Finite.elt

Get the target state of the transition

val initials : (states Strong.Finite.elt -> unit) -> unit

Iterate on initial states

val finals : (states Strong.Finite.elt -> unit) -> unit

Iterate final states

val refinements : 
  refine:(iter:((states Strong.Finite.elt -> unit) -> unit) -> unit) ->
  unit

The minimization algorithms operate on a DFA plus an optional initial refinement (state that must be distinguished, because of some external properties not observable from the labelled transitions alone).

If no refinements are needed, the minimum implementation is just: let refinements ~refine:_ = ()

Otherwise, the refinements function should invoke the refine function for each set of equivalent states and call the iter for each equivalent state.

E.g if our automata has 5 states, and states 2 and 3 have tag A while states 4 and 5 have tag B, we will do:

let refinements ~refine = refine (fun ~iter -> iter 2; 3); refine (fun ~iter -> iter 4; 5)