src/Tools/Metis/src/RandomSet.sml

 
 val K = Useful.K;
 
 val snd = Useful.snd;
 
-val randomInt = Useful.random;
+val randomInt = Portable.randomInt;
+
+val randomWord = Portable.randomWord;
 
 (* ------------------------------------------------------------------------- *)
 (* Random search trees.                                                      *)
 (* ------------------------------------------------------------------------- *)
+
+type priority = Word.word;
 
 datatype 'a tree =
     E
   | T of
     {size : int,
-     priority : real,
+     priority : priority,
      left : 'a tree,
      key : 'a,
      right : 'a tree};
     
 type 'a node =
      {size : int,
-      priority : real,
+      priority : priority,
       left : 'a tree,
       key : 'a,
       right : 'a tree};
 
 datatype 'a set = Set of ('a * 'a -> order) * 'a tree;

 (* ------------------------------------------------------------------------- *)
 (* Random priorities.                                                        *)
 (* ------------------------------------------------------------------------- *)
 
 local
-  val randomPriority =
-      let
-        val gen = Random.newgenseed 2.0
-      in
-        fn () => Random.random gen
-      end;
-
-  val priorityOrder = Real.compare;
+  val randomPriority = randomWord;
+
+  val priorityOrder = Word.compare;
 in
   fun treeSingleton key =
       T {size = 1, priority = randomPriority (),
          left = E, key = key, right = E};
 

 
 fun null s = size s = 0;
 
 fun member x s = Option.isSome (peek s x);
 
-(* add must be primitive to get hold of the comparison function *)
-
 fun add s x = union s (singleton (comparison s) x);
 
 (*DEBUG
 val add = fn s => fn x =>
     checkWellformed "RandomSet.add: result"

 local
   fun unionPairs ys [] = rev ys
     | unionPairs ys (xs as [_]) = List.revAppend (ys,xs)
     | unionPairs ys (x1 :: x2 :: xs) = unionPairs (union x1 x2 :: ys) xs;
 in
-  fun unionList [] = raise Error "Set.unionList: no sets"
+  fun unionList [] = raise Error "RandomSet.unionList: no sets"
     | unionList [s] = s
     | unionList l = unionList (unionPairs [] l);
 end;
 
 local
   fun intersectPairs ys [] = rev ys
     | intersectPairs ys (xs as [_]) = List.revAppend (ys,xs)
     | intersectPairs ys (x1 :: x2 :: xs) =
       intersectPairs (intersect x1 x2 :: ys) xs;
 in
-  fun intersectList [] = raise Error "Set.intersectList: no sets"
+  fun intersectList [] = raise Error "RandomSet.intersectList: no sets"
     | intersectList [s] = s
     | intersectList l = intersectList (intersectPairs [] l);
 end;
 
 fun symmetricDifference s1 s2 = union (difference s1 s2) (difference s2 s1);

 fun pick s =
     case findl (K true) s of
       SOME p => p
     | NONE => raise Error "RandomSet.pick: empty";
 
-fun random s = case size s of 0 => raise Empty | n => nth s (randomInt n);
+fun random s =
+    case size s of
+      0 => raise Error "RandomSet.random: empty"
+    | n => nth s (randomInt n);
 
 fun deletePick s = let val x = pick s in (x, delete s x) end;
 
 fun deleteRandom s = let val x = random s in (x, delete s x) end;