/// <summary> /// Konstruktor klasy NewGraphPage /// </summary> public NewGraphPage() { InitializeComponent(); graph = new BipartiteGraph(); ConnectionsTable.AutoGenerateColumns = false; SizeChanged += DrawOnSizeChange; }
public override void Reset() { // get number of bipartite graphs m = (int)Math.Ceiling(Math.Log(this.Domains.Count, 2)); // create bipartite graphs this.bipartiteGraphs = new List <BipartiteGraph>(m); for (int i = 0; i < m; ++i) { // create bipartie graph BipartiteGraph bg = new BipartiteGraph(this.Domains.Count); this.bipartiteGraphs.Add(bg); // do some swapping if (i > 0) { bg.Swap(i - 1, bg.Left.Count + i - 1); } } this.bipartiteGraphIndex = -1; this.leftIndex = 0; this.rightIndex = 0; this.tuple = null; }
public void TestTryBuildWithEmptyGraph() { var graph = new BipartiteGraph(1000, 2000); Matching matching; Assert.IsFalse(builder.TryBuild(graph, out matching)); }
public void IsBipartite(List <int[]> input, bool expected) { var sut = new BipartiteGraph(); var actual = sut.IsBipartite(input.ToArray()); Assert.AreEqual(expected, actual); }
public GraphBasedDependencyAnalysis(IEnumerable <WorkflowComponent> components) { Components = components?.ToList() ?? throw new NullReferenceException(); List <Data> allData = components.GetAllData(); forwardGraph = GraphBuilder.BipartiteFromTwoSets(components, allData, c => c.ModelDataOutputs, c => c.ModelDataInputs); backwardGraph = forwardGraph.Transpose(); }
/// <summary> /// Metoda LoadGraph wczytująca graf z pliku użytkownika <see cref="BipartiteGraphIO"/> /// </summary> private void LoadGraph() { graph = BipartiteGraphIO.LoadBipartiteGraph(); if (graph != null) { UpdateVertex(); } }
public void TestSimpleTryBuild() { var graph = new BipartiteGraph(1, 2); graph.AddEdge(0, 1); Matching matching; Assert.IsTrue(builder.TryBuild(graph, out matching)); }
public static EdgeList ToEdges(BipartiteGraph g, List <GraphNode> cycle) { var elist = new EdgeList(); for (int i = 1; i < cycle.Count; i++) { Edge edg = g.Edges.FindByNodes(cycle[cycle.Count - i], cycle[cycle.Count - i - 1]); elist.Add(edg); } return(elist); }
public void TestTryBuildWithCycleGraph() { var graph = new BipartiteGraph(2, 2); graph.AddEdge(0, 1); graph.AddEdge(1, 0); graph.AddEdge(0, 0); graph.AddEdge(1, 1); Matching matching; Assert.IsTrue(builder.TryBuild(graph, out matching)); }
public bool TryBuild(BipartiteGraph graph, out Matching matching) { matching = new Matching(graph.SecondPartSize); for (var i = 0; i < graph.FirstPartSize; ++i) { var used = new bool[graph.FirstPartSize]; if (!TryKuhn(i, used, graph, matching)) { return(false); } } return(true); }
public void TestHasAnotherMatching() { var graph = new BipartiteGraph(2, 2); graph.AddEdge(0, 0); graph.AddEdge(0, 1); graph.AddEdge(1, 1); var matching = new Matching(2); matching.AddPair(0, 0); matching.AddPair(1, 1); Assert.IsFalse(builder.HasAnotherMatching(graph, matching)); }
public double Compute(BipartiteGraph <V, EA> bipartitePossibilities) { // "dijkstra" simple upper bound heuristic return(Math.Min( bipartitePossibilities.potentialConnections .Where((kvp) => kvp.Value.Count > 0) .Count(), bipartitePossibilities.potentialConnectionsReversed .Where((kvp) => kvp.Value.Count > 0) .Count() )); }
public static void Enum_Maximum_Matching_Iter(BipartiteGraph G, EdgeList M) { //Step-1: If G has no edge, STOP if (G.Edges.Count == 0) { return; } var obj = new CycleInDirectedGraph(G); if (!obj.HasCycle) { return; } //Step-2: Choose an edge e. Edge e = chooseEdge(M, ToEdges(G, obj.Cycle)); }
private void CreateTuple() { // get bipartite graph BipartiteGraph bg = (BipartiteGraph)this.bipartiteGraphs[this.bipartiteGraphIndex]; this.tuple = new Tuple(); for (int i = 0; i < this.Domains.Count; ++i) { if (bg.Left.ContainsKey(i)) { this.tuple.Add(this.Domains[i][leftIndex]); } else { this.tuple.Add(this.Domains[i][rightIndex]); } } }
public void Bipartite_Test() { var BG = new Graph(7); BG.AddEdge(0, 1); BG.AddEdge(0, 2); BG.AddEdge(0, 5); BG.AddEdge(0, 6); BG.AddEdge(2, 3); BG.AddEdge(2, 4); BG.AddEdge(1, 3); BG.AddEdge(4, 6); BG.AddEdge(4, 5); IEnumerable <int> G1; IEnumerable <int> G2; bool actual = BipartiteGraph.Depart(BG, out G1, out G2); Assert.IsTrue(actual); }
/// <summary> /// Partitions a complex polygon (with chords and holes) into a group of chordless polygons. /// </summary> /// <param name="allIsoPerims">Array of lists of Vector2s, each describing a perimeter of a tile group.</param> /// <returns>A list of lists of Vector2s, each list describing a chordless polygon.</returns> // ReSharper disable once ReturnTypeCanBeEnumerable.Local private static (List <Chord>, List <ChordlessPolygon>) _ComplexToChordlessPolygons(List <Vector2>[] allIsoPerims) { HashSet <ConcaveVertex> concaveVertices = ConcaveVertexFinder.GetConcaveVertices(allIsoPerims); List <Chord> chords = _FindChords(concaveVertices, allIsoPerims); Dictionary <BipartiteGraphNode, Chord> bipartiteNodeToChords = _ConvertChordsToNodes(chords); var bipartiteGraph = new BipartiteGraph(bipartiteNodeToChords.Keys); HashSet <BipartiteGraphNode> maxIndependentSet = bipartiteGraph.GetMaxIndependentSet(); List <PolygonSplittingGraphNode> polygonSplittingNodes = _ConstructPolygonSplittingNodes(allIsoPerims, bipartiteNodeToChords, maxIndependentSet); var holes = new List <List <Vector2> >(); for (int i = 1; i < allIsoPerims.Length; i++) { holes.Add(allIsoPerims[i]); } var polygonSplittingGraph = new PolygonSplittingGraph(polygonSplittingNodes, holes); List <ChordlessPolygon> minCycles = polygonSplittingGraph.GetMinCycles(); return(chords, minCycles); }
private static int[] CanUseParameters(MethodBase info, Type[] parameterTypes) { ParameterInfo[] parameters = info.GetParameters(); if (parameters.Length < parameterTypes.Length) { return(null); } var permutation = new int[parameters.Length]; var graph = new BipartiteGraph(parameterTypes.Length, parameters.Length); for (int index = 0; index < parameters.Length; index++) { permutation[index] = -1; ParameterInfo parameter = parameters[index]; if (parameter.IsOut) { return(null); } for (int i = 0; i < parameterTypes.Length; i++) { if (parameter.ParameterType.IsAssignableFrom(parameterTypes[i])) { graph.AddEdge(i, index); } } } Matching matching; if (!matchingBuilder.TryBuild(graph, out matching) || matchingBuilder.HasAnotherMatching(graph, matching)) { return(null); } for (int i = 0; i < parameters.Length; i++) { if (matching.HasPair(i)) { permutation[i] = matching.GetPair(i); } } return(permutation); }
public void ComplexTest() { var graph = new BipartiteGraph(5, 5); graph.AddEdge(0, 0); graph.AddEdge(0, 3); graph.AddEdge(4, 0); graph.AddEdge(1, 1); graph.AddEdge(1, 2); graph.AddEdge(2, 1); graph.AddEdge(4, 2); graph.AddEdge(3, 3); graph.AddEdge(4, 4); Matching matching; Assert.IsTrue(builder.TryBuild(graph, out matching)); Assert.IsFalse(builder.HasAnotherMatching(graph, matching)); graph.AddEdge(1, 4); Assert.IsTrue(builder.HasAnotherMatching(graph, matching)); }
private bool TryKuhn(int v, bool[] used, BipartiteGraph bipartiteGraph, Matching matching) { if (used[v]) { return(false); } used[v] = true; for (var i = 0; i < bipartiteGraph.SecondPartSize; ++i) { if (bipartiteGraph.IsConnected(v, i)) { var to = i; if (!matching.HasPair(to) || TryKuhn(matching.GetPair(to), used, bipartiteGraph, matching)) { matching.AddPair(to, v); return(true); } } } return(false); }
public bool HasAnotherMatching(BipartiteGraph graph, Matching matching) { for (var i = 0; i < graph.SecondPartSize; i++) { if (matching.HasPair(i)) { var pair = matching.GetPair(i); matching.RemovePair(i); graph.RemoveEdge(pair, i); var used = new bool[graph.FirstPartSize]; if (TryKuhn(pair, used, graph, matching)) { matching.AddPair(i, pair); graph.AddEdge(pair, i); return(true); } matching.AddPair(i, pair); graph.AddEdge(pair, i); } } return(false); }
public double Compute(BipartiteGraph <V, EA> bipartitePossibilities) { if (bipartitePossibilities.potentialConnections.Count == 0 || bipartitePossibilities.potentialConnectionsReversed.Count == 0) { return(0); } var setA = new List <V>(); var setB = new List <V>(); var edges = new List <Edge <V> >(); foreach (var left in bipartitePossibilities.potentialConnections) { foreach (var right in left.Value) { edges.Add(new Edge <V>(left.Key, right)); } } setA.AddRange(bipartitePossibilities.potentialConnections.Keys); setB.AddRange(bipartitePossibilities.potentialConnectionsReversed.Keys); var graph = new AdjacencyGraph <V, Edge <V> >(true); graph.AddVerticesAndEdgeRange(edges); VertexFactory <V> vertexFactory = () => vertexGenerator(); EdgeFactory <V, Edge <V> > edgeFactory = (source, target) => new Edge <V>(source, target); var maxMatch = new MaximumBipartiteMatchingAlgorithm <V, Edge <V> >(graph, setA, setB, vertexFactory, edgeFactory); maxMatch.Compute(); return(maxMatch.MatchedEdges.Count); }
// Alternative way of calculating the boolean width of a decomposition by counting the number of maximal independent sets in bipartite graphs, // constructed for each cut of the decomposition private long CalculateBooleanWidthBiPartite() { BitSet left = new BitSet(0, Graph.Size); BitSet right = Graph.Vertices; long max = int.MinValue; foreach (int v in Sequence) { left += v; right -= v; // Construct the bipartite graph BipartiteGraph bg = new BipartiteGraph(Graph, left, right); // Count the number of maximal independent sets in this bipartite graph max = Math.Max(max, CcMis.Compute(bg)); } return max; }