/// <summary>
/// Initializes this Edge's two DirectedEdges, and for each DirectedEdge: sets the
/// Edge, sets the symmetric DirectedEdge, and adds this Edge to its from-Node.
/// </summary>
/// <param name="de0"></param>
/// <param name="de1"></param>
public void SetDirectedEdges(DirectedEdge de0, DirectedEdge de1)
{
dirEdge = new[] { de0, de1, };
de0.Edge = this;
de1.Edge = this;
de0.Sym = de1;
de1.Sym = de0;
de0.FromNode.AddOutEdge(de0);
de1.FromNode.AddOutEdge(de1);
}
public void AddEdge(int v, int w,double weight)
{
DirectedEdge e1 = new DirectedEdge (v,w,weight);
if (dictionary [v] == null) {
dictionary [v] = new HashSet<DirectedEdge> (){ e1 };
}
else {
dictionary [v].Add (e1);
}
}
public virtual void AddEdge(DirectedEdge edge)
{
edgeCount++;
int from = edge.From;
if (adjacents[from] == null)
{
adjacents[from] = new List<DirectedEdge>();
}
adjacents[from].Add(edge);
}
/// <summary>
/// Initializes an empty edge-weighted digraph with <tt>V</tt> vertices and 0 edges.
/// </summary>
/// <param name="v">V the number of vertices</param>
/// <exception cref="ArgumentException">if <tt>V</tt> < 0</exception>
public AdjMatrixEdgeWeightedDigraph(int v)
{
if (v < 0) throw new ArgumentException("Number of vertices must be nonnegative");
V = v;
E = 0;
_adj = new DirectedEdge[v][];
for (var i = 0; i < v; i++)
{
_adj[i] = new DirectedEdge[v];
}
}
public void Run()
{
var eu = new EdgeU(100, 50);
var ed = new EdgeD(22, 11);
var ew = new EdgeW(12, 34, 5.67);
var dew = new DirectedEdge(12, 34, 5.67);
Console.WriteLine(eu);
Console.WriteLine(ed);
Console.WriteLine(ew);
Console.WriteLine(dew);
Console.ReadLine();
}
private void write_edges_with_shapeids(IList<VA.Shapes.Connections.ConnectorEdge> edges)
{
foreach (var edge in edges)
{
var e = new DirectedEdge(
edge.From.ID,
edge.To.ID,
edge.Connector.ID
);
this.WriteObject(e);
}
}
/// <summary>
/// Initializes a random edge-weighted digraph with <tt>V</tt> vertices and <em>E</em> edges.
/// </summary>
/// <param name="v">V the number of vertices</param>
/// <param name="e">E the number of edges</param>
/// <exception cref="ArgumentException">if <tt>V</tt> < 0</exception>
/// <exception cref="ArgumentException">if <tt>E</tt> < 0</exception>
public EdgeWeightedDigraph(int v, int e)
: this(v)
{
if (e < 0) throw new ArgumentException("Number of edges in a Digraph must be nonnegative");
for (var i = 0; i < e; i++)
{
var ve = StdRandom.Uniform(v);
var we = StdRandom.Uniform(v);
var weight = .01 * StdRandom.Uniform(100);
var edge = new DirectedEdge(ve, we, weight);
AddEdge(edge);
}
}
private void Relax(DirectedEdge edge)
{
int v = edge.From;
int w = edge.To;
if (distTo[w] > distTo[v] + edge.Weight)
{
edgeTo[w] = edge;
distTo[w] = distTo[v] + edge.Weight;
if (pq.Contains(w))
pq.DecreaseKey(w, distTo[w]);
else
pq.Insert(w, distTo[w]);
}
}
/// <summary>
/// Removes this directed edge from its containing graph.
/// </summary>
internal void Remove()
{
this.sym = null;
this.parentEdge = null;
}
public void Initial_vertex_should_be_correct()
{
var edge = new DirectedEdge<int>(1, 2);
edge.InitialVertex.ShouldEqual(1);
}
public static bool LeadsOutOf(this DirectedEdge edge, Path path)
{
return(path.All(n => edge.To != n) && path.Any(n => edge.From == n));
}
/// <summary>
///
/// </summary>
/// <param name="start"></param>
/// <param name="geometryFactory"></param>
public MinimalEdgeRing(DirectedEdge start, IGeometryFactory geometryFactory)
: base(start, geometryFactory)
{
}
private bool Check(EdgeWeightedDigraph G, int s)
{
// check that edge weights are nonnegative
foreach (DirectedEdge e in G.edges())
{
if (e.Weight() < 0)
{
throw new System.Exception("negative edge weight detected");
return(false);
}
}
// check that distTo[v] and edgeTo[v] are consistent
if (distTo[s] != 0.0 || edgeTo[s] != null)
{
throw new System.Exception("distTo[s] and edgeTo[s] inconsistent");
return(false);
}
for (int v = 0; v < G.V(); v++)
{
if (v == s)
{
continue;
}
if (edgeTo[v] == null && distTo[v] != double.PositiveInfinity)
{
throw new System.Exception("distTo[] and edgeTo[] inconsistent");
return(false);
}
}
// check that all edges e = v->w satisfy distTo[w] <= distTo[v] + e.weight()
for (int v = 0; v < G.V(); v++)
{
foreach (DirectedEdge e in G.Adj(v))
{
int w = e.to();
if (distTo[v] + e.Weight() < distTo[w])
{
throw new System.Exception("edge " + e + " not relaxed");
return(false);
}
}
}
// check that all edges e = v->w on SPT satisfy distTo[w] == distTo[v] + e.weight()
for (int w = 0; w < G.V(); w++)
{
if (edgeTo[w] == null)
{
continue;
}
DirectedEdge e = edgeTo[w];
int v = e.from();
if (w != e.to())
{
return(false);
}
if (distTo[v] + e.Weight() != distTo[w])
{
throw new System.Exception("edge " + e + " on shortest path not tight");
return(false);
}
}
return(true);
}
/// <summary>
/// relax edge e, but update if you find a *longer* path
/// </summary>
/// <param name="e"></param>
private void Relax(DirectedEdge e)
{
int v = e.From(), w = e.To();
if (_distTo[w] < _distTo[v] + e.Weight)
{
_distTo[w] = _distTo[v] + e.Weight;
_edgeTo[w] = e;
}
}
private void ReleaseEdge(object sender, MouseButtonEventArgs args)
{
Contract.Assert(!args.Handled);
Contract.Assert(sender != null);
Contract.Assert(_source != null);
var vertex = sender as Vertex;
if (vertex != null)
{
String sourceName = (String)_source.GetValue(NameProperty),
sinkName = (String)vertex.GetValue(NameProperty);
if (GetValue(GraphProperty) is DirectedWeightedGraph)
{
var g = (DirectedWeightedGraph)GetValue(GraphProperty);
Graphs.Vertex source = g.Vertices.Single(v => v.Name == sourceName),
sink = g.Vertices.Single(v => v.Name == sinkName);
var e = new DirectedWeightedEdge(source, sink, 0); // нужно сделать вызов диалога задания веса
var ed = g[source, sink];
if (ed == null)
{
g.AddEdge(e);
}
else
{
g.RemoveEdge(ed);
}
}
if (GetValue(GraphProperty) is DirectedGraph)
{
var g = (DirectedGraph)GetValue(GraphProperty);
Graphs.Vertex source = g.Vertices.Single(v => v.Name == sourceName),
sink = g.Vertices.Single(v => v.Name == sinkName);
var e = new DirectedEdge(source, sink);
var ed = g[source, sink];
if (ed == null)
{
g.AddEdge(e);
}
else
{
g.RemoveEdge(ed);
}
}
if (GetValue(GraphProperty) is UndirectedGraph)
{
var g = (UndirectedGraph)GetValue(GraphProperty);
Graphs.Vertex source = g.Vertices.Single(v => v.Name == sourceName),
sink = g.Vertices.Single(v => v.Name == sinkName);
var e = new UndirectedEdge(source, sink);
var ed = g[source, sink];
if (ed == null)
{
g.AddEdge(e);
}
else
{
g.RemoveEdge(ed);
}
}
}
LayoutRoot.Children.Remove(_arrow);
_arrow = null;
LayoutRoot.MouseMove -= DirectEdge;
foreach (var v in LayoutRoot.Children)
{
v.MouseLeftButtonUp -= ReleaseEdge;
}
LayoutRoot.ReleaseMouseCapture();
}
public static Dictionary <string, string> ReorderParserRules(int pos, Document document, LspAntlr.ReorderType type)
{
var result = new Dictionary <string, string>();
// Check if lexer grammar.
AntlrGrammarDetails pd_parser = ParserDetailsFactory.Create(document) as AntlrGrammarDetails;
ExtractGrammarType lp = new ExtractGrammarType();
ParseTreeWalker.Default.Walk(lp, pd_parser.ParseTree);
var is_lexer = lp.Type == ExtractGrammarType.GrammarType.Lexer;
if (is_lexer)
{
return(result);
}
Table table = new Table(pd_parser, document);
table.ReadRules();
table.FindPartitions();
table.FindStartRules();
// Find new order or rules.
string old_code = document.Code;
List <Pair <int, int> > reorder = new List <Pair <int, int> >();
if (type == LspAntlr.ReorderType.DFS)
{
Digraph <string> graph = new Digraph <string>();
foreach (var r in table.rules)
{
if (!r.is_parser_rule)
{
continue;
}
graph.AddVertex(r.LHS);
}
foreach (var r in table.rules)
{
if (!r.is_parser_rule)
{
continue;
}
var j = r.RHS;
//j.Reverse();
foreach (var rhs in j)
{
var sym = table.rules.Where(t => t.LHS == rhs).FirstOrDefault();
if (!sym.is_parser_rule)
{
continue;
}
var e = new DirectedEdge <string>(r.LHS, rhs);
graph.AddEdge(e);
}
}
List <string> starts = new List <string>();
foreach (var r in table.rules)
{
if (r.is_parser_rule && r.is_start)
{
starts.Add(r.LHS);
}
}
Graphs.DepthFirstOrder <string, DirectedEdge <string> > sort = new DepthFirstOrder <string, DirectedEdge <string> >(graph, starts);
var ordered = sort.ToList();
foreach (var s in ordered)
{
var row = table.rules[table.nt_to_index[s]];
reorder.Add(new Pair <int, int>(row.start_index, row.end_index));
}
}
else if (type == LspAntlr.ReorderType.BFS)
{
Digraph <string> graph = new Digraph <string>();
foreach (var r in table.rules)
{
if (!r.is_parser_rule)
{
continue;
}
graph.AddVertex(r.LHS);
}
foreach (var r in table.rules)
{
if (!r.is_parser_rule)
{
continue;
}
var j = r.RHS;
//j.Reverse();
foreach (var rhs in j)
{
var sym = table.rules.Where(t => t.LHS == rhs).FirstOrDefault();
if (!sym.is_parser_rule)
{
continue;
}
var e = new DirectedEdge <string>(r.LHS, rhs);
graph.AddEdge(e);
}
}
List <string> starts = new List <string>();
foreach (var r in table.rules)
{
if (r.is_parser_rule && r.is_start)
{
starts.Add(r.LHS);
}
}
Graphs.BreadthFirstOrder <string, DirectedEdge <string> > sort = new BreadthFirstOrder <string, DirectedEdge <string> >(graph, starts);
var ordered = sort.ToList();
foreach (var s in ordered)
{
var row = table.rules[table.nt_to_index[s]];
reorder.Add(new Pair <int, int>(row.start_index, row.end_index));
}
}
else if (type == LspAntlr.ReorderType.Alphabetically)
{
var ordered = table.rules
.Where(r => r.is_parser_rule)
.Select(r => r.LHS)
.OrderBy(r => r).ToList();
foreach (var s in ordered)
{
var row = table.rules[table.nt_to_index[s]];
reorder.Add(new Pair <int, int>(row.start_index, row.end_index));
}
}
else
{
return(result);
}
StringBuilder sb = new StringBuilder();
int previous = 0;
{
int index_start = table.rules[0].start_index;
int len = 0;
string pre = old_code.Substring(previous, index_start - previous);
sb.Append(pre);
previous = index_start + len;
}
foreach (var l in reorder)
{
int index_start = l.a;
int len = l.b - l.a;
string add = old_code.Substring(index_start, len);
sb.Append(add);
}
// Now add all non-parser rules.
foreach (var r in table.rules)
{
if (r.is_parser_rule)
{
continue;
}
int index_start = r.start_index;
int len = r.end_index - r.start_index;
string add = old_code.Substring(index_start, len);
sb.Append(add);
}
//string rest = old_code.Substring(previous);
//sb.Append(rest);
string new_code = sb.ToString();
result.Add(document.FullPath, new_code);
return(result);
}
/// <summary>
///
/// </summary>
/// <param name="de"></param>
/// <param name="er"></param>
public override void SetEdgeRing(DirectedEdge de, EdgeRing er)
{
de.MinEdgeRing = er;
}
private void augment()
{
EdgeWeightedDigraph edgeWeightedDigraph = new EdgeWeightedDigraph(2 * this.N + 2);
int num = 2 * this.N;
int num2 = 2 * this.N + 1;
for (int i = 0; i < this.N; i++)
{
if (this.xy[i] == -1)
{
edgeWeightedDigraph.addEdge(new DirectedEdge(num, i, (double)0f));
}
}
for (int i = 0; i < this.N; i++)
{
if (this.yx[i] == -1)
{
edgeWeightedDigraph.addEdge(new DirectedEdge(this.N + i, num2, this.py[i]));
}
}
for (int i = 0; i < this.N; i++)
{
for (int j = 0; j < this.N; j++)
{
if (this.xy[i] == j)
{
edgeWeightedDigraph.addEdge(new DirectedEdge(this.N + j, i, (double)0f));
}
else
{
edgeWeightedDigraph.addEdge(new DirectedEdge(i, this.N + j, this.reduced(i, j)));
}
}
}
DijkstraSP dijkstraSP = new DijkstraSP(edgeWeightedDigraph, num);
Iterator iterator = dijkstraSP.pathTo(num2).iterator();
while (iterator.hasNext())
{
DirectedEdge directedEdge = (DirectedEdge)iterator.next();
int num3 = directedEdge.from();
int num4 = directedEdge.to() - this.N;
if (num3 < this.N)
{
this.xy[num3] = num4;
this.yx[num4] = num3;
}
}
for (int j = 0; j < this.N; j++)
{
double[] arg_180_0 = this.px;
int num5 = j;
double[] array = arg_180_0;
array[num5] += dijkstraSP.distTo(j);
}
for (int j = 0; j < this.N; j++)
{
double[] arg_1B6_0 = this.py;
int num5 = j;
double[] array = arg_1B6_0;
array[num5] += dijkstraSP.distTo(this.N + j);
}
}
/// <summary>
/// Adds a DirectedEdge which is known to form part of this ring.
/// </summary>
/// <param name="de">The DirectedEdge to add.</param>
public void Add(DirectedEdge de)
{
deList.Add(de);
}
public void AddEdge(DirectedEdge e)
{
m_adj[e.From()].Add(e);
m_e++;
}
private double Solve(DirectedWeightedGraph digraph, int root)
{
int vertex_size = digraph.V;
int edge_size = digraph.E;
double res = 0; //记录最终的最小树形图的
int v;
List <DirectedEdge> edge = ((IEnumerable <DirectedEdge>)digraph).ToList(); //digraph.ToList();
while (true)
{
for (int i = 0; i < vertex_size; ++i)
{
inw[i] = double.PositiveInfinity;//初始化权重很大
}
for (int i = 0; i < edge_size; ++i)
{
DirectedEdge dedge = (DirectedEdge)edge[i];
if (dedge.Src != dedge.End && dedge.Weight < inw[dedge.End])
{
//如果不是一个环、边的权值小于指向节点的权值。记录前驱
pre[dedge.End] = dedge.Src;
inw[dedge.End] = dedge.Weight;
}
}
//不能存在孤立点
for (int i = 0; i < vertex_size; ++i)
{
if (i != root && double.IsInfinity(inw[i]))
{
return(-1);
}
}
//找有向环
int tn = 0;//记录当前查找中的环总数
for (int i = 0; i < vertex_size; ++i)
{
id[i] = -1;
vis[i] = -1;
}
inw[root] = 0;//这是根
for (int i = 0; i < vertex_size; ++i)
{
res += inw[i]; //累加
v = i; //v 是开始遍历的节点。
//找图中的有向环 三种情况会终止while循环
//1,直到出现带有同样标记的点说明成环
//2,节点已经属于其他环
//3,遍历到根
while (vis[v] != i && id[v] == -1 && v != root)
{
vis[v] = i; //已经访问了
v = pre[v]; //向上查找
}
//因为找到某节点属于其他环 或者 遍历到根 说明当前没有找到有向环
if (v != root && id[v] == -1)//必须上述查找已经找到有向环
{
for (int u = pre[v]; u != v; u = pre[u])
{
id[u] = tn; //记录节点所属的 环编号
}
id[v] = tn++; //记录节点所属的 环编号 环编号累加
}
}
if (tn == 0)
{
break;//不存在有向环
}
//可能存在独立点
for (int i = 0; i < vertex_size; i++)
{
if (id[i] == -1)
{
id[i] = tn++;//环数累加
}
}
//对有向环缩点 和SCC缩点很像吧
for (int i = 0; i < edge_size; ++i)
{
DirectedEdge dedge = (DirectedEdge)edge[i];
v = dedge.Src;
dedge.Src = id[dedge.Src];
dedge.End = id[dedge.End];
//<u, v>有向边
//两点不在同一个环 u到v的距离为 边权cost - in[v]
if (dedge.Src != dedge.End)
{
dedge.Weight -= inw[v];//更新边权值 继续下一条边的判定
}
}
vertex_size = tn;//以环总数为下次操作的点数 继续执行上述操作 直到没有环
root = id[root];
}
return(res);
}
public void Run()
{
Console.WriteLine("Choose file:"); // Prompt
Console.WriteLine("1 - tinyEWDn.txt"); // Prompt
Console.WriteLine("2 - tinyEWDnc.txt"); // Prompt
//Console.WriteLine("3 - mediumEWG.txt"); // Prompt
Console.WriteLine("or quit"); // Prompt
var fileNumber = Console.ReadLine();
string fileName;
switch (fileNumber)
{
case "1":
fileName = "tinyEWDn.txt";
break;
case "2":
fileName = "tinyEWDnc.txt";
break;
//case "3":
// fileName = "largeEWG.zip";
// break;
case "quit":
return;
default:
return;
}
var @in = new In($"Files\\Graphs\\{fileName}");
var lines = @in.ReadAllLines();
var lineIterator = 0;
var v = 0;
var e = 0;
var edges = new List <DirectedEdge>();
foreach (var line in lines)
{
if (lineIterator == 0)
{
v = Convert.ToInt32(line);
}
if (lineIterator == 1)
{
e = Convert.ToInt32(line);
}
if (lineIterator > 1)
{
var lineSplitted = line.Split(new[] { ' ' }, StringSplitOptions.RemoveEmptyEntries);
var ve = Convert.ToInt32(lineSplitted[0]);
var we = Convert.ToInt32(lineSplitted[1]);
var weight = Convert.ToDouble(lineSplitted[2], CultureInfo.InvariantCulture);
var edge = new DirectedEdge(ve, we, weight);
edges.Add(edge);
}
lineIterator++;
}
var edgeWeightedDigraph = new EdgeWeightedDigraph(v, e, edges);
Console.WriteLine(edgeWeightedDigraph);
const int s = 0;
// compute shortest paths
var sp = new BellmanFordSP(edgeWeightedDigraph, s);
// print negative cycle
if (sp.HasNegativeCycle())
{
foreach (var edge in sp.NegativeCycle())
{
Console.WriteLine(edge);
}
}
else
{
// print shortest path
for (var t = 0; t < edgeWeightedDigraph.V; t++)
{
if (sp.HasPathTo(t))
{
Console.Write($"{s} to {t} {$"{sp.DistTo(t):0.00}"} ");
foreach (var edge in sp.PathTo(t))
{
Console.Write($"{edge} ");
}
Console.WriteLine();
}
else
{
Console.WriteLine($"{s} to {t} no path{Environment.NewLine}");
}
}
}
Console.ReadLine();
}
/**/ public static void main(string[] strarr)
{
DirectedEdge obj = new DirectedEdge(12, 23, 3.14);
StdOut.println(obj);
}
private void Relax( DirectedEdge edge )
{
int v = edge.From;
int w = edge.To;
if ( _distanceTo[w] > _distanceTo[v] + edge.Weight )
{
_distanceTo[w] = _distanceTo[v] + edge.Weight;
_edgeTo[w] = edge;
if ( _priorityQueue.Contains( w ) )
{
_priorityQueue.DecreaseKey( w, _distanceTo[w] );
}
else
{
_priorityQueue.Insert( w, _distanceTo[w] );
}
}
}
public void CommandifiedGraphAddRemoveGraphAndEdgesWithUndoTest()
{
Guid sessionId = Guid.NewGuid();
CQManager.ActivateCommandQueueStack(sessionId);
DirectedGraph<int, DirectedEdge<int>> graph = new DirectedGraph<int, DirectedEdge<int>>(true);
graph.Add(42);
graph.Add(13);
graph.Add(10);
graph.Add(new DirectedEdge<int>(42, 13)); // 42 -> 13
graph.Add(new DirectedEdge<int>(42, 10)); // 42 -> 10
Assert.IsTrue(graph.Contains(42));
Assert.IsTrue(graph.Contains(13));
Assert.IsTrue(graph.Contains(10));
Assert.AreEqual(2, graph.EdgeCount);
Assert.IsTrue(graph.ContainsEdge(42, 13));
Assert.IsTrue(graph.ContainsEdge(42, 10));
// create graph to add to this graph. Doesn't have to be a commandified graph, as we're not rolling back the actions on that graph.
DirectedGraph<int, DirectedEdge<int>> graphToAdd = new DirectedGraph<int, DirectedEdge<int>>();
graphToAdd.Add(1);
graphToAdd.Add(2);
graphToAdd.Add(3);
graphToAdd.Add(new DirectedEdge<int>(1, 2)); // 1 -> 2
graphToAdd.Add(new DirectedEdge<int>(1, 3)); // 1 -> 3
graphToAdd.Add(new DirectedEdge<int>(2, 3)); // 2 -> 3
Assert.AreEqual(3, graphToAdd.VertexCount);
Assert.AreEqual(3, graphToAdd.EdgeCount);
// add this graph to the main graph. This is an undoable action.
graph.Add(graphToAdd);
Assert.AreEqual(6, graph.VertexCount);
Assert.AreEqual(5, graph.EdgeCount);
Assert.IsTrue(graph.Contains(1));
Assert.IsTrue(graph.Contains(2));
Assert.IsTrue(graph.Contains(3));
Assert.IsTrue(graph.ContainsEdge(1, 2));
Assert.IsTrue(graph.ContainsEdge(1, 3));
Assert.IsTrue(graph.ContainsEdge(2, 3));
// undo add
CQManager.UndoLastCommand();
Assert.AreEqual(3, graph.VertexCount);
Assert.AreEqual(2, graph.EdgeCount);
Assert.IsFalse(graph.Contains(1));
Assert.IsFalse(graph.Contains(2));
Assert.IsFalse(graph.Contains(3));
Assert.IsFalse(graph.ContainsEdge(1, 2));
Assert.IsFalse(graph.ContainsEdge(1, 3));
Assert.IsFalse(graph.ContainsEdge(2, 3));
// redo
CQManager.RedoLastCommand();
Assert.AreEqual(6, graph.VertexCount);
Assert.AreEqual(5, graph.EdgeCount);
Assert.IsTrue(graph.Contains(1));
Assert.IsTrue(graph.Contains(2));
Assert.IsTrue(graph.Contains(3));
Assert.IsTrue(graph.ContainsEdge(1, 2));
Assert.IsTrue(graph.ContainsEdge(1, 3));
Assert.IsTrue(graph.ContainsEdge(2, 3));
// remove the graph we added
graph.Remove(graphToAdd);
Assert.AreEqual(3, graph.VertexCount);
Assert.AreEqual(2, graph.EdgeCount);
Assert.IsFalse(graph.Contains(1));
Assert.IsFalse(graph.Contains(2));
Assert.IsFalse(graph.Contains(3));
Assert.IsFalse(graph.ContainsEdge(1, 2));
Assert.IsFalse(graph.ContainsEdge(1, 3));
Assert.IsFalse(graph.ContainsEdge(2, 3));
CQManager.UndoLastCommand();
Assert.AreEqual(6, graph.VertexCount);
Assert.AreEqual(5, graph.EdgeCount);
Assert.IsTrue(graph.Contains(1));
Assert.IsTrue(graph.Contains(2));
Assert.IsTrue(graph.Contains(3));
Assert.IsTrue(graph.ContainsEdge(1, 2));
Assert.IsTrue(graph.ContainsEdge(1, 3));
Assert.IsTrue(graph.ContainsEdge(2, 3));
DirectedEdge<int> newEdge = new DirectedEdge<int>(42, 1); // 42 -> 1
graph.Add(newEdge);
Assert.AreEqual(6, graph.EdgeCount);
Assert.IsTrue(graph.ContainsEdge(42, 1));
Assert.IsFalse(graph.ContainsEdge(1, 42));
CQManager.UndoLastCommand();
Assert.AreEqual(5, graph.EdgeCount);
Assert.IsFalse(graph.ContainsEdge(42, 1));
CQManager.RedoLastCommand();
Assert.AreEqual(6, graph.EdgeCount);
Assert.IsTrue(graph.ContainsEdge(42, 1));
graph.Remove(newEdge);
Assert.AreEqual(5, graph.EdgeCount);
Assert.IsFalse(graph.ContainsEdge(42, 1));
CQManager.UndoLastCommand();
Assert.AreEqual(6, graph.EdgeCount);
Assert.IsTrue(graph.ContainsEdge(42, 1));
graph.Disconnect(42, 1, false);
Assert.AreEqual(5, graph.EdgeCount);
Assert.IsFalse(graph.ContainsEdge(42, 1));
CQManager.UndoLastCommand();
Assert.AreEqual(6, graph.EdgeCount);
Assert.IsTrue(graph.ContainsEdge(42, 1));
CQManager.ActivateCommandQueueStack(Guid.Empty);
}
/// <summary>
/// relax edge e and update pq if changed
/// </summary>
/// <param name="e"></param>
private void Relax(DirectedEdge e)
{
int v = e.From(), w = e.To();
if (_distTo[w] > _distTo[v] + e.Weight)
{
_distTo[w] = _distTo[v] + e.Weight;
_edgeTo[w] = e;
if (_pq.Contains(w)) _pq.DecreaseKey(w, _distTo[w]);
else _pq.Insert(w, _distTo[w]);
}
}
private bool IsRightPath(DirectedEdge[] path, params int[] nodes)
{
if(path != null && path.Length > 0)
{
List<int> tmp = new List<int>();
tmp.Add(path[0].From);
foreach(DirectedEdge e in path)
{
tmp.Add(e.To);
}
if (tmp.Count != nodes.Length) return false;
for(int i = 0; i < nodes.Length; i++)
{
if (nodes[i] != tmp[i]) return false;
}
return true;
}
return false;
}
/// <summary>
/// Removes this directed edge from its containing graph.
/// </summary>
internal void Remove()
{
_sym = null;
_parentEdge = null;
}
/// <summary>
/// Constructs an Edge initialized with the given DirectedEdges, and for each
/// DirectedEdge: sets the Edge, sets the symmetric DirectedEdge, and adds
/// this Edge to its from-Node.
/// </summary>
/// <param name="de0"></param>
/// <param name="de1"></param>
public Edge(DirectedEdge de0, DirectedEdge de1)
{
SetDirectedEdges(de0, de1);
}
public void Run()
{
Console.WriteLine("Choose file:"); // Prompt
Console.WriteLine("1 - tinyEWD.txt"); // Prompt
Console.WriteLine("2 - mediumEWD.txt"); // Prompt
//Console.WriteLine("3 - mediumEWG.txt"); // Prompt
Console.WriteLine("or quit"); // Prompt
var fileNumber = Console.ReadLine();
string fileName;
switch (fileNumber)
{
case "1":
fileName = "tinyEWD.txt";
break;
case "2":
fileName = "mediumEWD.txt";
break;
//case "3":
// fileName = "largeEWG.zip";
// break;
case "quit":
return;
default:
return;
}
var @in = new In($"Files\\Graphs\\{fileName}");
var lines = @in.ReadAllLines();
var lineIterator = 0;
var v = 0;
var e = 0;
var edges = new List<DirectedEdge>();
foreach (var line in lines)
{
if (lineIterator == 0)
{
v = Convert.ToInt32(line);
}
if (lineIterator == 1)
{
e = Convert.ToInt32(line);
}
if (lineIterator > 1)
{
var lineSplitted = line.Split(new[] {' '}, StringSplitOptions.RemoveEmptyEntries);
var ve = Convert.ToInt32(lineSplitted[0]);
var we = Convert.ToInt32(lineSplitted[1]);
var weight = Convert.ToDouble(lineSplitted[2], CultureInfo.InvariantCulture);
var edge = new DirectedEdge(ve, we, weight);
edges.Add(edge);
}
lineIterator++;
}
var edgeWeightedGraph = new EdgeWeightedDigraph(v, e, edges);
Console.WriteLine(edgeWeightedGraph);
Console.ReadLine();
}
/// <summary>
///
/// </summary>
/// <param name="de"></param>
/// <returns></returns>
public override DirectedEdge GetNext(DirectedEdge de)
{
return(de.NextMin);
}
public void Execute()
{
var hNodeDictionary = FUsedGraph.GetNodeDictionary();
var hNodeCount = hNodeDictionary.Count;
// Erstellen der SuperQuelle
var hSuperSource = new Node(hNodeCount);
FUsedGraph.TryToAddNode(hSuperSource);
// Erstellen der SuperSenke
var hSuperTarget = new Node(hNodeCount + 1);
FUsedGraph.TryToAddNode(hSuperTarget);
var hPseudoEdges = new List <Edge>();
// Die SuperQuelle mit den Knoten der Gruppe A verbinden
for (var hNodeInGroupAId = 0; hNodeInGroupAId < FNodesGroupALimit; hNodeInGroupAId++)
{
var hNodeInGroupA = hNodeDictionary[hNodeInGroupAId];
var hNewEdge = new DirectedEdge(hSuperSource, hNodeInGroupA);
hNewEdge.AddWeight(new CapacityWeighted(1));
FUsedGraph.AddEdge(hNewEdge);
hPseudoEdges.Add(hNewEdge);
}
for (var hNodeInGroupAId = FNodesGroupALimit; hNodeInGroupAId < hNodeCount; hNodeInGroupAId++)
{
var hNodeInGroupB = hNodeDictionary[hNodeInGroupAId];
var hNewEdge = new DirectedEdge(hNodeInGroupB, hSuperTarget);
hNewEdge.AddWeight(new CapacityWeighted(1));
FUsedGraph.AddEdge(hNewEdge);
hPseudoEdges.Add(hNewEdge);
}
FUsedGraph.UpdateNeighbourInfoInNodes();
var hEdmondsKarpAlgorithm = new EdmondsKarpAlgorithm(FUsedGraph);
var hFlow = hEdmondsKarpAlgorithm.Execute(hSuperSource.Id, hSuperTarget.Id);
// PseudoKanten wieder entfernen
foreach (var hPseudoEdge in hPseudoEdges)
{
FUsedGraph.RemoveEdge(hPseudoEdge);
}
// Superquelle und -senke wieder entfernen.
FUsedGraph.RemoveNode(hSuperSource);
FUsedGraph.RemoveNode(hSuperTarget);
var hFlowCopy = new List <string>(hFlow.Keys);
foreach (var hFlowEdge in hFlowCopy)
{
var hNodes = hFlowEdge.Split('-');
var hEdgeSourceNodeId = Convert.ToInt32(hNodes[0]);
var hEdgeTargetNodeId = Convert.ToInt32(hNodes[1]);
if (hEdgeSourceNodeId == hSuperSource.Id)
{
hFlow.Remove(hFlowEdge);
}
else if (hEdgeTargetNodeId == hSuperTarget.Id)
{
hFlow.Remove(hFlowEdge);
}
else if (hFlow[hFlowEdge] == 0.0)
{
hFlow.Remove(hFlowEdge);
}
}
Console.WriteLine("Die Anzahl der maximalen Matchings beträgt\t" + hFlow.Count);
}
/// <summary>
/// Adds a DirectedEdge which is known to form part of this ring.
/// </summary>
/// <param name="de">The DirectedEdge to add.</param>
private void Add(DirectedEdge de)
{
_deList.Add(de);
}
public void AddEdge(DirectedEdge edge)
{
adj[edge.From].Add(edge);
E++;
}
private readonly DirectedEdge[][] _edgeTo; // edgeTo[v][w] = last edge on shortest v->w path
#endregion Fields
#region Constructors
/// <summary>
/// Computes a shortest paths tree from each vertex to to every other vertex in
/// the edge-weighted digraph <tt>G</tt>. If no such shortest path exists for
/// some pair of vertices, it computes a negative cycle.
/// </summary>
/// <param name="g">G the edge-weighted digraph</param>
public FloydWarshall(AdjMatrixEdgeWeightedDigraph g)
{
var vv = g.V;
_distTo = new double[vv][];
for (var i = 0; i < vv; i++)
{
_distTo[i] = new double[vv];
}
_edgeTo = new DirectedEdge[vv][];
for (var i = 0; i < vv; i++)
{
_edgeTo[i] = new DirectedEdge[vv];
}
// initialize distances to infinity
for (var v = 0; v < vv; v++)
{
for (var w = 0; w < vv; w++)
{
_distTo[v][w] = double.PositiveInfinity;
}
}
// initialize distances using edge-weighted digraph's
for (var v = 0; v < g.V; v++)
{
foreach (var e in g.Adj(v))
{
_distTo[e.From()][e.To()] = e.Weight;
_edgeTo[e.From()][e.To()] = e;
}
// in case of self-loops
if (_distTo[v][v] >= 0.0)
{
_distTo[v][v] = 0.0;
_edgeTo[v][v] = null;
}
}
// Floyd-Warshall updates
for (var i = 0; i < vv; i++)
{
// compute shortest paths using only 0, 1, ..., i as intermediate vertices
for (var v = 0; v < vv; v++)
{
if (_edgeTo[v][i] == null) continue; // optimization
for (var w = 0; w < vv; w++)
{
if (_distTo[v][w] > _distTo[v][i] + _distTo[i][w])
{
_distTo[v][w] = _distTo[v][i] + _distTo[i][w];
_edgeTo[v][w] = _edgeTo[i][w];
}
}
// check for negative cycle
if (_distTo[v][v] < 0.0)
{
HasNegativeCycle = true;
return;
}
}
}
}
public void Run()
{
Console.WriteLine("Choose file:"); // Prompt
Console.WriteLine("1 - tinyEWD.txt"); // Prompt
Console.WriteLine("2 - mediumEWD.txt"); // Prompt
//Console.WriteLine("3 - mediumEWG.txt"); // Prompt
Console.WriteLine("or quit"); // Prompt
var fileNumber = Console.ReadLine();
string fileName;
switch (fileNumber)
{
case "1":
fileName = "tinyEWD.txt";
break;
case "2":
fileName = "mediumEWD.txt";
break;
//case "3":
// fileName = "largeEWG.zip";
// break;
case "quit":
return;
default:
return;
}
var @in = new In($"Files\\Graphs\\{fileName}");
var lines = @in.ReadAllLines();
var lineIterator = 0;
var v = 0;
var e = 0;
var edges = new List <DirectedEdge>();
foreach (var line in lines)
{
if (lineIterator == 0)
{
v = Convert.ToInt32(line);
}
if (lineIterator == 1)
{
e = Convert.ToInt32(line);
}
if (lineIterator > 1)
{
var lineSplitted = line.Split(new[] { ' ' }, StringSplitOptions.RemoveEmptyEntries);
var ve = Convert.ToInt32(lineSplitted[0]);
var we = Convert.ToInt32(lineSplitted[1]);
var weight = Convert.ToDouble(lineSplitted[2], CultureInfo.InvariantCulture);
var edge = new DirectedEdge(ve, we, weight);
edges.Add(edge);
}
lineIterator++;
}
var edgeWeightedGraph = new EdgeWeightedDigraph(v, e, edges);
Console.WriteLine(edgeWeightedGraph);
Console.ReadLine();
}
/// <summary>
/// Returns 1 if this DirectedEdge has a greater angle with the
/// positive x-axis than b", 0 if the DirectedEdges are collinear, and -1 otherwise.
/// Using the obvious algorithm of simply computing the angle is not robust,
/// since the angle calculation is susceptible to roundoff. A robust algorithm
/// is:
/// first compare the quadrants. If the quadrants are different, it it
/// trivial to determine which vector is "greater".
/// if the vectors lie in the same quadrant, the robust
/// <c>RobustCgAlgorithms.ComputeOrientation(Coordinate, Coordinate, Coordinate)</c>
/// function can be used to decide the relative orientation of the vectors.
/// </summary>
/// <param name="e"></param>
/// <returns></returns>
public virtual int CompareDirection(DirectedEdge e)
{
// if the rays are in different quadrants, determining the ordering is trivial
if (_quadrant > e.Quadrant)
return 1;
if (_quadrant < e.Quadrant)
return -1;
// vectors are in the same quadrant - check relative orientation of direction vectors
// this is > e if it is CCW of e
int i = CgAlgorithms.ComputeOrientation(e.StartPoint, e.EndPoint, _p1);
return i;
}
public void AddEdge(DirectedEdge e)
{
_adj[e.From].Add(e);
}
private void TraceBackDirectedCycle(DirectedEdge e, int w)
{
_cycle = new Collections.Stack<DirectedEdge>();
while (e.From() != w)
{
_cycle.Push(e);
e = _edgeTo[e.From()];
}
_cycle.Push(e);
}
// Note: indirect append means that adtress (with unfilled values) will be inserted inbetween start and end adtree.
// Unfilled values are expected to be filled later otherwise the adtree will be not valid.
private void TryToAppendIndirectly(AttachingPosition appendingPositionOfStartElement,
IAdTree start, IAdTree end,
string expectedSignature,
List <IAdTree> results)
{
using (Trace.Entering())
{
GrammarCharacter startGrammarCharacter = GrammarCharacter.e;
GrammarCharacter endGrammarCharacter = GrammarCharacter.e;
// If start adTree connects the bridge on its left.
if (appendingPositionOfStartElement == AttachingPosition.ParrentForLeft)
{
startGrammarCharacter = start.Pattern.LeftRule.GrammarCharacter;
endGrammarCharacter = end.RulingGrammarCharacter;
}
// If start adTree connects the bridge on its right.
else if (appendingPositionOfStartElement == AttachingPosition.ParrentForRight)
{
startGrammarCharacter = start.Pattern.RightRule.GrammarCharacter;
endGrammarCharacter = end.RulingGrammarCharacter;
}
// If the bridge connects the start adtree on its left.
else if (appendingPositionOfStartElement == AttachingPosition.ChildOnLeft)
{
startGrammarCharacter = start.RulingGrammarCharacter;
endGrammarCharacter = end.RulingGrammarCharacter;
}
// If the bridge connects the start adtree on its right.
else if (appendingPositionOfStartElement == AttachingPosition.ChildOnRight)
{
startGrammarCharacter = start.RulingGrammarCharacter;
endGrammarCharacter = end.RulingGrammarCharacter;
}
// Get all possibile ways how to get from start to end grammar character and path is not greater than 4.
IEnumerable <IReadOnlyList <DirectedEdge <GrammarCharacter, Pattern> > > connectionPaths = myConstructiveDictionary.PatternGraph
.FindAllEdges(startGrammarCharacter, endGrammarCharacter).ToList();
// Go via all possible ways.
foreach (IReadOnlyList <DirectedEdge <GrammarCharacter, Pattern> > path in connectionPaths)
{
IAdTree startCopy = start.MakeShallowCopy();
IAdTree endCopy = end.MakeShallowCopy();
IAdTree previousBridge = null;
// Go via the path.
for (int i = 0; i < path.Count; ++i)
{
DirectedEdge <GrammarCharacter, Pattern> edge = path[i];
BigInteger attributes = edge.Value.UpRule.AttributesRule is IReferenceValueRule <BigInteger> referenceAttributes ? referenceAttributes.ReferenceValue : myConstructiveDictionary.AttributesModel.GetAttributes(edge.Value.UpRule.GrammarCharacter);
IAdTree bridge = new AdTree(new Morpheme(myConstructiveDictionary.AttributesModel, "", attributes), edge.Value);
// If it is the first item on the path.
if (i == 0)
{
if (appendingPositionOfStartElement == AttachingPosition.ParrentForLeft)
{
if (startCopy.Left == null && startCopy.CanAttachToLeft(bridge, myConstructiveDictionary.AttributesModel))
{
startCopy.Left = bridge;
}
else
{
break;
}
}
else if (appendingPositionOfStartElement == AttachingPosition.ParrentForRight)
{
if (startCopy.Right == null && startCopy.CanAttachToRight(bridge, myConstructiveDictionary.AttributesModel))
{
startCopy.Right = bridge;
}
else
{
break;
}
}
else if (appendingPositionOfStartElement == AttachingPosition.ChildOnLeft)
{
if (bridge.Left == null && bridge.CanAttachToLeft(startCopy, myConstructiveDictionary.AttributesModel))
{
bridge.Left = startCopy;
}
else
{
break;
}
}
else if (appendingPositionOfStartElement == AttachingPosition.ChildOnRight)
{
if (bridge.Right == null && bridge.CanAttachToRight(startCopy, myConstructiveDictionary.AttributesModel))
{
bridge.Right = startCopy;
}
else
{
break;
}
}
}
else
{
if (previousBridge.Left == null && previousBridge.CanAttachToLeft(bridge, myConstructiveDictionary.AttributesModel))
{
previousBridge.Left = bridge;
}
else if (previousBridge.Right == null && previousBridge.CanAttachToRight(bridge, myConstructiveDictionary.AttributesModel))
{
previousBridge.Right = bridge;
}
else
{
break;
}
}
// If the signature does not match then break it.
var currentSignature = bridge.Root.GetSignature();
if (!expectedSignature.StartsWith(currentSignature))
{
break;
}
// If it is the last item in the path.
if (i == path.Count - 1)
{
if (bridge.Left == null && bridge.CanAttachToLeft(endCopy, myConstructiveDictionary.AttributesModel))
{
bridge.Left = endCopy;
currentSignature = endCopy.Root.GetSignature();
if (expectedSignature.StartsWith(currentSignature))
{
results.Add(endCopy);
}
}
else if (bridge.Right == null && bridge.CanAttachToRight(endCopy, myConstructiveDictionary.AttributesModel))
{
bridge.Right = endCopy;
currentSignature = endCopy.Root.GetSignature();
if (expectedSignature.StartsWith(currentSignature))
{
results.Add(endCopy);
}
}
else
{
break;
}
}
previousBridge = bridge;
}
}
}
}
public void Adjacency_should_work_correctly()
{
var edge = new DirectedEdge<int>(1, 2);
edge.AdjacentTo(1).ShouldBeTrue();
edge.AdjacentTo(2).ShouldBeTrue();
}
public void CommandifiedGraphAddRemoveGraphAndEdgesWithUndoTest()
{
Guid sessionId = Guid.NewGuid();
CQManager.ActivateCommandQueueStack(sessionId);
DirectedGraph <int, DirectedEdge <int> > graph = new DirectedGraph <int, DirectedEdge <int> >(true);
graph.Add(42);
graph.Add(13);
graph.Add(10);
graph.Add(new DirectedEdge <int>(42, 13)); // 42 -> 13
graph.Add(new DirectedEdge <int>(42, 10)); // 42 -> 10
Assert.IsTrue(graph.Contains(42));
Assert.IsTrue(graph.Contains(13));
Assert.IsTrue(graph.Contains(10));
Assert.AreEqual(2, graph.EdgeCount);
Assert.IsTrue(graph.ContainsEdge(42, 13));
Assert.IsTrue(graph.ContainsEdge(42, 10));
// create graph to add to this graph. Doesn't have to be a commandified graph, as we're not rolling back the actions on that graph.
DirectedGraph <int, DirectedEdge <int> > graphToAdd = new DirectedGraph <int, DirectedEdge <int> >();
graphToAdd.Add(1);
graphToAdd.Add(2);
graphToAdd.Add(3);
graphToAdd.Add(new DirectedEdge <int>(1, 2)); // 1 -> 2
graphToAdd.Add(new DirectedEdge <int>(1, 3)); // 1 -> 3
graphToAdd.Add(new DirectedEdge <int>(2, 3)); // 2 -> 3
Assert.AreEqual(3, graphToAdd.VertexCount);
Assert.AreEqual(3, graphToAdd.EdgeCount);
// add this graph to the main graph. This is an undoable action.
graph.Add(graphToAdd);
Assert.AreEqual(6, graph.VertexCount);
Assert.AreEqual(5, graph.EdgeCount);
Assert.IsTrue(graph.Contains(1));
Assert.IsTrue(graph.Contains(2));
Assert.IsTrue(graph.Contains(3));
Assert.IsTrue(graph.ContainsEdge(1, 2));
Assert.IsTrue(graph.ContainsEdge(1, 3));
Assert.IsTrue(graph.ContainsEdge(2, 3));
// undo add
CQManager.UndoLastCommand();
Assert.AreEqual(3, graph.VertexCount);
Assert.AreEqual(2, graph.EdgeCount);
Assert.IsFalse(graph.Contains(1));
Assert.IsFalse(graph.Contains(2));
Assert.IsFalse(graph.Contains(3));
Assert.IsFalse(graph.ContainsEdge(1, 2));
Assert.IsFalse(graph.ContainsEdge(1, 3));
Assert.IsFalse(graph.ContainsEdge(2, 3));
// redo
CQManager.RedoLastCommand();
Assert.AreEqual(6, graph.VertexCount);
Assert.AreEqual(5, graph.EdgeCount);
Assert.IsTrue(graph.Contains(1));
Assert.IsTrue(graph.Contains(2));
Assert.IsTrue(graph.Contains(3));
Assert.IsTrue(graph.ContainsEdge(1, 2));
Assert.IsTrue(graph.ContainsEdge(1, 3));
Assert.IsTrue(graph.ContainsEdge(2, 3));
// remove the graph we added
graph.Remove(graphToAdd);
Assert.AreEqual(3, graph.VertexCount);
Assert.AreEqual(2, graph.EdgeCount);
Assert.IsFalse(graph.Contains(1));
Assert.IsFalse(graph.Contains(2));
Assert.IsFalse(graph.Contains(3));
Assert.IsFalse(graph.ContainsEdge(1, 2));
Assert.IsFalse(graph.ContainsEdge(1, 3));
Assert.IsFalse(graph.ContainsEdge(2, 3));
CQManager.UndoLastCommand();
Assert.AreEqual(6, graph.VertexCount);
Assert.AreEqual(5, graph.EdgeCount);
Assert.IsTrue(graph.Contains(1));
Assert.IsTrue(graph.Contains(2));
Assert.IsTrue(graph.Contains(3));
Assert.IsTrue(graph.ContainsEdge(1, 2));
Assert.IsTrue(graph.ContainsEdge(1, 3));
Assert.IsTrue(graph.ContainsEdge(2, 3));
DirectedEdge <int> newEdge = new DirectedEdge <int>(42, 1); // 42 -> 1
graph.Add(newEdge);
Assert.AreEqual(6, graph.EdgeCount);
Assert.IsTrue(graph.ContainsEdge(42, 1));
Assert.IsFalse(graph.ContainsEdge(1, 42));
CQManager.UndoLastCommand();
Assert.AreEqual(5, graph.EdgeCount);
Assert.IsFalse(graph.ContainsEdge(42, 1));
CQManager.RedoLastCommand();
Assert.AreEqual(6, graph.EdgeCount);
Assert.IsTrue(graph.ContainsEdge(42, 1));
graph.Remove(newEdge);
Assert.AreEqual(5, graph.EdgeCount);
Assert.IsFalse(graph.ContainsEdge(42, 1));
CQManager.UndoLastCommand();
Assert.AreEqual(6, graph.EdgeCount);
Assert.IsTrue(graph.ContainsEdge(42, 1));
graph.Disconnect(42, 1, false);
Assert.AreEqual(5, graph.EdgeCount);
Assert.IsFalse(graph.ContainsEdge(42, 1));
CQManager.UndoLastCommand();
Assert.AreEqual(6, graph.EdgeCount);
Assert.IsTrue(graph.ContainsEdge(42, 1));
CQManager.ActivateCommandQueueStack(Guid.Empty);
}
public void Terminal_vertex_should_be_correct()
{
var edge = new DirectedEdge<int>(1, 2);
edge.TerminalVertex.ShouldEqual(2);
}
protected override Tags GetKeyForItem(DirectedEdge item)
{
return(item.Target);
}
/// <summary>
/// Returns 1 if this DirectedEdge has a greater angle with the
/// positive x-axis than b", 0 if the DirectedEdges are collinear, and -1 otherwise.
/// Using the obvious algorithm of simply computing the angle is not robust,
/// since the angle calculation is susceptible to roundoff. A robust algorithm
/// is:
/// first compare the quadrants. If the quadrants are different, it it
/// trivial to determine which vector is "greater".
/// if the vectors lie in the same quadrant, the robust
/// <c>RobustCGAlgorithms.ComputeOrientation(Coordinate, Coordinate, Coordinate)</c>
/// function can be used to decide the relative orientation of the vectors.
/// </summary>
/// <param name="e"></param>
/// <returns></returns>
public int CompareDirection(DirectedEdge e)
{
int i = 0;
// if the rays are in different quadrants, determining the ordering is trivial
if (quadrant > e.Quadrant)
i = 1;
if (quadrant < e.Quadrant)
i = -1;
// vectors are in the same quadrant - check relative orientation of direction vectors
// this is > e if it is CCW of e
i = CGAlgorithms.ComputeOrientation(e.p0, e.p1, p1);
return i;
}
public void Run()
{
Console.WriteLine("Choose file:"); // Prompt
Console.WriteLine("1 - rates.txt"); // Prompt
//Console.WriteLine("2 - mediumEWD.txt"); // Prompt
//Console.WriteLine("3 - mediumEWG.txt"); // Prompt
Console.WriteLine("or quit"); // Prompt
var fileNumber = Console.ReadLine();
string fileName;
switch (fileNumber)
{
case "1":
fileName = "rates.txt";
break;
//case "2":
// fileName = "mediumEWD.txt";
// break;
//case "3":
// fileName = "largeEWG.zip";
// break;
case "quit":
return;
default:
return;
}
var @in = new In($"Files\\Graphs\\{fileName}");
var lines = @in.ReadAllLines();
var lineIterator = 0;
var currencyIterator = 0;
// number of jobs
var n = 0;
// source and sink
var source = 0;
var sink = 0;
var v = 0;
var e = 0;
var edges = new List<DirectedEdge>();
string[] names = {};
foreach (var line in lines)
{
if (lineIterator == 0)
{
v = Convert.ToInt32(line);
names = new string[v];
}
if (lineIterator > 0)
{
var wordsIterator = 0;
var ratesIterator = 0;
var lineSplitted = line.Split(new[] { ' ' }, StringSplitOptions.RemoveEmptyEntries);
foreach (var word in lineSplitted)
{
if (wordsIterator == 0)
{
names[wordsIterator] = word;
}
if (wordsIterator > 0)
{
double rate = Convert.ToSingle(word,CultureInfo.InvariantCulture);
var edge = new DirectedEdge(currencyIterator, ratesIterator, -Math.Log(rate));
edges.Add(edge);
e++;
ratesIterator++;
}
wordsIterator ++;
}
currencyIterator++;
}
lineIterator++;
}
var edgeWeightedDigraph = new EdgeWeightedDigraph(v, e, edges);
Console.WriteLine(edgeWeightedDigraph);
// find shortest path from s to each other vertex in DAG
var arbitrage = new Arbitrage(edgeWeightedDigraph,source);
var spt = arbitrage.GetShotestPath();
// print results
Console.WriteLine(" job start finish");
Console.WriteLine("--------------------");
if (spt.HasNegativeCycle())
{
var stake = 1000.0;
foreach (var edge in spt.NegativeCycle())
{
Console.Write($"{stake:0.00000} {names[edge.From()]} ");
stake *= Math.Exp(-edge.Weight);
Console.Write($"= {stake:0.00000} {names[edge.To()]}{Environment.NewLine}");
}
}
else
{
Console.WriteLine("No arbitrage opportunity");
}
Console.ReadLine();
}
/// <summary>
/// Adds the directed edge <tt>e</tt> to the edge-weighted digraph (if there
/// is not already an edge with the same endpoints).
/// </summary>
/// <param name="e">e the edge</param>
public void AddEdge(DirectedEdge e)
{
var v = e.From();
var w = e.To();
if (_adj[v][w] != null) return;
E++;
_adj[v][w] = e;
}
public void Run()
{
Console.WriteLine("Choose file:"); // Prompt
Console.WriteLine("1 - tinyEWDAG.txt"); // Prompt
//Console.WriteLine("2 - mediumEWD.txt"); // Prompt
//Console.WriteLine("3 - mediumEWG.txt"); // Prompt
Console.WriteLine("or quit"); // Prompt
var fileNumber = Console.ReadLine();
string fileName;
switch (fileNumber)
{
case "1":
fileName = "tinyEWDAG.txt";
break;
//case "2":
// fileName = "mediumEWD.txt";
// break;
//case "3":
// fileName = "largeEWG.zip";
// break;
case "quit":
return;
default:
return;
}
var @in = new In($"Files\\Graphs\\{fileName}");
var lines = @in.ReadAllLines();
var lineIterator = 0;
var v = 0;
var e = 0;
var edges = new List <DirectedEdge>();
foreach (var line in lines)
{
if (lineIterator == 0)
{
v = Convert.ToInt32(line);
}
if (lineIterator == 1)
{
e = Convert.ToInt32(line);
}
if (lineIterator > 1)
{
var lineSplitted = line.Split(new[] { ' ' }, StringSplitOptions.RemoveEmptyEntries);
var ve = Convert.ToInt32(lineSplitted[0]);
var we = Convert.ToInt32(lineSplitted[1]);
var weight = Convert.ToDouble(lineSplitted[2], CultureInfo.InvariantCulture);
var edge = new DirectedEdge(ve, we, weight);
edges.Add(edge);
}
lineIterator++;
}
var edgeWeightedDigraph = new EdgeWeightedDigraph(v, e, edges);
Console.WriteLine(edgeWeightedDigraph);
const int s = 5;
// find shortest path from s to each other vertex in DAG
var lp = new AcyclicLP(edgeWeightedDigraph, s);
for (var vi = 0; vi < edgeWeightedDigraph.V; vi++)
{
if (lp.HasPathTo(vi))
{
Console.Write($"{s} to {vi} {$"{lp.DistTo(vi):0.00}"} ");
foreach (var ei in lp.PathTo(vi))
{
Console.Write($"{ei} ");
}
Console.WriteLine();
}
else
{
Console.Write($"{s} to {vi} no path{Environment.NewLine}");
}
}
Console.ReadLine();
}
public void Run()
{
Console.WriteLine("Choose file:"); // Prompt
Console.WriteLine("1 - tinyEWDAG.txt"); // Prompt
//Console.WriteLine("2 - mediumEWD.txt"); // Prompt
//Console.WriteLine("3 - mediumEWG.txt"); // Prompt
Console.WriteLine("or quit"); // Prompt
var fileNumber = Console.ReadLine();
string fileName;
switch (fileNumber)
{
case "1":
fileName = "tinyEWDAG.txt";
break;
//case "2":
// fileName = "mediumEWD.txt";
// break;
//case "3":
// fileName = "largeEWG.zip";
// break;
case "quit":
return;
default:
return;
}
var @in = new In($"Files\\Graphs\\{fileName}");
var lines = @in.ReadAllLines();
var lineIterator = 0;
var v = 0;
var e = 0;
var edges = new List<DirectedEdge>();
foreach (var line in lines)
{
if (lineIterator == 0)
{
v = Convert.ToInt32(line);
}
if (lineIterator == 1)
{
e = Convert.ToInt32(line);
}
if (lineIterator > 1)
{
var lineSplitted = line.Split(new[] { ' ' }, StringSplitOptions.RemoveEmptyEntries);
var ve = Convert.ToInt32(lineSplitted[0]);
var we = Convert.ToInt32(lineSplitted[1]);
var weight = Convert.ToDouble(lineSplitted[2], CultureInfo.InvariantCulture);
var edge = new DirectedEdge(ve, we, weight);
edges.Add(edge);
}
lineIterator++;
}
var edgeWeightedDigraph = new EdgeWeightedDigraph(v, e, edges);
Console.WriteLine(edgeWeightedDigraph);
const int s = 5;
// find shortest path from s to each other vertex in DAG
var sp = new AcyclicSP(edgeWeightedDigraph, s);
for (var vi = 0; vi < edgeWeightedDigraph.V; vi++)
{
if (sp.HasPathTo(vi))
{
Console.Write($"{s} to {vi} {$"{sp.DistTo(vi):0.00}"} ");
foreach (var ei in sp.PathTo(vi))
{
Console.Write($"{ei} ");
}
Console.WriteLine();
}
else
{
Console.Write($"{s} to {vi} no path{Environment.NewLine}");
}
}
Console.ReadLine();
}
/// <summary>
/// Initializes a new instance of the MinimalEdgeRing class.
/// A MinimalEdgeRing is a ring of edges with the property that no node
/// has degree greater than 2. These are the form of rings required
/// to represent polygons under the OGC SFS spatial data model.
/// </summary>
public MinimalEdgeRing(DirectedEdge start, GeometryFactory geometryFactory, CGAlgorithms cga) : base(start, geometryFactory, cga)
{
}
public void Run()
{
Console.WriteLine("Choose file:"); // Prompt
Console.WriteLine("1 - tinyEWD.txt"); // Prompt
Console.WriteLine("2 - mediumEWD.txt"); // Prompt
//Console.WriteLine("3 - mediumEWG.txt"); // Prompt
Console.WriteLine("or quit"); // Prompt
var fileNumber = Console.ReadLine();
string fileName;
switch (fileNumber)
{
case "1":
fileName = "tinyEWD.txt";
break;
case "2":
fileName = "mediumEWD.txt";
break;
//case "3":
// fileName = "largeEWG.zip";
// break;
case "quit":
return;
default:
return;
}
var @in = new In($"Files\\Graphs\\{fileName}");
var lines = @in.ReadAllLines();
var lineIterator = 0;
var v = 0;
var e = 0;
var edges = new List<DirectedEdge>();
foreach (var line in lines)
{
if (lineIterator == 0)
{
v = Convert.ToInt32(line);
}
if (lineIterator == 1)
{
e = Convert.ToInt32(line);
}
if (lineIterator > 1)
{
var lineSplitted = line.Split(new[] {' '}, StringSplitOptions.RemoveEmptyEntries);
var ve = Convert.ToInt32(lineSplitted[0]);
var we = Convert.ToInt32(lineSplitted[1]);
var weight = Convert.ToDouble(lineSplitted[2], CultureInfo.InvariantCulture);
var edge = new DirectedEdge(ve, we, weight);
edges.Add(edge);
}
lineIterator++;
}
var adjMatrixEdgeWeightedDigraph = new AdjMatrixEdgeWeightedDigraph(v, e, edges);
Console.WriteLine(adjMatrixEdgeWeightedDigraph);
// run Floyd-Warshall algorithm
var spt = new FloydWarshall(adjMatrixEdgeWeightedDigraph);
// print all-pairs shortest path distances
Console.Write(" ");
for (var vv = 0; vv < adjMatrixEdgeWeightedDigraph.V; vv++)
{
Console.Write($"{vv} ");
}
Console.WriteLine();
for (var vv = 0; vv < adjMatrixEdgeWeightedDigraph.V; vv++)
{
Console.Write($"{vv}: ");
for (var w = 0; w < adjMatrixEdgeWeightedDigraph.V; w++)
{
Console.Write(spt.HasPath(vv, w) ? $"{spt.Dist(vv, w):00} " : " Inf ");
}
Console.WriteLine();
}
// print negative cycle
if (spt.HasNegativeCycle)
{
Console.WriteLine("Negative cost cycle:");
foreach (var edge in spt.NegativeCycle())
Console.WriteLine(edge);
Console.WriteLine();
}
// print all-pairs shortest paths
else
{
for (var vv = 0; vv < adjMatrixEdgeWeightedDigraph.V; vv++)
{
for (var w = 0; w < adjMatrixEdgeWeightedDigraph.V; w++)
{
if (spt.HasPath(vv, w))
{
Console.Write($"{vv} to {w} {spt.Dist(vv, w):00} ");
foreach (var edge in spt.Path(vv, w))
Console.Write($"{edge} ");
Console.WriteLine();
}
else
{
Console.Write($"{vv} to {w} no path{Environment.NewLine}");
}
}
}
}
Console.ReadLine();
}
partial void test_math_nodeToolStripMenuItem_Click(object sender, EventArgs e)
{
string log = "";
Node a = new Node(); // test constructor
log += "\nNode " + a.ToString();
a.ID = 0; // test ID
Node b = new Node(1); // test constructor
log += "\n\nNode " + a.ToString();
log += "\nNode " + b.ToString();
object[] c0 = { 1.19, 4.23 };
a.Coordinate = c0;
object[] c1 = { 2.90, 3.01 };
b.Coordinate = c1; // test coordinate
object[] c2 = { 1.09, 0.98 };
Node c = new Node(2, c2); // test constructor
Node[] n = { a, b, c };
log += "\n";
for (int i = 0; i < n.Length; i++)
{
log += "\nNode " + n[i].ToString();
}
Math.Vector x, y, z;
// connect node 0 to node 1 with directed edge
x = new Math.Vector((double)a.Coordinate[0], (double)a.Coordinate[1]);
y = new Math.Vector((double)b.Coordinate[0], (double)b.Coordinate[1]);
z = y - x;
DirectedEdge e0 = new DirectedEdge(a, b);
e0.Weight = z.Magnitude;
a.Add(e0);
b.Add(e0);
// connect node 1 to node 2 with directed edge
x = new Math.Vector((double)b.Coordinate[0], (double)b.Coordinate[1]);
y = new Math.Vector((double)c.Coordinate[0], (double)c.Coordinate[1]);
z = y - x;
DirectedEdge e1 = new DirectedEdge(b, c);
e1.Weight = z.Magnitude;
b.Add(e1);
c.Add(e1);
// connect node 2 to node 0 with edge
x = new Math.Vector((double)c.Coordinate[0], (double)c.Coordinate[1]);
y = new Math.Vector((double)a.Coordinate[0], (double)a.Coordinate[1]);
z = y - x;
Edge e2 = (Edge) new Edge()
.Configure(c, a);
e2.Weight = z.Magnitude;
c.Add(e2);
a.Add(e2);
log += "\n";
for (int i = 0; i < n.Length; i++)
{
log += "\nNode " + n[i].ToString();
}
richTextBox.Text = log;
}
private bool MatchEdges(int from, DirectedEdge[] edges, params int[] to)
{
int edgesCount = 0;
Dictionary<int, bool> tmp = new Dictionary<int, bool>();
if (to != null)
{
foreach (int t in to)
{
tmp[t] = false;
}
}
if (edges != null)
{
edgesCount = edges.Length;
foreach (DirectedEdge e in edges)
{
if (e.From != from) return false;
if (!tmp.ContainsKey(e.To)) return false;
if (tmp[e.To]) return false;
tmp[e.To] = true;
}
}
if (tmp.Count != edgesCount) return false;
return true;
}
/// <summary>
/// Parse XML file
/// </summary>
private void ParseFile(XmlDocument doc)
{
vertices.Clear();
edges.Clear();
//Go through each node in XML file
foreach (XmlNode node in doc.DocumentElement.ChildNodes)
{
var vertex = new Vertex();
//One node (room)
if (node.Name.Equals("Node"))
{
//Go through properties of one node (room)
foreach (XmlNode n in node.ChildNodes)
{
if (n.Name.Equals("Identifier"))
{
vertex.Id = Int32.Parse(n.InnerText);
if (vertex.Id > maxId)
{
maxId = vertex.Id;
}
}
else if (n.Name.Equals("X"))
{
vertex.X = int.Parse(n.InnerText);
}
else if (n.Name.Equals("Y"))
{
vertex.Y = int.Parse(n.InnerText);
}
else if (n.Name.Equals("Rooms"))
{
foreach (XmlNode nc in n.ChildNodes)
{
if (nc.Name.Equals("Rm"))
{
vertex.Rooms.Add(int.Parse(nc.InnerText));
}
}
}
else if (n.Name.Equals("StartLocation") && bool.Parse(n.InnerText))
{
// Set starting location.
startVertex = vertex;
}
}
vertices.Add(vertex);
}
else if (node.Name.Equals("Connection"))
{
int a = -1, b = -1;
double weight = -1;
foreach (XmlNode n in node.ChildNodes)
{
if (n.Name.Equals("A"))
{
a = Int32.Parse(n.InnerText);
}
else if (n.Name.Equals("B"))
{
b = Int32.Parse(n.InnerText);
}
else if (n.Name.Equals("Weight"))
{
weight = double.Parse(n.InnerText);
}
}
if (a != -1 && b != -1 && weight != -1)
{
var edge1 = new DirectedEdge(a, b, weight);
var edge2 = new DirectedEdge(b, a, weight);
edges.Add(edge1);
edges.Add(edge2);
}
}
else
{
Debug.WriteLine("File is not formatted correctly.");
}
}
graph = new EdgeWeightedDigraph(maxId + 1);
foreach (var edge in edges)
{
graph.AddEdge(edge);
}
}
/// <summary>
/// Constructs an Edge initialized with the given DirectedEdges, and for each
/// DirectedEdge: sets the Edge, sets the symmetric DirectedEdge, and adds
/// this Edge to its from-Node.
/// </summary>
/// <param name="de0"></param>
/// <param name="de1"></param>
public Edge(DirectedEdge de0, DirectedEdge de1)
{
SetDirectedEdges(de0, de1);
}
public static void ShowCycles(int pos, Document document)
{
Dictionary <string, string> result = new Dictionary <string, string>();
// Check if initial file is a grammar.
ParsingResults pd_parser = ParsingResultsFactory.Create(document) as ParsingResults;
if (pd_parser == null)
{
throw new LanguageServerException("A grammar file is not selected. Please select one first.");
}
Transform.ExtractGrammarType egt = new Transform.ExtractGrammarType();
ParseTreeWalker.Default.Walk(egt, pd_parser.ParseTree);
bool is_grammar = egt.Type == Transform.ExtractGrammarType.GrammarType.Parser ||
egt.Type == Transform.ExtractGrammarType.GrammarType.Combined ||
egt.Type == Transform.ExtractGrammarType.GrammarType.Lexer;
if (!is_grammar)
{
throw new LanguageServerException("A grammar file is not selected. Please select one first.");
}
// Find all other grammars by walking dependencies (import, vocab, file names).
HashSet <string> read_files = new HashSet <string>
{
document.FullPath
};
Dictionary <Workspaces.Document, List <TerminalNodeImpl> > every_damn_literal =
new Dictionary <Workspaces.Document, List <TerminalNodeImpl> >();
for (; ;)
{
int before_count = read_files.Count;
foreach (string f in read_files)
{
List <string> additional = ParsingResults.InverseImports.Where(
t => t.Value.Contains(f)).Select(
t => t.Key).ToList();
read_files = read_files.Union(additional).ToHashSet();
}
foreach (string f in read_files)
{
var additional = ParsingResults.InverseImports.Where(
t => t.Key == f).Select(
t => t.Value);
foreach (var t in additional)
{
read_files = read_files.Union(t).ToHashSet();
}
}
int after_count = read_files.Count;
if (after_count == before_count)
{
break;
}
}
// Construct graph of symbol usage.
Transform.TableOfRules table = new Transform.TableOfRules(pd_parser, document);
table.ReadRules();
table.FindPartitions();
table.FindStartRules();
Digraph <string> graph = new Digraph <string>();
foreach (Transform.TableOfRules.Row r in table.rules)
{
if (!r.is_parser_rule)
{
continue;
}
graph.AddVertex(r.LHS);
}
foreach (Transform.TableOfRules.Row r in table.rules)
{
if (!r.is_parser_rule)
{
continue;
}
List <string> j = r.RHS;
//j.Reverse();
foreach (string rhs in j)
{
Transform.TableOfRules.Row sym = table.rules.Where(t => t.LHS == rhs).FirstOrDefault();
if (!sym.is_parser_rule)
{
continue;
}
DirectedEdge <string> e = new DirectedEdge <string>(r.LHS, rhs);
graph.AddEdge(e);
}
}
List <string> starts = new List <string>();
List <string> parser_lhs_rules = new List <string>();
foreach (Transform.TableOfRules.Row r in table.rules)
{
if (r.is_parser_rule)
{
parser_lhs_rules.Add(r.LHS);
if (r.is_start)
{
starts.Add(r.LHS);
}
}
}
IParseTree rule = null;
IParseTree it = pd_parser.AllNodes.Where(n =>
{
if (!(n is ANTLRv4Parser.ParserRuleSpecContext || n is ANTLRv4Parser.LexerRuleSpecContext))
{
return(false);
}
Interval source_interval = n.SourceInterval;
int a = source_interval.a;
int b = source_interval.b;
IToken ta = pd_parser.TokStream.Get(a);
IToken tb = pd_parser.TokStream.Get(b);
var start = ta.StartIndex;
var stop = tb.StopIndex + 1;
return(start <= pos && pos < stop);
}).FirstOrDefault();
rule = it;
var k = (ANTLRv4Parser.ParserRuleSpecContext)rule;
var tarjan = new TarjanSCC <string, DirectedEdge <string> >(graph);
List <string> ordered = new List <string>();
var sccs = tarjan.Compute();
StringBuilder sb = new StringBuilder();
sb.AppendLine("Cycles in " + document.FullPath);
var done = new List <IEnumerable <string> >();
foreach (var scc in sccs)
{
if (scc.Value.Count() <= 1)
{
continue;
}
if (!done.Contains(scc.Value))
{
foreach (var s in scc.Value)
{
sb.Append(" ");
sb.Append(s);
}
sb.AppendLine();
sb.AppendLine();
done.Add(scc.Value);
}
}
//var scc = sccs[k.RULE_REF().ToString()];
//foreach (var v in scc)
//{
// ordered.Add(v);
//}
}
