[Rules now (Set Rule) Rateable in own module
martin.hofmann@uni-bamberg.de**20090126090926] hunk ./src/Data/HypoSpace.hs 20
+import Rating.Rateable
+
hunk ./src/Data/Hypotheses.hs 72
-       
-instance Rateable Hypo where
-    rate h       =  -- S.size (open h) -- count number of open rules
-    			 let clsdrs = foldl' S.union S.empty (map rulesToSet (M.elems (clsd h)))
-    			     openrs = (S.map frag(open h))
-    			 in  S.size $ S.map lhs (S.union clsdrs openrs)
-				 -- total number of rules
-                   
-
-      
---instance Ord Hypo where
---    compare = ( \l r -> compare (rate l) (rate r) )
---    (<)     = ( \l r -> (<) (rate l) (rate r) )
---    (<=)    = ( \l r -> (<=) (rate l) (rate r) )
---    (>=)    = ( \l r -> (>=) (rate l) (rate r) )
---    (>)     = ( \l r -> (>) (rate l) (rate r) )  
hunk ./src/Data/Hypotheses.hs 105
-    | otherwise    = h{clsd = M.alter (insertRsM (frag rf)) (name rf) cs}
+    | otherwise    = h{clsd = M.alter (insertM (frag rf)) (name rf) cs}
hunk ./src/Data/Hypotheses.hs 111
-    | otherwise    = h{clsd = M.alter (deleteRsM (frag rf)) (name rf) cs}
+    | otherwise    = h{clsd = M.alter (deleteM (frag rf)) (name rf) cs}
hunk ./src/Data/IOData.hs 61
- 
-instance Rateable RuleFrag where
-    rate = rate.frag
-
hunk ./src/Data/IOData.hs 155
-        Just rs -> let rl = rulesToList rs
+        Just rs -> let rl = S.toList rs
hunk ./src/Data/IOData.hs 229
-    iod{rhsides = foldl' ins  rhss (rulesToList rs)}
+    iod{rhsides = foldl' ins  rhss (S.toList rs)}
hunk ./src/Data/IOData.hs 236
-    iod{lhsides = foldl' ins  lhss (rulesToList rs)}
+    iod{lhsides = foldl' ins  lhss (S.toList rs)}
hunk ./src/Data/Initialiser.hs 15
-import Data.Rules (Rules,Rule, rules, rule, rulesToList, lhs, rhs)
+import Data.Rules (Rules,Rule, rules, rule, lhs, rhs)
hunk ./src/Data/Initialiser.hs 18
+import qualified Data.Set as S
hunk ./src/Data/Initialiser.hs 60
-hypos2decs hs = map rules2decs hs'
-	where
-	hs' = case hs of
-	 		(x:xs) -> intersperse [(mkName "newHypo",rules[])] hs--x:(rename 1 xs)
-	 		_owise -> hs
---	rename _ [] = []		
---	rename i (x:xs) = (renameName i x):(rename (i+1) xs)
---	renameName
+hypos2decs hs =  map rules2decs hs
hunk ./src/Data/Initialiser.hs 69
-rules2clauses rs = map rule2clauses (rulesToList rs)
+rules2clauses rs = map rule2clauses (S.toList rs)
hunk ./src/Data/Rules.hs 8
-    insertRs, deleteRs, replaceRs,
-    insertRsM, deleteRsM, replaceRsM, 
-    mapRs , foldRs,
-    -- *FIXME* necessary?
-    --union, 
-    Rateable(..), RatingData, 
-    rulesToList, rulesToSet,
-    rulesFromList, rulesFromSet,
+    
+--    insertRs, deleteRs, replaceRs,
+    insertM, deleteM, replaceM, 
+--    mapRs , foldRs,
+--    -- *FIXME* necessary?
+--    --union, 
+--    rulesToList, rulesToSet,
+--    rulesFromList, rulesFromSet,
hunk ./src/Data/Rules.hs 91
--- *FIXME* necessary? 
-type RatingData = Int
hunk ./src/Data/Rules.hs 92
--- *FIXME* necessary?
-class Rateable r where
-    rate :: r -> RatingData
-
--- *FIXME* necessary?    
-instance Rateable Rule where
-    rate (R ls rs) = size ls * size rs
hunk ./src/Data/Rules.hs 107
-newtype Rules = RS { unRS :: Set Rule }
-    deriving(Eq, Ord)
-
-instance Show Rules where
-    show = show.pretty
-    
-instance Pretty Rules where
-	pretty (RS s) = pretty s
+type Rules = Set Rule
hunk ./src/Data/Rules.hs 110
-rules = rulesFromList
+rules = S.fromList
hunk ./src/Data/Rules.hs 113
-ruleAtIndex  i rs = (rulesToList rs) !! i
- 
-foldRs :: (Rule -> a -> a) -> a -> Rules -> a
-foldRs f i rs =  foldl' (flip f) i (rulesToList rs) -- S.fold f i (unRS rs)
+ruleAtIndex  i rs = (S.toAscList rs) !! i
hunk ./src/Data/Rules.hs 115
-mapRs :: (Rule -> Rule) -> Rules -> Rules
-mapRs f rs  = RS $ (S.map f) (unRS rs)
+deleteM :: (Ord a) => a -> Maybe (Set a) -> Maybe (Set a)
+deleteM r rs = 
+    liftM (S.delete r) rs >>=  \rs' -> 
+        if S.null rs' then return rs' else Nothing
hunk ./src/Data/Rules.hs 120
-nullRs :: Rules -> Bool
-nullRs = S.null.unRS
-
-emptyRs :: Rules
-emptyRs = RS $ S.empty
-
-insertRs :: Rule -> Rules -> Rules
-insertRs r rs = RS $ (S.insert r) $ unRS rs
-
-insertRsM :: Rule -> Maybe Rules -> Maybe Rules
-insertRsM  r rs   = 
+insertM :: (Ord a) => a -> Maybe (Set a) -> Maybe (Set a)
+insertM  r rs   = 
hunk ./src/Data/Rules.hs 123
-        (Just rs') -> return $ insertRs r rs'
-        Nothing    -> return $ insertRs r emptyRs
+        (Just rs') -> return $ S.insert r rs'
+        Nothing    -> return $ S.insert r S.empty
hunk ./src/Data/Rules.hs 126
-deleteRs :: Rule -> Rules -> Rules
-deleteRs r rs = RS $ (S.delete r) $ unRS rs
+replaceM r1 r2 = (insertM r2).(deleteM r1)
+        
+-- DEPRECATED
hunk ./src/Data/Rules.hs 130
-deleteRsM :: Rule -> Maybe Rules -> Maybe Rules
-deleteRsM r rs = do
-    rs' <- rs
-    d   <- return $ deleteRs r rs'
-    if nullRs d
-      then return d
-      else fail ""
+--instance Show Rules where
+--    show = show.pretty
+--    
+--instance Pretty Rules where
+--	pretty (RS s) = pretty s
hunk ./src/Data/Rules.hs 136
-replaceRs :: Rule ->  -- ^replace old rule 
-           Rule ->  -- ^by new rule
-           Rules -> -- ^in some rules
-           Rules
-replaceRs r1 r2 = (insertRs r2).(deleteRs r1) 
-
-replaceRsM r1 r2 = (insertRsM r2).(deleteRsM r1)
-
--- *FIXME* necessary?
---union :: Rules -> Rules -> Rules
---union (RS rs1) (RS rs2) = RS $ S.union rs1 rs2
--- *FIXME* necessary?
-rulesFromList :: [Rule] -> Rules
-rulesFromList rs  = RS $ S.fromList rs
+ 
+--foldRs :: (Rule -> a -> a) -> a -> Rules -> a
+--foldRs f i rs =  foldl' (flip f) i (rulesToList rs) -- S.fold f i (unRS rs)
+--
+--mapRs :: (Rule -> Rule) -> Rules -> Rules
+--mapRs f rs  = RS $ (S.map f) (unRS rs)
+--
+--nullRs :: Rules -> Bool
+--nullRs = S.null.unRS
+--
+--emptyRs :: Rules
+--emptyRs = RS $ S.empty
+--
+--insertRs :: Rule -> Rules -> Rules
+--insertRs r rs = RS $ (S.insert r) $ unRS rs
hunk ./src/Data/Rules.hs 152
--- *FIXME* necessary?
-rulesFromSet :: Set Rule -> Rules
-rulesFromSet rs = RS rs
+--insertRsM :: Rule -> Maybe Rules -> Maybe Rules
+--insertRsM  r rs   = 
+--    case rs of
+--        (Just rs') -> return $ insertRs r rs'
+--        Nothing    -> return $ insertRs r emptyRs
+--
+--deleteRs :: Rule -> Rules -> Rules
+--deleteRs r rs = RS $ (S.delete r) $ unRS rs
+--
hunk ./src/Data/Rules.hs 162
--- | An ascending ordered list of 'Rule's 
-rulesToList = S.toAscList.unRS
-rulesToSet = unRS
+--
+--replaceRs :: Rule ->  -- ^replace old rule 
+--           Rule ->  -- ^by new rule
+--           Rules -> -- ^in some rules
+--           Rules
+--replaceRs r1 r2 = (insertRs r2).(deleteRs r1) 
+--
+--replaceRsM r1 r2 = (insertRsM r2).(deleteRsM r1)
+--
+---- *FIXME* necessary?
+----union :: Rules -> Rules -> Rules
+----union (RS rs1) (RS rs2) = RS $ S.union rs1 rs2
+---- *FIXME* necessary?
+--rulesFromList :: [Rule] -> Rules
+--rulesFromList rs  = RS $ S.fromList rs
+--
+---- *FIXME* necessary?
+--rulesFromSet :: Set Rule -> Rules
+--rulesFromSet rs = RS rs
+--
+---- | An ascending ordered list of 'Rule's 
+--rulesToList = S.toAscList.unRS
+--rulesToSet = unRS
adddir ./src/Rating
addfile ./src/Rating/Rateable.hs
hunk ./src/Rating/Rateable.hs 1
-
+
+module Rating.Rateable (
+
+    Rateable(..), RatingData, 
+    
+    )where
+
+import Data.Hypotheses
+import Data.Rules
+import Data.IOData
+
+import Data.List
+import qualified Data.Map as M
+import qualified Data.Set as S
+
+type RatingData = Int
+
+class Rateable r where
+    rate :: r -> RatingData
+--------------------------------------------------------------------------------
+-- Rate a Rule
+--------------------------------------------------------------------------------
+instance Rateable Rule where
+    rate r = size (lhs r) * size (rhs r)
+
+--------------------------------------------------------------------------------
+-- Rate a RuleFragment
+--------------------------------------------------------------------------------
+instance Rateable RuleFrag where
+    rate = rate.frag
+
+--------------------------------------------------------------------------------
+-- Rate a Hypothese
+--------------------------------------------------------------------------------
+instance Rateable Hypo where
+    rate        =  noOfTotalRules
+
+-- count the number of open 'Rule's in a hypothese
+noOfOpenRules :: Hypo -> RatingData                 
+noOfOpenRules = S.size.open
+
+-- count the number of all rules in a hypothese
+noOfTotalRules :: Hypo -> RatingData 
+noOfTotalRules h = 
+                 let clsdrs = foldl' S.union S.empty (M.elems (clsd h))
+                     openrs = (S.map frag(open h))
+                 in  S.size $ S.map lhs (S.union clsdrs openrs)
+                 
+--noOfPartitions                 