public IEnumerable <Int32> ReversePost()
{
AST.Stack <Int32> reverse = new AST.Stack <Int32>();
foreach (Int32 vertice in this._postOrder)
{
reverse.Push(vertice);
}
return(reverse);
}
public NFARegularExpressionSearch(String expression)
{
this._expression = expression;
this._expressionSize = expression.Length;
this._graph = new Digraph(this._expressionSize + 1);
AST.Stack <Int32> operations = new AST.Stack <Int32>();
for (int i = 0; i < _expressionSize; i++)
{
int lp = i;
if (expression[i] == '(' || expression[i] == '|')
{
operations.Push(i);
}
else if (expression[i] == ')')
{
Int32 or = operations.Pop();
// 2-way OR operator.
if (expression[or] == '|')
{
lp = operations.Pop();
this._graph.AddEdge(lp, or + 1);
this._graph.AddEdge(or, i);
}
else if (expression[or] == '(')
{
lp = or;
}
}
// Closure operator (uses 1-character lookahead).
if (i < this._expressionSize - 1 && expression[i + 1] == '*')
{
this._graph.AddEdge(lp, i + 1);
this._graph.AddEdge(i + 1, lp);
}
if (expression[i] == '(' || expression[i] == '*' || expression[i] == ')')
{
this._graph.AddEdge(i, i + 1);
}
}
if (operations.Count != 0)
{
throw new ArgumentException("Invalid regular expression.", nameof(expression));
}
}
public IEnumerable <Edge> PathTo(Int32 vertice)
{
if (!this.HasPathTo(vertice))
{
return(null);
}
AST.Stack <Edge> path = new AST.Stack <Edge>();
for (Edge e = this._edgeTo[vertice]; e != null; e = this._edgeTo[e.Source])
{
path.Push(e);
}
return(path);
}
private void DFS(EdgeWeightedDigraph graph, Int32 vertice)
{
this._onStack[vertice] = true;
this._visited[vertice] = true;
foreach (Edge edge in graph.GetAdjacentVertices(vertice))
{
Int32 targetVertice = edge.Target;
// Short circuit if directed cycle found.
if (this._cycle != null)
{
return;
}
// Found new vertex, so recur.
if (!this._visited[targetVertice])
{
this._edgeTo[targetVertice] = edge;
this.DFS(graph, targetVertice);
}
// trace back directed cycle
else if (this._onStack[targetVertice])
{
this._cycle = new AST.Stack <Edge>();
Edge tempEdge = edge;
while (tempEdge.Source != targetVertice)
{
this._cycle.Push(tempEdge);
tempEdge = this._edgeTo[tempEdge.Source];
}
this._cycle.Push(tempEdge);
return;
}
}
this._onStack[vertice] = false;
}
public IEnumerable <Int32> PathFromSourceTo(Int32 vertice)
{
if (!this.IsConnectedToSource(vertice))
{
return(null);
}
AST.Stack <Int32> path = new AST.Stack <Int32>();
for (int i = vertice; i != this.SourceVertice; i = this._edgeTo[i])
{
path.Push(i);
}
path.Push(this.SourceVertice);
return(path);
}
private void DFS(Digraph digraph, Int32 vertice)
{
this._onStack[vertice] = true;
this._visited[vertice] = true;
foreach (Int32 adjacent in digraph.GetAdjacentVertices(vertice))
{
if (this.HasCycle)
{
return;
}
// The cycle occurrs when an adjacent vertice is on the stack of
// "vertices being processed".
// If vertice A is being processed (onStack) and one of its adjacents
// points to A again, we have a cycle.
if (!this._visited[adjacent])
{
this._edgeTo[adjacent] = vertice;
this.DFS(digraph, adjacent);
}
else if (this._onStack[adjacent])
{
this._cycle = new AST.Stack <Int32>();
for (int i = vertice; i != adjacent; i = this._edgeTo[i])
{
this._cycle.Push(i);
}
this._cycle.Push(adjacent);
this._cycle.Push(vertice);
}
}
// If we fully processed a vertice, it means the vertice is no more on
// the stack.
this._onStack[vertice] = false;
}
public IEnumerable <Edge> PathTo(Int32 vertice)
{
if (this.HasNegativeCycle)
{
throw new InvalidOperationException("Negative cost cycle exists.");
}
if (!this.HasPathTo(vertice))
{
return(null);
}
AST.Stack <Edge> path = new AST.Stack <Edge>();
for (Edge e = this._edgeTo[vertice]; e != null; e = this._edgeTo[e.Source])
{
path.Push(e);
}
return(path);
}
public static Double Evaluate(String expression)
{
AST.Stack <String> operations = new AST.Stack <String>();
AST.Stack <Double> values = new AST.Stack <Double>();
String[] tokens = expression.Split(" ");
foreach (String token in tokens)
{
switch (token)
{
case "(":
break;
case "+":
case "-":
case "*":
case "/":
case "sqrt":
operations.Push(token);
break;
case ")":
// Pop, evaluate, and push result if token is ")".
String operation = operations.Pop();
Double value = values.Pop();
switch (operation)
{
case "+":
value = values.Pop() + value;
break;
case "-":
value = values.Pop() - value;
break;
case "*":
value = values.Pop() * value;
break;
case "/":
value = values.Pop() / value;
break;
case "sqrt":
value = Math.Sqrt(value);
break;
}
values.Push(value);
break;
default:
// If token is not operator or parentheses: push double value.
values.Push(Double.Parse(token));
break;
}
}
return(values.Pop());
}