public void BidirectionalBFSTest_GermanyGraph()
{
var g = InitGermanyGraph();
var Frankfurt = g.Vertices.Single(v => v.UUID.Equals("1"));
var Muenchen = g.Vertices.Single(v => v.UUID.Equals("10"));
var Kassel = g.Vertices.Single(v => v.UUID.Equals("8"));
var path = BidirectionalBFS.Search(g, Frankfurt, Muenchen);
Assert.AreEqual(3, path.Count);
Assert.AreEqual(Frankfurt, path[0]);
Assert.AreEqual(Kassel, path[1]);
Assert.AreEqual(Muenchen, path[2]);
}
public void BidirectionalBFSTest_GermanyGraph_Matching()
{
var g = InitGermanyGraph();
var Frankfurt = g.Vertices.Single(v => v.UUID.Equals("1"));
var Muenchen = g.Vertices.Single(v => v.UUID.Equals("10"));
var Wuerzburg = g.Vertices.Single(v => v.UUID.Equals("3"));
var Nuernberg = g.Vertices.Single(v => v.UUID.Equals("7"));
// search for path that doesnt contain Kassel
var path = BidirectionalBFS.Search(g, Frankfurt, Muenchen, (v => !v["name"].Equals("Kassel")));
// Frankfurt -> Wuerzburg -> Nuernberg -> Muenchen
Assert.AreEqual(4, path.Count);
Assert.AreEqual(Frankfurt, path[0]);
Assert.AreEqual(Wuerzburg, path[1]);
Assert.AreEqual(Nuernberg, path[2]);
Assert.AreEqual(Muenchen, path[3]);
}
public void BidirectionalBFSTest_Barabasi_100_Vertices()
{
var g = InitGraph(BARABASI_N_100);
Assert.IsNotNull(g, "loading graph failed");
var n0 = g.Vertices.Single(v => v.UUID.Equals("n0"));
var n1 = g.Vertices.Single(v => v.UUID.Equals("n1"));
var n10 = g.Vertices.Single(v => v.UUID.Equals("n10"));
var n99 = g.Vertices.Single(v => v.UUID.Equals("n99"));
Assert.IsNotNull(n0, "source node was null");
Assert.IsNotNull(n99, "target node was null");
var path = BidirectionalBFS.Search(g, n0, n99);
// n0 -> n1 -> n10 -> n99
Assert.AreEqual(4, path.Count);
Assert.AreEqual(n0, path[0]);
Assert.AreEqual(n1, path[1]);
Assert.AreEqual(n10, path[2]);
Assert.AreEqual(n99, path[3]);
}
public override FuncParameter ExecFunc(IAttributeDefinition myAttributeDefinition,
Object myCallingObject,
IVertex myStartVertex,
IGraphDB myGraphDB,
SecurityToken mySecurityToken,
Int64 myTransactionToken,
params FuncParameter[] myParams)
{
#region initialize data
var graph = myGraphDB;
// The edge we starting of (e.g. Friends)
var typeAttribute = myAttributeDefinition;
if (myStartVertex == null)
{
throw new InvalidFunctionParameterException("StartVertex", "Vertex that represents the start vertex", "null");
}
//set the start node
var startNode = myStartVertex;
if ((myParams[0].Value as IEnumerable <IVertex>) == null)
{
throw new InvalidFunctionParameterException("TargetVertex", "Set of vertices that represents the target vertices", "null");
}
//set the target node
var targetNode = (myParams[0].Value as IEnumerable <IVertex>).First();
//set the maximum depth
UInt64 maxDepth = Convert.ToUInt64(myParams[1].Value);
//set the maximum path length
UInt64 maxPathLength = Convert.ToUInt64(myParams[2].Value);
//mark if only the shortest path should be searched
bool onlyShortestPath = Convert.ToBoolean(myParams[3].Value);
//mark if all paths should be searched
bool allPaths = Convert.ToBoolean(myParams[4].Value);
if (!onlyShortestPath && !allPaths)
{
allPaths = true;
}
bool useBidirectionalBFS = false;
if (myParams.GetLength(0) == 6)
{
//mark if the BidirectionalBFS should be used
useBidirectionalBFS = Convert.ToBoolean(myParams[5].Value);
}
var vertexType = myGraphDB.GetVertexType <IVertexType>(mySecurityToken,
myTransactionToken,
new RequestGetVertexType(startNode.VertexTypeID),
(stats, type) => type);
if (vertexType == null)
{
throw new InvalidFunctionParameterException("StartVertexType",
"VertexType that represents the start vertex type not found",
startNode.VertexTypeID);
}
#endregion
#region check correctness of parameters
//check if values are correct
if (maxDepth < 1)
{
throw new InvalidFunctionParameterException("maxDepth", ">= 1", maxDepth.ToString());
}
if (maxPathLength < 2)
{
throw new InvalidFunctionParameterException("maxPathLength", ">= 2", maxPathLength.ToString());
}
#endregion
#region call graph function
HashSet <List <Tuple <long, long> > > paths = null;
//call BFS find methods
if (useBidirectionalBFS)
{
paths = new BidirectionalBFS().Find(typeAttribute,
vertexType,
startNode,
targetNode,
onlyShortestPath,
allPaths,
maxDepth, maxPathLength);
}
else
{
paths = new BFS().Find(typeAttribute,
vertexType,
startNode,
targetNode,
onlyShortestPath,
allPaths,
maxDepth,
maxPathLength);
}
#endregion
#region create output
if (paths != null)
{
#region create outputted views
List <List <Tuple <long, long> > .Enumerator> enumerators = new List <List <Tuple <long, long> > .Enumerator>();
foreach (var path in paths)
{
enumerators.Add(path.GetEnumerator());
}
var view = GenerateVertexView(enumerators);
#endregion
return(new FuncParameter(view));
}
else
{
return(new FuncParameter(new VertexView(null, null)));
}
#endregion
}
