public void consolidateTree()
{
FibonacciHeap heap = new FibonacciHeap();
FibonacciNode n1 = heap.insert(1);
FibonacciNode n2 = heap.insert(2);
n1.MinPathValue = 23;
n2.MinPathValue = 7;
heap.consolidateTree(heap.root);
Assert.AreEqual(2, heap.minNode.StationID);
Assert.AreEqual(n2, n1.Parent);
Assert.AreEqual(1, n2.Degree);
Assert.AreEqual(0, n1.Degree);
Assert.AreEqual(n1, n2.Child);
FibonacciNode n3 = heap.insert(3);
n3.MinPathValue = 2;
heap.consolidateTree(heap.root);
Assert.AreEqual(3, heap.minNode.StationID);
Assert.AreEqual(0, n3.Degree);
Assert.AreEqual(null, n3.Parent);
Assert.AreEqual(null, n3.Child);
Assert.AreEqual(n2, n1.Parent);
Assert.AreEqual(1, n2.Degree);
Assert.AreEqual(0, n1.Degree);
Assert.AreEqual(n1, n2.Child);
}
public void calculateArraySize()
{
FibonacciHeap heap = new FibonacciHeap();
Assert.AreEqual(6, heap.calculateArraySize(15));
Assert.AreEqual(5, heap.calculateArraySize(7));
Assert.AreEqual(5, heap.calculateArraySize(8));
}
public void Cut()
{
FibonacciHeap heap = new FibonacciHeap();
DoubleLinkedList list = new DoubleLinkedList();
FibonacciNode y = new FibonacciNode() { StationID = 1, MinPathValue = 10 };
FibonacciNode x = new FibonacciNode() { StationID = 2, MinPathValue = 20 };
x.Parent = y;
y.Child = x;
list.Add(y);
heap.Cut(list, x, y);
Assert.AreEqual(null, x.Parent);
Assert.AreEqual(false, x.Mark);
Assert.AreEqual(1, list.head.StationID);
Assert.AreEqual(2, list.head.RightNode.StationID);
}
public void CascadingCut()
{
FibonacciHeap heap = new FibonacciHeap();
DoubleLinkedList list = new DoubleLinkedList();
FibonacciNode y = new FibonacciNode() { StationID = 1, MinPathValue = 10 };
FibonacciNode x = new FibonacciNode() { StationID = 2, MinPathValue = 20, Mark = true };
FibonacciNode z = new FibonacciNode() { StationID = 3, MinPathValue = 21, Mark = true };
x.Parent = y;
y.Child = x;
z.Parent = x;
x.Child = z;
list.Add(y);
heap.CascadingCut(list, z);
Assert.AreEqual(null, x.Child);
Assert.AreEqual(null, y.Child);
Assert.AreEqual(null, x.Parent);
Assert.AreEqual(null, z.Parent);
Assert.AreEqual(1, list.head.StationID);
Assert.AreEqual(3, list.head.RightNode.StationID);
Assert.AreEqual(2, list.head.RightNode.RightNode.StationID);
}
public void runUnpassedData()
{
List<int> dataList = readDataFromFile();
decimal preValue = 0;
decimal currentExtractValue = 0;
FibonacciHeap heap = new FibonacciHeap();
for (int i = 0; i < dataList.Count; i++)
{
FibonacciNode node = heap.insert(i+1);
heap.DecreasingKey(heap.root, node, dataList[i]);
Assert.AreEqual(i + 1, heap.numberOfNodes);
}
dataList.Sort();
List<FibonacciNode> listNode = new List<FibonacciNode>();
int size = dataList.Count;
for (int i = 0; i < dataList.Count; i++)
{
FibonacciNode node = heap.extractMinNode();
listNode.Add(node);
Assert.AreEqual(size - (i + 1), heap.numberOfNodes);
currentExtractValue = node.MinPathValue;
if (currentExtractValue < preValue)
{
Assert.Fail();
}
preValue = currentExtractValue;
}
for (int i = 0; i < dataList.Count; i++)
{
Assert.AreEqual(dataList[i], Convert.ToInt32(listNode[i].MinPathValue));
}
}
public void Link()
{
FibonacciHeap heap1 = new FibonacciHeap();
DoubleLinkedList root1 = new DoubleLinkedList();
FibonacciNode y = new FibonacciNode() { StationID = 1, MinPathValue = 10 };
FibonacciNode x = new FibonacciNode() { StationID = 2, MinPathValue = 5 };
root1.Add(y);
root1.Add(x);
heap1.Link(root1, y, x);
Assert.AreEqual(2, root1.head.StationID);
Assert.AreEqual(1, x.Child.StationID);
Assert.AreEqual(1, x.Degree);
Assert.AreEqual(2, root1.head.RightNode.StationID);
FibonacciHeap heap2 = new FibonacciHeap();
DoubleLinkedList root2 = new DoubleLinkedList();
FibonacciNode z = new FibonacciNode() { StationID = 3, MinPathValue = 10 };
x.Child = z;
z.Parent = x;
x.Degree = 1;
root1.Add(y);
root1.Add(x);
heap2.Link(root2, y, x);
Assert.AreEqual(2, root1.head.StationID);
Assert.AreEqual(3, x.Child.StationID);
Assert.AreEqual(2, x.Degree);
Assert.AreEqual(2, root1.head.RightNode.StationID);
Assert.AreEqual(3, x.Child.StationID);
Assert.AreEqual(1, x.Child.RightNode.StationID);
}
public void insertNode()
{
FibonacciHeap heap = new FibonacciHeap();
heap.insert(1);
Assert.AreEqual(1, heap.numberOfNodes);
Assert.AreEqual(1, heap.root.head.StationID);
Assert.AreEqual(1, heap.minNode.StationID);
heap.insert(2);
Assert.AreEqual(2, heap.numberOfNodes);
Assert.AreEqual(1, heap.root.head.StationID);
Assert.AreEqual(1, heap.minNode.StationID);
Assert.AreEqual(2, heap.root.head.RightNode.StationID);
Assert.AreEqual(1, heap.minNode.StationID);
}
public void extract_minWithRandomNumbers()
{
List<int> dataList = new List<int>();
try
{
FibonacciHeap heap = new FibonacciHeap();
Random r = new Random();
int ran = 0;
decimal preValue = 0;
decimal currentExtractValue = 0;
int size = 300; //can be adjusted
for (int i = 0; i < size; i++)
{
FibonacciNode node = heap.insert(i + 1);
ran = r.Next(1, 100);
heap.DecreasingKey(heap.root, node, ran);
dataList.Add(ran);
Assert.AreEqual(i + 1, heap.numberOfNodes);
}
for (int i = 0; i < size; i++)
{
FibonacciNode node = heap.extractMinNode();
Assert.AreEqual(size - (i + 1), heap.numberOfNodes);
currentExtractValue = node.MinPathValue;
if (currentExtractValue < preValue)
{
Assert.Fail();
}
preValue = currentExtractValue;
}
}
catch (IndexOutOfRangeException e)
{
writeDataToFile(e.Message, dataList);
throw new Exception();
}
catch (AssertFailedException e)
{
writeDataToFile(e.Message, dataList);
throw new Exception();
}
}
public void extractMinNode()
{
FibonacciHeap heap = new FibonacciHeap();
FibonacciNode n1 = heap.insert(1);
n1.MinPathValue = 5;
FibonacciNode n2 = heap.insert(2);
n2.MinPathValue = 10;
FibonacciNode n3 = heap.insert(3);
n3.MinPathValue = 15;
Assert.AreEqual(3, heap.numberOfNodes);
FibonacciNode min = heap.extractMinNode();
Assert.AreEqual(1, min.StationID);
Assert.AreEqual(5, Convert.ToInt32(min.MinPathValue));
Assert.AreEqual(2, heap.numberOfNodes);
Assert.AreEqual(2, heap.minNode.StationID);
FibonacciNode min2 = heap.extractMinNode();
Assert.AreEqual(2, min2.StationID);
Assert.AreEqual(10, Convert.ToInt32(min2.MinPathValue));
Assert.AreEqual(1, heap.numberOfNodes);
Assert.AreEqual(3, heap.minNode.StationID);
FibonacciNode min3 = heap.extractMinNode();
Assert.AreEqual(3, min3.StationID);
Assert.AreEqual(15, Convert.ToInt32(min3.MinPathValue));
Assert.AreEqual(0, heap.numberOfNodes);
Assert.AreEqual(null, heap.minNode);
}
public void DecreasingKey()
{
FibonacciHeap heap = new FibonacciHeap();
FibonacciNode x = heap.insert(1);
x.MinPathValue = 10;
heap.DecreasingKey(heap.root, x, 5);
Assert.AreEqual(5, Convert.ToInt32(x.MinPathValue));
Assert.AreEqual(1, heap.root.Size);
FibonacciNode y = heap.insert(2);
y.MinPathValue = 26;
y.Parent = x;
x.Child = y;
heap.DecreasingKey(heap.root, y, 20);
Assert.AreEqual(20, Convert.ToInt32(y.MinPathValue));
Assert.AreEqual(2, heap.root.Size);
}
//return a path with min weight
public static List<PathStop> shortestPathWithFibonacci(Dictionary<int, Dictionary<int, decimal>> adjListWithWeight, int startSID, int endSID)
{
FibonacciHeap Q = new FibonacciHeap();
Dictionary<int, FibonacciNode> QCopy = new Dictionary<int, FibonacciNode>();
List<int> R = new List<int>();
List<FibonacciNode> S = new List<FibonacciNode>();
//initialize start node
FibonacciNode start = Q.insert(startSID);
start.MinPathValue = 0;
QCopy.Add(startSID, start);
while (Q.numberOfNodes != 0)
{
FibonacciNode u = Q.extractMinNode();
R.Add(u.StationID);
S.Add(u);
if (R.Contains(endSID))
{
break; //if extracted list contains the end station id, stop algorithm
}
foreach (int vId in adjListWithWeight[u.StationID].Keys)
{
FibonacciNode v = null;
if (!R.Contains(vId)) //if the node is not in extracted list
{
if (!Q.stationIDs.Contains(vId))//if the node is not reached yet
{
v = Q.insert(vId);
QCopy.Add(vId, v);
}
else
{
v = QCopy[vId]; //The node is reached
}
decimal w = adjListWithWeight[u.StationID][vId];
relax(u, v, w, Q, QCopy);
}
}
}
List<PathStop> route = new List<PathStop>();
if (R.Contains(endSID))
{
route = buildRoute(S, endSID);
}
return route;
}
public static void relax(FibonacciNode u, FibonacciNode v, decimal w, FibonacciHeap Q, Dictionary<int, FibonacciNode> QCopy)
{
if (v.MinPathValue > u.MinPathValue + w)
{
Q.DecreasingKey(Q.root, v, u.MinPathValue + w);
QCopy[v.StationID].MinPathValue = u.MinPathValue + w;
v.lastStop = u;
}
}
public void relax()
{
FibonacciHeap Q = new FibonacciHeap();
FibonacciNode u = Q.insert(1);
u.MinPathValue = 5;
FibonacciNode v = Q.insert(2);
v.MinPathValue = 6;
Dictionary<int, FibonacciNode> QCopy = new Dictionary<int, FibonacciNode>();
QCopy.Add(1, u);
QCopy.Add(2, v);
decimal w = 3;
FindPath.relax(u, v, w, Q, QCopy);
Assert.AreEqual(6, Convert.ToInt32(v.MinPathValue));
Assert.AreEqual(null, v.lastStop);
Assert.AreEqual(6, Convert.ToInt32(QCopy[2].MinPathValue));
v.MinPathValue = 10;
FindPath.relax(u, v, w, Q, QCopy);
Assert.AreEqual(8, Convert.ToInt32(v.MinPathValue));
Assert.AreEqual(u, v.lastStop);
Assert.AreEqual(8, Convert.ToInt32(QCopy[2].MinPathValue));
}
