minor

src/IGraph/Algorithms/Centrality.chs

@@ -24,15 +24,20 @@ import           IGraph
 
 -- | The normalized closeness centrality of a node is the average length of the
 -- shortest path between the node and all other nodes in the graph.
-closeness :: [Int]  -- ^ vertices
+closeness :: Serialize e
+          => [Int]  -- ^ vertices
           -> Graph d v e
-          -> Maybe [Double]  -- ^ optional edge weights
           -> Bool   -- ^ whether to normalize the results
+          -> Maybe (e -> Double)  -- ^ Function to get edge weights
           -> [Double]
-closeness nds gr ws normal = unsafePerformIO $ allocaVector $ \result ->
+closeness nds gr normal getEdgeW = unsafePerformIO $ allocaVector $ \result ->
     withVerticesList nds $ \vs -> withListMaybe ws $ \ws' -> do
         igraphCloseness (_graph gr) result vs IgraphOut ws' normal
         toList result
+  where
+    ws = case getEdgeW of
+        Nothing -> Nothing
+        Just f -> Just $ map (f . snd) $ labEdges gr
 {#fun igraph_closeness as ^
     { `IGraph'
     , castPtr `Ptr Vector'
@@ -43,14 +48,19 @@ closeness nds gr ws normal = unsafePerformIO $ allocaVector $ \result ->
 
 
 -- | Betweenness centrality
-betweenness :: [Int]
+betweenness :: Serialize e
+            => [Int]
             -> Graph d v e
-            -> Maybe [Double]
+            -> Maybe (e -> Double)  -- ^ Function to get edge weights
             -> [Double]
-betweenness nds gr ws = unsafePerformIO $ allocaVector $ \result ->
+betweenness nds gr getEdgeW = unsafePerformIO $ allocaVector $ \result ->
     withVerticesList nds $ \vs -> withListMaybe ws $ \ws' -> do
         igraphBetweenness (_graph gr) result vs True ws' False
         toList result
+  where
+    ws = case getEdgeW of
+        Nothing -> Nothing
+        Just f -> Just $ map (f . snd) $ labEdges gr
 {#fun igraph_betweenness as ^
     { `IGraph'
     , castPtr `Ptr Vector'
@@ -60,13 +70,18 @@ betweenness nds gr ws = unsafePerformIO $ allocaVector $ \result ->
     , `Bool' } -> `CInt' void- #}
 
 -- | Eigenvector centrality
-eigenvectorCentrality :: Graph d v e
-                      -> Maybe [Double]
+eigenvectorCentrality :: Serialize e
+                      => Graph d v e
+                      -> Maybe (e -> Double)  -- ^ Function to get edge weights
                       -> [Double]
-eigenvectorCentrality gr ws = unsafePerformIO $ allocaArpackOpt $ \arparck ->
+eigenvectorCentrality gr getEdgeW = unsafePerformIO $ allocaArpackOpt $ \arparck ->
     allocaVector $ \result -> withListMaybe ws $ \ws' -> do
         igraphEigenvectorCentrality (_graph gr) result nullPtr True True ws' arparck
         toList result
+  where
+    ws = case getEdgeW of
+        Nothing -> Nothing
+        Just f -> Just $ map (f . snd) $ labEdges gr
 {#fun igraph_eigenvector_centrality as ^
     { `IGraph'
     , castPtr `Ptr Vector'
@@ -77,18 +92,15 @@ eigenvectorCentrality gr ws = unsafePerformIO $ allocaArpackOpt $ \arparck ->
     , castPtr `Ptr ArpackOpt' } -> `CInt' void- #}
 
 -- | Google's PageRank algorithm, with option to
-pagerank :: SingI d
+pagerank :: (SingI d, Serialize v, Serialize e)
          => Graph d v e
-         -> Maybe [Double]  -- ^ Node weights or reset probability. If provided,
-                            -- the personalized PageRank will be used
-         -> Maybe [Double]  -- ^ Edge weights
          -> Double  -- ^ damping factor, usually around 0.85
+         -> Maybe (v -> Double)  -- ^ Node weights or reset probability. If provided,
+                                 -- the personalized PageRank will be used
+         -> Maybe (e -> Double)  -- ^ Edge weights
          -> [Double]
-pagerank gr reset ws d
-    | n == 0 = []
-    | isJust ws && length (fromJust ws) /= m = error "incorrect length of edge weight vector"
-    | isJust reset && length (fromJust reset) /= n = error
-        "incorrect length of node weight vector"
+pagerank gr d getNodeW getEdgeW
+    | nNodes gr == 0 = []
     | fmap (foldl' (+) 0) reset == Just 0 = error "sum of node weight vector must be non-zero"
     | otherwise = unsafePerformIO $ alloca $ \p -> allocaVector $ \result ->
         withVerticesAll $ \vs -> withListMaybe ws $ \ws' -> do
@@ -100,9 +112,12 @@ pagerank gr reset ws d
                     (isDirected gr) d reset'' ws' nullPtr
             toList result
   where
-    n = nNodes gr
-    m = nEdges gr
-
+    reset = case getNodeW of
+        Nothing -> Nothing
+        Just f -> Just $ map (f . snd) $ labNodes gr
+    ws = case getEdgeW of
+        Nothing -> Nothing
+        Just f -> Just $ map (f . snd) $ labEdges gr
 {#fun igraph_pagerank as ^
     { `IGraph'
     , `PagerankAlgo'
@@ -114,7 +129,6 @@ pagerank gr reset ws d
     , castPtr `Ptr Vector'
     , id `Ptr ()'
     } -> `CInt' void- #}
-
 {#fun igraph_personalized_pagerank as ^
     { `IGraph'
     , `PagerankAlgo'

tests/Test/Algorithms.hs

@@ -93,4 +93,4 @@ pagerankTest = testGroup "PageRank"
     gr = star 11
     ranks = [0.47,0.05,0.05,0.05,0.05,0.05,0.05,0.05,0.05,0.05,0.05]
     ranks' = map ((/100) . fromIntegral . round. (*100)) $
-        pagerank gr Nothing Nothing 0.85
+        pagerank gr 0.85 Nothing Nothing