Подключение компонентов из графа QuickGraph

Я новичок в теории графов.

я создал график смежности с библиотека QuickGraph и, в конечном счете, я хотел бы иметь компонент связности в графе.

open QuickGraph

let tup = [(1M,1M); (2M, 18M); (3M, 3M); (4M, 5M); (5M, 24M); (24M, 6M); (7M, 6M); (8M, 9M); (10M, 9M)]

type Vertex = {decimal: decimal}

let edges = 
    tup
    |> List.map (fun x -> ({decimal = fst x}, {decimal = snd x}))
    |> List.map (fun x -> Edge<Vertex> x)

//Undirected Graph
let undirGraph = edges.ToUndirectedGraph()

undirGraph.Edges
undirGraph.Vertices

let x = QuickGraph.Algorithms.ConnectedComponents.ConnectedComponentsAlgorithm(undirGraph)

вывод undirGraph.Edges:

val it : Collections.Generic.IEnumerable<Edge<Vertex>> =
seq
[FSI_0227+Vertex->FSI_0227+Vertex {Source = {decimal = 1M;};
                                       Target = {decimal = 1M;};};
 FSI_0227+Vertex->FSI_0227+Vertex {Source = {decimal = 2M;};
                                   Target = {decimal = 18M;};};
 FSI_0227+Vertex->FSI_0227+Vertex {Source = {decimal = 3M;};
                                   Target = {decimal = 3M;};};
 FSI_0227+Vertex->FSI_0227+Vertex {Source = {decimal = 4M;};
                                   Target = {decimal = 5M;};}; ...]

и undirGraph.Vertices:

val it : Collections.Generic.IEnumerable<Vertex> =
seq
[{decimal = 1M;}; {decimal = 2M;}; {decimal = 18M;}; {decimal = 3M;}; ...]

как ожидается.

неориентированный график создан успешно, но теперь я застрял. Отсюда я не знаю, как установить связь. компоненты графика или, честно говоря, если я использую правильную структуру графика.

я ожидал x чтобы содержать компоненты в графике, но выводить из x;; в FSI выглядит так:

output from x in the FSI

значения в Примеру tuple list представляют BillTo и ShipTo значения идентификаторов клиентов в базе данных.

документация в библиотеке QuickGraph разрежена, особенно для тех, кто пытается - учись на лету."

этот вопрос заменяетпредыдущий вопрос я написал. Я думал изменить свой предыдущий вопрос, но, поскольку это совершенно отдельный вопрос, решил оставить его как есть.

7
.net c# f# quickgraph

2 ответов

библиотека QuickGraph не имеет интерфейса, который был бы очевиден для программистов F# (хотя я уверен, что программисты C# получают это немедленно). Оказывается, вам нужно позвонить в Compute метод алгоритм, чтобы на самом деле заставить его работать!

Я взял ваш пример кода и просто добавил вызов Compute:

let x = QuickGraph.Algorithms.ConnectedComponents.
          ConnectedComponentsAlgorithm(undirGraph)
x.Compute()

после этого x.Components содержит словарь, который присваивает индекс компонента каждой вершине, поэтому, если вы хотите группы вершин (представляя компоненты), вы можете просто сгруппировать результаты по Value (который является индексом компонента):

x.Components 
|> Seq.groupBy (fun kv -> kv.Value)
|> Seq.map (fun (comp, vertices) -> 
    comp, vertices |> Seq.map (fun kv -> kv.Key))

это дает следующее:

[ (0, [{decimal = 1M;}]); 
  (1, [{decimal = 2M;}; {decimal = 18M;}]);
  (2, [{decimal = 3M;}]);
  (3, [{decimal = 4M;}; {decimal = 5M;}; {decimal = 24M;}; 
       {decimal = 6M;}; {decimal = 7M;}]);
  (4, [{decimal = 8M;}; {decimal = 9M;}; {decimal = 10M;}]) ]
3

это то, что вы ищете?

Graph

Я бы использовал rprovider для отправки кода в R и создания этого, а затем при необходимости обернуть его в dll. Затем вы можете использовать components, clusters, groups etc. чтобы извлечь соединения.

# In R:
g1 <- graph(  edges=c( "1","1", "2", "18", "3", "3", "4", "5", "5", "24", "24", "6", "7", "6", "8", "9", "10", "9"),n=9,directed=T)
plot(g1)
comp1 <- components(g1)
comp1
groups(comp1)
cl <- clusters(g1)
lapply(seq_along(cl$csize)[cl$csize > 1], function(x) 
  V(g1)$name[cl$membership %in% x])

в случае, если вы решите по-прежнему придерживаться QuickGraph, то, что вы видите в FSI, потому что вы определяете тип записи под названием Vertex который имеет один член, называемый decimal of тип decimal. Это немного запутанно, поэтому изначально я бы предложил вам придерживаться int и просто создавать диаграмму следующим образом:

let tup = [(1,1); (2, 18); (3, 3); (4, 5); (5, 24); (24, 6); (7, 6); (8, 9); (10, 9)]
let edges =
    tup |> List.map (fun x -> SEdge<int>(fst x, snd x))
let graph = edges.ToAdjacencyGraph()
let uniGraph = edges.ToUndirectedGraph()

вы также можете просто написать какой-то словарь, как структура данных, которая хранит запись/количество ссылок.

6