Implement set-theoretic operation on 2WSATA (union, intersection,

negation, difference).

diff --git a/src/ata.ml b/src/ata.ml
index 2f20b14..5e28a54 100644 (file)
--- a/src/ata.ml
+++ b/src/ata.ml
@@ -492,3 +492,61 @@ let merge a1 a2 =
       in
       a1.transitions
   }
       in
       a1.transitions
   }

+
+
+let link a1 a2 q link_phi =
+  { a1 with
+    states = StateSet.union a1.states a2.states;
+    selecting_states = StateSet.singleton q;
+    starting_states = StateSet.union a1.starting_states a2.starting_states;
+    transitions =
+      let () =
+        Hashtbl.iter (fun k v -> Hashtbl.add a1.transitions k v) a2.transitions
+      in
+      Hashtbl.add a1.transitions q [(QNameSet.any, link_phi)];
+      a1.transitions
+  }
+
+let union a1 a2 =
+  let a1 = copy a1 in
+  let a2 = copy a2 in
+  let q = State.make () in
+  let link_phi =
+    StateSet.fold
+      (fun q phi -> Formula.(or_ (stay q) phi))
+      (StateSet.union a1.selecting_states a2.selecting_states)
+      Formula.false_
+  in
+  link a1 a2 q link_phi
+
+let inter a1 a2 =
+  let a1 = copy a1 in
+  let a2 = copy a2 in
+  let q = State.make () in
+  let link_phi =
+    StateSet.fold
+      (fun q phi -> Formula.(and_ (stay q) phi))
+      (StateSet.union a1.selecting_states a2.selecting_states)
+      Formula.true_
+  in
+  link a1 a2 q link_phi
+
+let neg a =
+  let a = copy a in
+  let q = State.make () in
+  let link_phi = 
+    StateSet.fold
+      (fun q phi -> Formula.(and_ (not_(stay q)) phi))
+      a.selecting_states
+      Formula.true_
+  in
+  let () = Hashtbl.add a.transitions q [(QNameSet.any, link_phi)] in
+  let a =
+    { a with
+      selecting_states = StateSet.singleton q;
+    }
+  in
+  normalize_negations a; a
+
+let diff a1 a2 = inter a1 (neg a2)
+

diff --git a/src/ata.mli b/src/ata.mli
index aa28abf..00070d4 100644 (file)
--- a/src/ata.mli
+++ b/src/ata.mli
@@ -126,6 +126,26 @@ val merge : t -> t -> t
     in parallel
 *)
 
     in parallel
 *)
 

+val union : t -> t -> t
+(** [union a a'] creates a new automaton [a''] that selects node
+    selected by either [a] or [a']
+*)
+
+val inter : t -> t -> t
+(** [inter a a'] creates a new automaton [a''] that selects node
+    selected by both [a] and [a']
+*)
+
+val neg : t -> t
+(** [neg a] creates a new automaton [a'] that selects the nodes not
+    selected by [a]
+*)
+
+val diff : t -> t -> t
+(** [diff a a'] creates a new automaton [a''] that select nodes selected
+    by [a] but not selected by [a']
+*)
+

 module Builder :
 sig
   type auto = t
 module Builder :
 sig
   type auto = t